diff --git a/.buildkite/bootstrap-amd-omni.sh b/.buildkite/amd/scripts/bootstrap-amd-omni.sh
similarity index 62%
rename from .buildkite/bootstrap-amd-omni.sh
rename to .buildkite/amd/scripts/bootstrap-amd-omni.sh
index 16ed02b26..32097cb8c 100755
--- a/.buildkite/bootstrap-amd-omni.sh
+++ b/.buildkite/amd/scripts/bootstrap-amd-omni.sh
@@ -6,6 +6,8 @@
 
 set -euo pipefail
 
+source .buildkite/common/scripts/resolve_skip_ci.sh
+
 if [[ -z "${RUN_ALL:-}" ]]; then
     RUN_ALL=0
 fi
@@ -22,10 +24,6 @@ if [[ -z "${AMD_MIRROR_HW:-}" ]]; then
     AMD_MIRROR_HW="amdproduction"
 fi
 
-if [[ -z "${DOCS_ONLY_DISABLE:-}" ]]; then
-    DOCS_ONLY_DISABLE=0
-fi
-
 fail_fast() {
     DISABLE_LABEL="ci-no-fail-fast"
     # If BUILDKITE_PULL_REQUEST != "false", then we check the PR labels using curl and jq
@@ -56,88 +54,6 @@ check_run_all_label() {
     fi
 }
 
-is_docs_only_change() {
-    local file_path
-    local has_any=0
-
-    while IFS= read -r file_path; do
-        [[ -z "${file_path}" ]] && continue
-        has_any=1
-
-        if [[ "${file_path}" == docs/* ]]; then
-            continue
-        fi
-        if [[ "${file_path}" == *.md ]]; then
-            continue
-        fi
-        if [[ "${file_path}" == "mkdocs.yml" ]]; then
-            continue
-        fi
-        return 1
-    done
-
-    [[ "${has_any}" -eq 1 ]]
-}
-
-resolve_skip_ci() {
-    local is_pr_build=0
-    local files
-    local base_branch base_ref
-
-    if [[ "${BUILDKITE_PULL_REQUEST:-false}" != "false" && -n "${BUILDKITE_PULL_REQUEST:-}" ]]; then
-        is_pr_build=1
-    fi
-
-    if [[ "${is_pr_build}" -eq 1 ]]; then
-        base_branch="${BUILDKITE_PULL_REQUEST_BASE_BRANCH:-main}"
-        if ! git rev-parse --verify "origin/${base_branch}" >/dev/null 2>&1; then
-            echo "resolve_skip_ci: origin/${base_branch} not found locally; trying fetch" >&2
-            git fetch --depth=200 origin "${base_branch}" >/dev/null 2>&1 || true
-        fi
-
-        base_ref=""
-        if git rev-parse --verify "origin/${base_branch}" >/dev/null 2>&1; then
-            base_ref="origin/${base_branch}"
-        elif git rev-parse --verify "${base_branch}" >/dev/null 2>&1; then
-            base_ref="${base_branch}"
-        else
-            echo "resolve_skip_ci: cannot resolve PR base ${base_branch}; skip-ci=0" >&2
-            echo -n 0
-            return 0
-        fi
-
-        if ! files="$(git diff --name-only "${base_ref}...${BUILDKITE_COMMIT}" 2>/dev/null)"; then
-            echo "resolve_skip_ci: failed to compute PR changed files; skip-ci=0" >&2
-            echo -n 0
-            return 0
-        fi
-    elif [[ "${BUILDKITE_BRANCH:-}" == "main" ]]; then
-        if ! git rev-parse --verify "${BUILDKITE_COMMIT}^" >/dev/null 2>&1; then
-            echo "resolve_skip_ci: commit has no parent on main; skip-ci=0" >&2
-            echo -n 0
-            return 0
-        fi
-        if ! files="$(git diff --name-only "${BUILDKITE_COMMIT}^..${BUILDKITE_COMMIT}" 2>/dev/null)"; then
-            echo "resolve_skip_ci: failed to compute main changed files; skip-ci=0" >&2
-            echo -n 0
-            return 0
-        fi
-    else
-        echo "resolve_skip_ci: not PR/main build; skip-ci=0" >&2
-        echo -n 0
-        return 0
-    fi
-
-    if is_docs_only_change <<< "${files}"; then
-        echo "resolve_skip_ci: docs-only change detected; skip-ci=1" >&2
-        echo -n 1
-        return 0
-    fi
-
-    echo "resolve_skip_ci: non-doc changes detected; skip-ci=0" >&2
-    echo -n 0
-}
-
 if [[ -z "${COV_ENABLED:-}" ]]; then
     COV_ENABLED=0
 fi
@@ -154,14 +70,14 @@ upload_pipeline() {
     fi
 
     # Use local template file for vllm-omni
-    cp .buildkite/test-template-amd-omni.j2 .buildkite/test-template.j2
+    cp .buildkite/amd/test-template-amd-omni.j2 .buildkite/amd/test-template.j2
 
 
     # (WIP) Use pipeline generator instead of jinja template
-    if [ -e ".buildkite/pipeline_generator/pipeline_generator.py" ]; then
+    if [ -e ".buildkite/amd/pipeline_generator/pipeline_generator.py" ]; then
         python -m pip install click pydantic
-        python .buildkite/pipeline_generator/pipeline_generator.py --run_all=$RUN_ALL --list_file_diff="$LIST_FILE_DIFF" --nightly="$NIGHTLY" --mirror_hw="$AMD_MIRROR_HW"
-        buildkite-agent pipeline upload .buildkite/pipeline.yaml
+        python .buildkite/amd/pipeline_generator/pipeline_generator.py --run_all=$RUN_ALL --list_file_diff="$LIST_FILE_DIFF" --nightly="$NIGHTLY" --mirror_hw="$AMD_MIRROR_HW"
+        buildkite-agent pipeline upload .buildkite/amd/pipeline.yaml
         exit 0
     fi
     echo "List file diff: $LIST_FILE_DIFF"
@@ -171,7 +87,7 @@ upload_pipeline() {
 
     FAIL_FAST=$(fail_fast)
 
-    cd .buildkite
+    cd .buildkite/amd
 
     # Select test definition file: merge suite for main, ready suite for PRs.
     # For debugging, DEBUG_TEST_YAML can override the selection — accepts
@@ -182,7 +98,7 @@ upload_pipeline() {
                 TEST_YAML="test-amd-merge.yml"
                 ;;
             ready)
-                TEST_YAML="test-amd-ready.yaml"
+                TEST_YAML="test-amd-ready.yml"
                 ;;
             *)
                 echo "ERROR: DEBUG_TEST_YAML must be 'merge' or 'ready', got '$DEBUG_TEST_YAML'" >&2
@@ -193,7 +109,7 @@ upload_pipeline() {
     elif [[ $BUILDKITE_BRANCH == "main" ]]; then
         TEST_YAML="test-amd-merge.yml"
     else
-        TEST_YAML="test-amd-ready.yaml"
+        TEST_YAML="test-amd-ready.yml"
     fi
 
     (
@@ -234,23 +150,13 @@ if [[ $BUILDKITE_BRANCH == "main" ]]; then
     file_diff=$(get_diff_main)
 fi
 
-# ----------------------------------------------------------------------
-# Early exit start: skip pipeline if conditions are met
-# ----------------------------------------------------------------------
-
-# Match CUDA Buildkite skip-ci behavior for docs/markdown-only changes.
-if [[ "${DOCS_ONLY_DISABLE}" != "1" ]]; then
-    SKIP_CI="$(resolve_skip_ci)"
-    if [[ "${SKIP_CI}" == "1" ]]; then
-        echo "[docs-only] Docs/markdown-only changes detected. Exiting before pipeline upload."
-        exit 0
-    fi
+# Early exit: unified skip-ci (docs / skip marks) and CI-yaml-only level targeting.
+if [[ $BUILDKITE_BRANCH == "main" ]]; then
+    gate_bootstrap_ci amd l3
+else
+    gate_bootstrap_ci amd l2
 fi
 
-# ----------------------------------------------------------------------
-# Early exit end
-# ----------------------------------------------------------------------
-
 patterns=(
     "docker/Dockerfile"
     "CMakeLists.txt"
diff --git a/.buildkite/scripts/hardware_ci/run-amd-test.sh b/.buildkite/amd/scripts/run-amd-test.sh
similarity index 98%
rename from .buildkite/scripts/hardware_ci/run-amd-test.sh
rename to .buildkite/amd/scripts/run-amd-test.sh
index f880455d4..c49614e70 100755
--- a/.buildkite/scripts/hardware_ci/run-amd-test.sh
+++ b/.buildkite/amd/scripts/run-amd-test.sh
@@ -56,7 +56,7 @@ container_name="rocm_${BUILDKITE_COMMIT}_$(tr -dc A-Za-z0-9 < /dev/urandom | hea
 # # Install AWS CLI to authenticate to ECR Public Gallery to get higher rate limit for pulling images
 # sudo apt-get update && sudo apt-get install -y awscli
 ##  Use safe docker login helper to prevent race conditions
-# source "$(dirname "${BASH_SOURCE[0]}")/../docker_login_ecr_public.sh"
+# source "$(dirname "${BASH_SOURCE[0]}")/../../common/scripts/docker_login_ecr_public.sh"
 # safe_docker_login_ecr_public
 
 ## Pull the container from AMD Docker Hub
diff --git a/.buildkite/test-amd-merge.yml b/.buildkite/amd/test-amd-merge.yml
similarity index 99%
rename from .buildkite/test-amd-merge.yml
rename to .buildkite/amd/test-amd-merge.yml
index 63433cc12..4e80d1968 100644
--- a/.buildkite/test-amd-merge.yml
+++ b/.buildkite/amd/test-amd-merge.yml
@@ -89,7 +89,7 @@ steps:
       mirror_hardwares: [amdproduction]
       grade: Blocking
       commands:
-        - pytest -s -v tests/diffusion/distributed/test_zimage_parallelism.py
+        - pytest -s -v tests/diffusion/distributed/test_tensor_parallel.py
 
     - label: "Diffusion Model Test"
       agent_pool: mi325_1
diff --git a/.buildkite/test-amd-ready.yaml b/.buildkite/amd/test-amd-ready.yml
similarity index 98%
rename from .buildkite/test-amd-ready.yaml
rename to .buildkite/amd/test-amd-ready.yml
index 8c645fff0..8f99ce909 100644
--- a/.buildkite/test-amd-ready.yaml
+++ b/.buildkite/amd/test-amd-ready.yml
@@ -35,7 +35,7 @@ steps:
   mirror_hardwares: [amdproduction]
   grade: Blocking
   commands:
-    - timeout 20m pytest -s -v tests/e2e/offline_inference/custom_pipeline/ -m "core_model"
+    - timeout 20m pytest -s -v tests/e2e/features/custom_pipeline/ -m "core_model"
 
 
 - label: "Voxtral TTS CUDA Unit Test"
diff --git a/.buildkite/test-template-amd-omni.j2 b/.buildkite/amd/test-template-amd-omni.j2
similarity index 96%
rename from .buildkite/test-template-amd-omni.j2
rename to .buildkite/amd/test-template-amd-omni.j2
index aa5ca8bcd..2f1a9aed3 100644
--- a/.buildkite/test-template-amd-omni.j2
+++ b/.buildkite/amd/test-template-amd-omni.j2
@@ -57,7 +57,7 @@ steps:
           {% endif %}
 {% set cmd_body = (step.command or (step.commands | join("\n"))) | trim %}
 {% set indented_cmd = cmd_body | replace("\n", "\n            ") %}
-        command: bash .buildkite/scripts/hardware_ci/run-amd-test.sh
+        command: bash .buildkite/amd/scripts/run-amd-test.sh
         env:
           DOCKER_BUILDKIT: "1"
 {% if step.env %}
@@ -104,7 +104,7 @@ steps:
       {% endif %}
 {% set cmd_body = (step.command or (step.commands | join("\n"))) | trim %}
 {% set indented_cmd = cmd_body | replace("\n", "\n        ") %}
-    command: bash .buildkite/scripts/hardware_ci/run-amd-test.sh
+    command: bash .buildkite/amd/scripts/run-amd-test.sh
     env:
       DOCKER_BUILDKIT: "1"
 {% if step.env %}
diff --git a/.buildkite/bootstrap-intel-omni.sh b/.buildkite/bootstrap-intel-omni.sh
deleted file mode 100755
index b99568141..000000000
--- a/.buildkite/bootstrap-intel-omni.sh
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/bin/bash
-# vllm-omni Intel bootstrap
-# Uses static pipeline-intel.yaml for Intel XPU tests
-# Based on: bootstrap-amd-omni.sh
-
-set -euo pipefail
-
-if [[ -z "${DOCS_ONLY_DISABLE:-}" ]]; then
-    DOCS_ONLY_DISABLE=0
-fi
-
-upload_pipeline() {
-    echo "--- 🛠 Preparing Intel pipeline"
-    buildkite-agent pipeline upload .buildkite/pipeline-intel.yaml
-}
-
-get_diff() {
-    $(git add .)
-    echo $(git diff --name-only --diff-filter=ACMDR $(git merge-base origin/main HEAD))
-}
-
-get_diff_main() {
-    $(git add .)
-    echo $(git diff --name-only --diff-filter=ACMDR HEAD~1)
-}
-
-file_diff=$(get_diff)
-if [[ $BUILDKITE_BRANCH == "main" ]]; then
-    file_diff=$(get_diff_main)
-fi
-
-# ----------------------------------------------------------------------
-# Early exit: skip pipeline if all changed files are under docs/
-# ----------------------------------------------------------------------
-if [[ "${DOCS_ONLY_DISABLE}" != "1" ]] && [[ -n "${file_diff:-}" ]]; then
-    docs_only=1
-    while IFS= read -r f; do
-        [[ -z "$f" ]] && continue
-        if [[ "$f" != docs/* ]]; then
-            docs_only=0
-            break
-        fi
-    done < <(printf '%s\n' "$file_diff" | tr ' ' '\n' | tr -d '\r')
-
-    if [[ "$docs_only" -eq 1 ]]; then
-        buildkite-agent annotate ":memo: CI skipped — docs only" --style "info"
-        exit 0
-    fi
-fi
-
-upload_pipeline
diff --git a/.buildkite/common/ci_mirror_hardwares.yml b/.buildkite/common/ci_mirror_hardwares.yml
new file mode 100644
index 000000000..b7d40c75d
--- /dev/null
+++ b/.buildkite/common/ci_mirror_hardwares.yml
@@ -0,0 +1,239 @@
+# Uploader-only hardware presets for CUDA / NPU test YAML.
+# Referenced as ``mirror_hardwares: l4_1`` on a step; ``upload_pipeline.py`` expands to
+# ``agents`` (+ optional top-level ``image`` for NPU) + ``plugins``, then strips
+# ``mirror_hardwares`` before Buildkite upload.
+#
+# CUDA naming: {chip}_{count}
+#   l4_1, l4_4, h100_1 … h100_4
+# NPU naming: {queue}_{resource_class}
+#   a2b3_npu_1  — ascend-a2b3, resource_class npu-1 (A2/B3 CI image)
+#   a2b3_npu_4  — ascend-a2b3, resource_class npu-4
+#   a3_npu_2    — ascend-a3, resource_class npu-2 (A3 CI image tag …:$BUILDKITE_COMMIT-a3)
+
+x-npu-k8s-plugins: &npu_k8s_plugins
+  - kubernetes:
+      podSpecPatch:
+        imagePullSecrets:
+          - name: swr-secret
+
+
+mirror_hardwares:
+  l4_1:
+    agents:
+      queue: gpu_1_queue
+    plugins:
+      - docker#v5.2.0:
+          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+          always-pull: true
+          propagate-environment: true
+          shm-size: "8gb"
+          environment:
+            - HF_HOME=/fsx/hf_cache
+            - HF_TOKEN
+          volumes:
+            - /fsx/hf_cache:/fsx/hf_cache
+
+  l4_4:
+    agents:
+      queue: gpu_4_queue
+    plugins:
+      - docker#v5.2.0:
+          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+          always-pull: true
+          propagate-environment: true
+          shm-size: "8gb"
+          environment:
+            - HF_HOME=/fsx/hf_cache
+            - HF_TOKEN
+          volumes:
+            - /fsx/hf_cache:/fsx/hf_cache
+
+  h100_1:
+    agents:
+      queue: mithril-h100-pool
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+                resources:
+                  limits:
+                    nvidia.com/gpu: 1
+                volumeMounts:
+                  - name: devshm
+                    mountPath: /dev/shm
+                  - name: hf-cache
+                    mountPath: /root/.cache/huggingface
+                env:
+                  - name: HF_HOME
+                    value: /root/.cache/huggingface
+                  - name: HF_TOKEN
+                    valueFrom:
+                      secretKeyRef:
+                        name: hf-token-secret
+                        key: token
+            nodeSelector:
+              node.kubernetes.io/instance-type: gpu-h100-sxm
+            volumes:
+              - name: devshm
+                emptyDir:
+                  medium: Memory
+              - name: hf-cache
+                hostPath:
+                  path: /mnt/hf-cache
+                  type: DirectoryOrCreate
+
+  h100_2:
+    agents:
+      queue: mithril-h100-pool
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+                resources:
+                  limits:
+                    nvidia.com/gpu: 2
+                volumeMounts:
+                  - name: devshm
+                    mountPath: /dev/shm
+                  - name: hf-cache
+                    mountPath: /root/.cache/huggingface
+                env:
+                  - name: HF_HOME
+                    value: /root/.cache/huggingface
+                  - name: HF_TOKEN
+                    valueFrom:
+                      secretKeyRef:
+                        name: hf-token-secret
+                        key: token
+            nodeSelector:
+              node.kubernetes.io/instance-type: gpu-h100-sxm
+            volumes:
+              - name: devshm
+                emptyDir:
+                  medium: Memory
+              - name: hf-cache
+                hostPath:
+                  path: /mnt/hf-cache
+                  type: DirectoryOrCreate
+
+  h100_3:
+    agents:
+      queue: mithril-h100-pool
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+                resources:
+                  limits:
+                    nvidia.com/gpu: 3
+                volumeMounts:
+                  - name: devshm
+                    mountPath: /dev/shm
+                  - name: hf-cache
+                    mountPath: /root/.cache/huggingface
+                env:
+                  - name: HF_HOME
+                    value: /root/.cache/huggingface
+                  - name: HF_TOKEN
+                    valueFrom:
+                      secretKeyRef:
+                        name: hf-token-secret
+                        key: token
+            nodeSelector:
+              node.kubernetes.io/instance-type: gpu-h100-sxm
+            volumes:
+              - name: devshm
+                emptyDir:
+                  medium: Memory
+              - name: hf-cache
+                hostPath:
+                  path: /mnt/hf-cache
+                  type: DirectoryOrCreate
+
+  h100_4:
+    agents:
+      queue: mithril-h100-pool
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+                resources:
+                  limits:
+                    nvidia.com/gpu: 4
+                volumeMounts:
+                  - name: devshm
+                    mountPath: /dev/shm
+                  - name: hf-cache
+                    mountPath: /root/.cache/huggingface
+                env:
+                  - name: HF_HOME
+                    value: /root/.cache/huggingface
+                  - name: HF_TOKEN
+                    valueFrom:
+                      secretKeyRef:
+                        name: hf-token-secret
+                        key: token
+            nodeSelector:
+              node.kubernetes.io/instance-type: gpu-h100-sxm
+            volumes:
+              - name: devshm
+                emptyDir:
+                  medium: Memory
+              - name: hf-cache
+                hostPath:
+                  path: /mnt/hf-cache
+                  type: DirectoryOrCreate
+
+  a2b3_npu_1:
+    agents:
+      queue: "ascend-a2b3"
+      resource_class: "npu-1"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}"
+    plugins: *npu_k8s_plugins
+
+  a2b3_npu_4:
+    agents:
+      queue: "ascend-a2b3"
+      resource_class: "npu-4"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}"
+    plugins: *npu_k8s_plugins
+
+
+  a2b3_npu_8:
+    agents:
+      queue: "ascend-a2b3"
+      resource_class: "npu-8"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}"
+    plugins: *npu_k8s_plugins
+
+  a3_npu_2:
+    agents:
+      queue: "ascend-a3"
+      resource_class: "npu-2"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}-a3"
+    plugins: *npu_k8s_plugins
+
+  a3_npu_4:
+    agents:
+      queue: "ascend-a3"
+      resource_class: "npu-4"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}-a3"
+    plugins: *npu_k8s_plugins
+
+  a3_npu_8:
+    agents:
+      queue: "ascend-a3"
+      resource_class: "npu-8"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}-a3"
+    plugins: *npu_k8s_plugins
+
+  a3_npu_16:
+    agents:
+      queue: "ascend-a3"
+      resource_class: "npu-16"
+    image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}-a3"
+    plugins: *npu_k8s_plugins
diff --git a/.buildkite/common/scripts/resolve_skip_ci.sh b/.buildkite/common/scripts/resolve_skip_ci.sh
new file mode 100644
index 000000000..666573f66
--- /dev/null
+++ b/.buildkite/common/scripts/resolve_skip_ci.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# Shared Buildkite skip-ci helpers for AMD / Intel bootstrap scripts.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKIP_CI_PY="${SCRIPT_DIR}/skip_ci.py"
+
+# Resolve git diff once. Exit 0 when this bootstrap should stop uploading.
+# Decision details are logged by skip_ci.py; this helper only annotates skip-all.
+# Usage: gate_bootstrap_ci <platform> <l2|l3>
+gate_bootstrap_ci() {
+    local platform="$1"
+    local level="$2"
+    local kind
+    if kind="$(python3 "${SKIP_CI_PY}" gate "${platform}" "${level}")"; then
+        if [[ "${kind}" == "skip-all" ]]; then
+            buildkite-agent annotate \
+                ":memo: CI skipped — docs or pytest skip-mark changes only" \
+                --style "info" 2>/dev/null || true
+        fi
+        exit 0
+    fi
+}
diff --git a/.buildkite/common/scripts/skip_ci.py b/.buildkite/common/scripts/skip_ci.py
new file mode 100644
index 000000000..b452b5adf
--- /dev/null
+++ b/.buildkite/common/scripts/skip_ci.py
@@ -0,0 +1,617 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Shared Buildkite skip-ci and CI-YAML level targeting logic.
+
+``resolve_ci_decision(changed_files, ...)`` buckets explicit file lists (tests, dry-run).
+``resolve_ci_context_from_git()`` resolves git diff once and returns decision + changed files
+for Buildkite bootstrap / upload scripts.
+
+CLI (for bootstrap scripts; exit code is the signal):
+  python3 skip_ci.py gate <platform> <level>
+      Exit 0 when bootstrap should stop (skip-all, or that L2/L3 target is off).
+      Prints ``skip-all`` or ``skip-l23`` on stdout; logs the decision once.
+  python3 skip_ci.py check-skip-all
+      Exit 0 when only docs/skip-mark changes → bootstrap skips entire CI upload.
+  python3 skip_ci.py check-skip-l2-l3 <platform> <level>
+      Exit 0 when that L2/L3 pipeline should be skipped (CI config YAML-only diffs).
+  python3 skip_ci.py print-annotate
+      Print decision message for Buildkite annotation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+
+LOG = "[skip-ci]"
+ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+PLATFORMS = ("cuda", "amd", "intel", "npu")
+L23_LEVELS = frozenset({"l2", "l3"})
+
+L2_YAML_FILES: dict[str, str] = {
+    ".buildkite/cuda/test-ready.yml": "cuda",
+    ".buildkite/npu/test-npu-ready.yml": "npu",
+    ".buildkite/amd/test-amd-ready.yml": "amd",
+    ".buildkite/intel/pipeline-intel.yml": "intel",
+}
+
+L3_YAML_FILES: dict[str, str] = {
+    ".buildkite/cuda/test-merge.yml": "cuda",
+    ".buildkite/amd/test-amd-merge.yml": "amd",
+}
+
+L45_YAML_FILES: dict[str, str] = {
+    ".buildkite/cuda/test-nightly.yml": "cuda",
+    ".buildkite/cuda/test-weekly.yml": "cuda",
+    ".buildkite/npu/test-npu-nightly.yml": "npu",
+}
+
+
+def _empty_platform_buckets() -> dict[str, list[str]]:
+    return {platform: [] for platform in PLATFORMS}
+
+
+@dataclass(frozen=True)
+class CiDevice:
+    """Per-platform / per-level skip flags for yaml-gated bootstrap (``skip_l2_l3``)."""
+
+    skip_cuda_l2: bool = False
+    skip_cuda_l3: bool = False
+    skip_amd_l2: bool = False
+    skip_amd_l3: bool = False
+    skip_intel_l2: bool = False
+    skip_intel_l3: bool = False
+    skip_npu_l2: bool = False
+    skip_npu_l3: bool = False
+
+    def is_skip(self, platform: str, level: str) -> bool:
+        return bool(getattr(self, f"skip_{platform}_{level}", True))
+
+
+@dataclass
+class DiffBuckets:
+    """Changed files grouped by doc / skip-mark / CI yaml / other."""
+
+    docs: list[str] = field(default_factory=list)
+    skip_tests: list[str] = field(default_factory=list)
+    other: list[str] = field(default_factory=list)
+    l2: dict[str, list[str]] = field(default_factory=_empty_platform_buckets)
+    l3: dict[str, list[str]] = field(default_factory=_empty_platform_buckets)
+    l45: dict[str, list[str]] = field(default_factory=_empty_platform_buckets)
+
+    @property
+    def has_doc_changes(self) -> bool:
+        return bool(self.docs)
+
+    @property
+    def has_skip_test_changes(self) -> bool:
+        return bool(self.skip_tests)
+
+    @property
+    def has_other_changes(self) -> bool:
+        """Product code or paths outside skip-ci scope."""
+        return bool(self.other)
+
+    @property
+    def has_l23_yaml_changes(self) -> bool:
+        """At least one whitelisted L2/L3 CI yaml file changed."""
+        return any(self.l2[platform] or self.l3[platform] for platform in PLATFORMS)
+
+    @property
+    def has_l45_yaml_changes(self) -> bool:
+        """At least one whitelisted L4/L5 (nightly/weekly) CI yaml file changed."""
+        return any(self.l45[platform] for platform in PLATFORMS)
+
+    @property
+    def has_skip_ci_scope_changes(self) -> bool:
+        """At least one doc / skip-mark / whitelisted CI yaml change."""
+        return (
+            self.has_doc_changes or self.has_skip_test_changes or self.has_l23_yaml_changes or self.has_l45_yaml_changes
+        )
+
+    def l2_platforms(self) -> frozenset[str]:
+        return frozenset(platform for platform in PLATFORMS if self.l2[platform])
+
+    def l3_platforms(self) -> frozenset[str]:
+        return frozenset(platform for platform in PLATFORMS if self.l3[platform])
+
+
+@dataclass(frozen=True)
+class SkipL2L3Basis:
+    skip_all_l2: bool
+    skip_all_l3: bool
+
+    @classmethod
+    def from_buckets(cls, buckets: DiffBuckets) -> SkipL2L3Basis | None:
+        """L4/L5 yaml → skip both L2 and L3 (L2/L3 buckets may rescue).
+
+        Docs / skip-mark changes do not block this path; they are ignored for
+        L2/L3 targeting when CI YAML is also present.
+        """
+        if buckets.has_other_changes:
+            return None
+        if not buckets.has_l45_yaml_changes:
+            return None
+        return cls(
+            skip_all_l2=not buckets.l2_platforms(),
+            skip_all_l3=not buckets.l3_platforms(),
+        )
+
+
+@dataclass(frozen=True)
+class SkipL3Basis:
+    enable_l2_platforms: frozenset[str]
+
+    @classmethod
+    def from_buckets(cls, buckets: DiffBuckets) -> SkipL3Basis | None:
+        """L2 yaml changed → skip L3; keep L2 on touched platforms."""
+        platforms = buckets.l2_platforms()
+        if not platforms:
+            return None
+        return cls(enable_l2_platforms=platforms)
+
+
+@dataclass(frozen=True)
+class SkipL2Basis:
+    enable_l3_platforms: frozenset[str]
+
+    @classmethod
+    def from_buckets(cls, buckets: DiffBuckets) -> SkipL2Basis | None:
+        """L3 yaml changed → skip L2; keep L3 on touched platforms."""
+        platforms = buckets.l3_platforms()
+        if not platforms:
+            return None
+        return cls(enable_l3_platforms=platforms)
+
+
+@dataclass(frozen=True)
+class CiDecision:
+    """Final CI skip decision for one diff."""
+
+    skip_all: bool = False
+    skip_l2_l3: bool = False
+    device: CiDevice = field(default_factory=CiDevice)
+    message: str = ""
+
+    @classmethod
+    def skip_all_basis(cls, buckets: DiffBuckets, *, diff_range: str | None) -> bool:
+        """Docs / pytest skip-mark only → suppress entire default CI."""
+        if buckets.has_other_changes:
+            return False
+        if (buckets.has_l23_yaml_changes or buckets.has_l45_yaml_changes) and (
+            buckets.has_doc_changes or buckets.has_skip_test_changes
+        ):
+            return False
+        if not buckets.has_doc_changes and not buckets.has_skip_test_changes:
+            return False
+        if diff_range is None and not buckets.has_doc_changes:
+            return False
+        return True
+
+    @classmethod
+    def from_yaml_basis(
+        cls,
+        l2_l3_basis: SkipL2L3Basis | None,
+        l3_basis: SkipL3Basis | None,
+        l2_basis: SkipL2Basis | None,
+    ) -> CiDecision:
+        """Build a yaml-gated decision by merging L2/L3 skip bases.
+
+        Bases are applied as a union of enables: L2 yaml keeps L2 on touched
+        platforms, L3 yaml keeps L3 on touched platforms. Cross-platform mixes
+        (e.g. CUDA ready + AMD merge) must preserve both enables. The resulting
+        per-platform / per-level matrix is stored on ``device`` as ``skip_*``.
+        """
+        run = {platform: {"l2": True, "l3": True} for platform in PLATFORMS}
+
+        if l2_l3_basis is not None:
+            if l2_l3_basis.skip_all_l2:
+                for platform in PLATFORMS:
+                    run[platform]["l2"] = False
+            if l2_l3_basis.skip_all_l3:
+                for platform in PLATFORMS:
+                    run[platform]["l3"] = False
+
+        if l3_basis is not None:
+            for platform in PLATFORMS:
+                run[platform]["l3"] = False
+                run[platform]["l2"] = platform in l3_basis.enable_l2_platforms
+
+        if l2_basis is not None:
+            for platform in PLATFORMS:
+                if platform in l2_basis.enable_l3_platforms:
+                    run[platform]["l3"] = True
+                    if l3_basis is None or platform not in l3_basis.enable_l2_platforms:
+                        run[platform]["l2"] = False
+                elif l3_basis is None:
+                    # L3-yaml-only: disable platforms that did not change L3.
+                    run[platform]["l2"] = False
+                    run[platform]["l3"] = False
+                # else: leave L2 enables from SkipL3Basis; keep this platform's L3 off.
+
+        return cls(
+            skip_l2_l3=True,
+            device=cls._device_from_run(run),
+        )
+
+    @staticmethod
+    def _device_from_run(run: dict[str, dict[str, bool]]) -> CiDevice:
+        return CiDevice(
+            **{f"skip_{platform}_{level}": not run[platform][level] for platform in PLATFORMS for level in ("l2", "l3")}
+        )
+
+    def is_run(self, platform: str, level: str) -> bool:
+        if self.skip_all:
+            return False
+        if not self.skip_l2_l3:
+            return True
+        if level not in L23_LEVELS:
+            return True
+        return not self.device.is_skip(platform, level)
+
+
+@dataclass(frozen=True)
+class CiContext:
+    """Skip-ci decision plus git diff inputs used to compute it."""
+
+    decision: CiDecision
+    changed_files: list[str] | None
+    diff_range: str | None
+
+
+def _log(message: str) -> None:
+    print(f"{LOG}: {message}", file=sys.stderr)
+
+
+def _git(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+# --- Diff helpers ---
+
+
+def _resolve_diff_range() -> str | None:
+    """Return a git diff range for PR or main builds, or None when unavailable."""
+    is_pr = os.environ.get("BUILDKITE_PULL_REQUEST", "false") != "false" and os.environ.get(
+        "BUILDKITE_PULL_REQUEST", ""
+    )
+    commit = os.environ.get("BUILDKITE_COMMIT", "")
+
+    if is_pr:
+        base_branch = os.environ.get("BUILDKITE_PULL_REQUEST_BASE_BRANCH", "main")
+        base_ref = f"origin/{base_branch}"
+        if _git("rev-parse", "--verify", base_ref).returncode != 0:
+            _log(f"origin/{base_branch} not found locally; trying fetch")
+            _git("fetch", "--depth=200", "origin", base_branch)
+        if _git("rev-parse", "--verify", base_ref).returncode != 0:
+            if _git("rev-parse", "--verify", base_branch).returncode == 0:
+                base_ref = base_branch
+            else:
+                _log(f"cannot resolve PR base {base_branch}; using safe defaults")
+                return None
+        return f"{base_ref}...{commit}"
+
+    if os.environ.get("BUILDKITE_BRANCH", "") == "main":
+        if _git("rev-parse", "--verify", f"{commit}^").returncode != 0:
+            _log("main commit has no parent; using safe defaults")
+            return None
+        return f"{commit}^..{commit}"
+
+    _log("not PR/main build; using safe defaults")
+    return None
+
+
+def _changed_files_for_diff_range(diff_range: str | None) -> list[str] | None:
+    """Return changed file paths for *diff_range*, or None when unavailable."""
+    if diff_range is None:
+        return None
+
+    result = _git("diff", "--name-only", diff_range)
+    if result.returncode != 0:
+        _log(f"git diff failed ({diff_range}); using safe defaults")
+        return None
+
+    files = [line for line in result.stdout.splitlines() if line.strip()]
+    _log(f"{len(files)} changed file(s)")
+    return files
+
+
+def resolve_ci_context_from_git() -> CiContext:
+    """Resolve git diff once and return skip-ci decision plus changed files."""
+    diff_range = _resolve_diff_range()
+    changed_files = _changed_files_for_diff_range(diff_range)
+    decision = resolve_ci_decision(changed_files, diff_range=diff_range)
+    return CiContext(decision=decision, changed_files=changed_files, diff_range=diff_range)
+
+
+# --- Doc / skip-mark helpers ---
+
+
+_SKIP_MARK_RE = re.compile(r"pytest\.mark\.skip(?:if)?\b|pytest\.skip\s*\(")
+_PYTESTMARK_SKIP_RE = re.compile(r"pytest\.mark\.skip\b")
+_PYTEST_MARK_ONLY_RE = re.compile(r"pytest\.mark\.\w+")
+
+
+def _diff_only_contains_skip_mark_changes(diff_text: str) -> bool:
+    """Return True when a unified diff only *adds* pytest skip marks.
+
+    Deleting a skip mark re-enables the test and must not suppress CI. Editing an
+    existing skip (``-`` old / ``+`` new) still qualifies when at least one skip
+    mark is added.
+    """
+
+    def paren_balance(line: str) -> int:
+        return line.count("(") - line.count(")")
+
+    def is_blank_or_comment(line: str) -> bool:
+        stripped = line.strip()
+        return not stripped or stripped.startswith("#")
+
+    def is_skip_mark_line(line: str) -> bool:
+        return _SKIP_MARK_RE.search(line.strip()) is not None
+
+    def is_pytestmark_adjacent_line(line: str) -> bool:
+        stripped = line.strip().rstrip(",")
+        if not stripped or stripped in {"[", "]"} or stripped.startswith("#"):
+            return True
+        if stripped.startswith("pytestmark"):
+            return True
+        return _PYTEST_MARK_ONLY_RE.search(stripped) is not None
+
+    pending_depth = 0
+    saw_change = False
+    has_added_skip_mark = False
+    for raw_line in diff_text.splitlines():
+        if raw_line.startswith("@@"):
+            pending_depth = 0
+            continue
+        if not (raw_line.startswith("+") or raw_line.startswith("-")):
+            continue
+        if raw_line.startswith("+++") or raw_line.startswith("---"):
+            continue
+
+        saw_change = True
+        is_add = raw_line.startswith("+")
+        content = raw_line[1:]
+
+        if pending_depth > 0:
+            pending_depth += paren_balance(content)
+            if pending_depth < 0:
+                pending_depth = 0
+            continue
+
+        if is_blank_or_comment(content):
+            continue
+
+        if is_skip_mark_line(content):
+            if is_add:
+                has_added_skip_mark = True
+            pending_depth = max(0, paren_balance(content))
+            continue
+
+        if is_pytestmark_adjacent_line(content):
+            continue
+
+        return False
+
+    return saw_change and has_added_skip_mark
+
+
+def _is_skip_testcase_change(file_path: str, *, diff_range: str) -> bool:
+    """Return True when a test file diff is skip-mark-only (including new-file cases)."""
+    diff_result = _git("diff", diff_range, "--", file_path)
+    if diff_result.returncode != 0:
+        _log(f"skip-mark-only: git diff failed for {file_path}")
+        return False
+
+    diff_text = diff_result.stdout
+    if not diff_text.strip():
+        _log(f"skip-mark-only: empty diff for {file_path}")
+        return False
+
+    if _diff_only_contains_skip_mark_changes(diff_text):
+        return True
+
+    if "new file mode" not in diff_text and "--- /dev/null" not in diff_text:
+        _log(f"skip-mark-only: non-skip changes in {file_path}")
+        return False
+
+    commit = os.environ.get("BUILDKITE_COMMIT", "")
+    if not commit:
+        return False
+
+    content_result = _git("show", f"{commit}:{file_path}")
+    if content_result.returncode != 0:
+        _log(f"skip-mark-only: cannot read {file_path} at {commit}")
+        return False
+
+    content = content_result.stdout
+    match = re.search(r"^pytestmark\s*=\s*\[(.*?)^\s*\]", content, re.MULTILINE | re.DOTALL)
+    if match is not None and _PYTESTMARK_SKIP_RE.search(match.group(1)) is not None:
+        _log(f"skip-mark-only: new test file with module-level pytest.mark.skip: {file_path}")
+        return True
+    if re.search(r"^pytestmark\s*=\s*pytest\.mark\.skip\b", content, re.MULTILINE):
+        _log(f"skip-mark-only: new test file with module-level pytest.mark.skip: {file_path}")
+        return True
+
+    _log(f"skip-mark-only: new test file without module-level pytest.mark.skip: {file_path}")
+    return False
+
+
+def _classify_changed_files_into_buckets(changed_files: list[str], *, diff_range: str | None) -> DiffBuckets:
+    """Classify each changed file path into a ``DiffBuckets`` category."""
+    buckets = DiffBuckets()
+    for file_path in changed_files:
+        if not file_path:
+            continue
+        if file_path.startswith("docs/") or file_path.endswith(".md") or file_path == "mkdocs.yml":
+            buckets.docs.append(file_path)
+            continue
+        path = Path(file_path)
+        if path.suffix == ".py" and path.parts and path.parts[0] == "tests":
+            if diff_range is not None and _is_skip_testcase_change(file_path, diff_range=diff_range):
+                buckets.skip_tests.append(file_path)
+            else:
+                buckets.other.append(file_path)
+            continue
+        if file_path in L2_YAML_FILES:
+            platform = L2_YAML_FILES[file_path]
+            buckets.l2[platform].append(file_path)
+        elif file_path in L3_YAML_FILES:
+            platform = L3_YAML_FILES[file_path]
+            buckets.l3[platform].append(file_path)
+        elif file_path in L45_YAML_FILES:
+            platform = L45_YAML_FILES[file_path]
+            buckets.l45[platform].append(file_path)
+        else:
+            buckets.other.append(file_path)
+    return buckets
+
+
+# --- Decision ---
+
+
+def _finish(decision: CiDecision, message: str) -> CiDecision:
+    finished = replace(decision, message=message)
+    _log(message)
+    return finished
+
+
+def _format_yaml_gated_message(buckets: DiffBuckets, decision: CiDecision) -> str:
+    """Human-readable summary of which CI YAML changed and which L2/L3 targets run."""
+    changed_parts: list[str] = []
+    for level_name, by_platform in (("L2", buckets.l2), ("L3", buckets.l3), ("L4/L5", buckets.l45)):
+        files = [path for platform in PLATFORMS for path in by_platform[platform]]
+        if files:
+            changed_parts.append(f"{level_name}=[{', '.join(files)}]")
+
+    run_targets = [
+        f"{platform}/{level}" for platform in PLATFORMS for level in ("l2", "l3") if decision.is_run(platform, level)
+    ]
+    skip_targets = [
+        f"{platform}/{level}"
+        for platform in PLATFORMS
+        for level in ("l2", "l3")
+        if not decision.is_run(platform, level)
+    ]
+
+    changed = "; ".join(changed_parts) if changed_parts else "none"
+    run = ", ".join(run_targets) if run_targets else "none"
+    skip = ", ".join(skip_targets) if skip_targets else "none"
+    if buckets.has_doc_changes or buckets.has_skip_test_changes:
+        return (
+            "CI config YAML + docs/skip-mark changed — follow CI YAML gating; "
+            f"changed: {changed}; run: {run}; skip: {skip}"
+        )
+    return f"only CI config YAML changed — changed: {changed}; run: {run}; skip: {skip}"
+
+
+def resolve_ci_decision(
+    changed_files: list[str] | None = None,
+    *,
+    diff_range: str | None = None,
+) -> CiDecision:
+    if changed_files is None:
+        return _finish(CiDecision(), "could not resolve changed files; run normal CI")
+
+    buckets = _classify_changed_files_into_buckets(changed_files, diff_range=diff_range)
+    if buckets.has_other_changes or not buckets.has_skip_ci_scope_changes:
+        return _finish(CiDecision(), "product or non-whitelisted changes present; run normal CI")
+
+    if CiDecision.skip_all_basis(buckets, diff_range=diff_range):
+        return _finish(
+            CiDecision(skip_all=True),
+            "CI skipped — docs or pytest skip-mark changes only",
+        )
+
+    # Docs / skip-mark mixed with whitelisted CI YAML → same yaml-gated path
+    # as CI-YAML-only (docs/skip-mark do not widen to normal CI).
+    if not buckets.has_l23_yaml_changes and not buckets.has_l45_yaml_changes:
+        if buckets.has_skip_test_changes and diff_range is None:
+            message = (
+                "only pytest skip-mark test changes detected, but no git diff range "
+                "is available to verify them (skip-all requires diff_range); run normal CI"
+            )
+        elif buckets.has_skip_test_changes:
+            message = "pytest skip-mark test changes did not qualify for skip-all and no ci yaml changed; run normal CI"
+        else:
+            message = "doc/skip-mark changes did not qualify for skip-all; run normal CI"
+        return _finish(CiDecision(), message)
+
+    decision = CiDecision.from_yaml_basis(
+        SkipL2L3Basis.from_buckets(buckets),
+        SkipL3Basis.from_buckets(buckets),
+        SkipL2Basis.from_buckets(buckets),
+    )
+    return _finish(decision, _format_yaml_gated_message(buckets, decision))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    gate_parser = subparsers.add_parser(
+        "gate",
+        help="exit 0 when bootstrap should stop (skip-all or PLATFORM/LEVEL disabled); logs once",
+    )
+    gate_parser.add_argument("platform", help="cuda, amd, intel, or npu")
+    gate_parser.add_argument("level", choices=("l2", "l3"), help="test level")
+
+    subparsers.add_parser(
+        "check-skip-all",
+        help="exit 0 when docs/skip-mark-only diff should skip entire CI upload",
+    )
+
+    skip_parser = subparsers.add_parser(
+        "check-skip-l2-l3",
+        help="exit 0 when PLATFORM l2/l3 pipeline should be skipped (CI config YAML-only diffs)",
+    )
+    skip_parser.add_argument("platform", help="cuda, amd, intel, or npu")
+    skip_parser.add_argument("level", choices=("l2", "l3"), help="test level")
+
+    subparsers.add_parser(
+        "print-annotate",
+        help="print human-readable skip reason for Buildkite annotation",
+    )
+
+    args = parser.parse_args()
+    decision = resolve_ci_context_from_git().decision
+
+    if args.command == "gate":
+        if decision.skip_all:
+            print("skip-all")
+            return 0
+        if not decision.is_run(args.platform, args.level):
+            print("skip-l23")
+            return 0
+        return 1
+
+    if args.command == "check-skip-all":
+        return 0 if decision.skip_all else 1
+
+    if args.command == "check-skip-l2-l3":
+        return 0 if not decision.is_run(args.platform, args.level) else 1
+
+    if args.command == "print-annotate":
+        print(decision.message or "CI will run normally")
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/.buildkite/common/scripts/upload_pipeline.py b/.buildkite/common/scripts/upload_pipeline.py
new file mode 100644
index 000000000..b27f78c3a
--- /dev/null
+++ b/.buildkite/common/scripts/upload_pipeline.py
@@ -0,0 +1,449 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Render and optionally upload Buildkite pipeline YAML with diff-aware logic.
+
+Bootstrap mode (``bootstrap-upload-steps.yml``):
+  - Hook uploads the entry YAML (``pipeline.yml`` / ``pipeline-npu.yml``) with one step that runs
+    ``upload_pipeline.py --upload <platform>/bootstrap-upload-steps.yml``.
+  - Injects ``if`` by step ``key`` from skip-ci and uploads child steps (image build, L2–L5 upload).
+  - Detect docs-only, pytest skip-mark-only, or combined skip-ci from git diff.
+  - When only CI level YAML changes, enable **L2/L3** upload steps for affected levels only.
+
+Test pipeline mode (e.g. test-merge.yml):
+  - Drop steps whose ``source_file_dependencies`` do not match changed files.
+  - Expand uploader-only ``mirror_hardwares: l4_1`` into ``agents`` (+ optional ``image``
+    for NPU) + ``plugins`` (see ci_mirror_hardwares.yml).
+
+Usage:
+  python3 upload_pipeline.py [--upload] [--all | --e2e] <pipeline.yml>
+
+Requires PyYAML (``pip install pyyaml``); installs it automatically when missing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import subprocess
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+except ModuleNotFoundError:
+    subprocess.run(
+        [sys.executable, "-m", "pip", "install", "-q", "pyyaml"],
+        check=True,
+    )
+    import yaml
+
+from skip_ci import (
+    ROOT,
+    resolve_ci_context_from_git,
+)
+
+# --- Constants ---
+
+LOG = "upload_pipeline"
+BOOTSTRAP_STEPS_FILENAME = "bootstrap-upload-steps.yml"
+BOOTSTRAP_IMAGE_BUILD_KEYS = frozenset({"image-build", "image-build-a2", "image-build-a3"})
+BOOTSTRAP_UPLOAD_IF_KEYS = {
+    "upload-ready-pipeline": "ready",
+    "upload-merge-pipeline": "merge",
+    "upload-nightly-pipeline": "nightly",
+    "upload-weekly-pipeline": "weekly",
+}
+E2E_GROUP_MARKER = "E2E Test"
+CI_MIRROR_HARDWARES_PATH = ROOT / ".buildkite/common/ci_mirror_hardwares.yml"
+
+CUDA_NIGHTLY_ONLY = (
+    '(build.pull_request.labels includes "nightly-test") || (build.branch == "main" && build.env("NIGHTLY") == "1")'
+)
+NPU_NIGHTLY_ONLY = (
+    '(build.branch == "main" && build.env("NIGHTLY") == "1") || '
+    '(build.branch != "main" && ('
+    'build.pull_request.labels includes "nightly-test" || '
+    'build.pull_request.labels includes "omni-test" || '
+    'build.pull_request.labels includes "tts-test" || '
+    'build.pull_request.labels includes "diffusion-x2iat-test" || '
+    'build.pull_request.labels includes "diffusion-x2v-test"'
+    "))"
+)
+
+
+# --- Logging ---
+
+
+def _log(message: str) -> None:
+    print(f"{LOG}: {message}", file=sys.stderr)
+
+
+# --- Bootstrap pipeline (bootstrap-upload-steps.yml) ---
+
+
+def _get_bootstrap_platform(path: Path) -> str:
+    parts = path.as_posix().split("/")
+    return "npu" if "npu" in parts else "cuda"
+
+
+def _load_bootstrap_steps(path: Path) -> str:
+    if path.name != BOOTSTRAP_STEPS_FILENAME:
+        raise ValueError(f"expected {BOOTSTRAP_STEPS_FILENAME}, got {path.name}")
+    return path.read_text(encoding="utf-8")
+
+
+def _format_bootstrap_if(expr: str) -> str:
+    """Return a Buildkite ``if`` string. Buildkite rejects YAML bool ``if`` values."""
+    if expr in ("true", "false"):
+        return expr
+    return f"({expr})"
+
+
+def _compute_bootstrap_if_exprs(*, decision, platform: str) -> dict[str, str]:
+    disabled = "false"
+    nightly_main = 'build.branch == "main" && build.env("NIGHTLY") == "1"'
+    nightly_only = NPU_NIGHTLY_ONLY if platform == "npu" else CUDA_NIGHTLY_ONLY
+
+    if platform == "npu":
+        ready_pr = (
+            'build.branch != "main" && ('
+            'build.pull_request.labels includes "npu-test" || '
+            'build.pull_request.labels includes "ready"'
+            ")"
+        )
+        nightly_label_if = nightly_only
+        weekly_label_if = disabled
+        merge_base = disabled
+    else:
+        ready_pr = 'build.branch != "main" && build.pull_request.labels includes "ready"'
+        merge_main = 'build.branch == "main" && build.env("NIGHTLY") != "1" && build.env("WEEKLY") != "1"'
+        merge_pr = 'build.branch != "main" && build.pull_request.labels includes "merge-test"'
+        nightly_label_if = (
+            '(build.branch == "main" && build.env("NIGHTLY") == "1") || '
+            '(build.branch != "main" && ('
+            'build.pull_request.labels includes "nightly-test" || '
+            'build.pull_request.labels includes "omni-test" || '
+            'build.pull_request.labels includes "tts-test" || '
+            'build.pull_request.labels includes "diffusion-x2iat-test" || '
+            'build.pull_request.labels includes "diffusion-x2v-test"'
+            "))"
+        )
+        weekly_label_if = (
+            '(build.branch == "main" && build.env("WEEKLY") == "1") || '
+            '(build.branch != "main" && build.pull_request.labels includes "weekly-test")'
+        )
+        merge_base = f"({nightly_main}) || (({merge_main}) || ({merge_pr}))"
+
+    ready_base = f"({nightly_main}) || ({ready_pr})"
+    weekly_main = 'build.branch == "main" && build.env("WEEKLY") == "1"'
+
+    if decision.skip_all:
+        # Docs / skip-mark only: no PR-label escape hatch. Main scheduled
+        # NIGHTLY=1 still runs L4 + L2/L3 (--e2e); WEEKLY=1 still runs L5.
+        image_expr = f"({nightly_main}) || ({weekly_main})" if platform == "cuda" else nightly_main
+        ready_expr = nightly_main
+        merge_expr = nightly_main if platform == "cuda" else disabled
+        nightly_expr = nightly_main
+        weekly_expr = weekly_main if platform == "cuda" else disabled
+    elif decision.skip_l2_l3:
+        l2_enabled = decision.is_run("npu", "l2") if platform == "npu" else decision.is_run("cuda", "l2")
+        l3_enabled = platform == "cuda" and decision.is_run("cuda", "l3")
+
+        ready_expr = ready_base if l2_enabled else disabled
+        merge_expr = merge_base if l3_enabled else disabled
+        nightly_expr = nightly_label_if
+        weekly_expr = weekly_label_if if platform == "cuda" else disabled
+
+        image_parts = [f"({nightly_label_if})"]
+        if platform == "cuda":
+            image_parts.append(f"({weekly_label_if})")
+        if l2_enabled:
+            image_parts.insert(0, f"({ready_base})")
+        if l3_enabled:
+            image_parts.insert(1 if l2_enabled else 0, f"({merge_base})")
+        image_expr = " || ".join(image_parts)
+    else:
+        image_expr = "true"
+        ready_expr = ready_base
+        merge_expr = merge_base if platform == "cuda" else disabled
+        nightly_expr = nightly_label_if
+        weekly_expr = weekly_label_if if platform == "cuda" else disabled
+
+    return {
+        "image": _format_bootstrap_if(image_expr),
+        "ready": _format_bootstrap_if(ready_expr),
+        "merge": _format_bootstrap_if(merge_expr),
+        "nightly": _format_bootstrap_if(nightly_expr),
+        "weekly": _format_bootstrap_if(weekly_expr),
+    }
+
+
+def _apply_bootstrap_if(steps: list[Any], if_exprs: dict[str, str]) -> list[Any]:
+    """Inject ``if`` by step key; drop steps that are unconditionally disabled."""
+    kept: list[Any] = []
+    for step in steps:
+        if not isinstance(step, dict):
+            kept.append(step)
+            continue
+        nested = step.get("steps")
+        if isinstance(nested, list):
+            nested_kept = _apply_bootstrap_if(nested, if_exprs)
+            if nested_kept:
+                kept.append({**step, "steps": nested_kept})
+            continue
+        key = step.get("key")
+        if key in BOOTSTRAP_IMAGE_BUILD_KEYS:
+            step["if"] = if_exprs["image"]
+        elif key in BOOTSTRAP_UPLOAD_IF_KEYS:
+            step["if"] = if_exprs[BOOTSTRAP_UPLOAD_IF_KEYS[key]]
+        if_expr = step.get("if")
+        if if_expr == "false":
+            _log(f"omit disabled bootstrap step {key!r}")
+            continue
+        if if_expr == "true":
+            # Unconditional step: omit ``if`` (Buildkite requires string ``if``, not YAML bool).
+            step.pop("if", None)
+        kept.append(step)
+    return kept
+
+
+def _render_bootstrap_pipeline(
+    steps_yaml: str,
+    *,
+    decision,
+    path: Path,
+) -> str:
+    """Load bootstrap steps YAML and inject ``if`` expressions from skip-ci decision."""
+    doc = yaml.safe_load(steps_yaml)
+    if not isinstance(doc, dict):
+        raise ValueError(f"invalid bootstrap steps YAML for {path}")
+    steps = doc.get("steps")
+    if not isinstance(steps, list):
+        raise ValueError(f"bootstrap steps YAML must contain steps: list in {path}")
+
+    platform = _get_bootstrap_platform(path)
+    if_exprs = _compute_bootstrap_if_exprs(decision=decision, platform=platform)
+    doc["steps"] = _apply_bootstrap_if(steps, if_exprs)
+    return yaml.safe_dump(doc, sort_keys=False)
+
+
+# --- Test pipeline (test-ready.yml, test-merge.yml) ---
+
+
+@lru_cache(maxsize=1)
+def _load_mirror_hardwares() -> dict[str, dict[str, Any]]:
+    if not CI_MIRROR_HARDWARES_PATH.is_file():
+        raise FileNotFoundError(f"missing CI mirror_hardwares registry: {CI_MIRROR_HARDWARES_PATH}")
+    doc = yaml.safe_load(CI_MIRROR_HARDWARES_PATH.read_text(encoding="utf-8"))
+    if not isinstance(doc, dict):
+        raise ValueError(f"invalid CI mirror_hardwares registry: {CI_MIRROR_HARDWARES_PATH}")
+    presets = doc.get("mirror_hardwares")
+    if not isinstance(presets, dict):
+        raise ValueError(f"mirror_hardwares must be a mapping in {CI_MIRROR_HARDWARES_PATH}")
+    return presets
+
+
+def _expand_mirror_hardwares(step: dict[str, Any]) -> dict[str, Any]:
+    """Replace uploader-only ``mirror_hardwares`` with preset fields from ci_mirror_hardwares.yml."""
+    hardware = step.get("mirror_hardwares")
+    if hardware is None:
+        return step
+
+    if not isinstance(hardware, str) or not hardware.strip():
+        raise ValueError(
+            f"mirror_hardwares must be a non-empty string in step {_get_step_label(step)!r}",
+        )
+
+    preset = _load_mirror_hardwares().get(hardware)
+    if preset is None:
+        known = ", ".join(sorted(_load_mirror_hardwares()))
+        raise ValueError(
+            f"unknown mirror_hardwares {hardware!r} in step {_get_step_label(step)!r}; known: {known}",
+        )
+
+    if step.get("agents") is not None or step.get("plugins") is not None or step.get("image") is not None:
+        raise ValueError(
+            f"step {_get_step_label(step)!r} sets mirror_hardwares together with agents/plugins/image; "
+            "use mirror_hardwares only",
+        )
+
+    expanded = copy.deepcopy(preset)
+    return {key: value for key, value in step.items() if key != "mirror_hardwares"} | expanded
+
+
+def _match_source_file(changed_files: list[str], prefixes: list[str]) -> bool:
+    for path in changed_files:
+        for prefix in prefixes:
+            normalized = prefix.rstrip("/")
+            if path == normalized or path.startswith(f"{normalized}/"):
+                return True
+    return False
+
+
+def _get_step_label(step: dict[str, Any]) -> str:
+    return str(step.get("group") or step.get("label") or "<step>")
+
+
+def _process_test_steps(
+    steps: list[Any],
+    changed_files: list[str] | None,
+) -> list[Any]:
+    """Drop steps by ``source_file_dependencies`` when *changed_files* is set; always strip that field."""
+    processed: list[Any] = []
+    for step in steps:
+        if not isinstance(step, dict):
+            processed.append(step)
+            continue
+
+        deps = step.get("source_file_dependencies")
+        if deps is not None and not isinstance(deps, list):
+            raise ValueError(
+                f"source_file_dependencies must be a list in step {_get_step_label(step)!r}",
+            )
+        if changed_files is not None and deps is not None and not _match_source_file(changed_files, deps):
+            _log(f"skip {_get_step_label(step)!r} (no changes under {deps})")
+            continue
+
+        nested = step.get("steps")
+        if nested is not None:
+            kept_nested = _process_test_steps(nested, changed_files)
+            if changed_files is not None and not kept_nested:
+                _log(f"omit empty group {_get_step_label(step)!r}")
+                continue
+            new_step = {key: value for key, value in step.items() if key != "source_file_dependencies"}
+            new_step["steps"] = kept_nested
+            processed.append(new_step)
+            continue
+
+        if deps is not None:
+            processed.append(
+                _expand_mirror_hardwares(
+                    {key: value for key, value in step.items() if key != "source_file_dependencies"},
+                ),
+            )
+        else:
+            processed.append(_expand_mirror_hardwares(step))
+
+    return processed
+
+
+def _select_e2e_group_steps(steps: list[Any]) -> list[Any]:
+    """Keep only top-level groups whose name contains ``E2E_GROUP_MARKER``."""
+    selected = [
+        step
+        for step in steps
+        if isinstance(step, dict) and isinstance(step.get("group"), str) and E2E_GROUP_MARKER in step["group"]
+    ]
+    if not selected:
+        _log(f"no group matching {E2E_GROUP_MARKER!r} found")
+    else:
+        _log(f"keep {len(selected)} group(s) matching {E2E_GROUP_MARKER!r}")
+    return selected
+
+
+def _render_test_pipeline(
+    doc: dict[str, Any],
+    changed_files: list[str] | None,
+    *,
+    e2e_only: bool = False,
+) -> dict[str, Any]:
+    """Filter steps by PR diff and strip uploader-only ``source_file_dependencies`` metadata."""
+    steps = doc.get("steps")
+    if not isinstance(steps, list):
+        return doc
+    if e2e_only:
+        steps = _select_e2e_group_steps(steps)
+    steps = _process_test_steps(steps, changed_files)
+    return {**doc, "steps": steps}
+
+
+# --- Entry (read file → bootstrap or test render → YAML string) ---
+
+
+def _render_pipeline(
+    path: Path,
+    *,
+    force_all: bool = False,
+    e2e_only: bool = False,
+) -> str:
+    if path.name == BOOTSTRAP_STEPS_FILENAME:
+        ctx = resolve_ci_context_from_git()
+        continuation = _load_bootstrap_steps(path)
+        return _render_bootstrap_pipeline(
+            continuation,
+            decision=ctx.decision,
+            path=path,
+        )
+
+    text = path.read_text(encoding="utf-8")
+    ctx = resolve_ci_context_from_git()
+    if force_all or e2e_only:
+        changed_files = None
+    else:
+        changed_files = ctx.changed_files
+
+    doc = yaml.safe_load(text)
+    if not isinstance(doc, dict):
+        raise ValueError(f"invalid pipeline YAML: {path}")
+
+    doc = _render_test_pipeline(doc, changed_files, e2e_only=e2e_only)
+    return yaml.safe_dump(doc, sort_keys=False)
+
+
+def _upload_to_buildkite(content: str) -> None:
+    subprocess.run(
+        ["buildkite-agent", "pipeline", "upload"],
+        input=content,
+        text=True,
+        check=True,
+    )
+
+
+# --- CLI ---
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "pipeline",
+        nargs="?",
+        default=".buildkite/cuda/bootstrap-upload-steps.yml",
+        help="Pipeline YAML path (default: .buildkite/cuda/bootstrap-upload-steps.yml)",
+    )
+    parser.add_argument(
+        "--upload",
+        action="store_true",
+        help="Pipe rendered YAML to buildkite-agent pipeline upload",
+    )
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--all",
+        action="store_true",
+        help="Keep all steps (disable diff-aware skipping)",
+    )
+    mode.add_argument(
+        "--e2e",
+        action="store_true",
+        help="Keep only the E2E Test group",
+    )
+    args = parser.parse_args()
+
+    path = Path(args.pipeline)
+    if not path.is_absolute():
+        path = ROOT / path
+    if not path.is_file():
+        _log(f"missing pipeline file: {path}")
+        return 1
+
+    rendered = _render_pipeline(path, force_all=args.all, e2e_only=args.e2e)
+    if args.upload:
+        _upload_to_buildkite(rendered)
+    else:
+        sys.stdout.write(rendered)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/.buildkite/cuda/bootstrap-upload-steps.yml b/.buildkite/cuda/bootstrap-upload-steps.yml
new file mode 100644
index 000000000..f2467bf42
--- /dev/null
+++ b/.buildkite/cuda/bootstrap-upload-steps.yml
@@ -0,0 +1,55 @@
+# Uploaded by upload_pipeline.py --upload (not the Buildkite hook).
+# ``if`` is injected by step ``key`` from skip-ci at upload time.
+steps:
+  - label: ":docker: Build image"
+    key: image-build
+    commands:
+      - "bash .buildkite/cuda/scripts/build-ci-image.sh"
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L2 Test — PR ready label (diff-aware) or main+NIGHTLY=1 (--e2e, full E2E group)
+  - label: "Upload Ready Pipeline"
+    depends_on: image-build
+    key: upload-ready-pipeline
+    commands:
+      - |
+        EXTRA=""
+        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
+          EXTRA="--e2e"
+        fi
+        python3 .buildkite/common/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/cuda/test-ready.yml
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L3 Test — PR merge-test label (diff-aware) or main+NIGHTLY=1 (--e2e, full E2E group)
+  - label: "Upload Merge Pipeline"
+    depends_on: image-build
+    key: upload-merge-pipeline
+    commands:
+      - |
+        EXTRA=""
+        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
+          EXTRA="--e2e"
+        fi
+        python3 .buildkite/common/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/cuda/test-merge.yml
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
+  - label: "Upload Nightly Pipeline"
+    depends_on: image-build
+    key: upload-nightly-pipeline
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/cuda/test-nightly.yml
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L5 Test — main+WEEKLY=1 (scheduled), or PR with weekly-test label
+  - label: "Upload Weekly Pipeline"
+    depends_on: image-build
+    key: upload-weekly-pipeline
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/cuda/test-weekly.yml
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/cuda/pipeline.yml b/.buildkite/cuda/pipeline.yml
new file mode 100644
index 000000000..aeec9d1aa
--- /dev/null
+++ b/.buildkite/cuda/pipeline.yml
@@ -0,0 +1,9 @@
+# Hook uploads this entry YAML; upload_pipeline.py --upload reads bootstrap-upload-steps.yml
+# and injects ``if`` by step ``key`` from skip-ci.
+steps:
+  - label: ":github: Resolve skip-ci & upload pipeline"
+    key: upload-ci-pipeline
+    commands:
+      - "python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/cuda/bootstrap-upload-steps.yml"
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/cuda/rebase-pipeline.yml b/.buildkite/cuda/rebase-pipeline.yml
new file mode 100644
index 000000000..391079c4a
--- /dev/null
+++ b/.buildkite/cuda/rebase-pipeline.yml
@@ -0,0 +1,35 @@
+steps:
+  - label: ":docker: Build image"
+    key: image-build
+    commands:
+      - "bash .buildkite/cuda/scripts/build-ci-image.sh"
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L2 Test
+  - label: "Upload Ready Pipeline"
+    depends_on: image-build
+    key: upload-ready-pipeline
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload --all .buildkite/cuda/test-ready.yml
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L3 Test
+  - label: "Upload Merge Pipeline"
+    depends_on: image-build
+    key: upload-merge-pipeline
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload --all .buildkite/cuda/test-merge.yml
+    agents:
+      queue: "cpu_queue_premerge"
+
+  # L4 Test
+  - label: "Upload Nightly Pipeline"
+    depends_on: image-build
+    key: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1"
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload --all .buildkite/cuda/test-nightly.yml
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/cuda/scripts/build-ci-image.sh b/.buildkite/cuda/scripts/build-ci-image.sh
new file mode 100755
index 000000000..9da69bc8b
--- /dev/null
+++ b/.buildkite/cuda/scripts/build-ci-image.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+set -euo pipefail
+
+# Build and push the CI Docker image with registry-based layer caching.
+#
+# Usage: build-ci-image.sh
+#
+# Expects the following environment variables (set by Buildkite):
+#   BUILDKITE_COMMIT          - commit SHA used as the image tag
+ECR_NAMESPACE="public.ecr.aws/q9t5s3a7"
+REGISTRY="${ECR_NAMESPACE}/vllm-ci-test-repo"
+REGION="us-east-1"
+DOCKERFILE="docker/Dockerfile.ci"
+BUILDER_NAME="vllm-omni-builder"
+
+# Ensure that the env vars are actually set, otherwise exit early
+if [ -z "${BUILDKITE_COMMIT:-}" ]; then
+    echo "ERROR: BUILDKITE_COMMIT is not set"
+    exit 1
+fi
+echo "BUILDKITE_COMMIT: ${BUILDKITE_COMMIT}"
+
+# Authenticate to ECR Public
+aws ecr-public get-login-password --region "$REGION" \
+    | docker login --username AWS --password-stdin "$ECR_NAMESPACE"
+
+# Compute the cache tag for the dependencies image as the hash of the contents.
+# This is because dependencies don't change often, so most PRs will have the same hash.
+#
+# The Dockerfile is also included to avoid churn in the cached image based on the vLLM version.
+DEP_FILES="pyproject.toml setup.py requirements/*.txt docker/Dockerfile.ci"
+CACHE_KEY=$(cat ${DEP_FILES} | sha256sum | cut -c1-16)
+CACHE_TAG="deps-cache-${CACHE_KEY}"
+echo "Cache key: ${CACHE_TAG}"
+
+# Set up buildx with docker-container driver; we need to do this
+# since cache export is not supported for the default docker driver
+# that is running in the CI.
+docker buildx inspect $BUILDER_NAME >/dev/null 2>&1 \
+|| docker buildx create --name $BUILDER_NAME --driver docker-container
+docker buildx use $BUILDER_NAME
+
+echo "Building image tag: ${REGISTRY}:${BUILDKITE_COMMIT}"
+
+# Build + push the image to the registry, using the hash from the dependencies.
+# Note that the caching here is layerwise, so we're just making sure we always
+# can cache hit on everything but the last copy at the moment.
+docker buildx build --push --progress=plain \
+    --cache-from "type=registry,ref=${REGISTRY}:${CACHE_TAG}" \
+    --cache-to "type=registry,ref=${REGISTRY}:${CACHE_TAG},mode=max,compression=zstd" \
+    --file "$DOCKERFILE" \
+    -t "${REGISTRY}:${BUILDKITE_COMMIT}" .
diff --git a/.buildkite/cuda/test-merge.yml b/.buildkite/cuda/test-merge.yml
new file mode 100644
index 000000000..e971acb75
--- /dev/null
+++ b/.buildkite/cuda/test-merge.yml
@@ -0,0 +1,259 @@
+env:
+  VLLM_WORKER_MULTIPROC_METHOD: spawn
+  VLLM_USE_FLASHINFER_MOE_FP16: 0
+  HF_HUB_DOWNLOAD_TIMEOUT: 300
+  HF_HUB_ETAG_TIMEOUT: 60
+
+steps:
+  - group: ":card_index_dividers: Simple Test"
+    depends_on: upload-merge-pipeline
+    steps:
+      - label: "Simple · Model Executor Test"
+        commands:
+          - "timeout 20m pytest -sv tests/model_executor -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Diffusion Test"
+        commands:
+          - "timeout 20m pytest -sv tests/diffusion -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Engine&Entrypoints Test"
+        commands:
+          - "timeout 20m pytest -sv tests/entrypoints tests/engine -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Other Test"
+        commands:
+          - "timeout 20m pytest -sv tests/ -m 'core_model and cpu' --ignore=tests/diffusion --ignore=tests/model_executor --ignore=tests/entrypoints --ignore=tests/engine --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: Diffusion Test"
+    depends_on: upload-merge-pipeline
+    steps:
+      - label: "Diffusion · LoRA Test"
+        timeout_in_minutes: 30
+        commands:
+          - pytest -sv tests/diffusion/lora/ -m 'advanced_model and cuda' --run-level "advanced_model"
+        mirror_hardwares: l4_1
+
+  - label: "Distributed Test"
+    depends_on: upload-merge-pipeline
+    timeout_in_minutes: 60
+    commands:
+      - |
+        timeout 55m bash -c "
+          set -e
+          export VLLM_IMAGE_FETCH_TIMEOUT=60
+          pytest -s -v tests/distributed -m 'advanced_model and cuda and H100' --run-level 'advanced_model'
+        "
+    mirror_hardwares: h100_1
+
+  - group: ":card_index_dividers: Entrypoints Test"
+    depends_on: upload-merge-pipeline
+    steps:
+      - label: "Entrypoint Test with H100"
+        # TEMPORARY 60 -> 90: engine startup/sleep-wake is ~13-15 min slower per
+        # run on the vLLM 0.26 image (model loading ~2x, init ~2x; see builds
+        # 2915 vs 2916), which pushed this suite past 60 min. Revert once the
+        # 0.26 startup regression is understood and fixed.
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and H100" --run-level "advanced_model"
+        mirror_hardwares: h100_2
+
+      - label: "Entrypoint Test with L4"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and L4" --run-level "advanced_model"
+        mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: E2E Test"
+    depends_on: upload-merge-pipeline
+    steps:
+      - label: "TTS · Qwen3-TTS CustomVoice Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
+          - tests/e2e/offline_inference/test_qwen3_tts_customvoice.py
+          - vllm_omni/model_executor/models/qwen3_tts/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+          - vllm_omni/deploy/qwen3_tts.yaml
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_LOGGING_LEVEL=DEBUG
+              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
+              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py tests/e2e/offline_inference/test_qwen3_tts_customvoice.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "TTS · Qwen3-TTS Base Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_tts_base.py
+          - tests/e2e/offline_inference/test_qwen3_tts_base.py
+          - vllm_omni/model_executor/models/qwen3_tts/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+          - vllm_omni/deploy/qwen3_tts.yaml
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_LOGGING_LEVEL=DEBUG
+              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
+              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_base.py tests/e2e/offline_inference/test_qwen3_tts_base.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "TTS · Higgs-Audio-V3 Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_higgs_audio_v3.py
+          - vllm_omni/model_executor/models/higgs_audio_v3/
+          - vllm_omni/model_executor/stage_input_processors/higgs_audio_v3.py
+          - vllm_omni/deploy/higgs_multimodal_qwen3.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              export VLLM_USE_DEEP_GEMM=0
+              export VLLM_MOE_USE_DEEP_GEMM=0
+              pytest -s -v tests/e2e/online_serving/test_higgs_audio_v3.py -m 'advanced_model' --run-level 'advanced_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "Omni · Qwen3-Omni Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_qwen3_omni.py
+          - tests/e2e/online_serving/test_qwen3_omni.py
+          - vllm_omni/model_executor/models/qwen3_omni/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
+          - vllm_omni/deploy/qwen3_omni_moe.yaml
+        timeout_in_minutes: 50
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+        mirror_hardwares: h100_2
+
+      - label: "Omni · MiniCPM-o 4.5 Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_minicpmo_4_5.py
+          - tests/e2e/online_serving/test_minicpmo_4_5.py
+          - vllm_omni/deploy/minicpmo_4_5.yaml
+        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_2
+
+      - label: "Omni · MiniCPM-o 4.5 Duplex Test"
+        source_file_dependencies:
+          - tests/assets/minicpmo_4_5/response_required_16k.wav
+          - tests/assets/minicpmo_4_5/soft_interrupt_16k.wav
+          - tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
+          - tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
+          - tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
+          - tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py
+          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
+          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
+          - tests/helpers/minicpmo_4_5_duplex.py
+          - vllm_omni/deploy/minicpmo_4_5_duplex.yaml
+          - vllm_omni/experimental/fullduplex/
+          - vllm_omni/model_executor/models/minicpmo_4_5/
+          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+          - vllm_omni/core/sched/
+          - vllm_omni/outputs/multimodal_accumulation.py
+          - vllm_omni/engine/stage_init_utils.py
+          - vllm_omni/engine/async_omni_engine.py
+          - vllm_omni/entrypoints/cli/serve.py
+        timeout_in_minutes: 50
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+        mirror_hardwares: h100_2
+
+      - label: "TTS · VoxCPM2 Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_voxcpm2_tts.py
+          - tests/e2e/online_serving/test_voxcpm2_tts.py
+          - vllm_omni/model_executor/models/voxcpm2/
+          - vllm_omni/deploy/voxcpm2.yaml
+        timeout_in_minutes: 30
+        commands:
+          - |
+            timeout 30m bash -c "
+              export VLLM_LOGGING_LEVEL=DEBUG
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              pytest -s -v tests/e2e/offline_inference/test_voxcpm2_tts.py tests/e2e/online_serving/test_voxcpm2_tts.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Qwen Image Edit Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image_edit.py
+          - vllm_omni/diffusion/models/qwen_image/
+        timeout_in_minutes: 20
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_qwen_image_edit.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+        mirror_hardwares: h100_1
+      - label: "Diffusion · Bagel Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_bagel.py
+          - tests/e2e/online_serving/test_bagel.py
+          - vllm_omni/model_executor/models/bagel/
+          - vllm_omni/diffusion/models/bagel/
+          - vllm_omni/model_executor/stage_input_processors/bagel.py
+          - vllm_omni/deploy/bagel.yaml
+        timeout_in_minutes: 20
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_bagel.py tests/e2e/online_serving/test_bagel.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Qwen Image Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - |
+            timeout 40m bash -c '
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+            '
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Qwen Image Layered Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image_layered.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_qwen_image_layered.py -m 'advanced_model and cuda' --run-level 'advanced_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Wan22 Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_wan22_t2v.py
+          - tests/e2e/online_serving/test_wan22_t2v.py
+          - vllm_omni/diffusion/models/wan2_2/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/offline_inference/test_wan22_t2v.py tests/e2e/online_serving/test_wan22_t2v.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Z Image Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_z_image.py
+          - tests/e2e/online_serving/test_z_image.py
+          - vllm_omni/diffusion/models/z_image/
+        timeout_in_minutes: 30
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_z_image.py tests/e2e/online_serving/test_z_image.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
+        mirror_hardwares: l4_1
+      - label: "Diffusion · FLUX.2 Klein Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_flux2_klein.py
+          - vllm_omni/diffusion/models/flux2_klein/
+        timeout_in_minutes: 30
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_flux2_klein.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
+        mirror_hardwares: l4_1
diff --git a/.buildkite/cuda/test-nightly.yml b/.buildkite/cuda/test-nightly.yml
new file mode 100644
index 000000000..9be72d3d5
--- /dev/null
+++ b/.buildkite/cuda/test-nightly.yml
@@ -0,0 +1,572 @@
+env:
+  VLLM_WORKER_MULTIPROC_METHOD: spawn
+  VLLM_USE_FLASHINFER_MOE_FP16: 0
+  HF_HUB_DOWNLOAD_TIMEOUT: 300
+  HF_HUB_ETAG_TIMEOUT: 60
+
+steps:
+  # Group: collapses under one heading in the Buildkite UI; child steps still run in parallel.
+  - group: ":card_index_dividers: Omni Model Test"
+    key: nightly-omni-test-group
+    depends_on: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "omni-test"
+    steps:
+
+      - label: ":full_moon: Omni · Function Test with H100"
+        timeout_in_minutes: 120
+        commands:
+          - pytest -sv tests/e2e --run-level "full_model" -m "full_model and H100 and omni" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py --ignore=tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · MiniCPM-o 4.5 Duplex Test"
+        timeout_in_minutes: 50
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py -m "full_model and cuda and H100 and omni" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Doc Test with L4"
+        timeout_in_minutes: 90
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - pytest -s -v tests/examples/ -m "full_model and omni and L4" --run-level "full_model"
+        mirror_hardwares: l4_4
+
+      - label: ":full_moon: Omni · Doc Test with H100"
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/examples/ -m "full_model and omni and H100" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - export SEED_TTS_WER_EVAL=1
+          - export SEED_TTS_EVAL_DEVICE=cuda:1
+          - |
+            set +e
+            pytest -s -v tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py -m "full_model" --run-level full_model
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Perf Test · No Async Chunk"
+        key: nightly-omni-performance-no-async-chunk
+        timeout_in_minutes: 300
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Perf Test · Async Chunk"
+        key: nightly-omni-performance-async-chunk
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Perf Test · vLLM Text"
+        key: nightly-omni-performance-vllm-text
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Omni · Perf Test · Multi-Replica"
+        key: nightly-omni-performance-multi-replicas
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_3
+
+      - label: ":full_moon: Omni · Multi-Replica Startup Test with 4x H100"
+        timeout_in_minutes: 45
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py -m "full_model" --run-level "core_model"
+        mirror_hardwares: h100_4
+
+  - group: ":card_index_dividers: TTS Model Test"
+    key: nightly-tts-test-group
+    depends_on: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "tts-test"
+    steps:
+
+      - label: ":full_moon: TTS · Function Test with L4"
+        timeout_in_minutes: 120
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - export VLLM_USE_DEEP_GEMM="0"
+          - export VLLM_MOE_USE_DEEP_GEMM="0"
+          - pytest -s -v tests/e2e/ -m "full_model and L4 and tts" --run-level "full_model" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_voxcpm2_tts_expansion.py
+        mirror_hardwares: l4_1
+
+      - label: ":full_moon: TTS · Accuracy Test · VoxCPM2"
+        timeout_in_minutes: 30
+        commands:
+          - |
+            timeout 30m bash -c "
+              export VLLM_LOGGING_LEVEL=DEBUG
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
+              pytest -s -v tests/e2e/online_serving/test_voxcpm2_tts_expansion.py -m 'full_model and cuda and tts' --run-level 'full_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: ":full_moon: TTS · Perf Test"
+        key: nightly-tts-performance
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: TTS · VoxCPM2 · Perf Test"
+        key: nightly-tts-performance-voxcpm2
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_voxcpm2.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: TTS · Higgs-Audio-V3 · Perf Test"
+        key: nightly-tts-performance-higgs-audio-v3
+        timeout_in_minutes: 180
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - export VLLM_USE_DEEP_GEMM="0"
+          - export VLLM_MOE_USE_DEEP_GEMM="0"
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_higgs_audio_v3.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+        mirror_hardwares: h100_1
+
+  - group: ":card_index_dividers: Tiny Model Tests [Multi-GPU]"
+    key: nightly-tiny-model-test-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test"
+    steps:
+
+      - label: ":full_moon: Tiny Model Tests · Diffusion (Multi-GPU accelerations)"
+        timeout_in_minutes: 30
+        # NOTE: Single-GPU (core_model) tiny model tests run on the ready label,
+        # so nightly only adds the multi-GPU parallelism configurations.
+        #
+        # This is a bit confusing, but `full_model` is used to mark the multigpu tests, and
+        # --run-level `core_model` is used to indicate that we should use tiny model weights
+        # for the CI, since these tests should pass irrespective of whether or not we use
+        # the full weights or not.
+        commands:
+          - timeout 25m pytest -sv tests/model_tests/diffusion -m 'full_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_4
+
+  - group: ":card_index_dividers: Diffusion X2I(&A&T) Model Test"
+    key: nightly-diffusion-x2iat-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2iat-test"
+    steps:
+      # Use explicit file shards so single-card cases do not reserve 2+ GPUs,
+      # and Bagel feature coverage is not duplicated via a broad tests/e2e sweep.
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Single-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_qwen_image_expansion.py
+            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
+            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
+            tests/e2e/online_serving/test_boogu_image.py
+            tests/e2e/online_serving/test_boogu_image_edit.py
+            tests/e2e/online_serving/test_boogu_image_expansion.py
+            tests/e2e/online_serving/test_boogu_image_edit_expansion.py
+            tests/e2e/online_serving/test_bagel_expansion.py
+            tests/e2e/online_serving/test_krea2_expansion.py
+            tests/e2e/offline_inference/test_krea2_expansion.py
+            -m "full_model and diffusion and H100 and not distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Qwen-Image"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_qwen_image_expansion.py
+            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
+            tests/e2e/offline_inference/test_krea2_expansion.py
+            -m "full_model and diffusion and H100 and distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Layered/LongCat/FLUX"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
+            -m "full_model and diffusion and H100 and distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Bagel"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_bagel_expansion.py
+            -m "full_model and diffusion and H100 and distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · GLM-Image Function Test with H100"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_glm_image_expansion.py
+            tests/e2e/offline_inference/test_glm_image_autoround_w4a16_expansion.py
+            -m "full_model and diffusion and H100"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with L4"
+        timeout_in_minutes: 120
+        commands:
+          - pytest -sv tests/e2e/ -k "not test_wan and not test_bagel_expansion and not hunyuan" -m "full_model and diffusion and L4" --run-level "full_model" --ignore=tests/e2e/accuracy
+        mirror_hardwares: l4_4
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Doc Test"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -s -v tests/examples/*/test_text_to_image.py -m "full_model and example and H100" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - export VLLM_HTTP_TIMEOUT_KEEP_ALIVE=120
+          - pytest -s -v tests/e2e/accuracy/test_qwen_image*.py --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2i_matches_diffusers' -m full_model --run-level full_model
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: HunyuanImage3-DIT · Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - export HUNYUAN_IMAGE3_MODEL="tencent/HunyuanImage-3.0-Instruct"
+          - export HUNYUAN_IMAGE3_DEVICES="0,1,2,3"
+          - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m full_model --run-level full_model
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image"
+        key: nightly-diffusion-x2iat-performance-qwen-image
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Edit"
+        key: nightly-diffusion-x2iat-performance-qwen-image-edit
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Edit-2511"
+        key: nightly-diffusion-x2iat-performance-qwen-image-edit-2511
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Layered"
+        key: nightly-diffusion-x2iat-performance-qwen-image-layered
+        timeout_in_minutes: 120
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · BAGEL"
+        key: nightly-diffusion-x2iat-performance-bagel
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_bagel_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_1
+
+  - group: ":card_index_dividers: Diffusion X2V Model Test"
+    key: nightly-diffusion-x2v-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2v-test"
+    steps:
+
+      - label: ":full_moon: Diffusion X2V · Wan2.2 T2V Function Test"
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · Wan2.2 I2V/TI2V Function Test"
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · LingBot Video MoE Function Test"
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_lingbot_video_moe.py -m "full_model and cuda" --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: Diffusion X2V · Doc Test"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -s -v tests/examples/offline_inference/test_image_to_video.py -m "full_model and example and H100" --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: Diffusion X2V · Other Function Test"
+        timeout_in_minutes: 90
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py -m "full_model and cuda" --run-level "full_model"
+          - pytest -s -v tests/e2e/online_serving/test_wan_2_1_vace_expansion.py tests/e2e/online_serving/test_ltx2_expansion.py -m "full_model and cuda" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · Wan2.2 Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - pytest -s -v tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py -m full_model --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2v_matches_diffusers' -m full_model --run-level full_model
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · MiniMax H3 T2VA Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - pytest -s -v tests/e2e/accuracy/minimax_h3/test_minimax_h3_t2va_similarity.py -m full_model --run-level full_model
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion X2V · Other Accuracy Test"
+        timeout_in_minutes: 180
+        commands:
+          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py -m full_model --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py -m full_model --run-level full_model
+          - pytest -s -v 'tests/e2e/accuracy/ltx/test_ltx_official_similarity.py::test_ltx_one_stage_matches_official[ltx2_3_i2v]' -m full_model --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/test_video_streaming_output_similarity.py -m full_model --run-level full_model
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · Perf Test"
+        key: nightly-diffusion-x2v-performance
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
+            EXIT1=$$?
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
+            EXIT2=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            if [ $$EXIT1 -ne 0 ]; then exit $$EXIT1; fi
+            exit $$EXIT2
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion X2V · Perf Test · MiniMax-H3"
+        key: nightly-diffusion-x2v-performance-minimax-h3
+        timeout_in_minutes: 180
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+        mirror_hardwares: h100_4
+
+  - group: ":card_index_dividers: Diffusion Test"
+    key: nightly-diffusion-test-group
+    depends_on: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test"
+    steps:
+      - label: ":full_moon: Diffusion · Distributed Test with L4"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4' --run-level "full_model"
+        mirror_hardwares: l4_4
+
+      - label: ":full_moon: Diffusion · Distributed Test with H100"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and H100' --run-level "full_model"
+        mirror_hardwares: h100_4
+
+      - label: ":full_moon: Diffusion · Offloader Test"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -sv tests/diffusion/offloader -m "full_model and cuda"
+        mirror_hardwares: l4_1
+
+      - label: ":full_moon: Diffusion · Quantization Test with H100 · Single-GPU"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and H100' --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: ":full_moon: Diffusion · MiniMax H3 FP8 Quality Test with H100 · 2-GPU"
+        timeout_in_minutes: 60
+        commands:
+          - pytest -sv tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py -m 'full_model and cuda and H100' --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: ":full_moon: Diffusion · Quantization Test with L4"
+        timeout_in_minutes: 60
+        commands:
+          - pip install "vllm-gguf-plugin>=0.0.3"
+          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and L4' --run-level "full_model"
+        mirror_hardwares: l4_1
+
+  - label: ":bar_chart: Testcase Statistics"
+    key: nightly-testcase-statistics
+    timeout_in_minutes: 120
+    depends_on: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1"
+    commands:
+      - python tools/nightly/buildkite_testcase_statistics.py -o tests/dfx/perf/results/buildkite_testcase_statistics.html
+      - buildkite-agent artifact upload "tests/dfx/perf/results/*.html"
+    mirror_hardwares: h100_1
+
+  # NOTE: ":email: Nightly Collection & Email" is deprecated and will be removed soon.
+  # Do not add new depends_on entries or extend this step.
+  - label: ":email: Nightly Collection & Email"
+    key: nightly-perf-distribution
+    depends_on:
+      - nightly-omni-performance-no-async-chunk
+      - nightly-omni-performance-async-chunk
+      - nightly-omni-performance-vllm-text
+      - nightly-omni-performance-multi-replicas
+      - nightly-tts-performance
+      - nightly-tts-performance-higgs-audio-v3
+      - nightly-diffusion-x2iat-performance-qwen-image
+      - nightly-diffusion-x2iat-performance-qwen-image-edit
+      - nightly-diffusion-x2iat-performance-qwen-image-edit-2511
+      - nightly-diffusion-x2iat-performance-qwen-image-layered
+      - nightly-diffusion-x2iat-performance-bagel
+      - nightly-diffusion-x2v-performance
+      - nightly-testcase-statistics
+    if: build.env("NIGHTLY") == "1" && build.env("EMAIL_DISTRIBUTION") == "1"
+    commands:
+      - pip install openpyxl
+      - export DEFAULT_INPUT_DIR=tests/dfx/perf/results
+      - export DEFAULT_OUTPUT_DIR=tests/dfx/perf/results
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-tts-performance
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-tts-performance-higgs-audio-v3
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-no-async-chunk
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-async-chunk
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-vllm-text
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-multi-replicas
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-edit
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-edit-2511
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-layered
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-bagel
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2v-performance
+      - buildkite-agent artifact download "tests/dfx/perf/results/*.html" . --step nightly-testcase-statistics
+      - python tools/nightly/generate_nightly_perf_excel.py
+      - python tools/nightly/generate_nightly_perf_html.py
+      - python tools/nightly/send_nightly_email.py --report-file "tests/dfx/perf/results/*.xlsx, tests/dfx/perf/results/*.html"
+      - buildkite-agent artifact upload "tests/dfx/perf/results/*.xlsx"
+      - buildkite-agent artifact upload "tests/dfx/perf/results/*.html"
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/cuda/test-ready.yml b/.buildkite/cuda/test-ready.yml
new file mode 100644
index 000000000..68149036d
--- /dev/null
+++ b/.buildkite/cuda/test-ready.yml
@@ -0,0 +1,346 @@
+env:
+  VLLM_WORKER_MULTIPROC_METHOD: spawn
+  VLLM_USE_FLASHINFER_MOE_FP16: 0
+  HF_HUB_DOWNLOAD_TIMEOUT: 300
+  HF_HUB_ETAG_TIMEOUT: 60
+
+steps:
+  - group: ":card_index_dividers: Simple Test"
+    depends_on: upload-ready-pipeline
+    steps:
+      - label: "Simple · Model Executor Test"
+        commands:
+          - "timeout 20m pytest -sv tests/model_executor -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Diffusion Test"
+        commands:
+          - "timeout 20m pytest -sv tests/diffusion -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Engine&Entrypoints Test"
+        commands:
+          - "timeout 20m pytest -sv tests/entrypoints tests/engine -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+      - label: "Simple · Other Test"
+        commands:
+          - "timeout 20m pytest -sv tests/ -m 'core_model and cpu' --ignore=tests/diffusion --ignore=tests/model_executor --ignore=tests/entrypoints --ignore=tests/engine --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
+        mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: Diffusion Test"
+    depends_on: upload-ready-pipeline
+    steps:
+
+      - label: "Diffusion · Offloader Test"
+        commands:
+          - timeout 40m pytest -s -v tests/diffusion/offloader -m "core_model and cuda" --run-level "core_model"
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Cache Test"
+        commands:
+          - timeout 15m pytest -sv tests/diffusion/cache -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Batch Test"
+        commands:
+          - timeout 15m pytest -sv tests/diffusion/batching -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Distributed Test"
+        source_file_dependencies:
+          - tests/diffusion/distributed/
+          - vllm_omni/diffusion/distributed/
+          - vllm_omni/diffusion/attention/parallel/
+          - vllm_omni/diffusion/data.py
+          - vllm_omni/diffusion/models/
+        commands:
+          - timeout 20m pytest -sv tests/diffusion/distributed -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_4
+
+      - label: "Diffusion · Model Test"
+        commands:
+          - timeout 15m pytest -sv tests/diffusion/models/ -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Other Test"
+        commands:
+          - timeout 15m pytest -sv tests/diffusion/*.py -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: Tiny Model Tests [Single GPU]"
+    depends_on: upload-ready-pipeline
+    steps:
+
+      - label: "Tiny Model Tests · Diffusion (base)"
+        commands:
+          - timeout 15m pytest -sv tests/model_tests/diffusion -m 'core_model and cuda' --run-level "core_model"
+        mirror_hardwares: l4_1
+
+  - label: "Engine&Model Executor Test"
+    depends_on: upload-ready-pipeline
+    commands:
+      - |
+        timeout 15m bash -c "
+                  pytest -sv tests/engine/ tests/model_executor/ -m 'core_model and cuda' --run-level 'core_model'
+        "
+    mirror_hardwares: l4_1
+
+  - label: "Distributed Test"
+    depends_on: upload-ready-pipeline
+    commands:
+      - |
+        timeout 20m bash -c "
+          pytest -sv tests/distributed/ -m 'core_model and cuda and L4' --run-level 'core_model'
+        "
+    mirror_hardwares: l4_1
+
+  - label: "Entrypoints Test"
+    depends_on: upload-ready-pipeline
+    commands:
+      - |
+        timeout 30m bash -c "
+          export VLLM_WORKER_MULTIPROC_METHOD=spawn
+          pytest -sv tests/entrypoints/ -m 'core_model and cuda' --run-level 'core_model'
+        "
+    mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: E2E Test"
+    depends_on: upload-ready-pipeline
+    steps:
+      - label: "Custom Pipeline Test"
+        source_file_dependencies:
+          - tests/e2e/features/custom_pipeline/
+          - tests/e2e/features/helpers/custom_pipeline.py
+          - vllm_omni/diffusion/
+          - vllm_omni/engine/
+          - vllm_omni/entrypoints/
+          - vllm_omni/inputs/
+          - vllm_omni/outputs/
+        commands:
+          - timeout 20m pytest -s -v tests/e2e/features/custom_pipeline/ -m "core_model"
+        agents:
+          queue: "gpu_1_queue"
+        plugins:
+          - docker#v5.2.0:
+              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
+              always-pull: true
+              propagate-environment: true
+              environment:
+                - "HF_HOME=/fsx/hf_cache"
+              volumes:
+                - "/fsx/hf_cache:/fsx/hf_cache"
+
+      - label: "RLHF · VeRL-Omni E2E Test"
+        source_file_dependencies:
+          - tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
+          - tests/e2e/features/helpers/verl_omni_server.py
+          - tests/e2e/features/helpers/custom_pipeline.py
+          - vllm_omni/diffusion/
+          - vllm_omni/engine/
+          - vllm_omni/entrypoints/
+          - vllm_omni/inputs/
+          - vllm_omni/outputs/
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
+            "
+        mirror_hardwares: l4_1
+
+      - label: "Omni · Qwen3-Omni Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_omni.py
+          - vllm_omni/model_executor/models/qwen3_omni/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
+          - vllm_omni/deploy/qwen3_omni_moe.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_2
+
+      - label: "Omni · MiniCPM-o 4.5 Offline Test"
+        source_file_dependencies:
+          - tests/e2e/offline_inference/test_minicpmo_4_5.py
+          - vllm_omni/deploy/minicpmo_4_5.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_2
+
+      - label: "Omni · MiniCPM-o 4.5 Online Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_minicpmo_4_5.py
+          - vllm_omni/deploy/minicpmo_4_5.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_2
+
+      - label: "Omni · MiniCPM-o 4.5 Duplex Test"
+        source_file_dependencies:
+          - tests/assets/minicpmo_4_5/response_required_16k.wav
+          - tests/assets/minicpmo_4_5/soft_interrupt_16k.wav
+          - tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
+          - tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
+          - tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
+          - tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py
+          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
+          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
+          - tests/helpers/minicpmo_4_5_duplex.py
+          - vllm_omni/deploy/minicpmo_4_5_duplex.yaml
+          - vllm_omni/experimental/fullduplex/
+          - vllm_omni/model_executor/models/minicpmo_4_5/
+          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+          - vllm_omni/core/sched/
+          - vllm_omni/outputs/multimodal_accumulation.py
+          - vllm_omni/engine/stage_init_utils.py
+          - vllm_omni/engine/async_omni_engine.py
+          - vllm_omni/entrypoints/cli/serve.py
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py -m 'core_model and cuda' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_2
+
+      - label: "TTS · VoxCPM2 Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_voxcpm2_tts.py
+          - vllm_omni/model_executor/models/voxcpm2/
+          - vllm_omni/deploy/voxcpm2.yaml
+        timeout_in_minutes: 30
+        commands:
+          - |
+            timeout 30m bash -c "
+              export VLLM_LOGGING_LEVEL=DEBUG
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              pytest -s -v tests/e2e/online_serving/test_voxcpm2_tts.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "TTS · Qwen3-TTS CustomVoice Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
+          - vllm_omni/model_executor/models/qwen3_tts/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+          - vllm_omni/deploy/qwen3_tts.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
+              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "TTS · Qwen3-TTS Base Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_tts_base.py
+          - vllm_omni/model_executor/models/qwen3_tts/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+          - vllm_omni/deploy/qwen3_tts.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
+              export VLLM_OMNI_USE_V2_RUNNER=1
+              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_base.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "TTS · Higgs-Audio-V3 Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_higgs_audio_v3.py
+          - vllm_omni/model_executor/models/higgs_audio_v3/
+          - vllm_omni/model_executor/stage_input_processors/higgs_audio_v3.py
+          - vllm_omni/deploy/higgs_multimodal_qwen3.yaml
+        commands:
+          - |
+            timeout 20m bash -c "
+              export VLLM_WORKER_MULTIPROC_METHOD=spawn
+              export VLLM_USE_DEEP_GEMM=0
+              export VLLM_MOE_USE_DEEP_GEMM=0
+              pytest -s -v tests/e2e/online_serving/test_higgs_audio_v3.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: l4_1
+
+      - label: "Diffusion · Qwen Image Edit Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image_edit.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - |
+            timeout 20m bash -c "
+              pytest -s -v tests/e2e/online_serving/test_qwen_image_edit.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Bagel Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_bagel.py
+          - vllm_omni/model_executor/models/bagel/
+          - vllm_omni/diffusion/models/bagel/
+          - vllm_omni/model_executor/stage_input_processors/bagel.py
+          - vllm_omni/deploy/bagel.yaml
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_bagel.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Wan22 Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_wan22_t2v.py
+          - vllm_omni/diffusion/models/wan2_2/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_wan22_t2v.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Cosmos3 Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_cosmos3.py
+          - vllm_omni/diffusion/models/cosmos3/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_cosmos3.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Qwen Image Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Qwen Image Layered Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image_layered.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - |
+            timeout 40m bash -c "
+              export VLLM_IMAGE_FETCH_TIMEOUT=60
+              pytest -s -v tests/e2e/online_serving/test_qwen_image_layered.py -m 'core_model' --run-level 'core_model'
+            "
+        mirror_hardwares: h100_1
diff --git a/.buildkite/cuda/test-weekly.yml b/.buildkite/cuda/test-weekly.yml
new file mode 100644
index 000000000..cc7f99647
--- /dev/null
+++ b/.buildkite/cuda/test-weekly.yml
@@ -0,0 +1,136 @@
+env:
+  VLLM_WORKER_MULTIPROC_METHOD: spawn
+  VLLM_USE_FLASHINFER_MOE_FP16: 0
+  HF_HUB_DOWNLOAD_TIMEOUT: 300
+  HF_HUB_ETAG_TIMEOUT: 60
+
+steps:
+
+  - label: "Reliability Test - qwen3-omni"
+    timeout_in_minutes: 180
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    commands:
+      - pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m "slow"
+    mirror_hardwares: h100_2
+
+  - label: "Reliability Test - wan22"
+    timeout_in_minutes: 180
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    commands:
+      - pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m "slow"
+    mirror_hardwares: h100_2
+
+  - label: "Reliability Test - hunyuan-image"
+    timeout_in_minutes: 180
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    commands:
+      - pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m "slow"
+    mirror_hardwares: h100_4
+
+  - label: "Reliability Test - voxcpm2"
+    timeout_in_minutes: 180
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    commands:
+      - pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m "slow"
+    mirror_hardwares: l4_1
+
+  - group: "Reliability Test - Invalid parameters Test"
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    steps:
+
+      - label: "Invalid parameters Test · H100"
+        timeout_in_minutes: 120
+        commands:
+          - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and H100"
+        mirror_hardwares: h100_2
+
+      - label: "Invalid parameters Test · L4"
+        timeout_in_minutes: 120
+        commands:
+          - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and L4"
+        mirror_hardwares: l4_1
+
+  - group: ":card_index_dividers: E2E Tests"
+    depends_on: upload-weekly-pipeline
+    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
+    steps:
+
+      - label: "Omni · L4"
+        timeout_in_minutes: 90
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - pytest -s -v tests/e2e/*/test_qwen2_5_omni_expansion.py --run-level "core_model"
+          - >-
+            pytest -s -v tests/e2e/
+            --ignore=tests/e2e/online_serving/test_qwen2_5_omni_expansion.py
+            --ignore=tests/e2e/offline_inference/test_qwen2_5_omni_expansion.py
+            -m "slow and L4 and omni"
+            --run-level "full_model"
+        mirror_hardwares: l4_4
+
+      - label: "Omni · H100"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and H100 and omni"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "TTS · L4"
+        timeout_in_minutes: 90
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - export VLLM_USE_DEEP_GEMM="0"
+          - export VLLM_MOE_USE_DEEP_GEMM="0"
+          - |
+            failed=0
+            for f in $(pytest --collect-only -q tests/e2e/ -m "slow and L4 and tts" --run-level "full_model" | grep '\.py::' | sed -E 's|::.*||' | sort -u); do
+              pytest -s -v "$$f" -m "slow and L4 and tts" --run-level "full_model" || failed=1
+            done
+            exit $$failed
+        mirror_hardwares: l4_1
+
+      - label: "TTS · H100"
+        timeout_in_minutes: 90
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - export VLLM_USE_DEEP_GEMM="0"
+          - export VLLM_MOE_USE_DEEP_GEMM="0"
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and H100 and tts"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · L4"
+        timeout_in_minutes: 60
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and diffusion and L4"
+            --run-level "full_model"
+        mirror_hardwares: l4_4
+
+      - label: "Diffusion · H100 · Single-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and diffusion and H100 and not distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · H100 · Multi-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and diffusion and H100 and distributed_cuda"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
diff --git a/.buildkite/pipeline-intel.yaml b/.buildkite/intel/pipeline-intel.yml
similarity index 73%
rename from .buildkite/pipeline-intel.yaml
rename to .buildkite/intel/pipeline-intel.yml
index d3a2655bf..acb135101 100644
--- a/.buildkite/pipeline-intel.yaml
+++ b/.buildkite/intel/pipeline-intel.yml
@@ -1,16 +1,16 @@
-# .buildkite/pipeline-intel.yaml
+# .buildkite/intel/pipeline-intel.yml
 steps:
   - group: "INTEL Tests"
     steps:
       - label: "Intel: XPU Test"
-        command: "bash .buildkite/scripts/hardware_ci/run-xpu-test.sh"
+        command: "bash .buildkite/intel/scripts/run-xpu-test.sh"
         agents:
           queue: "intel-gpu-omni"
         env:
           DOCKER_BUILDKIT: "1"
           # Buildkite will automatically replace this with the actual commit hash
           VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}"
-          VLLM_VERSION: "v0.25.0"
+          VLLM_VERSION: "v0.26.0"
         priority: 100
         timeout_in_minutes: 60
         soft_fail: false
diff --git a/.buildkite/intel/scripts/bootstrap-intel-omni.sh b/.buildkite/intel/scripts/bootstrap-intel-omni.sh
new file mode 100755
index 000000000..a5d3f00a6
--- /dev/null
+++ b/.buildkite/intel/scripts/bootstrap-intel-omni.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# vllm-omni Intel bootstrap
+# Uses static pipeline-intel.yml for Intel XPU tests
+
+set -euo pipefail
+
+source .buildkite/common/scripts/resolve_skip_ci.sh
+
+upload_pipeline() {
+    echo "--- 🛠 Preparing Intel pipeline"
+    buildkite-agent pipeline upload .buildkite/intel/pipeline-intel.yml
+}
+
+gate_bootstrap_ci intel l2
+
+upload_pipeline
diff --git a/.buildkite/scripts/hardware_ci/run-xpu-test.sh b/.buildkite/intel/scripts/run-xpu-test.sh
similarity index 95%
rename from .buildkite/scripts/hardware_ci/run-xpu-test.sh
rename to .buildkite/intel/scripts/run-xpu-test.sh
index 36860522b..6b40d58fb 100755
--- a/.buildkite/scripts/hardware_ci/run-xpu-test.sh
+++ b/.buildkite/intel/scripts/run-xpu-test.sh
@@ -74,6 +74,6 @@ time timeout -k 30 30m docker run \
     cd /workspace/vllm-omni
     pytest -v -s -m "core_model and xpu and B60"
     pytest -v -s tests/diffusion/quantization/test_mxfp8_config.py
-    export VLLM_XPU_USE_SAMPLER_KERNEL=0    # NOTE: Remove this after vLLM v0.21.1 is merged. Fixes Qwen2-5 omni-expansion tests.
     pytest -v -s -m "advanced_model and xpu and B60"
+    pytest -v -s -m "omni and xpu and B60"
 '
diff --git a/.buildkite/npu/bootstrap-upload-steps.yml b/.buildkite/npu/bootstrap-upload-steps.yml
new file mode 100644
index 000000000..64b97f895
--- /dev/null
+++ b/.buildkite/npu/bootstrap-upload-steps.yml
@@ -0,0 +1,181 @@
+# Uploaded by upload_pipeline.py --upload (not the Buildkite hook).
+# ``if`` is injected by step ``key`` from skip-ci at upload time.
+steps:
+  - label: ":buildkit: Build and Push NPU Test Image - A2"
+    key: image-build-a2
+    agents:
+      queue: "ascend-a2b3"
+      resource_class: "npu-1"
+    plugins:
+      - kubernetes:
+          metadata:
+            annotations:
+              vault.hashicorp.com/agent-init-first: "true"
+              vault.hashicorp.com/agent-inject: "true"
+              vault.hashicorp.com/agent-inject-perms-ca.pem: "0400"
+              vault.hashicorp.com/agent-inject-perms-cert.pem: "0400"
+              vault.hashicorp.com/agent-inject-perms-config.json: "0400"
+              vault.hashicorp.com/agent-inject-perms-key.pem: "0400"
+              vault.hashicorp.com/agent-inject-secret-ca.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-cert.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-config.json: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-key.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-template-ca.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.RootCA }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-cert.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaCert }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-config.json: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.dockerConfig }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-key.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaKey }}\n{{- end }}"
+              vault.hashicorp.com/agent-pre-populate-only: "true"
+              vault.hashicorp.com/agent-run-as-group: "1000"
+              vault.hashicorp.com/agent-run-as-user: "1000"
+              vault.hashicorp.com/agent-service-account-token-volume-name: token-vol
+              vault.hashicorp.com/role: ascend-gha-runners
+              vault.hashicorp.com/secret-volume-path: /home/user/.docker/
+              vault.hashicorp.com/tls-skip-verify: "true"
+          podSpecPatch:
+            volumes:
+            - name: token-vol
+              projected:
+                defaultMode: 420
+                sources:
+                - serviceAccountToken:
+                    audience: api
+                    expirationSeconds: 600
+                    path: token
+    env:
+      VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}"
+      IMAGE_NAME: "vllm-omni-ci-npu"
+      IMAGE_REGISTRY: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry"
+      BUILDKITD_ADDR: "tcp://buildkitd-service.buildkitd:1234"
+    command: |
+      set -ex
+
+      echo "--- Building and pushing NPU Test Image"
+      echo "Image: $${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
+      echo "buildkitd address: $${BUILDKITD_ADDR}"
+
+      if ! command -v buildctl &> /dev/null; then
+        echo "Installing buildctl..."
+        mkdir -p /tmp/buildkit
+        BUILDKIT_VERSION="v0.29.0"
+        wget -q "https://github.com/moby/buildkit/releases/download/$${BUILDKIT_VERSION}/buildkit-$${BUILDKIT_VERSION}.linux-arm64.tar.gz" -O /tmp/buildkit.tar.gz
+        tar -xzf /tmp/buildkit.tar.gz -C /tmp/buildkit
+        cp /tmp/buildkit/bin/buildctl /usr/local/bin/
+      fi
+
+      export DOCKER_CONFIG=/home/user/.docker
+      buildctl \
+        --addr="$${BUILDKITD_ADDR}" \
+        --tlscacert=/home/user/.docker/ca.pem \
+        --tlscert=/home/user/.docker/cert.pem \
+        --tlskey=/home/user/.docker/key.pem \
+        build \
+        --frontend dockerfile.v0 \
+        --local context=. \
+        --local dockerfile=./docker \
+        --opt filename=Dockerfile.npu.ci \
+        --secret id=dockerconfig,src=/home/user/.docker/config.json \
+        --output type=image,name=$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG},push=true \
+        --progress=plain
+
+      echo "--- Image pushed successfully"
+      echo "$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
+
+  - label: ":buildkit: Build and Push NPU Test Image - A3"
+    key: image-build-a3
+    agents:
+      queue: "ascend-a2b3"
+      resource_class: "npu-1"
+    plugins:
+      - kubernetes:
+          metadata:
+            annotations:
+              vault.hashicorp.com/agent-init-first: "true"
+              vault.hashicorp.com/agent-inject: "true"
+              vault.hashicorp.com/agent-inject-perms-ca.pem: "0400"
+              vault.hashicorp.com/agent-inject-perms-cert.pem: "0400"
+              vault.hashicorp.com/agent-inject-perms-config.json: "0400"
+              vault.hashicorp.com/agent-inject-perms-key.pem: "0400"
+              vault.hashicorp.com/agent-inject-secret-ca.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-cert.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-config.json: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-secret-key.pem: internal/data/ascend/buildkitd
+              vault.hashicorp.com/agent-inject-template-ca.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.RootCA }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-cert.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaCert }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-config.json: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.dockerConfig }}\n{{- end }}"
+              vault.hashicorp.com/agent-inject-template-key.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaKey }}\n{{- end }}"
+              vault.hashicorp.com/agent-pre-populate-only: "true"
+              vault.hashicorp.com/agent-run-as-group: "1000"
+              vault.hashicorp.com/agent-run-as-user: "1000"
+              vault.hashicorp.com/agent-service-account-token-volume-name: token-vol
+              vault.hashicorp.com/role: ascend-gha-runners
+              vault.hashicorp.com/secret-volume-path: /home/user/.docker/
+              vault.hashicorp.com/tls-skip-verify: "true"
+          podSpecPatch:
+            volumes:
+            - name: token-vol
+              projected:
+                defaultMode: 420
+                sources:
+                - serviceAccountToken:
+                    audience: api
+                    expirationSeconds: 600
+                    path: token
+    env:
+      VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}-a3"
+      IMAGE_NAME: "vllm-omni-ci-npu"
+      IMAGE_REGISTRY: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry"
+      BUILDKITD_ADDR: "tcp://buildkitd-service.buildkitd:1234"
+    command: |
+      set -ex
+
+      echo "--- Building and pushing NPU Test Image"
+      echo "Image: $${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
+      echo "buildkitd address: $${BUILDKITD_ADDR}"
+
+      if ! command -v buildctl &> /dev/null; then
+        echo "Installing buildctl..."
+        mkdir -p /tmp/buildkit
+        BUILDKIT_VERSION="v0.29.0"
+        wget -q "https://github.com/moby/buildkit/releases/download/$${BUILDKIT_VERSION}/buildkit-$${BUILDKIT_VERSION}.linux-arm64.tar.gz" -O /tmp/buildkit.tar.gz
+        tar -xzf /tmp/buildkit.tar.gz -C /tmp/buildkit
+        cp /tmp/buildkit/bin/buildctl /usr/local/bin/
+      fi
+
+      export DOCKER_CONFIG=/home/user/.docker
+      buildctl \
+        --addr="$${BUILDKITD_ADDR}" \
+        --tlscacert=/home/user/.docker/ca.pem \
+        --tlscert=/home/user/.docker/cert.pem \
+        --tlskey=/home/user/.docker/key.pem \
+        build \
+        --frontend dockerfile.v0 \
+        --local context=. \
+        --local dockerfile=./docker \
+        --opt filename=Dockerfile.npu.ci.a3 \
+        --secret id=dockerconfig,src=/home/user/.docker/config.json \
+        --output type=image,name=$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG},push=true \
+        --progress=plain
+
+      echo "--- Image pushed successfully"
+      echo "$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
+
+  - label: "Upload Ready Pipeline"
+    depends_on:
+      - image-build-a2
+      - image-build-a3
+    key: upload-ready-pipeline
+    agents:
+      queue: "cpu_queue_premerge"
+    command: |
+      python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/npu/test-npu-ready.yml
+
+  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
+  - label: "Upload Nightly Pipeline"
+    depends_on:
+      - image-build-a2
+      - image-build-a3
+    key: upload-nightly-pipeline
+    commands:
+      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/npu/test-npu-nightly.yml
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/pipeline-npu-a3.yaml b/.buildkite/npu/pipeline-npu-a3.yml
similarity index 97%
rename from .buildkite/pipeline-npu-a3.yaml
rename to .buildkite/npu/pipeline-npu-a3.yml
index 8776219e1..a57f5f8e5 100644
--- a/.buildkite/pipeline-npu-a3.yaml
+++ b/.buildkite/npu/pipeline-npu-a3.yml
@@ -88,7 +88,7 @@
 #   #     queue: "ascend-a3"
 #   #     resource_class: "npu-2"
 #   #   command: |
-#   #     buildkite-agent pipeline upload .buildkite/test-npu-ready.yaml
+#   #     buildkite-agent pipeline upload .buildkite/npu/test-npu-ready.yml
 
   # # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
   # - label: "Upload Nightly Pipeline"
@@ -104,7 +104,7 @@
   #       build.pull_request.labels includes "diffusion-x2v-test"
   #     ))
   #   commands:
-  #     - buildkite-agent pipeline upload .buildkite/test-npu-nightly.yaml
+  #     - buildkite-agent pipeline upload .buildkite/npu/test-npu-nightly.yml
   #   agents:
   #     queue: "ascend-a3"
   #     resource_class: "npu-2"
diff --git a/.buildkite/npu/pipeline-npu.yml b/.buildkite/npu/pipeline-npu.yml
new file mode 100644
index 000000000..237b65593
--- /dev/null
+++ b/.buildkite/npu/pipeline-npu.yml
@@ -0,0 +1,9 @@
+# Hook uploads this entry YAML; upload_pipeline.py --upload reads bootstrap-upload-steps.yml
+# and injects ``if`` by step ``key`` from skip-ci.
+steps:
+  - label: ":github: Resolve skip-ci & upload pipeline"
+    key: upload-ci-pipeline
+    commands:
+      - "python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/npu/bootstrap-upload-steps.yml"
+    agents:
+      queue: "cpu_queue_premerge"
diff --git a/.buildkite/npu/test-npu-nightly.yml b/.buildkite/npu/test-npu-nightly.yml
new file mode 100644
index 000000000..10626600c
--- /dev/null
+++ b/.buildkite/npu/test-npu-nightly.yml
@@ -0,0 +1,205 @@
+steps:
+  - group: ":card_index_dividers: Omni Model Test"
+    key: nightly-omni-test-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "omni-test"
+    steps:
+      - label: ":full_moon: Omni · Perf Test · No Async Chunk"
+        key: nightly-omni-performance-no-async-chunk
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py -m npu --test-config-file tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+      - label: ":full_moon: Omni · Perf Test · Async Chunk"
+        key: nightly-omni-performance-async-chunk
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py -m npu --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+      - label: ":robot: Omni · MiniCPM-o 4.5 Test"
+        mirror_hardwares: a3_npu_2
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5_expansion.py -m 'full_model' --run-level 'full_model'
+  - group: ":card_index_dividers: TTS Model Test"
+    key: nightly-tts-test-group
+    depends_on: upload-nightly-pipeline
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "tts-test"
+    steps:
+      - label: ":full_moon: TTS · Perf Test"
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_2
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py -m npu --test-config-file tests/dfx/perf/tests/test_tts.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
+            exit $$EXIT
+  - group: ":card_index_dividers: Diffusion X2I(&A&T) Model Test"
+    key: nightly-diffusion-x2iat-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2iat-test"
+    steps:
+      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Edit-2511"
+        key: nightly-diffusion-x2iat-performance-qwen-image-edit-2511
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_8
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - export CACHE_DIT_VERSION=1.3.0
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m npu --test-config-file tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+  - group: ":card_index_dividers: Diffusion I2I Model Test"
+    key: nightly-HunyuanImage3-x2i-test-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2iat-test"
+    steps:
+      - label: ":full_moon: HunyuanImage3-DIT · Accuracy Test"
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          HUNYUAN_IMAGE3_MODEL: "tencent/HunyuanImage-3.0-Instruct"
+          HUNYUAN_IMAGE3_DEVICES: "0,1,2,3"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m "full_model and A3" --run-level full_model
+  - group: ":card_index_dividers: Diffusion Benchmark Perf Test"
+    key: nightly-diffusion-benchmark-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2iat-test"
+    steps:
+      - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=2 CFGP=2"
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          HF_TOKEN: "${HF_TOKEN}"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m A3 --test-config-file tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+      - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=2 SP=2"
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          HF_TOKEN: "${HF_TOKEN}"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m A3 --test-config-file tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+      - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=4"
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          HF_TOKEN: "${HF_TOKEN}"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m A3 --test-config-file tests/dfx/perf/tests/test_hunyuan_image_tp4.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
+  - group: ":card_index_dividers: Diffusion X2V Model Test"
+    key: nightly-diffusion-x2v-group
+    depends_on: upload-nightly-pipeline
+    if: >-
+      build.env("NIGHTLY") == "1" ||
+      build.pull_request.labels includes "nightly-test" ||
+      build.pull_request.labels includes "diffusion-x2v-test"
+    steps:
+      - label: ":full_moon: Diffusion X2V · Function Test"
+        mirror_hardwares: a2b3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k npu_i2v --run-level "full_model"
+      - label: ":full_moon: Diffusion X2V · Perf Test"
+        key: nightly-diffusion-x2v-performance
+        timeout_in_minutes: 180
+        mirror_hardwares: a3_npu_4
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+          DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
+        commands:
+          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
+          - |
+            set +e
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m npu --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
+            EXIT=$$?
+            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
+            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
+            exit $$EXIT
diff --git a/.buildkite/npu/test-npu-ready.yml b/.buildkite/npu/test-npu-ready.yml
new file mode 100644
index 000000000..c427ff065
--- /dev/null
+++ b/.buildkite/npu/test-npu-ready.yml
@@ -0,0 +1,34 @@
+steps:
+  - group: ":card_index_dividers: Omni Model Test"
+    key: ready-omni-group
+    depends_on: upload-ready-pipeline
+    steps:
+      - label: ":robot: Omni · MiniCPM-o 4.5 Test"
+        agents:
+          queue: "ascend-a3"
+          resource_class: "npu-2"
+        image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}-a3"
+        plugins:
+          - kubernetes:
+              podSpecPatch:
+                imagePullSecrets:
+                  - name: swr-secret
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5.py -m 'core_model' --run-level 'core_model'
+
+  - group: ":card_index_dividers: TTS Model Test"
+    key: ready-tts-group
+    depends_on: upload-ready-pipeline
+    steps:
+      - label: ":sound: TTS · Qwen3-TTS CustomVoice Test"
+        mirror_hardwares: a2b3_npu_1
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+          HF_TOKEN: "${HF_TOKEN}"
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py -m 'core_model and npu' --run-level 'core_model'
diff --git a/.buildkite/pipeline-npu.yaml b/.buildkite/pipeline-npu.yaml
deleted file mode 100644
index 161b0e944..000000000
--- a/.buildkite/pipeline-npu.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-steps:
-  - label: ":buildkit: Build and Push NPU Test Image - A2"
-    key: image-build
-    agents:
-      queue: "ascend-a2b3"
-      resource_class: "npu-1"
-    plugins:
-      - kubernetes:
-          metadata:
-            annotations:
-              vault.hashicorp.com/agent-init-first: "true"
-              vault.hashicorp.com/agent-inject: "true"
-              vault.hashicorp.com/agent-inject-perms-ca.pem: "0400"
-              vault.hashicorp.com/agent-inject-perms-cert.pem: "0400"
-              vault.hashicorp.com/agent-inject-perms-config.json: "0400"
-              vault.hashicorp.com/agent-inject-perms-key.pem: "0400"
-              vault.hashicorp.com/agent-inject-secret-ca.pem: internal/data/ascend/buildkitd
-              vault.hashicorp.com/agent-inject-secret-cert.pem: internal/data/ascend/buildkitd
-              vault.hashicorp.com/agent-inject-secret-config.json: internal/data/ascend/buildkitd
-              vault.hashicorp.com/agent-inject-secret-key.pem: internal/data/ascend/buildkitd
-              vault.hashicorp.com/agent-inject-template-ca.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.RootCA }}\n{{- end }}"
-              vault.hashicorp.com/agent-inject-template-cert.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaCert }}\n{{- end }}"
-              vault.hashicorp.com/agent-inject-template-config.json: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.dockerConfig }}\n{{- end }}"
-              vault.hashicorp.com/agent-inject-template-key.pem: "{{- with secret \"internal/data/ascend/buildkitd\" -}}\n{{ .Data.data.ClientCaKey }}\n{{- end }}"
-              vault.hashicorp.com/agent-pre-populate-only: "true"
-              vault.hashicorp.com/agent-run-as-group: "1000"
-              vault.hashicorp.com/agent-run-as-user: "1000"
-              vault.hashicorp.com/agent-service-account-token-volume-name: token-vol
-              vault.hashicorp.com/role: ascend-gha-runners
-              vault.hashicorp.com/secret-volume-path: /home/user/.docker/
-              vault.hashicorp.com/tls-skip-verify: "true"
-          podSpecPatch:
-            volumes:
-            - name: token-vol
-              projected:
-                defaultMode: 420
-                sources:
-                - serviceAccountToken:
-                    audience: api
-                    expirationSeconds: 600
-                    path: token
-    env:
-      VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}"
-      IMAGE_NAME: "vllm-omni-ci-npu"
-      IMAGE_REGISTRY: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry"
-      BUILDKITD_ADDR: "tcp://buildkitd-service.buildkitd:1234"
-    command: |
-      set -ex
-
-      echo "--- Building and pushing NPU Test Image"
-      echo "Image: $${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
-      echo "buildkitd address: $${BUILDKITD_ADDR}"
-
-      if ! command -v buildctl &> /dev/null; then
-        echo "Installing buildctl..."
-        mkdir -p /tmp/buildkit
-        BUILDKIT_VERSION="v0.29.0"
-        wget -q "https://github.com/moby/buildkit/releases/download/$${BUILDKIT_VERSION}/buildkit-$${BUILDKIT_VERSION}.linux-arm64.tar.gz" -O /tmp/buildkit.tar.gz
-        tar -xzf /tmp/buildkit.tar.gz -C /tmp/buildkit
-        cp /tmp/buildkit/bin/buildctl /usr/local/bin/
-      fi
-
-      export DOCKER_CONFIG=/home/user/.docker
-      buildctl \
-        --addr="$${BUILDKITD_ADDR}" \
-        --tlscacert=/home/user/.docker/ca.pem \
-        --tlscert=/home/user/.docker/cert.pem \
-        --tlskey=/home/user/.docker/key.pem \
-        build \
-        --frontend dockerfile.v0 \
-        --local context=. \
-        --local dockerfile=./docker \
-        --opt filename=Dockerfile.npu.ci \
-        --secret id=dockerconfig,src=/home/user/.docker/config.json \
-        --output type=image,name=$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG},push=true \
-        --progress=plain
-
-      echo "--- Image pushed successfully"
-      echo "$${IMAGE_REGISTRY}/$${IMAGE_NAME}:$${VLLM_IMAGE_TAG}"
-
-  - label: "Upload Ready Pipeline"
-    depends_on: image-build
-    key: upload-ready-pipeline
-    if: >-
-      build.branch != "main" && (
-        build.pull_request.labels includes "npu-test" ||
-        build.pull_request.labels includes "ready"
-      )
-    agents:
-      queue: "ascend-a2b3"
-      resource_class: "npu-1"
-    command: |
-      buildkite-agent pipeline upload .buildkite/test-npu-ready.yaml
-
-  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
-  - label: "Upload Nightly Pipeline"
-    depends_on: image-build
-    key: upload-nightly-pipeline
-    if: >-
-      (build.branch == "main" && build.env("NIGHTLY") == "1") ||
-      (build.branch != "main" && (
-        build.pull_request.labels includes "nightly-test" ||
-        build.pull_request.labels includes "omni-test" ||
-        build.pull_request.labels includes "tts-test" ||
-        build.pull_request.labels includes "diffusion-x2iat-test" ||
-        build.pull_request.labels includes "diffusion-x2v-test"
-      ))
-    commands:
-      - buildkite-agent pipeline upload .buildkite/test-npu-nightly.yaml
-    agents:
-      queue: "ascend-a2b3"
-      resource_class: "npu-1"
diff --git a/.buildkite/pipeline.yml b/.buildkite/pipeline.yml
deleted file mode 100644
index 040393f6c..000000000
--- a/.buildkite/pipeline.yml
+++ /dev/null
@@ -1,87 +0,0 @@
-# Document 1: Buildkite loads only this block on first parse. The next step resolves docs-only,
-# pytest skip-mark-only, or combined skip-ci from git diff, then uploads document 2. When skip-ci
-# applies, image-build still runs for the nightly exception in upload_pipeline.py (nightly-test
-# label or main NIGHTLY=1); otherwise upload-nightly can be skipped together with test-ready/test-merge.
-# Weekly uploads also depend on image-build.
-
-# Document 2: appended after `---`; same file, read by upload_pipeline.py (not evaluated as a second pipeline by Buildkite). Child uploads include test-ready.yml, test-merge.yml, test-nightly.yml, and test-weekly.yml.
-steps:
-  - label: ":github: Resolve skip-ci (docs / skip marks) & upload pipeline"
-    key: upload-ci-pipeline
-    commands:
-      - "python3 .buildkite/scripts/upload_pipeline.py --upload .buildkite/pipeline.yml"
-    agents:
-      queue: "cpu_queue_premerge"
-
----
-steps:
-  - label: ":docker: Build image"
-    key: image-build
-    if: __IMAGE_BUILD_IF__
-    commands:
-      - "aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/q9t5s3a7"
-      - "docker build --progress=plain --file docker/Dockerfile.ci -t vllm-omni-ci ."
-      - "docker tag vllm-omni-ci public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT"
-      - "docker push public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT"
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L2 Test — PR ready label (diff-aware) or main+NIGHTLY=1 (--e2e, full E2E group)
-  - label: "Upload Ready Pipeline"
-    depends_on: image-build
-    key: upload-ready-pipeline
-    if: __UPLOAD_READY_IF__
-    commands:
-      - |
-        EXTRA=""
-        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
-          EXTRA="--e2e"
-        fi
-        python3 .buildkite/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/test-ready.yml
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L3 Test — PR merge-test label (diff-aware) or main+NIGHTLY=1 (--e2e, full E2E group)
-  - label: "Upload Merge Pipeline"
-    depends_on: image-build
-    key: upload-merge-pipeline
-    if: __UPLOAD_MERGE_IF__
-    commands:
-      - |
-        EXTRA=""
-        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
-          EXTRA="--e2e"
-        fi
-        python3 .buildkite/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/test-merge.yml
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
-  - label: "Upload Nightly Pipeline"
-    depends_on: image-build
-    key: upload-nightly-pipeline
-    if: >-
-      (build.branch == "main" && build.env("NIGHTLY") == "1") ||
-      (build.branch != "main" && (
-        build.pull_request.labels includes "nightly-test" ||
-        build.pull_request.labels includes "omni-test" ||
-        build.pull_request.labels includes "tts-test" ||
-        build.pull_request.labels includes "diffusion-x2iat-test" ||
-        build.pull_request.labels includes "diffusion-x2v-test"
-      ))
-    commands:
-      - buildkite-agent pipeline upload .buildkite/test-nightly.yml
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L5 Test — main+WEEKLY=1 (scheduled), or PR with weekly-test label
-  - label: "Upload Weekly Pipeline"
-    depends_on: image-build
-    key: upload-weekly-pipeline
-    if: >-
-      (build.branch == "main" && build.env("WEEKLY") == "1") ||
-      (build.branch != "main" && build.pull_request.labels includes "weekly-test")
-    commands:
-      - buildkite-agent pipeline upload .buildkite/test-weekly.yml
-    agents:
-      queue: "cpu_queue_premerge"
diff --git a/.buildkite/rebase-pipeline.yaml b/.buildkite/rebase-pipeline.yaml
deleted file mode 100644
index 796ad19a7..000000000
--- a/.buildkite/rebase-pipeline.yaml
+++ /dev/null
@@ -1,38 +0,0 @@
-steps:
-  - label: ":docker: Build image"
-    key: image-build
-    commands:
-      - "aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/q9t5s3a7"
-      - "docker build --progress=plain --file docker/Dockerfile.ci -t vllm-omni-ci ."
-      - "docker tag vllm-omni-ci public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT"
-      - "docker push public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT"
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L2 Test
-  - label: "Upload Ready Pipeline"
-    depends_on: image-build
-    key: upload-ready-pipeline
-    commands:
-      - python3 .buildkite/scripts/upload_pipeline.py --upload --all .buildkite/test-ready.yml
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L3 Test
-  - label: "Upload Merge Pipeline"
-    depends_on: image-build
-    key: upload-merge-pipeline
-    commands:
-      - python3 .buildkite/scripts/upload_pipeline.py --upload --all .buildkite/test-merge.yml
-    agents:
-      queue: "cpu_queue_premerge"
-
-  # L4 Test
-  - label: "Upload Nightly Pipeline"
-    depends_on: image-build
-    key: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1"
-    commands:
-      - python3 .buildkite/scripts/upload_pipeline.py --upload --all .buildkite/test-nightly.yml
-    agents:
-      queue: "cpu_queue_premerge"
diff --git a/.buildkite/release-pipeline.yaml b/.buildkite/release/release-pipeline.yml
similarity index 92%
rename from .buildkite/release-pipeline.yaml
rename to .buildkite/release/release-pipeline.yml
index c560fefe1..351e105cc 100644
--- a/.buildkite/release-pipeline.yaml
+++ b/.buildkite/release/release-pipeline.yml
@@ -16,7 +16,7 @@ steps:
       - "uv venv --python=3.12 && source .venv/bin/activate"
       - "uv pip install --upgrade build"
       - "python3 -m build"
-      - "bash .buildkite/scripts/upload-nightly-wheels.sh"
+      - "bash .buildkite/release/scripts/upload-nightly-wheels.sh"
 
   - label: "Generate and upload wheel indices"
     depends_on: "build-wheel"
@@ -24,7 +24,7 @@ steps:
     agents:
       queue: small_cpu_queue_release
     commands:
-      - "bash .buildkite/scripts/generate-and-upload-nightly-index.sh"
+      - "bash .buildkite/release/scripts/generate-and-upload-nightly-index.sh"
 
   - block: "Upload release wheels to PyPI"
     depends_on: "build-wheel"
@@ -38,7 +38,7 @@ steps:
     agents:
       queue: small_cpu_queue_release
     commands:
-      - "bash .buildkite/scripts/publish-release-wheels-pypi.sh"
+      - "bash .buildkite/release/scripts/publish-release-wheels-pypi.sh"
 
   - block: "Unblock to build release Docker images"
     depends_on: ~
@@ -100,7 +100,7 @@ steps:
     agents:
       queue: small_cpu_queue_release
     commands:
-      - "bash .buildkite/scripts/publish-release-images.sh"
+      - "bash .buildkite/release/scripts/publish-release-images.sh"
     plugins:
       - docker-login#v3.0.0:
           username: vllmbot
diff --git a/.buildkite/scripts/generate-and-upload-nightly-index.sh b/.buildkite/release/scripts/generate-and-upload-nightly-index.sh
similarity index 92%
rename from .buildkite/scripts/generate-and-upload-nightly-index.sh
rename to .buildkite/release/scripts/generate-and-upload-nightly-index.sh
index b09c13f5c..63f5da596 100755
--- a/.buildkite/scripts/generate-and-upload-nightly-index.sh
+++ b/.buildkite/release/scripts/generate-and-upload-nightly-index.sh
@@ -36,12 +36,12 @@ mkdir -p "$INDICES_OUTPUT_DIR"
 
 # HACK: we do not need regex module here, but it is required by pre-commit hook
 # To avoid any external dependency, we simply replace it back to the stdlib re module
-sed -i.bak 's/import regex as re/import re/g' .buildkite/scripts/generate-nightly-index.py && rm -f .buildkite/scripts/generate-nightly-index.py.bak
+sed -i.bak 's/import regex as re/import re/g' .buildkite/release/scripts/generate-nightly-index.py && rm -f .buildkite/release/scripts/generate-nightly-index.py.bak
 
 # Generate indices -- the version is just the commit hash (not omni/{commit})
 # because relative paths are computed between the index and wheel directories,
 # both of which live under the omni/ prefix in S3.
-$PYTHON .buildkite/scripts/generate-nightly-index.py \
+$PYTHON .buildkite/release/scripts/generate-nightly-index.py \
     --version "$BUILDKITE_COMMIT" \
     --current-objects "$obj_json" \
     --output-dir "$INDICES_OUTPUT_DIR" \
@@ -78,7 +78,7 @@ if [[ "$version" != *"dev"* ]]; then
     rm -rf "${INDICES_OUTPUT_DIR:?}"
     mkdir -p "$INDICES_OUTPUT_DIR"
     # wheel-dir is overridden to be the commit directory, so that the indices point to the correct wheel path
-    $PYTHON .buildkite/scripts/generate-nightly-index.py \
+    $PYTHON .buildkite/release/scripts/generate-nightly-index.py \
         --version "$s3_version" \
         --wheel-dir "$BUILDKITE_COMMIT" \
         --current-objects "$obj_json" \
diff --git a/.buildkite/scripts/generate-nightly-index.py b/.buildkite/release/scripts/generate-nightly-index.py
similarity index 100%
rename from .buildkite/scripts/generate-nightly-index.py
rename to .buildkite/release/scripts/generate-nightly-index.py
diff --git a/.buildkite/scripts/publish-release-images.sh b/.buildkite/release/scripts/publish-release-images.sh
similarity index 100%
rename from .buildkite/scripts/publish-release-images.sh
rename to .buildkite/release/scripts/publish-release-images.sh
diff --git a/.buildkite/scripts/publish-release-wheels-pypi.sh b/.buildkite/release/scripts/publish-release-wheels-pypi.sh
similarity index 100%
rename from .buildkite/scripts/publish-release-wheels-pypi.sh
rename to .buildkite/release/scripts/publish-release-wheels-pypi.sh
diff --git a/.buildkite/scripts/upload-nightly-wheels.sh b/.buildkite/release/scripts/upload-nightly-wheels.sh
similarity index 100%
rename from .buildkite/scripts/upload-nightly-wheels.sh
rename to .buildkite/release/scripts/upload-nightly-wheels.sh
diff --git a/.buildkite/scripts/docker_login_ecr_public.sh b/.buildkite/scripts/docker_login_ecr_public.sh
deleted file mode 100755
index 51c5e1a5d..000000000
--- a/.buildkite/scripts/docker_login_ecr_public.sh
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/bin/bash
-# Helper function to safely login to ECR Public with per-job config isolation
-# Uses DOCKER_CONFIG environment variable to prevent race conditions
-#
-# This script prevents the "device or resource busy" error by giving each
-# Buildkite job its own isolated Docker config directory.
-#
-# Usage:
-#   source docker_login_ecr_public.sh && safe_docker_login_ecr_public
-
-set -euo pipefail
-
-# Configuration
-ECR_REGISTRY="public.ecr.aws"
-
-setup_isolated_docker_config() {
-    # Use BUILDKITE_JOB_ID for job-specific isolation
-    # Fallback to PID if running outside Buildkite
-    local job_id="${BUILDKITE_JOB_ID:-$$}"
-
-    # Set Docker config to job-specific directory
-    export DOCKER_CONFIG="/tmp/docker-config-${job_id}"
-
-    # Create directory if it doesn't exist
-    mkdir -p "$DOCKER_CONFIG"
-
-    echo "[docker-config] Using isolated Docker config: $DOCKER_CONFIG"
-}
-
-check_docker_auth() {
-    # Check if already authenticated to the given registry
-    # Returns 0 if authenticated, 1 if not
-    local registry="$1"
-
-    # Check if credentials exist in the isolated config
-    if [[ -f "$DOCKER_CONFIG/config.json" ]]; then
-        # Check if registry is present in config
-        if grep -q "$registry" "$DOCKER_CONFIG/config.json" 2>/dev/null; then
-            return 0
-        fi
-    fi
-
-    return 1
-}
-
-safe_docker_login_ecr_public() {
-    # Setup isolated config first
-    setup_isolated_docker_config
-
-    local registry="$ECR_REGISTRY"
-
-    # Check if already authenticated (within this job)
-    if check_docker_auth "$registry"; then
-        echo "[docker-login] Already authenticated to $registry in this job"
-        return 0
-    fi
-
-    # Perform login to isolated config directory
-    echo "[docker-login] Logging in to $ECR_REGISTRY (isolated config)..."
-    if aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin "$ECR_REGISTRY"; then
-        echo "[docker-login] Login successful (config: $DOCKER_CONFIG)"
-        return 0
-    else
-        local exit_code=$?
-        echo "[docker-login] ERROR: Login failed with exit code $exit_code" >&2
-        return $exit_code
-    fi
-}
-
-# Execute if run as script (not sourced)
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    safe_docker_login_ecr_public
-fi
diff --git a/.buildkite/scripts/hardware_ci/run_npu_test.sh b/.buildkite/scripts/hardware_ci/run_npu_test.sh
deleted file mode 100644
index 492699c5f..000000000
--- a/.buildkite/scripts/hardware_ci/run_npu_test.sh
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/bin/bash
-
-# This script build the Ascend NPU docker image and run the offline inference inside the container.
-# It serves a sanity check for compilation and basic model usage.
-set -ex
-
-# Base ubuntu image with basic ascend development libraries and python installed
-VLLM_OMNI_REPO="https://github.com/vllm-project/vllm-omni.git"
-BASE_IMAGE_NAME="quay.nju.edu.cn/ascend/vllm-ascend:v0.11.0rc2"
-image_name="npu/vllm-omni-ci:${BUILDKITE_COMMIT}_${EPOCHSECONDS}"
-# image_name="npu/vllm-ci:${BUILDKITE_COMMIT}_${EPOCHSECONDS}"
-container_name="npu_${BUILDKITE_COMMIT}_$(tr -dc A-Za-z0-9 < /dev/urandom | head -c 10; echo)"
-
-# BUILDKITE_AGENT_NAME format is {hostname}-{agent_idx}-{npu_card_num}cards
-agent_idx=$(echo "${BUILDKITE_AGENT_NAME}" | awk -F'-' '{print $(NF-1)}')
-echo "agent_idx: ${agent_idx}"
-builder_name="cachebuilder${agent_idx}"
-builder_cache_dir="/mnt/docker-cache${agent_idx}"
-mkdir -p ${builder_cache_dir}
-
-# Try building the docker image
-cat <<EOF | DOCKER_BUILDKIT=1 docker build \
-    --add-host pypi-cache:${PYPI_CACHE_HOST} \
-    --builder ${builder_name} --cache-from type=local,src=${builder_cache_dir} \
-                           --cache-to type=local,dest=${builder_cache_dir},mode=max \
-    --build-arg BUILDKITE_PULL_REQUEST="${BUILDKITE_PULL_REQUEST}" \
-    --build-arg BUILDKITE_PULL_REQUEST_REPO="${BUILDKITE_PULL_REQUEST_REPO}" \
-    --progress=plain --load -t ${image_name} -f - .
-FROM ${BASE_IMAGE_NAME}
-
-# Define environments
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN pip config set global.index-url http://pypi-cache:${PYPI_CACHE_PORT}/pypi/simple && \
-    pip config set global.trusted-host pypi-cache && \
-    apt-get update -y && \
-    apt-get install -y python3-pip git vim wget net-tools gcc g++ cmake libnuma-dev && \
-    rm -rf /var/cache/apt/* && \
-    rm -rf /var/lib/apt/lists/*
-
-# Install for pytest to make the docker build cache layer always valid
-RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install pytest>=6.0  pytest-cov modelscope
-
-COPY . .
-
-# Install vllm-omni
-WORKDIR /workspace
-ARG VLLM_OMNI_REPO=https://github.com/vllm-project/vllm-omni.git
-ARG VLLM_OMNI_TAG=main
-ARG BUILDKITE_PULL_REQUEST
-ARG BUILDKITE_PULL_REQUEST_REPO
-RUN git config --global url."https://gh-proxy.test.osinfra.cn/https://github.com/".insteadOf "https://github.com/" && \
-    if [ "\$BUILDKITE_PULL_REQUEST" != "false" ] && [ -n "\$BUILDKITE_PULL_REQUEST" ]; then \
-        echo "Cloning and checking out PR #\$BUILDKITE_PULL_REQUEST..." && \
-        git clone \$VLLM_OMNI_REPO /workspace/vllm-omni && \
-        cd /workspace/vllm-omni && \
-        git fetch origin pull/\$BUILDKITE_PULL_REQUEST/head:pr-\$BUILDKITE_PULL_REQUEST && \
-        git checkout pr-\$BUILDKITE_PULL_REQUEST; \
-    else \
-        echo "Not a PR build, using main branch" && \
-        git clone --depth 1 \$VLLM_OMNI_REPO /workspace/vllm-omni; \
-    fi
-
-RUN --mount=type=cache,target=/root/.cache/pip \
-    export PIP_EXTRA_INDEX_URL=https://mirrors.huaweicloud.com/ascend/repos/pypi && \
-    source /usr/local/Ascend/ascend-toolkit/set_env.sh && \
-    source /usr/local/Ascend/nnal/atb/set_env.sh && \
-    export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/usr/local/Ascend/ascend-toolkit/latest/`uname -i`-linux/devlib && \
-    python3 -m pip install -v -e /workspace/vllm-omni/
-
-ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
-
-WORKDIR /workspace/vllm-omni
-CMD ["/bin/bash"]
-
-EOF
-
-# Setup cleanup
-remove_docker_container() {
-  docker rm -f "${container_name}" || true;
-  docker image rm -f "${image_name}" || true;
-  docker system prune -f || true;
-}
-trap remove_docker_container EXIT
-
-# Generate corresponding --device args based on BUILDKITE_AGENT_NAME
-# Ascend NPU BUILDKITE_AGENT_NAME format is {hostname}-{agent_idx}-{npu_card_num}cards, and agent_idx starts from 1.
-#   e.g. atlas-a2-001-1-2cards means this is the 1-th agent on atlas-a2-001 host, and it has 2 NPU cards.
-#   returns --device /dev/davinci0 --device /dev/davinci1
-parse_and_gen_devices() {
-    local input="$1"
-    local index cards_num
-    if [[ "$input" =~ ([0-9]+)-([0-9]+)cards$ ]]; then
-        index="${BASH_REMATCH[1]}"
-        cards_num="${BASH_REMATCH[2]}"
-    else
-        echo "parse error" >&2
-        return 1
-    fi
-
-    local devices=""
-    local i=0
-    while (( i < cards_num )); do
-        local dev_idx=$(((index - 1)*cards_num + i ))
-        devices="$devices --device /dev/davinci${dev_idx}"
-        ((i++))
-    done
-
-    # trim leading space
-    devices="${devices#"${devices%%[![:space:]]*}"}"
-    # Output devices: assigned to the caller variable
-    printf '%s' "$devices"
-}
-
-devices=$(parse_and_gen_devices "${BUILDKITE_AGENT_NAME}") || exit 1
-
-# Run the image and execute the Out-Of-Tree (OOT) platform interface test case on Ascend NPU hardware.
-# This test checks whether the OOT platform interface is functioning properly in conjunction with
-# the hardware plugin vllm-ascend.
-hf_model_cache_dir=/mnt/hf_cache${agent_idx}
-ms_model_cache_dir=/mnt/modelscope${agent_idx}
-mkdir -p ${hf_model_cache_dir}
-mkdir -p ${ms_model_cache_dir}
-docker run \
-    --init \
-    ${devices} \
-    --device /dev/davinci_manager \
-    --device /dev/devmm_svm \
-    --device /dev/hisi_hdc \
-    -v /usr/local/dcmi:/usr/local/dcmi \
-    -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
-    -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \
-    -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \
-    -v /etc/ascend_install.info:/etc/ascend_install.info \
-    -v ${hf_model_cache_dir}:/root/.cache/huggingface \
-    -v ${ms_model_cache_dir}:/root/.cache/modelscope \
-    --network host \
-    --entrypoint="" \
-    --name "${container_name}" \
-    "${image_name}" \
-    bash -c '
-    set -e
-    VLLM_USE_MODELSCOPE=True pytest -s -v tests/e2e/offline_inference/test_qwen2_5_omni_expansion.py
-'
diff --git a/.buildkite/scripts/upload_pipeline.py b/.buildkite/scripts/upload_pipeline.py
deleted file mode 100644
index d9220ed0f..000000000
--- a/.buildkite/scripts/upload_pipeline.py
+++ /dev/null
@@ -1,547 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: Apache-2.0
-"""Render and optionally upload Buildkite pipeline YAML with diff-aware logic.
-
-Bootstrap mode (pipeline.yml with __IMAGE_BUILD_IF__ placeholders):
-  - Detect docs-only, pytest skip-mark-only, or combined docs+skip-mark PR/main changes and
-    substitute skip-ci ``if`` expressions.
-
-Test pipeline mode (e.g. test-merge.yml):
-  - Drop steps or groups whose ``source_file_dependencies`` do not match changed files.
-  - ``source_file_dependencies`` may be set on a leaf step or on a group step.
-  - Always strip ``source_file_dependencies`` from uploaded YAML (Buildkite does not
-    recognize this uploader-only key).
-
-Usage:
-  python3 upload_pipeline.py [--upload] [--all | --e2e] <pipeline.yml>
-
-  # Bootstrap (replaces upload_pipeline_with_skip_ci.sh):
-  python3 upload_pipeline.py --upload .buildkite/pipeline.yml
-
-  # Test pipeline (replaces upload_test_pipeline_with_diff_skip.py):
-  python3 upload_pipeline.py --upload .buildkite/test-merge.yml
-
-  # Full suite (rebase pipeline): keep all steps, still strip the uploader-only key:
-  python3 upload_pipeline.py --upload --all .buildkite/test-merge.yml
-
-  # Nightly L2 E2E only: keep the E2E Test group, ignore source_file_dependencies:
-  python3 upload_pipeline.py --upload --e2e .buildkite/test-ready.yml
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-try:
-    import yaml
-except ImportError:
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "-q", "pyyaml"],
-    )
-    import yaml
-
-LOG = "upload_pipeline"
-ROOT = Path(__file__).resolve().parent.parent.parent
-DOC_SEP = "\n---\n"
-BOOTSTRAP_MARKER = "__IMAGE_BUILD_IF__"
-E2E_GROUP_MARKER = "E2E Test"
-
-
-def _log(message: str) -> None:
-    print(f"{LOG}: {message}", file=sys.stderr)
-
-
-def _git(*args: str) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        ["git", *args],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-
-
-def resolve_diff_range() -> str | None:
-    """Return a git diff range for PR or main builds, or None when unavailable."""
-    is_pr = os.environ.get("BUILDKITE_PULL_REQUEST", "false") != "false" and os.environ.get(
-        "BUILDKITE_PULL_REQUEST", ""
-    )
-    commit = os.environ.get("BUILDKITE_COMMIT", "")
-
-    if is_pr:
-        base_branch = os.environ.get("BUILDKITE_PULL_REQUEST_BASE_BRANCH", "main")
-        base_ref = f"origin/{base_branch}"
-        if _git("rev-parse", "--verify", base_ref).returncode != 0:
-            _log(f"origin/{base_branch} not found locally; trying fetch")
-            _git("fetch", "--depth=200", "origin", base_branch)
-        if _git("rev-parse", "--verify", base_ref).returncode != 0:
-            if _git("rev-parse", "--verify", base_branch).returncode == 0:
-                base_ref = base_branch
-            else:
-                _log(f"cannot resolve PR base {base_branch}; using safe defaults")
-                return None
-        return f"{base_ref}...{commit}"
-
-    if os.environ.get("BUILDKITE_BRANCH", "") == "main":
-        if _git("rev-parse", "--verify", f"{commit}^").returncode != 0:
-            _log("main commit has no parent; using safe defaults")
-            return None
-        return f"{commit}^..{commit}"
-
-    _log("not PR/main build; using safe defaults")
-    return None
-
-
-def resolve_changed_files() -> list[str] | None:
-    """Return changed file paths, or None when diff cannot be resolved."""
-    diff_range = resolve_diff_range()
-    if diff_range is None:
-        return None
-
-    result = _git("diff", "--name-only", diff_range)
-    if result.returncode != 0:
-        _log(f"git diff failed ({diff_range}); using safe defaults")
-        return None
-
-    files = [line for line in result.stdout.splitlines() if line.strip()]
-    _log(f"{len(files)} changed file(s)")
-    return files
-
-
-def _is_doc_file(file_path: str) -> bool:
-    if not file_path:
-        return False
-    if file_path.startswith("docs/"):
-        return True
-    if file_path.endswith(".md"):
-        return True
-    return file_path == "mkdocs.yml"
-
-
-def is_docs_only_change(changed_files: list[str]) -> bool:
-    has_any = False
-    for file_path in changed_files:
-        if not file_path:
-            continue
-        has_any = True
-        if not _is_doc_file(file_path):
-            return False
-    return has_any
-
-
-def _is_test_python_file(file_path: str) -> bool:
-    path = Path(file_path)
-    return path.suffix == ".py" and bool(path.parts) and path.parts[0] == "tests"
-
-
-_SKIP_MARK_RE = re.compile(r"pytest\.mark\.skip(?:if)?\b|pytest\.skip\s*\(")
-_PYTESTMARK_SKIP_RE = re.compile(r"pytest\.mark\.skip\b")
-_PYTEST_MARK_ONLY_RE = re.compile(r"pytest\.mark\.\w+")
-
-
-def _paren_balance(line: str) -> int:
-    return line.count("(") - line.count(")")
-
-
-def _is_skip_mark_related_content(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped:
-        return True
-    if stripped.startswith("#"):
-        return True
-    return _SKIP_MARK_RE.search(stripped) is not None
-
-
-def _is_pytestmark_adjacent_content(line: str) -> bool:
-    """Allow pytestmark list refactors that only add skip/skipif alongside existing marks."""
-    stripped = line.strip().rstrip(",")
-    if not stripped:
-        return True
-    if stripped in {"[", "]"}:
-        return True
-    if stripped.startswith("#"):
-        return True
-    if stripped.startswith("pytestmark"):
-        return True
-    return _PYTEST_MARK_ONLY_RE.search(stripped) is not None
-
-
-def diff_only_contains_skip_mark_changes(diff_text: str) -> bool:
-    """True when diff only edits skip marks or reformats pytestmark to add them."""
-    pending_depth = 0
-    saw_change = False
-    has_skip_mark_edit = False
-    for raw_line in diff_text.splitlines():
-        if raw_line.startswith("@@"):
-            pending_depth = 0
-            continue
-        if not (raw_line.startswith("+") or raw_line.startswith("-")):
-            continue
-        if raw_line.startswith("+++") or raw_line.startswith("---"):
-            continue
-
-        saw_change = True
-        content = raw_line[1:]
-
-        if pending_depth > 0:
-            pending_depth += _paren_balance(content)
-            if pending_depth < 0:
-                pending_depth = 0
-            continue
-
-        if _is_skip_mark_related_content(content):
-            has_skip_mark_edit = True
-            pending_depth = max(0, _paren_balance(content))
-            continue
-
-        if _is_pytestmark_adjacent_content(content):
-            continue
-
-        return False
-
-    return saw_change and has_skip_mark_edit
-
-
-def _git_file_diff(file_path: str, diff_range: str) -> str | None:
-    result = _git("diff", diff_range, "--", file_path)
-    if result.returncode != 0:
-        _log(f"skip-mark-only: git diff failed for {file_path}")
-        return None
-    return result.stdout
-
-
-def _is_new_file_diff(diff_text: str) -> bool:
-    return "new file mode" in diff_text or "--- /dev/null" in diff_text
-
-
-def _file_has_module_level_pytest_skip(content: str) -> bool:
-    """True when ``pytestmark`` applies unconditional ``pytest.mark.skip`` to the module."""
-    match = re.search(r"^pytestmark\s*=\s*\[(.*?)^\s*\]", content, re.MULTILINE | re.DOTALL)
-    if match is not None:
-        return _PYTESTMARK_SKIP_RE.search(match.group(1)) is not None
-    match = re.search(r"^pytestmark\s*=\s*pytest\.mark\.skip\b", content, re.MULTILINE)
-    return match is not None
-
-
-def _file_content_at_commit(file_path: str, commit: str) -> str | None:
-    result = _git("show", f"{commit}:{file_path}")
-    if result.returncode != 0:
-        _log(f"skip-mark-only: cannot read {file_path} at {commit}")
-        return None
-    return result.stdout
-
-
-def _qualifies_as_skip_mark_test_change(file_path: str, diff_range: str) -> bool:
-    diff_text = _git_file_diff(file_path, diff_range)
-    if diff_text is None:
-        return False
-    if not diff_text.strip():
-        _log(f"skip-mark-only: empty diff for {file_path}")
-        return False
-
-    if diff_only_contains_skip_mark_changes(diff_text):
-        return True
-
-    if not _is_new_file_diff(diff_text):
-        _log(f"skip-mark-only: non-skip changes in {file_path}")
-        return False
-
-    commit = os.environ.get("BUILDKITE_COMMIT", "")
-    if not commit:
-        return False
-    content = _file_content_at_commit(file_path, commit)
-    if content is None:
-        return False
-    if _file_has_module_level_pytest_skip(content):
-        _log(f"skip-mark-only: new test file with module-level pytest.mark.skip: {file_path}")
-        return True
-
-    _log(f"skip-mark-only: new test file without module-level pytest.mark.skip: {file_path}")
-    return False
-
-
-def is_skip_mark_only_change(changed_files: list[str], *, diff_range: str) -> bool:
-    """True when every changed file is a tests/ module with only skip-mark edits."""
-    has_any = False
-    for file_path in changed_files:
-        if not file_path:
-            continue
-        has_any = True
-        if not _is_test_python_file(file_path):
-            return False
-        if not _qualifies_as_skip_mark_test_change(file_path, diff_range):
-            return False
-    return has_any
-
-
-def is_docs_or_skip_mark_only_change(changed_files: list[str], *, diff_range: str) -> bool:
-    """True when each changed file is a doc path or a qualifying skip-mark test change."""
-    has_any = False
-    for file_path in changed_files:
-        if not file_path:
-            continue
-        has_any = True
-        if _is_doc_file(file_path):
-            continue
-        if _is_test_python_file(file_path) and _qualifies_as_skip_mark_test_change(file_path, diff_range):
-            continue
-        _log(f"docs/skip-mark-only: rejecting {file_path}")
-        return False
-    return has_any
-
-
-def resolve_skip_ci(changed_files: list[str] | None, *, diff_range: str | None = None) -> bool:
-    if changed_files is None:
-        _log("skip-ci=0 (could not resolve changed files)")
-        return False
-
-    if diff_range is not None and is_docs_or_skip_mark_only_change(changed_files, diff_range=diff_range):
-        if is_docs_only_change(changed_files):
-            _log("docs-only change detected; skip-ci=1")
-        elif is_skip_mark_only_change(changed_files, diff_range=diff_range):
-            _log("pytest skip-mark-only change detected; skip-ci=1")
-        else:
-            _log("docs + pytest skip-mark-only change detected; skip-ci=1")
-        return True
-
-    if diff_range is None and is_docs_only_change(changed_files):
-        _log("docs-only change detected; skip-ci=1")
-        return True
-
-    _log("non-doc/non-skip-mark changes detected; skip-ci=0")
-    return False
-
-
-def render_bootstrap_pipeline(text: str, *, skip_ci: bool) -> str:
-    if DOC_SEP in text:
-        _, continuation = text.split(DOC_SEP, 1)
-    else:
-        continuation = text
-
-    nightly_only = (
-        '(build.pull_request.labels includes "nightly-test") || (build.branch == "main" && build.env("NIGHTLY") == "1")'
-    )
-    nightly_main = 'build.branch == "main" && build.env("NIGHTLY") == "1"'
-    ready_pr = 'build.branch != "main" && build.pull_request.labels includes "ready"'
-    merge_main = 'build.branch == "main" && build.env("NIGHTLY") != "1" && build.env("WEEKLY") != "1"'
-    merge_pr = 'build.branch != "main" && build.pull_request.labels includes "merge-test"'
-    if skip_ci:
-        image_if = f"'{nightly_only}'"
-        ready_if = f"'({nightly_main})'"
-        merge_if = f"'({nightly_main})'"
-    else:
-        image_if = "'true'"
-        ready_if = f"'(({nightly_main}) || ({ready_pr}))'"
-        merge_if = f"'(({nightly_main}) || (({merge_main}) || ({merge_pr})))'"
-
-    return (
-        continuation.replace("__IMAGE_BUILD_IF__", image_if)
-        .replace("__UPLOAD_READY_IF__", ready_if)
-        .replace("__UPLOAD_MERGE_IF__", merge_if)
-    )
-
-
-def _matches_dependencies(changed_files: list[str], prefixes: list[str]) -> bool:
-    for path in changed_files:
-        for prefix in prefixes:
-            normalized = prefix.rstrip("/")
-            if path == normalized or path.startswith(f"{normalized}/"):
-                return True
-    return False
-
-
-def _strip_source_file_dependencies(step: dict[str, Any]) -> dict[str, Any]:
-    return {key: value for key, value in step.items() if key != "source_file_dependencies"}
-
-
-def _step_label(step: dict[str, Any]) -> str:
-    return str(step.get("group") or step.get("label") or "<step>")
-
-
-def _filter_steps(steps: list[Any], changed_files: list[str]) -> list[Any]:
-    filtered: list[Any] = []
-    for step in steps:
-        if not isinstance(step, dict):
-            filtered.append(step)
-            continue
-
-        deps = step.get("source_file_dependencies")
-        if deps is not None and not isinstance(deps, list):
-            raise ValueError(
-                f"source_file_dependencies must be a list in step {_step_label(step)!r}",
-            )
-        if deps is not None and not _matches_dependencies(changed_files, deps):
-            _log(
-                f"skip {_step_label(step)!r} (no changes under {deps})",
-            )
-            continue
-
-        nested = step.get("steps")
-        if nested is not None:
-            kept_nested = _filter_steps(nested, changed_files)
-            if not kept_nested:
-                _log(f"omit empty group {_step_label(step)!r}")
-                continue
-            new_step = _strip_source_file_dependencies(step)
-            new_step["steps"] = kept_nested
-            filtered.append(new_step)
-            continue
-
-        if deps is not None:
-            filtered.append(_strip_source_file_dependencies(step))
-        else:
-            filtered.append(step)
-
-    return filtered
-
-
-def _is_e2e_group(step: dict[str, Any]) -> bool:
-    group = step.get("group")
-    return isinstance(group, str) and E2E_GROUP_MARKER in group
-
-
-def _select_e2e_group_steps(steps: list[Any]) -> list[Any]:
-    selected = [step for step in steps if isinstance(step, dict) and _is_e2e_group(step)]
-    if not selected:
-        _log(f"no group matching {E2E_GROUP_MARKER!r} found")
-    else:
-        _log(f"keep {len(selected)} group(s) matching {E2E_GROUP_MARKER!r}")
-    return selected
-
-
-def _strip_uploader_metadata_from_steps(steps: list[Any]) -> list[Any]:
-    """Remove uploader-only keys while keeping all steps (no diff filtering)."""
-    stripped: list[Any] = []
-    for step in steps:
-        if not isinstance(step, dict):
-            stripped.append(step)
-            continue
-
-        deps = step.get("source_file_dependencies")
-        if deps is not None and not isinstance(deps, list):
-            raise ValueError(
-                f"source_file_dependencies must be a list in step {_step_label(step)!r}",
-            )
-
-        nested = step.get("steps")
-        new_step = _strip_source_file_dependencies(step)
-        if nested is not None:
-            new_step["steps"] = _strip_uploader_metadata_from_steps(nested)
-        stripped.append(new_step)
-
-    return stripped
-
-
-def render_test_pipeline(
-    doc: dict[str, Any],
-    changed_files: list[str] | None,
-    *,
-    e2e_only: bool = False,
-) -> dict[str, Any]:
-    steps = doc.get("steps")
-    if not isinstance(steps, list):
-        return doc
-    if e2e_only:
-        steps = _select_e2e_group_steps(steps)
-        steps = _strip_uploader_metadata_from_steps(steps)
-    elif changed_files is not None:
-        steps = _filter_steps(steps, changed_files)
-    else:
-        steps = _strip_uploader_metadata_from_steps(steps)
-    return {**doc, "steps": steps}
-
-
-def resolve_pipeline_path(arg: str) -> Path:
-    path = Path(arg)
-    if path.is_absolute():
-        return path
-    return ROOT / path
-
-
-def render_pipeline(
-    path: Path,
-    *,
-    force_all: bool = False,
-    e2e_only: bool = False,
-) -> str:
-    text = path.read_text(encoding="utf-8")
-    diff_range = resolve_diff_range()
-    changed_files = resolve_changed_files()
-
-    # ``--all`` forces the keep-all-steps path (no diff-aware skipping) while still
-    # stripping ``source_file_dependencies``. Used by the rebase pipeline so main builds
-    # run the full e2e suite (see .buildkite/rebase-pipeline.yaml).
-    if force_all or e2e_only:
-        changed_files = None
-
-    if BOOTSTRAP_MARKER in text:
-        rendered = render_bootstrap_pipeline(
-            text,
-            skip_ci=resolve_skip_ci(changed_files, diff_range=diff_range),
-        )
-        return rendered
-
-    doc = yaml.safe_load(text)
-    if not isinstance(doc, dict):
-        raise ValueError(f"invalid pipeline YAML: {path}")
-
-    doc = render_test_pipeline(doc, changed_files, e2e_only=e2e_only)
-
-    return yaml.safe_dump(doc, sort_keys=False)
-
-
-def upload_to_buildkite(content: str) -> None:
-    subprocess.run(
-        ["buildkite-agent", "pipeline", "upload"],
-        input=content,
-        text=True,
-        check=True,
-    )
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "pipeline",
-        nargs="?",
-        default=".buildkite/pipeline.yml",
-        help="Pipeline YAML path (default: .buildkite/pipeline.yml)",
-    )
-    parser.add_argument(
-        "--upload",
-        action="store_true",
-        help="Pipe rendered YAML to buildkite-agent pipeline upload",
-    )
-    mode = parser.add_mutually_exclusive_group()
-    mode.add_argument(
-        "--all",
-        action="store_true",
-        help="Keep all steps (disable diff-aware skipping); still strips source_file_dependencies",
-    )
-    mode.add_argument(
-        "--e2e",
-        action="store_true",
-        help="Keep only the E2E Test group; disable diff-aware skipping for those steps",
-    )
-    args = parser.parse_args()
-
-    path = resolve_pipeline_path(args.pipeline)
-    if not path.is_file():
-        _log(f"missing pipeline file: {path}")
-        return 1
-
-    rendered = render_pipeline(path, force_all=args.all, e2e_only=args.e2e)
-    if args.upload:
-        upload_to_buildkite(rendered)
-    else:
-        sys.stdout.write(rendered)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/.buildkite/test-amd.yaml b/.buildkite/test-amd.yaml
deleted file mode 100644
index 520c1bbae..000000000
--- a/.buildkite/test-amd.yaml
+++ /dev/null
@@ -1,118 +0,0 @@
-steps:
-
-- label: "Diffusion Model Test"
-  timeout_in_minutes: 30
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - pytest -s -v tests/e2e/offline_inference/test_z_image.py
-
-- label: "Diffusion Images API LoRA E2E"
-  timeout_in_minutes: 30
-  agent_pool: mi325_1
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/diffusion/lora/test_images_generations_lora.py
-
-- label: "Diffusion Model CPU offloading Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_1
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/diffusion/offloader/test_diffusion_cpu_offload.py
-    - pytest -s -v tests/diffusion/offloader/test_diffusion_layerwise_offload.py
-
-- label: "Diffusion Cache Backend Test"
-  timeout_in_minutes: 15
-  agent_pool: mi325_1
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v -m 'core_model and cache and diffusion and not distributed_rocm and MI325'
-
-- label: "Diffusion Sequence Parallelism Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/diffusion/distributed/test_sequence_parallel.py -m core_model
-
-- label: "Diffusion Tensor Parallelism Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_2
-  depends_on: amd-build
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/diffusion/distributed/test_zimage_parallelism.py
-
-- label: "Diffusion GPU Worker Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - pytest -s -v tests/diffusion/test_diffusion_worker.py
-
-- label: "Omni Model Test Qwen2-5-Omni"
-  timeout_in_minutes: 15
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/e2e/offline_inference/test_qwen2_5_omni_expansion.py
-    - pytest -s -v tests/engine/test_async_omni_engine_abort.py
-
-- label: "Omni Model Test Qwen3-Omni"
-  timeout_in_minutes: 15
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - export VLLM_ROCM_USE_AITER=0
-    - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py
-    - pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py
-
-
-- label: "Omni Sleep Mode Test"
-  timeout_in_minutes: 40
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export VLLM_LOGGING_LEVEL=DEBUG
-    - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-    - pytest -s -v tests/entrypoints/test_omni_sleep_mode.py -m "advanced_model and omni and MI325" --run-level "advanced_model"
diff --git a/.buildkite/test-merge.yml b/.buildkite/test-merge.yml
deleted file mode 100644
index 51c4223f2..000000000
--- a/.buildkite/test-merge.yml
+++ /dev/null
@@ -1,645 +0,0 @@
-env:
-  VLLM_WORKER_MULTIPROC_METHOD: spawn
-  VLLM_USE_FLASHINFER_MOE_FP16: 0
-  HF_HUB_DOWNLOAD_TIMEOUT: 300
-  HF_HUB_ETAG_TIMEOUT: 60
-
-steps:
-  - group: ":card_index_dividers: Simple Test"
-    depends_on: upload-merge-pipeline
-    steps:
-      - label: "Simple · Diffusion & Model Executor Test"
-        commands:
-          - "timeout 20m pytest -sv tests/diffusion tests/model_executor -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Simple · Other Test"
-        commands:
-          - "timeout 20m pytest -sv -m 'core_model and cpu' --ignore=tests/diffusion --ignore=tests/model_executor --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - group: ":card_index_dividers: Diffusion Test"
-    depends_on: upload-merge-pipeline
-    steps:
-      - label: "Diffusion · LoRA Test"
-        timeout_in_minutes: 30
-        commands:
-          - pytest -sv tests/diffusion/lora/ -m 'advanced_model and cuda' --run-level "advanced_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Distributed Test"
-    depends_on: upload-merge-pipeline
-    timeout_in_minutes: 60
-    commands:
-      - |
-        timeout 55m bash -c "
-          set -e
-          export VLLM_IMAGE_FETCH_TIMEOUT=60
-          pytest -s -v tests/distributed -m 'advanced_model and cuda and H100' --run-level 'advanced_model'
-        "
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                resources:
-                  limits:
-                    nvidia.com/gpu: 1
-                volumeMounts:
-                  - name: devshm
-                    mountPath: /dev/shm
-                  - name: hf-cache
-                    mountPath: /root/.cache/huggingface
-                env:
-                  - name: HF_HOME
-                    value: /root/.cache/huggingface
-                  - name: HF_TOKEN
-                    valueFrom:
-                      secretKeyRef:
-                        name: hf-token-secret
-                        key: token
-            nodeSelector:
-              node.kubernetes.io/instance-type: gpu-h100-sxm
-            volumes:
-              - name: devshm
-                emptyDir:
-                  medium: Memory
-              - name: hf-cache
-                hostPath:
-                  path: /mnt/hf-cache
-                  type: DirectoryOrCreate
-
-  - group: ":card_index_dividers: Entrypoints Test"
-    depends_on: upload-merge-pipeline
-    steps:
-      - label: "Entrypoint Test with H100"
-        timeout_in_minutes: 60
-        commands:
-          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and H100" --run-level "advanced_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Entrypoint Test with L4"
-        timeout_in_minutes: 30
-        commands:
-          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and L4" --run-level "advanced_model"
-        agents:
-          queue: "gpu_4_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - group: ":card_index_dividers: E2E Test"
-    depends_on: upload-merge-pipeline
-    steps:
-      - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - tests/e2e/offline_inference/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py tests/e2e/offline_inference/test_qwen3_tts_customvoice.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · Qwen3-TTS Base Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_base.py
-          - tests/e2e/offline_inference/test_qwen3_tts_base.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_base.py tests/e2e/offline_inference/test_qwen3_tts_base.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · Higgs-Audio-V3 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_higgs_audio_v3.py
-          - vllm_omni/model_executor/models/higgs_audio_v3/
-          - vllm_omni/model_executor/stage_input_processors/higgs_audio_v3.py
-          - vllm_omni/deploy/higgs_multimodal_qwen3.yaml
-        commands:
-          - |
-            timeout 20m bash -c "
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              export VLLM_USE_DEEP_GEMM=0
-              export VLLM_MOE_USE_DEEP_GEMM=0
-              pytest -s -v tests/e2e/online_serving/test_higgs_audio_v3.py -m 'advanced_model' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · IndexTTS2 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_indextts2.py
-          - tests/e2e/offline_inference/test_indextts2.py
-          - tests/model_executor/models/indextts2/
-          - tests/model_executor/stage_input_processors/test_indextts2.py
-          - tests/assets/indextts2/
-          - vllm_omni/model_executor/models/indextts2/
-          - vllm_omni/model_executor/stage_input_processors/indextts2.py
-          - vllm_omni/deploy/indextts2.yaml
-          - vllm_omni/deploy/indextts2_low_latency.yaml
-          - vllm_omni/entrypoints/openai/serving_speech.py
-          - vllm_omni/entrypoints/openai/tts_adapters/indextts2.py
-          - vllm_omni/config/pipeline_registry.py
-          - vllm_omni/model_executor/models/registry.py
-        timeout_in_minutes: 60
-        commands:
-          - |
-            timeout 45m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              pytest -s -v tests/e2e/online_serving/test_indextts2.py tests/e2e/offline_inference/test_indextts2.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_4_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              gpus: all
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Omni · Qwen3-Omni Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_qwen3_omni.py
-          - tests/e2e/online_serving/test_qwen3_omni.py
-          - vllm_omni/model_executor/models/qwen3_omni/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
-          - vllm_omni/deploy/qwen3_omni_moe.yaml
-        timeout_in_minutes: 50
-        commands:
-          - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "TTS · VoxCPM2 Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_voxcpm2_tts.py
-          - tests/e2e/online_serving/test_voxcpm2_tts.py
-          - vllm_omni/model_executor/models/voxcpm2/
-          - vllm_omni/deploy/voxcpm2.yaml
-        timeout_in_minutes: 30
-        commands:
-          - |
-            timeout 30m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              pytest -s -v tests/e2e/offline_inference/test_voxcpm2_tts.py tests/e2e/online_serving/test_voxcpm2_tts.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · SoulX-Singer Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_soulxsinger.py
-          - vllm_omni/diffusion/models/soulx_singer/
-          - vllm_omni/deploy/soulxsinger_svc.yaml
-          - vllm_omni/deploy/soulxsinger_svs.yaml
-        timeout_in_minutes: 30
-        commands:
-          - |
-            timeout 30m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              pytest -s -v tests/e2e/offline_inference/test_soulxsinger.py -k 'svc or precomputed' -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Qwen Image Edit Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image_edit.py
-          - vllm_omni/diffusion/models/qwen_image/
-        timeout_in_minutes: 20
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen_image_edit.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Bagel Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_bagel.py
-          - tests/e2e/online_serving/test_bagel.py
-          - vllm_omni/model_executor/models/bagel/
-          - vllm_omni/diffusion/models/bagel/
-          - vllm_omni/model_executor/stage_input_processors/bagel.py
-          - vllm_omni/deploy/bagel.yaml
-        timeout_in_minutes: 20
-        commands:
-          - pytest -s -v tests/e2e/offline_inference/test_bagel.py tests/e2e/online_serving/test_bagel.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-
-      - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - |
-            timeout 40m bash -c '
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            '
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Qwen Image Layered Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image_layered.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_qwen_image_layered.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Wan22 Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_wan22_t2v.py
-          - tests/e2e/online_serving/test_wan22_t2v.py
-          - vllm_omni/diffusion/models/wan2_2/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/offline_inference/test_wan22_t2v.py tests/e2e/online_serving/test_wan22_t2v.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Z Image Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_z_image.py
-          - tests/e2e/online_serving/test_z_image.py
-          - vllm_omni/diffusion/models/z_image/
-        timeout_in_minutes: 30
-        commands:
-          - pytest -s -v tests/e2e/offline_inference/test_z_image.py tests/e2e/online_serving/test_z_image.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · FLUX.2 Klein Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_flux2_klein.py
-          - vllm_omni/diffusion/models/flux2_klein/
-        timeout_in_minutes: 30
-        commands:
-          - pytest -s -v tests/e2e/offline_inference/test_flux2_klein.py -m 'advanced_model and cuda and diffusion' --run-level 'advanced_model'
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
diff --git a/.buildkite/test-nightly.yml b/.buildkite/test-nightly.yml
deleted file mode 100644
index 783d0ab1f..000000000
--- a/.buildkite/test-nightly.yml
+++ /dev/null
@@ -1,1673 +0,0 @@
-env:
-  VLLM_WORKER_MULTIPROC_METHOD: spawn
-  VLLM_USE_FLASHINFER_MOE_FP16: 0
-  HF_HUB_DOWNLOAD_TIMEOUT: 300
-  HF_HUB_ETAG_TIMEOUT: 60
-
-steps:
-  # Group: collapses under one heading in the Buildkite UI; child steps still run in parallel.
-  - group: ":card_index_dividers: Omni Model Test"
-    key: nightly-omni-test-group
-    depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "omni-test"
-    steps:
-      - label: ":full_moon: Omni · Function Test with H100"
-        timeout_in_minutes: 120
-        commands:
-          - pytest -sv tests/e2e --run-level "full_model" -m "full_model and H100 and omni" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Doc Test with L4"
-        timeout_in_minutes: 90
-        commands:
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - pytest -s -v tests/examples/ -m "full_model and omni and L4" --run-level "full_model"
-        agents:
-          queue: "gpu_4_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: ":full_moon: Omni · Doc Test with H100"
-        timeout_in_minutes: 90
-        commands:
-          - pytest -s -v tests/examples/ -m "full_model and omni and H100" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - export SEED_TTS_WER_EVAL=1
-          - export SEED_TTS_EVAL_DEVICE=cuda:1
-          - |
-            set +e
-            pytest -s -v tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py -m "full_model" --run-level full_model
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Perf Test · No Async Chunk"
-        key: nightly-omni-performance-no-async-chunk
-        timeout_in_minutes: 300
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Perf Test · Async Chunk"
-        key: nightly-omni-performance-async-chunk
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Perf Test · vLLM Text"
-        key: nightly-omni-performance-vllm-text
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Omni · Perf Test · Multi-Replica"
-        key: nightly-omni-performance-multi-replicas
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 3
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-
-      - label: ":full_moon: Omni · Multi-Replica Startup Test with 4x H100"
-        timeout_in_minutes: 45
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py -m "full_model" --run-level "core_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 4
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-  - group: ":card_index_dividers: TTS Model Test"
-    key: nightly-tts-test-group
-    depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "tts-test"
-    steps:
-      - label: ":full_moon: TTS · Function Test with L4"
-        timeout_in_minutes: 120
-        commands:
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - export VLLM_USE_DEEP_GEMM="0"
-          - export VLLM_MOE_USE_DEEP_GEMM="0"
-          - pytest -s -v tests/e2e/ -m "full_model and L4 and tts" --run-level "full_model" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_voxcpm2_tts_expansion.py
-        agents:
-          queue: "gpu_1_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      # - label: ":full_moon: TTS · Function Test with H100"
-      #   timeout_in_minutes: 90
-      #   commands:
-      #     - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-      #     - pytest -s -v tests/e2e/ -m "full_model and H100 and tts" --run-level "full_model" --ignore=tests/e2e/accuracy
-      #   agents:
-      #     queue: "mithril-h100-pool"
-      #   plugins:
-      #     - kubernetes:
-      #         podSpec:
-      #           containers:
-      #             - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-      #               resources:
-      #                 limits:
-      #                   nvidia.com/gpu: 1
-      #               volumeMounts:
-      #                 - name: devshm
-      #                   mountPath: /dev/shm
-      #                 - name: hf-cache
-      #                   mountPath: /root/.cache/huggingface
-      #               env:
-      #                 - name: HF_HOME
-      #                   value: /root/.cache/huggingface
-      #                 - name: HF_TOKEN
-      #                   valueFrom:
-      #                     secretKeyRef:
-      #                       name: hf-token-secret
-      #                       key: token
-      #           nodeSelector:
-      #             node.kubernetes.io/instance-type: gpu-h100-sxm
-      #           volumes:
-      #             - name: devshm
-      #               emptyDir:
-      #                 medium: Memory
-      #             - name: hf-cache
-      #               hostPath:
-      #                 path: /mnt/hf-cache
-      #                 type: DirectoryOrCreate
-
-      - label: ":full_moon: TTS · Accuracy Test · VoxCPM2"
-        timeout_in_minutes: 30
-        commands:
-          - |
-            timeout 30m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-              pytest -s -v tests/e2e/online_serving/test_voxcpm2_tts_expansion.py -m 'full_model and cuda and tts' --run-level 'full_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: ":full_moon: TTS · Perf Test"
-        key: nightly-tts-performance
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: TTS · VoxCPM2 · Perf Test"
-        key: nightly-tts-performance-voxcpm2
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_voxcpm2.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: TTS · Higgs-Audio-V3 · Perf Test"
-        key: nightly-tts-performance-higgs-audio-v3
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - export VLLM_USE_DEEP_GEMM="0"
-          - export VLLM_MOE_USE_DEEP_GEMM="0"
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_higgs_audio_v3.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-  - group: ":card_index_dividers: Tiny Model Tests [Multi-GPU]"
-    key: nightly-tiny-model-test-group
-    depends_on: upload-nightly-pipeline
-    if: >-
-      build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test"
-    steps:
-      - label: ":full_moon: Tiny Model Tests · Diffusion (Multi-GPU accelerations)"
-        timeout_in_minutes: 30
-        # NOTE: Single-GPU (core_model) tiny model tests run on the ready label,
-        # so nightly only adds the multi-GPU parallelism configurations.
-        #
-        # This is a bit confusing, but `full_model` is used to mark the multigpu tests, and
-        # --run-level `core_model` is used to indicate that we should use tiny model weights
-        # for the CI, since these tests should pass irrespective of whether or not we use
-        # the full weights or not.
-        commands:
-          - timeout 25m pytest -sv tests/model_tests/diffusion -m 'full_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_4_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  # Diffusion X2I suite: x2i / x2a / x2t and related non-video paths; x2v is only in "Diffusion X2V Model Test" below.
-  - group: ":card_index_dividers: Diffusion X2I(&A&T) Model Test"
-    key: nightly-diffusion-x2iat-group
-    depends_on: upload-nightly-pipeline
-    if: >-
-      build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2iat-test"
-    steps:
-      # Use explicit file shards so single-card cases do not reserve 2+ GPUs,
-      # and Bagel feature coverage is not duplicated via a broad tests/e2e sweep.
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Single-GPU"
-        timeout_in_minutes: 120
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_qwen_image_expansion.py
-            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
-            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
-            tests/e2e/online_serving/test_bagel_expansion.py
-            tests/e2e/online_serving/test_krea2_expansion.py
-            tests/e2e/offline_inference/test_krea2_expansion.py
-            -m "full_model and diffusion and H100 and not distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Qwen-Image"
-        timeout_in_minutes: 120
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_qwen_image_expansion.py
-            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
-            tests/e2e/offline_inference/test_krea2_expansion.py
-            -m "full_model and diffusion and H100 and distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Layered/LongCat/FLUX"
-        timeout_in_minutes: 90
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
-            -m "full_model and diffusion and H100 and distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Multi-GPU Bagel"
-        timeout_in_minutes: 120
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_bagel_expansion.py
-            -m "full_model and diffusion and H100 and distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · GLM-Image Function Test with H100"
-        timeout_in_minutes: 120
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_glm_image_expansion.py
-            tests/e2e/offline_inference/test_glm_image_autoround_w4a16_expansion.py
-            -m "full_model and diffusion and H100"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with L4"
-        timeout_in_minutes: 120
-        commands:
-          - pytest -sv tests/e2e/ -k "not test_wan and not test_bagel_expansion and not hunyuan" -m "full_model and diffusion and L4" --run-level "full_model" --ignore=tests/e2e/accuracy
-        agents:
-          queue: "gpu_4_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Doc Test"
-        timeout_in_minutes: 60
-        commands:
-          - pytest -s -v tests/examples/*/test_text_to_image.py -m "full_model and example and H100" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - pytest -s -v tests/e2e/accuracy/test_qwen_image*.py --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2i_matches_diffusers' -m full_model --run-level full_model
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: VLLM_HTTP_TIMEOUT_KEEP_ALIVE
-                        value: "120"
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: HunyuanImage3-DIT · Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - export HUNYUAN_IMAGE3_MODEL="tencent/HunyuanImage-3.0-Instruct"
-          - export HUNYUAN_IMAGE3_DEVICES="0,1,2,3"
-          - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m full_model --run-level full_model
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 4
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image"
-        key: nightly-diffusion-x2iat-performance-qwen-image
-        timeout_in_minutes: 180
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - export CACHE_DIT_VERSION=1.3.0
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 4
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Edit"
-        key: nightly-diffusion-x2iat-performance-qwen-image-edit
-        timeout_in_minutes: 180
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - export CACHE_DIT_VERSION=1.3.0
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 4
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Edit-2511"
-        key: nightly-diffusion-x2iat-performance-qwen-image-edit-2511
-        timeout_in_minutes: 180
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - export CACHE_DIT_VERSION=1.3.0
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 4
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image-Layered"
-        key: nightly-diffusion-x2iat-performance-qwen-image-layered
-        timeout_in_minutes: 120
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - export CACHE_DIT_VERSION=1.3.0
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · BAGEL"
-        key: nightly-diffusion-x2iat-performance-bagel
-        timeout_in_minutes: 180
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - export CACHE_DIT_VERSION=1.3.0
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_bagel_vllm_omni.json
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            exit $$EXIT
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-  # Diffusion x2v only (Wan, HunyuanVideo, …). x2i/x2a/x2t live in the X2I group above, not here.
-  - group: ":card_index_dividers: Diffusion X2V Model Test"
-    key: nightly-diffusion-x2v-group
-    depends_on: upload-nightly-pipeline
-    if: >-
-      build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2v-test"
-    steps:
-      - label: ":full_moon: Diffusion X2V · Wan2.2 T2V Function Test"
-        timeout_in_minutes: 90
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Wan2.2 I2V/TI2V Function Test"
-        timeout_in_minutes: 90
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Doc Test"
-        timeout_in_minutes: 60
-        commands:
-          - pytest -s -v tests/examples/offline_inference/test_image_to_video.py -m "full_model and example and H100" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Other Function Test"
-        timeout_in_minutes: 90
-        commands:
-          - pytest -s -v tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py -m "full_model and cuda" --run-level "full_model"
-          - pytest -s -v tests/e2e/online_serving/test_wan_2_1_vace_expansion.py tests/e2e/online_serving/test_ltx2_expansion.py -m "full_model and cuda" --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Wan2.2 Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - pytest -s -v tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2v_matches_diffusers' -m full_model --run-level full_model
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Other Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_ltx2_3_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_video_streaming_output_similarity.py -m full_model --run-level full_model
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Diffusion X2V · Perf Test"
-        key: nightly-diffusion-x2v-performance
-        timeout_in_minutes: 180
-        commands:
-          - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
-            EXIT1=$$?
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
-            EXIT2=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
-            buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
-            if [ $$EXIT1 -ne 0 ]; then exit $$EXIT1; fi
-            exit $$EXIT2
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-  - group: ":card_index_dividers: Diffusion · Quantization Test"
-    depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "diffusion-x2iat-test"
-    steps:
-      - label: ":full_moon: Quantization Test with H100"
-        commands:
-          - timeout 60m pytest -sv tests/diffusion/quantization -m 'full_model and cuda and H100' --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: ":full_moon: Quantization Test with L4"
-        timeout_in_minutes: 60
-        commands:
-          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and L4' --run-level "full_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: ":bar_chart: Testcase Statistics"
-    key: nightly-testcase-statistics
-    timeout_in_minutes: 120
-    depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1"
-    commands:
-      - python tools/nightly/buildkite_testcase_statistics.py -o tests/dfx/perf/results/buildkite_testcase_statistics.html
-      - buildkite-agent artifact upload "tests/dfx/perf/results/*.html"
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                resources:
-                  limits:
-                    nvidia.com/gpu: 1
-                volumeMounts:
-                  - name: devshm
-                    mountPath: /dev/shm
-                  - name: hf-cache
-                    mountPath: /root/.cache/huggingface
-                env:
-                  - name: HF_HOME
-                    value: /root/.cache/huggingface
-                  - name: HF_TOKEN
-                    valueFrom:
-                      secretKeyRef:
-                        name: hf-token-secret
-                        key: token
-            nodeSelector:
-              node.kubernetes.io/instance-type: gpu-h100-sxm
-            volumes:
-              - name: devshm
-                emptyDir:
-                  medium: Memory
-              - name: hf-cache
-                hostPath:
-                  path: /mnt/hf-cache
-                  type: DirectoryOrCreate
-
-  # No need to run this step for PRs with label nightly-test
-  - label: ":email: Nightly Collection & Email"
-    key: nightly-perf-distribution
-    depends_on:
-      - nightly-omni-performance-no-async-chunk
-      - nightly-omni-performance-async-chunk
-      - nightly-omni-performance-vllm-text
-      - nightly-omni-performance-multi-replicas
-      - nightly-tts-performance
-      - nightly-tts-performance-higgs-audio-v3
-      - nightly-diffusion-x2iat-performance-qwen-image
-      - nightly-diffusion-x2iat-performance-qwen-image-edit
-      - nightly-diffusion-x2iat-performance-qwen-image-edit-2511
-      - nightly-diffusion-x2iat-performance-qwen-image-layered
-      - nightly-diffusion-x2iat-performance-bagel
-      - nightly-diffusion-x2v-performance
-      - nightly-testcase-statistics
-    if: build.env("NIGHTLY") == "1" && build.env("EMAIL_DISTRIBUTION") == "1"
-    commands:
-      - pip install openpyxl
-      - export DEFAULT_INPUT_DIR=tests/dfx/perf/results
-      - export DEFAULT_OUTPUT_DIR=tests/dfx/perf/results
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-tts-performance
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-tts-performance-higgs-audio-v3
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-no-async-chunk
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-async-chunk
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-vllm-text
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-omni-performance-multi-replicas
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-edit
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-edit-2511
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-qwen-image-layered
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2iat-performance-bagel
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.json" . --step nightly-diffusion-x2v-performance
-      - buildkite-agent artifact download "tests/dfx/perf/results/*.html" . --step nightly-testcase-statistics
-      - python tools/nightly/generate_nightly_perf_excel.py
-      - python tools/nightly/generate_nightly_perf_html.py
-      - python tools/nightly/send_nightly_email.py --report-file "tests/dfx/perf/results/*.xlsx, tests/dfx/perf/results/*.html"
-      - buildkite-agent artifact upload "tests/dfx/perf/results/*.xlsx"
-      - buildkite-agent artifact upload "tests/dfx/perf/results/*.html"
-    agents:
-      queue: "cpu_queue_premerge"
diff --git a/.buildkite/test-npu-nightly.yaml b/.buildkite/test-npu-nightly.yaml
deleted file mode 100644
index 2c2372f4c..000000000
--- a/.buildkite/test-npu-nightly.yaml
+++ /dev/null
@@ -1,24 +0,0 @@
-steps:
-  - group: ":card_index_dividers: Diffusion X2V Model Test"
-    key: nightly-diffusion-x2v-group
-    depends_on: upload-nightly-pipeline
-    if: >-
-      build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2v-test"
-    steps:
-      - label: ":full_moon: Diffusion X2V · Function Test"
-        agents:
-          queue: "ascend-a2b3"
-          resource_class: "npu-4"
-        image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}"
-        plugins:
-          - kubernetes:
-              podSpecPatch:
-                imagePullSecrets:
-                  - name: swr-secret
-        env:
-          VLLM_WORKER_MULTIPROC_METHOD: spawn
-          HF_TOKEN: "${HF_TOKEN}"
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k npu_i2v --run-level "full_model"
diff --git a/.buildkite/test-npu-ready.yaml b/.buildkite/test-npu-ready.yaml
deleted file mode 100644
index e1fe20d60..000000000
--- a/.buildkite/test-npu-ready.yaml
+++ /dev/null
@@ -1,21 +0,0 @@
-steps:
-  - group: ":card_index_dividers: TTS Model Test"
-    key: ready-tts-group
-    depends_on: upload-ready-pipeline
-    steps:
-      - label: ":sound: TTS · Qwen3-TTS CustomVoice Test"
-        agents:
-          queue: "ascend-a2b3"
-          resource_class: "npu-1"
-        image: "swr.cn-southwest-2.myhuaweicloud.com/modelfoundry/vllm-omni-ci-npu:${BUILDKITE_COMMIT}"
-        plugins:
-          - kubernetes:
-              podSpecPatch:
-                imagePullSecrets:
-                  - name: swr-secret
-        env:
-          VLLM_WORKER_MULTIPROC_METHOD: spawn
-          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
-          HF_TOKEN: "${HF_TOKEN}"
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py -m 'core_model' --run-level 'core_model'
diff --git a/.buildkite/test-ready.yml b/.buildkite/test-ready.yml
deleted file mode 100644
index c9b60fe2c..000000000
--- a/.buildkite/test-ready.yml
+++ /dev/null
@@ -1,707 +0,0 @@
-env:
-  VLLM_WORKER_MULTIPROC_METHOD: spawn
-  VLLM_USE_FLASHINFER_MOE_FP16: 0
-  HF_HUB_DOWNLOAD_TIMEOUT: 300
-  HF_HUB_ETAG_TIMEOUT: 60
-
-steps:
-  - group: ":card_index_dividers: Simple Test"
-    depends_on: upload-ready-pipeline
-    steps:
-      - label: "Simple · Diffusion & Model Executor Test"
-        commands:
-          - "timeout 20m pytest -sv tests/diffusion tests/model_executor -m 'core_model and cpu' --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Simple · Other Test"
-        commands:
-          - "timeout 20m pytest -sv -m 'core_model and cpu' --ignore=tests/diffusion --ignore=tests/model_executor --cov=vllm_omni --cov-report=term-missing:skip-covered --cov-report=xml"
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Custom Pipeline Test"
-    depends_on: upload-ready-pipeline
-    commands:
-      - timeout 20m pytest -s -v tests/e2e/offline_inference/custom_pipeline/ -m "core_model"
-    agents:
-      queue: "gpu_1_queue"
-    plugins:
-      - docker#v5.2.0:
-          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-          always-pull: true
-          propagate-environment: true
-          environment:
-            - "HF_HOME=/fsx/hf_cache"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - group: ":card_index_dividers: Diffusion Test"
-    depends_on: upload-ready-pipeline
-    steps:
-      - label: "Diffusion · Offloader Test"
-        commands:
-          - timeout 40m pytest -s -v tests/diffusion/offloader -m "core_model and cuda" --run-level "core_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Cache Test"
-        commands:
-          - timeout 15m pytest -sv tests/diffusion/cache -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Batch Test"
-        commands:
-          - timeout 15m pytest -sv tests/diffusion/batching -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Distributed Test"
-        commands:
-          - timeout 20m pytest -sv tests/diffusion/distributed -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_4_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Model Test"
-        commands:
-          - timeout 15m pytest -sv tests/diffusion/models/ -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Other Test"
-        commands:
-          - timeout 15m pytest -sv tests/diffusion/*.py -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-
-  - group: ":card_index_dividers: Tiny Model Tests [Single GPU]"
-    depends_on: upload-ready-pipeline
-    steps:
-      - label: "Tiny Model Tests · Diffusion (base)"
-        commands:
-          - timeout 15m pytest -sv tests/model_tests/diffusion -m 'core_model and cuda' --run-level "core_model"
-        agents:
-          # Ready label only runs the cases that don't need parallelism for tiny
-          # model tests, which is usually just a smoke test for TTI and I2I
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Engine&Model Executor Test"
-    depends_on: upload-ready-pipeline
-    commands:
-      - |
-        timeout 15m bash -c "
-                  pytest -sv tests/engine/ tests/model_executor/ -m 'core_model and cuda' --run-level 'core_model'
-        "
-    agents:
-      queue: "gpu_1_queue" # g6.12xlarge instance on AWS, has 4 L4 GPU
-    plugins:
-      - docker#v5.2.0:
-          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-          always-pull: true
-          propagate-environment: true
-          shm-size: "8gb"
-          environment:
-            - "HF_HOME=/fsx/hf_cache"
-            - "HF_TOKEN"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-
-  - label: "Distributed Test"
-    depends_on: upload-ready-pipeline
-    commands:
-      - |
-        timeout 20m bash -c "
-          pytest -sv tests/distributed/ -m 'core_model and cuda and L4' --run-level 'core_model'
-        "
-    agents:
-      queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-    plugins:
-      - docker#v5.2.0:
-          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-          always-pull: true
-          propagate-environment: true
-          shm-size: "8gb"
-          environment:
-            - "HF_HOME=/fsx/hf_cache"
-            - "HF_TOKEN"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Entrypoints Test"
-    depends_on: upload-ready-pipeline
-    commands:
-      - |
-        timeout 30m bash -c "
-          export VLLM_WORKER_MULTIPROC_METHOD=spawn
-          pytest -sv tests/entrypoints/ -m 'core_model and cuda' --run-level 'core_model'
-        "
-    agents:
-      queue: "gpu_1_queue"
-    plugins:
-      - docker#v5.2.0:
-          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-          always-pull: true
-          propagate-environment: true
-          shm-size: "8gb"
-          environment:
-            - "HF_HOME=/fsx/hf_cache"
-            - "HF_TOKEN"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - group: ":card_index_dividers: E2E Test"
-    depends_on: upload-ready-pipeline
-    steps:
-      - label: "RLHF · VeRL-Omni E2E Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/rlhf_test/test_verl_omni_e2e.py
-          - tests/e2e/offline_inference/custom_pipeline/
-          - vllm_omni/diffusion/
-          - vllm_omni/engine/
-          - vllm_omni/entrypoints/
-          - vllm_omni/inputs/
-          - vllm_omni/outputs/
-        commands:
-          - |
-            timeout 20m bash -c "
-              pytest -s -v tests/e2e/offline_inference/rlhf_test/test_verl_omni_e2e.py
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Omni · Qwen3-Omni Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_omni.py
-          - vllm_omni/model_executor/models/qwen3_omni/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
-          - vllm_omni/deploy/qwen3_omni_moe.yaml
-        commands:
-          - |
-            timeout 20m bash -c "
-              pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "TTS · VoxCPM2 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_voxcpm2_tts.py
-          - vllm_omni/model_executor/models/voxcpm2/
-          - vllm_omni/deploy/voxcpm2.yaml
-        timeout_in_minutes: 30
-        commands:
-          - |
-            timeout 30m bash -c "
-              export VLLM_LOGGING_LEVEL=DEBUG
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              pytest -s -v tests/e2e/online_serving/test_voxcpm2_tts.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-        commands:
-          - |
-            timeout 20m bash -c "
-              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · Qwen3-TTS Base Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_base.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-        commands:
-          - |
-            timeout 20m bash -c "
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-              export VLLM_OMNI_USE_V2_RUNNER=1
-              pytest -s -v tests/e2e/online_serving/test_qwen3_tts_base.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · Higgs-Audio-V3 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_higgs_audio_v3.py
-          - vllm_omni/model_executor/models/higgs_audio_v3/
-          - vllm_omni/model_executor/stage_input_processors/higgs_audio_v3.py
-          - vllm_omni/deploy/higgs_multimodal_qwen3.yaml
-        commands:
-          - |
-            timeout 20m bash -c "
-              export VLLM_WORKER_MULTIPROC_METHOD=spawn
-              export VLLM_USE_DEEP_GEMM=0
-              export VLLM_MOE_USE_DEEP_GEMM=0
-              pytest -s -v tests/e2e/online_serving/test_higgs_audio_v3.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · Qwen Image Edit Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image_edit.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - |
-            timeout 20m bash -c "
-              pytest -s -v tests/e2e/online_serving/test_qwen_image_edit.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Bagel Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_bagel.py
-          - vllm_omni/model_executor/models/bagel/
-          - vllm_omni/diffusion/models/bagel/
-          - vllm_omni/model_executor/stage_input_processors/bagel.py
-          - vllm_omni/deploy/bagel.yaml
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_bagel.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Wan22 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_wan22_t2v.py
-          - vllm_omni/diffusion/models/wan2_2/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_wan22_t2v.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Cosmos3 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_cosmos3.py
-          - vllm_omni/diffusion/models/cosmos3/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_cosmos3.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-
-      - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · Qwen Image Layered Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image_layered.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - |
-            timeout 40m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_qwen_image_layered.py -m 'core_model' --run-level 'core_model'
-            "
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · GGUF Plugin Test"
-        soft_fail: true
-        source_file_dependencies:
-          - tests/plugin/test_gguf_diffusion.py
-          - vllm_omni/diffusion/model_loader
-        commands:
-          - pip install "vllm-gguf-plugin>=0.0.3"
-          - timeout 30m pytest -sv tests/plugin/test_gguf_diffusion.py
-        agents:
-          queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
diff --git a/.buildkite/test-weekly.yml b/.buildkite/test-weekly.yml
deleted file mode 100644
index d71bdae0a..000000000
--- a/.buildkite/test-weekly.yml
+++ /dev/null
@@ -1,451 +0,0 @@
-env:
-  VLLM_WORKER_MULTIPROC_METHOD: spawn
-  VLLM_USE_FLASHINFER_MOE_FP16: 0
-  HF_HUB_DOWNLOAD_TIMEOUT: 300
-  HF_HUB_ETAG_TIMEOUT: 60
-
-steps:
-  - label: "Reliability Test - qwen3-omni"
-    timeout_in_minutes: 180
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    commands:
-      - pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m "slow"
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                resources:
-                  limits:
-                    nvidia.com/gpu: 2
-                volumeMounts:
-                  - name: devshm
-                    mountPath: /dev/shm
-                  - name: hf-cache
-                    mountPath: /root/.cache/huggingface
-                env:
-                  - name: HF_HOME
-                    value: /root/.cache/huggingface
-                  - name: HF_TOKEN
-                    valueFrom:
-                      secretKeyRef:
-                        name: hf-token-secret
-                        key: token
-            nodeSelector:
-              node.kubernetes.io/instance-type: gpu-h100-sxm
-            volumes:
-              - name: devshm
-                emptyDir:
-                  medium: Memory
-              - name: hf-cache
-                hostPath:
-                  path: /mnt/hf-cache
-                  type: DirectoryOrCreate
-
-  - label: "Reliability Test - wan22"
-    timeout_in_minutes: 180
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    commands:
-      - pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m "slow"
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                resources:
-                  limits:
-                    nvidia.com/gpu: 2
-                volumeMounts:
-                  - name: devshm
-                    mountPath: /dev/shm
-                  - name: hf-cache
-                    mountPath: /root/.cache/huggingface
-                env:
-                  - name: HF_HOME
-                    value: /root/.cache/huggingface
-                  - name: HF_TOKEN
-                    valueFrom:
-                      secretKeyRef:
-                        name: hf-token-secret
-                        key: token
-            nodeSelector:
-              node.kubernetes.io/instance-type: gpu-h100-sxm
-            volumes:
-              - name: devshm
-                emptyDir:
-                  medium: Memory
-              - name: hf-cache
-                hostPath:
-                  path: /mnt/hf-cache
-                  type: DirectoryOrCreate
-
-  - label: "Reliability Test - hunyuan-image"
-    timeout_in_minutes: 180
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    commands:
-      - pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m "slow"
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                resources:
-                  limits:
-                    nvidia.com/gpu: 4
-                volumeMounts:
-                  - name: devshm
-                    mountPath: /dev/shm
-                  - name: hf-cache
-                    mountPath: /root/.cache/huggingface
-                env:
-                  - name: HF_HOME
-                    value: /root/.cache/huggingface
-                  - name: HF_TOKEN
-                    valueFrom:
-                      secretKeyRef:
-                        name: hf-token-secret
-                        key: token
-            nodeSelector:
-              node.kubernetes.io/instance-type: gpu-h100-sxm
-            volumes:
-              - name: devshm
-                emptyDir:
-                  medium: Memory
-              - name: hf-cache
-                hostPath:
-                  path: /mnt/hf-cache
-                  type: DirectoryOrCreate
-
-  - label: "Reliability Test - voxcpm2"
-    timeout_in_minutes: 180
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    commands:
-      - pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m "slow"
-    agents:
-      queue: "gpu_1_queue"
-    plugins:
-      - docker#v5.2.0:
-          image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-          always-pull: true
-          propagate-environment: true
-          shm-size: "8gb"
-          environment:
-            - "HF_HOME=/fsx/hf_cache"
-            - "HF_TOKEN"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  # Invalid HTTP / WS payloads vs live Omni servers (Issue #3649 tracks known skips).
-  - group: "Reliability Test - Invalid parameters Test"
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    steps:
-      - label: "Invalid parameters Test · H100"
-        timeout_in_minutes: 120
-        commands:
-          - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and H100"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      # Stable Audio Open, Qwen3-TTS speech/batch/voices paths marked ``L4``.
-      - label: "Invalid parameters Test · L4"
-        timeout_in_minutes: 120
-        commands:
-          - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and L4"
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - group: ":card_index_dividers: E2E Tests"
-    depends_on: upload-weekly-pipeline
-    if: build.env("WEEKLY") == "1" || build.pull_request.labels includes "weekly-test"
-    steps:
-      - label: "Omni · L4"
-        timeout_in_minutes: 90
-        commands:
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - pytest -s -v tests/e2e/*/test_qwen2_5_omni_expansion.py --run-level "core_model"
-          - >-
-            pytest -s -v tests/e2e/
-            --ignore=tests/e2e/online_serving/test_qwen2_5_omni_expansion.py
-            --ignore=tests/e2e/offline_inference/test_qwen2_5_omni_expansion.py
-            -m "slow and L4 and omni"
-            --run-level "full_model"
-        agents:
-          queue: "gpu_4_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Omni · H100"
-        timeout_in_minutes: 90
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/ -m "slow and H100 and omni"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "TTS · L4"
-        timeout_in_minutes: 90
-        commands:
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - export VLLM_USE_DEEP_GEMM="0"
-          - export VLLM_MOE_USE_DEEP_GEMM="0"
-          - |
-            failed=0
-            for f in $(pytest --collect-only -q tests/e2e/ -m "slow and L4 and tts" --run-level "full_model" | grep '\.py::' | sed -E 's|::.*||' | sort -u); do
-              pytest -s -v "$$f" -m "slow and L4 and tts" --run-level "full_model" || failed=1
-            done
-            exit $$failed
-        agents:
-          queue: "gpu_1_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "TTS · H100"
-        timeout_in_minutes: 90
-        commands:
-          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - export VLLM_USE_DEEP_GEMM="0"
-          - export VLLM_MOE_USE_DEEP_GEMM="0"
-          - >-
-            pytest -sv
-            tests/e2e/ -m "slow and H100 and tts"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · L4"
-        timeout_in_minutes: 60
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/ -m "slow and diffusion and L4"
-            --run-level "full_model"
-        agents:
-          queue: "gpu_4_queue"
-        plugins:
-          - docker#v5.2.0:
-              image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-              always-pull: true
-              propagate-environment: true
-              shm-size: "8gb"
-              environment:
-                - "HF_HOME=/fsx/hf_cache"
-                - "HF_TOKEN"
-              volumes:
-                - "/fsx/hf_cache:/fsx/hf_cache"
-
-      - label: "Diffusion · H100 · Single-GPU"
-        timeout_in_minutes: 120
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/ -m "slow and diffusion and H100 and not distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 1
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
-
-      - label: "Diffusion · H100 · Multi-GPU"
-        timeout_in_minutes: 90
-        commands:
-          - >-
-            pytest -sv
-            tests/e2e/ -m "slow and diffusion and H100 and distributed_cuda"
-            --run-level "full_model"
-        agents:
-          queue: "mithril-h100-pool"
-        plugins:
-          - kubernetes:
-              podSpec:
-                containers:
-                  - image: 936637512419.dkr.ecr.us-west-2.amazonaws.com/vllm-ci-pull-through-cache/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
-                    resources:
-                      limits:
-                        nvidia.com/gpu: 2
-                    volumeMounts:
-                      - name: devshm
-                        mountPath: /dev/shm
-                      - name: hf-cache
-                        mountPath: /root/.cache/huggingface
-                    env:
-                      - name: HF_HOME
-                        value: /root/.cache/huggingface
-                      - name: HF_TOKEN
-                        valueFrom:
-                          secretKeyRef:
-                            name: hf-token-secret
-                            key: token
-                nodeSelector:
-                  node.kubernetes.io/instance-type: gpu-h100-sxm
-                volumes:
-                  - name: devshm
-                    emptyDir:
-                      medium: Memory
-                  - name: hf-cache
-                    hostPath:
-                      path: /mnt/hf-cache
-                      type: DirectoryOrCreate
diff --git a/.claude/skills/add-diffusion-model/SKILL.md b/.claude/skills/add-diffusion-model/SKILL.md
index 906f3c485..bae8cd1b5 100644
--- a/.claude/skills/add-diffusion-model/SKILL.md
+++ b/.claude/skills/add-diffusion-model/SKILL.md
@@ -309,7 +309,7 @@ For Omni or custom models, create:
 
 Required updates:
 1. `docs/user_guide/diffusion/parallelism/overview.md` — parallelism support overview/table
-2. `docs/user_guide/diffusion/cpu_offload_diffusion.md` — if CPU offload supported (add to supported models table)
+2. `docs/user_guide/diffusion/cpu_offload.md` — if CPU offload supported (add to supported models table)
 3. `docs/user_guide/diffusion/cache_acceleration/teacache.md` — if TeaCache supported
 4. `docs/user_guide/diffusion/cache_acceleration/cache_dit.md` — if Cache-DiT supported
 5. Offline example docs under `examples/offline_inference/<name>/` (`README.md` or category-specific `.md`)
@@ -317,7 +317,7 @@ Required updates:
 
 ### Step 8: Add E2E Tests
 
-**Follow the [vllm-omni-test skill](../vllm-omni-test/SKILL.md)** for markers, file naming, Buildkite wiring, and run commands. Also read [l4_functionality_tests.inc.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md) and [CI_5levels.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/CI_5levels.md).
+**Follow the [vllm-omni-test skill](../vllm-omni-test/SKILL.md)** for markers, file naming, Buildkite wiring, and run commands. Also read [l4_functionality_tests.inc.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md), [test_system_overview.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_system_overview.md), and [test_writing_guide.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_writing_guide.md).
 
 Classify the model's **CI priority** first:
 
@@ -334,7 +334,7 @@ Classify the model's **CI priority** first:
 | **L1** | `tests/diffusion/models/{slug}/`, `tests/diffusion/cache/`, transformer unit tests | `core_model` + `cpu` | `test-ready.yml` | Weight remap, `_sp_plan`, cache enabler registration, shape contracts |
 | **L2** | `tests/e2e/online_serving/test_{slug}.py` (and offline if the category is offline-first) | **`core_model` + `advanced_model`** (both on baseline smoke) + `diffusion` + `@hardware_test` / `hardware_marks` | `test-ready.yml` | Default deploy smoke — minimal `num_inference_steps`, single prompt |
 | **L3** | `tests/e2e/online_serving/test_{slug}.py` **and** `tests/e2e/offline_inference/test_{slug}.py` when offline matters | Baseline smoke: **`core_model` + `advanced_model`**; heavier cases: `advanced_model` only (+ `diffusion`) | `test-merge.yml` **or** merged into nightly diffusion function job | Real weights, streaming/API paths, LoRA/offload smoke |
-| **L4** | `tests/e2e/online_serving/test_{slug}_expansion.py` (+ offline expansion if needed) | `full_model` + `diffusion` | `test-nightly.yml` (X2I / X2V / X2A function groups) | Feature combos per [#1832](https://github.com/vllm-project/vllm-omni/issues/1832); perf → `tests/dfx/perf/tests/test_{model}_vllm_omni.json` |
+| **L4** | `tests/e2e/online_serving/test_{slug}_expansion.py` (+ offline expansion if needed) | `full_model` + `diffusion` | `test-nightly.yml` (X2I / X2V / X2A function groups) | Feature combos per [#1832](https://github.com/vllm-project/vllm-omni/issues/1832); perf → `tests/dfx/perf/tests/test_{model}_vllm_omni.json` with per-case **`mark`** (`hardware_marks` + `full_model` + `diffusion`) |
 
 **L2 & L3 online — same file, dual marks on the baseline smoke:** The **first / simplest** case in `test_{slug}.py` (default deploy, minimal steps, single prompt) should carry **both** `@pytest.mark.core_model` and `@pytest.mark.advanced_model` on the **same** function so L2 (`test-ready.yml`) and L3 (`test-merge.yml`) share one smoke test. Heavier deploy variants or API paths in the same file use **`advanced_model` only**. When L3 moves to nightly, migrate those heavier cases into `test_{slug}_expansion.py` with `full_model` and remove the dedicated `test-merge.yml` job (see `test_longcat_image_expansion.py`, `test_qwen_image_expansion.py`).
 
@@ -418,7 +418,8 @@ def enable_cache_for_your_model(pipeline, cache_config):
 
 #### 9d. Register the custom enabler
 
-Add your enabler to `CUSTOM_DIT_ENABLERS` in `vllm_omni/diffusion/cache/cache_dit_backend.py`:
+Add your enabler to `CUSTOM_DIT_ENABLERS` in
+`vllm_omni/diffusion/cache/cachedit/model_specific.py`:
 
 ```python
 CUSTOM_DIT_ENABLERS = {
diff --git a/.claude/skills/add-diffusion-model/references/cache-dit-patterns.md b/.claude/skills/add-diffusion-model/references/cache-dit-patterns.md
index d34ce0e0f..2385a70ee 100644
--- a/.claude/skills/add-diffusion-model/references/cache-dit-patterns.md
+++ b/.claude/skills/add-diffusion-model/references/cache-dit-patterns.md
@@ -29,8 +29,13 @@ vLLM-Omni integrates cache-dit through `CacheDiTBackend`:
 | `cache_dit.refresh_context()` | Updates cache context when `num_inference_steps` changes |
 
 **Source files**:
-- `vllm_omni/diffusion/cache/cache_dit_backend.py` — `CacheDiTBackend`, enablers, `CUSTOM_DIT_ENABLERS`
-- `vllm_omni/diffusion/cache/` — cache backend implementations
+- `vllm_omni/diffusion/cache/cachedit/__init__.py` — public package API
+- `vllm_omni/diffusion/cache/cachedit/backend.py` — generic backend lifecycle and integration
+- `vllm_omni/diffusion/cache/cachedit/config.py` — Cache-DiT configuration types
+- `vllm_omni/diffusion/cache/cachedit/model_specific.py` — model-specific adapters, enablers, and registry
+
+Outside `vllm_omni/diffusion/cache`, import Cache-DiT symbols only from
+`vllm_omni.diffusion.cache.cachedit`.
 
 ## Standard Models: Automatic Support
 
@@ -175,7 +180,8 @@ Inspect your block's `forward()` return type and residual connection pattern to
 
 ## Registering Custom Enablers
 
-Add your enabler to `CUSTOM_DIT_ENABLERS` in `vllm_omni/diffusion/cache/cache_dit_backend.py`:
+Add your enabler to `CUSTOM_DIT_ENABLERS` in
+`vllm_omni/diffusion/cache/cachedit/model_specific.py`:
 
 ```python
 CUSTOM_DIT_ENABLERS = {
@@ -248,7 +254,7 @@ Models listed in `_NO_CACHE_ACCELERATION` in `vllm_omni/diffusion/registry.py` d
 
 | Model | Path | Notes |
 |-------|------|-------|
-| Standard DiT | `cache_dit_backend.py::enable_cache_for_dit` | Default enabler, automatic |
-| Wan2.2 | `cache_dit_backend.py::enable_cache_for_wan22` | Dual-transformer, auto-detects mode |
-| LongCat | `cache_dit_backend.py::enable_cache_for_longcat_image` | Multi-block-list |
-| BAGEL | `cache_dit_backend.py::enable_cache_for_bagel` | Complex omni model |
+| Standard DiT | `cachedit.backend::enable_cache_for_dit` | Default enabler, automatic |
+| Wan2.2 | `cachedit.model_specific::enable_cache_for_wan22` | Dual-transformer, auto-detects mode |
+| LongCat | `cachedit.config::CacheDiTAdapterConfig` | Declarative multi-block-list adapter |
+| BAGEL | `cachedit.model_specific::BagelCachedAdapter` | Custom cached adapter |
diff --git a/.claude/skills/add-tts-model/SKILL.md b/.claude/skills/add-tts-model/SKILL.md
index 260a7e924..dc423825a 100644
--- a/.claude/skills/add-tts-model/SKILL.md
+++ b/.claude/skills/add-tts-model/SKILL.md
@@ -307,7 +307,7 @@ def build_voice_clone_prompt(ref_audio_path: str, text: str, codec) -> list:
 
 ### Test Case Writing (CI Levels)
 
-**Follow the [vllm-omni-test skill](../vllm-omni-test/SKILL.md)** for markers, file naming (`test_{slug}.py` / `test_{slug}_expansion.py`), Buildkite wiring, and copy-paste run commands. Also read [CI_5levels.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/CI_5levels.md) and [tests_style.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/tests_style.md).
+**Follow the [vllm-omni-test skill](../vllm-omni-test/SKILL.md)** for markers, file naming (`test_{slug}.py` / `test_{slug}_expansion.py`), Buildkite wiring, and copy-paste run commands. Also read [test_system_overview.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_system_overview.md) and [test_writing_guide.md](https://github.com/vllm-project/vllm-omni/blob/main/docs/contributing/ci/test_writing_guide.md).
 
 Classify the model's **CI priority** first (high / medium / low). High-priority TTS models are typically those on the integration hot path or listed in tracking issues such as [#1832](https://github.com/vllm-project/vllm-omni/issues/1832); medium and low tiers cover the long tail. When unsure, ask the reviewer which tier applies.
 
diff --git a/.claude/skills/vllm-omni-test/SKILL.md b/.claude/skills/vllm-omni-test/SKILL.md
index 40a81f4cf..d5102b3f2 100644
--- a/.claude/skills/vllm-omni-test/SKILL.md
+++ b/.claude/skills/vllm-omni-test/SKILL.md
@@ -9,7 +9,7 @@ description: Generate and run tests for vllm-project/vllm-omni with CI-aligned l
 
 Use this skill to generate minimal, stable test cases and run them with the correct marker/level strategy for [vllm-project/vllm-omni](https://github.com/vllm-project/vllm-omni).
 
-**Link convention:** Paths such as `.buildkite/` and `docs/contributing/` live at the **vllm-omni repo root**. Markdown links use repo-relative paths from this skill file (e.g. `../../../.buildkite/test-ready.yml`, `../../../docs/contributing/ci/CI_5levels.md`).
+**Link convention:** Paths such as `.buildkite/` and `docs/contributing/` live at the **vllm-omni repo root**. Markdown links use repo-relative paths from this skill file (e.g. `../../../.buildkite/cuda/test-ready.yml`, `../../../docs/contributing/ci/test_system_overview.md`).
 
 Default priorities:
 
@@ -96,8 +96,8 @@ Existing references: `tests/e2e/offline_inference/test_qwen2_5_omni.py` (L2-styl
 |----------|------------------|---------------------------|---------------------------|
 | **Offline inference e2e** | `tests/e2e/offline_inference/` | **Module (default):** `omni_runner` + `omni_runner_handler`. **Function (isolation only):** `omni_runner_function` + `omni_runner_handler_function`. Diffusion/TTS may use `Omni(...).generate` directly | L2: `core_model` + **one of** `omni` / `tts` / `diffusion`; `@hardware_test(...)` when GPU/NPU is required |
 | **Online serving e2e** | `tests/e2e/online_serving/` | **Module (default):** `omni_server` + `openai_client`. **Function (isolation only):** `omni_server_function` + `openai_client_function`. Clients: `send_omni_request` (omni), `send_audio_speech_request` (tts), `send_diffusion_request` / `send_video_diffusion_request` / `send_images_generations_request` (diffusion) | Baseline smoke: **`core_model` + `advanced_model`**; heavier paths: `advanced_model` only; L4 expansion: `full_model` |
-| **Documentation / runnable examples** | `tests/examples/offline_inference/`, `tests/examples/online_serving/` | **Offline docs (preferred):** extract Python/Bash blocks from the doc README (e.g. `ReadmeSnippet.extract_readme_snippets`), `pytest.mark.parametrize` each snippet, run via `example_runner.run` with a stable `output_subfolder`. **Online docs:** copy client/request scripts into dedicated tests and keep them in sync with the doc page. | Usually **L4**: `advanced_model`, often `example` plus hardware marks matching the nightly docs-example job (see `.buildkite/test-nightly.yml`). Full conventions: [docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md](../../../docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md) (introduced in [PR #1910](https://github.com/vllm-project/vllm-omni/pull/1910): naming, output directory layout, skip rules, avoid trimming `num_inference_steps` without a strong CI reason). |
-| **Performance / benchmark** | `tests/dfx/perf/tests/*.json` + `run_*_benchmark.py` | JSON or script-driven server + load config; assert explicit metrics / baselines | L4 Perf: `full_model` + `benchmark`; wire `test-nightly.yml` Perf steps |
+| **Documentation / runnable examples** | `tests/examples/offline_inference/`, `tests/examples/online_serving/` | **Offline docs (preferred):** extract Python/Bash blocks from the doc README (e.g. `ReadmeSnippet.extract_readme_snippets`), `pytest.mark.parametrize` each snippet, run via `example_runner.run` with a stable `output_subfolder`. **Online docs:** copy client/request scripts into dedicated tests and keep them in sync with the doc page. | Usually **L4**: `advanced_model`, often `example` plus hardware marks matching the nightly docs-example job (see `.buildkite/cuda/test-nightly.yml`). Full conventions: [docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md](../../../docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md) (introduced in [PR #1910](https://github.com/vllm-project/vllm-omni/pull/1910): naming, output directory layout, skip rules, avoid trimming `num_inference_steps` without a strong CI reason). |
+| **Performance / benchmark** | `tests/dfx/perf/tests/*.json` + `run_*_benchmark.py` | JSON or script-driven server + load config; assert explicit metrics / baselines | L4 Perf: JSON `mark` with `full_model` + `omni`/`tts`/`diffusion`; wire `test-nightly.yml` Perf steps |
 | **Invalid parameter / negative HTTP validation** | `tests/dfx/reliability/invalid_param_test/` | Live `omni_server` + low-level `send_*_http_request` with `err_code` / `err_message` | `pytest.mark.slow` + `omni` / `tts` / `diffusion` + `@hardware_marks` (`H100` or `L4`); CI in **`test-weekly.yml`** (not ready/merge/nightly) |
 
 **If the user’s test plan includes invalid parameter validation / invalid params / negative HTTP / 400 validation:** do **not** add those `test_*` functions to `tests/e2e/online_serving/test_*.py` or `*_expansion.py`. **Move or author them** under `tests/dfx/reliability/invalid_param_test/` in the **endpoint-matching script** (see **Invalid parameter validation** below). Success-path e2e and invalid-param dfx tests must stay in separate modules.
@@ -270,7 +270,7 @@ def test_text_to_video_001(omni_server, openai_client) -> None:
 
 *Documentation example tests:* follow the **Preferred Test Strategy** in [l4_doc_example_tests.inc.md](../../../docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md): dynamic extraction for offline READMEs; explicit copied client code for online pages until extraction is justified; use the documented **naming**, **output directory** (page folder + case id), and **skipping** rules (e.g. Gradio-only scripts).
 
-*Performance tests:* add or extend entries under `tests/perf/` (and JSON configs where the project uses them), with **explicit baselines** and the same marker/run-level pairing as the CI step that will execute them.
+*Performance tests:* add or extend entries under `tests/dfx/perf/tests/` (and JSON configs where the project uses them), with **explicit baselines**, **`mark`** on each case (`hardware_marks` + `full_model` + type marker), and the same nightly Perf step pattern as in-tree configs.
 
 **3. Cross-cutting rules**
 
@@ -460,7 +460,7 @@ When the user asks for **invalid parameter validation**, **invalid request bodie
 
 4. **Adding a new model** to invalid-param coverage: append a `pytest.param(OmniServerParams(model="...", stage_config_path=..., server_args=...), ...)` entry to the script’s `_PARAMS` list — do **not** create `test_invalid_<model>.py` unless the route is new.
 
-5. **CI — `.buildkite/test-weekly.yml` only** (not `test-ready.yml` / `test-merge.yml` / `test-nightly.yml`):
+5. **CI — `.buildkite/cuda/test-weekly.yml` only** (not `test-ready.yml` / `test-merge.yml` / `test-nightly.yml`):
 
 | Weekly step | Command | When your cases run |
 |-------------|---------|---------------------|
@@ -559,7 +559,7 @@ L1 tests under `tests/entrypoints/` may keep **minimal** asserts next to the han
 
 #### Omni Test Writing Guidance (L1-L4 Layering)
 
-When the goal is a general Omni/multimodal test case, prioritize mapping the test to the correct purpose, directory, and resource assumptions aligned with the layers (see [CI_5levels.md](../../../docs/contributing/ci/CI_5levels.md)):
+When the goal is a general Omni/multimodal test case, prioritize mapping the test to the correct purpose, directory, and resource assumptions aligned with the layers (see [test_system_overview.md](../../../docs/contributing/ci/test_system_overview.md) and [test_writing_guide.md](../../../docs/contributing/ci/test_writing_guide.md)):
 
 - **L1**: Unit/logic validation on CPU (`core_model and cpu`). Cover input validation, branches, and exception paths (`tests/<component>/test_*.py`). **Mock with `mocker` / `monkeypatch` only — not `unittest.mock`.**
 - **L2**: Basic e2e (online/offline basic scenarios). Prefer dummy/lightweight models to validate the end-to-end request-to-output-structure/streaming chain (typically `tests/e2e/online_serving/` and `tests/e2e/offline_inference/`).
@@ -592,27 +592,31 @@ Implementation strategy:
 **When the user explicitly asks for L4 perf (or full L4 including perf):**
 
 1. **Do not** put throughput/latency assertions inside `test_*_expansion.py` — perf uses the **dfx benchmark harness**, not `omni_server` e2e fixtures.
-2. Add or extend a **JSON config** under `tests/dfx/perf/tests/` (mirror in-tree names: `test_qwen_image_vllm_omni.json`, `test_bagel_vllm_omni.json`).
-3. Each JSON entry: `test_name`, `server_params` (`model`, `serve_args`), `benchmark_params[]` with explicit **`baseline`** (`throughput_qps`, `latency_mean`, `peak_memory_mb_mean`, …).
+2. Add or extend a **JSON config** under `tests/dfx/perf/tests/` (mirror in-tree names: `test_qwen_image_vllm_omni.json`, `test_cosmos3_vllm_omni.json`, `test_qwen3_omni_async_chunk.json`).
+3. Each JSON **case**: `test_name`, optional **`mark`** (`hardware_marks` required when present; `marks`: `full_model` + `omni`/`tts`/`diffusion`), `server_params` (`model`, `serve_args` or `stage_config_name`), `benchmark_params[]` with **`name`** and explicit **`baseline`** (`throughput_qps`, `latency_mean`, `peak_memory_mb_mean`, …). Diffusion cases also set `server_type` (e.g. `"vllm-omni"`) and usually `benchmark_endpoint`.
 4. Run locally via the matching script (model type → runner):
 
 | Model type | Runner script | Example config |
 |------------|---------------|----------------|
 | **Diffusion X2I/X2V** | `tests/dfx/perf/scripts/run_diffusion_benchmark.py` | `tests/dfx/perf/tests/test_qwen_image_vllm_omni.json` |
 | **TTS** | `tests/dfx/perf/scripts/run_benchmark.py` | `tests/dfx/perf/tests/test_tts.json` (shared) or `test_{slug}.json` (dedicated; use when the model must not join the shared nightly matrix before integration — e.g. `test_voxcpm2.json`, `test_coqui_tts.json`) |
-| **Omni** | (see existing Omni Perf steps — `run_benchmark.py` / dedicated omni configs in-tree) | `tests/dfx/perf/tests/test_omni*.json` |
+| **Omni** | `tests/dfx/perf/scripts/run_benchmark.py` | `test_qwen3_omni_no_async_chunk.json`, `test_qwen3_omni_async_chunk.json`, `test_qwen3_omni_vllm_text.json`, `test_qwen3_omni_multi_replicas.json` |
 
-5. Wire **`test-nightly.yml` · Perf Test** step for that model (separate from Function Test): export `DIFFUSION_BENCHMARK_DIR` / `BENCHMARK_DIR`, run pytest on the script with `--test-config-file`, **upload artifacts** (`buildkite-agent artifact upload`), often **multi-GPU H100** for diffusion perf.
+5. Wire **`test-nightly.yml` · Perf Test** step for that model (separate from Function Test): export `DIFFUSION_BENCHMARK_DIR` / `BENCHMARK_DIR`, run pytest on the script with **`--test-config-file`** (nightly perf steps do not use `-m`), **upload artifacts** (`buildkite-agent artifact upload`), often **multi-GPU H100** for diffusion perf.
 6. **One benchmark scenario → one `test_name` block** in JSON (same spirit as one `test_*` per function case). Combine server `serve_args` + workload in one entry; use multiple `benchmark_params` rows for size/step sweeps under the same server config.
 
-**Perf local command (diffusion example):**
+**Perf local commands:**
 
 ```bash
 cd tests
 export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
 export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+# Single file (CI-like)
 pytest -s -v dfx/perf/scripts/run_diffusion_benchmark.py \
   --test-config-file dfx/perf/tests/test_<model>_vllm_omni.json
+# Bulk load + filter by JSON mark
+pytest -sv dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and diffusion and H100"
+pytest -sv dfx/perf/scripts/run_benchmark.py -m "full_model and omni and H100"
 ```
 
 **Clarify in the test plan** which L4 pillars you deliver: `Function only` | `Function + Perf` | `Function + Accuracy + Perf`.
@@ -625,10 +629,10 @@ If the test is not already collected by an existing pipeline command (for exampl
 
 | Test level | Edit this file | Typical trigger / intent |
 |------------|----------------|---------------------------|
-| **L1** and **L2** | [`.buildkite/test-ready.yml`](../../../.buildkite/test-ready.yml) | PR **ready** label; L1 CPU + L2 GPU/basic e2e (steps labeled **Omni ·**, **TTS ·**, **Diffusion ·**) |
-| **L3** | [`.buildkite/test-merge.yml`](../../../.buildkite/test-merge.yml) | Post-merge; `advanced_model` integration per model type |
-| **L4** | [`.buildkite/test-nightly.yml`](../../../.buildkite/test-nightly.yml) | Nightly; grouped by model type (see below) |
-| **Invalid param / reliability (weekly)** | [`.buildkite/test-weekly.yml`](../../../.buildkite/test-weekly.yml) | Weekly; `tests/dfx/reliability/invalid_param_test/` — **not** L1–L4 e2e pipelines |
+| **L1** and **L2** | [`.buildkite/cuda/test-ready.yml`](../../../.buildkite/cuda/test-ready.yml) | PR **ready** label; L1 CPU + L2 GPU/basic e2e (steps labeled **Omni ·**, **TTS ·**, **Diffusion ·**) |
+| **L3** | [`.buildkite/cuda/test-merge.yml`](../../../.buildkite/cuda/test-merge.yml) | Post-merge; `advanced_model` integration per model type |
+| **L4** | [`.buildkite/cuda/test-nightly.yml`](../../../.buildkite/cuda/test-nightly.yml) | Nightly; grouped by model type (see below) |
+| **Invalid param / reliability (weekly)** | [`.buildkite/cuda/test-weekly.yml`](../../../.buildkite/cuda/test-weekly.yml) | Weekly; `tests/dfx/reliability/invalid_param_test/` — **not** L1–L4 e2e pipelines |
 
 **Level-specific Buildkite delivery (follow the user’s requested level):**
 
@@ -805,21 +809,21 @@ Use **repo-relative paths** (no leading `./`). Prefer **directory** entries (`..
 
 When extending an **existing** E2E step to run an additional test file, **append** that file (and any new model/deploy paths) to `source_file_dependencies` on the same step. When authoring a PR, mention the dependency list in the **Buildkite change** section of your test plan.
 
-#### L3 / L4: validating Buildkite from a feature branch (root `pipeline.yml`)
+#### L3 / L4: validating Buildkite from a feature branch (`cuda/pipeline.yml`)
 
-Production behavior is driven by [`.buildkite/pipeline.yml`](../../../.buildkite/pipeline.yml): it builds the CI image, then uploads **L2** (`test-ready.yml` on non-`main`), **L3** (`test-merge.yml` when `build.branch == "main"`), and **L4** (`test-nightly.yml` when `build.env("NIGHTLY") == "1"`).
+Production behavior is driven by [`.buildkite/cuda/pipeline.yml`](../../../.buildkite/cuda/pipeline.yml): it builds the CI image, then uploads **L2** (`test-ready.yml` on non-`main`), **L3** (`test-merge.yml` when `build.branch == "main"`), and **L4** (`test-nightly.yml` when `build.env("NIGHTLY") == "1"`).
 
 When you add or debug **L3** or **L4** tests and need those child pipelines to run **off `main`** or **without** `NIGHTLY=1`, apply **temporary** edits (revert before merge):
 
 1. **Point the upload at the right file (optional shortcut)**  
-   In the **Upload Ready Pipeline** step, the command is `buildkite-agent pipeline upload .buildkite/test-ready.yml`. For a one-off run you may change that path to `.buildkite/test-merge.yml` (L3) or `.buildkite/test-nightly.yml` (L4), and adjust the step’s `if:` so it does not conflict with the other upload steps (avoid double-uploading unless intentional).
+   In the **Upload Ready Pipeline** step, the command is `buildkite-agent pipeline upload .buildkite/cuda/test-ready.yml`. For a one-off run you may change that path to `.buildkite/cuda/test-merge.yml` (L3) or `.buildkite/cuda/test-nightly.yml` (L4), and adjust the step’s `if:` so it does not conflict with the other upload steps (avoid double-uploading unless intentional).
 
 2. **L3 — merge pipeline**  
-   The gate `if: build.branch == "main"` lives on the **Upload Merge Pipeline** step in `pipeline.yml` (not inside `test-merge.yml`). **Comment out that `if` line** so `test-merge.yml` is uploaded on your feature branch. Alternatively rely on step (1) instead of the dedicated merge upload step.
+   The gate `if: build.branch == "main"` lives on the **Upload Merge Pipeline** step in `cuda/pipeline.yml` (not inside `test-merge.yml`). **Comment out that `if` line** so `test-merge.yml` is uploaded on your feature branch. Alternatively rely on step (1) instead of the dedicated merge upload step.
 
 3. **L4 — nightly pipeline**  
-   **Comment out** `if: build.env("NIGHTLY") == "1"` on the **Upload Nightly Pipeline** step in `pipeline.yml` so the nightly definition is uploaded without setting the env var.  
-   Child steps in [`test-nightly.yml`](../../../.buildkite/test-nightly.yml) often repeat `if: build.env("NIGHTLY") == "1"`; **comment out those lines on the steps you need to run**, otherwise they will still be skipped after upload.
+   **Comment out** `if: build.env("NIGHTLY") == "1"` on the **Upload Nightly Pipeline** step in `cuda/pipeline.yml` so the nightly definition is uploaded without setting the env var.  
+   Child steps in [`test-nightly.yml`](../../../.buildkite/cuda/test-nightly.yml) often repeat `if: build.env("NIGHTLY") == "1"`; **comment out those lines on the steps you need to run**, otherwise they will still be skipped after upload.
 
 ### Step 6: Run Tests
 
@@ -886,5 +890,5 @@ When completing a request, return:
 ## Additional Resources
 
 - Marker and command routing: [references/test-routing.md](references/test-routing.md)
-- CI pipelines (vllm-omni): [test-ready.yml](../../../.buildkite/test-ready.yml) (L1/L2), [test-merge.yml](../../../.buildkite/test-merge.yml) (L3), [test-nightly.yml](../../../.buildkite/test-nightly.yml) (L4), [test-weekly.yml](../../../.buildkite/test-weekly.yml) (invalid param / reliability)
+- CI pipelines (vllm-omni): [test-ready.yml](../../../.buildkite/cuda/test-ready.yml) (L1/L2), [test-merge.yml](../../../.buildkite/cuda/test-merge.yml) (L3), [test-nightly.yml](../../../.buildkite/cuda/test-nightly.yml) (L4), [test-weekly.yml](../../../.buildkite/cuda/test-weekly.yml) (invalid param / reliability)
 - L4 documentation example tests (naming, extraction vs copied scripts, output dirs, skips): [docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md](../../../docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md) — see also [PR #1910](https://github.com/vllm-project/vllm-omni/pull/1910)
diff --git a/.claude/skills/vllm-omni-test/references/test-routing.md b/.claude/skills/vllm-omni-test/references/test-routing.md
index 445a78399..394046b91 100644
--- a/.claude/skills/vllm-omni-test/references/test-routing.md
+++ b/.claude/skills/vllm-omni-test/references/test-routing.md
@@ -2,7 +2,7 @@
 
 Use this reference to map testing goals to levels, markers, and runnable commands.
 
-**Repo paths** (`.buildkite/`, `docs/contributing/…`): link with repo-relative paths from this file (e.g. `../../../../.buildkite/test-ready.yml`, `../../../../docs/contributing/ci/CI_5levels.md`).
+**Repo paths** (`.buildkite/`, `docs/contributing/…`): link with repo-relative paths from this file (e.g. `../../../../.buildkite/cuda/test-ready.yml`, `../../../../docs/contributing/ci/test_system_overview.md`).
 
 ## Model-centric e2e filename convention (L2–L4)
 
@@ -127,8 +127,12 @@ pytest -s -v e2e/online_serving/test_qwen_image_expansion.py -m "full_model and
 cd tests
 export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
 export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
+# CI-like: single JSON file (nightly Perf Test steps)
 pytest -s -v dfx/perf/scripts/run_diffusion_benchmark.py \
   --test-config-file dfx/perf/tests/test_qwen_image_vllm_omni.json
+# Local bulk load: all *.json under tests/dfx/perf/tests/, filter by JSON mark
+pytest -sv dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and diffusion and H100"
+pytest -sv dfx/perf/scripts/run_benchmark.py -m "full_model and omni and H100"
 ```
 
 Broad marker sweep (when no explicit file shard):
@@ -150,7 +154,26 @@ Nightly **L4** for a model is often **multiple jobs** in `test-nightly.yml`, not
 
 **Rule:** “L4 functional cases” → **Function only** by default. State that Perf/Accuracy are separate pillars; add them only when requested.
 
-**Diffusion perf JSON** (`tests/dfx/perf/tests/test_<slug>_vllm_omni.json`): array of objects with `test_name`, `server_params` (`model`, `serve_args`), `benchmark_params[]`, and per-workload **`baseline`** (`throughput_qps`, `latency_mean`, `peak_memory_mb_mean`). Copy structure from `test_qwen_image_vllm_omni.json` in-tree.
+**Diffusion perf JSON** (`tests/dfx/perf/tests/test_<slug>_vllm_omni.json`): array of **case objects**, each with:
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `test_name` | Yes | Unique server/workload id |
+| `mark` | Recommended | When present: **`hardware_marks` required** + optional `marks` (`full_model`, `diffusion`, `local_model`, …). Parsed by `resolve_pytest_marks`; enables local `-m` filtering. |
+| `server_type` | Diffusion | e.g. `"vllm-omni"` — routes case to `run_diffusion_benchmark.py` |
+| `benchmark_endpoint` | Diffusion | e.g. `/v1/videos`, `/v1/images/generations` |
+| `server_params` | Yes | `model`, `serve_args`, … |
+| `benchmark_params[]` | Yes | Each row: **`name`** (pytest id suffix), workload fields, **`baseline`** |
+
+Copy structure from `test_qwen_image_vllm_omni.json` or `test_cosmos3_vllm_omni.json` (2-GPU mark example).
+
+**Omni perf JSON**: `test_qwen3_omni_*.json` — same `mark` shape with `"marks": ["full_model", "omni"]`; run via `run_benchmark.py`.
+
+**Runner split**: `is_diffusion_perf_config()` → diffusion when `server_type` is set or `"diffusion"` ∈ `mark.marks`; otherwise omni/tts → `run_benchmark.py`.
+
+**Param ids**: `{test_name}-{benchmark_params.name}` (e.g. `test_tts-p0`, not `test_tts-0`).
+
+**Result filenames**: runtime hardware from `get_runtime_resource_label()`; `H100` omitted on default CI pool.
 
 **Diffusion perf nightly step** (under **Diffusion X2I(&A&T)**; copy full `kubernetes` plugins from `· Perf Test · Qwen-Image`):
 
@@ -177,9 +200,9 @@ Nightly **L4** for a model is often **multiple jobs** in `test-nightly.yml`, not
 
 | Model type | Perf runner | Config example |
 |------------|-------------|----------------|
-| Diffusion X2I/X2V | `dfx/perf/scripts/run_diffusion_benchmark.py` | `test_qwen_image_vllm_omni.json` |
-| TTS | `dfx/perf/scripts/run_benchmark.py` | `test_tts.json` (`BENCHMARK_DIR`) |
-| Omni | `run_benchmark.py` / omni configs in-tree | `test_omni*.json` |
+| Diffusion X2I/X2V | `dfx/perf/scripts/run_diffusion_benchmark.py` | `test_qwen_image_vllm_omni.json`, `test_cosmos3_vllm_omni.json` |
+| TTS | `dfx/perf/scripts/run_benchmark.py` | `test_tts.json`, `test_voxcpm2.json`, `test_higgs_audio_v3.json` |
+| Omni | `dfx/perf/scripts/run_benchmark.py` | `test_qwen3_omni_async_chunk.json`, `test_qwen3_omni_no_async_chunk.json`, … |
 
 Do **not** put throughput/latency baselines inside `test_*_expansion.py` — that belongs in the dfx perf JSON + nightly Perf job.
 
@@ -201,7 +224,7 @@ When the user’s test plan includes **invalid parameter validation**, **invalid
 | Sleep / wakeup / server control | `test_invalid_server_control.py` |
 
 3. **Style:** `pytestmark = [pytest.mark.slow, pytest.mark.<type>]`; `_PARAMS` + `hardware_marks`; `send_*_http_request` with `err_code` + `err_message`; parametrized `body_spec` rows with `id=`; `_minimal_*_json()` helpers; `_SKIP_ISSUE_3649` when tracked in [#3649](https://github.com/vllm-project/vllm-omni/issues/3649).
-4. **CI:** [`.buildkite/test-weekly.yml`](../../../../.buildkite/test-weekly.yml) group **Reliability Test - Invalid parameters Test** — **not** ready/merge/nightly.
+4. **CI:** [`.buildkite/cuda/test-weekly.yml`](../../../../.buildkite/cuda/test-weekly.yml) group **Reliability Test - Invalid parameters Test** — **not** ready/merge/nightly.
 
 ```bash
 # Weekly H100 (diffusion / omni / video invalid-param)
@@ -268,10 +291,10 @@ When adding or modifying tests, do not stop at “where the file lives” — al
 
 | Level | Repo file | Model-type grouping |
 |-------|-----------|---------------------|
-| L1, L2 | [`.buildkite/test-ready.yml`](../../../../.buildkite/test-ready.yml) | Steps prefixed **Omni ·**, **TTS ·**, **Diffusion ·** under **E2E Test** — **`source_file_dependencies` required** |
-| L3 | [`.buildkite/test-merge.yml`](../../../../.buildkite/test-merge.yml) | Per-model E2E steps; `-m "advanced_model and …"` — **`source_file_dependencies` required** |
-| L4 | [`.buildkite/test-nightly.yml`](../../../../.buildkite/test-nightly.yml) | **Omni / TTS / Diffusion X2I(&A&T) / X2V** — each group may have **Function**, **Accuracy**, **Perf**, **Doc** steps |
-| Invalid param (weekly) | [`.buildkite/test-weekly.yml`](../../../../.buildkite/test-weekly.yml) | **Invalid parameters Test · H100** / **· L4** — sweeps `tests/dfx/reliability/invalid_param_test/` |
+| L1, L2 | [`.buildkite/cuda/test-ready.yml`](../../../../.buildkite/cuda/test-ready.yml) | Steps prefixed **Omni ·**, **TTS ·**, **Diffusion ·** under **E2E Test** — **`source_file_dependencies` required** |
+| L3 | [`.buildkite/cuda/test-merge.yml`](../../../../.buildkite/cuda/test-merge.yml) | Per-model E2E steps; `-m "advanced_model and …"` — **`source_file_dependencies` required** |
+| L4 | [`.buildkite/cuda/test-nightly.yml`](../../../../.buildkite/cuda/test-nightly.yml) | **Omni / TTS / Diffusion X2I(&A&T) / X2V** — each group may have **Function**, **Accuracy**, **Perf**, **Doc** steps |
+| Invalid param (weekly) | [`.buildkite/cuda/test-weekly.yml`](../../../../.buildkite/cuda/test-weekly.yml) | **Invalid parameters Test · H100** / **· L4** — sweeps `tests/dfx/reliability/invalid_param_test/` |
 
 ### `source_file_dependencies` (E2E Test only — ready & merge)
 
@@ -357,7 +380,7 @@ Common patterns in `test-ready.yml` / `test-merge.yml`:
 
 When extending an existing step (e.g. add `tests/e2e/offline_inference/test_qwen_image.py` to **Diffusion · Qwen Image Test**), update `source_file_dependencies` and `commands` only; **keep the existing `agents` + `plugins` block unchanged** unless the hardware tier changes.
 
-The root [`.buildkite/pipeline.yml`](../../../../.buildkite/pipeline.yml) decides **which** child file is uploaded. To run **L3** on a feature branch, comment out `if: build.branch == "main"` on the merge upload step. To run **L4** without `NIGHTLY=1`, comment out the nightly upload step’s `if: build.env("NIGHTLY") == "1"` and the same `if` on relevant steps inside `test-nightly.yml`. Revert such edits before merging.
+[`.buildkite/cuda/pipeline.yml`](../../../../.buildkite/cuda/pipeline.yml) decides **which** child file is uploaded. To run **L3** on a feature branch, comment out `if: build.branch == "main"` on the merge upload step. To run **L4** without `NIGHTLY=1`, comment out the nightly upload step’s `if: build.env("NIGHTLY") == "1"` and the same `if` on relevant steps inside `test-nightly.yml`. Revert such edits before merging.
 
 Platform-specific pipelines (e.g. AMD) follow the same level → file pairing under `.buildkite/`.
 
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 6b3ddb474..c95d1df08 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -16,15 +16,15 @@
 /.claude/ @hsliuustc0106
 
 # Tests
-/tests/ @yenuo26
+/tests/ @yenuo26 @NickCao
 
 # CI
-/.buildkite/ @yenuo26 @congw729
+/.buildkite/ @yenuo26 @congw729 @NickCao
 
 # Engine and model_executor
 /vllm_omni/core/ @tzhouam @yinpeiqi @fake0fan @Sy0307
 /vllm_omni/engine/ @tzhouam @yinpeiqi @fake0fan @Sy0307
-/vllm_omni/entrypoints/ @tzhouam @yinpeiqi @fake0fan @alex-jw-brooks
+/vllm_omni/entrypoints/ @tzhouam @yinpeiqi @fake0fan @alex-jw-brooks @NickCao
 /vllm_omni/model_executor/ @tzhouam @gcanlin
 /vllm_omni/worker/ @tzhouam @gcanlin
 
@@ -37,7 +37,7 @@
 
 # Omni and TTS support
 /vllm_omni/transformers_utils/ @tzhouam @yuanheng-zhao
-/vllm_omni/model_executor/models/ @linyueqian @ZeldaHuang @princepride @yuanheng-zhao @amy-why-3459 @Bounty-hunter @Sy0307 @gcanlin
+/vllm_omni/model_executor/models/ @linyueqian @ZeldaHuang @princepride @yuanheng-zhao @amy-why-3459 @Bounty-hunter @Sy0307 @gcanlin @NickCao
 
 # Benchmarks
 /benchmarks/accuracy/ @david6666666
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 964fb5abc..2bd0cc133 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -24,3 +24,9 @@ jobs:
           python-version: "3.12"
           cache: 'pip'
       - uses: pre-commit/action@v3.0.1
+        # Don't run the pytest mark check against everything in the CI
+        # for now since a lot of files are still missing them. This check
+        # is used to help contributors remember to add the marks when they
+        # commit.
+        env:
+          SKIP: check-test-ci-coverage
diff --git a/.gitignore b/.gitignore
index 224dac867..3c24e40ae 100644
--- a/.gitignore
+++ b/.gitignore
@@ -259,7 +259,6 @@ configs/production.yaml
 configs/development.yaml
 
 # Docker
-.dockerignore
 Dockerfile.dev
 discussion
 tmp_test
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6db093e0e..be649785d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -54,6 +54,13 @@ repos:
       verbose: true
       stages: [commit-msg]
 
+    - id: check-test-ci-coverage
+      name: Ensure test files have pytestmarks
+      entry: python tools/pre_commit/check_test_marks.py
+      language: python
+      types: [python]
+      files: ^tests/
+
     # Keep `suggestion` last
     - id: suggestion
       name: Suggestion
diff --git a/README.md b/README.md
index e7fc6912e..9d63a4b1e 100644
--- a/README.md
+++ b/README.md
@@ -16,14 +16,10 @@ Easy, fast, and cheap omni-modality model serving for everyone
 ---
 
 *Latest News* 🔥
+- [2026/08] We released [0.26.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.26.0) - aligned with the vLLM 0.26 release line, featuring [MiniMax H3](recipes/MiniMaxAI/MiniMax-H3.md) joint video/audio generation, an experimental full-duplex realtime runtime for [MiniCPM-o 4.5](recipes/OpenBMB/MiniCPM-o-4_5.md), distributed layerwise diffusion offload, and broader model, hardware, streaming, TTS, and quantization support.
 - [2026/07] We released [0.24.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.24.0) - aligned with the vLLM 0.24 release line, expanding production-ready coverage across TTS, speech, diffusion, image/video generation, and robot-policy serving, with major Omni stage runtime refactoring, diffusion request-level batching, async output materialization, quantization/cache/memory improvements, and broad CUDA/ROCm/XPU/NPU support.
-- [2026/06] We released [0.22.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.22.0) - an **omnimodal world-model** release aligned with vLLM 0.22, featuring [Nvidia Cosmos3](recipes/cosmos3/Cosmos3-Nano.md)/DreamZero world model support, expanded quantization coverage across Blackwell/NPU/XPU, TTS production improvements, new models including MiniCPM-o 4.5, MOSS-TTS, and Lance, plus RL integration with [VeRL-Omni](https://github.com/verl-project/verl-omni).
-- [2026/05] We released [0.20.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.20.0) - refreshes the serving/runtime stack for large-scale omni workloads, and improves diffusion model performance, quantization, and hardware readiness across CUDA, ROCm, MUSA, NPU, and XPU backends.
-- [2026/03] We released [0.18.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.18.0) - strengthens the core runtime through a large entrypoint refactor and scheduler/runtime cleanups, expands unified quantization and diffusion execution, broadens multimodal model coverage, and improves production readiness across audio, omni, image, video, RL, and multi-platform deployments.
+- [2026/06] Starting with [0.14.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.14.0), vLLM-Omni publishes a stable release aligned with every even-numbered upstream vLLM minor version. [0.16.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.16.0), [0.18.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.18.0), [0.20.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.20.0), and [0.22.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.22.0) continued this cadence, expanding omni and world-model support with [NVIDIA Cosmos3](recipes/cosmos3/Cosmos3-Nano.md) and DreamZero, adding models such as MiniCPM-o 4.5, MOSS-TTS, and Lance, and advancing TTS, diffusion, distributed execution, quantization, RL integration through [VeRL-Omni](https://github.com/verl-project/verl-omni), and CUDA/ROCm/MUSA/NPU/XPU coverage.
 - [2026/03] Check out our first public [project deepdive](https://youtu.be/sgwNfsNnR9I) at the vLLM Hong Kong Meetup!
-- [2026/03] **[vllm-omni-skills](https://github.com/hsliuustc0106/vllm-omni-skills)** is a community-driven collection of AI assistant skills that help developers work with vLLM-Omni more effectively. These skills can be used with popular agentic AI coding assistants like **Cursor IDE**, **Claude**, **Codex**, and more.
-- [2026/02] We released [0.16.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.16.0) - A major alignment + capability release that rebases onto **upstream vLLM v0.16.0** and significantly expands performance, distributed execution, and production readiness across **Qwen3-Omni / Qwen3-TTS**, **Bagel**, **MiMo-Audio**, **GLM-Image** and the **Diffusion (DiT) image/video stack**—while also improving platform coverage (CUDA / ROCm / NPU / XPU), CI quality, and documentation.
-- [2026/02] We released [0.14.0](https://github.com/vllm-project/vllm-omni/releases/tag/v0.14.0) - This is the first **stable release** of vLLM-Omni that expands Omni’s diffusion / image-video generation and audio / TTS stack, improves distributed execution and memory efficiency, and broadens platform/backend coverage (GPU/ROCm/NPU/XPU). It also brings meaningful upgrades to serving APIs, profiling & benchmarking, and overall stability. Please check our latest [paper](https://arxiv.org/abs/2602.02204) for architecture design and performance results.
 - [2025/11] vLLM community officially released [vllm-project/vllm-omni](https://github.com/vllm-project/vllm-omni) in order to support omni-modality models serving.
 
 ---
@@ -55,12 +51,13 @@ vLLM-Omni is flexible and easy to use with:
 - Tensor, pipeline, data and expert parallelism support for distributed inference
 - Streaming outputs
 - OpenAI-compatible API server
+- Full-duplex realtime serving with streaming audio input and output (experimental)
 
 vLLM-Omni seamlessly supports most popular open-source models on HuggingFace, including:
 
-- **Omni-modality models** (e.g. Qwen3-Omni, Cosmos3, HunyuanImage, BAGEL)
+- **Omni-modality models** (e.g. Qwen3-Omni, MiniCPM-o 4.5, Cosmos3, HunyuanImage, BAGEL)
 - **TTS models** (e.g. Qwen3-TTS, VoxCPM2, Ming-Omni-TTS, CosyVoice3)
-- **Diffusion models** — image, video, and audio generation (e.g. Qwen-Image, Wan2.2, FLUX)
+- **Diffusion models** — image, video, and audio generation (e.g. MiniMax H3, Qwen-Image, Wan2.2, FLUX)
 - **Robot-policy and action models** (e.g. GR00T-N1.7, DreamZero-DROID, InternVLA-A1, Cosmos3 action policy)
 
 ## Getting Started
diff --git a/apps/ComfyUI-vLLM-Omni/README.md b/apps/ComfyUI-vLLM-Omni/README.md
index 54f2fdf2e..cbd53a9a0 100644
--- a/apps/ComfyUI-vLLM-Omni/README.md
+++ b/apps/ComfyUI-vLLM-Omni/README.md
@@ -47,7 +47,7 @@ If no, check your shell running the ComfyUI process. There may be some error mes
 This extension offers the following nodes based on the output modalities (at **ComfyUI sidebar -> Node Library**):
 
 - **Generate Image** for text-to-image and image-to-image tasks
-- **Generate Video** for text-to-video and image-to-video tasks
+- **Generate Video** for text-to-video, first-frame/image-to-video, and reference-conditioned video
 - **Multimodality Understanding** for multimodality-to-text and multimodality-to-audio tasks
 - **TTS** and **TTS Voice Clone** for TTS tasks
 
@@ -105,7 +105,7 @@ You can configure per-stage sampling parameters for multi-stage models.
 > [!TIP]
 > The node automatically choose text-to-image or image-to-image API endpoints depending on whether you connect an image input or not.
 
-### Text-to-video and image-to-video generation (e.g., Wan)
+### Text-to-video and image-to-video generation (e.g., Wan, MiniMax-H3)
 
 (Also available at **ComfyUI sidebar->Template->vLLM-Omni->vLLM-Omni Video Generation**)
 
@@ -117,7 +117,11 @@ You can configure per-stage sampling parameters for multi-stage models.
 </p>
 
 > [!TIP]
-> The node automatically choose text-to-video or image-to-video API endpoints depending on whether you connect an image input or not.
+> Connect a **frame** image for first-frame / image-to-video (e.g., Wan I2V, MiniMax-H3 FL2VA).
+>
+> For reference-conditioned generation (MiniMax-H3 Ref2VA), connect a **Video References** node instead.
+>
+> Do not use `frame` and `references` together. Task routing is automatic from which inputs you connect.
 
 ### TTS (e.g., Qwen TTS series)
 
diff --git a/apps/ComfyUI-vLLM-Omni/__init__.py b/apps/ComfyUI-vLLM-Omni/__init__.py
index e89b2ca1e..268107899 100644
--- a/apps/ComfyUI-vLLM-Omni/__init__.py
+++ b/apps/ComfyUI-vLLM-Omni/__init__.py
@@ -15,11 +15,13 @@ from .comfyui_vllm_omni.nodes import (
     VLLMOmniDiffusionSampling,
     VLLMOmniGenerateImage,
     VLLMOmniGenerateVideo,
+    VLLMOmniMiniMaxH3Params,
     VLLMOmniQwenTTSParams,
     VLLMOmniRemoteLoRA,
     VLLMOmniSamplingParamsList,
     VLLMOmniTTS,
     VLLMOmniUnderstanding,
+    VLLMOmniVideoReferences,
     VLLMOmniVoiceClone,
     VLLMOmniWanParams,
 )
@@ -32,6 +34,7 @@ NODE_CLASS_MAPPINGS = {
     "VLLMOmniUnderstanding": VLLMOmniUnderstanding,
     "VLLMOmniTTS": VLLMOmniTTS,
     "VLLMOmniVoiceClone": VLLMOmniVoiceClone,
+    "VLLMOmniVideoReferences": VLLMOmniVideoReferences,
     # === Params ===
     "VLLMOmniARSampling": VLLMOmniARSampling,
     "VLLMOmniDiffusionSampling": VLLMOmniDiffusionSampling,
@@ -39,6 +42,7 @@ NODE_CLASS_MAPPINGS = {
     "VLLMOmniRemoteLoRA": VLLMOmniRemoteLoRA,
     "VLLMOmniQwenTTSParams": VLLMOmniQwenTTSParams,
     "VLLMOmniWanParams": VLLMOmniWanParams,
+    "VLLMOmniMiniMaxH3Params": VLLMOmniMiniMaxH3Params,
 }
 
 # A dictionary that contains the friendly/humanly readable titles for the nodes
@@ -49,6 +53,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "VLLMOmniUnderstanding": "Multimodality Understanding",
     "VLLMOmniTTS": "TTS (Text to Speech)",
     "VLLMOmniVoiceClone": "TTS Voice Cloning",
+    "VLLMOmniVideoReferences": "Video References",
     # === Params ===
     "VLLMOmniARSampling": "AR Sampling Params",
     "VLLMOmniDiffusionSampling": "Diffusion Sampling Params",
@@ -56,6 +61,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "VLLMOmniRemoteLoRA": "LoRA",
     "VLLMOmniQwenTTSParams": "Qwen TTS Params",
     "VLLMOmniWanParams": "Wan Video Params",
+    "VLLMOmniMiniMaxH3Params": "MiniMax-H3 Video Params",
 }
 
 WEB_DIRECTORY = "./web"
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
index bfea93998..8fd00cd9c 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
@@ -10,7 +10,9 @@ from .utils.types import (
     AudioFormat,
     AutoregressionSamplingParams,
     DiffusionSamplingParams,
+    MiniMaxH3ModelSpecificParams,
     QwenTTSModelSpecificParams,
+    VideoReferences,
     WanModelSpecificParams,
 )
 from .utils.validators import (
@@ -163,7 +165,8 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
                 "num_frames": ("INT", {"default": 41, "min": 1}),
             },
             "optional": {
-                "image": ("IMAGE",),
+                "frame": ("IMAGE",),
+                "references": ("VIDEO_REFERENCES",),
                 "sampling_params": ("SAMPLING_PARAMS",),
                 "lora": ("REMOTE_LORA",),
                 "model_params": ("VIDEO_PARAMS",),
@@ -174,6 +177,15 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
     RETURN_NAMES = ("video",)
     FUNCTION = "generate"
 
+    @classmethod
+    def VALIDATE_INPUTS(cls, url, model, frame=None, references=None, **_kwargs) -> str | Literal[True]:
+        base = super().VALIDATE_INPUTS(url, model)
+        if base is not True:
+            return base
+        if frame is not None and references is not None:
+            return "Provide only one of frame or references, not both."
+        return True
+
     async def generate(
         self,
         url: str,
@@ -184,7 +196,8 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
         fps: int,
         num_frames: int,
         negative_prompt: str | None = None,
-        image: torch.Tensor | None = None,
+        frame: torch.Tensor | None = None,
+        references: dict | None = None,
         sampling_params: dict | list[dict] | None = None,
         model_params: dict | None = None,
         lora: dict | None = None,
@@ -207,14 +220,16 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
 
         if sampling_params is not None:
             sampling_params.pop("type", None)  # internal fields
-        if model_params is not None:
-            model_params.pop("type", None)  # internal fields
+        # model_params["type"] is also an internal field, but is used in api_client
+        # if model_params is not None:
+        #     model_params.pop("type", None)  # internal fields
 
         client = VLLMOmniClient(url)
         output = await client.generate_video(
             model=model,
             prompt=prompt,
-            image=image,  # image present => i2v, absent => t2v
+            frame=frame,  # frame present => fl2va / Wan I2V
+            references=references,
             width=width,
             height=height,
             num_frames=num_frames,
@@ -734,3 +749,78 @@ class VLLMOmniWanParams:
 
     def get_params(self, **kwargs):
         return (WanModelSpecificParams(kwargs),)
+
+
+class VLLMOmniMiniMaxH3Params:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "audio_flow_shift": (
+                    "FLOAT",
+                    {"default": 3.0, "min": 0.0, "max": 100.0, "step": 0.1},
+                ),
+                "flow_shift": (
+                    "FLOAT",
+                    {"default": 12.0, "min": 0.0, "max": 100.0, "step": 0.1},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("VIDEO_PARAMS",)
+    RETURN_NAMES = ("MiniMax-H3 video params",)
+    FUNCTION = "get_params"
+    CATEGORY = "vLLM-Omni/Video Params"
+
+    def get_params(self, **kwargs):
+        params = MiniMaxH3ModelSpecificParams(kwargs)
+        params["type"] = "minimax_h3"
+        return (params,)
+
+
+class VLLMOmniVideoReferences:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {},
+            "optional": {
+                "image_1": ("IMAGE",),
+                "image_2": ("IMAGE",),
+                "audio_1": ("AUDIO",),
+                "audio_2": ("AUDIO",),
+                "video_1": ("VIDEO",),
+                "video_2": ("VIDEO",),
+            },
+        }
+
+    RETURN_TYPES = ("VIDEO_REFERENCES",)
+    RETURN_NAMES = ("references",)
+    FUNCTION = "get_references"
+    CATEGORY = "vLLM-Omni"
+
+    def get_references(
+        self,
+        image_1: torch.Tensor | None = None,
+        image_2: torch.Tensor | None = None,
+        audio_1: AudioInput | None = None,
+        audio_2: AudioInput | None = None,
+        video_1: VideoInput | None = None,
+        video_2: VideoInput | None = None,
+        **kwargs,
+    ):
+        if kwargs:
+            logger.info("Uncaught kwargs: %s", kwargs)
+        refs = VideoReferences()
+        if image_1 is not None:
+            refs["image_1"] = image_1
+        if image_2 is not None:
+            refs["image_2"] = image_2
+        if audio_1 is not None:
+            refs["audio_1"] = audio_1
+        if audio_2 is not None:
+            refs["audio_2"] = audio_2
+        if video_1 is not None:
+            refs["video_1"] = video_1
+        if video_2 is not None:
+            refs["video_2"] = video_2
+        return (refs,)
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
index 8600fe393..cd509244a 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/api_client.py
@@ -24,6 +24,7 @@ from .format import (
     image_tensor_to_base64,
     image_tensor_to_png_bytes,
     video_to_base64,
+    video_to_bytes,
 )
 from .logger import get_logger, pretty_printer
 from .models import lookup_model_spec
@@ -63,7 +64,11 @@ async def url_bytes(session: aiohttp.ClientSession, url: str, verb: str = "get",
 
 class VLLMOmniClient:
     def __init__(
-        self, base_url: str, timeout: float | None = None, poll_interval: float = 5.0, max_poll_duration: float = 60 * 5
+        self,
+        base_url: str,
+        timeout: float | None = None,
+        poll_interval: float = 5.0,
+        max_poll_duration: float = 60 * 30,
     ):
         self.base_url = base_url
         self.timeout = aiohttp.ClientTimeout(total=timeout)
@@ -261,12 +266,17 @@ class VLLMOmniClient:
         num_frames: int,
         fps: int,
         negative_prompt: str | None = None,
-        image: torch.Tensor | None = None,
+        frame: torch.Tensor | None = None,
+        references: dict | None = None,
         sampling_params: dict | None = None,
         model_params: dict | None = None,
         lora: dict | None = None,
-        **extra_body,
+        **extra_params,
     ) -> VideoInput:
+        if frame is not None and references is not None:
+            raise ValueError("Provide only one of frame or references, not both.")
+
+        # === regular payload fields ===
         form = aiohttp.FormData()
         form.add_field("model", model)
         form.add_field("prompt", prompt)
@@ -279,23 +289,91 @@ class VLLMOmniClient:
         if sampling_params is not None:
             for k, v in sampling_params.items():
                 form.add_field(k, str(v))
-        if model_params is not None:
-            for k, v in model_params.items():
-                form.add_field(k, str(v))
         if lora is not None:
             form.add_field("lora", json.dumps(lora, ensure_ascii=False))
-        if extra_body:
-            form.add_field("extra_body", json.dumps(extra_body, ensure_ascii=False))
 
-        if image is not None:
+        # === multimodal inputs (first-last-frames, references, etc.) ===
+        input_reference_image: torch.Tensor | None = None
+        audio_reference: AudioInput | None = None
+        reference_videos: list[VideoInput] = []
+        video_task: str | None = None
+
+        if frame is not None:
+            input_reference_image = frame
+            video_task = "fl2va"
+        elif references is not None:
+            images = [references[k] for k in ("image_1", "image_2") if k in references and references[k] is not None]
+            audios = [references[k] for k in ("audio_1", "audio_2") if k in references and references[k] is not None]
+            videos = [references[k] for k in ("video_1", "video_2") if k in references and references[k] is not None]
+
+            if not images and not audios and not videos:
+                raise ValueError("references is empty; connect at least one image/audio/video.")
+
+            if videos:
+                if images or audios:
+                    raise ValueError(
+                        "Video references cannot be combined with image or audio references. "
+                        "Connect only video_1/video_2 for multi-video Ref2VA."
+                    )
+                reference_videos = videos
+                video_task = "ref2va"
+            elif len(images) == 1 and len(audios) == 1:
+                input_reference_image = images[0]
+                audio_reference = audios[0]
+                video_task = "ref2va"
+            else:
+                raise ValueError(
+                    "Invalid references combination. Supported modes: "
+                    "(1) one or more videos only, or (2) exactly one image and one audio."
+                )
+        else:
+            video_task = "t2va"
+
+        if input_reference_image is not None:
             image_filename = "image.png"  # Required for multipart form
             form.add_field(
                 "input_reference",
-                image_tensor_to_png_bytes(image, image_filename),
+                image_tensor_to_png_bytes(input_reference_image, image_filename),
                 filename=image_filename,
                 content_type="image/png",
             )
 
+        if audio_reference is not None:
+            form.add_field(
+                "audio_reference",
+                json.dumps({"audio_url": audio_to_base64(audio_reference)}, ensure_ascii=False),
+            )
+
+        for idx, video in enumerate(reference_videos, start=1):
+            video_filename = f"reference_{idx}.mp4"
+            form.add_field(
+                "input_references",
+                video_to_bytes(video, video_filename),
+                filename=video_filename,
+                content_type="video/mp4",
+            )
+
+        # === model specific params. Either use a specialized builder, or add flattened fields as-is ===
+        if model_params is not None:
+            model_params = dict(model_params)
+            model_params.pop("type", None)
+
+        spec, _ = lookup_model_spec(model)
+        params_builder = spec.get("params_builder") if spec else None
+        if params_builder is not None:
+            form_fields = params_builder(
+                model_params or {},
+                extra_params={**extra_params, "task": video_task},
+            )
+            for k, v in form_fields.items():
+                form.add_field(k, v if isinstance(v, str) else str(v))
+        else:
+            if model_params is not None:
+                for k, v in model_params.items():
+                    form.add_field(k, str(v))
+            if extra_params:
+                form.add_field("extra_params", json.dumps(extra_params, ensure_ascii=False))
+
         async with aiohttp.ClientSession(timeout=self.timeout) as session:
             # Start the video generation job
             url = f"{self.base_url}/videos"
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
index bfeddd82b..3a37db16d 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
@@ -1,7 +1,12 @@
+import json
 import re
+from typing import Any
 
+from .logger import get_logger
 from .types import Modality, ModelMode, Spec
 
+logger = get_logger(__name__)
+
 
 def _bagel_payload_preprocessor(payload: dict) -> dict:
     try:
@@ -29,6 +34,30 @@ def _qwen25_payload_preprocessor(payload: dict) -> dict:
     return payload
 
 
+def _minimaxh3_params_builder(
+    model_params: dict[str, Any],
+    *,
+    extra_params: dict[str, Any],
+) -> dict[str, Any]:
+    """Build multipart form fields for MiniMax-H3 from model_params + routed task."""
+    params = dict(model_params)
+    params.pop("type", None)
+    form_fields: dict[str, Any] = {}
+    merged_extra_params: dict[str, Any] = dict(extra_params or {})
+
+    if "flow_shift" in params:
+        form_fields["flow_shift"] = params.pop("flow_shift")
+    for key in ("audio_flow_shift",):
+        if key in params:
+            merged_extra_params[key] = params.pop(key)
+    if params:
+        logger.warning("Unused MiniMax-H3 model params ignored: %s", sorted(params))
+
+    if merged_extra_params:
+        form_fields["extra_params"] = json.dumps(merged_extra_params, ensure_ascii=False)
+    return form_fields
+
+
 _MODEL_PIPELINE_SPECS: dict[str, Spec] = {
     r"BAGEL-7B-MoT": {
         "stages": [
@@ -71,6 +100,21 @@ _MODEL_PIPELINE_SPECS: dict[str, Spec] = {
             }
         ],
     },
+    r"MiniMax-H3(/FL2VA|/Ref2VA)?": {
+        "stages": ["diffusion"],
+        "modes": [
+            {
+                "mode": ModelMode.VIDEO_GENERATION,
+                "input_modalities": [
+                    Modality.TEXT,
+                    Modality.IMAGE,
+                    Modality.VIDEO,
+                    Modality.AUDIO,
+                ],
+            }
+        ],
+        "params_builder": _minimaxh3_params_builder,
+    },
 }
 # Convert dict keys to regex patterns
 MODEL_PIPELINE_SPECS: dict[re.Pattern, Spec] = {}
@@ -80,12 +124,10 @@ del _MODEL_PIPELINE_SPECS
 
 
 def lookup_model_spec(model: str) -> tuple[Spec | None, str | None]:
-    try:
-        last_component = model.rstrip("/").rsplit("/", 1)[-1]
-    except IndexError:
-        last_component = model
+    normalized = model.rstrip("/").lstrip("/")
+    lookup_key = normalized.split("/", 1)[-1]
     for pattern, spec in MODEL_PIPELINE_SPECS.items():
-        if pattern.search(last_component):
+        if pattern.search(lookup_key):
             return spec, pattern.pattern
     return None, None
 
@@ -101,6 +143,9 @@ if __name__ == "__main__":
         "Qwen/Qwen3-Omni-30B-A3B-Instruct",
         "Custom/Path/UnknownModel-Instruct",
         "Not/Matching/Anything",
+        "/path/to/MiniMax-H3/FL2VA",
+        "/path/to/MiniMax-H3/Ref2VA",
+        "MiniMaxAI/MiniMax-H3",
     ]
 
     test_payload = {"messages": [{"role": "user", "content": "prompt"}]}
@@ -112,7 +157,13 @@ if __name__ == "__main__":
             if preprocessor := spec.get("payload_preprocessor"):
                 result = preprocessor(test_payload)
                 print(f"✓ {path:<40} → {result}")
+            elif params_builder := spec.get("params_builder"):
+                result = params_builder(
+                    {"audio_flow_shift": 3.0, "flow_shift": 12.0, "type": "minimax_h3"},
+                    extra_params={"task": "t2va"},
+                )
+                print(f"✓ {path:<40} → {result}")
             else:
-                print(f"✓ {path:<40} → No preprocessor")
+                print(f"✓ {path:<40} → No preprocessor/params_builder")
         else:
             print(f"✗ {path:<40} → No match")
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
index c7d254eb9..e1ae43916 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
@@ -1,12 +1,8 @@
 from collections.abc import Callable
 from enum import Enum, auto
-from typing import (
-    Any,
-    Literal,
-    NotRequired,
-    TypeAlias,
-    TypedDict,
-)
+from typing import Any, Literal, TypeAlias
+
+from typing_extensions import NotRequired, TypedDict
 
 AudioFormat: TypeAlias = Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
 
@@ -27,6 +23,14 @@ class WanModelSpecificParams(dict):
     pass
 
 
+class MiniMaxH3ModelSpecificParams(dict):
+    pass
+
+
+class VideoReferences(dict):
+    pass
+
+
 class ModelMode(Enum):
     IMAGE_GENERATION = auto()
     VIDEO_GENERATION = auto()
@@ -47,9 +51,11 @@ class ModelModeSpec(TypedDict):
 
 
 PayloadPreprocessor: TypeAlias = Callable[[dict[str, Any]], dict[str, Any]]
+ParamsBuilder: TypeAlias = Callable[..., dict[str, Any]]
 
 
 class Spec(TypedDict):
     stages: list[Literal["diffusion", "autoregression"]]
     modes: list[ModelModeSpec]
     payload_preprocessor: NotRequired[PayloadPreprocessor]
+    params_builder: NotRequired[ParamsBuilder]
diff --git a/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-video-generation.jpg b/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-video-generation.jpg
index a449a4eee..35a28bd5d 100644
Binary files a/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-video-generation.jpg and b/apps/ComfyUI-vLLM-Omni/docs/images/comfyui-video-generation.jpg differ
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json
index 636360ab8..9785845a5 100644
--- a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json	
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json	
@@ -1,513 +1 @@
-{
-    "id": "3aea1d08-7de5-4997-ba71-b2f66ad72a21",
-    "revision": 0,
-    "last_node_id": 14,
-    "last_link_id": 28,
-    "nodes": [
-        {
-            "id": 10,
-            "type": "MarkdownNote",
-            "pos": [
-                227.99306819575278,
-                -231.24143306069843
-            ],
-            "size": [
-                240.3326478922474,
-                136.3505820791881
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [],
-            "outputs": [],
-            "title": "Note: Task and Input",
-            "properties": {},
-            "widgets_values": [
-                "vLLM-Omni nodes are categorized based on the output modality. The \"Generate Video\" node supports both text-to-video generation and image-to-video generation. The node will create corresponding payload depending on whether an input image is present or not."
-            ],
-            "color": "#432",
-            "bgcolor": "#000"
-        },
-        {
-            "id": 4,
-            "type": "LoadImage",
-            "pos": [
-                496.31859627609606,
-                -229.71277089860084
-            ],
-            "size": [
-                270,
-                314
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-                {
-                    "localized_name": "image",
-                    "name": "image",
-                    "type": "COMBO",
-                    "widget": {
-                        "name": "image"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "choose file to upload",
-                    "name": "upload",
-                    "type": "IMAGEUPLOAD",
-                    "widget": {
-                        "name": "upload"
-                    },
-                    "link": null
-                }
-            ],
-            "outputs": [
-                {
-                    "localized_name": "IMAGE",
-                    "name": "IMAGE",
-                    "type": "IMAGE",
-                    "links": [
-                        25
-                    ]
-                },
-                {
-                    "localized_name": "MASK",
-                    "name": "MASK",
-                    "type": "MASK",
-                    "links": null
-                }
-            ],
-            "properties": {
-                "Node name for S&R": "LoadImage"
-            },
-            "widgets_values": [
-                "cute-cat.jpg",
-                "image"
-            ]
-        },
-        {
-            "id": 8,
-            "type": "VLLMOmniDiffusionSampling",
-            "pos": [
-                465.5140218220927,
-                148.80072646828987
-            ],
-            "size": [
-                284.205078125,
-                226
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-                {
-                    "localized_name": "n",
-                    "name": "n",
-                    "type": "INT",
-                    "widget": {
-                        "name": "n"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "num_inference_steps",
-                    "name": "num_inference_steps",
-                    "type": "INT",
-                    "widget": {
-                        "name": "num_inference_steps"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "guidance_scale",
-                    "name": "guidance_scale",
-                    "type": "FLOAT",
-                    "widget": {
-                        "name": "guidance_scale"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "true_cfg_scale",
-                    "name": "true_cfg_scale",
-                    "type": "FLOAT",
-                    "widget": {
-                        "name": "true_cfg_scale"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "vae_use_slicing",
-                    "name": "vae_use_slicing",
-                    "type": "BOOLEAN",
-                    "widget": {
-                        "name": "vae_use_slicing"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "vae_use_tiling",
-                    "name": "vae_use_tiling",
-                    "type": "BOOLEAN",
-                    "widget": {
-                        "name": "vae_use_tiling"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "seed",
-                    "name": "seed",
-                    "type": "INT",
-                    "widget": {
-                        "name": "seed"
-                    },
-                    "link": null
-                }
-            ],
-            "outputs": [
-                {
-                    "localized_name": "diffusion sampling params",
-                    "name": "diffusion sampling params",
-                    "type": "SAMPLING_PARAMS",
-                    "links": [
-                        27
-                    ]
-                }
-            ],
-            "properties": {
-                "Node name for S&R": "VLLMOmniDiffusionSampling"
-            },
-            "widgets_values": [
-                1,
-                50,
-                1,
-                1,
-                false,
-                false,
-                1992,
-                "randomize"
-            ]
-        },
-        {
-            "id": 14,
-            "type": "VLLMOmniWanParams",
-            "pos": [
-                518.6005521845747,
-                428.4455663719664
-            ],
-            "size": [
-                270,
-                106
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-                {
-                    "localized_name": "guidance_scale_2",
-                    "name": "guidance_scale_2",
-                    "type": "FLOAT",
-                    "widget": {
-                        "name": "guidance_scale_2"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "boundary_ratio",
-                    "name": "boundary_ratio",
-                    "type": "FLOAT",
-                    "widget": {
-                        "name": "boundary_ratio"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "flow_shift",
-                    "name": "flow_shift",
-                    "type": "FLOAT",
-                    "widget": {
-                        "name": "flow_shift"
-                    },
-                    "link": null
-                }
-            ],
-            "outputs": [
-                {
-                    "localized_name": "Wan video params",
-                    "name": "Wan video params",
-                    "type": "VIDEO_PARAMS",
-                    "links": [
-                        28
-                    ]
-                }
-            ],
-            "properties": {
-                "Node name for S&R": "VLLMOmniWanParams"
-            },
-            "widgets_values": [
-                4,
-                0.875,
-                5
-            ]
-        },
-        {
-            "id": 12,
-            "type": "VLLMOmniGenerateVideo",
-            "pos": [
-                827.2566336087867,
-                -73.77449831827545
-            ],
-            "size": [
-                400,
-                346
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-                {
-                    "localized_name": "image",
-                    "name": "image",
-                    "shape": 7,
-                    "type": "IMAGE",
-                    "link": 25
-                },
-                {
-                    "localized_name": "sampling_params",
-                    "name": "sampling_params",
-                    "shape": 7,
-                    "type": "SAMPLING_PARAMS",
-                    "link": 27
-                },
-                {
-                    "localized_name": "lora",
-                    "name": "lora",
-                    "shape": 7,
-                    "type": "REMOTE_LORA",
-                    "link": null
-                },
-                {
-                    "localized_name": "model_params",
-                    "name": "model_params",
-                    "shape": 7,
-                    "type": "VIDEO_PARAMS",
-                    "link": 28
-                },
-                {
-                    "localized_name": "url",
-                    "name": "url",
-                    "type": "STRING",
-                    "widget": {
-                        "name": "url"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "model",
-                    "name": "model",
-                    "type": "STRING",
-                    "widget": {
-                        "name": "model"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "prompt",
-                    "name": "prompt",
-                    "type": "STRING",
-                    "widget": {
-                        "name": "prompt"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "negative_prompt",
-                    "name": "negative_prompt",
-                    "type": "STRING",
-                    "widget": {
-                        "name": "negative_prompt"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "width",
-                    "name": "width",
-                    "type": "INT",
-                    "widget": {
-                        "name": "width"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "height",
-                    "name": "height",
-                    "type": "INT",
-                    "widget": {
-                        "name": "height"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "fps",
-                    "name": "fps",
-                    "type": "INT",
-                    "widget": {
-                        "name": "fps"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "num_frames",
-                    "name": "num_frames",
-                    "type": "INT",
-                    "widget": {
-                        "name": "num_frames"
-                    },
-                    "link": null
-                }
-            ],
-            "outputs": [
-                {
-                    "localized_name": "video",
-                    "name": "video",
-                    "type": "VIDEO",
-                    "links": [
-                        26
-                    ]
-                }
-            ],
-            "properties": {
-                "Node name for S&R": "VLLMOmniGenerateVideo"
-            },
-            "widgets_values": [
-                "http://localhost:8000/v1",
-                "Wan-AI/Wan2.2-TI2V-5B-Diffusers",
-                "Make the cat in the attached video yawning. Eye closed and mouth wide open. Keep the original realistic style.",
-                "Cartoonish",
-                900,
-                1200,
-                12,
-                41
-            ]
-        },
-        {
-            "id": 13,
-            "type": "SaveVideo",
-            "pos": [
-                1257.5441369501657,
-                -44.12956394419863
-            ],
-            "size": [
-                374,
-                372.34896826553796
-            ],
-            "flags": {},
-            "order": 5,
-            "mode": 0,
-            "inputs": [
-                {
-                    "localized_name": "video",
-                    "name": "video",
-                    "type": "VIDEO",
-                    "link": 26
-                },
-                {
-                    "localized_name": "filename_prefix",
-                    "name": "filename_prefix",
-                    "type": "STRING",
-                    "widget": {
-                        "name": "filename_prefix"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "format",
-                    "name": "format",
-                    "type": "COMBO",
-                    "widget": {
-                        "name": "format"
-                    },
-                    "link": null
-                },
-                {
-                    "localized_name": "codec",
-                    "name": "codec",
-                    "type": "COMBO",
-                    "widget": {
-                        "name": "codec"
-                    },
-                    "link": null
-                }
-            ],
-            "outputs": [],
-            "properties": {},
-            "widgets_values": [
-                "video/ComfyUI",
-                "auto",
-                "auto"
-            ]
-        }
-    ],
-    "links": [
-        [
-            25,
-            4,
-            0,
-            12,
-            0,
-            "IMAGE"
-        ],
-        [
-            26,
-            12,
-            0,
-            13,
-            0,
-            "VIDEO"
-        ],
-        [
-            27,
-            8,
-            0,
-            12,
-            1,
-            "SAMPLING_PARAMS"
-        ],
-        [
-            28,
-            14,
-            0,
-            12,
-            3,
-            "VIDEO_PARAMS"
-        ]
-    ],
-    "groups": [
-        {
-            "id": 1,
-            "title": "Input",
-            "bounding": [
-                213.1706010087147,
-                -313.20095750667554,
-                560.8246471437027,
-                407.4246532472182
-            ],
-            "color": "#3f789e",
-            "font_size": 24,
-            "flags": {}
-        }
-    ],
-    "config": {},
-    "extra": {
-        "workflowRendererVersion": "LG",
-        "ds": {
-            "scale": 1.1469075819486894,
-            "offset": [
-                101.7632950847089,
-                492.29121889347806
-            ]
-        }
-    },
-    "version": 0.4
-}
+{"id":"3aea1d08-7de5-4997-ba71-b2f66ad72a21","revision":0,"last_node_id":24,"last_link_id":35,"nodes":[{"id":13,"type":"SaveVideo","pos":[1315.729153459605,-137.92038948394355],"size":[374,313.7692307692308],"flags":{},"order":9,"mode":0,"inputs":[{"localized_name":"video","name":"video","type":"VIDEO","link":32},{"localized_name":"filename_prefix","name":"filename_prefix","type":"STRING","widget":{"name":"filename_prefix"},"link":null},{"localized_name":"format","name":"format","type":"COMBO","widget":{"name":"format"},"link":null},{"localized_name":"codec","name":"codec","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"codec"},"link":null}],"outputs":[{"localized_name":"video","name":"video","type":"VIDEO","links":null}],"properties":{},"widgets_values":["video/ComfyUI","auto","auto"]},{"id":10,"type":"MarkdownNote","pos":[183.74636797766794,-571.2529158046766],"size":[240.3326478922474,136.3505820791881],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[],"title":"Note: Task and Input","properties":{},"widgets_values":["vLLM-Omni nodes are categorized based on the output modality. The \"Generate Video\" node supports both *text-to-video*, *frame-to-video*, and *reference-to-video* generation. The node will create corresponding payload depending on whether an input image is present or not."],"color":"#432","bgcolor":"#000"},{"id":4,"type":"LoadImage","pos":[452.07189605801125,-569.7242536425791],"size":[270,314],"flags":{},"order":1,"mode":0,"inputs":[{"localized_name":"image","name":"image","type":"COMBO","widget":{"name":"image"},"link":null},{"localized_name":"choose file to upload","name":"upload","type":"IMAGEUPLOAD","widget":{"name":"upload"},"link":null}],"outputs":[{"localized_name":"IMAGE","name":"IMAGE","type":"IMAGE","links":[29]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["rap.png","image"]},{"id":23,"type":"LoadImage","pos":[9.206110246057657,-7.6955291509170785],"size":[270,314],"flags":{},"order":2,"mode":0,"inputs":[{"localized_name":"image","name":"image","type":"COMBO","widget":{"name":"image"},"link":null},{"localized_name":"choose file to upload","name":"upload","type":"IMAGEUPLOAD","widget":{"name":"upload"},"link":null}],"outputs":[{"localized_name":"IMAGE","name":"IMAGE","type":"IMAGE","links":[34]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["white-cat.jpg","image"]},{"id":22,"type":"MarkdownNote","pos":[-9.783113411416666,-148.8790300038605],"size":[297.3012007349086,88],"flags":{},"order":3,"mode":0,"inputs":[],"outputs":[],"title":"Note: Reference to video (r2v)","properties":{},"widgets_values":["For r2v tasks, connect this Video Reference block to the main Generate Video block. Then disconnect the \"frame\" input above."],"color":"#432","bgcolor":"#000"},{"id":24,"type":"LoadAudio","pos":[317.9929742385805,-141.44821500065095],"size":[282.798828125,136],"flags":{},"order":4,"mode":0,"inputs":[{"localized_name":"audio","name":"audio","type":"COMBO","widget":{"name":"audio"},"link":null},{"localized_name":"audioUI","name":"audioUI","type":"AUDIO_UI","widget":{"name":"audioUI"},"link":null},{"localized_name":"choose file to upload","name":"upload","type":"AUDIOUPLOAD","widget":{"name":"upload"},"link":null}],"outputs":[{"localized_name":"AUDIO","name":"AUDIO","type":"AUDIO","links":[35]}],"properties":{"Node name for S&R":"LoadAudio"},"widgets_values":["nothing-beats-a-jet2-holiday.mp3",null,""]},{"id":21,"type":"VLLMOmniVideoReferences","pos":[376.6129172897595,105.41557277556292],"size":[156.9380859375,126],"flags":{},"order":7,"mode":0,"inputs":[{"localized_name":"image_1","name":"image_1","shape":7,"type":"IMAGE","link":34},{"localized_name":"image_2","name":"image_2","shape":7,"type":"IMAGE","link":null},{"localized_name":"audio_1","name":"audio_1","shape":7,"type":"AUDIO","link":35},{"localized_name":"audio_2","name":"audio_2","shape":7,"type":"AUDIO","link":null},{"localized_name":"video_1","name":"video_1","shape":7,"type":"VIDEO","link":null},{"localized_name":"video_2","name":"video_2","shape":7,"type":"VIDEO","link":null}],"outputs":[{"localized_name":"references","name":"references","type":"VIDEO_REFERENCES","links":null}],"properties":{"Node name for S&R":"VLLMOmniVideoReferences"},"widgets_values":[]},{"id":8,"type":"VLLMOmniDiffusionSampling","pos":[83.24620208113915,422.08543477542605],"size":[284.205078125,226],"flags":{},"order":5,"mode":0,"inputs":[{"localized_name":"n","name":"n","type":"INT","widget":{"name":"n"},"link":null},{"localized_name":"num_inference_steps","name":"num_inference_steps","type":"INT","widget":{"name":"num_inference_steps"},"link":null},{"localized_name":"guidance_scale","name":"guidance_scale","type":"FLOAT","widget":{"name":"guidance_scale"},"link":null},{"localized_name":"true_cfg_scale","name":"true_cfg_scale","type":"FLOAT","widget":{"name":"true_cfg_scale"},"link":null},{"localized_name":"vae_use_slicing","name":"vae_use_slicing","type":"BOOLEAN","widget":{"name":"vae_use_slicing"},"link":null},{"localized_name":"vae_use_tiling","name":"vae_use_tiling","type":"BOOLEAN","widget":{"name":"vae_use_tiling"},"link":null},{"localized_name":"seed","name":"seed","type":"INT","widget":{"name":"seed"},"link":null}],"outputs":[{"localized_name":"diffusion sampling params","name":"diffusion sampling params","type":"SAMPLING_PARAMS","links":[30]}],"properties":{"Node name for S&R":"VLLMOmniDiffusionSampling"},"widgets_values":[1,50,1,1,false,false,213,"randomize"]},{"id":18,"type":"VLLMOmniMiniMaxH3Params","pos":[483.0944676363692,426.7197881452892],"size":[276.56796875,82],"flags":{},"order":6,"mode":0,"inputs":[{"localized_name":"audio_flow_shift","name":"audio_flow_shift","type":"FLOAT","widget":{"name":"audio_flow_shift"},"link":null},{"localized_name":"flow_shift","name":"flow_shift","type":"FLOAT","widget":{"name":"flow_shift"},"link":null}],"outputs":[{"localized_name":"MiniMax-H3 video params","name":"MiniMax-H3 video params","type":"VIDEO_PARAMS","links":[33]}],"properties":{"Node name for S&R":"VLLMOmniMiniMaxH3Params"},"widgets_values":[3,12]},{"id":16,"type":"VLLMOmniGenerateVideo","pos":[826.1428043381621,-148.53719710697413],"size":[425.5948726785682,551.767376721426],"flags":{},"order":8,"mode":0,"inputs":[{"localized_name":"frame","name":"frame","shape":7,"type":"IMAGE","link":29},{"localized_name":"references","name":"references","shape":7,"type":"VIDEO_REFERENCES","link":null},{"localized_name":"sampling_params","name":"sampling_params","shape":7,"type":"SAMPLING_PARAMS","link":30},{"localized_name":"lora","name":"lora","shape":7,"type":"REMOTE_LORA","link":null},{"localized_name":"model_params","name":"model_params","shape":7,"type":"VIDEO_PARAMS","link":33},{"localized_name":"url","name":"url","type":"STRING","widget":{"name":"url"},"link":null},{"localized_name":"model","name":"model","type":"STRING","widget":{"name":"model"},"link":null},{"localized_name":"prompt","name":"prompt","type":"STRING","widget":{"name":"prompt"},"link":null},{"localized_name":"negative_prompt","name":"negative_prompt","type":"STRING","widget":{"name":"negative_prompt"},"link":null},{"localized_name":"width","name":"width","type":"INT","widget":{"name":"width"},"link":null},{"localized_name":"height","name":"height","type":"INT","widget":{"name":"height"},"link":null},{"localized_name":"fps","name":"fps","type":"INT","widget":{"name":"fps"},"link":null},{"localized_name":"num_frames","name":"num_frames","type":"INT","widget":{"name":"num_frames"},"link":null}],"outputs":[{"localized_name":"video","name":"video","type":"VIDEO","links":[32]}],"properties":{"Node name for S&R":"VLLMOmniGenerateVideo"},"widgets_values":["http://localhost:8000/v1","/workspace/models/hub/models--MiniMaxAI--MiniMax-H3/snapshots/428986c4aa5280855b9ac26eff8d1a46b5999cd0/FL2VA","A scene of urban fantasy art. A dynamic graffiti art character. A boy made of spray paint comes to life on a concrete wall. He sings an English rap song at high speed while striking a classic, energetic rapper pose. The scene is set under an urban railway bridge at night. The light comes from a single street lamp, creating a cinematic atmosphere full of high energy and amazing detail. The audio of the video consists entirely of the rap, with no other dialogue or noise.","",832,480,24,120]}],"links":[[29,4,0,16,0,"IMAGE"],[30,8,0,16,2,"SAMPLING_PARAMS"],[32,16,0,13,0,"VIDEO"],[33,18,0,16,4,"VIDEO_PARAMS"],[34,23,0,21,0,"IMAGE"],[35,24,0,21,2,"AUDIO"]],"groups":[{"id":1,"title":"Image-to-video input (first-frame-to-video)","bounding":[168.92390079062986,-653.2124402506535,560.8246471437027,407.4246532472182],"color":"#3f789e","flags":{}},{"id":2,"title":"Reference-to-video input","bounding":[-66.75175444110151,-225.24978633666066,805.4597228678848,554.7384400819777],"color":"#3f789e","flags":{}}],"config":{},"extra":{"workflowRendererVersion":"LG","ds":{"scale":0.8,"offset":[1240.4751945653188,770.6151743053379]}},"version":0.4}
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 37a6264a9..0a8fb8058 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -28,6 +28,14 @@ Benchmarks for GLM-Image performance across HuggingFace baseline, vLLM-Omni offl
 - **Tasks**: text-to-image and image-to-image
 - **Key metrics**: request/image throughput, latency percentiles, optional per-stage pipeline timings
 
+### [LingBot-Video](lingbot_video/README.md) — Dense and MoE Parity
+
+Manual cross-runtime validation for the dense LingBot-Video pipeline and the
+LingBot-Video MoE transformer.
+
+- **Dense pipeline**: decoded-video MAE, MSE, PSNR, latency, and optional steady-state timings
+- **MoE transformer**: bitwise router, sparse-block, shared-expert, and full-transformer parity
+
 ### [Distributed](distributed/omni_connectors/README.md) — RDMA Connector Testing
 
 RDMA environment setup and transfer tests for `MooncakeTransferEngineConnector`, including pytest-based single-node checks and manual cross-node benchmarks.
diff --git a/benchmarks/diffusion/backends.py b/benchmarks/diffusion/backends.py
index f8ad1a71e..aeff3ebbb 100644
--- a/benchmarks/diffusion/backends.py
+++ b/benchmarks/diffusion/backends.py
@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import json
 import mimetypes
 import os
 import time
@@ -13,6 +14,17 @@ from tqdm import tqdm
 DEFAULT_EDITS_BOT_TASK = "think"
 
 
+def _is_minimax_h3_mixed_reference(model: str) -> bool:
+    """MiniMax-H3 Ref2VA consumes reference videos as file paths.
+
+    Its reference preparer ffprobes / ffmpegs the reference file, so single
+    ``video_reference`` uploads are sent as a base64 data URL: the server
+    persists them to disk and keeps ``source_path``, handing the pipeline a
+    real file path instead of a decoded frame list.
+    """
+    return "MiniMax-H3" in (model or "")
+
+
 @dataclass
 class RequestFuncInput:
     prompt: str
@@ -355,13 +367,21 @@ async def async_request_v1_videos(
         )
     elif input.video_paths and len(input.video_paths) > 0:
         video_path = input.video_paths[0]
-        image_file = open(video_path, "rb")
-        form.add_field(
-            "input_reference",
-            image_file,
-            filename=os.path.basename(video_path),
-            content_type=_guess_mime_type(video_path),
-        )
+        if _is_minimax_h3_mixed_reference(input.model):
+            with open(video_path, "rb") as reference_file:
+                video_b64 = base64.b64encode(reference_file.read()).decode("ascii")
+            form.add_field(
+                "video_reference",
+                json.dumps([{"video_url": f"data:video/mp4;base64,{video_b64}"}]),
+            )
+        else:
+            image_file = open(video_path, "rb")
+            form.add_field(
+                "input_reference",
+                image_file,
+                filename=os.path.basename(video_path),
+                content_type=_guess_mime_type(video_path),
+            )
 
     job_id = None
     job_status = None
diff --git a/benchmarks/diffusion/diffusion_benchmark_serving.py b/benchmarks/diffusion/diffusion_benchmark_serving.py
index 8f7a02858..6daac9df4 100644
--- a/benchmarks/diffusion/diffusion_benchmark_serving.py
+++ b/benchmarks/diffusion/diffusion_benchmark_serving.py
@@ -858,7 +858,12 @@ class RandomDataset(BaseDataset):
             height = int(self.args.height or profile.get("height") or 720)
             num_frames = int(self.args.num_frames or profile.get("num_frames") or 16)
             fps = float(self.args.fps or profile.get("fps") or 8)
-            writer = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height))
+            # cv2 typically writes MPEG-4 Part 2 (``mp4v``), which pipelines such
+            # as MiniMax-H3 Ref2VA reject because they require H.264/H.265
+            # reference videos. Write the synthetic clip first, then re-encode
+            # it to H.264 when ffmpeg is available; otherwise keep ``mp4v``.
+            raw_path = video_path + ".raw.mp4"
+            writer = cv2.VideoWriter(raw_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height))
             if not writer.isOpened():
                 raise RuntimeError("cv2.VideoWriter failed to open")
             for frame_idx in range(num_frames):
@@ -871,6 +876,10 @@ class RandomDataset(BaseDataset):
                 frame[max(y - 36, 0) : min(y + 36, height), x : min(x + 96, width), :] = (64, 128, 220)
                 writer.write(frame)
             writer.release()
+            if _reencode_video_to_h264(raw_path, video_path):
+                os.unlink(raw_path)
+            else:
+                os.replace(raw_path, video_path)
             return [video_path]
         except Exception as e:
             raise RuntimeError(
@@ -878,6 +887,40 @@ class RandomDataset(BaseDataset):
             ) from e
 
 
+def _reencode_video_to_h264(source: str, destination: str) -> bool:
+    """Re-encode a video to H.264/MP4 using ffmpeg when available.
+
+    Returns False when ffmpeg is missing or the re-encode fails so callers can
+    fall back to the original container/codec.
+    """
+    import shutil
+    import subprocess
+
+    if shutil.which("ffmpeg") is None:
+        return False
+    try:
+        result = subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-loglevel",
+                "error",
+                "-i",
+                source,
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                destination,
+            ],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0 and os.path.exists(destination)
+    except Exception:
+        return False
+
+
 def _compute_expected_latency_ms_from_base(req: RequestFuncInput, args, base_time_ms: float | None) -> float | None:
     """Compute expected execution time (ms) based on a base per-step-per-frame unit time.
 
diff --git a/benchmarks/lingbot_video/README.md b/benchmarks/lingbot_video/README.md
new file mode 100644
index 000000000..687973659
--- /dev/null
+++ b/benchmarks/lingbot_video/README.md
@@ -0,0 +1,62 @@
+# LingBot-Video Benchmarks
+
+These manual benchmarks compare the upstream LingBot-Video implementation with
+vLLM-Omni. Run all commands from the repository root.
+
+| Benchmark | Script | Purpose |
+|-----------|--------|---------|
+| Dense pipeline parity | `dense_pipeline_parity.py` | Compare generated videos and report MAE, MSE, PSNR, latency, and optional steady-state timings |
+| MoE numerical parity | `moe_transformer_parity.py` | Check bitwise parity for the sparse MoE block and the full MoE transformer |
+
+Both benchmarks require a local LingBot-Video checkout and local model files.
+They do not run in CI.
+
+## Dense pipeline parity
+
+The dense benchmark launches the upstream Diffusers inference script and the
+vLLM-Omni offline example with identical prompts and sampling parameters. It
+then compares the decoded MP4 frames.
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python benchmarks/lingbot_video/dense_pipeline_parity.py \
+  --model /path/to/lingbot-video-dense-1.3b \
+  --official-repo /path/to/lingbot-video \
+  --output-dir /tmp/lingbot_dense_parity
+```
+
+Use `--runs N` to additionally measure repeated in-process vLLM-Omni
+requests. The video comparison reports MAE, MSE, and PSNR; it is an end-to-end
+pipeline diagnostic rather than a bitwise transformer check.
+
+## MoE numerical parity
+
+The lightweight block comparison uses deterministic weights and inputs to
+cover correction-bias routing, group-limited top-k, routed experts, FP32
+scatter-weighted restore, padding masks, and the shared expert.
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python benchmarks/lingbot_video/moe_transformer_parity.py \
+  --scope block \
+  --official-repo /path/to/lingbot-video \
+  --output-json /tmp/lingbot_moe_block_parity.json
+```
+
+The full comparison loads the upstream and vLLM-Omni 30B transformers
+sequentially and compares their output tensors. It requires a CUDA device with
+`torch._grouped_mm` and enough memory for one 30B BF16 transformer.
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python benchmarks/lingbot_video/moe_transformer_parity.py \
+  --scope transformer \
+  --official-repo /path/to/lingbot-video \
+  --model /path/to/lingbot-video-moe-30b-a3b \
+  --output-json /tmp/lingbot_moe_transformer_parity.json
+```
+
+For the correctness oracle, the upstream transformer uses
+`diffusers:_native_math` and vLLM-Omni uses
+`TORCH_SDPA + SDPBackend.MATH`. The command exits with a nonzero status unless
+the selected comparisons are bitwise equal.
diff --git a/benchmarks/lingbot_video/dense_pipeline_parity.py b/benchmarks/lingbot_video/dense_pipeline_parity.py
new file mode 100644
index 000000000..0c0c1d7a0
--- /dev/null
+++ b/benchmarks/lingbot_video/dense_pipeline_parity.py
@@ -0,0 +1,217 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import statistics
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import imageio.v3 as iio
+import numpy as np
+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.platforms import current_omni_platform
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="LingBot dense parity and timing harness.")
+    parser.add_argument("--model", default="/home/models/lingbot-video-dense-1.3b")
+    parser.add_argument("--official-repo", default="/tmp/lingbot-video")
+    parser.add_argument("--output-dir", default="/tmp/lingbot_dense_parity")
+    parser.add_argument("--prompt", default="a robotic arm picks up a red block")
+    parser.add_argument("--height", type=int, default=192)
+    parser.add_argument("--width", type=int, default=320)
+    parser.add_argument("--num-frames", type=int, default=9)
+    parser.add_argument("--steps", type=int, default=2)
+    parser.add_argument("--guidance-scale", type=float, default=3.0)
+    parser.add_argument("--shift", type=float, default=3.0)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--runs", type=int, default=0, help="Optional in-process steady-state native runs.")
+    return parser.parse_args()
+
+
+def _run(cmd: list[str], cwd: Path | None = None) -> tuple[float, str]:
+    start = time.perf_counter()
+    proc = subprocess.run(cmd, cwd=cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    elapsed = time.perf_counter() - start
+    if proc.returncode != 0:
+        print(proc.stdout)
+        raise subprocess.CalledProcessError(proc.returncode, proc.args, output=proc.stdout)
+    return elapsed, proc.stdout
+
+
+def _read_video(path: Path) -> np.ndarray:
+    frames = iio.imread(path, plugin="pyav")
+    if frames.dtype != np.float32:
+        frames = frames.astype(np.float32) / 255.0
+    return frames
+
+
+def _compare(a: np.ndarray, b: np.ndarray) -> dict[str, Any]:
+    if a.shape != b.shape:
+        return {"shape_a": list(a.shape), "shape_b": list(b.shape), "shape_match": False}
+    diff = a - b
+    mse = float(np.mean(diff * diff))
+    mae = float(np.mean(np.abs(diff)))
+    psnr = float("inf") if mse == 0 else float(20.0 * np.log10(1.0 / np.sqrt(mse)))
+    return {
+        "shape": list(a.shape),
+        "shape_match": True,
+        "mae": mae,
+        "mse": mse,
+        "psnr": psnr,
+    }
+
+
+def _extract_total_generation_seconds(log: str) -> float | None:
+    match = re.search(r"Total generation time:\s*([0-9.]+)\s*seconds", log)
+    return float(match.group(1)) if match else None
+
+
+def _peak_memory_mb(output: Any) -> float:
+    result = output[0] if isinstance(output, list) and output else output
+    return float(getattr(result, "peak_memory_mb", 0.0) or 0.0)
+
+
+def _benchmark_native_requests(args: argparse.Namespace) -> dict[str, Any]:
+    load_start = time.perf_counter()
+    omni = Omni(
+        model=args.model,
+        model_class_name="LingBotVideoPipeline",
+        flow_shift=args.shift,
+        parallel_config=DiffusionParallelConfig(),
+    )
+    load_seconds = time.perf_counter() - load_start
+    prompt = {"prompt": args.prompt}
+    latencies: list[float] = []
+    peak_mb = 0.0
+
+    for _ in range(args.runs):
+        generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(args.seed)
+        sampling_params = OmniDiffusionSamplingParams(
+            height=args.height,
+            width=args.width,
+            num_frames=args.num_frames,
+            num_inference_steps=args.steps,
+            guidance_scale=args.guidance_scale,
+            generator=generator,
+            output_type="pt",
+            extra_args={"shift": args.shift},
+        )
+        start = time.perf_counter()
+        output = omni.generate(prompt, sampling_params)
+        latencies.append(time.perf_counter() - start)
+        peak_mb = max(peak_mb, _peak_memory_mb(output))
+        del output
+    omni.close()
+
+    return {
+        "load_seconds": load_seconds,
+        "run_seconds": latencies,
+        "mean_seconds": statistics.mean(latencies) if latencies else None,
+        "median_seconds": statistics.median(latencies) if latencies else None,
+        "min_seconds": min(latencies) if latencies else None,
+        "max_seconds": max(latencies) if latencies else None,
+        "peak_mb": peak_mb,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    official_out = output_dir / "official_diffusers.mp4"
+    native_out = output_dir / "vllm_omni_native.mp4"
+
+    official_cmd = [
+        sys.executable,
+        str(Path(args.official_repo) / "scripts" / "inference.py"),
+        "--backend",
+        "diffusers",
+        "--model_dir",
+        args.model,
+        "--mode",
+        "t2v",
+        "--prompt",
+        args.prompt,
+        "--output",
+        str(official_out),
+        "--height",
+        str(args.height),
+        "--width",
+        str(args.width),
+        "--num_frames",
+        str(args.num_frames),
+        "--steps",
+        str(args.steps),
+        "--guidance_scale",
+        str(args.guidance_scale),
+        "--shift",
+        str(args.shift),
+        "--seed",
+        str(args.seed),
+        "--fps",
+        str(args.fps),
+        "--quiet_progress",
+    ]
+    native_cmd = [
+        sys.executable,
+        "examples/offline_inference/text_to_video/text_to_video_lingbot.py",
+        "--model",
+        args.model,
+        "--prompt",
+        args.prompt,
+        "--output",
+        str(native_out),
+        "--height",
+        str(args.height),
+        "--width",
+        str(args.width),
+        "--num-frames",
+        str(args.num_frames),
+        "--num-inference-steps",
+        str(args.steps),
+        "--guidance-scale",
+        str(args.guidance_scale),
+        "--flow-shift",
+        str(args.shift),
+        "--seed",
+        str(args.seed),
+        "--fps",
+        str(args.fps),
+    ]
+
+    official_time, official_log = _run(official_cmd, cwd=Path(args.official_repo))
+    native_time, native_log = _run(native_cmd, cwd=Path.cwd())
+
+    result = {
+        "official_seconds": official_time,
+        "native_process_seconds": native_time,
+        "native_request_seconds": _extract_total_generation_seconds(native_log),
+        "official_output": str(official_out),
+        "native_output": str(native_out),
+        "accuracy": _compare(_read_video(official_out), _read_video(native_out)),
+        "official_log_tail": official_log.splitlines()[-20:],
+        "native_log_tail": native_log.splitlines()[-20:],
+    }
+    if args.runs > 0:
+        result["native_steady_state"] = _benchmark_native_requests(args)
+
+    result_path = output_dir / "comparison.json"
+    result_path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/lingbot_video/moe_transformer_parity.py b/benchmarks/lingbot_video/moe_transformer_parity.py
new file mode 100644
index 000000000..cdad31f19
--- /dev/null
+++ b/benchmarks/lingbot_video/moe_transformer_parity.py
@@ -0,0 +1,399 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Reproduce LingBot-Video MoE block and transformer numerical parity."""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import importlib
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import torch
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--scope",
+        choices=("block", "transformer", "all"),
+        default="block",
+        help="Run the lightweight sparse-block check, the real transformer check, or both.",
+    )
+    parser.add_argument(
+        "--official-repo",
+        type=Path,
+        required=True,
+        help="Local checkout of https://github.com/Robbyant/lingbot-video.",
+    )
+    parser.add_argument(
+        "--model",
+        default=None,
+        help="Local MoE checkpoint path or a checkpoint already present in the Hugging Face cache.",
+    )
+    parser.add_argument("--transformer-subfolder", default="transformer")
+    parser.add_argument("--output-json", type=Path, default=None)
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--num-frames", type=int, default=1)
+    parser.add_argument("--height", type=int, default=8)
+    parser.add_argument("--width", type=int, default=8)
+    parser.add_argument("--text-length", type=int, default=16)
+    return parser.parse_args()
+
+
+def _load_official_module(official_repo: Path):
+    transformer_file = official_repo / "lingbot_video" / "transformer_lingbot_video.py"
+    if not transformer_file.is_file():
+        raise FileNotFoundError(f"Upstream transformer not found: {transformer_file}")
+    sys.path.insert(0, str(official_repo))
+    module = importlib.import_module("lingbot_video.transformer_lingbot_video")
+    module_path = Path(module.__file__).resolve()
+    if official_repo.resolve() not in module_path.parents:
+        raise RuntimeError(f"Imported LingBot module from {module_path}, not {official_repo.resolve()}")
+    return module
+
+
+def _load_native_module():
+    return importlib.import_module("vllm_omni.diffusion.models.lingbot_video.lingbot_video_transformer")
+
+
+def _tensor_metrics(actual: torch.Tensor, expected: torch.Tensor) -> dict[str, Any]:
+    actual_float = actual.float()
+    expected_float = expected.float()
+    diff = (actual_float - expected_float).abs()
+    denominator = actual_float.norm() * expected_float.norm()
+    cosine = (
+        float(torch.dot(actual_float.flatten(), expected_float.flatten()) / denominator)
+        if float(denominator) > 0
+        else 1.0
+    )
+    return {
+        "shape": list(actual.shape),
+        "equal": bool(torch.equal(actual, expected)),
+        "max_abs": float(diff.max()) if diff.numel() else 0.0,
+        "mean_abs": float(diff.mean()) if diff.numel() else 0.0,
+        "rmse": float(torch.sqrt(torch.mean(diff.square()))) if diff.numel() else 0.0,
+        "cosine": cosine,
+        "finite": bool(torch.isfinite(actual).all() and torch.isfinite(expected).all()),
+    }
+
+
+def _initialize_block(module: torch.nn.Module, seed: int) -> None:
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    with torch.no_grad():
+        for parameter in module.parameters():
+            values = torch.randn(parameter.shape, generator=generator, dtype=torch.float32)
+            parameter.copy_((values * 0.02).to(parameter.dtype))
+        module.router.e_score_correction_bias.copy_(torch.tensor([0.9, 0.8, 1.0, 0.0, 0.7, 0.6, 0.5, 0.4]))
+
+
+def _apply_padding(
+    scores: torch.Tensor,
+    padding_mask: torch.Tensor,
+    route_scale: float,
+) -> torch.Tensor:
+    scores = scores * padding_mask.unsqueeze(-1).to(scores.dtype)
+    scores = scores / (scores.sum(dim=-1, keepdim=True) + 1e-9)
+    return scores * route_scale
+
+
+def _run_block_parity(
+    official_module,
+    native_module,
+    *,
+    device: torch.device,
+    seed: int,
+) -> dict[str, Any]:
+    if not hasattr(torch, "_grouped_mm"):
+        raise RuntimeError("The block parity check requires torch._grouped_mm.")
+
+    common = {
+        "hidden_size": 16,
+        "num_experts": 8,
+        "top_k": 2,
+        "moe_intermediate_size": 8,
+        "score_func": "sigmoid",
+        "norm_topk_prob": True,
+        "n_group": 4,
+        "topk_group": 1,
+        "routed_scaling_factor": 1.5,
+        "n_shared_experts": 1,
+    }
+    official = official_module.LingBotVideoSparseMoeBlock(
+        intermediate_size=32,
+        **common,
+    )
+    native = native_module.LingBotVideoSparseMoeBlock(**common)
+    _initialize_block(official, seed)
+    native.load_state_dict(official.state_dict(), strict=True)
+    official = official.to(device=device, dtype=torch.bfloat16).eval()
+    native = native.to(device=device, dtype=torch.bfloat16).eval()
+
+    generator = torch.Generator(device=device).manual_seed(seed)
+    hidden_states = torch.randn(
+        2,
+        5,
+        common["hidden_size"],
+        generator=generator,
+        device=device,
+        dtype=torch.bfloat16,
+    )
+    padding_mask = torch.tensor(
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+        device=device,
+        dtype=torch.float32,
+    )
+    tokens = hidden_states.reshape(-1, common["hidden_size"])
+
+    with torch.inference_mode():
+        official_router = official.router(tokens)
+        official_indices, official_scores = official_router[:2]
+        native_indices, native_scores = native.router(tokens)
+
+        official_scores = _apply_padding(
+            official_scores,
+            padding_mask,
+            official.router.route_scale,
+        )
+        native_scores = _apply_padding(
+            native_scores,
+            padding_mask,
+            native.router.route_scale,
+        )
+        official_routed = official._run_selected_experts(
+            tokens,
+            official_scores,
+            official_indices,
+        )
+        native_routed = native._run_selected_experts(
+            tokens,
+            native_scores,
+            native_indices,
+        )
+        official_shared = official.shared_experts(hidden_states)
+        native_shared = native.shared_experts(hidden_states)
+        official_output = official(hidden_states, padding_mask=padding_mask)
+        native_output = native(hidden_states, padding_mask=padding_mask)
+
+    result = {
+        "router_indices_equal": bool(torch.equal(native_indices, official_indices)),
+        "router_scores": _tensor_metrics(native_scores, official_scores),
+        "routed_output": _tensor_metrics(native_routed, official_routed),
+        "shared_output": _tensor_metrics(native_shared, official_shared),
+        "final_output": _tensor_metrics(native_output, official_output),
+    }
+    result["exact"] = bool(
+        result["router_indices_equal"]
+        and result["router_scores"]["equal"]
+        and result["routed_output"]["equal"]
+        and result["shared_output"]["equal"]
+        and result["final_output"]["equal"]
+    )
+    return result
+
+
+def _release_cuda() -> None:
+    gc.collect()
+    torch.accelerator.empty_cache()
+    torch.accelerator.synchronize()
+
+
+def _make_transformer_inputs(
+    config,
+    args: argparse.Namespace,
+) -> dict[str, torch.Tensor]:
+    generator = torch.Generator(device="cpu").manual_seed(args.seed)
+    hidden_states = torch.randn(
+        1,
+        int(config.in_channels),
+        args.num_frames,
+        args.height,
+        args.width,
+        generator=generator,
+        dtype=torch.float32,
+    ).to(torch.bfloat16)
+    encoder_hidden_states = torch.randn(
+        1,
+        args.text_length,
+        int(config.text_dim),
+        generator=generator,
+        dtype=torch.float32,
+    ).to(torch.bfloat16)
+    return {
+        "hidden_states": hidden_states,
+        "timestep": torch.tensor([500.0], dtype=torch.float32),
+        "encoder_hidden_states": encoder_hidden_states,
+        "encoder_attention_mask": torch.ones(1, args.text_length, dtype=torch.long),
+    }
+
+
+def _load_transformer(
+    transformer_cls,
+    args: argparse.Namespace,
+    device: torch.device,
+):
+    start = time.perf_counter()
+    model = transformer_cls.from_pretrained(
+        args.model,
+        subfolder=args.transformer_subfolder,
+        torch_dtype=torch.bfloat16,
+        local_files_only=True,
+        low_cpu_mem_usage=True,
+    )
+    model = model.to(device=device, dtype=torch.bfloat16).eval()
+    torch.accelerator.synchronize()
+    return model, time.perf_counter() - start
+
+
+def _forward_transformer(
+    model,
+    inputs: dict[str, torch.Tensor],
+    device: torch.device,
+    attention_context,
+) -> tuple[torch.Tensor, float, float]:
+    torch.accelerator.reset_peak_memory_stats(device)
+    gpu_inputs = {name: value.to(device) for name, value in inputs.items()}
+    start = time.perf_counter()
+    with torch.inference_mode(), attention_context:
+        output = model(**gpu_inputs, return_dict=False)[0]
+    torch.accelerator.synchronize()
+    elapsed = time.perf_counter() - start
+    peak_gib = torch.accelerator.max_memory_reserved(device) / (1024**3)
+    return output.cpu(), elapsed, peak_gib
+
+
+def _run_transformer_parity(
+    official_module,
+    native_module,
+    *,
+    args: argparse.Namespace,
+    device: torch.device,
+) -> dict[str, Any]:
+    if args.model is None:
+        raise ValueError("--model is required for transformer parity.")
+
+    from diffusers.models.attention_dispatch import attention_backend
+    from torch.nn.attention import SDPBackend, sdpa_kernel
+
+    from vllm_omni.diffusion.config import set_current_diffusion_config
+    from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, OmniDiffusionConfig
+
+    official, official_load = _load_transformer(
+        official_module.LingBotVideoTransformer3DModel,
+        args,
+        device,
+    )
+    inputs = _make_transformer_inputs(official.config, args)
+    official_output, official_forward, official_peak = _forward_transformer(
+        official,
+        inputs,
+        device,
+        attention_backend("_native_math"),
+    )
+    del official
+    _release_cuda()
+
+    native_config = OmniDiffusionConfig(
+        diffusion_attention_config=AttentionConfig(
+            default=AttentionSpec(backend="TORCH_SDPA"),
+        ),
+    )
+    with set_current_diffusion_config(native_config):
+        native, native_load = _load_transformer(
+            native_module.LingBotVideoTransformer3DModel,
+            args,
+            device,
+        )
+    native_backend_prefs = {block.attn.attn.backend_pref for block in native.blocks}
+    if native_backend_prefs != {"TORCH_SDPA"}:
+        raise RuntimeError(
+            f"Failed to force the native transformer to TORCH_SDPA: resolved preferences were {native_backend_prefs}."
+        )
+    native_output, native_forward, native_peak = _forward_transformer(
+        native,
+        inputs,
+        device,
+        sdpa_kernel(SDPBackend.MATH),
+    )
+    del native
+    _release_cuda()
+
+    metrics = _tensor_metrics(native_output, official_output)
+    return {
+        "backends": {
+            "official": "diffusers:_native_math",
+            "native": "TORCH_SDPA+SDPBackend.MATH",
+        },
+        "official": {
+            "load_seconds": official_load,
+            "forward_seconds": official_forward,
+            "peak_reserved_gib": official_peak,
+        },
+        "native": {
+            "load_seconds": native_load,
+            "forward_seconds": native_forward,
+            "peak_reserved_gib": native_peak,
+        },
+        "output": metrics,
+        "exact": metrics["equal"],
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    device = torch.device(args.device)
+    if device.type != "cuda" or not torch.cuda.is_available():
+        raise RuntimeError("LingBot MoE parity requires an available CUDA device.")
+
+    os.environ["DIFFUSERS_ATTN_BACKEND"] = "_native_math"
+    os.environ["DIFFUSION_ATTENTION_BACKEND"] = "TORCH_SDPA"
+    os.environ["LINGBOT_MOE_EXPERT_BACKEND"] = "grouped_mm"
+    os.environ["LINGBOT_MOE_PAD_BACKEND"] = "loop"
+    os.environ["LINGBOT_MOE_REORDER_BACKEND"] = "sort"
+    os.environ["LINGBOT_MOE_RESTORE_BACKEND"] = "scatter"
+
+    official_module = _load_official_module(args.official_repo)
+    native_module = _load_native_module()
+
+    result: dict[str, Any] = {
+        "settings": {
+            "scope": args.scope,
+            "seed": args.seed,
+            "device": str(device),
+            "official_repo": str(args.official_repo.resolve()),
+            "model": args.model,
+        }
+    }
+    if args.scope in {"block", "all"}:
+        result["block"] = _run_block_parity(
+            official_module,
+            native_module,
+            device=device,
+            seed=args.seed,
+        )
+    if args.scope in {"transformer", "all"}:
+        result["transformer"] = _run_transformer_parity(
+            official_module,
+            native_module,
+            args=args,
+            device=device,
+        )
+
+    result["exact"] = all(section["exact"] for name, section in result.items() if name in {"block", "transformer"})
+    payload = json.dumps(result, indent=2, sort_keys=True)
+    print(payload)
+    if args.output_json is not None:
+        args.output_json.parent.mkdir(parents=True, exist_ok=True)
+        args.output_json.write_text(payload + "\n", encoding="utf-8")
+    return 0 if result["exact"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/docker/Dockerfile.ci b/docker/Dockerfile.ci
index f4444f8ac..02a7be452 100644
--- a/docker/Dockerfile.ci
+++ b/docker/Dockerfile.ci
@@ -1,12 +1,26 @@
-# Target vllm version: v0.24.0 (releases/v0.24.0 branch).
-# The pinned VLLM_PRECOMPILED_WHEEL_COMMIT and VLLM_BASE_TAG below must
-# be updated on every rebase to match the new upstream vllm commit/tag.
+# Target vllm version: v0.26.0 (releases/v0.26.0 branch).
+# Keep VLLM_BASE_TAG aligned with the target vLLM release on every rebase.
 ARG VLLM_BASE_IMAGE=vllm/vllm-openai
-ARG VLLM_BASE_TAG=v0.25.0
-FROM ${VLLM_BASE_IMAGE}:${VLLM_BASE_TAG}
-ARG APP_DIR=/workspace/vllm-omni
+ARG VLLM_BASE_TAG=v0.26.0
+
+# We use registry-based layer caching for the dependencies,
+# where the tag is determined based on the hash of the contents
+# of files like pyproject.toml, etc. The deps stage should have
+# everything except the actual project dir, since that should not
+# change much across branches.
+FROM ${VLLM_BASE_IMAGE}:${VLLM_BASE_TAG} AS deps
+# Keep APP_DIR outside /workspace so k8s Buildkite workspace mounts cannot
+# shadow the editable install target (#5364). Docker WORKDIR creates /opt if
+# needed.
+ARG APP_DIR=/opt/vllm-omni
 WORKDIR ${APP_DIR}
-COPY . .
+
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+# Placeholder package tree so editable install can register APP_DIR.
+# The final stage COPY --link fills this directory with the real sources;
+# the editable .pth / egg-link keeps resolving imports there — no PYTHONPATH.
+RUN mkdir -p vllm_omni && touch vllm_omni/__init__.py
 
 # Install system dependencies
 RUN apt-get update && \
@@ -14,9 +28,30 @@ RUN apt-get update && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
-RUN uv pip install --system ".[dev]"
+# Copy dependency related things first and install deps/
+# We set the version str to 0.0.0 since it doesn't matter
+# for CI
+COPY pyproject.toml setup.py ./
+COPY requirements/ requirements/
+ENV SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0
+# Editable install: deps + project metadata are cached in this layer, while
+# the package itself is linked to APP_DIR (populated later by COPY --link).
+# Do NOT use a non-editable install here — that copies an empty stub into
+# site-packages and breaks ``import vllm_omni.entrypoints``.
+RUN uv pip install --system -e ".[dev]"
 
+# The final stage just copies the working dir on top of the
+# dependencies image. This uses --link so that we can skip
+# the image pull in Buildkite when we have a cache hit.
+#
+# IMPORTANT: Do not make any modifications that depend on the
+# file system after the --link copy, otherwise we'd need to pull
+# the heavy base image to build it. Editable install above already
+# registered APP_DIR, so we must not re-pip-install after COPY.
+FROM deps
+ARG APP_DIR=/opt/vllm-omni
+WORKDIR ${APP_DIR}
 
-RUN ln -sf /usr/bin/python3 /usr/bin/python
+COPY --link . .
 
 ENTRYPOINT []
diff --git a/docker/Dockerfile.ci.dockerignore b/docker/Dockerfile.ci.dockerignore
new file mode 100644
index 000000000..ab137c2b5
--- /dev/null
+++ b/docker/Dockerfile.ci.dockerignore
@@ -0,0 +1,37 @@
+# NOTE: this is largely taken from vLLM
+
+# Exclude .git for CI builds — version is set via SETUPTOOLS_SCM_PRETEND_VERSION
+.git
+.venv
+/build
+dist
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+.mypy_cache
+
+# Distribution / packaging
+.Python
+/build/
+cmake-build-*/
+CMakeUserPresets.json
+develop-eggs/
+/dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+rust/target/
diff --git a/docker/Dockerfile.cuda b/docker/Dockerfile.cuda
index 4e9075f2a..f2e80eaf3 100644
--- a/docker/Dockerfile.cuda
+++ b/docker/Dockerfile.cuda
@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=vllm/vllm-openai:v0.25.0
+ARG BASE_IMAGE=vllm/vllm-openai:v0.26.0
 FROM ${BASE_IMAGE}
 
 ARG COMMON_WORKDIR=/app
diff --git a/docker/Dockerfile.npu b/docker/Dockerfile.npu
index 642b89882..05a780542 100644
--- a/docker/Dockerfile.npu
+++ b/docker/Dockerfile.npu
@@ -1,5 +1,5 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_TAG=v0.25.0
+ARG VLLM_ASCEND_TAG=v0.26.0
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_TAG}
 
 # WORKDIR /vllm-workspace/vllm
@@ -26,6 +26,10 @@ RUN export PIP_EXTRA_INDEX_URL=https://mirrors.huaweicloud.com/ascend/repos/pypi
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/Ascend/ascend-toolkit/latest/`uname -i`-linux/devlib && \
     python3 -m pip install -v -e /vllm-workspace/vllm-omni/ --no-build-isolation
 
+RUN python3 -m pip install -v --no-deps \
+      "stepaudio2-minicpmo>=0.1.1" \
+      "step-audio2>=1.0.0"
+
 ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
 
 ENTRYPOINT []
diff --git a/docker/Dockerfile.npu.a3 b/docker/Dockerfile.npu.a3
index 4fe1d56fe..d226a505f 100644
--- a/docker/Dockerfile.npu.a3
+++ b/docker/Dockerfile.npu.a3
@@ -1,5 +1,5 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_TAG=v0.25.0-a3
+ARG VLLM_ASCEND_TAG=v0.26.0-a3
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_TAG}
 
 # WORKDIR /vllm-workspace/vllm
@@ -26,6 +26,10 @@ RUN export PIP_EXTRA_INDEX_URL=https://mirrors.huaweicloud.com/ascend/repos/pypi
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/Ascend/ascend-toolkit/latest/`uname -i`-linux/devlib && \
     python3 -m pip install -v -e /vllm-workspace/vllm-omni/ --no-build-isolation
 
+RUN python3 -m pip install -v --no-deps \
+      "stepaudio2-minicpmo>=0.1.1" \
+      "step-audio2>=1.0.0"
+
 ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
 
 ENTRYPOINT []
diff --git a/docker/Dockerfile.npu.ci b/docker/Dockerfile.npu.ci
index f5c3cdfaf..fa2c0d45f 100644
--- a/docker/Dockerfile.npu.ci
+++ b/docker/Dockerfile.npu.ci
@@ -1,11 +1,13 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_TAG=v0.25.0
+ARG VLLM_ASCEND_TAG=v0.26.0
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_TAG}
 
 ARG APP_DIR=/vllm-workspace/vllm-omni
 WORKDIR ${APP_DIR}
 COPY . .
 
+RUN sed -i "s@^\(deb.*\)https\?://[a-z0-9.-]*\.ubuntu\.com@\1http://cache-service.nginx-pypi-cache.svc.cluster.local:8081@g" /etc/apt/sources.list
+
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         ffmpeg \
@@ -33,8 +35,16 @@ RUN source /usr/local/Ascend/ascend-toolkit/set_env.sh && \
       "psutil>=7.2.0" \
       "soundfile>=0.13.1" \
       "pyttsx3>=2.99" \
+      "opencc==1.4.1" \
       "opencv-python>=4.12.0.88" \
       "imageio[ffmpeg]>=0.6.0" \
+      "jiwer>=3.0.0" \
+      "zhon>=2.0.0" \
+      "zhconv>=1.4.2" \
+      "funasr>=1.0.0" \
+      "hyperpyyaml>=1.2.0" \
+      "onnx>=1.16.0" \
+      "librosa>=0.10.0" \
       --index-url http://cache-service.nginx-pypi-cache.svc.cluster.local/pypi/simple \
       --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
       --default-timeout=60 && \
@@ -43,6 +53,17 @@ RUN source /usr/local/Ascend/ascend-toolkit/set_env.sh && \
       --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
       --default-timeout=60
 
+# MiniCPM-o 4.5 Stage-2 vocoder assets: s3tokenizer plus flashcosyvoice, which
+# is shipped by step-audio2. --no-deps keeps pip from replacing the Ascend torch
+# build and from shadowing onnxruntime-cann with the vanilla onnxruntime wheel;
+# the deps these two actually need are installed above.
+RUN python3 -m pip install -v --no-deps \
+      "s3tokenizer>=0.3.0" \
+      "step-audio2>=1.0.0" \
+      --index-url http://cache-service.nginx-pypi-cache.svc.cluster.local/pypi/simple \
+      --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
+      --default-timeout=60
+
 ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
 
 ENTRYPOINT []
diff --git a/docker/Dockerfile.npu.ci.a3 b/docker/Dockerfile.npu.ci.a3
index 6a8ac4678..383eea892 100644
--- a/docker/Dockerfile.npu.ci.a3
+++ b/docker/Dockerfile.npu.ci.a3
@@ -1,11 +1,13 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_TAG=v0.25.0-a3
+ARG VLLM_ASCEND_TAG=v0.26.0-a3
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_TAG}
 
 ARG APP_DIR=/vllm-workspace/vllm-omni
 WORKDIR ${APP_DIR}
 COPY . .
 
+RUN sed -i "s@^\(deb.*\)https\?://[a-z0-9.-]*\.ubuntu\.com@\1http://cache-service.nginx-pypi-cache.svc.cluster.local:8081@g" /etc/apt/sources.list
+
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         ffmpeg \
@@ -33,8 +35,17 @@ RUN source /usr/local/Ascend/ascend-toolkit/set_env.sh && \
       "psutil>=7.2.0" \
       "soundfile>=0.13.1" \
       "pyttsx3>=2.99" \
+      "opencc==1.4.1" \
       "opencv-python>=4.12.0.88" \
       "imageio[ffmpeg]>=0.6.0" \
+      "jiwer>=3.0.0" \
+      "zhon>=2.0.0" \
+      "zhconv>=1.4.2" \
+      "funasr>=1.0.0" \
+      "hyperpyyaml>=1.2.0" \
+      "onnx>=1.16.0" \
+      "librosa>=0.10.0" \
+      "torchmetrics>=1.9.0" \
       --index-url http://cache-service.nginx-pypi-cache.svc.cluster.local/pypi/simple \
       --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
       --default-timeout=60 && \
@@ -43,6 +54,17 @@ RUN source /usr/local/Ascend/ascend-toolkit/set_env.sh && \
       --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
       --default-timeout=60
 
+# MiniCPM-o 4.5 Stage-2 vocoder assets: s3tokenizer plus flashcosyvoice, which
+# is shipped by step-audio2. --no-deps keeps pip from replacing the Ascend torch
+# build and from shadowing onnxruntime-cann with the vanilla onnxruntime wheel;
+# the deps these two actually need are installed above.
+RUN python3 -m pip install -v --no-deps \
+      "s3tokenizer>=0.3.0" \
+      "step-audio2>=1.0.0" \
+      --index-url http://cache-service.nginx-pypi-cache.svc.cluster.local/pypi/simple \
+      --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
+      --default-timeout=60
+
 ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
 
 ENTRYPOINT []
diff --git a/docker/Dockerfile.rocm b/docker/Dockerfile.rocm
index 49c6f02aa..6b5a12309 100644
--- a/docker/Dockerfile.rocm
+++ b/docker/Dockerfile.rocm
@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.25.0
+ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.26.0
 FROM ${BASE_IMAGE} AS base
 
 # Declare a variable to know if we want to use the nightly build or the stable build.
@@ -10,14 +10,14 @@ FROM ${BASE_IMAGE} AS base
 #    we should swap over to use stable release ASAP.
 #    We should avoid relying on custom commits.
 ARG USE_NIGHTLY_BUILD=0
-ARG VLLM_VERSION_OR_COMMIT_HASH=89138b21cc246ae944c741d5c399c148e2b770ab
+ARG VLLM_VERSION_OR_COMMIT_HASH=v0.26.0
 ARG ARG_PYTORCH_ROCM_ARCH
 ENV PYTORCH_ROCM_ARCH=${ARG_PYTORCH_ROCM_ARCH:-${PYTORCH_ROCM_ARCH}}
 
 ARG COMMON_WORKDIR=/app
 WORKDIR ${COMMON_WORKDIR}
 
-# Step 1: Setup - Install system dependencies
+# Step 1: Setup - Install system dependencies.
 # Need to include ffmpeg because vllm rocm upstream docker image
 # does not include it.
 RUN apt-get update && \
@@ -38,6 +38,26 @@ RUN if [ "${USE_NIGHTLY_BUILD}" = "1" ]; then \
         rm -rf vllm/.git; \
     fi
 
+# Build TorchCodec after any optional nightly vLLM reinstall so it targets the
+# final torch/ROCm ABI. Keep this layer before COPY . so source changes do not
+# invalidate the expensive native build. FFmpeg development headers are
+# removed after the wheel is built.
+COPY tools/install_torchcodec_rocm.sh /tmp/install_torchcodec_rocm.sh
+RUN --mount=type=cache,target=/root/.cache/pip \
+    --mount=type=cache,target=/root/.cache/torchcodec-wheels \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+        pkg-config \
+        libavcodec-dev libavformat-dev libavutil-dev \
+        libswscale-dev libavdevice-dev libavfilter-dev libswresample-dev && \
+    bash /tmp/install_torchcodec_rocm.sh && \
+    apt-get purge -y \
+        libavcodec-dev libavformat-dev libavutil-dev \
+        libswscale-dev libavdevice-dev libavfilter-dev libswresample-dev && \
+    rm -f /tmp/install_torchcodec_rocm.sh && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
 # Step 3: Copy vllm-omni code and install without uv
 RUN mkdir -p ${COMMON_WORKDIR}/vllm-omni
 COPY . ${COMMON_WORKDIR}/vllm-omni
@@ -59,7 +79,10 @@ RUN printf '%s\n' \
     '    os._exit(_exit_code)' \
     > ${COMMON_WORKDIR}/vllm-omni/conftest.py
 
-RUN cd ${COMMON_WORKDIR}/vllm-omni && uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" --no-cache-dir ".[dev]" --no-build-isolation
+RUN cd ${COMMON_WORKDIR}/vllm-omni && \
+    uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" \
+        --no-cache-dir ".[dev]" --no-build-isolation && \
+    python3 -c "from torchcodec.decoders import VideoDecoder"
 
 RUN ln -sf /usr/bin/python3 /usr/bin/python
 
diff --git a/docker/Dockerfile.xpu b/docker/Dockerfile.xpu
index b70dd274e..5d298040c 100644
--- a/docker/Dockerfile.xpu
+++ b/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.25.0
+ARG VLLM_VERSION=v0.26.0
 RUN git clone -b ${VLLM_VERSION} https://github.com/vllm-project/vllm
 WORKDIR /workspace/vllm
 
diff --git a/docs/.nav.yml b/docs/.nav.yml
index cd5a83807..fc11bb838 100644
--- a/docs/.nav.yml
+++ b/docs/.nav.yml
@@ -16,13 +16,11 @@ nav:
   - Examples:
     - examples/README.md
     - Offline Inference:
-      - BAGEL-7B-MoT: user_guide/examples/offline_inference/bagel.md
       - GLM-Image Multistage End-to-End Inference: user_guide/examples/offline_inference/glm_image.md
       - HunyuanImage-3.0 Image-to-Text Inference: user_guide/examples/offline_inference/hunyuan_image3.md
       - Image-To-Image: user_guide/examples/offline_inference/image_to_image.md
       - Image-To-Video: user_guide/examples/offline_inference/image_to_video.md
       - InternVLA-A1: user_guide/examples/offline_inference/internvla_a1.md
-      - MammothModa2-Preview: user_guide/examples/offline_inference/mammothmodal2_preview.md
       - MiMo-Audio: user_guide/examples/offline_inference/mimo_audio.md
       - Qwen2.5-Omni: user_guide/examples/offline_inference/qwen2_5_omni.md
       - Qwen3-Omni: user_guide/examples/offline_inference/qwen3_omni.md
@@ -56,6 +54,7 @@ nav:
     - 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
@@ -69,13 +68,12 @@ nav:
         - 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_diffusion.md
+      - CPU Offloading: user_guide/diffusion/cpu_offload.md
       - LoRA: user_guide/diffusion/lora.md
       - Custom Pipeline: features/custom_pipeline.md
-      - Request-Level Batching: user_guide/diffusion/request_batching.md
-      - Step Execution: user_guide/diffusion/step_execution.md
+      - Execution Modes: user_guide/diffusion/execution_modes.md
     - Quantization:
-      - Overview: user_guide/quantization/overview.md
+      - Quantization: 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
@@ -103,30 +101,49 @@ nav:
   - CI: contributing/ci
   - Design Documents:
     - design/index.md
-    - design/architecture_overview.md
+    - Architecture Documents:
+      - Architecture Overview: design/architecture_overview.md
     - Feature Design:
-      - design/feature/disaggregated_inference.md
-      - design/feature/ray_based_execution.md
-      - design/feature/omni_connectors/
-      - design/feature/prefix_caching.md
-      - design/feature/cfg_parallel.md
-      - design/feature/expert_parallel.md
-      - design/feature/sequence_parallel.md
-      - design/feature/tensor_parallel.md
-      - design/feature/vae_parallel.md
-      - design/feature/hsdp.md
-      - design/feature/cache_dit.md
-      - design/feature/teacache.md
-      - design/feature/async_chunk.md
-      - design/feature/vae_parallel.md
-      - design/feature/diffusion_step_execution.md
-      - design/feature/diffusion_request_level_batching.md
-      - design/feature/diffusion_continuous_batching.md
+      - Runtime and Stage Execution:
+        - Disaggregated Inference: design/feature/disaggregated_inference.md
+        - Async Chunk: design/feature/async_chunk.md
+        - Async Diffusion Output: design/feature/async_diffusion_output.md
+        - Async Omni Output Materialization: design/feature/omni_async_output_materialization.md
+        - Automatic Prefix Caching: design/feature/prefix_caching.md
+      - Communication:
+        - OmniConnector Implementations:
+          - Mooncake Store Connector: design/feature/omni_connectors/mooncake_store_connector.md
+          - Mooncake Transfer Engine Connector: design/feature/omni_connectors/mooncake_transfer_engine_connector.md
+          - Mori Transfer Engine Connector: design/feature/omni_connectors/mori_transfer_engine_connector.md
+          - 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
+      - Diffusion Acceleration:
+        - Parallelism:
+          - CFG-Parallel: design/feature/cfg_parallel.md
+          - Expert Parallel: design/feature/expert_parallel.md
+          - Hybrid Sharded Data Parallel (HSDP): design/feature/hsdp.md
+          - Pipeline Parallel: design/feature/pipeline_parallel.md
+          - Sequence Parallel: design/feature/sequence_parallel.md
+          - Tensor Parallel: design/feature/tensor_parallel.md
+          - VAE Patch Parallelism: design/feature/vae_parallel.md
+        - Attention Backends:
+          - 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
+        - Distributed Layerwise Offload: design/feature/distributed_layerwise_offload.md
+    - Infrastructure and Performance:
+      - Prometheus Metrics: design/metrics.md
+      - Speech Generation Performance Optimizations: design/qwen3_omni_tts_performance_optimization.md
     - Module Design:
       - Entrypoints: design/module/entrypoints.md
       - vLLM-Omni Configuration: design/module/vllm_omni_config.md
       - Input, Output, and Modality Contracts: design/module/input_output_modality_contracts.md
+      - Error Contracts: design/module/error_contracts.md
       - Engine Orchestration: design/module/engine_orchestration.md
+      - Stage Runtime: design/module/stage_runtime.md
       - OmniConnector: design/module/omni_connector.md
       - Model Integration: design/module/model_integration.md
       - Autoregressive Runtime: design/module/ar_runtime.md
diff --git a/docs/README.md b/docs/README.md
index f6263483b..f3dfe70c2 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -52,12 +52,13 @@ vLLM-Omni is flexible and easy to use with:
 - Tensor, pipeline, data and expert parallelism support for distributed inference
 - Streaming outputs
 - OpenAI-compatible API server
+- Full-duplex realtime serving with streaming audio input and output (experimental)
 
 vLLM-Omni seamlessly supports most popular open-source models on HuggingFace, including:
 
-- Omni-modality models (e.g. Qwen3-Omni, Cosmos3, HunyuanImage, BAGEL)
+- Omni-modality models (e.g. Qwen3-Omni, MiniCPM-o 4.5, Cosmos3, HunyuanImage, BAGEL)
 - TTS models (e.g. Qwen3-TTS, VoxCPM2, Ming-Omni-TTS, CosyVoice3)
-- Diffusion models — image, video, and audio generation (e.g. Qwen-Image, Wan2.2, FLUX)
+- Diffusion models — image, video, and audio generation (e.g. MiniMax H3, Qwen-Image, Wan2.2, FLUX)
 - Robot-policy and action models (e.g. GR00T-N1.7, DreamZero-DROID, InternVLA-A1, Cosmos3 action policy)
 
 For more information, checkout the following:
diff --git a/docs/api/README.md b/docs/api/README.md
index cfea6d175..4a34e3f31 100644
--- a/docs/api/README.md
+++ b/docs/api/README.md
@@ -62,7 +62,6 @@ Engine classes for offline and online inference.
 
 Core scheduling and caching components.
 
-- [vllm_omni.core.sched.omni_ar_scheduler.KVCacheTransferData][]
 - [vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler][]
 - [vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler][]
 - [vllm_omni.core.sched.output.OmniCachedRequestData][]
@@ -131,7 +130,7 @@ Worker classes and model runners for distributed inference.
 - [vllm_omni.diffusion.worker.diffusion_worker.DiffusionWorker][]
 - [vllm_omni.diffusion.worker.diffusion_worker.WorkerProc][]
 - [vllm_omni.diffusion.worker.diffusion_worker.WorkerWrapperBase][]
-- [vllm_omni.diffusion.worker.utils.DiffusionRequestState][]
+- [vllm_omni.diffusion.worker.utils.StepRequestState][]
 - [vllm_omni.diffusion.worker.utils.RunnerOutput][]
 - [vllm_omni.platforms.npu.worker.npu_ar_model_runner.ExecuteModelState][]
 - [vllm_omni.platforms.npu.worker.npu_ar_model_runner.NPUARModelRunner][]
diff --git a/docs/assets/WeChat.jpg b/docs/assets/WeChat.jpg
index cb7300de2..af1bea53c 100644
Binary files a/docs/assets/WeChat.jpg and b/docs/assets/WeChat.jpg differ
diff --git a/docs/cli/README.md b/docs/cli/README.md
index 9e3240de4..40858ca1a 100644
--- a/docs/cli/README.md
+++ b/docs/cli/README.md
@@ -18,18 +18,12 @@ Specify the port:
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
 ```
 
-For a migrated model, load a custom deploy configuration with `--deploy-config`:
+Load a custom deploy configuration with `--deploy-config`:
 
 ```bash
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --deploy-config /path/to/deploy_config.yaml
 ```
 
-The deprecated `--stage-configs-path` flag is retained for models that still use the legacy `stage_args` schema:
-
-```bash
-vllm serve ByteDance-Seed/BAGEL-7B-MoT --omni --stage-configs-path /path/to/legacy_stage_config.yaml
-```
-
 ## bench
 
 Run benchmark tests for online serving throughput.
diff --git a/docs/cli/serve.md b/docs/cli/serve.md
index 9d1747e0b..cf3d068a6 100644
--- a/docs/cli/serve.md
+++ b/docs/cli/serve.md
@@ -8,8 +8,6 @@ The stage-based CLI is designed for deployments that require launching each pipe
 - For **migrated models** that utilize the bundled deployment YAML configurations located in
   `vllm_omni/deploy/`, the `--deploy-config` flag is only required to override the default configuration. By default, executing `vllm serve MODEL --omni ...`
   automatically loads the bundled deployment configuration.
-- For **legacy models** utilizing configuration files located in
-  `vllm_omni/model_executor/stage_configs/`, the `--stage-configs-path` parameter remains mandatory.
 
 Example: Initializing Stage 0 (Orchestrator and API Server):
 The commands below show a common device mapping where Stage 0 uses GPU 0 and
@@ -33,7 +31,7 @@ CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
     --omni-master-port 26000
 ```
 
-When utilizing a custom deployment YAML based on the new schema, append `--deploy-config /path/to/override.yaml` to each command execution. Conversely, for legacy models, substitute this parameter with `--stage-configs-path /path/to/stage_configs.yaml`.
+When utilizing a custom deployment YAML, append `--deploy-config /path/to/override.yaml` to each command execution.
 
 In the standard execution paradigm, the `--stage-overrides` argument is utilized to apply stage-specific configurations from a single CLI command.
 However, under the **stage-based CLI** paradigm, where each process strictly encapsulates a single stage, it is recommended to specify tuning parameters directly via discrete command-line flags for the respective stage, rather than constructing a composite `--stage-overrides` JSON string.
diff --git a/docs/community/governance.md b/docs/community/governance.md
index 3b0c62c09..63d38cd20 100644
--- a/docs/community/governance.md
+++ b/docs/community/governance.md
@@ -40,6 +40,7 @@ Committers have write access and merge rights. They typically have deep expertis
 - [@Isotr0py](https://github.com/Isotr0py): Diffusion and Quantization
 - [@linyueqian](https://github.com/linyueqian): TTS and Omni Support
 - [@lishunyang12](https://github.com/lishunyang12): Quantization and Configuration
+- [@NickCao](https://github.com/NickCao): CI, Tests, Entrypoint, and TTS Model Support
 - [@princepride](https://github.com/princepride): Diffusion and Omni Support
 - [@RuixiangMa](https://github.com/RuixiangMa): Diffusion models, parallel, cache, and docs
 - [@SamitHuang](https://github.com/SamitHuang): RL, Diffusion, and cache
diff --git a/docs/configuration/README.md b/docs/configuration/README.md
index 390176e9c..09772ccd1 100644
--- a/docs/configuration/README.md
+++ b/docs/configuration/README.md
@@ -2,7 +2,7 @@
 
 This section lists the most common options for running vLLM-Omni.
 
-For options within a vLLM Engine. Please refer to [vLLM Configuration](https://docs.vllm.ai/en/v0.16.0/configuration/index.html)
+For options within a vLLM Engine, please refer to the [vLLM 0.26 configuration guide](https://docs.vllm.ai/en/v0.26.0/configuration/index.html).
 
 Currently, the main options are maintained by stage configs for each model.
 
diff --git a/docs/configuration/composable_parallel.md b/docs/configuration/composable_parallel.md
index a456de843..473605c69 100644
--- a/docs/configuration/composable_parallel.md
+++ b/docs/configuration/composable_parallel.md
@@ -34,12 +34,8 @@ Two additional `StrategySpec` slots — `layer_hook_specs` and `kernel_specs` 
 | Flag | Description |
 |------|-------------|
 | `--strategy-config PATH` | Path to a `strategy.yaml`. Only takes effect on registry-based deploy paths (`--deploy-config` or the bundled default deploy YAML). Its derived sizing is overlaid onto the merged stages *before* CLI overrides. |
-| `--stage-configs-path PATH` | **Legacy.** Loads the old `stage_args` YAML schema for un-migrated models. Passing `--strategy-config` together with this path is silently inapplicable — vLLM-Omni emits a warning and the strategy is ignored (see `vllm_omni/entrypoints/utils.py`, lines 372–380). |
 | `--omni-lb-policy POLICY` | Orchestrator-wide load-balancer policy. Strategy-derived from any `stage_replica` axis; an explicit CLI value wins and must match the derived one or `AsyncOmniEngine` raises `Conflicting load-balancer policy` at construction. |
 
-!!! warning
-    `--strategy-config` cannot be used with `--stage-configs-path` (the legacy deploy path). If your model has not been migrated to the registry-based pipeline yet, the strategy is silently dropped with a warning. Migrate to a registry-based model or use `--deploy-config` to apply a strategy.
-
 ## Sub-schemas
 
 ### `axis`
@@ -216,17 +212,6 @@ Strategy keys MUST be `model_stage` *names* (strings), the same labels stage con
 !!! warning "Mixing CLI overrides with a strategy on the same axis"
     A strategy is meant to be the single writer for the axes it declares. If a CLI override (`--tensor-parallel-size 2`, `--stage-overrides '{"0": {"tensor_parallel_size": 2}}'`) sets the same axis, the **CLI value wins** and a warning is emitted from `_reconcile_strategy_with_cli`. The device-layout guard then re-runs against the effective layout, so a CLI override that breaks `tp * dp * pp * num_replicas` will still fail fast at config time.
 
-!!! warning "Passing `--strategy-config` against the legacy `--stage-configs-path`"
-    Composable parallel only applies on the registry-based deploy path. If a model still resolves through the legacy `stage_args` YAML (loaded via `--stage-configs-path`), `--strategy-config` is silently inapplicable and emits:
-
-    ```text
-    --strategy-config (<path>) was provided but model '<model>' resolves via the
-    legacy stage_configs YAML path, which does not support composable-parallel
-    strategies; the strategy is ignored. Use a registry-based model to apply it.
-    ```
-
-    Migrate the model to the new deploy schema (see `configuration/stage_configs.md`) before applying a strategy.
-
 !!! warning "Conflicting `omni_lb_policy` across stages"
     `omni_lb_policy` is a single pipeline-wide knob. If two `stage_replica` axes in different stages derive different policies, `apply_strategy_specs` raises:
 
diff --git a/docs/configuration/pd_disaggregation.md b/docs/configuration/pd_disaggregation.md
index 7deb0443a..93c623ebd 100644
--- a/docs/configuration/pd_disaggregation.md
+++ b/docs/configuration/pd_disaggregation.md
@@ -158,7 +158,7 @@ runtime:
 
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 \
-    --stage-configs-path /path/to/qwen3_omni_pd.yaml
+    --deploy-config /path/to/qwen3_omni_pd.yaml
 ```
 
 ## Operational Notes
diff --git a/docs/configuration/stage_configs.md b/docs/configuration/stage_configs.md
index 1f14d21fd..290c15b94 100644
--- a/docs/configuration/stage_configs.md
+++ b/docs/configuration/stage_configs.md
@@ -1,9 +1,9 @@
-# Deploy and legacy stage configurations
+# Pipeline and deploy configurations
 
-In vLLM-Omni, a model's `PipelineConfig` defines its fixed stage topology, while a deploy configuration controls how those stages run. Models that have not migrated to this split still use legacy stage configurations with a `stage_args` schema.
+In vLLM-Omni, a model's `PipelineConfig` defines its fixed stage topology, while a deploy configuration controls how those stages run.
 
 !!! note
-    Default deploy config YAMLs (for example, `vllm_omni/deploy/qwen2_5_omni.yaml`, `vllm_omni/deploy/qwen3_omni_moe.yaml`, and `vllm_omni/deploy/qwen3_tts.yaml`) are bundled and loaded automatically when neither `--stage-configs-path` nor `--deploy-config` is provided — the model registry resolves the right pipeline + deploy YAML by `model_type`. The bundled defaults have been verified on 1xH100 for Qwen2.5-Omni and 2xH100 for Qwen3-Omni. Models that have not yet migrated to the new schema continue to use the legacy `vllm_omni/model_executor/stage_configs/<model>.yaml` files via `--stage-configs-path`.
+    Default deploy config YAMLs (for example, `vllm_omni/deploy/qwen2_5_omni.yaml`, `vllm_omni/deploy/qwen3_omni_moe.yaml`, and `vllm_omni/deploy/qwen3_tts.yaml`) are bundled and loaded automatically when `--deploy-config` is omitted. The model registry resolves the right pipeline and deploy YAML by `model_type`.
 
 ## Deploy configuration schema
 
@@ -65,7 +65,7 @@ connectors:
 
 | Connector class | Use case | `extra` keys |
 |-----------------|----------|--------------|
-| `SharedMemoryConnector` | Same-host KV transfer between stages (default for bundled YAMLs). | `shm_threshold_bytes` (int, default `65536`). |
+| `SharedMemoryConnector` | Same-host KV transfer between stages (default for bundled YAMLs). | None. All payloads use shared memory. |
 | `MooncakeStoreConnector` | Cross-host KV transfer over TCP. Required for multi-node deployments. | `host`, `metadata_server`, `master`, `segment` (int bytes), `localbuf` (int bytes), `proto` (`"tcp"` / `"rdma"`). |
 
 A stage references a connector by name in its `input_connectors` / `output_connectors`:
@@ -86,10 +86,9 @@ stages:
 
 | Flag | Description |
 |------|-------------|
-| `--deploy-config PATH` | Load a new-schema deploy YAML. It is mutually exclusive with `--stage-configs-path`. **Optional** — when omitted, the bundled `vllm_omni/deploy/<model_type>.yaml` is auto-loaded by the model registry. |
+| `--deploy-config PATH` | Load a deploy YAML. **Optional** — when omitted, the bundled `vllm_omni/deploy/<model_type>.yaml` is auto-loaded by the model registry. |
 | `--stage-overrides JSON` | Per-stage JSON overrides, e.g. `'{"0":{"gpu_memory_utilization":0.5}}'`. Per-stage values always win over global flags. |
 | `--async-chunk` / `--no-async-chunk` | Flip the deploy YAML's `async_chunk:` bool. Unset (default) leaves the YAML value in force. |
-| `--stage-configs-path` | **Deprecated.** Load a legacy `stage_args` YAML. New-schema YAMLs passed to this flag are auto-detected for compatibility, but should use `--deploy-config`. It is mutually exclusive with `--deploy-config` and will be removed in a future release. |
 
 ### Stage-Based CLI Paradigm
 
@@ -119,8 +118,7 @@ CUDA_VISIBLE_DEVICES=1 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
     --omni-master-port 26000
 ```
 
-When instantiating a custom deployment YAML conforming to the updated schema, append the `--deploy-config /path/to/override.yaml` directive
-to all node invocations. For legacy architectures (e.g., BAGEL) configured via deprecated `stage_args:` schemas, continue to specify the relevant configuration via `--stage-configs-path /path/to/config.yaml`.
+When instantiating a custom deployment YAML, append the `--deploy-config /path/to/override.yaml` directive to all node invocations.
 
 In the context of standard initialization architectures, utilizing the `--stage-overrides` parameter operates as the optimal methodology
 for delineating stage-specific tuning from the CLI interface:
@@ -220,8 +218,7 @@ Therefore, as a core part of vLLM-Omni, a model's pipeline and deployment config
 
 To override specific parameters, explicitly inject the customized configuration schema
 in both online and offline instantiation flows. Use the `--deploy-config` flag
-when loading a deploy configuration, reserving the `--stage-configs-path` parameter
-exclusively to maintain compatibility with legacy `stage_args` YAML constructs.
+when loading a deploy configuration.
 
 Examples:
 
@@ -236,11 +233,6 @@ For online serving:
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
 
-Legacy online serving:
-
-```bash
-vllm serve ByteDance-Seed/BAGEL-7B-MoT --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
-```
 !!! important
     We are actively iterating on the definition of deployment configurations, and we welcome feedback from users and developers.
 
@@ -377,7 +369,12 @@ Default: `"0"`
 
 #### `engine_args.max_num_seqs`
 
-The maximum number of sequences for concurrent processing in this stage. For LLM stages, this controls the vLLM scheduler's maximum concurrent sequences. For all stage types, this also controls how many tasks can be batched together in the task processing loop.
+The maximum number of sequences for concurrent processing in this stage. For
+LLM stages, this controls the vLLM scheduler's maximum concurrent sequences.
+For diffusion stages, this controls scheduler wave capacity in both request
+batch mode and step batch mode. `max_num_seqs: 1` is the serial/conservative
+path; values above `1` allow compatible requests to batch when the selected
+diffusion pipeline supports that batching mode.
 
 Default: `1`
 
@@ -390,8 +387,8 @@ that support request-level batching with `step_execution` disabled.
 
 Use this together with `max_num_seqs > 1` for bursty serving traffic. `0`
 disables admission waiting and preserves the lowest first-request latency.
-For diffusion request-level batching tuning, see
-[Request-Level Batching](../user_guide/diffusion/request_batching.md).
+For diffusion execution and batching tuning, see
+[Diffusion Execution Modes](../user_guide/diffusion/execution_modes.md).
 
 Default: `0.0`
 
diff --git a/docs/contributing/README.md b/docs/contributing/README.md
index e10d8d3b3..4c05fe0f2 100644
--- a/docs/contributing/README.md
+++ b/docs/contributing/README.md
@@ -71,7 +71,7 @@ For additional features and advanced configurations, refer to the:
 ### Testing
 
 vLLM-Omni uses `pytest` to test the codebase.
-Please refer to the [test instructions](./ci/test_guide.md) for detailed testing information.
+Please refer to the [test instructions](./ci/test_execution_guide.md) for detailed testing information.
 
 !!! warning
     Currently, not all unit tests pass when run on CPU platforms. If you don't have access to a GPU platform to run unit tests locally, rely on the continuous integration system to run the tests for now.
@@ -127,11 +127,11 @@ The skill offers two modes:
 The precheck covers five PR types: Bug Fix, Performance, New Model, Diffusion Model, and General. Each type has a tailored checklist that validates evidence quality (repro steps, A/B benchmarks, registry entries, etc.). See the [precheck-pr skill](https://github.com/vllm-project/vllm-omni/blob/main/.claude/skills/precheck-pr/SKILL.md) for the full checklist.
 
 ### Local Test
-Please run the L1 and L2 test cases locally first and attach the results before contacting us to add the "ready" label. Please refer to the [test instructions](./ci/test_guide.md) for running the test cases.
+Please run the L1 and L2 test cases locally first and attach the results before contacting us to add the "ready" label. Please refer to the [test instructions](./ci/test_execution_guide.md) for running the test cases.
 
 ### Automatic skip-ci (docs and pytest skip marks)
 
-On pull requests and `main` pushes, the bootstrap step in [`.buildkite/pipeline.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/pipeline.yml) runs [`.buildkite/scripts/upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/scripts/upload_pipeline.py) against the git diff. When every changed file qualifies, **L2 (`ready`) and L3 (`merge-test`) pipelines are not uploaded**, so the default GPU CI jobs are skipped.
+On pull requests and `main` pushes, the bootstrap step in [`.buildkite/cuda/pipeline.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/pipeline.yml) runs [`.buildkite/common/scripts/upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) against the git diff. When every changed file qualifies, **L2 (`ready`) and L3 (`merge-test`) pipelines are not uploaded**, so the default GPU CI jobs are skipped.
 
 | Change per file | Examples |
 | --- | --- |
@@ -148,7 +148,7 @@ These PR shapes all trigger skip-ci:
 Skip-ci does **not** apply when the diff also touches product code (for example `vllm_omni/`), or when test files change assertions, imports, fixtures, or other non-skip logic. If the diff cannot be resolved (non-PR branches outside `main`), CI runs as usual.
 
 !!! note
-    Skipping L2/L3 does **not** disable the Docker image build step. Nightly (L4) upload can still run when the PR has a `nightly-test` label or on scheduled `main` builds with `NIGHTLY=1`. See [CI levels](./ci/CI_5levels.md) for how bootstrap skip-ci relates to diff-gated E2E jobs.
+    Skipping L2/L3 does **not** disable the Docker image build step. Nightly (L4) upload can still run when the PR has a `nightly-test` label or on scheduled `main` builds with `NIGHTLY=1`. Bootstrap child steps live in `bootstrap-upload-steps.yml`; the hook entry step runs `upload_pipeline.py --upload <platform>/bootstrap-upload-steps.yml`, which injects `if` by step `key` from skip-ci before upload. See [CI Settings — Diff-aware CI](./ci/ci_settings.md#diff-aware-ci) and [Test System Overview](./ci/test_system_overview.md).
 
 ### Code Quality
 
diff --git a/docs/contributing/ci/.nav.yaml b/docs/contributing/ci/.nav.yaml
index 0f187f3a1..867bcc330 100644
--- a/docs/contributing/ci/.nav.yaml
+++ b/docs/contributing/ci/.nav.yaml
@@ -1,6 +1,6 @@
 nav:
-  - CI_5levels.md
+  - test_system_overview.md
+  - ci_settings.md
+  - test_writing_guide.md
   - failures.md
-  - test_guide.md
-  - test_markers.md
-  - test_style.md
+  - test_execution_guide.md
diff --git a/docs/contributing/ci/CI_5levels.md b/docs/contributing/ci/CI_5levels.md
deleted file mode 100644
index 17b4a3792..000000000
--- a/docs/contributing/ci/CI_5levels.md
+++ /dev/null
@@ -1,913 +0,0 @@
-# Multi-Level Automated Testing System Documentation
-
-## Document Overview
-
-This testing system aims to build a complete, efficient, and well-structured quality assurance framework for the development, integration, and release of model services. It draws on the concept of the test pyramid from modern software engineering, progressively expanding testing activities from basic code logic verification to complex end-to-end (E2E) functionality, performance, accuracy, and even long-term stability validation.
-
-Through five levels (L1-L5) and common (Common) specifications, the system clarifies the testing objectives, scope, execution frequency, and required resources for different development stages (e.g., each commit, PR merge, daily build, pre-release). This ensures that models meet high standards for functionality, performance, and reliability across various deployment scenarios (online serving and offline inference).
-
-<table>
-  <thead>
-    <tr>
-      <th>Level</th>
-      <th>Scope & Focus</th>
-      <th>Model Coverage Strategy</th>
-      <th>Feature Coverage Strategy</th>
-      <th>Interface Coverage Strategy</th>
-      <th>Tags</th>
-      <th>Time Cost</th>
-      <th>Test Dir</th>
-      <th>Doc</th>
-      <th>Frequency</th>
-      <th>Hardware</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td rowspan="2"><strong>Common</strong></td>
-      <td>Contribution Guideline & PR checklist</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>.github/PULL_REQUEST_TEMPLATE.md <a href="../tests_style/"> Test Style (PR Checklist)</a></td>
-      <td>/</td>
-      <td>/</td>
-    </tr>
-    <tr>
-      <td>CI Failure Description</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td><a href="../failures/"> CI Failures</a></td>
-      <td>/</td>
-      <td>/</td>
-    </tr>
-    <tr>
-      <td><strong>L1</strong><br>(Unit & Logic)</td>
-      <td>Unit tests for components like entrypoints, models</td>
-      <td>/</td>
-      <td>/</td>
-      <td>/</td>
-      <td><code>core_model and cpu</code></td>
-      <td rowspan="2">&lt;15min</td>
-      <td>/tests/{component_name}/test_xxx</td>
-      <td>
-        <a href="#chapter-1-l1-l2-level-testing-unit-testing-and-basic-end-to-end-verification">Chapter 1</a><br>
-        Section 1 L1&amp;L2: Purpose, Test Content, Directory Location, Example
-      </td>
-      <td>PR with ready label (also can run locally)</td>
-      <td>CPU</td>
-    </tr>
-    <tr>
-      <td><strong>L2</strong><br>(E2E across models & GPU-required UT)</td>
-      <td>Online (basic deployment scenarios):<br>dummy, normal inference function (output format, stream), some instance startup UT</td>
-      <td>High-priority models + online basic scenarios; request success, non-empty output, format match (no Whisper/accuracy)</td>
-      <td>High-priority features (using random lightweight models)</td>
-      <td>High-priority interfaces (using random lightweight models)</td>
-      <td><code>core_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
-      <td>
-        <strong>Model tests:</strong><br>
-        /tests/e2e/online_serving/test_{model_name}.py<br>
-        <strong>Feature tests:</strong><br>
-        /tests/{component_name}/test_xxx<br>
-        <strong>Interface tests:</strong><br>
-        /tests/entrypoints/test_xxx
-      </td>
-      <td>
-        <a href="#chapter-1-l1-l2-level-testing-unit-testing-and-basic-end-to-end-verification">Chapter 1</a><br>
-        L1&amp;L2: Purpose, Test Content, Directory Location, Example
-      </td>
-      <td>PR with ready label</td>
-      <td>GPU</td>
-    </tr>
-    <tr>
-      <td><strong>L3</strong><br>(Important Perf & Integration & Accuracy)</td>
-      <td>Online & Offline (multiple deployment scenarios):<br>real model, normal inference function, normal accuracy</td>
-      <td>High/medium-priority models + key online/offline scenarios; real weights, Whisper/similarity, preset voice gender, basic accuracy</td>
-      <td>Medium-priority features (using random lightweight models)</td>
-      <td>Medium-priority interfaces (using random lightweight models)</td>
-      <td><code>advanced_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
-      <td>&lt;30min</td>
-      <td>
-        <strong>Model tests:</strong><br>
-        /tests/e2e/online_serving/test_{model_name}.py<br>
-        /tests/e2e/offline_inference/test_{model_name}.py<br>
-        <strong>Feature tests:</strong><br>
-        /tests/{component_name}/test_xxx<br>
-        <strong>Interface tests:</strong><br>
-        /tests/entrypoints/test_xxx
-      </td>
-      <td>
-        <a href="#chapter-2-l3-level-testing-core-integration-performance-and-accuracy-verification">Chapter 2</a><br>
-        L3: Purpose, Test Content, Directory Location, Example
-      </td>
-      <td>PR Merged (Also run L1&L2 Tests)</td>
-      <td>GPU</td>
-    </tr>
-    <tr>
-      <td><strong>L4</strong><br>(Perf & Integration & Accuracy)</td>
-      <td>Online: full functional scenarios + performance test + doc test + accuracy test</td>
-      <td>High-priority models: function, performance, accuracy, and doc testing<br>Medium-priority models: function and doc testing</td>
-      <td>Low-priority features (using real weights)</td>
-      <td>Low-priority interfaces (using real weights)</td>
-      <td><code>full_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
-      <td>&lt;3 hour</td>
-      <td>
-        <strong>Model tests:</strong><br>
-        /tests/e2e/online_serving/test_{model_name}_expansion.py<br>
-        <strong>Feature tests:</strong><br>
-        /tests/{component_name}/test_xxx<br>
-        <strong>Interface tests:</strong><br>
-        /tests/entrypoints/test_xxx<br>
-        <strong>Performance:</strong><br>
-        /tests/dfx/perf/tests/test_qwen_omni.json (Omni), test_tts.json (TTS),<br>
-        and /tests/dfx/perf/tests/test_{diffusion_model}_vllm_omni.json (Diffusion)<br>
-        <strong>Doc Test:</strong><br>
-        tests/example/online_serving/test_{model_name}.py<br>
-        tests/example/offline_inference/test_{model_name}.py<br>
-        <strong>Accuracy Test:</strong><br>
-        /tests/e2e/accuracy/test_{model_name}.py
-      </td>
-      <td>
-        <a href="#chapter-3-l4-level-testing-full-functionality-performance-and-documentation-testing">Chapter 3</a><br>
-        L4: Purpose, Test Content, Directory Location, Example
-      </td>
-      <td>Nightly</td>
-      <td>GPU</td>
-    </tr>
-    <tr>
-      <td><strong>L5</strong><br>(Stability & Reliability)</td>
-      <td>Online: long-term stability test + reliability test</td>
-      <td>Long-term stability and reliability testing for high-priority models<br>Low-priority models: function and doc testing</td>
-      <td>/</td>
-      <td>Invalid-parameter validation for high-priority interfaces</td>
-      <td><code>slow and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
-      <td> Depends on reality </td>
-      <td>
-        <strong>Stability:</strong><br>
-        /tests/dfx/stability/tests/test_qwen3_omni.json<br>
-        /tests/dfx/stability/tests/test_wan22.json<br>
-        <strong>Reliability:</strong><br>
-        tests/dfx/reliability/test_reliability_{model_key}.py<br>
-        (e.g. <code>test_reliability_qwen3_omni.py</code>, <code>test_reliability_wan22.py</code>, <code>test_reliability_hunyuan_image.py</code>, <code>test_reliability_voxcpm2.py</code>)
-      </td>
-      <td>
-        <a href="#chapter-4-l5-level-testing-stability-and-reliability-testing">Chapter 4</a><br>
-        L5: Purpose, Test Content, Directory Location, Example
-      </td>
-      <td>Weekly / Days before Release</td>
-      <td>GPU</td>
-    </tr>
-  </tbody>
-</table>
-
-
----
-<details>
-<summary> The folder structure for tests file based on the 5 levels design</summary>
-Legend: `✅` = test exists, `⬜` = suggested to add.
-```
-vllm_omni/                                    tests/
-├── config/                             →     ├── config/
-│   ├── model.py                              │   └── test_model.py                    ⬜
-│   └── lora.py                               │   └── test_lora.py                      ⬜
-│
-├── core/                               →     ├── core/
-│   └── sched/                                 │   └── sched/
-│       ├── omni_ar_scheduler.py               │       ├── test_omni_ar_scheduler.py    ⬜
-│       ├── omni_generation_scheduler.py       │       ├── test_omni_generation_scheduler.py  ⬜
-│       └── output.py                          │       └── test_output.py               ✅ currently in entrypoints/test_omni_new_request_data.py (tests output.OmniNewRequestData)
-│
-├── diffusion/                          →     ├── diffusion/
-│   ├── diffusion_engine.py                    │   ├── test_diffusion_engine.py          ⬜
-│   ├── attention/                             │   ├── attention/
-│   │   ├── layer.py                            │   │   ├── test_attention_sp.py         ✅
-│   │   └── backends/                           │   │   └── test_flash_attn.py           ✅
-│   ├── distributed/                           │   ├── distributed/
-│   │   └── ...                                 │   │   ├── test_comm.py                 ✅
-│   │                                            │   │   ├── test_cfg_parallel.py        ✅
-│   │                                            │   │   └── test_sp_plan_hooks.py       ✅
-│   ├── lora/                                   │   ├── lora/
-│   │   └── ...                                 │   │   ├── test_base_linear.py          ✅
-│   │                                            │   │   └── test_lora_manager.py        ✅
-│   ├── models/                                 │   ├── models/
-│   │   ├── qwen_image/                         │   │   ├── qwen_image/                 (e2e coverage)
-│   │   ├── ovis_image/                         │   │   ├── ovis_image/
-│   │   │   └── ...                             │   │   │   └── test_ovis_image.py     ✅
-│   │   ├── z_image/                            │   │   └── z_image/
-│   │   └── ...                                 │   │       └── test_zimage_tp_constraints.py  ✅
-│   └── worker/                                 │   └── worker/
-│       ├── diffusion_worker.py                 │       └── test_diffusion_worker.py   ✅ file at diffusion/test_diffusion_worker.py
-│       └── diffusion_model_runner.py            │
-│
-├── distributed/                         →     ├── distributed/
-│   └── omni_connectors/                         │   └── omni_connectors/
-│       ├── adapter.py                           │       ├── test_adapter_and_flow.py   ✅
-│       ├── kv_transfer_manager.py               │       ├── test_basic_connectors.py   ✅
-│       ├── connectors/                           │       ├── test_kv_flow.py             ✅
-│       └── utils/                               │       └── test_omni_connector_configs.py  ✅
-│
-├── engine/                             →     ├── engine/
-│   ├── input_processor.py                      │   ├── test_input_processor.py         ⬜  (no processor.py in source)
-│   ├── output_processor.py                     │   └── test_output_processor.py         ⬜
-│   └── arg_utils.py                            │   └── test_arg_utils.py               ⬜
-│
-├── entrypoints/                        →     ├── entrypoints/
-│   ├── stage_utils.py                          │   ├── test_stage_utils.py            ✅
-│   ├── cli/                                     │   ├── cli/                           (benchmarks/test_serve_cli.py covers CLI serve)
-│   │   └── ...                                  │   │   └── test_*.py                  ⬜
-│   └── openai/                                  │   └── openai_api/                    # maps to entrypoints/openai/
-│       ├── api_server.py                        │       ├── test_api_server.py         ⬜  (e2e indirect coverage)
-│       ├── serving_chat.py                       │       ├── test_serving_chat_sampling_params.py  ✅
-│       ├── serving_speech.py                     │       ├── test_serving_speech.py     ✅
-│       └── image_api_utils.py                   │       └── test_image_server.py      ✅
-│
-├── inputs/                             →     ├── inputs/
-│   ├── data.py                                 │   ├── test_data.py                   ⬜
-│   ├── parse.py                                │   ├── test_parse.py                 ⬜
-│   └── preprocess.py                            │   └── test_preprocess.py            ✅ currently in entrypoints/test_omni_input_preprocessor.py
-│
-├── model_executor/                     →     ├── model_executor/
-│   ├── layers/                                  │   ├── layers/
-│   │   └── mrope.py                             │   │   └── test_mrope.py              ⬜
-│   ├── model_loader/                            │   ├── model_loader/
-│   │   └── weight_utils.py                      │   │   └── test_weight_utils.py      ⬜
-│   ├── models/                                  │   ├── models/
-│   │   ├── qwen2_5_omni/                         │   │   ├── qwen2_5_omni/
-│   │   │   ├── qwen2_5_omni_thinker.py           │   │   │   ├── test_audio_length.py  ✅
-│   │   │   ├── qwen2_5_omni_talker.py            │   │   │   ├── test_qwen2_5_omni_thinker.py  ⬜
-│   │   │   └── qwen2_5_omni_token2wav.py         │   │   │   ├── test_qwen2_5_omni_talker.py  ⬜
-│   │   └── qwen3_omni/                          │   │   │   └── test_qwen2_5_omni_token2wav.py  ⬜
-│   │       └── ...                               │   │   └── qwen3_omni/
-│   ├── stage_configs/                           │   │       └── test_*.py              ⬜
-│   │   └── *.yaml                               │   └── stage_configs/                 (used by e2e, test_*.py can be added)  ⬜
-│   └── stage_input_processors/                  │   └── stage_input_processors/
-│       └── ...                                  │       └── test_*.py                 ⬜
-│
-├── sample/                             →     ├── sample/
-│   └── __init__.py                             │   └── test_*.py                      ⬜
-│
-├── utils/                              →     ├── utils/
-│   └── __init__.py                             │   └── test_*.py                       ⬜  (no platform_utils.py currently)
-│
-├── worker/                             →     ├── worker/
-│   ├── gpu_ar_model_runner.py                  │   ├── test_gpu_ar_model_runner.py    ⬜
-│   ├── gpu_ar_worker.py                        │   ├── test_gpu_ar_worker.py           ⬜
-│   ├── gpu_generation_model_runner.py          │   ├── test_gpu_generation_model_runner.py  ✅
-│   ├── gpu_generation_worker.py                │   ├── test_gpu_generation_worker.py  ⬜
-│   ├── gpu_model_runner.py                     │   ├── test_omni_gpu_model_runner.py   ✅
-│   └── mixins.py                               │   └── (npu under platforms/npu/worker/)  # not worker/npu/
-│
-├── platforms/                          →     (no tests/platforms/, e2e and stage_configs provide indirect coverage)
-│   ├── cuda/
-│   ├── npu/worker/                             # NPU worker here, not vllm_omni/worker/npu/
-│   ├── rocm/
-│   └── xpu/worker/
-│
-├── outputs.py                          →     test_outputs.py                         ✅ (at tests root)
-├── (logger, patch, request, version)    →     (no corresponding unit test)
-│
-└── e2e (tests side only)               →     ├── e2e/
-                                               ├── online_serving/                     ✅ non-empty
-                                               │   ├── test_qwen2_5_omni.py
-                                               │   ├── test_async_omni.py
-                                               │   ├── test_qwen3_omni.py
-                                               │   ├── test_qwen3_omni_expansion.py
-                                               │   ├── test_mimo_audio.py
-                                               │   └── test_images_generations_lora.py
-                                               └── offline_inference/                  ✅
-                                                   ├── test_qwen2_5_omni.py
-                                                   ├── test_qwen3_omni.py
-                                                   ├── test_bagel_text2img.py
-                                                   ├── test_z_image.py
-                                                   ├── test_wan22.py
-                                                   ├── test_zimage_tensor_parallel.py
-                                                   ├── test_cache_dit.py
-                                                   ├── test_teacache.py
-                                                   ├── test_stable_audio_expansion.py
-                                                   ├── test_diffusion_cpu_offload.py
-                                                   ├── test_diffusion_layerwise_offload.py
-                                                   ├── test_diffusion_lora.py
-                                                   ├── test_sequence_parallel.py
-                                                   └── stage_configs/                  (legacy schema, still
-                                                       ├── bagel_*.yaml                 present for unmigrated
-                                                       └── npu/, rocm/, etc.            models)
-
-# Migrated models (qwen3_omni_moe, qwen2_5_omni, qwen3_tts) live under
-# vllm_omni/deploy/ instead — see docs/configuration/stage_configs.md.
-```
-
-
-</details>
-
-
-## Common Specifications
-
-Before entering specific testing levels, the project establishes two common specifications aimed at standardizing the development process and quickly locating issues.
-
-1.  ***PR Checklist ([Tests Style](../ci/tests_style.md))***: This template defines the self-check items that must be completed before submitting a code review (Pull Request). It ensures that each code change meets basic requirements such as code style, dependency updates, and documentation synchronization before entering the automated testing pipeline, serving as the first manual line of defense for quality assurance.
-2.  ***CI Failure Explanation ([CI Failures](../ci/failures.md))***: This document archives and explains common failure patterns in the Continuous Integration (CI) pipeline, error log interpretation, and preliminary troubleshooting steps. It helps developers and testers quickly diagnose the causes of automated test failures, improving problem-solving efficiency.
-
-## Notes
-
-### Diff-aware Buildkite uploads (`source_file_dependencies`)
-
-L2 (`.buildkite/test-ready.yml`) and L3 (`.buildkite/test-merge.yml`) pipelines can **skip unrelated GPU jobs at upload time** based on the PR diff. This is implemented by `.buildkite/scripts/upload_pipeline.py`, which filters steps before calling `buildkite-agent pipeline upload`.
-
-#### What `source_file_dependencies` is
-
-- A **uploader-only** YAML key on a Buildkite step or group. **Buildkite does not understand it**; `upload_pipeline.py` always **removes** it from the YAML that is uploaded.
-- A list of path **prefixes** (directories or individual files). If **any** changed file in the diff equals a prefix or starts with `prefix/`, the step is kept; otherwise the step (or entire group) is **omitted** from the uploaded pipeline.
-
-#### When filtering runs
-
-| Build context | Changed files used for matching |
-| --- | --- |
-| Pull request | `git diff --name-only origin/<base>...<BUILDKITE_COMMIT>` |
-| `main` branch push | `git diff --name-only <commit>^..<commit>` |
-| Other (e.g. local dry-run, non-PR branch) | Diff cannot be resolved → **no filtering**; all steps are uploaded and `source_file_dependencies` is still stripped |
-
-Docs-only PRs are handled earlier in bootstrap (`pipeline.yml`) via skip-ci logic; `source_file_dependencies` applies only to the **uploaded** L2/L3 test pipelines.
-
-#### Where it is configured
-
-| Level | Pipeline file | Upload entry |
-| --- | --- | --- |
-| L2 | `.buildkite/test-ready.yml` | `upload_pipeline.py --upload .buildkite/test-ready.yml` (from `pipeline.yml`) |
-| L3 | `.buildkite/test-merge.yml` | `upload_pipeline.py --upload .buildkite/test-merge.yml` (from `pipeline.yml`) |
-
-Steps **without** `source_file_dependencies` are always uploaded (subject to the usual label conditions: `ready` for L2, `merge-test` for L3).
-
-#### Current skip policy (L2 / L3)
-
-To balance CI cost and coverage:
-
-- **Always run** (no `source_file_dependencies`): baseline groups outside E2E Test—e.g. Simple Test, Diffusion unit tests, Engine/Model Executor, Distributed, Custom Pipeline, Entrypoints (L2), LoRA / Entrypoints (L3).
-- **Diff-gated** (`source_file_dependencies` set): **every leaf job under the E2E Test group** in `test-ready.yml` and `test-merge.yml`, regardless of queue (`mithril-h100-pool`, `gpu_1_queue`, or `gpu_4_queue`). Each step lists the smallest set of prefixes that should trigger it—typically:
-  - pytest file(s) exercised by the job (online and/or offline);
-  - model code under `vllm_omni/model_executor/models/` or `vllm_omni/diffusion/models/`;
-  - related `vllm_omni/model_executor/stage_input_processors/` and `vllm_omni/deploy/*.yaml` when applicable.
-
-Adding a new E2E step: add `source_file_dependencies` on the leaf job with those prefixes. Prefer **per-step** deps rather than a broad group-level list unless every child shares the same paths.
-
-#### YAML examples
-
-H100 E2E (kubernetes / `mithril-h100-pool`):
-
-```yaml
-      - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'core_model' ...
-        agents:
-          queue: "mithril-h100-pool"
-```
-
-Docker E2E (`gpu_1_queue` / `gpu_4_queue`)—same key, same upload-time filtering:
-
-```yaml
-      - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-        commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py ...
-        agents:
-          queue: "gpu_4_queue"
-```
-
-A **group** may also define `source_file_dependencies`; nested steps inherit filtering as a unit—the whole group is dropped if no prefix matches.
-
-#### Local dry-run
-
-```bash
-# Render filtered YAML to stdout (no upload)
-python3 .buildkite/scripts/upload_pipeline.py .buildkite/test-ready.yml
-
-# Confirm uploader-only keys are stripped
-python3 .buildkite/scripts/upload_pipeline.py .buildkite/test-merge.yml | grep source_file_dependencies
-# (no output expected)
-```
-
-On a PR build, Buildkite logs from `upload_pipeline.py` include lines such as `skip '…' (no changes under …)` for omitted steps.
-
-#### Related
-
-- Implementation: `.buildkite/scripts/upload_pipeline.py`
-- L2/L3 diff skip does **not** replace label-based triggers (`ready`, `merge-test`); it only reduces which steps appear **after** the pipeline is already scheduled.
-
-### Test helper environment variables
-
-Some shared helpers under `tests/helpers/` honor optional environment variables for local debugging. These are **not** set in CI by default.
-
-| Variable | Accepted values | Description |
-| -------- | --------------- | ----------- |
-| `VLLM_OMNI_KEEP_REQUEST_MEDIA` | `1`, `true`, `yes` (case-insensitive) | When enabled, temporary WAV files created by `tests.helpers.media.convert_audio_bytes_to_text` are **not** deleted when the pytest process exits. By default, each call writes a unique file under the system temp directory via `tempfile.mkstemp` and registers `atexit` cleanup. Use this when debugging audio output validation (Whisper transcription, keyword checks, text–audio similarity). The saved path is logged as `audio data is saved: <path>`. |
-
-Example (Linux / macOS):
-
-```bash
-export VLLM_OMNI_KEEP_REQUEST_MEDIA=1
-pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -k test_mix_to_text_audio
-```
-
-Example (Windows PowerShell):
-
-```powershell
-$env:VLLM_OMNI_KEEP_REQUEST_MEDIA = "1"
-pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -k test_mix_to_text_audio
-```
-
-## Chapter 1: L1 & L2 Level Testing - Unit Testing and Basic End-to-End Verification
-
-### 1.1 Testing Purpose
-
-L1 and L2 level testing form the foundation of the quality assurance system. L1 level testing focuses on verifying the internal logic correctness of code units (e.g., functions, classes), ensuring each independent component behaves as designed.
-
-L2 level testing builds upon L1 by introducing GPU resources and verifying that the end-to-end (E2E) process of the model in basic deployment scenarios is smooth. For example, it uses dummy models to confirm that core interfaces like the inference pipeline, output format, and streaming response work properly. The common goal of these two levels is to provide developers with rapid feedback, discovering and fixing issues early in the development cycle.
-
-
-
-### 1.2 Testing Content and Scope
-
--   ***L1 (Unit & Logic Testing)***:
--   -   ***Scope***: Tests internal functions and methods of core components such as `entrypoints`, `models`.
-    -   ***Focus***: Branch coverage, exception handling, algorithm logic correctness. Does not involve external dependencies or the complete service stack.
-    -   ***Time Cost***: Execution time is controlled within ***15 minutes*** to ensure fast feedback.
--   ***L2 (Basic End-to-End Testing)***:
--   -   ***Scope***: Covers two basic deployment scenarios: `online` (serving) and `offline` (inference).
-    -   ***Focus***: Uses `dummy` weights (via deploy YAML patching at `core_model`) or lightweight real models to verify that the entire chain from request input to result output works normally, including output data structure, streaming (stream) support, and **cheap payload checks** at `--run-level core_model` (see below). Also includes some unit tests that require launching independent service instances.
-    -   ***L2 response validation (`core_model`)***: Implemented in `tests/helpers/assertions.py` and invoked by `OpenAIClientHandler` based on `--run-level`. At L2 we require **request success** plus minimal output sanity—not full accuracy:
-        -   **Speech / TTS** (`assert_audio_speech_response`): decoded audio must be present and non-empty (or exceed `min_audio_bytes` when set in `request_config`); `response_format` must match the returned content-type (e.g. `wav`, `pcm`). Whisper transcript similarity, PCM HNR, and preset-voice gender checks run only at L3+.
-        -   **Diffusion** (`assert_diffusion_response`): at least one non-empty image, video, or audio artifact. Resolution/frame-count parity and other deep checks run only at L3+.
-        -   **Omni multimodal** (`assert_omni_response`): L2 asserts successful completion; keyword, transcript, and cross-modal similarity checks run only at L3+.
-    -   ***Characteristic***: Requires ***GPU*** resources to perform model computations.
-
-### 1.3 Test Directory and Execution Files
-
-A clear directory structure is key to managing test cases efficiently.
-
--   ***L1 Test Directory***: `/tests/{component_name}/test_xxx.py`
--   -   Here, `{component_name}` corresponds to modules in the source code, such as `distributed`, `entrypoints`, etc., and `test_xxx.py` is the specific test file.
--   ***L2 Test Directory***:
--   -   Online Serving: `/tests/e2e/online_serving/test_{model_name}.py`
-    -   Offline Inference: `/tests/e2e/offline_inference/test_{model_name}.py`
-
-### 1.4 Execution Method and Example
-
--   ***Trigger Timing***: **`PR with ready label`**. That is, when a developer adds a "ready for review" or similar label to a PR on platforms like GitHub, L1 and L2 tests are automatically triggered.
--   ***Diff-aware step skipping***: On L2, **E2E Test** jobs may be omitted at pipeline upload when the PR diff does not touch their [`source_file_dependencies`](#diff-aware-buildkite-uploads-source_file_dependencies) prefixes (H100 and docker queues alike); non-E2E groups still always upload. See [Diff-aware Buildkite uploads](#diff-aware-buildkite-uploads-source_file_dependencies).
--   ***Execution Environment***: L1 uses ***CPU*** environment; L2 requires ***GPU*** environment.
--   ***Script Example***:
-
-<details>
-<summary> L1 Test Examples</summary>
-
-Examples from `tests/model_executor/models/qwen2_5_omni/test_audio_length.py`
-```python
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import pytest
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-def test_resolve_max_mel_frames_default():
-    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import resolve_max_mel_frames
-
-    assert resolve_max_mel_frames(None, default=30000) == 30000
-    assert resolve_max_mel_frames(None, default=6000) == 6000
-
-
-def test_resolve_max_mel_frames_explicit():
-    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import resolve_max_mel_frames
-
-    # Explicit argument always wins over default
-    assert resolve_max_mel_frames(123, default=30000) == 123
-    assert resolve_max_mel_frames(6000, default=30000) == 6000
-    assert resolve_max_mel_frames(0, default=30000) == 0
-
-
-@pytest.mark.parametrize("repeats", [2, 4])
-@pytest.mark.parametrize("code_len", [0, 1, 32768])
-@pytest.mark.parametrize("max_mel_frames", [None, -1, 0, 1, 6000, 30000])
-def test_cap_and_align_mel_length_no_mismatch(repeats, code_len, max_mel_frames):
-    """Guard that any max_mel_frames yields a mel length aligned to repeats, and
-    consistent with the truncated code length (prevents concat mismatch).
-    """
-    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import cap_and_align_mel_length
-
-    target_code_len, target_mel_len = cap_and_align_mel_length(
-        code_len=code_len,
-        repeats=repeats,
-        max_mel_frames=max_mel_frames,
-    )
-
-    assert isinstance(target_code_len, int)
-    assert isinstance(target_mel_len, int)
-
-    if code_len == 0:
-        assert target_code_len == 0
-        assert target_mel_len == 0
-        return
-
-    assert target_code_len >= 1
-    assert target_mel_len >= repeats
-    assert target_mel_len % repeats == 0
-    assert target_mel_len == target_code_len * repeats
-    assert target_code_len <= code_len
-
-    if max_mel_frames is not None and int(max_mel_frames) > 0 and int(max_mel_frames) >= repeats:
-        assert target_mel_len <= int(max_mel_frames)
-```
-</details>
-
-<details>
-<summary> L2 Test Examples</summary>
-You can refer to Test Examples in Chapter 2 to see example test cases that incorporate both L2 and L3 testing logic.
-</details>
-
--   -   ***Run Command***:
-
-    `pytest -s -v /tests/e2e/online_serving/test_{model_name}.py`
-    `pytest -s -v -m 'core_model and cpu' --run-level=core_model`
-
-## Chapter 2: L3 Level Testing - Core Integration, Performance, and Accuracy Verification
-
-### 2.1 Testing Purpose
-
-L3 level testing executes after code is merged into the main branch. Its core purpose is to verify the integration effect, key performance indicators, and output accuracy of ***real models*** in ***multiple deployment scenarios***
-
-. It acts as the "quality gatekeeper" for the main branch, ensuring that no merge breaks the core capabilities of the model service. Testing needs to provide clear conclusions within a relatively short time (<30min), balancing test depth with feedback speed.
-
-
-
-### 2.2 Testing Content and Scope
-
--   ***Deployment Scenarios***: Covers richer `online` and `offline` deployment configurations, which may include different hardware configurations, batch sizes, concurrency levels, etc.
--   ***Core Verification***:
--   1.  ***Inference Functionality***: Ensures real models can perform forward computation normally and return results.
-    2.  ***Accuracy Compliance***: Verifies that the model's evaluation metrics (e.g., accuracy) meet the expected baseline, preventing code changes from introducing accuracy issues.
-    3.  ***Important Performance***: Verifies whether performance (e.g., P99 latency, throughput) in core scenarios meets preset thresholds.
--   ***L3 response validation (`advanced_model`)***: At `--run-level advanced_model`, `tests/helpers/assertions.py` adds semantic checks on top of L2 payload gates (see Chapter 1):
-    -   **Speech / TTS** (`assert_audio_speech_response`): Whisper transcript of returned audio vs `request_config["input"]` (cosine similarity &gt; 0.9 when input text is set); optional `min_audio_bytes` floor; PCM harmonic-to-noise ratio when `response_format` is `pcm`; **preset voice gender** via `_assert_preset_voice_gender_from_audio` when `voice` matches a known preset in `_PRESET_VOICE_GENDER_MAP` (pitch/F0-based classifier; skipped for unknown voices or `pcm` output).
-    -   **Omni multimodal** (`assert_omni_response`): non-empty text/audio outputs; `key_words` in transcript or text; text–audio similarity / containment; preset **`speaker`** gender check (same helper as TTS).
-    -   **Diffusion** (`assert_*_diffusion_response`): image/video dimension and frame-count parity with request parameters where configured.
-    -   **Accuracy suites**: pixel/video similarity and metric baselines under `/tests/e2e/accuracy/` (separate from inline helper assertions).
-
-### 2.3 Test Directory and Execution Files
-
--   ***Functional Testing***:
--   -   Online Serving: `/tests/e2e/online_serving/test_{model_name}_expansion.py`
-    -   Offline Inference: `/tests/e2e/offline_inference/test_{model_name}_expansion.py`
-    -   (Note: `_expansion.py` likely means it contains more comprehensive scenario cases compared to L2 tests).
-
-### 2.4 Execution Method and Example
-
--   ***Trigger Timing***: **`PR Merged`**. Automatically triggered after code review is approved and merged into the main branch (typically via `merge-test` label on the PR before merge).
--   ***Diff-aware step skipping***: Same [`source_file_dependencies`](#diff-aware-buildkite-uploads-source_file_dependencies) mechanism as L2—**all E2E Test** leaf steps are diff-gated; other L3 groups always upload. See [Diff-aware Buildkite uploads](#diff-aware-buildkite-uploads-source_file_dependencies).
--   ***Execution Environment***: ***GPU*** servers.
--   ***Script Example***:
-
-???+ example "Test Examples"
-
-    **2.4.1 Mark Declaration Section**
-
-    ```python
-    @pytest.mark.advanced_model
-    @pytest.mark.core_model
-    @pytest.mark.parametrize("omni_server", test_params, indirect=True)
-    ```
-
-    **Explanation**:
-
-    @pytest.mark.advanced_model: Marks the test as L3 merge level (`--run-level advanced_model`): real weights, Whisper/similarity/keyword checks, diffusion deep checks, and **preset voice/speaker gender** validation where applicable. @pytest.mark.full_model: Marks L4 nightly-only suites (e.g. `test_*_expansion.py`, doc examples).
-
-    @pytest.mark.core_model: Marks the test as L1 or L2 level. At `--run-level core_model`, validation is limited to request success plus cheap payload checks (e.g. non-empty audio bytes, response format/content-type, non-empty diffusion outputs)—not Whisper, keyword, or accuracy gates. Deploy YAML may use `load_format: dummy` for fast PR feedback.
-
-    @pytest.mark.parametrize: A parameterization decorator that allows abstracting test data into parameters, enabling reuse of the same test logic across different data configurations. indirect=True indicates that parameters will be passed to the fixture for processing.
-
-    **Notes**: If you believe the test case only needs to execute basic run logic at the PR-level CI, you can mark it only with @pytest.mark.core_model. If you believe it only needs to execute deep validation at merge (L3), use @pytest.mark.advanced_model. For L4 nightly-only expansion and doc-example tests, use @pytest.mark.full_model with `--run-level full_model`. If the test case needs both basic run and deep validation, mark with @pytest.mark.core_model and the appropriate L3/L4 marker (`advanced_model` and/or `full_model`).
-
-    **2.4.2 Test Function Definition and Documentation**
-
-    ```python
-    def test_mix_to_text_audio_001(omni_server, openai_client) -> None:
-        """
-        Test multi-modal input processing and text/audio output generation via OpenAI API.
-        Deploy Setting: default yaml
-        Input Modal: text + audio + video + image
-        Output Modal: text + audio
-        Input Setting: stream=True
-        Datasets: single request
-        """
-    ```
-
-    **Explanation**:
-
-    **Function Naming Convention**: Uses the test_ prefix, describes the test scenario mix_to_text_audio, and the number 001 indicates the first test case for this scenario.
-
-    **Parameter Explanation**:
-
-    omni_server: Omni server instance obtained via fixture, containing model information and configuration.
-
-    openai_client: Unified OpenAI client processing instance, encapsulating request sending and response validation logic.
-
-    Docstring: Describes the test purpose, deployment settings, input/output modalities, streaming settings, and dataset type in detail, providing clear context for test maintenance.
-
-    **2.4.3 Multimodal Data Preparation**
-
-    ```python
-    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(224, 224, 300)['base64']}"
-    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(224, 224)['base64']}"
-    audio_data_url = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
-    ```
-
-    **Explanation**:
-
-    **Data Generation Functions**: Use the generate_synthetic_* series of functions to generate synthetic test data, avoiding reliance on external resources and ensuring test reproducibility and stability.
-
-    **Parameter Explanation**:
-
-    Video: width, height, duration_frames
-
-    Image: width, height
-
-    Audio: duration_seconds, channels
-
-    **2.4.4 Request Configuration and Keyword Validation**
-
-    ```python
-    request_config = {
-        "model": omni_server.model,
-        "messages": messages,
-        "stream": True,
-        "key_words": {
-            "audio": ["water", "cricket"],
-            "video": ["sphere", "globe", "circle", "round"],
-            "image": ["square", "quadrate"],
-            "text": ["beijing"]
-        },
-    }
-    ```
-
-    **Explanation**:
-
-    **Model Specification**: Uses omni_server.model to ensure the test aligns with the model configured on the server.
-
-    **Keyword Validation Mechanism**: This is an innovative design of the template to address the specific needs of multimodal testing:
-
-    Audio Keywords: Validate whether the generated text's description of audio content contains expected elements (e.g., "water" for water sounds, "cricket" for cricket sounds). If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
-
-    **Video Keywords**: Validate whether the generated text's description of video content contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
-
-    Image Keywords: Validate whether the generated text's description of image content contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
-
-    Text Keywords: Validate whether the generated text contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
-
-    **2.4.5 Request Execution**
-
-    ```python
-    openai_client.send_omni_request(request_config, request_num=1)  # for omni-understanding models
-    # or
-    openai_client.send_diffusion_request(request_config, request_num=1)  # for diffusion models
-    ```
-
-    **Explanation**:
-
-    **Unified Client**: Uses the OpenAIClientHandler instance to send requests. This client encapsulates error handling, retry mechanisms, and response validation logic.
-
-    **Single Request**: The comment clearly states this is a single-request completion test. For concurrent testing, it can be extended to multiple requests using request_num = n.
-
-    **Implicit Validation**: `send_omni_request`, `send_audio_speech_request`, and `send_diffusion_request` call `assert_*_response` helpers with the session `--run-level`. At `core_model`, checks are limited to success plus cheap payload sanity (non-empty audio/media, format/content-type, optional `min_audio_bytes`). At `advanced_model` and `full_model`, deep validation adds Whisper transcripts, keyword/similarity, diffusion dimension checks, PCM HNR, etc.
-
-    **Audio output debugging**: Deep validation may transcribe returned audio via `convert_audio_bytes_to_text` (Whisper). If an audio keyword or text–audio similarity assertion fails, set `VLLM_OMNI_KEEP_REQUEST_MEDIA=1` before running pytest to keep the intermediate WAV files for inspection (see [Test helper environment variables](#test-helper-environment-variables)).
-
--   ***Run Command (L3 merge)***: `pytest -s -v /tests/e2e/online_serving/test_{model_name}.py -m advanced_model --run-level=advanced_model`
-
--   ***Run Command (L4 nightly expansion)***: `pytest -s -v /tests/e2e/online_serving/test_{model_name}_expansion.py -m full_model --run-level=full_model`
-
-## Chapter 3: L4 Level Testing - Full Functionality, Performance, and Documentation Testing
-
-### 3.1 Testing Purpose
-
-L4 level testing is a comprehensive quality audit before a version release. It expands upon L3, executing ***full*** functional scenarios, conducting systematic ***performance stress tests***, and simultaneously verifying the correctness of accompanying ***example documentation***. Its purpose is to perform deep validation of the system during off-peak nighttime hours, providing quality trend reports for daytime development and data support for release decisions.
-
-
-
-### 3.2 Testing Content and Scope
-
--   ***Full Functionality Testing***: Executes all test cases defined in `test_{model_name}_expansion.py`, covering all implemented features, positive flows, boundary conditions, and exception handling.
--   ***Performance Testing***: Uses `tests/dfx/perf/tests/test_qwen_omni.json`, `tests/dfx/perf/tests/test_tts.json`, and diffusion configs in the form `tests/dfx/perf/tests/test_*_vllm_omni.json` (passed to `run_benchmark.py` via `--test-config-file`) to drive performance testing tools for stress, load, and endurance tests, collecting metrics like throughput, response time, and resource utilization.
--   ***Documentation Testing***: Verifies whether the example code provided to users is runnable and its results match the description.
-
-### 3.3 Test Directory and Execution Files
-
--   ***Functional Testing***: Same directories as L3.
--   ***Performance Test Configuration***: `tests/dfx/perf/tests/test_qwen_omni.json`, `tests/dfx/perf/tests/test_tts.json`, and diffusion configs `tests/dfx/perf/tests/test_*_vllm_omni.json` (e.g. `test_qwen_image_vllm_omni.json`)
--   ***Documentation Example Tests***:
--   -   `tests/example/online_serving/test_{model_name}.py`
-    -   `tests/example/offline_inference/test_{model_name}.py`
-
-### 3.4 Execution Method and Example
-
--   ***Trigger Timing***: **`Nightly`**, automatically executed every night.
--   ***Execution Environment***: ***GPU*** server clusters to meet the resource demands of performance testing.
--   ***Script Example***:
-
-??? example "Test Examples: Documentation Example Tests"
-
-    --8<-- "docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md"
-
-??? example "Test Examples: Performance Tests"
-
-    --8<-- "docs/contributing/ci/test_examples/l4_performance_tests.inc.md"
-
-??? example "Test Examples: Functionality Tests"
-
-    --8<-- "docs/contributing/ci/test_examples/l4_functionality_tests.inc.md"
-
--   ***Run Command***: (Specific commands would depend on the performance testing tool and configuration defined in `nightly.json`).
-
-## Chapter 4: L5 Level Testing - Stability and Reliability Testing
-
-### 4.1 Testing Purpose
-
-L5 level testing focuses on the performance of model services under ***long-running*** and ***abnormal fault*** scenarios. It aims to uncover deep-seated issues that only manifest under sustained pressure or extreme conditions, such as memory leaks, resource contention, gradual performance degradation, and lack of fault tolerance mechanisms. This is the final, yet crucial, line of defense for ensuring service high availability and production environment robustness.
-
-
-
-### 4.2 Testing Content and Scope
-
--   ***Long-term Stability (Stability) Testing***: Uses JSON under `tests/dfx/stability/tests/` (for example `test_qwen3_omni.json` and `test_wan22.json`) to run the service under moderate load for an extended period (e.g., over 12 hours), monitoring whether metrics like memory/VRAM usage, response time, and throughput degrade over time, and whether the service process remains stable.
--   ***Reliability Testing***: Uses pytest suites under `tests/dfx/reliability/` to inject controlled faults against a **live** `vllm_omni serve` instance (same **`omni_server` / `omni_server_function`** fixture style as E2E). Current suites emphasize **GPU memory pressure** (CUDA sidecar “memory hog”), **worker / runtime process kill** (`SIGKILL` on `VLLM::Worker` for Qwen3-Omni, `multiprocessing.spawn` for Wan2.2 video workers, or `vLLM-Omni::` for HunyuanImage DiT workers), **large multimodal chat**, **`/v1/videos`**, **`/v1/images/generations`**, or **`/v1/audio/speech`** jobs under OOM, **`/health` → 503** and **fast-fail / non-hanging concurrent** requests after kill, and **OpenAI-style 5xx error contracts** (e.g. text vs text+audio under OOM). **Post-fault recovery** checks exist where enabled (some cases may be `skip` while issues are tracked). See the Reliability `<details>` block in Section 4.4 for file-level responsibilities and CI markers (`slow`, `hardware_test`, POSIX-only kill).
-
-### 4.3 Test Directory and Execution Files
-
--   ***Stability Test Configuration***: `tests/dfx/stability/tests/test_qwen3_omni.json`, `tests/dfx/stability/tests/test_wan22.json` (one JSON per model / runner family)
--   ***Reliability Test Suite*** (`tests/dfx/reliability/`):
-    -   `test_reliability_qwen3_omni.py` — Qwen3-Omni chat / multimodal reliability (GPU OOM, process kill, recovery, error contract under `--async-chunk` vs default).
-    -   `test_reliability_wan22.py` — Wan2.2 I2V video API reliability (`/v1/videos` under OOM and process kill, recovery).
-    -   `test_reliability_hunyuan_image.py` — HunyuanImage-3.0-Instruct DiT-only reliability (`/v1/images/generations` under OOM and process kill; deploy `hunyuan_image3_dit.yaml`, H100 × 4).
-    -   `test_reliability_voxcpm2.py` — VoxCPM2 TTS reliability (`/v1/audio/speech` under OOM and process kill; deploy `voxcpm2.yaml`, L4 × 1).
-    -   `helpers.py` — Shared primitives used by current suites: raw HTTP probes for `/v1/chat/completions` and `/health`, OpenAI-style error parsing, GPU OOM sidecar (`inject_gpu_oom` / `stop_gpu_oom_hogs`), and `pgrep`-based process-kill injector construction (`make_process_kill_fault_injector`).
-    -   `conftest.py` — `fault_injector` and `omni_server_after_fault` / `omni_server_after_fault_function` fixtures to run a callable **after** the server is ready.
-    -   `README.md` — Short local run commands for this directory.
-
-### 4.4 Execution Method and Example
-
--   ***Trigger Timing***: **`Weekly`** (weekly) or **`Days before Release`** (several days before a major release). Due to long execution times, the frequency is lower.
--   ***Execution Environment***: ***GPU*** servers, requiring a stable and exclusive testing environment.
--   ***Script Example***:
-<details>
-<summary> Test Examples</summary>
-
-When you want to add L5-level stability test cases, add or extend the appropriate JSON file under `tests/dfx/stability/tests/` (for example `test_qwen3_omni.json` for Omni bench traffic, or `test_wan22.json` for diffusion `/v1/videos` workloads). The following illustrates the Qwen3-Omni shape:
-
-```json
-{
-    "test_name": "test_qwen3_omni_stability",
-    "server_params": {
-        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-        "stage_config_name": "qwen3_omni.yaml"
-    },
-    "benchmark_params": [
-        {
-            "dataset_name": "random",
-            "backend": "openai-chat-omni",
-            "endpoint": "/v1/chat/completions",
-            "duration_sec": 43200,
-            "request_rate": 0.5,
-            "num_prompts_per_batch": 20,
-            "random_input_len": 2500,
-            "random_output_len": 900,
-            "ignore_eos": true,
-            "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration"
-        }
-    ]
-}
-```
-
-#### Parameter Explanation
-
-***Overview***
-
-| Field            | Required | Description                                                                 |
-| ---------------- | -------- | --------------------------------------------------------------------------- |
-| test_name        | Yes      | Unique identifier for the stability test case                               |
-| server_params    | Yes      | Server-side configuration parameters (model, stage configuration, etc.)     |
-| benchmark_params | Yes      | Stability benchmark running parameters (supports multiple configurations)   |
-
-#### server_params Configuration
-
-##### Basic Parameters
-
-| Parameter         | Required | Example                            | Description                         |
-| ----------------- | -------- | ---------------------------------- | ----------------------------------- |
-| model             | Yes      | "Qwen/Qwen3-Omni-30B-A3B-Instruct" | Model name or path                  |
-| stage_config_name | Yes      | "qwen3_omni.yaml"                  | Stage configuration file name       |
-
-##### Dynamic Configuration (update/delete)
-
-Supports incremental modifications based on the basic configuration:
-
-| Operation | Description                          |
-| --------- | ------------------------------------ |
-| update    | Update or add configuration items    |
-| delete    | Delete specified configuration items |
-
-***Example***:
-You can refer to Test Examples in Chapter 3.4
-
-#### benchmark_params Configuration
-
-For stability testing, the key parameters are:
-
--   **duration_sec**: Total duration (in seconds) during which benchmark traffic is sent. The stability benchmark will keep sending batches until this duration is reached.
--   **request_rate** / **max_concurrency**: Exactly one of them must be specified. They control how the traffic is generated for each batch:
-    -   `request_rate`: Number of requests per second. The benchmark will send `num_prompts_per_batch` requests at the given rate.
-    -   `max_concurrency`: Maximum number of concurrent requests. When this is used, `request_rate` is set to `inf` internally.
--   **num_prompts_per_batch**: Number of prompts sent in each batch. Multiple batches will be executed sequentially within `duration_sec`.
-
-All other optional parameters follow the same rules as the in Chapter 3.4.
-
-</details>
-
-<details>
-<summary> Reliability test suite (<code>tests/dfx/reliability</code>)</summary>
-
-#### Purpose and relationship to stability
-
-Reliability tests are **short fault-injection** integration runs (L5 **(b)** in `tests/dfx/reliability/README.md`). They complement **stability** JSON-driven long runs: instead of hours of steady traffic, they **perturb** the server (GPU OOM sidecar, fatal signals on selected processes) and check **failure mode** and **latency bounds** (e.g. chat or `/v1/videos` must not hang under concurrent fault-time load).
-
-#### Directory layout
-
-| Path | Responsibility |
-| ---- | -------------- |
-| `helpers.py` | Shared helpers used by current reliability suites: raw `POST`/`GET` probes (`/v1/chat/completions`, `/health`), OpenAI error parsing (`extract_openai_error_contract_from_bytes`), GPU OOM sidecar lifecycle (`inject_gpu_oom`, `stop_gpu_oom_hogs`), and process-kill injector builder (`make_process_kill_fault_injector`). |
-| `conftest.py` | Pytest fixtures: indirect `fault_injector`, `omni_server_after_fault` / `omni_server_after_fault_function` (run injector after server is ready, then yield server). |
-| `test_reliability_qwen3_omni.py` | Qwen3-Omni: OOM vs **text vs text+audio** error contract, large multimodal chat under OOM, concurrent pressure, **SIGKILL** on `VLLM::Worker`, `/health` → 503 + fast-fail + concurrent chat; optional OOM recovery scenario (may be skipped while tracked in issues). |
-| `test_reliability_wan22.py` | Wan2.2 I2V: large `/v1/videos` under OOM, **SIGKILL** on `multiprocessing.spawn` chain, health / fast-fail / concurrent video requests; optional recovery test (may be skipped). |
-| `test_reliability_hunyuan_image.py` | HunyuanImage DiT-only: large `/v1/images/generations` under OOM, **SIGKILL** on `vLLM-Omni::` workers and serve/tree targets, health / fast-fail / concurrent image requests; some OOM/recovery cases may be skipped while tracked in issues. |
-| `test_reliability_voxcpm2.py` | VoxCPM2: `/v1/audio/speech` under OOM (error contract), **SIGKILL** on `VLLM::` workers and serve/tree targets, health / fast-fail / concurrent speech requests; some OOM cases may be skipped while tracked in issues. |
-| `README.md` | Minimal run / collect examples. |
-
-#### Parametrization and markers
-
-- Each test module defines a **`RELIABILITY_SCENARIOS`** list (`test_name`, `server_params`: model, `stage_config_name` or diffusion `server_args`, etc.). **`create_reliability_omni_server_params()`** in `tests/dfx/conftest.py` resolves stage paths (including XPU substitutions where applicable) and builds **`OmniServerParams`** lists consumed by **`@pytest.mark.parametrize(..., indirect=True)`** on `omni_server` or `omni_server_function`.
-- Cases are tagged **`@pytest.mark.slow`** for weekly / selective CI. GPU-heavy suites use **`@hardware_test(res={"cuda": "H100"}, num_cards=...)`** or **`@hardware_test(res={"cuda": "L4"}, num_cards=1)`** (Qwen3-Omni **2**× H100; Wan2.2 **1**× H100; HunyuanImage DiT **4**× H100; VoxCPM2 **1**× L4).
-- **Process-kill** tests use **`@pytest.mark.skipif(os.name == "nt", ...)`** because injection uses POSIX **`pgrep` / `kill`**.
-
-#### CI trigger
-
-Weekly Buildkite (`.buildkite/test-weekly.yml`) runs one step per model suite (trigger: `WEEKLY=1` or PR label `weekly-test`), for example:
-
-| Buildkite step | Test file | CI hardware |
-| -------------- | --------- | ----------- |
-| Reliability Test - qwen3-omni | `test_reliability_qwen3_omni.py` | H100 × 2 (`mithril-h100-pool`) |
-| Reliability Test - wan22 | `test_reliability_wan22.py` | H100 × 2 (`mithril-h100-pool`) |
-| Reliability Test - hunyuan-image | `test_reliability_hunyuan_image.py` | H100 × 4 (`mithril-h100-pool`) |
-| Reliability Test - voxcpm2 | `test_reliability_voxcpm2.py` | L4 × 1 (`gpu_1_queue`) |
-
-```bash
-pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m "slow"
-pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m "slow"
-pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m "slow"
-pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m "slow"
-```
-
-#### Local commands
-
-```bash
-pytest --collect-only tests/dfx/reliability
-pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m slow
-pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m slow
-pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m slow
-pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m slow
-```
-
-#### Adding a new model suite
-
-1. Add `test_reliability_<model>.py` under `tests/dfx/reliability/`.
-2. Define **`RELIABILITY_SCENARIOS`** and pass them through **`create_reliability_omni_server_params()`** with the correct deploy or e2e stage-config directory (same pattern as existing files).
-3. Reuse **`helpers`** for OOM / kill / raw HTTP; prefer **`assert_fault_exception()`** and **`resolve_oom_device_spec()`** from `tests/dfx/conftest.py` for consistent device selection vs stage YAML.
-4. Register **`slow`** (and **`hardware_test`** if needed); extend **`.buildkite/test-weekly.yml`** when the suite should run in weekly L5.
-
-</details>
-
--   -   ***Stability***: `pytest -s -v tests/dfx/stability/scripts/test_stability_qwen3_omni.py` or `pytest -s -v tests/dfx/stability/scripts/test_stability_wan22.py` (or add `test_stability_<model>.py` alongside a matching JSON config)
-    -   ***Reliability***: `pytest -s -v tests/dfx/reliability/test_reliability_<model>.py -m slow` (current suites: `qwen3_omni`, `wan22`, `hunyuan_image`, `voxcpm2`; add `test_reliability_<suite>.py` and a matching step in `.buildkite/test-weekly.yml` for new models)
-
-## Summary
-
-This multi-level testing system achieves continuous, progressive validation of model service quality by tightly integrating testing activities with the development workflow (commit, review, merge, release). From rapid unit testing to comprehensive end-to-end testing, and further to in-depth performance, stability, and reliability verification, each level has clear objectives, collectively building a robust quality protection net. By following this system, teams can deliver high-quality, highly reliable model services more efficiently.
diff --git a/docs/contributing/ci/ci_settings.md b/docs/contributing/ci/ci_settings.md
new file mode 100644
index 000000000..ff4b8e107
--- /dev/null
+++ b/docs/contributing/ci/ci_settings.md
@@ -0,0 +1,344 @@
+# CI Settings
+
+This document describes **where** Buildkite YAML lives in the repo, **how each platform organizes CI**, and **how to add a new job**. It does not document agent queues, GPU types, or container plugin details—those belong in infra / preset files (for example `.buildkite/common/ci_mirror_hardwares.yml`).
+
+For CI levels (L1–L5) and triggers, see [Test System Overview](./test_system_overview.md). For test authoring, see [Test Writing Guide](./test_writing_guide.md). For running tests locally or replaying CI jobs, see [Test Execution Guide](./test_execution_guide.md).
+
+## Directory layout
+
+Canonical layout (prefer these paths for new changes):
+
+```
+.buildkite/
+├── common/                          # Shared across platforms
+│   ├── scripts/
+│   │   ├── skip_ci.py               # skip-ci decision (docs / skip-mark / CI YAML paths)
+│   │   ├── upload_pipeline.py       # Bootstrap + test-pipeline uploader (CUDA/NPU)
+│   │   └── resolve_skip_ci.sh       # Shell helpers for AMD/Intel bootstrap
+│   └── ci_mirror_hardwares.yml      # CUDA uploader presets (referenced by name only)
+├── cuda/                            # Primary NVIDIA CUDA CI
+│   ├── pipeline.yml                 # Bootstrap entry (hook upload)
+│   ├── bootstrap-upload-steps.yml   # Bootstrap child steps (upload_pipeline --upload)
+│   ├── test-ready.yml               # L2
+│   ├── test-merge.yml               # L3
+│   ├── test-nightly.yml             # L4
+│   ├── test-weekly.yml              # L5
+│   └── rebase-pipeline.yml
+├── npu/
+│   ├── pipeline-npu.yml             # Bootstrap entry (hook upload)
+│   ├── bootstrap-upload-steps.yml   # Bootstrap child steps (upload_pipeline --upload)
+│   ├── pipeline-npu-a3.yml          # A3 variant (when used)
+│   ├── test-npu-ready.yml           # L2
+│   ├── test-npu-nightly.yml         # L4
+│   └── scripts/
+├── amd/
+│   ├── test-amd-ready.yml           # L2 job definitions (template input)
+│   ├── test-amd-merge.yml           # L3 job definitions
+│   ├── test-template-amd-omni.j2    # Renders final pipeline.yaml
+│   └── scripts/
+│       ├── bootstrap-amd-omni.sh    # Entry: skip-ci → Jinja → upload
+│       └── run-amd-test.sh          # Wraps pytest inside ROCm docker
+├── intel/
+│   ├── pipeline-intel.yml           # Static Intel XPU pipeline
+│   └── scripts/
+│       ├── bootstrap-intel-omni.sh
+│       └── run-xpu-test.sh
+└── release/
+    ├── release-pipeline.yml
+    └── scripts/
+```
+
+**Placement rules**
+
+| Rule | Detail |
+| ---- | ------ |
+| Platform code under platform dir | New CUDA jobs go in `.buildkite/cuda/`; do not add new top-level `.buildkite/test-*.yml` files. |
+| Shared logic in `common/` | Skip-ci and CUDA upload rendering stay in `.buildkite/common/scripts/`. |
+| Bootstrap vs test YAML | **Bootstrap** (`pipeline*.yml`) builds images and uploads **child** test pipelines. **Test** YAML (`test-*.yml`) lists pytest steps only. |
+| Register CI YAML in `skip_ci.py` | If you add a new whitelisted test pipeline file, update `L2_YAML_FILES`, `L3_YAML_FILES`, or `L45_YAML_FILES` in `.buildkite/common/scripts/skip_ci.py` so skip-ci paths stay correct. |
+
+There are still **legacy copies** at `.buildkite/*.yaml` (without the `cuda/` prefix). Treat `.buildkite/cuda/*` as source of truth.
+
+## Platform comparison
+
+| Platform | Bootstrap entry | Test job files | Upload mechanism | Job hardware in YAML |
+| -------- | ---------------- | -------------- | ---------------- | -------------------- |
+| **CUDA** | `cuda/pipeline.yml` | `test-ready.yml`, `test-merge.yml`, `test-nightly.yml`, `test-weekly.yml` | `upload_pipeline.py --upload` (expands uploader-only keys) | `mirror_hardwares: <preset>` (string) |
+| **NPU** | `npu/pipeline-npu.yml` | `test-npu-ready.yml`, `test-npu-nightly.yml` | `upload_pipeline.py --upload` | `mirror_hardwares: a2b3_npu_1` / `a2b3_npu_4` / `a3_npu_2` |
+| **AMD** | `amd/scripts/bootstrap-amd-omni.sh` | `test-amd-ready.yml`, `test-amd-merge.yml` | Jinja (`test-template-amd-omni.j2`) → `pipeline upload` | `agent_pool` + `mirror_hardwares: [amdproduction]` (array, template filter) |
+| **Intel** | `intel/scripts/bootstrap-intel-omni.sh` | `intel/pipeline-intel.yml` (steps inline) | Direct `pipeline upload` | Inline `agents.queue` on each step |
+
+## Platform configuration style
+
+=== "CUDA"
+
+    **Bootstrap:** [`cuda/pipeline.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/pipeline.yml) (hook upload) + [`cuda/bootstrap-upload-steps.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/bootstrap-upload-steps.yml) (child steps). Document 1 runs [`upload_pipeline.py --upload .buildkite/cuda/bootstrap-upload-steps.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py), which injects `if` by step `key` from skip-ci and uploads image build plus L2–L5 child pipeline upload steps (see [Diff-aware CI — Bootstrap skip](#bootstrap-skip)).
+
+    **Test YAML:** `cuda/test-ready.yml` (L2), `test-merge.yml` (L3), `test-nightly.yml` (L4), `test-weekly.yml` (L5). Each file starts with shared `env:` then `steps:`.
+
+    | CI level | File | Typical trigger |
+    | -------- | ---- | ----------------- |
+    | L2 | `cuda/test-ready.yml` | `ready` label |
+    | L3 | `cuda/test-merge.yml` | `merge-test` label / main merge |
+    | L4 | `cuda/test-nightly.yml` | `nightly-test` label or `NIGHTLY=1` |
+    | L5 | `cuda/test-weekly.yml` | `weekly-test` label or `WEEKLY=1` |
+
+    **Upload:** `upload_pipeline.py --upload` expands uploader-only keys before Buildkite upload.
+
+    **Hardware in YAML:** `mirror_hardwares: <preset>` (string)—preset names in [`common/ci_mirror_hardwares.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/ci_mirror_hardwares.yml). Do **not** set `agents` / `plugins` on the same step.
+
+    **Conventions**
+
+    - **`depends_on`:** leaf jobs depend on `upload-ready-pipeline`, `upload-merge-pipeline`, etc.
+    - **`group` / `label`:** `:card_index_dividers:` groups; labels like `Diffusion · Qwen Image Test`.
+    - **`commands`:** `timeout … pytest …` with markers and `--run-level` for the pipeline level.
+    - **`source_file_dependencies`:** required on **E2E Test** leaf jobs in L2/L3; see [Step filtering](#step-filtering).
+
+    **Adding a job**
+
+    1. Pick the level file (ready / merge / nightly / weekly).
+    2. Add a step under the right **group** (usually **E2E Test** for model pytest).
+    3. Set `label`, `commands`, `mirror_hardwares`, `depends_on: upload-<level>-pipeline`.
+    4. For L2/L3 E2E, add `source_file_dependencies` (pytest + model + deploy YAML prefixes).
+    5. Dry-run:
+
+    ```bash
+    python3 .buildkite/common/scripts/upload_pipeline.py .buildkite/cuda/test-ready.yml
+    ```
+
+=== "NPU"
+
+    **Bootstrap:** [`npu/pipeline-npu.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/npu/pipeline-npu.yml) + [`npu/bootstrap-upload-steps.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/npu/bootstrap-upload-steps.yml)—same split as CUDA; builds A2/B3 and A3 CI images, then uploads child test pipelines.
+
+    **Test YAML:** `npu/test-npu-ready.yml` (L2), `test-npu-nightly.yml` (L4).
+
+    **Upload:** same as CUDA—`upload_pipeline.py --upload`.
+
+    **Hardware in YAML:** `mirror_hardwares` preset (string), expanded to `agents`, top-level `image`, and `plugins`. Presets: `a2b3_npu_1`, `a2b3_npu_4`, `a3_npu_2` in `common/ci_mirror_hardwares.yml`.
+
+    **Conventions**
+
+    - **`depends_on: upload-ready-pipeline`** (or `upload-nightly-pipeline`) ties jobs to bootstrap upload keys.
+    - Do not duplicate `agents` / `image` / `plugins` when using `mirror_hardwares`.
+
+    **Adding a job**
+
+    1. Edit `test-npu-ready.yml` (L2) or `test-npu-nightly.yml` (L4).
+    2. Add a step with `mirror_hardwares` (add a new preset in `ci_mirror_hardwares.yml` first if needed).
+    3. Set `commands` to your pytest file and markers.
+    4. Dry-run:
+
+    ```bash
+    python3 .buildkite/common/scripts/upload_pipeline.py .buildkite/npu/test-npu-ready.yml
+    ```
+
+    5. Register new pipeline paths in `skip_ci.py` (`L2_YAML_FILES` or `L45_YAML_FILES`) when applicable.
+
+=== "AMD"
+
+    **Bootstrap:** [`amd/scripts/bootstrap-amd-omni.sh`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/amd/scripts/bootstrap-amd-omni.sh)—skip-ci, diff filtering, Jinja render, then `buildkite-agent pipeline upload`.
+
+    **Test YAML (data):** `amd/test-amd-ready.yml` (L2 / PR), `test-amd-merge.yml` (L3 / main).
+
+    **Rendering:** [`test-template-amd-omni.j2`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/amd/test-template-amd-omni.j2) wraps data steps with `amd-build` image build and `amd_<agent_pool>` queues. Do **not** hand-edit generated `pipeline.yaml`.
+
+    **Hardware in YAML:** `agent_pool` (for example `mi325_1`) plus `mirror_hardwares: [amdproduction]` (array—Buildkite template filter, not the CUDA/NPU uploader preset mechanism).
+
+    **Data file fields**
+
+    | Field | Purpose |
+    | ----- | ------- |
+    | `agent_pool` | ROCm pool; template maps to `queue: amd_<pool>`. |
+    | `mirror_hardwares` | Which mirror HW runs the step (for example `[amdproduction]`). |
+    | `commands` | Passed into `run-amd-test.sh` via `TEST_COMMAND`. |
+
+    **Adding a job**
+
+    1. Edit `test-amd-ready.yml` or `test-amd-merge.yml`.
+    2. Copy a neighboring block: `label`, `agent_pool`, `mirror_hardwares`, `commands`, optional `grade`.
+    3. Regenerate via bootstrap / Jinja; update `skip_ci.py` if you add a new YAML path.
+
+=== "Intel"
+
+    **Bootstrap:** [`intel/scripts/bootstrap-intel-omni.sh`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/intel/scripts/bootstrap-intel-omni.sh)—skip-ci, then direct `pipeline upload`.
+
+    **Test YAML:** steps live inline in [`intel/pipeline-intel.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/intel/pipeline-intel.yml); runners under `intel/scripts/` (for example `run-xpu-test.sh`).
+
+    **Upload:** `buildkite-agent pipeline upload` (no `upload_pipeline.py` mirror expansion).
+
+    **Hardware in YAML:** inline `agents.queue` (for example `intel-gpu-omni`) on each step.
+
+    **Adding a job**
+
+    1. Add a step to `pipeline-intel.yml`, or extend an existing runner script.
+    2. Match `agents`, `env`, `timeout_in_minutes`, and `command`/`commands` with sibling steps.
+    3. Keep `pipeline-intel.yml` listed in `L2_YAML_FILES` in `skip_ci.py`.
+
+## Cross-cutting conventions
+
+### Diff-aware CI {#diff-aware-ci}
+
+PR diffs drive **two independent skip layers**. Both read changed files from git, but at different pipeline stages and with different granularity:
+
+| Layer | Script | When | What is skipped | Where you configure |
+| ----- | ------ | ---- | --------------- | ------------------- |
+| **Bootstrap** | [`skip_ci.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/skip_ci.py) + [`upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) | Before child test pipelines upload (`cuda/pipeline.yml`, `npu/pipeline-npu.yml`, AMD/Intel bootstraps) | Entire default CI, or whole L2/L3 upload for a platform | Whitelists in `skip_ci.py`; bootstrap `if` injected by step `key` in `upload_pipeline.py` |
+| **Step filter** | [`upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) | While uploading CUDA L2/L3 YAML | Individual Buildkite steps inside `test-ready.yml` / `test-merge.yml` | `source_file_dependencies` on each step or group |
+
+**Changed files** (both layers):
+
+| Build context | Diff command |
+| --- | --- |
+| Pull request | `git diff --name-only origin/<base>...<BUILDKITE_COMMIT>` |
+| `main` push | `git diff --name-only <commit>^..<commit>` |
+| Local dry-run / non-PR | Diff unavailable → bootstrap and step filter both keep all steps; uploader-only keys are still stripped |
+
+Label triggers (`ready`, `merge-test`) are unchanged—diff-aware logic only reduces what runs **after** a pipeline is already scheduled.
+
+#### Bootstrap skip {#bootstrap-skip}
+
+[`skip_ci.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/skip_ci.py) classifies the git diff into buckets (docs / qualifying skip-mark / whitelisted L2·L3·L4/L5 YAML / other), then picks one decision path. CUDA/NPU apply that decision by injecting Buildkite `if` on `bootstrap-upload-steps.yml` step keys; AMD/Intel call `gate_bootstrap_ci <platform> <l2|l3>`.
+
+##### Decision overview
+
+| Diff shape | Path | Default L2/L3 |
+| --- | --- | --- |
+| Product code / non-whitelisted paths | normal CI | all on |
+| Docs and/or qualifying skip-mark only | `skip_all` | all off (scheduled `main` NIGHTLY/WEEKLY exceptions below) |
+| Whitelisted CI YAML only | yaml-gated (`skip_l2_l3`) | per platform/level matrix |
+| Docs/skip-mark **+** whitelisted CI YAML | yaml-gated (`skip_l2_l3`) | same as CI-YAML-only (does **not** widen to normal CI) |
+| Non-qualifying skip-mark and no CI YAML | normal CI | all on |
+| Diff unavailable | normal CI | all on |
+
+**`skip_all` exceptions (CUDA/NPU bootstrap only):** PR labels (`nightly-test`, `merge-test`, `npu-test`, `weekly-test`, …) do **not** revive jobs. On `main`, scheduled `NIGHTLY=1` still builds the image and uploads L4 plus L2/L3 (with `--e2e`); `WEEKLY=1` still builds the image and uploads L5 (CUDA).
+
+**Yaml-gated nightly/weekly:** L4/L5 upload steps keep their normal label / `NIGHTLY` / `WEEKLY` conditions (for example PR `nightly-test` still uploads nightly). Only L2/L3 upload steps are matrix-gated.
+
+##### Whitelisted CI YAML → platform
+
+Register new files in `L2_YAML_FILES`, `L3_YAML_FILES`, or `L45_YAML_FILES` in `skip_ci.py`.
+
+| Level | File | Platform |
+| --- | --- | --- |
+| L2 | `.buildkite/cuda/test-ready.yml` | cuda |
+| L2 | `.buildkite/npu/test-npu-ready.yml` | npu |
+| L2 | `.buildkite/amd/test-amd-ready.yml` | amd |
+| L2 | `.buildkite/intel/pipeline-intel.yml` | intel |
+| L3 | `.buildkite/cuda/test-merge.yml` | cuda |
+| L3 | `.buildkite/amd/test-amd-merge.yml` | amd |
+| L4/L5 | `.buildkite/cuda/test-nightly.yml`, `test-weekly.yml` | cuda |
+| L4/L5 | `.buildkite/npu/test-npu-nightly.yml` | npu |
+
+##### Yaml-gated category branches
+
+`L2?` / `L3?` / `L45?` = whether any file in that whitelist changed. Untouched platforms/levels end up off.
+
+| ID | L2? | L3? | L45? | Enabled L2/L3 |
+| --- | --- | --- | --- | --- |
+| G1 | | | ✓ | none (all L2/L3 off) |
+| G2 | ✓ | | | L2 only on platforms whose L2 YAML changed |
+| G3 | | ✓ | | L3 only on platforms whose L3 YAML changed |
+| G4 | ✓ | ✓ | | union of G2 and G3 (same platform ready+merge → both on) |
+| G5 | ✓ | | ✓ | same as G2 (L45 rescued by L2 YAML) |
+| G6 | | ✓ | ✓ | same as G3 (L45 rescued by L3 YAML) |
+| G7 | ✓ | ✓ | ✓ | same as G4 |
+
+##### Yaml-gated examples (platform-level)
+
+Docs/skip-mark mixed with any row below follows the same matrix.
+
+| Diff (whitelist) | Branch | Enabled L2/L3 |
+| --- | --- | --- |
+| Only `cuda/test-ready.yml` | G2 | `cuda/l2` |
+| Only `amd/test-amd-ready.yml` | G2 | `amd/l2` |
+| Only `npu/test-npu-ready.yml` | G2 | `npu/l2` |
+| Only `intel/pipeline-intel.yml` | G2 | `intel/l2` |
+| Only `cuda/test-merge.yml` | G3 | `cuda/l3` |
+| Only `amd/test-amd-merge.yml` | G3 | `amd/l3` |
+| CUDA ready + CUDA merge | G4 | `cuda/l2` + `cuda/l3` |
+| CUDA ready + AMD merge | G4 | `cuda/l2` + `amd/l3` |
+| CUDA ready + AMD ready | G2 | `cuda/l2` + `amd/l2` |
+| CUDA merge + AMD merge | G3 | `cuda/l3` + `amd/l3` |
+| Only nightly / weekly / npu-nightly YAML | G1 | (none) |
+| CUDA ready + nightly | G5 | `cuda/l2` |
+| CUDA merge + nightly | G6 | `cuda/l3` |
+| CUDA ready + merge + nightly | G7 | `cuda/l2` + `cuda/l3` |
+
+##### How platforms consume the decision
+
+| Platform | Mechanism |
+| --- | --- |
+| **CUDA** | `upload_pipeline.py` injects `if` by step `key` (`image-build`, `upload-ready-pipeline`, `upload-merge-pipeline`, …) from `is_run(cuda, l2/l3)` |
+| **NPU** | Same injection; no merge upload step (L3 always off in bootstrap) |
+| **AMD / Intel** | `gate_bootstrap_ci <platform> <l2\|l3>` exits 0 when `skip_all` or that target is off |
+
+Unit coverage: `tests/buildkite/test_skip_ci.py`.
+
+#### Step filtering {#step-filtering}
+
+CUDA **L2** (`.buildkite/cuda/test-ready.yml`) and **L3** (`.buildkite/cuda/test-merge.yml`) only. Bootstrap upload entry: `upload_pipeline.py --upload .buildkite/cuda/bootstrap-upload-steps.yml`.
+
+**Uploader-only keys** — removed before Buildkite sees the YAML; never used at runtime on agents:
+
+| Key | Purpose |
+| --- | ------- |
+| `source_file_dependencies` | List of path **prefixes**. If any changed file equals a prefix or starts with `prefix/`, keep the step (or group); otherwise omit it. |
+| `mirror_hardwares` | Expand to `agents` + `plugins` (+ optional `image`) from `ci_mirror_hardwares.yml`. |
+
+**Policy**
+
+- **Always uploaded** (no key): groups outside **E2E Test**—Simple Test, Diffusion unit tests, Engine/Model Executor, Distributed, Custom Pipeline, Entrypoints (L2), LoRA / Entrypoints (L3).
+- **Diff-gated**: every **E2E Test** leaf job. List the smallest prefix set per step—pytest file(s), model code under `vllm_omni/model_executor/models/` or `vllm_omni/diffusion/models/`, plus `stage_input_processors/` and `vllm_omni/deploy/*.yaml` when applicable. A **group** may define the key instead; the whole group drops if no prefix matches.
+
+**YAML examples**
+
+```yaml
+      - label: "Diffusion · Qwen Image Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen_image.py
+          - vllm_omni/diffusion/models/qwen_image/
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'core_model' ...
+        mirror_hardwares: h100_1
+
+      - label: "TTS · Qwen3-TTS CustomVoice Test"
+        source_file_dependencies:
+          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
+          - vllm_omni/model_executor/models/qwen3_tts/
+          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+          - vllm_omni/deploy/qwen3_tts.yaml
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py ...
+        mirror_hardwares: l4_4
+```
+
+**Local dry-run**
+
+```bash
+python3 .buildkite/common/scripts/upload_pipeline.py .buildkite/cuda/test-ready.yml
+python3 .buildkite/common/scripts/upload_pipeline.py .buildkite/cuda/test-merge.yml | grep source_file_dependencies
+# (no output expected)
+```
+
+On PR builds, `upload_pipeline.py` logs `skip '…' (no changes under …)` for omitted steps.
+
+### Labels and grouping
+
+- Use **groups** for dashboard readability; keep **E2E Test** as the group name CUDA diff filtering expects for `--e2e` nightly runs on main.
+- Prefix labels by model domain: **Omni ·**, **TTS ·**, **Diffusion ·**, **Simple ·**, etc., matching existing steps.
+
+### Validation checklist
+
+| Check | Command / location |
+| ----- | ------------------ |
+| CUDA render | `python3 .buildkite/common/scripts/upload_pipeline.py .buildkite/cuda/test-<level>.yml` |
+| No leaked uploader keys | `… \| grep -E 'mirror_hardwares|source_file_dependencies'` → empty |
+| Skip-ci / upload unit tests | `pytest tests/buildkite/` |
+| Local job replay (CUDA L2+) | `tools/run_ready_jobs.sh`, `tools/run_merge_jobs.sh`, `tools/nightly/run_nightly_jobs.sh` (read YAML from `cuda/`) |
+
+## Related documentation
+
+- [Test System Overview](./test_system_overview.md) — L1–L5 scope, triggers, test pyramid
+- [Test Writing Guide](./test_writing_guide.md) — markers, directories, L1–L5 examples
+- [Test Execution Guide](./test_execution_guide.md) — running CI-aligned jobs locally
+- Implementation: `.buildkite/common/scripts/upload_pipeline.py`, `.buildkite/common/scripts/skip_ci.py`
diff --git a/docs/contributing/ci/failures.md b/docs/contributing/ci/failures.md
index 80699e6a5..9743097cf 100644
--- a/docs/contributing/ci/failures.md
+++ b/docs/contributing/ci/failures.md
@@ -79,7 +79,7 @@ For resilience behavior under injected process signals/OOM pressure (validation
 
 ### Running Tests Locally
 
-For instructions on running tests locally (including specific test files, functions, and markers), see the [Running Tests](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/ci/test_guide/#running-tests) section in the Test Guide.
+For instructions on running tests locally (including specific test files, functions, and markers), see the [Running Tests](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/ci/test_execution_guide/#running-tests) section in the Test Execution guide.
 
 ## Step 4: Raise an Issue or Fix It
 
diff --git a/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md b/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md
index 688933f13..5e65d2f48 100644
--- a/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md
+++ b/docs/contributing/ci/test_examples/l4_functionality_tests.inc.md
@@ -1,6 +1,6 @@
 **Scope**
 
-For diffusion models, the L4 functionality test covers all or common *diffusion features* that are supported by this model, including several [parallelism acceleration methods](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/parallelism_acceleration/), [CPU offloading](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/cpu_offload_diffusion/), [TeaCache](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/teacache/) and [Cache-DiT](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/cache_dit_acceleration/) cache backends, [quantization methods](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/quantization/overview/).
+For diffusion models, the L4 functionality test covers all or common *diffusion features* that are supported by this model, including several [parallelism acceleration methods](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/parallelism_acceleration/), [CPU offloading](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/cpu_offload/), [TeaCache](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/teacache/) and [Cache-DiT](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/diffusion/cache_dit_acceleration/) cache backends, [quantization methods](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/quantization/overview/).
 
 **Test Case Design**
 
@@ -37,7 +37,7 @@ Currently all the features are available in online serving mode. Hence, only nee
 **Code Style**
 
 - Validation: test that the multimodal output files of your model have the correct shapes. `OpenAIClientHandler.send_diffusion_request` should have taken care of this.
-- Test marks: always add `full_model` and `diffusion` for L4 nightly `test_*_expansion.py` cases. Add GPU-related marks if needed. Ref: [Markers for Tests](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/ci/tests_markers/).
+- Test marks: always add `full_model` and `diffusion` for L4 nightly `test_*_expansion.py` cases. Add GPU-related marks if needed. Ref: [Markers for Tests](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/ci/test_writing_guide/#markers-for-tests).
 - To maximize code reuse, you may refer to
     - `tests/conftest.py` for `omni_server` (running server in subprocess) and `openai_client` fixtures (sending requests and validating output), `generate_synthetic_image` and `assert_XXX_valid` helper.
     - `tests/helpers/mark.py` for `@hardware_test(...)` and `hardware_marks`.
diff --git a/docs/contributing/ci/test_examples/l4_performance_tests.inc.md b/docs/contributing/ci/test_examples/l4_performance_tests.inc.md
index f1f3073dc..8ff27ee08 100644
--- a/docs/contributing/ci/test_examples/l4_performance_tests.inc.md
+++ b/docs/contributing/ci/test_examples/l4_performance_tests.inc.md
@@ -1,14 +1,41 @@
-When you want to add L4-level ***performance test*** cases, you can refer to the following format for case addition in `tests/dfx/perf/tests/test_qwen_omni.json`, `tests/dfx/perf/tests/test_tts.json`, or diffusion configs such as `tests/dfx/perf/tests/test_*_vllm_omni.json` (selected via `pytest ... run_benchmark.py --test-config-file <path>`):
+When you want to add L4-level ***performance test*** cases, add entries to JSON files under `tests/dfx/perf/tests/` and run them via `tests/dfx/perf/scripts/run_benchmark.py` (omni / TTS) or `run_diffusion_benchmark.py` (diffusion).
+
+**Config file layout (in-tree examples)**
+
+| Model type | Runner | Example JSON files |
+| ---------- | ------ | ------------------ |
+| Omni | `run_benchmark.py` | `test_qwen3_omni_no_async_chunk.json`, `test_qwen3_omni_async_chunk.json`, `test_qwen3_omni_vllm_text.json`, `test_qwen3_omni_multi_replicas.json` |
+| TTS | `run_benchmark.py` | `test_tts.json`, `test_voxcpm2.json`, `test_higgs_audio_v3.json` |
+| Diffusion | `run_diffusion_benchmark.py` | `test_qwen_image_vllm_omni.json`, `test_bagel_vllm_omni.json`, `test_wan22_i2v_vllm_omni.json`, `test_cosmos3_vllm_omni.json`, … |
+
+**How runners pick cases**
+
+Without **`--test-config-file`**, each runner scans all `*.json` under `tests/dfx/perf/tests/` but only keeps its own model type:
+
+- **`run_benchmark.py`**: omni and TTS cases only (skips diffusion JSON).
+- **`run_diffusion_benchmark.py`**: diffusion cases only (skips omni / TTS JSON).
+
+Diffusion cases are detected when the JSON has `server_type` (typically `"vllm-omni"`) or `"diffusion"` in the `mark` array. Omni / TTS JSON has neither.
+
+**Running perf cases**
+
+Pass **`--test-config-file`** to run one JSON file as-is, or omit it for the bulk scan above and filter with pytest **`-m`** on each case's JSON `mark` (for example `pytest … run_benchmark.py -m "full_model and tts and H100"`).
 
 ```JSON
 {
-    "test_name": "test_qwen3_omni",
+    "test_name": "test_qwen3_omni_async_chunk",
+    "mark": [
+        {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}},
+        "full_model",
+        "omni"
+    ],
     "server_params": {
         "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
         "stage_config_name": "qwen3_omni.yaml"
     },
     "benchmark_params": [
         {
+            "name": "random_10p",
             "dataset_name": "random",
             "num_prompts": [10, 20],
             "max_concurrency": [1, 4],
@@ -17,9 +44,11 @@ When you want to add L4-level ***performance test*** cases, you can refer to the
             "ignore_eos": true,
             "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
             "baseline": {
-                "mean_ttft_ms": [500, 800],
-                "mean_audio_ttfp_ms": [2000, 3500],
-                "mean_audio_rtf": [0.25, 0.35]
+                "H100": {
+                    "mean_ttft_ms": [500, 800],
+                    "mean_audio_ttfp_ms": [2000, 3500],
+                    "mean_audio_rtf": [0.25, 0.35]
+                }
             }
         }
     ]
@@ -33,8 +62,91 @@ When you want to add L4-level ***performance test*** cases, you can refer to the
 | Field            | Required | Description                                                     |
 | ---------------- | -------- | --------------------------------------------------------------- |
 | test_name        | Yes      | Unique identifier for the test case                             |
+| mark             | No       | Pytest marks for this case (see **`mark` field** below). Omit only for configs not meant to be filtered by `-m`. |
 | server_params    | Yes      | Server-side configuration parameters                            |
 | benchmark_params | Yes      | Benchmark running parameters (supports multiple configurations) |
+| server_type      | Diffusion only | When set (e.g. `"vllm-omni"`), routes the case to `run_diffusion_benchmark.py`. |
+| benchmark_endpoint | Diffusion only | API path for the benchmark client (e.g. `/v1/videos`, `/v1/images/generations`). |
+
+**`mark` field**
+
+Optional top-level field on each perf JSON **case object** (one per `test_name`). `run_benchmark.py` and `run_diffusion_benchmark.py` read it via `tests.dfx.conftest.resolve_pytest_marks` and attach the marks to the corresponding `pytest.param`, so you can filter locally with `-m`.
+
+When `mark` is present, it must be an **array** with exactly one ``hardware_marks`` object (same shape as `@hardware_test` / `hardware_marks()` in `tests/helpers/mark.py`), followed by registered pytest marker name strings such as `full_model`, `omni`, `tts`, `diffusion`, or `local_model`.
+
+Supported form:
+
+| Form | Example | Effect |
+| ---- | ------- | ------ |
+| Array (single platform) | `"mark": [{"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}}, "full_model", "diffusion"]` | Hardware marks from `hardware_marks(...)`; `num_cards` > 1 adds `distributed_*` (+ CUDA `skipif_cuda` when applicable). String entries become extra pytest marks. |
+| Array (multi-platform) | `"mark": [{"hardware_marks": {"res": {"cuda": "H100", "rocm": "MI325", "npu": "A2"}, "num_cards": {"cuda": 2, "rocm": 2, "npu": 1}}}, "full_model", "omni"]` | Same as above, but declares **multiple platforms** in one case. Filter examples: `-m "full_model and H100 and cuda"`, `-m "full_model and MI325 and rocm"`. |
+
+Recommended for L4 perf cases:
+
+```JSON
+{
+    "test_name": "test_bagel_single_device_single_stage_t2i",
+    "mark": [
+        {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}},
+        "full_model",
+        "diffusion"
+    ],
+    "server_type": "vllm-omni",
+    "server_params": { "...": "..." },
+    "benchmark_params": [ { "name": "1024x1024_steps20", "...": "..." } ]
+}
+```
+
+Multi-GPU diffusion (example: Cosmos3 with `cfg-parallel-size=2`):
+
+```JSON
+{
+    "test_name": "test_cosmos3_t2i_official_demo_2gpu",
+    "mark": [
+        {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}},
+        "full_model",
+        "diffusion"
+    ],
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/images/generations",
+    "server_params": { "...": "..." },
+    "benchmark_params": [ { "name": "1024x1024_steps4", "...": "..." } ]
+}
+```
+
+- Omni perf: include `"omni"` in the `mark` array
+- TTS perf: include `"tts"` in the `mark` array
+- Diffusion perf: include `"diffusion"` in the `mark` array
+- HunyuanImage local-weight cases: add `"local_model"` to the `mark` array
+
+**Parametrization IDs**
+
+Each `(server, benchmark index)` pair becomes one `pytest.param` with id `{test_name}-{suffix}`. The suffix comes from `benchmark_params[].name` when set (for example `test_tts-p0`, `test_omni-p1`); otherwise it is derived from fields like `task` / `eval_phase`.
+
+**Benchmark result filenames**
+
+Result files use the **runtime** hardware label from `get_runtime_resource_label()` (detected GPU/NPU name on the machine that ran the job), **not** `mark.hardware_marks.res`. On the default H100 CI pool, `H100` is **omitted** from filenames (`resource_label_for_filename`).
+
+Examples:
+
+- Omni/TTS: `result_{test_name}_{optional_hw}_{dataset}_....json` under `BENCHMARK_DIR`
+- Diffusion: one aggregate `diffusion_result_{config_stem}_{optional_hw}_{timestamp}.json` per source JSON file (array of all runs from that file)
+
+**Local commands**
+
+```bash
+# Bulk load + filter by JSON mark
+pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and H100 and diffusion"
+pytest -s -v tests/dfx/perf/scripts/run_benchmark.py -m "full_model and omni and H100"
+
+# Single file (same as nightly CI Perf steps)
+pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py \
+  --test-config-file tests/dfx/perf/tests/test_bagel_vllm_omni.json
+pytest -s -v tests/dfx/perf/scripts/run_benchmark.py \
+  --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+```
+
+See also [Markers for Tests](#markers-for-tests) for registered hardware markers (`H100`, `L4`, `cuda`, `distributed_cuda`, …).
 
 **`server_params` Configuration**
 
@@ -79,11 +191,13 @@ You can add any benchmark running parameters you need here. For all optional par
 1.  Change the --xxx-xx-xx running parameters to xxx_xx_xx format and fill them as keys in the JSON file.
 2.  For boolean variables in the running parameters, modify them to forms such as ignore_eos: true/false and fill them into the JSON file.
 3.  Optionally add a `baseline` object (see **Baseline thresholds** below). If you omit `baseline` or leave it empty, the performance test still runs but does not assert metric thresholds from this field.
-4.  The qps and concurrency modes are recommended to be mutually exclusive. For detailed explanations, see the table below:
+4.  Set `"name"` on each `benchmark_params` entry for stable pytest ids and readable result keys.
+5.  The qps and concurrency modes are recommended to be mutually exclusive. For detailed explanations, see the table below:
 
 | Parameter       | Type        | Required | Example/Values  | Description                                                                                                                                                                                                                                                          |
 | --------------- | ----------- | -------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| name            | string      | No       | `"1024x1024_steps4"` | Stable suffix for pytest param id and logs. |
 | num_prompts     | int / array | Yes      | 10,[10, 20, 30] | Number of requests. Supports single values or arrays. If a single value is used, it will be automatically expanded to match the number of qps or max_concurrency, e.g., [10,10,10]. If an array is used, its length must match the number of qps or max_concurrency. |
 | request_rate    | float / array | No  | 0.5, [0.5, 1, inf] | Queries per second. Supports single values or arrays. If a single value is used, it will be automatically expanded to match the number of num_prompts, e.g., [1,1,1]. If an array is used, its length must match the number of num_prompts.                          |
 | max_concurrency | int / array | No       | 1, [1, 2, 3]    | Maximum concurrent in-flight requests. Same array / expansion rules as `request_rate` (mutually exclusive with QPS mode).                                                                                                                                                                                                             |
-| baseline        | object      | No       | see above       | Optional per-metric thresholds; keys must match benchmark output fields. Scalar, list (per sweep step), or object (keyed by concurrency or QPS string).  
+| baseline        | object      | No       | see below       | Optional thresholds. **Hardware-nested only**: top-level keys must be `[hardware-resource]` pytest markers from `pyproject.toml` (`get_hardware_mark_list()`). Under each hardware key, metric names are free-form; values are scalars or sweep-aligned lists. Example: `{"H100": {"throughput_qps": […], "custom_stage_ms": 1.0}, "A3": {…}}`. Runtime filename aliases (`_RUNTIME_DEVICE_ALIASES`) are separate and do not expand this allowlist. |
diff --git a/docs/contributing/ci/test_guide.md b/docs/contributing/ci/test_execution_guide.md
similarity index 74%
rename from docs/contributing/ci/test_guide.md
rename to docs/contributing/ci/test_execution_guide.md
index 26996129e..d1c2c560f 100644
--- a/docs/contributing/ci/test_guide.md
+++ b/docs/contributing/ci/test_execution_guide.md
@@ -1,4 +1,4 @@
-# Test Guide
+# Test Execution Guide
 ## Setting Up the Test Environment
 ### Creating a Container
 vLLM-Omni provides an official Docker image for deployment. These images are built upon vLLM Docker images and are available on [Docker Hub](https://hub.docker.com/r/vllm/vllm-omni/tags). The version of vLLM-Omni indicates which vLLM release it is based on.
@@ -49,11 +49,11 @@ Failed jobs: 1/2
     cd tests
     pytest -s -v -m "core_model and cpu"
     ```
-    The latest test command is available in the "Simple Unit Test" step of this [pipeline](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-ready.yml).
+    The latest test command is available in the "Simple Unit Test" step of this [pipeline](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/test-ready.yml).
 
 === "L2 level"
 
-    **Recommended:** run CI-aligned jobs from the repo root via [`tools/run_ready_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/run_ready_jobs.sh). The script reads [`.buildkite/test-ready.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-ready.yml), generates per-step bash wrappers, runs pytest, and tees logs under `logs/ready_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts) for timing and timeout behavior). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
+    **Recommended:** run CI-aligned jobs from the repo root via [`tools/run_ready_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/run_ready_jobs.sh). The script reads [`.buildkite/cuda/test-ready.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/test-ready.yml), generates per-step bash wrappers, runs pytest, and tees logs under `logs/ready_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts) for timing and timeout behavior). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
 
     ```bash
     # All L2 and L1 jobs (default: every pytest step in test-ready.yml)
@@ -85,7 +85,7 @@ Failed jobs: 1/2
 
 === "L3 level"
 
-    **Recommended:** run CI-aligned jobs from the repo root via [`tools/run_merge_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/run_merge_jobs.sh). The script reads [`.buildkite/test-merge.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-merge.yml), generates per-step bash wrappers, runs pytest, and tees logs under `logs/merge_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts)). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
+    **Recommended:** run CI-aligned jobs from the repo root via [`tools/run_merge_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/run_merge_jobs.sh). The script reads [`.buildkite/cuda/test-merge.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/test-merge.yml), generates per-step bash wrappers, runs pytest, and tees logs under `logs/merge_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts)). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
 
     ```bash
     # All L3 and L1 jobs (default: every pytest step in test-merge.yml)
@@ -117,7 +117,7 @@ Failed jobs: 1/2
 
 === "L4 level"
 
-    **Recommended:** run CI-aligned nightly jobs from the repo root via [`tools/nightly/run_nightly_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/nightly/run_nightly_jobs.sh). The script reads [`.buildkite/test-nightly.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-nightly.yml), generates per-step bash wrappers, runs pytest (perf jobs first, then aggregates perf JSON into Excel), and tees logs under `logs/nightly_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts); `generate_nightly_perf_excel` is included in the timing summary). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
+    **Recommended:** run CI-aligned nightly jobs from the repo root via [`tools/nightly/run_nightly_jobs.sh`](https://github.com/vllm-project/vllm-omni/blob/main/tools/nightly/run_nightly_jobs.sh). The script reads [`.buildkite/cuda/test-nightly.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/test-nightly.yml), generates per-step bash wrappers, runs pytest (perf jobs first, then aggregates perf JSON into Excel), and tees logs under `logs/nightly_jobs/` (see [CI job runners](#ci-job-runners-l2l4-logs-timing-and-timeouts); `generate_nightly_perf_excel` is included in the timing summary). Requires `bash`, `python3`, and PyYAML (`pip install pyyaml`).
 
     ```bash
     # All nightly jobs (default: test-type all, model-type all)
@@ -149,12 +149,18 @@ Failed jobs: 1/2
     pytest -s -v -m "full_model and distributed_cuda and L4" --run-level=full_model
     pytest -s -v -m "full_model and (omni or tts) and H100" --run-level=full_model
     ```
-
-    To run a standalone perf benchmark (defaults to ``test_qwen_omni.json``; use ``--test-config-file tests/dfx/perf/tests/test_tts.json`` for TTS):
-
+    If you only want to run specific test cases on a particular platform, you can use:
     ```bash
-    pytest -s -v tests/dfx/perf/scripts/run_benchmark.py
+    pytest -s -v -m "full_model and distributed_cuda and L4"  --run-level=full_model
     ```
+    Note: ``run_benchmark.py`` and ``run_diffusion_benchmark.py`` accept an optional ``--test-config-file``. If omitted, each loads every ``*.json`` under ``tests/dfx/perf/tests/`` (omni/tts vs diffusion split by ``is_diffusion_perf_config``) and pytest ``-m`` filters by each case's JSON ``mark``:
+    ```bash
+    pytest -sv tests/dfx/perf/scripts/run_benchmark.py -m "full_model and tts and H100"
+    pytest -sv tests/dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and diffusion and H100"
+    pytest -sv tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json
+    pytest -sv tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
+    ```
+    Nightly **Perf Test** jobs in ``test-nightly.yml`` use ``--test-config-file`` only (no ``-m``). E2e L4 function tests still use ``full_model`` + ``--run-level full_model`` (see [test-nightly.yml](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-nightly.yml)). Example:
 
 === "L5 level"
 
@@ -183,9 +189,9 @@ Failed jobs: 1/2
 
     ```
 
-    The latest L5 CI jobs (reliability + invalid-parameter weekly steps) are in [test-weekly.yml](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/test-weekly.yml).
+    The latest L5 CI jobs (reliability + invalid-parameter weekly steps) are in [test-weekly.yml](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/cuda/test-weekly.yml).
 
-You can find more information about markers in the documentation: [marker doc](./tests_markers.md)
+You can find more information about markers in [Test Writing Guide — Markers for Tests](./test_writing_guide.md#markers-for-tests).
 
 ## Adding New Test Cases
-Please refer to the [L5 Layering Specification document](./CI_5levels.md).
+Please refer to the [Test System Overview](./test_system_overview.md) and [Test Writing Guide](./test_writing_guide.md).
diff --git a/docs/contributing/ci/test_system_overview.md b/docs/contributing/ci/test_system_overview.md
new file mode 100644
index 000000000..335ed5c53
--- /dev/null
+++ b/docs/contributing/ci/test_system_overview.md
@@ -0,0 +1,214 @@
+# Multi-Level Automated Testing System Overview
+
+## Document Overview
+
+This testing system aims to build a complete, efficient, and well-structured quality assurance framework for the development, integration, and release of model services. It draws on the concept of the test pyramid from modern software engineering, progressively expanding testing activities from basic code logic verification to complex end-to-end (E2E) functionality, performance, accuracy, and even long-term stability validation.
+
+Through five levels (L1-L5) and common (Common) specifications, the system clarifies the testing objectives, scope, execution frequency, and required resources for different development stages (e.g., each commit, PR merge, daily build, pre-release). This ensures that models meet high standards for functionality, performance, and reliability across various deployment scenarios (online serving and offline inference).
+
+<table>
+  <thead>
+    <tr>
+      <th>Level</th>
+      <th>Scope & Focus</th>
+      <th>Model Coverage Strategy</th>
+      <th>Feature Coverage Strategy</th>
+      <th>Interface Coverage Strategy</th>
+      <th>Tags</th>
+      <th>Time Cost</th>
+      <th>Test Dir</th>
+      <th>Doc</th>
+      <th>Frequency</th>
+      <th>Hardware</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td rowspan="2"><strong>Common</strong></td>
+      <td>Contribution Guideline & PR checklist</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td><a href="https://github.com/vllm-project/vllm-omni/blob/main/.github/PULL_REQUEST_TEMPLATE.md">PR Checklist</a></td>
+      <td>/</td>
+      <td>/</td>
+    </tr>
+    <tr>
+      <td>CI Failure Description</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td><a href="./failures.md">CI Failures</a></td>
+      <td>/</td>
+      <td>/</td>
+    </tr>
+    <tr>
+      <td><strong>L1</strong><br>(Unit & Logic)</td>
+      <td>Unit tests for components like entrypoints, models</td>
+      <td>/</td>
+      <td>/</td>
+      <td>/</td>
+      <td><code>core_model and cpu</code></td>
+      <td rowspan="2">&lt;15min</td>
+      <td>
+        <code>tests/{component}/…</code> mirroring <code>vllm_omni/{component}/</code><br>
+        (e.g. <code>tests/diffusion/</code>, <code>tests/engine/</code>, <code>tests/entrypoints/</code>)<br>
+        Do <strong>not</strong> add new top-level <code>tests/</code> dirs unrelated to a component.
+      </td>
+      <td>
+        <a href="test_writing_guide.md#l1--l2-level-testing-unit-testing-and-basic-end-to-end-verification">L1 &amp; L2</a><br>
+        Section 1 L1&amp;L2: Purpose, Test Content, Directory Location, Example
+      </td>
+      <td>PR with ready label (also can run locally)</td>
+      <td>CPU</td>
+    </tr>
+    <tr>
+      <td><strong>L2</strong><br>(E2E across models & GPU-required UT)</td>
+      <td>Online (basic deployment scenarios):<br>dummy, normal inference function (output format, stream), some instance startup UT</td>
+      <td>High-priority models + online basic scenarios; request success, non-empty output, format match (no Whisper/accuracy)</td>
+      <td>High-priority features and component tests that require launching instances</td>
+      <td>High-priority interfaces (using random lightweight models)</td>
+      <td><code>core_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
+      <td>
+        <strong>Model E2E:</strong><br>
+        <code>tests/e2e/online_serving/test_{model}.py</code><br>
+        <code>tests/e2e/offline_inference/test_{model}.py</code><br>
+        <strong>Feature integration:</strong><br>
+        <code>tests/e2e/features/&lt;feature&gt;/</code><br>
+        (e.g. <code>fullduplex/</code>, <code>custom_pipeline/</code>, <code>rlhf_test/</code>)<br>
+        <strong>Component / interface Test (GPU):</strong><br>
+        <code>tests/{component}/…</code>, <code>tests/entrypoints/…</code>
+      </td>
+      <td>
+        <a href="test_writing_guide.md#l1--l2-level-testing-unit-testing-and-basic-end-to-end-verification">L1 &amp; L2</a><br>
+        L1&amp;L2: Purpose, Test Content, Directory Location, Example
+      </td>
+      <td>PR with ready label</td>
+      <td>GPU</td>
+    </tr>
+    <tr>
+      <td><strong>L3</strong><br>(Important Perf & Integration & Accuracy)</td>
+      <td>Online & Offline (multiple deployment scenarios):<br>real model, normal inference function, normal accuracy</td>
+      <td>High/medium-priority models + key online/offline scenarios; real weights, Whisper/similarity, preset voice gender, basic accuracy</td>
+      <td>Medium-priority features and component tests that require launching instances</td>
+      <td>Medium-priority interfaces (using random lightweight models)</td>
+      <td><code>advanced_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
+      <td>&lt;30min</td>
+      <td>
+        <strong>Model E2E:</strong><br>
+        <code>tests/e2e/online_serving/test_{model}.py</code><br>
+        <code>tests/e2e/offline_inference/test_{model}.py</code><br>
+        <code>tests/e2e/accuracy/</code><br>
+        <strong>Feature integration:</strong><br>
+        <code>tests/e2e/features/&lt;feature&gt;/</code><br>
+        <strong>Component / interface Test:</strong><br>
+        <code>tests/{component}/…</code>, <code>tests/entrypoints/…</code>
+      </td>
+      <td>
+        <a href="test_writing_guide.md#l3-level-testing-core-integration-performance-and-accuracy-verification">L3</a><br>
+        L3: Purpose, Test Content, Directory Location, Example
+      </td>
+      <td>PR Merged (Also run L1&L2 Tests)</td>
+      <td>GPU</td>
+    </tr>
+    <tr>
+      <td><strong>L4</strong><br>(Perf & Integration & Accuracy)</td>
+      <td>Online: full functional scenarios + performance test + doc test + accuracy test</td>
+      <td>High-priority models: function, performance, accuracy, and doc testing<br>Medium-priority models: function and doc testing</td>
+      <td>Low-priority features and component tests that require launching instances</td>
+      <td>Low-priority interfaces (using real weights)</td>
+      <td><code>full_model and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
+      <td>&lt;3 hour</td>
+      <td>
+        <strong>Model E2E:</strong><br>
+        <code>tests/e2e/online_serving/test_{model}_expansion.py</code><br>
+        <code>tests/e2e/offline_inference/test_{model}_expansion.py</code><br>
+        <code>tests/e2e/accuracy/test_{model}.py</code><br>
+        <strong>Feature integration:</strong><br>
+        <code>tests/e2e/features/&lt;feature&gt;/</code><br>
+        <strong>Component / interface Test:</strong><br>
+        <code>tests/{component}/…</code>, <code>tests/entrypoints/…</code><br>
+        <strong>Performance:</strong><br>
+        <code>tests/dfx/perf/tests/</code><br>
+        <strong>Doc examples:</strong><br>
+        <code>tests/examples/online_serving/</code>, <code>tests/examples/offline_inference/</code>
+      </td>
+      <td>
+        <a href="test_writing_guide.md#l4-level-testing-full-functionality-performance-and-documentation-testing">L4</a><br>
+        L4: Purpose, Test Content, Directory Location, Example
+      </td>
+      <td>Nightly</td>
+      <td>GPU</td>
+    </tr>
+    <tr>
+      <td><strong>L5</strong><br>(Stability & Reliability)</td>
+      <td>Online: long-term stability test + reliability test</td>
+      <td>Long-term stability and reliability testing for high-priority models<br>Low-priority models: function and doc testing</td>
+      <td>/</td>
+      <td>Invalid-parameter validation for high-priority interfaces</td>
+      <td><code>slow and hardware_test(H100, L4, etc.) and omni/tts/diffusion</code></td>
+      <td> Depends on reality </td>
+      <td>
+        <strong>Stability:</strong><br>
+        <code>tests/dfx/stability/tests/</code><br>
+        <strong>Reliability:</strong><br>
+        <code>tests/dfx/reliability/test_reliability_{model}.py</code>
+      </td>
+      <td>
+        <a href="test_writing_guide.md#l5-level-testing-stability-and-reliability-testing">L5</a><br>
+        L5: Purpose, Test Content, Directory Location, Example
+      </td>
+      <td>Weekly / Days before Release</td>
+      <td>GPU</td>
+    </tr>
+  </tbody>
+</table>
+
+**Test Dir placement (summary):** component / unit under `tests/{component}/` mirroring `vllm_omni/`; model E2E under `tests/e2e/online_serving/`, `tests/e2e/offline_inference/`, and `tests/e2e/accuracy/`; feature integration under `tests/e2e/features/<feature>/`; doc example tests under `tests/examples/online_serving/` and `tests/examples/offline_inference/`; performance under `tests/dfx/perf/`; stability under `tests/dfx/stability/`; reliability under `tests/dfx/reliability/`. Do **not** add new top-level directories under `tests/` that are unrelated to a `vllm_omni` component (or to the established `e2e` / `dfx` / `helpers` / `examples` / `buildkite` layout).
+
+For per-level test authoring (markers, examples), see [Test Writing Guide](./test_writing_guide.md).
+
+## Common Specifications
+
+Before entering specific testing levels, the project establishes two common specifications aimed at standardizing the development process and quickly locating issues.
+
+1.  ***PR Checklist ([`.github/PULL_REQUEST_TEMPLATE.md`](https://github.com/vllm-project/vllm-omni/blob/main/.github/PULL_REQUEST_TEMPLATE.md))***: This template defines the self-check items that must be completed before submitting a code review (Pull Request). It ensures that each code change meets basic requirements such as code style, dependency updates, and documentation synchronization before entering the automated testing pipeline, serving as the first manual line of defense for quality assurance.
+2.  ***CI Failure Explanation ([CI Failures](./failures.md))***: This document archives and explains common failure patterns in the Continuous Integration (CI) pipeline, error log interpretation, and preliminary troubleshooting steps. It helps developers and testers quickly diagnose the causes of automated test failures, improving problem-solving efficiency.
+
+## Notes
+
+### L2 / L3 diff-aware CI (CUDA)
+
+On CUDA **L2** and **L3**, **E2E Test** Buildkite jobs may be omitted at pipeline upload when the PR diff does not touch their path prefixes; other groups still always upload. Full two-layer mechanics and YAML examples: [CI Settings — Diff-aware CI](./ci_settings.md#diff-aware-ci) ([step filtering](./ci_settings.md#step-filtering)).
+
+### Test helper environment variables
+
+Some shared helpers under `tests/helpers/` honor optional environment variables for local debugging. These are **not** set in CI by default.
+
+| Variable | Accepted values | Description |
+| -------- | --------------- | ----------- |
+| `VLLM_OMNI_KEEP_REQUEST_MEDIA` | `1`, `true`, `yes` (case-insensitive) | When enabled, temporary WAV files created by `tests.helpers.media.convert_audio_bytes_to_text` are **not** deleted when the pytest process exits. By default, each call writes a unique file under the system temp directory via `tempfile.mkstemp` and registers `atexit` cleanup. Use this when debugging audio output validation (Whisper transcription, keyword checks, text–audio similarity). The saved path is logged as `audio data is saved: <path>`. |
+
+Example (Linux / macOS):
+
+```bash
+export VLLM_OMNI_KEEP_REQUEST_MEDIA=1
+pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -k test_mix_to_text_audio
+```
+
+Example (Windows PowerShell):
+
+```powershell
+$env:VLLM_OMNI_KEEP_REQUEST_MEDIA = "1"
+pytest -s -v tests/e2e/online_serving/test_qwen3_omni.py -k test_mix_to_text_audio
+```
+
+## Summary
+
+This multi-level testing system achieves continuous, progressive validation of model service quality by tightly integrating testing activities with the development workflow (commit, review, merge, release). From rapid unit testing to comprehensive end-to-end testing, and further to in-depth performance, stability, and reliability verification, each level has clear objectives, collectively building a robust quality protection net. By following this system, teams can deliver high-quality, highly reliable model services more efficiently.
diff --git a/docs/contributing/ci/test_writing_guide.md b/docs/contributing/ci/test_writing_guide.md
new file mode 100644
index 000000000..397f5e83c
--- /dev/null
+++ b/docs/contributing/ci/test_writing_guide.md
@@ -0,0 +1,712 @@
+# Test Writing Guide
+
+This document describes how to author tests for each CI level (L1–L5). For the level matrix, CI triggers, and Buildkite upload behavior, see [Test System Overview](./test_system_overview.md).
+
+## Test Directory Structure
+
+Canonical placement by CI level is in the **Test Dir** column of the level matrix in [Test System Overview](./test_system_overview.md).
+
+Summary:
+
+- **Component / unit:** `tests/{component}/…` mirroring `vllm_omni/{component}/`
+- **Model E2E:** `tests/e2e/online_serving/`, `tests/e2e/offline_inference/`, `tests/e2e/accuracy/`
+- **Feature integration:** `tests/e2e/features/<feature>/`
+- **Doc example tests:** `tests/examples/online_serving/`, `tests/examples/offline_inference/`
+- **Performance:** `tests/dfx/perf/tests/` (JSON configs; runners under `tests/dfx/perf/scripts/`)
+- **Stability:** `tests/dfx/stability/tests/`
+- **Reliability:** `tests/dfx/reliability/`
+- Do **not** add new top-level `tests/` directories unrelated to a component (or to `e2e` / `dfx` / `helpers` / `examples` / `buildkite`)
+
+Deploy YAMLs: `vllm_omni/deploy/` via `tests.helpers.stage_config.get_deploy_config_path` (see [stage configs](../../configuration/stage_configs.md)).
+
+## Markers for Tests
+
+By adding markers before test functions, tests can later be executed uniformly by simply declaring the corresponding marker type.
+
+### Current Markers
+Defined in `pyproject.toml`:
+
+| Marker             | Description                                               |
+| ------------------ | --------------------------------------------------------- |
+| `core_model`       | L1&L2 tests (run in each PR)                              |
+| `advanced_model`   | L3 tests (run on each merge to main)                 |
+| `full_model`       | L4 tests (run nightly) |
+| `diffusion`        | Diffusion model tests                                     |
+| `omni`             | Omni multimodal model tests |
+| `tts`              | TTS model tests     |
+| `cache`            | Cache backend tests                                       |
+| `parallel`         | Parallelism/distributed tests                             |
+| `cpu`              | Tests that run on CPU                                     |
+| `gpu`              | Tests that run on GPU *                                   |
+| `cuda`             | Tests that run on CUDA *                                  |
+| `rocm`             | Tests that run on AMD/ROCm *                              |
+| `xpu`              | Tests that run on Intel XPU *                             |
+| `npu`              | Tests that run on NPU/Ascend *                            |
+| `H100`             | Tests that require H100 GPU  *                            |
+| `L4`               | Tests that require L4 GPU *                               |
+| `MI325`            | Tests that require MI325 GPU (AMD/ROCm) *                 |
+| `A2`               | Tests that require A2 NPU *                               |
+| `A3`               | Tests that require A3 NPU *                               |
+| `distributed_cuda` | Tests that require multi cards on CUDA platform *         |
+| `distributed_rocm` | Tests that require multi cards on ROCm platform  *        |
+| `distributed_npu`  | Tests that require multi cards on NPU platform  *         |
+| `skipif_cuda`      | Skip if the num of CUDA cards is less than the required * |
+| `skipif_rocm`      | Skip if the num of ROCm cards is less than the required * |
+| `skipif_npu`       | Skip if the num of NPU cards is less than the required *  |
+| `slow`             | Slow tests (may skip in quick CI)                         |
+| `benchmark`        | Benchmark tests (decorator on runner test functions; perf JSON uses `full_model` + type marker instead) |
+| `local_model`      | Tests requiring local / non-HF-hub model weights          |
+
+\* Means those markers are auto-added by `@hardware_test` (parametrization decorator) or `hardware_marks` (only returning the list of marks for flexibility).
+
+#### Example usage for markers
+
+```python
+from tests.helpers.mark import hardware_test
+
+@pytest.mark.core_model
+@pytest.mark.omni
+@hardware_test(
+   res={"cuda": "L4", "rocm": "MI325", "npu": "A2"},
+   num_cards=2,
+)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_video_to_audio()
+    ...
+```
+
+#### Decorator: `@hardware_test`
+
+This decorator is intended to make hardware-aware, cross-platform test authoring easier and more robust for CI/CD environments. The `hardware_test` decorator in `vllm-omni/tests/helpers/mark.py` performs the following actions:
+
+1. **Applies platform and resource markers**  
+   Adds the appropriate pytest markers for each specified hardware platform (e.g., `cuda`, `rocm`, `xpu`, `npu`) and resource type (e.g., `L4`, `H100`, `MI325`, `B60`, `A2`, `A3`).
+   ```
+   @pytest.mark.cuda
+   @pytest.mark.L4
+   ```
+2. **Handles multi-card (distributed) scenarios**  
+   For tests requiring multiple cards, it automatically adds distributed markers such as `distributed_cuda`, `distributed_rocm`, or `distributed_npu`.
+   ```
+   @pytest.mark.distributed_cuda(num_cards=num_cards)
+   ```
+3. **Supports flexible card requirements**  
+   Accepts `num_cards` as either a single integer for all platforms or as a dictionary with per-platform values. If not specified, defaults to 1 card per platform.
+
+4. **Integrates resource validation**  
+   On CUDA, adds a skip marker (`skipif_cuda`) if the system does not have the required number of devices.
+   Support for `skipif_rocm` and `skipif_npu` will be implemented later.
+
+
+5. **Works with pytest filtering**  
+   Allows tests to be filtered and selected at runtime using standard pytest marker expressions (e.g., `-m "distributed_cuda and L4"`).
+
+##### Example usage for decorator
+- Single call for multiple platforms:
+    ```python
+    @hardware_test(
+        res={"cuda": "L4", "rocm": "MI325", "xpu": "B60", "npu": "A2"},
+        num_cards={"cuda": 2, "rocm": 2, "xpu": 2, "npu": 2},
+    )
+    ```
+    or
+    ```python
+    @hardware_test(
+        res={"cuda": "L4", "rocm": "MI325", "xpu": "B60", "npu": "A2"},
+        num_cards=2,
+    )
+    ```
+- `res` must be a dict; supported resources: CUDA (L4/H100), ROCm (MI325), XPU (B60), MUSA (S5000), NPU (A2/A3)
+- `num_cards` can be int (all platforms) or dict (per platform); defaults to 1 when missing
+- Distributed markers (`distributed_cuda`, `distributed_rocm`, `distributed_npu`) are auto-added for multi-card cases
+- Filtering examples:
+    - CUDA only: `pytest -m "distributed_cuda and L4"`
+    - ROCm only: `pytest -m "distributed_rocm and MI325"`
+    - NPU only: `pytest -m "distributed_npu"`
+
+#### Function: `hardware_marks`
+
+`hardware_marks` returns a list of pytest mark objects with the same signature as `@hardware_test`. Use it when you need more flexibility, such as attaching hardware marks to individual `pytest.param` entries rather than an entire test function.
+
+```python
+from tests.helpers.mark import hardware_marks
+
+MULTI_CARD_MARKS = hardware_marks(
+    res={"cuda": "H100", "rocm": "MI325", "npu": "A2"}, num_cards=2
+)
+
+@pytest.mark.parametrize("omni_server", [
+    pytest.param(OmniServerParams(...), id="case_001", marks=MULTI_CARD_MARKS),
+], indirect=True)
+def test_feature(omni_server):
+    ...
+```
+
+#### JSON `mark` field (L4 perf configs)
+
+Perf JSON under `tests/dfx/perf/tests/` can attach pytest marks per **case** (`test_name` block). Parsed by `tests.dfx.conftest.resolve_pytest_marks` and applied to each parametrized run in `run_benchmark.py` / `run_diffusion_benchmark.py`.
+
+When `mark` is present, it must be an **array** with exactly one ``hardware_marks`` object (same semantics as `hardware_marks()` above), followed by registered pytest marker name strings such as `full_model`, `omni`, `tts`, or `diffusion`.
+
+```json
+{
+  "test_name": "test_cosmos3_t2i_official_demo_2gpu",
+  "mark": [
+    {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}},
+    "full_model",
+    "diffusion"
+  ],
+  "server_type": "vllm-omni",
+  "server_params": { "...": "..." },
+  "benchmark_params": [{ "name": "1024x1024_steps4", "...": "..." }]
+}
+```
+
+- Local bulk load: `pytest -sv tests/dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and diffusion and H100"`
+- Nightly CI perf steps: `--test-config-file tests/dfx/perf/tests/test_<model>_vllm_omni.json` (file selects cases; no `-m`)
+- Result filenames use **runtime** GPU detection (`get_runtime_resource_label`); `H100` is omitted on the default CI pool
+
+See [L4 performance test examples](./test_examples/l4_performance_tests.inc.md) for the full schema.
+
+### Add Support for a New Platform
+
+If you want to add support for a new platform (e.g., "tpu" for a new accelerator), follow these steps:
+
+1. **Extend the marker list in your pytest config** so that platform/resource markers are defined:
+   ```toml
+   # In pyproject.toml or pytest.ini
+   [tool.pytest.ini_options]
+   markers = [
+       # ... existing markers ...
+       "tpu: Tests that require TPU device",
+       "TPU_V3: Tests that require TPU v3 hardware",
+       "distributed_tpu: Tests that require multiple TPU devices",
+   ]
+   ```
+2. **Implement a marker construction function for your platform** in `vllm-omni/tests/helpers/mark.py`:
+   ```python
+   # In vllm-omni/tests/helpers/mark.py
+
+   def tpu_marks(*, res: str, num_cards: int):
+       test_platform = pytest.mark.tpu
+       if res == "TPU_V3":
+           test_resource = pytest.mark.TPU_V3
+       else:
+           raise ValueError(
+               f"Invalid TPU resource type: {res}. Supported: TPU_V3")
+
+       if num_cards == 1:
+           return [test_platform, test_resource]
+       else:
+           test_distributed = pytest.mark.distributed_tpu(num_cards=num_cards)
+           # Optionally: add skipif_tpu when implemented
+           return [test_platform, test_resource, test_distributed]
+   ```
+3. **Update `hardware_marks` to recognize your new platform**:
+    In the relevant place (see the `hardware_marks` implementation), add:
+    ```python
+    if platform == "tpu":
+        marks = tpu_marks(res=resource, num_cards=cards)
+    ```
+    (`hardware_test` calls `hardware_marks` internally, so both will pick up the change.)
+4. **(Recommended) Add a test using your new markers**:
+   ```python
+   @hardware_test(
+       res={"tpu": "TPU_V3"},
+       num_cards=2,
+   )
+   def test_my_tpu_feature():
+       ...
+   ```
+
+**Summary**:  
+- Add pytest markers for your new platform/resources  
+- Implement a marker function (`xxx_marks`)  
+- Plug into `hardware_marks`  
+- You're done: tests using `@hardware_test` or `hardware_marks` with your platform now automatically get the correct markers, distribution, and isolation!
+
+See code in `vllm-omni/tests/helpers/mark.py` for existing examples (`cuda_marks`, `rocm_marks`, `npu_marks`).
+
+## Test case style
+
+### L1 & L2 Level Testing - Unit Testing and Basic End-to-End Verification
+
+#### 1.1 Testing Purpose
+
+L1 and L2 level testing form the foundation of the quality assurance system. L1 level testing focuses on verifying the internal logic correctness of code units (e.g., functions, classes), ensuring each independent component behaves as designed.
+
+L2 level testing builds upon L1 by introducing GPU resources and verifying that the end-to-end (E2E) process of the model in basic deployment scenarios is smooth. For example, it uses dummy models to confirm that core interfaces like the inference pipeline, output format, and streaming response work properly. The common goal of these two levels is to provide developers with rapid feedback, discovering and fixing issues early in the development cycle.
+
+
+
+#### 1.2 Testing Content and Scope
+
+-   ***L1 (Unit & Logic Testing)***:
+-   -   ***Scope***: Tests internal functions and methods of core components such as `entrypoints`, `models`.
+    -   ***Focus***: Branch coverage, exception handling, algorithm logic correctness. Does not involve external dependencies or the complete service stack.
+    -   ***Time Cost***: Execution time is controlled within ***15 minutes*** to ensure fast feedback.
+-   ***L2 (Basic End-to-End Testing)***:
+-   -   ***Scope***: Covers two basic deployment scenarios: `online` (serving) and `offline` (inference).
+    -   ***Focus***: Uses `dummy` weights (via deploy YAML patching at `core_model`) or lightweight real models to verify that the entire chain from request input to result output works normally, including output data structure, streaming (stream) support, and **cheap payload checks** at `--run-level core_model` (see below). Also includes some unit tests that require launching independent service instances.
+    -   ***L2 response validation (`core_model`)***: Implemented in `tests/helpers/assertions.py` and invoked by `OpenAIClientHandler` based on `--run-level`. At L2 we require **request success** plus minimal output sanity—not full accuracy:
+        -   **Speech / TTS** (`assert_audio_speech_response`): decoded audio must be present and non-empty (or exceed `min_audio_bytes` when set in `request_config`); `response_format` must match the returned content-type (e.g. `wav`, `pcm`). Whisper transcript similarity, PCM HNR, and preset-voice gender checks run only at L3+.
+        -   **Diffusion** (`assert_diffusion_response`): at least one non-empty image, video, or audio artifact. Resolution/frame-count parity and other deep checks run only at L3+.
+        -   **Omni multimodal** (`assert_omni_response`): L2 asserts successful completion; keyword, transcript, and cross-modal similarity checks run only at L3+.
+    -   ***Characteristic***: Requires ***GPU*** resources to perform model computations.
+
+#### 1.3 Test Directory and Execution Files
+
+A clear directory structure is key to managing test cases efficiently. See the **Test Dir** column in [Test System Overview](./test_system_overview.md) for the canonical placement rules.
+
+-   ***L1 (component / unit)***: `tests/{component_name}/…` mirroring `vllm_omni/{component_name}/` (e.g. `tests/diffusion/`, `tests/entrypoints/`). Do **not** invent new top-level `tests/` folders unrelated to a component.
+-   ***L2 (basic model E2E)***:
+    -   Online serving: `tests/e2e/online_serving/test_{model_name}.py`
+    -   Offline inference: `tests/e2e/offline_inference/test_{model_name}.py`
+-   ***Feature-level integration*** (cross-cutting, not a single-model smoke): `tests/e2e/features/<feature>/` (e.g. `fullduplex/`, `custom_pipeline/`, `rlhf_test/`).
+
+#### 1.4 Execution Method and Example
+
+-   ***Trigger Timing***: **`PR with ready label`**. That is, when a developer adds a "ready for review" or similar label to a PR on platforms like GitHub, L1 and L2 tests are automatically triggered.
+-   ***Diff-aware step skipping***: On L2, **E2E Test** jobs may be omitted at pipeline upload when the PR diff does not touch their [`source_file_dependencies`](ci_settings.md#step-filtering) prefixes; non-E2E groups still always upload. See [CI Settings — Diff-aware CI](ci_settings.md#diff-aware-ci).
+-   ***Execution Environment***: L1 uses ***CPU*** environment; L2 requires ***GPU*** environment.
+-   ***Script Example***:
+
+<details>
+<summary> L1 Test Examples</summary>
+
+Examples from `tests/model_executor/models/qwen2_5_omni/test_audio_length.py`
+```python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+def test_resolve_max_mel_frames_default():
+    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import resolve_max_mel_frames
+
+    assert resolve_max_mel_frames(None, default=30000) == 30000
+    assert resolve_max_mel_frames(None, default=6000) == 6000
+
+
+def test_resolve_max_mel_frames_explicit():
+    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import resolve_max_mel_frames
+
+    # Explicit argument always wins over default
+    assert resolve_max_mel_frames(123, default=30000) == 123
+    assert resolve_max_mel_frames(6000, default=30000) == 6000
+    assert resolve_max_mel_frames(0, default=30000) == 0
+
+
+@pytest.mark.parametrize("repeats", [2, 4])
+@pytest.mark.parametrize("code_len", [0, 1, 32768])
+@pytest.mark.parametrize("max_mel_frames", [None, -1, 0, 1, 6000, 30000])
+def test_cap_and_align_mel_length_no_mismatch(repeats, code_len, max_mel_frames):
+    """Guard that any max_mel_frames yields a mel length aligned to repeats, and
+    consistent with the truncated code length (prevents concat mismatch).
+    """
+    from vllm_omni.model_executor.models.qwen2_5_omni.audio_length import cap_and_align_mel_length
+
+    target_code_len, target_mel_len = cap_and_align_mel_length(
+        code_len=code_len,
+        repeats=repeats,
+        max_mel_frames=max_mel_frames,
+    )
+
+    assert isinstance(target_code_len, int)
+    assert isinstance(target_mel_len, int)
+
+    if code_len == 0:
+        assert target_code_len == 0
+        assert target_mel_len == 0
+        return
+
+    assert target_code_len >= 1
+    assert target_mel_len >= repeats
+    assert target_mel_len % repeats == 0
+    assert target_mel_len == target_code_len * repeats
+    assert target_code_len <= code_len
+
+    if max_mel_frames is not None and int(max_mel_frames) > 0 and int(max_mel_frames) >= repeats:
+        assert target_mel_len <= int(max_mel_frames)
+```
+</details>
+
+<details>
+<summary> L2 Test Examples</summary>
+You can refer to Test Examples in the L3 section to see example test cases that incorporate both L2 and L3 testing logic.
+</details>
+
+-   -   ***Run Command***:
+
+    `pytest -s -v /tests/e2e/online_serving/test_{model_name}.py`
+    `pytest -s -v -m 'core_model and cpu' --run-level=core_model`
+
+### L3 Level Testing - Core Integration, Performance, and Accuracy Verification
+
+#### 2.1 Testing Purpose
+
+L3 level testing executes after code is merged into the main branch. Its core purpose is to verify the integration effect, key performance indicators, and output accuracy of ***real models*** in ***multiple deployment scenarios***
+
+. It acts as the "quality gatekeeper" for the main branch, ensuring that no merge breaks the core capabilities of the model service. Testing needs to provide clear conclusions within a relatively short time (<30min), balancing test depth with feedback speed.
+
+
+
+#### 2.2 Testing Content and Scope
+
+-   ***Deployment Scenarios***: Covers richer `online` and `offline` deployment configurations, which may include different hardware configurations, batch sizes, concurrency levels, etc.
+-   ***Core Verification***:
+-   1.  ***Inference Functionality***: Ensures real models can perform forward computation normally and return results.
+    2.  ***Accuracy Compliance***: Verifies that the model's evaluation metrics (e.g., accuracy) meet the expected baseline, preventing code changes from introducing accuracy issues.
+    3.  ***Important Performance***: Verifies whether performance (e.g., P99 latency, throughput) in core scenarios meets preset thresholds.
+-   ***L3 response validation (`advanced_model`)***: At `--run-level advanced_model`, `tests/helpers/assertions.py` adds semantic checks on top of L2 payload gates (see L1 & L2 above):
+    -   **Speech / TTS** (`assert_audio_speech_response`): Whisper transcript of returned audio vs `request_config["input"]` (cosine similarity &gt; 0.9 when input text is set); optional `min_audio_bytes` floor; PCM harmonic-to-noise ratio when `response_format` is `pcm`; **preset voice gender** via `_assert_preset_voice_gender_from_audio` when `voice` matches a known preset in `_PRESET_VOICE_GENDER_MAP` (pitch/F0-based classifier; skipped for unknown voices or `pcm` output).
+    -   **Omni multimodal** (`assert_omni_response`): non-empty text/audio outputs; `key_words` in transcript or text; text–audio similarity / containment; preset **`speaker`** gender check (same helper as TTS).
+    -   **Diffusion** (`assert_*_diffusion_response`): image/video dimension and frame-count parity with request parameters where configured.
+    -   **Accuracy suites**: pixel/video similarity and metric baselines under `/tests/e2e/accuracy/` (separate from inline helper assertions).
+
+#### 2.3 Test Directory and Execution Files
+
+-   ***Functional / model E2E***:
+    -   Online serving: `tests/e2e/online_serving/test_{model_name}_expansion.py`
+    -   Offline inference: `tests/e2e/offline_inference/test_{model_name}_expansion.py`
+    -   Accuracy / similarity: `tests/e2e/accuracy/`
+    -   (`_expansion.py` holds broader scenario coverage than the L2 smoke file.)
+-   ***Feature-level integration***: `tests/e2e/features/<feature>/` (not under a new top-level `tests/` directory).
+
+#### 2.4 Execution Method and Example
+
+-   ***Trigger Timing***: **`PR Merged`**. Automatically triggered after code review is approved and merged into the main branch (typically via `merge-test` label on the PR before merge).
+-   ***Diff-aware step skipping***: Same [`source_file_dependencies`](ci_settings.md#step-filtering) mechanism as L2—**all E2E Test** leaf steps are diff-gated; other L3 groups always upload. See [CI Settings — Diff-aware CI](ci_settings.md#diff-aware-ci).
+-   ***Execution Environment***: ***GPU*** servers.
+-   ***Script Example***:
+
+???+ example "Test Examples"
+
+    **2.4.1 Mark Declaration Section**
+
+    ```python
+    @pytest.mark.advanced_model
+    @pytest.mark.core_model
+    @pytest.mark.parametrize("omni_server", test_params, indirect=True)
+    ```
+
+    **Explanation**:
+
+    @pytest.mark.advanced_model: Marks the test as L3 merge level (`--run-level advanced_model`): real weights, Whisper/similarity/keyword checks, diffusion deep checks, and **preset voice/speaker gender** validation where applicable. @pytest.mark.full_model: Marks L4 nightly-only suites (e.g. `test_*_expansion.py`, doc examples).
+
+    @pytest.mark.core_model: Marks the test as L1 or L2 level. At `--run-level core_model`, validation is limited to request success plus cheap payload checks (e.g. non-empty audio bytes, response format/content-type, non-empty diffusion outputs)—not Whisper, keyword, or accuracy gates. Deploy YAML may use `load_format: dummy` for fast PR feedback.
+
+    @pytest.mark.parametrize: A parameterization decorator that allows abstracting test data into parameters, enabling reuse of the same test logic across different data configurations. indirect=True indicates that parameters will be passed to the fixture for processing.
+
+    **Notes**: If you believe the test case only needs to execute basic run logic at the PR-level CI, you can mark it only with @pytest.mark.core_model. If you believe it only needs to execute deep validation at merge (L3), use @pytest.mark.advanced_model. For L4 nightly-only expansion and doc-example tests, use @pytest.mark.full_model with `--run-level full_model`. If the test case needs both basic run and deep validation, mark with @pytest.mark.core_model and the appropriate L3/L4 marker (`advanced_model` and/or `full_model`).
+
+    **2.4.2 Test Function Definition and Documentation**
+
+    ```python
+    def test_mix_to_text_audio_001(omni_server, openai_client) -> None:
+        """
+        Test multi-modal input processing and text/audio output generation via OpenAI API.
+        Deploy Setting: default yaml
+        Input Modal: text + audio + video + image
+        Output Modal: text + audio
+        Input Setting: stream=True
+        Datasets: single request
+        """
+    ```
+
+    **Explanation**:
+
+    **Function Naming Convention**: Uses the test_ prefix, describes the test scenario mix_to_text_audio, and the number 001 indicates the first test case for this scenario.
+
+    **Parameter Explanation**:
+
+    omni_server: Omni server instance obtained via fixture, containing model information and configuration.
+
+    openai_client: Unified OpenAI client processing instance, encapsulating request sending and response validation logic.
+
+    Docstring: Describes the test purpose, deployment settings, input/output modalities, streaming settings, and dataset type in detail, providing clear context for test maintenance.
+
+    **2.4.3 Multimodal Data Preparation**
+
+    ```python
+    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(224, 224, 300)['base64']}"
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(224, 224)['base64']}"
+    audio_data_url = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
+    ```
+
+    **Explanation**:
+
+    **Data Generation Functions**: Use the generate_synthetic_* series of functions to generate synthetic test data, avoiding reliance on external resources and ensuring test reproducibility and stability.
+
+    **Parameter Explanation**:
+
+    Video: width, height, duration_frames
+
+    Image: width, height
+
+    Audio: duration_seconds, channels
+
+    **2.4.4 Request Configuration and Keyword Validation**
+
+    ```python
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+        "key_words": {
+            "audio": ["water", "cricket"],
+            "video": ["sphere", "globe", "circle", "round"],
+            "image": ["square", "quadrate"],
+            "text": ["beijing"]
+        },
+    }
+    ```
+
+    **Explanation**:
+
+    **Model Specification**: Uses omni_server.model to ensure the test aligns with the model configured on the server.
+
+    **Keyword Validation Mechanism**: This is an innovative design of the template to address the specific needs of multimodal testing:
+
+    Audio Keywords: Validate whether the generated text's description of audio content contains expected elements (e.g., "water" for water sounds, "cricket" for cricket sounds). If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
+
+    **Video Keywords**: Validate whether the generated text's description of video content contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
+
+    Image Keywords: Validate whether the generated text's description of image content contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
+
+    Text Keywords: Validate whether the generated text contains expected elements. If you provide multiple keywords, the validation is considered successful if at least one keyword is present.
+
+    **2.4.5 Request Execution**
+
+    ```python
+    openai_client.send_omni_request(request_config, request_num=1)  # for omni-understanding models
+    # or
+    openai_client.send_diffusion_request(request_config, request_num=1)  # for diffusion models
+    ```
+
+    **Explanation**:
+
+    **Unified Client**: Uses the OpenAIClientHandler instance to send requests. This client encapsulates error handling, retry mechanisms, and response validation logic.
+
+    **Single Request**: The comment clearly states this is a single-request completion test. For concurrent testing, it can be extended to multiple requests using request_num = n.
+
+    **Implicit Validation**: `send_omni_request`, `send_audio_speech_request`, and `send_diffusion_request` call `assert_*_response` helpers with the session `--run-level`. At `core_model`, checks are limited to success plus cheap payload sanity (non-empty audio/media, format/content-type, optional `min_audio_bytes`). At `advanced_model` and `full_model`, deep validation adds Whisper transcripts, keyword/similarity, diffusion dimension checks, PCM HNR, etc.
+
+    **Audio output debugging**: Deep validation may transcribe returned audio via `convert_audio_bytes_to_text` (Whisper). If an audio keyword or text–audio similarity assertion fails, set `VLLM_OMNI_KEEP_REQUEST_MEDIA=1` before running pytest to keep the intermediate WAV files for inspection (see [Test helper environment variables](test_system_overview.md#test-helper-environment-variables)).
+
+-   ***Run Command (L3 merge)***: `pytest -s -v /tests/e2e/online_serving/test_{model_name}.py -m advanced_model --run-level=advanced_model`
+
+-   ***Run Command (L4 nightly expansion)***: `pytest -s -v /tests/e2e/online_serving/test_{model_name}_expansion.py -m full_model --run-level=full_model`
+
+### L4 Level Testing - Full Functionality, Performance, and Documentation Testing
+
+#### 3.1 Testing Purpose
+
+L4 level testing is a comprehensive quality audit before a version release. It expands upon L3, executing ***full*** functional scenarios, conducting systematic ***performance stress tests***, and simultaneously verifying the correctness of accompanying ***example documentation***. Its purpose is to perform deep validation of the system during off-peak nighttime hours, providing quality trend reports for daytime development and data support for release decisions.
+
+
+
+#### 3.2 Testing Content and Scope
+
+-   ***Full Functionality Testing***: Executes all test cases defined in `test_{model_name}_expansion.py`, covering all implemented features, positive flows, boundary conditions, and exception handling.
+-   ***Performance Testing***: Uses `tests/dfx/perf/tests/test_qwen3_omni_*.json` (Omni), `test_tts.json` / `test_voxcpm2.json` / `test_higgs_audio_v3.json` (TTS), and diffusion configs `tests/dfx/perf/tests/test_*_vllm_omni.json` (passed to `run_benchmark.py` or `run_diffusion_benchmark.py` via `--test-config-file` in nightly **Perf Test** steps) to drive throughput, latency, and memory benchmarks. Each JSON **case** may declare an optional top-level **`mark`** array: exactly one ``hardware_marks`` object plus pytest marker name strings (`full_model`, `omni` / `tts` / `diffusion`, …). Runners attach those marks to each parametrized `(server, benchmark index)` pair so **local** bulk runs can filter with `-m` (for example `-m "full_model and H100 and diffusion"`). Nightly CI perf jobs select workloads by **`--test-config-file`**, not `-m`. Details are in the Performance Tests example below.
+-   ***Documentation Testing***: Verifies whether the example code provided to users is runnable and its results match the description.
+
+#### 3.3 Test Directory and Execution Files
+
+-   ***Functional Testing***: Same directories as L3.
+-   ***Performance Test Configuration***: `tests/dfx/perf/tests/test_qwen3_omni_*.json`, `test_tts.json`, `test_voxcpm2.json`, `test_higgs_audio_v3.json`, and diffusion configs `tests/dfx/perf/tests/test_*_vllm_omni.json` (e.g. `test_qwen_image_vllm_omni.json`, `test_cosmos3_vllm_omni.json`). Optional per-case `mark` for local `-m` filtering is documented in Section 3.4 Performance Tests.
+-   ***Documentation Example Tests***:
+    -   `tests/examples/online_serving/test_{model_name}.py`
+    -   `tests/examples/offline_inference/test_{model_name}.py`
+
+#### 3.4 Execution Method and Example
+
+-   ***Trigger Timing***: **`Nightly`**, automatically executed every night.
+-   ***Execution Environment***: ***GPU*** server clusters to meet the resource demands of performance testing.
+-   ***Script Example***:
+
+??? example "Test Examples: Documentation Example Tests"
+
+    --8<-- "docs/contributing/ci/test_examples/l4_doc_example_tests.inc.md"
+
+??? example "Test Examples: Performance Tests"
+
+    --8<-- "docs/contributing/ci/test_examples/l4_performance_tests.inc.md"
+
+??? example "Test Examples: Functionality Tests"
+
+    --8<-- "docs/contributing/ci/test_examples/l4_functionality_tests.inc.md"
+
+-   ***Run Command***: (Specific commands would depend on the performance testing tool and configuration defined in `nightly.json`).
+
+### L5 Level Testing - Stability and Reliability Testing
+
+#### 4.1 Testing Purpose
+
+L5 level testing focuses on the performance of model services under ***long-running*** and ***abnormal fault*** scenarios. It aims to uncover deep-seated issues that only manifest under sustained pressure or extreme conditions, such as memory leaks, resource contention, gradual performance degradation, and lack of fault tolerance mechanisms. This is the final, yet crucial, line of defense for ensuring service high availability and production environment robustness.
+
+
+
+#### 4.2 Testing Content and Scope
+
+-   ***Long-term Stability (Stability) Testing***: Uses JSON under `tests/dfx/stability/tests/` (for example `test_qwen3_omni.json` and `test_wan22.json`) to run the service under moderate load for an extended period (e.g., over 12 hours), monitoring whether metrics like memory/VRAM usage, response time, and throughput degrade over time, and whether the service process remains stable.
+-   ***Reliability Testing***: Uses pytest suites under `tests/dfx/reliability/` to inject controlled faults against a **live** `vllm_omni serve` instance (same **`omni_server` / `omni_server_function`** fixture style as E2E). Current suites emphasize **GPU memory pressure** (CUDA sidecar “memory hog”), **worker / runtime process kill** (`SIGKILL` on `VLLM::Worker` for Qwen3-Omni, `multiprocessing.spawn` for Wan2.2 video workers, or `vLLM-Omni::` for HunyuanImage DiT workers), **large multimodal chat**, **`/v1/videos`**, **`/v1/images/generations`**, or **`/v1/audio/speech`** jobs under OOM, **`/health` → 503** and **fast-fail / non-hanging concurrent** requests after kill, and **OpenAI-style 5xx error contracts** (e.g. text vs text+audio under OOM). **Post-fault recovery** checks exist where enabled (some cases may be `skip` while issues are tracked). See the Reliability `<details>` block in Section 4.4 for file-level responsibilities and CI markers (`slow`, `hardware_test`, POSIX-only kill).
+
+#### 4.3 Test Directory and Execution Files
+
+-   ***Stability Test Configuration***: `tests/dfx/stability/tests/test_qwen3_omni.json`, `tests/dfx/stability/tests/test_wan22.json` (one JSON per model / runner family)
+-   ***Reliability Test Suite*** (`tests/dfx/reliability/`):
+    -   `test_reliability_qwen3_omni.py` — Qwen3-Omni chat / multimodal reliability (GPU OOM, process kill, recovery, error contract under `--async-chunk` vs default).
+    -   `test_reliability_wan22.py` — Wan2.2 I2V video API reliability (`/v1/videos` under OOM and process kill, recovery).
+    -   `test_reliability_hunyuan_image.py` — HunyuanImage-3.0-Instruct DiT-only reliability (`/v1/images/generations` under OOM and process kill; deploy `hunyuan_image3_dit.yaml`, H100 × 4).
+    -   `test_reliability_voxcpm2.py` — VoxCPM2 TTS reliability (`/v1/audio/speech` under OOM and process kill; deploy `voxcpm2.yaml`, L4 × 1).
+    -   `helpers.py` — Shared primitives used by current suites: raw HTTP probes for `/v1/chat/completions` and `/health`, OpenAI-style error parsing, GPU OOM sidecar (`inject_gpu_oom` / `stop_gpu_oom_hogs`), and `pgrep`-based process-kill injector construction (`make_process_kill_fault_injector`).
+    -   `conftest.py` — `fault_injector` and `omni_server_after_fault` / `omni_server_after_fault_function` fixtures to run a callable **after** the server is ready.
+    -   `README.md` — Short local run commands for this directory.
+
+#### 4.4 Execution Method and Example
+
+-   ***Trigger Timing***: **`Weekly`** (weekly) or **`Days before Release`** (several days before a major release). Due to long execution times, the frequency is lower.
+-   ***Execution Environment***: ***GPU*** servers, requiring a stable and exclusive testing environment.
+-   ***Script Example***:
+<details>
+<summary> Test Examples</summary>
+
+When you want to add L5-level stability test cases, add or extend the appropriate JSON file under `tests/dfx/stability/tests/` (for example `test_qwen3_omni.json` for Omni bench traffic, or `test_wan22.json` for diffusion `/v1/videos` workloads). The following illustrates the Qwen3-Omni shape:
+
+```json
+{
+    "test_name": "test_qwen3_omni_stability",
+    "server_params": {
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "stage_config_name": "qwen3_omni.yaml"
+    },
+    "benchmark_params": [
+        {
+            "dataset_name": "random",
+            "backend": "openai-chat-omni",
+            "endpoint": "/v1/chat/completions",
+            "duration_sec": 43200,
+            "request_rate": 0.5,
+            "num_prompts_per_batch": 20,
+            "random_input_len": 2500,
+            "random_output_len": 900,
+            "ignore_eos": true,
+            "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration"
+        }
+    ]
+}
+```
+
+##### Parameter Explanation
+
+***Overview***
+
+| Field            | Required | Description                                                                 |
+| ---------------- | -------- | --------------------------------------------------------------------------- |
+| test_name        | Yes      | Unique identifier for the stability test case                               |
+| server_params    | Yes      | Server-side configuration parameters (model, stage configuration, etc.)     |
+| benchmark_params | Yes      | Stability benchmark running parameters (supports multiple configurations)   |
+
+##### server_params Configuration
+
+###### Basic Parameters
+
+| Parameter         | Required | Example                            | Description                         |
+| ----------------- | -------- | ---------------------------------- | ----------------------------------- |
+| model             | Yes      | "Qwen/Qwen3-Omni-30B-A3B-Instruct" | Model name or path                  |
+| stage_config_name | Yes      | "qwen3_omni.yaml"                  | Stage configuration file name       |
+
+###### Dynamic Configuration (update/delete)
+
+Supports incremental modifications based on the basic configuration:
+
+| Operation | Description                          |
+| --------- | ------------------------------------ |
+| update    | Update or add configuration items    |
+| delete    | Delete specified configuration items |
+
+***Example***:
+You can refer to Test Examples in L4 §3.4
+
+##### benchmark_params Configuration
+
+For stability testing, the key parameters are:
+
+-   **duration_sec**: Total duration (in seconds) during which benchmark traffic is sent. The stability benchmark will keep sending batches until this duration is reached.
+-   **request_rate** / **max_concurrency**: Exactly one of them must be specified. They control how the traffic is generated for each batch:
+    -   `request_rate`: Number of requests per second. The benchmark will send `num_prompts_per_batch` requests at the given rate.
+    -   `max_concurrency`: Maximum number of concurrent requests. When this is used, `request_rate` is set to `inf` internally.
+-   **num_prompts_per_batch**: Number of prompts sent in each batch. Multiple batches will be executed sequentially within `duration_sec`.
+
+All other optional parameters follow the same rules as in L4 §3.4.
+
+</details>
+
+<details>
+<summary> Reliability test suite (<code>tests/dfx/reliability</code>)</summary>
+
+##### Purpose and relationship to stability
+
+Reliability tests are **short fault-injection** integration runs (L5 **(b)** in `tests/dfx/reliability/README.md`). They complement **stability** JSON-driven long runs: instead of hours of steady traffic, they **perturb** the server (GPU OOM sidecar, fatal signals on selected processes) and check **failure mode** and **latency bounds** (e.g. chat or `/v1/videos` must not hang under concurrent fault-time load).
+
+##### Directory layout
+
+| Path | Responsibility |
+| ---- | -------------- |
+| `helpers.py` | Shared helpers used by current reliability suites: raw `POST`/`GET` probes (`/v1/chat/completions`, `/health`), OpenAI error parsing (`extract_openai_error_contract_from_bytes`), GPU OOM sidecar lifecycle (`inject_gpu_oom`, `stop_gpu_oom_hogs`), and process-kill injector builder (`make_process_kill_fault_injector`). |
+| `conftest.py` | Pytest fixtures: indirect `fault_injector`, `omni_server_after_fault` / `omni_server_after_fault_function` (run injector after server is ready, then yield server). |
+| `test_reliability_qwen3_omni.py` | Qwen3-Omni: OOM vs **text vs text+audio** error contract, large multimodal chat under OOM, concurrent pressure, **SIGKILL** on `VLLM::Worker`, `/health` → 503 + fast-fail + concurrent chat; optional OOM recovery scenario (may be skipped while tracked in issues). |
+| `test_reliability_wan22.py` | Wan2.2 I2V: large `/v1/videos` under OOM, **SIGKILL** on `multiprocessing.spawn` chain, health / fast-fail / concurrent video requests; optional recovery test (may be skipped). |
+| `test_reliability_hunyuan_image.py` | HunyuanImage DiT-only: large `/v1/images/generations` under OOM, **SIGKILL** on `vLLM-Omni::` workers and serve/tree targets, health / fast-fail / concurrent image requests; some OOM/recovery cases may be skipped while tracked in issues. |
+| `test_reliability_voxcpm2.py` | VoxCPM2: `/v1/audio/speech` under OOM (error contract), **SIGKILL** on `VLLM::` workers and serve/tree targets, health / fast-fail / concurrent speech requests; some OOM cases may be skipped while tracked in issues. |
+| `README.md` | Minimal run / collect examples. |
+
+##### Parametrization and markers
+
+- Each test module defines a **`RELIABILITY_SCENARIOS`** list (`test_name`, `server_params`: model, `stage_config_name` or diffusion `server_args`, etc.). **`create_reliability_omni_server_params()`** in `tests/dfx/conftest.py` resolves stage paths (including XPU substitutions where applicable) and builds **`OmniServerParams`** lists consumed by **`@pytest.mark.parametrize(..., indirect=True)`** on `omni_server` or `omni_server_function`.
+- Cases are tagged **`@pytest.mark.slow`** for weekly / selective CI. GPU-heavy suites use **`@hardware_test(res={"cuda": "H100"}, num_cards=...)`** or **`@hardware_test(res={"cuda": "L4"}, num_cards=1)`** (Qwen3-Omni **2**× H100; Wan2.2 **1**× H100; HunyuanImage DiT **4**× H100; VoxCPM2 **1**× L4).
+- **Process-kill** tests use **`@pytest.mark.skipif(os.name == "nt", ...)`** because injection uses POSIX **`pgrep` / `kill`**.
+
+##### CI trigger
+
+Weekly Buildkite (`.buildkite/cuda/test-weekly.yml`) runs one step per model suite (trigger: `WEEKLY=1` or PR label `weekly-test`), for example:
+
+| Buildkite step | Test file | CI hardware |
+| -------------- | --------- | ----------- |
+| Reliability Test - qwen3-omni | `test_reliability_qwen3_omni.py` | H100 × 2 (`mithril-h100-pool`) |
+| Reliability Test - wan22 | `test_reliability_wan22.py` | H100 × 2 (`mithril-h100-pool`) |
+| Reliability Test - hunyuan-image | `test_reliability_hunyuan_image.py` | H100 × 4 (`mithril-h100-pool`) |
+| Reliability Test - voxcpm2 | `test_reliability_voxcpm2.py` | L4 × 1 (`gpu_1_queue`) |
+
+```bash
+pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m "slow"
+pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m "slow"
+pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m "slow"
+pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m "slow"
+```
+
+##### Local commands
+
+```bash
+pytest --collect-only tests/dfx/reliability
+pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m slow
+pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m slow
+pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m slow
+pytest -s -v tests/dfx/reliability/test_reliability_voxcpm2.py -m slow
+```
+
+##### Adding a new model suite
+
+1. Add `test_reliability_<model>.py` under `tests/dfx/reliability/`.
+2. Define **`RELIABILITY_SCENARIOS`** and pass them through **`create_reliability_omni_server_params()`** with the correct deploy or e2e stage-config directory (same pattern as existing files).
+3. Reuse **`helpers`** for OOM / kill / raw HTTP; prefer **`assert_fault_exception()`** and **`resolve_oom_device_spec()`** from `tests/dfx/conftest.py` for consistent device selection vs stage YAML.
+4. Register **`slow`** (and **`hardware_test`** if needed); extend **`.buildkite/cuda/test-weekly.yml`** when the suite should run in weekly L5.
+
+</details>
+
+-   -   ***Stability***: `pytest -s -v tests/dfx/stability/scripts/test_stability_qwen3_omni.py` or `pytest -s -v tests/dfx/stability/scripts/test_stability_wan22.py` (or add `test_stability_<model>.py` alongside a matching JSON config)
+    -   ***Reliability***: `pytest -s -v tests/dfx/reliability/test_reliability_<model>.py -m slow` (current suites: `qwen3_omni`, `wan22`, `hunyuan_image`, `voxcpm2`; add `test_reliability_<suite>.py` and a matching step in `.buildkite/cuda/test-weekly.yml` for new models)
diff --git a/docs/contributing/ci/tests_markers.md b/docs/contributing/ci/tests_markers.md
deleted file mode 100644
index cc89cee47..000000000
--- a/docs/contributing/ci/tests_markers.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# Markers for Tests
-
-By adding markers before test functions, tests can later be executed uniformly by simply declaring the corresponding marker type.
-
-## Current Markers
-Defined in `pyproject.toml`:
-
-| Marker             | Description                                               |
-| ------------------ | --------------------------------------------------------- |
-| `core_model`       | L1&L2 tests (run in each PR)                              |
-| `advanced_model`   | L3 tests (run on each merge to main)                 |
-| `full_model`       | L4 tests (run nightly) |
-| `diffusion`        | Diffusion model tests                                     |
-| `omni`             | Omni multimodal model tests |
-| `tts`              | TTS model tests     |
-| `cache`            | Cache backend tests                                       |
-| `parallel`         | Parallelism/distributed tests                             |
-| `cpu`              | Tests that run on CPU                                     |
-| `gpu`              | Tests that run on GPU *                                   |
-| `cuda`             | Tests that run on CUDA *                                  |
-| `rocm`             | Tests that run on AMD/ROCm *                              |
-| `xpu`              | Tests that run on Intel XPU *                             |
-| `npu`              | Tests that run on NPU/Ascend *                            |
-| `H100`             | Tests that require H100 GPU  *                            |
-| `L4`               | Tests that require L4 GPU *                               |
-| `MI325`            | Tests that require MI325 GPU (AMD/ROCm) *                 |
-| `A2`               | Tests that require A2 NPU *                               |
-| `A3`               | Tests that require A3 NPU *                               |
-| `distributed_cuda` | Tests that require multi cards on CUDA platform *         |
-| `distributed_rocm` | Tests that require multi cards on ROCm platform  *        |
-| `distributed_npu`  | Tests that require multi cards on NPU platform  *         |
-| `skipif_cuda`      | Skip if the num of CUDA cards is less than the required * |
-| `skipif_rocm`      | Skip if the num of ROCm cards is less than the required * |
-| `skipif_npu`       | Skip if the num of NPU cards is less than the required *  |
-| `slow`             | Slow tests (may skip in quick CI)                         |
-| `benchmark`        | Benchmark tests                                           |
-
-\* Means those markers are auto-added by `@hardware_test` (parametrization decorator) or `hardware_marks` (only returning the list of marks for flexibility).
-
-### Example usage for markers
-
-```python
-from tests.helpers.mark import hardware_test
-
-@pytest.mark.core_model
-@pytest.mark.omni
-@hardware_test(
-   res={"cuda": "L4", "rocm": "MI325", "npu": "A2"},
-   num_cards=2,
-)
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_video_to_audio()
-    ...
-```
-
-### Decorator: `@hardware_test`
-
-This decorator is intended to make hardware-aware, cross-platform test authoring easier and more robust for CI/CD environments. The `hardware_test` decorator in `vllm-omni/tests/helpers/mark.py` performs the following actions:
-
-1. **Applies platform and resource markers**  
-   Adds the appropriate pytest markers for each specified hardware platform (e.g., `cuda`, `rocm`, `xpu`, `npu`) and resource type (e.g., `L4`, `H100`, `MI325`, `B60`, `A2`, `A3`).
-   ```
-   @pytest.mark.cuda
-   @pytest.mark.L4
-   ```
-2. **Handles multi-card (distributed) scenarios**  
-   For tests requiring multiple cards, it automatically adds distributed markers such as `distributed_cuda`, `distributed_rocm`, or `distributed_npu`.
-   ```
-   @pytest.mark.distributed_cuda(num_cards=num_cards)
-   ```
-3. **Supports flexible card requirements**  
-   Accepts `num_cards` as either a single integer for all platforms or as a dictionary with per-platform values. If not specified, defaults to 1 card per platform.
-
-4. **Integrates resource validation**  
-   On CUDA, adds a skip marker (`skipif_cuda`) if the system does not have the required number of devices.
-   Support for `skipif_rocm` and `skipif_npu` will be implemented later.
-
-
-5. **Works with pytest filtering**  
-   Allows tests to be filtered and selected at runtime using standard pytest marker expressions (e.g., `-m "distributed_cuda and L4"`).
-
-#### Example usage for decorator
-- Single call for multiple platforms:
-    ```python
-    @hardware_test(
-        res={"cuda": "L4", "rocm": "MI325", "xpu": "B60", "npu": "A2"},
-        num_cards={"cuda": 2, "rocm": 2, "xpu": 2, "npu": 2},
-    )
-    ```
-    or
-    ```python
-    @hardware_test(
-        res={"cuda": "L4", "rocm": "MI325", "xpu": "B60", "npu": "A2"},
-        num_cards=2,
-    )
-    ```
-- `res` must be a dict; supported resources: CUDA (L4/H100), ROCm (MI325), NPU (A2/A3)
-- `num_cards` can be int (all platforms) or dict (per platform); defaults to 1 when missing
-- Distributed markers (`distributed_cuda`, `distributed_rocm`, `distributed_npu`) are auto-added for multi-card cases
-- Filtering examples:
-    - CUDA only: `pytest -m "distributed_cuda and L4"`
-    - ROCm only: `pytest -m "distributed_rocm and MI325"`
-    - NPU only: `pytest -m "distributed_npu"`
-
-### Function: `hardware_marks`
-
-`hardware_marks` returns a list of pytest mark objects with the same signature as `@hardware_test`. Use it when you need more flexibility, such as attaching hardware marks to individual `pytest.param` entries rather than an entire test function.
-
-```python
-from tests.helpers.mark import hardware_marks
-
-MULTI_CARD_MARKS = hardware_marks(
-    res={"cuda": "H100", "rocm": "MI325", "npu": "A2"}, num_cards=2
-)
-
-@pytest.mark.parametrize("omni_server", [
-    pytest.param(OmniServerParams(...), id="case_001", marks=MULTI_CARD_MARKS),
-], indirect=True)
-def test_feature(omni_server):
-    ...
-```
-
-## Add Support for a New Platform
-
-If you want to add support for a new platform (e.g., "tpu" for a new accelerator), follow these steps:
-
-1. **Extend the marker list in your pytest config** so that platform/resource markers are defined:
-   ```toml
-   # In pyproject.toml or pytest.ini
-   [tool.pytest.ini_options]
-   markers = [
-       # ... existing markers ...
-       "tpu: Tests that require TPU device",
-       "TPU_V3: Tests that require TPU v3 hardware",
-       "distributed_tpu: Tests that require multiple TPU devices",
-   ]
-   ```
-2. **Implement a marker construction function for your platform** in `vllm-omni/tests/helpers/mark.py`:
-   ```python
-   # In vllm-omni/tests/helpers/mark.py
-
-   def tpu_marks(*, res: str, num_cards: int):
-       test_platform = pytest.mark.tpu
-       if res == "TPU_V3":
-           test_resource = pytest.mark.TPU_V3
-       else:
-           raise ValueError(
-               f"Invalid TPU resource type: {res}. Supported: TPU_V3")
-
-       if num_cards == 1:
-           return [test_platform, test_resource]
-       else:
-           test_distributed = pytest.mark.distributed_tpu(num_cards=num_cards)
-           # Optionally: add skipif_tpu when implemented
-           return [test_platform, test_resource, test_distributed]
-   ```
-3. **Update `hardware_marks` to recognize your new platform**:
-    In the relevant place (see the `hardware_marks` implementation), add:
-    ```python
-    if platform == "tpu":
-        marks = tpu_marks(res=resource, num_cards=cards)
-    ```
-    (`hardware_test` calls `hardware_marks` internally, so both will pick up the change.)
-4. **(Recommended) Add a test using your new markers**:
-   ```python
-   @hardware_test(
-       res={"tpu": "TPU_V3"},
-       num_cards=2,
-   )
-   def test_my_tpu_feature():
-       ...
-   ```
-
-**Summary**:  
-- Add pytest markers for your new platform/resources  
-- Implement a marker function (`xxx_marks`)  
-- Plug into `hardware_marks`  
-- You're done: tests using `@hardware_test` or `hardware_marks` with your platform now automatically get the correct markers, distribution, and isolation!
-
-See code in `vllm-omni/tests/helpers/mark.py` for existing examples (`cuda_marks`, `rocm_marks`, `npu_marks`).
diff --git a/docs/contributing/ci/tests_style.md b/docs/contributing/ci/tests_style.md
deleted file mode 100644
index 420a8821d..000000000
--- a/docs/contributing/ci/tests_style.md
+++ /dev/null
@@ -1,466 +0,0 @@
-# Test File Structure and Style Guide
-
-To ensure project maintainability and sustainable development, we encourage contributors to submit test code (unit tests, system tests, or end-to-end tests) alongside their code changes. This document outlines the guidelines for organizing and naming test files.
-
-## Checklist before submitting your test files
-
-1. The file is saved in an appropriate place and the file name is clear.
-2. The coding style follows the requirements outlined below.
-3. All test functions have appropriate pytest markers.
-4. For tests that need run in CI, please ensure it labeled as ``@pytest.mark.core_model` the test is configured under the `./buildkite/` folder.
-
-
-## Test Types
-
-For more details about our [Five Levels Tests design](../ci/CI_5levels.md).
-
-### Unit Tests and System Tests
-For unit tests and system tests, we strongly recommend placing test files in the same directory structure as the source code being tested, using the naming convention `test_*.py`.
-
-### End-to-End (E2E) Tests for Models
-End-to-end tests verify the complete functionality of a system or component. For our project, the E2E tests for different omni models are organized into two subdirectories:
-
-- **`tests/e2e/offline_inference/`**: Tests for offline inference modes (e.g., Qwen3Omni offline inference)
-
-- **`tests/e2e/online_serving/`**: Tests for online serving scenarios (e.g., API server tests)
-
-## Test Directory Structure
-
-The ideal directory structure mirrors the source code organization. Legend: `✅` = test exists, `⬜` = suggested to add.
-
-```
-vllm_omni/                                    tests/
-├── config/                             →     ├── config/
-│   ├── model.py                              │   └── test_model.py                    ⬜
-│   └── lora.py                               │   └── test_lora.py                      ⬜
-│
-├── core/                               →     ├── core/
-│   └── sched/                                 │   └── sched/
-│       ├── omni_ar_scheduler.py               │       ├── test_omni_ar_scheduler.py    ⬜
-│       ├── omni_generation_scheduler.py       │       ├── test_omni_generation_scheduler.py  ⬜
-│       └── output.py                          │       └── test_output.py               ✅ currently in entrypoints/test_omni_new_request_data.py (tests output.OmniNewRequestData)
-│
-├── diffusion/                          →     ├── diffusion/
-│   ├── diffusion_engine.py                    │   ├── test_diffusion_engine.py          ⬜
-│   ├── attention/                             │   ├── attention/
-│   │   ├── layer.py                            │   │   ├── test_attention_sp.py         ✅
-│   │   └── backends/                           │   │   └── test_flash_attn.py           ✅
-│   ├── distributed/                           │   ├── distributed/
-│   │   └── ...                                 │   │   ├── test_comm.py                 ✅
-│   │                                            │   │   ├── test_cfg_parallel.py        ✅
-│   │                                            │   │   └── test_sp_plan_hooks.py       ✅
-│   ├── lora/                                   │   ├── lora/
-│   │   └── ...                                 │   │   ├── test_base_linear.py          ✅
-│   │                                            │   │   └── test_lora_manager.py        ✅
-│   ├── models/                                 │   ├── models/
-│   │   ├── qwen_image/                         │   │   ├── qwen_image/                 (e2e coverage)
-│   │   ├── ovis_image/                         │   │   ├── ovis_image/
-│   │   │   └── ...                             │   │   │   └── test_ovis_image.py     ✅
-│   │   ├── z_image/                            │   │   └── z_image/
-│   │   └── ...                                 │   │       └── test_zimage_tp_constraints.py  ✅
-│   └── worker/                                 │   └── worker/
-│       ├── diffusion_worker.py                 │       └── test_diffusion_worker.py   ✅ file at diffusion/test_diffusion_worker.py
-│       └── diffusion_model_runner.py            │
-│
-├── distributed/                         →     ├── distributed/
-│   └── omni_connectors/                         │   └── omni_connectors/
-│       ├── adapter.py                           │       ├── test_adapter_and_flow.py   ✅
-│       ├── kv_transfer_manager.py               │       ├── test_basic_connectors.py   ✅
-│       ├── connectors/                           │       ├── test_kv_flow.py             ✅
-│       └── utils/                               │       └── test_omni_connector_configs.py  ✅
-│
-├── engine/                             →     ├── engine/
-│   ├── input_processor.py                      │   ├── test_input_processor.py         ⬜  (no processor.py in source)
-│   ├── output_processor.py                     │   └── test_output_processor.py         ⬜
-│   └── arg_utils.py                            │   └── test_arg_utils.py               ⬜
-│
-├── entrypoints/                        →     ├── entrypoints/
-│   ├── stage_utils.py                          │   ├── test_stage_utils.py            ✅
-│   ├── cli/                                     │   ├── cli/                           (benchmarks/test_serve_cli.py covers CLI serve)
-│   │   └── ...                                  │   │   └── test_*.py                  ⬜
-│   └── openai/                                  │   └── openai_api/                    # maps to entrypoints/openai/
-│       ├── api_server.py                        │       ├── test_api_server.py         ⬜  (e2e indirect coverage)
-│       ├── serving_chat.py                       │       ├── test_serving_chat_sampling_params.py  ✅
-│       ├── serving_speech.py                     │       ├── test_serving_speech.py     ✅
-│       └── image_api_utils.py                   │       └── test_image_server.py      ✅
-│
-├── inputs/                             →     ├── inputs/
-│   ├── data.py                                 │   ├── test_data.py                   ⬜
-│   ├── parse.py                                │   ├── test_parse.py                 ⬜
-│   └── preprocess.py                            │   └── test_preprocess.py            ✅ currently in entrypoints/test_omni_input_preprocessor.py
-│
-├── model_executor/                     →     ├── model_executor/
-│   ├── layers/                                  │   ├── layers/
-│   │   └── mrope.py                             │   │   └── test_mrope.py              ⬜
-│   ├── model_loader/                            │   ├── model_loader/
-│   │   └── weight_utils.py                      │   │   └── test_weight_utils.py      ⬜
-│   ├── models/                                  │   ├── models/
-│   │   ├── qwen2_5_omni/                         │   │   ├── qwen2_5_omni/
-│   │   │   ├── qwen2_5_omni_thinker.py           │   │   │   ├── test_audio_length.py  ✅
-│   │   │   ├── qwen2_5_omni_talker.py            │   │   │   ├── test_qwen2_5_omni_thinker.py  ⬜
-│   │   │   └── qwen2_5_omni_token2wav.py         │   │   │   ├── test_qwen2_5_omni_talker.py  ⬜
-│   │   └── qwen3_omni/                          │   │   │   └── test_qwen2_5_omni_token2wav.py  ⬜
-│   │       └── ...                               │   │   └── qwen3_omni/
-│   ├── stage_configs/                           │   │       └── test_*.py              ⬜
-│   │   └── *.yaml                               │   └── stage_configs/                 (used by e2e, test_*.py can be added)  ⬜
-│   └── stage_input_processors/                  │   └── stage_input_processors/
-│       └── ...                                  │       └── test_*.py                 ⬜
-│
-├── sample/                             →     ├── sample/
-│   └── __init__.py                             │   └── test_*.py                      ⬜
-│
-├── utils/                              →     ├── utils/
-│   └── __init__.py                             │   └── test_*.py                       ⬜  (no platform_utils.py currently)
-│
-├── worker/                             →     ├── worker/
-│   ├── gpu_ar_model_runner.py                  │   ├── test_gpu_ar_model_runner.py    ⬜
-│   ├── gpu_ar_worker.py                        │   ├── test_gpu_ar_worker.py           ⬜
-│   ├── gpu_generation_model_runner.py          │   ├── test_gpu_generation_model_runner.py  ✅
-│   ├── gpu_generation_worker.py                │   ├── test_gpu_generation_worker.py  ⬜
-│   ├── gpu_model_runner.py                     │   ├── test_omni_gpu_model_runner.py   ✅
-│   └── mixins.py                               │   └── (npu under platforms/npu/worker/)  # not worker/npu/
-│
-├── platforms/                          →     (no tests/platforms/, e2e and stage_configs provide indirect coverage)
-│   ├── cuda/
-│   ├── npu/worker/                             # NPU worker here, not vllm_omni/worker/npu/
-│   ├── rocm/
-│   └── xpu/worker/
-│
-├── outputs.py                          →     test_outputs.py                         ✅ (at tests root)
-├── (logger, patch, request, version)    →     (no corresponding unit test)
-│
-└── e2e (tests side only)               →     ├── e2e/
-                                               ├── online_serving/                     ✅ non-empty
-                                               │   ├── test_qwen2_5_omni.py
-                                               │   ├── test_async_omni.py
-                                               │   ├── test_qwen3_omni.py
-                                               │   ├── test_qwen3_omni_expansion.py
-                                               │   ├── test_mimo_audio.py
-                                               │   └── test_images_generations_lora.py
-                                               └── offline_inference/                  ✅
-                                                   ├── test_qwen2_5_omni.py
-                                                   ├── test_qwen3_omni.py
-                                                   ├── test_bagel_text2img.py
-                                                   ├── test_z_image.py
-                                                   ├── test_wan22.py
-                                                   ├── test_zimage_tensor_parallel.py
-                                                   ├── test_cache_dit.py
-                                                   ├── test_teacache.py
-                                                   ├── test_stable_audio_expansion.py
-                                                   ├── test_diffusion_cpu_offload.py
-                                                   ├── test_diffusion_layerwise_offload.py
-                                                   ├── test_diffusion_lora.py
-                                                   ├── test_sequence_parallel.py
-                                                   ├── test_qwen_image_edit_expansion.py
-                                                   └── stage_configs/                  (legacy schema, still present
-                                                       ├── bagel_*.yaml                 for unmigrated models)
-                                                       └── npu/, rocm/, etc.
-
-# Migrated models (qwen3_omni_moe, qwen2_5_omni, qwen3_tts) live under
-# vllm_omni/deploy/ instead — see docs/configuration/stage_configs.md.
-examples/                                     tests
-│                                             └── examples
-├── online_serving/                     →         ├── online_serving/
-│   └── {doc_page_title}/README.md                │   └── test_{doc_page_title}.py  ⬜
-└── offline_inference/                  →         └── offline_inference/
-    └── {doc_page_title}/README.md                    └── test_{doc_page_title}.py  ⬜
-```
-
-
-
-### Naming Conventions
-
-- **Unit Tests**: Use `test_<module_name>.py` format. Example: `stage_utils.py` → `test_stage_utils.py`
-
-- **E2E Tests**: Place in `tests/e2e/offline_inference/` or `tests/e2e/online_serving/` with descriptive names. Example: `tests/e2e/offline_inference/test_qwen3_omni.py`, `tests/e2e/offline_inference/test_diffusion_model.py`
-
-- **Expansion Tests**
-
-### Best Practices
-
-1. **Mirror Source Structure**: Test directories should mirror the source code structure
-2. **Test Type Indicators**: Use comments to indicate test types (UT for unit tests, E2E for end-to-end tests)
-3. **Shared Resources**: Place shared test configurations (e.g., CI configs) in appropriate subdirectories
-4. **Consistent Naming**: Follow the `test_*.py` naming convention consistently across all test files
-
-
-## Test codes requirements
-
-### Coding style
-
-1. **File header**: Add SPDX license header to all test files
-2. **Imports**: Pls don't use manual `sys.path` modifications, use standard imports instead.
-3. **Test type differentiation**:
-
-      - Unit tests: Maintain mock style
-      - E2E tests for models: Consider using OmniRunner uniformly, avoid decorators
-
-4. **Documentation**: Add docstrings to all test functions
-5. **Environment variables**: Set uniformly in `conftest.py` or at the top of files
-6. **Type annotations**: Add type annotations to all test function parameters
-7. **Pytest Markers**: Add necessary markers like `@pytest.mark.core_model` and use `@hardware_test` to declare hardware requirements (check detailed in [Markers for Tests](../ci/tests_markers.md)).
-
-### Template
-#### E2E - Online serving
-
-E2E Online tests for Qwen3-Omni model with mix input and audio+text output. Based on `tests/e2e/online_serving/test_qwen3_omni.py`.
-
-```python
-"""
-E2E Online tests for Qwen3-Omni model with mix input and audio+text output.
-"""
-
-import os
-
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-import threading
-from pathlib import Path
-
-import openai
-import pytest
-
-from tests.helpers.media import (
-    convert_audio_bytes_to_text,
-    cosine_similarity_text,
-    generate_synthetic_video,
-)
-from tests.helpers.runtime import OmniServer, dummy_messages_from_mix_data
-from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
-from vllm_omni.platforms import current_omni_platform
-
-# Edit: model name and stage config path
-models = ["Qwen/Qwen3-Omni-30B-A3B-Instruct"]
-
-#If you use the default configuration file, you can directly use the following address.
-def get_default_config():
-    return get_deploy_config_path("ci/qwen3_omni_moe.yaml")
-
-#If you need to modify the configuration file, you can use modify_stage_config.
-def get_chunk_config():
-    path = modify_stage_config(
-        get_default_config(),
-        updates={
-            "async_chunk": True,
-            "stage_args": {
-                0: {
-                    "engine_args.custom_process_next_stage_input_func": "vllm_omni.model_executor.stage_input_processors.qwen3_omni.thinker2talker_async_chunk"
-                },
-                1: {
-                    "engine_args.custom_process_next_stage_input_func": "vllm_omni.model_executor.stage_input_processors.qwen3_omni.talker2code2wav_async_chunk"
-                },
-            },
-        },
-        deletes={"stage_args": {2: ["custom_process_input_func"]}},
-    )
-    return path
-
-stage_configs = [get_default_config(), CHUNK_CONFIG_PATH]
-
-test_params = [(model, stage_config) for model in models for stage_config in stage_configs]
-
-
-#Please use this method to launch the online instance.
-_omni_server_lock = threading.Lock()
-
-@pytest.fixture(scope="module")
-def omni_server(request):
-    """Start vLLM-Omni server as a subprocess. Use module scope for multi-stage init (10-20+ min)."""
-    with _omni_server_lock:
-        model, stage_config_path = request.param
-        with OmniServer(
-            model,
-            ["--stage-configs-path", stage_config_path, "--stage-init-timeout", "120"],
-        ) as server:
-            yield server
-
-
-@pytest.fixture
-def client(omni_server):
-    """OpenAI client for the running vLLM-Omni server."""
-    return openai.OpenAI(
-        base_url=f"http://{omni_server.host}:{omni_server.port}/v1",
-        api_key="EMPTY",
-    )
-
-#Please use function definitions above the test function to define the prompts and other parameters you need.
-def get_system_prompt():
-    return {
-        "role": "system",
-        "content": [
-            {
-                "type": "text",
-                "text": (
-                    "You are Qwen, a virtual human developed by the Qwen Team, "
-                    "Alibaba Group, capable of perceiving auditory and visual inputs, "
-                    "as well as generating text and speech."
-                ),
-            }
-        ],
-    }
-
-...
-
-#Please define test case tags according to the instructions in the marker documentation.
-@pytest.mark.core_model
-@pytest.mark.omni
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_mix_to_text_audio_001(client: openai.OpenAI, omni_server, request) -> None:
-    # PLEASE FOLLOW THESE TEMPLATE INSTRUCTIONS:
-    # ============================================================================
-    # TEMPLATE USAGE GUIDE:
-    # 1. Copy this entire function as a starting point for multi-modal tests
-    # 2. Update the test name to reflect your specific test scenario
-    # 3. Modify input/output modalities as needed (see OPTIONS section below)
-    # 4. Adjust assertions based on your expected outcomes
-    # 5. Add custom validation logic for your specific use case
-    # ============================================================================
-
-    #Please list the relevant test points.
-    """
-    Test multi-modal input processing and text/audio output generation via OpenAI API.
-    Deploy Setting: default yaml
-    Input Modal: text + audio + video + image
-    Output Modal: text + audio
-    Input Setting: stream=True
-    Datasets: single request
-    """
-    # SECTION 1: TEST SETUP AND INITIALIZATION
-    # =========================================
-    # INSTRUCTIONS: Initialize test variables and prepare test environment
-    # MODIFY: Add any additional test setup required for your scenario
-    e2e_list = list()
-    # SECTION 2: TEST DATA GENERATION
-    # ================================
-    # INSTRUCTIONS: Generate or load test data for each input modality
-    # MODIFY: Replace synthetic generators with your actual data sources
-    # VIDEO DATA - Generate synthetic video for testing
-    # FORMAT: data:video/mp4;base64,{base64_encoded_video}
-    # PARAMETERS: width, height, duration_frames
-    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(224, 224, 300)['base64']}"
-    # IMAGE DATA - Generate synthetic image for testing
-    # FORMAT: data:image/jpeg;base64,{base64_encoded_image}
-    # PARAMETERS: width, height
-    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(224, 224)['base64']}"
-    # AUDIO DATA - Generate synthetic audio for testing
-    # FORMAT: data:audio/wav;base64,{base64_encoded_audio}
-    # PARAMETERS: duration_seconds, channels
-    audio_data_url = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
-
-    # SECTION 3: MESSAGE CONSTRUCTION
-    # ================================
-    # INSTRUCTIONS: Assemble the complete message payload for API request
-    # MODIFY: Add/remove modalities or change prompt structure as needed
-
-    # USAGE: Construct a message containing all input modalities
-    # IMPORTANT: Ensure the message structure matches OpenAI API expectations
-    # CUSTOMIZATION POINTS:
-    #   - system_prompt: Controls the assistant's behavior
-    #   - content_text: The user's text prompt/question
-    #   - *_data_url: URLs for media content (video/image/audio)
-    messages = dummy_messages_from_mix_data(
-        system_prompt=get_system_prompt(),
-        video_data_url=video_data_url,
-        image_data_url=image_data_url,
-        audio_data_url=audio_data_url,
-        content_text=get_prompt("mix"),
-    )
-
-    # SECTION 4: API REQUEST EXECUTION
-    # =================================
-    # INSTRUCTIONS: Make the API call and measure performance
-    # MODIFY: Add timeout, retry logic, or additional parameters
-    start_time = time.perf_counter()
-    chat_completion = client.chat.completions.create(model=omni_server.model, messages=messages, stream=True)
-
-    #Call using your preferred method and obtain the final audio and text outputs.
-    ...
-
-    # SECTION 5: OUTPUT VALIDATION
-    # =============================
-    # INSTRUCTIONS: Verify that outputs meet expected criteria
-    # MODIFY: Adjust validation logic for your specific requirements
-
-    # ASSERTION 1: E2E Validation
-    # PURPOSE: Verify that the E2E latency is less than the baseline.
-    current_e2e = time.perf_counter() - start_time
-    print(f"the request e2e is: {current_e2e}")
-    e2e_list.append(current_e2e)
-
-    print(f"the avg e2e is: {sum(e2e_list) / len(e2e_list)}")
-
-
-
-    # ASSERTION 2: Text Output Validation
-    # PURPOSE: Verify that text output was generated with keyword content
-    assert text_content is not None and len(text_content) >= 2, "No text output is generated"
-    assert any(
-        keyword in text_content.lower() for keyword in ["square", "quadrate", "sphere", "globe", "circle", "round"]
-    ), "The output does not contain any of the keywords."
-
-
-    # ASSERTION 3: Cross-Modal Consistency
-    # PURPOSE: Verify text and audio outputs convey the same information
-    # CUSTOMIZATION: Adjust similarity threshold (0.9) based on accuracy requirements
-    assert audio_data is not None, "No audio output is generated"
-    audio_content = convert_audio_bytes_to_text(audio_data)
-    print(f"text content is: {text_content}")
-    print(f"audio content is: {audio_content}")
-    similarity = cosine_similarity_text(audio_content.lower(), text_content.lower())
-    print(f"similarity is: {similarity}")
-    assert similarity > 0.9, "The audio content is not same as the text"
-```
-
-
-#### E2E - Offline inference
-```python
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""
-Offline E2E smoke test for an omni model (video → audio).
-"""
-
-import os
-from pathlib import Path
-
-import pytest
-from vllm.assets.video import VideoAsset
-
-from tests.helpers.mark import hardware_test
-from ..multi_stages.conftest import OmniRunner
-
-# Optional: set process start method for workers
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-models = ["{your model name}"] #Edit here to load your model
-stage_configs = [str(Path(__file__).parent / "stage_configs" / {your model yaml})] #Edit here to load your model yaml
-
-# Create parameter combinations for model and stage config
-test_params = [(model, stage_config) for model in models for stage_config in stage_configs]
-
-# function name: test_{input_modality}_to_{output_modality}
-# modality candidate: text, image, audio, video, mixed_modalities
-@pytest.mark.core_model
-@pytest.mark.omni
-@hardware_test(
-    res={"cuda": "L4", "rocm": "MI325", "npu": "A2"},
-    num_cards=2,
-)
-@pytest.mark.parametrize("test_config", test_params)
-def test_video_to_audio(omni_runner: type[OmniRunner], model: str) -> None:
-    """Offline inference: video input, audio output."""
-    model, stage_config_path = test_config
-    with omni_runner(model, seed=42, stage_configs_path=stage_config_path) as runner:
-        # Prepare inputs
-        video = VideoAsset(name="sample", num_frames=4).np_ndarrays
-
-        outputs = runner.generate_multimodal(
-            prompts="Describe this video briefly.",
-            videos=video,
-        )
-
-        # Minimal assertions: got outputs and at least one audio result
-        assert outputs
-        has_audio = any(o.final_output_type == "audio" for o in outputs)
-        assert has_audio
-```
diff --git a/docs/contributing/model/adding_diffusion_model.md b/docs/contributing/model/adding_diffusion_model.md
index b38805112..678797652 100644
--- a/docs/contributing/model/adding_diffusion_model.md
+++ b/docs/contributing/model/adding_diffusion_model.md
@@ -653,7 +653,7 @@ python end2end.py --model your-org/your-model-name --modality text2img --prompts
 Mirror BAGEL’s online serving setup:
 
 - Server launcher: `examples/online_serving/your_model_name/run_server.sh`
-  - Wrap `vllm serve ... --omni --port ...` (and `--stage-configs-path ...` if needed)
+  - Wrap `vllm serve ... --omni --port ...` (and `--deploy-config ...` if needed)
 - Client: `examples/online_serving/your_model_name/openai_chat_client.py`
   - Send requests to `POST /v1/chat/completions`
   - Support multimodal inputs (e.g., base64 image) if your model needs it
@@ -685,7 +685,7 @@ For a fair comparison, keep the same **prompt**, **seed**, **resolution**, **num
 
 To ensure project maintainability and sustainable development, please submit test code (unit tests, system tests, or end-to-end tests) alongside their code changes.
 
-For comprehensive testing guidelines and the definition of test levels (L1-L5), please refer to the [Multi-Level Automated Testing System Documentation](../ci/CI_5levels.md). You are at least required to add an L4 *functionality* test described in that document.
+For the definition of test levels (L1-L5), see [Test System Overview](../ci/test_system_overview.md). You are at least required to add an L4 *functionality* test as described in [Test Writing Guide](../ci/test_writing_guide.md#l4-level-testing-full-functionality-performance-and-documentation-testing).
 
 ---
 
@@ -755,7 +755,8 @@ omni = Omni(model="your-model", ulysses_degree=2, ring_degree=2)
 
 ### Step Execution
 
-See detailed design guide: [How to add step execution support](../../design/feature/diffusion_step_execution.md)
+See the detailed
+[Diffusion Continuous Batching design guide](../../design/feature/diffusion_continuous_batching.md).
 
 Use this only when your pipeline can be split into stable request-scoped and
 step-scoped phases. The reference implementation is
@@ -769,9 +770,8 @@ step-scoped phases. The reference implementation is
 Do not enable `step_execution=True` until those four methods are implemented
 and validated against the request-level path.
 
-If you want the pipeline to work with the experimental batched step-wise path
-(`max_num_seqs > 1`), also see:
-[Continuous Batching for Step-Wise Diffusion](../../design/feature/diffusion_continuous_batching.md).
+The same design guide covers the experimental batched step-wise path used when
+`max_num_seqs > 1`.
 
 If you expose this in example scripts or recipes, keep it opt-in. Surface
 runtime features like `step_execution` as optional flags instead of silently
@@ -824,7 +824,7 @@ omni = Omni(model="your-model",
 
 ### CPU Offload
 
-See detailed guide: [CPU Offloading for Diffusion Models](../../user_guide/diffusion/cpu_offload_diffusion.md)
+See detailed guide: [CPU Offloading for Diffusion Models](../../user_guide/diffusion/cpu_offload.md)
 
 vLLM-Omni provides two offloading strategies to reduce GPU memory usage:
 
diff --git a/docs/contributing/model/adding_omni_model.md b/docs/contributing/model/adding_omni_model.md
index c20e94eda..4698caf9c 100644
--- a/docs/contributing/model/adding_omni_model.md
+++ b/docs/contributing/model/adding_omni_model.md
@@ -34,6 +34,7 @@ vllm_omni/model_executor/models/
 └── your_model_name/              # Model directory (e.g., qwen3_omni)
     ├── __init__.py               # Exports main model class
     ├── your_model.py             # Main unified model class
+    ├── pipeline.py               # Pipeline topology registry entry
     ├── your_model_stage1_implementation.py      # Stage 1 implementation (e.g., thinker)
     ├── your_model_stage2_implementation.py      # Stage 2 implementation (e.g., talker)
     └── your_model_stage3_implementation.py      # Stage 3 implementation (e.g., code2wav)
@@ -42,10 +43,14 @@ vllm_omni/model_executor/models/
 vllm_omni/model_executor/stage_input_processors/
 └── your_model_name.py            # Stage transition processors
 
-vllm_omni/model_executor/stage_configs/
-└── your_model_name.yaml          # Stage configuration file
+vllm_omni/deploy/
+└── your_model_name.yaml          # Deployment configuration file
 ```
 
+New in-tree models should register their `PipelineConfig` in
+`vllm_omni/config/pipeline_registry.py`; use `--deploy-config` for custom
+deployment YAMLs.
+
 ## Step-by-Step Implementation
 
 ### Step 1: Create the Model Directory
@@ -535,7 +540,7 @@ Do **not** add a no-suffix `thinker2talker` when a `sync_process_input_func` is
 
 ## Testing
 
-For comprehensive testing guidelines, please refer to the [Test File Structure and Style Guide](../ci/tests_style.md).
+For comprehensive testing guidelines, please refer to the [Test Writing Guide](../ci/test_writing_guide.md).
 
 ## Adding a Model Recipe
 
diff --git a/docs/contributing/model/adding_tts_model.md b/docs/contributing/model/adding_tts_model.md
index 3e5ae30df..6b70fdb1e 100644
--- a/docs/contributing/model/adding_tts_model.md
+++ b/docs/contributing/model/adding_tts_model.md
@@ -175,15 +175,16 @@ vllm_omni/model_executor/models/
   your_model_name/
     __init__.py
     your_model.py                    # Unified class (stage dispatch)
+    pipeline.py                      # Pipeline topology registry entry
     your_model_ar_stage.py           # Stage 0: AR stage
     your_model_decoder.py            # Stage 1: audio decoder
 
 vllm_omni/model_executor/stage_input_processors/
   your_model_name.py                 # Stage 0 -> Stage 1 transition
 
-vllm_omni/model_executor/stage_configs/
-  your_model_name.yaml               # Batch mode config
-  your_model_name_async_chunk.yaml   # Streaming mode config
+vllm_omni/deploy/
+  your_model_name.yaml               # Batch/deploy config
+  your_model_name_async_chunk.yaml   # Streaming/deploy config
 ```
 
 ### Example placement
@@ -445,6 +446,12 @@ Key configuration fields:
 | `final_output` | Whether this stage produces the final user-facing output |
 | `final_output_type` | Type of final output (`audio`, `text`, etc.) |
 
+!!! note
+    New in-tree models should define frozen topology in `models/<model>/pipeline.py`,
+    register it in `vllm_omni/config/pipeline_registry.py`, and put deployment
+    knobs in `vllm_omni/deploy/<model>.yaml`. Use `--deploy-config` to load a
+    custom deployment YAML.
+
 ### Batch mode
 
 ```yaml
@@ -629,7 +636,7 @@ Key points:
 
 ## Testing
 
-For general testing conventions, see [tests_style.md](../ci/tests_style.md).
+For general testing conventions, see [Test Writing Guide](../ci/test_writing_guide.md).
 
 Recommended test cases for a new TTS model:
 
@@ -771,8 +778,9 @@ directly from the model's own generator.
 vllm_omni/model_executor/models/your_model_name/
     __init__.py
     modeling_your_model_name.py    # unified class: load_weights + forward + streaming
+    pipeline.py                    # single-stage pipeline topology
 
-vllm_omni/model_executor/stage_configs/your_model_name.yaml
+vllm_omni/deploy/your_model_name.yaml
 ```
 
 No stage input processor is needed.
diff --git a/docs/design/ar_diffusion_pipeline_capability.md b/docs/design/ar_diffusion_pipeline_capability.md
new file mode 100644
index 000000000..c9e05c8e8
--- /dev/null
+++ b/docs/design/ar_diffusion_pipeline_capability.md
@@ -0,0 +1,165 @@
+# AR-Diffusion pipeline capability
+
+> **Status:** experimental and non-normative. This note documents the current
+> `experimental/ar_diffusion` contract. It follows the ownership and lifecycle
+> direction in [#5137](https://github.com/vllm-project/vllm-omni/issues/5137),
+> but it is not yet part of the stable module-design hierarchy.
+
+`ARDiffusionEngine` is an opt-in diffusion backend for pipelines that keep
+autoregressive attention KV across requests. The engine only selects
+`ARDiffusionModelRunner`; the runner owns paged KV pools, session lookup, LRU
+eviction, and failure cleanup.
+
+A pipeline opts in by implementing `SupportsARDiffusionPipeline`. Its immutable
+`ARDiffusionKVCacheSpec` reports worker-local KV geometry and policy:
+
+- self-attention layers, TP-local KV heads, head size, and tokens per latent frame;
+- latent frames committed by one model block, sliding window, and attention sink;
+- logical KV branches mapped to worker-local storage slots;
+- named fixed-length cross-attention KV, model-specific scratch geometry, and
+  the pipeline's requested session-capacity upper bound.
+
+The runner binds an `ARDiffusionKVState` only around one `forward()` call. The
+pipeline may use it during that context but must not retain it. The session
+survives subsequent requests with the same `session_id`. Request reset, explicit
+close, LRU eviction, and forward exceptions all release runner-owned KV and call
+the pipeline's reset/close lifecycle hook. Cross-attention KV is allocated lazily
+per session and logical KV branch, and is released on the same path. A pipeline
+publishes one named cache transactionally by yielding exactly one `(k, v)` pair
+per layer:
+
+```python
+state.populate_cross_attention("main", "text", project_text_kv_by_layer())
+```
+
+The cache becomes readable only after the iterable completes successfully.
+Logical branches remain independent even when they share a worker-local
+`local_index`; that index only maps lazily executed self-attention and scratch
+work to worker-local capacity slots. It does not define cross-attention cache
+ownership.
+
+Requests select the session with `extra_args["session_id"]`; setting `reset=True`
+replaces it before the forward, while `close_session=True` releases it after a
+successful forward. The runner also exposes `reset_session()` and
+`close_session()` for an owning serving layer.
+
+## Current execution limits
+
+The experimental runner supports request-mode execution with
+`max_num_seqs=1`. It rejects step execution and request-batch execution at load
+time, and its inherited batch/step entry points also fail explicitly. Supporting
+those paths requires a batch-aware state-binding contract rather than silently
+bypassing `bind_ar_diffusion_state()`.
+
+The current implementation retains one session per model instance. A request
+for a different `session_id` closes the resident session through the same LRU
+lifecycle used by explicit close and failure cleanup before allocating the new
+one. Self-attention and cross-attention memory are therefore sized for one
+resident session even if the pipeline declares a larger `session_capacity`.
+This prioritizes rollout throughput and prevents block-pool exhaustion before a
+count-based eviction can run. Multi-session residency can be added later with a
+memory-backed capacity calculation or allocation-pressure eviction.
+
+Scratch storage is also capability-driven. `frames_per_block` reserves space for
+an uncommitted current video block, while `max_scratch_tokens_per_branch`
+declares the maximum model-specific tokens, such as action/state registers, that
+must coexist with it. `AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH` may increase
+that derived minimum for deployment experiments but cannot reduce it.
+
+## DreamZero adapter
+
+DreamZero implements the capability directly on `DreamZeroPipeline`. Its adapter
+reads DreamZero transformer geometry, describes the positive and negative CFG
+branches, binds the state with a context manager, and translates the existing
+boolean CFG calls to the explicit `"positive"` and `"negative"` KV branch names.
+Its optional `ar_diffusion_warmup_requests()` provider owns the robot observation
+schema and the one-frame/four-frame warmup convention; none of those details are
+present in the generic runner.
+
+Code migrating from the former experimental KV state API should use the
+mechanical mapping below:
+
+```python
+# Before: state.pos, state.neg, state.get_kv_caches(is_negative, ...)
+positive = state.adapter("positive")
+negative = state.adapter("negative")
+contexts = state.get_kv_caches("negative", seq_len=frame_tokens, commit_current=True)
+```
+
+Direct experimental `ARDiffusionKVCache` construction also migrates
+mechanically: replace `local_branches` with explicit `kv_branches`,
+`num_frame_per_block` with `frames_per_block`, and the fixed text/image length
+arguments with a named `cross_attention_lengths` mapping plus
+`session_capacity`. Normal engine users do not construct this object directly.
+
+Cross-attention writers migrate from incremental publication:
+
+```python
+# Before
+for layer_index, (key, value) in enumerate(project_text_kv_by_layer()):
+    state.write_cross_attention_kv("text", layer_index, branch, key, value)
+state.mark_cross_attention_populated(branch, "text")
+
+# After
+state.populate_cross_attention(branch, "text", project_text_kv_by_layer())
+```
+
+The iterable is consumed once and must yield exactly `num_layers` pairs. Failed
+or incomplete projection leaves the previous complete cache unchanged, or
+leaves the cache absent on its first population.
+
+## Single-KV-branch pipeline sketch
+
+A future single-branch causal DMD pipeline can opt in without changes to the
+runner or KV core:
+
+```python
+class WorldPipeline:
+    def ar_diffusion_kv_cache_spec(self):
+        return ARDiffusionKVCacheSpec(
+            num_layers=self.transformer.num_layers,
+            num_kv_heads=self.transformer.tp_local_kv_heads,
+            head_size=self.transformer.head_size,
+            tokens_per_frame=self.transformer.tokens_per_latent_frame,
+            frames_per_block=3,
+            window_frames=self.transformer.sliding_window_frames,
+            sink_frames=self.transformer.sink_frames,
+            kv_branches=(ARDiffusionKVBranchSpec("main", 0),),
+            cross_attention=(ARDiffusionCrossAttentionKVSpec("text", self.text_length),),
+            max_scratch_tokens_per_branch=self.transformer.max_register_tokens,
+            session_capacity=1,
+        )
+
+    @contextmanager
+    def bind_ar_diffusion_state(self, session_id, state):
+        self.current_ar_state = state
+        try:
+            yield
+        finally:
+            self.current_ar_state = None
+
+    def reset_ar_diffusion_session(self, session_id):
+        self.model_states.pop(session_id, None)
+
+    def close_ar_diffusion_session(self, session_id):
+        self.model_states.pop(session_id, None)
+```
+
+The model writes/reads named cross-attention KV through the bound state and uses
+the `"main"` KV branch for paged self-attention. Pipelines without a warmup
+provider are loaded normally and skip AR rollout warmup.
+
+## Relationship to the multi-stage KV manager RFC
+
+[#5244](https://github.com/vllm-project/vllm-omni/issues/5244) describes a
+future multi-stage KV transfer manager, connector integration, and cache-aware
+scheduling. This capability has a narrower scope: it owns model-local paged KV
+and session lifecycle inside one AR-Diffusion runner. It does not define
+cross-stage transfer, connector behavior, or scheduler-visible cache affinity.
+
+When the experimental runtime migrates toward #5244, the implementation should
+reconcile its current full `KVCacheManager` use with the RFC's proposed
+`BlockPool`-oriented DiT manager. The pipeline capability should remain the
+model-facing geometry and state-binding boundary where possible, while the
+experimental `ARDiffusionKVCache` class itself should not be treated as a stable
+public API.
diff --git a/docs/design/feature/async_diffusion_output.md b/docs/design/feature/async_diffusion_output.md
new file mode 100644
index 000000000..a81ed6811
--- /dev/null
+++ b/docs/design/feature/async_diffusion_output.md
@@ -0,0 +1,174 @@
+# Async Diffusion Output
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Performance](#performance)
+3. [Architecture](#architecture)
+4. [Model Coverage](#model-coverage)
+5. [Configuration](#configuration)
+6. [Related Files](#related-files)
+
+## Overview
+
+The async diffusion output feature moves the D2H (Device→Host) copy and SHM packing from the Worker main thread to a background daemon thread, so the GPU default stream can immediately start the next request's forward pass. This eliminates the GPU bubble caused by synchronous D2H/packing.
+
+**Core benefit**: the previous request's output D2H/packing overlaps with the next request's forward pass.
+
+**Automatically enabled** when `step_execution=False` (default, request-mode). No extra configuration needed. When `step_execution=True` (step-mode), the original synchronous path is used — pump thread and Worker background thread are not started.
+
+## Performance
+
+### HunyuanImage-3.0 (TP4)
+
+| Resolution | Async Off (QPS) | Async On (QPS) | Change |
+|---|---|---|---|
+| 1024×1024 | 0.4773 | 0.4802 | +0.60% |
+| 768×768 | 0.8370 | 0.8533 | +1.95% |
+
+**Analysis**: smaller resolution → larger QPS gain. D2H/packing is relatively fixed overhead; forward is variable (scales with resolution). Smaller images → shorter forward → D2H/packing occupies a larger fraction of total time → more benefit from overlapping it.
+
+## Architecture
+
+### Execution Timeline
+
+```
+Before (synchronous D2H):
+[forward req1] [D2H+SHM pack req1] [forward req2] [D2H+SHM pack req2]
+                                 ^^^^^^^^^^^^^^^^ GPU bubble
+
+After (async D2H):
+[forward req1] [forward req2]
+[D2H+SHM pack req1 (side stream)] [D2H+SHM pack req2 (side stream)]
+                                 ^^^^^^^^^^^^^^^^ bubble eliminated
+```
+
+### Data Flow
+
+```
+                    ┌─────────────────────────────────────────────────────┐
+                    │                 Worker Process                      │
+                    │                                                    │
+  execute_model ──> │ WorkerBusyLoop ──> forward() ──> DiffusionOutput   │
+                    │       │                              │ (GPU tensor)│
+                    │       │                    ┌─────────┴──────────┐  │
+                    │       │                    │  async output path │  │
+                    │       │                    │                    │  │
+                    │       │              compute_done ──> result_mq │  │
+                    │       │                    │                    │  │
+                    │       │                    ▼                    │  │
+                    │       │            AsyncOutputThread            │  │
+                    │       │         (side CUDA stream)             │  │
+                    │       │         wait_event(gpu_event)          │  │
+                    │       │         pack_diffusion_output_shm()    │  │
+                    │       │         D2H + SHM write                │  │
+                    │       │                    │                    │  │
+                    │       │              output_ready ──> result_mq │  │
+                    │       │                    │                    │  │
+                    │       ▼                    ▼                    │  │
+                    │  (dequeue next request)                        │  │
+                    └─────────────────────────────────────────────────────┘
+                                         │
+                                         ▼
+                    ┌─────────────────────────────────────────────────────┐
+                    │              Executor (main process)               │
+                    │                                                    │
+                    │  ResultPumpThread (sole reader of result_mq)       │
+                    │       │                                            │
+                    │       ├── AsyncDiffusionOutput(COMPUTE_DONE)       │
+                    │       │   → resolve _rpc_futures[rpc_id]           │
+                    │       │   → RunnerOutput(async_output_id=...)      │
+                    │       │                                            │
+                    │       ├── AsyncDiffusionOutput(OUTPUT_READY)       │
+                    │       │   → resolve _output_futures[async_output_id]│
+                    │       │   → or batch split via _batch_split_map   │
+                    │       │                                            │
+                    │       └── Non-async message                        │
+                    │           → _sync_result_buffer (for other RPCs)   │
+                    │                                                    │
+                    │  wait_output_ready(async_output_id) → Future       │
+                    └─────────────────────────────────────────────────────┘
+```
+
+### Key Components
+
+1. **AsyncDiffusionOutput** (`data.py`): Protocol envelope for `result_mq`. `kind` field routes messages:
+   - `COMPUTE_DONE` — forward finished, GPU can start next request
+   - `OUTPUT_READY` — D2H/SHM packing finished, final output available
+   - `RPC_RESULT` — ordinary RPC return (including error propagation)
+
+2. **Worker AsyncOutputThread** (`diffusion_worker.py`): Background daemon thread that:
+   - Waits for `gpu_event` (cross-stream sync ensuring forward wrote the tensor)
+   - Runs `pack_diffusion_output_shm()` on a side CUDA stream
+   - Enqueues `OUTPUT_READY` to `result_mq` when packing completes
+
+3. **ResultPumpThread** (`multiproc_executor.py`): Sole reader of `result_mq` in request-mode. Dispatches messages:
+   - `COMPUTE_DONE` / `RPC_RESULT` → resolves `_rpc_futures[rpc_id]`
+   - `OUTPUT_READY` → resolves `_output_futures[async_output_id]` (with batch split via `_batch_split_map`)
+   - Non-async messages → `_sync_result_buffer` for other RPCs
+
+4. **collective_rpc() two-path dispatch** (`multiproc_executor.py`):
+   - **Path 1**: `execute_model` / `execute_model_batch` → generates `rpc_id`, registers Future, waits for pump to deliver `compute_done`
+   - **Path 2**: All other RPCs → `_sync_result_buffer` (pump-fed) or `_result_mq` (step-mode, no pump)
+
+5. **record_device_event** (`platforms/`): Cross-platform GPU event recording for side-stream synchronization. Implemented for CUDA, NPU, ROCm, XPU, MUSA; base class returns `None` (safe no-op).
+
+6. **IPC side-stream D2H** (`ipc.py`): `pack_diffusion_output_shm()` and helpers accept `d2h_stream` parameter; use `pin_memory` + `copy_(non_blocking=True)` on the side stream instead of synchronous `.cpu()`.
+
+### Batch Split
+
+When `execute_model_batch` returns a `COMPUTE_DONE` with a single `async_output_id` for the entire batch, the executor splits it into per-request `async_output_id`s (format `{batch_id}/{request_id}`) via `_batch_split_map`. When `OUTPUT_READY` arrives, the pump extracts per-request results from the batch output and resolves each request's output future independently.
+
+## Model Coverage
+
+### Currently Supported (request-mode, `step_execution=False`)
+
+All models running in request-mode (`step_execution=False`, the default) automatically use async output.
+
+**Verified models**:
+
+| Model | Type | `supports_request_batch` |
+|---|---|---|
+| **HunyuanImage-3.0** | Image | `False` |
+| **Qwen-Image** | Image | `True` |
+
+Other models with `step_execution=False` are also supported but not yet verified.
+
+### Not Yet Supported (step-mode, `step_execution=True`)
+
+When `step_execution=True` (or `streaming_output=True`, which auto-enables step-mode), models use `execute_stepwise` instead of `execute_model`, which is not in the async Path 1 whitelist. Async output is not applicable.
+
+**Verified**: Helios (`step_execution=True`, does not benefit from this feature).
+
+Other models with `step_execution=True` are also not applicable.
+
+Adapting step-mode requires additional design because:
+
+- Each step's `RunnerOutput` must be available synchronously for the scheduler to advance
+- Intermediate latent tensors may not need D2H (only the final step needs D2H + postprocess)
+- Steps are serial (step N+1 depends on step N output), so the overlap benefit is limited to "final step's D2H overlaps with the next request's forward"
+
+**Planned approach**: first cover only the final step's async D2H, keep intermediate steps synchronous. This matches the request-mode benefit pattern.
+
+## Configuration
+
+No configuration needed. Async output is automatically enabled when `step_execution=False` (default).
+
+| `step_execution` | Mode | Async Output | Pump Thread | Worker BG Thread |
+|---|---|---|---|---|
+| `False` (default) | request-mode | ✅ enabled | ✅ started | ✅ started |
+| `True` | step-mode | ❌ disabled | ❌ not started | ❌ not started |
+
+## Related Files
+
+- `vllm_omni/diffusion/data.py`: `AsyncDiffusionOutput`, `AsyncOutputKind`, `DiffusionOutput.async_output_id`
+- `vllm_omni/diffusion/worker/diffusion_worker.py`: `WorkerProc._return_result()`, `_async_output_loop()`, `_generate_async_output_id()`
+- `vllm_omni/diffusion/executor/multiproc_executor.py`: `ResultPumpThread`, `collective_rpc()` two-path dispatch, `wait_output_ready()`, `_batch_split_map`
+- `vllm_omni/diffusion/diffusion_engine.py`: `step()` / `step_streaming()` / `add_req_and_wait_for_response()` async output waiting
+- `vllm_omni/diffusion/sched/request_scheduler.py`: `update_from_output()` — `async_output_id` → `FINISHED_COMPLETED`
+- `vllm_omni/diffusion/ipc.py`: `pack_diffusion_output_shm()` side-stream D2H path
+- `vllm_omni/platforms/interface.py`: `OmniPlatform.record_device_event()` base class
+- `vllm_omni/platforms/cuda/platform.py`: `CudaOmniPlatform.record_device_event()`
+- `vllm_omni/platforms/npu/platform.py`: `NPUOmniPlatform.record_device_event()`
+- `vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py`: `get_hunyuan_image3_post_process_func()`, postprocess removal
+- `vllm_omni/diffusion/registry.py`: `_DIFFUSION_POST_PROCESS_FUNCS` postprocess registry
diff --git a/docs/design/feature/cache_dit.md b/docs/design/feature/cache_dit.md
index 237a95877..38b597ca3 100644
--- a/docs/design/feature/cache_dit.md
+++ b/docs/design/feature/cache_dit.md
@@ -32,10 +32,13 @@ The library supports three main caching strategies:
 
 vLLM-omni integrates cache-dit through the `CacheDiTBackend` class, which provides a unified interface for managing cache-dit acceleration on diffusion models.
 
+Code outside `vllm_omni/diffusion/cache` must import Cache-DiT symbols from the
+package-level API: `vllm_omni.diffusion.cache.cachedit`.
+
 | Method/Class | Purpose | Behavior |
 |--------------|---------|----------|
-| [`CacheDiTBackend`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/#vllm_omni.diffusion.cache.CacheBackend) | Unified backend interface | Automatically handles enabler selection and cache refresh |
-| [`enable_cache_for_dit()`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/cache_dit_backend/#vllm_omni.diffusion.cache.cache_dit_backend.enable_cache_for_dit) | Apply caching to transformer | Configures DBCache on transformer blocks |
+| `CacheDiTBackend` | Unified backend interface | Automatically handles enabler selection and cache refresh |
+| `enable_cache_for_dit()` | Apply caching to transformer | Configures DBCache on transformer blocks |
 
 **Key APIs from Cache-DiT:**
 
@@ -47,7 +50,7 @@ vLLM-omni integrates cache-dit through the `CacheDiTBackend` class, which provid
 | `ForwardPattern` | Defines block forward signature patterns: `Pattern_0`, `Pattern_1`, `Pattern_2` |
 | `ParamsModifier` | Per-transformer or per-block-list cache configuration customization |
 | `DBCacheConfig` | Configuration for DBCache parameters (warmup steps, cached steps, thresholds) |
-| `refresh_context()` | Update cache context | Called when `num_inference_steps` changes |
+| `refresh_context()` | Update cache context | Called at every generation boundary |
 
 ---
 
@@ -179,7 +182,8 @@ cache_dit.enable_cache(
 
 ### Registering Custom Implementations
 
-After writing your custom enabler, register it in `CUSTOM_DIT_ENABLERS` in `vllm_omni/diffusion/cache/cache_dit_backend.py`:
+After writing your custom enabler, register it in `CUSTOM_DIT_ENABLERS` in
+`vllm_omni/diffusion/cache/cachedit/model_specific.py`:
 
 ```python
 CUSTOM_DIT_ENABLERS = {
@@ -266,10 +270,10 @@ Complete examples in the codebase:
 
 | Model | Path | Pattern | Notes |
 |-------|------|---------|-------|
-| **Standard DiT** | [`cache_dit_backend.py::enable_cache_for_dit`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/cache_dit_backend/#vllm_omni.diffusion.cache.cache_dit_backend.enable_cache_for_dit) | Default enabler | Single transformer, automatic |
-| **Wan2.2** | [`cache_dit_backend.py::enable_cache_for_wan22`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/cache_dit_backend/#vllm_omni.diffusion.cache.cache_dit_backend.enable_cache_for_wan22) | Single or dual-transformer | Auto-detects mode based on transformer_2 presence |
-| **LongCat** | [`cache_dit_backend.py::enable_cache_for_longcat_image`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/cache_dit_backend/#vllm_omni.diffusion.cache.cache_dit_backend.enable_cache_for_longcat_image) | Multi-block-list | Two block lists in one transformer |
-| **BAGEL** | [`cache_dit_backend.py::enable_cache_for_bagel`](https://docs.vllm.ai/projects/vllm-omni/en/latest/api/vllm_omni/diffusion/cache/cache_dit_backend/#vllm_omni.diffusion.cache.cache_dit_backend.enable_cache_for_bagel) | Omni model | Complex architecture |
+| **Standard DiT** | `cachedit.backend::enable_cache_for_dit` | Default enabler | Single transformer, automatic |
+| **Wan2.2** | `cachedit.model_specific::enable_cache_for_wan22` | Single or dual-transformer | Auto-detects mode based on transformer_2 presence |
+| **LongCat** | `cachedit.config::CacheDiTAdapterConfig` | Declarative block adapter | Two block lists in one transformer |
+| **BAGEL** | `cachedit.model_specific::BagelCachedAdapter` | Custom cached adapter | Complex architecture |
 
 ---
 
diff --git a/docs/design/feature/diffusion_continuous_batching.md b/docs/design/feature/diffusion_continuous_batching.md
index f90969369..2ec89b9d1 100644
--- a/docs/design/feature/diffusion_continuous_batching.md
+++ b/docs/design/feature/diffusion_continuous_batching.md
@@ -1,163 +1,232 @@
-# Continuous Batching for Step-Wise Diffusion
+# Diffusion Continuous Batching
 
-!!! warning "Experimental Feature"
-    This feature is experimental. It currently applies only to native
-    diffusion pipelines running with `step_execution=True`.
-
-This document describes the batching extension built on top of
-[Diffusion Step Execution](diffusion_step_execution.md). The base
-step-execution contract is unchanged. The batching work is mainly in the
-scheduler and runner layers.
-
-## Why It Helps
-
-Step-wise execution breaks a long denoise loop into scheduler-visible units.
-That gives the runtime a place to admit other compatible requests between
-steps instead of waiting for an entire request to finish.
-
-This matters most in low-MFU or bursty serving scenarios:
-
-- one request's denoise step may not fully saturate the GPU
-- several compatible requests can share the same denoise forward pass
-- throughput and device utilization can improve without changing request-local
-  scheduler state
-
-This is **not** a guaranteed single-request latency win. The main benefit is
-usually higher utilization and better throughput when the workload contains
-multiple in-flight compatible requests.
+This document describes the unified diffusion execution architecture, including
+request execution, request-level batching, step execution, continuous batching,
+and output delivery. For user-facing configuration and CLI examples, see
+[Diffusion Execution Modes](../../user_guide/diffusion/execution_modes.md).
 
 ## Overview
 
-With continuous batching enabled:
+`DiffusionEngine` selects an execution mode from `step_execution` and uses
+`max_num_seqs` as that mode's scheduler capacity:
 
-- the scheduler may keep multiple compatible requests active at the same time
-- the runner packs request-local step state into one `InputBatch`
-- `denoise_step()` runs on that batch
-- `step_scheduler()` and `post_decode()` still run per request
+| Configuration | Engine mode | Scheduler | Execution |
+|---|---|---|---|
+| `step_execution=False`, `max_num_seqs=1` | `REQUEST_BATCH` | `RequestScheduler` | One complete request-level `forward()` |
+| `step_execution=False`, `max_num_seqs>1` | `REQUEST_BATCH` | `RequestScheduler` | One fused `forward()` over compatible requests |
+| `step_execution=True`, `max_num_seqs=1` | `STEP_BATCH` | `StepScheduler` | One request advanced one denoise step per scheduler tick |
+| `step_execution=True`, `max_num_seqs>1` | `STEP_BATCH` | `StepScheduler` | Compatible requests advanced together in step waves |
 
-The current implementation is conservative:
+Serial request execution is handled inside `REQUEST_BATCH`; it is not a
+separate engine mode. Similarly, continuous batching is the multi-request
+configuration of `STEP_BATCH`, not an independent execution mode.
 
-- only compatible requests are batched together
-- per-request progress and completion remain independent
+The engine performs the following initialization:
 
-Here, "continuous batching" means the step-wise path enabled by
-`step_execution=True`. Request-mode `DiffusionRequestBatch` is static
-request-level batching for one full pipeline `forward()` call; it does not
-admit or remove requests between denoise steps.
+1. Resolve model-specific pre- and post-processing hooks.
+2. Select `REQUEST_BATCH` or `STEP_BATCH`.
+3. Construct the configured `DiffusionExecutor`.
+4. Construct `RequestScheduler` or `StepScheduler`, unless a scheduler was
+   explicitly injected.
+5. Bind `execute_batch` or `execute_step`.
 
-## Enablement
+`DiffusionEngine.make_engine()` owns startup warmup after engine construction.
+This keeps construction, backend selection, and warmup failure cleanup in one
+lifecycle.
 
-Use `--step-execution` as the feature gate, then increase `--max-num-seqs`
-above `1` if you want batching:
+## Unified Output Stream
 
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --step-execution \
-  --max-num-seqs 8
+All asynchronous diffusion requests use the same per-request output stream,
+regardless of whether the caller exposes streaming results to the user.
+
+```python
+async for output in engine.step_streaming(request):
+    ...
 ```
 
-`--max-num-seqs 1` keeps the step-wise path without enabling batching.
+When a request is admitted, the engine creates an
+`asyncio.Queue[DiffusionOutput]` keyed by its request ID. The busy loop sends
+both intermediate chunks and final results through that queue:
 
-For a reproducible replay flow using the bundled serving benchmark, see the
-Qwen-Image replay commands in
-[`benchmarks/diffusion/README.md`](gh-file:benchmarks/diffusion/README.md)
-and
-[`benchmarks/diffusion/performance_dashboard/qwen_image_serving_performance.md`](gh-file:benchmarks/diffusion/performance_dashboard/qwen_image_serving_performance.md).
+```text
+request
+  -> scheduler.add_request()
+  -> scheduler.schedule()
+  -> execute_batch() or execute_step()
+  -> scheduler.update_from_output()
+  -> per-request output queue
+  -> step_streaming()
+```
 
-## Scheduler
+Streaming callers forward every yielded output. Non-streaming callers consume
+the same generator to completion and return only its final output. This avoids
+maintaining separate future-based and queue-based result paths.
 
-The scheduler derives its batch capacity from `max_num_seqs` through
-`max_num_running_reqs`.
+`DiffusionEngine.step()` and
+`async_add_req_and_wait_for_response()` remain deprecated compatibility
+wrappers. New integrations should consume `step_streaming()` or
+`async_add_req_and_stream_response()`.
 
-Batch admission is gated by
-[`SamplingParamsKey`](gh-file:vllm_omni/diffusion/sched/interface.py),
-which is built from shape-sensitive and CFG-sensitive sampling fields. This is
-the core correctness rule for batching: requests are only co-batched when they
-share the same denoise tensor contract.
+### Completion and Cancellation
 
-There are three important details:
+Output delivery and scheduler lifecycle are related but separate:
 
-- `num_inference_steps` is not part of the key, so requests with different
-  total step counts can still share a batch
-- requests also do not need to be at the same current denoise progress; active
-  requests can continue batching even when their current step indices diverge
-- admission is still FIFO, so an incompatible request at the head of the
-  waiting queue blocks later compatible requests
+- A terminal scheduler result always finalizes request state.
+- A disconnected or cancelled consumer removes only its delivery queue.
+- The scheduler may still finish and clean up the request after its queue has
+  been removed.
+- Engine shutdown sends an error output to all remaining streams.
 
-Today that compatibility rule is still shape-sensitive. `height`, `width`,
-`num_frames`, and CFG-related fields remain part of the key, so different
-resolutions or incompatible guidance settings do **not** co-batch yet. The
-key also covers LoRA identity (`lora_int_id`, `lora_scale`), so requests
-targeting different adapters or scales run in separate batches and the
-worker can activate exactly one adapter per step.
+This separation prevents cancelled consumers from leaving active request IDs in
+the scheduler.
 
-The scheduler batching unit is one logical `OmniDiffusionRequest`. In the
-step-wise path, runtime tensor batching is represented as `StepInputBatch`. For
-request-mode prompt semantics, see
-[Request-Level Batching](../../user_guide/diffusion/request_batching.md).
+## Request-Batch Execution
 
-## Runner
+Request-batch execution runs the complete diffusion pipeline for each scheduler
+wave. Each `OmniDiffusionRequest` remains an independent logical request with
+its own prompt, sampling parameters, seed, request ID, output, error, and abort
+state.
 
-The runner keeps persistent per-request execution state in
-[`DiffusionRequestState`](gh-file:vllm_omni/diffusion/worker/utils.py),
-while the scheduler owns a separate lightweight request state for queueing and
-lifecycle tracking.
+With `max_num_seqs=1`, `execute_batch()` handles the serial request path. With a
+larger value, a pipeline can opt into fused execution by declaring:
 
-For each step, the runner builds an
-[`InputBatch`](gh-file:vllm_omni/diffusion/worker/input_batch.py) from the
-active request states:
+```python
+supports_request_batch = True
+```
 
-- prompt embeddings and masks are normalized and padded
-- dynamic tensors such as `latents` and `timesteps` are gathered each step
-- buffers are reused when batch composition stays the same
+Its `forward()` method must accept `DiffusionRequestBatch` and return one
+`DiffusionOutput` per request. The runner validates the result count and maps
+outputs back to their original request IDs with `BatchRunnerOutput`.
 
-The step-wise batched path is:
+Current in-tree request-batch implementations include the Flux, LTX-2, SD3, and
+Qwen-Image pipelines. Treat the pipeline capability flag in the source as
+authoritative because support continues to expand.
 
-1. Run `prepare_encode()` for newly admitted requests.
+### Request-Batch Data Flow
+
+- `DiffusionSchedulerOutput` carries scheduled request IDs and payloads.
+- `DiffusionRequestBatch` provides the pipeline-facing static batch.
+- `BatchRunnerOutput` carries per-request results back to the engine.
+
+Request-local setup, such as seed handling and output/error mapping, remains
+per request. Cache refresh, homogeneous LoRA activation, and
+`pipeline.forward(req_batch)` can be shared by the batch.
+
+### Compatibility and Admission
+
+`RequestBatchSamplingParamsKey` contains fields that affect the tensor contract,
+including shape, guidance, output count, and LoRA identity. Only compatible
+requests can share a fused forward call.
+
+Admission is FIFO and conservative. An incompatible request at the front of the
+waiting queue can prevent later compatible requests from joining the current
+wave.
+
+`request_batch_max_wait_ms` optionally delays the first schedule operation of a
+new wave so bursty arrivals can accumulate. It applies only when:
+
+- the pipeline supports request batching;
+- step execution is disabled;
+- no requests are currently running; and
+- the configured wait is greater than zero.
+
+The wait ends when the queue reaches capacity, stabilizes briefly, reaches its
+deadline, or the engine stops.
+
+## Step-Batch Execution
+
+Step execution exposes denoising progress to the scheduler. A supporting
+pipeline implements four stateful operations:
+
+| Operation | Responsibility |
+|---|---|
+| `prepare_encode(state)` | Validate input, encode prompts, initialize latents and timesteps, and create request-local scheduler state |
+| `denoise_step(input_batch, *, states=...)` | Run one denoise forward for the scheduler-provided request states |
+| `step_scheduler(state, noise_pred)` | Update latents and advance request progress |
+| `post_decode(state)` | Decode and postprocess a completed request or output boundary |
+
+Persistent request state lives in `StepRequestState`. Pipeline-specific fields
+that do not belong in the shared contract should be stored in `state.extra`.
+Queueing and lifecycle metadata remain in the scheduler's request state.
+
+Current native pipelines that explicitly enable step execution include
+Qwen-Image, HunyuanImage3, and Helios. Step execution alone does not imply
+continuous-batching support: Qwen-Image accepts batched step states.
+HunyuanImage3 accepts batched step states only when its resolved self-attention
+backend is `TORCH_SDPA`; otherwise it rejects groups larger than one request.
+Configure `DIFFUSION_ATTENTION_BACKEND=TORCH_SDPA` or
+`diffusion_attention_config.default.backend=TORCH_SDPA` when
+`max_num_seqs>1`. See the
+[HunyuanImage-3.0 recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/Tencent/HunyuanImage-3.0-Instruct.md)
+for its validated configuration. Helios supports only a single active step
+request and must use `max_num_seqs=1`.
+
+### Continuous Batching
+
+When `max_num_seqs>1`, `StepScheduler` can keep multiple compatible requests
+active. The runner gathers their state into `InputBatch`, performs one batched
+denoise forward, then applies scheduler updates per request:
+
+1. Receive transferred KV payloads, then run `prepare_encode()` for newly
+   admitted requests.
 2. Build or refresh `InputBatch`.
-3. Run one batched `denoise_step(input_batch)`.
-4. Slice the batched `noise_pred` back per request.
-5. Run per-request `step_scheduler()`.
-6. Run `post_decode()` only for requests that finished denoising.
-7. Scatter updated latents back into persistent request state with
-   [`scatter_latents()`](gh-file:vllm_omni/diffusion/worker/input_batch.py).
+3. Run one batched `denoise_step(input_batch, states=states)`.
+4. Slice noise predictions back to each request.
+5. Run each request's `step_scheduler()`.
+6. Run `post_decode()` at a chunk boundary or request completion.
+7. Scatter updated latents back into persistent request state.
 
-This keeps the shared work limited to the denoise forward pass while preserving
-request-local scheduler state and outputs.
+`StepBatchSamplingParamsKey` protects the batched tensor contract. Requests can
+have different total step counts and current step indices, but shape-sensitive,
+CFG-sensitive, and LoRA fields must be compatible. FIFO head-of-line blocking
+also applies here.
 
-## Engine
+Chunk-capable pipelines may emit intermediate results. Final-only step
+pipelines emit when the request finishes even if `streaming_output=True`.
 
-[`DiffusionEngine`](gh-file:vllm_omni/diffusion/diffusion_engine.py) provides
-the background loop and async add-request path needed for multiple requests to
-accumulate in the scheduler.
+## Model Author Guidelines
 
-When `step_execution=True`, the engine routes work through the step-wise
-executor path. The continuous batching behavior is defined by scheduler-side
-compatibility gating and runner-side `StepInputBatch` packing.
+When converting a request-level pipeline:
 
-## Current Limitations
+- Reuse the same helpers as `forward()` to avoid behavior drift.
+- Copy request-scoped scheduler state into `state.scheduler`.
+- Advance `state.step_index` only in `step_scheduler()`.
+- Keep model forward work in `denoise_step()`.
+- Keep latent mutation in `step_scheduler()`.
+- Keep final decoding equivalent to the tail of `forward()`.
+- Store masks, condition latents, and other request-local tensors in the
+  request state rather than on the shared pipeline.
 
-- Experimental feature; use `max_num_seqs=1` for the older conservative path.
-- Only native pipelines that already support `step_execution=True`.
-- Only homogeneous batches keyed by `SamplingParamsKey` are supported.
-- `cache_backend`, KV transfer, and other request-mode extras are not wired
-  into the batched step-wise path yet.
-- Future work can relax the current same-shape restriction with richer
-  heterogeneous batching policies such as bucketing or padded execution for
-  different resolutions.
+Before setting `supports_step_execution = True`, validate output parity for the
+same seed and sampling parameters, scheduler isolation across concurrent
+requests, abort cleanup, progress reporting, and all supported CFG paths.
 
-## Related Files
+Before setting `supports_request_batch = True`, validate the batch input
+contract, one-output-per-request result shape, request identity and error
+mapping, seeded concurrency, LoRA compatibility, and tensor IPC.
 
-- Scheduler base:
-  [`vllm_omni/diffusion/sched/base_scheduler.py`](gh-file:vllm_omni/diffusion/sched/base_scheduler.py)
-- Scheduler interface:
-  [`vllm_omni/diffusion/sched/interface.py`](gh-file:vllm_omni/diffusion/sched/interface.py)
-- Step scheduler:
-  [`vllm_omni/diffusion/sched/step_scheduler.py`](gh-file:vllm_omni/diffusion/sched/step_scheduler.py)
-- Runner:
-  [`vllm_omni/diffusion/worker/diffusion_model_runner.py`](gh-file:vllm_omni/diffusion/worker/diffusion_model_runner.py)
-- Input batch:
-  [`vllm_omni/diffusion/worker/input_batch.py`](gh-file:vllm_omni/diffusion/worker/input_batch.py)
-- Tests:
-  [`tests/diffusion/test_diffusion_scheduler.py`](gh-file:tests/diffusion/test_diffusion_scheduler.py)
+## Limitations
+
+- Request batching requires an explicit pipeline capability when
+  `max_num_seqs>1`.
+- Step execution requires the four-method stateful pipeline contract.
+- Both batching paths currently require homogeneous compatibility keys.
+- FIFO scheduling can reduce batching opportunities.
+- `request_batch_max_wait_ms` trades first-request latency for burst
+  coalescing.
+- All diffusion cache backends are currently unsupported in step mode.
+- KV transfer is supported for newly admitted step requests; some other
+  request-mode extras remain unsupported.
+- Step continuous batching remains experimental; use `max_num_seqs=1` for the
+  conservative step path.
+
+## Related Implementation
+
+- Engine: [`vllm_omni/diffusion/diffusion_engine.py`](gh-file:vllm_omni/diffusion/diffusion_engine.py)
+- Model contract: [`vllm_omni/diffusion/models/interface.py`](gh-file:vllm_omni/diffusion/models/interface.py)
+- Scheduler interface: [`vllm_omni/diffusion/sched/interface.py`](gh-file:vllm_omni/diffusion/sched/interface.py)
+- Request scheduler: [`vllm_omni/diffusion/sched/request_scheduler.py`](gh-file:vllm_omni/diffusion/sched/request_scheduler.py)
+- Step scheduler: [`vllm_omni/diffusion/sched/step_scheduler.py`](gh-file:vllm_omni/diffusion/sched/step_scheduler.py)
+- Runner: [`vllm_omni/diffusion/worker/diffusion_model_runner.py`](gh-file:vllm_omni/diffusion/worker/diffusion_model_runner.py)
+- Request batch: [`vllm_omni/diffusion/worker/request_batch.py`](gh-file:vllm_omni/diffusion/worker/request_batch.py)
+- Step input batch: [`vllm_omni/diffusion/worker/input_batch.py`](gh-file:vllm_omni/diffusion/worker/input_batch.py)
diff --git a/docs/design/feature/diffusion_request_level_batching.md b/docs/design/feature/diffusion_request_level_batching.md
deleted file mode 100644
index 57287ada4..000000000
--- a/docs/design/feature/diffusion_request_level_batching.md
+++ /dev/null
@@ -1,175 +0,0 @@
-# Request-Level Batching for Diffusion
-
-This document describes the request-mode batching path for diffusion pipelines.
-For end-user enablement and tuning, see
-[Request-Level Batching](../../user_guide/diffusion/request_batching.md).
-
-This is separate from
-[Continuous Batching for Step-Wise Diffusion](diffusion_continuous_batching.md).
-Request-level batching runs one full pipeline `forward()` over a static batch of
-compatible requests. Step-wise continuous batching admits work between denoise
-steps when `step_execution=True`.
-
-## Why It Helps
-
-The request-level design avoids coupling several logical requests to one request
-object. This keeps request identity, abort/error handling, and per-request
-metadata unambiguous while still allowing one fused pipeline forward pass for
-bursty or concurrent traffic.
-
-## Overview
-
-With request-level batching enabled:
-
-- each `OmniDiffusionRequest` contains one `prompt` and one `request_id`
-- the scheduler groups compatible waiting requests into one scheduler wave
-- `DiffusionRequestBatch` wraps the scheduled requests for pipeline `forward()`
-- batch-capable pipelines return `list[DiffusionOutput]`, one output per
-  request
-- `BatchRunnerOutput` maps each result back to its original `request_id`
-
-Pipelines opt in with `supports_request_batch = True` and a `forward()` method
-that accepts `DiffusionRequestBatch` and returns `list[DiffusionOutput]`.
-Pipelines that do not opt in keep the existing per-request execution path.
-
-## Enablement
-
-Request-level batching is the request-mode path, so `step_execution` must remain
-disabled. Increase `max_num_seqs` above `1` to let the scheduler keep multiple
-compatible requests active:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --max-num-seqs 4
-```
-
-For bursty online ingress, `request_batch_max_wait_ms` can add a bounded
-admission wait before the first `schedule()` of a scheduler wave:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --max-num-seqs 4 \
-  --request-batch-max-wait-ms 20
-```
-
-`request_batch_max_wait_ms=0` disables this wait and is the default.
-
-## Request Contract
-
-`OmniDiffusionRequest` represents one logical request. It owns one prompt,
-sampling parameters, request id, and request-local metadata. Runtime batches are
-formed by the scheduler and represented separately from the request payload.
-
-Runtime batching is represented by:
-
-- [`DiffusionSchedulerOutput`](gh-file:vllm_omni/diffusion/sched/interface.py)
-  for scheduled request ids and request payloads
-- [`DiffusionRequestBatch`](gh-file:vllm_omni/diffusion/worker/request_batch.py)
-  for the pipeline-facing request batch
-- [`BatchRunnerOutput`](gh-file:vllm_omni/diffusion/worker/utils.py) for
-  per-request results
-
-`DiffusionRequestBatch` intentionally exposes compatibility properties such as
-`prompts`, `sampling_params`, `request_id`, and `kv_sender_info` so migrated
-pipelines can stay close to upstream code while using a batch-aware contract.
-
-## Scheduler
-
-The scheduler derives its capacity from `max_num_seqs` through
-`max_num_running_reqs`. It exposes waiting/running queue counters so the engine
-can decide whether admission wait is useful before scheduling a new wave.
-
-Batch compatibility is controlled by
-[`SamplingParamsKey`](gh-file:vllm_omni/diffusion/sched/interface.py). The key
-contains shape-sensitive and guidance-sensitive fields, including output count
-and LoRA identity. Requests with incompatible shapes, CFG settings, output
-counts, LoRA adapters, or LoRA scales are kept in separate batches.
-
-Admission is conservative:
-
-- the scheduler only batches compatible requests
-- FIFO ordering is preserved
-- an incompatible request at the head of the waiting queue blocks later
-  compatible requests
-
-## Engine
-
-[`DiffusionEngine`](gh-file:vllm_omni/diffusion/diffusion_engine.py) resolves
-request-batch capability during initialization from the configured pipeline
-class, including custom pipeline classes.
-
-The capability check uses the pipeline class attribute
-`supports_request_batch = True`. Pipelines that set this attribute must implement
-a request-batch-compatible `forward()` contract and return one
-`DiffusionOutput` per request; the runner validates that return shape at runtime.
-
-When the selected pipeline is batch-capable and `step_execution=False`, request
-mode routes scheduler waves through the batch executor path. Otherwise it keeps
-the per-request executor path.
-
-The optional admission wait runs only when:
-
-- request batching is supported
-- `step_execution=False`
-- `request_batch_max_wait_ms > 0`
-- no requests are currently running
-
-The wait exits early when the waiting queue reaches capacity, when the queue is
-stable for a short window, when the deadline expires, or when the engine stops.
-
-## Executor And Runner
-
-The executor exposes two request-mode entries:
-
-- `execute_request`: one worker call per scheduled request
-- `execute_batch`: one worker call for the whole `DiffusionSchedulerOutput`
-
-On the batch path, the worker builds a `DiffusionRequestBatch` and runs the
-pipeline once. Request-local setup remains per request:
-
-- KV transfer metadata
-- random generator and seed handling
-- request output/error/abort mapping
-
-Shared batch setup happens once per batch when possible:
-
-- cache refresh
-- LoRA activation for the homogeneous adapter key
-- pipeline `forward(req_batch)`
-
-Large tensor IPC still uses the shared-memory packing path. The packer traverses
-both normal `RunnerOutput.result` wrappers and nested batch results so batched
-outputs do not fall back to pickle IPC for tensor payloads.
-
-## Current Limitations
-
-- Only pipelines that declare the request-batch contract use fused batch
-  execution.
-- Batches are homogeneous under `SamplingParamsKey`; heterogeneous resolution or
-  incompatible guidance settings do not co-batch yet.
-- FIFO scheduling can reduce batching opportunities when an incompatible
-  request is at the front of the queue.
-- `request_batch_max_wait_ms` improves burst coalescing but can add latency to
-  the first request in a scheduler wave. Keep it small for latency-sensitive
-  serving.
-- Step-wise continuous batching is documented separately and only applies when
-  `step_execution=True`.
-
-## Related Files
-
-- Request object and request batch:
-  [`vllm_omni/diffusion/request.py`](gh-file:vllm_omni/diffusion/request.py)
-- Scheduler interface:
-  [`vllm_omni/diffusion/sched/interface.py`](gh-file:vllm_omni/diffusion/sched/interface.py)
-- Scheduler base:
-  [`vllm_omni/diffusion/sched/base_scheduler.py`](gh-file:vllm_omni/diffusion/sched/base_scheduler.py)
-- Engine:
-  [`vllm_omni/diffusion/diffusion_engine.py`](gh-file:vllm_omni/diffusion/diffusion_engine.py)
-- Worker runner:
-  [`vllm_omni/diffusion/worker/diffusion_model_runner.py`](gh-file:vllm_omni/diffusion/worker/diffusion_model_runner.py)
-- Executor interface:
-  [`vllm_omni/diffusion/executor/abstract.py`](gh-file:vllm_omni/diffusion/executor/abstract.py)
-- Tests:
-  [`tests/diffusion/test_diffusion_engine.py`](gh-file:tests/diffusion/test_diffusion_engine.py)
diff --git a/docs/design/feature/diffusion_step_execution.md b/docs/design/feature/diffusion_step_execution.md
deleted file mode 100644
index 797a1cb48..000000000
--- a/docs/design/feature/diffusion_step_execution.md
+++ /dev/null
@@ -1,131 +0,0 @@
-# Adding Step Execution Support for Diffusion Pipelines
-
-This guide documents vLLM-Omni's stepwise diffusion contract for model authors
-and contributors implementing `step_execution=True` support for a diffusion
-pipeline.
-
-For end-user enablement, supported models, and current limitations, see
-[Step Execution](../../user_guide/diffusion/step_execution.md).
-
-This document describes the base step-execution contract only. For the
-experimental batching policy layered on top of the step-wise path, see
-[Continuous Batching for Step-Wise Diffusion](diffusion_continuous_batching.md).
-
-## Current Support Scope
-
-`step_execution` is **not** a generic diffusion toggle. It only works for
-pipelines that implement the segmented stateful contract in
-[`vllm_omni/diffusion/models/interface.py`](gh-file:vllm_omni/diffusion/models/interface.py).
-
-This page is intentionally author-facing. Treat runtime enablement
-(`step_execution=True` in Python or `--step-execution` in serving) as an
-opt-in user knob layered on top of the implementation contract below.
-
-Current in-tree support:
-
-| Pipeline | Example models | Step execution |
-|----------|----------------|----------------|
-| `QwenImagePipeline` | `Qwen/Qwen-Image`, `Qwen/Qwen-Image-2512` | Yes |
-| All other diffusion pipelines | `QwenImageEditPipeline`, `QwenImageEditPlusPipeline`, `QwenImageLayeredPipeline`, GLM-Image, Wan, Flux, etc. | No |
-
-Current engine/runtime limitations:
-
-- Continuous batching with `max_num_seqs > 1` is experimental and documented in
-  [Continuous Batching for Step-Wise Diffusion](diffusion_continuous_batching.md).
-  Keep `max_num_seqs=1` if you want the older conservative behavior.
-- `cache_backend` is not supported in step mode.
-- Request-mode extras such as KV transfer are not wired into step mode yet.
-- Unsupported pipelines now fail early during model loading instead of failing on the first request.
-
-## Execution Contract
-
-Step mode is driven by four pipeline methods plus the shared mutable request
-state object:
-
-- `prepare_encode(state)`: one-time request preparation.
-- `denoise_step(state)`: compute the noise prediction for the current step.
-- `step_scheduler(state, noise_pred)`: mutate latents and advance step state.
-- `post_decode(state)`: decode the final output after denoising is complete.
-
-The state lives in
-[`vllm_omni/diffusion/worker/utils.py`](gh-file:vllm_omni/diffusion/worker/utils.py)
-as `DiffusionRequestState`. Store request-scoped tensors there, or use
-`state.extra` for model-specific fields that do not justify extending the core
-dataclass.
-
-The worker-side step loop lives in
-[`vllm_omni/diffusion/worker/diffusion_model_runner.py`](gh-file:vllm_omni/diffusion/worker/diffusion_model_runner.py):
-
-1. `prepare_encode()` runs once for a new request.
-2. `denoise_step()` runs every scheduler tick.
-3. `step_scheduler()` mutates `state.latents` and advances `state.step_index`.
-4. `post_decode()` runs exactly once after `state.denoise_completed` becomes true.
-
-## Recommended Split
-
-When converting an existing request-level `forward()` pipeline, keep the split
-strict and mechanical:
-
-| Request-level phase | Stepwise method | What belongs there |
-|---------------------|-----------------|--------------------|
-| Input validation, prompt encoding, latent init, timestep prep, per-request scheduler creation | `prepare_encode()` | Anything that should happen once per request |
-| Transformer forward / noise prediction | `denoise_step()` | Pure denoise computation for the current timestep |
-| `scheduler.step(...)` and `step_index += 1` | `step_scheduler()` | Only latent/state mutation for one step |
-| VAE decode / postprocess | `post_decode()` | Final decode only |
-
-Keep the stepwise path reusing the same helpers as the request-level path
-whenever possible. Reimplementing the denoise loop from scratch is the easiest
-way to introduce behavioral drift.
-
-## Qwen-Image Reference
-
-[`pipeline_qwen_image.py`](gh-file:vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py)
-is the reference implementation and is split correctly for the current
-contract:
-
-- `prepare_encode()` reuses `_prepare_generation_context()` so prompt encoding,
-  latent init, timestep creation, CFG setup, and shape bookkeeping stay aligned
-  with `forward()`.
-- `prepare_encode()` deep-copies `self.scheduler` **after**
-  `prepare_timesteps()` so request-specific scheduler state is isolated.
-- `denoise_step()` reuses `_build_denoise_kwargs()` plus
-  `predict_noise_maybe_with_cfg()`, so sequential CFG, CFG-parallel, and
-  non-CFG behavior stay identical to the request-level path.
-- `step_scheduler()` only calls
-  `scheduler_step_maybe_with_cfg(..., per_request_scheduler=state.scheduler)`
-  and increments `state.step_index`.
-- `post_decode()` reuses `_decode_latents()`, so the final image decode matches
-  the normal `forward()` path.
-
-That decomposition is the target pattern for future models.
-
-## Rules For New Pipelines
-
-- Do not keep request-scoped scheduler state on `self.scheduler`. Copy it into
-  `state.scheduler` during `prepare_encode()`.
-- Do not mutate `state.step_index` inside `denoise_step()`. Only
-  `step_scheduler()` should advance the step.
-- Do not decode partial outputs in `denoise_step()` or `step_scheduler()`.
-- If the request-level pipeline has condition latents, masks, or edit-specific
-  tensors, store them in `state` or `state.extra`, not in global pipeline
-  attributes.
-- Preserve CFG behavior by sharing the same helper path used by `forward()`.
-- Keep `post_decode()` equivalent to the tail of `forward()`.
-
-## Validation Checklist
-
-Before marking a pipeline as `supports_step_execution = True`, verify:
-
-- Stepwise output matches request-level output for the same seed and sampling params.
-- Per-request scheduler state is isolated across concurrent requests.
-- Abort during denoise does not leak cached state.
-- `step_index` reported by `RunnerOutput` matches the scheduler progress.
-- CFG-parallel and non-CFG paths both work if the request-level pipeline supports them.
-
-## Related Files
-
-- Contract: [`vllm_omni/diffusion/models/interface.py`](gh-file:vllm_omni/diffusion/models/interface.py)
-- State: [`vllm_omni/diffusion/worker/utils.py`](gh-file:vllm_omni/diffusion/worker/utils.py)
-- Runner loop: [`vllm_omni/diffusion/worker/diffusion_model_runner.py`](gh-file:vllm_omni/diffusion/worker/diffusion_model_runner.py)
-- Scheduler transport: [`vllm_omni/diffusion/sched/interface.py`](gh-file:vllm_omni/diffusion/sched/interface.py)
-- Reference pipeline: [`vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py`](gh-file:vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py)
diff --git a/docs/design/feature/disaggregated_inference.md b/docs/design/feature/disaggregated_inference.md
index 15d9e09df..c31086c0d 100644
--- a/docs/design/feature/disaggregated_inference.md
+++ b/docs/design/feature/disaggregated_inference.md
@@ -66,8 +66,6 @@ runtime:
   connectors:
     connector_of_shared_memory:
       name: SharedMemoryConnector
-      extra:
-        shm_threshold_bytes: 65536
 ```
 
 Wire stages to connectors:
diff --git a/docs/design/feature/distributed_layerwise_offload.md b/docs/design/feature/distributed_layerwise_offload.md
new file mode 100644
index 000000000..da735d60b
--- /dev/null
+++ b/docs/design/feature/distributed_layerwise_offload.md
@@ -0,0 +1,156 @@
+# Distributed Layerwise Offload
+
+This document describes distributed layerwise offload (DLO) for diffusion
+models. DLO keeps only a small number of DiT blocks on the accelerator and
+streams the remaining blocks from host memory. The distributed backend can
+either shard those host-side weights across an existing parallel group or keep
+the standard loader's rank-local weights and avoid an additional collective.
+
+For user-facing commands, see the
+[distributed layerwise offloading guide](../../user_guide/diffusion/cpu_offload.md)
+and the [Cosmos3 recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/cosmos3/Cosmos3-DistOffload.md).
+
+## Status
+
+DLO is implemented for multi-device diffusion execution. The default
+AllGather path is the primary path for DP and SP deployments. The
+`--dlo-no-use-allgather` path is a rank-local compatibility mode: it is useful
+for standard-loader sharding, workstation bring-up, and systems where an
+additional DLO collective is undesirable, but it does not reduce host weight
+storage across ranks.
+
+The compatibility matrix below describes the current implementation. The
+unit-level guards are covered, but not every parallelism combination has a
+full model-and-hardware end-to-end test.
+
+## Design
+
+### DLO consumes the existing parallel topology
+
+DLO does not create a new DP, TP, or SP topology. It reads the configured
+`DiffusionParallelConfig` and attaches offload hooks to the DiT blocks after the
+standard distributed groups have been initialized.
+
+The DLO weight-sharding group is selected as follows:
+
+1. Use the existing DP group when `data_parallel_size > 1`.
+2. When DP is one and SP is greater than one, use the SP group.
+3. Otherwise, run rank-locally without a DLO process group.
+
+TP is deliberately not used as DLO's AllGather group. HSDP has its own
+parameter-sharding lifecycle and is not allowed to be sharded a second time by
+DLO's AllGather path.
+
+### AllGather path
+
+With the default `dlo_use_allgather=True`, each rank stores approximately
+`1 / group_size` of each streamable block in pinned host memory. The next
+block's shard is copied to a device buffer and reconstructed with
+`all_gather_into_tensor` on a communication stream while the current block is
+executing.
+
+```text
+Compute:    [Block N]             [Block N+1]          [Block N+2]
+H2D:                      [shard N+1]           [shard N+2]
+AllGather:                [full N+1]             [full N+2]
+Buffers:    [current slot]       [prefetch slot]       [current slot]
+```
+
+![DLO double-buffer prefetch pipeline](../figures/dlo/dlo_pipeline.gif)
+
+The backend uses two shared device buffers, so accelerator weight residency is
+bounded by the largest streamed blocks rather than the complete model.
+
+When DP is greater than one, the engine can process one request per DP rank in
+the same denoising wave. Because AllGather is a collective, all participating
+requests must take the same execution path at every denoising step.
+
+### Rank-local path without DLO AllGather
+
+With `--dlo-no-use-allgather`, DLO forces its internal offload shard size to
+one. The regular model loader remains responsible for preparing each rank's
+weights, including TP-local tensors or HSDP-managed parameters. DLO then
+streams those rank-local tensors block by block using H2D copies only.
+
+This mode means:
+
+- DP still provides independent replicas, but DLO does not shard weights
+  across DP ranks.
+- SP still performs its normal activation/attention collectives, but DLO does
+  not shard weights across SP ranks.
+- TP/HSDP/SP collectives, if configured, are not disabled by this flag; only
+  DLO's additional weight AllGather is disabled.
+- Pure DP deployments keep a full host-side model copy per rank, subject to
+  shared OS page-cache behavior.
+- The scheduler does not require a synchronized DP request wave for DLO.
+
+This path is intentionally not implemented by reusing the AllGather mmap
+loader. It relies on the standard loader so model-specific TP/HSDP transforms
+remain intact.
+
+## Parallelism compatibility
+
+| Parallelism | DLO + AllGather | DLO without AllGather |
+|---|---|---|
+| **DP** | Supported primary path. DLO shards host weights across the DP group and can run DP multi-concurrency. | Supported rank-local path. DP replicas remain independent; no DLO weight sharding or cross-DP DLO collective. |
+| **SP** | Supported in the implementation. With DP=1, DLO uses the SP group for host-weight sharding; SP still shards sequence/activation work. | SP remains active, but DLO keeps standard-loader rank-local weights and adds no SP weight collective. |
+| **TP > 1** | Unsupported in the DLO mmap path. TP-aware loader callbacks are bypassed, so the backend rejects this configuration when it enters that path. | Standard loading is retained and TP-local tensors can be streamed. This is the intended compatibility path, but it still needs broader model and hardware validation. |
+| **HSDP** | Rejected. HSDP has already sharded parameters, so DLO AllGather would double-shard them. | Accepted by configuration. HSDP owns parameter sharding and its own gathers; DLO only stages rank-local parameters. End-to-end coverage is limited. |
+
+### Combined dimensions
+
+- **DP + SP:** DLO uses the DP group for weight sharding when DP is greater
+  than one; SP continues to use its own sequence-parallel group. If DP is one,
+  the SP group becomes DLO's sharding group in AllGather mode.
+- **DP + TP/SP without AllGather:** standard model loading defines the
+  rank-local tensor layout. DLO adds no cross-DP, cross-TP, or cross-SP weight
+  collective.
+- **HSDP + SP:** the general parallel configuration permits HSDP over SP, but
+  DLO must use `--dlo-no-use-allgather`. HSDP remains responsible for weight
+  materialization and synchronization.
+- **HSDP + DP or TP:** rejected independently by the diffusion parallel
+  configuration.
+
+## Request and loading constraints
+
+AllGather DP multi-concurrency requires:
+
+- explicit `num_inference_steps`;
+- the same `num_inference_steps` for all requests in a wave; and
+- identical request arguments that affect the collective execution path.
+
+The no-AllGather path does not impose these DLO-specific synchronized-wave
+requirements.
+
+The mmap loader is used only by the supported DLO+AllGather path when the
+model has a compatible checkpoint layout. Online quantization is incompatible
+with that sharded mmap path; use `--dlo-no-use-allgather` or disable online
+quantization. Models that do not meet the mmap requirements use the regular
+loader path.
+
+## Validation coverage
+
+Current source-level validation includes:
+
+- HSDP + DLO + AllGather rejection;
+- HSDP + DLO without AllGather acceptance at configuration level;
+- TP rejection in the DLO+AllGather mmap path;
+- resident-layer requests requiring no-AllGather;
+- DP request-wave validation for denoising-step compatibility;
+- sharding, double-buffer, AllGather-size, and heterogeneous-block regression
+  tests.
+
+The highest-value missing coverage is end-to-end numerical comparison against
+ordinary layerwise offload for DP+SP, TP+no-AllGather, and HSDP+SP+no-AllGather
+on the target CUDA/NCCL or CANN/HCCL hardware.
+
+## Recommendations
+
+- Use **DP + DLO AllGather** for the supported throughput and host-memory
+  scaling path.
+- Use **SP + DLO AllGather** for long-sequence workloads when DP concurrency is
+  not the goal.
+- Use **no-AllGather** to bring up TP or workstation PCIe configurations, with
+  the expectation of higher host-memory use and lower validation confidence.
+- Prefer **HSDP alone** for production HSDP deployments until the combined
+  HSDP + DLO no-AllGather path has broader end-to-end coverage.
diff --git a/docs/design/feature/omni_async_output_materialization.md b/docs/design/feature/omni_async_output_materialization.md
new file mode 100644
index 000000000..50a2e7c52
--- /dev/null
+++ b/docs/design/feature/omni_async_output_materialization.md
@@ -0,0 +1,386 @@
+# Async Omni Output Materialization
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Performance](#performance)
+3. [Architecture](#architecture)
+4. [Enabling the Feature](#enabling-the-feature)
+5. [Compatibility and Fallbacks](#compatibility-and-fallbacks)
+6. [Related Files](#related-files)
+
+## Overview
+
+Async Omni output materialization moves CPU-side construction of
+`OmniModelRunnerOutput` out of the autoregressive (AR) decode critical path.
+It complements [Async Chunk](async_chunk.md): async chunk pipelines partial
+outputs between stages, while async output materialization prevents the
+construction of those partial outputs from blocking the next decode step.
+
+An AR stage must return sampled token IDs quickly because the scheduler needs
+them for the next decode step. However, an Omni stage can also produce hidden
+states, multimodal tensors, streaming inter-stage payloads, and connector
+metadata. Building these payloads can require device-to-host (D2H) copies,
+tensor slicing, flattening, and Python object construction.
+
+Without this feature, all of that work runs inline in `sample_tokens()`:
+
+```text
+sample tokens
+  -> update decode state
+  -> copy hidden and multimodal outputs to CPU
+  -> build per-request payloads
+  -> build the streaming wire payload
+  -> collect connector signals
+  -> return sampled tokens
+  -> launch the next decode step
+```
+
+With async output materialization, only work required by the next decode step
+stays on the critical path:
+
+```text
+sample tokens
+  -> update decode state
+  -> snapshot output state and start asynchronous D2H copies
+  -> register sampled tokens
+  -> launch the next decode step
+
+background output path
+  -> wait for the payload snapshot
+  -> build per-request payloads
+  -> build the streaming wire payload
+  -> collect connector signals
+  -> construct OmniModelRunnerOutput
+```
+
+This allows payload construction for step `N` to overlap with GPU decode work
+for step `N + 1`. It does not change model computation or generated output.
+
+!!! note "Platform and validation scope"
+    The performance and correctness validation in this document covers CUDA
+    and ROCm. This is a validation scope, not a runtime platform guard: XPU
+    inherits `GPUARModelRunner`, and MUSA selects `GPUARWorker`, so those
+    backends may enter the asynchronous path when its other guards pass. XPU
+    and MUSA have not been validated for this optimization. Ascend NPU uses a
+    separate `NPUARModelRunner` path that still constructs
+    `OmniModelRunnerOutput` and drains connector output synchronously before
+    wrapping the result as an asynchronous runner output.
+
+<p align="center">
+  <img
+    alt="Decode step gap before and after async output materialization"
+    src="../../../source/architecture/qwen3-omni-async-output-step-gap.svg"
+    width="100%"
+  >
+</p>
+
+<p align="center">
+  <em>
+    Figure 1: Moving payload construction off the decode path reduces the
+    observed gap between consecutive Talker steps from about 2.8 ms to 41 µs.
+    Adapted from the
+    <a href="https://vllm.ai/blog/2026-07-01-qwen3-omni-optimization">
+      Qwen3-Omni optimization blog
+    </a>.
+  </em>
+</p>
+
+For Qwen3-Omni, the feature is enabled for both AR stages:
+
+- **Thinker**: Defers hidden-state and multimodal payload materialization.
+- **Talker**: Runs its decode-state postprocess eagerly, then defers codec
+  payload materialization. Because Code2Wav consumes codec codes rather than
+  Talker hidden states, the Talker also skips unnecessary hidden-state D2H.
+- **Code2Wav**: Does not use this path because it is a generation stage rather
+  than an AR stage.
+
+Qwen3-TTS uses the same mechanism in its AR Talker stage. The Talker updates
+the decode state it needs for the next step before returning, then constructs
+the codec payload for Code2Wav in the background.
+
+## Performance
+
+In the controlled Qwen3-Omni optimization sweep, enabling async output
+materialization on top of CUDA Graph and async chunk produced the following
+results at concurrency 64:
+
+| Configuration | Request throughput | Mean audio TTFP | Mean audio RTF |
+|---|---:|---:|---:|
+| CUDA Graph + async chunk | 9.3 req/s | 655 ms | 0.63 |
+| + async output materialization | 11.3 req/s | 631 ms | 0.47 |
+| Change | **+22%** | **-4%** | **-25%** |
+
+The sweep used `Qwen/Qwen3-Omni-30B-A3B-Instruct`, 640 Seed-TTS English
+prompts, and one replica each for Thinker, Talker, and Code2Wav. Async output
+materialization recovers throughput by removing CPU payload construction from
+the decode critical path without regressing time to first audio packet (TTFP).
+See the
+[Qwen3-Omni optimization blog](https://vllm.ai/blog/2026-07-01-qwen3-omni-optimization)
+for the complete benchmark methodology and results.
+
+The implementation was also validated against the synchronous safe-copy path.
+The text and audio output hashes matched, confirming that overlap does not
+change the generated result. See
+[PR #4476](https://github.com/vllm-project/vllm-omni/pull/4476) for the
+correctness and profiling details.
+
+## Architecture
+
+### Output Lifecycle
+
+`OmniAsyncGPUModelRunnerOutput` extends vLLM's
+`AsyncGPUModelRunnerOutput`. It preserves the existing asynchronous
+sampled-token feedback while adding a background builder for the complete Omni
+output.
+
+The output lifecycle is:
+
+1. `GPUARModelRunner.sample_tokens()` samples tokens and performs the
+   bookkeeping required by the next decode step.
+2. The runner snapshots step-local metadata such as request IDs, token spans,
+   scheduler output, and query start locations.
+3. CUDA payload tensors are cloned before reusable model or CUDA Graph buffers
+   can be overwritten.
+4. The cloned payload is copied to pinned CPU memory on a dedicated CUDA
+   stream. A CUDA event records when the copy is ready.
+5. `OmniAsyncGPUModelRunnerOutput` starts a background thread that waits for
+   the payload event and builds `OmniModelRunnerOutput`.
+6. The AR runner immediately registers the sampled-token CPU copy with the
+   input batch and returns, allowing async scheduling to advance.
+7. When the engine calls `get_output()`, it joins the background builder,
+   propagates any builder exception, and finalizes sampled tokens and logprobs
+   through the upstream output implementation.
+
+```text
+GPU / decode path                         Background output path
+
+forward + sample
+      |
+      +-- clone output tensors
+      +-- enqueue D2H copy --------------> wait for D2H event
+      +-- register sampled tokens               |
+      +-- return async output                    +-- slice per request
+      |                                         +-- build multimodal payloads
+next decode step                                +-- partition streaming payloads
+                                                +-- build the wire payload
+                                                +-- drain connector signals
+                                                +-- build OmniModelRunnerOutput
+```
+
+### Safe State Snapshots
+
+The next scheduler step can mutate runner state while the background builder is
+still active. Most step-local builder inputs are therefore detached snapshots.
+The snapshotted state includes:
+
+- scheduler token counts and speculative-token metadata
+- request IDs and request-to-batch-index mappings
+- sampled token IDs, logprobs, and prompt logprobs
+- query start locations and scheduled-token spans
+- hidden states and multimodal output tensors
+- KV-connector and encoder-cache outputs captured for the step
+
+CUDA tensor cloning is required because CUDA Graph and model output buffers can
+be reused by the next forward pass. The dedicated copy stream and pinned host
+buffers make the D2H transfer asynchronous; the snapshot retains its cloned
+CUDA sources until the transfer event completes.
+
+### Live Runner State and Ownership
+
+The complete builder input is not a detached snapshot. Connector output state
+remains runner-owned: `get_omni_connector_output()` drains live, per-cycle
+connector signals after the streaming payload is built. Correctness therefore
+depends on that builder being the only consumer that drains connector signals
+for its output cycle. Receive-side connector state written by the background
+receiver is coordinated by the connector mixin's `_lock`.
+`OmniAsyncGPUModelRunnerOutput.get_output()` joins the builder and is the
+completion and exception boundary before the materialized output is consumed.
+
+The shared output builder also contains a full-payload accumulation branch
+that reads `self.requests`. That branch is not reachable when async Omni output
+materialization is enabled: this feature requires `async_chunk`, while
+`should_accumulate_full_payload_output()` returns `False` whenever
+`async_chunk` is enabled. The feature path partitions each step's payload into
+streaming inter-stage and client handoffs instead.
+
+### Output Builder
+
+The background builder performs the work that previously ran inline:
+
+- resolves which requests need downstream payloads
+- converts hidden and multimodal tensors into per-request CPU payloads
+- applies model-specific payload processing
+- partitions per-step payloads into inter-stage and client streams
+- creates the tensor-only `multimodal_outputs` wire payload
+- drains live connector readiness signals after building the streaming payload
+- constructs the final `OmniModelRunnerOutput`
+
+Input-side connector operations remain synchronous with model execution. In
+particular, receiving inputs and flushing previously completed connector
+outputs are not deferred because they affect scheduler-visible request state.
+
+### Qwen3-Omni Stage Behavior
+
+| Stage | Async output behavior | Reason |
+|---|---|---|
+| Thinker | Snapshots hidden states and multimodal outputs; builds the downstream payload in the background | The Talker needs the payload, but the next Thinker decode step only needs sampled-token feedback |
+| Talker | Runs lightweight postprocess eagerly; snapshots codec outputs; omits hidden states from the downstream payload | `hidden_states.last` is needed by the next Talker step, while Code2Wav only needs codec codes |
+| Code2Wav | Uses the normal generation-stage output path | Code2Wav is not executed by `GPUARModelRunner` |
+
+The Qwen3-TTS Talker follows the same pattern as the Qwen3-Omni Talker:
+postprocess runs eagerly because the next decode step needs its updated state,
+while codec payload construction runs asynchronously. Its Code2Wav stage also
+uses the normal generation-stage path.
+
+## Enabling the Feature
+
+There is no separate `async_omni_output` command-line or YAML option. The
+feature is selected automatically for model stages that opt in when the runtime
+conditions are safe. On the validated CUDA and ROCm configurations, using the
+bundled deployment profile is enough to turn it on for the supported
+Qwen3-Omni and Qwen3-TTS pipelines. The selection logic has no CUDA/ROCm-only
+guard; see [Compatibility and Fallbacks](#compatibility-and-fallbacks) for the
+other platform paths. The same profile does not enable background Omni
+materialization on Ascend NPU.
+
+### Example 1: Qwen3-Omni
+
+Start the full Qwen3-Omni pipeline:
+
+```bash
+vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct \
+  --omni \
+  --port 8091
+```
+
+The model registry automatically loads
+`vllm_omni/deploy/qwen3_omni_moe.yaml`. Its relevant settings are:
+
+```yaml
+async_chunk: true
+
+stages:
+  - stage_id: 0  # Thinker
+    enable_prefix_caching: false
+    # async_scheduling defaults to true for AR stages
+
+  - stage_id: 1  # Talker
+    enable_prefix_caching: false
+    # async_scheduling defaults to true for AR stages
+
+  - stage_id: 2  # Code2Wav
+    enable_prefix_caching: false
+    async_scheduling: false
+```
+
+With this profile, async output materialization activates automatically for:
+
+- **Stage 0, Thinker**: Defers hidden-state and multimodal payload
+  construction.
+- **Stage 1, Talker**: Defers codec payload construction after eagerly
+  updating its decode state.
+
+Stage 2 does not use this feature because Code2Wav is not an AR stage.
+
+### Example 2: Qwen3-TTS
+
+Start Qwen3-TTS with any checkpoint that uses the Qwen3-TTS Talker pipeline.
+For example:
+
+```bash
+vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
+  --omni \
+  --port 8091
+```
+
+The model registry automatically loads `vllm_omni/deploy/qwen3_tts.yaml`. Its
+relevant settings are:
+
+```yaml
+async_chunk: true
+
+stages:
+  - stage_id: 0  # Talker
+    async_scheduling: true
+    enable_prefix_caching: false
+
+  - stage_id: 1  # Code2Wav
+    enable_prefix_caching: false
+```
+
+Async output materialization activates only for Stage 0, the AR Talker. The
+Talker keeps the state required by its next decode step on the GPU, skips an
+unnecessary hidden-state D2H copy, and builds the codec payload for Code2Wav in
+the background. Stage 1 uses the generation-stage output path.
+
+The same behavior applies to the Base and VoiceDesign Qwen3-TTS checkpoints
+because they use the same Talker implementation.
+
+!!! warning
+    Do not pass `--no-async-chunk` or enable prefix caching when you want this
+    optimization. Either change causes the runner to fall back to synchronous
+    output construction. Enabling async chunk alone cannot activate the feature
+    for a model that has not opted into async Omni output.
+
+!!! note "Prefix cache compatibility"
+    Async Omni output materialization and Omni prefix caching cannot currently
+    run together. `_should_use_async_omni_output()` returns `False` whenever
+    `self.omni_prefix_cache` is present, so prefix caching selects synchronous
+    output materialization. Supporting both features requires snapshotting or
+    otherwise synchronizing prefix-cache merge and update state before the
+    background output path can consume it safely.
+
+## Compatibility and Fallbacks
+
+`GPUARModelRunner` uses the async output path only when all of the following
+runtime conditions hold:
+
+| Requirement | Reason |
+|---|---|
+| AR async scheduling is enabled | The optimization relies on the scheduler advancing while the prior output is materialized |
+| `async_chunk` is enabled | The feature targets incremental downstream Omni payloads |
+| The model stage opts in with `use_async_omni_output` | Models must declare that their output lifecycle is safe to defer |
+| Omni prefix cache is disabled | Prefix-cache merge and update ordering currently requires synchronous materialization |
+| Speculative decoding is disabled | Speculative output state is not included in this deferred path |
+| Routed-expert output is disabled | Routed-expert extraction currently requires the synchronous path |
+| Postprocess is absent or explicitly runs eagerly | State needed by the next decode step must be updated before the runner returns |
+
+These checks are evaluated per stage on runners based on `GPUARModelRunner`.
+An unsupported combination does not prevent serving; it only falls back to
+synchronous output construction for that stage. CUDA and ROCm are the validated
+platforms. XPU inherits `GPUARModelRunner`, and MUSA selects `GPUARWorker`, so
+they may select the async path when these checks pass, but this optimization is
+not yet validated on either backend.
+
+Ascend NPU does not use this selection path. `NPUARModelRunner.sample_tokens()`
+fully constructs `OmniModelRunnerOutput`, calls
+`get_omni_connector_output()`, and only then creates the asynchronous wrapper,
+so Omni payload materialization remains synchronous.
+
+!!! note
+    `use_async_omni_output`,
+    `eager_omni_postprocess_before_async_output`, and
+    `omni_pooler_payload_include_hidden` are model implementation contracts,
+    not user-facing configuration fields.
+
+## Related Files
+
+- `vllm_omni/worker/gpu_ar_model_runner.py`: Async output object, safe tensor
+  snapshots, compatibility guards, and deferred Omni output builder.
+- `vllm_omni/platforms/npu/worker/npu_ar_model_runner.py`: Separate Ascend NPU
+  runner, where Omni output materialization remains synchronous.
+- `vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py`: Thinker and
+  Talker opt-in behavior.
+- `vllm_omni/deploy/qwen3_omni_moe.yaml`: Default Qwen3-Omni deployment
+  settings.
+- `vllm_omni/model_executor/models/qwen3_tts/qwen3_tts_talker.py`: Qwen3-TTS
+  Talker opt-in and eager postprocess behavior.
+- `vllm_omni/deploy/qwen3_tts.yaml`: Default Qwen3-TTS deployment settings.
+- `tests/worker/test_gpu_ar_model_runner.py`: Snapshot, guard, connector
+  ordering, and background error-propagation tests.
+- [Async Chunk](async_chunk.md): Inter-stage chunking and scheduling design.
+- [Qwen3-Omni optimization blog](https://vllm.ai/blog/2026-07-01-qwen3-omni-optimization):
+  Optimization context and controlled performance results.
+- [PR #4476](https://github.com/vllm-project/vllm-omni/pull/4476): Feature
+  implementation, validation, and review history.
diff --git a/docs/design/feature/omni_connectors/shared_memory_connector.md b/docs/design/feature/omni_connectors/shared_memory_connector.md
index 5b35014f2..62d77cd6d 100644
--- a/docs/design/feature/omni_connectors/shared_memory_connector.md
+++ b/docs/design/feature/omni_connectors/shared_memory_connector.md
@@ -8,9 +8,7 @@ auto-configured when no explicit connector is specified for an edge.
 ## How It Works
 
 All payloads are serialized and stored in shared memory (`/dev/shm`); the SHM
-segment name is returned in metadata. The configuration exposes a
-`shm_threshold_bytes` field for a future inline-vs-SHM split, but the current
-implementation always uses shared memory regardless of payload size.
+segment name is returned in metadata.
 
 ## Configuration
 
@@ -19,8 +17,6 @@ runtime:
   connectors:
     connector_of_shared_memory:
       name: SharedMemoryConnector
-      extra:
-        shm_threshold_bytes: 65536
 ```
 
 ## Notes
@@ -166,27 +162,10 @@ This path is mainly for older code paths and is not the preferred mode for the c
 
 ### 6. Key Implementation Characteristics
 
-#### 6.1 Threshold Exists, but the Current Code Always Uses SHM
+#### 6.1 All Payloads Use Shared Memory
 
-The class keeps a `shm_threshold_bytes` field and still exposes metrics for inline writes. However, the current implementation uses:
-
-```python
-if True:
-    ...
-```
-
-inside `put()`, which means the current code path always writes to shared memory.
-
-So the design still suggests a future split between:
-
-- small payloads inline
-- large payloads in shared memory
-
-but the current behavior is effectively:
-
-- all payloads go through shared memory
-
-This should be documented because it affects real runtime behavior.
+`put()` writes every serialized payload to shared memory. The connector has no
+inline-payload path or size threshold.
 
 #### 6.2 Cleanup Is Currently Passive
 
diff --git a/docs/design/feature/quantization.md b/docs/design/feature/quantization.md
new file mode 100644
index 000000000..37dd5e26b
--- /dev/null
+++ b/docs/design/feature/quantization.md
@@ -0,0 +1,249 @@
+# Quantization
+
+This document describes the quantization architecture in vLLM-Omni and the
+extension points for contributors. For user-facing configuration, supported
+hardware, and method-specific instructions, see the
+[quantization user guide](../../user_guide/quantization/overview.md).
+
+## Goals and scope
+
+The design has four goals:
+
+1. Provide one `quantization_config` entry point for diffusion-only,
+   multi-stage omni/TTS, and multi-stage diffusion models.
+2. Reuse vLLM's quantization registry and `QuantizationConfig` contract where
+   a vLLM backend already provides the required behavior.
+3. Allow different components of one pipeline to use different quantization
+   configurations.
+4. Preserve the distinction between online quantization of a BF16/FP16
+   checkpoint and loading a pre-quantized checkpoint with serialized scales.
+
+This document covers configuration resolution, component routing, model
+integration, backend extension, and validation. Kernel implementations and
+user-facing support matrices are outside its scope.
+
+## Architecture
+
+The quantization path is split across the following layers:
+
+| Layer | Responsibility | Source |
+| --- | --- | --- |
+| Public API | Exposes `build_quant_config`, component routing, and backend registration | `vllm_omni/quantization/__init__.py` |
+| Factory | Normalizes method names, selects Omni overrides or vLLM registry backends, detects ModelOpt configs, and reconciles checkpoint metadata | `vllm_omni/quantization/factory.py` |
+| Component router | Resolves a quantization config from a layer prefix using longest-prefix matching | `vllm_omni/quantization/component_config.py` |
+| Method configs | Implement `QuantizationConfig` and select the platform-specific linear method | `vllm_omni/quantization/*_config.py` |
+| Diffusion configuration | Stores the canonical runtime config and propagates checkpoint configuration | `vllm_omni/diffusion/data.py` |
+| Worker and model integration | Passes the resolved config into vLLM's model configuration and model layers | `vllm_omni/diffusion/worker/diffusion_worker.py` and `vllm_omni/diffusion/models/` |
+
+The runtime contract remains vLLM's `QuantizationConfig`:
+
+```text
+user/CLI or model config
+          |
+          v
+OmniDiffusionConfig.quantization_config
+          |
+          +--> build_quant_config()
+          |        |
+          |        +--> Omni override
+          |        +--> vLLM registry backend
+          |        +--> ComponentQuantizationConfig
+          |
+          +--> checkpoint metadata reconciliation
+          |
+          +--> diffusion worker / vLLM config
+          |
+          +--> model layers call get_quant_method(layer, prefix)
+```
+
+The model layer receives either a method implementation or `None`. Returning
+`None` leaves that layer unquantized.
+
+## Configuration resolution
+
+`build_quant_config()` accepts the following forms:
+
+| Input | Resolution |
+| --- | --- |
+| `None` or `"none"` | Disable quantization. |
+| Method string, such as `"fp8"` | Resolve an Omni override first, then the vLLM quantization registry. |
+| Flat dictionary with `method` or `quant_method` | Normalize the method and construct its `QuantizationConfig`. |
+| Per-component dictionary | Construct a `ComponentQuantizationConfig`. |
+| Existing `QuantizationConfig` | Pass through without rebuilding it. |
+
+Method aliases are normalized case-insensitively, with `-` and `_` treated as
+equivalent. `auto-round` and `auto_round` use the Omni INC/AutoRound adapter.
+ModelOpt checkpoint metadata is detected from its method, producer metadata, or
+`quant_algo`, then mapped to the corresponding vLLM ModelOpt configuration.
+
+The factory uses Omni-specific overrides for methods whose diffusion behavior
+or platform dispatch is not provided by the vLLM registry. The current override
+set includes INT8, BitsAndBytes, MXFP8, MXFP4, MXFP4 dual-scale, and INC/
+AutoRound. Other methods, such as FP8, GGUF, and ModelOpt, are resolved through
+vLLM's registry when their configuration is compatible.
+
+## Per-component routing
+
+Multi-stage models do not necessarily want one quantization policy for every
+module. A component map expresses that policy without requiring each pipeline
+to construct separate vLLM configurations:
+
+```python
+quantization_config = {
+    "transformer": {"method": "fp8"},
+    "vae": None,
+    "default": None,
+}
+```
+
+`ComponentQuantizationConfig` applies the following rules:
+
+1. Component keys are interpreted as runtime layer-prefixes.
+2. The longest matching prefix wins.
+3. `None` disables quantization for the matching component.
+4. `default`, when present, handles prefixes with no explicit match.
+5. A matching child config delegates to its normal
+   `get_quant_method(layer, prefix)` implementation.
+
+Prefix matching happens after the model's weight-name mapping. New model
+integrations must verify the actual runtime prefixes, especially when a
+`WeightsMapper` changes checkpoint names. A prefix mismatch can silently route
+a layer to the default configuration, so component-routing tests should cover
+both positive matches and fall-through behavior.
+
+## Online and pre-quantized checkpoints
+
+The same method name can represent two different loading paths:
+
+- **Online**: the source checkpoint contains BF16/FP16 weights; the method
+  creates quantized weights or scales while the model is loaded.
+- **Pre-quantized**: the checkpoint contains quantized weights and the metadata
+  required by the method; the loader consumes those serialized tensors.
+
+Method configuration owns the mode flag, for example
+`is_checkpoint_int8_serialized` or `is_checkpoint_mxfp8_serialized`. The
+configuration's `get_quant_method()` selects the corresponding linear method.
+
+For pipelines with transformer-specific `config.json` files, such as cascade
+models, `resolve_quant_config_from_disk()` reconciles the active configuration
+with each transformer's checkpoint metadata. Its invariants are:
+
+- If no active configuration exists, valid checkpoint metadata can be used for
+  auto-detection.
+- A method mismatch is an error rather than an implicit conversion.
+- Serialized-checkpoint flags rebuild an online configuration into the
+  matching offline configuration.
+- Checkpoint-specific `ignored_layers` are preserved by rebuilding the active
+  configuration when they differ.
+- AutoRound MXFP8 metadata (`data_type="mx_fp"`) selects its offline path.
+
+This prevents a model from interpreting serialized weights with an online
+loader or silently applying the wrong method to one transformer in a
+multi-transformer pipeline.
+
+## Model and layer integration
+
+Diffusion model constructors receive the resolved configuration and pass it to
+quantizable vLLM layers. Each method configuration is responsible for:
+
+- identifying supported layers in `get_quant_method()`;
+- creating the correct parameter shapes and loaders;
+- processing weights after loading when conversion is required; and
+- applying the platform-specific quantized operation at runtime.
+
+Model code must keep precision-sensitive or unsupported modules unquantized.
+The shared `safe_quant_config()` helper is used by model integrations for
+normalization and modulation layers where a generic FP8 configuration would be
+unsafe. Text encoders, audio/vision encoders, VAEs, schedulers, and tokenizers
+are not implicitly quantized just because the main transformer is quantized;
+they require explicit component routing and method support.
+
+Weight quantization and quantized KV cache are separate paths. The former is
+resolved through `quantization_config`; runtime attention/KV-cache quantization
+is configured by the diffusion attention configuration and must be validated
+independently.
+
+## Platform and parallelism boundaries
+
+Platform checks belong in the method implementation rather than in the common
+factory. This keeps configuration parsing portable while allowing CUDA, NPU,
+and XPU methods to select different kernels or reject unsupported execution at
+model construction time. The user guide is the source of truth for the current
+hardware support matrix.
+
+Quantization methods must also respect the weight layout produced by the
+configured parallelism strategy:
+
+- Tensor-parallel layers may receive partitioned weight shapes and loaders.
+- Sequence-parallel execution changes activation movement but does not by
+  itself change the quantization configuration.
+- Data-parallel replicas build their own method state; quantization metadata
+  must be available consistently on every rank.
+- `WeightsMapper` transformations must be applied before matching ignored-layer
+  lists or component prefixes.
+
+Distributed layerwise offload has an additional boundary: its sharded mmap
+AllGather path is not compatible with online quantization because the path
+expects already materialized checkpoint weights. Use the rank-local
+`--dlo-no-use-allgather` path or a compatible pre-quantized checkpoint when
+combining these features. See the [DLO design document](distributed_layerwise_offload.md)
+for the full compatibility matrix.
+
+## Adding a quantization backend
+
+Contributors should follow this sequence:
+
+1. Check whether an existing vLLM backend can provide the required weight
+   format and kernel behavior. Prefer reuse over a duplicate Omni backend.
+2. If Omni-specific behavior is required, implement a `QuantizationConfig` and
+   its `QuantizeMethodBase`/linear method in `vllm_omni/quantization/`.
+3. Implement `get_name()`, supported activation dtypes, minimum capability,
+   checkpoint parsing, ignored-layer handling, and `get_quant_method()`.
+4. Add a lazy factory override in `factory.py`. Keep optional platform
+   dependencies out of package import paths and normalize aliases to one
+   canonical method name.
+5. If the method is pre-quantized, define the checkpoint metadata and the
+   serialized loading path before adding an online path.
+6. Add model-specific component routing only when the model contains stages
+   that must use different policies.
+7. Document user-visible configuration in the quantization user guide and keep
+   implementation rationale here.
+
+The public factory registration hook,
+`register_quantization_override(method, builder)`, is intended for integrations
+that need to register an Omni-compatible builder without changing the vLLM
+registry.
+
+## Validation
+
+Validation should cover the complete path, not only whether a config object can
+be instantiated:
+
+| Area | Required checks |
+| --- | --- |
+| Factory | Strings, aliases, flat dictionaries, invalid inputs, passthrough, and component maps |
+| Method config | Online/offline selection, ignored layers, platform guards, and weight loading |
+| Checkpoint metadata | Auto-detection, method mismatch errors, serialized flags, and per-transformer metadata |
+| Model integration | Correct quantization scope, unquantized components, and parallel weight layouts |
+| Numerical quality | Same-seed BF16 versus quantized output comparison at representative resolutions and step counts |
+| Performance | Peak device memory, generation latency, and any backend-specific throughput metric |
+
+The unit tests live under `tests/diffusion/quantization/`. The trajectory
+similarity tool in
+`vllm_omni/quantization/tools/compare_diffusion_trajectory_similarity.py`
+provides a repeatable quality and memory comparison for diffusion models.
+Method support and feature combinations remain model- and hardware-dependent;
+passing factory tests alone does not establish production support.
+
+## Design invariants
+
+- `quantization_config` is the single runtime source of truth after config
+  normalization.
+- A checkpoint method mismatch fails loudly instead of risking weight
+  corruption.
+- Components without an explicit supported quantization path remain in their
+  original precision.
+- Optional backend dependencies are imported lazily.
+- Method implementations own platform-specific capability checks and kernels.
+- User-facing support claims require model, hardware, numerical, and memory
+  validation in addition to configuration-level tests.
diff --git a/docs/design/feature/ray_based_execution.md b/docs/design/feature/ray_based_execution.md
deleted file mode 100644
index ae10d661f..000000000
--- a/docs/design/feature/ray_based_execution.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# Distributed utils
-
-This directory (vllm_omni/distributed/ray_utils) contains utilities for distributed execution in vllm-omni, supporting both **Ray** and **Multiprocessing** backends.
-## 1. Installation
-```bash
-pip install "ray[default]"
-```
-## 2. Ray Utils
-
-The `ray_utils` module provides helper functions for managing Ray clusters and actors, which is essential for:
-*   **Multi-node deployment**: Running pipeline stages across different physical machines.
-*   **Resource management**: Efficient GPU/CPU allocation.
-
-### 2.1 Basic Usage
-
-To use the Ray backend, specify `worker_backend="ray"` when initializing the engine.
-
-**Command Line Example:**
-```bash
-vllm serve Qwen/Qwen2.5-Omni-7B \
-  --omni \
-  --port 8091 \
-  --worker-backend ray \
-  --ray-address auto
-```
-
-### 2.2 Cluster Setup
-
-**Step 1: Start Head Node**
-Run this on your primary machine:
-```bash
-ray start --head --port=6399
-```
-
-**Step 2: Connect Worker Nodes**
-Run this on each worker machine:
-```bash
-ray start --address=<HEAD_NODE_IP>:6399
-```
-
-> **Tip**: For a complete cluster setup script, refer to the vLLM example:
-> [run_cluster.sh](https://github.com/vllm-project/vllm/blob/main/examples/online_serving/run_cluster.sh)
-
-### 2.3 Distributed Connector Support
-
-When running on Ray, the system automatically adapts its communication strategy:
-
-*   **Cross-Node**: Recommended to use `MooncakeTransferEngineConnector` (RDMA, fastest) or `MooncakeStoreConnector` (TCP fallback).
-*   **Same-Node**: Can still use `SharedMemoryConnector` for efficiency, or Ray's native object store (plasma).
-*   **SHM threshold default differs**: when `worker_backend="ray"`, the SharedMemoryConnector default threshold is set to `sys.maxsize`, which forces payloads to go inline (no SHM). Override `shm_threshold_bytes` in the connector config if you want SHM for Ray runs.
-
-### 2.4 Internal Helpers
-
-*   **`initialize_ray_cluster`**: Connects to an existing Ray cluster or starts a local one.
-
-## 3. Troubleshooting
-
-*   **Connection Issues**: Ensure the Ray head node is accessible and ports (default 6399 in this example) are open.
-*   **Version Mismatch**: Ensure all nodes run the same version of Ray and Python.
diff --git a/docs/design/feature/skip_softmax.md b/docs/design/feature/skip_softmax.md
new file mode 100644
index 000000000..8e6375ee8
--- /dev/null
+++ b/docs/design/feature/skip_softmax.md
@@ -0,0 +1,88 @@
+# Skip-Softmax
+
+Skip-Softmax is the sparse-attention mode of the `TRTLLM_ATTN` backend. Usage — the config keys
+and how to pick an operating point — is in
+[Diffusion Attention Backends](../../user_guide/diffusion/attention_backends.md). This page explains
+the algorithm.
+
+## Motivation
+
+In a long attention row (a video DiT can have tens of thousands of keys), the softmax weight
+concentrates on a small fraction of the keys; the rest receive near-zero weight and barely move the
+output. Computing softmax and the value-weighted sum over those keys is wasted work. Skip-Softmax
+detects, per block of keys, when a block cannot matter and skips its softmax and its value
+multiply.
+
+It is approximate: a skipped block still carries a small non-zero contribution, so the mode is
+opt-in and off by default.
+
+## The online-softmax pass
+
+Attention is computed in a single streaming pass over the keys, in tiles of 128. Per query row the
+kernel maintains three running values:
+
+- `m` — the largest score seen so far,
+- `l` — the running denominator `Σ exp(sⱼ − m)`,
+- `O` — the running numerator `Σ exp(sⱼ − m)·vⱼ`,
+
+and returns `O / l` at the end. For each key tile it computes the tile's scores `Q · K_jᵀ · scale`,
+updates `m`, and accumulates that tile's contribution into `l` and `O`. Rescaling `l` and `O` when
+`m` grows keeps the single pass numerically exact.
+
+## The skip test
+
+Once a tile's scores are known, its largest score `tile_max` is compared against the running
+maximum:
+
+```text
+if exp(tile_max − running_max) < threshold:
+    skip this tile          # do not compute its softmax weights or its P·V accumulation
+```
+
+`exp(tile_max − running_max)` is an upper bound on the softmax weight any key in the tile can
+receive: if even the tile's best key is far below the current maximum, every key in the tile is
+negligible, and both the softmax (the exponentials) and the `P·V` accumulation for that tile can be
+dropped. The tile's contribution to `l` and `O` is simply skipped.
+
+## What this bounds
+
+Two properties of the test shape the achievable speedup:
+
+- **`Q · K_jᵀ` always runs.** The test needs `tile_max`, which comes from the tile's scores, so the
+  score matmul is never skipped — only the softmax and the `P·V` accumulation are. The score matmul
+  and the value matmul are comparable in cost, so skipping every eligible tile removes at most
+  roughly half the attention work; the kernel-level speedup is bounded well under 2×, not unbounded.
+
+- **The decision is per tile, not per key.** A tile is skipped only when *all* of its keys are
+  collectively negligible; a single important key keeps the whole tile. How many tiles actually
+  qualify depends on the data and rounds down to tile granularity, so `target_sparsity` selects an
+  operating point on a calibrated curve — it is not a promise that a fixed fraction of tiles is
+  skipped.
+
+## The threshold
+
+The per-tile threshold is normalized by sequence length:
+
+```text
+threshold = factor / seqlen
+```
+
+`factor` comes from one of two sources:
+
+- **Calibrated** — `factor = a · exp(b · target_sparsity)`, where `a` and `b` are fit per model (and
+  per expert, for a multi-expert model) so that a given `target_sparsity` lands near that fraction of
+  skipped tiles on the calibration data.
+- **Direct** — `factor = skip_softmax.threshold · seqlen`, the calibration-free path; the user sets
+  the threshold themselves.
+
+## Timestep gating
+
+`disabled_until_timestep = D` keeps the mode off during the early, high-noise denoise steps and
+turns it on once the normalized timestep `t` drops to `t ≤ D` (`t` runs `1.0` → `0.0` over the
+schedule). The early steps set the global structure of the output and their errors propagate through
+every later step, so keeping them dense costs a few skipped-tile opportunities but protects fidelity.
+
+`t` is the scheduler's own timestep divided by `num_train_timesteps`, published by the pipeline via
+`DenoiseProgressMixin.record_denoise_step`. It is deliberately not derived from the step index,
+because schedulers space their steps non-uniformly. A pipeline that does not publish a timestep
+stays dense when `disabled_until_timestep` is set.
diff --git a/docs/design/feature/tensor_parallel.md b/docs/design/feature/tensor_parallel.md
index bcafde7e7..a01e2a0e6 100644
--- a/docs/design/feature/tensor_parallel.md
+++ b/docs/design/feature/tensor_parallel.md
@@ -264,7 +264,7 @@ Complete examples in the codebase:
 | **Z-Image** | `vllm_omni/diffusion/models/z_image/z_image_transformer.py` | Standard TP | Full implementation with validation |
 | **FLUX** | `vllm_omni/diffusion/models/flux/flux_transformer.py` | Dual-stream | Image + text streams |
 | **Qwen-Image** | `vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py` | Standard TP | With RoPE |
-| **TP Tests** | `tests/e2e/offline_inference/test_zimage_parallelism.py` | E2E testing | TP correctness and performance |
+| **TP Tests** | `tests/diffusion/distributed/test_tensor_parallel.py` | E2E testing | TP correctness and performance |
 | **Constraint Tests** | `tests/diffusion/models/z_image/test_zimage_tp_constraints.py` | Unit testing | Validation logic |
 
 ---
diff --git a/docs/design/feature/vae_parallel.md b/docs/design/feature/vae_parallel.md
index 00f41378a..c465449f8 100644
--- a/docs/design/feature/vae_parallel.md
+++ b/docs/design/feature/vae_parallel.md
@@ -445,6 +445,7 @@ Complete examples in the codebase:
 | **Z-Image** | `vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl.py` | ✅ | ❌ |
 | **Wan2.2** | `vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_wan.py` | ✅ | ✅ |
 | **Qwen-Image** | `vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_qwenimage.py` | ✅ | ❌ |
+| **FLUX.2-dev** | `vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_flux2.py` | ✅ | ✅ |
 
 ---
 
diff --git a/docs/design/figures/dlo/dlo_pipeline.gif b/docs/design/figures/dlo/dlo_pipeline.gif
new file mode 100644
index 000000000..cc206d03b
Binary files /dev/null and b/docs/design/figures/dlo/dlo_pipeline.gif differ
diff --git a/docs/design/index.md b/docs/design/index.md
index 0a59af4cf..c98af378d 100644
--- a/docs/design/index.md
+++ b/docs/design/index.md
@@ -1,6 +1,9 @@
 # Design Documents
 
-This section contains design documents and architecture specifications for vLLM-Omni.
+This section contains design documents and architecture specifications for
+vLLM-Omni. The sidebar groups documents by the system concern they describe;
+retired module pages are preserved in the legacy archive instead of remaining
+in the active navigation.
 
 ## Architecture Documents
 
@@ -8,22 +11,63 @@ This section contains design documents and architecture specifications for vLLM-
 
 ## Feature Design Documents
 
-- [Disaggregated Inference](feature/disaggregated_inference.md)
-- [Ray-based Execution](feature/ray_based_execution.md)
-- [Adding Step Execution Support for Diffusion Pipelines](feature/diffusion_step_execution.md)
-- [Request-Level Batching for Diffusion](feature/diffusion_request_level_batching.md)
-- [Continuous Batching for Step-Wise Diffusion](feature/diffusion_continuous_batching.md)
+### Runtime and stage execution
 
-## Infrastructure Design Documents
+- [Disaggregated Inference](feature/disaggregated_inference.md)
+- [Async Chunk](feature/async_chunk.md)
+- [Async Diffusion Output](feature/async_diffusion_output.md)
+- [Async Omni Output Materialization](feature/omni_async_output_materialization.md)
+- [Automatic Prefix Caching in Omni Models](feature/prefix_caching.md)
+
+### Communication
+
+#### OmniConnector implementations
+
+- [Mooncake Store Connector](feature/omni_connectors/mooncake_store_connector.md)
+- [Mooncake Transfer Engine Connector](feature/omni_connectors/mooncake_transfer_engine_connector.md)
+- [Mori Transfer Engine Connector](feature/omni_connectors/mori_transfer_engine_connector.md)
+- [Shared Memory Connector](feature/omni_connectors/shared_memory_connector.md)
+- [Yuanrong Store Connector](feature/omni_connectors/yuanrong_connector.md)
+- [Yuanrong Transfer Engine Connector](feature/omni_connectors/yuanrong_transfer_engine_connector.md)
+
+### Diffusion acceleration
+
+#### Parallelism
+
+- [CFG-Parallel](feature/cfg_parallel.md)
+- [Expert Parallel](feature/expert_parallel.md)
+- [Hybrid Sharded Data Parallel (HSDP)](feature/hsdp.md)
+- [Pipeline Parallel](feature/pipeline_parallel.md)
+- [Sequence Parallel](feature/sequence_parallel.md)
+- [Tensor Parallel](feature/tensor_parallel.md)
+- [VAE Patch Parallelism](feature/vae_parallel.md)
+
+#### Attention Backends
+
+- [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)
+- [Distributed Layerwise Offload](feature/distributed_layerwise_offload.md)
+
+## Infrastructure and Performance
 
 - [Prometheus Metrics](metrics.md)
+- [Speech Generation Performance Optimizations](qwen3_omni_tts_performance_optimization.md)
 
 ## Module Design Documents
 
-- [Entrypoints](module/entrypoints.md)
+- [Entrypoints and Serving Boundaries](module/entrypoints.md)
 - [vLLM-Omni Configuration](module/vllm_omni_config.md)
 - [Input, Output, and Modality Contracts](module/input_output_modality_contracts.md)
+- [Error Classification, Propagation, and Rendering](module/error_contracts.md)
 - [Engine Orchestration](module/engine_orchestration.md)
+- [Stage Runtime and Replica Lifecycle](module/stage_runtime.md)
 - [OmniConnector](module/omni_connector.md)
 - [Model Integration](module/model_integration.md)
 - [Autoregressive Runtime](module/ar_runtime.md)
@@ -40,3 +84,7 @@ This section contains design documents and architecture specifications for vLLM-
 - [Observability](module/observability.md)
 - [Profiling](module/profiling.md)
 - [Benchmarking](module/benchmarking.md)
+
+The pre-#5137 pages are preserved in the
+[legacy module archive](module/archive/README.md) for historical reference and
+are not active design contracts.
diff --git a/docs/design/metrics.md b/docs/design/metrics.md
index 09f0907df..6e4946f4e 100644
--- a/docs/design/metrics.md
+++ b/docs/design/metrics.md
@@ -148,7 +148,13 @@ Upstream vLLM's `Scheduler.make_stats()` runs on every AR generation step, retur
 
 `OmniSchedulerMixin.make_stats()` (in `vllm_omni/core/sched/omni_scheduler_mixin.py`) throttles stats emission to at most once per second **per scheduler** — i.e. per `(stage, replica)` since each replica owns its own scheduler instance. Between intervals it returns `None`, which the engine core skips serializing. This keeps gauges fresh enough for Prometheus scrapes (typically 15-30s intervals) while eliminating the per-step overhead.
 
-The orchestrator side does not add its own throttle on top: the per-replica recording loop gates only on `raw_outputs.scheduler_stats is not None` (i.e. this replica's scheduler passed its own 1 Hz gate). A previous global `_last_stats_ts` on the orchestrator was removed because it starved every replica other than the first to emit within each second.
+The orchestrator side does not add its own throttle on top. Scheduler gauges are
+recorded when `raw_outputs.scheduler_stats is not None` (i.e. this replica's
+scheduler passed its own 1 Hz gate), while output-batch request/token metrics
+are recorded from `IterationStats` whenever a non-empty output batch is
+processed. A previous global `_last_stats_ts` on the orchestrator was removed
+because it starved every replica other than the first to emit within each
+second.
 
 ## Metric Definitions
 
diff --git a/docs/design/module/archive/README.md b/docs/design/module/archive/README.md
new file mode 100644
index 000000000..6afc76947
--- /dev/null
+++ b/docs/design/module/archive/README.md
@@ -0,0 +1,18 @@
+# Archived module design pages
+
+This directory preserves module-design pages that predate the structure
+proposed in [issue #5137](https://github.com/vllm-project/vllm-omni/issues/5137).
+They are historical snapshots, not active architectural contracts, and are
+intentionally excluded from the documentation navigation.
+
+| Archived page | Active destination |
+| --- | --- |
+| [AR Module](ar_module.md) | [Autoregressive Runtime](../ar_runtime.md) |
+| [AsyncOmni Architecture](async_omni_architecture.md) | [Engine Orchestration](../engine_orchestration.md) and [Stage Runtime](../stage_runtime.md) |
+| [DiT Module](dit_module.md) | [Diffusion module overview](../diffusion/index.md) |
+| [Entrypoint Module](entrypoint_module.md) | [Entrypoints and Serving Boundaries](../entrypoints.md) |
+
+Do not update these pages with current design guidance. Move still-useful
+material into the active destination and review it against current code and
+tests instead. No compatibility redirect pages are provided at the former
+paths.
diff --git a/docs/design/module/archive/ar_module.md b/docs/design/module/archive/ar_module.md
new file mode 100644
index 000000000..f0085fa42
--- /dev/null
+++ b/docs/design/module/archive/ar_module.md
@@ -0,0 +1,387 @@
+# AutoRegressive (AR) Module
+
+## 1. Overview
+
+The AutoRegressive (AR) module in vLLM-Omni handles autoregressive generation stages, primarily used for text, chain-of-thought(COT), and audio latent tokens generation stages in multi-stage models like Qwen2.5-Omni, Qwen3-Omni, BAGEL, .etc. Unlike some representative non-autoregressive generation stages (e.g., Diffusion), AR stages generate tokens sequentially, one at a time, following the standard transformer decoder pattern.
+
+The AR module of vLLM-Omni extends vLLM's core components to support:
+
+- **Multimodal inputs/outputs**: Processing images, videos, and audio alongside text
+- **Direct embedding transfer**: Passing pre-computed prompt embeddings between pipeline stages via serialized payloads
+- **Additional information flow**: Carrying per-request metadata (tensors, lists) through the pipeline
+- **Hidden state exposure**: Exposing per-request hidden representations for downstream stages
+- **Basic generator support**: Support some basic heterogeneous architecture such as Convolution, LSTM, etc.
+
+As shown in the [end2end example](../../../user_guide/examples/offline_inference/qwen3_omni.md), AR module can be widely applied across multiple stages, generating text tokens in thinker(AR), audio latent tokens in talker(AR) and audio wave in code2wav(Convolution).
+
+## 2. Relationship with vLLM
+
+The AR module builds upon vLLM main framework through inheritance, extending core classes while preserving compatibility with vLLM's scheduling, batching, KV cache management, and execution mechanisms.
+
+### Inheritance Hierarchy
+- Scheduler
+
+```mermaid
+classDiagram
+    class VLLMScheduler {
+        +schedule() SchedulerOutput
+        +update_from_output() EngineCoreOutputs
+    }
+    class OmniARScheduler {
+        +schedule() SchedulerOutput
+    }
+    class OmniGenerationScheduler {
+        +schedule() SchedulerOutput
+        +update_from_output() EngineCoreOutputs
+    }
+    VLLMScheduler <|-- OmniARScheduler
+    VLLMScheduler <|-- OmniGenerationScheduler
+```
+- Worker
+
+```mermaid
+classDiagram
+    class GPUWorker {
+        +init_device()
+        +model_runner
+    }
+    class GPUARWorker {
+        +init_device()
+    }
+    class GPUGenerationWorker {
+        +init_device()
+    }
+    GPUWorker <|-- GPUARWorker
+    GPUWorker <|-- GPUGenerationWorker
+```
+- ModelRunner
+
+```mermaid
+classDiagram
+    class GPUModelRunner {
+        +execute_model()
+        +sample_tokens()
+    }
+    class OmniGPUModelRunner {
+        +_update_states()
+        +_preprocess()
+        +_model_forward()
+    }
+    class GPUARModelRunner {
+        +execute_model()
+        +sample_tokens()
+    }
+    class GPUGenerationModelRunner {
+        +execute_model()
+    }
+    GPUModelRunner <|-- OmniGPUModelRunner
+    OmniGPUModelRunner <|-- GPUARModelRunner
+    OmniGPUModelRunner <|-- GPUGenerationModelRunner
+```
+- InputProcessor/OutputProcessor
+
+```mermaid
+classDiagram
+    class InputProcessor {
+        +process_inputs() EngineCoreRequest
+    }
+
+    class VLLMOutputProcessor {
+        +process_outputs() OutputProcessorOutput
+    }
+    class MultimodalOutputProcessor {
+        +process_outputs() OutputProcessorOutput
+        +_route_and_normalize()
+    }
+    VLLMOutputProcessor <|-- MultimodalOutputProcessor
+```
+
+### Key Extensions
+
+- **Scheduler**: `OmniARScheduler` extends `vllm.v1.core.sched.scheduler.Scheduler` to enrich scheduled requests with omni-specific payloads
+- **Worker**: `GPUARWorker` extends `vllm.v1.worker.gpu_worker.Worker` to initialize AR-specific model runners
+- **ModelRunner**: `GPUARModelRunner` extends `OmniGPUModelRunner` → `vllm.v1.worker.gpu_model_runner.GPUModelRunner` to expose hidden states and handle multimodal outputs
+- **InputProcessor**: Stage-0 uses upstream `vllm.v1.engine.input_processor.InputProcessor`; `AsyncOmniEngine` then restores omni-specific payloads (for example `additional_information` and `prompt_embeds`) when building `OmniEngineCoreRequest`
+- **OutputProcessor**: `MultimodalOutputProcessor` extends `vllm.v1.engine.output_processor.OutputProcessor` to route and accumulate multimodal outputs
+
+## 3. Scheduler Design
+
+The AR module provides two scheduler implementations: one for standard autoregressive generation and one for basic heterogeneous architectures.
+
+### Request Flow
+
+The following diagram illustrates the request flow through the AR module components:
+
+```mermaid
+flowchart TD
+    A[InputProcessor stage-0 in AsyncOmniEngine] -->|EngineCoreRequest then upgraded to OmniEngineCoreRequest| B[OmniARScheduler]
+    B -->|schedule: OmniNewRequestData| C[GPUARWorker]
+    C -->|SchedulerOutput| D[GPUARModelRunner]
+    D -->|execute_model: None| E[Model Forward Pass]
+    E -->|hidden_states, logits| D
+    D -->|sample_tokens: OmniModelRunnerOutput| F[OmniARScheduler]
+    F -->|update_from_output| G[MultimodalOutputProcessor]
+    G -->|RequestOutput| H[Client/Downstream Stage]
+
+    style A fill:#e1f5ff
+    style B fill:#fff4e1
+    style C fill:#e8f5e9
+    style D fill:#f3e5f5
+    style G fill:#fce4ec
+```
+
+The flow follows vLLM's standard pattern: input processing → scheduling → worker execution → output processing, with omni-specific enrichments at each stage.
+
+### OmniARScheduler
+
+`OmniARScheduler` extends the base vLLM scheduler with minimal modifications, focusing on enriching scheduled requests with omni-specific payloads.
+
+#### Modified API: `schedule()`
+
+The scheduler wraps base `NewRequestData` entries with `OmniNewRequestData` to include prompt embeddings and additional information:
+
+```python
+def schedule(self) -> SchedulerOutput:
+    scheduler_output = super().schedule()
+    # Rewrap base NewRequestData entries with OmniNewRequestData
+    new_list = []
+    for nr in scheduler_output.scheduled_new_reqs:
+        request = self.requests.get(nr.req_id)
+        omni_nr = OmniNewRequestData(
+            req_id=nr.req_id,
+            prompt_token_ids=nr.prompt_token_ids,
+            # ... other base fields ...
+            prompt_embeds=getattr(request, "prompt_embeds", None),
+            additional_information=getattr(request, "additional_information", None),
+        )
+        new_list.append(omni_nr)
+    scheduler_output.scheduled_new_reqs = new_list
+    return scheduler_output
+```
+
+The `update_from_output()` method remains unchanged, inheriting standard request lifecycle management from the base scheduler.
+
+### OmniGenerationScheduler
+
+`OmniGenerationScheduler` implements a fast-path scheduling strategy for basic heterogeneous architectures that process all input tokens in a single step.
+
+#### Modified API: `schedule()`
+
+Allocates all input tokens for a request at once (or 1 placeholder if zero), falling back to default scheduling if budget is insufficient:
+
+```python
+def schedule(self) -> SchedulerOutput:
+    # Fast path: allocate all input tokens at once
+    while self.waiting and token_budget > 0:
+        request = self.waiting.peek_request()
+        required_tokens = max(getattr(request, "num_prompt_tokens", 0), 1)
+        if required_tokens > token_budget:
+            break  # Fall back to default scheduling
+        # Allocate and schedule...
+```
+
+#### Modified API: `update_from_output()`
+
+Marks requests as finished immediately after one step, since generation models complete in a single forward pass:
+
+```python
+def update_from_output(self, ...) -> dict[int, EngineCoreOutputs]:
+    # ...
+    # Diffusion request: completes in one step
+    request.status = RequestStatus.FINISHED_STOPPED
+    kv_transfer_params = self._free_request(request)
+    # ...
+```
+
+## 4. Worker and ModelRunner Design
+
+### GPUARWorker
+
+`GPUARWorker` initializes the AR-specific model runner while maintaining standard device initialization:
+
+```python
+class GPUARWorker(GPUWorker):
+    def init_device(self):
+        # ... standard device initialization ...
+        self.model_runner = GPUARModelRunner(self.vllm_config, self.device)
+```
+
+### GPUARModelRunner
+
+`GPUARModelRunner` follows vLLM's two-phase execute/sample flow while exposing hidden states and multimodal outputs.
+
+#### Two-Phase Execution
+
+**Phase 1: `execute_model()`** - Runs forward pass and stores state:
+- Computes logits from hidden states
+- Stores `ExecuteModelState` with hidden states, logits, and multimodal outputs
+- Returns `None` to defer sampling
+
+**Phase 2: `sample_tokens()`** - Samples tokens and builds output:
+- Retrieves stored state from `execute_model()`
+- Samples tokens using logits
+- Extracts per-request hidden states and multimodal outputs
+- Builds `OmniModelRunnerOutput` with `pooler_output` containing hidden states
+
+```python
+def sample_tokens(self, grammar_output) -> OmniModelRunnerOutput:
+    # Retrieve stored state
+    hidden_states, multimodal_outputs = self.execute_model_state
+
+    # Sample tokens
+    sampler_output = self._sample(logits, spec_decode_metadata)
+
+    # Extract per-request hidden states
+    pooler_output = []
+    for rid in req_ids:
+        hidden_slice = hidden_states_cpu[start:end]
+        payload = {"hidden": hidden_slice}
+        # Add multimodal outputs if present
+        pooler_output.append(payload)
+
+    return OmniModelRunnerOutput(
+        pooler_output=pooler_output,
+        # ... other fields ...
+    )
+```
+
+### GPUGenerationModelRunner
+
+`GPUGenerationModelRunner` implements a simplified single-phase execution for basic heterogeneous architectures:
+
+- No logits computation or token sampling
+- Direct generation from forward pass in model implementation
+- Returns outputs via `pooler_output` immediately after forward pass
+
+### OmniGPUModelRunner
+
+`OmniGPUModelRunner` provides shared functionality for both AR and Generation runners:
+
+#### Prompt Embeddings Overlay
+
+During prefill, overlays custom `prompt_embeds` from request state onto `inputs_embeds`:
+
+```python
+def _collect_additional_information_for_prefill(self, num_scheduled_tokens_np):
+    for req_index, req_id in enumerate(self.input_batch.req_ids):
+        req_state = self.requests[req_id]
+        pe_cpu = getattr(req_state, "prompt_embeds_cpu", None)
+        # Overlay prompt_embeds for prefill portion
+        if pe_cpu is not None:
+            src = pe_cpu[num_computed_tokens:num_computed_tokens + overlay_len]
+            self.inputs_embeds[start_offset:start_offset + overlay_len].copy_(src)
+```
+
+#### Additional Information Processing
+
+Decodes and manages `additional_information` payloads:
+- Decodes serialized payloads → CPU tensors in request state
+- Passes runtime information to model via `runtime_additional_information` kwarg
+- Processes model-provided updates via `postprocess()` hook
+- Merges updates back into request state
+
+#### M-RoPE Position Initialization
+
+For multimodal models using M-RoPE (e.g., Qwen2-VL), computes position encodings from multimodal feature metadata (image grids, video grids, audio features).
+
+## 5. Input/Output Processing
+
+### Processing Pipeline
+
+The input/output processing pipeline handles serialization, routing, and accumulation of multimodal data:
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant AsyncOmniEngine
+    participant InputProcessor
+    participant Scheduler
+    participant ModelRunner
+    participant MultimodalOutputProcessor
+    participant Client
+
+    Client->>AsyncOmniEngine: prompt + prompt_embeds + additional_info
+    AsyncOmniEngine->>InputProcessor: process_inputs()
+    InputProcessor->>Scheduler: EngineCoreRequest
+    AsyncOmniEngine->>AsyncOmniEngine: _upgrade_to_omni_request() + serialize_additional_information()
+    Scheduler->>ModelRunner: OmniNewRequestData (with payloads)
+    ModelRunner->>ModelRunner: Decode payloads → CPU tensors
+    ModelRunner->>ModelRunner: Overlay prompt_embeds on inputs_embeds
+    ModelRunner->>ModelRunner: Forward pass with runtime_additional_information
+    ModelRunner->>ModelRunner: Extract hidden states + multimodal outputs
+    ModelRunner->>MultimodalOutputProcessor: OmniModelRunnerOutput (pooler_output)
+    MultimodalOutputProcessor->>MultimodalOutputProcessor: Route by output_type
+    MultimodalOutputProcessor->>MultimodalOutputProcessor: Accumulate tensors in OmniRequestState
+    MultimodalOutputProcessor->>MultimodalOutputProcessor: Consolidate tensor lists
+    MultimodalOutputProcessor->>Client: RequestOutput (with multimodal_output)
+```
+
+### Stage-0 Input Processing
+
+Stage-0 now uses upstream `InputProcessor` directly, and `AsyncOmniEngine` upgrades the request to `OmniEngineCoreRequest` while restoring omni-specific payloads.
+
+```python
+request = self.input_processor.process_inputs(
+    request_id=request_id,
+    prompt=prompt,
+    params=params,
+    supported_tasks=self.supported_tasks,
+)
+request = _upgrade_to_omni_request(request, prompt)
+```
+
+### MultimodalOutputProcessor
+
+`MultimodalOutputProcessor` routes outputs by modality type and accumulates multimodal tensors.
+
+#### Output Routing
+
+Routes `EngineCoreOutput` by `output_type` attribute:
+- `"text"`: Standard text generation path
+- `"image"`, `"audio"`, `"latents"`: Extract from `pooling_output` or `multimodal_outputs`
+- Fallback: Heuristic based on presence of `pooling_output`
+
+#### Tensor Accumulation
+
+`OmniRequestState` accumulates multimodal tensors across multiple steps:
+
+```python
+def add_multimodal_tensor(self, payload, mm_type):
+    # Normalize payload to dict
+    incoming = {mm_type or "hidden": payload}
+
+    # Accumulate: convert tensors to lists for deferred concatenation
+    if isinstance(v, torch.Tensor) and isinstance(existing, torch.Tensor):
+        self.mm_accumulated[k] = [existing, v]  # List accumulation
+```
+
+Before final output, consolidates tensor lists via concatenation:
+
+```python
+def _consolidate_multimodal_tensors(self):
+    for k, v in self.mm_accumulated.items():
+        if isinstance(v, list) and isinstance(v[0], torch.Tensor):
+            self.mm_accumulated[k] = torch.cat(v, dim=0)  # Concatenate
+```
+
+The consolidated tensors are attached to `RequestOutput.multimodal_output` for consumption by downstream stages or clients.
+
+## 6. Summary
+
+The AR module of vLLM-Omni extends vLLM through strategic inheritance and minimal API modifications:
+
+### Key Design Patterns
+
+1. **Inheritance over composition**: Extends vLLM classes to preserve compatibility with existing scheduling, batching, and execution mechanisms
+2. **Payload serialization**: Uses serialized `additional_information` payloads together with prompt-embedding handoff for efficient inter-stage transfer
+3. **Two-phase execution**: Maintains vLLM's execute/sample separation for AR models while supporting single-phase execution for generation models
+4. **Multimodal routing**: Routes outputs by `output_type` and accumulates tensors incrementally to support streaming
+
+### Differences from vLLM
+
+- **Payload support**: Serialized additional information and prompt embeddings enable direct transfer between pipeline stages
+- **Multimodal handling**: Extended input/output processors support images, audio, and other modalities alongside text
+- **Hidden state exposure**: AR model runners expose per-request hidden states via `pooler_output` for downstream consumption
+- **Generation scheduler**: Fast-path scheduling for basic heterogeneous architectures that complete in one step
+
+The AR module seamlessly integrates with vLLM's existing infrastructure while adding the necessary extensions for multi-stage, multimodal generation pipelines.
diff --git a/docs/design/module/archive/async_omni_architecture.md b/docs/design/module/archive/async_omni_architecture.md
new file mode 100644
index 000000000..92b13a3da
--- /dev/null
+++ b/docs/design/module/archive/async_omni_architecture.md
@@ -0,0 +1,203 @@
+# AsyncOmni Architecture (Qwen3-Omni Example)
+
+## 1. System Architecture
+
+```text
+• ┌─────────────────────────────────────────────────────────────────────────────────┐
+  │                                    API Layer                                    │
+  │  ┌─────────────────────────────────────┐  ┌──────────────────────────────────┐  │
+  │  │ AsyncOmni (EngineClient)            │  │ Omni                             │  │
+  │  │ • generate() / abort() / shutdown() │  │ • generate()                     │  │
+  │  │ • _final_output_handler()           │  │                                  |  │
+  │  └─────────────────────────────────────┘  └──────────────────────────────────┘  │
+  ├─────────────────────────────────────────────────────────────────────────────────┤
+  │                              Engine Layer (Proxy)                               │
+  │  ┌───────────────────────────────────────────────────────────────────────────┐  │
+  │  │ AsyncOmniEngine                                                           │  │
+  │  │ • _bootstrap_orchestrator() & _initialize_stages()                        │  │
+  │  │ • add_request() / add_request_async() -> input_processor.process_inputs() │  │
+  │  │ • try_get_output() / try_get_output_async()                               │  │
+  │  └───────────────────┬─────────────────────────────────▲─────────────────────┘  │
+  │         request_queue (janus.Queue)        output_queue (janus.Queue)           │
+  ├──────────────────────┼─────────────────────────────────┼────────────────────────┤
+  │                      ▼        Orchestration Layer      │                        │
+  │  ┌───────────────────────────────────────────────────────────────────────────┐  │
+  │  │ Orchestrator [background thread]                                          │  │
+  │  │ • _request_handler()                                                      │  │
+  │  │     -  stage_client.add_request_async() & _prewarm_async_chunk_stages()   │  │
+  │  │ • _orchestration_output_handler()                                         │  │
+  │  │     -  _process_stage_outputs() -> output_processors[i].process_outputs() │  │
+  │  │     -  _route_output() & _forward_to_next_stage()                         │  │
+  │  └──────────┬─────────────────────────┬────────────────────────┬─────────────┘  │
+  ├─────────────┼─────────────────────────┼────────────────────────┼────────────────┤
+  │             │                 Communication Layer              │                │
+  │  ┌───────────────────────┐ ┌───────────────────────┐ ┌───────────────────────┐  │
+  │  │ StageEngineCoreClient │ │ StageEngineCoreClient │ │ StageDiffusionClient  │  │
+  │  │ • ZMQ ROUTER / PULL   │ │ • ZMQ ROUTER / PULL   │ │ • ZMQ ROUTER / PULL   │  │
+  │  │ • Msgpack codec       │ │ • Msgpack codec       │ │ • Msgpack codec       │  │
+  │  └──────────┬────────────┘ └──────────┬────────────┘ └──────────┬────────────┘  │
+  │             ▼ ZMQ IPC                 ▼ ZMQ IPC                 ▼ ZMQ IPC       │
+  ├─────────────────────────────────────────────────────────────────────────────────┤
+  │                                 Execution Layer                                 │
+  │  ┌───────────────────────┐ ┌───────────────────────┐ ┌───────────────────────┐  │
+  │  │ StageCoreProc         │ │ StageCoreProc         │ │ DiffusionEngine       │  │
+  │  │ [background process]  │ │ [background process]  │ │ [background process]  │  │
+  │  └───────────────────────┘ └───────────────────────┘ └───────────────────────┘  │
+  └─────────────────────────────────────────────────────────────────────────────────┘
+```
+
+## 2. Execution Flow (Arrow Steps, one generate request)
+
+```text
+[1] App
+    -> AsyncOmni.generate(prompt, request_id)
+
+[2] AsyncOmni
+    -> _final_output_handler()   (started on first request)
+    -> AsyncOmniEngine.add_request(stage_id=0, ...)
+
+[3] AsyncOmniEngine.add_request
+    -> (if stage-0 is llm and input is not EngineCoreRequest)
+       InputProcessor.process_inputs()
+       OutputProcessor[0].add_request()
+    -> request_queue.put(add_request_msg)
+
+[4] Orchestrator._request_handler
+    -> _handle_add_request(msg)
+    -> stage_clients[0].add_request_async(...)
+
+[5] Orchestrator._orchestration_loop (loop)
+    -> poll stage output
+       - llm stage: await get_output_async()
+       - diffusion stage: get_diffusion_output_nowait()
+    -> (llm stage) output_processors[i].process_outputs(...)
+    -> _route_output(...)
+    -> if finished and not final_stage and non-async-chunk:
+         _forward_to_next_stage(...)
+         -> next_stage.add_request_async(...)
+    -> output_queue.put(output)
+
+[6] AsyncOmni._final_output_loop (background coroutine)
+    -> AsyncOmniEngine.try_get_output_async()
+    -> route by request_id to ClientRequestState.queue
+
+[7] AsyncOmni._process_orchestrator_results
+    -> read from ClientRequestState.queue
+    -> _process_single_result(...)
+    -> yield OmniRequestOutput
+
+[8] Exit condition
+    -> receive result["finished"] == True
+    -> generate() ends
+```
+
+## 3. Runtime Sequence (one generate request)
+
+```mermaid
+sequenceDiagram
+    participant APP as App
+    participant AO as AsyncOmni
+    participant ENG as AsyncOmniEngine
+    participant ORCH as Orchestrator
+    participant S0 as Stage-0 Client
+    participant SN as Next Stage Client
+
+    APP->>AO: generate
+    AO->>AO: start output_handler once
+    AO->>ENG: add_request(stage_id=0, ...)
+    ENG->>ENG: input_processor.process_inputs()
+    ENG->>ORCH: request_queue.put(add_request)
+
+    ORCH->>ORCH: _handle_add_request
+    ORCH->>S0: add_request_async
+
+    loop poll route forward
+        ORCH->>S0: get_output_async / get_diffusion_output_nowait
+        ORCH->>ORCH: _route_output
+        alt need forward to next stage
+            ORCH->>SN: add_request_async
+        end
+        ORCH-->>ENG: output_queue.put
+    end
+
+    AO->>ENG: try_get_output_async
+    ENG-->>AO: message
+    AO-->>APP: yield OmniRequestOutput
+```
+
+## 4. Comparison
+
+Previous topology (reference):
+
+```text
+┌────────────────────────────────────────────────────────────────────────────┐
+│ Main Process                                                               │
+│  ┌──────────────────────┐   ┌────────────────────────────────────────────┐ │
+│  │ generate()           │   │ final_output_handler()                     │ │
+│  └──────────────────────┘   └────────────────────────────────────────────┘ │
+└──────────┬─────────────────────────┬─────────────────────────┬─────────────┘
+  mp.Queue (in_q/out_q)    mp.Queue (in_q/out_q)    mp.Queue (in_q/out_q)
+           ▼▲                        ▼▲                        ▼▲
+┌───────────────────────┐  ┌───────────────────────┐  ┌──────────────────────┐
+│ Worker Proc-0         │  │ Worker Proc-1         │  │ Worker Proc-2        │
+│ (Thinker LLM)         │  │ (Talker LLM)          │  │ (Vocoder)            │
+│  ┌────────────────┐   │  │  ┌────────────────┐   │  │  ┌────────────────┐  │
+│  │_stage_worker   │   │  │  │_stage_worker   │   │  │  │_stage_worker   │  │
+│  │_async()        │   │  │  │_async()        │   │  │  │_async()        │  │
+│  └────────────────┘   │  │  └────────────────┘   │  │  └────────────────┘  │
+│  ┌────────────────┐   │  │  ┌────────────────┐   │  │  ┌────────────────┐  │
+│  │output_handler()│   │  │  │output_handler()│   │  │  │output_handler()│  │
+│  └────────────────┘   │  │  └────────────────┘   │  │  └────────────────┘  │
+└──────────┬────────────┘  └──────────┬────────────┘  └──────────┬───────────┘
+       ZMQ ▼ ▲ ZMQ               ZMQ ▼ ▲ ZMQ               ZMQ ▼ ▲ ZMQ
+┌──────────────────────┐   ┌──────────────────────┐   ┌──────────────────────┐
+│ EngineCore Proc-0    │   │ EngineCore Proc-1    │   │ EngineCore Proc-2    │
+│ (Thinker)            │   │ (Talker)             │   │ (Vocoder)            │
+└──────────────────────┘   └──────────────────────┘   └──────────────────────┘
+```
+
+Current topology:
+
+```text
+┌────────────────────────────────────────────────────────────────────────────┐
+│ Main Process                                                               │
+│  ┌──────────────────────────────────────────────────────────────────────┐  │
+│  │ Main Thread                                                          │  │
+│  │  ┌──────────────────────┐   ┌─────────────────────────────────────┐  │  │
+│  │  │ generate()           │   │ final_output_handler()              │  │  │
+│  │  └──────────────────────┘   └─────────────────────────────────────┘  │  │
+│  └──────────────────────────────────────────────────────────────────────┘  │
+│         janus.Queue (request_queue) ▼  ▲ janus.Queue (output_queue)        │
+│  ┌──────────────────────────────────────────────────────────────────────┐  │
+│  │ Orchestrator Thread                                                  │  │
+│  │  ┌──────────────────────┐  ┌──────────────────────────────────────┐  │  │
+│  │  │ _request_handler()   │  │ _orchestration_output_handler()      │  │  │
+│  │  └──────────────────────┘  └──────────────────────────────────────┘  │  │
+│  │  ┌────────────────────────────────────────────────────────────────┐  │  │
+│  │  │ _orchestration_loop(): poll/process/route outputs for all stages│  │  │
+│  │  └────────────────────────────────────────────────────────────────┘  │  │
+│  └───────┬─────────────────────────┬─────────────────────────┬──────────┘  │
+└──────────┬─────────────────────────┬─────────────────────────┬─────────────┘
+       ZMQ ▼ ▲ ZMQ               ZMQ ▼ ▲ ZMQ               ZMQ ▼ ▲ ZMQ  
+  ┌──────────────────────┐  ┌──────────────────────┐  ┌──────────────────────┐
+  │ EngineCore Proc-0    │  │ EngineCore Proc-1    │  │ EngineCore Proc-2    │
+  │ (Thinker)            │  │ (Talker)             │  │ (Vocoder)            │
+  └──────────────────────┘  └──────────────────────┘  └──────────────────────┘
+```
+
+
+Test scripts:
+```bash
+# enter offline inference folder.
+cd examples/offline_inference/qwen2_5_omni
+python end2end.py --output-dir output_audio --query-type use_mixed_modalities
+
+cd ../qwen3_omni
+python end2end.py --output-dir output_audio --query-type text --async-chunk --enable-stats
+
+cd ../bagel
+python end2end.py --prompts "A cute cat"
+
+cd ../text_to_image
+python text_to_image.py --prompt "a cup of coffee on the table" --output output.png
+```
diff --git a/docs/design/module/archive/dit_module.md b/docs/design/module/archive/dit_module.md
new file mode 100644
index 000000000..f505d1e67
--- /dev/null
+++ b/docs/design/module/archive/dit_module.md
@@ -0,0 +1,978 @@
+---
+toc_depth: 4
+---
+
+# Diffusion Module Architecture Design
+
+The vLLM-Omni diffusion module (`vllm_omni/diffusion`) is a high-performance inference engine for diffusion models, designed with a modular architecture that separates concerns across multiple components. It provides efficient execution for non-autoregressive generation tasks such as image and video generation.
+
+This document describes the architecture design of the diffusion module, including the diffusion engine, scheduler, worker, diffusion pipeline, and acceleration components.
+
+<p align="center">
+   <img src="https://github.com/user-attachments/assets/cde1ebea-4006-4d30-8283-15a5721a09d2" alt="vLLM-Omni Diffusion Module Components" width="80%">
+</p>
+<p align="center">
+  <em> Main Components of the Diffusion Module </em>
+</p>
+
+
+**Table of Content:**
+
+- [Architecture Overview](#architecture-overview)
+- [Diffusion Engine](#1-diffusion-engine)
+- [Scheduler](#2-scheduler)
+- [Worker](#3-worker)
+- [Diffusion Pipeline](#4-diffusion-pipeline)
+- [Acceleration Components](#5-acceleration-components)
+    - [Attention Backends](#51-attention-backends)
+    - [Parallel Attention](#52-parallel-attention)
+    - [Cache Backends](#53-cache-backends)
+    - [Parallel Strategies](#54-parallel-strategies)
+- [Data Flow](#6-data-flow)
+
+---
+
+## Architecture Overview
+
+The diffusion module follows a **multi-process, distributed architecture** with clear separation of concerns:
+
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/78c4d446-d238-4406-a057-eb17d2ccc8e0" alt="vLLM-Omni Diffusion Module Architecture" width="100%">
+</p>
+<p align="center">
+  <em> Diffusion Architecture Overview </em>
+</p>
+
+
+---
+
+## 1. Diffusion Engine
+
+**Location**: `vllm_omni/diffusion/diffusion_engine.py`
+
+### Responsibilities
+
+The `DiffusionEngine` is the **orchestrator** of the diffusion inference system. It owns request admission, scheduler/executor coordination, output-stream delivery, cancellation cleanup, and startup warmup.
+
+### Key Components
+
+#### 1.1 Initialization
+
+```python
+class DiffusionEngine:
+    def __init__(
+        self,
+        od_config: OmniDiffusionConfig,
+        scheduler: SchedulerInterface | None = None,
+    ):
+        self.od_config = od_config
+        self._init_process_hooks(od_config)
+        self.execution_mode = self._resolve_execution_mode(od_config)
+        self._init_executor(od_config)
+        self._init_scheduler(od_config, scheduler)
+        self._init_runtime_state()
+        self._init_execute_fn()
+```
+
+**Key Features**:
+
+- **Pre/Post Processing**: Registers model-specific pre-processing and post-processing functions via registry pattern
+
+- **Execution Mode Selection**: Selects one of two execution modes:
+  - `REQUEST_BATCH`: complete requests are scheduled through request-level execution. `max_num_seqs=1` is the serial request path; values above `1` allow compatible requests to use fused `pipeline.forward(batch)` when the pipeline supports it.
+  - `STEP_BATCH`: requests are advanced one denoising step at a time through `prepare_encode()`, `denoise_step()`, `step_scheduler()`, and `post_decode()`. `max_num_seqs` controls the maximum number of compatible active requests in one step wave.
+
+- **Scheduler Selection**: Uses `StepScheduler` for step-batch execution and `RequestScheduler` for request-batch execution. Tests and custom integrations may inject a `SchedulerInterface` instance explicitly.
+
+- **Executor Selection**: Builds the configured `DiffusionExecutor`, then routes scheduled work through `execute_batch` or `execute_step` according to the execution mode. `execute_batch` handles the serial `max_num_seqs=1` request path internally.
+
+- **Factory-Owned Warmup**: `DiffusionEngine.make_engine()` constructs the selected engine backend and then runs startup warmup through `run_startup_warmup()`.
+
+#### 1.2 Execution Modes
+
+```python
+class DiffusionExecutionMode(str, Enum):
+    REQUEST_BATCH = "request_batch"
+    STEP_BATCH = "step_batch"
+```
+
+`streaming_output=True` requires step execution. If streaming is enabled without `step_execution=True`, the engine enables step execution so the output stream can receive intermediate chunks or the final step output.
+
+#### 1.3 Output Stream Lifecycle
+
+```python
+request_id = engine.add_request(request)
+async for output in engine.get_output_stream(request_id):
+    yield output
+```
+
+**Design Decisions**:
+
+- **Unified Stream Semantics**: `step_streaming()` is the public async engine path. Streaming callers forward every yielded output. Non-streaming callers consume the same stream to completion and return only the final output.
+
+- **Queue Delivery**: Each admitted request gets an `asyncio.Queue[DiffusionOutput]`. The busy loop emits chunks/final outputs into that queue.
+
+- **Cancellation Cleanup**: If a client disconnects or cancels stream consumption, `get_output_stream()` removes only the queue. Scheduler terminal state is still finalized when the scheduler reports the request as finished, so request IDs do not remain active indefinitely.
+
+#### 1.4 Request Processing Flow
+
+```python
+async def step_streaming(self, request: OmniDiffusionRequest):
+    # 1. Pre-process requests
+    request = self.pre_process_func(request)
+
+    # 2. Add request and consume the unified output stream
+    async for output in self.async_add_req_and_stream_response(request):
+        # 3. Post-process each delivered output
+        yield self.postprocess_output(request, output, ...)
+```
+
+**Flow**:
+
+1. **Pre-processing**: Applies model-specific transformations
+
+2. **Scheduling**: Delegates request state transitions to the selected scheduler
+
+3. **Execution**: Calls the selected executor function for request, request-batch, or step execution
+
+4. **Output Delivery**: Emits intermediate chunks and final outputs through the request output stream
+
+5. **Post-processing**: Converts raw outputs to final format (e.g., PIL images)
+
+---
+
+## 2. Scheduler
+
+**Location**: `vllm_omni/diffusion/sched/`
+
+### Architecture
+
+The scheduler is a **request-state scheduler**. It owns request lifecycle management and scheduling decisions, while execution stays in `DiffusionEngine` and the executor.
+
+### Key Components
+
+#### 2.1 Request State Model
+
+```python
+class DiffusionRequestStatus(enum.IntEnum):
+    WAITING = ...
+    RUNNING = ...
+    PREEMPTED = ...
+    FINISHED_COMPLETED = ...
+    FINISHED_ABORTED = ...
+    FINISHED_ERROR = ...
+
+@dataclass
+class SchedulerRequestState:
+    request_id: str
+    req: OmniDiffusionRequest
+    sampling_params_key: StepBatchSamplingParamsKey | RequestBatchSamplingParamsKey | None = None
+    status: DiffusionRequestStatus = DiffusionRequestStatus.WAITING
+    error: str | None = None
+```
+
+**Design Features**:
+
+- **Explicit lifecycle**: Requests move through waiting, running, optional preemption, and terminal states.
+
+- **Centralized error handling**: Completion, abort, and error states are all normalized in the scheduler layer.
+
+#### 2.2 Shared Bookkeeping in `BaseScheduler`
+
+```python
+class BaseScheduler:
+    def __init__(self) -> None:
+        self._request_states = {}
+        self._waiting = deque()
+        self._running = []
+        self._finished_req_ids = set()
+        self.max_num_running_reqs = 1
+
+    def add_request(self, request: OmniDiffusionRequest) -> str: ...
+    def schedule(self) -> DiffusionSchedulerOutput: ...
+    def update_from_output(
+        self,
+        sched_output: DiffusionSchedulerOutput,
+        output: BaseRunnerOutput,
+    ) -> set[str]: ...
+```
+
+**Responsibilities**:
+
+- **Lifecycle contract**: Defines how the engine adds requests, triggers one scheduling cycle, and feeds executor results back.
+
+- **Stable boundary**: `DiffusionSchedulerOutput` is the only scheduling result consumed by `DiffusionEngine`.
+
+- **Pluggability**: Different scheduler policies can reuse the same engine integration path.
+
+**Design Features**:
+
+- **Common state storage**: Shared request maps and waiting/running sets live in the base class.
+
+- **Shared cleanup logic**: Duplicate-request checks, finish handling, and state removal are centralized instead of
+  duplicated in each policy.
+
+- **Current constraint boundary**: `BaseScheduler` derives `max_num_running_reqs` from `max_num_seqs`. Request-mode diffusion can use that capacity for compatible independent requests when the configured pipeline declares `supports_request_batch = True`; step-wise diffusion uses the same scheduler capacity for compatible step batches.
+
+#### 2.3 Current `RequestScheduler` Policy
+
+```python
+class RequestScheduler(BaseScheduler):
+    def schedule(self) -> DiffusionSchedulerOutput:
+        # 1. keep existing RUNNING requests in the scheduling result
+        # 2. pull WAITING requests while capacity remains
+        # 3. move newly admitted requests into RUNNING
+```
+
+**Behavior**:
+
+- **FIFO request scheduling**: Waiting requests are promoted in queue order.
+
+- **Compatible request admission**: `RequestScheduler` admits waiting requests while capacity remains and the request's `RequestBatchSamplingParamsKey` is compatible with the active batch. Request-mode execution keeps each logical request independent, while batch-capable pipelines receive the scheduled requests as a runner-side `DiffusionRequestBatch`.
+
+- **Executor result feedback**: `update_from_output()` converts executor output into `FINISHED_COMPLETED` or `FINISHED_ERROR` and returns finished request ids.
+
+#### 2.4 Engine-Driven Execution Loop
+
+```python
+request_id = scheduler.add_request(request)
+while True:
+    sched_output = scheduler.schedule()
+    output = executor.add_req(req)
+    finished_req_ids = scheduler.update_from_output(sched_output, output)
+```
+
+**Design Decisions**:
+
+- **Separation of concerns**: Scheduler manages state and policy; executor handles runtime execution.
+
+- **No scheduler-owned IPC**: Scheduler no longer talks to workers directly.
+
+- **Split concurrency model**: Request-mode diffusion can schedule a static
+  batch of compatible independent requests for one full pipeline forward when
+  the pipeline supports request-level batching; the step-wise path can also
+  admit or remove compatible requests between denoise steps. See
+  [Diffusion Continuous Batching](../../feature/diffusion_continuous_batching.md).
+
+---
+
+## 3. Worker
+
+**Location**: `vllm_omni/diffusion/worker/gpu_worker.py`
+
+### Architecture
+
+Workers are **independent processes** that execute the actual model inference. Each worker runs on a dedicated GPU and participates in distributed inference.
+
+### Key Components
+
+#### 3.1 Worker Process Structure
+
+```python
+class WorkerProc:
+    def __init__(self, od_config, gpu_id, broadcast_handle):
+        # Initialize ZMQ context for IPC
+        self.context = zmq.Context(io_threads=2)
+
+        # Connect to broadcast queue (receive requests)
+        self.mq = MessageQueue.create_from_handle(broadcast_handle, gpu_id)
+
+        # Create result queue (only rank 0)
+        if gpu_id == 0:
+            self.result_mq = MessageQueue(n_reader=1, ...)
+
+        # Initialize GPU worker
+        self.worker = self._create_worker(gpu_id, od_config, ...)
+```
+
+**Initialization Steps**:
+
+1. **IPC Setup**: Creates ZMQ context and message queues
+
+2. **Distributed Environment Setup**: Initializes PyTorch distributed communication
+
+    - For CUDA GPUs: Uses NCCL (fast GPU communication)
+
+    - For NPU: Uses HCCL (Huawei Collective Communications Library)
+
+    - For other devices: Uses appropriate backend (GLOO, MCCL, etc.)
+
+3. **Model Loading**: Loads diffusion pipeline on assigned GPU
+
+4. **Cache Setup**: Enables cache backend if configured.
+
+#### 3.2 GPU Worker
+
+```python
+class DiffusionWorker:
+    def init_device(self):
+        # Set distributed environment variables
+        os.environ["RANK"] = str(rank)
+        os.environ["WORLD_SIZE"] = str(world_size)
+
+        # Select the device and initialize distributed execution
+        self.device = current_omni_platform.get_torch_device(rank)
+        current_omni_platform.set_device(self.device)
+        self.vllm_config = _create_diffusion_worker_vllm_config(
+            self.device, self.od_config
+        )
+        init_distributed_environment(world_size, rank)
+        parallel_config = self.od_config.parallel_config
+        initialize_model_parallel(
+            data_parallel_size=parallel_config.data_parallel_size,
+            cfg_parallel_size=parallel_config.cfg_parallel_size,
+            sequence_parallel_size=parallel_config.sequence_parallel_size,
+            tensor_parallel_size=parallel_config.tensor_parallel_size,
+            pipeline_parallel_size=parallel_config.pipeline_parallel_size,
+        )
+
+    def load_model(self, load_format="default", custom_pipeline_name=None):
+        self.model_runner.load_model(
+            load_format=load_format,
+            custom_pipeline_name=custom_pipeline_name,
+        )
+
+    def init_lora_manager(self):
+        self.lora_manager = DiffusionLoRAManager(
+            pipeline=self.model_runner.pipeline,
+            device=self.device,
+            dtype=self.od_config.dtype,
+        )
+```
+
+**Key Features**:
+
+- **Tensor Parallelism**: Supports multi-GPU tensor parallelism via PyTorch distributed
+
+- **Model Loading**: Uses `DiffusersPipelineLoader` for efficient weight loading
+
+- **Cache Integration**: Enables cache backends (TeaCache, cache-dit, etc.) transparently
+
+#### 3.3 Worker Busy Loop
+
+```python
+def _worker_busy_loop(self):
+    while self._running:
+        # 1. Receive unified message (generation request, RPC request, or shutdown)
+        msg = self.mq.dequeue(timeout=1.0)
+
+        # 2. Route message based on type
+        if isinstance(msg, dict) and msg.get("type") == "rpc":
+            # Handle RPC request
+            result, should_reply = self._execute_rpc(msg)
+            if should_reply:
+                self._return_result(result)
+
+        elif isinstance(msg, dict) and msg.get("type") == "shutdown":
+            # Handle shutdown message
+            self._running = False
+
+        else:
+            # Handle generation request (OmniDiffusionRequest list)
+            output = self.worker.execute_model(msg, self.od_config)
+            self._return_result(output)
+```
+
+**Execution Flow**:
+
+1. **Receive**: Dequeues unified messages from shared memory queue
+
+2. **Route**: Handles different message types (generation, RPC, shutdown)
+
+3. **Execute**: Runs forward pass through pipeline for generation requests
+
+4. **Respond**: Sends results back (rank 0 for generation, specified rank for RPC)
+
+#### 3.4 Model Execution
+
+```python
+@torch.inference_mode()
+def execute_model(self, reqs: list[OmniDiffusionRequest], od_config):
+    req = reqs[0]  # TODO: support batching
+
+    # Refresh cache backend if enabled
+    if self.cache_backend is not None and self.cache_backend.is_enabled():
+        self.cache_backend.refresh(self.pipeline, req.num_inference_steps)
+
+    # Set forward context for parallelism
+    with set_forward_context(
+        vllm_config=self.vllm_config,
+        omni_diffusion_config=self.od_config
+    ):
+        output = self.pipeline.forward(req)
+    return output
+```
+
+The model execution leverages multiple parallelism strategies that are transparently applied during the forward pass. The `set_forward_context()` context manager makes parallel group information available throughout the forward pass:
+
+```python
+# Inside transformer layers, parallel groups are accessed via:
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_sp_group, get_dp_group, get_cfg_group, get_pp_group
+)
+```
+
+**Optimizations**:
+
+- **Cache Refresh**: Clears cache state before each generation for clean state
+
+- **Context Management**: Forward context ensures parallel groups are available during execution
+
+- **Single Request**: Currently processes one request at a time (batching TODO)
+
+---
+
+## 4. Diffusion Pipeline
+
+**Location**: `vllm_omni/diffusion/models/*/pipeline_*.py`
+
+The pipeline is the **model-specific implementation** that orchestrates the diffusion process. Different models (QwenImage, Wan2.2, Z-Image) have their own pipeline implementations.
+
+Most pipeline implementation are referred from `diffusers`. The multi-step diffusion loop is usually the most time-consuming part during the overall inference process, which is defined by the `diffuse` function in the pipeline class. An example is as follows:
+
+```python
+def diffuse(self, ...):
+    for i, t in enumerate(timesteps):
+        # Forward pass for positive prompt
+        transformer_kwargs = {
+            "hidden_states": latents,
+            "timestep": timestep / 1000,
+            "encoder_hidden_states": prompt_embeds,
+        }
+        noise_pred = self.transformer(**transformer_kwargs)[0]
+
+        # Forward pass for negative prompt (CFG)
+        if do_true_cfg:
+            neg_transformer_kwargs = {...}
+            neg_transformer_kwargs["cache_branch"] = "negative"
+            neg_noise_pred = self.transformer(**neg_transformer_kwargs)[0]
+
+            # Combine predictions
+            comb_pred = neg_noise_pred + true_cfg_scale * (noise_pred - neg_noise_pred)
+            noise_pred = comb_pred * (cond_norm / noise_norm)
+
+        # Scheduler step
+        latents = self.scheduler.step(noise_pred, t, latents)[0]
+
+    return latents
+```
+
+**Key Features**:
+
+- **CFG Support**: Handles classifier-free guidance with separate forward passes
+
+- **Cache Branching**: Uses `cache_branch` parameter for cache-aware execution
+
+- **True CFG**: Implements advanced CFG with norm preservation
+
+To learn more about the diffusion pipeline and how to add a new diffusion pipeline, please view [Adding Diffusion Model](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/model/adding_diffusion_model)
+
+---
+
+## 5. Acceleration Components
+
+### 5.1 Attention Backends
+
+**Location**: `vllm_omni/diffusion/attention/`
+
+#### Architecture
+
+The attention system uses a **role-aware backend selector pattern**. Each `Attention` site declares a semantic `role` (`"self"`, `"cross"`, or a model-specific string). The selector consults the user's `AttentionConfig` to pick a backend per role and falls back to the platform default when nothing is configured.
+
+#### Backend Selection
+
+**Location**: `vllm_omni/diffusion/attention/selector.py`
+
+```python
+class Attention(nn.Module):
+    def __init__(self, num_heads, head_size, causal, softmax_scale, *,
+                 role="self", role_category=None, ...):
+        # Resolve backend for this role from the active OmniDiffusionConfig
+        config = get_current_diffusion_config_or_none()
+        attention_config = config.diffusion_attention_config if config is not None else None
+        attn_backend_cls, spec = get_attn_backend_for_role(
+            role=role,
+            head_size=head_size,
+            attention_config=attention_config,
+            role_category=role_category,
+        )
+        self.attn_impl_cls = attn_backend_cls.get_impl_cls()
+        self.attention = self.attn_impl_cls(..., backend_kwargs=spec.backend_kwargs() if spec else None)
+```
+
+**Available Backends**:
+
+- **FlashAttention** (`FLASH_ATTN`): Memory-efficient kernel that dispatches to FA2/FA3 on CUDA, AITER on ROCm, and `mindiesd` on Ascend NPU.
+
+- **SDPA** (`TORCH_SDPA`): PyTorch's scaled dot-product attention — cross-platform fallback.
+
+- **SageAttention** (`SAGE_ATTN`): Quantized attention implementation from the SageAttention library.
+
+These backends provide the **kernel implementations** for attention computation. For attention-level sequence parallelism strategies (Ring Attention, Ulysses), see [Parallel Attention](#52-parallel-attention).
+
+#### Backend Selection Mechanism
+
+Selection is driven by `OmniDiffusionConfig.diffusion_attention_config`, which carries a global `default` plus a `per_role` map of `AttentionSpec` entries. A role string is resolved in this order:
+
+```python
+def get_attn_backend_for_role(role, head_size, attention_config=None, role_category=None):
+    # 1. attention_config.per_role[role]            — exact match
+    # 2. attention_config.per_role[role_category]   — category fallback
+    # 3. attention_config.default                   — global default
+    # 4. Platform default                           — hardware-specific
+    if attention_config is not None:
+        spec, source = attention_config.resolve_with_source(
+            role=role, role_category=role_category,
+        )
+        if spec is not None:
+            return load_backend(spec.backend), spec
+    return current_omni_platform.get_diffusion_attn_backend_cls(...), None
+```
+
+**Selection Priority**:
+
+1. **Per-role override** (`--diffusion-attention-config.per_role.<role>.backend`) — finest control; matched on the layer's exact `role` string.
+
+2. **Role category fallback** (`--diffusion-attention-config.per_role.<category>.backend`) — used when an exact match is missing and the layer declared `role_category` (e.g. a `"mymodel.audio_to_video"` site can fall back to `"cross"`).
+
+3. **Global default** (`--diffusion-attention-backend FLASH_ATTN`, or `--diffusion-attention-config.default.backend`, or `DIFFUSION_ATTENTION_BACKEND` env var).
+
+4. **Platform default** — `current_omni_platform.get_diffusion_attn_backend_cls(...)` picks the best-available kernel for the hardware.
+
+A backend that needs configuration exposes it as a typed field on `AttentionSpec`; `AttentionSpec.backend_kwargs()` serializes it into the `backend_kwargs` the impl consumes. Today those fields are `skip_softmax` (TRTLLM_ATTN) and `block_sparse` (any block-sparse backend, currently RAINFUSION_ATTN), so e.g. `target_sparsity` or `sparsity` can be set without changing model code.
+
+For the user-facing CLI surface, see [Diffusion Attention Backends](../../../user_guide/diffusion/attention_backends.md). For the role declaration contract on the model side, see [Adding a Diffusion Model](../../../contributing/model/adding_diffusion_model.md).
+
+**Backend Availability**:
+
+- **SDPA**: Always available (PyTorch built-in)
+
+- **FlashAttention**: Requires `flash-attn` on CUDA, `aiter` on ROCm, or `mindiesd` on Ascend NPU
+
+- **SageAttention**: Requires `sage-attention` package (from THU-ML GitHub)
+
+#### Attention Backend Registry
+
+**Location**: `vllm_omni/diffusion/attention/selector.py` + `vllm_omni/platforms/<device>/platform.py`
+
+Backend resolution is delegated to the active platform: `current_omni_platform.get_diffusion_attn_backend_cls(selected_backend, head_size)` returns a fully-qualified class path that `_load_backend_cls` imports lazily, with the result cached by `(backend_name, head_size)`.
+
+```python
+@cache
+def _cached_get_backend_cls(backend_name: str | None, head_size: int) -> type[AttentionBackend]:
+    backend_cls_path = current_omni_platform.get_diffusion_attn_backend_cls(
+        selected_backend=backend_name,
+        head_size=head_size,
+    )
+    return _load_backend_cls(backend_cls_path)
+```
+
+Each platform (`cuda`, `rocm`, `xpu`, `musa`, `npu`) maps backend names like `"FLASH_ATTN"`, `"TORCH_SDPA"`, `"SAGE_ATTN"` to the right backend class path for that hardware, including head-size compatibility checks. Passing `selected_backend=None` lets the platform pick its own default.
+
+#### Attention Backend Integration
+
+The `Attention` layer integrates backends through a unified interface. Here's how **FlashAttentionBackend** is integrated as an example:
+
+```python
+# attention/backends/flash_attn.py
+
+class FlashAttentionBackend(AttentionBackend):
+    @staticmethod
+    def get_name() -> str:
+        return "FLASH_ATTN"
+
+    @staticmethod
+    def get_impl_cls() -> type["FlashAttentionImpl"]:
+        return FlashAttentionImpl
+
+    @staticmethod
+    def get_supported_head_sizes() -> list[int]:
+        return [64, 96, 128, 192, 256]  # FlashAttention supports these head sizes
+
+
+class FlashAttentionImpl(AttentionImpl):
+    def __init__(self, num_heads, head_size, softmax_scale, causal, ...):
+        self.num_heads = num_heads
+        self.causal = causal
+        self.softmax_scale = softmax_scale
+
+    def forward(self, query, key, value, attn_metadata=None):
+        # Call FlashAttention kernel
+        out = flash_attn_func(
+            query, key, value,
+            causal=self.causal,
+            softmax_scale=self.softmax_scale,
+        )
+        return out
+```
+
+---
+
+### 5.2 Parallel Attention
+
+**Location**: `vllm_omni/diffusion/attention/parallel/`
+
+#### Architecture
+
+Parallel attention strategies implement **Sequence Parallelism (SP) at the attention layer level**. These strategies distribute attention computation across multiple GPUs by splitting the sequence dimension, using different communication patterns. They work **on top of** AttentionBackend implementations (FlashAttention, SDPA, etc.), handling the parallelization/communication while the backends handle the actual attention computation.
+
+**Key Distinction**: Unlike AttentionBackend (which provides kernel implementations), ParallelAttentionStrategy provides communication patterns for multi-GPU attention parallelism. These strategies implement the `ParallelAttentionStrategy` interface and use AttentionBackend implementations internally.
+
+Both Ring Attention and Ulysses are forms of Sequence Parallelism (SP) that:
+
+- Split the sequence dimension across GPUs
+
+- Contribute to `sequence_parallel_size` (via `ring_degree` and `ulysses_degree`)
+
+- Work at the attention layer level (not model/pipeline level)
+
+#### Ulysses Sequence Parallelism (USP)
+
+**Location**: `vllm_omni/diffusion/attention/parallel/ulysses.py`
+
+USP is a sequence-parallel attention strategy that splits attention computation across multiple GPUs by distributing both the sequence dimension and attention heads. It uses **all-to-all communication** to efficiently parallelize attention for very long sequences. Specifically, it uses **all-to-all** collective operations to redistribute Q/K/V tensors before attention computation and gather results afterward.
+
+Ulysses splits attention computation in two dimensions:
+
+1. **Sequence Dimension**: Splits the sequence length across GPUs
+
+2. **Head Dimension**: Splits attention heads across GPUs
+
+**Configuration**: `ulysses_degree` contributes to `sequence_parallel_size`
+
+#### Ring Sequence Parallelism
+
+**Location**: `vllm_omni/diffusion/attention/parallel/ring.py`
+
+Ring Attention is a **parallel attention strategy** that implements sequence parallelism using ring-based point-to-point (P2P) communication. Unlike attention backends that provide the attention kernel implementation, Ring Attention is a **communication pattern** that works on top of attention backends (FlashAttention or SDPA).
+
+Ring Attention splits sequence dimension across GPUs in a ring topology, implemented via the `ParallelAttentionStrategy` interface, instead of `AttentionBackend`. P2P ring communication is applied to circulate Key/Value blocks across GPUs. Internally, `ring_flash_attn_func` or `ring_pytorch_attn_func` is used depending on available backends.
+
+**Architecture**:
+```python
+class RingParallelAttention:
+    """Ring sequence-parallel strategy."""
+
+    def run_attention(self, query, key, value, attn_metadata, ...):
+        # Selects underlying attention kernel (FlashAttention or SDPA)
+        if backend_pref == "sdpa":
+            return ring_pytorch_attn_func(...)  # Uses SDPA kernel
+        else:
+            return ring_flash_attn_func(...)    # Uses FlashAttention kernel
+```
+
+**Integration**:
+
+- Ring Attention is activated when `ring_degree > 1` in parallel config
+
+- It's selected by `build_parallel_attention_strategy()` in the attention layer
+
+- The `Attention` layer routes to `_run_ring_attention()` when Ring is enabled
+
+- Works alongside attention backends: Ring handles communication, backends handle computation
+
+**Configuration**: `ring_degree` contributes to `sequence_parallel_size`
+
+#### Relationship with AttentionBackend
+
+Parallel attention strategies (Ring, Ulysses) work **on top of** AttentionBackend implementations:
+
+- They use AttentionBackend for the actual attention computation (FlashAttention, SDPA, etc.)
+
+- They handle the multi-GPU communication/parallelization layer
+
+- They implement `ParallelAttentionStrategy` interface (not `AttentionBackend`)
+
+For general parallelism strategies (Data Parallelism, Tensor Parallelism, Pipeline Parallelism), see [Parallel Strategies](#54-parallel-strategies).
+
+---
+
+### 5.3 Cache Backends
+
+**Location**: `vllm_omni/diffusion/cache/`
+
+#### Architecture
+
+Cache backends provide a **unified interface** for applying different caching strategies to accelerate diffusion inference. The system supports multiple backends (TeaCache, cache-dit) with a consistent API for enabling and refreshing cache state.
+
+#### Cache Backend Interface
+
+```python
+class CacheBackend(ABC):
+    def __init__(self, config: DiffusionCacheConfig):
+        self.config = config
+        self.enabled = False
+
+    @abstractmethod
+    def enable(self, pipeline: Any) -> None:
+        """Enable cache on the pipeline."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def refresh(self, pipeline: Any, num_inference_steps: int, verbose: bool = True) -> None:
+        """Refresh cache state for new generation."""
+        raise NotImplementedError
+
+    def is_enabled(self) -> bool:
+        """Check if cache is enabled."""
+        return self.enabled
+```
+
+**Design Pattern**:
+
+- **Abstract Base Class**: Defines contract for all cache backends
+
+- **Pipeline-based**: Works with pipeline instances (not just transformers)
+
+- **State Management**: Provides refresh mechanism for clean state between generations
+
+#### Available Backends
+
+**1. TeaCache Backend**
+
+**Location**: `vllm_omni/diffusion/cache/teacache/backend.py`
+
+```python
+class TeaCacheBackend(CacheBackend):
+    def enable(self, pipeline: Any):
+        # Extract transformer from pipeline
+        transformer = pipeline.transformer
+        transformer_type = transformer.__class__.__name__
+
+        # Create TeaCacheConfig from DiffusionCacheConfig
+        teacache_config = TeaCacheConfig(
+            transformer_type=transformer_type,
+            rel_l1_thresh=self.config.rel_l1_thresh,
+            coefficients=self.config.coefficients,
+        )
+
+        # Apply hooks to transformer
+        apply_teacache_hook(transformer, teacache_config)
+        self.enabled = True
+
+    def refresh(self, pipeline: Any, num_inference_steps: int, verbose: bool = True):
+        transformer = pipeline.transformer
+        if hasattr(transformer, "_hook_registry"):
+            transformer._hook_registry.reset_hook(TeaCacheHook._HOOK_NAME)
+```
+
+**TeaCache Features**:
+
+- **Timestep-aware**: Caches based on timestep embedding similarity
+
+- **Adaptive**: Dynamically decides when to reuse cached computations
+
+- **CFG-aware**: Handles positive/negative branches separately
+
+- **Custom Hook System**: Uses a custom forward interception mechanism (via `HookRegistry`) that wraps the module's `forward` method, allowing transparent integration without modifying model code
+
+**2. Cache-DiT Backend**
+
+**Location**: `vllm_omni/diffusion/cache/cachedit/`
+
+```python
+class CacheDiTBackend(CacheBackend):
+    def enable(self, pipeline: Any):
+        # Uses cache-dit library for acceleration
+        # Supports DBCache, SCM (Step Computation Masking), TaylorSeer
+        # Works with single and dual-transformer architectures
+        ...
+        self.enabled = True
+
+    def refresh(self, pipeline: Any, num_inference_steps: int, verbose: bool = True):
+        # Updates cache context with new num_inference_steps
+        ...
+```
+
+**Cache-DiT Features**:
+
+- **DBCache**: Dynamic block caching with configurable compute blocks
+
+- **SCM**: Step Computation Masking for additional speedup
+
+- **TaylorSeer**: Advanced calibration for cache accuracy
+
+- **Dual-transformer Support**: Handles models like Wan2.2 with two transformers
+
+#### Cache Backend Selector
+
+**Location**: `vllm_omni/diffusion/cache/selector.py`
+
+```python
+def get_cache_backend(
+    cache_backend: str | None,
+    cache_config: dict | DiffusionCacheConfig
+) -> CacheBackend | None:
+    """Get cache backend instance based on cache_backend string.
+
+    Args:
+        cache_backend: Cache backend name ("cache_dit", "tea_cache", or None)
+        cache_config: Cache configuration (dict or DiffusionCacheConfig)
+
+    Returns:
+        Cache backend instance or None if cache_backend is "none"
+    """
+    if cache_backend is None or cache_backend == "none":
+        return None
+
+    if isinstance(cache_config, dict):
+        cache_config = DiffusionCacheConfig.from_dict(cache_config)
+
+    if cache_backend == "cache_dit":
+        return CacheDiTBackend(cache_config)
+    elif cache_backend == "tea_cache":
+        return TeaCacheBackend(cache_config)
+    else:
+        raise ValueError(f"Unsupported cache backend: {cache_backend}")
+```
+
+**Usage Flow**:
+
+1. **Selection**: `get_cache_backend()` returns appropriate backend instance
+
+2. **Enable**: `backend.enable(pipeline)` called during worker initialization
+
+3. **Refresh**: `backend.refresh(pipeline, num_inference_steps)` called before each generation
+
+4. **Check**: `backend.is_enabled()` verifies cache is active
+
+### 5.4 Parallel Strategies
+
+**Location**: `vllm_omni/diffusion/distributed/parallel_state.py`
+
+#### Parallelism Types
+
+The system supports multiple orthogonal parallelism strategies:
+
+**Sequence Parallelism (SP)**
+
+- **Purpose**: Split sequence dimension across GPUs
+
+- **Attention-level SP**: Ring Attention and Ulysses (USP) implement SP at the attention layer level
+
+    - See [Parallel Attention](#52-parallel-attention) for details
+
+    - Configuration: `ulysses_degree` × `ring_degree` = `sequence_parallel_size`
+
+- **Use Case**: Very long sequences (e.g., high-resolution images)
+
+**Data Parallelism (DP)**
+
+- **Purpose**: Replicate model across GPUs, split batch
+
+- **Use Case**: Batch processing, throughput optimization
+
+**Tensor Parallelism (TP)** (Experimental)
+
+- **Purpose**: Split model weights across GPUs
+
+- **Implementation**: Uses vLLM's tensor parallel groups
+
+- **Use Case**: Large models that don't fit on single GPU
+
+**CFG Parallelism**  (under development)
+
+- **Purpose**: Parallelize Classifier-Free Guidance (positive/negative prompts)
+
+- **Infrastructure**: CFG parallel groups are initialized and available via `get_cfg_group()`
+
+#### Parallel Group Management
+
+```python
+def initialize_model_parallel(
+    data_parallel_size: int = 1,
+    cfg_parallel_size: int = 1,
+    sequence_parallel_size: int | None = None,
+    ulysses_degree: int = 1,
+    ring_degree: int = 1,
+    tensor_parallel_size: int = 1,
+    pipeline_parallel_size: int = 1,
+    vae_parallel_size: int = 0,
+):
+    # Generate orthogonal parallel groups
+    rank_generator = RankGenerator(
+        tensor_parallel_size,
+        sequence_parallel_size,
+        pipeline_parallel_size,
+        cfg_parallel_size,
+        data_parallel_size,
+        "tp-sp-pp-cfg-dp",
+    )
+
+    # Initialize each parallel group
+    _DP = init_model_parallel_group(rank_generator.get_ranks("dp"), ...)
+    _CFG = init_model_parallel_group(rank_generator.get_ranks("cfg"), ...)
+    _SP = init_model_parallel_group(rank_generator.get_ranks("sp"), ...)
+    _PP = init_model_parallel_group(rank_generator.get_ranks("pp"), ...)
+    _TP = init_model_parallel_group(rank_generator.get_ranks("tp"), ...)
+```
+
+**Rank Order**: `tp-sp-pp-cfg-dp` (tensor → sequence → pipeline → cfg → data)
+
+**Note**: For attention-level Sequence Parallelism implementations (Ring Attention and Ulysses), see [Parallel Attention](#52-parallel-attention). This section covers higher-level parallelism strategies.
+
+
+---
+
+## 6. Data Flow
+
+### Complete Request Flow
+
+<p align="center">
+   <img src="https://github.com/user-attachments/assets/6e093a0d-29c0-4efd-85d5-747002bd2fed" alt="vLLM-Omni Diffusion Module Components" width="100%">
+</p>
+<p align="center">
+  <em> End-to-end Data Flow in the vLLM-Omni Diffusion Module </em>
+</p>
+
+
+```
+1. User Request
+   └─> Omni.generate(prompt)
+       └─> Prepare OmniDiffusionRequest
+           └─> DiffusionEngine.step_streaming(request)
+
+2. Pre-processing
+   └─> pre_process_func(request)
+       └─> Model-specific transformations
+
+3. Scheduling
+       └─> scheduler.add_request(request)
+           └─> scheduler.schedule()
+           └─> DiffusionEngine selects execute_batch / execute_step
+
+4. Worker Execution
+   └─> WorkerProc._worker_busy_loop()
+       └─> DiffusionWorker.execute_model(req)
+           └─> DiffusionModelRunner selects execution mode
+               ├─> REQUEST_BATCH
+               │   └─> Pipeline.forward(req_or_batch)
+               │       ├─> encode_prompt()
+               │       ├─> prepare_latents()
+               │       ├─> diffuse() [loop]
+               │       │   ├─> transformer.forward() [with cache backend hooks]
+               │       │   └─> scheduler.step()
+               │       └─> vae.decode()
+               └─> STEP
+                   ├─> pipeline.prepare_encode(state) [new requests]
+                   ├─> pipeline.denoise_step(input_batch)
+                   ├─> pipeline.step_scheduler(state, noise_pred)
+                   └─> pipeline.post_decode(state) [chunk boundary or final step]
+
+5. Result Collection
+   └─> Executor returns RunnerOutput / BatchRunnerOutput
+       └─> scheduler.update_from_output(...)
+           ├─> DiffusionEngine emits chunk/final output to request queue
+           └─> DiffusionEngine finalizes terminal scheduler state
+
+6. Post-processing
+   └─> post_process_func(output)
+       └─> Convert to PIL images / final format
+
+7. Stream Completion / Cancellation
+   ├─> Streaming callers receive every yielded output
+   ├─> Non-streaming callers drain the stream and return the final output
+   └─> Cancelled streams drop their output queue but still allow scheduler state cleanup
+```
+
+---
diff --git a/docs/design/module/archive/entrypoint_module.md b/docs/design/module/archive/entrypoint_module.md
new file mode 100644
index 000000000..7a26fbb7f
--- /dev/null
+++ b/docs/design/module/archive/entrypoint_module.md
@@ -0,0 +1 @@
+Architecture design of the entrypoint (update soon)
diff --git a/docs/design/module/engine_orchestration.md b/docs/design/module/engine_orchestration.md
index cf8ef1fd0..5bb0ea0df 100644
--- a/docs/design/module/engine_orchestration.md
+++ b/docs/design/module/engine_orchestration.md
@@ -2,26 +2,56 @@
 title: Engine Orchestration
 kind: module
 status: draft
+architecture_state: current-plus-in-flight
 owners:
   - "@tzhouam"
-  - "@yinpeiqi"
   - "@fake0fan"
+document_stewards:
+  - "@hsliuustc0106"
+  - "@Gaohan123"
+  - "@david6666666"
+required_reviewers:
+  - "@yinpeiqi"
   - "@Sy0307"
+  - "@yenuo26"
+  - "@NickCao"
 primary_code_paths:
-  - vllm_omni/engine/**
+  - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/engine/async_engine_utils.py
+  - vllm_omni/engine/orchestrator.py
+  - vllm_omni/engine/cfg_companion_tracker.py
+  - vllm_omni/engine/rpc_result_router.py
 related_code_paths:
+  - vllm_omni/engine/messages.py
+  - vllm_omni/engine/orchestrator_monitor.py
+  - vllm_omni/engine/stage_client.py
+  - vllm_omni/engine/stage_pool.py
+  - vllm_omni/outputs/output_processor.py
   - vllm_omni/distributed/omni_coordinator/**
-  - vllm_omni/distributed/ray_utils/**
 depends_on:
-  - vllm_omni_config.md
   - input_output_modality_contracts.md
+  - error_contracts.md
+  - stage_runtime.md
   - omni_connector.md
 validation_paths:
-  - tests/engine/**
-  - tests/distributed/omni_coordinator/**
+  - tests/engine/test_async_omni_engine_input.py
+  - tests/engine/test_async_omni_engine_outputs.py
+  - tests/engine/test_async_omni_engine_abort.py
+  - tests/engine/test_async_omni_engine_stage_init.py
+  - tests/engine/test_orchestrator.py
+  - tests/engine/test_orchestrator_error_handling.py
+  - tests/engine/test_orchestrator_stage_input_bridge.py
+  - tests/engine/test_cfg_companion_lifecycle.py
+  - tests/engine/test_rpc_result_router.py
+  - tests/e2e/features/fullduplex/engine/**
 upstream_refs:
-  - vllm.v1.engine
-last_reviewed: 2026-07-16
+  - vllm.v1.engine.EngineCoreRequest
+  - vllm.v1.engine.EngineCoreOutputs
+  - vllm.v1.engine.exceptions.EngineDeadError
+  - vllm.outputs.RequestOutput
+invariant_namespace: ORCH-INV
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
 ---
 
 # Engine orchestration
@@ -29,24 +59,64 @@ last_reviewed: 2026-07-16
 Engine orchestration coordinates configured AR and diffusion stages while
 keeping public clients independent from stage processes and transports.
 
+## Contract status
+
+This document is a draft description of current behavior. It also identifies
+the boundary affected by the in-flight stage client/process refactor in
+[#5441](https://github.com/vllm-project/vllm-omni/pull/5441). Names and
+responsibilities proposed only by that PR are not current contracts.
+
+## Ownership boundary
+
+This document owns `AsyncOmniEngine`, `Orchestrator`, request-state creation,
+cross-stage routing, output ordering, companion tracking, control/RPC
+correlation, cancellation propagation, and terminal-state convergence.
+
+It does not own stage placement, replica selection, stage-process startup,
+payload schemas, public protocol rendering, connector transport, or semantic
+error classification. Those responsibilities belong to the stage runtime,
+I/O, entrypoint, connector, and error contracts.
+
 ## Candidate invariants
 
+These identifiers are proposals while the document is `draft`.
+
 ### ORCH-INV-001: The orchestrator owns cross-stage routing
 
 **Rule:** Entrypoints and stage clients MUST NOT independently forward a
-request to a downstream stage.
+request to a downstream logical stage.
 
 ### ORCH-INV-002: Stage clients do not own routing policy
 
 **Rule:** Stage clients MUST implement communication and lifecycle operations
 without selecting the next logical stage.
 
-### ORCH-INV-003: Terminal state is monotonic
+### ORCH-INV-100: Terminal state is monotonic
 
 **Rule:** Once a request reaches a terminal state, orchestration MUST NOT
 forward new work for that request.
 
+## Invariant namespace
+
+`ORCH-INV` reserves `001-099` for dependency direction, `100-199` for
+request state and ordering, `200-299` for failure/cancellation/cleanup, and
+`300-399` for extension points, shutdown ordering, and upstream alignment.
+Numbers become append-only after normative promotion.
+
 ## Safe-change guide
 
-Test routing, output ordering, cancellation, failure propagation, shutdown, and
-representative multi-stage execution.
+Test routing, output ordering, queue correlation, cancellation, failure
+propagation, shutdown ordering, and representative multi-stage execution.
+Changes that cross into stage runtime or public error behavior require review
+from that contract's owners.
+
+## Promotion gate
+
+- Reconcile current names and boundaries after #5441 merges, closes, or is
+  replaced.
+- Demonstrate one terminal outcome per request across success, abort,
+  request-scoped failure, and fatal engine failure.
+- Verify queue correlation and orchestrator-before-runtime shutdown ordering
+  in the cited validation paths.
+- Obtain approval from a technical owner and an independent validation
+  reviewer.
diff --git a/docs/design/module/entrypoints.md b/docs/design/module/entrypoints.md
index 8d4da8434..80b576f96 100644
--- a/docs/design/module/entrypoints.md
+++ b/docs/design/module/entrypoints.md
@@ -1,51 +1,134 @@
 ---
-title: Entrypoints
+title: Entrypoints and Serving Boundaries
 kind: module
 status: draft
+architecture_state: current-plus-in-flight
 owners:
-  - "@tzhouam"
-  - "@yinpeiqi"
-  - "@fake0fan"
   - "@alex-jw-brooks"
+  - "@linyueqian"
+document_stewards:
+  - "@hsliuustc0106"
+  - "@Gaohan123"
+  - "@david6666666"
+required_reviewers:
+  - "@tzhouam"
+  - "@herotai214"
+  - "@yenuo26"
+  - "@NickCao"
 primary_code_paths:
-  - vllm_omni/entrypoints/**
+  - vllm_omni/entrypoints/omni.py
+  - vllm_omni/entrypoints/async_omni.py
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/entrypoints/cli/**
+  - vllm_omni/entrypoints/openai/**
+  - vllm_omni/entrypoints/openpi/**
+  - vllm_omni/entrypoints/client_request_state.py
+  - vllm_omni/entrypoints/stage_utils.py
+  - vllm_omni/entrypoints/utils.py
+primary_path_exceptions:
+  - path: vllm_omni/entrypoints/openai/errors.py
+    owner: error_contracts.md
 related_code_paths:
-  - vllm_omni/reasoning/**
+  - vllm_omni/errors.py
+  - vllm_omni/inputs/**
+  - vllm_omni/outputs/**
+  - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/config/**
+  - vllm_omni/deploy/**
 depends_on:
-  - vllm_omni_config.md
   - input_output_modality_contracts.md
+  - error_contracts.md
   - engine_orchestration.md
 validation_paths:
-  - tests/entrypoints/**
-  - tests/reasoning/**
+  - tests/entrypoints/test_omni_entrypoints.py
+  - tests/entrypoints/test_async_omni.py
+  - tests/entrypoints/test_async_omni_duplex.py
+  - tests/entrypoints/test_serve.py
+  - tests/entrypoints/test_stream_finish_reason.py
+  - tests/entrypoints/openai/**
+  - tests/entrypoints/openai_api/**
+  - tests/e2e/online_serving/**
 upstream_refs:
-  - vllm.entrypoints
-last_reviewed: 2026-07-16
+  - vllm.engine.protocol.EngineClient
+  - vllm.entrypoints.openai/**
+  - vllm.entrypoints.serve/**
+  - vllm.renderers/**
+  - vllm.v1.engine.exceptions/**
+invariant_namespace: ENTRY-INV
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
 ---
 
-# Entrypoints
+# Entrypoints and serving boundaries
 
 Entrypoints translate offline, CLI, and serving requests into stable engine
 operations and translate engine outputs into public responses.
 
+## Contract status
+
+This document describes current entrypoint responsibilities plus the boundary
+under review in the open roadmap
+[#5227](https://github.com/vllm-project/vllm-omni/issues/5227) and helper-move
+PR [#5453](https://github.com/vllm-project/vllm-omni/pull/5453). In-flight
+helper locations are not treated as current paths.
+
+## Ownership boundary
+
+This document owns offline API semantics, CLI and serve composition,
+supported OpenAI-compatible routes, request validation and normalization,
+response conversion, streaming/session behavior, and engine handoff.
+
+It does not own configuration precedence, cross-stage routing, stage
+placement, payload implementation, or semantic error classification.
+`entrypoints/openai/errors.py` is an explicit primary-path exception owned by
+`error_contracts.md`.
+
 ## Candidate invariants
 
+These identifiers are proposals while the document is `draft`.
+
 ### ENTRY-INV-001: Entrypoints adapt but do not orchestrate
 
 **Rule:** Entrypoints MUST NOT implement cross-stage routing or stage lifecycle
 policy.
 
-### ENTRY-INV-002: Public requests are normalized once
+### ENTRY-INV-100: Public requests are normalized once
 
 **Rule:** Public protocol values MUST be validated and converted to internal
 request contracts before engine submission.
 
-### ENTRY-INV-003: Streaming preserves request identity
+### ENTRY-INV-101: Streaming preserves request identity
 
 **Rule:** Every streamed response MUST remain associated with the request and
 output modality that produced it.
 
+The reviewer-proposed rule that model-specific behavior should stay behind a
+common adapter or processor abstraction remains an unnumbered candidate until
+the entrypoint refactor makes that boundary enforceable.
+
+## Invariant namespace
+
+`ENTRY-INV` reserves `001-099` for boundary and dependency direction,
+`100-199` for normalization, sessions, and streaming, `200-299` for
+disconnect, cancellation, rendering, and cleanup, and `300-399` for upstream
+route and renderer compatibility. Numbers become append-only after normative
+promotion.
+
 ## Safe-change guide
 
-Test request validation, protocol conversion, streaming, cancellation, and
-error mapping for each affected entrypoint.
+Test request validation, protocol conversion, model-adapter routing,
+streaming, session identity, disconnect/cancellation, and error mapping for
+each affected offline or serving entrypoint.
+
+## Promotion gate
+
+- Reconcile the page after #5227's P0 ownership work and #5453's final
+  disposition.
+- Publish a supported route/transport matrix rather than claiming blanket
+  OpenAI parity.
+- Verify one normalization and handoff path per route family and one terminal
+  outcome per streaming transport.
+- Promote the `api_server.py` composition-root rule only after helper moves and
+  import boundaries enforce it.
+- Obtain approval from a technical owner and an independent validation
+  reviewer.
diff --git a/docs/design/module/error_contracts.md b/docs/design/module/error_contracts.md
new file mode 100644
index 000000000..02469d075
--- /dev/null
+++ b/docs/design/module/error_contracts.md
@@ -0,0 +1,109 @@
+---
+title: Error Classification, Propagation, and Rendering
+kind: module
+status: draft
+architecture_state: current-plus-rfc
+owners:
+  - "@alex-jw-brooks"
+  - "@NickCao"
+document_stewards:
+  - "@hsliuustc0106"
+  - "@Gaohan123"
+  - "@david6666666"
+required_reviewers:
+  - "@yinpeiqi"
+  - "@tzhouam"
+  - "@yenuo26"
+primary_code_paths:
+  - vllm_omni/errors.py
+  - vllm_omni/entrypoints/openai/errors.py
+related_code_paths:
+  - vllm_omni/engine/messages.py
+  - vllm_omni/engine/orchestrator.py
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/entrypoints/async_omni.py
+  - vllm_omni/entrypoints/openai/api_server.py
+  - vllm_omni/entrypoints/openai/serving_chat.py
+  - vllm_omni/entrypoints/openai/serving_speech.py
+  - vllm_omni/entrypoints/openai/serving_audio_generate.py
+  - vllm_omni/entrypoints/openai/protocol/images.py
+  - vllm_omni/entrypoints/openai/protocol/videos.py
+depends_on: []
+validation_paths:
+  - tests/engine/test_orchestrator_error_handling.py
+  - tests/engine/test_async_omni_engine_outputs.py
+  - tests/entrypoints/test_omni_entrypoints.py
+  - tests/entrypoints/test_stream_finish_reason.py
+  - tests/entrypoints/openai_api/test_image_server.py
+  - tests/entrypoints/openai_api/test_video_server.py
+  - tests/entrypoints/openai_api/test_serving_audio_generate.py
+  - tests/entrypoints/openai_api/test_serving_speech.py
+  - tests/metrics/test_prometheus.py
+upstream_refs:
+  - vllm.v1.engine.exceptions.EngineDeadError
+  - vllm.v1.engine.exceptions.EngineGenerateError
+  - vllm.entrypoints.serve.utils.error_response
+  - vLLM RFC #48227
+  - vLLM PR #49665
+invariant_namespace: ERR-INV
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
+---
+
+# Error classification, propagation, and rendering
+
+This contract separates the meaning of a failure from the transport used to
+carry it and the public protocol used to render it.
+
+## Contract status
+
+Current behavior is distributed across engine, message, and entrypoint code.
+The semantic hierarchy proposed by
+[#5570](https://github.com/vllm-project/vllm-omni/issues/5570) remains an open
+RFC. Proposed types and wire records from that RFC are not current contracts.
+
+## Ownership boundary
+
+This document owns semantic classification, fatal versus request-scoped
+failure, cross-process error context, compatibility policy, sanitization, and
+offline, HTTP, SSE, WebSocket, and asynchronous-job rendering rules.
+
+`engine/messages.py` remains primarily owned by the I/O contract; this page
+owns the semantics of its error fields. Route and serving files remain
+primarily owned by `entrypoints.md`; this page owns their rendering
+constraints.
+
+## Candidate invariants
+
+The following topics require owner review before receiving stable IDs:
+
+- A request-scoped failure terminates only the affected request unless the
+  underlying engine is no longer usable.
+- Every public rendering path preserves a stable classification while
+  removing sensitive internal context.
+- Cancellation remains distinguishable from internal failure across process
+  and protocol boundaries.
+
+## Invariant namespace
+
+`ERR-INV` reserves `001-099` for classification ownership, `100-199` for wire
+context and compatibility, `200-299` for fatality, termination, sanitization,
+and rendering, and `300-399` for upstream alignment and transport extension
+points. Numbers become append-only after normative promotion.
+
+## Safe-change guide
+
+Exercise exception classification, stage wire round trips, fatal and
+request-scoped propagation, cancellation, sanitization, offline exceptions,
+HTTP status/body consistency, streaming terminal events, asynchronous-job
+persistence, and metrics classification.
+
+## Promotion gate
+
+- Resolve #5570's hierarchy, wire record, sanitization, and mixed-version
+  questions.
+- Add table-driven exception/status/type tests and stage wire round trips.
+- Verify all public transports terminate once and do not leak sensitive
+  payload data.
+- Obtain approval from both technical owners and an independent validation
+  reviewer.
diff --git a/docs/design/module/input_output_modality_contracts.md b/docs/design/module/input_output_modality_contracts.md
index 10d803d26..1083b09b0 100644
--- a/docs/design/module/input_output_modality_contracts.md
+++ b/docs/design/module/input_output_modality_contracts.md
@@ -2,46 +2,132 @@
 title: Input, Output, and Modality Contracts
 kind: module
 status: draft
+architecture_state: current
 owners:
+  - "@Sy0307"
+  - "@amy-why-3459"
+document_stewards:
+  - "@hsliuustc0106"
+  - "@Gaohan123"
+  - "@david6666666"
+required_reviewers:
   - "@tzhouam"
-  - "@gcanlin"
+  - "@linyueqian"
+  - "@david6666666"
+  - "@yenuo26"
+  - "@NickCao"
 primary_code_paths:
   - vllm_omni/inputs/**
   - vllm_omni/outputs/**
+  - vllm_omni/request.py
+  - vllm_omni/data_entry_keys.py
+  - vllm_omni/engine/messages.py
+  - vllm_omni/engine/serialization.py
+  - vllm_omni/engine/mm_outputs.py
+  - vllm_omni/engine/output_modality.py
+  - vllm_omni/engine/output_processor.py
 related_code_paths:
-  - vllm_omni/tokenizers/**
-depends_on: []
+  - vllm_omni/model_executor/stage_input_processors/**
+  - vllm_omni/core/sched/**
+  - vllm_omni/distributed/omni_connectors/**
+  - vllm_omni/diffusion/request.py
+  - vllm_omni/diffusion/worker/request_batch.py
+  - vllm_omni/errors.py
+depends_on:
+  - error_contracts.md
 validation_paths:
   - tests/inputs/**
+  - tests/engine/test_data_entry_keys.py
+  - tests/engine/test_omni_request.py
+  - tests/engine/test_omni_request_output.py
+  - tests/engine/test_multimodal_accumulation.py
+  - tests/engine/test_output_modality.py
+  - tests/engine/test_output_processor.py
+  - tests/engine/test_wire_multimodal_output.py
+  - tests/utils/test_mm_outputs.py
+  - tests/utils/test_mm_outputs_partition.py
+  - tests/diffusion/test_diffusion_output_metadata.py
 upstream_refs:
-  - vllm.inputs
-  - vllm.outputs
-last_reviewed: 2026-07-16
+  - vllm.inputs/**
+  - vllm.outputs/**
+  - vllm.v1.request.Request
+  - vllm.v1.engine.EngineCoreRequest
+  - vllm.v1.engine.EngineCoreOutput
+  - vllm.v1.engine.output_processor.OutputProcessor
+invariant_namespace: IO-INV
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
 ---
 
 # Input, output, and modality contracts
 
 These contracts define the data that may cross entrypoint, orchestration,
-stage, and model boundaries.
+stage, connector, and model boundaries.
+
+## Contract status
+
+This document is a draft description of the current request, message,
+serialization, modality, accumulation, and output types. It does not assign
+semantic error ownership to the wire schema.
+
+## Ownership boundary
+
+This document owns request identity, prompt/input types, modality keys and
+metadata, queue and wire message schemas, serialization, output types,
+accumulation, completion semantics, and compatibility shims.
+
+It does not own route-specific validation or rendering, model-specific
+interpretation, connector transport mechanics, scheduling policy, or semantic
+error classification. The `ErrorMessage` schema belongs here; the meaning and
+public rendering of its error fields belong to `error_contracts.md`.
 
 ## Candidate invariants
 
+These identifiers are proposals while the document is `draft`.
+
 ### IO-INV-001: Boundary data has an explicit modality
 
 **Rule:** Data crossing a module or stage boundary MUST identify its modality
 and use the corresponding validated contract.
 
-### IO-INV-002: Request identity is stable
+### IO-INV-100: Request identity is stable
 
 **Rule:** Request identity MUST be preserved across conversions, stages,
 streaming updates, cancellation, and errors.
 
-### IO-INV-003: Internal objects do not leak into public protocols
+### IO-INV-101: Completion is explicit
+
+**Rule:** Producers MUST distinguish partial updates from the terminal update
+for every output modality.
+
+### IO-INV-300: Internal objects do not leak into public protocols
 
 **Rule:** Entrypoints MUST explicitly translate internal output objects into
 public response types.
 
+## Invariant namespace
+
+`IO-INV` reserves `001-099` for schema ownership and dependency direction,
+`100-199` for identity, modality, accumulation, ordering, and completion,
+`200-299` for serialization failure and payload cleanup, and `300-399` for
+upstream extension, deprecation, and compatibility. Numbers become
+append-only after normative promotion.
+
 ## Safe-change guide
 
-Test construction, validation, serialization, streaming, optional fields, and
-compatibility at every affected producer-consumer boundary.
+Test construction, validation, serialization, round trips, streaming,
+accumulation, completion, optional fields, unknown fields, and compatibility
+at every affected producer-consumer boundary.
+
+## Promotion gate
+
+- Add explicit CODEOWNERS for the primary I/O paths or confirm that fallback
+  ownership is intentional.
+- Document the compatibility window for deprecated `vllm_omni.engine`
+  I/O-related imports.
+- Verify wire round trips and rejection of unknown or incompatible schema
+  fields.
+- Define payload-versus-metadata rules and completion semantics for streaming
+  and batched outputs.
+- Obtain approval from a technical owner and independent AR, diffusion,
+  connector, entrypoint, and validation reviewers as applicable.
diff --git a/docs/design/module/stage_runtime.md b/docs/design/module/stage_runtime.md
new file mode 100644
index 000000000..aefba5a40
--- /dev/null
+++ b/docs/design/module/stage_runtime.md
@@ -0,0 +1,126 @@
+---
+title: Stage Runtime and Replica Lifecycle
+kind: module
+status: draft
+architecture_state: current-plus-in-flight
+owners:
+  - "@tzhouam"
+  - "@fake0fan"
+document_stewards:
+  - "@hsliuustc0106"
+  - "@Gaohan123"
+  - "@david6666666"
+required_reviewers:
+  - "@Sy0307"
+  - "@princepride"
+  - "@chickeyton"
+  - "@yenuo26"
+  - "@NickCao"
+primary_code_paths:
+  - vllm_omni/engine/stage_runtime.py
+  - vllm_omni/engine/stage_pool.py
+  - vllm_omni/engine/stage_client.py
+  - vllm_omni/engine/membership_controller.py
+  - vllm_omni/engine/stage_engine_startup.py
+  - vllm_omni/engine/stage_engine_core_client.py
+  - vllm_omni/engine/stage_engine_core_proc.py
+  - vllm_omni/engine/stage_engine_core_proc_manager.py
+  - vllm_omni/engine/stage_init_utils.py
+related_code_paths:
+  - vllm_omni/distributed/omni_coordinator/**
+  - vllm_omni/distributed/ray_utils/**
+  - vllm_omni/diffusion/inline_stage_diffusion_client.py
+  - vllm_omni/diffusion/stage_diffusion_client.py
+  - vllm_omni/diffusion/stage_diffusion_proc.py
+  - vllm_omni/config/**
+depends_on:
+  - input_output_modality_contracts.md
+  - error_contracts.md
+  - omni_connector.md
+validation_paths:
+  - tests/engine/test_async_omni_engine_stage_init.py
+  - tests/engine/test_membership_controller.py
+  - tests/engine/test_single_stage_mode.py
+  - tests/engine/test_stage_engine_core_client.py
+  - tests/engine/test_stage_engine_core_proc.py
+  - tests/diffusion/test_inline_stage_diffusion_client.py
+  - tests/diffusion/test_stage_diffusion_proc.py
+  - tests/distributed/omni_coordinator/**
+upstream_refs:
+  - vllm.v1.engine.core_client.AsyncMPClient
+  - vllm.v1.engine.core_client.DPLBAsyncMPClient
+  - vllm.v1.engine.core.EngineCoreProc
+  - vllm.v1.engine.utils.CoreEngineProcManager
+  - vllm.v1.engine.coordinator.DPCoordinator
+invariant_namespace: STAGE-INV
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
+---
+
+# Stage runtime and replica lifecycle
+
+The stage runtime turns a logical stage definition into ready local or
+distributed replicas and provides the lifecycle boundary used by the
+orchestrator.
+
+## Contract status
+
+This document describes the current `StageRuntime`, `StagePool`, stage-client,
+and stage-process layout. The unified LLM/diffusion direction in
+[#5441](https://github.com/vllm-project/vllm-omni/pull/5441) remains in flight
+and is not presented as current behavior.
+
+## Ownership boundary
+
+This document owns local and distributed stage placement, startup and
+readiness, one pool per logical stage, replica identity and membership,
+selection and affinity, stage-client/process lifecycle, liveness, draining,
+and shutdown.
+
+It does not own cross-stage request policy, model scheduler policy, connector
+transfer semantics, configuration precedence, or public error rendering.
+
+## Candidate invariants
+
+These identifiers are proposals while the document is `draft`.
+
+### STAGE-INV-001: The runtime owns replica lifecycle
+
+**Rule:** Orchestration MUST acquire stage capacity through the stage runtime
+and MUST NOT construct or retire backend replicas directly.
+
+### STAGE-INV-100: Affinity uses stable replica identity
+
+**Rule:** Follow-up operations for a request with replica affinity MUST resolve
+the same logical replica until the request terminates or the replica is
+declared lost.
+
+### STAGE-INV-200: Shutdown is idempotent
+
+**Rule:** Repeated shutdown or cleanup signals MUST NOT leak stage clients,
+process managers, or membership registrations.
+
+## Invariant namespace
+
+`STAGE-INV` reserves `001-099` for placement and ownership, `100-199` for
+replica identity/readiness/affinity, `200-299` for liveness loss, draining and
+cleanup, and `300-399` for local/distributed and upstream compatibility.
+Numbers become append-only after normative promotion.
+
+## Safe-change guide
+
+Exercise local and distributed startup, readiness, replica selection,
+affinity, membership changes, abort routing, process failure, draining, and
+repeated shutdown. Cross-stage policy changes belong in
+`engine_orchestration.md`.
+
+## Promotion gate
+
+- Reconcile terminology and ownership after #5441 reaches a final state.
+- Add or identify a dedicated StageRuntime/StagePool lifecycle suite; current
+  evidence is distributed across the cited tests.
+- Demonstrate affinity preservation for update, interaction, and abort paths.
+- Demonstrate membership loss and repeated shutdown without leaked clients or
+  processes.
+- Obtain approval from a technical owner and an independent validation
+  reviewer.
diff --git a/docs/design/module/vllm_omni_config.md b/docs/design/module/vllm_omni_config.md
index 5df0cdcb3..085e4cee6 100644
--- a/docs/design/module/vllm_omni_config.md
+++ b/docs/design/module/vllm_omni_config.md
@@ -2,6 +2,8 @@
 title: vLLM-Omni Configuration
 kind: module
 status: draft
+architecture_state: deferred-pending-refactor
+ownership_status: provisional
 owners:
   - "@lishunyang12"
   - "@alex-jw-brooks"
@@ -16,32 +18,39 @@ validation_paths:
   - tests/config/**
 upstream_refs:
   - vllm.config
-last_reviewed: 2026-07-16
+last_reviewed: 2026-08-07
+last_verified_commit: 3d7fc3b9ba3cac88d579d4dc35b78b0b641675fc
 ---
 
 # vLLM-Omni configuration
 
-Configuration defines how user input becomes validated engine, stage,
-deployment, and platform settings.
+This page intentionally records discovery paths only. Substantive
+configuration ownership and contract work is deferred until the active
+configuration refactoring has settled.
 
-## Candidate invariants
+## Deferred contract scope
 
-### CONFIG-INV-001: Configuration is validated before startup
+The current code and tests remain authoritative for parsing, defaults,
+overrides, deployment topology, stage construction, and runtime projection.
+This draft does not define a stable precedence model, environment-variable
+capture rule, canonical configuration object, or invariant namespace.
 
-**Rule:** Invalid stage graphs, resource assignments, and incompatible options
-MUST fail before managed runtime processes start.
+The PR review proposal to capture environment-derived values in configuration
+objects at initialization is an open design question, not a current
+invariant.
 
-### CONFIG-INV-002: Precedence is deterministic
+## Safe-change guide while deferred
 
-**Rule:** Defaults, files, environment variables, and CLI overrides MUST have a
-documented and deterministic precedence.
+Changes should trace every affected producer to its runtime consumer and test
+the structured, legacy, CLI, and deployment paths that are actually supported.
+Do not infer a stable contract from this placeholder page.
 
-### CONFIG-INV-003: Runtime modules consume validated configuration
+## Promotion gate
 
-**Rule:** Runtime modules MUST NOT independently reinterpret raw user
-configuration.
-
-## Safe-change guide
-
-Test defaults, parsing, override precedence, serialization, invalid
-combinations, and representative multi-stage configurations.
+- Finish or stabilize the configuration refactor and identify the canonical
+  runtime configuration representation.
+- Confirm technical owners, primary path exceptions, and validation owners.
+- Document parsing and override precedence, including when environment values
+  are captured.
+- Allocate an invariant namespace only after those behaviors are enforced and
+  owner-approved.
diff --git a/docs/design/qwen3_omni_tts_performance_optimization.md b/docs/design/qwen3_omni_tts_performance_optimization.md
index e4548a17c..bc1e29a7f 100644
--- a/docs/design/qwen3_omni_tts_performance_optimization.md
+++ b/docs/design/qwen3_omni_tts_performance_optimization.md
@@ -419,8 +419,7 @@ Notes:
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct \
   --omni \
-  --port 8091 \
-  --stage-configs-path vllm_omni/model_executor/stage_configs/qwen3_omni_moe_async_chunk.yaml
+  --port 8091
 ```
 
 #### 3) Key config knobs
@@ -494,7 +493,7 @@ The default config (`qwen3_tts.yaml`) enables the full optimization stack:
 vllm-omni serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
   --omni \
   --port 8000 \
-  --stage-configs-path vllm_omni/model_executor/stage_configs/qwen3_tts_no_async_chunk.yaml
+  --no-async-chunk
 ```
 
 #### 3) Key config knobs
diff --git a/docs/features/session_state_manager.md b/docs/features/session_state_manager.md
new file mode 100644
index 000000000..c0c055fcb
--- /dev/null
+++ b/docs/features/session_state_manager.md
@@ -0,0 +1,160 @@
+# Session State Manager (experimental)
+
+!!! warning
+    This feature is **experimental** (RFC [#4480](https://github.com/vllm-project/vllm-omni/issues/4480)).
+    The code lives under `vllm_omni/experimental/world_models/` and its APIs may
+    change without notice. It is **off by default**; when disabled, model
+    behavior is byte-for-byte unchanged.
+
+Autoregressive diffusion world models (DreamZero, Cosmos3, and similar) keep
+per-session state across `forward()` calls: accumulated video latents, frame
+stitching buffers, encode-once conditioning, counters, and reset heuristics.
+Historically each model hand-rolled this state. The session state manager
+extracts it into a shared, typed contract:
+
+- `StateObject` — one typed unit of session state (e.g. `LatentBuffer` for
+  accumulated latents and bounded rings), with a uniform lifecycle
+  (`allocate` / `commit` / `view` / `reset` / `evict` / `nbytes_by_device`).
+- `SessionStateManager` — maps `session_id -> {name: StateObject}`, caps the
+  number of retained sessions by evicting the least recently used one first
+  (matching the bespoke caches it replaces), and reports per-device byte usage
+  via `stats()` for observability.
+
+Attention KV is *not* managed here: for DreamZero it is owned by the
+AR-Diffusion engine's paged KV pool (PR
+[#4534](https://github.com/vllm-project/vllm-omni/pull/4534)). The manager
+covers the model's non-KV session state; integrating the engine's per-session
+KV handle into the same byte accounting is RFC #4480 Phase 1.
+
+## Enabling
+
+Via config:
+
+```yaml
+# deploy config
+enable_session_state_manager: true
+```
+
+or programmatically with `OmniDiffusionConfig(enable_session_state_manager=True)`.
+
+Via environment variables (no config change needed):
+
+```bash
+export OMNI_DIFFUSION_SESSION_STATE_MANAGER=1            # 1/0/true/false/yes/no/on/off
+export OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS=64   # optional, positive int
+```
+
+**Precedence:** a *set* environment variable overrides the config value, in
+both directions — `OMNI_DIFFUSION_SESSION_STATE_MANAGER=0` force-disables the
+manager even if the config enables it. Unset or unparsable values fall back
+to the config (an unparsable `MAX_SESSIONS` logs a warning and is ignored).
+
+**Why both a config field and an environment variable?** The config field is
+the API. The environment override exists for A/B equivalence validation: the
+manager-backed path must be bit-identical to the bespoke path, and the way to
+verify that is to run the *same* deploy config twice with only the flag
+flipped per process — no config-file edits, so the two runs cannot drift
+apart. (Same pattern as the `DIFFUSION_CACHE_BACKEND` fallback.)
+
+**Why is `MAX_SESSIONS` not a config field?** The retained-session cap is not
+a public tuning knob: it mirrors the bespoke `MAX_DREAMZERO_SESSIONS = 64`
+constant (which is not configurable either), so the manager-backed path evicts
+exactly like the path it replaces. The environment variable exists only to
+stress eviction in tests and experiments. It is deliberately not promoted to
+the config, because RFC #4480 Phase 1 replaces count-based capping with a byte
+budget — that budget, not this cap, is the knob that deserves a config field.
+
+## Choosing between an attribute and a `StateObject`
+
+A session holds its values in two places. Named `StateObject`s live in the
+session's object map; everything else lives in `SessionState.attrs`, declared
+one line per value with the `SessionAttr` descriptor. The rule for choosing is:
+
+> A value belongs in a `StateObject` when the **manager** must be able to act on
+> it — release it under budget pressure, accumulate into it, stage and commit
+> it, or rebuild it from a recorded source. It belongs in `attrs` when the
+> manager only needs to **carry** it: the model assigns it wholesale, reads it
+> back, and clears it, and no one but the model can decide its fate.
+
+Byte accounting is independent of that choice. A session reports every byte it
+holds in either bucket, because the number describes what the process is
+holding, not what the manager may do about it.
+
+The consequence is worth stating plainly: **a value left in `attrs` is a value
+the byte-budget planner cannot free.** In Phase 0, which accounts but does not
+enforce, that is legitimate — but it should be a recorded decision rather than
+an accident, which is what the table below records.
+
+Note what the rule does *not* say. "Is it big" is not the criterion, and
+neither is "does it grow". The largest allocation a DreamZero session holds —
+`vae_enc_feat_map`, 603 MiB — is an *attribute*, because nothing the manager
+can do to it is useful: it is replaced wholesale, it has no recompute source,
+and freeing it mid-session breaks the encoder stream. Ending the session is the
+only release available, and that reclaims attributes anyway. Size alone argues
+for counting a value, which the accounting does regardless of bucket; it does
+not argue for a lifecycle.
+
+What would change that answer is a release the manager can perform without
+losing the value — offloading it to host memory and copying it back is
+transparent, needs no recomputation, and suits a large contiguous cache. The
+contract has no such operation: `evict()` frees storage, it does not park it.
+So the bucket follows the operations that exist, and moves if they do.
+
+### Byte accounting
+
+`SessionStateManager.stats()` reports byte totals keyed by device
+(`nbytes:cuda:0`, `nbytes:cpu`) alongside `total_nbytes`. The split is not
+cosmetic: device memory is the contended resource and host memory generally is
+not, so a single figure covering both answers no question. Which pool a budget
+applies to is a question for whoever enforces it, and is not decided here.
+
+Two details make the numbers honest. Bytes are counted per **storage**, not as
+`numel() * element_size()`, so a narrow slice reports the whole allocation it
+keeps alive rather than the part it exposes. And storages are **deduplicated**
+across the whole session, so two views of one buffer — or an alias between an
+attribute and a state object — are counted once.
+
+## Scope and guarantees
+
+- **Opt-in and equivalent.** With the flag off, models use their bespoke state
+  paths unchanged. With the flag on, the manager-backed path is validated
+  bit-identical to the bespoke path (CPU equivalence tests under
+  `tests/dreamzero/test_session_state_equivalence.py`, plus GPU A/B runs).
+- **Session eviction is count-based (LRU).** Evicting a session drops it from
+  the lookup table only; an adapter still holding the session keeps its state
+  (matching bespoke behavior, where the caller holds the state object).
+- **Byte budget is recorded, not enforced.** `SessionStateManager.stats()`
+  reports per-manager, per-device byte totals; budget *enforcement* (and
+  eviction driven by it) is a later phase of RFC #4480.
+
+## Supported models
+
+### DreamZero
+
+Sizes measured on one A100 at the shipped deploy config (`180x320` per camera,
+three cameras stitched to `352x640`, bfloat16), over a 400-step session.
+
+| Value | Bucket | Size | Notes |
+|---|---|---|---|
+| `vae_enc_feat_map` | `attrs` | **603 MiB** | Wan encoder causal-conv cache, 24 entries. Constant from ~step 50. The largest thing a session holds: 64 sessions is 37.7 GiB. Counted, not releasable — see the rule above. |
+| `video_latents_across_time` | `LatentBuffer` | grows | AR video latent chunks, host memory (`.cpu()`), kept for decode. |
+| `stitched_buffer` | `LatentBuffer` | bounded | Stitched pixel frames, host memory, ring of `FRAMES_PER_CHUNK`. |
+| `vae_encoder_out` | `LatentBuffer` | 0.43 MiB | Bounded ring of `num_frame_per_block` latent frames — see below. |
+| `clip_feas`, `ys`, `language`, `prompt_embeds` | `attrs` | small | Conditioning tensors, written once per session and reread. |
+| `vae_pending_body_frames` | `attrs` | ≤2.6 MiB | Raw frames awaiting a 4-frame body chunk; bounded by construction. |
+| `call_count`, `current_start_frame`, `vae_stream_initialized` | `attrs` | — | Counters and flags. |
+
+Attention KV does not appear here: it is engine-owned (PR #4534).
+
+**The bounded VAE encoder ring.** The bespoke state concatenates every encoded
+chunk into one tensor and clears it only on a *session* reset — a window reset
+deliberately keeps it — so it grows for as long as the session lives, at
+0.215 MiB per latent frame (one per four steps). Its only reader,
+`_vae_stream_get_observation_latents`, quantises the whole history and then
+keeps the last `num_frame_per_block` latent frames. Since `quant_conv` is a
+`WanCausalConv3d` of kernel size 1, pointwise in time, those frames do not
+depend on the discarded ones. The manager-backed state therefore retains a ring
+of `num_frame_per_block` frames instead: identical output, bounded memory, and
+the per-step quantisation no longer scales with session length. Asking for more
+frames than the ring retains raises rather than silently returning a shorter
+window. The bespoke path is unchanged.
diff --git a/docs/getting_started/installation/README.md b/docs/getting_started/installation/README.md
index 89562c53c..b49cee794 100644
--- a/docs/getting_started/installation/README.md
+++ b/docs/getting_started/installation/README.md
@@ -1,5 +1,8 @@
 # Installation
 
+!!! important
+    vLLM-Omni is released against the matching upstream vLLM major/minor version. vLLM-Omni 0.26.x requires vLLM 0.26.x; the stable v0.26.0 instructions pin vLLM 0.26.0.
+
 vLLM-Omni supports the following hardware platforms:
 
 - [GPU](gpu.md)
diff --git a/docs/getting_started/installation/gpu.md b/docs/getting_started/installation/gpu.md
index e21a11cee..59d2aa482 100644
--- a/docs/getting_started/installation/gpu.md
+++ b/docs/getting_started/installation/gpu.md
@@ -34,7 +34,7 @@ vLLM-Omni is a Python library that supports the following GPU variants. The libr
 
 ### Pre-built wheels
 
-Note: Pre-built wheels are currently available for vLLM-Omni 0.11.0rc1, 0.12.0rc1, 0.14.0rc1, 0.14.0, 0.16.0, 0.18.0, 0.20.0, 0.21.0, 0.22.0, 0.23.0, 0.24.0, and 0.25.0. If you need a newer unreleased revision, please [build from source](https://docs.vllm.ai/projects/vllm-omni/en/latest/getting_started/installation/gpu/#build-wheel-from-source).
+Note: Pre-built wheels are currently available for vLLM-Omni 0.11.0rc1, 0.12.0rc1, 0.14.0rc1, 0.14.0, 0.16.0, 0.18.0, 0.20.0, 0.21.0, 0.22.0, 0.23.0, 0.24.0, 0.25.0, and 0.26.0. If you need a newer unreleased revision, please [build from source](https://docs.vllm.ai/projects/vllm-omni/en/latest/getting_started/installation/gpu/#build-wheel-from-source).
 
 === "NVIDIA CUDA"
 
diff --git a/docs/getting_started/installation/gpu/cuda.inc.md b/docs/getting_started/installation/gpu/cuda.inc.md
index d4808139e..a68bfdb58 100644
--- a/docs/getting_started/installation/gpu/cuda.inc.md
+++ b/docs/getting_started/installation/gpu/cuda.inc.md
@@ -5,7 +5,7 @@
 # --8<-- [end:requirements]
 # --8<-- [start:set-up-using-python]
 
-vLLM-Omni depends vLLM. So please follow instructions below mainly for vLLM.
+vLLM-Omni depends on the matching major/minor release of vLLM. The vLLM-Omni 0.26.x release line uses vLLM 0.26.x.
 
 !!! note
     PyTorch installed via `conda` will statically link `NCCL` library, which can cause issues when vLLM tries to use `NCCL`. See <gh-issue:8420> for more details.
@@ -20,7 +20,7 @@ Therefore, it is recommended to install vLLM and vLLM-Omni with a **fresh new**
 
 vLLM-Omni is built based on vLLM. Please install it with command below.
 ```bash
-uv pip install vllm==0.25.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto
 ```
 
 #### Installation of vLLM-Omni
@@ -39,13 +39,13 @@ uv pip install 'vllm-omni[demo]'
 # --8<-- [start:build-wheel-from-source]
 
 #### Installation of vLLM
-If you do not need to modify source code of vLLM, you can directly install the stable 0.25.0 release version of the library
+If you do not need to modify source code of vLLM, you can directly install the stable 0.26.0 release version of the library
 
 ```bash
-uv pip install vllm==0.25.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto
 ```
 
-The 0.25.0 release of vLLM ships CUDA 13.0-compatible binaries by default. If you need a different CUDA variant or want to reuse an existing PyTorch installation, build vLLM from source instead.
+The 0.26.0 release of vLLM ships CUDA 13.0-compatible binaries by default. If you need a different CUDA variant or want to reuse an existing PyTorch installation, build vLLM from source instead.
 
 #### Installation of vLLM-Omni
 Since vllm-omni is rapidly evolving, it's recommended to install it from source
@@ -66,12 +66,12 @@ If you want to check, modify or debug with source code of vLLM, install the libr
 ```bash
 git clone https://github.com/vllm-project/vllm.git
 cd vllm
-git checkout v0.25.0
+git checkout v0.26.0
 ```
 Set up environment variables to get pre-built wheels. If there are internet problems, just download the whl file manually. And set `VLLM_PRECOMPILED_WHEEL_LOCATION` as your local absolute path of whl file.
 ```bash
-#For CUDA 13.0 (the default for v0.25.0; the wheel filename has no `+cu130` suffix)
-export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.25.0/vllm-0.25.0-cp38-abi3-manylinux_2_28_x86_64.whl
+#For CUDA 13.0 (the default for v0.26.0; the wheel filename has no `+cu130` suffix)
+export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0-cp38-abi3-manylinux_2_28_x86_64.whl
 ```
 Install vllm with command below (If you have no existing PyTorch).
 ```bash
@@ -102,7 +102,7 @@ docker run --runtime nvidia --gpus 2 \
     --env "HF_TOKEN=$HF_TOKEN" \
     -p 8091:8091 \
     --ipc=host \
-    vllm/vllm-omni:v0.25.0 \
+    vllm/vllm-omni:v0.26.0 \
     vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
@@ -124,7 +124,7 @@ If you want to specify the base vLLM version:
 ```bash
 DOCKER_BUILDKIT=1 docker build \
   -f docker/Dockerfile.cuda \
-  --build-arg BASE_IMAGE=vllm/vllm-openai:v0.22.1 \
+  --build-arg BASE_IMAGE=vllm/vllm-openai:v0.26.0 \
   -t vllm-omni-cuda .
 ```
 
diff --git a/docs/getting_started/installation/gpu/rocm.inc.md b/docs/getting_started/installation/gpu/rocm.inc.md
index 4a64e8723..c44407299 100644
--- a/docs/getting_started/installation/gpu/rocm.inc.md
+++ b/docs/getting_started/installation/gpu/rocm.inc.md
@@ -13,7 +13,7 @@ vLLM-Omni current recommends the steps in under setup through Docker Images.
 
 vLLM-Omni is built based on vLLM. Please install it with command below.
 ```bash
-uv pip install vllm==0.25.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.25.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723
 ```
 
 #### Installation of vLLM-Omni
@@ -34,13 +34,13 @@ uv pip install onnxruntime-rocm
 # --8<-- [start:build-wheel-from-source]
 
 #### Installation of vLLM
-If you do not need to modify source code of vLLM, you can directly install the stable 0.25.0 release version of the library
+If you do not need to modify source code of vLLM, you can directly install the stable 0.26.0 release version of the library
 
 ```bash
-uv pip install vllm==0.25.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.25.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723
 ```
 
-The pre-built 0.25.0 vLLM wheel targets ROCm 7.2.3. If you need a different ROCm stack or want to reuse an existing PyTorch installation, build vLLM from source instead.
+The pre-built 0.26.0 vLLM wheel targets ROCm 7.2.3. If you need a different ROCm stack or want to reuse an existing PyTorch installation, build vLLM from source instead.
 
 #### Installation of vLLM-Omni
 Since vllm-omni is rapidly evolving, it's recommended to install it from source
@@ -58,7 +58,7 @@ If you want to check, modify or debug with source code of vLLM, install the libr
 ```bash
 git clone https://github.com/vllm-project/vllm.git
 cd vllm
-git checkout v0.25.0
+git checkout v0.26.0
 python3 -m pip install -r requirements/rocm.txt
 python3 setup.py develop
 ```
@@ -130,7 +130,7 @@ docker run --rm \
   -v ~/.cache/huggingface:/root/.cache/huggingface \
   --env "HF_TOKEN=$HF_TOKEN" \
   -p 8091:8091 \
-  vllm/vllm-omni-rocm:v0.25.0 \
+  vllm/vllm-omni-rocm:v0.26.0 \
   --model Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
@@ -149,7 +149,7 @@ docker run --rm -it \
   -v ~/.cache/huggingface:/root/.cache/huggingface \
   --env "HF_TOKEN=$HF_TOKEN" \
   --entrypoint bash \
-  vllm/vllm-omni-rocm:v0.25.0
+  vllm/vllm-omni-rocm:v0.26.0
 ```
 
 # --8<-- [end:pre-built-images]
diff --git a/docs/getting_started/installation/npu/npu.inc.md b/docs/getting_started/installation/npu/npu.inc.md
index 7381f5b10..a0d4c86b0 100644
--- a/docs/getting_started/installation/npu/npu.inc.md
+++ b/docs/getting_started/installation/npu/npu.inc.md
@@ -9,8 +9,8 @@ The recommended way to use vLLM-Omni on NPU is through the vLLM-Ascend pre-built
 
 ```bash
 # vLLM-Ascend image
-# Atlas A2: quay.io/atlas-ci/vllm-ascend:v0.25.0
-# Atlas A3: quay.io/atlas-ci/vllm-ascend:v0.25.0-a3
+# Atlas A2: quay.io/atlas-ci/vllm-ascend:v0.26.0
+# Atlas A3: quay.io/atlas-ci/vllm-ascend:v0.26.0-a3
 docker run --rm \
     --name vllm-omni-npu \
     --shm-size=1g \
@@ -28,11 +28,11 @@ docker run --rm \
     -v /etc/ascend_install.info:/etc/ascend_install.info \
     -v /root/.cache:/root/.cache \
     -p 8000:8000 \
-    -it quay.io/atlas-ci/vllm-ascend:0.25.0-a3 bash
+    -it quay.io/atlas-ci/vllm-ascend:v0.26.0-a3 bash
 
 # Inside the container, install vLLM-Omni from source
 cd /vllm-workspace
-git clone -b v0.25.0 https://github.com/vllm-project/vllm-omni.git
+git clone -b v0.26.0 https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
 pip install -v -e . --no-build-isolation
 # or VLLM_OMNI_TARGET_DEVICE=npu pip install -v -e .
@@ -53,16 +53,20 @@ We are keeping [issue #886](https://github.com/vllm-project/vllm-omni/issues/886
 You can also build vLLM-Omni from the latest main branch if you want to use the latest features or bug fixes. (But sometimes it will break for a while. You can check [issue #886](https://github.com/vllm-project/vllm-omni/issues/886) for the status of the latest commit of vLLM-Omni main branch on NPU.)
 
 ```bash
-# Pin vLLM version to 0.18.0
-git clone -b v0.18.0 https://github.com/vllm-project/vllm.git
+# Pin vLLM and vLLM-Ascend to the v0.26 release line
+git clone -b v0.26.0 https://github.com/vllm-project/vllm.git
+cd vllm
 VLLM_TARGET_DEVICE=empty pip install -v -e .
+cd ..
 
-git clone -b v0.18.0rc1 https://github.com/vllm-project/vllm-ascend.git
+git clone -b releases/v0.26.0rc https://github.com/vllm-project/vllm-ascend.git
+cd vllm-ascend
 pip install -v -e .
+cd ..
 
 # Install vLLM-Omni from the latest main branch
 git clone https://github.com/vllm-project/vllm-omni.git
-cd /vllm-workspace/vllm-omni
+cd vllm-omni
 pip install -v -e . --no-build-isolation
 # or VLLM_OMNI_TARGET_DEVICE=npu pip install -v -e .
 export VLLM_WORKER_MULTIPROC_METHOD=spawn
@@ -84,8 +88,8 @@ Supported images as following.
 Here's an example deployment command that has been verified on 4 x NPUs:
 
 ```bash
-# Atlas A2: quay.io/ascend/vllm-omni:v0.25.0
-# Atlas A3: quay.io/ascend/vllm-omni:v0.25.0-a3
+# Atlas A2: quay.io/ascend/vllm-omni:v0.26.0
+# Atlas A3: quay.io/ascend/vllm-omni:v0.26.0-a3
 docker run --rm \
     --name vllm-omni-a3 \
     --shm-size=4g \
@@ -110,7 +114,7 @@ docker run --rm \
     -v /etc/ascend_install.info:/etc/ascend_install.info \
     -v ~/.cache:/root/.cache \
     -p 8091:8091 \
-    -it quay.io/ascend/vllm-omni:v0.25.0-a3 bash
+    -it quay.io/ascend/vllm-omni:v0.26.0-a3 bash
 ```
 
 !!! tip
@@ -122,9 +126,9 @@ Or build IMAGE from **source code**:
 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
 # A2
-docker build -t vllm-omni-dev-image:latest -f ./docker/Dockerfile.npu .
+# docker build -t vllm-omni-dev-image:latest -f ./docker/Dockerfile.npu .
 # A3
-# docker build -t vllm-omni-dev-image:latest -f ./docker/Dockerfile.npu.a3 .
+docker build -t vllm-omni-dev-image:latest -f ./docker/Dockerfile.npu.a3 .
 ```
 
 # --8<-- [end:pre-built-images]
diff --git a/docs/getting_started/quickstart.md b/docs/getting_started/quickstart.md
index 914f1f7b4..f9673eac7 100644
--- a/docs/getting_started/quickstart.md
+++ b/docs/getting_started/quickstart.md
@@ -19,10 +19,10 @@ uv venv --python 3.12 --seed
 source .venv/bin/activate
 
 # On CUDA
-uv pip install vllm==0.25.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto
 
 # On ROCm
-uv pip install vllm==0.25.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.25.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723
 
 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
@@ -34,7 +34,7 @@ For additional installation methods — please see the [installation guide](inst
 !!! note
     It is important to install the same major & minor version of vLLM and vLLM Omni, otherwise things may not work as expected. If the versions are misaligned, you will see a warning when you import vLLM Omni.
 
-    If you are seeing strange behavior with the `vllm` command not handling the `--omni` flag correctly, you most likely have a version mismatch with vLLM < `0.25.0` and vLLM Omni `0.25.0`, as vLLM Omni no longer hijacks the vLLM entrypoint. Updating vLLM should resolve this issue.
+    If you are seeing strange behavior with the `vllm` command not handling the `--omni` flag correctly, you most likely have a version mismatch with vLLM < `0.26.0` and vLLM Omni `0.26.0`, as vLLM Omni no longer hijacks the vLLM entrypoint. Updating vLLM should resolve this issue.
 
 ## Offline Inference
 
@@ -87,9 +87,8 @@ if __name__ == "__main__":
 
 !!! info
 
-    For diffusion request-level batching controls such as `max_num_seqs` and
-    `request_batch_max_wait_ms`, see
-    [Request-Level Batching](../user_guide/diffusion/request_batching.md).
+    For diffusion request batching, step execution, and streaming controls, see
+    [Diffusion Execution Modes](../user_guide/diffusion/execution_modes.md).
 
 For more usages, please refer to [offline inference](../user_guide/examples/offline_inference/qwen2_5_omni.md)
 
diff --git a/docs/models/supported_models.md b/docs/models/supported_models.md
index 99b17d529..d1d4e051d 100644
--- a/docs/models/supported_models.md
+++ b/docs/models/supported_models.md
@@ -41,24 +41,24 @@ th {
 | `Wan22S2VPipeline` | Wan2.2-S2V | `Wan-AI/Wan2.2-S2V-14B` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `Wan22VACEPipeline` | Wan2.1-VACE | `Wan-AI/Wan2.1-VACE-1.3B-diffusers`, `Wan-AI/Wan2.1-VACE-14B-diffusers` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `Wan22VACEPipeline` | Wan2.2-VACE | `Pyros13/Wan2.2-VACE-Fun-A14B-Diffusers` | ✅︎ |   |   |   |
-| `LTX2Pipeline` | LTX-2-T2V | `Lightricks/LTX-2` | ✅︎ | ✅︎ | | |
-| `LTX2ImageToVideoPipeline` | LTX-2-I2V | `Lightricks/LTX-2` | ✅︎ | ✅︎ | | |
-| `LTX2TwoStagesPipeline` | LTX-2-T2V | `rootonchair/LTX-2-19b-distilled` | ✅︎ | ✅︎ | | |
-| `LTX2ImageToVideoTwoStagesPipeline` | LTX-2-I2V | `rootonchair/LTX-2-19b-distilled` | ✅︎ | ✅︎ | | |
-| `LTX23Pipeline` | LTX-2.3-T2V | `dg845/LTX-2.3-Diffusers` | ✅︎ | ✅︎ | | |
-| `LTX23ImageToVideoPipeline` | LTX-2.3-I2V | `dg845/LTX-2.3-Diffusers` | ✅︎ | ✅︎ | | |
+| `LTX2Pipeline` | LTX-2 / LTX-2.3 one-stage T2V and I2V | `Lightricks/LTX-2`, `diffusers/LTX-2.3-Diffusers` | ✅︎ | ✅︎ | | |
+| `LTX2DistilledPipeline` | LTX-2 distilled two-stage T2V and I2V | `rootonchair/LTX-2-19b-distilled` | ✅︎ | ✅︎ | | |
+| `LingBotVideoPipeline` | LingBot-Video dense and MoE T2V | `robbyant/lingbot-video-dense-1.3b`, `robbyant/lingbot-video-moe-30b-a3b` | ✅︎ | | | |
+| `MiniMaxH3Pipeline` | MiniMax H3 T2VA, first/last-keyframe FL2VA, and mixed-reference Ref2VA | `MiniMaxAI/MiniMax-H3` | ✅︎ | | | |
 | `DreamZeroPipeline` | DreamZero-DROID | `GEAR-Dreams/DreamZero-DROID` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `HeliosPipeline`, `HeliosPyramidPipeline` | Helios | `BestWishYsh/Helios-Base`, `BestWishYsh/Helios-Mid`, `BestWishYsh/Helios-Distilled` | ✅︎ | ✅︎ | ✅︎ | |
 | `MagiHumanPipeline` | MagiHuman | `SII-GAIR/daVinci-MagiHuman-Base-1080p` | ✅︎ | ✅︎ | | |
 | `OvisImagePipeline` | Ovis-Image | `OvisAI/Ovis-Image` | ✅︎ | ✅︎ | | ✅︎ |
 | `LongcatImagePipeline` | LongCat-Image | `meituan-longcat/LongCat-Image` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `LongCatImageEditPipeline` | LongCat-Image-Edit | `meituan-longcat/LongCat-Image-Edit` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
+| `BooguImagePipeline` | Boogu-Image | `Boogu/Boogu-Image-0.1-Base`, `Boogu/Boogu-Image-0.1-Edit` | ✅︎ | | | |
 | `StableDiffusionXLPipeline` | Stable-Diffusion-XL | `stabilityai/stable-diffusion-xl-base-1.0` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `StableDiffusion3Pipeline` | Stable-Diffusion-3 | `stabilityai/stable-diffusion-3.5-medium` | ✅︎ | ✅︎ | | ✅︎ |
 | `CosyVoice3Model` | CosyVoice3 | `FunAudioLLM/Fun-CosyVoice3-0.5B-2512` | ✅︎ | ✅︎ | | ✅︎ |
 | `OmniVoiceModel` | OmniVoice | `k2-fsa/OmniVoice` | ✅︎ | | | |
 | `VoxCPM2TalkerForConditionalGeneration` | VoxCPM2 | `openbmb/VoxCPM2` | ✅︎ | | | |
 | `MammothModa2ForConditionalGeneration` | MammothModa2-Preview | `bytedance-research/MammothModa2-Preview` | ✅︎ | ✅︎ | | |
+| `MammothModa2ForConditionalGeneration` | MammothModa2-Dev (AR-only image understanding) | `bytedance-research/MammothModa2-Dev` | ✅︎ | | | |
 | `Flux2KleinPipeline` | FLUX.2-klein | `black-forest-labs/FLUX.2-klein-4B`, `black-forest-labs/FLUX.2-klein-9B` | ✅︎ | ✅︎ | ✅︎ | ✅︎ |
 | `FluxKontextPipeline` | FLUX.1-Kontext-dev | `black-forest-labs/FLUX.1-Kontext-dev` | ✅︎ | ✅︎ | | |
 | `FluxPipeline` | FLUX.1-dev | `black-forest-labs/FLUX.1-dev` | ✅︎ | ✅︎ | | ✅︎ |
@@ -83,7 +83,7 @@ th {
 | `MiMoAudioModel` | MiMo-Audio-7B-Instruct | `XiaomiMiMo/MiMo-Audio-7B-Instruct` | ✅︎ | ✅︎ | | |
 | `MiMoV2ASRForCausalLM` | MiMo-V2.5-ASR | `XiaomiMiMo/MiMo-V2.5-ASR` | ✅︎ | ✅︎ | | |
 | `Flux2Pipeline` | FLUX.2-dev | `black-forest-labs/FLUX.2-dev` | ✅︎ | ✅︎ | | |
-| `FishSpeechSlowARForConditionalGeneration` | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✅︎ | ✅︎ | | |
+| `FishSpeechSlowARForConditionalGeneration` | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✅︎ | ✅︎ | | ✅︎ |
 | `DreamIDOmniPipeline` | DreamID-Omni | `XuGuo699/DreamID-Omni` | ✅︎ | ✅︎ | | |
 | `SenseNovaU1Pipeline` | SenseNova-U1 (DiT-only) | `SenseNova/SenseNova-U1-8B-MoT` | ✅︎ | | | |
 | `LancePipeline` | Lance | `bytedance-research/Lance` | ✅︎ | | | |
diff --git a/docs/serving/audio_generate_api.md b/docs/serving/audio_generate_api.md
index afe693ae4..3109446c1 100644
--- a/docs/serving/audio_generate_api.md
+++ b/docs/serving/audio_generate_api.md
@@ -66,7 +66,7 @@ Content-Type: application/json
 |-----------|------|---------|-------------|
 | `input` | string | **required** | Text prompt describing the audio to generate |
 | `model` | string | server's model | Model to use (optional, should match server if specified) |
-| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, aac, opus |
+| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, opus |
 | `speed` | float | 1.0 | Playback speed (0.25 - 4.0) |
 
 #### Diffusion Parameters
@@ -90,7 +90,6 @@ Returns binary audio data with the appropriate `Content-Type` header:
 | `mp3` | `audio/mpeg` |
 | `flac` | `audio/flac` |
 | `pcm` | `audio/pcm` |
-| `aac` | `audio/aac` |
 | `opus` | `audio/opus` |
 
 ## Examples
@@ -285,7 +284,7 @@ Pydantic validation failure (e.g. invalid `response_format`, `speed` out of rang
     "detail": [
         {
             "type": "literal_error",
-            "msg": "Input should be 'wav', 'pcm', 'flac', 'mp3', 'aac' or 'opus'",
+            "msg": "Input should be 'wav', 'pcm', 'flac', 'mp3' or 'opus'",
             ...
         }
     ]
diff --git a/docs/serving/speech_api.md b/docs/serving/speech_api.md
index 27dfda95f..0deea7f8c 100644
--- a/docs/serving/speech_api.md
+++ b/docs/serving/speech_api.md
@@ -109,7 +109,7 @@ Content-Type: application/json
 | `input` | string | **required** | The text to synthesize into speech |
 | `model` | string | server's model | Model to use (optional, should match server if specified) |
 | `voice` | string | "vivian" | Speaker name (e.g., vivian, ryan, aiden) |
-| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, aac, opus |
+| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, opus |
 | `speed` | float | 1.0 | Playback speed (0.25-4.0) |
 
 #### vLLM-Omni Extension Parameters
@@ -276,20 +276,42 @@ Client -> Server:
 
 | Message | Description |
 |---------|-------------|
-| `{"type": "session.config", ...}` | Session configuration (sent once, first message) |
+| `{"type": "session.config", ...}` | Session configuration (first message; may be resent between utterances to change it) |
 | `{"type": "input.text", "text": "..."}` | Text chunk |
-| `{"type": "input.done"}` | End of input, flushes remaining buffer |
+| `{"type": "input.done"}` | End of utterance: flushes the buffer and keeps the connection open |
+| `{"type": "session.close"}` | End of connection |
 
 Server -> Client:
 
 | Message | Description |
 |---------|-------------|
-| `{"type": "audio.start", "sentence_index": 0, "sentence_text": "...", "format": "pcm", "sample_rate": 24000}` | Audio generation starting for the buffered input |
+| `{"type": "audio.start", "utterance_index": 0, "sentence_index": 0, "sentence_text": "...", "format": "pcm", "sample_rate": 24000}` | Audio generation starting for the buffered input |
 | Binary frame | Raw audio bytes (one or more PCM chunks when `stream_audio=true`) |
-| `{"type": "audio.done", "sentence_index": 0, "total_bytes": 96000, "error": false}` | Audio complete for the buffered input |
-| `{"type": "session.done", "total_sentences": N}` | Session complete |
+| `{"type": "audio.done", "utterance_index": 0, "sentence_index": 0, "total_bytes": 96000, "error": false}` | Audio complete for the buffered input |
+| `{"type": "session.done", "utterance_index": 0, "total_sentences": N}` | Flushed utterance complete |
 | `{"type": "error", "message": "..."}` | Non-fatal error |
 
+### Flushing vs. Closing
+
+`input.done` is a flush, not a disconnect. The server synthesizes the buffered
+text, emits `session.done`, and then waits on the same connection for the next
+utterance, so a client that speaks repeatedly (for example one driven by an
+upstream LLM) pays the WebSocket handshake once instead of once per utterance.
+
+* The session config is sticky. Send `input.text` again straight after
+  `session.done` to reuse it, or send another `session.config` first to change
+  voice, format, or reference audio. A `session.config` sent while text is
+  still buffered is rejected so no pending input is silently dropped.
+* An utterance is the flush unit, not a linguistic one: it is whatever text was
+  buffered when `input.done` arrived, of any length, synthesized as one request.
+  `utterance_index` counts those flushes across the connection, so it tells you
+  which `input.done` a frame belongs to. `sentence_index` counts within one
+  flush and so pairs with `total_sentences`, which means every utterance reports
+  `sentence_index: 0` of `total_sentences: 1` (or `0` for an empty buffer).
+* End the connection with `session.close`, or by closing the socket. An idle
+  connection is still closed after the server's idle timeout, which now also
+  applies to the gap between utterances.
+
 ### Session Config Parameters
 
 All REST API parameters are supported, plus:
diff --git a/docs/serving/videos_api.md b/docs/serving/videos_api.md
index 72d79c304..6a94f9dab 100644
--- a/docs/serving/videos_api.md
+++ b/docs/serving/videos_api.md
@@ -73,7 +73,7 @@ curl -L "http://localhost:8091/v1/videos/${video_id}/content" -o output.mp4
 | `audio_reference` | string | null | JSON-encoded audio reference for speech-to-video: `{"audio_url": "..."}` — supports HTTP(s) URLs or base64 data URLs |
 | `width` | integer | model default | Output video width |
 | `height` | integer | model default | Output video height |
-| `num_frames` | integer | model default | Number of generated frames |
+| `num_frames` | integer | 1 | Number of generated frames |
 | `fps` | integer | model default | Output frames per second |
 | `num_inference_steps` | integer | model default | Number of diffusion steps |
 | `guidance_scale` | number | null | CFG guidance scale for the low-noise stage |
diff --git a/docs/source/architecture/qwen3-omni-async-output-step-gap.svg b/docs/source/architecture/qwen3-omni-async-output-step-gap.svg
new file mode 100644
index 000000000..f1ccea6ee
--- /dev/null
+++ b/docs/source/architecture/qwen3-omni-async-output-step-gap.svg
@@ -0,0 +1,150 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="600" viewBox="0 0 1024 600" role="img" aria-labelledby="title desc">
+  <title id="title">Qwen3-Omni Talker step gap before and after asynchronous output materialization</title>
+  <desc id="desc">Before the optimization, synchronous D2H copy, per-request payload construction, streaming payload handoff, and connector-signal drain separate consecutive Talker forward and sample steps by about 2.8 milliseconds. After the optimization, that Omni output work runs on a background builder while the next Talker step executes, leaving a boundary of about 41 microseconds for snapshot, D2H enqueue, state update, and sampled-token feedback.</desc>
+  <defs>
+    <marker id="time-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#64748b"/>
+    </marker>
+    <marker id="red-end" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="5" markerHeight="5" orient="auto">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#b91c1c"/>
+    </marker>
+    <marker id="red-start" viewBox="0 0 10 10" refX="2" refY="5" markerWidth="5" markerHeight="5" orient="auto">
+      <path d="M 10 0 L 0 5 L 10 10 z" fill="#b91c1c"/>
+    </marker>
+    <marker id="blue-end" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#2563eb"/>
+    </marker>
+    <style>
+      .canvas { fill: #ffffff; stroke: #e5e7eb; }
+      .title { font: 700 22px system-ui, -apple-system, Segoe UI, sans-serif; fill: #111827; }
+      .subtitle { font: 500 13px system-ui, -apple-system, Segoe UI, sans-serif; fill: #64748b; }
+      .phase { font: 700 16px system-ui, -apple-system, Segoe UI, sans-serif; fill: #1f2937; }
+      .phase-sub { font: 500 12px system-ui, -apple-system, Segoe UI, sans-serif; fill: #64748b; }
+      .lane { font: 600 12px system-ui, -apple-system, Segoe UI, sans-serif; fill: #374151; }
+      .block-title { font: 700 10px system-ui, -apple-system, Segoe UI, sans-serif; letter-spacing: .25px; fill: #ffffff; }
+      .block-op { font: 500 9.5px system-ui, -apple-system, Segoe UI, sans-serif; fill: #ffffff; }
+      .axis { font: 500 11px system-ui, -apple-system, Segoe UI, sans-serif; fill: #94a3b8; }
+      .measure { font: 700 12px system-ui, -apple-system, Segoe UI, sans-serif; fill: #b91c1c; }
+      .inset-title { font: 700 11px system-ui, -apple-system, Segoe UI, sans-serif; fill: #475569; }
+      .inset-step { font: 600 10px system-ui, -apple-system, Segoe UI, sans-serif; fill: #ffffff; }
+      .note-title { font: 700 12px system-ui, -apple-system, Segoe UI, sans-serif; fill: #1e3a8a; }
+      .note-text { font: 500 10.5px system-ui, -apple-system, Segoe UI, sans-serif; fill: #475569; }
+      .stat-cap { font: 600 11px system-ui, -apple-system, Segoe UI, sans-serif; fill: #64748b; }
+      .stat-big { font: 800 16px system-ui, -apple-system, Segoe UI, sans-serif; fill: #111827; }
+      .stat-sub { font: 500 11px system-ui, -apple-system, Segoe UI, sans-serif; fill: #64748b; }
+      .before-card { fill: #eef4ff; stroke: #c7dbf6; }
+      .after-card { fill: #eafaf0; stroke: #bfe7cf; }
+      .talker { fill: #16a34a; }
+      .sync-output { fill: #ea580c; }
+      .async-output { fill: #2563eb; }
+      .zoom-card { fill: #fff7f7; stroke: #f3caca; }
+      .note-card { fill: #eff6ff; stroke: #bfdbfe; }
+      .stat-blue { fill: #eef4ff; stroke: #c7dbf6; }
+      .stat-green { fill: #eafaf0; stroke: #bfe7cf; }
+      .stat-gray { fill: #f4f5f7; stroke: #e2e5ea; }
+      .guide { stroke: #e2e8f0; stroke-width: 1; }
+      .time-line { stroke: #64748b; stroke-width: 1.3; fill: none; marker-end: url(#time-arrow); }
+      .measure-line { stroke: #b91c1c; stroke-width: 1.4; marker-start: url(#red-start); marker-end: url(#red-end); }
+      .zoom-lead { stroke: #dc2626; stroke-width: 1.15; stroke-dasharray: 4 3; fill: none; }
+      .handoff { stroke: #2563eb; stroke-width: 1.3; stroke-dasharray: 3 2; fill: none; marker-end: url(#blue-end); }
+    </style>
+  </defs>
+
+  <rect x="14" y="14" width="996" height="572" rx="14" class="canvas"/>
+
+  <text x="44" y="52" class="title">Async output: what moves off the Talker decode path</text>
+  <text x="44" y="74" class="subtitle">Qwen3-Omni Talker stage &#183; consecutive decode steps in a fixed profiler window</text>
+
+  <!-- ===================== BEFORE ===================== -->
+  <rect x="44" y="94" width="144" height="110" rx="10" class="before-card"/>
+  <text x="60" y="120" class="phase">Before</text>
+  <text x="60" y="139" class="phase-sub">Omni output built</text>
+  <text x="60" y="156" class="phase-sub">synchronously on the</text>
+  <text x="60" y="173" class="phase-sub">AR critical path</text>
+
+  <text x="206" y="122" class="lane">AR path</text>
+  <line x1="300" y1="88" x2="300" y2="210" class="guide"/>
+
+  <rect x="300" y="104" width="190" height="54" rx="5" class="talker"/>
+  <text x="395" y="124" text-anchor="middle" class="block-title">TALKER STAGE &#183; STEP N</text>
+  <text x="395" y="145" text-anchor="middle" class="block-op">forward &#8594; sample</text>
+
+  <rect x="490" y="104" width="250" height="54" rx="5" class="sync-output"/>
+  <text x="615" y="120" text-anchor="middle" class="block-title">SYNC OMNI OUTPUT &#183; STEP N</text>
+  <text x="615" y="138" text-anchor="middle" class="block-op">D2H &#8594; per-request slice / payload build</text>
+  <text x="615" y="152" text-anchor="middle" class="block-op">streaming handoff &#8594; connector-signal drain</text>
+
+  <rect x="740" y="104" width="220" height="54" rx="5" class="talker"/>
+  <text x="850" y="124" text-anchor="middle" class="block-title">TALKER STAGE &#183; STEP N+1</text>
+  <text x="850" y="145" text-anchor="middle" class="block-op">forward &#8594; sample</text>
+
+  <line x1="490" y1="174" x2="740" y2="174" class="measure-line"/>
+  <text x="615" y="194" text-anchor="middle" class="measure">~2.8 ms GPU gap: output work is inline</text>
+
+  <!-- ===================== AFTER ===================== -->
+  <rect x="44" y="218" width="144" height="140" rx="10" class="after-card"/>
+  <text x="60" y="244" class="phase">After</text>
+  <text x="60" y="263" class="phase-sub">Only step feedback</text>
+  <text x="60" y="280" class="phase-sub">stays inline; payload</text>
+  <text x="60" y="297" class="phase-sub">work runs in the</text>
+  <text x="60" y="314" class="phase-sub">background</text>
+
+  <text x="206" y="254" class="lane">Talker GPU</text>
+  <text x="206" y="326" class="lane">Output builder</text>
+  <line x1="300" y1="212" x2="300" y2="370" class="guide"/>
+
+  <rect x="300" y="226" width="235" height="54" rx="5" class="talker"/>
+  <text x="418" y="246" text-anchor="middle" class="block-title">TALKER STAGE &#183; STEP N</text>
+  <text x="418" y="267" text-anchor="middle" class="block-op">forward &#8594; sample</text>
+
+  <rect x="540" y="226" width="235" height="54" rx="5" class="talker"/>
+  <text x="658" y="246" text-anchor="middle" class="block-title">TALKER STAGE &#183; STEP N+1</text>
+  <text x="658" y="267" text-anchor="middle" class="block-op">forward &#8594; sample</text>
+
+  <path d="M 535 280 L 548 298" class="handoff"/>
+  <rect x="540" y="298" width="360" height="58" rx="5" class="async-output"/>
+  <text x="720" y="315" text-anchor="middle" class="block-title">BACKGROUND OMNI OUTPUT &#183; STEP N</text>
+  <text x="720" y="334" text-anchor="middle" class="block-op">wait for D2H &#8594; per-request slice / payload build</text>
+  <text x="720" y="349" text-anchor="middle" class="block-op">streaming handoff &#8594; connector-signal drain</text>
+
+  <line x1="300" y1="366" x2="930" y2="366" class="time-line"/>
+  <text x="922" y="382" text-anchor="end" class="axis">time</text>
+
+  <!-- leads from the real 41 us boundary to the magnified inset -->
+  <line x1="535" y1="280" x2="485" y2="424" class="zoom-lead"/>
+  <line x1="540" y1="280" x2="525" y2="424" class="zoom-lead"/>
+
+  <!-- ===================== 41 µs BOUNDARY ===================== -->
+  <rect x="300" y="386" width="400" height="92" rx="10" class="zoom-card"/>
+  <text x="316" y="404" class="inset-title">Zoom &#183; Talker step boundary (magnified)</text>
+
+  <rect x="320" y="416" width="165" height="26" rx="4" class="talker"/>
+  <rect x="525" y="416" width="155" height="26" rx="4" class="talker"/>
+  <text x="403" y="433" text-anchor="middle" class="inset-step">Talker step N</text>
+  <text x="603" y="433" text-anchor="middle" class="inset-step">Talker step N+1</text>
+
+  <line x1="485" y1="452" x2="525" y2="452" class="measure-line"/>
+  <text x="505" y="469" text-anchor="middle" class="measure">~41 &#181;s</text>
+
+  <rect x="720" y="386" width="240" height="92" rx="10" class="note-card"/>
+  <text x="736" y="405" class="note-title">Inline at the ~41 &#181;s boundary</text>
+  <text x="736" y="424" class="note-text">&#8226; eager Talker state update</text>
+  <text x="736" y="441" class="note-text">&#8226; output snapshot + D2H enqueue</text>
+  <text x="736" y="458" class="note-text">&#8226; sampled-token feedback</text>
+
+  <!-- ===================== SUMMARY ===================== -->
+  <rect x="44" y="494" width="296" height="70" rx="9" class="stat-blue"/>
+  <text x="60" y="514" class="stat-cap">Step-to-step gap</text>
+  <text x="60" y="538" class="stat-big">2.8 ms &#8594; 41 &#181;s</text>
+  <text x="60" y="555" class="stat-sub">~68&#215; tighter</text>
+
+  <rect x="356" y="494" width="296" height="70" rx="9" class="stat-green"/>
+  <text x="372" y="514" class="stat-cap">Talker GPU</text>
+  <text x="372" y="538" class="stat-big">next step starts immediately</text>
+  <text x="372" y="555" class="stat-sub">decode workers stay busy</text>
+
+  <rect x="668" y="494" width="312" height="70" rx="9" class="stat-gray"/>
+  <text x="684" y="514" class="stat-cap">Background builder</text>
+  <text x="684" y="538" class="stat-big">materializes Omni output</text>
+  <text x="684" y="555" class="stat-sub">payload work overlaps the next Talker step</text>
+</svg>
diff --git a/docs/user_guide/diffusion/attention_backends.md b/docs/user_guide/diffusion/attention_backends.md
index 50e02971f..7dc35b367 100644
--- a/docs/user_guide/diffusion/attention_backends.md
+++ b/docs/user_guide/diffusion/attention_backends.md
@@ -14,7 +14,8 @@ The full set of backends and their platform defaults is in the **Backend Options
 
 | Value | Notes |
 |---|---|
-| `FLASH_ATTN` | Wraps FlashAttention 2. Default on Hopper / Ada / Ampere when `flash-attn` is installed. |
+| `TRTLLM_ATTN` | FlashInfer's trtllm-gen FMHA (TensorRT-LLM's generated kernels, vendored by FlashInfer). Dense BF16, GQA native, `head_dim=128`. Datacenter Blackwell only (sm_100 / sm_103). Packed paths can provide `cu_seqlens` directly. Supports optional **Skip-Softmax** sparse attention — see below. Requires `flashinfer`. |
+| `FLASH_ATTN` | Wraps FlashAttention 4 on Blackwell when `flash-attn-4` is installed, then falls back to FlashAttention 3/2. Default on Hopper / Ada / Ampere when a compatible FlashAttention package is installed. |
 | `CUDNN_ATTN` | Pins `sdpa_kernel([CUDNN_ATTENTION])`. Default on Blackwell (sm_10x / sm_12x) with cuDNN ≥ 9.5. Wins on mask-heavy DiTs (HunyuanVideo-1.5: 2× e2e vs SDPA). |
 | `FLASHINFER_ATTN` | Calls FlashInfer's dense `single_prefill_with_kv_cache` directly with `custom_mask` for non-causal masked attention. Used as Blackwell fallback when cuDNN is unavailable. Requires `flashinfer`. |
 | `TORCH_SDPA` | PyTorch `scaled_dot_product_attention` with the default backend dispatcher. Most conservative; always available. |
@@ -22,6 +23,7 @@ The full set of backends and their platform defaults is in the **Backend Options
 | `SAGE_ATTN_3` | Requires `sageattn3` from `SageAttention/sageattention3_blackwell`. CUDA only, intended for Blackwell GPUs, with GQA/MQA requests falling back to PyTorch SDPA. |
 | `FLASH_ATTN_HUB` | FlashAttention 2 from HuggingFace `kernels` library. Useful for train/rollout alignment. |
 | `FLASH_ATTN_3_HUB` | FlashAttention 3 from HuggingFace `kernels` library. CUDA Hopper (sm_90+) only; falls back to `FLASH_ATTN_HUB` on older GPUs. |
+| `RAINFUSION_ATTN` | MindIE-SD **RainFusion** block-sparse video attention — see [below](#rainfusion_attn-backend-and-block-sparse-video-attention). Ascend NPU only; requires `mindiesd`. Delegates to `FLASH_ATTN` for anything that is not a packed video sequence. |
 
 
 ## Configuration
@@ -68,11 +70,13 @@ vllm-omni serve <model> \
     --diffusion-attention-config '{"default":{"backend":"FLASH_ATTN"},"per_role":{"cross":{"backend":"TORCH_SDPA"}}}'
 ```
 
-Backends may also accept backend-specific parameters via `extra`:
+A backend that needs configuration exposes it as a typed field on the spec:
+`TRTLLM_ATTN`'s Skip-Softmax (see [below](#trtllm_attn-backend-and-skip-softmax)) and
+`RAINFUSION_ATTN`'s RainFusion block (see [below](#rainfusion_attn-backend-and-block-sparse-video-attention)):
 
 ```bash
---diffusion-attention-config.per_role.self.backend SPARSE_BLOCK \
---diffusion-attention-config.per_role.self.extra.block_size 128
+--diffusion-attention-config.default.backend TRTLLM_ATTN \
+--diffusion-attention-config.default.skip_softmax.target_sparsity 0.5
 ```
 
 ### Programmatic API
@@ -101,10 +105,15 @@ A plain dict is also accepted and normalized to `AttentionConfig`.
 
 Auto-route preference, in order:
 
-1. `CUDNN_ATTN` — when cuDNN ≥ 9.5 is available (ships in PyTorch 2.5+ wheels)
-2. `FLASHINFER_ATTN` — when `flashinfer` is installed but cuDNN < 9.5
-3. `FLASH_ATTN` — when `flash-attn` is installed with the Blackwell CUTE kernel
-4. `TORCH_SDPA` — last resort
+1. `TRTLLM_ATTN` — on **datacenter** Blackwell (sm_100 / sm_103) when `flashinfer` is installed, the model's `head_dim` is 128, **and the model declares a compatible packed/mask-free path**
+2. `CUDNN_ATTN` — when cuDNN ≥ 9.5 is available (ships in PyTorch 2.5+ wheels)
+3. `FLASHINFER_ATTN` — when `flashinfer` is installed but cuDNN < 9.5
+4. `FLASH_ATTN` — when `flash-attn` is installed with the Blackwell CUTE kernel
+5. `TORCH_SDPA` — last resort
+
+`TRTLLM_ATTN` is skipped on workstation Blackwell (sm_120 / sm_121) and for any `head_dim != 128`, so those GPUs keep the `CUDNN_ATTN` route described below.
+
+`TRTLLM_ATTN` outranks `CUDNN_ATTN` on datacenter Blackwell for compatible packed/mask-free pipelines. Workstation Blackwell (sm_120 / sm_121) and pipelines that require attention masks retain their normal fallback.
 
 The startup log line `Defaulting to diffusion attention backend CUDNN_ATTN (Blackwell sm_120, cuDNN 91002)` confirms the route.
 
@@ -119,6 +128,158 @@ Auto-route preference:
 
 `CUDNN_ATTN` and `FLASHINFER_ATTN` are still selectable via env var on these GPUs but are not in the auto-route — FlashAttention 2 is the well-tuned path on pre-Blackwell hardware.
 
+## TRTLLM_ATTN Backend and Skip-Softmax
+
+`TRTLLM_ATTN` runs FlashInfer's trtllm-gen FMHA. Dense it is a BF16 backend like the others; on top of
+that it can enable **Skip-Softmax**, a sparse-attention mode that trades a little fidelity for speed
+(algorithm: [design doc](../../design/feature/skip_softmax.md)).
+
+Enable it through the typed `skip_softmax` block on the attention spec:
+
+| Key | Valid values | Meaning |
+|---|---|---|
+| `target_sparsity` | finite, `[0, 1]` | Operating point on a calibrated curve. Needs a calibration for the model. |
+| `threshold` | finite, `≥ 0` | Direct threshold, no calibration needed. Mutually exclusive with `target_sparsity`. |
+| `disabled_until_timestep` | finite, `[0, 1]` | Holds early, high-noise steps dense; skip turns on once the normalized timestep `t ≤ D`. |
+
+```bash
+vllm-omni serve Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --diffusion-attention-config '{"default": {"backend": "TRTLLM_ATTN",
+      "skip_softmax": {"target_sparsity": 0.65, "disabled_until_timestep": 0.86}}}'
+```
+
+Programmatically the same block is a typed `SkipSoftmaxSpec` (values validated at construction):
+
+```python
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, SkipSoftmaxSpec
+
+AttentionConfig(
+    default=AttentionSpec(
+        backend="TRTLLM_ATTN",
+        skip_softmax=SkipSoftmaxSpec(target_sparsity=0.65, disabled_until_timestep=0.86),
+    ),
+)
+```
+
+**Start at `target_sparsity=0.65, disabled_until_timestep=0.86`** and raise `target_sparsity` only
+as far as your quality bar allows — the output diverges from dense as it climbs. The gain grows with
+sequence length, since Skip-Softmax only accelerates attention. Dense BF16 is `TRTLLM_ATTN` with no
+`skip_softmax` block.
+
+Requires datacenter Blackwell with `head_dim == 128`; elsewhere, or without FlashInfer, selecting
+`TRTLLM_ATTN` raises rather than silently degrading.
+
+## TRTLLM_ATTN SAGE Quantization
+
+On top of dense/Skip-Softmax, `TRTLLM_ATTN` can run **SAGE** (SageAttention) — the trtllm-gen
+FMHA kernel with per-block quantized Q/K and per-channel fp8 V, so the two attention matmuls run
+in low precision. Enable it through the typed `quant` block on the attention spec:
+
+| Key | Valid values | Meaning |
+|---|---|---|
+| `dtype_qk` | `int8`, `fp8_e4m3` | Quantization dtype for Q and K. Absent ⇒ dense (SAGE off). |
+| `q_block_size` | `1`, `4`, `16` | Per-token block size for Q scales (default `1`). |
+| `k_block_size` | `1`, `4`, `16` | Per-token block size for K scales (default `16`). |
+
+V is always quantized per-channel to fp8_e4m3 and K-smoothing is applied inside the routine, so
+neither is a user knob. Only block sizes `1`, `4`, `16` have compiled kernels.
+
+The `quant` block is a shared `AttnQuantSpec` consumed by more than one backend; each reads the
+fields that apply and rejects the rest. `TRTLLM_ATTN` (SAGE) reads `dtype_qk` (`int8` / `fp8_e4m3`),
+`q_block_size`, and `k_block_size`; `FLASHINFER_ATTN` reads `dtype_qk` (`float16` / `bfloat16`),
+`dtype_vo`, and `flashinfer_backend` (see its section). A `dtype_qk` from the wrong set raises.
+
+```bash
+vllm-omni serve Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --diffusion-attention-config '{"default": {"backend": "TRTLLM_ATTN",
+      "quant": {"dtype_qk": "fp8_e4m3", "q_block_size": 1, "k_block_size": 16}}}'
+```
+
+```python
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, AttnQuantSpec
+
+AttentionConfig(
+    default=AttentionSpec(
+        backend="TRTLLM_ATTN",
+        quant=AttnQuantSpec(dtype_qk="fp8_e4m3", q_block_size=1, k_block_size=16),
+    ),
+)
+```
+
+**Requirements.** Needs FlashInfer ≥ 0.6.16rc1. Kernel
+availability is arch-dependent: `fp8_e4m3` QK has kernels on both **SM100** (B200) and **SM103**
+(B300); `int8` QK kernels are compiled for **SM100 only**.
+
+## RAINFUSION_ATTN Backend and Block-Sparse Video Attention
+
+`RAINFUSION_ATTN` runs MindIE-SD's RainFusion (`rf_v2`) kernel on Ascend NPU. It pools each
+128-token block of keys, ranks them per query block, and computes attention against only the
+top-scoring ones. Video tokens are rearranged into `(t, h, w)` order first, so the kept blocks are
+spatiotemporal neighbours rather than arbitrary rows of the packed sequence.
+
+Only the video segment is sparsified. The prefix rows (text, visual conditions, audio) and the
+first-frame blocks are always kept dense, which is why the realized sparsity is lower than the
+nominal `sparsity` you configure. Anything the kernel cannot handle — a warmup denoise step, an
+exempt layer, a sequence with no published video geometry, a video segment under 32 blocks —
+delegates to `FLASH_ATTN`, so a model can select this backend unconditionally.
+
+Enable it through the typed `block_sparse` block on the attention spec, shared by every
+block-sparse backend:
+
+| Key | Valid values | Meaning |
+|---|---|---|
+| `sparsity` | finite, `[0, 1]` | Nominal fraction of key blocks dropped per query block. `0` disables sparsity. Defaults to `0.8`. |
+| `start_step` | `≥ 0` | Keep the first N denoise steps dense. Layout is decided early, so these steps dominate structural fidelity. |
+| `skip_layers` | index selector, e.g. `"0-3,38"` | DiT blocks that always stay dense. |
+
+```bash
+vllm-omni serve MiniMaxAI/MiniMax-H3 \
+  --diffusion-attention-config '{"default": {"backend": "RAINFUSION_ATTN",
+      "block_sparse": {"sparsity": 0.8, "start_step": 0}}}'
+```
+
+Programmatically the same block is a typed `BlockSparseSpec` (values validated at construction):
+
+```python
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, BlockSparseSpec
+
+AttentionConfig(
+    default=AttentionSpec(
+        backend="RAINFUSION_ATTN",
+        block_sparse=BlockSparseSpec(sparsity=0.8, start_step=0, skip_layers="0-1"),
+    ),
+)
+```
+
+**Tune in the order `start_step` → `sparsity` → `skip_layers`.** Raise `start_step` first: it is the
+cheapest way to recover structure, because the early high-noise steps decide global layout while the
+later steps only refine texture. Then walk `sparsity` up to your quality bar. Reach for
+`skip_layers` last, once an A/B against dense at the same seed points at specific blocks.
+
+Requires Ascend NPU with `mindiesd`; selecting it on any other platform raises. It is also
+incompatible with ring sequence parallelism, since `rf_v2` needs the whole key sequence to rank
+blocks — use Ulysses SP (`ring_degree=1`).
+
+### Which geometries run sparse
+
+Sparsity is only applied when the video segment is a **multiple of 128 rows**, where the row count
+is `latent_t × (height / 32) × (width / 32)`. Otherwise `rf_v2`'s block mask and the kernel's own
+tiling disagree on the block count, and the block straddling the seam mixes video and prefix rows
+that selection may then drop. Any resolution still runs — an unaligned geometry falls back to dense
+attention and logs `RAINFUSION_ATTN staying dense` with the row count it computed — but it gets no
+speedup, so pick an aligned geometry when you want one.
+
+Alignment is necessary, not sufficient, for good quality. `rf_v2` groups video positions into 8x8
+spatial tiles (two tiles fill one 128-row block), which is what makes a selected block a compact
+patch of the frame. When the latent `h` or `w` is not a multiple of 8, the leftover rows or columns
+are peeled off and appended as a flat run instead of being tiled, so they get pooled with spatially
+distant positions and selection can no longer rank them meaningfully. This is silent, and invisible
+to a `sparsity=0` check, because a fully populated mask does not care how blocks are grouped.
+
+"Multiple of 8" on the latent grid means **width and height that are multiples of 256**. Aligned
+resolutions off that grid still run sparse; they just lose more fidelity at the same `sparsity`,
+which you can buy back with `start_step`.
+
 ## End-to-End Benchmark (BF16, sm_120 RTX Pro 6000 Blackwell)
 
 Same prompt and seed across runs. `Total generation time` from `text_to_video.py` / `text_to_image.py`.
@@ -145,9 +306,17 @@ DIFFUSION_ATTENTION_BACKEND=FLASHINFER_ATTN python examples/offline_inference/te
     --model Lightricks/LTX-2 ...
 ```
 
-### FA4 not yet integrated
+### FlashAttention-4 on Blackwell
 
-FlashAttention-4 (released March 2026) targets Blackwell natively and reportedly beats cuDNN by ~20% on B200. As of this writing the `flash-attn-4 4.0.0b10` wheel crashes with `AttributeError: 'NoneType' object has no attribute '_trait'` during JIT on sm_120. Not yet wired into vLLM-Omni; revisit when stable lands.
+Install the optional CUDA 13 extra to use the CuTe-based FA4 path:
+
+```bash
+pip install 'vllm-omni[fa4]'
+```
+
+`FLASH_ATTN` prefers `flash_attn.cute` on Blackwell and falls back to FA3/FA2
+when it is unavailable. Version `4.0.0b18` is required; earlier beta
+wheels had known JIT failures on Blackwell.
 
 ## Choosing a Backend Manually
 
@@ -305,64 +474,3 @@ DIFFUSION_ATTENTION_BACKEND=SAGE_ATTN_3 python examples/offline_inference/text_t
     --tensor-parallel-size 2 \
     --output outputs/hv15_sage3.mp4
 ```
-
-### Mixed backends across roles
-
-Use `FLASH_ATTN` for self-attention and `TORCH_SDPA` for cross-attention:
-
-```bash
-python examples/offline_inference/text_to_video/text_to_video.py \
-    --model Wan-AI/Wan2.2-TI2V-5B-Diffusers \
-    --prompt "A dog running across a field of golden wheat." \
-    --diffusion-attention-config.per_role.self.backend FLASH_ATTN \
-    --diffusion-attention-config.per_role.cross.backend TORCH_SDPA \
-    --tensor-parallel-size 2 \
-    --output outputs/wan22_mixed.mp4
-```
-
-### Compare against FlashAttention
-
-Unset the backend override, or explicitly use `FLASH_ATTN`:
-
-```bash
-python examples/offline_inference/text_to_video/text_to_video.py \
-    --model Wan-AI/Wan2.2-TI2V-5B-Diffusers \
-    --prompt "A dog running across a field of golden wheat." \
-    --height 704 --width 1280 --num-frames 49 \
-    --num-inference-steps 30 --seed 42 --guidance-scale 5.0 \
-    --tensor-parallel-size 2 \
-    --output outputs/wan22_fa3.mp4
-```
-
-## Validation Guidance
-
-Don't assume a faster attention backend is numerically interchangeable with `TORCH_SDPA`.
-
-Always compare:
-
-- End-to-end runtime
-- Diffusion-stage runtime (`add_req_and_wait` line in DiffusionEngine.step breakdown)
-- Output quality against a known-good baseline (CLIP similarity, frame-level diff, or visual review)
-
-At minimum, keep the same:
-
-- model
-- prompt
-- seed
-- resolution
-- frame count / step count
-- parallel config (TP / CFG-parallel / Ulysses degrees)
-
-## Reproducing the Benchmark Table
-
-The end-to-end numbers above were collected by running `text_to_video.py` /
-`text_to_image.py` with the same prompt and seed while varying
-`DIFFUSION_ATTENTION_BACKEND`. For a quick kernel-level comparison of the
-backends without loading a model:
-
-```bash
-python benchmarks/diffusion/bench_attention_backends.py --preset hv15
-```
-
-It runs all three BF16 backends on representative DiT attention shapes and
-prints a ranking table at the end.
diff --git a/docs/user_guide/diffusion/cpu_offload_diffusion.md b/docs/user_guide/diffusion/cpu_offload.md
similarity index 56%
rename from docs/user_guide/diffusion/cpu_offload_diffusion.md
rename to docs/user_guide/diffusion/cpu_offload.md
index d6fcd8944..02ab9f074 100644
--- a/docs/user_guide/diffusion/cpu_offload_diffusion.md
+++ b/docs/user_guide/diffusion/cpu_offload.md
@@ -179,7 +179,145 @@ class Flux2Transformer2DModel(nn.Module):
 - Support single GPU only for now
 
 
-### Implementation Notes
+## Distributed Layerwise Offloading
+
+### How It Works
+
+Distributed layerwise offloading extends single-GPU layerwise offloading to
+multi-device deployments. In the default mode, each rank stores only
+**1/dp_size** of the model weights in host memory; full layer weights are
+reconstructed at runtime via **AllGather** on a dedicated communication stream,
+overlapped with computation via a fixed double-buffer scheme. The
+`--dlo-no-use-allgather` mode instead streams standard-loader rank-local
+weights independently and does not shard weights across ranks.
+
+For the implementation design and compatibility matrix, see
+[Distributed Layerwise Offload](../../design/feature/distributed_layerwise_offload.md).
+
+**Key features:**
+- **Weight sharding + AllGather**: each rank stores 1/dp_size of weights,
+  reconstructed per-layer via `all_gather_into_tensor`
+- **Fixed double-buffer**: exactly 2 transformer blocks on each device at any
+  time, regardless of model size
+- **DP multi-concurrency**: N concurrent requests processed in parallel
+  (AllGather only gathers weight shards, which are request-independent)
+- **mmap weight loading**: weights loaded as mmap views pointing to shared OS
+  page cache, eliminating O(dp_size × model_size) RSS during model creation
+- **Platform-agnostic**: works on NVIDIA GPU (CUDA/NCCL) and Ascend NPU
+  (CANN/HCCL) via vLLM-Omni's platform abstraction
+
+**Execution Flow (per device):**
+
+```
+Compute Stream:  [Layer N]          [Layer N+1]          [Layer N+2]
+H2D Stream:      [H2D Shard N+1]   [H2D Shard N+2]
+AllGather:       [AG N+1]          [AG N+2]
+Slot Usage:      Slot0: Layer N    Slot1: Layer N+1
+```
+
+### Usage
+
+**CLI:**
+```bash
+# 4× GPU/NPU with AllGather (recommended)
+vllm serve /path/to/model --omni \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 4
+
+# Without DLO AllGather (each rank streams standard-loader rank-local weights)
+vllm serve /path/to/model --omni \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 4 \
+  --dlo-no-use-allgather
+
+# With SP instead of DP (long sequences)
+vllm serve /path/to/model --omni \
+  --enable-distributed-layerwise-offload \
+  --usp 4
+```
+
+**Python API:**
+```python
+from vllm_omni import Omni
+
+m = Omni(
+    model="/path/to/model",
+    enable_distributed_layerwise_offload=True,
+    dlo_use_allgather=True,  # default
+)
+```
+
+### CLI Flags
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--enable-distributed-layerwise-offload` | Enable DLO | `false` |
+| `--data-parallel-size N` | Number of DP ranks; DLO weight-sharding group when AllGather is enabled | `1` |
+| `--dlo-use-allgather` | Shard + AllGather (saves CPU, requires concurrent requests) | `true` |
+| `--dlo-no-use-allgather` | Use standard-loader rank-local weights; no DLO sharding or AllGather | `false` |
+
+### How model weights are loaded (mmap path)
+
+When DLO + AllGather is active, the offloader:
+
+1. **Saves non-persistent buffers** (e.g. RoPE `inv_freq`, timestep `freqs`)
+   from the normally-created transformer
+2. **Converts to meta device** via `to_empty(device="meta")`, releasing random
+   initialization weights
+3. **Loads checkpoint weights as mmap views** via `safe_open().get_tensor()`,
+   which return views into the OS page cache (shared across all ranks, 0 RSS)
+4. **Calls `post_load_weights()`** to apply model-specific dtype conversions
+   (e.g. Cosmos3's `time_embedder` → FP32)
+5. **Restores non-persistent buffers** from saved copies
+
+This approach requires **zero model-specific code changes** — no pipeline or
+transformer modifications are needed.
+
+### OffloadPlan (declarative topology metadata)
+
+Models can optionally declare an `OffloadPlan` class variable to provide
+topology metadata (block attribute names, submodules to offload) without
+any offload-specific logic:
+
+```python
+from vllm_omni.diffusion.offloader import OffloadPlan
+
+class MyPipeline(nn.Module):
+    _dit_modules = ["transformer"]
+    _offload_plan = OffloadPlan(
+        block_attrs={"transformer": ("blocks",)},
+        offload_submodules={"context_encoder": "layers"},
+    )
+```
+
+When not declared, the offloader falls back to `_layerwise_offload_blocks_attrs`
+and heuristic attribute search.  This is backward-compatible — existing models
+work without any changes.
+
+### DP Multi-concurrency
+
+When `--data-parallel-size > 1` and AllGather is enabled, the scheduler batches
+up to `dp_size` requests per denoise step.  Each DP rank processes a different
+request while AllGather synchronizes only weight shards (request-independent).
+
+**Requirements for concurrent requests:**
+- `num_inference_steps` must be specified explicitly (None is not allowed)
+- All concurrent requests must have the same `num_inference_steps` value
+- These constraints exist because AllGather is a collective that requires
+  every rank to participate at each denoise step
+
+### Limitations
+- Online quantization (FP8) is incompatible with mmap loading — falls back to
+  regular loading only when the model is outside the DLO+AllGather mmap path;
+  online quantization with DLO+AllGather is rejected. Use
+  `--dlo-no-use-allgather` or disable online quantization.
+- Tensor Parallel > 1 is rejected in the DLO+AllGather mmap path because TP-aware
+  weight-loader callbacks are bypassed. The no-AllGather path retains the
+  standard TP loader and is experimental.
+- HSDP + AllGather is rejected because it would double-shard parameters. HSDP
+  with no-AllGather is accepted at configuration level, but has limited
+  end-to-end validation.
+- `num_inference_steps=None` is not allowed in DP multi-concurrency mode
 
 **Module Discovery**
 
@@ -208,7 +346,10 @@ OffloadBackend (base class)
 ├── ModelLevelOffloadBackend → uses SequentialOffloadHook (.to() swap)
 │                              (delegates to a pipeline's enable_omni_model_cpu_offload
 │                               for split models like Cosmos3)
-└── LayerWiseOffloadBackend → uses LayerwiseOffloadHook
+├── LayerWiseOffloadBackend → uses LayerwiseOffloadHook
+│                          (single-GPU, full weights on host)
+└── DistributedLayerwiseOffloadBackend → uses DistributedLayerwiseOffloadHook
+                                         (multi-GPU, sharded AllGather or rank-local mode)
 ```
 
 Factory function `get_offload_backend()` selects the appropriate backend based on
@@ -221,19 +362,28 @@ reasoner/generator components inside the model forward pass.
 
 ## Supported Models
 
-| Architecture | Example Models | DiT Class | Model-Level Offload | Layerwise Offload | Blocks Attrs (Layerwise specific) |
-|--------------|----------------|-----------|---------------------|-------------------|-----------------------------------|
-| LongCatImagePipeline | `meituan-longcat/LongCat-Image` | `LongCatImageTransformer2DModel` | - | ✓ | `"transformer_blocks"`, `"single_transformer_blocks"` |
-| NextStep11Pipeline | `stepfun-ai/NextStep-1.1` | `NextStepModel` | - | ✓ | `"layers"` |
-| OvisImagePipeline | `AIDC-AI/Ovis-Image-7B` | `OvisImageTransformer2DModel` | - | ✓ | `"transformer"` |
-| QwenImagePipeline | `Qwen/Qwen-Image` | `QwenImageTransformer2DModel` | ✓ | ✓ | `"transformer_blocks"` |
-| StableDiffusionXLPipeline | `stabilityai/stable-diffusion-xl-base-1.0` | `SDXLUNet2DConditionModel` | ✓ | ✓ | `"down_blocks"`, `"up_blocks"` |
-| StableDiffusion3Pipeline | `stabilityai/stable-diffusion-3.5-medium` | `SD3Transformer2DModel` | - | ✓ | `"transformer_blocks"` |
-| Wan22I2VPipeline | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` | `WanTransformer3DModel` | ✓ | ✓ | `"blocks"` |
-| Wan22Pipeline | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | `WanTransformer3DModel` | ✓ | ✓ | `"blocks"` |
-| SoulXSingerPipeline / SoulXSingerSVCPipeline | `Soul-AILab/SoulX-Singer` | `DiffLlama` (`cfm_decoder.model.diff_estimator`) | ✓ | ✓ | `"layers"` |
-| BagelPipeline | `ByteDance-Seed/BAGEL-7B-MoT` | `Qwen2MoTModel` | - | ✓ | `"layers"`, `"customized modules"` |
+| Architecture | Example Models | DiT Class | Model-Level Offload | Layerwise Offload | Distributed Layerwise Offload | Blocks Attrs (Layerwise specific) |
+|--------------|----------------|-----------|---------------------|-------------------|-------------------------------|-----------------------------------|
+| Flux2Pipeline | `black-forest-labs/FLUX.2-dev` | `Flux2Transformer2DModel` | ✓ | ✓ | - | `"transformer_blocks"`, `"single_transformer_blocks"` |
+| LongCatImagePipeline | `meituan-longcat/LongCat-Image` | `LongCatImageTransformer2DModel` | - | ✓ | - | `"transformer_blocks"`, `"single_transformer_blocks"` |
+| NextStep11Pipeline | `stepfun-ai/NextStep-1.1` | `NextStepModel` | - | ✓ | - | `"layers"` |
+| OvisImagePipeline | `AIDC-AI/Ovis-Image-7B` | `OvisImageTransformer2DModel` | - | ✓ | - | `"transformer"` |
+| QwenImagePipeline | `Qwen/Qwen-Image` | `QwenImageTransformer2DModel` | ✓ | ✓ | - | `"transformer_blocks"` |
+| StableDiffusionXLPipeline | `stabilityai/stable-diffusion-xl-base-1.0` | `SDXLUNet2DConditionModel` | ✓ | ✓ | - | `"down_blocks"`, `"up_blocks"` |
+| StableDiffusion3Pipeline | `stabilityai/stable-diffusion-3.5-medium` | `SD3Transformer2DModel` | - | ✓ | - | `"transformer_blocks"` |
+| Wan22I2VPipeline | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` | `WanTransformer3DModel` | ✓ | ✓ | - | `"blocks"` |
+| Wan22Pipeline | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | `WanTransformer3DModel` | ✓ | ✓ | - | `"blocks"` |
+| SoulXSingerPipeline / SoulXSingerSVCPipeline | `Soul-AILab/SoulX-Singer` | `DiffLlama` (`cfm_decoder.model.diff_estimator`) | ✓ | ✓ | - | `"layers"` |
+| BagelPipeline | `ByteDance-Seed/BAGEL-7B-MoT` | `Qwen2MoTModel` | - | ✓ | - | `"layers"`, `"customized modules"` |
+| Cosmos3OmniDiffusersPipeline | `nvidia/Cosmos3-Nano`, `nvidia/Cosmos3-Super` | `Cosmos3VFMTransformer`, `Cosmos3LanguageModel` | ✓ | ✓ | ✓ | `"layers"`, `"gen_layers"` |
 
 **Notes:**
 - Model-Level Offloading is expected to be supported by all common diffusion models (DiT and encoders) naturally
 - Layerwise Offloading requires DiT class to define `_layerwise_offload_blocks_attrs` pointing to transformer blocks
+- Distributed Layerwise Offloading reuses the layerwise block topology, but the
+  model and parallelism combination still needs validation. AllGather mode
+  additionally requires a compatible checkpoint/mmap layout; no-AllGather mode
+  retains the standard loader's rank-local tensors. See the
+  [DLO design](../../design/feature/distributed_layerwise_offload.md) and
+  [Cosmos3 DistOffload recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/cosmos3/Cosmos3-DistOffload.md)
+  for usage examples.
diff --git a/docs/user_guide/diffusion/execution_modes.md b/docs/user_guide/diffusion/execution_modes.md
new file mode 100644
index 000000000..9611a8210
--- /dev/null
+++ b/docs/user_guide/diffusion/execution_modes.md
@@ -0,0 +1,252 @@
+# Diffusion Execution Modes
+
+vLLM-Omni supports complete-request execution and step-wise diffusion
+execution. Both modes use the same asynchronous engine output stream; the
+configuration controls how work is scheduled and whether intermediate outputs
+are exposed.
+
+## Choose a Mode
+
+| Goal | CLI configuration |
+|---|---|
+| Serial request execution | `--max-num-seqs 1` |
+| Fused request-level batching | `--max-num-seqs N` |
+| Single-request step execution | `--step-execution --max-num-seqs 1` |
+| Step-wise continuous batching | `--step-execution --max-num-seqs N` |
+| Chunked diffusion output | `--diffusion-streaming-output` |
+
+`N` must be greater than `1` to allow batching. The selected pipeline must
+support request-level batching or batched-step execution as appropriate;
+single-request step support alone is not sufficient for step-wise continuous
+batching.
+
+## Request Execution
+
+Request execution is the default when `--step-execution` is omitted. The
+pipeline performs a complete `forward()` for each scheduler wave.
+
+### Serial Requests
+
+Use the conservative serial path with any request-mode pipeline:
+
+```bash
+vllm serve MODEL --omni \
+  --port 8091 \
+  --max-num-seqs 1
+```
+
+### Request-Level Batching
+
+Set `max_num_seqs` above one to combine compatible independent requests into a
+single pipeline forward:
+
+```bash
+vllm serve Qwen/Qwen-Image --omni \
+  --port 8091 \
+  --max-num-seqs 4
+```
+
+For bursty traffic, add a small admission window:
+
+```bash
+vllm serve Qwen/Qwen-Image --omni \
+  --port 8091 \
+  --max-num-seqs 4 \
+  --request-batch-max-wait-ms 20
+```
+
+`--request-batch-max-wait-ms 0` is the default. A nonzero value can improve
+batch formation but adds up to that much latency before a new scheduler wave.
+It has no effect in step mode.
+
+Each prompt remains a separate logical request. Do not submit a top-level list
+as one packed prompt. Concurrent serving requests are batched internally when
+their shapes, guidance settings, output counts, and LoRA settings are
+compatible.
+
+Only pipelines that declare request-batch support accept
+`max_num_seqs>1` in request mode. Unsupported pipelines fail during engine
+initialization; use `max_num_seqs=1` instead.
+
+## Step Execution
+
+Step execution lets the scheduler advance and abort requests between denoise
+steps:
+
+```bash
+vllm serve Qwen/Qwen-Image --omni \
+  --port 8091 \
+  --step-execution \
+  --max-num-seqs 1
+```
+
+Set a larger capacity to allow compatible requests to share denoise waves:
+
+```bash
+vllm serve Qwen/Qwen-Image --omni \
+  --port 8091 \
+  --step-execution \
+  --max-num-seqs 8
+```
+
+Step continuous batching is experimental. Start with `max_num_seqs=1` when
+validating a model or debugging correctness, then increase it for
+multi-request throughput.
+
+Step execution is capability-based, not a generic switch for every diffusion
+model. Qwen-Image supports step-wise continuous batching. HunyuanImage3 also
+supports it, but only when its resolved self-attention backend is `TORCH_SDPA`;
+set `DIFFUSION_ATTENTION_BACKEND=TORCH_SDPA` or configure
+`diffusion_attention_config.default.backend=TORCH_SDPA` before using
+`--max-num-seqs >1`. See the
+[HunyuanImage-3.0 recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/Tencent/HunyuanImage-3.0-Instruct.md)
+for its validated configuration. Helios supports single-request step execution only: use
+`--step-execution --max-num-seqs 1` for Helios. Consult the selected pipeline's
+documentation and source for the latest support status.
+
+## Streaming Output
+
+Use `--diffusion-streaming-output` for a pipeline that can produce intermediate
+diffusion outputs:
+
+```bash
+vllm serve BestWishYsh/Helios-Distilled --omni \
+  --port 8000 \
+  --diffusion-streaming-output
+```
+
+Streaming output requires step execution. If
+`--diffusion-streaming-output` is set without `--step-execution`, the engine
+enables step execution automatically. Model initialization fails if the
+pipeline does not implement step execution.
+
+Chunk-capable pipelines emit intermediate and final outputs through the same
+request stream. Final-only step pipelines emit only the final result even when
+streaming output is enabled.
+
+The normal non-streaming serving path uses the same internal stream but drains
+it and returns only the final output. Users do not need to enable
+`--diffusion-streaming-output` to benefit from the unified engine lifecycle.
+
+## Send Requests
+
+Execution-mode flags configure the server. They do not change the
+OpenAI-compatible client request format. For example, after starting any of
+the non-streaming configurations above:
+
+```bash
+curl -X POST http://localhost:8091/v1/images/generations \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "a cat sitting on a windowsill",
+    "size": "1024x1024",
+    "num_inference_steps": 50,
+    "seed": 42
+  }' | jq -r '.data[0].b64_json' | base64 -d > cat.png
+```
+
+To create a request-level batch, send multiple independent requests
+concurrently. Do not put several prompts into one `prompt` field:
+
+```bash
+for prompt in "a red fox" "a blue bird" "a green frog"; do
+  curl -s -X POST http://localhost:8091/v1/images/generations \
+    -H "Content-Type: application/json" \
+    -d "{\"prompt\":\"${prompt}\",\"size\":\"1024x1024\",\"seed\":42}" \
+    > /dev/null &
+done
+wait
+```
+
+The scheduler may batch these requests when their sampling parameters are
+compatible. See the
+[Image Generation API](../../serving/image_generation_api.md) for response
+formats and additional client examples. Streaming models can use
+model-specific streaming endpoints documented by their serving guide.
+
+## Python API
+
+The Python arguments mirror the CLI flags:
+
+```python
+from vllm_omni import Omni
+
+omni = Omni(
+    model="Qwen/Qwen-Image",
+    max_num_seqs=4,
+    request_batch_max_wait_ms=20.0,
+)
+
+outputs = omni.generate(
+    [
+        "a cup of coffee on a table",
+        "a toy dinosaur on a sandy beach",
+        "a fox waking up in bed and yawning",
+    ]
+)
+```
+
+Each list item passed to `Omni.generate()` becomes an independent logical
+request that the scheduler may batch with compatible items.
+
+For step execution:
+
+```python
+from vllm_omni import Omni
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+omni = Omni(
+    model="Qwen/Qwen-Image",
+    step_execution=True,
+    max_num_seqs=1,
+)
+
+outputs = omni.generate(
+    "A cat sitting on a windowsill",
+    OmniDiffusionSamplingParams(num_inference_steps=50),
+)
+```
+
+## Stage Configuration
+
+Use the equivalent engine arguments in a deployment YAML:
+
+```yaml
+stage_args:
+  - stage_id: 0
+    stage_type: diffusion
+    engine_args:
+      step_execution: false
+      max_num_seqs: 4
+      request_batch_max_wait_ms: 20
+```
+
+For step execution, set `step_execution: true` and remove
+`request_batch_max_wait_ms`.
+
+## CLI Reference
+
+| Flag | Default | Effect |
+|---|---:|---|
+| `--step-execution` | disabled | Select step-wise scheduling |
+| `--max-num-seqs` | `1` for diffusion stages | Set request- or step-scheduler capacity |
+| `--request-batch-max-wait-ms` | `0` | Wait for burst coalescing in request mode |
+| `--diffusion-streaming-output` | disabled | Expose supported intermediate diffusion outputs and require step execution |
+
+## Limitations and Troubleshooting
+
+- Requests batch only when their compatibility-sensitive parameters match.
+- Different LoRA adapters or scales run in separate batches.
+- FIFO scheduling can cause an incompatible request to block later compatible
+  requests.
+- All diffusion cache backends are unsupported in step mode. KV transfer is
+  supported for newly admitted step requests; some other request-mode extras
+  remain unsupported.
+- If request-mode startup reports that the pipeline does not support batching,
+  use `--max-num-seqs 1`.
+- If step-mode startup mentions `prepare_encode()`, `denoise_step()`,
+  `step_scheduler()`, or `post_decode()`, the pipeline does not implement the
+  required step contract.
+
+For implementation details and model-author guidance, see
+[Diffusion Continuous Batching](../../design/feature/diffusion_continuous_batching.md).
diff --git a/docs/user_guide/diffusion/regional_compilation.md b/docs/user_guide/diffusion/regional_compilation.md
new file mode 100644
index 000000000..469a62b2c
--- /dev/null
+++ b/docs/user_guide/diffusion/regional_compilation.md
@@ -0,0 +1,38 @@
+# Regional Compilation
+
+Regional compilation applies `torch.compile` to the repeated transformer blocks
+declared by a diffusion model. It is the default compilation scope when
+diffusion inference runs without `--enforce-eager`.
+
+## Configuration
+
+Dynamic compilation is enabled by default so the compiled regions can handle
+mixed resolutions. For a fixed-shape workload, disable it explicitly:
+
+```bash
+vllm serve <model> --omni --no-diffusion-compile-dynamic
+```
+
+The equivalent per-stage deploy configuration is:
+
+```yaml
+stages:
+  - stage_id: 0
+    diffusion_compile_granularity: regional
+    diffusion_compile_dynamic: false
+```
+
+For an experimental whole-transformer compile scope, set
+`--diffusion-compile-granularity full` or use
+`diffusion_compile_granularity: full` in the stage configuration. Full scope may
+still contain graph breaks; it does not force one graph. It is rejected when
+HSDP, sequence parallelism, CPU offload, or layerwise offload is enabled. Use
+regional scope with those features.
+
+These settings control the generic model-runner compilation path. Pipelines
+that provide their own `setup_compile()` implementation manage their compilation
+policy independently. Compilation is lazy, so backend or graph errors can first
+surface on the initial request.
+
+Use `--enforce-eager` to disable the model runner's generic compile setup.
+Pipelines that compile internally define their own eager-mode behavior.
diff --git a/docs/user_guide/diffusion/request_batching.md b/docs/user_guide/diffusion/request_batching.md
deleted file mode 100644
index 5cd24802b..000000000
--- a/docs/user_guide/diffusion/request_batching.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Request-Level Batching
-
-Request-level batching lets diffusion serving combine multiple compatible
-logical requests into one pipeline `forward()` call. Each prompt remains a
-separate request with its own `request_id`, sampling parameters, seed, output,
-error, and abort state. The scheduler decides which requests can run together.
-
-!!! warning "Prompt List Semantics"
-
-    Diffusion request-level batching does not support a top-level packed
-    list-prompt request. Submit multiple prompts as independent requests and let
-    the scheduler batch compatible in-flight requests. Multimodal payloads stay
-    inside a single prompt dict, for example
-    `{"prompt": "...", "multi_modal_data": {"image": image}}`.
-
-## Enablement
-
-Increase `max_num_seqs` above `1` to allow the request scheduler to keep more
-than one compatible request active:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --max-num-seqs 4
-```
-
-For bursty online traffic, you can also set a small admission wait window. This
-lets the engine wait briefly before the first `schedule()` of a new wave so
-nearby compatible requests can arrive and share the same fused forward pass:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --max-num-seqs 4 \
-  --request-batch-max-wait-ms 20
-```
-
-`--request-batch-max-wait-ms 0` is the default and disables admission waiting,
-so there is no added wait latency.
-
-For deploy YAMLs, configure the diffusion stage engine args:
-
-```yaml
-stage_args:
-  - stage_id: 0
-    stage_type: diffusion
-    engine_args:
-      max_num_seqs: 4
-      request_batch_max_wait_ms: 20
-```
-
-## Compatibility
-
-Only pipelines that declare request-batch support use the fused request-batch
-path. The engine validates that the pipeline `forward()` uses the request-batch
-contract and returns `list[DiffusionOutput]`. Pipelines that do not support this
-contract do not use fused `pipeline.forward(batch)`; scheduled requests are
-executed through per-request worker calls.
-
-The scheduler batches only compatible requests. Compatibility is based on
-shape-sensitive and guidance-sensitive sampling fields, including resolution,
-frame count, CFG settings, output count, and LoRA identity. Requests with
-different LoRA adapters or scales are kept in separate batches so the worker
-activates one adapter per batch.
-
-Request-level batching applies when `step_execution=False`. For the separate
-step-wise runtime, see [Step Execution](step_execution.md).
-
-## Tuning
-
-- `max_num_seqs` caps the number of active compatible requests in one scheduler
-  wave.
-- `request_batch_max_wait_ms` is an upper bound on extra admission wait before a
-  new wave starts. Keep it small for latency-sensitive serving; values such as
-  `10` to `50` ms are a practical starting range for bursty HTTP ingress.
-- `0` disables admission waiting and preserves the lowest first-request latency.
-- FIFO ordering is conservative: an incompatible request at the front of the
-  waiting queue can block later compatible requests from joining the current
-  batch.
-
-## Python API
-
-When constructing `Omni`, pass the same engine arguments:
-
-```python
-from vllm_omni.entrypoints.omni import Omni
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    max_num_seqs=4,
-    request_batch_max_wait_ms=20.0,
-)
-
-outputs = omni.generate(
-    [
-        "a cup of coffee on a table",
-        "a toy dinosaur on a sandy beach",
-        "a fox waking up in bed and yawning",
-    ]
-)
-```
-
-`Omni.generate([...])` submits each list item as its own logical diffusion
-request. The runtime may batch those requests internally when their sampling
-parameters are compatible.
-
-## For Contributors
-
-For implementation details and model-author guidance, see
-[Request-Level Batching for Diffusion](../../design/feature/diffusion_request_level_batching.md).
diff --git a/docs/user_guide/diffusion/step_execution.md b/docs/user_guide/diffusion/step_execution.md
deleted file mode 100644
index 07184a787..000000000
--- a/docs/user_guide/diffusion/step_execution.md
+++ /dev/null
@@ -1,95 +0,0 @@
-# Step Execution
-
-Step execution is an opt-in diffusion execution mode enabled with
-`step_execution=True` when constructing `Omni`.
-
-It is not a generic diffusion toggle for every pipeline. Only pipelines that
-implement the stepwise contract support it today.
-
-## Quick Start
-
-### Python API
-
-```python
-from vllm_omni import Omni
-from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    step_execution=True,
-)
-
-outputs = omni.generate(
-    "A cat sitting on a windowsill",
-    OmniDiffusionSamplingParams(
-        num_inference_steps=50,
-    ),
-)
-```
-
-### Serving
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --port 8091 \
-  --step-execution \
-  --max-num-seqs 8
-```
-
-For serving, `--step-execution` enables the step-wise runtime. Continuous
-batching only becomes relevant when `--max-num-seqs > 1`.
-
-## Supported Pipelines
-
-| Pipeline | Example models | Step execution |
-|----------|----------------|----------------|
-| `QwenImagePipeline` | `Qwen/Qwen-Image`, `Qwen/Qwen-Image-2512` | Yes |
-| All other diffusion pipelines | `QwenImageEditPipeline`, `QwenImageEditPlusPipeline`, `QwenImageLayeredPipeline`, GLM-Image, Wan, Flux, etc. | No |
-
-!!! warning "Experimental continuous batching"
-    When `--step-execution` is enabled and `max_num_seqs > 1` is configured,
-    the step-wise path can batch
-    compatible requests together. This is experimental. Requests with
-    incompatible sampling parameters are intentionally kept in separate batches,
-    and `max_num_seqs=1` remains the conservative default.
-
-## Current Limitations
-
-- Continuous batching under `step_execution` is experimental and only batches
-  compatible requests.
-- `cache_backend` is not supported together with step execution.
-- Unsupported pipelines fail early during model loading.
-- Request-mode extras such as KV transfer are not wired into step mode yet.
-- LoRA is supported in step mode, but each batch must use a single adapter:
-  requests with different `lora_request` or `lora_scale` are scheduled into
-  separate batches.
-
-## When To Use It
-
-Use step execution only when you specifically need the pipeline to run through
-its stepwise request state machine. For normal diffusion inference, leave it
-disabled unless your workflow depends on this mode.
-
-For Qwen-Image online serving, the usual progression is:
-
-- start with `--step-execution --max-num-seqs 1` if you only need the step-wise path
-- increase `--max-num-seqs` after that if you want the experimental compatible-request batching behavior
-
-If you are looking for general diffusion speedups, see
-[Diffusion Features Overview](../diffusion_features.md).
-
-## Troubleshooting
-
-If model loading fails with a message mentioning `prepare_encode()`,
-`denoise_step()`, `step_scheduler()`, and `post_decode()`, the selected
-pipeline does not support step execution.
-
-## For Model Authors
-
-If you want to add step execution support to a new diffusion pipeline, see the
-implementation guide:
-[Diffusion Step Execution Design](../../design/feature/diffusion_step_execution.md).
-
-If you also want that pipeline to participate in the experimental batched
-step-wise path, see:
-[Continuous Batching for Step-Wise Diffusion](../../design/feature/diffusion_continuous_batching.md).
diff --git a/docs/user_guide/diffusion_features.md b/docs/user_guide/diffusion_features.md
index d3ed3bd67..83bc3643e 100644
--- a/docs/user_guide/diffusion_features.md
+++ b/docs/user_guide/diffusion_features.md
@@ -59,7 +59,7 @@ Memory optimization methods help reduce GPU memory usage, enabling inference on
 
 | Method | Description | Best For |
 |--------|-------------|----------|
-| **[CPU Offload](diffusion/cpu_offload_diffusion.md)** | Offloads model components to CPU memory | Limited VRAM, large models on consumer GPUs |
+| **[CPU Offload](diffusion/cpu_offload.md)** | Offloads model components to CPU memory | Limited VRAM, large models on consumer GPUs |
 | **[Quantization](quantization/overview.md)** | Reduces transformer stages from BF16 to FP8/INT8/etc. | Limited VRAM, minimal accuracy loss    |
 | **[VAE Parallelism](diffusion/parallelism/vae_parallelism.md)** | Distributes VAE decode work across GPUs | High-resolution generation with reduced VAE memory peak |
 
@@ -80,12 +80,11 @@ denoise steps.
 
 | Method | Description | Best For |
 |--------|-------------|----------|
-| **[Request-Level Batching](diffusion/request_batching.md)** | Scheduler batches compatible independent diffusion requests into one pipeline forward pass | Bursty online serving and multi-request throughput |
-| **[Step Execution](diffusion/step_execution.md)** | Per-step denoise execution with mid-request abort support | Request cancellation between denoise steps, fine-grained execution control |
+| **[Diffusion Execution Modes](diffusion/execution_modes.md)** | Configures serial requests, request batching, step execution, continuous batching, and streaming output | Matching latency, throughput, cancellation, and output-delivery requirements |
 
-**Note:** Request-level batching is available for pipelines that declare the
-request-batch forward contract. Step execution is currently supported by
-QwenImagePipeline only. See [Supported Models](#supported-models) for details.
+**Note:** Request-level batching and step execution are capability-based.
+Consult the execution guide and the selected pipeline's documentation for
+current support.
 
 ### Quantization Methods
 
@@ -105,8 +104,8 @@ The following tables show which models support each feature:
 
 > Notes:
 
-> 1. CPU Offload has two methods: Module-wise (default for models with DiT + text encoder) and Layerwise. The tables below show **Layerwise support** only. Split models like Cosmos3 (no separate text encoder) swap their reasoner/generator components for module-wise offload; see the [CPU Offload Guide](diffusion/cpu_offload_diffusion.md).
-> 2. The **💾Quantization** column is collapsed for readability. See [Quantization Overview](quantization/overview.md) for per-method and per-model support details.
+> 1. CPU Offload has two methods: Module-wise (default for models with DiT + text encoder) and Layerwise. The tables below show **Layerwise support** only. Split models like Cosmos3 (no separate text encoder) swap their reasoner/generator components for module-wise offload; see the [CPU Offload Guide](diffusion/cpu_offload.md).
+> 2. The **💾Quantization** column is collapsed for readability. See [Quantization](quantization/overview.md) for per-method and per-model support details.
 
 ### ImageGen
 
@@ -116,8 +115,8 @@ The following tables show which models support each feature:
 | **FLUX.1-dev**           |     ✅     |     ✅      |           ❌           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ✅        |        ❌         |
 | **FLUX.1-schnell**       |     ❌     |     ✅      |           ❌           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ✅        |        ❌         |
 | **FLUX.2-klein**         |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ✅        |        ❌         |
-| **FLUX.1-Kontext-dev**   |     ❌     |     ❌      |           ❌           |       ❌        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ❌        |        ❌         |
-| **FLUX.2-dev**           |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ❌        |        ❌         |
+| **FLUX.1-Kontext-dev**   |     ❌     |     ✅      |           ❌           |       ❌        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ❌        |        ❌         |
+| **FLUX.2-dev**           |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ✅    |             ✅             |          ✅           |       ❌        |        ❌         |
 | **GLM-Image**            |     ❌     |     ❌      |           ❌           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ❌        |        ❌         |
 | **Hidream-I1-Full**        |     ❌     |     ❌      |           ❌           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ❌        |        ❌         |
 | **HunyuanImage3**        |     ❌     |     ✅      |           ❌           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ✅        |        ❌         |
@@ -154,13 +153,13 @@ The following tables show which models support each feature:
 | **Wan2.2**                   |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ✅         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ❌        |        ❌         |
 | **Wan2.2-S2V**               |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ❌        |        ❌         |
 | **Wan2.1-VACE**              |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
-| **LTX-2**                    |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ❌         |
-| **LTX-2.3**                  |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ❌    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
+| **LTX-2**                    |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
+| **LTX-2.3**                  |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
 | **Helios**                   |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **HunyuanVideo-1.5 T2V I2V** |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ✅        |        ❌         |
 | **DreamID-Omni**             |     ❌     |     ❌      |           ❌           |       ✅        |         ❌         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **Cosmos3**                  |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ✅        |        ❌         |
-
+| **MiniMax-H3**               |     ❌     |     ✅      |           ✅           |       ❌        |       ✅ (DiT/TE)  |         ❌         |   ✅    |             ✅             |       ✅ (tile)       |      ✅ (DiT)      |        ❌         |
 
 **Frame Interpolation Support**
 
@@ -206,7 +205,7 @@ The following tables show which models support each feature:
     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.
-    6. Step Execution is not compatible with cache backends (TeaCache, Cache-DiT). 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).
+    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
@@ -275,9 +274,9 @@ Measured on NVIDIA H800:
 
 **Memory Optimization:**
 
-- **[CPU Offload Guide](diffusion/cpu_offload_diffusion.md)** - Offload model components to CPU, reduce GPU memory usage
+- **[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 Overview](quantization/overview.md)** - Overview of quantization methods for diffusion, multi-stage omni/TTS, and multi-stage diffusion models
+- **[Quantization](quantization/overview.md)** - Quantization methods for diffusion, multi-stage omni/TTS, and multi-stage diffusion models
 
 **Extensions:**
 
@@ -286,7 +285,7 @@ Measured on NVIDIA H800:
 
 **Execution Modes:**
 
-- **[Step Execution Guide](diffusion/step_execution.md)** - Per-step denoise execution with mid-request abort support
+- **[Diffusion Execution Modes](diffusion/execution_modes.md)** - Configure request batching, step execution, continuous batching, and streaming output
 
 **Startup Optimization:**
 
diff --git a/docs/user_guide/examples/offline_inference/bagel.md b/docs/user_guide/examples/offline_inference/bagel.md
deleted file mode 100644
index 391c41b35..000000000
--- a/docs/user_guide/examples/offline_inference/bagel.md
+++ /dev/null
@@ -1,287 +0,0 @@
-# BAGEL-7B-MoT
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/bagel>.
-
-## Setup
-
-Please refer to the [stage configuration documentation](https://docs.vllm.ai/projects/vllm-omni/en/latest/configuration/stage_configs/) to configure memory allocation appropriately for your hardware setup.
-
-## Architecture
-
-BAGEL-7B-MoT is a Mixture-of-Transformers (MoT) model supporting both image generation and understanding. It offers two deployment topologies:
-
-| Topology | Stages | Description |
-| :------- | :----- | :---------- |
-| **Two-stage** (default) | Stage 0 (Thinker, AR) + Stage 1 (DiT, Diffusion) | Thinker handles text/understanding via vLLM AR engine; DiT handles image generation. KV cache is transferred between stages. |
-| **Single-stage** | Stage 0 (DiT, Diffusion) only | The DiT stage contains a full LLM, ViT, VAE, and tokenizer internally. All modalities are handled within a single diffusion process. |
-
-Both topologies support all four modalities: `text2img`, `img2img`, `img2text`, `text2text`.
-
-## Quick Start
-
-```bash
-cd examples/offline_inference/bagel
-
-# Default two-stage mode (auto-detected)
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat"
-
-# Single-stage mode
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat" \
-                  --deploy-config vllm_omni/deploy/bagel_single_stage.yaml
-```
-
-> **Note**: These examples work with the default configuration on an **NVIDIA A100 (80GB)**. For dual-GPU setups, modify the deploy YAML to distribute stages across devices.
-
-## Modality Control
-
-Control the mode using the `--modality` argument:
-
-| Modality | Input | Output | Description |
-| :------- | :---- | :----- | :---------- |
-| `text2img` | Text | Image | Generate images from text prompts |
-| `img2img` | Image + Text | Image | Transform images using text guidance |
-| `img2text` | Image + Text | Text | Generate text descriptions from images |
-| `text2text` | Text | Text | Pure text generation (language model mode) |
-
-### Text to Image (text2img)
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat" \
-                  --steps 50
-```
-
-### Image to Image (img2img)
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality img2img \
-                  --image-path /path/to/image.jpg \
-                  --prompts "Let the woman wear a blue dress"
-```
-
-### Image to Text (img2text)
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality img2text \
-                  --image-path /path/to/image.jpg \
-                  --prompts "Describe this image in detail"
-```
-
-### Text to Text (text2text)
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2text \
-                  --prompts "What is the capital of France?"
-
-# Load prompts from a text file (one prompt per line):
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2text \
-                  --txt-prompts /path/to/prompts.txt
-```
-
-## Think Mode
-
-Think mode enables the model to generate `<think>...</think>` planning/reasoning tokens before producing the final output. This improves generation quality for complex prompts.
-
-- **Two-stage**: The Thinker (AR) stage decodes think tokens, then transfers the augmented KV cache to the DiT stage for image generation.
-- **Single-stage**: The DiT's internal LLM generates think tokens in-place before proceeding to denoise.
-
-```bash
-# Think + text2img: plan before generating
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A futuristic city with flying cars" \
-                  --think \
-                  --max-think-tokens 1000
-
-# Think + img2img: reason about the edit
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality img2img \
-                  --image-path /path/to/image.jpg \
-                  --prompts "Make it look like a watercolor painting" \
-                  --think
-
-# Think + img2text: reason before describing
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality img2text \
-                  --image-path /path/to/image.jpg \
-                  --prompts "What is happening in this image?" \
-                  --think
-
-# Think + text2text: chain-of-thought reasoning
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2text \
-                  --prompts "Solve: 23 * 47" \
-                  --think
-```
-
-Think mode parameters:
-
-| Argument | Default | Description |
-| :------- | :------ | :---------- |
-| `--think` | `False` | Enable thinking mode |
-| `--max-think-tokens` | `1000` | Maximum tokens for think generation |
-| `--do-sample` | `False` | Enable sampling (vs. greedy) for text generation |
-| `--text-temperature` | `0.3` | Temperature for text generation sampling |
-
-## Classifier-Free Guidance (CFG)
-
-CFG controls the trade-off between prompt fidelity and diversity. These parameters apply to image generation modalities (`text2img`, `img2img`).
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A photorealistic portrait" \
-                  --cfg-text-scale 6.0 \
-                  --cfg-img-scale 2.0 \
-                  --negative-prompt "blurry, low quality, distorted" \
-                  --cfg-interval 0.4 1.0 \
-                  --cfg-renorm-type global \
-                  --cfg-renorm-min 0.0
-```
-
-| Argument | Default | Description |
-| :------- | :------ | :---------- |
-| `--cfg-text-scale` | `4.0` | Text CFG scale (higher = more prompt-adherent) |
-| `--cfg-img-scale` | `1.5` | Image CFG scale (for img2img) |
-| `--negative-prompt` | `None` | Negative prompt for CFG conditioning |
-| `--cfg-interval` | pipeline default | CFG active interval `[start, end]` as fractions of total timesteps |
-| `--cfg-renorm-type` | `None` | Renormalization type: `global`, `text_channel`, `channel` |
-| `--cfg-renorm-min` | `None` | Minimum renormalization value |
-| `--cfg-parallel-size` | `1` | CFG parallel size: `1` = batched (single GPU), `2` = 2-branch parallel, `3` = full 3-GPU parallel |
-
-## Deployment Topologies
-
-### Two-Stage (Default)
-
-The default topology auto-detected from the model. No extra flags needed.
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat"
-```
-
-The pipeline is defined in [`bagel.yaml`](https://github.com/vllm-project/vllm-omni/tree/main/vllm_omni/deploy/bagel.yaml). Stage 0 (Thinker) and Stage 1 (DiT) share GPU 0 by default. For dual-GPU setups, customize the deploy YAML and set `devices: "1"` for stage 1.
-
-### Single-Stage
-
-Pass the single-stage deploy config via `--deploy-config`:
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat" \
-                  --deploy-config vllm_omni/deploy/bagel_single_stage.yaml
-```
-
-See [`bagel_single_stage.yaml`](https://github.com/vllm-project/vllm-omni/tree/main/vllm_omni/deploy/bagel_single_stage.yaml) for configuration details. The `pipeline: bagel_single_stage` field selects the single-stage topology from the pipeline registry.
-
-### Tensor Parallelism (TP)
-
-For larger models or multi-GPU environments, customize the deploy YAML (see [`bagel.yaml`](https://github.com/vllm-project/vllm-omni/tree/main/vllm_omni/deploy/bagel.yaml)) and set per-stage `tensor_parallel_size` and `devices`:
-
-```yaml
-# Example: TP=2 on GPUs 0,1 for the Thinker stage
-stages:
-  - stage_id: 0
-    tensor_parallel_size: 2
-    devices: "0,1"
-```
-
-Then pass the custom deploy YAML:
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat" \
-                  --deploy-config /path/to/custom_bagel.yaml
-```
-
-### FP8 Quantization
-
-```bash
-python end2end.py --model ByteDance-Seed/BAGEL-7B-MoT \
-                  --modality text2img \
-                  --prompts "A cute cat" \
-                  --quantization fp8
-```
-
-## Command Line Reference
-
-### Core Arguments
-
-| Argument | Type | Default | Description |
-| :------- | :--- | :------ | :---------- |
-| `--model` | string | `ByteDance-Seed/BAGEL-7B-MoT` | Model path or HuggingFace name |
-| `--modality` | choice | `text2img` | `text2img`, `img2img`, `img2text`, `text2text` |
-| `--prompts` | list | `None` | Input text prompts |
-| `--txt-prompts` | string | `None` | Path to text file with one prompt per line |
-| `--image-path` | string | `None` | Input image path (required for `img2img`/`img2text`) |
-| `--output` | string | `.` | Output directory for saved images |
-| `--steps` | int | `50` | Number of diffusion inference steps |
-| `--seed` | int | `None` | Random seed for reproducibility |
-
-### Think Mode Arguments
-
-| Argument | Type | Default | Description |
-| :------- | :--- | :------ | :---------- |
-| `--think` | flag | `False` | Enable `<think>...</think>` planning/reasoning |
-| `--max-think-tokens` | int | `1000` | Maximum tokens for think generation |
-| `--do-sample` | flag | `False` | Use sampling instead of greedy decoding |
-| `--text-temperature` | float | `0.3` | Sampling temperature for text generation |
-
-### CFG Arguments
-
-| Argument | Type | Default | Description |
-| :------- | :--- | :------ | :---------- |
-| `--cfg-text-scale` | float | `4.0` | Text CFG guidance scale |
-| `--cfg-img-scale` | float | `1.5` | Image CFG guidance scale |
-| `--negative-prompt` | string | `None` | Negative prompt for CFG |
-| `--cfg-parallel-size` | int | `1` | CFG parallel GPU count (1, 2, or 3) |
-| `--cfg-interval` | float[2] | pipeline default | CFG active window `[start, end]` |
-| `--cfg-renorm-type` | string | `None` | `global`, `text_channel`, or `channel` |
-| `--cfg-renorm-min` | float | `None` | Minimum renormalization value |
-
-### Engine Arguments
-
-| Argument | Type | Default | Description |
-| :------- | :--- | :------ | :---------- |
-| `--deploy-config` | string | `None` | Path to deploy YAML (auto-detected if omitted) |
-| `--stage-configs-path` | string | `None` | [Deprecated] Legacy path to `stage_args` YAML; prefer `--deploy-config` |
-| `--worker-backend` | choice | `multi_process` | `multi_process` or `ray` |
-| `--ray-address` | string | `None` | Ray cluster address |
-| `--quantization` | string | `None` | Quantization method (e.g. `fp8`) |
-| `--log-stats` | flag | `False` | Enable statistics logging |
-| `--init-timeout` | int | `300` | Initialization timeout (seconds) |
-| `--batch-timeout` | int | `5` | Batch timeout (seconds) |
-| `--enable-diffusion-pipeline-profiler` | flag | `False` | Profile diffusion stage durations |
-
-## FAQ
-
-- If you encounter OOM errors, try decreasing `max_model_len` or `gpu_memory_utilization` in the deploy YAML.
-
-**Two-stage VRAM usage:**
-
-| Stage | VRAM |
-| :---- | :--- |
-| Stage 0 (Thinker) | **15.04 GiB + KV Cache** |
-| Stage 1 (DiT) | **26.50 GiB** |
-| Total | **~42 GiB + KV Cache** |
-
-**Single-stage VRAM usage:** The DiT loads the full model (~42 GiB) in one process.
-
-## Example materials
-
-??? abstract "end2end.py"
-    ``````py
-    --8<-- "examples/offline_inference/bagel/end2end.py"
-    ``````
diff --git a/docs/user_guide/examples/offline_inference/image_to_video.md b/docs/user_guide/examples/offline_inference/image_to_video.md
index dc1d3d6b2..db7a31ce5 100644
--- a/docs/user_guide/examples/offline_inference/image_to_video.md
+++ b/docs/user_guide/examples/offline_inference/image_to_video.md
@@ -4,7 +4,7 @@ Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inf
 
 
 This example demonstrates how to generate videos from images using Wan2.2,
-LTX-2/LTX-2.3, and HunyuanVideo-1.5 Image-to-Video models with vLLM-Omni's
+LTX-2, and HunyuanVideo-1.5 Image-to-Video models with vLLM-Omni's
 offline inference API.
 
 ## Local CLI Usage
@@ -53,34 +53,22 @@ python image_to_video.py \
   --output i2v_output.mp4
 ```
 
-### LTX-2.3
+### LTX-2
 
 ```bash
 python image_to_video.py \
-  --model dg845/LTX-2.3-Diffusers \
-  --model-class-name LTX23ImageToVideoPipeline \
+  --model Lightricks/LTX-2 \
   --image cherry_blossom.jpg \
   --prompt "Cherry blossoms swaying gently in the breeze with synchronized ambient sound" \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 384 \
-  --width 512 \
-  --num-frames 25 \
-  --guidance-scale 4.0 \
-  --num-inference-steps 20 \
-  --frame-rate 24 \
-  --fps 24 \
-  --output ltx23_i2v_output.mp4
+  --output ltx2_i2v_output.mp4
 ```
 
-Use a Diffusers-format checkpoint such as `dg845/LTX-2.3-Diffusers`; the
-upstream `Lightricks/LTX-2.3` raw safetensors repo is not directly loadable by
-this pipeline. Pass `--model-class-name LTX23ImageToVideoPipeline` to select
-the LTX-2.3 image-to-video pipeline.
+See the [LTX-2 recipe](../../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, T2V, defaults, and advanced options.
 
 Key arguments:
 
-- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V, or
-  LTX-2/LTX-2.3).
+- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V, or LTX-2).
 - `--image`: Path to input image (required).
 - `--prompt`: Text description of desired motion/animation.
 - `--height/--width`: Output resolution (auto-calculated from image if not set).
diff --git a/docs/user_guide/examples/offline_inference/mammothmodal2_preview.md b/docs/user_guide/examples/offline_inference/mammothmodal2_preview.md
deleted file mode 100644
index 60f1cbe5f..000000000
--- a/docs/user_guide/examples/offline_inference/mammothmodal2_preview.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# MammothModa2-Preview
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/mammothmodal2_preview>.
-
-
-## Run examples (MammothModa2-Preview)
-
-Download model
-```bash
-hf download bytedance-research/MammothModa2-Preview --local-dir ./MammothModa2-Preview
-```
-
-### Text-to-Image (T2I)
-
-Text-to-image now runs through the shared offline image example
-(`examples/offline_inference/text_to_image/text_to_image.py`). See the recipe
-`recipes/MammothModa2/MammothModa2-Preview.md` for the full command and the
-`extra_body` knobs (`text_guidance_scale`, `cfg_range`, `num_inference_steps`).
-
-### Image Summary
-
-```bash
-python examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py \
-  --model ./MammothModa2-Preview \
-  --deploy-config ./vllm_omni/deploy/mammoth_moda2_ar.yaml \
-  --question "Summarize this image." \
-  --image ./image.png
-```
-
-## Example materials
-
-??? abstract "run_mammothmoda2_image_summarize.py"
-    ``````py
-    --8<-- "examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py"
-    ``````
diff --git a/docs/user_guide/examples/offline_inference/text_to_image.md b/docs/user_guide/examples/offline_inference/text_to_image.md
index 7cd508d29..f1cdb9293 100644
--- a/docs/user_guide/examples/offline_inference/text_to_image.md
+++ b/docs/user_guide/examples/offline_inference/text_to_image.md
@@ -184,7 +184,7 @@ if __name__ == "__main__":
 !!! info
 
     For diffusion request-level batching controls such as `max_num_seqs`, see
-    [Request-Level Batching](../../diffusion/request_batching.md).
+    [Diffusion Execution Modes](../../diffusion/execution_modes.md).
 
 ### Negative Prompts
 
diff --git a/docs/user_guide/examples/offline_inference/text_to_video.md b/docs/user_guide/examples/offline_inference/text_to_video.md
index 5d89eac34..fcd3e7337 100644
--- a/docs/user_guide/examples/offline_inference/text_to_video.md
+++ b/docs/user_guide/examples/offline_inference/text_to_video.md
@@ -12,7 +12,7 @@ For backend selection and SageAttention usage, see the [Diffusion Attention Back
 | Model | Default Resolution | Default Frames | Default Steps | Guidance | VRAM (BF16) |
 |---|---|---|---|---|---|
 | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | 720x1280 | 81 | 40 | 4.0 | ~60 GiB |
-| `dg845/LTX-2.3-Diffusers` | 384x512 | 25 | 20 | 4.0 | 96GB-class GPU |
+| `Lightricks/LTX-2` | 512x768 | 121 | 40 | video 3.0 / audio 7.0 | Model-dependent |
 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_t2v` | 480x832 | 121 | 50 | 6.0 | 1×A100 80GB |
 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_t2v` | 720x1280 | 121 | 50 | 6.0 | FP8 + VAE tiling required |
 
@@ -35,45 +35,17 @@ python text_to_video.py \
   --output t2v_out.mp4
 ```
 
-LTX2 example:
+### LTX-2
 
 ```bash
 python text_to_video.py \
-  --model "Lightricks/LTX-2" \
-  --prompt "A cinematic close-up of ocean waves at golden hour." \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 512 \
-  --width 768 \
-  --num-frames 121 \
-  --num-inference-steps 40 \
-  --guidance-scale 4.0 \
-  --frame-rate 24 \
-  --output ltx2_out.mp4
-```
-
-### LTX-2.3
-
-```bash
-python text_to_video.py \
-  --model dg845/LTX-2.3-Diffusers \
-  --model-class-name LTX23Pipeline \
+  --model Lightricks/LTX-2 \
   --prompt "Cherry blossoms swaying gently in the breeze with synchronized ambient sound" \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 384 \
-  --width 512 \
-  --num-frames 25 \
-  --num-inference-steps 20 \
-  --guidance-scale 4.0 \
-  --frame-rate 24 \
-  --fps 24 \
-  --audio-sample-rate 48000 \
-  --output ltx23_t2v_output.mp4
+  --output ltx2_output.mp4
 ```
 
-Use a Diffusers-format checkpoint such as `dg845/LTX-2.3-Diffusers`; the
-upstream `Lightricks/LTX-2.3` raw safetensors repo is not directly loadable by
-this pipeline. Pass `--model-class-name LTX23Pipeline` to select the LTX-2.3
-text-to-video pipeline explicitly.
+See the [LTX-2 recipe](../../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, I2V, defaults, and advanced options.
 
 ### HunyuanVideo-1.5 (480p)
 
@@ -135,8 +107,7 @@ python text_to_video.py \
 ### Common
 
 - `--model`: Diffusers model ID or local path.
-- `--model-class-name`: Optional explicit pipeline class. Use `LTX23Pipeline`
-  for LTX-2.3 text-to-video.
+- `--model-class-name`: Optional explicit pipeline override.
 - `--prompt`: text description (string).
 - `--height/--width`: output resolution. Default depends on model.
 - `--num-frames`: number of frames. Default depends on model.
@@ -151,8 +122,7 @@ python text_to_video.py \
 - `--enable-cpu-offload`: enable CPU offloading for diffusion models.
 - `--enable-layerwise-offload`: enable layerwise offloading on DiT modules.
 - `--frame-rate`: generation FPS for pipelines that require it (e.g., LTX2).
-- `--audio-sample-rate`: audio sample rate for embedded audio (when the
-  pipeline returns audio; LTX-2.3 outputs 48kHz audio).
+- `--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.
 
diff --git a/docs/user_guide/examples/online_serving/bagel.md b/docs/user_guide/examples/online_serving/bagel.md
index aa8b33de8..4b5c6dde6 100644
--- a/docs/user_guide/examples/online_serving/bagel.md
+++ b/docs/user_guide/examples/online_serving/bagel.md
@@ -40,7 +40,7 @@ bash run_server_stage_cli.sh --stage 0
 bash run_server_stage_cli.sh --stage 1
 ```
 
-To use a custom deploy YAML (note: `--stage-configs-path` is deprecated in favor of `--deploy-config`):
+To use a custom deploy YAML:
 
 ```bash
 vllm serve ByteDance-Seed/BAGEL-7B-MoT --omni --port 8091 \
diff --git a/docs/user_guide/examples/online_serving/glm_image.md b/docs/user_guide/examples/online_serving/glm_image.md
index ea404faa9..8d41b26fd 100644
--- a/docs/user_guide/examples/online_serving/glm_image.md
+++ b/docs/user_guide/examples/online_serving/glm_image.md
@@ -11,8 +11,8 @@ memory, sampling params) live in `vllm_omni/deploy/glm_image.yaml`.
 vllm serve zai-org/GLM-Image --omni --port 8091
 ```
 
-The config system auto-detects the pipeline from the model's `model_index.json` — no
-manual `--stage-configs-path` or `--deploy-config` needed.
+The config system auto-detects the pipeline from the model's `model_index.json`, so
+no manual `--deploy-config` is needed.
 
 By default, stage 0 (AR) runs on GPU 0 and stage 1 (Diffusion) on GPU 1. To colocate
 both stages on a single GPU, override per stage:
diff --git a/docs/user_guide/examples/online_serving/qwen2_5_omni.md b/docs/user_guide/examples/online_serving/qwen2_5_omni.md
index d8c48a403..a06e6d7a0 100644
--- a/docs/user_guide/examples/online_serving/qwen2_5_omni.md
+++ b/docs/user_guide/examples/online_serving/qwen2_5_omni.md
@@ -15,9 +15,9 @@ Please refer to [README.md](https://github.com/vllm-project/vllm-omni/tree/main/
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
 ```
 
-If you have custom stage configs file, launch the server with command below
+To use a custom deploy config, launch the server with the command below:
 ```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
+vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
 
 ### Send Multi-modal Request
@@ -182,7 +182,7 @@ The script supports the following arguments:
 - `--model`: Model name/path (default: Qwen/Qwen2.5-Omni-7B)
 - `--server-port`: Port for vLLM server (default: 8091)
 - `--gradio-port`: Port for Gradio demo (default: 7861)
-- `--stage-configs-path`: Path to custom stage configs YAML file (optional)
+- `--deploy-config`: Path to a custom deploy config YAML file (optional)
 - `--server-host`: Host for vLLM server (default: 0.0.0.0)
 - `--gradio-ip`: IP for Gradio demo (default: 127.0.0.1)
 - `--share`: Share Gradio demo publicly (creates a public link)
@@ -195,9 +195,9 @@ The script supports the following arguments:
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
 ```
 
-If you have custom stage configs file:
+To use a custom deploy config:
 ```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
+vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
 
 **Step 2: Run the Gradio demo**
diff --git a/docs/user_guide/examples/online_serving/qwen3_omni.md b/docs/user_guide/examples/online_serving/qwen3_omni.md
index ec509d597..b4c05bdbe 100644
--- a/docs/user_guide/examples/online_serving/qwen3_omni.md
+++ b/docs/user_guide/examples/online_serving/qwen3_omni.md
@@ -140,7 +140,7 @@ You can control output modalities to specify which types of output the model sho
 | Modalities | Output |
 |------------|--------|
 | `["text"]` | Text only |
-| `["audio"]` | Text + Audio |
+| `["audio"]` | Audio only |
 | `["text", "audio"]` | Text + Audio |
 | Not specified | Text + Audio (default) |
 
@@ -161,13 +161,16 @@ curl http://localhost:8091/v1/chat/completions \
 #### Text + Audio
 
 ```bash
-curl http://localhost:8091/v1/chat/completions \
+response=$(curl -s http://localhost:8091/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{
     "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
     "messages": [{"role": "user", "content": "Describe vLLM in brief."}],
-    "modalities": ["audio"]
-  }'
+    "modalities": ["text", "audio"]
+  }')
+
+echo "$response" | jq -r '.choices[0].message.content'
+echo "$response" | jq -r '.choices[1].message.audio.data' | base64 -d > output.wav
 ```
 
 ### Using Python client
@@ -205,7 +208,7 @@ client = OpenAI(base_url="http://localhost:8091/v1", api_key="EMPTY")
 response = client.chat.completions.create(
     model="Qwen/Qwen3-Omni-30B-A3B-Instruct",
     messages=[{"role": "user", "content": "Describe vLLM in brief."}],
-    modalities=["audio"]
+    modalities=["text", "audio"]
 )
 # Response contains two choices: one with text, one with audio
 print(response.choices[0].message.content)  # Text response
@@ -303,7 +306,7 @@ The gradio script supports the following arguments:
     ``````
 ??? abstract "qwen3_omni_moe_thinking.yaml"
     ``````yaml
-    --8<-- "examples/online_serving/qwen3_omni/qwen3_omni_moe_thinking.yaml"
+    --8<-- "vllm_omni/deploy/qwen3_omni_moe_thinking.yaml"
     ``````
 ??? abstract "run_curl_multimodal_generation.sh"
     ``````sh
diff --git a/docs/user_guide/examples/online_serving/text_to_audio.md b/docs/user_guide/examples/online_serving/text_to_audio.md
index b1ec33a20..a4833aef6 100644
--- a/docs/user_guide/examples/online_serving/text_to_audio.md
+++ b/docs/user_guide/examples/online_serving/text_to_audio.md
@@ -139,7 +139,7 @@ Content-Type: application/json
 |-----------|------|---------|-------------|
 | `input` | string | **required** | Text prompt describing the audio to generate |
 | `model` | string | server's model | Model to use (optional, should match server if specified) |
-| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, aac, opus |
+| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, opus |
 | `speed` | float | 1.0 | Playback speed (0.25 - 4.0) |
 | `audio_length` | float | null | Audio duration in seconds (max ~47s for `stable-audio-open-1.0`) |
 | `audio_start` | float | 0.0 | Audio start time in seconds |
diff --git a/docs/user_guide/examples/online_serving/text_to_speech.md b/docs/user_guide/examples/online_serving/text_to_speech.md
index 5640845d8..c6a613723 100644
--- a/docs/user_guide/examples/online_serving/text_to_speech.md
+++ b/docs/user_guide/examples/online_serving/text_to_speech.md
@@ -422,12 +422,19 @@ curl -X POST http://localhost:8091/v1/audio/speech \
 Raw PCM streaming requires `stream_format="audio"`, `response_format="pcm"`, and `async_chunk: true` on the stage config (default in `qwen3_tts.yaml`). `speed` is not supported when streaming.
 
 ### Streaming WebSocket
-The `/v1/audio/speech/stream` endpoint accepts text incrementally, splits it at sentence boundaries, and emits one PCM stream per sentence:
+The `/v1/audio/speech/stream` endpoint accepts text incrementally and synthesizes the buffered text as one continuous request on `input.done`:
 ```bash
 python qwen3_tts/streaming_speech_client.py --text "Hello world. How are you? I am fine."
 python qwen3_tts/streaming_speech_client.py --text "..." --simulate-stt --stt-delay 0.1
 ```
 
+`input.done` flushes without closing, so repeating `--text` synthesizes several utterances over one connection:
+```bash
+python qwen3_tts/streaming_speech_client.py \
+    --text "First utterance." \
+    --text "Second utterance, same connection."
+```
+
 ### Gradio demos
 ```bash
 ./qwen3_tts/run_gradio_demo.sh                              # CustomVoice (default)
diff --git a/docs/user_guide/examples/online_serving/text_to_video.md b/docs/user_guide/examples/online_serving/text_to_video.md
index d4d520d5e..2f00d386b 100644
--- a/docs/user_guide/examples/online_serving/text_to_video.md
+++ b/docs/user_guide/examples/online_serving/text_to_video.md
@@ -191,7 +191,7 @@ curl -X POST http://localhost:8091/v1/videos \
 | `negative_prompt`     | str    | None    | Negative prompt                                  |
 | `width`               | int    | None    | Video width in pixels                            |
 | `height`              | int    | None    | Video height in pixels                           |
-| `num_frames`          | int    | None    | Number of frames to generate                     |
+| `num_frames`          | int    | 1       | Number of frames to generate; set explicitly for video generation |
 | `fps`                 | int    | None    | Frames per second for output video               |
 | `num_inference_steps` | int    | None    | Number of denoising steps                        |
 | `guidance_scale`      | float  | None    | CFG guidance scale (low-noise stage)             |
@@ -289,90 +289,12 @@ done
 
 ## LTX-2
 
-### Start Server
-
-#### Basic Start
-
 ```bash
-vllm serve Lightricks/LTX-2 --omni --port 8098 \
-    --enforce-eager --flow-shift 1.0 --boundary-ratio 1.0
+vllm serve Lightricks/LTX-2 --omni --port 8098
 ```
 
-For multi-GPU memory reduction, you can enable HSDP:
-
-```bash
-vllm serve Lightricks/LTX-2 --omni --port 8098 \
-    --enforce-eager --flow-shift 1.0 --boundary-ratio 1.0 \
-    --use-hsdp --hsdp-shard-size 2
-```
-
-#### Start with Optimization Presets
-
-Use the LTX-2 startup script with built-in optimization presets:
-
-```bash
-# Baseline (1 GPU, eager)
-bash run_server_ltx2.sh baseline
-
-# 4-GPU Ulysses sequence parallelism (lossless)
-bash run_server_ltx2.sh ulysses4
-
-# Cache-DiT lossy acceleration (1 GPU, ~1.4× speedup)
-bash run_server_ltx2.sh cache-dit
-
-# Best combo: 4-GPU Ulysses SP + Cache-DiT (~2.2× speedup)
-bash run_server_ltx2.sh best-combo
-```
-
-#### Optimization Benchmarks
-
-Benchmarked on H800, online serving (480×768, 41 frames, 20 steps, `seed=42`).
-"Inference" is the server-reported inference time; excludes HTTP/poll overhead.
-
-| Preset | Server Command | Inference (s) | Speedup | Type |
-|--------|---------------|---------------|---------|------|
-| `baseline` | `--enforce-eager` | 10.3 | 1.00× | — |
-| `compile` | *(default, no --enforce-eager)* | ~10.3 (warm) | ~1.00× | Lossless |
-| `ulysses4` | `--enforce-eager --usp 4` | ~10.3 | ~1.00× | Lossless |
-| `cache-dit` | `--enforce-eager --cache-backend cache_dit` | 7.4 avg | ~1.4× | Lossy |
-| `best-combo` | `--enforce-eager --usp 4 --cache-backend cache_dit` | 4.7 avg | **~2.2×** | Lossless + Lossy |
-
-**Observations**:
-- **torch.compile**: On H800, warm-request inference time matches the eager baseline (~10.3s).
-  The first request pays ~6s compilation overhead. Benefit depends on model architecture and GPU.
-- **Ulysses SP (4 GPU)**: No measurable speedup alone for 41-frame generation at this resolution.
-  Communication overhead outweighs gains at this sequence length.
-- **Cache-DiT**: Inference varies per request (6–10s) due to dynamic caching decisions.
-  Average is ~7.4s (~1.4× speedup) with slight quality tradeoff.
-- **Best combo**: 4-GPU Ulysses SP + Cache-DiT synergize well — Cache-DiT reduces per-step
-  computation, making the communication overhead of Ulysses SP worthwhile. Average ~4.7s
-  (~2.2× speedup).
-- **FP8 quantization**: Reduces VRAM but does not speed up LTX-2 on H800 (compute-bound).
-
-**Deployment Recommendations**:
-- For **production with quality priority**: use `baseline` with `--enforce-eager`
-- For **maximum throughput** (4 GPUs, quality tradeoff): use `best-combo` (~2.2× speedup)
-- For **single-GPU throughput**: use `cache-dit` (~1.4× speedup)
-- `--enforce-eager` is recommended to avoid torch.compile warmup latency on first request
-
-### Send Requests (curl)
-
-```bash
-# Using the provided script
-bash run_curl_ltx2.sh
-
-# Or directly
-curl -sS -X POST http://localhost:8098/v1/videos \
-  -H "Accept: application/json" \
-  -F "prompt=A serene lakeside sunrise with mist over the water." \
-  -F "width=768" \
-  -F "height=480" \
-  -F "num_frames=41" \
-  -F "fps=24" \
-  -F "num_inference_steps=20" \
-  -F "guidance_scale=3.0" \
-  -F "seed=42"
-```
+See the [LTX-2 recipe](../../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, requests, defaults, and advanced options.
 
 ## Example materials
 
diff --git a/docs/user_guide/fault_injection_reliability_matrix.md b/docs/user_guide/fault_injection_reliability_matrix.md
index 974982b3b..28271affa 100644
--- a/docs/user_guide/fault_injection_reliability_matrix.md
+++ b/docs/user_guide/fault_injection_reliability_matrix.md
@@ -65,23 +65,23 @@ More failure modes (for example, network jitter and network interruption) will b
 
 ## Source of Conclusions
 
-The behaviors and conclusions above are summarized from current fault injection validation results on **`Qwen3-Omni`**, **`Wan2.2`**, **`HunyuanImage-3.0-Instruct`** (DiT-only, `/v1/images/generations`), and **`VoxCPM2`** (`/v1/audio/speech`). Automated coverage lives under `tests/dfx/reliability/` (`test_reliability_qwen3_omni.py`, `test_reliability_wan22.py`, `test_reliability_hunyuan_image.py`, `test_reliability_voxcpm2.py`) and runs weekly via `.buildkite/test-weekly.yml`.
+The behaviors and conclusions above are summarized from current fault injection validation results on **`Qwen3-Omni`**, **`Wan2.2`**, **`HunyuanImage-3.0-Instruct`** (DiT-only, `/v1/images/generations`), and **`VoxCPM2`** (`/v1/audio/speech`). Automated coverage lives under `tests/dfx/reliability/` (`test_reliability_qwen3_omni.py`, `test_reliability_wan22.py`, `test_reliability_hunyuan_image.py`, `test_reliability_voxcpm2.py`) and runs weekly via `.buildkite/cuda/test-weekly.yml`.
 
 ### Example: `SIGTERM` fault injection log (Qwen3-Omni)
 
-The following full log is from a real run where a `SIGTERM` signal was sent to the serve root process.
+The following log is based on a real run where a `SIGTERM` signal was sent to the serve root process. Its command line has been normalized to the current `--deploy-config` option.
 
 ```text
-Launching OmniServer with: /workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --stage-configs-path vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
+Launching OmniServer with: /workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --deploy-config vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
 Server ready on 127.0.0.1:60675 (OmniServer startup took 206.023s)
 OmniServer started successfully
-[reliability][process-kill] current_server_proc pid=556855 name=python3 cmdline=/workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --stage-configs-path vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
+[reliability][process-kill] current_server_proc pid=556855 name=python3 cmdline=/workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --deploy-config vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
 [reliability][process-kill] current_server_proc pid=557118 name=python3 cmdline=/workspace/.venv/bin/python3 -c from multiprocessing.resource_tracker import main;main(57)
 [reliability][process-kill] current_server_proc pid=557119 name=VLLM::StageEngineCoreProc_noid_replica0_DP0 cmdline=VLLM::StageEngineCoreProc_noid_replica0_DP0
 [reliability][process-kill] current_server_proc pid=557122 name=VLLM::StageEngineCoreProc_noid_replica0_DP0 cmdline=VLLM::StageEngineCoreProc_noid_replica0_DP0
 [reliability][process-kill] current_server_proc pid=558201 name=VLLM::StageEngineCoreProc_noid_replica0_DP0 cmdline=VLLM::StageEngineCoreProc_noid_replica0_DP0
 
-[reliability][process-kill] root-kill pid=556855 name=python3 signal=SIGTERM cmdline=/workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --stage-configs-path vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
+[reliability][process-kill] root-kill pid=556855 name=python3 signal=SIGTERM cmdline=/workspace/.venv/bin/python3 -m vllm_omni.entrypoints.cli.main serve Qwen/Qwen3-Omni-30B-A3B-Instruct --host 127.0.0.1 --port 60675 --omni --async-chunk --stage-init-timeout 600 --init-timeout 900 --log-stats --deploy-config vllm-omni/vllm_omni/deploy/qwen3_omni_moe.yaml
 [0;36m(APIServer pid=556855)[0;0m INFO 05-19 12:24:51 [omni_base.py:463] [AsyncOmni] Shutting down
 [0;36m(APIServer pid=556855)[0;0m INFO 05-19 12:24:51 [async_omni_engine.py:2397] [AsyncOmniEngine] Shutting down Orchestrator
 [0;36m(APIServer pid=556855)[0;0m INFO 05-19 12:24:51 [orchestrator.py:351] [Orchestrator] Received shutdown signal
diff --git a/docs/user_guide/quantization/fp8.md b/docs/user_guide/quantization/fp8.md
index 6114812db..ddca3ea19 100644
--- a/docs/user_guide/quantization/fp8.md
+++ b/docs/user_guide/quantization/fp8.md
@@ -88,10 +88,12 @@ warmup_quack_fp8([(14040, 2048, 6144), (14040, 2048, 2048)])
 | Wan2.2 | Wan2.2 diffusion pipelines | Not validated | Not validated | Validate against BF16 before documenting as supported | TBD | |
 | Z-Image | `Tongyi-MAI/Z-Image-Turbo` | Yes | Yes | All layers | None | ✅︎ |
 | FLUX.1 | `black-forest-labs/FLUX.1-dev`, `black-forest-labs/FLUX.1-schnell` | Yes | Yes | All layers | None | |
+| FLUX.2-dev | `black-forest-labs/FLUX.2-dev` | Yes | Not validated | All layers | None | ✅︎ |
 | FLUX.2-klein | `black-forest-labs/FLUX.2-klein-4B` | Yes | Yes | All layers | None | |
 | HunyuanImage-3.0 | `tencent/HunyuanImage-3.0`, `tencent/HunyuanImage-3.0-Instruct` | Yes | Yes | All layers; use the Hunyuan stage config for multi-stage runs | None | |
 | HunyuanVideo-1.5 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_t2v`, `720p_t2v`, `480p_i2v` | Yes | Yes | All layers | None | |
 | Cosmos3 | `nvidia/Cosmos3-Nano`, `nvidia/Cosmos3-Super` | Yes | Not validated | All layers | None | |
+| MiniMax H3 | `MiniMaxAI/MiniMax-H3` | Yes | Not validated | DiT linears except patch, timestep, and final projections; not compatible with layerwise offload | None | |
 
 ### Multi-Stage Omni/TTS Model (Qwen3-Omni, Qwen3-TTS)
 
diff --git a/docs/user_guide/quantization/overview.md b/docs/user_guide/quantization/overview.md
index 3a4a45573..ee36f5b60 100644
--- a/docs/user_guide/quantization/overview.md
+++ b/docs/user_guide/quantization/overview.md
@@ -5,6 +5,9 @@ path. The same configuration entrypoint is used across diffusion-only models,
 multi-stage omni/TTS models, and multi-stage diffusion models, but each model
 type has a different quantization scope.
 
+For the internal architecture and backend extension points, see the
+[quantization design document](../../design/feature/quantization.md).
+
 ## Quantization Modes
 
 | Mode | Guide | Description | Methods |
diff --git a/examples/model_display_names.yml b/examples/model_display_names.yml
index be3f8e381..7a04ff8fa 100644
--- a/examples/model_display_names.yml
+++ b/examples/model_display_names.yml
@@ -8,5 +8,4 @@ mimo_audio: MiMo-Audio
 ming_flash_omni: Ming-flash-omni 2.0
 qwen2_5_omni: Qwen2.5-Omni
 qwen3_omni: Qwen3-Omni
-sensenova_u1: SenseNova-U1
 step_audio2: Step-Audio2
diff --git a/examples/offline_inference/audex/README.md b/examples/offline_inference/audex/README.md
new file mode 100644
index 000000000..793b69eb9
--- /dev/null
+++ b/examples/offline_inference/audex/README.md
@@ -0,0 +1,114 @@
+# Audex (Nemotron-Labs-Audex-2B) offline inference
+
+One checkpoint, four tasks — each script builds its own `Omni` engine with
+the right deploy yaml, so they run as plain `python <script>` with no extra
+flags. Pass the HF repo ROOT as `--model` (default
+`nvidia/Nemotron-Labs-Audex-2B`); per-stage subfolders and download subsets
+resolve automatically.
+
+| script | pipeline (`vllm_omni/deploy/<name>.yaml`) | audio in | text out | speech out | general audio out |
+|---|---|---|---|---|---|
+| `text_to_speech.py` | `audex_tts` | ❌ | ❌ | ✅ | ❌ |
+| `text_to_audio.py` | `audex_tta` | ❌ | ❌ | ❌ | ✅ |
+| `audio_qa.py` | `audex_thinker_only` | ✅ | ✅ | ❌ | ❌ |
+| `speech_to_speech.py` | `audex_s2s` | ✅ | ✅ | ✅ | ❌ |
+
+Shared plumbing (corpus/WAV IO, tokenizer loading, the CFG cond/uncond
+pair contract) lives in `common.py`; each task script keeps only its own
+prompt recipe and flow. Note `text_to_audio.py` here drives the Audex
+two-stage AR pipeline — for diffusion text-to-audio models (Stable Audio
+Open, AudioX) use the generic
+`examples/offline_inference/text_to_audio/text_to_audio.py` instead.
+
+## text_to_speech.py — text → speech
+
+Thinker generates `<speechcodec_N>` tokens; the streaming causal decoder
+turns them into 16 kHz WAVs (one file per prompt, slugified filename).
+
+```bash
+# three built-in demo sentences -> results/audex_wavs/
+python examples/offline_inference/audex/text_to_speech.py
+
+# your own texts, with classifier-free guidance (official quality setting)
+python examples/offline_inference/audex/text_to_speech.py \
+    --texts "Hello there." "Nice to meet you." --cfg-scale 1.5 \
+    --output-dir results/my_tts
+```
+
+Key flags: `--texts` / `--texts-file` (TSV `utt_id<TAB>text`),
+`--cfg-scale` (default 1.0 = off; 1.5 recommended — guided requests run
+one at a time, each paired with a length-matched null prompt),
+`--temperature` (overrides the deploy yaml's stage-0 default).
+
+## text_to_audio.py — caption → general audio (sound effects)
+
+Same thinker over the interleaved 4-codebook `<audiocodec_N>` RVQ block,
+decoded by the external XCodec1 checkpoint. CFG is effectively mandatory
+(default scale 3.0). Clips are capped at `--codec-cap 4000` codec tokens
+(10 s).
+
+```bash
+# three built-in demo captions -> results/audex_tta_wavs/
+python examples/offline_inference/audex/text_to_audio.py
+
+python examples/offline_inference/audex/text_to_audio.py \
+    --captions "Thunder rolling across a valley." --output-dir results/my_tta
+```
+
+XCodec1 resolves from `--xcodec1-path`, the `XCODEC1_PATH` env var, or the
+default `hf-audio/xcodec-hubert-general-balanced` repo (downloaded on
+first use).
+
+## audio_qa.py — audio (+ instruction) → text
+
+Single-stage audio understanding on the full checkpoint (NV-Whisper
+encoder + projector + LM). The default question is ASR
+("Transcribe the input speech."); without `--audio-files`, vLLM's public
+`mary_had_lamb` asset is transcribed.
+
+```bash
+# transcribe the built-in demo asset
+python examples/offline_inference/audex/audio_qa.py
+
+# your own clips / free-form QA
+python examples/offline_inference/audex/audio_qa.py \
+    --audio-files a.wav b.wav --question "What language is being spoken?"
+```
+
+## speech_to_speech.py — spoken question → spoken answer
+
+The official three-pass cascade over ONE `audex_s2s` deployment: ASR
+(audio → transcript, text-final) → chat (transcript → answer, text-final)
+→ TTS (answer → speech through the streaming decoder). Only the TTS pass
+touches the codec path. Without `--audio-file`, the `mary_had_lamb` asset
+is used as the spoken input.
+
+```bash
+# full cascade on the built-in demo asset -> results/audex_s2s_answer.wav
+python examples/offline_inference/audex/speech_to_speech.py
+
+python examples/offline_inference/audex/speech_to_speech.py \
+    --audio-file question.wav --output results/answer.wav --cfg-scale 1.5
+```
+
+`--cfg-scale` (default 1.5) applies to the TTS pass only; 1.0 disables it.
+
+Online-serving counterparts (server + HTTP clients) live in
+`examples/online_serving/audex/`.
+
+## 30B-A3B (nvidia/Nemotron-Labs-Audex-30B-A3B)
+
+The same four scripts serve the 30B MoE checkpoint (hybrid Mamba + MoE
+NemotronH thinker; identical token space and decoder). The 30B REQUIRES an
+explicit 30B deploy yaml — the model root's default resolution lands on the
+2B-tuned configs:
+
+    python examples/offline_inference/audex/text_to_speech.py \
+        --model nvidia/Nemotron-Labs-Audex-30B-A3B \
+        --deploy-config vllm_omni/deploy/audex_tts_30b.yaml
+
+Per-mode yamls: `audex_{tts,tta,thinker_only,s2s}_30b.yaml`. Defaults fit a
+single H100 80 GB (thinker + decoder share the card; prefix caching is off —
+hybrid Mamba); if long sequences OOM, set `tensor_parallel_size: 2` on
+stage 0. First run downloads ~60 GB. Verified on a single H100 80 GB: ~61 GiB
+weights + healthy KV headroom; TP2 was not needed.
diff --git a/examples/offline_inference/audex/audio_qa.py b/examples/offline_inference/audex/audio_qa.py
new file mode 100644
index 000000000..120acce4c
--- /dev/null
+++ b/examples/offline_inference/audex/audio_qa.py
@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline Audex (Nemotron-Labs-Audex-2B) audio understanding example.
+
+Speech (or general audio) + text instruction → text, through the
+single-stage ``audex_thinker_only`` pipeline: NV-Whisper
+encoder + relu2 projector + 2B dense LM on ``checkpoint_folder_full``.
+
+The prompt format mirrors the official audioqa script: a ChatML user turn
+holding the ``<so_embedding>`` placeholder (expanded by the processor to
+750 embedding positions per 30 s clip) plus the instruction, with a closed
+``<think></think>`` priming.
+
+Examples (without --audio-files, vLLM's public ``mary_had_lamb`` asset is
+transcribed):
+
+    # Transcribe WAVs (ASR):
+    python examples/offline_inference/audex/audio_qa.py \\
+        --audio-files a.wav b.wav
+
+    # Free-form audio QA:
+    python examples/offline_inference/audex/audio_qa.py \\
+        --audio-files a.wav --question "What language is being spoken?"
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from common import default_deploy_config, load_audio_file, request_index
+from vllm.assets.audio import AudioAsset
+
+from vllm_omni import Omni
+
+ASR_QUESTION = "Transcribe the input speech."
+
+
+def build_prompt(question: str) -> str:
+    return f"<|im_start|>user\n<so_embedding>\n{question}<|im_end|>\n<|im_start|>assistant\n<think></think>"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Offline Audex audio understanding")
+    parser.add_argument("--model", type=str, default="nvidia/Nemotron-Labs-Audex-2B")
+    parser.add_argument(
+        "--audio-files",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Input clips. Defaults to vLLM's mary_had_lamb audio asset.",
+    )
+    parser.add_argument("--question", type=str, default=ASR_QUESTION)
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        # The model root's default deploy yaml is the TTS pipeline; audio
+        # understanding needs the single-stage thinker-only pipeline.
+        default=default_deploy_config("audex_thinker_only.yaml"),
+        help="Deploy yaml (defaults to the audex_thinker_only pipeline).",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    engine = Omni(model=args.model, deploy_config=args.deploy_config, trust_remote_code=True)
+
+    prompt_text = build_prompt(args.question)
+    if args.audio_files:
+        clips = [load_audio_file(path) for path in args.audio_files]
+    else:
+        clips = [AudioAsset("mary_had_lamb").audio_and_sample_rate]
+    prompts = []
+    for audio, sr in clips:
+        prompts.append(
+            {
+                "prompt": prompt_text,
+                "multi_modal_data": {"audio": (audio, sr)},
+            }
+        )
+
+    outputs = engine.generate(prompts)
+
+    ordered = sorted(outputs, key=request_index)
+    names = [Path(p).name for p in args.audio_files] if args.audio_files else ["mary_had_lamb"]
+    for name, req_output in zip(names, ordered):
+        text = req_output.outputs[0].text if req_output.outputs else ""
+        print(f"{name}: {text.strip()}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/audex/common.py b/examples/offline_inference/audex/common.py
new file mode 100644
index 000000000..9f1836335
--- /dev/null
+++ b/examples/offline_inference/audex/common.py
@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Shared helpers for the offline Audex examples in this directory.
+
+Import style follows the repo's example convention (same-directory module,
+see ``text_to_speech/qwen3_tts/tts_common.py``): scripts run as files, so
+``from common import ...`` resolves via the script's own directory.
+"""
+
+from __future__ import annotations
+
+import copy
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import soundfile as sf
+import torch
+
+from vllm_omni import Omni
+from vllm_omni.model_executor.models.audex.prompt import build_null_prompt
+
+SAMPLE_RATE = 16_000
+_DEPLOY_DIR = Path(__file__).resolve().parents[3] / "vllm_omni" / "deploy"
+
+# Guided decoding sharpens the distribution, so the unguided temperature
+# (0.1) adds excess sampling noise under CFG. Measured on the en-24 gate
+# corpus at cfg 1.5: temp 0.1 -> CER 7.31%, temp 0.05 -> CER 6.87% (vs the
+# unguided baseline 7.24%).
+GUIDED_TEMPERATURE = 0.05
+
+
+def default_deploy_config(name: str) -> str:
+    """Absolute path of a deploy yaml bundled with vllm_omni."""
+    return str(_DEPLOY_DIR / name)
+
+
+def slugify(text: str, fallback: str = "prompt") -> str:
+    slug = re.sub(r"\s+", "_", text.strip().lower())
+    slug = re.sub(r"[^a-z0-9_]+", "", slug)
+    return slug[:48] or fallback
+
+
+def load_corpus(
+    corpus_file: str | None,
+    texts: list[str] | None,
+    default_texts: tuple[str, ...],
+) -> list[tuple[str, str]]:
+    """(utt_id, text) pairs from a TSV corpus file, CLI texts, or defaults."""
+    if corpus_file:
+        corpus = []
+        for line in Path(corpus_file).read_text().splitlines():
+            if not line.strip():
+                continue
+            utt, text = line.split("\t", 1)
+            corpus.append((utt, text.strip()))
+        return corpus
+    resolved = texts if texts else list(default_texts)
+    return [(slugify(t), t) for t in resolved]
+
+
+def load_audio_file(path: str) -> tuple[np.ndarray, int]:
+    """Mono float32 samples + native sample rate (processors resample)."""
+    audio, sr = sf.read(path, dtype="float32")
+    if audio.ndim == 2:
+        audio = audio.mean(axis=1)
+    return audio, sr
+
+
+def extract_pcm(multimodal_output: dict) -> torch.Tensor:
+    """Flatten one request's audio payload to a 1-D float32 CPU tensor."""
+    audio = multimodal_output.get("model_outputs")
+    if audio is None:
+        audio = multimodal_output.get("audio")
+    if audio is None:
+        raise ValueError(f"no audio key in multimodal_output: {list(multimodal_output.keys())}")
+    if isinstance(audio, list):
+        valid = [torch.as_tensor(a).float().cpu().reshape(-1) for a in audio if a is not None]
+        if not valid:
+            raise ValueError("audio list is empty")
+        return torch.cat(valid, dim=0) if len(valid) > 1 else valid[0]
+    return torch.as_tensor(audio).float().cpu().reshape(-1)
+
+
+def write_wav(path: Path, pcm: torch.Tensor, sample_rate: int = SAMPLE_RATE) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    arr = (np.clip(pcm.numpy(), -1.0, 1.0) * 32767.0).astype(np.int16)
+    sf.write(str(path), arr, sample_rate, format="WAV", subtype="PCM_16")
+
+
+def load_audex_tokenizer(model: str, profile: str = "tts", folder: str = "checkpoint_folder_audiogen"):
+    """Thinker tokenizer for CFG/TTA prompt building (resolves the snapshot)."""
+    from transformers import AutoTokenizer
+
+    from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
+
+    root = ensure_audex_snapshot(model, profile=profile)
+    return AutoTokenizer.from_pretrained(str(Path(root) / folder), trust_remote_code=True)
+
+
+def request_index(req_output) -> int:
+    """Submission index from the numeric request-id prefix.
+
+    ``Omni.generate`` may return outputs out of submission order, and a
+    lexicographic sort would misplace "10_..." before "2_...".
+    """
+    match = re.search(r"(\d+)", str(req_output.request_id))
+    return int(match.group(1)) if match else 0
+
+
+def guided_stage_params(
+    engine: Omni,
+    cond_prompt: str,
+    tokenizer,
+    cfg_scale: float,
+    pair_id: str,
+    *,
+    temperature: float | None = None,
+    extra_args: dict[str, Any] | None = None,
+    null_prompt_builder: Callable[[str, Any], str] = build_null_prompt,
+) -> list:
+    """Stage sampling params carrying the CFG pair contract for ONE request.
+
+    Clones the engine's resolved defaults (never mutates the shared list),
+    applies ``extra_args`` unconditionally (e.g. the TTA RVQ contract), and
+    attaches the cond/uncond pair contract when ``cfg_scale > 1.0``. Guided
+    requests must go one at a time: each needs its own pair id and a
+    length-matched null prompt built from its own text.
+    """
+    params = copy.deepcopy(engine.resolve_sampling_params_list(None))
+    stage0 = params[0]
+    if temperature is not None:
+        stage0.temperature = temperature
+    if stage0.extra_args is None:
+        stage0.extra_args = {}
+    if extra_args:
+        stage0.extra_args.update(extra_args)
+    if cfg_scale > 1.0:
+        stage0.extra_args.update(
+            {
+                "cfg_scale": float(cfg_scale),
+                "cfg_role": "cond",
+                "cfg_pair_id": pair_id,
+                "cfg_null_prompt": null_prompt_builder(cond_prompt, tokenizer),
+            }
+        )
+    return params
diff --git a/examples/offline_inference/audex/speech_to_speech.py b/examples/offline_inference/audex/speech_to_speech.py
new file mode 100644
index 000000000..9a98c1745
--- /dev/null
+++ b/examples/offline_inference/audex/speech_to_speech.py
@@ -0,0 +1,277 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline Audex (Nemotron-Labs-Audex-2B) cascaded speech-to-speech example.
+
+The official three-pass cascade over ONE ``audex_s2s``
+deployment:
+
+  1. ASR pass  (audio + "Transcribe the input speech." → transcript, text)
+  2. chat pass (transcript → answer, text)
+  3. TTS pass  (answer → speech, audio via the streaming causal decoder)
+
+Text passes carry ``modalities: ["text"]`` and finish at stage 0; only the
+TTS pass (``modalities: ["audio"]``) streams codec frames into code2wav.
+
+Example (without --audio-file, vLLM's public ``mary_had_lamb`` asset is
+used as the spoken input):
+
+    python examples/offline_inference/audex/speech_to_speech.py \\
+        --audio-file question.wav --output results/answer.wav
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import re
+from pathlib import Path
+
+import torch
+from common import (
+    SAMPLE_RATE,
+    default_deploy_config,
+    guided_stage_params,
+    load_audex_tokenizer,
+    load_audio_file,
+    write_wav,
+)
+from vllm.assets.audio import AudioAsset
+
+from vllm_omni import Omni
+from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+ASR_QUESTION = "Transcribe the input speech."
+SYSTEM_PROMPT = "You are a helpful and harmless assistant.\n\nYou are not allowed to use any tools."
+# The official chat-pass recipe below (SYSTEM_PROMPT + TEXT_INSTRUCTION
+# prefix, open <think> priming, temp 1.0/top_p 0.95, seed retry) applies to
+# the 30B-A3B ONLY (see is_30b()/_chat_prompt below and
+# tests/e2e/offline_inference/test_audex_s2s.py, which mirrors this same
+# split). It is load-bearing on the 30B: without the formatting-instruction
+# prefix a bare transcript turn is treated as a TTS request and the model
+# emits literal <speechcodec_N> tokens instead of a text answer (the system
+# prompt alone does not prevent this). The 2B must NOT use this recipe: it
+# is long-verified stable on a bare prompt + engine-default sampling, while
+# the official temp-1.0 seed-0 draw hallucinates off-language text (yet
+# closes </think> cleanly, so the seed retry never fires) and fails the
+# round-trip WER gate — measured, reproduced byte-identically.
+TEXT_INSTRUCTION = (
+    "SYSTEM & FORMATTING INSTRUCTION: You are Audex, created by NVIDIA based on the Nemotron-Cascade-2 architecture. "
+    "You may output your reasoning, followed by your final response. "
+    "You may format your reasoning block however you like. "
+    "However, your final response must strictly follow these rules: "
+    "* Write in plain, unformatted prose like a book or newspaper article. "
+    "* Do not use markdown, bullet points, lists, or headers. "
+    "* Standard numbers, abbreviations, and symbols are acceptable. "
+    "* [CRITICAL] You must press enter after every single sentence, placing each sentence on its own separate line."
+)
+
+
+def is_30b(model: str) -> bool:
+    # Users pass arbitrary repo IDs or local snapshot paths, so this is a
+    # heuristic (not an exact match against the official 30B-A3B repo ID)
+    # — good enough for an example script; keep in sync with the same
+    # branch in examples/online_serving/audex/client.py and
+    # tests/e2e/offline_inference/test_audex_s2s.py.
+    return "30b" in model.lower()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Offline Audex cascaded S2S")
+    parser.add_argument("--model", type=str, default="nvidia/Nemotron-Labs-Audex-2B")
+    parser.add_argument(
+        "--audio-file",
+        type=str,
+        default=None,
+        help="Spoken question (WAV). Defaults to vLLM's mary_had_lamb audio asset.",
+    )
+    parser.add_argument("--output", type=str, default="results/audex_s2s_answer.wav")
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        # The model root's default deploy yaml is the TTS-only pipeline; the
+        # cascade needs the audio-capable 2-stage full pipeline.
+        default=default_deploy_config("audex_s2s.yaml"),
+        help="Deploy yaml (defaults to the audex_s2s pipeline).",
+    )
+    parser.add_argument(
+        "--cfg-scale",
+        type=float,
+        default=1.5,
+        help="CFG strength for the TTS pass (1.0 disables; official setting 1.5).",
+    )
+    return parser.parse_args()
+
+
+def _chat_prompt(user_text: str) -> str:
+    # Official chat-pass recipe: system prompt + formatting instruction
+    # prefixed to the user text, thinking ENABLED via an open <think> block
+    # (the official demo's web UI ships "Enable reasoning" checked, i.e.
+    # build_chat_prompt(..., enable_thinking=True); chat_template.jinja then
+    # renders "<|im_start|>assistant\n<think>\n"). The instruction invites
+    # the model to reason before answering — priming the block open keeps
+    # that reasoning inside <think>...</think> so _extract_final_response
+    # below can drop it; with a closed block the 30B leaks the reasoning as
+    # plain text in front of the answer.
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n{TEXT_INSTRUCTION}\n\n{user_text}<|im_end|>\n"
+        "<|im_start|>assistant\n<think>\n"
+    )
+
+
+def _asr_prompt() -> str:
+    return f"<|im_start|>user\n<so_embedding>\n{ASR_QUESTION}<|im_end|>\n<|im_start|>assistant\n<think></think>"
+
+
+def _extract_final_response(text: str) -> str:
+    # Mirror the official demo's extract_spoken_answer
+    # (cascaded_s2s_web_server.py): keep only what follows the LAST closing
+    # think tag, falling back to the full text when the model skipped
+    # reasoning or never closed the block. Benign no-op for the 2B, whose
+    # answers carry no think block.
+    if "</think>" in text:
+        answer = text.rsplit("</think>", 1)[-1].strip()
+        if answer:
+            return answer
+    return text.strip()
+
+
+def _clean(text: str) -> str:
+    # The full checkpoint prefixes transcripts with a language tag sentence
+    # and quotes the content; extract the quoted payload when present. Span
+    # first-to-last quote (not split on every apostrophe) so contractions
+    # inside the transcript (e.g. "don't") survive intact.
+    text = text.strip()
+    match = re.search(r"'(.*)'", text, flags=re.S)
+    if match and match.group(1).strip():
+        return match.group(1).strip()
+    return text
+
+
+def _text_of(outputs) -> str:
+    (req_output,) = outputs
+    return (req_output.outputs[0].text or "").strip()
+
+
+CHAT_MAX_TOKENS = 2048  # official --text-max-tokens default
+# The official demo samples this pass unseeded; some trajectories deliberate
+# past the token budget without ever closing the think block, so retry a few
+# deterministic seeds until one closes (see the chat pass below).
+CHAT_SEEDS = (0, 1, 2)
+
+
+def _chat_params(engine: Omni, seed: int):
+    # Official demo text-pass sampling (cascaded_s2s_web_server.py defaults:
+    # --text-temperature 1.0, --text-top-p 0.95, --text-max-tokens 2048).
+    # The yaml stage-0 defaults (temperature 0.1, top_k 80) are TTS-thinker
+    # settings; under near-greedy decoding the 30B loops inside its
+    # reasoning block until the token budget runs out and never emits
+    # </think>, so the extracted "answer" would be truncated reasoning.
+    params = copy.deepcopy(engine.resolve_sampling_params_list(None))
+    stage0 = params[0]
+    stage0.temperature = 1.0
+    stage0.top_p = 0.95
+    stage0.top_k = -1
+    stage0.max_tokens = CHAT_MAX_TOKENS
+    stage0.seed = seed
+    return params
+
+
+def _chat_once(engine: Omni, prompt: str, seed: int) -> tuple[str, bool]:
+    (req_output,) = engine.generate([{"prompt": prompt, "modalities": ["text"]}], _chat_params(engine, seed))
+    out = req_output.outputs[0]
+    text = (out.text or "").strip()
+    truncated = getattr(out, "finish_reason", None) == "length" or len(out.token_ids or []) >= CHAT_MAX_TOKENS
+    return text, truncated
+
+
+def main():
+    args = parse_args()
+    engine = Omni(model=args.model, deploy_config=args.deploy_config, trust_remote_code=True)
+
+    tokenizer = None
+    if args.cfg_scale > 1.0:
+        tokenizer = load_audex_tokenizer(args.model, profile="full", folder="checkpoint_folder_full")
+
+    if args.audio_file:
+        audio, sr = load_audio_file(args.audio_file)
+    else:
+        audio, sr = AudioAsset("mary_had_lamb").audio_and_sample_rate
+
+    # Pass 1 — ASR (text-final; never touches the speech decoder).
+    transcript = _clean(
+        _text_of(
+            engine.generate(
+                [
+                    {
+                        "prompt": _asr_prompt(),
+                        "multi_modal_data": {"audio": (audio, sr)},
+                        "modalities": ["text"],
+                    }
+                ]
+            )
+        )
+    )
+    print(f"[1/3] transcript : {transcript}")
+    if not transcript:
+        raise SystemExit("ASR pass produced an empty transcript; aborting cascade")
+
+    # Pass 2 — chat answer (text-final). The recipe is size-conditional (see
+    # the TEXT_INSTRUCTION comment above): the 30B requires the official
+    # recipe, the 2B regresses under it.
+    if is_30b(args.model):
+        # Official recipe. The raw completion is
+        # <reasoning...></think><answer>; speak only the final response.
+        # Retry with the next seed only when the budget ran out before the
+        # reasoning block closed (a natural stop without </think> is a
+        # complete answer); if every seed spins, fall back to the official
+        # demo's behavior of keeping the full text.
+        raw = ""
+        for seed in CHAT_SEEDS:
+            raw, truncated = _chat_once(engine, _chat_prompt(transcript), seed)
+            if "</think>" in raw or not truncated:
+                break
+            print(f"[2/3] chat seed {seed} hit the token budget mid-reasoning; retrying")
+        answer = _extract_final_response(raw)
+    else:
+        # 2B: bare prompt with a closed think block, engine-default sampling
+        # (yaml near-greedy), no retry; the answer is used as-is.
+        chat_prompt = f"<|im_start|>user\n{transcript}<|im_end|>\n<|im_start|>assistant\n<think></think>"
+        answer = _text_of(engine.generate([{"prompt": chat_prompt, "modalities": ["text"]}]))
+    print(f"[2/3] answer     : {answer}")
+    if not answer:
+        raise SystemExit("Chat pass produced an empty answer; aborting cascade")
+
+    # Pass 3 — TTS (audio-final; streams through code2wav). Both final
+    # stages of the pipeline may emit an output record for the request;
+    # collect the audio-bearing one.
+    # The formatting instruction puts every sentence on its own line;
+    # flatten to plain prose for the TTS thinker.
+    tts_prompt = build_cond_prompt(re.sub(r"\s+", " ", answer).strip())
+    outputs = engine.generate(
+        [{"prompt": tts_prompt, "modalities": ["audio"]}],
+        guided_stage_params(engine, tts_prompt, tokenizer, args.cfg_scale, "s2s-tts-pass"),
+    )
+    chunks: list[torch.Tensor] = []
+    for req_output in outputs:
+        mm = getattr(req_output, "multimodal_output", None) or {}
+        if not mm and req_output.outputs:
+            mm = getattr(req_output.outputs[0], "multimodal_output", None) or {}
+        audio_val = mm.get("model_outputs", mm.get("audio"))
+        if audio_val is None:
+            continue
+        if isinstance(audio_val, list):
+            chunks.extend(torch.as_tensor(a).float().cpu().reshape(-1) for a in audio_val if a is not None)
+        else:
+            chunks.append(torch.as_tensor(audio_val).float().cpu().reshape(-1))
+    pcm = torch.cat(chunks) if chunks else torch.empty(0)
+    if pcm.numel() == 0:
+        raise SystemExit("TTS pass produced empty audio")
+
+    out_path = Path(args.output)
+    write_wav(out_path, pcm)
+    print(f"[3/3] speech     : {pcm.numel() / SAMPLE_RATE:.2f}s -> {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/audex/text_to_audio.py b/examples/offline_inference/audex/text_to_audio.py
new file mode 100644
index 000000000..c357819c3
--- /dev/null
+++ b/examples/offline_inference/audex/text_to_audio.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline Audex (Nemotron-Labs-Audex-2B) text-to-audio inference example.
+
+Caption → general audio through the vLLM-Omni TTA pipeline: the audiogen
+thinker generates interleaved 4-codebook <audiocodec_N> RVQ tokens under an
+RVQ phase mask, and the external XCodec1 checkpoint decodes them to a 16 kHz
+mono WAV.
+
+(For DIFFUSION text-to-audio models — Stable Audio Open, AudioX — use
+``examples/offline_inference/text_to_audio/text_to_audio.py`` instead; Audex
+TTA is a two-stage autoregressive pipeline with a different interface.)
+
+Classifier-free guidance is effectively mandatory for TTA quality (official
+default scale 3.0), so every request submits a cond/uncond pair; requests
+run one at a time.
+
+Pass the HF repo ROOT as --model. XCodec1 resolves from --xcodec1-path /
+XCODEC1_PATH / the default hf-audio repo.
+
+Example:
+
+    python examples/offline_inference/audex/text_to_audio.py \\
+        --captions "Heavy rain falling on a tin roof." \\
+        --output-dir results/audex_tta_wavs
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import time
+from pathlib import Path
+
+from common import (
+    SAMPLE_RATE,
+    default_deploy_config,
+    extract_pcm,
+    guided_stage_params,
+    load_audex_tokenizer,
+    load_corpus,
+    write_wav,
+)
+
+from vllm_omni import Omni
+from vllm_omni.model_executor.models.audex.prompt import build_tta_cond_prompt, build_tta_null_prompt
+from vllm_omni.model_executor.models.audex.tta import build_tta_phase_token_ids
+
+DEFAULT_CAPTIONS = (
+    "Heavy rain falling on a tin roof.",
+    "A dog barking in the distance while birds chirp.",
+    "Ocean waves crashing on a rocky shore.",
+)
+DEFAULT_CODEC_CAP = 4000
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Offline Audex TTA inference")
+    parser.add_argument("--model", type=str, default="nvidia/Nemotron-Labs-Audex-2B")
+    parser.add_argument("--captions", type=str, nargs="+", default=None, help="Audio captions.")
+    parser.add_argument(
+        "--captions-file",
+        type=str,
+        default=None,
+        help="TSV corpus: one 'utt_id<TAB>caption' per line (overrides --captions).",
+    )
+    parser.add_argument("--output-dir", type=str, default="results/audex_tta_wavs")
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        # The model root's default deploy yaml is the TTS pipeline; TTA
+        # prompts and RVQ sampling params require the dedicated TTA pipeline.
+        default=default_deploy_config("audex_tta.yaml"),
+        help="Deploy yaml (defaults to the audex_tta pipeline).",
+    )
+    parser.add_argument(
+        "--xcodec1-path",
+        type=str,
+        default=None,
+        help="Local XCodec1 checkpoint (defaults to $XCODEC1_PATH or the hf-audio repo).",
+    )
+    parser.add_argument(
+        "--cfg-scale",
+        type=float,
+        default=3.0,
+        help="Classifier-free guidance strength (official TTA default 3.0; 1.0 disables).",
+    )
+    parser.add_argument(
+        "--codec-cap",
+        type=int,
+        default=DEFAULT_CODEC_CAP,
+        help="Max generated codec tokens before the phase mask forces <audiogen_end>.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    if args.xcodec1_path:
+        os.environ["XCODEC1_PATH"] = args.xcodec1_path
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    corpus = load_corpus(args.captions_file, args.captions, DEFAULT_CAPTIONS)
+
+    tokenizer = load_audex_tokenizer(args.model, profile="tta")
+    phase_token_ids, start_tid, end_tid = build_tta_phase_token_ids(tokenizer)
+    tta_rvq = {
+        "phase_token_ids": phase_token_ids,
+        "start_tid": start_tid,
+        "end_tid": end_tid,
+        "codec_cap": args.codec_cap,
+        # The prompt ends with <audiogen_start>, so generation begins at
+        # RVQ phase 0 immediately.
+        "start_in_prompt": True,
+    }
+
+    engine = Omni(model=args.model, deploy_config=args.deploy_config, trust_remote_code=True)
+
+    print(f"Model       : {args.model}")
+    print(f"Captions    : {len(corpus)}")
+    print(f"CFG scale   : {args.cfg_scale}")
+    print(f"Codec cap   : {args.codec_cap}")
+    print(f"Output dir  : {output_dir}")
+
+    total_elapsed = 0.0
+    total_dur = 0.0
+    for utt, caption in corpus:
+        cond_prompt = build_tta_cond_prompt(caption)
+        sampling = guided_stage_params(
+            engine,
+            cond_prompt,
+            tokenizer,
+            args.cfg_scale,
+            f"tta-{utt}",
+            extra_args={"tta_rvq": tta_rvq},
+            null_prompt_builder=build_tta_null_prompt,
+        )
+        t_start = time.perf_counter()
+        outputs = engine.generate([cond_prompt], sampling)
+        total_elapsed += time.perf_counter() - t_start
+
+        (req_output,) = outputs
+        pcm = extract_pcm(req_output.outputs[0].multimodal_output)
+        dur = pcm.numel() / SAMPLE_RATE
+        if dur <= 0:
+            raise RuntimeError(f"empty audio for {utt}")
+        out_path = output_dir / f"{utt}.wav"
+        write_wav(out_path, pcm)
+        total_dur += dur
+        print(f"  {utt:<48} dur={dur:6.2f}s  -> {out_path}")
+
+    rtf = total_elapsed / total_dur if total_dur > 0 else float("inf")
+    print(f"Total infer : {total_elapsed:.2f}s  total audio: {total_dur:.2f}s  RTF: {rtf:.3f}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/audex/text_to_speech.py b/examples/offline_inference/audex/text_to_speech.py
new file mode 100644
index 000000000..aadc3f719
--- /dev/null
+++ b/examples/offline_inference/audex/text_to_speech.py
@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline Audex (Nemotron-Labs-Audex-2B) TTS inference example.
+
+Runs Stage 0 (thinker) + Stage 1 (streaming causal speech decoder) end-to-end
+through the vLLM-Omni engine and saves a 16 kHz mono WAV per prompt.
+
+Pass the HF repo ROOT as --model; per-stage subfolders resolve automatically.
+
+Examples:
+
+    python examples/offline_inference/audex/text_to_speech.py \\
+        --texts "The weather is so good today." \\
+        --output-dir results/audex_wavs
+
+    # TSV corpus (utt_id<TAB>text per line), all requests in flight at once:
+    python examples/offline_inference/audex/text_to_speech.py \\
+        --texts-file corpus.tsv --output-dir results/audex_wavs
+
+    # One request at a time:
+    python examples/offline_inference/audex/text_to_speech.py \\
+        --texts-file corpus.tsv --sequential --output-dir results/audex_wavs
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+
+from common import (
+    GUIDED_TEMPERATURE,
+    SAMPLE_RATE,
+    extract_pcm,
+    guided_stage_params,
+    load_audex_tokenizer,
+    load_corpus,
+    request_index,
+    write_wav,
+)
+
+from vllm_omni import Omni
+from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+DEFAULT_TEXTS = (
+    "Hello world.",
+    "The quick brown fox jumps over the lazy dog.",
+    "Today is a beautiful day for a walk in the park.",
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Offline Audex TTS inference")
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="nvidia/Nemotron-Labs-Audex-2B",
+        help="HF repo root (or local snapshot root).",
+    )
+    parser.add_argument("--texts", type=str, nargs="+", default=None, help="Plain-text prompts.")
+    parser.add_argument(
+        "--texts-file",
+        type=str,
+        default=None,
+        help="TSV corpus: one 'utt_id<TAB>text' per line (overrides --texts).",
+    )
+    parser.add_argument("--output-dir", type=str, default="results/audex_wavs")
+    parser.add_argument("--deploy-config", type=str, default=None, help="Override the deploy config path.")
+    parser.add_argument(
+        "--sequential",
+        action="store_true",
+        help="Submit one request at a time instead of all at once.",
+    )
+    parser.add_argument(
+        "--cfg-scale",
+        type=float,
+        default=1.0,
+        help=(
+            "Classifier-free guidance strength. 1.0 disables guidance (default, "
+            "matches the v1 baseline); 1.5 is the official quality setting. "
+            "Guided runs submit one request at a time (each carries its own "
+            "length-matched null prompt and pair id)."
+        ),
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=None,
+        help="Override the deploy yaml's stage-0 sampling temperature.",
+    )
+    return parser.parse_args()
+
+
+def _write_outputs(outputs, batch: list[tuple[str, str]], output_dir: Path) -> float:
+    ordered = sorted(outputs, key=request_index)
+    if len(ordered) != len(batch):
+        raise RuntimeError(f"expected {len(batch)} outputs, got {len(ordered)}")
+
+    total_dur = 0.0
+    for (utt, _text), req_output in zip(batch, ordered):
+        pcm = extract_pcm(req_output.outputs[0].multimodal_output)
+        dur = pcm.numel() / SAMPLE_RATE
+        if dur <= 0:
+            raise RuntimeError(f"empty audio for {utt}")
+        out_path = output_dir / f"{utt}.wav"
+        write_wav(out_path, pcm)
+        total_dur += dur
+        print(f"  {utt:<40} dur={dur:6.2f}s  -> {out_path}")
+    return total_dur
+
+
+def main():
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    corpus = load_corpus(args.texts_file, args.texts, DEFAULT_TEXTS)
+
+    engine = Omni(model=args.model, deploy_config=args.deploy_config, trust_remote_code=True)
+
+    cfg_enabled = args.cfg_scale > 1.0
+    tokenizer = load_audex_tokenizer(args.model) if cfg_enabled else None
+
+    print(f"Model       : {args.model}")
+    print(f"Prompts     : {len(corpus)}")
+    print(f"Mode        : {'sequential' if args.sequential or cfg_enabled else 'batched'}")
+    print(f"CFG scale   : {args.cfg_scale}" + (" (guidance off)" if not cfg_enabled else ""))
+    print(f"Output dir  : {output_dir}")
+
+    total_elapsed = 0.0
+    total_dur = 0.0
+    # CFG runs one request at a time: each request needs its own pair id and
+    # text-specific null prompt in the stage-0 sampling params.
+    batches = [[item] for item in corpus] if (args.sequential or cfg_enabled) else [corpus]
+    for batch in batches:
+        prompts = [build_cond_prompt(text) for _utt, text in batch]
+        sampling_params_list = None
+        if cfg_enabled:
+            sampling_params_list = guided_stage_params(
+                engine,
+                prompts[0],
+                tokenizer,
+                args.cfg_scale,
+                f"cfg-{batch[0][0]}",
+                temperature=GUIDED_TEMPERATURE,
+            )
+        if args.temperature is not None:
+            import copy
+
+            if sampling_params_list is None:
+                sampling_params_list = copy.deepcopy(engine.resolve_sampling_params_list(None))
+            sampling_params_list[0].temperature = args.temperature
+        t_start = time.perf_counter()
+        outputs = engine.generate(prompts, sampling_params_list)
+        total_elapsed += time.perf_counter() - t_start
+        total_dur += _write_outputs(outputs, batch, output_dir)
+
+    rtf = total_elapsed / total_dur if total_dur > 0 else float("inf")
+    print(f"Total infer : {total_elapsed:.2f}s  total audio: {total_dur:.2f}s  RTF: {rtf:.3f}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/covo_audio/end2end.py b/examples/offline_inference/covo_audio/end2end.py
index ae7e5c6bb..ce728373d 100644
--- a/examples/offline_inference/covo_audio/end2end.py
+++ b/examples/offline_inference/covo_audio/end2end.py
@@ -64,7 +64,6 @@ def main(args):
         stage_init_timeout=args.stage_init_timeout,
         batch_timeout=args.batch_timeout,
         init_timeout=args.init_timeout,
-        shm_threshold_bytes=args.shm_threshold_bytes,
     )
 
     # Stage 0: fused_thinker_talker
diff --git a/examples/offline_inference/custom_pipeline/image_to_image/custom_pipeline.py b/examples/offline_inference/custom_pipeline/image_to_image/custom_pipeline.py
index fb14d9d33..1d38a598e 100644
--- a/examples/offline_inference/custom_pipeline/image_to_image/custom_pipeline.py
+++ b/examples/offline_inference/custom_pipeline/image_to_image/custom_pipeline.py
@@ -6,13 +6,13 @@ import logging
 import torch
 
 from vllm_omni.diffusion.data import OmniDiffusionConfig
-from vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image_edit import QwenImageEditPipeline
+from vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image_edit_plus import QwenImageEditPlusPipeline
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 
 logger = logging.getLogger(__name__)
 
 
-class CustomPipeline(QwenImageEditPipeline):
+class CustomPipeline(QwenImageEditPlusPipeline):
     def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
         super().__init__(od_config=od_config, prefix=prefix)
 
diff --git a/examples/offline_inference/image_to_image/image_edit.py b/examples/offline_inference/image_to_image/image_edit.py
index 12bd978a3..10cf91088 100644
--- a/examples/offline_inference/image_to_image/image_edit.py
+++ b/examples/offline_inference/image_to_image/image_edit.py
@@ -97,6 +97,7 @@ import torch
 from PIL import Image
 
 from vllm_omni.diffusion.data import DiffusionParallelConfig
+from vllm_omni.diffusion.utils.image_output import extract_images_from_outputs
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.entrypoints.openai.stage_params import clone_sampling_params
@@ -625,6 +626,9 @@ def main():
         if images:
             break
 
+    if not images:
+        images = extract_images_from_outputs(outputs)
+
     if not images:
         raise ValueError("No images found in request_output")
 
diff --git a/examples/offline_inference/image_to_video/README.md b/examples/offline_inference/image_to_video/README.md
index c161022a5..5df7f99cd 100644
--- a/examples/offline_inference/image_to_video/README.md
+++ b/examples/offline_inference/image_to_video/README.md
@@ -1,7 +1,7 @@
 # Image-To-Video
 
-This shared example generates videos from images with VACE, Wan2.2,
-LTX-2/LTX-2.3, HunyuanVideo-1.5, Cosmos3, and other compatible pipelines.
+This shared example generates videos from images with VACE, Wan2.2, LTX-2,
+HunyuanVideo-1.5, Cosmos3, and other compatible pipelines.
 
 - `image_to_video.py`: command-line script for single video generation with advanced options.
 
@@ -26,7 +26,7 @@ This folder provides a unified CLI script for image-to-video generation using vL
 | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` | 480 x 832 | 81 | 50 | 5.0 | Around 60 GiB BF16 for basic single-card usage |
 | `Wan-AI/Wan2.2-TI2V-5B-Diffusers` | 480 x 832 | 81 | 50 | 4.0 | Around 20–25 GiB BF16, smallest I2V model |
 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_i2v` | 480 x 832 | 121 | 50 | 6.0 | Around 100 GiB at default settings; the example enables `--enable-cpu-offload` + VAE tiling/slicing to fit an 80 GiB card |
-| LTX2 (local path + `--model-class-name LTX2ImageToVideoPipeline`) | 512 x 768 | 121 | 40 | 4.0 | Memory use depends on frame count and tensor parallelism |
+| `Lightricks/LTX-2` | 512 x 768 | 121 | 40 | video 3.0 / audio 7.0 | Memory use depends on frame count and tensor parallelism |
 
 !!! info
     Peak VRAM: based on basic single-card usage, batch size = 1, without any acceleration/optimization features. Some model weights cannot fit into one card with 80 GiB VRAM, which may need to use CPU offloading.
@@ -105,7 +105,7 @@ python image_to_video.py \
 | Argument | Type | Default | Description |
 | -------- | ---- | ------- | ----------- |
 | `--model` | str | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` | Diffusers I2V model ID or local path |
-| `--model-class-name` | str | `None` | Override model class name (e.g., `LTX2ImageToVideoPipeline`) |
+| `--model-class-name` | str | `None` | Optional pipeline override |
 | `--image` | str | (required) | Path to input image |
 | `--prompt` | str | `""` | Text description of desired motion/animation |
 | `--negative-prompt` | str | `""` | Optional list of artifacts to suppress |
@@ -195,24 +195,19 @@ python image_to_video.py \
   --output hunyuan_i2v.mp4
 ```
 
-### LTX2 Image-to-Video
+### LTX-2
 
 ```bash
 python image_to_video.py \
-  --model /path/to/LTX-2 \
-  --model-class-name LTX2ImageToVideoPipeline \
+  --model Lightricks/LTX-2 \
   --image cherry_blossom.jpg \
   --prompt "A cinematic dolly shot of cherry blossoms" \
-  --height 512 \
-  --width 768 \
-  --num-frames 121 \
-  --num-inference-steps 40 \
-  --guidance-scale 4.0 \
-  --frame-rate 24 \
-  --fps 24 \
   --output ltx2_i2v.mp4
 ```
 
+See the [LTX-2 recipe](../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, T2V, defaults, and advanced options.
+
 ## Advanced Features
 
 ### CFG Parallel
@@ -233,30 +228,6 @@ python image_to_video.py \
   --output i2v_cached.mp4
 ```
 
-### LTX-2.3
-
-```bash
-python image_to_video.py \
-  --model dg845/LTX-2.3-Diffusers \
-  --model-class-name LTX23ImageToVideoPipeline \
-  --image cherry_blossom.jpg \
-  --prompt "Cherry blossoms swaying gently in the breeze with synchronized ambient sound" \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 384 \
-  --width 512 \
-  --num-frames 25 \
-  --guidance-scale 4.0 \
-  --num-inference-steps 20 \
-  --frame-rate 24 \
-  --fps 24 \
-  --output ltx23_i2v_output.mp4
-```
-
-Use a Diffusers-format checkpoint such as `dg845/LTX-2.3-Diffusers`; the
-upstream `Lightricks/LTX-2.3` raw safetensors repo is not directly loadable by
-this pipeline. Pass `--model-class-name LTX23ImageToVideoPipeline` to select
-the LTX-2.3 image-to-video pipeline.
-
 ### Cosmos3
 
 ```bash
@@ -274,8 +245,8 @@ python image_to_video.py \
 
 Key arguments:
 
-- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V,
-  LTX-2/LTX-2.3, Cosmos3, or VACE).
+- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V, LTX-2,
+  Cosmos3, or VACE).
 - `--image`: Path to the first-frame or source image.
 - `--last-image`: Optional last-frame condition for models such as VACE.
 - `--mask-image`: Optional inpainting mask. White pixels are regenerated and black pixels are preserved.
@@ -290,7 +261,7 @@ Key arguments:
 - `--guidance-scale` and `--guidance-scale-high`: CFG scale (applied to low/high-noise stages for MoE).
 - `--negative-prompt`: Optional list of artifacts to suppress.
 - `--boundary-ratio`: Boundary split ratio for two-stage MoE models.
-- `--flow-shift`: Scheduler flow shift (default: model-specific — Wan/LTX2 5.0, Cosmos3 10.0).
+- `--flow-shift`: Scheduler flow shift (default: Wan 5.0, Cosmos3 10.0). LTX does not consume this option.
 - `--sample-solver`: Wan2.2 sampling solver. Use `unipc` for the default multistep solver, or `euler` for Lightning/Distill checkpoints.
 - `--num-inference-steps`: Number of denoising steps (default: model-specific — Wan 50, LTX2 40, Cosmos3 35).
 - `--fps`: Frames per second for the saved MP4 (requires `diffusers` export_to_video).
diff --git a/examples/offline_inference/image_to_video/image_to_video.py b/examples/offline_inference/image_to_video/image_to_video.py
index 2d1e70697..b2f27bb5b 100644
--- a/examples/offline_inference/image_to_video/image_to_video.py
+++ b/examples/offline_inference/image_to_video/image_to_video.py
@@ -23,16 +23,14 @@ Usage:
 
     # LTX2 image-to-video
     python image_to_video.py --model /path/to/LTX-2 \
-        --model-class-name LTX2ImageToVideoPipeline \
         --image input.jpg --prompt "A cinematic dolly shot of a boat" \
-        --num-frames 121 --num-inference-steps 40 --guidance-scale 4.0 \
+        --num-frames 121 --num-inference-steps 40 \
         --frame-rate 24 --fps 24 --output ltx2_i2v.mp4
 
     # LTX-2.3 image-to-video
-    python image_to_video.py --model dg845/LTX-2.3-Diffusers \
-        --model-class-name LTX23ImageToVideoPipeline \
+    python image_to_video.py --model diffusers/LTX-2.3-Diffusers \
         --image input.jpg --prompt "A cinematic dolly shot of a boat" \
-        --height 384 --width 512 --num-frames 25 --num-inference-steps 20 \
+        --height 512 --width 768 --num-frames 121 --num-inference-steps 30 \
         --frame-rate 24 --fps 24 --output ltx23_i2v.mp4
 
     # HunyuanVideo-1.5 I2V (480p)
@@ -100,7 +98,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--model-class-name",
         default=None,
-        help="Override model class name (e.g., LTX2ImageToVideoPipeline or LTX23ImageToVideoPipeline).",
+        help="Override model class name (LTX checkpoints default to LTX2Pipeline).",
+    )
+    parser.add_argument(
+        "--deploy-config",
+        default=None,
+        help="Optional deploy config YAML to use for pipeline-backed runs.",
     )
     parser.add_argument("--image", help="Path to the first-frame or source image.")
     parser.add_argument("--last-image", help="Path to a last-frame condition (used by models such as VACE).")
@@ -112,7 +115,7 @@ def parse_args() -> argparse.Namespace:
         help="Path to a reference image. Repeat to provide multiple references.",
     )
     parser.add_argument("--prompt", default="", help="Text prompt describing the desired motion.")
-    parser.add_argument("--negative-prompt", default="", help="Negative prompt.")
+    parser.add_argument("--negative-prompt", default=None, help="Negative prompt. Default: model-specific.")
     parser.add_argument("--seed", type=int, default=42, help="Random seed.")
     parser.add_argument("--guidance-scale", type=float, default=None, help="CFG scale. Default: model-specific.")
     parser.add_argument(
@@ -326,8 +329,12 @@ def main():
     generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(args.seed)
     model_name = str(args.model).lower() if args.model is not None else ""
     model_class_name = args.model_class_name
-    is_ltx2 = model_class_name in {"LTX2ImageToVideoPipeline", "LTX23ImageToVideoPipeline"}
+    model_class_name_lower = (model_class_name or "").lower()
+    is_ltx2_distilled = "distilled" in model_class_name_lower or "distilled" in model_name
+    is_ltx23 = "ltx23" in model_class_name_lower or "ltx-2.3" in model_name
+    is_ltx2 = is_ltx2_distilled or is_ltx23 or "ltx2" in model_class_name_lower or "ltx-2" in model_name
     is_cosmos = "cosmos" in model_name or (model_class_name is not None and "cosmos" in model_class_name.lower())
+    is_cosmos_edge = is_cosmos and ("edge" in model_name or "edge" in model_class_name_lower)
 
     image = PIL.Image.open(args.image).convert("RGB") if args.image else None
     last_image = PIL.Image.open(args.last_image).convert("RGB") if args.last_image else None
@@ -341,7 +348,19 @@ def main():
 
     # Per-model generation defaults, applied only when the matching flag is omitted.
     # Cosmos3 would otherwise silently inherit the Wan2.2 defaults (wrong size/steps/shift).
-    if is_cosmos:
+    if is_cosmos_edge:
+        # Cosmos3-Edge native defaults: 480x832, gs 5.0, flow_shift 3.0 — NOT the Nano/Super
+        # 720p / gs 6.0 / flow_shift 10.0 below, which produce degenerate output on Edge.
+        d_fps, d_guidance, d_num_frames, d_steps, d_flow_shift, d_max_area, d_mod = (
+            24,
+            5.0,
+            189,
+            35,
+            3.0,
+            480 * 832,
+            16,
+        )
+    elif is_cosmos:
         d_fps, d_guidance, d_num_frames, d_steps, d_flow_shift, d_max_area, d_mod = (
             24,
             6.0,
@@ -351,13 +370,23 @@ def main():
             1280 * 720,
             16,
         )
+    elif is_ltx2_distilled:
+        d_fps, d_guidance, d_num_frames, d_steps, d_flow_shift, d_max_area, d_mod = (
+            24,
+            None,
+            121,
+            8,
+            None,
+            1024 * 1536,
+            64,
+        )
     elif is_ltx2:
         d_fps, d_guidance, d_num_frames, d_steps, d_flow_shift, d_max_area, d_mod = (
             24,
-            4.0,
+            None,
             121,
-            40,
-            5.0,
+            30 if is_ltx23 else 40,
+            None,
             512 * 768,
             32,
         )
@@ -440,7 +469,6 @@ def main():
         vae_use_slicing=args.vae_use_slicing,
         vae_use_tiling=args.vae_use_tiling,
         boundary_ratio=args.boundary_ratio,
-        flow_shift=flow_shift,
         diffusion_kv_cache_dtype=args.diffusion_kv_cache_dtype,
         diffusion_kv_cache_skip_steps=args.diffusion_kv_cache_skip_steps,
         diffusion_kv_cache_skip_layers=args.diffusion_kv_cache_skip_layers,
@@ -453,6 +481,10 @@ def main():
         enable_diffusion_pipeline_profiler=args.enable_diffusion_pipeline_profiler,
         profiler_config=args.profiler_config,
     )
+    if args.deploy_config:
+        omni_kwargs["deploy_config"] = args.deploy_config
+    if flow_shift is not None:
+        omni_kwargs["flow_shift"] = flow_shift
     if args.quantization is not None:
         omni_kwargs["quantization"] = args.quantization
     # Cosmos3 loads its (gated) guardrail models at build time, so the guardrails
@@ -485,10 +517,14 @@ def main():
     print(f"  Video size: {width}x{height}")
     print(f"{'=' * 60}\n")
 
+    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=args.negative_prompt,
+        negative_prompt=negative_prompt,
         media_inputs=media_inputs,
         height=height,
         width=width,
@@ -504,11 +540,10 @@ def main():
         num_inference_steps=num_inference_steps,
         num_frames=num_frames,
         frame_rate=frame_rate,
-        extra_args={
-            "sample_solver": args.sample_solver,
-            "flow_shift": flow_shift,
-        },
+        extra_args={"sample_solver": args.sample_solver},
     )
+    if flow_shift is not None:
+        sampling_params.extra_args["flow_shift"] = flow_shift
 
     # Route model-specific knobs through extra_body, filtered against the model's
     # declared extra_body_params. Models without a declaration only forward explicit
diff --git a/examples/offline_inference/mammothmodal2_preview/README.md b/examples/offline_inference/mammothmodal2_preview/README.md
deleted file mode 100644
index bb68f3845..000000000
--- a/examples/offline_inference/mammothmodal2_preview/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# MammothModa2-Preview
-
-> Text-to-image (T2I) generation has moved to the shared offline image example.
-> See the recipe: [`recipes/MammothModa2/MammothModa2-Preview.md`](../../../recipes/MammothModa2/MammothModa2-Preview.md).
->
-> This directory retains the image-understanding (image → text) example below,
-> which is outside the scope of the diffusion `model_extras` example migration
-> (#4548 / RFC #4539: AR / Omni understanding examples keep dedicated scripts).
-
-## Run example (MammothModa2-Preview)
-
-Download model
-```bash
-hf download bytedance-research/MammothModa2-Preview --local-dir ./MammothModa2-Preview
-```
-
-### Image Summary
-
-```bash
-python examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py \
-  --model ./MammothModa2-Preview \
-  --deploy-config ./vllm_omni/deploy/mammoth_moda2_ar.yaml \
-  --question "Summarize this image." \
-  --image ./image.png
-```
diff --git a/examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py b/examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py
deleted file mode 100644
index 7a22803c9..000000000
--- a/examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py
+++ /dev/null
@@ -1,117 +0,0 @@
-"""
-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 = getattr(stage_outputs, "request_output", 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()
diff --git a/examples/offline_inference/mimo_audio/end2end.py b/examples/offline_inference/mimo_audio/end2end.py
index 2fe46c972..4ba8f483a 100644
--- a/examples/offline_inference/mimo_audio/end2end.py
+++ b/examples/offline_inference/mimo_audio/end2end.py
@@ -188,7 +188,6 @@ def main(args):
         init_sleep_seconds=args.init_sleep_seconds,
         batch_timeout=args.batch_timeout,
         init_timeout=args.init_timeout,
-        shm_threshold_bytes=args.shm_threshold_bytes,
     )
 
     thinker_sampling_params = SamplingParams(
@@ -219,31 +218,31 @@ def main(args):
     # Build query result based on query type
     # Notice: The audio files used in this example are available at: https://github.com/XiaomiMiMo/MiMo-Audio/tree/main/examples
     if args.query_type == "tts_sft":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type tts_sft
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type tts_sft
         query_result = query_func(text=text, read_text_only=True)
     elif args.query_type == "tts_sft_with_instruct":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type tts_sft_with_instruct --instruct "Speak happily in a child's voice"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type tts_sft_with_instruct --instruct "Speak happily in a child's voice"
         query_result = query_func(text=text, instruct=instruct, read_text_only=True)
     elif args.query_type == "tts_sft_with_audio":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type tts_sft_with_audio --audio_path "./spoken_dialogue_assistant_turn_1.wav"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type tts_sft_with_audio --audio-path "./spoken_dialogue_assistant_turn_1.wav"
         audio_list = [get_audio_data(audio_path)]
         query_result = query_func(text=text, read_text_only=True, prompt_speech=audio_path, audio_list=audio_list)
     elif args.query_type == "tts_sft_with_natural_instruction":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type tts_sft_with_natural_instruction --text "In a panting young male voice, he said: I can't run anymore, wait for me!"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type tts_sft_with_natural_instruction --text "In a panting young male voice, he said: I can't run anymore, wait for me!"
         query_result = query_func(text=text, read_text_only=False)
     elif args.query_type == "audio_trancribing_sft":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type audio_trancribing_sft --audio_path "./spoken_dialogue_assistant_turn_1.wav"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type audio_trancribing_sft --audio-path "./spoken_dialogue_assistant_turn_1.wav"
         audio_path = "spoken_dialogue_assistant_turn_1.wav"
         text = "Please transcribe this audio and repeat it once."
         query_result = query_func(text=text, audio_path=audio_path, use_sostm=True)
     elif args.query_type == "audio_understanding_sft":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type audio_understanding_sft --text "Summarize the audio." --audio_path "./spoken_dialogue_assistant_turn_1.wav"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type audio_understanding_sft --text "Summarize the audio." --audio-path "./spoken_dialogue_assistant_turn_1.wav"
         query_result = query_func(text=text, audio_path=audio_path)
     elif args.query_type == "audio_understanding_sft_with_thinking":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type audio_understanding_sft_with_thinking --text "Summarize the audio." --audio_path "./spoken_dialogue_assistant_turn_1.wav"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type audio_understanding_sft_with_thinking --text "Summarize the audio." --audio-path "./spoken_dialogue_assistant_turn_1.wav"
         query_result = query_func(text=text, audio_path=audio_path, thinking=True)
     elif args.query_type == "spoken_dialogue_sft_multiturn":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type spoken_dialogue_sft_multiturn  --audio_path "./prompt_speech_zh_m.wav"
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type spoken_dialogue_sft_multiturn --audio-path "./prompt_speech_zh_m.wav"
         first_turn_text_response = "我没办法获取实时的天气信息。不过呢，你可以试试几个方法来查看今天的天气。首先，你可以用手机自带的天气功能，比如苹果手机的天气应用，或者直接在系统设置里查看。其次，你也可以用一些专业的天气服务，像是国外的AccuWeather、Weather.com，或者国内的中国天气网、墨迹天气等等。再有就是，你还可以在谷歌或者百度里直接搜索你所在的城市加上天气这两个字。如果你能告诉我你所在的城市，我也可以帮你分析一下历史天气趋势，不过最新的数据还是需要你通过官方渠道去获取哦。"
         audio_list = []
         s1_audio_path = "weather_of_today.mp3"
@@ -261,7 +260,7 @@ def main(args):
         ]
         query_result = query_func(message_list, system_prompt=None, ref_audio_path=audio_path, audio_list=audio_list)
     elif args.query_type == "speech2text_dialogue_sft_multiturn":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type speech2text_dialogue_sft_multiturn
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type speech2text_dialogue_sft_multiturn
         s1_audio_path = "weather_of_today.mp3"
         s2_audio_path = "beijing.mp3"
         audio_list = []
@@ -277,7 +276,7 @@ def main(args):
         ]
         query_result = query_func(message_list, thinking=True, audio_list=audio_list)
     elif args.query_type == "text_dialogue_sft_multiturn":
-        # python3 -u end2end.py --stage-configs-path ${config_file} --model ${MODEL_PATH}  --query-type text_dialogue_sft_multiturn
+        # python3 -u end2end.py --deploy-config ${config_file} --model-name ${MODEL_PATH} --query-type text_dialogue_sft_multiturn
         message_list = [
             {"role": "user", "content": "Could you recommend some tourist attractions in China?"},
             {"role": "assistant", "content": "Hello, which city would you like to travel to?"},
diff --git a/examples/offline_inference/minicpmo/README.md b/examples/offline_inference/minicpmo/README.md
new file mode 100644
index 000000000..b80fc0aa6
--- /dev/null
+++ b/examples/offline_inference/minicpmo/README.md
@@ -0,0 +1,91 @@
+# MiniCPM-o 4.5: Offline inference
+
+Two-stage pipeline: **thinker** (multimodal understanding) → **talker + Token2Wav**
+(24 kHz speech). Deploy config auto-loads from
+`vllm_omni/deploy/minicpmo_4_5.yaml` (2-GPU default).
+
+## Setup
+
+- Install talker deps: `pip install stepaudio2-minicpmo`
+- `--trust-remote-code` is always passed by `end2end.py` (required for MiniCPMO)
+- See [stage configuration docs](https://docs.vllm.ai/projects/vllm-omni/en/latest/configuration/stage_configs/) for memory tuning
+
+## Run examples
+
+### Single prompt
+
+```bash
+cd examples/offline_inference/minicpmo
+bash run_single_prompt.sh
+```
+
+### Multiple prompts
+
+```bash
+bash run_multiple_prompts.sh
+```
+
+### Thinker tensor parallel (3-GPU)
+
+```bash
+bash run_single_prompt_tp.sh
+```
+
+### Modality control
+
+Text-only (skip talker / no `<|tts_bos|>`):
+
+```bash
+python end2end.py --query-type use_audio --modalities text
+```
+
+Text + speech (default — appends `<|tts_bos|>`):
+
+```bash
+python end2end.py --query-type text --modalities text,audio
+```
+
+### Local media files
+
+```bash
+python end2end.py --query-type use_video --video-path /path/to/video.mp4
+python end2end.py --query-type use_image --image-path /path/to/image.jpg
+python end2end.py --query-type use_audio --audio-path /path/to/audio.wav
+python end2end.py --query-type use_mixed_modalities \
+    --video-path /path/to/video.mp4 \
+    --image-path /path/to/image.jpg \
+    --audio-path /path/to/audio.wav
+```
+
+Supported `--query-type` values:
+
+| Query type | Inputs |
+|---|---|
+| `text` | Text only |
+| `use_image` | Image + text |
+| `use_audio` | Audio + text |
+| `use_video` | Video + text |
+| `use_multi_audios` | Two audio clips |
+| `use_mixed_modalities` | Audio + image + video |
+
+### Custom deploy config
+
+```bash
+python end2end.py --query-type text \
+    --deploy-config /path/to/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
+```
+
+## Notes
+
+- Speech requires `<|tts_bos|>` on the assistant prefix (offline equivalent of
+  online `chat_template_kwargs.use_tts_template=true`). Without it, the talker
+  gets an empty TTS span.
+- Output WAV is **24 kHz mono**.
+- Placeholders in the prompt are MiniCPM-style:
+  `(<image>./</image>)`, `(<audio>./</audio>)`, `(<video>./</video>)`.
+- Default layout needs **2 GPUs**. Async chunking is off in the bundled YAMLs.
+
+## Online serving
+
+See [`examples/online_serving/minicpmo/`](../../online_serving/minicpmo/) and
+the recipe [`recipes/OpenBMB/MiniCPM-o-4_5.md`](../../../recipes/OpenBMB/MiniCPM-o-4_5.md).
diff --git a/examples/offline_inference/minicpmo/end2end.py b/examples/offline_inference/minicpmo/end2end.py
new file mode 100644
index 000000000..e9c9019c0
--- /dev/null
+++ b/examples/offline_inference/minicpmo/end2end.py
@@ -0,0 +1,543 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""
+Offline end-to-end inference for MiniCPM-o 4.5 (thinker + talker/Token2Wav).
+
+MiniCPM-o uses placeholders ``(<image>./</image>)``, ``(<audio>./</audio>)``,
+and ``(<video>./</video>)``. Speech output requires a ``<|tts_bos|>`` suffix on
+the assistant prefix (equivalent to online ``chat_template_kwargs.use_tts_template``).
+"""
+
+import os
+import time
+from typing import NamedTuple
+
+import numpy as np
+import soundfile as sf
+import vllm
+from PIL import Image
+from vllm import SamplingParams
+from vllm.assets.audio import AudioAsset
+from vllm.assets.image import ImageAsset
+from vllm.assets.video import VideoAsset, video_to_ndarrays
+from vllm.multimodal.image import convert_image_mode
+from vllm.multimodal.media.audio import load_audio
+
+from vllm_omni.entrypoints.omni import Omni
+from vllm_omni.utils.tracking_parser import TrackingArgumentParser
+
+SEED = 42
+
+default_system = (
+    "You are MiniCPM-o, a helpful multimodal assistant that can "
+    "understand images, audio and video, and respond in text and speech."
+)
+
+
+class QueryResult(NamedTuple):
+    inputs: dict
+    limit_mm_per_prompt: dict[str, int]
+
+
+def _assistant_prefix(use_tts: bool) -> str:
+    # Matches HF chat_template: assistant header, optional empty <think>, then TTS bos.
+    prefix = "<|im_start|>assistant\n"
+    if use_tts:
+        prefix += "<|tts_bos|>"
+    return prefix
+
+
+def _build_prompt(user_body: str, use_tts: bool) -> str:
+    return (
+        f"<|im_start|>system\n{default_system}<|im_end|>\n"
+        f"<|im_start|>user\n{user_body}<|im_end|>\n"
+        f"{_assistant_prefix(use_tts)}"
+    )
+
+
+def get_text_query(question: str | None = None, use_tts: bool = True) -> QueryResult:
+    if question is None:
+        question = "Say hello, then introduce vLLM-Omni in one sentence."
+    return QueryResult(
+        inputs={"prompt": _build_prompt(question, use_tts=use_tts)},
+        limit_mm_per_prompt={},
+    )
+
+
+def get_image_query(
+    question: str | None = None,
+    image_path: str | None = None,
+    use_tts: bool = True,
+) -> QueryResult:
+    if question is None:
+        question = "What is the content of this image?"
+    user_body = f"(<image>./</image>)\n{question}"
+
+    if image_path:
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+        image_data = convert_image_mode(Image.open(image_path), "RGB")
+    else:
+        image_data = convert_image_mode(ImageAsset("cherry_blossom").pil_image, "RGB")
+
+    return QueryResult(
+        inputs={
+            "prompt": _build_prompt(user_body, use_tts=use_tts),
+            "multi_modal_data": {"image": image_data},
+        },
+        limit_mm_per_prompt={"image": 1},
+    )
+
+
+def get_audio_query(
+    question: str | None = None,
+    audio_path: str | None = None,
+    sampling_rate: int = 16000,
+    use_tts: bool = True,
+) -> QueryResult:
+    if question is None:
+        question = "What is the content of this audio?"
+    user_body = f"(<audio>./</audio>)\n{question}"
+
+    if audio_path:
+        if not os.path.exists(audio_path):
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+        audio_signal, sr = load_audio(audio_path, sr=sampling_rate)
+        audio_data = (audio_signal.astype(np.float32), sr)
+    else:
+        audio_data = AudioAsset("mary_had_lamb").audio_and_sample_rate
+
+    return QueryResult(
+        inputs={
+            "prompt": _build_prompt(user_body, use_tts=use_tts),
+            "multi_modal_data": {"audio": audio_data},
+        },
+        limit_mm_per_prompt={"audio": 1},
+    )
+
+
+def get_video_query(
+    question: str | None = None,
+    video_path: str | None = None,
+    num_frames: int = 16,
+    use_tts: bool = True,
+) -> QueryResult:
+    if question is None:
+        question = "Why is this video funny?"
+    user_body = f"(<video>./</video>)\n{question}"
+
+    if video_path:
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        video_frames = video_to_ndarrays(video_path, num_frames=num_frames)
+    else:
+        video_frames = VideoAsset(name="baby_reading", num_frames=num_frames).np_ndarrays
+
+    return QueryResult(
+        inputs={
+            "prompt": _build_prompt(user_body, use_tts=use_tts),
+            "multi_modal_data": {"video": video_frames},
+        },
+        limit_mm_per_prompt={"video": 1},
+    )
+
+
+def get_mixed_modalities_query(
+    video_path: str | None = None,
+    image_path: str | None = None,
+    audio_path: str | None = None,
+    num_frames: int = 16,
+    sampling_rate: int = 16000,
+    use_tts: bool = True,
+) -> QueryResult:
+    question = "What is recited in the audio? What is the content of this image? Why is this video funny?"
+    user_body = f"(<audio>./</audio>)\n(<image>./</image>)\n(<video>./</video>)\n{question}"
+
+    if video_path:
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        video_frames = video_to_ndarrays(video_path, num_frames=num_frames)
+    else:
+        video_frames = VideoAsset(name="baby_reading", num_frames=num_frames).np_ndarrays
+
+    if image_path:
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+        image_data = convert_image_mode(Image.open(image_path), "RGB")
+    else:
+        image_data = convert_image_mode(ImageAsset("cherry_blossom").pil_image, "RGB")
+
+    if audio_path:
+        if not os.path.exists(audio_path):
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+        audio_signal, sr = load_audio(audio_path, sr=sampling_rate)
+        audio_data = (audio_signal.astype(np.float32), sr)
+    else:
+        audio_data = AudioAsset("mary_had_lamb").audio_and_sample_rate
+
+    return QueryResult(
+        inputs={
+            "prompt": _build_prompt(user_body, use_tts=use_tts),
+            "multi_modal_data": {
+                "audio": audio_data,
+                "image": image_data,
+                "video": video_frames,
+            },
+        },
+        limit_mm_per_prompt={"audio": 1, "image": 1, "video": 1},
+    )
+
+
+def get_multi_audios_query(use_tts: bool = True) -> QueryResult:
+    question = "Are these two audio clips the same?"
+    user_body = f"(<audio>./</audio>)\n(<audio>./</audio>)\n{question}"
+    return QueryResult(
+        inputs={
+            "prompt": _build_prompt(user_body, use_tts=use_tts),
+            "multi_modal_data": {
+                "audio": [
+                    AudioAsset("winning_call").audio_and_sample_rate,
+                    AudioAsset("mary_had_lamb").audio_and_sample_rate,
+                ],
+            },
+        },
+        limit_mm_per_prompt={"audio": 2},
+    )
+
+
+query_map = {
+    "text": get_text_query,
+    "use_audio": get_audio_query,
+    "use_image": get_image_query,
+    "use_video": get_video_query,
+    "use_multi_audios": get_multi_audios_query,
+    "use_mixed_modalities": get_mixed_modalities_query,
+}
+
+
+def _wants_tts(modalities: str | None) -> bool:
+    """TTS bos is needed whenever audio is among the requested output modalities."""
+    if modalities is None:
+        return True
+    parts = {p.strip() for p in modalities.split(",") if p.strip()}
+    return "audio" in parts
+
+
+def main(args):
+    model_name = args.model
+    print("=" * 20, "\n", f"vllm version: {vllm.__version__}", "\n", "=" * 20)
+
+    video_path = getattr(args, "video_path", None)
+    image_path = getattr(args, "image_path", None)
+    audio_path = getattr(args, "audio_path", None)
+    use_tts = _wants_tts(args.modalities)
+
+    query_func = query_map[args.query_type]
+    if args.query_type == "use_video":
+        query_result = query_func(
+            video_path=video_path,
+            num_frames=getattr(args, "num_frames", 16),
+            use_tts=use_tts,
+        )
+    elif args.query_type == "use_image":
+        query_result = query_func(image_path=image_path, use_tts=use_tts)
+    elif args.query_type == "use_audio":
+        query_result = query_func(
+            audio_path=audio_path,
+            sampling_rate=getattr(args, "sampling_rate", 16000),
+            use_tts=use_tts,
+        )
+    elif args.query_type == "use_mixed_modalities":
+        query_result = query_func(
+            video_path=video_path,
+            image_path=image_path,
+            audio_path=audio_path,
+            num_frames=getattr(args, "num_frames", 16),
+            sampling_rate=getattr(args, "sampling_rate", 16000),
+            use_tts=use_tts,
+        )
+    elif args.query_type == "use_multi_audios":
+        query_result = query_func(use_tts=use_tts)
+    else:
+        query_result = query_func(use_tts=use_tts)
+
+    omni_kwargs = vars(args).copy()
+    # Drop example-only CLI keys that are not Omni / engine args.
+    for key in (
+        "query_type",
+        "output_wav",
+        "output_dir",
+        "num_prompts",
+        "txt_prompts",
+        "video_path",
+        "image_path",
+        "audio_path",
+        "num_frames",
+        "sampling_rate",
+        "modalities",
+        "py_generator",
+        "enable_profiler",
+        "profiler_stages",
+        "log_dir",
+    ):
+        omni_kwargs.pop(key, None)
+    omni_kwargs["model"] = model_name
+    omni_kwargs["trust_remote_code"] = True
+    omni = Omni(**omni_kwargs)
+
+    # Stage 0 (thinker): multimodal understanding → text (+ TTS span when enabled).
+    thinker_sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        top_k=-1,
+        max_tokens=2048,
+        seed=SEED,
+        detokenize=True,
+        repetition_penalty=1.1,
+    )
+    # Stage 1 (talker + Token2Wav): max_tokens=1 satisfies the scheduler;
+    # waveform is produced in-process by Token2Wav.
+    talker_sampling_params = SamplingParams(
+        temperature=0.0,
+        top_p=1.0,
+        top_k=-1,
+        max_tokens=1,
+        seed=SEED,
+        detokenize=False,
+    )
+    sampling_params_list = [thinker_sampling_params, talker_sampling_params][: omni.num_stages]
+
+    if args.txt_prompts is None:
+        prompts = [query_result.inputs for _ in range(args.num_prompts)]
+    else:
+        assert args.query_type == "text", "txt-prompts is only supported for text query type"
+        with open(args.txt_prompts, encoding="utf-8") as f:
+            lines = [ln.strip() for ln in f.readlines()]
+            prompts = [get_text_query(ln, use_tts=use_tts).inputs for ln in lines if ln != ""]
+            print(f"[Info] Loaded {len(prompts)} prompts from {args.txt_prompts}")
+
+    if args.modalities is not None:
+        output_modalities = args.modalities.split(",")
+        for prompt in prompts:
+            prompt["modalities"] = output_modalities
+
+    profiler_enabled = args.enable_profiler
+    if profiler_enabled:
+        omni.start_profile(stages=args.profiler_stages)
+
+    omni_generator = omni.generate(prompts, sampling_params_list, py_generator=args.py_generator)
+    output_dir = args.output_dir if getattr(args, "output_dir", None) else args.output_wav
+    os.makedirs(output_dir, exist_ok=True)
+
+    total_requests = len(prompts)
+    processed_count = 0
+    print(f"query type: {args.query_type}")
+    print(f"use_tts (tts_bos): {use_tts}")
+
+    for stage_outputs in omni_generator:
+        output = stage_outputs.request_output
+        if stage_outputs.final_output_type == "text":
+            request_id = output.request_id
+            text_output = output.outputs[0].text
+            out_txt = os.path.join(output_dir, f"{request_id}.txt")
+            lines = [
+                "Prompt:\n",
+                str(output.prompt) + "\n",
+                "vllm_text_output:\n",
+                str(text_output).strip() + "\n",
+            ]
+            try:
+                with open(out_txt, "w", encoding="utf-8") as f:
+                    f.writelines(lines)
+            except Exception as e:
+                print(f"[Warn] Failed writing text file {out_txt}: {e}")
+            print(f"Request ID: {request_id}, Text saved to {out_txt}")
+        elif stage_outputs.final_output_type == "audio":
+            request_id = output.request_id
+            audio_tensor = output.outputs[0].multimodal_output["audio"]
+            output_wav = os.path.join(output_dir, f"output_{request_id}.wav")
+
+            if isinstance(audio_tensor, list):
+                import torch
+
+                audio_tensor = torch.cat(
+                    [(t if isinstance(t, torch.Tensor) else torch.tensor(t)).flatten() for t in audio_tensor]
+                )
+            audio_numpy = audio_tensor.float().detach().cpu().numpy()
+            if audio_numpy.ndim > 1:
+                audio_numpy = audio_numpy.flatten()
+
+            # MiniCPM-o 4.5 Token2Wav emits 24 kHz mono.
+            sf.write(output_wav, audio_numpy, samplerate=24000, format="WAV")
+            print(f"Request ID: {request_id}, Saved audio to {output_wav}")
+
+        processed_count += 1
+        if profiler_enabled and processed_count >= total_requests:
+            print(f"[Info] Processed {processed_count}/{total_requests}. Stopping profiler inside active loop...")
+            omni.stop_profile(stages=args.profiler_stages)
+            print("[Info] Waiting 30s for workers to write trace files to disk...")
+            time.sleep(30)
+            print("[Info] Trace export wait time finished.")
+    omni.close()
+
+
+def parse_args():
+    parser = TrackingArgumentParser(
+        description="Offline inference demo for MiniCPM-o 4.5 (text / image / audio / video → text + speech)"
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="openbmb/MiniCPM-o-4_5",
+        help="Model name or path.",
+    )
+    parser.add_argument(
+        "--query-type",
+        "-q",
+        type=str,
+        default="text",
+        choices=query_map.keys(),
+        help="Query type.",
+    )
+    parser.add_argument(
+        "--log-stats",
+        action="store_true",
+        default=False,
+        help="Enable writing detailed statistics (default: disabled)",
+    )
+    parser.add_argument(
+        "--stage-init-timeout",
+        type=int,
+        default=300,
+        help="Timeout for initializing a single stage in seconds (default: 300)",
+    )
+    parser.add_argument(
+        "--batch-timeout",
+        type=int,
+        default=5,
+        help="Timeout for batching in seconds (default: 5)",
+    )
+    parser.add_argument(
+        "--init-timeout",
+        type=int,
+        default=300,
+        help="Timeout for initializing stages in seconds (default: 300)",
+    )
+    parser.add_argument(
+        "--shm-threshold-bytes",
+        type=int,
+        default=65536,
+        help="Threshold for using shared memory in bytes (default: 65536)",
+    )
+    parser.add_argument(
+        "--output-wav",
+        default="output_audio",
+        help="[Deprecated] Output wav directory (use --output-dir).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=None,
+        help="Output directory for text/audio results.",
+    )
+    parser.add_argument(
+        "--num-prompts",
+        type=int,
+        default=1,
+        help="Number of prompts to generate.",
+    )
+    parser.add_argument(
+        "--txt-prompts",
+        type=str,
+        default=None,
+        help="Path to a .txt file with one prompt per line (preferred).",
+    )
+    parser.add_argument(
+        "--stage-configs-path",
+        type=str,
+        default=None,
+        help="Path to a stage configs file (deprecated; prefer --deploy-config).",
+    )
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        default=None,
+        help="Path to a deploy YAML (default: auto-load minicpmo_4_5.yaml).",
+    )
+    parser.add_argument(
+        "--video-path",
+        "-v",
+        type=str,
+        default=None,
+        help="Path to local video file. If not provided, uses default video asset.",
+    )
+    parser.add_argument(
+        "--image-path",
+        "-i",
+        type=str,
+        default=None,
+        help="Path to local image file. If not provided, uses default image asset.",
+    )
+    parser.add_argument(
+        "--audio-path",
+        "-a",
+        type=str,
+        default=None,
+        help="Path to local audio file. If not provided, uses default audio asset.",
+    )
+    parser.add_argument(
+        "--num-frames",
+        type=int,
+        default=16,
+        help="Number of frames to extract from video (default: 16).",
+    )
+    parser.add_argument(
+        "--sampling-rate",
+        type=int,
+        default=16000,
+        help="Sampling rate for audio loading (default: 16000).",
+    )
+    parser.add_argument(
+        "--log-dir",
+        type=str,
+        default="logs",
+        help="Log directory (default: logs).",
+    )
+    parser.add_argument(
+        "--modalities",
+        type=str,
+        default=None,
+        help="Output modalities (comma-separated), e.g. text or text,audio.",
+    )
+    parser.add_argument(
+        "--py-generator",
+        action="store_true",
+        default=False,
+        help="Use py_generator mode. The returned type of Omni.generate() is a Python Generator object.",
+    )
+    parser.add_argument(
+        "--enable-profiler",
+        action="store_true",
+        default=False,
+        help="Enables profiling when set.",
+    )
+    parser.add_argument(
+        "--profiler-stages",
+        type=int,
+        nargs="*",
+        default=None,
+        help="List of stage IDs to profile. If not set, profiles all stages.",
+    )
+    parser.add_argument(
+        "--dtype",
+        type=str,
+        default="auto",
+        help="Model dtype (auto, half, float16, bfloat16, float, float32).",
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/offline_inference/minicpmo/run_multiple_prompts.sh b/examples/offline_inference/minicpmo/run_multiple_prompts.sh
new file mode 100755
index 000000000..f130fece3
--- /dev/null
+++ b/examples/offline_inference/minicpmo/run_multiple_prompts.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# Multi-prompt offline batch (py_generator mode).
+set -euo pipefail
+cd "$(dirname "$0")"
+
+python end2end.py --output-wav output_audio \
+                  --query-type text \
+                  --txt-prompts ../qwen3_omni/text_prompts_10.txt \
+                  --py-generator
diff --git a/examples/offline_inference/minicpmo/run_single_prompt.sh b/examples/offline_inference/minicpmo/run_single_prompt.sh
new file mode 100755
index 000000000..3a43ddda9
--- /dev/null
+++ b/examples/offline_inference/minicpmo/run_single_prompt.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Single-prompt offline smoke test (text → text + 24 kHz speech).
+set -euo pipefail
+cd "$(dirname "$0")"
+
+python end2end.py --output-wav output_audio \
+                  --query-type text
diff --git a/examples/offline_inference/minicpmo/run_single_prompt_tp.sh b/examples/offline_inference/minicpmo/run_single_prompt_tp.sh
new file mode 100755
index 000000000..88f488d2c
--- /dev/null
+++ b/examples/offline_inference/minicpmo/run_single_prompt_tp.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Single-prompt offline run with thinker tensor-parallel (3-GPU layout).
+# Thinker on GPU 0,1 (TP=2); talker + Token2Wav on GPU 2.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+REPO_ROOT="$(cd ../../.. && pwd)"
+
+python end2end.py --output-wav output_audio \
+                  --query-type use_audio \
+                  --deploy-config "${REPO_ROOT}/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml" \
+                  --stage-init-timeout 300
diff --git a/examples/offline_inference/personaplex/personaplex_offline.py b/examples/offline_inference/personaplex/personaplex_offline.py
new file mode 100644
index 000000000..ea011b8a9
--- /dev/null
+++ b/examples/offline_inference/personaplex/personaplex_offline.py
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline PersonaPlex inference through the vllm-omni fullduplex backend.
+
+This is the runnable end-to-end proof for the integration: it drives a user WAV
+through :class:`PersonaPlexEngine` + :class:`PersonaPlexSession` (our wrappers
+around the Moshi/Mimi lockstep loop) and writes the agent's audio + inner-monologue
+text. It mirrors ``python -m moshi.offline`` but goes through our ``FrameStepper``
+seam, so a green run validates that the session/adapter plumbing is faithful.
+
+Prereqs: HF access to ``nvidia/personaplex-7b-v1`` (``export HF_TOKEN=...``). The
+stack is moshi-free (native temporal + depformer + streaming Mimi via
+``transformers``); decoding is greedy.
+
+Example:
+    python examples/offline_inference/personaplex/personaplex_offline.py \\
+        --input-wav input_assistant.wav --output-wav out.wav \\
+        --voice-prompt NATF2.pt --persona "You are a wise and friendly teacher."
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.personaplex import (
+    PersonaPlexConfig,
+    PersonaPlexEngine,
+    PersonaPlexSession,
+)
+from vllm_omni.experimental.fullduplex.personaplex.config import DEFAULT_PERSONA
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input-wav", required=True, help="User-side input WAV")
+    parser.add_argument("--output-wav", required=True, help="Agent audio output WAV")
+    parser.add_argument("--output-text", default=None, help="Optional JSON for agent text")
+    parser.add_argument("--voice-prompt", default="NATF2.pt", help="Voice clone (bundled .pt or .wav)")
+    parser.add_argument("--persona", default=DEFAULT_PERSONA, help="System role text")
+    parser.add_argument("--hf-repo", default="nvidia/personaplex-7b-v1")
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--cpu-offload", action="store_true")
+    args = parser.parse_args()
+
+    import sphn  # local import: only the runnable driver needs the audio I/O dep
+
+    config = PersonaPlexConfig(
+        hf_repo=args.hf_repo,
+        voice_prompt=args.voice_prompt,
+        persona=args.persona,
+        device=args.device,
+        cpu_offload=args.cpu_offload,
+    )
+
+    engine = PersonaPlexEngine(config).load()
+    session = PersonaPlexSession(engine, config)
+    session.open()
+
+    # Load exactly like the reference (moshi.lm.load_audio): native read then
+    # explicit resample, so greedy runs stay bit-faithful to `python -m moshi.offline`.
+    user_pcm, src_sr = sphn.read(args.input_wav)
+    user_pcm = sphn.resample(user_pcm, src_sample_rate=src_sr, dst_sample_rate=config.sample_rate)
+    audio, text = session.run(np.asarray(user_pcm[0], dtype=np.float32))
+
+    sphn.write_wav(args.output_wav, audio, config.sample_rate)
+    print(f"wrote {audio.shape[0] / config.sample_rate:.2f}s of agent audio to {args.output_wav}")
+    print(f"agent text: {text!r}")
+    if args.output_text:
+        with open(args.output_text, "w") as f:
+            json.dump({"text": text}, f, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/sensenova_u1/README.md b/examples/offline_inference/sensenova_u1/README.md
deleted file mode 100644
index 9fdc23a00..000000000
--- a/examples/offline_inference/sensenova_u1/README.md
+++ /dev/null
@@ -1,214 +0,0 @@
-# SenseNova-U1: Offline inference
-
-## Architecture
-
-SenseNova-U1 is a unified Qwen3-based LLM with Mixture-of-Tokenizers (MoT) attention. Unlike two-stage pipelines (e.g., BAGEL), it handles text encoding, optional reasoning ("think mode"), and flow-matching-based image denoising entirely within a single diffusion stage.
-
-| Feature | Description |
-| :------ | :---------- |
-| **Model type** | Unified LLM (single-stage diffusion pipeline) |
-| **Base LLM** | Qwen3 with MoT attention and 3D RoPE |
-| **Image generation** | Flow-matching Euler sampler, no separate VAE |
-| **Think mode** | Optional chain-of-thought reasoning before image generation |
-| **Parallelism** | Tensor Parallelism (TP) with fused QKV and fused gate/up projections |
-| **Modalities** | text2img, img2img, img2text (understanding), text2text |
-
-## Quick Start
-
-```bash
-cd examples/offline_inference/sensenova_u1
-
-# Text-to-image
-python end2end.py --prompt "A cute cat" --think
-
-# Image-to-image editing
-python end2end.py --prompt "Turn this into an oil painting" \
-                  --image input.png --think
-
-# Image understanding (img2text)
-python end2end.py --modality img2text \
-                  --prompt "Describe this image in detail" \
-                  --image photo.jpg
-
-# Text-to-text (pure chat)
-python end2end.py --modality text2text \
-                  --prompt "What is the capital of France?"
-
-# Custom resolution (image generation)
-python end2end.py --prompt "A futuristic cityscape at sunset" \
-                  --width 2048 --height 1024 --think
-
-# Text-to-image with cache acceleration (cache_dit or tea_cache)
-python end2end.py --prompt "A cute cat" \
-                  --cache-backend tea_cache
-```
-
-> **Note**: Default configuration works on a single **NVIDIA A100 (80GB)** or **H100** GPU.
-
-## Text-to-Image (t2i)
-
-Standard text-to-image with optional think mode:
-
-```bash
-python end2end.py \
-    --prompt "Close portrait of an elderly woman by a farmhouse window, textured skin, gentle smile, warm natural light" \
-    --width 1536 --height 2720 \
-    --think --print-think
-```
-
-## Image-to-Image Editing (img2img)
-
-Pass one or more `--image` paths to trigger img2img mode. The model uses the
-input image(s) as visual context for editing:
-
-```bash
-# Single input image
-python end2end.py \
-    --prompt "Add a sunset sky in the background" \
-    --image photo.jpg \
-    --width 2048 --height 2048 \
-    --think
-
-# Multiple reference images
-python end2end.py \
-    --prompt "Combine the style of Image-1 with the content of Image-2" \
-    --image style_ref.png content_ref.png \
-    --width 2048 --height 2048 \
-    --think
-```
-
-### Dual CFG for img2img
-
-img2img supports dual classifier-free guidance (text CFG + image CFG):
-
-```bash
-python end2end.py \
-    --prompt "Make the person smile" \
-    --image portrait.jpg \
-    --cfg-scale 4.0 \
-    --img-cfg-scale 2.0 \
-    --think
-```
-
-| `img_cfg_scale` | Behavior |
-| :-------------- | :------- |
-| `1.0` (default) | Text-only CFG: guidance = image-condition → full-condition |
-| `== cfg_scale` | Standard CFG: guidance = unconditional → full-condition |
-| Other value | Dual CFG: separate text and image guidance strengths |
-
-## Full Parameter Reference
-
-### General Parameters
-
-| Parameter | Default | Description |
-| :-------- | :------ | :---------- |
-| `--modality` | `auto` | Task modality: `auto`, `text2img`, `img2img`, `img2text`, `text2text` |
-| `--prompt` | "A cute cat..." | Text prompt / editing instruction / question |
-| `--image` | None | Input image path(s) for img2img or img2text |
-
-### Image Generation Parameters (text2img / img2img)
-
-| Parameter | Default | Description |
-| :-------- | :------ | :---------- |
-| `--height` | 2048 | Height of generated image (pixels) |
-| `--width` | 2048 | Width of generated image (pixels) |
-| `--seed` | 42 | Random seed for reproducibility |
-| `--num-steps` | 50 | Number of denoising steps |
-| `--cfg-scale` | 4.0 | Text classifier-free guidance scale |
-| `--img-cfg-scale` | 1.0 | Image CFG scale (img2img only, 1.0 = disabled) |
-| `--cfg-norm` | "none" | CFG normalization: none, global, channel, cfg_zero_star (t2i only) |
-| `--timestep-shift` | 3.0 | Timestep shift for flow-matching schedule |
-| `--t-eps` | 0.02 | Epsilon for timestep schedule |
-| `--think` | False | Enable think mode |
-| `--print-think` | False | Print think text to stdout |
-
-### Text Generation Parameters (text2text / img2text)
-
-| Parameter | Default | Description |
-| :-------- | :------ | :---------- |
-| `--max-tokens` | 512 | Maximum number of tokens to generate |
-| `--do-sample` | False | Use sampling instead of greedy decoding |
-| `--temperature` | 0.7 | Sampling temperature (higher = more diverse) |
-
-### Infrastructure Parameters
-
-| Parameter | Default | Description |
-| :-------- | :------ | :---------- |
-| `--model` | `SenseNova/SenseNova-U1-8B-MoT` | HuggingFace model ID or local path |
-| `--output` | `.` | Output directory for saved images |
-| `--tensor-parallel-size` | 1 | Number of GPUs for tensor parallelism |
-| `--enforce-eager` | False | Disable torch.compile |
-| `--enable-cpu-offload` | False | Enable module-wise (sequential) CPU offload to reduce peak VRAM |
-| `--cache-backend` | None | Set to `cache_dit` or `tea_cache` for image generation acceleration |
-| `--enable-cache-dit-summary` | False | Print Cache-DiT cache statistics after generation |
-
-## Reducing GPU Memory Usage
-
-For hardware with limited VRAM, enable **module-wise CPU offload** with
-`--enable-cpu-offload`. The pipeline implements `SupportsComponentDiscovery`, so the
-vision encoder (`vision_model`) and the Qwen3 LLM (`language_model`) are
-swapped between CPU and GPU on demand:
-
-- During text/vision encoding, the LLM is on CPU.
-- During the diffusion loop, the vision encoder is on CPU.
-- Lightweight FM modules stay resident on GPU.
-
-This lowers peak VRAM at the cost of extra CPU<->GPU transfers (use pinned
-memory) — useful for running SenseNova-U1 on consumer-grade GPUs.
-
-```bash
-# Text-to-image with CPU offload
-python end2end.py \
-    --prompt "A cute cat sitting on a windowsill" \
-    --width 2048 --height 2048 \
-    --enable-cpu-offload --think
-
-# Image-to-image editing with CPU offload
-python end2end.py \
-    --prompt "Turn this into an oil painting" \
-    --image input.png \
-    --width 2048 --height 2048 \
-    --enable-cpu-offload --think
-
-# Image understanding (img2text) with CPU offload
-python end2end.py \
-    --modality img2text \
-    --prompt "Describe this image in detail" \
-    --image photo.jpg \
-    --enable-cpu-offload
-```
-
-> **Notes**
-> - CPU offload is **single-GPU only** (incompatible with `--tensor-parallel-size > 1`).
-> - First-step latency is higher because of the cold-start CPU<->GPU transfers.
-> - For more details and other offloading strategies, see
->   [CPU Offloading for Diffusion Models](../../../docs/user_guide/diffusion/cpu_offload_diffusion.md).
-
-## Reproducing the E2E Test
-
-The following command reproduces the pixel-validated CI test case:
-
-```bash
-python end2end.py \
-    --prompt "Close portrait of an elderly woman by a farmhouse window, textured skin, gentle smile, warm natural light, emotional documentary look. The portrait should feel polished and natural, with sharp eyes, realistic skin texture, accurate facial anatomy, and premium lighting that keeps the face as the main focus." \
-    --width 1536 --height 2720 \
-    --seed 42 --num-steps 50 \
-    --cfg-scale 4.0 --timestep-shift 3.0 --cfg-norm none \
-    --think --print-think \
-    --output outputs
-```
-
-The corresponding pytest:
-
-```bash
-pytest -s -v tests/e2e/offline_inference/test_sensenova_u1_text2img.py \
-    -m "advanced_model" --run-level "advanced_model"
-```
-
-The img2img counterpart lives at
-`tests/e2e/offline_inference/test_sensenova_u1_img2img.py`.
-
-## Online Serving
-
-For OpenAI-compatible API serving, see
-[`examples/online_serving/sensenova_u1/`](../../online_serving/sensenova_u1/README.md).
diff --git a/examples/offline_inference/sensenova_u1/end2end.py b/examples/offline_inference/sensenova_u1/end2end.py
deleted file mode 100644
index 9547c40b9..000000000
--- a/examples/offline_inference/sensenova_u1/end2end.py
+++ /dev/null
@@ -1,307 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""
-End-to-end offline inference for SenseNova-U1-8B-MoT.
-
-Supports four modalities: text2img, img2img, img2text, text2text.
-
-Text-to-image:
-    python end2end.py --prompt "A cute cat" --think
-
-Image-to-image (editing):
-    python end2end.py --prompt "Turn this into an oil painting" \
-        --image input.png --think
-
-Image understanding:
-    python end2end.py --modality img2text \
-        --prompt "Describe this image" --image photo.jpg
-
-Text chat:
-    python end2end.py --modality text2text \
-        --prompt "What is the capital of France?"
-
-See README.md for more examples.
-"""
-
-import argparse
-import os
-
-from PIL import Image
-
-from vllm_omni.entrypoints.omni import Omni
-from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="SenseNova-U1 text-to-image / image-to-image / text / understanding via vLLM-Omni.",
-    )
-    parser.add_argument(
-        "--model",
-        default="SenseNova/SenseNova-U1-8B-MoT",
-        help="HuggingFace model ID or local path.",
-    )
-    parser.add_argument(
-        "--modality",
-        default="auto",
-        choices=["auto", "text2img", "img2img", "img2text", "text2text"],
-        help="Task modality. 'auto' infers from --image (img2img/img2text if images, else t2i/t2t).",
-    )
-    parser.add_argument(
-        "--prompt",
-        default="A cute cat sitting on a windowsill, soft natural light",
-        help="Text prompt for generation or editing instruction.",
-    )
-    parser.add_argument(
-        "--image",
-        nargs="+",
-        metavar="PATH",
-        default=None,
-        help="Input image path(s) for img2img or img2text.",
-    )
-    parser.add_argument(
-        "--output",
-        type=str,
-        default=".",
-        help="Output directory to save generated images.",
-    )
-    # Image dimensions
-    parser.add_argument("--height", type=int, default=2048, help="Height of generated image.")
-    parser.add_argument("--width", type=int, default=2048, help="Width of generated image.")
-
-    # Generation parameters
-    parser.add_argument("--seed", type=int, default=42, help="Random seed for deterministic results.")
-    parser.add_argument("--num-steps", type=int, default=50, help="Number of denoising steps.")
-    parser.add_argument("--cfg-scale", type=float, default=4.0, help="Text classifier-free guidance scale.")
-    parser.add_argument(
-        "--img-cfg-scale",
-        type=float,
-        default=1.0,
-        help="Image CFG scale for img2img (1.0 = disabled). "
-        "When both --cfg-scale and --img-cfg-scale differ, dual CFG is used.",
-    )
-    parser.add_argument(
-        "--cfg-norm",
-        type=str,
-        default="none",
-        choices=["none", "global", "channel", "cfg_zero_star"],
-        help="CFG normalization mode. cfg_zero_star is only for t2i.",
-    )
-    parser.add_argument(
-        "--timestep-shift",
-        type=float,
-        default=3.0,
-        help="Timestep shift for flow-matching schedule.",
-    )
-    parser.add_argument(
-        "--t-eps",
-        type=float,
-        default=0.02,
-        help="Epsilon for flow-matching timestep schedule.",
-    )
-
-    # Text generation parameters (for text2text / img2text)
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=2048,
-        help="Max tokens for text generation (text2text / img2text).",
-    )
-    parser.add_argument(
-        "--do-sample",
-        action="store_true",
-        help="Use sampling instead of greedy decoding for text generation.",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.7,
-        help="Sampling temperature for text generation.",
-    )
-
-    # Think mode
-    parser.add_argument(
-        "--think",
-        action="store_true",
-        help="Enable think mode: the model reasons about the prompt before generating the image.",
-    )
-    parser.add_argument(
-        "--print-think",
-        action="store_true",
-        help="Print the generated think text to stdout.",
-    )
-
-    # Advanced
-    parser.add_argument(
-        "--tensor-parallel-size",
-        type=int,
-        default=1,
-        help="Number of GPUs for tensor parallelism.",
-    )
-    parser.add_argument(
-        "--cfg-parallel-size",
-        type=int,
-        default=1,
-        help="Number of GPUs for CFG parallelism.",
-    )
-    parser.add_argument(
-        "--enforce-eager",
-        action="store_true",
-        help="Disable torch.compile and force eager execution.",
-    )
-    parser.add_argument(
-        "--enable-cpu-offload",
-        action="store_true",
-        help=(
-            "Enable model-level (sequential) CPU offloading. "
-            "Mutually exclusive between vision_model and language_model: "
-            "only one is on GPU at a time, reducing peak VRAM at the cost "
-            "of extra CPU<->GPU transfers."
-        ),
-    )
-    parser.add_argument(
-        "--cache-backend",
-        type=str,
-        default=None,
-        choices=["cache_dit", "tea_cache"],
-        help="Cache backend to use for image generation acceleration.",
-    )
-    parser.add_argument(
-        "--enable-cache-dit-summary",
-        action="store_true",
-        help="Enable cache-dit summary logging after diffusion forward passes.",
-    )
-
-    return parser.parse_args()
-
-
-def _resolve_modality(args):
-    """Determine the effective modality from CLI args."""
-    if args.modality != "auto":
-        return args.modality
-    has_images = args.image is not None
-    # Default: image-producing tasks for backward compatibility
-    return "img2img" if has_images else "text2img"
-
-
-def main():
-    args = parse_args()
-    os.makedirs(args.output, exist_ok=True)
-
-    modality = _resolve_modality(args)
-    is_text_output = modality in ("text2text", "img2text")
-    has_images = modality in ("img2img", "img2text")
-
-    omni = Omni(
-        model=args.model,
-        tensor_parallel_size=args.tensor_parallel_size,
-        enforce_eager=args.enforce_eager,
-        enable_cpu_offload=args.enable_cpu_offload,
-        cache_backend=args.cache_backend,
-        enable_cache_dit_summary=args.enable_cache_dit_summary,
-        cfg_parallel_size=args.cfg_parallel_size,
-    )
-
-    extra_args = {
-        "cfg_scale": args.cfg_scale,
-        "cfg_norm": args.cfg_norm,
-        "timestep_shift": args.timestep_shift,
-        "cfg_interval": (0.0, 1.0),
-        "batch_size": 1,
-        "think": args.think,
-        "t_eps": args.t_eps,
-    }
-    if modality == "img2img":
-        extra_args["img_cfg_scale"] = args.img_cfg_scale
-    if is_text_output:
-        extra_args["max_tokens"] = args.max_tokens
-        extra_args["do_sample"] = args.do_sample
-        extra_args["temperature"] = args.temperature
-
-    sampling_params = OmniDiffusionSamplingParams(
-        height=args.height,
-        width=args.width,
-        seed=args.seed,
-        num_inference_steps=args.num_steps,
-        extra_args=extra_args,
-    )
-
-    print(f"\n{'=' * 60}")
-    print(f"SenseNova-U1 Configuration ({modality}):")
-    print(f"  Model          : {args.model}")
-    if not is_text_output:
-        print(f"  Image size     : {args.width}x{args.height}")
-        print(f"  Steps          : {args.num_steps}")
-        print(f"  CFG scale      : {args.cfg_scale}")
-    if modality == "img2img":
-        print(f"  Img CFG scale  : {args.img_cfg_scale}")
-    if has_images:
-        print(f"  Input images   : {args.image}")
-    if is_text_output:
-        print(f"  Max tokens     : {args.max_tokens}")
-        print(f"  Temperature    : {args.temperature}")
-    print(f"  Seed           : {args.seed}")
-    print(f"  Think mode     : {args.think}")
-    print(f"  TP size        : {args.tensor_parallel_size}")
-    print(f"  CFG size       : {args.cfg_parallel_size}")
-    print(f"  Cache backend  : {args.cache_backend or 'none'}")
-    print(f"{'=' * 60}\n")
-
-    # Build prompt dict
-    if has_images:
-        if not args.image:
-            raise ValueError(f"{modality} requires --image.")
-        input_images = [Image.open(p).convert("RGB") for p in args.image]
-        if is_text_output:
-            prompt_dict = {
-                "prompt": args.prompt,
-                "multi_modal_data": {"image": input_images},
-                "modalities": ["text"],
-            }
-        else:
-            prompt_dict = {
-                "prompt": args.prompt,
-                "multi_modal_data": {"image": input_images},
-                "modalities": ["img2img"],
-            }
-    elif is_text_output:
-        prompt_dict = {"prompt": args.prompt, "modalities": ["text"]}
-    else:
-        prompt_dict = {"prompt": args.prompt, "modalities": ["image"]}
-
-    outputs = list(
-        omni.generate(
-            prompts=prompt_dict,
-            sampling_params_list=sampling_params,
-        )
-    )
-
-    for req_output in outputs:
-        multimodal_output = getattr(req_output, "multimodal_output", {}) or {}
-        metadata = multimodal_output.get("metadata", {}) if isinstance(multimodal_output, dict) else {}
-        text_metadata = metadata.get("text", {}) if isinstance(metadata, dict) else {}
-        think_text = text_metadata.get("think_text") if isinstance(text_metadata, dict) else None
-        if args.print_think and think_text:
-            print(f"[Think]\n{think_text}\n")
-
-        if is_text_output:
-            text = multimodal_output.get("text", "") if isinstance(multimodal_output, dict) else ""
-            if not text:
-                text = text_metadata.get("text_output", "") if isinstance(text_metadata, dict) else ""
-            if not text:
-                text = getattr(req_output, "text", "") or ""
-            print(f"[Response]\n{text}")
-        else:
-            images = getattr(req_output, "images", None) or []
-            if not images:
-                print("[Warning] No images generated.")
-                continue
-            for j, img in enumerate(images):
-                save_path = os.path.join(args.output, f"sensenova_u1_output_{j}.png")
-                img.save(save_path)
-                print(f"[Output] Saved {img.size[0]}x{img.size[1]} image to {save_path}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/offline_inference/step_audio2/README.md b/examples/offline_inference/step_audio2/README.md
index 84d0ecdde..abd21f371 100644
--- a/examples/offline_inference/step_audio2/README.md
+++ b/examples/offline_inference/step_audio2/README.md
@@ -51,7 +51,7 @@ Single request latency comparison between vLLM-Omni and official Step-Audio2 imp
 
 **Benchmark environment:**
 - GPU: NVIDIA H100 80GB (single card)
-- Model: Step-Audio2-mini
+- Model: Step-Audio-2-mini
 - Warmup: 1 run, Measured: 3 runs (averaged)
 
 ### Async Chunk Streaming Performance
@@ -73,7 +73,7 @@ Comparison between sequential (non-async) and async chunk modes via `/v1/audio/s
 
 **Benchmark environment:**
 - GPU: 4x NVIDIA RTX 3090 24GB (TP=2 for Thinker, 1 GPU for Token2Wav)
-- Model: Step-Audio2-mini
+- Model: Step-Audio-2-mini
 - Endpoint: `/v1/audio/speech` (10 prompts, concurrency=1)
 - Measured via `bench_tts_serve.py`
 
@@ -91,23 +91,22 @@ pip install step-audio2
 
 ## Model Setup
 
+Step-Audio2 ships a custom Transformers configuration, so this model-specific
+example enables remote code loading when it initializes the model.
+
 ### Option 1: Auto-download from HuggingFace (Recommended)
 
-The script will **automatically download** the model on first run:
+The script will **automatically download** the model on first run when a
+HuggingFace model id is passed:
 
 ```bash
-# Just run without specifying --model, it will auto-download stepfun-ai/Step-Audio2-mini
-python end2end.py --query-type audio_to_text
-
-# Or explicitly specify the HuggingFace model
-python end2end.py --query-type audio_to_text --model stepfun-ai/Step-Audio2-mini
+python end2end.py --query-type audio_to_text --model stepfun-ai/Step-Audio-2-mini
 ```
 
 Models will be cached in `~/.cache/huggingface/hub/` for future use.
 
-**Available models**:
-- `stepfun-ai/Step-Audio2-mini` (smaller, faster)
-- `stepfun-ai/Step-Audio2-7B` (larger, better quality)
+**Supported model**:
+- `stepfun-ai/Step-Audio-2-mini`
 
 ### Option 2: Manual Download (for offline use)
 
@@ -115,15 +114,15 @@ Download and use locally:
 
 ```bash
 # Download from HuggingFace
-huggingface-cli download stepfun-ai/Step-Audio2-mini --local-dir ./models/Step-Audio2-mini
+hf download stepfun-ai/Step-Audio-2-mini --local-dir ./models/Step-Audio-2-mini
 
 # Then use the local path
-python end2end.py --query-type audio_to_text --model ./models/Step-Audio2-mini
+python end2end.py --query-type audio_to_text --model ./models/Step-Audio-2-mini
 ```
 
 Ensure the model directory contains:
 ```
-Step-Audio2-mini/
+Step-Audio-2-mini/
 ├── config.json
 ├── model.safetensors (or pytorch_model.bin)
 ├── tokenizer.json
@@ -144,20 +143,18 @@ Transcribe audio to text:
 
 ```bash
 # Quick start - Using default model and test audio
-python end2end.py --query-type audio_to_text
+python end2end.py --query-type audio_to_text \
+    --model stepfun-ai/Step-Audio-2-mini
 
 # Using your own audio file (model will auto-download)
-python end2end.py --query-type audio_to_text \
-    --audio-path /path/to/input.wav
-
-# With specific model
 python end2end.py --query-type audio_to_text \
     --audio-path /path/to/input.wav \
-    --model stepfun-ai/Step-Audio2-7B
+    --model stepfun-ai/Step-Audio-2-mini
 
 # With custom question
 python end2end.py --query-type audio_to_text \
     --audio-path input.wav \
+    --model stepfun-ai/Step-Audio-2-mini \
     --question "What is the speaker saying?"
 ```
 
@@ -170,12 +167,8 @@ Convert text to speech:
 ```bash
 # Basic TTS (model auto-downloads)
 python end2end.py --query-type text_to_audio \
-    --text "Hello, this is a test of Step Audio 2 synthesis."
-
-# With specific model
-python end2end.py --query-type text_to_audio \
-    --text "Hello, this is a test." \
-    --model stepfun-ai/Step-Audio2-7B
+    --text "Hello, this is a test of Step Audio 2 synthesis." \
+    --model stepfun-ai/Step-Audio-2-mini
 ```
 
 **Note**: Speaker voice is controlled by the `STEP_AUDIO2_DEFAULT_PROMPT_WAV` environment variable or the default prompt wav bundled with the model.
@@ -191,12 +184,8 @@ Process input audio and generate output audio:
 ```bash
 # Basic voice conversion (model auto-downloads)
 python end2end.py --query-type audio_to_audio \
-    --audio-path /path/to/source_audio.wav
-
-# With specific model
-python end2end.py --query-type audio_to_audio \
-    --audio-path source.wav \
-    --model stepfun-ai/Step-Audio2-7B
+    --audio-path /path/to/source_audio.wav \
+    --model stepfun-ai/Step-Audio-2-mini
 ```
 
 This mode:
@@ -210,8 +199,14 @@ This mode:
 ```bash
 # Use custom stage configuration
 python end2end.py --query-type audio_to_text \
+    --model stepfun-ai/Step-Audio-2-mini \
     --stage-configs-path /path/to/custom_config.yaml
 
+# Use custom deploy configuration
+python end2end.py --query-type audio_to_text \
+    --model stepfun-ai/Step-Audio-2-mini \
+    --deploy-config /path/to/step_audio_2_asr.yaml
+
 # Multiple prompts (for batch testing)
 python end2end.py --query-type audio_to_text \
     --audio-path input.wav \
@@ -246,14 +241,14 @@ python end2end.py --query-type text_to_audio \
 
 ## Configuration
 
-### Stage Configuration
+### Deploy Configuration
 
-The default configuration (`step_audio_2.yaml`) uses:
+The default configuration (`vllm_omni/deploy/step_audio_2.yaml`) uses:
 
-- **Stage 0 (Thinker)**: GPU 0, 80% memory
-- **Stage 1 (Token2Wav)**: GPU 1, 30% memory
+- **Stage 0 (Thinker)**: GPUs 0-1 with tensor parallel size 2, 70% memory
+- **Stage 1 (Token2Wav)**: GPU 1, 20% memory
 
-For **single GPU** setup, edit the config to use `devices: "0"` for both stages.
+For **single GPU** setup, edit a deploy config copy to use `devices: "0"` for both stages.
 
 ### Sampling Parameters
 
@@ -351,7 +346,7 @@ Complete example from audio to final output:
 # 1. ASR: Transcribe audio
 python end2end.py --query-type audio_to_text \
     --audio-path interview.wav \
-    --model ./models/Step-Audio2-7B \
+    --model ./models/Step-Audio-2-mini \
     --output-dir ./outputs
 
 # 2. Check the transcription
@@ -361,7 +356,7 @@ cat ./outputs/00000_text.txt
 STEP_AUDIO2_DEFAULT_PROMPT_WAV=./speaker_samples/female_voice.wav \
 python end2end.py --query-type text_to_audio \
     --text "The quick brown fox jumps over the lazy dog" \
-    --model ./models/Step-Audio2-7B \
+    --model ./models/Step-Audio-2-mini \
     --output-dir ./outputs
 
 # 4. Listen to the result
diff --git a/examples/offline_inference/step_audio2/end2end.py b/examples/offline_inference/step_audio2/end2end.py
index c67f44926..e0d1836a8 100644
--- a/examples/offline_inference/step_audio2/end2end.py
+++ b/examples/offline_inference/step_audio2/end2end.py
@@ -232,32 +232,42 @@ def main(args):
         raise ValueError(f"Unknown query type: {args.query_type}")
 
     # Initialize vLLM-Omni with Step-Audio2
-    # Resolve stage config path
+    # Resolve deploy config path. Keep explicit stage_configs_path for legacy
+    # custom configs, but use bundled deploy configs by default.
+    deploy_config_path = None
+    stage_config_path = None
+    if args.stage_configs_path and args.deploy_config:
+        raise ValueError("--stage-configs-path and --deploy-config are mutually exclusive")
     if args.stage_configs_path:
         stage_config_path = args.stage_configs_path
+    elif args.deploy_config:
+        deploy_config_path = args.deploy_config
     else:
-        configs_dir = Path(__file__).parent.parent.parent.parent / "vllm_omni/model_executor/stage_configs"
+        configs_dir = Path(__file__).parent.parent.parent.parent / "vllm_omni/deploy"
         if args.query_type == "audio_to_text":
             # ASR only needs Thinker (Stage 0), no Token2Wav
-            stage_config_path = str(configs_dir / "step_audio_2_asr.yaml")
-            if not os.path.exists(stage_config_path):
-                stage_config_path = str(configs_dir / "step_audio_2.yaml")
+            deploy_config_path = str(configs_dir / "step_audio_2_asr.yaml")
         else:
             # TTS/S2ST need both stages
-            stage_config_path = str(configs_dir / "step_audio_2.yaml")
+            deploy_config_path = str(configs_dir / "step_audio_2.yaml")
 
-    omni_llm = Omni(
-        model=model_name,
-        log_stats=args.enable_stats,
-        log_file=("step_audio2_pipeline.log" if args.enable_stats else None),
-        init_sleep_seconds=args.init_sleep_seconds,
-        batch_timeout=args.batch_timeout,
-        init_timeout=args.init_timeout,
-        shm_threshold_bytes=args.shm_threshold_bytes,
-        stage_configs_path=stage_config_path,
-        worker_backend=args.worker_backend,
-        ray_address=args.ray_address,
-    )
+    omni_kwargs = {
+        "model": model_name,
+        "log_stats": args.enable_stats,
+        "log_file": ("step_audio2_pipeline.log" if args.enable_stats else None),
+        "init_sleep_seconds": args.init_sleep_seconds,
+        "batch_timeout": args.batch_timeout,
+        "init_timeout": args.init_timeout,
+        "worker_backend": args.worker_backend,
+        "ray_address": args.ray_address,
+        "trust_remote_code": True,
+    }
+    if stage_config_path is not None:
+        omni_kwargs["stage_configs_path"] = stage_config_path
+    else:
+        omni_kwargs["deploy_config"] = deploy_config_path
+
+    omni_llm = Omni(**omni_kwargs)
 
     # Configure sampling parameters for each stage
     # Stage 0 (Thinker): Generate text and audio tokens
@@ -405,16 +415,21 @@ def parse_args():
         help=(
             "Model path (required). Can be:\n"
             "  - Local path: /path/to/step-audio-2\n"
-            "  - HuggingFace ID: stepfun-ai/Step-Audio2-mini"
+            "  - HuggingFace ID: stepfun-ai/Step-Audio-2-mini"
         ),
     )
     parser.add_argument(
         "--stage-configs-path",
         type=str,
         default=None,
-        help="Path to stage config YAML file (default: use built-in step_audio_2.yaml)",
+        help="Path to a legacy stage config YAML file (default: use bundled deploy config)",
+    )
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        default=None,
+        help="Path to a deploy config YAML file (default: use bundled Step-Audio2 deploy config)",
     )
-
     # Query configuration
     parser.add_argument(
         "--query-type",
diff --git a/examples/offline_inference/text_to_image/README.md b/examples/offline_inference/text_to_image/README.md
index 985c4ff7d..6ebc7ae63 100644
--- a/examples/offline_inference/text_to_image/README.md
+++ b/examples/offline_inference/text_to_image/README.md
@@ -260,7 +260,7 @@ if __name__ == "__main__":
     For diffusion pipelines, the input list is sliced into single-item requests
     before feeding into the diffusion pipeline. For request-level batching
     controls such as `max_num_seqs`, see
-    [Request-Level Batching](../../../docs/user_guide/diffusion/request_batching.md).
+    [Diffusion Execution Modes](../../../docs/user_guide/diffusion/execution_modes.md).
 
 ### Negative Prompts
 
diff --git a/examples/offline_inference/text_to_image/text_to_image.py b/examples/offline_inference/text_to_image/text_to_image.py
index 61dd29261..81acebe00 100644
--- a/examples/offline_inference/text_to_image/text_to_image.py
+++ b/examples/offline_inference/text_to_image/text_to_image.py
@@ -11,6 +11,7 @@ from typing import Any
 import torch
 
 from vllm_omni.diffusion.data import logger
+from vllm_omni.diffusion.utils.image_output import extract_images_from_outputs
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.entrypoints.openai.stage_params import clone_sampling_params
@@ -555,9 +556,21 @@ def main():
         elif init_non_diffusion and hasattr(params, "extra_args"):
             if params.extra_args is None:
                 params.extra_args = {}
+            params.extra_args.update(diffusion_params.extra_args or {})
             if args.seed is not None and hasattr(params, "seed"):
                 params.seed = args.seed
 
+            # MammothModa2's AR stage emits one visual token per grid cell,
+            # one EOL token per row, and one final look-ahead token whose hidden
+            # state is unavailable. Size the first stage from the prompt metadata
+            # instead of SamplingParams' default of 16 tokens.
+            prompt_info = prompt_dict.get("additional_information", {})
+            if idx == 0 and prompt_info.get("omni_task") == ["t2i"]:
+                ar_width = int(prompt_info.get("ar_width", [0])[0])
+                ar_height = int(prompt_info.get("ar_height", [0])[0])
+                if ar_width > 0 and ar_height > 0:
+                    params.max_tokens = ar_height * (ar_width + 1) + 1
+
     if not diffusion_replaced and len(sampling_params_list) == 1:
         sampling_params_list = [diffusion_params]
 
@@ -601,11 +614,8 @@ def main():
         if images:
             break
 
-    # Fallback: generation-stage pipelines (e.g. MammothModa2's AR->DiT) return the
-    # generated image as a tensor under multimodal_output instead of populating the
-    # `images` field that diffusion-stage pipelines fill.
     if not images:
-        images = _images_from_multimodal_output(outputs)
+        images = extract_images_from_outputs(outputs)
 
     if not images:
         raise ValueError("No images found in request_output")
@@ -624,36 +634,5 @@ def main():
             print(f"Saved generated image to {save_path}")
 
 
-def _images_from_multimodal_output(outputs: list[Any]) -> list[Any]:
-    """Extract PIL images from multimodal_output tensors.
-
-    Generation-stage pipelines (e.g. MammothModa2's AR->DiT) return the generated
-    image as a tensor (normalized to [-1, 1], CHW) under ``multimodal_output``
-    rather than populating the ``images`` field. Convert any such tensors to PIL.
-    """
-    from PIL import Image
-
-    pil_images: list[Any] = []
-    for output in outputs:
-        req_out = getattr(output, "request_output", output)
-        for completion in getattr(req_out, "outputs", None) or []:
-            # multimodal_output is a MultimodalPayload (a Mapping) keyed by modality,
-            # matching how omni examples (ming_flash_omni / magi_human / dynin) read it.
-            mm = getattr(completion, "multimodal_output", None) or {}
-            if "image" not in mm:
-                continue
-            payload = mm["image"]
-            for tensor in payload if isinstance(payload, list) else [payload]:
-                if not isinstance(tensor, torch.Tensor):
-                    continue
-                img = tensor.detach().to("cpu", dtype=torch.float32)
-                if img.ndim == 4:
-                    img = img[0]
-                img = (img / 2 + 0.5).clamp(0, 1).mul(255).to(torch.uint8)
-                img = img.permute(1, 2, 0).contiguous().numpy()
-                pil_images.append(Image.fromarray(img))
-    return pil_images
-
-
 if __name__ == "__main__":
     main()
diff --git a/examples/offline_inference/text_to_speech/cosyvoice3/end2end.py b/examples/offline_inference/text_to_speech/cosyvoice3/end2end.py
index e5c266f7a..ccfb1aaef 100644
--- a/examples/offline_inference/text_to_speech/cosyvoice3/end2end.py
+++ b/examples/offline_inference/text_to_speech/cosyvoice3/end2end.py
@@ -182,10 +182,13 @@ def run_e2e():
                 print(f"Multimodal output keys: {mm.keys()}")
                 if "audio" in mm:
                     audio_out = mm["audio"]
+                    # The model emits its own rate (24 kHz for CosyVoice3); take
+                    # it from the payload so the file is not mislabeled.
+                    sample_rate = int(mm["sr"]) if "sr" in mm.keys() else 24000
                     print(f"Generated Audio Shape: {audio_out.shape}")
                     out_path = f"output_{i}.wav"
-                    sf.write(out_path, audio_out.cpu().numpy().squeeze(), 22050)
-                    print(f"Saved audio to {out_path}")
+                    sf.write(out_path, audio_out.cpu().numpy().squeeze(), sample_rate)
+                    print(f"Saved audio to {out_path} (sr={sample_rate})")
             else:
                 print("No multimodal output found.")
         except Exception as e:
diff --git a/examples/offline_inference/text_to_speech/fish_speech/end2end.py b/examples/offline_inference/text_to_speech/fish_speech/end2end.py
index 4d6855246..5661cccd3 100644
--- a/examples/offline_inference/text_to_speech/fish_speech/end2end.py
+++ b/examples/offline_inference/text_to_speech/fish_speech/end2end.py
@@ -122,12 +122,48 @@ def _save_wav(output_dir: str, request_id: str, mm: dict) -> None:
     logger.info("Request %s: saved audio to %s (sr=%d)", request_id, out_wav, sr)
 
 
+def _collect_audio_chunk(
+    mm: dict,
+    all_audio_chunks: list[torch.Tensor],
+    sample_rate: int | None,
+) -> tuple[int | None, int]:
+    """Extract audio and sample rate from a multimodal output chunk.
+
+    Returns updated sample_rate and the number of audio segments in this chunk.
+    """
+    audio = mm.get("audio") if mm else None
+    if audio is not None:
+        if isinstance(audio, list):
+            all_audio_chunks.extend(audio)
+        else:
+            all_audio_chunks.append(audio)
+    sr_raw = mm.get("sr") if mm else None
+    if sr_raw is not None and not (isinstance(sr_raw, (list, tuple)) and len(sr_raw) == 0):
+        sr_val = sr_raw[-1] if isinstance(sr_raw, list) and sr_raw else sr_raw
+        sample_rate = sr_val.item() if hasattr(sr_val, "item") else int(sr_val)
+    n = len(audio) if isinstance(audio, list) else (0 if audio is None else 1)
+    return sample_rate, n
+
+
+def _build_omni_kwargs(args, model_name: str) -> dict:
+    """Build keyword arguments for Omni/AsyncOmni initialization."""
+    omni_kwargs = dict(
+        model=model_name,
+        log_stats=args.log_stats,
+        stage_init_timeout=args.stage_init_timeout,
+    )
+    if args.deploy_config:
+        omni_kwargs["deploy_config"] = args.deploy_config
+    else:
+        omni_kwargs["stage_configs_path"] = args.stage_configs_path or DEFAULT_STAGE_CONFIG
+    return omni_kwargs
+
+
 def main(args):
     """Run offline inference with Omni."""
     output_dir = args.output_dir
     os.makedirs(output_dir, exist_ok=True)
 
-    stage_configs_path = args.stage_configs_path or DEFAULT_STAGE_CONFIG
     model_name = args.model or DEFAULT_MODEL
 
     inputs = [
@@ -139,12 +175,7 @@ def main(args):
         )
     ]
 
-    omni = Omni(
-        model=model_name,
-        stage_configs_path=stage_configs_path,
-        log_stats=args.log_stats,
-        stage_init_timeout=args.stage_init_timeout,
-    )
+    omni = Omni(**_build_omni_kwargs(args, model_name))
 
     t_start = time.perf_counter()
     for stage_outputs in omni.generate(inputs):
@@ -165,7 +196,6 @@ async def main_streaming(args):
     output_dir = args.output_dir
     os.makedirs(output_dir, exist_ok=True)
 
-    stage_configs_path = args.stage_configs_path or DEFAULT_STAGE_CONFIG
     model_name = args.model or DEFAULT_MODEL
 
     prompt = build_prompt(
@@ -175,24 +205,20 @@ async def main_streaming(args):
         model_name=model_name,
     )
 
-    omni = AsyncOmni(
-        model=model_name,
-        stage_configs_path=stage_configs_path,
-        log_stats=args.log_stats,
-        stage_init_timeout=args.stage_init_timeout,
-    )
+    omni = AsyncOmni(**_build_omni_kwargs(args, model_name))
 
     request_id = "0"
     t_start = time.perf_counter()
     t_prev = t_start
     chunk_idx = 0
+    all_audio_chunks: list[torch.Tensor] = []
+    sample_rate = None
 
     async for stage_output in omni.generate(prompt, request_id=request_id):
         mm = stage_output.request_output.outputs[0].multimodal_output
         if not stage_output.finished:
             t_now = time.perf_counter()
-            audio = mm.get("audio")
-            n = len(audio) if isinstance(audio, list) else (0 if audio is None else 1)
+            sample_rate, n = _collect_audio_chunk(mm, all_audio_chunks, sample_rate)
             dt_ms = (t_now - t_prev) * 1000
             ttfa_ms = (t_now - t_start) * 1000
             if chunk_idx == 0:
@@ -202,10 +228,20 @@ async def main_streaming(args):
             t_prev = t_now
             chunk_idx += 1
         else:
+            # Collect any remaining audio in the final message
+            sample_rate, _ = _collect_audio_chunk(mm, all_audio_chunks, sample_rate)
+
             t_end = time.perf_counter()
             total_ms = (t_end - t_start) * 1000
             logger.info("Request %s: done total=%.1fms chunks=%d", request_id, total_ms, chunk_idx)
-            _save_wav(output_dir, request_id, mm)
+
+            if all_audio_chunks and sample_rate:
+                audio_tensor = torch.cat(all_audio_chunks, dim=-1)
+                out_wav = os.path.join(output_dir, f"output_{request_id}.wav")
+                sf.write(out_wav, audio_tensor.float().cpu().numpy().flatten(), samplerate=sample_rate, format="WAV")
+                logger.info("Request %s: saved audio to %s (sr=%d)", request_id, out_wav, sample_rate)
+            else:
+                logger.warning("Request %s: no audio chunks received", request_id)
 
 
 def parse_args():
@@ -236,11 +272,17 @@ def parse_args():
         default=None,
         help=f"HuggingFace model path (default: {DEFAULT_MODEL}).",
     )
+    parser.add_argument(
+        "--deploy-config",
+        type=str,
+        default=None,
+        help="Deploy config YAML path (under vllm_omni/deploy/).",
+    )
     parser.add_argument(
         "--stage-configs-path",
         type=str,
         default=None,
-        help="Path to stage configs YAML.",
+        help="Path to stage configs YAML (legacy, prefer --deploy-config).",
     )
     parser.add_argument(
         "--output-dir",
diff --git a/examples/offline_inference/text_to_speech/ming_tts/runner.py b/examples/offline_inference/text_to_speech/ming_tts/runner.py
index 35852ce04..6f9d75740 100644
--- a/examples/offline_inference/text_to_speech/ming_tts/runner.py
+++ b/examples/offline_inference/text_to_speech/ming_tts/runner.py
@@ -140,7 +140,6 @@ def build_engine_kwargs(args, stats_log_file: str | None) -> dict:
         "stage_init_timeout": args.stage_init_timeout,
         "init_timeout": args.init_timeout,
         "batch_timeout": args.batch_timeout,
-        "shm_threshold_bytes": args.shm_threshold_bytes,
         "worker_backend": args.worker_backend,
     }
     if stats_log_file is not None:
diff --git a/examples/offline_inference/text_to_video/text_to_video.md b/examples/offline_inference/text_to_video/text_to_video.md
index edc75bb26..0df1f9bd0 100644
--- a/examples/offline_inference/text_to_video/text_to_video.md
+++ b/examples/offline_inference/text_to_video/text_to_video.md
@@ -8,7 +8,7 @@ A unified script for text-to-video generation. Supports multiple models with mod
 |---|---|---|---|---|---|
 | `Wan-AI/Wan2.1-VACE-1.3B-diffusers` | 480x832 | 81 | 30 | 5.0 | ~20 GiB (RTX 5090, VAE tiling) |
 | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | 720x1280 | 81 | 40 | 4.0 | ~60 GiB |
-| `dg845/LTX-2.3-Diffusers` | 384x512 | 25 | 20 | 4.0 | 96GB-class GPU |
+| `Lightricks/LTX-2` | 512x768 | 121 | 40 | video 3.0 / audio 7.0 | Model-dependent |
 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_t2v` | 480x832 | 121 | 50 | 6.0 | 1×A100 80GB |
 | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_t2v` | 720x1280 | 121 | 50 | 6.0 | FP8 + VAE tiling required |
 | `nvidia/Cosmos3-Nano` | 720x1280 | 189 | 35 | 6.0 | ~46 GiB (peak, 720p) |
@@ -55,45 +55,17 @@ python text_to_video.py \
   --output vace_t2v_output.mp4
 ```
 
-LTX2 example:
+### LTX-2
 
 ```bash
 python text_to_video.py \
-  --model "Lightricks/LTX-2" \
-  --prompt "A cinematic close-up of ocean waves at golden hour." \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 512 \
-  --width 768 \
-  --num-frames 121 \
-  --num-inference-steps 40 \
-  --guidance-scale 4.0 \
-  --frame-rate 24 \
-  --output ltx2_out.mp4
-```
-
-### LTX-2.3
-
-```bash
-python text_to_video.py \
-  --model dg845/LTX-2.3-Diffusers \
-  --model-class-name LTX23Pipeline \
+  --model Lightricks/LTX-2 \
   --prompt "Cherry blossoms swaying gently in the breeze with synchronized ambient sound" \
-  --negative-prompt "worst quality, inconsistent motion, blurry, jittery, distorted" \
-  --height 384 \
-  --width 512 \
-  --num-frames 25 \
-  --num-inference-steps 20 \
-  --guidance-scale 4.0 \
-  --frame-rate 24 \
-  --fps 24 \
-  --audio-sample-rate 48000 \
-  --output ltx23_t2v_output.mp4
+  --output ltx2_output.mp4
 ```
 
-Use a Diffusers-format checkpoint such as `dg845/LTX-2.3-Diffusers`; the
-upstream `Lightricks/LTX-2.3` raw safetensors repo is not directly loadable by
-this pipeline. Pass `--model-class-name LTX23Pipeline` to select the LTX-2.3
-text-to-video pipeline explicitly.
+See the [LTX-2 recipe](../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, I2V, defaults, and advanced options.
 
 ### HunyuanVideo-1.5 (480p)
 
@@ -212,8 +184,7 @@ python text_to_video.py \
 ### Common
 
 - `--model`: Diffusers model ID or local path.
-- `--model-class-name`: Optional explicit pipeline class. Use `LTX23Pipeline`
-  for LTX-2.3 text-to-video.
+- `--model-class-name`: Optional explicit pipeline override.
 - `--prompt`: text description (string).
 - `--height/--width`: output resolution. Default depends on model.
 - `--num-frames`: number of frames. Default depends on model.
@@ -229,8 +200,7 @@ python text_to_video.py \
 - `--enable-cpu-offload`: enable CPU offloading for diffusion models.
 - `--enable-layerwise-offload`: enable layerwise offloading on DiT modules.
 - `--frame-rate`: generation FPS for pipelines that require it (e.g., LTX2).
-- `--audio-sample-rate`: audio sample rate for embedded audio (when the
-  pipeline returns audio; LTX-2.3 outputs 48kHz audio).
+- `--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.
 - `--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).
diff --git a/examples/offline_inference/text_to_video/text_to_video.py b/examples/offline_inference/text_to_video/text_to_video.py
index 0f9bb8c8e..b21ec8f48 100644
--- a/examples/offline_inference/text_to_video/text_to_video.py
+++ b/examples/offline_inference/text_to_video/text_to_video.py
@@ -56,6 +56,19 @@ _MODEL_PRESETS = {
         "flow_shift": 10.0,
         "output": "cosmos3_t2v_output.mp4",
     },
+    # Cosmos3-Edge is a compact checkpoint with its own native resolution / guidance /
+    # flow_shift. It must NOT inherit the Nano/Super "cosmos" numbers above (720p / gs 6.0 /
+    # flow_shift 10.0), which produce degenerate output on Edge.
+    "cosmos3_edge": {
+        "height": 480,
+        "width": 832,
+        "num_frames": 189,
+        "num_inference_steps": 35,
+        "guidance_scale": 5.0,
+        "fps": 24,
+        "flow_shift": 3.0,
+        "output": "cosmos3_edge_t2v_output.mp4",
+    },
     "helios": {
         "height": 384,
         "width": 640,
@@ -65,13 +78,48 @@ _MODEL_PRESETS = {
         "fps": 16,
         "output": "helios_output.mp4",
     },
+    "ltx2": {
+        "height": 512,
+        "width": 768,
+        "num_frames": 121,
+        "num_inference_steps": 40,
+        "fps": 24,
+        "output": "ltx2_output.mp4",
+    },
+    "ltx2_distilled": {
+        "height": 1024,
+        "width": 1536,
+        "num_frames": 121,
+        "num_inference_steps": 8,
+        "fps": 24,
+        "output": "ltx2_distilled_output.mp4",
+    },
+    "ltx23": {
+        "height": 512,
+        "width": 768,
+        "num_frames": 121,
+        "num_inference_steps": 30,
+        "fps": 24,
+        "output": "ltx23_output.mp4",
+    },
 }
 
 
-def _detect_preset(model: str) -> dict:
+def _detect_preset(model: str, model_class_name: str | None = None) -> dict:
     model_lower = model.lower()
+    class_lower = (model_class_name or "").lower()
+    if "distilled" in class_lower or "distilled" in model_lower:
+        return _MODEL_PRESETS["ltx2_distilled"]
+    if "ltx23" in class_lower or "ltx-2.3" in model_lower or "ltx_2.3" in model_lower:
+        return _MODEL_PRESETS["ltx23"]
+    if "ltx2" in class_lower or "ltx-2" in model_lower or "ltx_2" in model_lower:
+        return _MODEL_PRESETS["ltx2"]
     if "vace" in model_lower:
         return _MODEL_PRESETS["vace"]
+    # Edge must be matched before the generic cosmos branch (its "cosmos" substring would
+    # otherwise pick up the Nano/Super 720p / gs 6.0 / flow_shift 10.0 preset).
+    if ("cosmos" in model_lower or "cosmos" in class_lower) and ("edge" in model_lower or "edge" in class_lower):
+        return _MODEL_PRESETS["cosmos3_edge"]
     if "cosmos" in model_lower:
         return _MODEL_PRESETS["cosmos"]
     if "hunyuan" in model_lower:
@@ -122,10 +170,15 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--model-class-name",
         default=None,
-        help="Override model class name (e.g., LTX2TwoStagesVideoPipeline).",
+        help="Override model class name (e.g., LTX2Pipeline).",
+    )
+    parser.add_argument(
+        "--deploy-config",
+        default=None,
+        help="Optional deploy config YAML to use for pipeline-backed runs.",
     )
     parser.add_argument("--prompt", default="A serene lakeside sunrise with mist over the water.", help="Text prompt.")
-    parser.add_argument("--negative-prompt", default="", help="Negative prompt.")
+    parser.add_argument("--negative-prompt", default=None, help="Negative prompt. Default: model-specific.")
     parser.add_argument(
         "--extra-body",
         type=parse_extra_body,
@@ -326,7 +379,7 @@ def main():
     args = parse_args()
     model_class_name = args.model_class_name
 
-    preset = _detect_preset(args.model)
+    preset = _detect_preset(args.model, model_class_name)
     for key, default_val in preset.items():
         if getattr(args, key.replace("-", "_"), None) is None:
             setattr(args, key.replace("-", "_"), default_val)
@@ -375,6 +428,8 @@ def main():
         enable_diffusion_pipeline_profiler=args.enable_diffusion_pipeline_profiler,
         profiler_config=args.profiler_config,
     )
+    if args.deploy_config:
+        omni_kwargs["deploy_config"] = args.deploy_config
     if args.boundary_ratio is not None:
         omni_kwargs["boundary_ratio"] = args.boundary_ratio
     if args.flow_shift is not None:
@@ -415,8 +470,11 @@ def main():
     print(f"{'=' * 60}\n")
 
     prompt_dict = {"prompt": args.prompt}
-    if args.negative_prompt:
+    if args.negative_prompt is not None:
         prompt_dict["negative_prompt"] = args.negative_prompt
+    elif preset not in (_MODEL_PRESETS["ltx2"], _MODEL_PRESETS["ltx23"]):
+        # Preserve the historical empty-prompt behavior for non-LTX examples.
+        prompt_dict["negative_prompt"] = ""
 
     sampling_kwargs = dict(
         height=args.height,
diff --git a/examples/offline_inference/text_to_video/text_to_video_lingbot.py b/examples/offline_inference/text_to_video/text_to_video_lingbot.py
new file mode 100644
index 000000000..a8f8a2015
--- /dev/null
+++ b/examples/offline_inference/text_to_video/text_to_video_lingbot.py
@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+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
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Generate text-to-video with a LingBot-Video checkpoint.")
+    parser.add_argument("--model", default="/home/models/lingbot-video-dense-1.3b")
+    parser.add_argument("--prompt", default="a robotic arm picks up a red block")
+    parser.add_argument("--negative-prompt", default="")
+    parser.add_argument("--output", default="lingbot_video_output.mp4")
+    parser.add_argument("--height", type=int, default=192)
+    parser.add_argument("--width", type=int, default=320)
+    parser.add_argument("--num-frames", type=int, default=9)
+    parser.add_argument("--num-inference-steps", type=int, default=2)
+    parser.add_argument("--guidance-scale", type=float, default=3.0)
+    parser.add_argument("--flow-shift", type=float, default=3.0)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--output-type", choices=["pt", "np"], default="pt")
+    parser.add_argument("--batch-cfg", action="store_true")
+    return parser.parse_args()
+
+
+def _peak_memory_mb(output: Any) -> float:
+    result = output[0] if isinstance(output, list) and output else output
+    return float(getattr(result, "peak_memory_mb", 0.0) or 0.0)
+
+
+def _extract_video(output: Any) -> Any:
+    if isinstance(output, list):
+        output = output[0] if output else None
+    if isinstance(output, OmniRequestOutput):
+        if output.final_output_type != "image":
+            raise ValueError(f"Unexpected output type {output.final_output_type!r}.")
+        if not output.images:
+            raise ValueError("No video frames found in OmniRequestOutput.")
+        return output.images[0] if len(output.images) == 1 else output.images
+    return output
+
+
+def _to_frame_array(video: Any) -> np.ndarray:
+    if isinstance(video, torch.Tensor):
+        tensor = video.detach().cpu()
+        if tensor.dim() == 5:
+            tensor = tensor[0] if tensor.shape[1] not in (3, 4) else tensor[0].permute(1, 2, 3, 0)
+        elif tensor.dim() == 4 and tensor.shape[0] in (3, 4):
+            tensor = tensor.permute(1, 2, 3, 0)
+        if tensor.is_floating_point():
+            if float(tensor.min()) < 0.0:
+                tensor = tensor.clamp(-1, 1) * 0.5 + 0.5
+            else:
+                tensor = tensor.clamp(0, 1)
+        return tensor.float().numpy()
+    if isinstance(video, np.ndarray):
+        array = video[0] if video.ndim == 5 else video
+        if np.issubdtype(array.dtype, np.integer):
+            return array.astype(np.float32) / 255.0
+        return array.astype(np.float32, copy=False)
+    if isinstance(video, list):
+        return np.stack([_to_frame_array(frame) for frame in video], axis=0)
+    return np.asarray(video, dtype=np.float32)
+
+
+def main() -> None:
+    args = parse_args()
+    generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(args.seed)
+    omni = Omni(
+        model=args.model,
+        model_class_name="LingBotVideoPipeline",
+        flow_shift=args.flow_shift,
+        parallel_config=DiffusionParallelConfig(),
+    )
+
+    prompt: dict[str, str] = {"prompt": args.prompt}
+    if args.negative_prompt:
+        prompt["negative_prompt"] = args.negative_prompt
+
+    sampling_params = OmniDiffusionSamplingParams(
+        height=args.height,
+        width=args.width,
+        num_frames=args.num_frames,
+        num_inference_steps=args.num_inference_steps,
+        guidance_scale=args.guidance_scale,
+        generator=generator,
+        output_type=args.output_type,
+        extra_args={"batch_cfg": args.batch_cfg, "shift": args.flow_shift},
+    )
+
+    start = time.perf_counter()
+    output = omni.generate(prompt, sampling_params)
+    elapsed = time.perf_counter() - start
+    print(f"Total generation time: {elapsed:.4f} seconds ({elapsed * 1000:.2f} ms)")
+    peak_mb = _peak_memory_mb(output)
+    if peak_mb:
+        print(f"Worker peak GPU memory (reserved): {peak_mb:.2f} MiB ({peak_mb / 1024:.2f} GiB)")
+
+    video = _to_frame_array(_extract_video(output))
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    from diffusers.utils import export_to_video
+
+    export_to_video(list(video), str(output_path), fps=args.fps)
+    print(f"Saved generated video to {output_path}")
+    omni.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/x_to_text/README.md b/examples/offline_inference/x_to_text/README.md
new file mode 100644
index 000000000..de668b6ee
--- /dev/null
+++ b/examples/offline_inference/x_to_text/README.md
@@ -0,0 +1,105 @@
+# X-To-Text
+
+Generate text from text or image inputs with vLLM-Omni's shared offline entrypoint.
+
+- `x_to_text.py`: command-line script for text-to-text (T2T) and image-to-text (I2T) inference.
+
+## Supported Models
+
+| Model | T2T | I2T | Default deploy config |
+| --- | --- | --- | --- |
+| `ByteDance-Seed/BAGEL-7B-MoT` | Yes | Yes | `vllm_omni/deploy/bagel.yaml` |
+| `tencent/HunyuanImage-3.0-Instruct` | Yes | Yes | `vllm_omni/deploy/hunyuan_image3_ar.yaml` |
+| `bytedance-research/MammothModa2-Preview` | Yes | Yes | `vllm_omni/deploy/mammoth_moda2_ar.yaml` |
+| `bytedance-research/MammothModa2-Dev` | Yes | Yes | `vllm_omni/deploy/mammoth_moda2_ar.yaml` |
+
+The script recognizes these model families from `config.json`, applies the
+model-specific prompt format, and selects an AR-only deploy for HunyuanImage-3
+and MammothModa2. BAGEL uses its registered default deploy.
+
+## Text-To-Text
+
+### BAGEL
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ByteDance-Seed/BAGEL-7B-MoT \
+  --prompt "Where is the capital of France?"
+```
+
+### HunyuanImage-3
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --prompt "Explain multimodal inference in three concise sentences."
+```
+
+### MammothModa2
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model bytedance-research/MammothModa2-Preview \
+  --prompt "Explain multimodal inference in three concise sentences."
+```
+
+The same command supports the Dev checkpoint:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model bytedance-research/MammothModa2-Dev \
+  --prompt "Explain multimodal inference in three concise sentences."
+```
+
+## Image-To-Text
+
+Pass one image with `--image`. The default question can be replaced with any
+instruction supported by the checkpoint.
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ByteDance-Seed/BAGEL-7B-MoT \
+  --image image.png \
+  --prompt "Describe this image in detail."
+```
+
+Use the same command with either of the other supported checkpoints:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --image image.png \
+  --prompt "Describe this image in detail."
+```
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model bytedance-research/MammothModa2-Preview \
+  --image image.png \
+  --prompt "Describe this image in detail."
+```
+
+Use `bytedance-research/MammothModa2-Dev` in the same command to run I2T with
+the Dev checkpoint.
+
+## Key Arguments
+
+| Argument | Default | Description |
+| --- | --- | --- |
+| `--model` | Required | Hugging Face model ID or local checkpoint path |
+| `--prompt` | Required | User question or instruction |
+| `--image` | None | Input image; enables I2T when supplied |
+| `--output` | None | Optional text output file |
+| `--deploy-config` | Model default | Override the deploy YAML |
+| `--max-tokens` | `512` | Maximum generated tokens |
+| `--temperature` | `0.0` | Sampling temperature |
+| `--top-p` | `1.0` | Nucleus sampling probability |
+| `--seed` | `42` | Sampling seed |
+| `--trust-remote-code` | Off | Allow checkpoint-provided Python code |
+| `--enforce-eager` | Off | Disable graph compilation |
+
+## Hardware Notes
+
+The committed HunyuanImage-3 AR-only default uses four GPUs with TP=4. To use a
+different topology, pass a custom AR-only YAML through `--deploy-config`.
+BAGEL and MammothModa2 use their repository deploy defaults unless overridden.
diff --git a/examples/offline_inference/x_to_text/x_to_text.py b/examples/offline_inference/x_to_text/x_to_text.py
new file mode 100644
index 000000000..9937a57ff
--- /dev/null
+++ b/examples/offline_inference/x_to_text/x_to_text.py
@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Shared offline example for any supported input modality to text."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+
+from vllm_omni import Omni
+from vllm_omni.model_extras import build_x_to_text_prompt, get_x_to_text_model_family
+
+_REPO_ROOT = Path(__file__).resolve().parents[3]
+_HUNYUAN_AR_DEPLOY_CONFIG = _REPO_ROOT / "vllm_omni" / "deploy" / "hunyuan_image3_ar.yaml"
+_MAMMOTH_AR_DEPLOY_CONFIG = _REPO_ROOT / "vllm_omni" / "deploy" / "mammoth_moda2_ar.yaml"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run shared offline x-to-text inference (currently T2T and I2T).")
+    parser.add_argument("--model", required=True, help="Model name or local path.")
+    parser.add_argument("--prompt", required=True, help="Question or text prompt.")
+    parser.add_argument("--image", help="Optional input image. Supplying it selects image-to-text.")
+    parser.add_argument("--output", help="Optional path to write the generated text.")
+    parser.add_argument("--deploy-config", help="Optional deploy YAML override.")
+    parser.add_argument("--max-tokens", type=int, default=512)
+    parser.add_argument("--temperature", type=float, default=0.0)
+    parser.add_argument("--top-p", type=float, default=1.0)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--trust-remote-code", action="store_true")
+    parser.add_argument("--enforce-eager", action="store_true", default=None)
+    parser.add_argument("--log-stats", action="store_true")
+    return parser.parse_args()
+
+
+def _extract_text(outputs: list[Any]) -> str:
+    chunks: list[str] = []
+    for output in outputs:
+        request_output = getattr(output, "request_output", output)
+        for completion in getattr(request_output, "outputs", None) or []:
+            chunks.append(getattr(completion, "text", "") or "")
+    return "".join(chunks).strip()
+
+
+def main() -> None:
+    args = parse_args()
+    family = get_x_to_text_model_family(args.model)
+    image = Image.open(args.image).convert("RGB") if args.image else None
+
+    prompt_dict, stop_token_ids = build_x_to_text_prompt(
+        model_family=family,
+        model=args.model,
+        prompt=args.prompt,
+        has_image=image is not None,
+    )
+
+    if image is not None:
+        prompt_dict["multi_modal_data"] = {"image": image}
+
+    omni_kwargs: dict[str, Any] = {
+        "model": args.model,
+        "mode": "image-to-text" if image is not None else "text-to-text",
+        "trust_remote_code": args.trust_remote_code or family in {"hunyuan_image3", "mammoth_moda2"},
+        "log_stats": args.log_stats,
+    }
+    if args.enforce_eager is not None:
+        omni_kwargs["enforce_eager"] = args.enforce_eager
+    if args.deploy_config:
+        omni_kwargs["deploy_config"] = args.deploy_config
+    elif family == "hunyuan_image3":
+        omni_kwargs["deploy_config"] = str(_HUNYUAN_AR_DEPLOY_CONFIG)
+    elif family == "mammoth_moda2":
+        omni_kwargs["deploy_config"] = str(_MAMMOTH_AR_DEPLOY_CONFIG)
+
+    omni = Omni(**omni_kwargs)
+    try:
+        sampling_params = list(omni.default_sampling_params_list or [])
+        for params in sampling_params:
+            if hasattr(params, "max_tokens"):
+                params.max_tokens = args.max_tokens
+            if hasattr(params, "temperature"):
+                params.temperature = args.temperature
+            if hasattr(params, "top_p"):
+                params.top_p = args.top_p
+            if hasattr(params, "seed"):
+                params.seed = args.seed
+            if stop_token_ids is not None and hasattr(params, "stop_token_ids"):
+                params.stop_token_ids = stop_token_ids
+        outputs = list(omni.generate([prompt_dict], sampling_params_list=sampling_params or None))
+    finally:
+        omni.close()
+
+    text = _extract_text(outputs)
+    print(text)
+    if args.output:
+        Path(args.output).write_text(text + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/audex/README.md b/examples/online_serving/audex/README.md
new file mode 100644
index 000000000..e61c66266
--- /dev/null
+++ b/examples/online_serving/audex/README.md
@@ -0,0 +1,89 @@
+# Audex (Nemotron-Labs-Audex-2B) online serving
+
+One checkpoint, four deployment modes. `run_server.sh` starts the server
+for a given `MODE`; `client.py --mode <mode>` tests it. The capability
+matrix:
+
+| mode (`vllm_omni/deploy/audex_<mode>.yaml`) | audio in | text out | speech out | general audio out | endpoint |
+|---|---|---|---|---|---|
+| `tts` | ❌ | ❌ | ✅ | ❌ | `/v1/audio/speech` |
+| `tta` | ❌ | ❌ | ❌ | ✅ | `/v1/audio/speech` |
+| `thinker_only` | ✅ | ✅ | ❌ | ❌ | `/v1/chat/completions` |
+| `s2s` | ✅ | ✅ | ✅ | ❌ | both |
+
+Audio-input modes of `client.py` fall back to vLLM's public
+`mary_had_lamb` asset when `--audio-file` is omitted; CFG defaults follow
+the official settings per mode (tts/s2s 1.5, tta 3.0; `--cfg-scale 1.0`
+disables).
+
+## tts — text → speech
+
+Text-only thinker (`checkpoint_folder_audiogen`) emits `<speechcodec_N>`
+tokens; the streaming causal decoder produces 16 kHz WAVs. This is also
+the DEFAULT pipeline when the repo root is served without a deploy config.
+
+```bash
+./run_server.sh                       # MODE=tts, port 8097
+
+python client.py --mode tts --text "Hello there." --output hello.wav
+# or raw curl:
+curl -s http://localhost:8097/v1/audio/speech \
+    -H 'Content-Type: application/json' \
+    -d '{"model": "nvidia/Nemotron-Labs-Audex-2B", "input": "Hello there.", "response_format": "wav", "extra_params": {"cfg_scale": 1.5}}' \
+    -o hello.wav
+```
+
+## tta — caption → general audio
+
+Same thinker over the 4-codebook `<audiocodec_N>` RVQ block, decoded by
+the external XCodec1 checkpoint (auto-downloaded; override with
+`XCODEC1_PATH`). Clips are capped at 10 s.
+
+```bash
+MODE=tta ./run_server.sh
+
+python client.py --mode tta --caption "Heavy rain falling on a tin roof." \
+    --output rain.wav
+```
+
+## thinker_only — audio (+ instruction) → text
+
+Single-stage audio understanding on the full checkpoint (NV-Whisper
+encoder + projector + LM). Send the clip as `input_audio` chat content.
+
+```bash
+MODE=thinker_only ./run_server.sh
+
+python client.py --mode thinker_only                      # transcribe the demo asset
+python client.py --mode thinker_only --audio-file a.wav \
+    --question "What language is being spoken?"
+```
+
+## s2s — spoken question → spoken answer
+
+The audio-capable thinker plus the speech decoder in one deployment.
+`client.py --mode s2s` runs the official three passes: ASR (chat with
+`input_audio`) → chat on the transcript → TTS on the answer. Text-final
+passes carry `"modalities": ["text"]`; only the TTS pass streams through
+the decoder.
+
+```bash
+MODE=s2s PORT=8098 ./run_server.sh
+
+python client.py --mode s2s --port 8098 \
+    --audio-file question.wav --output answer.wav
+```
+
+Offline counterparts (no HTTP, one `Omni` engine per script) live in
+`examples/offline_inference/audex/`.
+
+## 30B-A3B (nvidia/Nemotron-Labs-Audex-30B-A3B)
+
+`SIZE=30b` switches run_server.sh to the 30B yamls and model id:
+
+    SIZE=30b ./run_server.sh                 # 30B tts on port 8097
+    SIZE=30b MODE=s2s PORT=8098 ./run_server.sh
+
+Pass `--model nvidia/Nemotron-Labs-Audex-30B-A3B` to the client — the server
+validates the model id and 404s on a mismatch. Single-H100 defaults; see the
+yaml comments for the TP2 fallback. First launch downloads ~60 GB.
diff --git a/examples/online_serving/audex/client.py b/examples/online_serving/audex/client.py
new file mode 100644
index 000000000..e85a3cdf6
--- /dev/null
+++ b/examples/online_serving/audex/client.py
@@ -0,0 +1,319 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex online client for all four deployment modes.
+
+Pick ``--mode`` to match the server's deploy yaml (see run_server.sh):
+
+  tts           /v1/audio/speech: text -> speech WAV
+  tta           /v1/audio/speech: caption -> general-audio WAV
+  thinker_only  /v1/chat/completions: audio (+ question) -> text
+  s2s           the official three-pass cascade against one audex_s2s
+                server: ASR (chat, input_audio) -> chat -> TTS
+
+Audio-input modes fall back to vLLM's public ``mary_had_lamb`` asset when
+``--audio-file`` is omitted.
+
+Examples:
+
+    python examples/online_serving/audex/client.py --mode tts \\
+        --text "Hello there." --output hello.wav
+    python examples/online_serving/audex/client.py --mode tta \\
+        --caption "Heavy rain falling on a tin roof." --output rain.wav
+    python examples/online_serving/audex/client.py --mode thinker_only
+    python examples/online_serving/audex/client.py --mode s2s \\
+        --audio-file question.wav --output answer.wav
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import re
+from pathlib import Path
+
+import requests
+
+ASR_QUESTION = "Transcribe the input speech."
+SYSTEM_PROMPT = "You are a helpful and harmless assistant.\n\nYou are not allowed to use any tools."
+# The official chat-pass recipe below (SYSTEM_PROMPT + TEXT_INSTRUCTION
+# prefix, reasoning enabled, temp 1.0/top_p 0.95, seed retry) applies to the
+# 30B-A3B ONLY (see is_30b() below and
+# tests/e2e/offline_inference/test_audex_s2s.py, which mirrors this same
+# split). It is load-bearing on the 30B: without the formatting-instruction
+# prefix a bare transcript turn is treated as a TTS request and the model
+# emits literal <speechcodec_N> tokens instead of a text answer (the system
+# prompt alone does not prevent this). The 2B must NOT use this recipe: the
+# official temp-1.0 seed-0 draw measurably hallucinates off-language text on
+# the 2B (yet closes </think> cleanly, so the seed retry never fires) and
+# fails the round-trip WER gate — measured, reproduced byte-identically. The
+# 2B instead keeps its original bare-message / enable_thinking=False /
+# temperature=0.0 recipe.
+TEXT_INSTRUCTION = (
+    "SYSTEM & FORMATTING INSTRUCTION: You are Audex, created by NVIDIA based on the Nemotron-Cascade-2 architecture. "
+    "You may output your reasoning, followed by your final response. "
+    "You may format your reasoning block however you like. "
+    "However, your final response must strictly follow these rules: "
+    "* Write in plain, unformatted prose like a book or newspaper article. "
+    "* Do not use markdown, bullet points, lists, or headers. "
+    "* Standard numbers, abbreviations, and symbols are acceptable. "
+    "* [CRITICAL] You must press enter after every single sentence, placing each sentence on its own separate line."
+)
+DEFAULT_TEXT = "Hello there! This is the Audex text to speech pipeline."
+DEFAULT_CAPTION = "Heavy rain falling on a tin roof."
+# Official quality settings; 1.0 disables guidance.
+DEFAULT_CFG = {"tts": 1.5, "tta": 3.0, "s2s": 1.5}
+
+
+def is_30b(model: str) -> bool:
+    # Users pass arbitrary repo IDs or local snapshot paths, so this is a
+    # heuristic (not an exact match against the official 30B-A3B repo ID)
+    # — good enough for an example script; keep in sync with the same
+    # branch in examples/offline_inference/audex/speech_to_speech.py and
+    # tests/e2e/offline_inference/test_audex_s2s.py.
+    return "30b" in model.lower()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Audex online client (tts / tta / thinker_only / s2s)")
+    parser.add_argument("--mode", choices=("tts", "tta", "thinker_only", "s2s"), default="s2s")
+    parser.add_argument("--host", type=str, default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8097)
+    parser.add_argument("--model", type=str, default="nvidia/Nemotron-Labs-Audex-2B")
+    parser.add_argument("--text", type=str, default=DEFAULT_TEXT, help="TTS input text (mode=tts).")
+    parser.add_argument("--caption", type=str, default=DEFAULT_CAPTION, help="TTA caption (mode=tta).")
+    parser.add_argument(
+        "--audio-file",
+        type=str,
+        default=None,
+        help="Input WAV for thinker_only/s2s. Defaults to vLLM's mary_had_lamb asset.",
+    )
+    parser.add_argument("--question", type=str, default=ASR_QUESTION, help="Instruction (mode=thinker_only).")
+    parser.add_argument("--output", type=str, default="results/audex_online.wav")
+    parser.add_argument(
+        "--cfg-scale",
+        type=float,
+        default=None,
+        help="CFG strength; defaults per mode (tts/s2s 1.5, tta 3.0). 1.0 disables.",
+    )
+    parser.add_argument("--max-tokens", type=int, default=512)
+    return parser.parse_args()
+
+
+def _audio_b64(audio_file: str | None) -> str:
+    if audio_file:
+        return base64.b64encode(Path(audio_file).read_bytes()).decode()
+    # Fall back to vLLM's public asset, re-encoded as WAV for the chat API.
+    import io
+
+    import numpy as np
+    import soundfile as sf
+    from vllm.assets.audio import AudioAsset
+
+    audio, sr = AudioAsset("mary_had_lamb").audio_and_sample_rate
+    buf = io.BytesIO()
+    sf.write(buf, np.asarray(audio, dtype="float32"), int(sr), format="WAV")
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def _chat(
+    base_url: str,
+    model: str,
+    messages: list[dict],
+    max_tokens: int,
+    enable_thinking: bool = False,
+    temperature: float = 0.0,
+    top_p: float = 1.0,
+    seed: int = 0,
+) -> tuple[str, str]:
+    resp = requests.post(
+        f"{base_url}/v1/chat/completions",
+        json={
+            "model": model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "seed": seed,
+            # Text-final passes must say so explicitly: without "modalities"
+            # the server falls back to the deployment's configured output
+            # modalities, which for the s2s pipeline include the audio final
+            # stage — routing ASR/chat through code2wav instead of stopping
+            # at stage 0.
+            "modalities": ["text"],
+            # The checkpoint's chat template thinking toggle. The official
+            # cascaded demo transcribes with enable_thinking=False but runs
+            # the chat pass with reasoning ENABLED (its web UI ships the
+            # "Enable reasoning" checkbox checked), priming the generation
+            # prompt with an open "<think>\n" so the model's reasoning stays
+            # inside the think block; _extract_final_response then drops it.
+            # With thinking disabled the 30B leaks its reasoning as plain
+            # text in front of the final response.
+            "chat_template_kwargs": {"enable_thinking": enable_thinking},
+        },
+        timeout=300,
+    )
+    resp.raise_for_status()
+    choice = resp.json()["choices"][0]
+    return choice["message"]["content"].strip(), choice.get("finish_reason") or ""
+
+
+def _speech(base_url: str, model: str, text: str, cfg_scale: float, out_path: Path) -> None:
+    payload: dict = {"model": model, "input": text, "response_format": "wav"}
+    if cfg_scale > 1.0:
+        payload["extra_params"] = {"cfg_scale": cfg_scale}
+    resp = requests.post(f"{base_url}/v1/audio/speech", json=payload, timeout=600)
+    resp.raise_for_status()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_bytes(resp.content)
+
+
+def _audio_question(audio_b64: str, question: str) -> list[dict]:
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
+                {"type": "text", "text": question},
+            ],
+        }
+    ]
+
+
+def _tts_text(answer: str) -> str:
+    # The formatting instruction's CRITICAL rule puts each final-response
+    # sentence on its own line, and the official demo TTS-es those sentence
+    # segments (split_sentence_segments). Mirror that per-line segmentation
+    # but keep a single /v1/audio/speech request: speak the leading whole
+    # sentences of the CLEANED final response up to ~200 chars, never
+    # cutting mid-sentence. Markdown markup is stripped as before (it makes
+    # the TTS thinker stop almost immediately).
+    sentences = []
+    for line in answer.splitlines():
+        line = re.sub(r"[*#_`]+", "", line)
+        line = re.sub(r"\s+", " ", line).strip()
+        if line:
+            sentences.append(line)
+    picked: list[str] = []
+    total = 0
+    for sentence in sentences:
+        if picked and total + len(sentence) > 200:
+            break
+        picked.append(sentence)
+        total += len(sentence) + 1
+    return " ".join(picked)
+
+
+def _extract_final_response(text: str) -> str:
+    # Mirror the official demo's extract_spoken_answer
+    # (cascaded_s2s_web_server.py): the chat pass reasons inside the primed
+    # <think> block, so keep only what follows the LAST closing tag; fall
+    # back to the full text when the model skipped reasoning or never
+    # closed the block. Benign no-op for the 2B's clean answers.
+    if "</think>" in text:
+        answer = text.rsplit("</think>", 1)[-1].strip()
+        if answer:
+            return answer
+    return text.strip()
+
+
+def _clean_transcript(text: str) -> str:
+    # The full checkpoint prefixes transcripts with a language-tag sentence
+    # and quotes the content; extract the quoted payload when present. Span
+    # first-to-last quote (not split on every apostrophe) so contractions
+    # inside the transcript (e.g. "don't") survive intact.
+    text = text.strip()
+    match = re.search(r"'(.*)'", text, flags=re.S)
+    if match and match.group(1).strip():
+        return match.group(1).strip()
+    return text
+
+
+def main():
+    args = parse_args()
+    base_url = f"http://{args.host}:{args.port}"
+    cfg_scale = args.cfg_scale if args.cfg_scale is not None else DEFAULT_CFG.get(args.mode, 1.0)
+    out_path = Path(args.output)
+
+    if args.mode == "tts":
+        _speech(base_url, args.model, args.text, cfg_scale, out_path)
+        print(f"speech: {out_path.stat().st_size} bytes -> {out_path}")
+        return
+
+    if args.mode == "tta":
+        _speech(base_url, args.model, args.caption, cfg_scale, out_path)
+        print(f"audio : {out_path.stat().st_size} bytes -> {out_path}")
+        return
+
+    audio_b64 = _audio_b64(args.audio_file)
+
+    if args.mode == "thinker_only":
+        content, _ = _chat(base_url, args.model, _audio_question(audio_b64, args.question), args.max_tokens)
+        print(f"answer: {_extract_final_response(content)}")
+        return
+
+    # s2s — the official three-pass cascade.
+    asr_content, _ = _chat(base_url, args.model, _audio_question(audio_b64, ASR_QUESTION), args.max_tokens)
+    transcript = _clean_transcript(asr_content)
+    print(f"[1/3] transcript : {transcript}")
+    if not transcript:
+        raise SystemExit("ASR pass produced an empty transcript; aborting cascade")
+
+    # The chat-pass recipe is size-conditional (see the TEXT_INSTRUCTION
+    # comment above): the 30B requires the official recipe, the 2B keeps its
+    # original bare-message recipe.
+    if is_30b(args.model):
+        # Official recipe: system prompt + formatting instruction prefixed
+        # to the transcript, reasoning enabled, and the official demo's
+        # text-pass sampling (its defaults: --text-temperature 1.0,
+        # --text-top-p 0.95, --text-max-tokens 2048). Near-greedy decoding
+        # makes the 30B loop inside its reasoning block until the token
+        # budget runs out without ever closing </think>. Even at the
+        # official temperature some trajectories spin past the budget, so
+        # retry a few deterministic seeds; a natural stop without </think>
+        # is a complete answer, and if every seed spins we keep the full
+        # text like the official demo does.
+        chat_messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": f"{TEXT_INSTRUCTION}\n\n{transcript}"},
+        ]
+        raw = ""
+        for seed in (0, 1, 2):
+            raw, finish_reason = _chat(
+                base_url,
+                args.model,
+                chat_messages,
+                max(args.max_tokens, 2048),
+                enable_thinking=True,
+                temperature=1.0,
+                top_p=0.95,
+                seed=seed,
+            )
+            if "</think>" in raw or finish_reason != "length":
+                break
+            print(f"[2/3] chat seed {seed} hit the token budget mid-reasoning; retrying")
+        answer = _extract_final_response(raw)
+    else:
+        # 2B: bare user message (no system/instruction prefix), reasoning
+        # disabled, temperature 0.0, no retry — its original recipe. The
+        # official temp-1.0 seed-0 recipe measurably makes the 2B
+        # hallucinate off-language answers (see the module-level comment).
+        chat_messages = [{"role": "user", "content": transcript}]
+        raw, _ = _chat(
+            base_url,
+            args.model,
+            chat_messages,
+            args.max_tokens,
+            enable_thinking=False,
+            temperature=0.0,
+        )
+        answer = _extract_final_response(raw)
+    print(f"[2/3] answer     : {answer}")
+    if not answer:
+        raise SystemExit("Chat pass produced an empty answer; aborting cascade")
+
+    _speech(base_url, args.model, _tts_text(answer), cfg_scale, out_path)
+    print(f"[3/3] speech     : {out_path.stat().st_size} bytes -> {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/audex/run_server.sh b/examples/online_serving/audex/run_server.sh
new file mode 100755
index 000000000..042a1c985
--- /dev/null
+++ b/examples/online_serving/audex/run_server.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+# Launch the vLLM-Omni server for Audex (Nemotron-Labs-Audex-2B).
+#
+# MODE picks the deployment (see README.md for the capability matrix):
+#   tts           text -> speech            /v1/audio/speech   (default)
+#   tta           caption -> general audio  /v1/audio/speech
+#   thinker_only  audio -> text             /v1/chat/completions
+#   s2s           cascaded speech-to-speech (both endpoints)
+#
+# Pass the HF repo ROOT as MODEL — per-stage subfolders resolve
+# automatically.
+#
+# Usage:
+#   ./run_server.sh                       # 2B tts on port 8097, GPU 0
+#   SIZE=30b ./run_server.sh              # 30B-A3B tts (explicit 30B yaml)
+#   SIZE=30b MODE=s2s PORT=8098 ./run_server.sh
+#   MODE=tta ./run_server.sh              # needs XCodec1 (auto-downloaded)
+#   MODEL=/path/to/local/snapshot ./run_server.sh
+
+set -e
+
+MODE="${MODE:-${1:-tts}}"
+SIZE="${SIZE:-2b}"
+if [ "$SIZE" = "30b" ]; then
+    MODEL="${MODEL:-nvidia/Nemotron-Labs-Audex-30B-A3B}"
+    YAML_SUFFIX="_30b"
+elif [ "$SIZE" = "2b" ]; then
+    MODEL="${MODEL:-nvidia/Nemotron-Labs-Audex-2B}"
+    YAML_SUFFIX=""
+else
+    echo "Unknown SIZE '$SIZE'; expected 2b|30b" >&2
+    exit 1
+fi
+PORT="${PORT:-8097}"
+GPUS="${GPUS:-0}"
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+DEPLOY_YAML="$REPO_ROOT/vllm_omni/deploy/audex_${MODE}${YAML_SUFFIX}.yaml"
+if [ ! -f "$DEPLOY_YAML" ]; then
+    echo "Unknown MODE '$MODE' / SIZE '$SIZE' (no $DEPLOY_YAML); expected MODE=tts|tta|thinker_only|s2s, SIZE=2b|30b" >&2
+    exit 1
+fi
+
+echo "Starting Audex server"
+echo "  MODE=$MODE ($DEPLOY_YAML)"
+echo "  SIZE=$SIZE"
+echo "  MODEL=$MODEL"
+echo "  PORT=$PORT"
+echo "  CUDA_VISIBLE_DEVICES=$GPUS"
+
+CUDA_VISIBLE_DEVICES="$GPUS" \
+vllm-omni serve "$MODEL" \
+    --host 0.0.0.0 \
+    --port "$PORT" \
+    --trust-remote-code \
+    --deploy-config "$DEPLOY_YAML" \
+    --omni
diff --git a/examples/online_serving/chart-helm/templates/_helpers.tpl b/examples/online_serving/chart-helm/templates/_helpers.tpl
index 00f407bab..cbb03596b 100644
--- a/examples/online_serving/chart-helm/templates/_helpers.tpl
+++ b/examples/online_serving/chart-helm/templates/_helpers.tpl
@@ -28,8 +28,11 @@ If image.command is set, uses that as a full override.
 - {{ .Values.omniArgs.numGpus | quote }}
 {{- end }}
 {{- if .Values.omniArgs.stageConfigsPath }}
-- "--stage-configs-path"
-- {{ .Values.omniArgs.stageConfigsPath | quote }}
+{{- fail "omniArgs.stageConfigsPath has been removed; use omniArgs.deployConfigPath" }}
+{{- end }}
+{{- if .Values.omniArgs.deployConfigPath }}
+- "--deploy-config"
+- {{ .Values.omniArgs.deployConfigPath | quote }}
 {{- end }}
 {{- if and .Values.omniArgs.cacheBackend (ne .Values.omniArgs.cacheBackend "none") }}
 - "--cache-backend"
diff --git a/examples/online_serving/chart-helm/tests/deployment_test.yaml b/examples/online_serving/chart-helm/tests/deployment_test.yaml
index e2c7b32c4..d068891fc 100644
--- a/examples/online_serving/chart-helm/tests/deployment_test.yaml
+++ b/examples/online_serving/chart-helm/tests/deployment_test.yaml
@@ -78,6 +78,26 @@ tests:
           path: spec.template.spec.containers[0].command
           content: "--enable-layerwise-offload"
 
+  - it: should include deploy config in command
+    set:
+      omniArgs:
+        deployConfigPath: "/configs/deploy.yaml"
+    asserts:
+      - equal:
+          path: spec.template.spec.containers[0].command[8]
+          value: "--deploy-config"
+      - equal:
+          path: spec.template.spec.containers[0].command[9]
+          value: "/configs/deploy.yaml"
+
+  - it: should reject removed stage config value
+    set:
+      omniArgs:
+        stageConfigsPath: "/configs/legacy.yaml"
+    asserts:
+      - failedTemplate:
+          errorMessage: "omniArgs.stageConfigsPath has been removed; use omniArgs.deployConfigPath"
+
   - it: should use full command override when image.command is set
     set:
       image:
diff --git a/examples/online_serving/chart-helm/values.yaml b/examples/online_serving/chart-helm/values.yaml
index 52c5bacbd..57b3d041a 100644
--- a/examples/online_serving/chart-helm/values.yaml
+++ b/examples/online_serving/chart-helm/values.yaml
@@ -67,8 +67,8 @@ omniArgs:
   enableCpuOffload: false
   # -- Number of GPUs for diffusion inference (empty = auto)
   numGpus:
-  # -- Path to stage configs file (empty = auto-detected from model)
-  stageConfigsPath:
+  # -- Path to deploy config file (empty = auto-detected from model)
+  deployConfigPath:
   # -- Cache backend: none, tea_cache, or cache_dit
   cacheBackend: "none"
   # -- Default sampling params as a JSON string
diff --git a/examples/online_serving/minicpmo/README.md b/examples/online_serving/minicpmo/README.md
index a34764652..aea9a2b6a 100644
--- a/examples/online_serving/minicpmo/README.md
+++ b/examples/online_serving/minicpmo/README.md
@@ -1,49 +1,127 @@
-# vLLM-Omni · MiniCPM-o 4.5 Online Demo
+# MiniCPM-o 4.5: Online serving
 
-Gradio-based web UI for **MiniCPM-o 4.5** served via `vllm-omni`'s
-OpenAI-compatible endpoints.
+This directory contains MiniCPM-o 4.5 online serving demos for vLLM-Omni.
+Inputs can include text, image, audio, or video; outputs are text and optional
+24 kHz speech.
 
-The UI supports:
+For the experimental native duplex runtime architecture, lifecycle invariants,
+capability boundary, and validation scope, see
+[`vllm_omni/experimental/fullduplex/DESIGN.md`](../../../vllm_omni/experimental/fullduplex/DESIGN.md).
 
-- **Inputs**: text prompt + optional image, audio (file or mic), video.
-- **Outputs**: text + speech (WAV player).
+## Installation
 
-## 1. Start the backend server
+Install vLLM-Omni with the MiniCPM-o talker dependencies:
 
-The deploy config auto-loads via `--omni`; the default
-`vllm_omni/deploy/minicpmo_4_5.yaml` targets a 2-GPU layout (thinker on
-GPU 0, talker + t2w sharing GPU 1).  For other hardware layouts pick
-one of the deploy variants below.
+```bash
+pip install stepaudio2-minicpmo
+```
+
+The `minicpmo` extra installs `stepaudio2-minicpmo` and its audio dependencies,
+including `librosa`.
+
+## Start the backend server
+
+The deploy config auto-loads via `--omni`.
+The default `vllm_omni/deploy/minicpmo_4_5.yaml` keeps all three stages on
+logical device 0 with memory budgets of 55%, 15%, and 15%, leaving headroom
+for runtime kernels such as the HiFi-GAN vocoder's cuDNN workspace. The
+profile admits at most four sequences per stage and bounds startup video
+profiling to 32 frames per video. For throughput,
+`minicpmo_4_5_2gpu.yaml` gives the Thinker
+GPU 0 (90%) and colocates the Talker (55%) and Code2Wav (35%) on GPU 1. That
+profile admits at most four concurrent sequences per stage.
 
 | deploy config | GPUs | Notes |
 |---|---|---|
-| `minicpmo_4_5.yaml` (default) | 2 | Thinker on GPU0, talker+t2w on GPU1. |
-| `minicpmo_4_5_3gpu.yaml` | 3 | Thinker 2-way TP on GPU0/1, talker+t2w share GPU2. |
+| `minicpmo_4_5.yaml` (default) | 1 | Memory-constrained compatibility layout. |
+| `minicpmo_4_5_2gpu.yaml` | 2 | Recommended continuous-batching layout; Talker and Code2Wav share GPU 1. |
+| `minicpmo_4_5_3gpu.yaml` | 3 | One GPU per stage. |
 | `minicpmo_4_5_8x4090.yaml` | 8 | Full 8x4090 layout. |
+| `minicpmo_4_5_duplex.yaml` | 1 | Experimental native full-duplex overlay. |
 
-Default (2-GPU):
+The split pipeline preserves native-duplex epoch/turn identity, segment text,
+turn completion, reference voice, and terminal-audio metadata through
+Code2Wav. Focused CPU regressions cover this envelope; run the Realtime
+scenario below for live barge-in validation on the target GPU.
+
+Default:
 
 ```bash
-vllm serve openbmb/MiniCPM-o-4_5 --omni \
+vllm-omni serve openbmb/MiniCPM-o-4_5 \
+    --omni \
+    --deploy-config vllm_omni/deploy/minicpmo_4_5.yaml \
     --trust-remote-code \
     --host 0.0.0.0 --port 8099
 ```
 
-Other layouts via `--deploy-config`:
+For local ModelScope checkpoints, replace `openbmb/MiniCPM-o-4_5` with the
+checkpoint path. To start the experimental native duplex backend, use
+`vllm_omni/deploy/minicpmo_4_5_duplex.yaml`.
+
+### Per-stage overrides
 
 ```bash
-vllm serve openbmb/MiniCPM-o-4_5 --omni \
-    --deploy-config vllm_omni/deploy/minicpmo_4_5_8x4090.yaml \
-    --trust-remote-code \
-    --host 0.0.0.0 --port 8099
+vllm serve openbmb/MiniCPM-o-4_5 --omni --trust-remote-code --port 8099 \
+    --stage-overrides '{"0": {"gpu_memory_utilization": 0.55}}'
 ```
 
-## 2. Launch the Gradio demo
+## Send multimodal requests
+
+```bash
+cd examples/online_serving/minicpmo
+```
+
+### curl
+
+```bash
+bash run_curl_multimodal_generation.sh text
+bash run_curl_multimodal_generation.sh use_image
+bash run_curl_multimodal_generation.sh use_audio '["text"]'
+
+python openai_chat_completion_client_for_multimodal_generation.py \
+    --query-type use_image \
+    --port 8099 \
+    --host localhost
+
+# Text-only (faster; no <|tts_bos|>)
+python openai_chat_completion_client_for_multimodal_generation.py \
+    --query-type text \
+    --modalities text \
+    --prompt "Briefly introduce yourself."
+```
+
+Streaming text + audio (use `--stream`):
+
+```bash
+python openai_chat_completion_client_for_multimodal_generation.py \
+    --query-type text \
+    --prompt "Briefly introduce yourself." \
+    --port 8099 \
+    --stream
+```
+
+The client prints text deltas as they arrive and saves streamed audio chunks
+to WAV files.
+
+Shared helpers also work if you pass MiniCPM defaults yourself:
+
+```bash
+python ../openai_chat_completion_client_for_multimodal_generation.py \
+    --model openbmb/MiniCPM-o-4_5 \
+    --query-type text \
+    --port 8099
+```
+
+Speech output no longer depends on a MiniCPM-specific default in the generic
+serving layer. `chat_template_kwargs.use_tts_template=true` remains an
+explicitly supported model option.
+
+## Launch the Gradio demo
 
 ```bash
 bash examples/online_serving/minicpmo/run_gradio_demo.sh
 
-# Or run the python entry point directly:
+# Or run the Python entry point directly:
 python examples/online_serving/minicpmo/gradio_demo.py \
     --minicpmo45-api-base http://localhost:8099/v1 \
     --minicpmo45-model openbmb/MiniCPM-o-4_5 \
@@ -52,14 +130,90 @@ python examples/online_serving/minicpmo/gradio_demo.py \
 
 Open `http://<host>:7862` in a browser.
 
-## Notes
+## Daily-Omni accuracy
 
-- **TTS trigger**: the demo sets
-  `extra_body.chat_template_kwargs.use_tts_template=True`, which appends
-  `<|tts_bos|>` to the assistant prefix.
-- Uncheck **"Generate speech output (TTS)"** to get text-only responses
-  (faster).
-- The audio output is the raw WAV returned by the stage-1 talker +
-  Token2Wav; sample rate is 24 kHz.
-- Video input is forwarded as a base64 `video_url` entry; the server needs
-  decord/torchvision to decode it.
+Daily-Omni requires one A–D letter. Set
+`chat_template_kwargs.enable_thinking=false` explicitly in `--extra-body`;
+the generic benchmark CLI does not inject a MiniCPM-specific default.
+Leaving reasoning enabled can exhaust the 256-token answer budget inside
+`<think>` and make first-letter extraction score reasoning text.
+
+For the established text benchmark, send
+`--extra_body '{"modalities":["text"],"chat_template_kwargs":{"enable_thinking":false}}'`.
+Requesting audio also benchmarks Talker and Code2Wav and changes the
+assistant template, so it is not an apples-to-apples accuracy run.
+
+## Run the Realtime duplex CLI demo
+
+After the duplex backend is running, stream one WAV through the Realtime
+WebSocket endpoint:
+
+```bash
+python examples/online_serving/minicpmo/realtime_duplex_demo.py \
+    --url ws://localhost:8099/v1/realtime?duplex=1 \
+    --model openbmb/MiniCPM-o-4_5 \
+    --input-wav /path/to/input_16k_mono_pcm16.wav \
+    --ref-audio /path/to/MiniCPM-o-Demo/assets/ref_audio/ref_minicpm_signature.wav \
+    --output-dir /tmp/minicpmo_realtime_duplex_demo
+```
+
+## Open the experimental browser client
+
+The browser UI serves the page and proxies the same-origin Realtime WebSocket to
+the backend:
+
+```bash
+python -m examples.online_serving.minicpmo.realtime_web \
+    --port 7862 \
+    --ws-backend ws://127.0.0.1:8099 \
+    --ref-audio /path/to/MiniCPM-o-Demo/assets/ref_audio/ref_minicpm_signature.wav
+```
+
+Open `http://<host>:7862/`. When using a reverse proxy, open the URL mapped to
+port `7862`; the browser derives its WebSocket endpoint relative to that URL.
+
+If the page proxy serves HTTP but does not forward WebSocket upgrades, point the
+browser at a separately exposed Realtime endpoint:
+
+```bash
+python -m examples.online_serving.minicpmo.realtime_web \
+    --port 7862 \
+    --ws-backend ws://127.0.0.1:8099 \
+    --public-realtime-url wss://public.example/v1/realtime
+```
+
+## Validate soft-interrupt behavior
+
+The soft-interrupt E2E driver defaults to `--validation-mode model-policy`,
+which checks lifecycle and streaming invariants for arbitrary input audio. The
+stronger `response-required` mode is diagnostic: it requires a purpose-built
+two-response WAV, its `--input-sha256`, and an
+`--expect-second-response-substring` value.
+
+## Related examples
+
+- [Offline MiniCPM-o inference](../../offline_inference/minicpmo/)
+- [MiniCPM-o 4.5 recipe](../../../recipes/OpenBMB/MiniCPM-o-4_5.md)
+
+## Pipeline notes
+
+- Stage 1 performs request-owned AR continuous batching. Stage 2 keeps
+  request-owned Flow/HiFT caches and batches exact-shape-compatible chunks.
+- Reference audio travels with the first codec chunk; Stage 2 owns its
+  temporary prompt WAV and evicts prompt features when the request finishes.
+- Codec sampling reads the checkpoint `tts_config` (default deterministic
+  seed 42). Stage-1 YAML sampling parameters govern only the binary
+  continue/stop token exposed to vLLM.
+- `StageRequestStats.batch_size` is request-scoped and does not report the
+  scheduler's execution batch.
+- Stage 0 and Stage 1 use vLLM CUDA Graph capture. Stage 2 remains eager until
+  a dedicated exact-shape graph wrapper owns static I/O buffers and copies
+  request cache state outside capture.
+- Co-locating all three stages minimizes hardware requirements but makes their
+  CUDA contexts contend for one GPU. Use the 8x4090 layout or a custom
+  multi-GPU deploy config when throughput is the primary goal.
+- Output audio is base64 WAV in `message.audio.data` (24 kHz mono).
+- Offline counterpart:
+  [`examples/offline_inference/minicpmo/`](../../offline_inference/minicpmo/)
+- Recipe:
+  [`recipes/OpenBMB/MiniCPM-o-4_5.md`](../../../recipes/OpenBMB/MiniCPM-o-4_5.md)
diff --git a/examples/online_serving/minicpmo/openai_chat_completion_client_for_multimodal_generation.py b/examples/online_serving/minicpmo/openai_chat_completion_client_for_multimodal_generation.py
new file mode 100644
index 000000000..45afe7e5d
--- /dev/null
+++ b/examples/online_serving/minicpmo/openai_chat_completion_client_for_multimodal_generation.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""OpenAI chat-completions client for MiniCPM-o 4.5 online serving.
+
+Thin wrapper around the shared multimodal client helpers, with MiniCPM-specific
+defaults (port 8099, system prompt, ``chat_template_kwargs.use_tts_template``).
+"""
+
+from __future__ import annotations
+
+import base64
+import concurrent.futures
+import os
+import sys
+
+from openai import OpenAI
+
+from vllm_omni.utils.tracking_parser import TrackingArgumentParser
+
+# Reuse prompt builders / URL helpers from the shared online client.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_ONLINE_ROOT = os.path.abspath(os.path.join(_HERE, ".."))
+if _ONLINE_ROOT not in sys.path:
+    sys.path.insert(0, _ONLINE_ROOT)
+
+from openai_chat_completion_client_for_multimodal_generation import (  # noqa: E402
+    _build_prompt_for_query_type,
+    _parse_csv_arg,
+    make_audio_output_filename,
+    query_map,
+)
+
+SEED = 42
+
+default_system = (
+    "You are MiniCPM-o, a helpful multimodal assistant that can "
+    "understand images, audio and video, and respond in text and speech."
+)
+
+
+def get_system_prompt() -> dict:
+    return {
+        "role": "system",
+        "content": [{"type": "text", "text": default_system}],
+    }
+
+
+def _wants_tts(modalities: list[str] | None) -> bool:
+    if modalities is None:
+        return True
+    return "audio" in modalities
+
+
+def run_multimodal_generation(args, client: OpenAI) -> None:
+    model_name = args.model
+    video_path = getattr(args, "video_path", None)
+    image_path = getattr(args, "image_path", None)
+    audio_path = getattr(args, "audio_path", None)
+    custom_prompt = getattr(args, "prompt", None)
+
+    if args.modalities is not None:
+        output_modalities = args.modalities.split(",")
+    else:
+        output_modalities = None
+
+    use_tts = _wants_tts(output_modalities)
+    num_concurrent_requests = args.num_concurrent_requests
+    prompt_list = _parse_csv_arg(getattr(args, "prompts", None))
+
+    request_payloads = []
+    for idx in range(num_concurrent_requests):
+        per_req_prompt = (
+            prompt_list[idx]
+            if idx < len(prompt_list)
+            else (custom_prompt if idx == 0 or not prompt_list else prompt_list[-1])
+        )
+        prompt = _build_prompt_for_query_type(
+            query_type=args.query_type,
+            custom_prompt=per_req_prompt,
+            video_path=video_path,
+            image_path=image_path,
+            audio_path=audio_path,
+        )
+        extra_body: dict = {
+            "chat_template_kwargs": {"use_tts_template": use_tts},
+        }
+        if args.query_type == "use_audio_in_video":
+            # MiniCPM-o 4.5 does not use Qwen's use_audio_in_video path; keep
+            # the flag only if the shared query type is selected explicitly.
+            extra_body["mm_processor_kwargs"] = {"use_audio_in_video": True}
+        request_payloads.append({"prompt": prompt, "extra_body": extra_body})
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=num_concurrent_requests) as executor:
+        futures = [
+            executor.submit(
+                client.chat.completions.create,
+                messages=[
+                    get_system_prompt(),
+                    payload["prompt"],
+                ],
+                model=model_name,
+                modalities=output_modalities,
+                extra_body=payload["extra_body"],
+                stream=args.stream,
+            )
+            for payload in request_payloads
+        ]
+        chat_completions = [future.result() for future in concurrent.futures.as_completed(futures)]
+
+    assert len(chat_completions) == num_concurrent_requests
+    count = 0
+    if not args.stream:
+        for chat_completion in chat_completions:
+            request_id = getattr(chat_completion, "id", None)
+            for choice in chat_completion.choices:
+                if choice.message.audio:
+                    audio_data = base64.b64decode(choice.message.audio.data)
+                    audio_file_path = make_audio_output_filename(request_id=request_id, index=count)
+                    with open(audio_file_path, "wb") as f:
+                        f.write(audio_data)
+                    print(f"Audio saved to {audio_file_path}")
+                    count += 1
+                elif choice.message.content:
+                    print("Chat completion output from text:", choice.message.content)
+    else:
+        printed_content = False
+        for chat_completion in chat_completions:
+            for chunk in chat_completion:
+                for choice in chunk.choices:
+                    if hasattr(choice, "delta"):
+                        content = getattr(choice.delta, "content", None)
+                    else:
+                        content = None
+
+                    if getattr(chunk, "modality", None) == "audio" and content:
+                        audio_data = base64.b64decode(content)
+                        request_id = getattr(chunk, "id", None)
+                        audio_file_path = make_audio_output_filename(request_id=request_id, index=count)
+                        with open(audio_file_path, "wb") as f:
+                            f.write(audio_data)
+                        print(f"\nAudio saved to {audio_file_path}")
+                        count += 1
+                    elif getattr(chunk, "modality", None) == "text":
+                        if not printed_content:
+                            printed_content = True
+                            print("\ncontent:", end="", flush=True)
+                        print(content, end="", flush=True)
+
+
+def parse_args():
+    parser = TrackingArgumentParser(description="MiniCPM-o 4.5 online multimodal chat client")
+    parser.add_argument(
+        "--query-type",
+        "-q",
+        type=str,
+        default="text",
+        choices=query_map.keys(),
+        help="Query type.",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default="openbmb/MiniCPM-o-4_5",
+        help="Model Name / Path",
+    )
+    parser.add_argument(
+        "--video-path",
+        "-v",
+        type=str,
+        default=None,
+        help="Path to local video file or URL.",
+    )
+    parser.add_argument(
+        "--image-path",
+        "-i",
+        type=str,
+        default=None,
+        help="Path to local image file or URL.",
+    )
+    parser.add_argument(
+        "--audio-path",
+        "-a",
+        type=str,
+        default=None,
+        help="Path to local audio file or URL.",
+    )
+    parser.add_argument(
+        "--prompt",
+        "-p",
+        type=str,
+        default=None,
+        help="Custom text prompt/question.",
+    )
+    parser.add_argument(
+        "--modalities",
+        type=str,
+        default=None,
+        help="Output modalities, e.g. text or text,audio.",
+    )
+    parser.add_argument(
+        "--stream",
+        action="store_true",
+        help="Stream the response.",
+    )
+    parser.add_argument(
+        "--num-concurrent-requests",
+        type=int,
+        default=1,
+        help="Number of concurrent requests to send.",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8099,
+        help="Port of the vLLM Omni API server.",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="localhost",
+        help="Host/IP of the vLLM Omni API server.",
+    )
+    parser.add_argument(
+        "--prompts",
+        type=str,
+        default=None,
+        help="Comma-separated prompts for concurrent requests.",
+    )
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    openai_api_base = f"http://{args.host}:{args.port}/v1"
+    client = OpenAI(api_key="EMPTY", base_url=openai_api_base)
+    run_multimodal_generation(args, client)
diff --git a/examples/online_serving/minicpmo/realtime_duplex_demo.py b/examples/online_serving/minicpmo/realtime_duplex_demo.py
new file mode 100644
index 000000000..fcb7042a0
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_duplex_demo.py
@@ -0,0 +1,399 @@
+"""Minimal single-input MiniCPM-o 4.5 Realtime duplex demo.
+
+Run this after starting the duplex server. Strict lifecycle, overlap, and
+multi-session validation lives under ``tests/e2e/online_serving``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import json
+import sys
+import time
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
+    PCM16_BYTES_PER_SAMPLE,
+    PCM16_SAMPLE_RATE,
+    RealtimeDuplexClient,
+    RealtimeEventCollector,
+    build_realtime_url,
+    read_pcm16_wav,
+    wait_for,
+    write_pcm16_wav,
+)
+
+
+class _StreamingOutputWriter:
+    """Persist and report output deltas as the client receives them."""
+
+    def __init__(self, output_dir: Path) -> None:
+        self.output_dir = output_dir
+        self.audio_chunk_dir = output_dir / "audio_chunks"
+        self.audio_chunk_paths: list[Path] = []
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.audio_chunk_dir.mkdir(parents=True, exist_ok=True)
+        (self.output_dir / "output.pcm").write_bytes(b"")
+
+    def handle(self, event: dict[str, object]) -> None:
+        event_type = event.get("type")
+        if event_type in {
+            "response.audio_transcript.delta",
+            "response.output_text.delta",
+        }:
+            delta = event.get("delta")
+            if isinstance(delta, str) and delta:
+                print(delta, end="", file=sys.stderr, flush=True)
+            return
+        if event_type != "response.audio.delta":
+            return
+
+        delta = event.get("delta") or event.get("audio")
+        if not isinstance(delta, str) or not delta:
+            return
+        try:
+            pcm16 = base64.b64decode(delta)
+        except ValueError:
+            return
+        if not pcm16:
+            return
+
+        chunk_index = len(self.audio_chunk_paths) + 1
+        chunk_path = self.audio_chunk_dir / f"chunk_{chunk_index:04d}.wav"
+        sample_rate_hz = event.get("sample_rate_hz")
+        if not isinstance(sample_rate_hz, int) or sample_rate_hz <= 0:
+            sample_rate_hz = 24_000
+        with (self.output_dir / "output.pcm").open("ab") as output_pcm:
+            output_pcm.write(pcm16)
+        write_pcm16_wav(chunk_path, pcm16, sample_rate_hz=sample_rate_hz)
+        self.audio_chunk_paths.append(chunk_path)
+        print(
+            f"\n[audio chunk {chunk_index}: {len(pcm16)} bytes -> {chunk_path}]",
+            file=sys.stderr,
+            flush=True,
+        )
+
+
+class _StreamingEventCollector(RealtimeEventCollector):
+    def __init__(self, writer: _StreamingOutputWriter) -> None:
+        super().__init__()
+        self._writer = writer
+
+    def add(self, event: dict[str, object], *, received_at_s: float | None = None) -> None:
+        super().add(event, received_at_s=received_at_s)
+        self._writer.handle(self.events[-1])
+
+
+def _input_committed_index(
+    events: list[dict[str, object]],
+    after_index: int,
+) -> int | None:
+    for index, event in enumerate(events[max(after_index, 0) :], start=max(after_index, 0)):
+        if event.get("type") == "input_audio_buffer.committed":
+            return index
+    return None
+
+
+def _post_commit_model_decision(
+    events: list[dict[str, object]],
+    committed_index: int | None,
+) -> str | None:
+    if committed_index is None:
+        return None
+    for event in events[committed_index + 1 :]:
+        event_type = event.get("type")
+        if event_type == "response.listen":
+            return "listen"
+        if event_type == "response.done":
+            response = event.get("response")
+            if not isinstance(response, dict) or response.get("status") != "cancelled":
+                return "speak"
+    return None
+
+
+def _latest_model_decision(
+    events: list[dict[str, object]],
+    after_index: int,
+) -> str | None:
+    decision: str | None = None
+    for event in events[max(after_index, 0) :]:
+        event_type = event.get("type")
+        if event_type == "response.listen":
+            decision = "listen"
+        elif event_type == "response.done":
+            response = event.get("response")
+            if not isinstance(response, dict) or response.get("status") != "cancelled":
+                decision = "speak"
+    return decision
+
+
+def _chunk_period_ms(events: list[dict[str, object]]) -> int:
+    for event in reversed(events):
+        session = event.get("session")
+        if not isinstance(session, dict):
+            continue
+        capabilities = session.get("capabilities")
+        if not isinstance(capabilities, dict):
+            continue
+        chunk_period_ms = capabilities.get("chunk_period_ms")
+        if isinstance(chunk_period_ms, int) and chunk_period_ms > 0:
+            return chunk_period_ms
+    return 1000
+
+
+def _has_residual_model_unit(pcm16: bytes, *, chunk_period_ms: int) -> bool:
+    unit_bytes = PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * chunk_period_ms // 1000
+    return bool(unit_bytes > 0 and len(pcm16) % unit_bytes)
+
+
+def _response_in_progress(events: list[dict[str, object]]) -> bool:
+    return sum(event.get("type") == "response.created" for event in events) > sum(
+        event.get("type") == "response.done" for event in events
+    )
+
+
+def _event_count_after(
+    events: list[dict[str, object]],
+    event_type: str,
+    index: int | None,
+) -> int:
+    if index is None:
+        return 0
+    return sum(event.get("type") == event_type for event in events[index + 1 :])
+
+
+def _ref_audio_data_url(path: str | None) -> str | None:
+    if path is None:
+        return None
+    ref_path = Path(path).expanduser()
+    return "data:audio/wav;base64," + base64.b64encode(ref_path.read_bytes()).decode("ascii")
+
+
+async def run_demo(args: argparse.Namespace) -> dict[str, object]:
+    input_pcm16 = read_pcm16_wav(Path(args.input_wav))
+    if not input_pcm16:
+        raise ValueError("input WAV has no audio")
+
+    output_dir = Path(args.output_dir)
+    stream_writer = _StreamingOutputWriter(output_dir)
+
+    url = build_realtime_url(
+        args.url,
+        args.model,
+        autostart=False if args.ref_audio else None,
+        session_id=args.session_id,
+    )
+    client = RealtimeDuplexClient(url)
+    client.events = _StreamingEventCollector(stream_writer)
+    async with client:
+        await client.configure(
+            args.model,
+            ref_audio=_ref_audio_data_url(args.ref_audio),
+            session_id=args.session_id,
+            timeout_s=args.timeout_s,
+        )
+        stream_event_cursor = len(client.events.events)
+        await client.stream_pcm16(
+            input_pcm16,
+            chunk_ms=args.chunk_ms,
+            realtime=not args.no_realtime_pacing,
+        )
+        commit_event_cursor = len(client.events.events)
+        stream_decision = _latest_model_decision(client.events.events, stream_event_cursor)
+        input_has_residual_model_unit = _has_residual_model_unit(
+            input_pcm16,
+            chunk_period_ms=_chunk_period_ms(client.events.events),
+        )
+        wait_for_post_commit_decision = False
+        commit_sent_at_s = time.monotonic()
+        await client.commit()
+        wait_error: str | None = None
+        committed_index: int | None = None
+        post_commit_decision: str | None = None
+        try:
+            await wait_for(
+                lambda: _input_committed_index(client.events.events, commit_event_cursor) is not None,
+                timeout_s=args.timeout_s,
+                label="input_audio_buffer.committed",
+            )
+            committed_index = _input_committed_index(client.events.events, commit_event_cursor)
+            stream_decision = _latest_model_decision(client.events.events[: committed_index + 1], stream_event_cursor)
+            wait_for_post_commit_decision = input_has_residual_model_unit or _response_in_progress(
+                client.events.events[: committed_index + 1]
+            )
+            if wait_for_post_commit_decision:
+                await wait_for(
+                    lambda: _post_commit_model_decision(client.events.events, committed_index) is not None,
+                    timeout_s=args.timeout_s,
+                    label="post-commit model decision or response drain",
+                )
+                post_commit_decision = _post_commit_model_decision(client.events.events, committed_index)
+        except TimeoutError as exc:
+            wait_error = str(exc)
+        await client.acknowledge_playback()
+        close_error: str | None = None
+        try:
+            await client.close_session(timeout_s=args.timeout_s)
+        except TimeoutError as exc:
+            close_error = str(exc)
+
+        audio = client.events.audio_bytes()
+        first_text_at_s = client.events.first_received_at(
+            "response.audio_transcript.delta",
+            "response.output_text.delta",
+            after_s=commit_sent_at_s,
+        )
+        first_audio_at_s = client.events.first_received_at(
+            "response.audio.delta",
+            after_s=commit_sent_at_s,
+        )
+        response_created_at_s = client.events.first_received_at(
+            "response.created",
+            after_s=commit_sent_at_s,
+        )
+        response_done_at_s = client.events.first_received_at(
+            "response.done",
+            after_s=commit_sent_at_s,
+        )
+        audio_duration_s = len(audio) / (client.events.output_sample_rate_hz * 2)
+        response_generation_s = (
+            response_done_at_s - response_created_at_s
+            if response_done_at_s is not None and response_created_at_s is not None
+            else None
+        )
+        transcript_deltas = [
+            str(event.get("delta", ""))
+            for event in client.events.events
+            if event.get("type")
+            in {
+                "response.audio_transcript.delta",
+                "response.output_text.delta",
+            }
+        ]
+        response_id = client.events.response_ids[0] if client.events.response_ids else None
+        timing = client.events.timing_summary(
+            after_s=commit_sent_at_s,
+            input_committed_at_s=commit_sent_at_s,
+            response_id=response_id,
+        )
+        errors = client.events.errors()
+        if wait_error:
+            errors.append({"type": "client.timeout", "message": wait_error})
+        if close_error:
+            errors.append({"type": "client.timeout", "message": close_error})
+        model_decision = post_commit_decision or stream_decision
+        (output_dir / "events.jsonl").write_text(
+            "".join(json.dumps(event, ensure_ascii=False) + "\n" for event in client.events.events),
+            encoding="utf-8",
+        )
+        (output_dir / "output.pcm").write_bytes(audio)
+        if audio:
+            write_pcm16_wav(
+                output_dir / "output.wav",
+                audio,
+                sample_rate_hz=client.events.output_sample_rate_hz,
+            )
+
+        result = {
+            "ok": (
+                client.events.count("session.created") > 0
+                and client.events.count("session.closed") > 0
+                and not errors
+                and model_decision is not None
+                and (bool(audio) or not args.require_audio)
+            ),
+            "model_decision": model_decision,
+            "post_commit": {
+                "input_committed_event_index": committed_index,
+                "decision": post_commit_decision,
+                "decision_required": wait_for_post_commit_decision,
+                "input_had_residual_model_unit": input_has_residual_model_unit,
+                "response_listen_count": _event_count_after(
+                    client.events.events,
+                    "response.listen",
+                    committed_index,
+                ),
+                "response_done_count": _event_count_after(
+                    client.events.events,
+                    "response.done",
+                    committed_index,
+                ),
+            },
+            "audio_bytes": len(audio),
+            "audio_chunk_count": len(stream_writer.audio_chunk_paths),
+            "audio_chunk_files": [str(path) for path in stream_writer.audio_chunk_paths],
+            "output_sample_rate_hz": client.events.output_sample_rate_hz,
+            "latency": {
+                "ttft_ms": (
+                    round((first_text_at_s - commit_sent_at_s) * 1000, 2) if first_text_at_s is not None else None
+                ),
+                "ttfp_ms": (
+                    round((first_audio_at_s - commit_sent_at_s) * 1000, 2) if first_audio_at_s is not None else None
+                ),
+                "rtf": (
+                    round(response_generation_s / audio_duration_s, 4)
+                    if response_generation_s is not None and audio_duration_s > 0
+                    else None
+                ),
+                "response_generation_ms": (
+                    round(response_generation_s * 1000, 2) if response_generation_s is not None else None
+                ),
+                "text_stream_ms": (
+                    round((response_done_at_s - first_text_at_s) * 1000, 2)
+                    if response_done_at_s is not None and first_text_at_s is not None
+                    else None
+                ),
+                "transcript_delta_count": len(transcript_deltas),
+                "audio_duration_s": round(audio_duration_s, 3),
+                "measurement_origin": "input_audio_buffer.commit send",
+            },
+            "timing": timing,
+            "response_ids": client.events.response_ids,
+            "transcript": "".join(transcript_deltas),
+            "errors": errors,
+            "output_dir": str(output_dir),
+        }
+        (output_dir / "result.json").write_text(
+            json.dumps(result, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+        return result
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://localhost:8099/v1/realtime?duplex=1")
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument("--session-id")
+    parser.add_argument("--input-wav", required=True)
+    parser.add_argument(
+        "--ref-audio",
+        required=True,
+        help=(
+            "Reference WAV for the MiniCPM-o duplex assistant voice. "
+            "This demo matches the official flow by always providing a reference audio clip."
+        ),
+    )
+    parser.add_argument("--output-dir", default="/tmp/minicpmo_realtime_duplex_demo")
+    parser.add_argument("--chunk-ms", type=int, default=200)
+    parser.add_argument("--timeout-s", type=float, default=60.0)
+    parser.add_argument("--no-realtime-pacing", action="store_true")
+    parser.add_argument("--require-audio", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    result = asyncio.run(run_demo(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    if not result["ok"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/minicpmo/realtime_web/__init__.py b/examples/online_serving/minicpmo/realtime_web/__init__.py
new file mode 100644
index 000000000..9a5de5e18
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/__init__.py
@@ -0,0 +1,5 @@
+"""Browser demo for the experimental full-duplex runtime."""
+
+from .server import build_app
+
+__all__ = ["build_app"]
diff --git a/examples/online_serving/minicpmo/realtime_web/__main__.py b/examples/online_serving/minicpmo/realtime_web/__main__.py
new file mode 100644
index 000000000..f5f6e402d
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/__main__.py
@@ -0,0 +1,4 @@
+from .server import main
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/minicpmo/realtime_web/app/index.html b/examples/online_serving/minicpmo/realtime_web/app/index.html
new file mode 100644
index 000000000..46ab15907
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/app/index.html
@@ -0,0 +1,79 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="light">
+    <title>MiniCPM-o 4.5 Voice</title>
+    <link rel="stylesheet" href="static/styles.css">
+  </head>
+  <body>
+    <header class="app-header">
+      <div>
+        <p class="eyebrow">Experimental full-duplex runtime</p>
+        <h1>MiniCPM-o 4.5 Voice</h1>
+      </div>
+      <span id="connectionState" class="status status-offline">Offline</span>
+    </header>
+
+    <main>
+      <section class="call-bar" aria-label="Session controls">
+        <div class="call-actions">
+          <button id="callButton" class="primary" type="button">Start session</button>
+          <button id="muteButton" class="secondary" type="button" disabled>Mute</button>
+          <button id="cameraButton" class="secondary" type="button" disabled>Camera</button>
+          <video id="cameraPreview" muted playsinline style="display:none;width:96px;height:72px;border-radius:8px;object-fit:cover;background:#000"></video>
+        </div>
+        <div style="display:flex;gap:8px;align-items:flex-start;margin-top:8px;width:100%">
+          <label style="display:inline-flex;flex-direction:column;gap:4px;font-size:13px;opacity:.85;white-space:nowrap">
+            Prompt preset
+            <select id="promptPreset" style="font-size:13px;padding:4px 6px;border-radius:6px">
+              <option value="omni" selected>Omni (official omni preset)</option>
+              <option value="chinese_call">中文通话 (official audio preset)</option>
+              <option value="english_call">English Call (official audio preset)</option>
+              <option value="custom">Custom</option>
+            </select>
+          </label>
+          <textarea id="systemPrompt" rows="2" placeholder="System prompt" style="flex:1;font-size:13px;padding:6px 8px;border-radius:6px;resize:vertical">Streaming Omni Conversation.</textarea>
+        </div>
+        <div class="meter" aria-label="Microphone level">
+          <span>Mic</span>
+          <div class="meter-track"><div id="meterFill" class="meter-fill"></div></div>
+        </div>
+        <dl class="runtime-status">
+          <div><dt>Model</dt><dd id="modelState">Idle</dd></div>
+          <div><dt>Playback</dt><dd id="playbackState">Idle</dd></div>
+          <div><dt>Session</dt><dd id="sessionTimer">00:00</dd></div>
+        </dl>
+      </section>
+
+      <section class="conversation-section" aria-labelledby="conversationTitle">
+        <div class="section-heading">
+          <div>
+            <p class="eyebrow">Live transcript</p>
+            <h2 id="conversationTitle">Conversation</h2>
+          </div>
+          <span class="policy-label">Model-controlled listen / speak</span>
+        </div>
+        <div id="conversation" class="conversation" aria-live="polite">
+          <p id="emptyConversation" class="empty-state">Start a session and speak naturally.</p>
+        </div>
+      </section>
+
+      <details class="diagnostics" open>
+        <summary>
+          <span>Event log</span>
+          <span id="eventCount" class="event-count">0 events</span>
+        </summary>
+        <div class="log-toolbar">
+          <span id="runtimeDetail">No active connection</span>
+          <button id="clearLogButton" class="icon-button" type="button" title="Clear event log">Clear</button>
+        </div>
+        <pre id="eventLog" class="event-log" aria-live="polite"></pre>
+      </details>
+    </main>
+
+    <script>window.FULL_DUPLEX_CONFIG = __FULL_DUPLEX_CONFIG__;</script>
+    <script src="static/app.js?v=__FULL_DUPLEX_APP_VERSION__"></script>
+  </body>
+</html>
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/app.js b/examples/online_serving/minicpmo/realtime_web/app/static/app.js
new file mode 100644
index 000000000..e8a3047c6
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/app/static/app.js
@@ -0,0 +1,671 @@
+(() => {
+  'use strict';
+
+  const config = window.FULL_DUPLEX_CONFIG || {};
+  const callButton = document.getElementById('callButton');
+  const muteButton = document.getElementById('muteButton');
+  const cameraButton = document.getElementById('cameraButton');
+  const cameraPreview = document.getElementById('cameraPreview');
+  const promptPreset = document.getElementById('promptPreset');
+  const systemPromptInput = document.getElementById('systemPrompt');
+  const connectionState = document.getElementById('connectionState');
+  const modelState = document.getElementById('modelState');
+  const playbackState = document.getElementById('playbackState');
+  const sessionTimer = document.getElementById('sessionTimer');
+  const meterFill = document.getElementById('meterFill');
+  const conversation = document.getElementById('conversation');
+  const emptyConversation = document.getElementById('emptyConversation');
+  const eventLog = document.getElementById('eventLog');
+  const eventCount = document.getElementById('eventCount');
+  const runtimeDetail = document.getElementById('runtimeDetail');
+  const clearLogButton = document.getElementById('clearLogButton');
+
+  const INPUT_RATE = 16000;
+  const OUTPUT_RATE = 24000;
+  const SEND_INTERVAL_MS = 200;
+  const ECHO_GUARD_MS = 300;
+  const INITIAL_PLAYBACK_BUFFER_MS = 400;
+  const SESSION_CLOSE_TIMEOUT_MS = 1000;
+
+  // Default prompts mirroring the official MiniCPM-o-Demo presets
+  // (assets/presets/{omni,audio_duplex}/*.yaml).
+  const PROMPT_PRESETS = {
+    omni: 'Streaming Omni Conversation.',
+    chinese_call: '扮演一个具有以上声音特征的助手。请认真、高质量地回复用户的问题。'
+      + '请用高自然度的方式和用户聊天。你处于双工模式，可以一边听、一边说。'
+      + '你是由面壁智能开发的人工智能助手：面壁小钢炮。',
+    english_call: 'Replicate the tone and style from the input audio. Your task is to be '
+      + 'a helpful assistant using this voice pattern. Please answer the user\'s questions '
+      + 'seriously and in a high quality. Please chat with the user in a high naturalness '
+      + 'style. You are in duplex mode, where you can listen and speak at the same time.',
+  };
+
+  let socket = null;
+  let mediaStream = null;
+  let captureContext = null;
+  let captureNode = null;
+  let playbackContext = null;
+  let playbackNode = null;
+  let sendTimer = null;
+  let clockTimer = null;
+  let startedAt = 0;
+  let running = false;
+  let muted = false;
+  let assistantActive = false;
+  let captureRate = INPUT_RATE;
+  let cameraStream = null;
+  let cameraTimer = null;
+  let cameraPendingFrame = null;
+  const cameraCanvas = document.createElement('canvas');
+  let playbackRate = OUTPUT_RATE;
+  let pendingCapture = [];
+  let currentResponseId = null;
+  let responseHasAudio = false;
+  let logCount = 0;
+  let liveUserTurn = null;
+  let liveAssistantTurn = null;
+  let sessionCloseResolver = null;
+
+  function staticAssetUrl(path) {
+    const version = String(config.appVersion || '').trim();
+    return version ? `${path}?v=${encodeURIComponent(version)}` : path;
+  }
+
+  if (promptPreset && systemPromptInput) {
+    promptPreset.addEventListener('change', () => {
+      const preset = PROMPT_PRESETS[promptPreset.value];
+      if (preset !== undefined) systemPromptInput.value = preset;
+    });
+    systemPromptInput.addEventListener('input', () => {
+      promptPreset.value = 'custom';
+    });
+  }
+
+  function realtimeUrl() {
+    const url = new URL(config.realtimePath, window.location.href);
+    url.protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    url.searchParams.set('duplex', '1');
+    url.searchParams.set('model', config.model || 'openbmb/MiniCPM-o-4_5');
+    url.searchParams.set('minicpmo45_native_duplex', '1');
+    url.searchParams.set('autostart', '0');
+    return url.toString();
+  }
+
+  function setConnection(label, kind) {
+    connectionState.textContent = label;
+    connectionState.className = `status status-${kind}`;
+  }
+
+  function setModel(label) {
+    modelState.textContent = label;
+  }
+
+  function setPlayback(label) {
+    playbackState.textContent = label;
+  }
+
+  function compactEvent(event) {
+    const fields = [];
+    const payload = event.event || event;
+    const responseId = responseIdOf(event);
+    if (responseId) fields.push(`response=${responseId}`);
+    if (event.item_id) fields.push(`item=${event.item_id}`);
+    if (event.code) fields.push(`code=${event.code}`);
+    if (event.response && event.response.status) fields.push(`status=${event.response.status}`);
+    if (payload.played_ms !== undefined) fields.push(`played=${payload.played_ms}ms`);
+    if (payload.committed_ms !== undefined) fields.push(`committed=${payload.committed_ms}ms`);
+    if (payload.history_committed !== undefined) fields.push(`history=${payload.history_committed}`);
+    return fields.join(' ');
+  }
+
+  function appendLog(message, error = false) {
+    const time = new Date().toLocaleTimeString([], { hour12: false });
+    const line = document.createElement('span');
+    if (error) line.className = 'log-error';
+    line.textContent = `${time}  ${message}\n`;
+    eventLog.appendChild(line);
+    eventLog.scrollTop = eventLog.scrollHeight;
+    logCount += 1;
+    eventCount.textContent = `${logCount} ${logCount === 1 ? 'event' : 'events'}`;
+  }
+
+  function appendEventLog(event) {
+    const detail = compactEvent(event);
+    appendLog(`${event.type || 'unknown'}${detail ? `  ${detail}` : ''}`, event.type === 'error');
+  }
+
+  function responseIdOf(event) {
+    return event.response_id || (event.response && event.response.id) || null;
+  }
+
+  function ensureTurn(role) {
+    const existing = role === 'user' ? liveUserTurn : liveAssistantTurn;
+    if (existing) return existing;
+    if (emptyConversation) emptyConversation.remove();
+    const row = document.createElement('div');
+    row.className = `turn turn-${role} turn-live`;
+    const label = document.createElement('div');
+    label.className = 'turn-role';
+    label.textContent = role === 'user' ? 'You' : 'Assistant';
+    const text = document.createElement('div');
+    text.className = 'turn-text';
+    row.append(label, text);
+    conversation.appendChild(row);
+    conversation.scrollTop = conversation.scrollHeight;
+    const turn = { row, text, value: '' };
+    if (role === 'user') liveUserTurn = turn;
+    else liveAssistantTurn = turn;
+    return turn;
+  }
+
+  function addTranscript(role, delta) {
+    if (!delta) return;
+    const turn = ensureTurn(role);
+    turn.value += delta;
+    turn.text.textContent = turn.value;
+    conversation.scrollTop = conversation.scrollHeight;
+  }
+
+  function finishTranscript(role, finalText = '') {
+    const turn = role === 'user' ? liveUserTurn : liveAssistantTurn;
+    if (!turn && !finalText) return;
+    const current = turn || ensureTurn(role);
+    if (finalText) {
+      current.value = finalText;
+      current.text.textContent = finalText;
+    }
+    current.row.classList.remove('turn-live');
+    if (role === 'user') liveUserTurn = null;
+    else liveAssistantTurn = null;
+  }
+
+  function bytesToBase64(bytes) {
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+    }
+    return btoa(binary);
+  }
+
+  function int16ToBase64(pcm) {
+    return bytesToBase64(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+  }
+
+  function base64ToBytes(encoded) {
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  }
+
+  function resampleInt16(input, sourceRate, targetRate) {
+    if (sourceRate === targetRate) return input;
+    const ratio = sourceRate / targetRate;
+    const output = new Int16Array(Math.floor(input.length / ratio));
+    for (let index = 0; index < output.length; index += 1) {
+      const start = Math.floor(index * ratio);
+      const end = Math.max(start + 1, Math.min(input.length, Math.floor((index + 1) * ratio)));
+      let sum = 0;
+      for (let source = start; source < end; source += 1) sum += input[source];
+      output[index] = sum / (end - start);
+    }
+    return output;
+  }
+
+  async function decodeAudioDelta(event) {
+    const encoded = event.delta || (event.response && event.response.audio);
+    if (!encoded) return null;
+    const bytes = base64ToBytes(encoded);
+    const format = String(event.format || event.audio_format || 'pcm16').toLowerCase();
+    const sourceRate = Number(event.sample_rate_hz || event.sample_rate || OUTPUT_RATE);
+    if (format.includes('f32')) {
+      const floats = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
+      const pcm = new Int16Array(floats.length);
+      for (let index = 0; index < floats.length; index += 1) {
+        const sample = Math.max(-1, Math.min(1, floats[index]));
+        pcm[index] = sample < 0 ? sample * 32768 : sample * 32767;
+      }
+      return { pcm, sourceRate };
+    }
+    if (format.includes('wav')) {
+      const decoded = await playbackContext.decodeAudioData(bytes.buffer.slice(0));
+      const channel = decoded.getChannelData(0);
+      const pcm = new Int16Array(channel.length);
+      for (let index = 0; index < channel.length; index += 1) {
+        const sample = Math.max(-1, Math.min(1, channel[index]));
+        pcm[index] = sample < 0 ? sample * 32768 : sample * 32767;
+      }
+      return { pcm, sourceRate: decoded.sampleRate };
+    }
+    return {
+      pcm: new Int16Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 2)),
+      sourceRate,
+    };
+  }
+
+  function updateMeter(pcm) {
+    let peak = 0;
+    for (let index = 0; index < pcm.length; index += 8) peak = Math.max(peak, Math.abs(pcm[index]));
+    meterFill.style.width = `${Math.min(100, (peak / 32768) * 150).toFixed(0)}%`;
+  }
+
+  function microphoneUploadEnabled() {
+    return running && !muted;
+  }
+
+  function flushCapture() {
+    if (!socket || socket.readyState !== WebSocket.OPEN || pendingCapture.length === 0) return;
+    if (!microphoneUploadEnabled()) {
+      pendingCapture = [];
+      return;
+    }
+    const length = pendingCapture.reduce((total, chunk) => total + chunk.length, 0);
+    const merged = new Int16Array(length);
+    let offset = 0;
+    for (const chunk of pendingCapture) {
+      merged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    pendingCapture = [];
+    const pcm = resampleInt16(merged, captureRate, INPUT_RATE);
+    const appendEvent = {
+      type: 'input_audio_buffer.append',
+      audio: int16ToBase64(pcm),
+      format: 'pcm16',
+      sample_rate_hz: INPUT_RATE,
+    };
+    // Omni duplex: ~1 fps camera frame rides the audio append (official
+    // MiniCPM-o-Demo contract: one base64 JPEG per ~1 s chunk).
+    if (cameraPendingFrame) {
+      appendEvent.video_frames = [cameraPendingFrame];
+      cameraPendingFrame = null;
+    }
+    socket.send(JSON.stringify(appendEvent));
+  }
+
+  function beginAssistant(responseId) {
+    currentResponseId = responseId || currentResponseId;
+    responseHasAudio = false;
+    assistantActive = true;
+    setModel('Speaking');
+  }
+
+  function feedPlayback(decoded, responseId) {
+    if (!decoded || !decoded.pcm || decoded.pcm.length === 0 || !playbackNode) return;
+    const pcm = resampleInt16(decoded.pcm, decoded.sourceRate, playbackRate);
+    responseHasAudio = true;
+    assistantActive = true;
+    setPlayback('Buffering');
+    playbackNode.port.postMessage({
+      type: 'audio',
+      pcm,
+      responseId: responseId || currentResponseId,
+      initialBufferMs: INITIAL_PLAYBACK_BUFFER_MS,
+    }, [pcm.buffer]);
+  }
+
+  function requestPlaybackDrain(responseId) {
+    if (!playbackNode) return;
+    playbackNode.port.postMessage({ type: 'drain', responseId: responseId || currentResponseId });
+  }
+
+  function sendPlaybackAck(responseId, playedMs) {
+    if (!responseId || !socket || socket.readyState !== WebSocket.OPEN || playedMs <= 0) {
+      if (!responseId && playedMs > 0) appendLog('playback ack skipped: missing response id', true);
+      return;
+    }
+    socket.send(JSON.stringify({
+      type: 'playback.ack',
+      response_id: responseId,
+      item_id: `item_${responseId}`,
+      played_ms: playedMs,
+      committed_ms: playedMs,
+    }));
+  }
+
+  function playbackDrained(message) {
+    const responseId = message.responseId || currentResponseId;
+    sendPlaybackAck(responseId, Number(message.playedMs) || 0);
+    setPlayback('Idle');
+    if (message.underrunMs > 0) {
+      appendLog(`playback underrun ${message.underrunMs} ms`);
+    }
+    window.setTimeout(() => {
+      assistantActive = false;
+      currentResponseId = null;
+      responseHasAudio = false;
+      if (running) setModel('Listening');
+    }, ECHO_GUARD_MS);
+  }
+
+  function handleEvent(event) {
+    appendEventLog(event);
+    const responseId = responseIdOf(event);
+    switch (event.type) {
+      case 'session.created':
+      case 'session.updated':
+        setConnection('Connected', 'online');
+        setModel('Listening');
+        break;
+      case 'response.listen':
+        assistantActive = false;
+        setModel('Listening');
+        break;
+      case 'response.created':
+      case 'response.speak':
+        beginAssistant(responseId);
+        break;
+      case 'response.audio.delta':
+        currentResponseId = responseId || currentResponseId;
+        assistantActive = true;
+        setModel('Speaking');
+        decodeAudioDelta(event)
+          .then((decoded) => feedPlayback(decoded, responseId))
+          .catch((error) => appendLog(`audio decode failed: ${error.message || error}`, true));
+        break;
+      case 'response.audio.done':
+        requestPlaybackDrain(responseId);
+        break;
+      case 'response.audio_transcript.delta':
+        addTranscript('assistant', event.delta || '');
+        break;
+      case 'response.audio_transcript.done':
+        finishTranscript('assistant', event.transcript || '');
+        break;
+      case 'conversation.item.input_audio_transcription.delta':
+        addTranscript('user', event.delta || '');
+        break;
+      case 'conversation.item.input_audio_transcription.completed':
+        finishTranscript('user', event.transcript || '');
+        break;
+      case 'response.done':
+        finishTranscript('assistant');
+        if (!responseHasAudio) requestPlaybackDrain(responseId);
+        break;
+      case 'playback.acknowledged':
+        {
+          const acknowledgement = event.event || event;
+          runtimeDetail.textContent = `Playback committed ${acknowledgement.committed_ms || 0} ms`;
+        }
+        break;
+      case 'session.closed':
+        if (sessionCloseResolver) sessionCloseResolver();
+        sessionCloseResolver = null;
+        break;
+      case 'error':
+        setConnection('Error', 'error');
+        runtimeDetail.textContent = String(event.error || event.code || 'Server error');
+        break;
+      default:
+        break;
+    }
+  }
+
+  async function openPlayback() {
+    playbackContext = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: OUTPUT_RATE });
+    playbackRate = playbackContext.sampleRate;
+    await playbackContext.audioWorklet.addModule(staticAssetUrl('static/playback_worklet.js'));
+    playbackNode = new AudioWorkletNode(playbackContext, 'fullduplex-pcm-playback');
+    playbackNode.port.onmessage = (message) => {
+      if (message.data.type === 'playback-started') setPlayback('Playing');
+      else if (message.data.type === 'playback-drained') playbackDrained(message.data);
+      else if (message.data.type === 'playback-underrun') {
+        runtimeDetail.textContent = `Playback underrun ${message.data.underrunMs || 0} ms`;
+      }
+    };
+    playbackNode.connect(playbackContext.destination);
+    await playbackContext.resume();
+  }
+
+  async function openCapture() {
+    mediaStream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        channelCount: 1,
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+        sampleRate: { ideal: INPUT_RATE },
+      },
+    });
+    try {
+      captureContext = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: INPUT_RATE });
+    } catch (_error) {
+      captureContext = new (window.AudioContext || window.webkitAudioContext)();
+    }
+    captureRate = captureContext.sampleRate;
+    await captureContext.audioWorklet.addModule(staticAssetUrl('static/pcm_worklet.js'));
+    const source = captureContext.createMediaStreamSource(mediaStream);
+    captureNode = new AudioWorkletNode(captureContext, 'fullduplex-pcm-capture');
+    captureNode.port.onmessage = (message) => {
+      const pcm = new Int16Array(message.data);
+      updateMeter(pcm);
+      if (microphoneUploadEnabled()) pendingCapture.push(pcm);
+    };
+    const silentSink = captureContext.createGain();
+    silentSink.gain.value = 0;
+    source.connect(captureNode);
+    captureNode.connect(silentSink).connect(captureContext.destination);
+    await captureContext.resume();
+  }
+
+  function openSocket() {
+    return new Promise((resolve, reject) => {
+      const url = realtimeUrl();
+      socket = new WebSocket(url);
+      let settled = false;
+      socket.onopen = () => {
+        settled = true;
+        const extraBody = {
+          auto_response: true,
+          minicpmo45_native_duplex: true,
+        };
+        const session = {
+          modalities: ['audio', 'text'],
+          voice: 'default',
+          extra_body: extraBody,
+        };
+        // Reference voice for TTS cloning, provided by the server via
+        // --ref-audio (mirrors the official demo's default ref audio).
+        if (config.refAudio) session.ref_audio = config.refAudio;
+        const instructions = systemPromptInput ? systemPromptInput.value.trim() : '';
+        if (instructions) session.instructions = instructions;
+        socket.send(JSON.stringify({ type: 'session.update', session }));
+        runtimeDetail.textContent = `${captureRate} Hz capture / ${playbackRate} Hz playback`;
+        appendLog(`websocket open  ${url}`);
+        resolve();
+      };
+      socket.onmessage = (message) => {
+        if (typeof message.data !== 'string') return;
+        try {
+          handleEvent(JSON.parse(message.data));
+        } catch (error) {
+          appendLog(`invalid server event: ${error.message || error}`, true);
+        }
+      };
+      socket.onerror = () => {
+        if (!settled) {
+          settled = true;
+          reject(new Error(`WebSocket connection failed: ${url}`));
+        }
+      };
+      socket.onclose = (event) => {
+        appendLog(`websocket closed  code=${event.code}`);
+        if (running) {
+          setConnection('Disconnected', 'error');
+          stopSession();
+        }
+      };
+    });
+  }
+
+  function formatElapsed(seconds) {
+    const minutes = Math.floor(seconds / 60);
+    return `${String(minutes).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`;
+  }
+
+  function startClock() {
+    startedAt = Date.now();
+    clockTimer = window.setInterval(() => {
+      sessionTimer.textContent = formatElapsed(Math.floor((Date.now() - startedAt) / 1000));
+    }, 1000);
+  }
+
+  async function startSession() {
+    if (running) return;
+    callButton.disabled = true;
+    setConnection('Connecting', 'connecting');
+    runtimeDetail.textContent = 'Requesting microphone access';
+    try {
+      await openPlayback();
+      await openCapture();
+      await openSocket();
+      running = true;
+      muted = false;
+      assistantActive = false;
+      sendTimer = window.setInterval(flushCapture, SEND_INTERVAL_MS);
+      startClock();
+      callButton.textContent = 'End session';
+      callButton.classList.add('is-active');
+      muteButton.disabled = false;
+      cameraButton.disabled = false;
+      setConnection('Connected', 'online');
+      setModel('Listening');
+      appendLog('session started');
+    } catch (error) {
+      appendLog(`start failed: ${error.message || error}`, true);
+      setConnection('Error', 'error');
+      runtimeDetail.textContent = String(error.message || error);
+      await stopSession();
+    } finally {
+      callButton.disabled = false;
+    }
+  }
+
+  async function startCamera() {
+    if (cameraStream) return;
+    cameraStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: false });
+    cameraPreview.srcObject = cameraStream;
+    cameraPreview.style.display = '';
+    await cameraPreview.play().catch(() => {});
+    // Official omni-duplex cadence: one JPEG (quality 0.7) per ~1 s chunk,
+    // no client-side resize (the server normalizes at scale_resolution=448).
+    cameraTimer = window.setInterval(() => {
+      if (!cameraStream || cameraPreview.videoWidth === 0) return;
+      cameraCanvas.width = cameraPreview.videoWidth;
+      cameraCanvas.height = cameraPreview.videoHeight;
+      cameraCanvas.getContext('2d').drawImage(cameraPreview, 0, 0);
+      cameraPendingFrame = cameraCanvas.toDataURL('image/jpeg', 0.7).split(',')[1];
+    }, 1000);
+    cameraButton.textContent = 'Camera off';
+    cameraButton.classList.add('is-active');
+    appendLog('camera on (1 fps omni frames)');
+  }
+
+  function stopCamera() {
+    if (cameraTimer !== null) clearInterval(cameraTimer);
+    cameraTimer = null;
+    if (cameraStream) {
+      for (const track of cameraStream.getTracks()) track.stop();
+    }
+    cameraStream = null;
+    cameraPendingFrame = null;
+    cameraPreview.srcObject = null;
+    cameraPreview.style.display = 'none';
+    cameraButton.textContent = 'Camera';
+    cameraButton.classList.remove('is-active');
+  }
+
+  cameraButton.addEventListener('click', () => {
+    if (cameraStream) {
+      stopCamera();
+      appendLog('camera off');
+      return;
+    }
+    startCamera().catch((error) => appendLog(`camera failed: ${error.message || error}`, true));
+  });
+
+  function waitForSessionClosed(targetSocket, timeoutMs) {
+    if (!targetSocket || targetSocket.readyState !== WebSocket.OPEN) return Promise.resolve();
+    return new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        if (sessionCloseResolver === finish) sessionCloseResolver = null;
+        resolve();
+      };
+      sessionCloseResolver = finish;
+      window.setTimeout(finish, timeoutMs);
+    });
+  }
+
+  async function stopSession({ terminal = true } = {}) {
+    running = false;
+    assistantActive = false;
+    pendingCapture = [];
+    if (sendTimer !== null) clearInterval(sendTimer);
+    if (clockTimer !== null) clearInterval(clockTimer);
+    sendTimer = null;
+    clockTimer = null;
+    if (socket) {
+      const closingSocket = socket;
+      socket = null;
+      closingSocket.onclose = null;
+      if (terminal && closingSocket.readyState === WebSocket.OPEN) {
+        const closed = waitForSessionClosed(closingSocket, SESSION_CLOSE_TIMEOUT_MS);
+        closingSocket.send(JSON.stringify({ type: 'session.close' }));
+        await closed;
+      }
+      closingSocket.close(1000, 'client stop');
+    }
+    if (playbackNode) playbackNode.port.postMessage({ type: 'clear' });
+    if (mediaStream) {
+      for (const track of mediaStream.getTracks()) track.stop();
+    }
+    mediaStream = null;
+    stopCamera();
+    cameraButton.disabled = true;
+    if (captureContext) await captureContext.close().catch(() => {});
+    if (playbackContext) await playbackContext.close().catch(() => {});
+    captureContext = null;
+    captureNode = null;
+    playbackContext = null;
+    playbackNode = null;
+    currentResponseId = null;
+    responseHasAudio = false;
+    meterFill.style.width = '0%';
+    sessionTimer.textContent = '00:00';
+    callButton.textContent = 'Start session';
+    callButton.classList.remove('is-active');
+    muteButton.textContent = 'Mute';
+    muteButton.classList.remove('is-active');
+    muteButton.disabled = true;
+    setConnection('Offline', 'offline');
+    setModel('Idle');
+    setPlayback('Idle');
+    if (runtimeDetail.textContent.startsWith('Playback committed')) return;
+    if (!runtimeDetail.textContent.startsWith('start failed')) runtimeDetail.textContent = 'No active connection';
+  }
+
+  function toggleMute() {
+    if (!running) return;
+    muted = !muted;
+    pendingCapture = [];
+    muteButton.textContent = muted ? 'Unmute' : 'Mute';
+    muteButton.classList.toggle('is-active', muted);
+    appendLog(muted ? 'microphone muted' : 'microphone unmuted');
+  }
+
+  callButton.addEventListener('click', () => {
+    if (running) stopSession();
+    else startSession();
+  });
+  muteButton.addEventListener('click', toggleMute);
+  clearLogButton.addEventListener('click', () => {
+    eventLog.textContent = '';
+    logCount = 0;
+    eventCount.textContent = '0 events';
+  });
+  window.addEventListener('beforeunload', () => { stopSession({ terminal: false }); });
+})();
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/pcm_worklet.js b/examples/online_serving/minicpmo/realtime_web/app/static/pcm_worklet.js
new file mode 100644
index 000000000..608ac6b01
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/app/static/pcm_worklet.js
@@ -0,0 +1,15 @@
+class FullDuplexPcmCapture extends AudioWorkletProcessor {
+  process(inputs) {
+    const channel = inputs[0] && inputs[0][0];
+    if (!channel || channel.length === 0) return true;
+    const pcm = new Int16Array(channel.length);
+    for (let index = 0; index < channel.length; index += 1) {
+      const sample = Math.max(-1, Math.min(1, channel[index]));
+      pcm[index] = sample < 0 ? sample * 32768 : sample * 32767;
+    }
+    this.port.postMessage(pcm.buffer, [pcm.buffer]);
+    return true;
+  }
+}
+
+registerProcessor('fullduplex-pcm-capture', FullDuplexPcmCapture);
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js b/examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js
new file mode 100644
index 000000000..f0d3d42ae
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/app/static/playback_worklet.js
@@ -0,0 +1,168 @@
+class FullDuplexPcmPlayback extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.queue = [];
+    this.offset = 0;
+    this.playedFrames = 0;
+    this.underrunFrames = 0;
+    this.drain = null;
+    this.terminalFadeFrames = 0;
+    this.started = false;
+    this.activeResponseId = null;
+    this.initialBufferFrames = Math.round(sampleRate * 0.2);
+    this.bufferWaitFrames = this.initialBufferFrames;
+    this.rebuffering = false;
+    this.fadeFrames = Math.max(1, Math.round(sampleRate * 0.005));
+    this.fadeInFrames = 0;
+    this.port.onmessage = (event) => this.handleMessage(event.data || {});
+  }
+
+  handleMessage(message) {
+    if (message.type === 'audio' && message.pcm) {
+      const wasEmpty = this.queue.length === 0;
+      if (!this.started && !this.activeResponseId) {
+        this.activeResponseId = message.responseId || null;
+      }
+      if (!this.started && Number.isFinite(message.initialBufferMs)) {
+        this.initialBufferFrames = Math.max(0, Math.round((sampleRate * message.initialBufferMs) / 1000));
+      }
+      this.queue.push(message.pcm);
+      if (!this.started && wasEmpty && !this.rebuffering) {
+        this.bufferWaitFrames = this.initialBufferFrames;
+      }
+    } else if (message.type === 'drain') {
+      this.drain = { responseId: message.responseId || null };
+      this.terminalFadeFrames = Math.min(this.fadeFrames, this.bufferedFrames());
+      if (!this.started && this.bufferedFrames() > 0) {
+        this.bufferWaitFrames = 0;
+        this.startPlayback();
+      }
+      this.notifyIfDrained();
+    } else if (message.type === 'clear') {
+      this.queue = [];
+      this.offset = 0;
+      this.playedFrames = 0;
+      this.underrunFrames = 0;
+      this.drain = null;
+      this.terminalFadeFrames = 0;
+      this.started = false;
+      this.activeResponseId = null;
+      this.bufferWaitFrames = this.initialBufferFrames;
+      this.rebuffering = false;
+      this.fadeInFrames = 0;
+    }
+  }
+
+  bufferedFrames() {
+    return this.queue.reduce((total, pcm, index) => (
+      total + pcm.length - (index === 0 ? this.offset : 0)
+    ), 0);
+  }
+
+  startPlayback() {
+    if (this.started) return;
+    this.started = true;
+    this.fadeInFrames = this.fadeFrames;
+    if (this.playedFrames === 0) {
+      this.port.postMessage({ type: 'playback-started', responseId: this.activeResponseId });
+    }
+  }
+
+  notifyIfDrained() {
+    if (!this.drain || this.queue.length > 0) return;
+    this.port.postMessage({
+      type: 'playback-drained',
+      responseId: this.drain.responseId,
+      playedMs: Math.round((this.playedFrames * 1000) / sampleRate),
+      underrunMs: Math.round((this.underrunFrames * 1000) / sampleRate),
+    });
+    this.playedFrames = 0;
+    this.underrunFrames = 0;
+    this.drain = null;
+    this.terminalFadeFrames = 0;
+    this.started = false;
+    this.activeResponseId = null;
+    this.bufferWaitFrames = this.initialBufferFrames;
+    this.rebuffering = false;
+    this.fadeInFrames = 0;
+  }
+
+  reportUnderrun() {
+    this.port.postMessage({
+      type: 'playback-underrun',
+      responseId: this.activeResponseId,
+      underrunMs: Math.round((this.underrunFrames * 1000) / sampleRate),
+    });
+  }
+
+  process(_inputs, outputs) {
+    const output = outputs[0][0];
+    output.fill(0);
+    if (!this.started) {
+      if (this.rebuffering && !this.drain) {
+        this.underrunFrames += output.length;
+        this.reportUnderrun();
+      }
+      if (this.queue.length > 0 && this.bufferWaitFrames > 0) {
+        this.bufferWaitFrames = Math.max(0, this.bufferWaitFrames - output.length);
+        return true;
+      }
+      if (this.queue.length > 0) {
+        this.startPlayback();
+        this.rebuffering = false;
+      }
+    }
+    if (!this.started) {
+      this.notifyIfDrained();
+      return true;
+    }
+    let target = 0;
+    while (target < output.length && this.queue.length > 0) {
+      const pcm = this.queue[0];
+      const count = Math.min(output.length - target, pcm.length - this.offset);
+      const remainingBeforeChunk = this.bufferedFrames();
+      for (let index = 0; index < count; index += 1) {
+        let sample = pcm[this.offset + index] / 32768;
+        if (this.fadeInFrames > 0) {
+          const elapsed = this.fadeFrames - this.fadeInFrames;
+          sample *= elapsed / this.fadeFrames;
+          this.fadeInFrames -= 1;
+        }
+        const remainingFrames = remainingBeforeChunk - index;
+        if (
+          this.drain
+          && this.terminalFadeFrames > 0
+          && remainingFrames <= this.terminalFadeFrames
+        ) {
+          sample *= this.terminalFadeFrames === 1
+            ? 0
+            : (remainingFrames - 1) / (this.terminalFadeFrames - 1);
+        }
+        output[target + index] = sample;
+      }
+      target += count;
+      this.offset += count;
+      this.playedFrames += count;
+      if (this.offset >= pcm.length) {
+        this.queue.shift();
+        this.offset = 0;
+      }
+    }
+    if (target < output.length && !this.drain) {
+      const fadeCount = Math.min(target, this.fadeFrames);
+      for (let index = 0; index < fadeCount; index += 1) {
+        output[target - fadeCount + index] *= (fadeCount - index - 1) / fadeCount;
+      }
+      this.underrunFrames += output.length - target;
+      this.reportUnderrun();
+      this.started = false;
+      this.rebuffering = true;
+      this.bufferWaitFrames = this.initialBufferFrames;
+      this.fadeInFrames = 0;
+    }
+    this.notifyIfDrained();
+    return true;
+  }
+}
+
+registerProcessor('fullduplex-pcm-playback', FullDuplexPcmPlayback);
diff --git a/examples/online_serving/minicpmo/realtime_web/app/static/styles.css b/examples/online_serving/minicpmo/realtime_web/app/static/styles.css
new file mode 100644
index 000000000..9b080176b
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/app/static/styles.css
@@ -0,0 +1,127 @@
+:root {
+  color-scheme: light;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #20252b;
+  background: #f4f6f7;
+  font-synthesis: none;
+}
+
+* { box-sizing: border-box; }
+
+body { margin: 0; min-width: 320px; }
+
+button, summary { font: inherit; }
+
+button:focus-visible, summary:focus-visible {
+  outline: 3px solid rgba(21, 101, 192, .25);
+  outline-offset: 2px;
+}
+
+.app-header {
+  min-height: 104px;
+  padding: 24px clamp(20px, 5vw, 64px);
+  background: #ffffff;
+  border-bottom: 1px solid #d9dee3;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 20px;
+}
+
+h1, h2, p { margin: 0; }
+h1 { font-size: 24px; line-height: 1.2; letter-spacing: 0; }
+h2 { font-size: 18px; line-height: 1.3; letter-spacing: 0; }
+
+.eyebrow {
+  margin-bottom: 5px;
+  color: #68717b;
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: .08em;
+}
+
+main { width: min(1040px, calc(100% - 40px)); margin: 28px auto 48px; }
+
+.status {
+  min-width: 88px;
+  padding: 7px 10px;
+  border: 1px solid;
+  border-radius: 6px;
+  text-align: center;
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.status-offline { color: #616971; background: #f0f2f3; border-color: #cbd1d6; }
+.status-connecting { color: #8a4b00; background: #fff5df; border-color: #e6b76a; }
+.status-online { color: #176a3a; background: #e9f7ef; border-color: #7dc49b; }
+.status-error { color: #a12222; background: #fff0f0; border-color: #df8f8f; }
+
+.call-bar {
+  min-height: 86px;
+  padding: 16px 18px;
+  background: #252b31;
+  color: #ffffff;
+  border-radius: 6px;
+  display: grid;
+  grid-template-columns: auto minmax(150px, 1fr) auto;
+  align-items: center;
+  gap: 24px;
+}
+
+.call-actions { display: flex; gap: 8px; }
+button { border-radius: 5px; border: 1px solid transparent; cursor: pointer; }
+button:disabled { opacity: .46; cursor: default; }
+.primary { padding: 10px 15px; color: #ffffff; background: #16834b; font-weight: 700; }
+.primary.is-active { background: #b43636; }
+.secondary { padding: 10px 13px; color: #ffffff; background: #39414a; border-color: #59636d; }
+.secondary.is-active { color: #2b2525; background: #ffc9c9; border-color: #e58f8f; }
+
+.meter { min-width: 0; display: flex; align-items: center; gap: 10px; color: #c8cfd6; font-size: 12px; }
+.meter-track { height: 8px; flex: 1; overflow: hidden; background: #444d56; border-radius: 4px; }
+.meter-fill { width: 0; height: 100%; background: #54bd7d; transition: width 70ms linear; }
+
+.runtime-status { margin: 0; display: flex; gap: 24px; }
+.runtime-status div { min-width: 68px; }
+.runtime-status dt { color: #9fa8b1; font-size: 10px; text-transform: uppercase; }
+.runtime-status dd { margin: 3px 0 0; font-size: 13px; font-weight: 700; font-variant-numeric: tabular-nums; }
+
+.conversation-section { margin-top: 22px; padding: 22px 0 10px; }
+.section-heading { display: flex; justify-content: space-between; align-items: end; gap: 16px; padding: 0 2px 14px; border-bottom: 1px solid #cfd5da; }
+.policy-label { color: #5e6871; font-size: 12px; }
+.conversation { min-height: 260px; max-height: 440px; overflow-y: auto; padding: 18px 2px; }
+.empty-state { color: #7a838b; font-size: 14px; }
+
+.turn { display: grid; grid-template-columns: 92px minmax(0, 1fr); gap: 12px; padding: 12px 0; border-bottom: 1px solid #e0e4e7; }
+.turn-role { padding-top: 2px; color: #68717b; font-size: 11px; font-weight: 800; text-transform: uppercase; }
+.turn-user .turn-role { color: #1565c0; }
+.turn-assistant .turn-role { color: #a45117; }
+.turn-text { min-width: 0; white-space: pre-wrap; overflow-wrap: anywhere; line-height: 1.55; }
+.turn-live .turn-text::after { content: ""; display: inline-block; width: 6px; height: 14px; margin-left: 4px; background: #9098a0; vertical-align: -2px; animation: blink 1s step-end infinite; }
+@keyframes blink { 50% { opacity: 0; } }
+
+.diagnostics { margin-top: 18px; border-top: 1px solid #bfc6cc; border-bottom: 1px solid #bfc6cc; background: #ffffff; }
+.diagnostics summary { padding: 13px 14px; display: flex; justify-content: space-between; cursor: pointer; font-weight: 700; list-style: none; }
+.diagnostics summary::-webkit-details-marker { display: none; }
+.event-count { color: #6f7880; font-size: 12px; font-weight: 500; }
+.log-toolbar { min-height: 40px; padding: 7px 12px; border-top: 1px solid #e0e4e7; display: flex; align-items: center; justify-content: space-between; gap: 12px; color: #69727a; font-size: 12px; }
+.icon-button { padding: 5px 9px; color: #394149; background: #f4f6f7; border-color: #cdd3d8; }
+.event-log { height: 200px; margin: 0; padding: 12px 14px; overflow: auto; background: #171b1f; color: #d9e0e6; font: 11px/1.55 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; white-space: pre-wrap; }
+.log-error { color: #ff9f9f; }
+
+@media (max-width: 760px) {
+  .app-header { min-height: 88px; padding: 18px 20px; }
+  h1 { font-size: 20px; }
+  main { width: min(100% - 24px, 620px); margin-top: 16px; }
+  .call-bar { grid-template-columns: 1fr; gap: 15px; }
+  .call-actions button { flex: 1; }
+  .runtime-status { justify-content: space-between; gap: 10px; }
+  .section-heading { align-items: start; flex-direction: column; gap: 7px; }
+  .conversation { min-height: 230px; }
+  .turn { grid-template-columns: 72px minmax(0, 1fr); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { animation-duration: .01ms !important; animation-iteration-count: 1 !important; }
+}
diff --git a/examples/online_serving/minicpmo/realtime_web/server.py b/examples/online_serving/minicpmo/realtime_web/server.py
new file mode 100644
index 000000000..ee78fff74
--- /dev/null
+++ b/examples/online_serving/minicpmo/realtime_web/server.py
@@ -0,0 +1,186 @@
+"""Static host and same-origin Realtime proxy for the full-duplex demo."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import contextlib
+import hashlib
+import json
+import logging
+from pathlib import Path
+from urllib.parse import urlencode
+
+import uvicorn
+import websockets
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse, Response
+from fastapi.staticfiles import StaticFiles
+
+logger = logging.getLogger(__name__)
+APP_DIR = Path(__file__).parent / "app"
+STATIC_DIR = APP_DIR / "static"
+
+
+def _join_ws_url(base: str, path: str, query: str) -> str:
+    return base.rstrip("/") + path + (("?" + query) if query else "")
+
+
+async def _pump_client_to_backend(client: WebSocket, backend) -> None:
+    try:
+        while True:
+            message = await client.receive()
+            if message["type"] == "websocket.disconnect":
+                await backend.close()
+                return
+            if message.get("text") is not None:
+                await backend.send(message["text"])
+            elif message.get("bytes") is not None:
+                await backend.send(message["bytes"])
+    except (WebSocketDisconnect, websockets.ConnectionClosed):
+        with contextlib.suppress(Exception):
+            await backend.close()
+
+
+async def _pump_backend_to_client(client: WebSocket, backend) -> None:
+    try:
+        async for message in backend:
+            if isinstance(message, bytes):
+                await client.send_bytes(message)
+            else:
+                await client.send_text(message)
+    except (WebSocketDisconnect, websockets.ConnectionClosed):
+        return
+    except RuntimeError as exc:
+        if "websocket.send" in str(exc) and "websocket.close" in str(exc):
+            return
+        raise
+
+
+def _expected_proxy_close(exc: BaseException) -> bool:
+    if isinstance(exc, (WebSocketDisconnect, websockets.ConnectionClosed, asyncio.CancelledError)):
+        return True
+    return isinstance(exc, RuntimeError) and "websocket.send" in str(exc) and "websocket.close" in str(exc)
+
+
+def build_app(
+    *,
+    ws_backend: str = "ws://127.0.0.1:8099",
+    model: str = "openbmb/MiniCPM-o-4_5",
+    public_realtime_url: str | None = None,
+    ref_audio: str | None = None,
+) -> FastAPI:
+    app = FastAPI(title="Experimental Full-Duplex Web Demo")
+    index_path = APP_DIR / "index.html"
+    app_version_hash = hashlib.sha256()
+    for asset_path in (
+        STATIC_DIR / "app.js",
+        STATIC_DIR / "pcm_worklet.js",
+        STATIC_DIR / "playback_worklet.js",
+    ):
+        app_version_hash.update(asset_path.read_bytes())
+    app_version = app_version_hash.hexdigest()[:12]
+
+    ref_audio_uri: str | None = None
+    if ref_audio:
+        ref_path = Path(ref_audio)
+        if not ref_path.is_file():
+            raise SystemExit(f"--ref-audio not found: {ref_audio}")
+        encoded = base64.b64encode(ref_path.read_bytes()).decode("ascii")
+        ref_audio_uri = f"data:audio/wav;base64,{encoded}"
+
+    @app.get("/", response_class=HTMLResponse)
+    def index() -> HTMLResponse:
+        config = json.dumps(
+            {
+                "model": model,
+                "realtimePath": public_realtime_url or "v1/realtime",
+                "refAudio": ref_audio_uri,
+                "appVersion": app_version,
+            },
+            ensure_ascii=True,
+        )
+        html = (
+            index_path.read_text(encoding="utf-8")
+            .replace("__FULL_DUPLEX_CONFIG__", config)
+            .replace("__FULL_DUPLEX_APP_VERSION__", app_version)
+        )
+        return HTMLResponse(html, headers={"Cache-Control": "no-store"})
+
+    @app.get("/healthz")
+    def healthz() -> Response:
+        return Response(content="ok", media_type="text/plain")
+
+    @app.websocket("/v1/realtime")
+    async def realtime_proxy(websocket: WebSocket) -> None:
+        await websocket.accept()
+        query = urlencode(websocket.query_params.multi_items())
+        backend_url = _join_ws_url(ws_backend, "/v1/realtime", query)
+        logger.info("Proxying Realtime WebSocket to %s", backend_url)
+        try:
+            async with websockets.connect(
+                backend_url,
+                max_size=64 * 1024 * 1024,
+            ) as backend:
+                tasks = {
+                    asyncio.create_task(_pump_client_to_backend(websocket, backend)),
+                    asyncio.create_task(_pump_backend_to_client(websocket, backend)),
+                }
+                done, pending = await asyncio.wait(
+                    tasks,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+                await asyncio.gather(*pending, return_exceptions=True)
+                for result in await asyncio.gather(*done, return_exceptions=True):
+                    if isinstance(result, BaseException) and not _expected_proxy_close(result):
+                        raise result
+        except (WebSocketDisconnect, websockets.ConnectionClosed):
+            return
+        except Exception:
+            logger.exception("Realtime WebSocket proxy failed")
+            with contextlib.suppress(Exception):
+                await websocket.close(code=1011)
+
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    return app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7862)
+    parser.add_argument("--ws-backend", default="ws://127.0.0.1:8099")
+    parser.add_argument(
+        "--public-realtime-url",
+        help="Browser-visible ws:// or wss:// Realtime URL; defaults to the same-origin proxy.",
+    )
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument(
+        "--ref-audio",
+        required=True,
+        help=(
+            "Reference voice wav for TTS voice cloning, e.g. the "
+            "official MiniCPM-o-Demo assets/ref_audio/ref_minicpm_signature.wav"
+        ),
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+    uvicorn.run(
+        build_app(
+            ws_backend=args.ws_backend,
+            model=args.model,
+            public_realtime_url=args.public_realtime_url,
+            ref_audio=args.ref_audio,
+        ),
+        host=args.host,
+        port=args.port,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/minicpmo/run_curl_multimodal_generation.sh b/examples/online_serving/minicpmo/run_curl_multimodal_generation.sh
new file mode 100755
index 000000000..426a2df00
--- /dev/null
+++ b/examples/online_serving/minicpmo/run_curl_multimodal_generation.sh
@@ -0,0 +1,154 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Default query type
+QUERY_TYPE="${1:-text}"
+
+# Default modalities argument (JSON). Use null for server default (text+audio).
+MODALITIES="${2:-null}"
+
+# Validate query type
+if [[ ! "$QUERY_TYPE" =~ ^(text|use_audio|use_image|use_video)$ ]]; then
+    echo "Error: Invalid query type '$QUERY_TYPE'"
+    echo "Usage: $0 [text|use_audio|use_image|use_video] [modalities]"
+    echo "  text: Text query"
+    echo "  use_audio: Audio + text query"
+    echo "  use_image: Image + text query"
+    echo "  use_video: Video + text query"
+    echo "  modalities: JSON list or null (default: null → text+audio)"
+    echo "    examples: '[\"text\"]'  '[\"text\",\"audio\"]'"
+    exit 1
+fi
+
+HOST="${HOST:-localhost}"
+PORT="${PORT:-8099}"
+MODEL="${MODEL:-openbmb/MiniCPM-o-4_5}"
+
+thinker_sampling_params='{
+  "temperature": 0.0,
+  "top_p": 1.0,
+  "top_k": -1,
+  "max_tokens": 2048,
+  "seed": 42,
+  "detokenize": true,
+  "repetition_penalty": 1.1
+}'
+
+talker_sampling_params='{
+  "temperature": 0.0,
+  "top_p": 1.0,
+  "top_k": -1,
+  "max_tokens": 1,
+  "seed": 42,
+  "detokenize": false
+}'
+# Above is optional; defaults live in vllm_omni/deploy/minicpmo_4_5.yaml.
+
+MARY_HAD_LAMB_AUDIO_URL="https://vllm-public-assets.s3.us-west-2.amazonaws.com/multimodal_asset/mary_had_lamb.ogg"
+CHERRY_BLOSSOM_IMAGE_URL="https://vllm-public-assets.s3.us-west-2.amazonaws.com/vision_model_images/cherry_blossom.jpg"
+SAMPLE_VIDEO_URL="https://huggingface.co/datasets/raushan-testing-hf/videos-test/resolve/main/sample_demo_1.mp4"
+
+case "$QUERY_TYPE" in
+  text)
+    user_content='[
+      {
+        "type": "text",
+        "text": "Say hello, then introduce vLLM-Omni in one sentence."
+      }
+    ]'
+    ;;
+  use_audio)
+    user_content='[
+        {
+          "type": "audio_url",
+          "audio_url": {
+            "url": "'"$MARY_HAD_LAMB_AUDIO_URL"'"
+          }
+        },
+        {
+          "type": "text",
+          "text": "What is the content of this audio?"
+        }
+      ]'
+    ;;
+  use_image)
+    user_content='[
+        {
+          "type": "image_url",
+          "image_url": {
+            "url": "'"$CHERRY_BLOSSOM_IMAGE_URL"'"
+          }
+        },
+        {
+          "type": "text",
+          "text": "What is the content of this image?"
+        }
+      ]'
+    ;;
+  use_video)
+    user_content='[
+        {
+          "type": "video_url",
+          "video_url": {
+            "url": "'"$SAMPLE_VIDEO_URL"'"
+          }
+        },
+        {
+          "type": "text",
+          "text": "Why is this video funny?"
+        }
+      ]'
+    ;;
+esac
+
+sampling_params_list='[
+  '"$thinker_sampling_params"',
+  '"$talker_sampling_params"'
+]'
+
+# TTS speech path needs use_tts_template at the request root (curl does not
+# flatten nested extra_body). Skip it when the caller asked for text-only.
+USE_TTS_TEMPLATE=true
+if [[ "$MODALITIES" == '["text"]' || "$MODALITIES" == "['text']" ]]; then
+  USE_TTS_TEMPLATE=false
+fi
+
+echo "Running query type: $QUERY_TYPE (host=$HOST port=$PORT model=$MODEL)"
+echo "modalities=$MODALITIES  use_tts_template=$USE_TTS_TEMPLATE"
+echo ""
+
+request_body=$(cat <<EOF
+{
+  "model": "$MODEL",
+  "sampling_params_list": $sampling_params_list,
+  "modalities": $MODALITIES,
+  "chat_template_kwargs": {"use_tts_template": $USE_TTS_TEMPLATE},
+  "messages": [
+    {
+      "role": "system",
+      "content": [
+        {
+          "type": "text",
+          "text": "You are MiniCPM-o, a helpful multimodal assistant that can understand images, audio and video, and respond in text and speech."
+        }
+      ]
+    },
+    {
+      "role": "user",
+      "content": $user_content
+    }
+  ]
+}
+EOF
+)
+
+output=$(curl -sS --retry 3 --retry-delay 3 --retry-connrefused \
+    -X POST "http://${HOST}:${PORT}/v1/chat/completions" \
+    -H "Content-Type: application/json" \
+    -d "$request_body")
+
+# Text content of the first choice only (audio is base64 WAV and too large to print).
+echo "Output of request: $(echo "$output" | jq -r '.choices[0].message.content // .error // .')"
+# Indicate whether any choice carried audio.
+has_audio=$(echo "$output" | jq '[.choices[]? | select(.message.audio != null)] | length')
+echo "Choices with audio: ${has_audio}"
diff --git a/examples/online_serving/minicpmo/run_gradio_demo.sh b/examples/online_serving/minicpmo/run_gradio_demo.sh
index 22cc9f182..2126e4363 100755
--- a/examples/online_serving/minicpmo/run_gradio_demo.sh
+++ b/examples/online_serving/minicpmo/run_gradio_demo.sh
@@ -3,7 +3,7 @@
 #
 # Prereq:
 #   Start a vllm-omni OpenAI server for MiniCPM-o 4.5 on :8099 (see the
-#   8x4090 stage config under vllm_omni/model_executor/stage_configs).
+#   8x4090 deploy config at vllm_omni/deploy/minicpmo_4_5_8x4090.yaml).
 set -e
 
 HERE="$(cd "$(dirname "$0")" && pwd)"
diff --git a/examples/online_serving/personaplex/README.md b/examples/online_serving/personaplex/README.md
new file mode 100644
index 000000000..cf105dd6c
--- /dev/null
+++ b/examples/online_serving/personaplex/README.md
@@ -0,0 +1,84 @@
+# PersonaPlex full-duplex online serving
+
+Serve [`nvidia/personaplex-7b-v1`](https://huggingface.co/nvidia/personaplex-7b-v1)
+(a Moshi-based full-duplex speech-to-speech model) with the native vLLM-Omni engine.
+
+The server hosts the **official PersonaPlex web client** at `/` (auto-downloaded from
+the model repo) and implements its WebSocket protocol at `/api/chat`, so you talk to the
+model live in the browser — mic in, agent speech + inner-monologue text out.
+
+> Experimental. Requires a GPU and Hugging Face access to the gated repo
+> (`HF_TOKEN` with access to `nvidia/personaplex-7b-v1`).
+
+## Start the server
+
+```bash
+HF_TOKEN=... CUDA_VISIBLE_DEVICES=0 bash run_server.sh
+# or directly:
+HF_TOKEN=... CUDA_VISIBLE_DEVICES=0 python -m \
+    vllm_omni.experimental.fullduplex.personaplex.serving.server --port 8124
+```
+
+## Talk to it
+
+- **Browser (recommended):** open `http://localhost:8124/` and allow the microphone.
+  Use headphones so the agent does not hear itself.
+- **Headless:** stream a 24 kHz mono WAV and save the reply:
+
+  ```bash
+  python duplex_client.py --url ws://localhost:8124/api/chat --input user.wav --out reply.wav
+  ```
+
+## Unified Realtime API
+
+The default `vllm_omni/deploy/personaplex.yaml` also enables main's engine-owned
+full-duplex control plane:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python -m vllm_omni.entrypoints.cli.main serve \
+  /path/to/personaplex-7b-v1 \
+  --omni \
+  --stage-configs-path vllm_omni/deploy/personaplex.yaml
+```
+
+Validate the actual `/v1/realtime?duplex=1` scheduler path with paced 24 kHz
+PCM, two concurrent sessions, overflow admission, per-session slot recycling,
+and non-silent output:
+
+```bash
+python tests/e2e/online_serving/personaplex_realtime_duplex.py \
+  --model /path/to/personaplex-7b-v1 \
+  --input-wav /path/to/speech.wav \
+  --output-dir /tmp/personaplex-realtime-duplex
+```
+
+This is distinct from the standalone `/api/chat` compatibility server above.
+The unified endpoint advertises `supports_barge_in=false`: overlapping speech
+is native model behavior, but destructive output interruption and model-state
+rewind have not been validated for PersonaPlex.
+
+## Protocol (`/api/chat`)
+
+Binary WebSocket messages, first byte is a tag (identical to `moshi.server`):
+
+| Direction | Tag | Payload |
+| --- | --- | --- |
+| server → client | `\x00` | ready handshake (after the system-prompt prefill) |
+| client → server | `\x01` | Opus-encoded mic audio (24 kHz) |
+| server → client | `\x01` | Opus-encoded agent audio |
+| server → client | `\x02` | UTF-8 inner-monologue text |
+
+Connect with query params `text_prompt` (persona) and `voice_prompt` (voice file).
+A raw-PCM endpoint (`/v1/audio/duplex`, JSON `open` + float32 frames) is also available
+for clients that do not want an Opus dependency.
+
+## Notes
+
+- **Run the client near the server.** Real-time 80 ms audio is sensitive to network
+  latency/jitter; over a high-latency remote link playback can stutter regardless of
+  engine speed. On localhost it is smooth.
+- Greedy decoding by default. One conversation per server by default (a second
+  concurrent connection is rejected with WS close 1013 until the first ends);
+  pass `--batch-size N` to host N concurrent conversations on one engine
+  (elastic batching; connections beyond N are rejected until a slot frees).
+- Full runbook: [`recipes/NVIDIA/PersonaPlex.md`](../../../recipes/NVIDIA/PersonaPlex.md).
diff --git a/examples/online_serving/personaplex/duplex_client.py b/examples/online_serving/personaplex/duplex_client.py
new file mode 100644
index 000000000..bb1eaba2b
--- /dev/null
+++ b/examples/online_serving/personaplex/duplex_client.py
@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Headless client for the PersonaPlex duplex server (official Moshi protocol).
+
+Streams a 24 kHz mono WAV to ``/api/chat`` exactly as the browser client does
+(Opus over WebSocket, tags ``\\x00`` ready / ``\\x01`` audio / ``\\x02`` text),
+collects the agent's reply audio + inner-monologue text, and writes a WAV.
+
+The browser UI at ``http://<host>:<port>/`` is the primary demo; this script is
+for headless testing / scripting.
+
+    python duplex_client.py --url ws://localhost:8124/api/chat \
+        --input user.wav --out reply.wav
+
+Deps: ``websockets``, ``sphn``, ``soundfile``, ``numpy``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+
+import numpy as np
+import soundfile as sf
+import sphn
+
+SR = 24000  # PersonaPlex / Mimi codec rate
+
+
+async def converse(url: str, pcm: np.ndarray) -> tuple[np.ndarray, str]:
+    import websockets
+
+    reader = sphn.OpusStreamReader(SR)  # decode agent audio
+    writer = sphn.OpusStreamWriter(SR)  # encode our mic audio
+    text: list[str] = []
+    ready = asyncio.Event()
+    last = {"t": 0.0}
+
+    async with websockets.connect(url, max_size=None) as ws:
+
+        async def receive() -> None:
+            loop = asyncio.get_event_loop()
+            while True:
+                try:
+                    msg = await ws.recv()
+                except Exception:
+                    return
+                if not isinstance(msg, (bytes, bytearray)) or not msg:
+                    continue
+                tag, payload = msg[0], msg[1:]
+                if tag == 0:
+                    ready.set()
+                elif tag == 1:
+                    reader.append_bytes(bytes(payload))
+                    last["t"] = loop.time()
+                elif tag == 2:
+                    text.append(payload.decode("utf8", errors="replace"))
+
+        recv_task = asyncio.create_task(receive())
+        await asyncio.wait_for(ready.wait(), timeout=120)  # waits for system-prompt prefill
+
+        frame = 1920  # 80 ms
+        for i in range(0, len(pcm), frame):
+            chunk = pcm[i : i + frame]
+            if len(chunk) < frame:
+                chunk = np.concatenate([chunk, np.zeros(frame - len(chunk), dtype=np.float32)])
+            writer.append_pcm(chunk)
+            data = writer.read_bytes()
+            if data:
+                await ws.send(b"\x01" + data)
+            await asyncio.sleep(frame / SR)  # pace at real time
+
+        loop = asyncio.get_event_loop()
+        last["t"] = loop.time()
+        while loop.time() - last["t"] < 2.5:  # drain until the agent stops talking
+            await asyncio.sleep(0.1)
+        recv_task.cancel()
+
+    chunks: list[np.ndarray] = []
+    while True:
+        out = reader.read_pcm()
+        if out is None or out.shape[-1] == 0:
+            break
+        chunks.append(np.asarray(out, dtype=np.float32))
+    audio = np.concatenate(chunks) if chunks else np.zeros(0, dtype=np.float32)
+    return audio, "".join(text)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--url", default="ws://localhost:8124/api/chat")
+    ap.add_argument("--input", required=True, help="24 kHz mono WAV of the user turn")
+    ap.add_argument("--out", default="personaplex_reply.wav")
+    ap.add_argument("--tail", type=float, default=10.0, help="trailing silence (s) for the agent reply")
+    ap.add_argument("--persona", default="")
+    ap.add_argument("--voice", default="NATF2.pt")
+    args = ap.parse_args()
+
+    wav, sr = sf.read(args.input, dtype="float32")
+    if wav.ndim > 1:
+        wav = wav.mean(axis=1)
+    if sr != SR:
+        raise SystemExit(f"input must be {SR} Hz mono; got {sr} Hz. Resample it first.")
+    wav = np.concatenate([wav, np.zeros(int(args.tail * SR), dtype=np.float32)])
+
+    url = f"{args.url}?text_prompt={args.persona}&voice_prompt={args.voice}"
+    audio, text = asyncio.run(converse(url, wav))
+    sf.write(args.out, audio if audio.size else np.zeros(SR, dtype=np.float32), SR)
+    print(f"agent reply: {audio.size / SR:.2f}s -> {args.out}")
+    print(f"inner-monologue: {text.strip()!r}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/personaplex/run_server.sh b/examples/online_serving/personaplex/run_server.sh
new file mode 100755
index 000000000..53f6f0886
--- /dev/null
+++ b/examples/online_serving/personaplex/run_server.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+# PersonaPlex full-duplex online serving.
+#
+# Serves the OFFICIAL PersonaPlex web client at / (auto-downloaded from
+# nvidia/personaplex-7b-v1) and the Moshi WebSocket protocol at /api/chat,
+# backed by the native vLLM-Omni engine. Requires HF access to the gated repo.
+
+HOST="${HOST:-0.0.0.0}"
+PORT="${PORT:-8124}"
+
+echo "Starting PersonaPlex duplex server on ${HOST}:${PORT}..."
+echo "Open http://localhost:${PORT}/ for the official web client (run it near the server)."
+
+python -m vllm_omni.experimental.fullduplex.personaplex.serving.server \
+    --host "$HOST" --port "$PORT"
diff --git a/examples/online_serving/qwen2_5_omni/README.md b/examples/online_serving/qwen2_5_omni/README.md
index 48406003d..8d30fd314 100644
--- a/examples/online_serving/qwen2_5_omni/README.md
+++ b/examples/online_serving/qwen2_5_omni/README.md
@@ -12,9 +12,9 @@ Please refer to [README.md](../../../README.md)
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
 ```
 
-If you have custom stage configs file, launch the server with command below
+To use a custom deploy config, launch the server with the command below:
 ```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
+vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
 
 ### Send Multi-modal Request
@@ -173,7 +173,7 @@ The script supports the following arguments:
 - `--model`: Model name/path (default: Qwen/Qwen2.5-Omni-7B)
 - `--server-port`: Port for vLLM server (default: 8091)
 - `--gradio-port`: Port for Gradio demo (default: 7861)
-- `--stage-configs-path`: Path to custom stage configs YAML file (optional)
+- `--deploy-config`: Path to a custom deploy config YAML file (optional)
 - `--server-host`: Host for vLLM server (default: 0.0.0.0)
 - `--gradio-ip`: IP for Gradio demo (default: 127.0.0.1)
 - `--share`: Share Gradio demo publicly (creates a public link)
@@ -186,9 +186,9 @@ The script supports the following arguments:
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
 ```
 
-If you have custom stage configs file:
+To use a custom deploy config:
 ```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
+vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
 
 **Step 2: Run the Gradio demo**
diff --git a/examples/online_serving/qwen2_5_omni/run_gradio_demo.sh b/examples/online_serving/qwen2_5_omni/run_gradio_demo.sh
index 296cc7fa5..da6232ce1 100755
--- a/examples/online_serving/qwen2_5_omni/run_gradio_demo.sh
+++ b/examples/online_serving/qwen2_5_omni/run_gradio_demo.sh
@@ -13,7 +13,7 @@ set -e
 MODEL="Qwen/Qwen2.5-Omni-7B"
 SERVER_PORT=8091
 GRADIO_PORT=7861
-STAGE_CONFIGS_PATH=""
+DEPLOY_CONFIG_PATH=""
 SERVER_HOST="0.0.0.0"
 GRADIO_IP="127.0.0.1"
 GRADIO_SHARE=false
@@ -33,8 +33,8 @@ while [[ $# -gt 0 ]]; do
             GRADIO_PORT="$2"
             shift 2
             ;;
-        --stage-configs-path)
-            STAGE_CONFIGS_PATH="$2"
+        --deploy-config)
+            DEPLOY_CONFIG_PATH="$2"
             shift 2
             ;;
         --server-host)
@@ -56,7 +56,7 @@ while [[ $# -gt 0 ]]; do
             echo "  --model MODEL                 Model name/path (default: Qwen/Qwen2.5-Omni-7B)"
             echo "  --server-port PORT            Port for vLLM server (default: 8091)"
             echo "  --gradio-port PORT            Port for Gradio demo (default: 7861)"
-            echo "  --stage-configs-path PATH     Path to custom stage configs YAML file (optional)"
+            echo "  --deploy-config PATH          Path to custom deploy config YAML file (optional)"
             echo "  --server-host HOST            Host for vLLM server (default: 0.0.0.0)"
             echo "  --gradio-ip IP                IP for Gradio demo (default: 127.0.0.1)"
             echo "  --share                       Share Gradio demo publicly"
@@ -87,8 +87,8 @@ echo "=========================================="
 
 # Build vLLM server command
 SERVER_CMD=("vllm" "serve" "$MODEL" "--omni" "--port" "$SERVER_PORT" "--host" "$SERVER_HOST")
-if [ -n "$STAGE_CONFIGS_PATH" ]; then
-    SERVER_CMD+=("--stage-configs-path" "$STAGE_CONFIGS_PATH")
+if [ -n "$DEPLOY_CONFIG_PATH" ]; then
+    SERVER_CMD+=("--deploy-config" "$DEPLOY_CONFIG_PATH")
 fi
 
 # Function to cleanup on exit
diff --git a/examples/online_serving/qwen3_omni/README.md b/examples/online_serving/qwen3_omni/README.md
index 3c3ad2b16..74a18af32 100644
--- a/examples/online_serving/qwen3_omni/README.md
+++ b/examples/online_serving/qwen3_omni/README.md
@@ -353,13 +353,16 @@ curl http://localhost:8091/v1/chat/completions \
 #### Text + Audio
 
 ```bash
-curl -s http://localhost:8091/v1/chat/completions \
+response=$(curl -s http://localhost:8091/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{
     "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
     "messages": [{"role": "user", "content": "Describe vLLM in brief."}],
-    "modalities": ["audio"]
-  }' | jq -r '.choices[0].message.audio.data' | base64 -d > output.wav
+    "modalities": ["text", "audio"]
+  }')
+
+echo "$response" | jq -r '.choices[0].message.content'
+echo "$response" | jq -r '.choices[1].message.audio.data' | base64 -d > output.wav
 ```
 
 ### Using Python client
@@ -456,8 +459,8 @@ response = client.chat.completions.create(
     modalities=["audio"],
     extra_body={"speaker": "chelsie"}
 )
-# Audio uses the specified speaker
-print(response.choices[1].message.audio)
+# Audio-only responses contain a single audio choice
+print(response.choices[0].message.audio)
 ```
 
 Supported speaker names depend on the model (e.g. `Ethan`, `Chelsie`, `Aiden`). Omit `speaker` to use the default.
diff --git a/examples/online_serving/qwen3_omni/qwen3_omni_moe_thinking.yaml b/examples/online_serving/qwen3_omni/qwen3_omni_moe_thinking.yaml
deleted file mode 100644
index 7ce88f80a..000000000
--- a/examples/online_serving/qwen3_omni/qwen3_omni_moe_thinking.yaml
+++ /dev/null
@@ -1,36 +0,0 @@
-# Stage config for running Qwen3-Omni-MoE-Thinking (text-only output)
-# This config is for models like Qwen3-Omni-30B-A3B-Thinking that only have the
-# thinker component and do not support audio output.
-#
-# Single stage: Thinker (multimodal understanding + text generation)
-
-# The following config has been verified on 2x H100-80G GPUs.
-stage_args:
-  - stage_id: 0
-    runtime:
-      devices: "0,1"
-    engine_args:
-      model_stage: thinker
-      max_num_seqs: 1
-      model_arch: Qwen3OmniMoeForConditionalGeneration
-      worker_type: ar
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      gpu_memory_utilization: 0.9
-      enforce_eager: true
-      trust_remote_code: true
-      engine_output_type: text
-      distributed_executor_backend: "mp"
-      enable_prefix_caching: true
-      hf_config_name: thinker_config
-      tensor_parallel_size: 2
-    final_output: true
-    final_output_type: text
-    is_comprehension: true
-    default_sampling_params:
-      temperature: 0.4
-      top_p: 0.9
-      top_k: 1
-      max_tokens: 2048
-      seed: 42
-      detokenize: True
-      repetition_penalty: 1.05
diff --git a/examples/online_serving/qwen3_omni/run_gradio_demo.sh b/examples/online_serving/qwen3_omni/run_gradio_demo.sh
index 73ce273d9..465304534 100755
--- a/examples/online_serving/qwen3_omni/run_gradio_demo.sh
+++ b/examples/online_serving/qwen3_omni/run_gradio_demo.sh
@@ -13,7 +13,7 @@ set -e
 MODEL="Qwen/Qwen3-Omni-30B-A3B-Instruct"
 SERVER_PORT=8091
 GRADIO_PORT=7861
-STAGE_CONFIGS_PATH=""
+DEPLOY_CONFIG=""
 SERVER_HOST="0.0.0.0"
 GRADIO_IP="127.0.0.1"
 GRADIO_SHARE=false
@@ -33,8 +33,8 @@ while [[ $# -gt 0 ]]; do
             GRADIO_PORT="$2"
             shift 2
             ;;
-        --stage-configs-path)
-            STAGE_CONFIGS_PATH="$2"
+        --deploy-config)
+            DEPLOY_CONFIG="$2"
             shift 2
             ;;
         --server-host)
@@ -56,7 +56,7 @@ while [[ $# -gt 0 ]]; do
             echo "  --model MODEL                 Model name/path (default: Qwen/Qwen3-Omni-30B-A3B-Instruct)"
             echo "  --server-port PORT            Port for vLLM server (default: 8091)"
             echo "  --gradio-port PORT            Port for Gradio demo (default: 7861)"
-            echo "  --stage-configs-path PATH     Path to custom stage configs YAML file (optional)"
+            echo "  --deploy-config PATH          Path to custom deploy config YAML file (optional)"
             echo "  --server-host HOST            Host for vLLM server (default: 0.0.0.0)"
             echo "  --gradio-ip IP                IP for Gradio demo (default: 127.0.0.1)"
             echo "  --share                       Share Gradio demo publicly"
@@ -87,8 +87,8 @@ echo "=========================================="
 
 # Build vLLM server command
 SERVER_CMD=("vllm" "serve" "$MODEL" "--omni" "--port" "$SERVER_PORT" "--host" "$SERVER_HOST")
-if [ -n "$STAGE_CONFIGS_PATH" ]; then
-    SERVER_CMD+=("--stage-configs-path" "$STAGE_CONFIGS_PATH")
+if [ -n "$DEPLOY_CONFIG" ]; then
+    SERVER_CMD+=("--deploy-config" "$DEPLOY_CONFIG")
 fi
 
 # Function to cleanup on exit
diff --git a/examples/online_serving/replica_data_parallel/README.md b/examples/online_serving/replica_data_parallel/README.md
new file mode 100644
index 000000000..a230d71eb
--- /dev/null
+++ b/examples/online_serving/replica_data_parallel/README.md
@@ -0,0 +1,90 @@
+# Replica Data Parallelism for Video Generation
+
+A runnable recipe + benchmark for **replica data parallelism** (replica-DP) on a
+video DiT. Replica-DP runs `N` independent diffusion engine replicas, one per GPU,
+and routes each request to a single replica. It scales **request throughput**
+near-linearly; it does **not** change single-request latency (for that, use an
+intra-request axis such as tensor/sequence/CFG parallelism).
+
+This example uses `Wan-AI/Wan2.2-TI2V-5B-Diffusers` with one GPU per replica.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `wan2_2_ti2v_dp.yaml` | Deploy config; `num_replicas` + `devices` drive the fan-out. |
+| `run_server.sh` | Substitutes `NUM_REPLICAS` / `DEVICES` into the config and serves. |
+| `bench_replica_dp.py` | Replica-agnostic load driver; reports throughput, latency, and a per-input isolation check. |
+
+## Run
+
+Start the server with the replica count you want (one GPU per replica):
+
+```bash
+# baseline
+NUM_REPLICAS=1 DEVICES=0        ./run_server.sh
+# 2 replicas
+NUM_REPLICAS=2 DEVICES=0,1      ./run_server.sh
+# 4 replicas
+NUM_REPLICAS=4 DEVICES=0,1,2,3  ./run_server.sh
+```
+
+In another shell, drive a fixed workload and read the throughput:
+
+```bash
+python bench_replica_dp.py --url http://127.0.0.1:8098 \
+    --num-requests 28 --concurrency 8 --label "replicas=4"
+```
+
+Re-run the server at `NUM_REPLICAS=1,2,4` (same client workload each time) and
+compare `videos/min`. Pass `--baseline-tpm <N=1 value>` to print a scaling factor.
+
+### Isolation check
+
+Identical outputs under a *shared* prompt+seed prove nothing -- every request
+would be identical regardless of isolation. Instead each request gets a distinct
+input (a prompt from the pool + a unique seed `base_seed+i`), and we check that a
+request's output is unchanged whether it runs alone or concurrently amid other
+distinct requests. Capture a per-input baseline on `N=1`, then verify it under
+`N>=2` concurrency:
+
+```bash
+# 1) against NUM_REPLICAS=1 (serial), record each input's output hash
+python bench_replica_dp.py --num-requests 8 --concurrency 1 \
+    --write-baseline baseline.json
+
+# 2) against NUM_REPLICAS>=2, replay the SAME inputs concurrently and verify
+python bench_replica_dp.py --num-requests 8 --concurrency 8 \
+    --check-baseline baseline.json
+```
+
+Step 2 exits non-zero if any request's output differs from its own baseline (a
+mismatch means cross-request state bleed or misrouting). Keep `--num-requests`,
+`--base-seed`, and the prompt source identical between the two runs so the input
+sets match.
+
+## Measured scaling
+
+Wan2.2-TI2V-5B (832×480, 33 frames, 30 steps), 4× A800-80GB (NVLink), one GPU per replica:
+
+| Replicas | Throughput (videos/min) | Scaling | Efficiency |
+|----------|-------------------------|---------|------------|
+| 1 | 4.71 | 1.00× | — |
+| 2 | 9.20 | 1.95× | 98% |
+| 4 | 18.02 | 3.83× | 96% |
+
+Per-request latency stayed flat (~13–14 s) across all replica counts. Isolation
+is checked per-input via the baseline/verify protocol above: each request's
+output under `N>=2` concurrency must match its own single-replica baseline.
+
+## Notes on the config surface
+
+- `runtime.num_replicas: N` fans out `N` replicas; `runtime.devices` assigns their
+  GPUs. With `tensor_parallel_size = 1`, list one GPU per replica
+  (`num_replicas * tensor_parallel_size` entries, pool mode).
+- Replica fan-out here comes from the deploy config, not a CLI flag. (The headless /
+  multi-runtime launch path uses the process-local `--omni-dp-size-local`, which
+  requires `--stage-id`.)
+- This recipe serves via `--deploy-config`. Replica fan-out comes from the deploy
+  config's `num_replicas` / `devices`; stage topology comes from the registered
+  `WanPipeline`.
diff --git a/examples/online_serving/replica_data_parallel/bench_replica_dp.py b/examples/online_serving/replica_data_parallel/bench_replica_dp.py
new file mode 100755
index 000000000..977f475ac
--- /dev/null
+++ b/examples/online_serving/replica_data_parallel/bench_replica_dp.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Throughput-scaling + isolation benchmark for diffusion replica data parallelism.
+
+Sends `--num-requests` text-to-video requests (up to `--concurrency` in flight)
+to a running vLLM-Omni video server via `POST /v1/videos/sync` (blocks until the
+clip is produced) and reports:
+
+    completed / failed, makespan (wall clock), throughput (videos/min),
+    per-request latency p50/p90/max (nearest-rank), and -- when a baseline
+    manifest is supplied -- a per-request isolation check.
+
+Each request gets a *distinct* input (a prompt from the pool + a unique seed),
+so an output is a deterministic function of its own input and nothing else.
+
+Measuring replica scaling
+-------------------------
+This client is replica-agnostic. Vary the *server's* replica count
+(`runtime.num_replicas` in the stage config; see run_server.sh) and keep the
+client workload fixed, then compare throughput:
+
+    N=1 -> baseline
+    N=2 -> expect ~2x
+    N=4 -> expect ~4x   (near-linear is the goal)
+
+Pass the single-replica videos/min via `--baseline-tpm` to print a scaling
+factor for the current run.
+
+Isolation / correctness
+-----------------------
+Byte-identical outputs under a *shared* prompt+seed prove nothing -- every
+request would be identical regardless of isolation. Instead, give each request a
+distinct input and check that its output is unchanged whether it runs alone or
+concurrently amid other distinct requests:
+
+    1. Against an N=1 server, capture a per-input baseline:
+         bench_replica_dp.py --num-requests 8 --concurrency 1 \
+             --write-baseline baseline.json
+    2. Against an N>=2 server, replay the *same* inputs concurrently and verify
+       each output matches its own baseline:
+         bench_replica_dp.py --num-requests 8 --concurrency 8 \
+             --check-baseline baseline.json
+
+A mismatch means a request's output changed under concurrency -- cross-request
+state bleed or misrouting -- and the run exits non-zero.
+
+Requires: requests (`pip install requests`).
+"""
+
+import argparse
+import concurrent.futures as cf
+import hashlib
+import json
+import math
+import sys
+import time
+from pathlib import Path
+
+import requests
+
+# Distinct prompts, cycled across requests; combined with a per-request unique
+# seed this makes every request a distinct input (see input_key()).
+DEFAULT_PROMPTS = [
+    "A cat playing piano, cinematic, high detail",
+    "A drone shot over a snowy mountain range at sunrise",
+    "A red sports car driving through a neon-lit city at night",
+    "Ocean waves crashing on a rocky shore, slow motion",
+    "A hot air balloon floating over green rolling hills",
+    "Timelapse of clouds moving over a desert canyon at dusk",
+    "A steam train crossing a stone viaduct in autumn",
+    "A jellyfish drifting through deep blue water, backlit",
+]
+
+
+def input_key(prompt, seed, args):
+    """Stable identity of a request's input; matches baseline<->verify by content, not order."""
+    return "\x1f".join([prompt, str(seed), args.size, str(args.num_frames), str(args.steps)])
+
+
+def nearest_rank(xs, q):
+    """Nearest-rank percentile; q in [0, 1]. Correct for tiny samples (unlike int(q*n)-1)."""
+    if not xs:
+        return float("nan")
+    s = sorted(xs)
+    rank = max(1, math.ceil(q * len(s)))
+    return s[rank - 1]
+
+
+def one_request(args, spec, idx, save):
+    """Fire one /v1/videos/sync request; return (ok, latency, nbytes, md5, key, err)."""
+    prompt, seed = spec["prompt"], spec["seed"]
+    key = input_key(prompt, seed, args)
+    # multipart form fields match POST /v1/videos/sync in the omni API server
+    form = {
+        "prompt": (None, prompt),
+        "size": (None, args.size),  # e.g. "832x480"
+        "num_frames": (None, str(args.num_frames)),
+        "num_inference_steps": (None, str(args.steps)),
+        "seed": (None, str(seed)),  # per-request unique -> distinct, reproducible input
+    }
+    if args.model:
+        form["model"] = (None, args.model)
+    if args.negative_prompt:
+        form["negative_prompt"] = (None, args.negative_prompt)
+
+    t0 = time.perf_counter()
+    try:
+        r = requests.post(f"{args.url}/v1/videos/sync", files=form, timeout=args.timeout)
+        dt = time.perf_counter() - t0
+        if r.status_code != 200:
+            return (False, dt, 0, "", key, f"HTTP {r.status_code}: {r.text[:160]}")
+        body = r.content
+        md5 = hashlib.md5(body).hexdigest()
+        if save and args.save_dir:
+            Path(args.save_dir).mkdir(parents=True, exist_ok=True)
+            (Path(args.save_dir) / f"req{idx:03d}_seed{seed}.mp4").write_bytes(body)
+        return (True, dt, len(body), md5, key, "")
+    except Exception as e:  # noqa: BLE001 - report any client-side failure
+        return (False, time.perf_counter() - t0, 0, "", key, repr(e))
+
+
+def build_specs(args):
+    """Deterministic list of distinct (prompt, seed) inputs; identical across baseline/verify runs."""
+    prompts = DEFAULT_PROMPTS
+    if args.prompts_file:
+        prompts = [ln.strip() for ln in Path(args.prompts_file).read_text().splitlines() if ln.strip()]
+    return [{"prompt": prompts[i % len(prompts)], "seed": args.base_seed + i} for i in range(args.num_requests)]
+
+
+def run_batch(args, specs, save):
+    """Fire specs concurrently; return (results, makespan). results = list of one_request tuples."""
+    results = []
+    wall0 = time.perf_counter()
+    with cf.ThreadPoolExecutor(max_workers=args.concurrency) as ex:
+        futs = {ex.submit(one_request, args, spec, i, save): i for i, spec in enumerate(specs)}
+        for done, f in enumerate(cf.as_completed(futs), 1):
+            res = f.result()
+            results.append(res)
+            good, dt, nbytes, _md5, _key, err = res
+            print(f"  [{done}/{len(specs)}] {'ok' if good else 'FAIL'} {dt:6.1f}s {(nbytes / 1e6):5.1f}MB {err}")
+    return results, time.perf_counter() - wall0
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Diffusion replica-DP throughput + isolation benchmark")
+    ap.add_argument("--url", default="http://127.0.0.1:8098", help="server base URL (no path)")
+    ap.add_argument("--num-requests", type=int, default=16, help="total requests to send")
+    ap.add_argument("--concurrency", type=int, default=4, help="max in-flight (set >= replica count)")
+    ap.add_argument("--warmup", type=int, default=-1, help="warmup requests before timing (default: =concurrency)")
+    ap.add_argument("--base-seed", type=int, default=42, help="request i uses seed base_seed+i (distinct inputs)")
+    ap.add_argument("--prompts-file", default="", help="optional file, one prompt per line (else a built-in pool)")
+    ap.add_argument("--negative-prompt", default="")
+    ap.add_argument("--size", default="832x480", help="WIDTHxHEIGHT")
+    ap.add_argument("--num-frames", type=int, default=33)
+    ap.add_argument("--steps", type=int, default=30, help="num_inference_steps")
+    ap.add_argument("--model", default="", help="optional; defaults to the served model")
+    ap.add_argument("--timeout", type=float, default=1800, help="per-request timeout (s)")
+    ap.add_argument("--save-dir", default="", help="save returned clips")
+    ap.add_argument("--label", default="", help="run label, e.g. 'replicas=2'")
+    ap.add_argument(
+        "--baseline-tpm", type=float, default=0.0, help="single-replica videos/min, to print a scaling factor"
+    )
+    ap.add_argument("--write-baseline", default="", help="run against N=1: write per-input md5 manifest to this path")
+    ap.add_argument("--check-baseline", default="", help="run against N>=2: verify each output matches this manifest")
+    args = ap.parse_args()
+
+    if args.write_baseline and args.check_baseline:
+        ap.error("--write-baseline and --check-baseline are mutually exclusive")
+
+    specs = build_specs(args)
+    warmup = args.concurrency if args.warmup < 0 else args.warmup
+
+    print(
+        f"-> {args.url}/v1/videos/sync | {args.num_requests} reqs "
+        f"| concurrency {args.concurrency} | warmup {warmup} | {args.size} {args.num_frames}f {args.steps}steps "
+        f"| {args.label}"
+    )
+
+    # Warmup: absorb each replica's first-call compile/init cost so it does not
+    # skew the measured makespan. Results are discarded and never saved.
+    if warmup > 0:
+        print(f"warming up ({warmup} reqs, not timed)...")
+        run_batch(args, [specs[i % len(specs)] for i in range(warmup)], save=False)
+
+    results, makespan = run_batch(args, specs, save=True)
+
+    ok = sum(1 for r in results if r[0])
+    fail = len(results) - ok
+    lat = [r[1] for r in results if r[0]]
+    errs = [r[5] for r in results if not r[0]]
+    got = {r[4]: r[3] for r in results if r[0]}  # input_key -> md5
+
+    print(f"\n===== result {args.label} =====")
+    print(f"completed {ok} / failed {fail} | makespan {makespan:.1f}s")
+    if ok:
+        tpm = ok / makespan * 60.0
+        print(f"throughput: {tpm:.2f} videos/min  ({ok / makespan:.4f} videos/s)")
+        print(
+            f"latency (s): p50={nearest_rank(lat, 0.50):.1f} "
+            f"p90={nearest_rank(lat, 0.90):.1f} "
+            f"min={min(lat):.1f} max={max(lat):.1f}"
+        )
+        if args.baseline_tpm > 0:
+            print(f"scaling vs baseline ({args.baseline_tpm:.2f}/min): {tpm / args.baseline_tpm:.2f}x")
+    if errs:
+        print("sample failures:", errs[:3])
+
+    # Isolation check: compare each request's output against its own single-replica baseline.
+    isolation_failed = False
+    if args.write_baseline:
+        Path(args.write_baseline).write_text(json.dumps(got, indent=2))
+        print(f"baseline: wrote {len(got)} per-input hashes -> {args.write_baseline}")
+    elif args.check_baseline:
+        baseline = json.loads(Path(args.check_baseline).read_text())
+        matched = mismatched = unknown = 0
+        for key, md5 in got.items():
+            if key not in baseline:
+                unknown += 1
+                print(f"  isolation: NO BASELINE for input {key!r} (not in the baseline manifest)")
+            elif baseline[key] == md5:
+                matched += 1
+            else:
+                mismatched += 1
+                print(f"  isolation: MISMATCH for input {key!r} (output changed under concurrency)")
+        # PASS requires the run to cover the *whole* baseline: a subset (fewer requests, or
+        # some failed) must not pass just because the inputs it did run happened to match.
+        unverified = sorted(set(baseline) - set(got))
+        for key in unverified:
+            print(f"  isolation: NOT VERIFIED for baseline input {key!r} (absent from this run)")
+        isolation_failed = mismatched > 0 or unknown > 0 or len(unverified) > 0
+        verdict = "PASS (isolated)" if not isolation_failed else "FAIL"
+        print(
+            f"isolation: {matched} matched / {mismatched} mismatched / {unknown} unknown / "
+            f"{len(unverified)} unverified vs baseline({len(baseline)}) -> {verdict}"
+        )
+
+    if fail > 0 or ok == 0 or isolation_failed:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/replica_data_parallel/run_server.sh b/examples/online_serving/replica_data_parallel/run_server.sh
new file mode 100755
index 000000000..6b6f641fd
--- /dev/null
+++ b/examples/online_serving/replica_data_parallel/run_server.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Serve N independent Wan2.2 TI2V-5B replicas (replica data parallelism).
+#
+# Usage:
+#   NUM_REPLICAS=1 DEVICES=0        ./run_server.sh      # baseline
+#   NUM_REPLICAS=2 DEVICES=0,1      ./run_server.sh
+#   NUM_REPLICAS=4 DEVICES=0,1,2,3  ./run_server.sh
+#
+# Then drive load with bench_replica_dp.py (see README.md) and compare
+# throughput across replica counts.
+set -euo pipefail
+
+MODEL="${MODEL:-Wan-AI/Wan2.2-TI2V-5B-Diffusers}"
+HOST="${HOST:-127.0.0.1}"
+PORT="${PORT:-8098}"
+NUM_REPLICAS="${NUM_REPLICAS:-1}"
+DEVICES="${DEVICES:-0}"   # one GPU per replica for tensor_parallel_size=1
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+TEMPLATE="$HERE/wan2_2_ti2v_dp.yaml"
+CFG="$(mktemp --suffix=_wan2_2_dp.yaml)"
+trap 'rm -f "$CFG"' EXIT
+
+sed -e "s/__NUM_REPLICAS__/${NUM_REPLICAS}/" \
+    -e "s/__DEVICES__/${DEVICES}/" \
+    "$TEMPLATE" > "$CFG"
+
+echo "Serving ${MODEL}: num_replicas=${NUM_REPLICAS} devices=${DEVICES} (config ${CFG})"
+
+vllm serve "$MODEL" --omni \
+    --host "$HOST" \
+    --port "$PORT" \
+    --deploy-config "$CFG"
diff --git a/examples/online_serving/replica_data_parallel/wan2_2_ti2v_dp.yaml b/examples/online_serving/replica_data_parallel/wan2_2_ti2v_dp.yaml
new file mode 100644
index 000000000..52cf99778
--- /dev/null
+++ b/examples/online_serving/replica_data_parallel/wan2_2_ti2v_dp.yaml
@@ -0,0 +1,27 @@
+# Replica data-parallel recipe for Wan2.2 TI2V-5B (video DiT).
+#
+# Fans out `num_replicas` independent DiffusionEngine replicas, one per GPU,
+# and lets the serving layer route each request to a single replica. This
+# scales request throughput near-linearly; it does not change single-request
+# latency. See ./README.md for measured numbers and the `run_server.sh` driver.
+#
+# run_server.sh substitutes __NUM_REPLICAS__ / __DEVICES__ from env before serving.
+# For tensor_parallel_size = 1, `devices` lists one GPU per replica (pool mode):
+# num_replicas=4 -> devices "0,1,2,3".
+#
+# Stage topology (diffusion DiT, video output) comes from the registered
+# WanPipeline, which auto-detects TI2V-5B mode from model_index.json; this file
+# carries deployment knobs only.
+trust_remote_code: true
+distributed_executor_backend: mp
+
+stages:
+  - stage_id: 0
+    num_replicas: __NUM_REPLICAS__
+    devices: "__DEVICES__"
+    max_num_seqs: 1
+    tensor_parallel_size: 1
+    enforce_eager: true
+    vae_use_tiling: true
+    default_sampling_params:
+      seed: 42
diff --git a/examples/online_serving/step_audio2/README.md b/examples/online_serving/step_audio2/README.md
index e93f58ccc..25e2a6785 100644
--- a/examples/online_serving/step_audio2/README.md
+++ b/examples/online_serving/step_audio2/README.md
@@ -10,15 +10,15 @@ Please refer to [README.md](../../../README.md)
 
 ```bash
 # Async chunk mode (recommended — lower first-packet latency for TTS)
-vllm serve stepfun-ai/Step-Audio2-mini --omni --port 8092 \
-    --stage-configs-path vllm_omni/model_executor/stage_configs/step_audio_2_async_chunk.yaml \
+vllm serve stepfun-ai/Step-Audio-2-mini --omni --port 8092 \
+    --deploy-config vllm_omni/deploy/step_audio_2_async_chunk.yaml \
     --trust-remote-code --enforce-eager
 ```
 
 Sequential mode:
 ```bash
-vllm serve stepfun-ai/Step-Audio2-mini --omni --port 8092 \
-    --stage-configs-path vllm_omni/model_executor/stage_configs/step_audio_2.yaml \
+vllm serve stepfun-ai/Step-Audio-2-mini --omni --port 8092 \
+    --deploy-config vllm_omni/deploy/step_audio_2.yaml \
     --trust-remote-code --enforce-eager
 ```
 
@@ -51,7 +51,7 @@ Or via curl:
 ```bash
 curl -X POST http://localhost:8092/v1/audio/speech \
     -H "Content-Type: application/json" \
-    -d '{"model":"stepfun-ai/Step-Audio2-mini","input":"你好世界","voice":"default"}' \
+    -d '{"model":"stepfun-ai/Step-Audio-2-mini","input":"你好世界","voice":"default"}' \
     --output output.wav
 ```
 
@@ -139,7 +139,7 @@ Step-Audio2 uses the OpenAI-compatible chat completions API:
 
 ```json
 {
-  "model": "stepfun-ai/Step-Audio2-mini",
+  "model": "stepfun-ai/Step-Audio-2-mini",
   "messages": [
     {
       "role": "system",
diff --git a/examples/online_serving/step_audio2/openai_chat_completion_client.py b/examples/online_serving/step_audio2/openai_chat_completion_client.py
index 2b91dacb2..94acb5533 100644
--- a/examples/online_serving/step_audio2/openai_chat_completion_client.py
+++ b/examples/online_serving/step_audio2/openai_chat_completion_client.py
@@ -9,7 +9,7 @@ Step-Audio2 is a two-stage model:
 
 Usage examples:
   # Start server first:
-  vllm serve stepfun-ai/Step-Audio2-mini --omni --port 8092
+  vllm serve stepfun-ai/Step-Audio-2-mini --omni --port 8092
 
   # Audio to text (ASR)
   python openai_chat_completion_client.py --query-type audio_to_text
@@ -311,7 +311,7 @@ def parse_args():
         "--model",
         "-m",
         type=str,
-        default="stepfun-ai/Step-Audio2-mini",
+        default="stepfun-ai/Step-Audio-2-mini",
         help="Model name",
     )
     parser.add_argument(
diff --git a/examples/online_serving/step_audio2/openai_speech_client.py b/examples/online_serving/step_audio2/openai_speech_client.py
index 740b36805..762ca72a6 100644
--- a/examples/online_serving/step_audio2/openai_speech_client.py
+++ b/examples/online_serving/step_audio2/openai_speech_client.py
@@ -87,7 +87,7 @@ def parse_args():
         "--model",
         "-m",
         type=str,
-        default="stepfun-ai/Step-Audio2-mini",
+        default="stepfun-ai/Step-Audio-2-mini",
         help="Model name/path",
     )
     parser.add_argument(
diff --git a/examples/online_serving/step_audio2/run_curl.sh b/examples/online_serving/step_audio2/run_curl.sh
index 3811308e7..3a3b1c9f4 100755
--- a/examples/online_serving/step_audio2/run_curl.sh
+++ b/examples/online_serving/step_audio2/run_curl.sh
@@ -110,7 +110,7 @@ output=$(curl -sS -X POST "${API_BASE}/v1/chat/completions" \
     -H "Content-Type: application/json" \
     -d @- <<EOF
 {
-  "model": "stepfun-ai/Step-Audio2-mini",
+  "model": "stepfun-ai/Step-Audio-2-mini",
   "sampling_params_list": $sampling_params_list,
   "messages": [
     {
diff --git a/examples/online_serving/streaming_video_generation/README.md b/examples/online_serving/streaming_video_generation/README.md
index 1cfa29dfd..7caa74906 100644
--- a/examples/online_serving/streaming_video_generation/README.md
+++ b/examples/online_serving/streaming_video_generation/README.md
@@ -21,13 +21,16 @@ The `--diffusion-streaming-output` CLI flag is forwarded as `streaming_output=Tr
 | Direction | Message | Format | Description |
 | --- | --- | --- | --- |
 | Client to server | `session.start` | JSON text: `{"type":"session.start","model":"...","prompt":"...","format":"m4s"}` | Starts generation. `format` is optional and accepts `m4s` (default). Sampling fields such as `width`, `height`, `fps`, `num_frames`, and `extra_params` may be included. |
+| Client to server | `session.interaction` | JSON text: `{"type":"session.interaction","interaction":{"event_id":"xxx","event":{"prompt":"..."},"transition_chunks":3}}` | Updates the active prompt midway through generation. `event_id` is optional and `transition_chunks` defaults to the model setting. |
 | Server to client | `video.start` | JSON text: `{"type":"video.start","request_id":"...","format":"m4s","config":{...}}` | Confirms the session and mirrors the accepted `format`. |
+| Server to client | `video.chunk_metadata` | JSON text: `{"type":"video.chunk_metadata","request_id":"...","kind":"media","transport_chunk_index":0,"generation_chunk_index":0,"num_frames":9,"byte_length":1234,"started_event_ids":[],"active_event_ids":[],"completed_event_ids":[]}` | Precedes each binary frame and describes the immediately following payload. |
 | Server to client | Video chunk | Binary WebSocket frame | Fragmented MP4 (`m4s`) video bytes. |
 | Client to server | `session.stop` | JSON text: `{"type":"session.stop"}` | Requests cancellation of the active session. |
 | Client to server | `session.ping` | JSON text: `{"type":"session.ping"}` | Optional keepalive; refreshes the server stall clock. |
+| Server to client | `session.interaction.queued` | JSON text: `{"type":"session.interaction.queued","request_id":"...","event_id":"xxx"}` | Confirms the server queued the interaction for the active request. |
 | Server to client | `session.done` | JSON text: `{"type":"session.done","request_id":"...","chunks":3,"stopped":false}` | Ends a completed or stopped session. |
 | Server to client | `session.pong` | JSON text: `{"type":"session.pong"}` | Reply to `session.ping`. |
-| Server to client | `error` | JSON text: `{"type":"error","message":"..."}` | Reports invalid input, unsupported formats, generation failures, control-message errors, or stall timeout. |
+| Server to client | `error` | JSON text: `{"type":"error","message":"..."}` | Reports invalid input, unsupported formats, inactive requests, unsupported prompt updates, generation failures, control-message errors, or stall timeout. |
 
 During generation the client normally sends only `session.start` and then receives binary chunks; silence on the client socket is expected. The server closes the session with a stall error only when there is no engine progress and no `session.ping` for about 60 seconds.
 
@@ -59,6 +62,17 @@ python streaming_video_client.py \
 The client sends one `session.start` message, prints each received binary video chunk with its byte size and elapsed time, and saves the received bytes to `--output` after `session.done`.
 The client remuxes the gathered stream to a regular progressive MP4 file so that local playback knows the video duration.
 
+Schedule midway prompt updates with `--prompt-updates`. Each entry uses `"at"` as seconds on the client clock after the server sends `video.start`:
+
+```bash
+python streaming_video_client.py \
+  --prompt "A serene lakeside sunrise with mist over the water." \
+  --prompt-updates '[
+    {"at": 2.5, "prompt": "A sea turtle glides past the reeds"},
+    {"at": 5.0, "prompt": "Sunlight breaks through the morning mist", "transition_chunks": 2}
+  ]'
+```
+
 ## Run The Gradio Demo
 
 ```bash
diff --git a/examples/online_serving/streaming_video_generation/gradio_demo.py b/examples/online_serving/streaming_video_generation/gradio_demo.py
index 2f7a301f1..964b70f89 100644
--- a/examples/online_serving/streaming_video_generation/gradio_demo.py
+++ b/examples/online_serving/streaming_video_generation/gradio_demo.py
@@ -14,8 +14,9 @@ from __future__ import annotations
 
 import argparse
 import json
+import math
 from pathlib import Path
-from typing import Any
+from typing import Any, TypedDict
 
 try:
     import gradio as gr
@@ -23,16 +24,49 @@ except ImportError:
     raise ImportError("gradio is required to run this demo. Install it with: pip install 'vllm-omni[demo]'") from None
 
 DEFAULT_PROMPT = "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement."
+DEFAULT_TRANSITION_CHUNKS = 3
+PROMPT_UPDATE_HEADERS = ["At (s)", "Prompt", "Transition Chunks"]
+PROMPT_UPDATE_VALUES = [
+    [
+        4,
+        (
+            "An underwater tornado appears and affects the ocean floor in a dramatic and chaotic scene. "
+            "The water is murky, swirling violently, carrying debris and marine life into the vortex. "
+            "The tropical fish on the scene all swim in panic, trying to avoid the powerful currents. "
+            "The camera remains stationary, capturing the intensity of the underwater tornado as it disrupts the serene ocean floor. "
+            "Close-up shot emphasizing the turbulent motion and destruction."
+        ),
+        3,
+    ],
+    [
+        11,
+        (
+            "The swirling underwater vortex now seizes a heavy, encrusted treasure chest, its lid flapping open as it is smashed onto the ocean floor. "
+            "Gold coins and silver trinkets spill out, glittering briefly in the murky water before being swept instantly into the violent funnel. "
+            "The heavy wooden box tumbles end over end, colliding with floating rocks and adding to the debris field. "
+            "Swirling sediment and bubbles surround the spilling fortune, highlighting the chaotic power of the storm as it ravages the seabed. "
+            "Close-up shot emphasizing the turbulent motion and destruction."
+        ),
+        3,
+    ],
+]
 VIDEO_STREAM_VIEW_HTML = Path(__file__).with_name("video-stream-view.html")
 VIDEO_STREAM_VIEW_JS = Path(__file__).with_name("video-stream-view.js")
 
 
+class ScheduledPromptUpdate(TypedDict):
+    at: float
+    prompt: str
+    transition_chunks: int
+
+
 def _maybe_set(payload: dict[str, Any], key: str, value: Any) -> None:
     if value is None:
         return
-    if isinstance(value, str) and not value.strip():
-        return
-    payload[key] = value
+    if isinstance(value, str):
+        payload[key] = value.strip()
+    else:
+        payload[key] = value
 
 
 def _optional_int(value: int | float | None) -> int | None:
@@ -43,11 +77,83 @@ def _optional_float(value: int | float | None) -> float | None:
     return None if value is None else float(value)
 
 
+def _normalize_prompt_update_row(row: list[Any] | tuple[Any, ...]) -> tuple[Any, Any, Any]:
+    values = []
+    for v in row[: len(PROMPT_UPDATE_HEADERS)]:
+        if isinstance(v, str):
+            values.append(v.strip() or None)
+        elif isinstance(v, float) and math.isnan(v):
+            values.append(None)
+        else:
+            values.append(v)
+    while len(values) < len(PROMPT_UPDATE_HEADERS):
+        values.append(None)
+    return values[0], values[1], values[2]  # pyright: ignore[reportIndexIssue]
+
+
+def _prompt_update_row_is_empty(row: list[Any] | tuple[Any, ...]) -> bool:
+    at, prompt, transition = _normalize_prompt_update_row(row)
+    return at is None and prompt is None and transition is None
+
+
+def _parse_prompt_update_row(row: list[Any] | tuple[Any, ...], *, index: int) -> ScheduledPromptUpdate:
+    at_val, prompt_val, transition_val = _normalize_prompt_update_row(row)
+    row_label = f"Prompt update row {index + 1}"
+
+    if at_val is None or prompt_val is None:
+        raise gr.Error(f"{row_label} requires both At (s) and Prompt.")
+
+    try:
+        at = float(at_val)
+    except (TypeError, ValueError) as exc:
+        raise gr.Error(f"{row_label}: At (s) must be a number.") from exc
+    if at < 0:
+        raise gr.Error(f"{row_label}: At (s) must be >= 0.")
+
+    prompt = str(prompt_val).strip()
+    if not prompt:
+        raise gr.Error(f"{row_label}: Prompt must be a non-empty string.")
+
+    transition_chunks = DEFAULT_TRANSITION_CHUNKS
+    if transition_val is not None:
+        try:
+            transition_chunks = int(transition_val)
+        except (TypeError, ValueError) as exc:
+            raise gr.Error(f"{row_label}: Transition Chunks must be an integer.") from exc
+        if transition_chunks < 0:
+            raise gr.Error(f"{row_label}: Transition Chunks must be >= 0.")
+
+    return {
+        "at": at,
+        "prompt": prompt,
+        "transition_chunks": transition_chunks,
+    }
+
+
+def _parse_prompt_updates_dataframe(rows: list[list[Any]] | None) -> list[ScheduledPromptUpdate]:
+    if not rows:
+        return []
+
+    # Single row: empty or complete.
+    if len(rows) == 1:
+        row = rows[0]
+        if _prompt_update_row_is_empty(row):
+            return []
+        return [_parse_prompt_update_row(row, index=0)]
+
+    updates: list[ScheduledPromptUpdate] = []
+    for index, row in enumerate(rows):
+        if _prompt_update_row_is_empty(row):
+            raise gr.Error(f"Prompt update row {index + 1} cannot be empty when multiple rows are present.")
+        updates.append(_parse_prompt_update_row(row, index=index))
+    return sorted(updates, key=lambda update: update["at"])
+
+
 def _build_session_start(
     *,
     model: str,
     prompt: str,
-    negative_prompt: str,
+    negative_prompt: str | None,
     width: int | float | None,
     height: int | float | None,
     fps: int | float | None,
@@ -101,6 +207,7 @@ def build_browser_stream_config(
     model: str,
     prompt: str,
     negative_prompt: str,
+    include_negative_prompt: bool,
     width: int | float | None,
     height: int | float | None,
     fps: int | float,
@@ -118,6 +225,7 @@ def build_browser_stream_config(
     flow_shift: int | float | None,
     include_true_cfg_scale: bool,
     true_cfg_scale: int | float | None,
+    prompt_updates_df: list[list[Any]] | None,
 ) -> tuple[str, Any]:
     """Build the browser-side WebSocket request config for the HTML/MSE player."""
     if not model.strip():
@@ -128,7 +236,7 @@ def build_browser_stream_config(
     payload = _build_session_start(
         model=model.strip(),
         prompt=prompt.strip(),
-        negative_prompt=negative_prompt,
+        negative_prompt=negative_prompt if include_negative_prompt else None,
         width=width,
         height=height,
         fps=fps,
@@ -141,15 +249,21 @@ def build_browser_stream_config(
         true_cfg_scale=true_cfg_scale if include_true_cfg_scale else None,
         seed=seed if include_seed else None,
     )
+    prompt_updates = _parse_prompt_updates_dataframe(prompt_updates_df)
     config = {
         "url": f"ws://{host}:{int(port)}/v1/realtime/video",
         "payload": payload,
     }
+    if prompt_updates:
+        config["prompt_updates"] = prompt_updates
     return json.dumps(config, ensure_ascii=False), gr.update(value="Streaming...", interactive=False)
 
 
 def create_demo() -> gr.Blocks:
-    with gr.Blocks(title="Streaming Video Generation") as demo:
+    with gr.Blocks(
+        title="Streaming Video Generation",
+        css="textarea:disabled, input:disabled { color: var(--body-text-color-subdued); -webkit-text-fill-color: var(--body-text-color-subdued); background-color: var(--background-fill-secondary); }",
+    ) as demo:
         gr.Markdown("# Streaming Video Generation")
         gr.Markdown(
             "Connects to `WS /v1/realtime/video` in the browser and appends fMP4 chunks "
@@ -162,7 +276,6 @@ def create_demo() -> gr.Blocks:
                 port = gr.Number(label="Server Port", value=8000, precision=0)
                 model = gr.Textbox(label="Model", value="BestWishYsh/Helios-Distilled")
                 prompt = gr.Textbox(label="Prompt", value=DEFAULT_PROMPT, lines=3)
-                negative_prompt = gr.Textbox(label="Negative Prompt", value="", lines=2)
 
                 with gr.Row():
                     width = gr.Number(label="Width", value=640, precision=0)
@@ -170,49 +283,66 @@ def create_demo() -> gr.Blocks:
 
                 with gr.Row():
                     fps = gr.Number(label="FPS", value=16, precision=0)
-                    num_frames = gr.Number(label="Num Frames", value=132, precision=0)
+                    num_frames = gr.Number(label="Num Frames", value=429, precision=0)
                     num_inference_steps = gr.Number(label="Num Inference Steps", value=50, precision=0)
 
-                with gr.Row():
-                    with gr.Column():
-                        guidance_scale = gr.Number(
-                            label="Guidance Scale",
-                            value=1.0,
-                            interactive=True,
-                            scale=4,
-                        )
-                        include_guidance_scale = gr.Checkbox(label="Send", value=True, scale=1, min_width=70)
-                    with gr.Column():
-                        guidance_scale_2 = gr.Number(
-                            label="Guidance Scale 2",
-                            value=None,
-                            interactive=False,
-                            scale=4,
-                        )
-                        include_guidance_scale_2 = gr.Checkbox(label="Send", value=False, scale=1, min_width=70)
-                    with gr.Column():
-                        true_cfg_scale = gr.Number(
-                            label="True CFG Scale",
-                            value=None,
-                            interactive=False,
-                            scale=4,
-                        )
-                        include_true_cfg_scale = gr.Checkbox(label="Send", value=False, scale=1, min_width=70)
-                    # I want it to wrap after 3, but it auto wrap after 2. I'll rather fully delegate to auto wrapping.
-                    with gr.Column():
-                        boundary_ratio = gr.Number(
-                            label="Boundary Ratio",
-                            value=None,
-                            interactive=False,
-                            scale=4,
-                        )
-                        include_boundary_ratio = gr.Checkbox(label="Send", value=False, scale=1, min_width=70)
-                    with gr.Column():
-                        flow_shift = gr.Number(label="Flow Shift", value=None, interactive=False, scale=4)
-                        include_flow_shift = gr.Checkbox(label="Send", value=False, scale=1, min_width=70)
-                    with gr.Column():
-                        seed = gr.Number(label="Seed", value=42, precision=0, interactive=True, scale=4)
-                        include_seed = gr.Checkbox(label="Send", value=True, scale=1, min_width=70)
+                with gr.Accordion("Advanced Sampling", open=False):
+                    with gr.Row():
+                        with gr.Column():
+                            negative_prompt = gr.Textbox(label="Negative Prompt", value="", lines=1, interactive=False)
+                            include_negative_prompt = gr.Checkbox(label="Send", value=False)
+                    with gr.Row():
+                        with gr.Column(scale=0, min_width=150):
+                            guidance_scale = gr.Number(
+                                label="Guidance Scale",
+                                value=1.0,
+                                interactive=True,
+                            )
+                            include_guidance_scale = gr.Checkbox(label="Send", value=True)
+                        with gr.Column(scale=0, min_width=150):
+                            guidance_scale_2 = gr.Number(
+                                label="Guidance Scale 2",
+                                value=None,
+                                interactive=False,
+                            )
+                            include_guidance_scale_2 = gr.Checkbox(label="Send", value=False)
+                        with gr.Column(scale=0, min_width=150):
+                            true_cfg_scale = gr.Number(
+                                label="True CFG Scale",
+                                value=None,
+                                interactive=False,
+                            )
+                            include_true_cfg_scale = gr.Checkbox(label="Send", value=False)
+                        with gr.Column(scale=0, min_width=150):
+                            boundary_ratio = gr.Number(
+                                label="Boundary Ratio",
+                                value=None,
+                                interactive=False,
+                            )
+                            include_boundary_ratio = gr.Checkbox(label="Send", value=False)
+                        with gr.Column(scale=0, min_width=150):
+                            flow_shift = gr.Number(label="Flow Shift", value=None, interactive=False)
+                            include_flow_shift = gr.Checkbox(label="Send", value=False)
+                        with gr.Column(scale=0, min_width=150):
+                            seed = gr.Number(label="Seed", value=42, precision=0, interactive=True)
+                            include_seed = gr.Checkbox(label="Send", value=True)
+
+                with gr.Accordion("Prompt Updates", open=True):
+                    gr.Markdown(
+                        "Schedule midway text `session.interaction` messages after `video.start`. "
+                        "With one row, leave it fully empty or fill both **At (s)** and **Prompt**. "
+                        "With multiple rows, every row must be complete."
+                    )
+                    prompt_updates_df = gr.Dataframe(
+                        headers=PROMPT_UPDATE_HEADERS,
+                        datatype=["number", "str", "number"],
+                        type="array",
+                        row_count=1,
+                        row_limits=(1, None),
+                        column_count=3,
+                        value=PROMPT_UPDATE_VALUES,
+                        interactive=True,
+                    )
 
                 with gr.Row():
                     start_button = gr.Button("Start", variant="primary", elem_id="streaming-video-start")
@@ -231,6 +361,7 @@ def create_demo() -> gr.Blocks:
             model,
             prompt,
             negative_prompt,
+            include_negative_prompt,
             width,
             height,
             fps,
@@ -248,8 +379,10 @@ def create_demo() -> gr.Blocks:
             flow_shift,
             include_true_cfg_scale,
             true_cfg_scale,
+            prompt_updates_df,
         ]
         for toggle, field in [
+            (include_negative_prompt, negative_prompt),
             (include_guidance_scale, guidance_scale),
             (include_guidance_scale_2, guidance_scale_2),
             (include_seed, seed),
diff --git a/examples/online_serving/streaming_video_generation/streaming_video_client.py b/examples/online_serving/streaming_video_generation/streaming_video_client.py
index c77113420..e8dcd8cdd 100644
--- a/examples/online_serving/streaming_video_generation/streaming_video_client.py
+++ b/examples/online_serving/streaming_video_generation/streaming_video_client.py
@@ -13,10 +13,12 @@ Requirements:
 
 import argparse
 import asyncio
+import contextlib
 import io
 import json
 import os
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -39,17 +41,69 @@ HELIOS_DISTILLED_EXTRA_PARAMS = {
     "is_amplify_first_chunk": True,
 }
 
+DEFAULT_TRANSITION_CHUNKS = 3
 
-def _json_object(value: str, *, argument_name: str) -> dict[str, Any]:
+
+@dataclass(frozen=True)
+class ScheduledPromptUpdate:
+    """Client-side schedule entry for a midway text ``session.interaction``."""
+
+    at: float
+    prompt: str
+    transition_chunks: int
+
+
+def _parse_extra_params(value: str) -> dict[str, Any]:
     try:
         parsed = json.loads(value)
     except json.JSONDecodeError as exc:
-        raise argparse.ArgumentTypeError(f"{argument_name} must be valid JSON: {exc}") from exc
+        raise argparse.ArgumentTypeError(f"--extra-params must be valid JSON: {exc}") from exc
     if not isinstance(parsed, dict):
-        raise argparse.ArgumentTypeError(f"{argument_name} must be a JSON object")
+        raise argparse.ArgumentTypeError("--extra-params must be a JSON object")
     return parsed
 
 
+def _parse_prompt_updates(value: str) -> list[ScheduledPromptUpdate]:
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise argparse.ArgumentTypeError(f"--prompt-updates must be valid JSON: {exc}") from exc
+    if not isinstance(parsed, list):
+        raise argparse.ArgumentTypeError("--prompt-updates must be a JSON array")
+
+    updates: list[ScheduledPromptUpdate] = []
+    for index, item in enumerate(parsed):
+        try:
+            at = float(item["at"])
+            prompt = item["prompt"]
+        except (KeyError, TypeError, ValueError) as exc:
+            raise argparse.ArgumentTypeError(
+                f"--prompt-updates[{index}] must have valid 'at' and 'prompt' fields"
+            ) from exc
+        if at < 0:
+            raise argparse.ArgumentTypeError(f"--prompt-updates[{index}].at must be >= 0")
+        if not isinstance(prompt, str) or not prompt.strip():
+            raise argparse.ArgumentTypeError(f"--prompt-updates[{index}].prompt must be a non-empty string")
+
+        try:
+            transition_chunks = item.get("transition_chunks", DEFAULT_TRANSITION_CHUNKS)
+            transition_chunks = int(transition_chunks)
+        except (TypeError, ValueError) as exc:
+            raise argparse.ArgumentTypeError(f"--prompt-updates[{index}].transition_chunks must be an integer") from exc
+        if transition_chunks < 0:
+            raise argparse.ArgumentTypeError(f"--prompt-updates[{index}].transition_chunks must be >= 0")
+
+        updates.append(
+            ScheduledPromptUpdate(
+                at=at,
+                prompt=prompt,
+                transition_chunks=transition_chunks,
+            )
+        )
+
+    return sorted(updates, key=lambda update: update.at)
+
+
 def _maybe_set(payload: dict[str, Any], key: str, value: Any) -> None:
     if value is not None:
         payload[key] = value
@@ -88,6 +142,31 @@ def build_session_start(args: argparse.Namespace) -> dict[str, Any]:
     return payload
 
 
+async def _run_prompt_update_scheduler(
+    websocket: Any,
+    updates: list[ScheduledPromptUpdate],
+    *,
+    video_started_at: float,
+    send_lock: asyncio.Lock,
+) -> None:
+    for update in updates:
+        delay = (video_started_at + update.at) - time.perf_counter()
+        if delay > 0:
+            await asyncio.sleep(delay)
+
+        payload = {
+            "type": "session.interaction",
+            "interaction": {
+                "event_id": f"scheduled-{update.at:.3f}",
+                "event": {"prompt": update.prompt},
+                "transition_chunks": update.transition_chunks,
+            },
+        }
+        async with send_lock:
+            await websocket.send(json.dumps(payload, ensure_ascii=False))
+        print(f"Sent session.interaction at t={update.at:.2f}s: {json.dumps(payload, ensure_ascii=False)}")
+
+
 def _count_decoded_frames(video_bytes: bytes, *, stream_format: str) -> int | None:
     """Return the number of decodable video frames in a streamed byte sequence, if known."""
     if not video_bytes:
@@ -144,11 +223,15 @@ async def stream_video(args: argparse.Namespace) -> None:
     stream_format = "m4s"
     done = False
     ws = None
+    send_lock = asyncio.Lock()
+    prompt_update_task: asyncio.Task[None] | None = None
+    pending_chunk_metadata: dict[str, Any] | None = None
 
     try:
         async with connect(url, max_size=None) as websocket:
             ws = websocket
-            await websocket.send(json.dumps(payload))
+            async with send_lock:
+                await websocket.send(json.dumps(payload))
             print(f"Connected: {url}")
             print(f"Sent session.start: {json.dumps(payload, ensure_ascii=False)}")
             started_at = time.perf_counter()
@@ -159,6 +242,9 @@ async def stream_video(args: argparse.Namespace) -> None:
                 now = time.perf_counter()
 
                 if isinstance(message, bytes):
+                    # Use chunk metadata just received before video chunks
+                    metadata = pending_chunk_metadata or {}
+                    pending_chunk_metadata = None
                     chunks.append(message)
                     chunk_bytes = len(message)
                     chunk_elapsed = now - last_chunk_at
@@ -176,8 +262,11 @@ async def stream_video(args: argparse.Namespace) -> None:
                     total_elapsed = now - started_at
                     print(
                         f"[chunk {len(chunks):03d}] "
+                        f"kind={metadata.get('kind', 'media')} "
                         f"bytes={chunk_bytes} "
-                        f"frames={chunk_frames} "
+                        f"frames={metadata.get('num_frames', chunk_frames)} "
+                        f"generation_chunk={metadata.get('generation_chunk_index')} "
+                        f"active_interactions={metadata.get('active_event_ids', [])} "
                         f"elapsed={chunk_elapsed:.2f}s "
                         f"total_bytes={total_bytes} "
                         f"total_frames={total_frames} "
@@ -190,9 +279,26 @@ async def stream_video(args: argparse.Namespace) -> None:
                 if msg_type == "video.start":
                     stream_format = msg.get("format") or stream_format
                     print(f"Video session started: request_id={msg.get('request_id')} format={msg.get('format')}")
+                    if args.prompt_updates and prompt_update_task is None:
+                        video_started_at = time.perf_counter()
+                        prompt_update_task = asyncio.create_task(
+                            _run_prompt_update_scheduler(
+                                websocket,
+                                args.prompt_updates,
+                                video_started_at=video_started_at,
+                                send_lock=send_lock,
+                            )
+                        )
+                elif msg_type == "video.chunk_metadata":
+                    # Save the metadata for the incoming video chunk
+                    pending_chunk_metadata = msg
+                elif msg_type == "session.interaction.queued":
+                    print(f"Interaction queued by server: event_id={msg.get('event_id')}")
                 elif msg_type == "session.done":
                     print(f"Session complete: {json.dumps(msg, ensure_ascii=False)}")
                     done = True
+                    if prompt_update_task is not None:
+                        prompt_update_task.cancel()
                     break
                 elif msg_type == "error":
                     print(f"ERROR: {msg.get('message', msg)}")
@@ -202,12 +308,17 @@ async def stream_video(args: argparse.Namespace) -> None:
         print("\nInterrupted. Asking server to stop the active session...")
         if ws is not None:
             try:
-                await ws.send(json.dumps({"type": "session.stop"}))
+                async with send_lock:
+                    await ws.send(json.dumps({"type": "session.stop"}))
                 await ws.close(code=1000, reason="client interrupted")
             except Exception:
                 pass
         raise
     finally:
+        if prompt_update_task is not None:
+            prompt_update_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await prompt_update_task
         print(
             "Saving video... (May take a while. Remuxing concatenated chunks into one progressive MP4 file with total duration metadata in file header)"
         )
@@ -232,7 +343,15 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument(
         "--prompt",
-        default="A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement.",
+        default=(
+            "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. "
+            "The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. "
+            "The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. "
+            "The water is crystal clear, allowing for a view of the sandy ocean floor below. "
+            "The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. "
+            "The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. "
+            "A close-up shot with dynamic movement."
+        ),
         help="Text prompt for video generation",
     )
     parser.add_argument("--output", default="streaming_video_output.mp4", help="Path for the received video bytes")
@@ -241,7 +360,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--size", default=None, help="Video size as WIDTHxHEIGHT; alternative to width/height")
     parser.add_argument("--seconds", default=None, help="Clip duration in seconds")
     parser.add_argument("--fps", type=int, default=16, help="Frames per second")
-    parser.add_argument("--num-frames", type=int, default=99, help="Number of generated frames")
+    parser.add_argument("--num-frames", type=int, default=429, help="Number of generated frames")
 
     parser.add_argument("--negative-prompt", default=None, help="Negative prompt")
     parser.add_argument("--num-inference-steps", type=int, default=None, help="Number of diffusion steps")
@@ -260,10 +379,44 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument(
         "--extra-params",
-        type=lambda value: _json_object(value, argument_name="--extra-params"),
+        type=_parse_extra_params,
         default=None,
         help="JSON object merged into extra_params; overrides preset keys on conflict.",
     )
+    parser.add_argument(
+        "--prompt-updates",
+        type=_parse_prompt_updates,
+        default=json.dumps(
+            [
+                {
+                    "at": 4,
+                    "prompt": (
+                        "An underwater tornado appears and affects the ocean floor in a dramatic and chaotic scene. "
+                        "The water is murky, swirling violently, carrying debris and marine life into the vortex. "
+                        "The tropical fish on the scene all swim in panic, trying to avoid the powerful currents. "
+                        "The camera remains stationary, capturing the intensity of the underwater tornado as it disrupts the serene ocean floor. "
+                        "Close-up shot emphasizing the turbulent motion and destruction."
+                    ),
+                },
+                {
+                    "at": 11,
+                    "prompt": (
+                        "The swirling underwater vortex now seizes a heavy, encrusted treasure chest, its lid flapping open as it is smashed onto the ocean floor. "
+                        "Gold coins and silver trinkets spill out, glittering briefly in the murky water before being swept instantly into the violent funnel. "
+                        "The heavy wooden box tumbles end over end, colliding with floating rocks and adding to the debris field. "
+                        "Swirling sediment and bubbles surround the spilling fortune, highlighting the chaotic power of the storm as it ravages the seabed. "
+                        "Close-up shot emphasizing the turbulent motion and destruction."
+                    ),
+                    # "transition_chunks": 3,
+                },
+            ]
+        ),
+        help=(
+            "JSON array of scheduled prompt updates. Each object requires "
+            "'at' (seconds after video.start) and 'prompt'. Optional "
+            f"'transition_chunks' defaults to {DEFAULT_TRANSITION_CHUNKS}."
+        ),
+    )
     return parser.parse_args()
 
 
diff --git a/examples/online_serving/streaming_video_generation/video-stream-view.js b/examples/online_serving/streaming_video_generation/video-stream-view.js
index 1b0a5024b..46206c0d0 100644
--- a/examples/online_serving/streaming_video_generation/video-stream-view.js
+++ b/examples/online_serving/streaming_video_generation/video-stream-view.js
@@ -14,6 +14,7 @@
   let totalBytes = 0;
   let done = false;
   let objectUrl = null;
+  let promptUpdateTimers = [];
 
   function el(id) {
     return document.getElementById(id);
@@ -73,7 +74,50 @@
     } catch (_) { }
   }
 
+  function clearPromptUpdateTimers() {
+    for (const timer of promptUpdateTimers) {
+      clearTimeout(timer);
+    }
+    promptUpdateTimers = [];
+  }
+
+  function schedulePromptUpdates(updates) {
+    clearPromptUpdateTimers();
+    if (!Array.isArray(updates) || updates.length === 0) return;
+
+    const videoStartedAt = performance.now();
+    for (const update of updates) {
+      const atSeconds = Number(update.at);
+      if (!Number.isFinite(atSeconds) || atSeconds < 0) continue;
+
+      const delayMs = Math.max(0, atSeconds * 1000 - (performance.now() - videoStartedAt));
+      const transitionChunks = Number.isFinite(Number(update.transition_chunks))
+        ? Number(update.transition_chunks)
+        : 3;
+
+      const timer = setTimeout(() => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) return;
+        const payload = {
+          type: "session.interaction",
+          interaction: {
+            event_id: "scheduled-" + atSeconds.toFixed(3),
+            event: { prompt: update.prompt },
+            transition_chunks: transitionChunks,
+          },
+        };
+        try {
+          ws.send(JSON.stringify(payload));
+          log("Sent session.interaction at t=" + atSeconds.toFixed(2) + "s: " + JSON.stringify(payload));
+        } catch (err) {
+          log("Failed to send session.interaction: " + err.message);
+        }
+      }, delayMs);
+      promptUpdateTimers.push(timer);
+    }
+  }
+
   function stopCurrent() {
+    clearPromptUpdateTimers();
     if (ws && ws.readyState === WebSocket.OPEN) {
       try { ws.send(JSON.stringify({ type: "session.stop" })); } catch (_) { }
       try { ws.close(); } catch (_) { }
@@ -148,6 +192,11 @@
           const msg = JSON.parse(event.data);
           if (msg.type === "video.start") {
             log("Video session started: request_id=" + (msg.request_id || "") + " format=" + (msg.format || ""));
+            schedulePromptUpdates(config.prompt_updates);
+          } else if (msg.type === "video.chunk_metadata") {
+            log("Chunk metadata: " + JSON.stringify(msg));
+          } else if (msg.type === "session.interaction.queued") {
+            log("Interaction queued by server: event_id=" + (msg.event_id || ""));
           } else if (msg.type === "session.done") {
             done = true;
             setStatus("Done");
diff --git a/examples/online_serving/text_to_speech/README.md b/examples/online_serving/text_to_speech/README.md
index 201cb5d78..b331966b3 100644
--- a/examples/online_serving/text_to_speech/README.md
+++ b/examples/online_serving/text_to_speech/README.md
@@ -336,7 +336,7 @@ vllm serve OpenMOSS-Team/MOSS-TTS-Nano --omni --port 8091
 # or:
 ./moss_tts_nano/run_server.sh
 ```
-The deploy config at `vllm_omni/deploy/moss_tts_nano.yaml` auto-loads; no `--stage-configs-path`, `--trust-remote-code`, or `--enforce-eager` flags are needed.
+The deploy config at `vllm_omni/deploy/moss_tts_nano.yaml` auto-loads; no `--deploy-config`, `--trust-remote-code`, or `--enforce-eager` flags are needed.
 
 ### Sending requests
 ```bash
@@ -537,12 +537,19 @@ curl -X POST http://localhost:8091/v1/audio/speech \
 Raw PCM streaming requires `stream_format="audio"`, `response_format="pcm"`, and `async_chunk: true` on the stage config (default in `qwen3_tts.yaml`). `speed` is not supported when streaming.
 
 ### Streaming WebSocket
-The `/v1/audio/speech/stream` endpoint accepts text incrementally, splits it at sentence boundaries, and emits one PCM stream per sentence:
+The `/v1/audio/speech/stream` endpoint accepts text incrementally and synthesizes the buffered text as one continuous request on `input.done`:
 ```bash
 python qwen3_tts/streaming_speech_client.py --text "Hello world. How are you? I am fine."
 python qwen3_tts/streaming_speech_client.py --text "..." --simulate-stt --stt-delay 0.1
 ```
 
+`input.done` flushes without closing, so repeating `--text` synthesizes several utterances over one connection:
+```bash
+python qwen3_tts/streaming_speech_client.py \
+    --text "First utterance." \
+    --text "Second utterance, same connection."
+```
+
 To receive word-level timestamps, launch the server with a forced aligner:
 ```bash
 vllm-omni serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
diff --git a/examples/online_serving/text_to_speech/qwen3_tts/streaming_speech_client.py b/examples/online_serving/text_to_speech/qwen3_tts/streaming_speech_client.py
index 92a40739e..e141a4c48 100644
--- a/examples/online_serving/text_to_speech/qwen3_tts/streaming_speech_client.py
+++ b/examples/online_serving/text_to_speech/qwen3_tts/streaming_speech_client.py
@@ -7,6 +7,12 @@ Usage:
     # Send full text at once
     python streaming_speech_client.py --text "Hello world. How are you? I am fine."
 
+    # Several utterances over one connection: input.done flushes each of them
+    # and the connection stays open, so only the first pays the handshake
+    python streaming_speech_client.py \
+        --text "First utterance." \
+        --text "Second utterance, same connection."
+
     # Pick a built-in speaker for CustomVoice models
     python streaming_speech_client.py \
         --text "打开电子枪，关闭扫描，切换到低倍模式。" \
@@ -64,18 +70,27 @@ except ImportError:
     raise SystemExit(1)
 
 
-def save_audio_file(output_dir: str, sentence_index: int, response_format: str, chunks: list[bytes]) -> str:
+def frame_basename(msg: dict) -> str:
+    """Name a file after the utterance and sentence a frame belongs to.
+
+    Every utterance is sentence 0, so the utterance index is what keeps the
+    files of one connection from overwriting each other.
+    """
+    return f"utterance_{msg['utterance_index']:03d}_sentence_{msg['sentence_index']:03d}"
+
+
+def save_audio_file(output_dir: str, basename: str, response_format: str, chunks: list[bytes]) -> str:
     audio_bytes = b"".join(chunks)
     if response_format == "pcm":
-        raw_path = os.path.join(output_dir, f"sentence_{sentence_index:03d}.pcm")
+        raw_path = os.path.join(output_dir, f"{basename}.pcm")
         with open(raw_path, "wb") as f:
             f.write(audio_bytes)
 
-        wav_path = os.path.join(output_dir, f"sentence_{sentence_index:03d}.wav")
+        wav_path = os.path.join(output_dir, f"{basename}.wav")
         save_pcm_wav(wav_path, audio_bytes)
         return wav_path
 
-    filename = os.path.join(output_dir, f"sentence_{sentence_index:03d}.{response_format}")
+    filename = os.path.join(output_dir, f"{basename}.{response_format}")
     with open(filename, "wb") as f:
         f.write(audio_bytes)
     return filename
@@ -95,183 +110,207 @@ def timestamp_words_text(timestamps: list[dict] | None) -> str:
     return " ".join(str(item.get("word", "")) for item in timestamps if item.get("word"))
 
 
+async def send_utterance(ws, text: str, simulate_stt: bool, stt_delay: float) -> None:
+    """Send one utterance's text, then input.done to flush it."""
+    if simulate_stt:
+        words = text.split(" ")
+        for i, word in enumerate(words):
+            chunk = word + (" " if i < len(words) - 1 else "")
+            await ws.send(
+                json.dumps(
+                    {
+                        "type": "input.text",
+                        "text": chunk,
+                    }
+                )
+            )
+            print(f"  Sent: {chunk!r}")
+            await asyncio.sleep(stt_delay)
+    else:
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "input.text",
+                    "text": text,
+                }
+            )
+        )
+        print(f"Sent full text: {text!r}")
+
+    await ws.send(json.dumps({"type": "input.done"}))
+    print("Sent input.done")
+
+
+async def receive_utterance(
+    ws,
+    output_dir: str,
+    response_format: str,
+    word_timestamps: bool,
+    save_chunks: bool,
+) -> None:
+    """Consume frames until session.done marks the flushed utterance complete."""
+    current_label = "utterance 0"
+    current_sentence_text = ""
+    current_chunks: list[bytes] = []
+    current_timestamps: list[dict] = []
+    # Distinguish `null` (aligner failed) from `[]` (silence / no tokens):
+    # the sentence is a failure only if no frame ever carried timestamps.
+    alignment_frame_seen = False
+
+    while True:
+        message = await ws.recv()
+
+        if isinstance(message, bytes):
+            current_chunks.append(message)
+            print(f"  Received audio chunk for {current_label}: {len(message)} bytes")
+        else:
+            # JSON frame
+            msg = json.loads(message)
+            msg_type = msg.get("type")
+
+            if msg_type == "audio.start":
+                current_label = f"utterance {msg['utterance_index']}"
+                current_sentence_text = msg.get("sentence_text", "")
+                current_chunks = []
+                current_timestamps = []
+                alignment_frame_seen = False
+                print(f"  [{current_label}] Generating: {current_sentence_text!r}")
+            elif msg_type == "audio.chunk":
+                audio = base64.b64decode(msg["audio_b64"])
+                current_chunks.append(audio)
+                chunk_timestamps = msg.get("timestamps")
+                # Sentence-level alignment sends a trailing timestamp-only
+                # frame with empty audio; don't write an empty chunk file.
+                if save_chunks and audio:
+                    chunk_base = os.path.join(
+                        output_dir,
+                        f"{frame_basename(msg)}_chunk_{msg['chunk_id']:03d}",
+                    )
+                    chunk_pcm = f"{chunk_base}.pcm"
+                    chunk_wav = f"{chunk_base}.wav"
+                    chunk_json = f"{chunk_base}_timestamps.json"
+                    with open(chunk_pcm, "wb") as f:
+                        f.write(audio)
+                    save_pcm_wav(chunk_wav, audio, int(msg.get("sample_rate", 24000)))
+                    with open(chunk_json, "w", encoding="utf-8") as f:
+                        json.dump(
+                            {
+                                "utterance_index": msg["utterance_index"],
+                                "sentence_index": msg["sentence_index"],
+                                "chunk_id": msg["chunk_id"],
+                                "chunk_start_ms": msg.get("chunk_start_ms"),
+                                "chunk_end_ms": msg.get("chunk_end_ms"),
+                                "sentence_text": current_sentence_text,
+                                "covered_text": timestamp_words_text(chunk_timestamps),
+                                "timestamps": chunk_timestamps,
+                            },
+                            f,
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                if chunk_timestamps is None:
+                    print(f"  [{current_label}] chunk {msg['chunk_id']}: {len(audio)} bytes, timestamps unavailable")
+                else:
+                    alignment_frame_seen = True
+                    current_timestamps.extend(chunk_timestamps)
+                    print(
+                        f"  [{current_label}] chunk {msg['chunk_id']}: "
+                        f"{len(audio)} bytes, {len(chunk_timestamps)} timestamp(s)"
+                    )
+                if save_chunks and audio:
+                    print(f"    saved chunk -> {chunk_wav}")
+            elif msg_type == "audio.done":
+                filename = save_audio_file(
+                    output_dir,
+                    frame_basename(msg),
+                    response_format,
+                    current_chunks,
+                )
+                if word_timestamps:
+                    # `null` on failure, else the accumulated list (`[]` for silence).
+                    sentence_timestamps = current_timestamps if alignment_frame_seen else None
+                    ts_filename = os.path.join(
+                        output_dir,
+                        f"{frame_basename(msg)}_timestamps.json",
+                    )
+                    with open(ts_filename, "w", encoding="utf-8") as f:
+                        json.dump(
+                            {
+                                "utterance_index": msg["utterance_index"],
+                                "sentence_index": msg["sentence_index"],
+                                "sentence_text": current_sentence_text,
+                                "covered_text": timestamp_words_text(sentence_timestamps),
+                                "timestamps": sentence_timestamps,
+                            },
+                            f,
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                print(
+                    f"  [{current_label}] Done"
+                    f" bytes={msg.get('total_bytes', len(b''.join(current_chunks)))}"
+                    f" error={msg.get('error', False)}"
+                    f" -> {filename}"
+                )
+                if word_timestamps:
+                    print(f"  [{current_label}] Timestamps -> {ts_filename}")
+                current_chunks = []
+                current_timestamps = []
+                alignment_frame_seen = False
+            elif msg_type == "session.done":
+                print(f"\nUtterance {msg['utterance_index']} complete: {msg['total_sentences']} sentence(s) generated")
+                return
+            elif msg_type == "error":
+                print(f"  ERROR: {msg['message']}")
+            else:
+                print(f"  Unknown message: {msg}")
+
+
 async def stream_tts(
     url: str,
-    text: str,
+    texts: list[str],
     config: dict,
     output_dir: str,
     simulate_stt: bool = False,
     stt_delay: float = 0.1,
     save_chunks: bool = False,
 ) -> None:
-    """Connect to the streaming TTS endpoint and process audio responses."""
+    """Connect to the streaming TTS endpoint and process audio responses.
+
+    Every text is synthesized over the same connection: input.done flushes an
+    utterance without closing, so only the first one pays the handshake.
+    """
     os.makedirs(output_dir, exist_ok=True)
+    response_format = config.get("response_format", "wav")
+    word_timestamps = bool(config.get("word_timestamps", False))
 
     async with websockets.connect(url) as ws:
-        # 1. Send session config
+        # 1. Send session config; it stays in effect for every utterance below.
         config_msg = {"type": "session.config", **config}
         await ws.send(json.dumps(config_msg))
         print(f"Sent session config: {config}")
 
-        # 2. Send text (either all at once or word-by-word)
-        async def send_text():
-            if simulate_stt:
-                words = text.split(" ")
-                for i, word in enumerate(words):
-                    chunk = word + (" " if i < len(words) - 1 else "")
-                    await ws.send(
-                        json.dumps(
-                            {
-                                "type": "input.text",
-                                "text": chunk,
-                            }
-                        )
-                    )
-                    print(f"  Sent: {chunk!r}")
-                    await asyncio.sleep(stt_delay)
-            else:
-                await ws.send(
-                    json.dumps(
-                        {
-                            "type": "input.text",
-                            "text": text,
-                        }
-                    )
-                )
-                print(f"Sent full text: {text!r}")
-
-            # 3. Signal end of input
-            await ws.send(json.dumps({"type": "input.done"}))
-            print("Sent input.done")
-
-        # Run sender and receiver concurrently
-        sender_task = asyncio.create_task(send_text())
-
-        response_format = config.get("response_format", "wav")
-        word_timestamps = bool(config.get("word_timestamps", False))
-        current_sentence_index = 0
-        current_sentence_text = ""
-        current_chunks: list[bytes] = []
-        current_timestamps: list[dict] = []
-        # Distinguish `null` (aligner failed) from `[]` (silence / no tokens):
-        # the sentence is a failure only if no frame ever carried timestamps.
-        alignment_frame_seen = False
-
-        try:
-            while True:
-                message = await ws.recv()
-
-                if isinstance(message, bytes):
-                    current_chunks.append(message)
-                    print(f"  Received audio chunk for sentence {current_sentence_index}: {len(message)} bytes")
-                else:
-                    # JSON frame
-                    msg = json.loads(message)
-                    msg_type = msg.get("type")
-
-                    if msg_type == "audio.start":
-                        current_sentence_index = msg["sentence_index"]
-                        current_sentence_text = msg.get("sentence_text", "")
-                        current_chunks = []
-                        current_timestamps = []
-                        alignment_frame_seen = False
-                        print(f"  [sentence {msg['sentence_index']}] Generating: {current_sentence_text!r}")
-                    elif msg_type == "audio.chunk":
-                        audio = base64.b64decode(msg["audio_b64"])
-                        current_chunks.append(audio)
-                        chunk_timestamps = msg.get("timestamps")
-                        # Sentence-level alignment sends a trailing timestamp-only
-                        # frame with empty audio; don't write an empty chunk file.
-                        if save_chunks and audio:
-                            chunk_base = os.path.join(
-                                output_dir,
-                                f"sentence_{msg['sentence_index']:03d}_chunk_{msg['chunk_id']:03d}",
-                            )
-                            chunk_pcm = f"{chunk_base}.pcm"
-                            chunk_wav = f"{chunk_base}.wav"
-                            chunk_json = f"{chunk_base}_timestamps.json"
-                            with open(chunk_pcm, "wb") as f:
-                                f.write(audio)
-                            save_pcm_wav(chunk_wav, audio, int(msg.get("sample_rate", 24000)))
-                            with open(chunk_json, "w", encoding="utf-8") as f:
-                                json.dump(
-                                    {
-                                        "sentence_index": msg["sentence_index"],
-                                        "chunk_id": msg["chunk_id"],
-                                        "chunk_start_ms": msg.get("chunk_start_ms"),
-                                        "chunk_end_ms": msg.get("chunk_end_ms"),
-                                        "sentence_text": current_sentence_text,
-                                        "covered_text": timestamp_words_text(chunk_timestamps),
-                                        "timestamps": chunk_timestamps,
-                                    },
-                                    f,
-                                    ensure_ascii=False,
-                                    indent=2,
-                                )
-                        if chunk_timestamps is None:
-                            print(
-                                f"  [sentence {msg['sentence_index']}] chunk {msg['chunk_id']}: "
-                                f"{len(audio)} bytes, timestamps unavailable"
-                            )
-                        else:
-                            alignment_frame_seen = True
-                            current_timestamps.extend(chunk_timestamps)
-                            print(
-                                f"  [sentence {msg['sentence_index']}] chunk {msg['chunk_id']}: "
-                                f"{len(audio)} bytes, {len(chunk_timestamps)} timestamp(s)"
-                            )
-                        if save_chunks and audio:
-                            print(f"    saved chunk -> {chunk_wav}")
-                    elif msg_type == "audio.done":
-                        filename = save_audio_file(
-                            output_dir,
-                            msg["sentence_index"],
-                            response_format,
-                            current_chunks,
-                        )
-                        if word_timestamps:
-                            # `null` on failure, else the accumulated list (`[]` for silence).
-                            sentence_timestamps = current_timestamps if alignment_frame_seen else None
-                            ts_filename = os.path.join(
-                                output_dir,
-                                f"sentence_{msg['sentence_index']:03d}_timestamps.json",
-                            )
-                            with open(ts_filename, "w", encoding="utf-8") as f:
-                                json.dump(
-                                    {
-                                        "sentence_index": msg["sentence_index"],
-                                        "sentence_text": current_sentence_text,
-                                        "covered_text": timestamp_words_text(sentence_timestamps),
-                                        "timestamps": sentence_timestamps,
-                                    },
-                                    f,
-                                    ensure_ascii=False,
-                                    indent=2,
-                                )
-                        print(
-                            f"  [sentence {msg['sentence_index']}] Done"
-                            f" bytes={msg.get('total_bytes', len(b''.join(current_chunks)))}"
-                            f" error={msg.get('error', False)}"
-                            f" -> {filename}"
-                        )
-                        if word_timestamps:
-                            print(f"  [sentence {msg['sentence_index']}] Timestamps -> {ts_filename}")
-                        current_chunks = []
-                        current_timestamps = []
-                        alignment_frame_seen = False
-                    elif msg_type == "session.done":
-                        print(f"\nSession complete: {msg['total_sentences']} sentence(s) generated")
-                        break
-                    elif msg_type == "error":
-                        print(f"  ERROR: {msg['message']}")
-                    else:
-                        print(f"  Unknown message: {msg}")
-        finally:
-            sender_task.cancel()
+        for text in texts:
+            # 2. Send text (either all at once or word-by-word), then flush.
+            sender_task = asyncio.create_task(send_utterance(ws, text, simulate_stt, stt_delay))
             try:
-                await sender_task
-            except asyncio.CancelledError:
-                pass  # Task cancellation is expected during shutdown
+                await receive_utterance(
+                    ws,
+                    output_dir=output_dir,
+                    response_format=response_format,
+                    word_timestamps=word_timestamps,
+                    save_chunks=save_chunks,
+                )
+            finally:
+                sender_task.cancel()
+                try:
+                    await sender_task
+                except asyncio.CancelledError:
+                    pass  # Task cancellation is expected during shutdown
+
+        # 3. Release the connection once there is nothing left to say.
+        await ws.send(json.dumps({"type": "session.close"}))
+        print("Sent session.close")
 
     print(f"\nAudio files saved to: {output_dir}/")
 
@@ -286,7 +325,8 @@ def main():
     parser.add_argument(
         "--text",
         required=True,
-        help="Text to synthesize",
+        action="append",
+        help="Text to synthesize; repeat to send several utterances over one connection",
     )
     parser.add_argument(
         "--output-dir",
@@ -385,7 +425,7 @@ def main():
     asyncio.run(
         stream_tts(
             url=args.url,
-            text=args.text,
+            texts=args.text,
             config=config,
             output_dir=args.output_dir,
             simulate_stt=args.simulate_stt,
diff --git a/examples/online_serving/text_to_video/README.md b/examples/online_serving/text_to_video/README.md
index 93de44a88..51512fe0c 100644
--- a/examples/online_serving/text_to_video/README.md
+++ b/examples/online_serving/text_to_video/README.md
@@ -248,82 +248,12 @@ done
 
 ## LTX-2
 
-### Start Server
-
-#### Basic Start
-
 ```bash
-vllm serve Lightricks/LTX-2 --omni --port 8098 \
-    --enforce-eager --flow-shift 1.0 --boundary-ratio 1.0
+vllm serve Lightricks/LTX-2 --omni --port 8098
 ```
 
-#### Start with Optimization Presets
-
-Use the LTX-2 startup script with built-in optimization presets:
-
-```bash
-# Baseline (1 GPU, eager)
-bash run_server_ltx2.sh baseline
-
-# 4-GPU Ulysses sequence parallelism (lossless)
-bash run_server_ltx2.sh ulysses4
-
-# Cache-DiT lossy acceleration (1 GPU, ~1.4× speedup)
-bash run_server_ltx2.sh cache-dit
-
-# Best combo: 4-GPU Ulysses SP + Cache-DiT (~2.2× speedup)
-bash run_server_ltx2.sh best-combo
-```
-
-#### Optimization Benchmarks
-
-Benchmarked on H800, online serving (480×768, 41 frames, 20 steps, `seed=42`).
-"Inference" is the server-reported inference time; excludes HTTP/poll overhead.
-
-| Preset | Server Command | Inference (s) | Speedup | Type |
-|--------|---------------|---------------|---------|------|
-| `baseline` | `--enforce-eager` | 10.3 | 1.00× | — |
-| `compile` | *(default, no --enforce-eager)* | ~10.3 (warm) | ~1.00× | Lossless |
-| `ulysses4` | `--enforce-eager --usp 4` | ~10.3 | ~1.00× | Lossless |
-| `cache-dit` | `--enforce-eager --cache-backend cache_dit` | 7.4 avg | ~1.4× | Lossy |
-| `best-combo` | `--enforce-eager --usp 4 --cache-backend cache_dit` | 4.7 avg | **~2.2×** | Lossless + Lossy |
-
-**Observations**:
-- **torch.compile**: On H800, warm-request inference time matches the eager baseline (~10.3s).
-  The first request pays ~6s compilation overhead. Benefit depends on model architecture and GPU.
-- **Ulysses SP (4 GPU)**: No measurable speedup alone for 41-frame generation at this resolution.
-  Communication overhead outweighs gains at this sequence length.
-- **Cache-DiT**: Inference varies per request (6–10s) due to dynamic caching decisions.
-  Average is ~7.4s (~1.4× speedup) with slight quality tradeoff.
-- **Best combo**: 4-GPU Ulysses SP + Cache-DiT synergize well — Cache-DiT reduces per-step
-  computation, making the communication overhead of Ulysses SP worthwhile. Average ~4.7s
-  (~2.2× speedup).
-- **FP8 quantization**: Reduces VRAM but does not speed up LTX-2 on H800 (compute-bound).
-
-**Deployment Recommendations**:
-- For **production with quality priority**: use `baseline` with `--enforce-eager`
-- For **maximum throughput** (4 GPUs, quality tradeoff): use `best-combo` (~2.2× speedup)
-- For **single-GPU throughput**: use `cache-dit` (~1.4× speedup)
-- `--enforce-eager` is recommended to avoid torch.compile warmup latency on first request
-
-### Send Requests (curl)
-
-```bash
-# Using the provided script
-bash run_curl_ltx2.sh
-
-# Or directly
-curl -sS -X POST http://localhost:8098/v1/videos \
-  -H "Accept: application/json" \
-  -F "prompt=A serene lakeside sunrise with mist over the water." \
-  -F "width=768" \
-  -F "height=480" \
-  -F "num_frames=41" \
-  -F "fps=24" \
-  -F "num_inference_steps=20" \
-  -F "guidance_scale=3.0" \
-  -F "seed=42"
-```
+See the [LTX-2 recipe](../../../recipes/LTX/LTX-2.md) for all checkpoints,
+pipeline selection, requests, defaults, and advanced options.
 
 ## Helios
 
diff --git a/examples/online_serving/text_to_video/run_curl_ltx2.sh b/examples/online_serving/text_to_video/run_curl_ltx2.sh
index b82f672ea..1cf828bba 100644
--- a/examples/online_serving/text_to_video/run_curl_ltx2.sh
+++ b/examples/online_serving/text_to_video/run_curl_ltx2.sh
@@ -22,7 +22,6 @@ create_response=$(
     -F "num_frames=41" \
     -F "fps=24" \
     -F "num_inference_steps=20" \
-    -F "guidance_scale=3.0" \
     -F "seed=42"
 )
 
diff --git a/examples/online_serving/text_to_video/run_server_ltx2.sh b/examples/online_serving/text_to_video/run_server_ltx2.sh
index f4597d3cd..da9351f7f 100644
--- a/examples/online_serving/text_to_video/run_server_ltx2.sh
+++ b/examples/online_serving/text_to_video/run_server_ltx2.sh
@@ -21,8 +21,6 @@ set -euo pipefail
 
 MODEL="${MODEL:-Lightricks/LTX-2}"
 PORT="${PORT:-8098}"
-FLOW_SHIFT="${FLOW_SHIFT:-1.0}"
-BOUNDARY_RATIO="${BOUNDARY_RATIO:-1.0}"
 
 PRESET="${1:-baseline}"
 
@@ -66,19 +64,13 @@ case "$PRESET" in
         echo "Environment variables:"
         echo "  MODEL           - Model path (default: Lightricks/LTX-2)"
         echo "  PORT            - Server port (default: 8098)"
-        echo "  FLOW_SHIFT      - Scheduler flow shift (default: 1.0)"
-        echo "  BOUNDARY_RATIO  - Boundary ratio (default: 1.0)"
         exit 1
         ;;
 esac
 
 echo "Model: $MODEL"
 echo "Port: $PORT"
-echo "Flow shift: $FLOW_SHIFT"
-echo "Boundary ratio: $BOUNDARY_RATIO"
 
 vllm serve "$MODEL" --omni \
     --port "$PORT" \
-    --flow-shift "$FLOW_SHIFT" \
-    --boundary-ratio "$BOUNDARY_RATIO" \
     "${EXTRA_ARGS[@]}"
diff --git a/mkdocs.yml b/mkdocs.yml
index 8d5ffaa1b..fd97b9b37 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -71,6 +71,14 @@ plugins:
   - search
   - autorefs
   - awesome-nav
+  - redirects:
+      redirect_maps:
+        user_guide/diffusion/request_batching.md: user_guide/diffusion/execution_modes.md
+        user_guide/diffusion/step_execution.md: user_guide/diffusion/execution_modes.md
+        user_guide/diffusion/cpu_offload_diffusion.md: user_guide/diffusion/cpu_offload.md
+        user_guide/quantization/index.md: user_guide/quantization/overview.md
+        design/feature/diffusion_request_level_batching.md: design/feature/diffusion_continuous_batching.md
+        design/feature/diffusion_step_execution.md: design/feature/diffusion_continuous_batching.md
   - glightbox
   - git-revision-date-localized:
       # exclude files
diff --git a/pyproject.toml b/pyproject.toml
index 0da2d7b5f..f8328e656 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -36,44 +36,45 @@ classifiers = [
 [project.optional-dependencies]
 
 dev = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-    "pytest-cov>=4.0.0",
-    "pytest-mock>=3.10.0",
-    "websockets>=15.0.1",
-    "pytest-subtests>=0.11.0",
-    "datasets>=2.14.0",
+    "pytest==9.1.1",
+    "pytest-asyncio==1.4.0",
+    "pytest-cov==7.1.0",
+    "pytest-mock==3.15.1",
+    "websockets==16.1",
+    "pytest-subtests==0.15.0",
+    "datasets==3.6.0",
     "mypy==1.11.1",
     "pre-commit==4.0.1",
-    "openai-whisper>=20250625",
-    "psutil>=7.2.0",
-    "soundfile>=0.13.1",
-    "imageio[ffmpeg]>=0.6.0",
-    "opencv-python>=4.12.0.88",
-    "mooncake-transfer-engine-cuda13>=0.3.9",
-    "av", # for ComfyUI tests
-    "openpyxl>=3.0.0", # for nightly CI
-    "pyttsx3>=2.99",
-    "opencc>=1.2.0",
-    "mistune>=3.2.0", # for example tests
-    "torchmetrics>=1.4.0", # for accuracy similarity metrics
-    "ray[default]", # for RL test
-    "jiwer>=3.0.0",
-    "zhon>=2.0.0",
-    "zhconv>=1.4.2",
-    "scipy>=1.10.0",
-    "funasr>=1.0.0",
-    "lpips>=0.1.4", # for quantization fp8
-    "orjson>=3.11.7", # to make v1/embeddings API fast
-    "voxcpm>=2.0.2", # for VoxCPM2 path-locating in tests
-    "torchdiffeq>=0.2.5", # for covo_audio Test
-    "FlagEmbedding", # for hunyuan_image3 tests
-    "kernels<0.15.0", # for accuracy tests comparison with diffusers output (0.15.0 incompatible with diffusers 0.38.0)
-    "s3tokenizer>=0.3.0", # for tts test
-    "step-audio2>=1.0.0", # Step-Audio2 Token2Wav (flashcosyvoice / hyperpyyaml)
+    "openai-whisper==20250625",
+    "psutil==7.2.2",
+    "soundfile==0.14.0",
+    "imageio[ffmpeg]==2.37.4",
+    "opencv-python==5.0.0.93",
+    "mooncake-transfer-engine-cuda13==0.3.11.post1",
+    "av==18.0.0", # for ComfyUI tests
+    "openpyxl==3.1.5", # for nightly CI
+    "pyttsx3==2.99",
+    "opencc==1.4.1",
+    "mistune==3.3.4", # for example tests
+    "torchmetrics==1.9.0", # for accuracy similarity metrics
+    "ray[default]==2.56.1", # for RL test
+    "jiwer==4.0.0",
+    "zhon==2.1.1",
+    "zhconv==1.4.3",
+    "scipy==1.18.0",
+    "funasr==1.3.29",
+    "lpips==0.1.4", # for quantization fp8
+    "orjson==3.11.9", # to make v1/embeddings API fast
+    "voxcpm==2.0.3", # for VoxCPM2 path-locating in tests
+    "torchdiffeq==0.2.5", # for covo_audio Test
+    "FlagEmbedding==1.4.0", # for hunyuan_image3 tests
+    "kernels==0.14.1", # for accuracy tests comparison with diffusers output (0.15.0 incompatible with diffusers 0.38.0)
+    "s3tokenizer==0.3.0", # for tts test
+    "step-audio2==1.0.0", # Step-Audio2 / MiniCPM-o 4.5 Token2Wav (flashcosyvoice / hyperpyyaml)
 ]
 
 demo = [
+    "gradio>=6.7.0",
     "opencv-python>=4.12.0.88",  # cli/stream_client frame reading
     "requests>=2.28.0",  # cli/stream_client HTTP
     "cn2an>=0.5.22",  # Chinese number normalization for TTS (e.g. "1次" -> "一次")
@@ -88,24 +89,18 @@ local = [
     "FlagEmbedding",
 ]
 
-# Optional runtime dependencies for the MiniCPM-o 4.5 talker pipeline.
-# The talker loads MiniCPMTTS via `trust_remote_code` from the model repo,
-# and that module performs `from stepaudio2 import Token2wav` against the
-# MiniCPM-o-flavored Token2wav vocoder (PyPI: `stepaudio2-minicpmo`, NOT
-# upstream `stepfun-ai/Step-Audio2` — the upstream signature rejects
-# `n_timesteps` and crashes at construction). A clean `vllm-omni` install
-# does not pull this in by default to avoid forcing the dep onto users
-# who only need other models; opt in with `pip install vllm-omni[minicpmo]`.
-minicpmo = [
-    "stepaudio2-minicpmo",
-]
-
 # Optional Blackwell-only fused-bias FP8 GEMM; package is `quack-kernels` (imported
 # as `quack`), not the unrelated `quack`. See docs/user_guide/quantization/fp8.md.
 quack = [
     "quack-kernels>=0.3.11",
 ]
 
+# Optional Blackwell-native FlashAttention-4 backend. Keep this opt-in because
+# the CuTe/CUTLASS dependency is CUDA 13 and Blackwell specific.
+fa4 = [
+    "flash-attn-4[cu13]==4.0.0b18",
+]
+
 docs = [
     "mkdocs>=1.5.0",
     "mkdocs-api-autonav",
@@ -113,6 +108,7 @@ docs = [
     "mkdocstrings-python",
     "mkdocs-gen-files",
     "mkdocs-awesome-nav",
+    "mkdocs-redirects",
     "mkdocs-glightbox",
     "mkdocs-git-revision-date-localized-plugin",
     "mkdocs-minify-plugin",
@@ -151,7 +147,6 @@ include = ["vllm_omni*"]
 
 [tool.setuptools.package-data]
 "vllm_omni" = ["_version.py", "py.typed"]
-"vllm_omni.model_executor.stage_configs" = ["*.yaml"]
 
 [tool.setuptools_scm]
 # no extra settings needed, presence enables setuptools-scm
@@ -255,13 +250,16 @@ markers = [
     "npu: Tests that run on NPU/Ascend (auto-added)",
     "musa: Tests that run on MUSA/Moore Threads (auto-added)",
     # specified computation resources marks (auto-added)
-    "H100: Tests that require H100 GPU",
-    "L4: Tests that require L4 GPU",
-    "MI325: Tests that require MI325 GPU (AMD/ROCm)",
-    "B60: Tests that require Intel Arc Pro B60 XPU",
-    "S5000: Tests that require S5000 GPU (Moore Threads/MUSA)",
-    "A2: Tests that require A2 NPU",
-    "A3: Tests that require A3 NPU",
+    # Tag with [hardware-resource] for tests.helpers.mark.get_hardware_mark_list().
+    "H100: [hardware-resource] Tests that require H100 GPU",
+    "H200: [hardware-resource] Tests that require H200 GPU",
+    "L4: [hardware-resource] Tests that require L4 GPU",
+    "B200: [hardware-resource] Tests that require B200 GPU",
+    "MI325: [hardware-resource] Tests that require MI325 GPU (AMD/ROCm)",
+    "B60: [hardware-resource] Tests that require Intel Arc Pro B60 XPU",
+    "S5000: [hardware-resource] Tests that require S5000 GPU (Moore Threads/MUSA)",
+    "A2: [hardware-resource] Tests that require A2 NPU",
+    "A3: [hardware-resource] Tests that require A3 NPU",
     "distributed_cuda: Tests that require multi cards on CUDA platform",
     "distributed_rocm: Tests that require multi cards on ROCm platform",
     "distributed_xpu: Tests that require multi cards on XPU platform",
diff --git a/recipes/Bagel/BAGEL-7B-MoT.md b/recipes/Bagel/BAGEL-7B-MoT.md
index a7b0524e4..4c2d75aca 100644
--- a/recipes/Bagel/BAGEL-7B-MoT.md
+++ b/recipes/Bagel/BAGEL-7B-MoT.md
@@ -6,7 +6,7 @@
 
 - Vendor: ByteDance Seed
 - Model: `ByteDance-Seed/BAGEL-7B-MoT`
-- Task: Text-to-image and image-to-image generation
+- Task: Text-to-image, image-to-image, text-to-text, and image-to-text
 - Mode: Offline inference and OpenAI-compatible online serving
 - Maintainer: Community
 
@@ -26,6 +26,8 @@ parameters through the pipeline-declared `extra_args` contract.
   [`examples/offline_inference/text_to_image/text_to_image.py`](../../examples/offline_inference/text_to_image/text_to_image.py)
 - Related offline image-to-image example:
   [`examples/offline_inference/image_to_image/image_edit.py`](../../examples/offline_inference/image_to_image/image_edit.py)
+- Related offline understanding example:
+  [`examples/offline_inference/x_to_text/x_to_text.py`](../../examples/offline_inference/x_to_text/x_to_text.py)
 - Related online example:
   [`examples/online_serving/text_to_image/openai_chat_client.py`](../../examples/online_serving/text_to_image/openai_chat_client.py)
 - Related online image-to-image example:
@@ -118,6 +120,25 @@ The `--extra-args` JSON forwards BAGEL-specific parameters (e.g. `cfg_text_scale
 `cfg_img_scale`, `cfg_interval`, `cfg_renorm_type`) into
 `OmniDiffusionSamplingParams.extra_args` via the model-extras registry.
 
+Run text-to-text with the shared understanding example. BAGEL's default
+`bagel.yaml` deploy config is discovered from the checkpoint, so no model-specific
+example or explicit deploy config is required:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ByteDance-Seed/BAGEL-7B-MoT \
+  --prompt "Where is the capital of France?"
+```
+
+Add `--image` to run image-to-text with the same example:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ByteDance-Seed/BAGEL-7B-MoT \
+  --image /path/to/input.jpg \
+  --prompt "Please describe this image in detail."
+```
+
 #### Online Commands
 
 Start the OpenAI-compatible server:
diff --git a/recipes/Boogu/Boogu-Image.md b/recipes/Boogu/Boogu-Image.md
new file mode 100644
index 000000000..b9bff789f
--- /dev/null
+++ b/recipes/Boogu/Boogu-Image.md
@@ -0,0 +1,180 @@
+# Boogu-Image
+
+> Text-to-image and image-editing online serving (Boogu-Image-0.1-Base / -Edit)
+
+## Summary
+
+- Vendor: Boogu
+- Model: `Boogu/Boogu-Image-0.1-Base` (text-to-image), `Boogu/Boogu-Image-0.1-Edit` (image editing)
+- Task: Text-to-image generation and text-guided image editing (TI2I)
+- Mode: Online serving with the OpenAI-compatible API
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe when you want a known-good starting point for serving
+`Boogu/Boogu-Image-0.1-Base` with vLLM-Omni's native pipeline (no
+`--diffusion-load-format diffusers`, and the upstream `boogu` package is not
+required).
+
+Boogu-Image-0.1 is an Apache-2.0 unified image generation and editing model
+family. This recipe covers the Base text-to-image checkpoint, which pairs a
+Qwen3-VL multimodal encoder with a Diffusion Transformer (DiT) and a flow-match
+Euler scheduler with time-shift. It handles photorealistic generation and
+Chinese/English text rendering.
+
+## References
+
+- Upstream model card: <https://huggingface.co/Boogu/Boogu-Image-0.1-Base>
+- Project page: <https://boogu.org>
+- GitHub: <https://github.com/boogu-project/Boogu-Image>
+- Related example: [`examples/online_serving/text_to_image/`](../../examples/online_serving/text_to_image/README.md)
+
+## Hardware Support
+
+This recipe documents tested configurations for CUDA GPU serving. The native
+pipeline runs single-GPU; multi-GPU parallelism, CPU offload, and cache
+acceleration are not yet supported for this model (see Notes).
+
+## GPU
+
+### 1 x A100/H100 (Single GPU, 40GB+ VRAM)
+
+The model footprint is roughly 34.6 GiB on GPU, so a 40GB+ card is recommended.
+
+#### Command
+
+```bash
+vllm serve Boogu/Boogu-Image-0.1-Base --omni --port 8091
+```
+
+!!! note
+    If you hit Out-of-Memory (OOM) on a smaller card, enable VAE slicing and
+    tiling to reduce peak memory: `--vae-use-slicing --vae-use-tiling`.
+
+#### Verification
+
+After the server is ready, test with a simple request:
+
+```bash
+curl -X POST http://localhost:8091/v1/images/generations \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "Boogu/Boogu-Image-0.1-Base",
+    "prompt": "A mountain lake at sunset, photorealistic, cinematic lighting",
+    "size": "1024x1024",
+    "num_inference_steps": 28,
+    "guidance_scale": 4.0,
+    "seed": 42
+  }' | jq -r '.data[0].b64_json' | base64 -d > output.png
+```
+
+Or via the chat-completions endpoint (parameters go in `extra_body`):
+
+```bash
+curl -s http://localhost:8091/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "A mountain lake at sunset, photorealistic, cinematic lighting"}
+    ],
+    "extra_body": {
+      "height": 1024,
+      "width": 1024,
+      "num_inference_steps": 28,
+      "guidance_scale": 4.0,
+      "seed": 42
+    }
+  }' | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2- | base64 -d > output.png
+```
+
+#### Notes
+
+- **Memory usage:** ~34.6 GiB on GPU. Use `--vae-use-slicing --vae-use-tiling`
+  to trim peak VRAM if needed.
+- **Key flags:**
+  - `--omni` — enables vLLM-Omni diffusion serving.
+- **Guidance:** Boogu-Image uses `guidance_scale` (mapped to the upstream
+  `text_guidance_scale`); the default is `4.0`. Classifier-free guidance is
+  active whenever `guidance_scale > 1.0`.
+- **Recommended settings:** `num_inference_steps=28`-`50`, `guidance_scale=4.0`.
+  The model's maximum native resolution is 2K.
+- **Known limitations (not yet supported):** CPU offload
+  (`--enable-cpu-offload` / `--enable-layerwise-offload`), Cache-DiT
+  (`--cache-backend cache_dit`), and multi-GPU parallelism (TP / SP / CFG /
+  HSDP) are planned follow-ups and are not validated for this model yet.
+
+## Image editing (Boogu-Image-0.1-Edit)
+
+The Edit checkpoint is served by the same native pipeline (`BooguImagePipeline`);
+the image-editing (TI2I) path activates automatically when a request carries a
+reference image. The Base text-to-image path is unaffected (no reference image
+is sent).
+
+#### Command
+
+```bash
+vllm serve Boogu/Boogu-Image-0.1-Edit --omni --port 8091
+```
+
+#### Verification
+
+Edit an image with `/v1/images/edits` (the model-card example — change a photo
+to a colored-pencil drawing). Diffusion parameters are plain multipart form
+fields; add `guidance_scale_2` to enable image guidance (double-guidance path):
+
+```bash
+curl -s http://localhost:8091/v1/images/edits \
+  -F model="Boogu/Boogu-Image-0.1-Edit" \
+  -F image="@input.png" \
+  -F prompt="Change the style to a colored pencil drawing." \
+  -F num_inference_steps=28 \
+  -F guidance_scale=5.0 \
+  -F guidance_scale_2=2.0 \
+  -F seed=42 \
+  | jq -r '.data[0].b64_json' | base64 -d > edited.png
+```
+
+Or via chat completions (attach the image as a data URL; parameters go in
+`extra_body`):
+
+```bash
+curl -s http://localhost:8091/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": [
+        {"type": "image_url", "image_url": {"url": "data:image/png;base64,<BASE64>"}},
+        {"type": "text", "text": "Change the style to a colored pencil drawing."}
+      ]}
+    ],
+    "extra_body": {
+      "num_inference_steps": 28,
+      "guidance_scale": 5.0,
+      "guidance_scale_2": 1.0,
+      "seed": 42
+    }
+  }' | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2- | base64 -d > edited.png
+```
+
+#### Notes
+
+- **Single reference image:** only one input image is supported for now (the
+  upstream "Only support 1 reference image for now" limit).
+- **Guidance semantics:**
+  - `guidance_scale` = text guidance (upstream `text_guidance_scale`, default
+    `4.0`); `> 1.0` enables text CFG. Editing typically uses `5.0`.
+  - `guidance_scale_2` = image guidance (upstream `image_guidance_scale`,
+    default `1.0` = off). Setting it `> 1.0` enables the double-guidance path
+    (3 model predictions per step), steering more strongly toward the reference
+    image.
+- **Output resolution:** the output size follows the reference image (upstream
+  `align_res`, on by default for a single reference), so `height`/`width` are
+  derived from the input and requested sizes are not applied for edits.
+- **Same limitations** as the Base checkpoint apply (no CPU offload, Cache-DiT,
+  or multi-GPU parallelism yet).
+- **Offline editing:** the shared offline example
+  [`examples/offline_inference/image_to_image/image_edit.py`](../../examples/offline_inference/image_to_image/image_to_image.md)
+  supports Boogu-Image-Edit directly
+  (`--model Boogu/Boogu-Image-0.1-Edit --guidance-scale 5.0`, optional
+  `--guidance-scale-2`).
diff --git a/recipes/JD/JoyAI-VL-Interaction.md b/recipes/JD/JoyAI-VL-Interaction.md
index ed767830f..e09d5b16c 100644
--- a/recipes/JD/JoyAI-VL-Interaction.md
+++ b/recipes/JD/JoyAI-VL-Interaction.md
@@ -168,7 +168,7 @@ the model + orchestrator + WebUI together — point `WEBUI_DIR` at your clone.
 python examples/online_serving/joyvl_interaction/cli/run_cli_demo.py \
   path/to/video.mp4 --query "Alert me if a fire breaks out"
 
-pytest tests/fullduplex   # framework + JoyVL unit tests
+pytest tests/e2e/features/fullduplex   # framework + JoyVL unit tests
 ```
 
 ## Testing with an RTSP stream (optional)
diff --git a/recipes/LTX/LTX-2.3.md b/recipes/LTX/LTX-2.3.md
deleted file mode 100644
index c83a14883..000000000
--- a/recipes/LTX/LTX-2.3.md
+++ /dev/null
@@ -1,154 +0,0 @@
-# LTX-2.3
-
-> 22B parameter text-to-video + audio generation model served via vLLM-Omni
-
-## Summary
-
-- Vendor: Lightricks
-- Model: `dg845/LTX-2.3-Diffusers`
-- Task: Text-to-video and image-to-video with synchronized audio generation
-- Mode: Online serving (pure diffusion)
-- Maintainer: @oglok
-
-## When to use this recipe
-
-Use this recipe when you want to serve LTX-2.3 for text-to-video or
-image-to-video generation with audio. The model generates videos up to 20+
-seconds at 768x512 resolution with 48kHz audio from text prompts, and can
-condition video generation on an initial image. Start with a 96GB-class GPU for
-validation because the model combines a 22B parameter transformer with text
-encoder, VAE, and vocoder components.
-
-## References
-
-- Upstream raw checkpoints: <https://huggingface.co/Lightricks/LTX-2.3>
-- Diffusers-format checkpoint: <https://huggingface.co/dg845/LTX-2.3-Diffusers>
-- Requires `diffusers >= 0.38.0` (install from git: `pip install git+https://github.com/huggingface/diffusers.git`)
-
-## Serving
-
-### Command
-
-```bash
-vllm serve dg845/LTX-2.3-Diffusers \
-  --omni \
-  --model-class-name LTX23Pipeline \
-  --stage-init-timeout 600
-```
-
-For image-to-video:
-
-```bash
-vllm serve dg845/LTX-2.3-Diffusers \
-  --omni \
-  --model-class-name LTX23ImageToVideoPipeline \
-  --stage-init-timeout 600
-```
-
-### T2V Verification
-
-```bash
-# Health check
-curl http://localhost:8000/health
-
-# Generate a 3-second video (81 frames at 24fps)
-curl -X POST http://localhost:8000/v1/videos \
-  -F "prompt=A majestic bald eagle soaring over a misty mountain valley at dawn, golden sunlight breaking through clouds" \
-  -F "negative_prompt=blurry, low quality, distorted, watermark" \
-  -F "model=dg845/LTX-2.3-Diffusers" \
-  -F "num_frames=81" \
-  -F "fps=24" \
-  -F "size=768x512" \
-  -F "num_inference_steps=30" \
-  -F "guidance_scale=4.0" \
-  -F "seed=42"
-
-# Generate a 10-second video (241 frames)
-curl -X POST http://localhost:8000/v1/videos \
-  -F "prompt=A cozy Japanese ramen shop at night in the rain, steam rising from bowls, neon signs reflecting on wet cobblestone streets" \
-  -F "model=dg845/LTX-2.3-Diffusers" \
-  -F "num_frames=241" \
-  -F "fps=24" \
-  -F "size=768x512" \
-  -F "num_inference_steps=30" \
-  -F "guidance_scale=4.0"
-
-# Generate a 20-second video (481 frames)
-curl -X POST http://localhost:8000/v1/videos \
-  -F "prompt=An underwater coral reef teeming with tropical fish, sea turtles gliding gracefully, National Geographic documentary style" \
-  -F "model=dg845/LTX-2.3-Diffusers" \
-  -F "num_frames=481" \
-  -F "fps=24" \
-  -F "size=768x512" \
-  -F "num_inference_steps=30" \
-  -F "guidance_scale=4.0"
-```
-
-### I2V Verification
-
-Start the server with `--model-class-name LTX23ImageToVideoPipeline`, then pass
-an image reference. The I2V pipeline requires `input_reference` or
-`image_reference` because the first frame is the conditioning input.
-
-```bash
-curl http://localhost:8000/health
-
-curl -X POST http://localhost:8000/v1/videos/sync \
-  -F "prompt=A plush toy astronaut gently waving while the camera slowly pushes in." \
-  -F "input_reference=@/absolute/path/to/reference.png" \
-  -F "model=dg845/LTX-2.3-Diffusers" \
-  -F "num_frames=81" \
-  -F "fps=24" \
-  -F "size=768x512" \
-  -F "num_inference_steps=30" \
-  -F "guidance_scale=4.0" \
-  -F "seed=42" \
-  -o ltx23_i2v.mp4
-```
-
-### Notes
-
-- Memory usage: run a latest-head serving smoke or DFX benchmark on the target
-  GPU before publishing load/peak VRAM numbers.
-- Checkpoint format: use a Diffusers-format checkpoint such as
-  `dg845/LTX-2.3-Diffusers`; the upstream `Lightricks/LTX-2.3` repository ships
-  raw safetensors and does not contain the subfolder configs required by this
-  pipeline loader.
-- Key flags:
-  - `--stage-init-timeout 600`: Gives the initial `torch.compile` warmup enough time on large checkpoints
-  - `--model-class-name LTX23Pipeline`: Selects the LTX-2.3 text-to-video pipeline (not LTX-2)
-  - `--model-class-name LTX23ImageToVideoPipeline`: Selects the LTX-2.3 image-to-video pipeline
-  - `input_reference=@...`: Uploads the I2V reference image directly
-- Audio: 48kHz AAC via BWE vocoder, automatically synced with video
-- CPU offloading: Text encoder (Gemma-3-12B), connectors, VAE, audio VAE, and vocoder stay on CPU and are moved to GPU only when needed
-- Supported resolutions: 768x512, 512x384 (must be divisible by 32)
-- Frame rate: 24 fps
-- Duration: Controlled by `num_frames` (frames = duration_seconds * 24 + 1)
-- Known limitations:
-  - LTX-2.3 I2V currently supports first-frame image conditioning, matching the LTX image-conditioning contract.
-  - Requires `diffusers >= 0.38.0` (not yet on PyPI, install from git)
-
-## Hardware Support
-
-## GPU
-
-### 1x NVIDIA RTX PRO 6000 Blackwell (96GB)
-
-#### Environment
-
-- OS: Ubuntu 22.04
-- Python: 3.10+
-- Driver / runtime: CUDA 13.0, Driver 580.126.09
-- vLLM version: Match the PR or release checkout being validated
-- vLLM-Omni version or commit: Use the commit you are deploying from
-
-### Benchmarking
-
-Do not copy latency or VRAM numbers between commits or machines. Record them
-only after running a latest-head sweep on the target hardware.
-
-For formal PR benchmarking, reuse
-`tests/dfx/perf/tests/test_ltx2_3_vllm_omni.json` with
-`tests/dfx/perf/scripts/run_diffusion_benchmark.py`. That config captures the
-single-device eager baseline and CFG-parallel=2 case for a small 384x512,
-25-frame, 20-step workload.
diff --git a/recipes/LTX/LTX-2.md b/recipes/LTX/LTX-2.md
index df049f5c6..3142f9fd1 100644
--- a/recipes/LTX/LTX-2.md
+++ b/recipes/LTX/LTX-2.md
@@ -1,121 +1,337 @@
-# LTX-2
+# LTX-2 Family
 
-> Text-to-video and image-to-video serving
+> LTX-2 and LTX-2.3 text-to-video and image-to-video generation with synchronized audio
 
-## Summary
+## Pipelines
 
-- Vendor: Lightricks
-- Model: `Lightricks/LTX-2`
-- Task: Text-to-video generation and image-to-video generation
-- Mode: Online serving with the OpenAI-compatible video API
-- Maintainer: Community
+| Model | Checkpoint | Task | `--model-class-name` | Batching |
+|---|---|---|---|---|
+| LTX-2 | `Lightricks/LTX-2` | One-stage T2V/I2V | `LTX2Pipeline` | Yes |
+| LTX-2 distilled | `rootonchair/LTX-2-19b-distilled` | Two-stage T2V/I2V | `LTX2DistilledPipeline` | No |
+| LTX-2.3 | `diffusers/LTX-2.3-Diffusers` | One-stage T2V/I2V | `LTX2Pipeline` | Yes |
 
-## When to use this recipe
+`LTX2Pipeline` is the unified one-stage entry. Checkpoint metadata selects the
+LTX-2 or LTX-2.3 profile; omitting an image selects T2V, while one initial
+image selects I2V. Both one-stage repositories declare this class, so
+`--model-class-name` is optional. LTX-2.3 requires the Diffusers checkpoint;
+the raw `Lightricks/LTX-2.3` safetensors repository is not directly loadable.
 
-Use this recipe when you want to deploy the base `Lightricks/LTX-2` model
-for both text-to-video and image-to-video generation. The same model ID is used for
-both tasks; switch the pipeline class with `--model-class-name` depending on
-whether you want T2V or I2V.
+`LTX2DistilledPipeline` is the unified distilled entry: omit `image` for T2V
+or provide one initial image for I2V. As in the official LTX pipelines,
+distilled mode is selected explicitly rather than inferred from the checkpoint
+name or metadata; always pass `--model-class-name LTX2DistilledPipeline`.
+
+## API Migration
+
+Only `req` may be passed positionally to `LTX2Pipeline`; every optional
+`forward` argument is keyword-only:
+
+```python
+# No longer supported
+pipe(req, prompt)
+pipe(req, image, prompt)
+
+# Supported
+pipe(req, prompt=prompt)
+pipe(req, image=image, prompt=prompt)
+```
+
+The consolidation also removes these registry names without aliases:
+
+| Removed name | Replacement |
+|---|---|
+| `LTX23Pipeline` | `LTX2Pipeline`; checkpoint metadata selects LTX-2.3 |
+| `LTX2ImageToVideoPipeline` | `LTX2Pipeline` with `image=` |
+| `LTX23ImageToVideoPipeline` | `LTX2Pipeline` with `image=`; checkpoint metadata selects LTX-2.3 |
+| `LTX2TwoStagesPipeline` | `LTX2DistilledPipeline` |
+| `LTX2ImageToVideoTwoStagesPipeline` | `LTX2DistilledPipeline` with `image=` |
+
+Passing any second positional argument now raises `TypeError`. These changes
+affect direct Python callers and explicit `--model-class-name` overrides;
+offline and serving entrypoints already use named fields and are unaffected.
+
+## One-Stage Defaults
+
+| Parameter | LTX-2 | LTX-2.3 |
+|---|---:|---:|
+| Width × height | 768 × 512 | 768 × 512 |
+| Frames / frame rate | 121 / 24 | 121 / 24 |
+| Denoise steps | 40 | 30 |
+| Video/audio CFG | 3.0 / 7.0 | 3.0 / 7.0 |
+| Video/audio STG | 1.0 / 1.0 | 1.0 / 1.0 |
+| Video/audio modality guidance | 3.0 / 3.0 | 3.0 / 3.0 |
+| Video/audio rescale | 0.7 / 0.7 | 0.7 / 0.7 |
+| Video/audio STG blocks | `[29]` / `[29]` | `[28]` / `[28]` |
+
+The model recipe also supplies the default negative prompt. Top-level
+`guidance_scale` overrides both video and audio CFG values. The online video
+API defaults `num_frames` to `1`, so set it explicitly; the offline LTX scripts
+default to `121`.
+
+## Distilled Two-Stage Defaults
+
+| Parameter | Value |
+|---|---:|
+| Final width × height | 1536 × 1024 |
+| Stage 1 width × height | 768 × 512 |
+| Frames / frame rate | 121 / 24 |
+| Stage 1 / Stage 2 denoise steps | 8 / 3 |
+| Guidance | Fixed positive-only |
+
+The dimensions passed to the API are the final output dimensions and must be
+divisible by 64. Both one- and two-stage requests require `num_frames = 8k+1`.
+The distilled recipe fixes both sigma schedules; `num_inference_steps` must be
+`8` when supplied.
+
+## Serving
+
+Start either checkpoint:
+
+```bash
+vllm serve Lightricks/LTX-2 --omni --stage-init-timeout 600
+```
+
+```bash
+vllm serve diffusers/LTX-2.3-Diffusers --omni --stage-init-timeout 600
+```
+
+Start the distilled checkpoint with its two-stage entry:
+
+```bash
+vllm serve rootonchair/LTX-2-19b-distilled --omni \
+  --model-class-name LTX2DistilledPipeline --stage-init-timeout 600
+```
+
+The same server handles T2V and I2V. A T2V request using the selected recipe's
+default guidance is:
+
+```bash
+curl -X POST http://localhost:8000/v1/videos/sync \
+  -F "prompt=A cinematic close-up of ocean waves at golden hour." \
+  -F "negative_prompt=worst quality, inconsistent motion, blurry, jittery, distorted" \
+  -F "size=768x512" \
+  -F "num_frames=121" \
+  -F "fps=24" \
+  -F "seed=42" \
+  -o ltx_t2v.mp4
+```
+
+For I2V, provide exactly one initial image:
+
+```bash
+curl -X POST http://localhost:8000/v1/videos/sync \
+  -F "prompt=A plush toy astronaut gently waving while the camera slowly pushes in." \
+  -F "negative_prompt=worst quality, inconsistent motion, blurry, jittery, distorted" \
+  -F "input_reference=@/absolute/path/to/reference.png" \
+  -F "size=768x512" \
+  -F "num_frames=121" \
+  -F "fps=24" \
+  -F "seed=42" \
+  -o ltx_i2v.mp4
+```
+
+Use `image_reference` for a URL or JSON-safe image reference. Do not provide it
+together with `input_reference`.
+
+## Guidance
+
+LTX supports independent video/audio CFG, spatio-temporal guidance (STG),
+cross-modality guidance, and rescaling:
+
+| Parameter | Default | Effect | Alias |
+|---|---:|---|---|
+| `video_cfg_scale` | 3.0 | Video text CFG; `1.0` disables it | `video_cfg_guidance_scale` |
+| `audio_cfg_scale` | 7.0 | Audio text CFG; `1.0` disables it | `audio_cfg_guidance_scale` |
+| `video_stg_scale` | 1.0 | Video STG; `0.0` disables it | `video_stg_guidance_scale` |
+| `audio_stg_scale` | 1.0 | Audio STG; `0.0` disables it | `audio_stg_guidance_scale` |
+| `video_modality_scale` | 3.0 | Audio-to-video guidance; `1.0` disables it | `a2v_guidance_scale` |
+| `audio_modality_scale` | 3.0 | Video-to-audio guidance; `1.0` disables it | `v2a_guidance_scale` |
+| `video_rescale_scale` | 0.7 | Video guidance rescale; `0.0` disables it | — |
+| `audio_rescale_scale` | 0.7 | Audio guidance rescale; `0.0` disables it | — |
+| `video_stg_blocks` | `[29]` / `[28]` | Perturbed video transformer blocks | — |
+| `audio_stg_blocks` | `[29]` / `[28]` | Perturbed audio transformer blocks | — |
+
+The STG block defaults are shown as LTX-2 / LTX-2.3. A canonical name wins
+over its alias. Explicit top-level `guidance_scale` wins over both CFG fields;
+omit it for independent video/audio CFG.
+
+Pass these fields in online `extra_params` or offline `--extra-body`:
+
+```bash
+# Add to the curl request above
+-F 'extra_params={"video_cfg_scale":3.0,"audio_cfg_scale":7.0}'
+
+# Add to text_to_video.py or image_to_video.py
+--extra-body '{"video_cfg_scale":3.0,"audio_cfg_scale":7.0}'
+```
+
+### Guidance Parallelism
+
+For LTX, `cfg_parallel_size` is the number of ranks used to execute the
+complete guidance plan in parallel. Despite the legacy `cfg` name, it covers
+text CFG, STG, and cross-modality guidance passes; guidance rescaling is
+applied after all pass predictions are gathered.
+
+The default one-stage recipe has four Transformer passes per denoise step:
+`cond`, `uncond`, `ptb` (STG), and `mod` (cross-modality). The useful balanced
+configurations are therefore:
+
+| `--cfg-parallel-size` | Passes per rank | Guidance-slot utilization | Notes |
+|---:|---:|---:|---|
+| `1` | 4 | 100% | Single-rank fused guidance batch |
+| `2` | 2 | 100% | Recommended two-rank configuration |
+| `4` | 1 | 100% | One guidance pass per rank |
+
+Other positive sizes are accepted. When the pass count is not divisible by
+`cfg_parallel_size`, ranks are padded to an equal number of execution slots
+and LTX emits a warning with the expected utilization. For example, four
+passes on three ranks use six slots and have 66.7% guidance-slot utilization.
+
+Start an LTX-2.3 server with two-way guidance parallelism:
+
+```bash
+vllm serve diffusers/LTX-2.3-Diffusers --omni \
+  --cfg-parallel-size 2 --stage-init-timeout 600
+```
+
+The total device count is the product of `cfg_parallel_size` and the other
+configured parallel dimensions. Distilled pipelines use positive-only
+guidance, so `cfg_parallel_size > 1` does not provide guidance speedup for
+them.
+
+### Python API
+
+Normal per-request values belong in `OmniDiffusionSamplingParams`. Pass the
+resulting `DiffusionRequestBatch` as the only positional argument:
+
+```python
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+params = OmniDiffusionSamplingParams(
+    width=768,
+    height=512,
+    num_frames=121,
+    frame_rate=24.0,
+    num_inference_steps=30,
+    seed=42,
+    extra_args={"video_cfg_scale": 3.0, "audio_cfg_scale": 7.0},
+)
+req = DiffusionRequestBatch([
+    OmniDiffusionRequest(
+        prompt={"prompt": "Cherry blossoms moving in a light breeze"},
+        sampling_params=params,
+        request_id="ltx-example",
+    )
+])
+
+t2v_output = pipe(req)
+i2v_output = pipe(req, image=image)
+```
+
+Direct keyword arguments are low-level fallbacks, for example
+`pipe(req, prompt=prompt, width=768)`. Request fields take precedence unless
+noted below.
+
+### Complete `forward` Surface
+
+| Argument | Type/default | Meaning and constraints |
+|---|---|---|
+| `req` | `DiffusionRequestBatch`, required | Only positional argument; contains prompts and per-request sampling parameters. |
+| `image` | image or batch, `None` | Direct value wins over request images; no image selects T2V. I2V accepts one image per prompt, and a batch cannot mix T2V/I2V. |
+| `prompt` | string or list, `None` | Positive-text fallback; request prompts win. Mutually exclusive with `prompt_embeds`. |
+| `negative_prompt` | string or list, `None` | Fallback after request values and before the recipe default; mutually exclusive with negative embeddings. |
+| `height` | `int`, `None` | Request → direct value → recipe default; divisible by 32 one-stage or 64 distilled. |
+| `width` | `int`, `None` | Same precedence and alignment as `height`. |
+| `num_frames` | `int`, `None` | Request → direct value → recipe default; must be `8k+1` and also determines audio duration with `frame_rate`. |
+| `frame_rate` | `float`, `None` | Request `frame_rate` → request `fps` → direct value → recipe default. |
+| `num_inference_steps` | `int`, `None` | Request → direct value → recipe default; minimum 2 one-stage, fixed at 8 for distilled Stage 1. Custom one-stage `sigmas` determine actual steps. |
+| `sigmas` | list of float, `None` | One-stage only. Request values win; every request in a fused batch must use the same schedule. |
+| `timesteps` | list of int, `None` | Compatibility slot; LTX accepts only `None`. Use `sigmas`. |
+| `guidance_scale` | `float`, `None` | One-stage common video/audio CFG fallback; an explicit request value wins. Distilled two-stage uses fixed positive-only guidance. |
+| `guidance_rescale` | `float`, `None` | Accepts only `None` or `0.0`; use the modality rescale fields. |
+| `noise_scale` | `float`, `0.0` | Compatibility slot; LTX accepts only `0.0`. |
+| `num_videos_per_prompt` | `int`, `1` | Output-count fallback; positive request `num_outputs_per_prompt` wins. |
+| `generator` | generator or list, `None` | Explicit RNG; otherwise request generators/seeds are collated. Lists must match the effective output batch. |
+| `latents` | tensor, `None` | Request tensors win. One-stage accepts packed `[B, S, C]` and validated unpacked video layouts. |
+| `audio_latents` | tensor, `None` | One-stage initial audio latents; request tensors win and are collated. |
+| `prompt_embeds` | tensor, `None` | Precomputed positive conditioning; requires `prompt_attention_mask` and cannot accompany `prompt`. |
+| `negative_prompt_embeds` | tensor, `None` | One-stage precomputed negative conditioning; requires its mask and cannot accompany `negative_prompt`. |
+| `prompt_attention_mask` | tensor, `None` | Mask for positive embeddings; request `prompt_attention_mask` or `attention_mask` wins. |
+| `negative_prompt_attention_mask` | tensor, `None` | Mask for negative embeddings; request negative mask fields win. |
+| `decode_timestep` | float or list, `0.0` | Video-VAE decode timestep; request value wins. Lists may match 1, prompt batch, or output batch. |
+| `decode_noise_scale` | float or list, `None` | Same list rules; request value wins. Defaults to `decode_timestep`. |
+| `output_type` | string, `"np"` | Request value wins. `"np"` decodes output; `"latent"` skips VAE/vocoder decode. |
+| `return_dict` | `bool`, `True` | Compatibility slot; only `True` is accepted. |
+| `attention_kwargs` | dict, `None` | Per-call values are unsupported; configure attention at engine startup. |
+| `max_sequence_length` | `int`, `None` | Request → direct value → tokenizer limit. |
+
+Request-object naming differs only in a few places: `num_videos_per_prompt`
+maps to `num_outputs_per_prompt`; images and prompt text/embeddings live in the
+request prompt payload; LTX guidance fields live in sampling `extra_args`.
+
+### Recipe-Specific Request Capabilities
+
+| Override | One-stage | Distilled two-stage |
+|---|---|---|
+| Guidance | Supported | Fixed positive-only |
+| Negative prompt/embeddings | Supported | Rejected |
+| `num_inference_steps` | Supported | Fixed at 8 for Stage 1; Stage 2 uses 3 |
+| Custom `sigmas` | Supported | Rejected; both phases use fixed schedules |
+| Video/audio latents | Supported | Rejected |
+
+These capability checks apply equally to direct `forward` keywords and
+values in `OmniDiffusionSamplingParams`; unsupported values fail instead of
+being silently ignored.
+
+### Custom Sigma Schedules
+
+One-stage Python requests may set final scheduler boundaries directly:
+
+```python
+params = OmniDiffusionSamplingParams(sigmas=[1.0, 0.75, 0.5, 0.25])
+```
+
+Each nonterminal value produces one denoise step, and a terminal `0.0` is
+appended when omitted. This schedule overrides `num_inference_steps`. All
+requests in a fused batch must use the same list. The video form API and
+bundled offline CLI do not currently expose `sigmas`.
+
+### Constraints
+
+- LTX rejects non-default `timesteps`, `flow_shift`, `guidance_rescale`,
+  `noise_scale`, `attention_kwargs`, and `return_dict=False`. Use final
+  `sigmas`, modality rescale fields, startup attention configuration, and the
+  standard `DiffusionOutput` respectively.
+- Fused one-stage requests must resolve to identical LTX guidance and sigma
+  schedules. Keep concurrent requests guidance-homogeneous or use
+  `--max-num-seqs 1`.
+- `--cfg-parallel-size` shards the complete LTX guidance plan, including STG,
+  modality guidance, and rescale-compatible prediction gathering.
+
+## Operational Notes
+
+- LTX-2 one-stage previously loaded and peaked at about 73.5 GiB on one H200
+  141GB; remeasure on the deployed commit and hardware.
+- LTX-2.3 includes a 22B transformer, Gemma encoder, two VAEs, and a vocoder.
+  Start on a 96GB-class GPU or use CPU/layerwise offload on smaller devices.
+- The distilled upsampler uses the configured pipeline dtype and participates
+  in component discovery/device placement; it remains resident during denoise
+  offload because it is used only at the phase boundary.
+- The output audio sample rate comes from the loaded components and is not a
+  request parameter.
+- For benchmarks, use `tests/dfx/perf/tests/test_ltx2_vllm_omni.json` with
+  `tests/dfx/perf/scripts/run_diffusion_benchmark.py`.
+- Current two-stage support is limited to the distilled checkpoint; official
+  LTX two-stage/HQ execution remains out of scope.
 
 ## References
 
-- Model: <https://huggingface.co/Lightricks/LTX-2>
-- User guide:
-  [`docs/user_guide/examples/online_serving/text_to_video.md`](../../docs/user_guide/examples/online_serving/text_to_video.md)
-- Example guide:
-  [`examples/online_serving/text_to_video/README.md`](../../examples/online_serving/text_to_video/README.md)
-  [`examples/online_serving/image_to_video/README.md`](../../examples/online_serving/image_to_video/README.md)
-
-## Hardware Support
-
-## GPU
-
-### 1x H200 141GB (Text-to-Video)
-
-#### Environment
-
-- OS: Ubuntu 22.04.5 LTS
-- Python: 3.12+
-- Driver / runtime: NVIDIA CUDA environment with H200 141GB GPU
-- vLLM version: Match the repository requirements from your current checkout
-- vLLM-Omni version or commit: Use the commit you are deploying from
-
-#### Command
-
-```bash
-vllm serve Lightricks/LTX-2 \
-  --omni \
-  --model-class-name LTX2Pipeline
-```
-
-#### Verification
-
-```bash
-curl http://localhost:8000/health
-
-curl -X POST http://localhost:8000/v1/videos \
-  -F "prompt=A cinematic close-up of ocean waves at golden hour." \
-  -F "negative_prompt=worst quality, inconsistent motion, blurry, jittery, distorted" \
-  -F "width=512" \
-  -F "height=768" \
-  -F "num_frames=121" \
-  -F "fps=24" \
-  -F "num_inference_steps=40" \
-  -F "guidance_scale=4.0" \
-  -o ltx2_t2v_h200.mp4
-```
-
-#### Notes
-
-- Memory usage: Model loads at ~73.5GB, peaks at ~73.5 GiB during inference.
-- Key flags:
-  - `--model-class-name LTX2Pipeline` selects the text-to-video pipeline explicitly.
-- Known limitations:
-  - This recipe is tested on 1x H200 validation; add measured latency and VRAM after running it on your target machine.
-
-### 1x H200 141GB (Image-to-Video)
-
-#### Environment
-
-- OS: Ubuntu 22.04.5 LTS
-- Python: 3.12+
-- Driver / runtime: NVIDIA CUDA environment with H200 141GB GPU
-- vLLM version: Match the repository requirements from your current checkout
-- vLLM-Omni version or commit: Use the commit you are deploying from
-
-#### Command
-
-```bash
-vllm serve Lightricks/LTX-2 \
-  --omni \
-  --model-class-name LTX2ImageToVideoPipeline
-```
-
-#### Verification
-
-```bash
-curl http://localhost:8000/health
-
-curl -X POST http://localhost:8000/v1/videos/sync \
-  -F "prompt=A plush toy astronaut gently waving while the camera slowly pushes in." \
-  -F "input_reference=@/absolute/path/to/reference.png" \
-  -F "width=512" \
-  -F "height=768" \
-  -F "num_frames=121" \
-  -F "fps=24" \
-  -F "num_inference_steps=40" \
-  -F "guidance_scale=4.0" \
-  -o ltx2_i2v_h200.mp4
-```
-
-#### Notes
-
-- Memory usage: Model loads at ~73.5GB, peaks at ~73.5 GiB during inference.
-- Key flags:
-  - `--model-class-name LTX2ImageToVideoPipeline` switches the same `Lightricks/LTX-2` weights into image-to-video mode.
-  - `input_reference=@...` uploads the reference image directly
-- Known limitations:
-  - Use `image_reference` when you want to pass a URL or JSON-safe image reference
-instead of uploading a file.
-  - Do not send `input_reference` and `image_reference` in the same request.
-  - This recipe is tested on 1x H200 validation; add measured latency and VRAM after running it on your target machine.
+- <https://huggingface.co/Lightricks/LTX-2>
+- <https://huggingface.co/Lightricks/LTX-2.3>
+- <https://huggingface.co/diffusers/LTX-2.3-Diffusers>
+- [Online video generation](../../docs/user_guide/examples/online_serving/text_to_video.md)
+- [Diffusion execution modes](../../docs/user_guide/diffusion/execution_modes.md)
+- [T2V offline example](../../examples/offline_inference/text_to_video/text_to_video.md)
+- [I2V offline example](../../examples/offline_inference/image_to_video/README.md)
diff --git a/recipes/MammothModa2/MammothModa2-Preview.md b/recipes/MammothModa2/MammothModa2.md
similarity index 58%
rename from recipes/MammothModa2/MammothModa2-Preview.md
rename to recipes/MammothModa2/MammothModa2.md
index 0733b0630..7056a6f8f 100644
--- a/recipes/MammothModa2/MammothModa2-Preview.md
+++ b/recipes/MammothModa2/MammothModa2.md
@@ -1,19 +1,19 @@
-# MammothModa2-Preview
+# MammothModa2
 
-> MammothModa2-Preview text-to-image generation through the shared offline image example
+> MammothModa2-Preview and MammothModa2-Dev unified understanding and generation
 
 ## Summary
 
 - Vendor: ByteDance Research
-- Model: `bytedance-research/MammothModa2-Preview`
-- Task: Text-to-image generation (AR → DiT two-stage pipeline)
+- Models: `bytedance-research/MammothModa2-Preview`, `bytedance-research/MammothModa2-Dev`
+- Tasks: Preview and Dev text-to-image (AR → DiT); Dev text/image understanding
 - Mode: Offline inference
 - Maintainer: Community
 
 ## When to use this recipe
 
-Use this recipe to run MammothModa2-Preview text-to-image through the shared
-offline image example (`text_to_image.py`) instead of a model-specific script.
+Use this recipe to run MammothModa2-Preview through shared task-oriented
+offline examples. Text-to-image uses the shared image example (`text_to_image.py`) instead of a model-specific script.
 The generic example formats the AR prompt, drives the AR → DiT stage pipeline,
 and forwards MammothModa2-specific generation parameters through the
 pipeline-declared `extra_body` contract.
@@ -28,8 +28,12 @@ flags. Image size uses the standard `--height` / `--width` flags.
 
 - Upstream model:
   [`bytedance-research/MammothModa2-Preview`](https://huggingface.co/bytedance-research/MammothModa2-Preview)
+- Dev model:
+  [`bytedance-research/MammothModa2-Dev`](https://huggingface.co/bytedance-research/MammothModa2-Dev)
 - Related offline example:
   [`examples/offline_inference/text_to_image/text_to_image.py`](../../examples/offline_inference/text_to_image/text_to_image.py)
+- Related T2T/I2T example:
+  [`examples/offline_inference/x_to_text/x_to_text.py`](../../examples/offline_inference/x_to_text/x_to_text.py)
 - Declared parameters:
   [`vllm_omni/model_extras/mammothmodal2_preview.py`](../../vllm_omni/model_extras/mammothmodal2_preview.py)
 - Deploy config:
@@ -99,6 +103,25 @@ so unknown keys for MammothModa2 are silently dropped:
 
 `--height` and `--width` must be multiples of 16.
 
+Run text-to-text through the shared understanding example. It recognizes the
+MammothModa2 checkpoint and automatically selects `mammoth_moda2_ar.yaml`:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ./MammothModa2-Preview \
+  --prompt "Explain multimodal generation in three sentences."
+```
+
+Add an image for image-to-text or image summarization. The shared example
+uses MammothModa2's chat and vision-token template:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ./MammothModa2-Preview \
+  --image /path/to/input.jpg \
+  --prompt "Please summarize the content of this image."
+```
+
 #### Verification
 
 The example writes the generated image to the `--output` path. Confirm the file
@@ -108,3 +131,44 @@ exists and is a valid image:
 ls -lh mammoth_t2i.png
 python -c "from PIL import Image; print(Image.open('mammoth_t2i.png').size)"
 ```
+
+## MammothModa2-Dev unified inference
+
+MammothModa2-Dev uses a Qwen3-VL AR backbone, while MammothModa2-Preview uses
+Qwen2.5-VL. vLLM-Omni selects the matching implementation from the nested
+`llm_config.model_type`; no checkpoint edits or `trust_remote_code` flag are
+required.
+
+Text-to-text and image-to-text use the AR-only deploy. Text-to-image loads the
+Qwen3 generation experts (`gen_mlp`), extra visual vocabulary and image head,
+then sends the generated visual tokens and hidden states to the DiT stage.
+
+Download the checkpoint:
+
+```bash
+hf download bytedance-research/MammothModa2-Dev --local-dir ./MammothModa2-Dev
+```
+
+Run text-to-text through the shared understanding example. It recognizes the
+Dev checkpoint as MammothModa2 and automatically selects
+`mammoth_moda2_ar.yaml`:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ./MammothModa2-Dev \
+  --prompt "Explain multimodal generation in three sentences."
+```
+
+Add an image for image-to-text or image summarization:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model ./MammothModa2-Dev \
+  --image ./image.png \
+  --prompt "Please summarize the content of this image."
+```
+
+The Dev checkpoint is approximately 47.55 GiB on disk. In the verified AR-only
+run, loaded model weights used approximately 16.97 GiB of GPU memory before KV
+and encoder caches. Allow additional GPU memory for those caches and the input
+image.
diff --git a/recipes/MiniMaxAI/MiniMax-H3-5090.md b/recipes/MiniMaxAI/MiniMax-H3-5090.md
new file mode 100644
index 000000000..fb8b0f118
--- /dev/null
+++ b/recipes/MiniMaxAI/MiniMax-H3-5090.md
@@ -0,0 +1,61 @@
+# MiniMax-H3 on RTX 5090
+
+This recipe uses BF16 weights, tiled VAE decode, tensor parallelism where a
+second GPU is available, and distributed layerwise offload (DLO). It is a
+memory-first serving configuration; lower resident counts reduce HBM use and
+increase CPU-to-GPU transfer time.
+
+## Capacity requirements
+
+| Resource | One RTX 5090 | Two RTX 5090s |
+| --- | ---: | ---: |
+| GPU HBM | 32 GiB | 32 GiB per GPU |
+| Checkpoint storage | 135 GiB per partition | 135 GiB per partition |
+| Available system RAM | 200 GiB minimum | 200 GiB minimum |
+| Recommended system RAM | 384 GiB | 384 GiB |
+
+`FL2VA` and `Ref2VA` are separate 135 GiB checkpoint partitions. Start one
+server at a time. DLO keeps rank-local weights in pinned host memory; increasing
+`--dlo-resident-layers` improves latency but does **not** reduce host RAM in the
+current implementation because resident layers retain pinned CPU master copies.
+
+> **Modular H3:** after #5720 lands, preserve this recipe's one-partition
+> behavior with `--task-type fl2va` or `--task-type ref2va`.
+
+## One RTX 5090: 1344x768, 5 seconds
+
+Use 12 resident DiT layers. A 50-step B300 allocation test with this exact
+single-rank topology peaked at 26.50 GiB; re-measure peak HBM on the target
+card before increasing the resident count.
+
+```bash
+CUDA_VISIBLE_DEVICES=0 vllm serve /path/to/MiniMax-H3/FL2VA \
+  --omni --trust-remote-code --host 0.0.0.0 --port 8000 \
+  --num-gpus 1 --tensor-parallel-size 1 --text-encoder-tp-size 1 \
+  --usp 1 --ring 1 --vae-patch-parallel-size 1 \
+  --vae-parallel-mode tile --vae-use-tiling \
+  --enable-distributed-layerwise-offload --dlo-no-use-allgather \
+  --dlo-resident-layers 12 --enforce-eager \
+  --diffusion-attention-backend CUDNN_ATTN
+```
+
+## Two RTX 5090s: 1344x768, 5 seconds
+
+Use TP2 and 20 resident DiT layers. The two-rank B300 capacity run peaked at
+27,726 MiB per rank for this shape and 50 steps. This is a memory/correctness
+proxy, not a consumer-GPU latency claim.
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1 vllm serve /path/to/MiniMax-H3/FL2VA \
+  --omni --trust-remote-code --host 0.0.0.0 --port 8000 \
+  --num-gpus 2 --tensor-parallel-size 2 --text-encoder-tp-size 2 \
+  --usp 1 --ring 1 --vae-patch-parallel-size 2 \
+  --vae-parallel-mode tile --vae-use-tiling \
+  --enable-distributed-layerwise-offload --dlo-no-use-allgather \
+  --dlo-resident-layers 20 --enforce-eager \
+  --diffusion-attention-backend CUDNN_ATTN
+```
+
+For Ref2VA, stop the FL2VA server and restart the same command with
+`/path/to/MiniMax-H3/Ref2VA`. Ref2VA reference video count and prompt length
+can increase activation memory; begin with one request at a time.
diff --git a/recipes/MiniMaxAI/MiniMax-H3-MUSA.md b/recipes/MiniMaxAI/MiniMax-H3-MUSA.md
new file mode 100644
index 000000000..8d5053759
--- /dev/null
+++ b/recipes/MiniMaxAI/MiniMax-H3-MUSA.md
@@ -0,0 +1,146 @@
+# MiniMax H3 on Moore Threads MUSA
+
+> Joint video and audio generation on Moore Threads GPUs
+
+## Summary
+
+- Vendor: MiniMaxAI
+- Model: [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- Tasks: T2VA, FL2VA, and Ref2VA
+- Mode: OpenAI-compatible `/v1/videos` HTTP serving
+- Hardware: 4x Moore Threads MTT S5000 for the validated Ref2VA profile
+- Maintainer: Community
+
+This recipe adapts [MiniMax-H3.md](MiniMax-H3.md) for MUSA environments.
+The modular H3 pipeline can load both task-specific DiTs, but this MUSA recipe
+uses a **single task partition**: `FL2VA` for `t2va`/`fl2va`, or `Ref2VA` for
+`ref2va`. This avoids loading both DiTs.
+
+## Prerequisites
+
+### Checkpoint
+
+Download the partition required by the selected startup task. The commands below
+run a single-task server; do not use the modular default (combined) mode on MUSA
+until its two-DiT memory and performance profile is validated.
+
+For T2VA and FL2VA:
+
+```bash
+python -m pip install modelscope
+export MODEL_ROOT=/path/to/MiniMax-H3
+modelscope download MiniMax/MiniMax-H3 \
+  --local_dir "${MODEL_ROOT}" \
+  --max-workers 16 \
+  --include 'FL2VA/**'
+```
+
+For Ref2VA, download `Ref2VA/**` instead.
+
+### Environment
+
+Install a compatible PyTorch/torch-musa, torchada, MATE, and vLLM-MUSA
+stack before installing vLLM-Omni. Importing vLLM-Omni should report that the
+`musa` vLLM platform plugin is active.
+
+Install vLLM-Omni from a checkout containing MiniMax H3 support:
+
+```bash
+python -m pip install -e .
+```
+
+MiniMax H3 reference inputs and MP4 output require `soundfile`, `ffmpeg`, and
+`ffprobe`. The Python dependency is installed by vLLM-Omni; install the two
+executables with the operating system package manager and verify them:
+
+```bash
+python -c 'import soundfile; print(soundfile.__version__)'
+ffmpeg -version
+ffprobe -version
+```
+
+When torchaudio cannot load TorchCodec, vLLM-Omni automatically falls back to
+soundfile. Formats that libsndfile cannot read are demuxed through ffmpeg.
+
+## Start a server
+
+Use the partition path and set `--task-type` explicitly: `fl2va` for T2VA/FL2VA
+or `ref2va` for Ref2VA.
+
+The validated Ref2VA configuration uses tensor parallelism across four MTT S5000 GPUs and offloads inactive model components to CPU:
+
+```bash
+export MODEL="${MODEL_ROOT}/Ref2VA"
+export PORT=8091
+
+MUSA_VISIBLE_DEVICES=0,1,2,3 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 4 \
+  --task-type ref2va \
+  --tensor-parallel-size 4 \
+  --vae-patch-parallel-size 4 \
+  --enable-cpu-offload \
+  --vae-use-tiling \
+  --diffusion-attention-backend FLASH_ATTN
+```
+
+On MUSA, `FLASH_ATTN` selects the MATE/FlashAttention-3 implementation. Do
+not install the CUDA-only `fa4` optional dependency.
+
+For request examples and parameter definitions, see
+[MiniMax-H3.md](MiniMax-H3.md#http-api-examples).
+
+## MUSA validation
+
+The following weight-independent gates have been validated on one MTT S5000:
+
+- packed variable-length attention selects MATE FlashAttention-3 and returns
+  finite BF16 output;
+- MiniMax H3 RoPE casts CPU FP64 position metadata to FP32 before device
+  arithmetic and returns finite output;
+- the video-VAE seeded RNG context is deterministic on MUSA and restores both
+  CPU and MUSA RNG states;
+- the soundfile fallback preserves stereo channel layout, FP32 samples, and
+  the native sample rate when torchaudio/TorchCodec is unavailable.
+
+Ref2VA image+audio generation was also validated end to end on one MTT S5000
+with CPU offload and VAE tiling. The smoke used a 448x256 reference image, a
+four-second 32 kHz stereo audio reference, two denoising steps, and seed 42.
+The synchronous HTTP request completed in 50.6 seconds and returned an MP4
+with the following decoded properties:
+
+- 107 video frames at 448x256 and 24 FPS;
+- non-static video (`pixel_std=13.07`, `temporal_delta=0.49`);
+- finite stereo audio at 32 kHz (`audio_rms=0.0458`).
+
+Official Ref2VA video-reference serving was validated with the expanded
+MiniMax prompt at 1344x768, 5 seconds, seed 0, and 50 steps. A true TP4 run on
+four MTT S5000 GPUs returned HTTP 200 in 638.6 seconds and produced 124 H.264
+frames at 24 FPS with AAC stereo audio at 32 kHz.
+
+Keep `--vae-use-tiling` enabled for this serving profile.
+
+## Known limitations
+
+- Keep Ring Attention at degree 1. The current Ring path does not preserve
+  MiniMax H3 packed padding boundaries.
+- H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1.
+- This MUSA recipe uses an explicitly selected single task partition; combined
+  serving loads both DiTs.
+- H3 currently executes one generation request per diffusion batch.
+- FP8 quantization has not been enabled for MiniMax H3.
+- MP3, M4A, MP4, and reference-video audio fallback requires `ffmpeg` on
+  `PATH`; WAV inputs can be read directly through soundfile.
+
+## Additional resources
+
+- [MiniMax-H3.md](MiniMax-H3.md) — full model and API guide
+- [MiniMax-H3-NPU.md](MiniMax-H3-NPU.md) — Ascend NPU deployment guide
+- [Supported models](../../docs/models/supported_models.md)
+- [Video API](../../docs/serving/videos_api.md)
diff --git a/recipes/MiniMaxAI/MiniMax-H3-NPU.md b/recipes/MiniMaxAI/MiniMax-H3-NPU.md
new file mode 100755
index 000000000..930411f1a
--- /dev/null
+++ b/recipes/MiniMaxAI/MiniMax-H3-NPU.md
@@ -0,0 +1,187 @@
+# MiniMax H3 on Ascend NPU
+
+> Joint video and audio generation with text, first/last keyframes, and mixed
+> image/video/audio references — Ascend NPU deployment guide
+
+## Summary
+
+- Vendor: MiniMaxAI
+- Model: [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- Tasks: T2VA, FL2VA, and Ref2VA
+- Mode: OpenAI-compatible `/v1/videos` HTTP serving
+- Hardware: Atlas 800I A3
+- Maintainer: Community
+
+This recipe adapts [MiniMax-H3.md](MiniMax-H3.md) for Ascend NPU
+environments. Differences from the GPU path:
+
+- Runs on a CPU-only (aarch64) PyTorch build with `torch_npu`; no CUDA
+  runtime is present.
+- Audio loading does **not** require TorchCodec (whose aarch64 wheels are
+  built against CUDA torch and fail to load on CPU-only builds). vLLM-Omni
+  automatically falls back to soundfile / ffmpeg for wav/mp3/m4a/mp4 audio
+  inputs.
+
+## Prerequisites
+
+### Checkpoint
+
+Same as the GPU recipe — Hugging Face access approval is required. Authenticate
+once; `vllm serve` downloads the required nested components automatically:
+
+```bash
+hf auth login
+export MODEL=MiniMaxAI/MiniMax-H3
+```
+
+### Environment
+
+- Ascend driver & firmware: 25.5.1
+- CANN toolkit: 9.0.1
+- Python: 3.12
+- PyTorch: 2.10.0+cpu
+- torch_npu: 2.10.0.post2
+- Install vLLM-Omni from a checkout with MiniMax H3 support:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+Install the **mindie-sd** operator library to enable Ascend-optimized fused
+operators (`adalayernorm`, etc.) and the RainFusion `rf_v2` block-sparse
+attention kernel:
+
+```bash
+git clone https://gitcode.com/Ascend/MindIE-SD.git && cd MindIE-SD
+
+# Comment out the tik_ops build step (not needed for this use case)
+sed -i 's|^\(\s*\)source ${current_script_dir}/build_tik_ops.sh|\1# source ${current_script_dir}/build_tik_ops.sh|' build/build_ops.sh
+
+python setup.py bdist_wheel
+cd dist
+pip install mindiesd-*.whl
+```
+
+- `ffmpeg` and `ffprobe` must be available on `PATH`. They are used for
+  reference-video preparation and MP4 output.
+- Reference-video decoding uses `decord` when available and falls back to
+  PyAV otherwise.
+- Audio inputs do not require TorchCodec: wav/mp3/m4a/mp4 files are loaded
+  at native sample rate through the soundfile / ffmpeg fallback.
+
+## Start a server
+
+Pass the repository ID directly. The pipeline loads the two nested DiTs while
+sharing the tokenizer, processor, text encoder, and VAEs from `FL2VA`.
+
+### Multi-NPU: 768P combined-service configuration
+
+Use Ulysses sequence parallelism degree 8, text-encoder tensor parallelism
+degree 8, native tiled VAE patch parallelism degree 8, and layerwise offload:
+
+```bash
+export ASCEND_RT_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+export PORT=9098
+export MODEL=MiniMaxAI/MiniMax-H3
+export VLLM_WORKER_MULTIPROC_METHOD=spawn
+export VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800
+export PYTHONDONTWRITEBYTECODE=1
+
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 8 \
+  --usp 8 \
+  --ring 1 \
+  --text-encoder-tp-size 8 \
+  --enable-layerwise-offload \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --vae-patch-parallel-size 8 \
+  --diffusion-attention-backend FLASH_ATTN
+```
+
+Do not add `--enforce-eager`. The first request includes regional
+compilation; warm the server once before measuring steady-state latency.
+H3 is CFG-distilled, so `--cfg-parallel-size` must remain 1.
+
+The same endpoint accepts `task=t2va`, `task=fl2va`, and `task=ref2va`; no
+partition restart is required. Layerwise offload applies to both DiTs.
+
+### Optional optimizations
+
+Two independent optimizations may be enabled on top of the configuration
+above. Both are validated for T2VA only.
+
+**RainFusion block-sparse attention** — switch the attention backend, keeping
+every other flag unchanged:
+
+```bash
+  --diffusion-attention-backend RAINFUSION_ATTN
+```
+
+**INT8 online quantization** — add one flag to the server command above:
+
+```bash
+  --quantization int8
+```
+
+Keep `--ring 1` when using RainFusion: the `rf_v2` kernel ranks key blocks
+over the whole sequence, so ring parallelism would split away the keys it
+needs. Scale with `--usp` instead.
+
+## HTTP API examples
+
+The request format is identical to the GPU recipe; see
+[MiniMax-H3.md § HTTP API examples](MiniMax-H3.md#http-api-examples).
+Use the validated 768P shapes (e.g. `width=1344 height=768`) on NPU.
+
+## Key parameters
+
+Same as the GPU recipe; see
+[MiniMax-H3.md § Key parameters](MiniMax-H3.md#key-parameters).
+The validated resolution on NPU is 768P (e.g. 1344x768).
+
+## Validated NPU evidence
+
+Measured on an Atlas 800I A3 server (8x NPU) with CANN 9.0.1,
+PyTorch 2.10.0+cpu, and torch_npu 2.10.0.post2, using the multi-NPU
+configuration above:
+
+| Workload | Configuration |
+|----------|---------------|
+| T2VA, 209 frames, 1344x768 | TE TP8, layerwise offload, Ulysses 8, VPP8 tile, regional compile |
+| Ref2VA (prompt + video), 124 frames, 1344x768 | TE TP8, layerwise offload, Ulysses 8, VPP8 tile, regional compile |
+
+These measurements describe the validated shapes rather than a general
+throughput guarantee.
+
+## Known limitations
+
+- Combined serving requires sibling `FL2VA` and `Ref2VA` directories, loads
+  both task-specific DiTs, and loads one copy of every shared component.
+- H3 currently executes one generation request per diffusion batch.
+- The first regional-compile request is a warmup and should not be included
+  in steady-state performance measurements.
+- The official H3 input matrix and media limits are documented in the [GPU
+  recipe](MiniMax-H3.md#official-input-matrix-and-limits); this NPU path uses
+  the same HTTP request contract.
+- VAE patch parallelism requires size 1 or the full DiT group size and
+  supports the H3 native `tile` mode only.
+- RainFusion block-sparse attention and INT8 quantization are validated for
+  T2VA only; use the BF16 dense configuration for FL2VA and Ref2VA.
+- Online quantization cannot be combined with distributed layerwise offload
+  while AllGather is enabled; pass `--dlo-no-use-allgather` in that case.
+
+## Additional resources
+
+- [MiniMax-H3.md](MiniMax-H3.md) — full GPU guide
+- [Attention backends § RAINFUSION_ATTN](../../docs/user_guide/diffusion/attention_backends.md#rainfusion_attn-backend-and-block-sparse-video-attention)
+  — RainFusion knobs and tuning
+- [Int8 quantization](../../docs/user_guide/quantization/int8.md)
+- [Supported models](../../docs/models/supported_models.md)
+- [Video API](../../docs/serving/videos_api.md)
diff --git a/recipes/MiniMaxAI/MiniMax-H3.md b/recipes/MiniMaxAI/MiniMax-H3.md
new file mode 100644
index 000000000..cfe9b5796
--- /dev/null
+++ b/recipes/MiniMaxAI/MiniMax-H3.md
@@ -0,0 +1,639 @@
+# MiniMax H3
+
+> Joint video and audio generation with text, first/last keyframes, and
+> mixed image/video/audio references
+
+## Summary
+
+- Vendor: MiniMaxAI
+- Model: [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- Tasks: T2VA, FL2VA, and Ref2VA
+- Mode: OpenAI-compatible `/v1/videos` HTTP serving
+- Maintainer: Community
+
+MiniMax H3 is a CFG-distilled joint video/audio diffusion transformer. Its
+checkpoint has two task-specific DiT partitions:
+
+- `FL2VA`: text-to-video+audio (`t2va`) and first-frame-to-video+audio
+  (`fl2va`)
+- `Ref2VA`: up to 9 images, 3 videos, and 3 audio references in supported
+  image/video/audio combinations (`ref2va`; audio-only is rejected)
+
+One vLLM-Omni diffusion stage can load both DiTs while instantiating the
+tokenizer, processor, Qwen3-VL text encoder, video VAE, and audio VAE only
+once. Requests select the DiT with `extra_params.task`.
+
+The generated MP4 contains H.264 video and synchronized stereo audio.
+
+## Prerequisites
+
+The checkpoint requires Hugging Face access approval. Authenticate once;
+`vllm serve` downloads the required components automatically:
+
+```bash
+hf auth login
+export MODEL=MiniMaxAI/MiniMax-H3
+```
+
+The vLLM-Omni pipeline downloads `FL2VA/**`, `Ref2VA/model_index.json`, and
+`Ref2VA/transformer/**`. It does not download or load the diffusers-format
+`transformer`, `transformer_ref`, or `vae` weights at the repository root, nor
+duplicate Ref2VA copies of shared components.
+
+Install vLLM-Omni from the checkout containing MiniMax H3 support. The
+two-GPU RTX 5090/4090 profiles use cuDNN attention and do not need
+FlashAttention-4. Install the optional dependency only for the four-GPU
+B300/GB200 `FLASH_ATTN` profile:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+To keep FA4 available as an explicit option on Blackwell, install the
+FlashAttention-4 extra:
+
+```bash
+uv pip install -e '.[fa4]'
+```
+
+`ffmpeg` and `ffprobe` must be available on `PATH`. They are used for
+reference-video preparation and MP4 output.
+
+## Start a server
+
+Pass the repository ID directly. The pipeline uses `FL2VA` for model discovery
+and shared components, and loads the second DiT from `Ref2VA/transformer`.
+
+### Memory and storage requirements
+
+Treat GPU HBM, host RAM, and checkpoint storage as separate requirements. Each
+H3 checkpoint partition (`FL2VA` or `Ref2VA`) contains about **134 GiB** of
+BF16 safetensors (about **135 GiB** on disk). Keeping both partitions
+locally therefore needs roughly **270 GiB** of model storage. A combined
+service downloads both; `--task-type fl2va` or `--task-type ref2va` downloads
+only the selected partition.
+
+CPU offload and distributed layerwise offload reduce GPU residency; they do
+not make the model weights disappear. With `--dlo-no-use-allgather`, each
+worker retains its standard-loader rank-local weights in host memory, including
+pinned CPU buffers used for H2D streaming. Use at least **200 GiB available
+system RAM** before starting the two-GPU recipe; a **384 GiB host is
+recommended** to leave room for the OS, CUDA/PyTorch allocations, request
+inputs, and filesystem cache. Do not run the FL2VA and Ref2VA servers at the
+same time on a host sized for this minimum.
+
+The consumer-GPU profiles below are HBM budgets only. They still require the
+host-RAM budget above.
+
+### Single GPU: accuracy and memory first
+
+The single-GPU configuration uses model-level CPU offload.
+This matches the accuracy-qualified reference path and prevents the Qwen3-VL
+encoder and DiT from being resident on the GPU at the same time.
+
+```bash
+export MODEL=MiniMaxAI/MiniMax-H3
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 1 \
+  --enable-cpu-offload \
+  --diffusion-attention-backend FLASH_ATTN
+```
+
+Use a GPU with enough memory for the active H3 component and enough system RAM
+for both offloaded DiTs plus the shared components. Model-level offload keeps
+the two DiTs mutually exclusive on GPU, but adds PCIe/NVLink transfer latency.
+
+### Two 24/32 GB GPUs: TP2 distributed layerwise offload
+
+For two PCIe consumer GPUs, combine TP2 with distributed layerwise offload
+(DLO). The standard loader first creates the rank-local TP shard. DLO keeps
+that shard in pinned host memory and streams the 30 tail DiT blocks through a
+shared two-buffer window without a DP AllGather. The first 20 DiT blocks are
+copied to the GPUs once per denoise stage, reused by every sampling step, and
+released before VAE decode so the decoder can reuse their HBM.
+
+```bash
+export MODEL=MiniMaxAI/MiniMax-H3
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,1 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=14400 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --task-type fl2va \
+  --num-gpus 2 \
+  --tensor-parallel-size 2 \
+  --usp 1 \
+  --ring 1 \
+  --text-encoder-tp-size 2 \
+  --vae-patch-parallel-size 2 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --enable-distributed-layerwise-offload \
+  --dlo-no-use-allgather \
+  --dlo-resident-layers 20 \
+  --enforce-eager \
+  --diffusion-attention-backend CUDNN_ATTN
+```
+
+Use the profile that matches the per-GPU memory capacity:
+
+| Profile | GPUs | Starting shape | Resident DiT blocks | Attention | Execution | Status |
+|---|---:|---:|---:|---|---|---|
+| `rtx5090` | 2 x 32 GB | 1344x768 | 20 | cuDNN attention | eager | Target-hardware validated |
+| `rtx4090` | 2 x 24 GB | 1024x576 | 12 | cuDNN attention | eager | Capacity-proxy starting point |
+
+This topology uses all available parallel capacity: TP2 shards both the DiT
+and text encoder, `--dlo-no-use-allgather` streams each rank's local TP shard
+without reconstructing full blocks, and VAE patch parallelism splits tiled
+decode across both GPUs. cuDNN attention is selected explicitly for the RTX
+consumer path; the server stays eager to avoid an unqualified compile path.
+
+The resident count changes placement and transfer frequency only; it does not
+quantize or change the BF16/FP32 denoise math. Re-measure peak memory before
+increasing it on a different request shape.
+
+### RTX 5090 target-hardware validation
+
+At vLLM-Omni commit `ae6577ea`, one full 50-step T2VA request completed on
+2 x RTX 5090 without OOM:
+
+| Shape | Frames | Client E2E | Sampled peak/GPU | Output validation |
+|---:|---:|---:|---:|---|
+| 1344x768 | 124 at 24 FPS | 8 min 38 s | approximately 22.6 GiB | H.264 video + 32 kHz stereo AAC; full `ffmpeg` decode passed |
+
+This is a single end-to-end validation run, not a warmed multi-run latency
+benchmark. The sampled `nvidia-smi` peak is also not a CUDA allocator
+high-water mark. The environment used vLLM 0.26.0, vLLM-Omni
+`0.26.1.dev14+gae6577ea`, and PyTorch 2.11.0+cu130. The
+[run record](https://github.com/lishunyang12/vllm-omni-rankings/blob/dcd06d7e83cb069842535918c0169ee9f3f29ba0/scripts/%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20260805000034_86_237.png)
+captures the environment, output contract, elapsed time, and sampled peak.
+
+Before the target run, both profiles were exercised on two B300 ranks as an
+allocation and correctness proxy. At 1344x768, 124 frames, and 50 steps, the
+20-layer profile peaked at 27,726 MiB per rank. At 1024x576, the 12-layer
+profile peaked at 18,888 MiB per rank in a 5-step capacity run. The resident
+and fully streamed placements produced identical decoded video-frame and audio
+hashes for the same shape, step count, prompt, and seed. The B300 result does
+not establish RTX 4090 PCIe latency; treat the 4090 profile as a conservative
+starting point until it is measured on that GPU.
+
+To run T2VA, FL2VA, image+audio Ref2VA, and two-video Ref2VA in order, validate
+every MP4's H.264/AAC streams, and retain live server and GPU-memory logs:
+
+```bash
+RUN_ROOT=/path/to/run-root \
+MODEL_ROOT=/path/to/MiniMax-H3 \
+GPU_IDS=0,1 \
+PROFILE=rtx5090 \
+bash examples/offline_inference/minimax_h3/run_h3_2gpu_all_tasks.sh
+```
+
+The script selects 20 resident layers for `PROFILE=rtx5090` and 12 for
+`PROFILE=rtx4090`; `DLO_RESIDENT_LAYERS=N` overrides either default.
+
+### Four GPUs: throughput-oriented combined service
+
+For a combined service on four high-memory GPUs, use:
+
+- no CPU or layerwise offload;
+- Ulysses sequence parallelism degree 4;
+- native tiled VAE patch parallelism degree 4;
+- regional `torch.compile` for the repeated DiT blocks;
+- dense BF16 `TRTLLM_ATTN`, with Ring and TP left at 1.
+
+Both DiTs remain resident in this no-offload configuration. If they do not fit,
+use model-level CPU offload.
+
+```bash
+export MODEL=MiniMaxAI/MiniMax-H3
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,1,2,3 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 4 \
+  --usp 4 \
+  --ring 1 \
+  --vae-patch-parallel-size 4 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling
+```
+
+Do not add `--enforce-eager` to this performance configuration. The first
+request includes regional compilation; warm the server once before measuring
+steady-state latency. H3 is CFG-distilled, so `--cfg-parallel-size` must remain
+1. The H3 VAE supports its native `tile` mode, not
+`spatial_shard_height` or `spatial_shard_width`.
+
+### Attention Backends
+
+On datacenter Blackwell GPUs, MiniMax H3 defaults to dense BF16
+`TRTLLM_ATTN`; no attention backend flag is required. To select it explicitly,
+use:
+
+```bash
+--diffusion-attention-backend TRTLLM_ATTN
+```
+
+Stable measurements with the four-GPU profile above put dense `TRTLLM_ATTN`
+and FA4 within 2% of each other. `TRTLLM_ATTN` remains the datacenter Blackwell
+default and enables the optional optimizations below. Confirm the server log
+contains `Defaulting to diffusion attention backend TRTLLM_ATTN` before
+recording measurements when using the default selection.
+
+FA4 remains available by explicitly selecting the `FLASH_ATTN` backend:
+
+```bash
+--diffusion-attention-backend FLASH_ATTN
+```
+
+On Blackwell, `FLASH_ATTN` selects FA4. Confirm the server log contains
+`Using CuTe FlashAttention-4 on Blackwell` before recording FA4 measurements.
+
+`TRTLLM_ATTN` additionally supports two **lossy** optimizations for the long main
+DiT attention sequence: SAGE attention quantization and Skip-Softmax Sparse
+Attention. SAGE quantizes Q/K to the configured dtype and V to FP8. This example uses
+`fp8_e4m3` for Q/K; B200 also supports `int8` Q/K. The TRTLLM SAGE path fixes V
+to FP8, so vLLM-Omni only exposes the Q/K dtype. The token refiner is a short
+attention path, so the `per_role` override leaves SAGE and Skip-Softmax disabled
+for it. The example enables the calibration-free Skip-Softmax path with
+`threshold=0.05`, after the normalized timestep reaches `0.97`:
+
+```bash
+--diffusion-attention-config '{
+  "default": {
+    "backend": "TRTLLM_ATTN",
+    "quant": {
+      "dtype_qk": "fp8_e4m3",
+      "q_block_size": 1,
+      "k_block_size": 16
+    },
+    "skip_softmax": {
+      "threshold": 0.05,
+      "disabled_until_timestep": 0.97
+    }
+  },
+  "per_role": {
+    "minimax_h3.token_refiner": {
+      "backend": "TRTLLM_ATTN"
+    }
+  }
+}'
+```
+
+For configuration details, see
+[TRTLLM_ATTN Backend and Skip-Softmax](https://github.com/vllm-project/vllm-omni/blob/main/docs/user_guide/diffusion/attention_backends.md#trtllm_attn-backend-and-skip-softmax)
+and
+[TRTLLM_ATTN SAGE Quantization](https://github.com/vllm-project/vllm-omni/blob/main/docs/user_guide/diffusion/attention_backends.md#trtllm_attn-sage-quantization).
+
+### Text encoder tensor parallelism
+
+The Qwen3-VL text encoder (~51.5 GB in BF16 for the retained 50 layers) is by
+default fully resident on the DiT main rank.  On multi-GPU no-offload runs that
+rank becomes the peak-memory hotspot.  Add `--text-encoder-tp-size N` to shard
+the encoder across the first `N` DiT ranks (the encoder is implemented with
+vLLM-style tensor-parallel layers and runs with distributed collectives over
+its own encoder process group):
+
+```bash
+export MODEL=MiniMaxAI/MiniMax-H3
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,1,2,3 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 4 \
+  --usp 4 \
+  --ring 1 \
+  --text-encoder-tp-size 4 \
+  --vae-patch-parallel-size 4 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling
+```
+
+`N` must divide the Qwen3-VL head counts (64 attention heads / 8 KV heads), so
+valid values on a 4-GPU server are 1, 2, and 4 (1, 2, 4, 8 on 8 GPUs).  The
+encoder TP rank set is the first `N` DiT ranks; on 4 GPUs
+`--text-encoder-tp-size 4` shards the encoder 4-way, dropping the DiT main
+rank's no-offload peak by roughly `(N-1)/N` of the ~51.5 GB encoder while the
+other ranks each gain `~51.5/N` GB.  The encoder output remains identical to
+the reference path within bf16 rounding: every encoder rank all-reduces the
+row-parallel projections, so the full `[seq, 5120]` layer-50 hidden state is
+replicated on every rank.
+
+No restart is needed: `task=fl2va` routes to `FL2VA/transformer`, while
+`task=ref2va` routes to
+`Ref2VA/transformer`. T2VA uses the FL2VA DiT.
+
+### Online FP8 quantization
+
+MiniMax H3 supports load-time FP8 quantization of the DiT. The checkpoint
+remains BF16 on disk; vLLM-Omni quantizes eligible weights while loading and
+uses dynamic activation scaling during inference. By default, attention and
+MLP linears in the token refiner and main DiT blocks, the condition
+projection, and all AdaLN projections use FP8. Patch, timestep, and final
+projections remain FP32; the text encoder and VAEs are unchanged.
+
+Add this option to an existing H3 server command:
+
+```bash
+--quantization fp8
+```
+
+Use `ignored_layers` to keep any otherwise eligible linear in BF16. H3
+resolves the `transformer` component before constructing the DiT, so names do
+not start with `transformer.`. Entries are exact runtime linear prefixes; a
+parent name such as `blocks.0.attn` does not exclude its children.
+
+Eligible names are the `attn.qkv_proj`, `attn.out_proj`, `mlp.fc1`, and
+`mlp.fc2` children under `token_refiner.blocks.<0-1>` or `blocks.<0-49>`.
+The other eligible names are `condition_proj`,
+`blocks.<0-49>.adaln_proj.linear`, and `final_layer.adaln_proj.linear`.
+For example, keep the first main block's attention projections in BF16 with:
+
+```bash
+--diffusion-quantization-config \
+  '{"transformer":{"method":"fp8","ignored_layers":["blocks.0.attn.qkv_proj","blocks.0.attn.out_proj"]}}'
+```
+
+The structured option replaces `--quantization fp8`. Online FP8 is currently
+incompatible with H3 layerwise offload because the offload path produces a
+weight stride rejected by the Cutlass FP8 kernel. Use resident FP8 with tensor
+parallelism and VAE tiling instead.
+
+## HTTP API examples
+
+The following requests use the synchronous endpoint so the returned body can
+be saved directly as an MP4. The asynchronous `POST /v1/videos` endpoint can
+also be used when job polling is preferred.
+
+All four tasks use 24 FPS, 50 sigma points, seed values from the validated
+workloads, and the checkpoint-reference video/audio flow shifts of 12 and 3.
+Decimal durations are passed through `extra_params`.
+
+Set the endpoint once:
+
+```bash
+export API_URL="http://127.0.0.1:${PORT}/v1/videos/sync"
+```
+
+### 1. T2VA: text to video and audio
+
+Run this request against the combined service:
+
+```bash
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=In a snowy blue-purple forest, Ori carefully walks past a sleeping giant; footsteps crunch in the snow while the creature breathes and softly snorts.' \
+  -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":8.7,"audio_flow_shift":3.0}' \
+  -o t2va.mp4
+```
+
+### 2. FL2VA: first frame to video and audio
+
+Run this request against the combined service. When width and height are
+omitted, H3 preserves the first-frame aspect ratio and uses a 768-pixel short
+edge.
+
+```bash
+export FIRST_FRAME=/path/to/fl2va_first_frame.png
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=A man stands beside a yellow car at night. The car drives away; he follows it with his eyes and begins singing sadly, with synchronized voice and city ambience.' \
+  -F 'fps=24' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=2101' \
+  -F 'extra_params={"task":"fl2va","duration":8.7,"audio_flow_shift":3.0}' \
+  -F "input_reference=@${FIRST_FRAME};type=image/png" \
+  -o fl2va.mp4
+```
+
+Use the same `FL2VA` partition for the official tail-keyframe forms. A single
+image with `frame_indices=[-1]` conditions the last frame; two ordered images
+with `frame_indices=[0,-1]` condition the first and last frames:
+
+```bash
+export LAST_FRAME=/path/to/fl2va_last_frame.png
+export FIRST_FRAME=/path/to/fl2va_first_frame.png
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=The subject moves naturally from the first image to the last image.' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=2102' \
+  -F 'extra_params={"task":"fl2va","duration":8.7,"frame_indices":[0,-1],"audio_flow_shift":3.0}' \
+  -F "input_references=@${FIRST_FRAME};type=image/png" \
+  -F "input_references=@${LAST_FRAME};type=image/png" \
+  -o fl2va_first_last.mp4
+```
+
+### 3. Ref2VA: image-only, image/audio, or mixed references
+
+Run these requests against the combined service or a Ref2VA-only service.
+Image-only Ref2VA omits `audio_reference`; adding one or more audio references
+is optional. The typed fields accept one object or an ordered JSON list.
+`audio_reference` accepts an HTTP(S) URL or a `data:` URL. In one terminal,
+expose the local reference assets to the serving host:
+
+```bash
+python -m http.server 8092 \
+  --bind 127.0.0.1 \
+  --directory /path/to/reference_assets
+```
+
+Then submit an image-only request from another terminal:
+
+```bash
+export REF_IMAGE=/path/to/reference_assets/ref2va_image.png
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=A white cat sits on a beige couch and slowly looks toward the camera.' \
+  -F 'aspect_ratio=adaptive' \
+  -F 'short_edge=768' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=3100' \
+  -F 'extra_params={"task":"ref2va","duration":8.0,"audio_flow_shift":3.0}' \
+  -F "input_reference=@${REF_IMAGE};type=image/png" \
+  -o ref2va_image_only.mp4
+```
+
+An image-plus-audio request is:
+
+```bash
+export REF_IMAGE=/path/to/reference_assets/ref2va_image.png
+export AUDIO_URL=http://127.0.0.1:8092/ref2va_audio.mp3
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=A white cat with black mustache and eyebrow markings sits on a beige couch, lip-syncing precisely to the complete reference audio before shifting from confusion to deadpan speechlessness.' \
+  -F 'width=1344' \
+  -F 'height=768' \
+  -F 'fps=24' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=3101' \
+  -F 'extra_params={"task":"ref2va","duration":15.0,"audio_flow_shift":3.0}' \
+  -F "input_reference=@${REF_IMAGE};type=image/png" \
+  -F "audio_reference={\"audio_url\":\"${AUDIO_URL}\"}" \
+  -o ref2va_image_audio.mp4
+```
+
+The requested duration should cover the complete audio. If `duration` is
+shorter, the reference soundtrack is truncated to the generated clip.
+
+### 4. Ref2VA: video, separate audio, and mixed references
+
+Run this request against the combined service. Repeat the
+`input_references` multipart field once per source video. H3 consumes the
+videos in form order and preserves their original soundtracks during
+conditioning.
+
+```bash
+export SUBJECT_VIDEO=/path/to/green_screen_subject.mp4
+export BACKGROUND_VIDEO=/path/to/fairytale_background.mov
+
+curl -sS -X POST "${API_URL}" \
+  -F 'prompt=Remove the green screen background of Video 1 and replace it with the fairytale environment from Video 2. Match the background motion to the character actions and relight the character to fit the scene.' \
+  -F 'width=1344' \
+  -F 'height=768' \
+  -F 'fps=24' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=3101' \
+  -F 'extra_params={"task":"ref2va","duration":15.0,"audio_flow_shift":3.0}' \
+  -F "input_references=@${SUBJECT_VIDEO};type=video/mp4" \
+  -F "input_references=@${BACKGROUND_VIDEO};type=video/quicktime" \
+  -o ref2va_video_video.mp4
+```
+
+The server stores uploaded references only for the lifetime of the request and
+deletes temporary files after generation. A video may use its embedded
+soundtrack, a separate `audio_reference`, or both. To send a mixed multipart
+request, repeat `input_references` for each image, video, or audio file; the
+server classifies them by MIME type and preserves the per-type order.
+
+Reference videos must be MP4/MOV with H.264/H.265 video, optional AAC/MP3
+audio, 2–15 seconds each, and at most 15 seconds combined. They may still be
+longer than the generated clip. Use `start_time_seconds` to select a
+synchronized segment; for multiple typed video references, pass one value per
+video in `extra_params.start_time_seconds`.
+
+Reference images accept JPG/JPEG, PNG, WEBP, HEIC, or HEIF up to 30 MiB. Standalone
+audio references accept WAV or MP3 up to 15 MiB, with 2–15 seconds per file and
+at most 15 seconds combined.
+
+## Official input matrix and limits
+
+| Task | Supported references | Limits |
+|------|----------------------|--------|
+| T2VA | text only | prompt must be non-empty |
+| FL2VA | first image, last image, or ordered first+last images | at most 2 images; `frame_indices` is `[0]`, `[-1]`, or `[0,-1]` |
+| Ref2VA | image-only, image+image, image+video, video+audio, and mixed image/video/audio | images ≤9, videos ≤3, audios ≤3, total references ≤12; audio requires a visual reference |
+
+The H3 output contract is 4–15 seconds at 24 FPS, stereo 32 kHz audio, and a
+32-pixel canvas multiple. T2VA requires one named output ratio from `21:9`,
+`16:9`, `4:3`, `1:1`, `3:4`, or `9:16`. FL2VA always follows the first input
+image's ratio and ignores a generic `aspect_ratio` override. Ref2VA defaults to
+`16:9`; `adaptive` and SGLang's `auto` spelling are accepted aliases for that
+default. `short_edge` controls the 768-pixel canvas and must be `768`.
+`num_outputs_per_prompt` accepts 1–10 and derives each output seed as
+`seed + output_index`. The asynchronous endpoint returns all
+outputs; the synchronous raw-MP4 endpoint returns the first output when more
+than one is requested.
+
+## Key parameters
+
+| Parameter | Recommended value | Notes |
+|-----------|-------------------|-------|
+| `task` | `t2va`, `fl2va`, or `ref2va` | Passed in `extra_params`; selects the task-specific DiT |
+| `duration` | Workload-specific | Decimal seconds in `extra_params`; converted to H3-compatible frame count |
+| `fps` | `24` | H3 output FPS is fixed |
+| `num_inference_steps` | `50` | Matches the reference accuracy workloads |
+| `flow_shift` | `12` | Video sigma shift |
+| `audio_flow_shift` | `3` | Audio sigma shift, passed in `extra_params` |
+| `seed` | Task-specific | Use a fixed value for reproducibility |
+| `aspect_ratio` | Task-specific | T2VA requires a named ratio; FL2VA follows the input image; Ref2VA defaults to `16:9` |
+| `short_edge` | `768` | H3 shape policy requires exactly 768 when `width`/`height` are omitted |
+| `num_outputs_per_prompt` | `1` | 1–10; async API returns every output |
+| `start_time_seconds` | `0` | Reference-video segment start; use a list in `extra_params` for multiple videos |
+| `width`, `height` | Multiples of 32 | Output aspect ratio must be between 1:4 and 4:1 |
+
+## ComfyUI Frontend
+
+Users can also use a ComfyUI frontend to interact with a hosted MiniMax-H3 service. The ComfyUI frontend can run in a separate environment or machine. Refer to [vLLM-Omni ComfyUI Integration](../../docs/features/comfyui.md) for details.
+
+## Validated four-GPU evidence
+
+The four-GPU recommendation was measured on four NVIDIA B300 GPUs with one
+excluded warmup followed by three requests.
+
+| Workload | Configuration | Observed result |
+|----------|---------------|-----------------|
+| FL2VA, 209 frames, 1248x768 | no offload, U4, VPP4 tile, regional compile | 86.964 s mean HTTP client latency |
+| Two-video Ref2VA, 362 frames, 1344x768 | no offload, U4, VPP4 tile, regional compile | 784.394 s accounted model-stage mean |
+
+These measurements describe the validated shapes rather than a general
+throughput guarantee. Multi-video Ref2VA is much slower because the two
+reference videos expand both the Qwen3-VL vision sequence and the packed DiT
+attention sequence.
+
+## Validated FP8 evidence
+
+With eager DiT/text-encoder TP2 and VAE tiling, the 384x672, 107-frame,
+10-step quality case measured LPIPS 0.1156 (limit 0.20), PSNR 23.6316 dB,
+audio spectral cosine 0.9589 (minimum 0.80), and audio RMS ratio 0.9342. The
+resident per-GPU peak was 68.52 GiB for BF16 and 53.51 GiB for FP8, a 22%
+reduction.
+
+## Known limitations
+
+- Combined serving requires sibling `FL2VA` and `Ref2VA` directories, loads
+  both task-specific DiTs, and loads shared components once from `FL2VA`.
+- H3 currently executes one generation request per diffusion batch.
+- The first regional-compile request is a warmup and should not be included in
+  steady-state performance measurements.
+- Online FP8 is not compatible with layerwise offload.
+- Image+audio Ref2VA accepts exactly one image and one audio reference.
+- Video Ref2VA accepts one or more video files, but not an additional standalone
+  audio reference.
+- VAE patch parallelism requires size 1 or the full DiT group size and supports
+  the H3 native `tile` mode only.
+
+## Additional resources
+
+- [Supported models](../../docs/models/supported_models.md)
+- [Video API](../../docs/serving/videos_api.md)
+- [Diffusion parallelism](../../docs/user_guide/diffusion/parallelism/overview.md)
diff --git a/recipes/NVIDIA/GR00T-N1.7.md b/recipes/NVIDIA/GR00T-N1.7.md
index 91f676a52..0a5270222 100644
--- a/recipes/NVIDIA/GR00T-N1.7.md
+++ b/recipes/NVIDIA/GR00T-N1.7.md
@@ -69,8 +69,13 @@ Notes:
 ## Verification
 
 ```python
-from tests.gr00t.openpi_client_helper import run_policy_session, validate_session_result
-validate_session_result(run_policy_session(host="127.0.0.1", port=8000))
+from tests.helpers.runtime import OpenAIClientHandler
+
+handler = OpenAIClientHandler(host="127.0.0.1", port=8000, log_stats=False)
+response = handler.send_robot_openpi_ws_request(
+    {"run_default_policy_session": True, "session_id": "gr00t-smoke"}
+)[0]
+assert response.operation_responses[-1]["status"] == "reset successful"
 ```
 
 Or run the e2e test suite:
diff --git a/recipes/NVIDIA/Nemotron-Labs-Audex.md b/recipes/NVIDIA/Nemotron-Labs-Audex.md
new file mode 100644
index 000000000..21ee7e655
--- /dev/null
+++ b/recipes/NVIDIA/Nemotron-Labs-Audex.md
@@ -0,0 +1,142 @@
+# Nemotron-Labs Audex (2B / 30B-A3B)
+
+> Speech suite on 1×H100: TTS, text-to-audio, audio understanding, and cascaded speech-to-speech
+
+## Summary
+
+- Vendor: NVIDIA
+- Model: `nvidia/Nemotron-Labs-Audex-2B`, `nvidia/Nemotron-Labs-Audex-30B-A3B`
+- Task: Text-to-speech (English), text-to-audio (sound effects), audio understanding (ASR / audio QA), cascaded speech-to-speech
+- Mode: Online serving (`/v1/audio/speech`, `/v1/chat/completions`) and offline batch inference
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to serve either Audex checkpoint through one of its four
+deployment pipelines. Both sizes share the same repo layout, codec token
+space, and streaming causal speech decoder (16 kHz output); they differ in
+the thinker: the 2B is a dense LM, the 30B-A3B is a hybrid Mamba + MoE
+NemotronH (~3B active parameters). Pick the pipeline by task:
+
+| pipeline (`vllm_omni/deploy/<name>[_30b].yaml`) | audio in | text out | speech out | general audio out | endpoint |
+|---|---|---|---|---|---|
+| `audex_tts` | ❌ | ❌ | ✅ | ❌ | `/v1/audio/speech` |
+| `audex_tta` | ❌ | ❌ | ❌ | ✅ | `/v1/audio/speech` |
+| `audex_thinker_only` | ✅ | ✅ | ❌ | ❌ | `/v1/chat/completions` |
+| `audex_s2s` | ✅ | ✅ | ✅ | ❌ | both |
+
+## References
+
+- Model cards: [Nemotron-Labs-Audex-2B](https://huggingface.co/nvidia/Nemotron-Labs-Audex-2B), [Nemotron-Labs-Audex-30B-A3B](https://huggingface.co/nvidia/Nemotron-Labs-Audex-30B-A3B)
+- Offline examples: [`examples/offline_inference/audex/`](../../examples/offline_inference/audex/)
+- Online examples: [`examples/online_serving/audex/`](../../examples/online_serving/audex/)
+
+## Hardware Support
+
+## GPU
+
+### 1×H100 80GB — Audex-2B
+
+#### Environment
+
+- OS: Linux
+- Python: 3.12+
+- CUDA: 12.x
+- vLLM version: 0.24.0
+- vLLM-Omni version or commit: PR #4976 (branch `audex`)
+
+#### Command
+
+**Online serving** (TTS is the default pipeline; the repo root's
+`model_type` auto-resolves `audex_tts.yaml`):
+
+```bash
+vllm-omni serve nvidia/Nemotron-Labs-Audex-2B \
+    --host 0.0.0.0 --port 8097 \
+    --trust-remote-code --omni
+# other modes: add --stage-configs-path vllm_omni/deploy/audex_{tta,thinker_only,s2s}.yaml
+# or use the launcher: MODE=s2s PORT=8098 examples/online_serving/audex/run_server.sh
+```
+
+**Offline batch inference** (one script per task, each defaults to its
+correct deploy yaml):
+
+```bash
+python examples/offline_inference/audex/text_to_speech.py \
+    --texts "Hello world." --cfg-scale 1.5 --output-dir results/audex_wavs
+python examples/offline_inference/audex/text_to_audio.py     # sound effects
+python examples/offline_inference/audex/audio_qa.py          # ASR / audio QA
+python examples/offline_inference/audex/speech_to_speech.py  # 3-pass cascade
+```
+
+#### Verification
+
+```bash
+curl -X POST http://localhost:8097/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "nvidia/Nemotron-Labs-Audex-2B",
+        "input": "Hello, how are you?",
+        "response_format": "wav",
+        "extra_params": {"cfg_scale": 1.5}
+    }' --output hello.wav
+# or the universal client (all four modes):
+python examples/online_serving/audex/client.py --mode tts --output hello.wav
+```
+
+#### Notes
+
+- Memory usage: TTS deploy — stage 0 (thinker) 0.4, stage 1 (decoder) 0.25
+  GPU-memory fraction; both stages share GPU 0.
+- Key flags: `--trust-remote-code` and `--omni` are required.
+- Classifier-free guidance: `extra_params.cfg_scale` (1.0 = off; 1.5 is the
+  official quality setting; TTA effectively requires its default 3.0).
+  Measured en-24 self-transcribed CER: 6.87% guided vs 7.24% unguided.
+- Output: 16 kHz mono WAV. English, single built-in voice (no cloning).
+- TTA decodes through the external XCodec1 checkpoint
+  (`hf-audio/xcodec-hubert-general-balanced`, auto-downloaded; override
+  with `XCODEC1_PATH`).
+
+### 1×H100 80GB — Audex-30B-A3B
+
+#### Environment
+
+Same as the 2B row above.
+
+#### Command
+
+The 30B REQUIRES its explicit deploy yaml (the shared HF `model_type`
+auto-resolves to the 2B-tuned config otherwise):
+
+```bash
+vllm-omni serve nvidia/Nemotron-Labs-Audex-30B-A3B \
+    --host 0.0.0.0 --port 8097 \
+    --trust-remote-code --omni \
+    --stage-configs-path vllm_omni/deploy/audex_tts_30b.yaml
+# or: SIZE=30b MODE=tts examples/online_serving/audex/run_server.sh
+```
+
+Offline: same four scripts with
+`--model nvidia/Nemotron-Labs-Audex-30B-A3B --deploy-config vllm_omni/deploy/audex_<mode>_30b.yaml`.
+
+#### Verification
+
+Same curl / `client.py` as the 2B with
+`"model": "nvidia/Nemotron-Labs-Audex-30B-A3B"` (the server validates the
+model id). First launch downloads ~60 GB.
+
+#### Notes
+
+- Memory usage: ~61 GiB weights on one H100 80 GB (stage 0 at 0.85 GPU
+  fraction + decoder at 0.08 on the same card); verified with healthy KV
+  headroom. If long sequences OOM, set `tensor_parallel_size: 2` on
+  stage 0 (documented in the yaml headers).
+- `enable_prefix_caching: false` on stage 0 — hybrid Mamba constraint.
+- CUDA graphs stay ON for the thinker: the NemotronH stage captures
+  cleanly and eager mode costs ~7× single-stream TTS RTF (review-measured
+  0.30 vs 2.08).
+- Quality (en-24 self-transcribed CER): 0.72% unguided baseline; 0.72% at
+  cfg 1.5 with guided temperature 0.1.
+- Known limitation: the S2S chat pass needs the official
+  formatting-instruction prompt (the bundled examples/client send it);
+  a bare transcript turn makes the 30B answer in speech-codec tokens.
diff --git a/recipes/NVIDIA/PersonaPlex.md b/recipes/NVIDIA/PersonaPlex.md
new file mode 100644
index 000000000..62d04a499
--- /dev/null
+++ b/recipes/NVIDIA/PersonaPlex.md
@@ -0,0 +1,174 @@
+# PersonaPlex
+
+> Live full-duplex speech-to-speech (talk to the model in your browser, it listens
+> while it speaks) with persona and voice control, on the native vLLM-Omni engine.
+
+## Summary
+
+- Vendor: NVIDIA
+- Model: [`nvidia/personaplex-7b-v1`](https://huggingface.co/nvidia/personaplex-7b-v1)
+  (gated; a Moshi finetune)
+- Task: Full-duplex speech-to-speech. 24 kHz mic audio in, agent speech +
+  inner-monologue text out, in 80 ms lockstep. Persona (role text) and voice
+  (zero-shot clone) are set per session.
+- Mode: Live duplex WebSocket server with the official browser client, single or
+  multi-session (`--batch-size`), plus an offline WAV-in / WAV-out example
+- Maintainer: [`@linyueqian`](https://github.com/linyueqian)
+
+## When to use this recipe
+
+Use this recipe to run `nvidia/personaplex-7b-v1` as a live voice agent on one GPU.
+The integration is **moshi-free**: the temporal transformer, depformer, and
+streaming Mimi codec are all native vLLM-Omni modules (Mimi runs on
+`transformers.MimiModel`), so no vendored fork is installed. Decoding is greedy,
+matching the reference implementation frame for frame on the golden replays used
+as the acceptance gate.
+
+PersonaPlex is the first Moshi-class (pure-lockstep) model in the experimental
+full-duplex framework (`vllm_omni/experimental/fullduplex/`), and the first with
+elastic multi-session batching: one engine hosts `--batch-size` concurrent
+conversations, callers join or leave on any 80 ms tick without disturbing live
+slots (greedy isolation is bit-exact).
+
+## References
+
+- Serving package:
+  [`vllm_omni/experimental/fullduplex/personaplex/`](../../vllm_omni/experimental/fullduplex/personaplex/)
+- Native model modules (temporal / depformer / streaming Mimi):
+  [`vllm_omni/model_executor/models/personaplex/`](../../vllm_omni/model_executor/models/personaplex/)
+- Online example (server + headless client):
+  [`examples/online_serving/personaplex/`](../../examples/online_serving/personaplex/)
+- Offline example:
+  [`examples/offline_inference/personaplex/personaplex_offline.py`](../../examples/offline_inference/personaplex/personaplex_offline.py)
+- Staged offline pipeline (talker -> Mimi code2wav, async-chunk streaming):
+  [`vllm_omni/deploy/personaplex.yaml`](../../vllm_omni/deploy/personaplex.yaml)
+- Integration PR: [vllm-project/vllm-omni#4771](https://github.com/vllm-project/vllm-omni/pull/4771)
+- Framework context: [RFC #3745](https://github.com/vllm-project/vllm-omni/issues/3745)
+  (duplex adapter patterns), [#1335](https://github.com/vllm-project/vllm-omni/issues/1335)
+  (full-duplex target), [PR #3907](https://github.com/vllm-project/vllm-omni/pull/3907)
+  (fullduplex core contracts this adapter conforms to)
+- Upstream model card:
+  [`nvidia/personaplex-7b-v1`](https://huggingface.co/nvidia/personaplex-7b-v1)
+
+## Why it is different from MiniCPM-o / JoyVL duplex
+
+| | MiniCPM-o 4.5 (#3907) | JoyVL | **PersonaPlex (this)** |
+|---|---|---|---|
+| Cadence | 1 s chunk groups | ~1 fps frames | **80 ms lockstep (12.5 Hz)** |
+| Turn control | learned `⟨listen⟩`/`⟨speak⟩` | `</silence>`/`</response>` | **none, pure lockstep** |
+| Per step | variable-length token group | text decision | **1 user frame in -> 1 agent frame + 1 text token** |
+| Barge-in | at chunk boundary | n/a | **native (model always hears the user)** |
+| Session state | chunk-group KV | per-tick HTTP | **persistent ring KV + streaming Mimi state** |
+
+This is the lockstep ("parallel-frame joint") shape of the duplex adapter
+patterns: the adapter declares `DuplexCapability.continuous = True`, and
+`core.DuplexRuntime` runs ONE eternal response that consumes input frames as they
+arrive and drains on close. The flag is a small, default-off lifecycle mode, so
+turn-based adapters (JoyVL, MiniCPM-o) are unaffected.
+
+## Architecture (Moshi RQ-Transformer, all native)
+
+- **Mimi codec** 24 kHz, 12.5 Hz, 1920 samples/frame, 8 active codebooks
+  (card 2048). Streaming encode + decode via `transformers.MimiModel` with the
+  PersonaPlex reference checkpoint weights.
+- **Temporal transformer** (Helium backbone) 4096-d / 32 layers / 32 heads,
+  sliding window 3000 frames (a 4-minute rolling context) held in a ring KV cache
+  with per-slot recycle.
+- **Depformer** 1024-d / 6 layers / 16 heads, autoregressive over 16 codebooks
+  per frame (8 vocoded), reset each frame.
+- Per-frame token column `[B, 17, 1]`: row 0 = inner-monologue text,
+  rows 1-8 = agent audio, rows 9-16 = user audio.
+- Persona + voice are injected once at session open through the same lockstep
+  step: voice clone forces the agent stream from reference-audio Mimi codes;
+  persona forces the text stream from `<system> ... <system>` tokens.
+
+## Hardware Support
+
+Verified on GPU (Hopper-class). The serving path is plain PyTorch eager plus the
+native modules, so other CUDA GPUs with enough memory are expected to work.
+
+## GPU
+
+### 1x 141 GB Hopper-class GPU (H20-class, verified)
+
+#### Environment
+
+- OS: Linux
+- Python: 3.10+ (CI covers 3.11 / 3.12)
+- vLLM-Omni: PR #4771 branch or current `main` once merged
+- Extra dependency for the live server: `pip install sphn` (Opus framing;
+  `aiohttp` already ships with vLLM)
+- `export HF_TOKEN=...` with access to the gated
+  `nvidia/personaplex-7b-v1` repo (accept the license on the model page)
+
+First run auto-downloads from the model repo: `model.safetensors`,
+`tokenizer_spm_32k_3.model`, `voices.tgz`, and the Mimi reference checkpoint;
+`kyutai/mimi` is fetched via `transformers` for the codec module graph.
+
+#### Command
+
+Live duplex server (official browser client served at `/`):
+
+```bash
+HF_TOKEN=... CUDA_VISIBLE_DEVICES=0 \
+python -m vllm_omni.experimental.fullduplex.personaplex.serving.server \
+    --port 8124 --voice NATF2.pt
+```
+
+Multi-session on the same GPU (elastic batching, callers join/leave any tick):
+
+```bash
+HF_TOKEN=... CUDA_VISIBLE_DEVICES=0 \
+python -m vllm_omni.experimental.fullduplex.personaplex.serving.server \
+    --port 8124 --batch-size 4
+```
+
+Then open `http://localhost:8124/` and allow the microphone (use headphones so
+the agent does not hear itself). Headless alternative:
+
+```bash
+python examples/online_serving/personaplex/duplex_client.py \
+    --url ws://localhost:8124/api/chat --input user.wav --out reply.wav
+```
+
+Offline WAV-in / WAV-out (no server):
+
+```bash
+python examples/offline_inference/personaplex/personaplex_offline.py \
+    --input-wav question.wav --output-wav reply.wav --output-text reply.json \
+    --voice-prompt NATF2.pt --persona "You are a wise and friendly teacher."
+```
+
+#### Verification
+
+```bash
+# GPU-free contract tests (stubbed FrameStepper)
+pytest tests/e2e/features/fullduplex/test_personaplex_adapter.py \
+       tests/e2e/features/fullduplex/test_personaplex_session.py \
+       tests/e2e/features/fullduplex/test_personaplex_batched.py -q
+
+# GPU e2e: batched isolation + slot recycle (coherence check needs a real
+# question WAV via PPLEX_QUESTION_WAV)
+pytest tests/e2e/features/fullduplex/test_personaplex_elastic.py -q
+```
+
+A green offline run producing a coherent spoken reply (and inner-monologue text
+in `reply.json`) is the quickest end-to-end check.
+
+#### Notes
+
+- Realtime budget is 80 ms/frame. Verified eager per-tick latency at
+  `--batch-size 4` is ~70-74 ms on this hardware class, i.e. all four
+  conversations stay realtime; single-session has comfortable headroom.
+- Decoding is greedy only (temperature/top-k knobs are intentionally not
+  exposed): greedy is what the parity gates pin against the reference
+  implementation, and sampling amplifies sub-bit numeric drift into divergence.
+- With `--batch-size N`, connections beyond N are rejected until a slot frees;
+  a recycled slot is bit-exact with a fresh engine for the same inputs.
+- Voice prompts: bundled `voices.tgz` names (`NATF*`/`NATM*` natural,
+  `VARF*`/`VARM*` varied) or a path to your own `.pt`/`.wav`.
+- Run the browser client near the server. The 80 ms cadence is sensitive to
+  network jitter; over a high-latency link playback can stutter regardless of
+  engine speed. On localhost it is smooth.
+- Sliding window is 3000 frames (~4 min). The ring KV recycles beyond that;
+  very long sessions keep running with a rolling context.
diff --git a/recipes/OpenBMB/MiniCPM-o-4_5.md b/recipes/OpenBMB/MiniCPM-o-4_5.md
index 8b3d2909d..f87ee5b19 100644
--- a/recipes/OpenBMB/MiniCPM-o-4_5.md
+++ b/recipes/OpenBMB/MiniCPM-o-4_5.md
@@ -1,6 +1,7 @@
 # MiniCPM-o 4.5
 
-> Online serving for omni multimodal chat (text / image / audio / video → text + 24 kHz speech)
+> Online serving and offline inference for omni multimodal chat
+> (text / image / audio / video → text + 24 kHz speech)
 
 ## Summary
 
@@ -9,34 +10,38 @@
 - Task: Omni multimodal chat — accepts text / image / audio / video input;
   emits text and 24 kHz mono speech in the same response
 - Mode: Online serving via the OpenAI-compatible `/v1/chat/completions`
-  API, plus a bundled Gradio demo (text + speech UI)
+  API (plus Gradio demo), and offline inference via `Omni.generate`
 - Maintainer: [`@tc-mb`](https://github.com/tc-mb) (MiniCPM-V / MiniCPM-o team)
 
 ## When to use this recipe
 
 Use this recipe as a known-good starting point for serving
 `openbmb/MiniCPM-o-4_5` on vLLM-Omni. MiniCPM-o 4.5 is the omni member
-of the MiniCPM-o family — it pairs a multimodal-understanding thinker
-LLM with a streaming `MiniCPMTTS + Token2Wav` talker so a single
+of the MiniCPM-o family — it runs a multimodal thinker, a streaming
+MiniCPMTTS codec talker, and a separate batched Code2Wav stage so a single
 `/v1/chat/completions` call can return text and 24 kHz speech in one
-shot. The recipe covers three shipped GPU layouts (2 / 3 / 8 GPUs)
-selected via `--deploy-config`.
+shot. The recommended batching deploy isolates the Thinker on GPU 0 and
+co-locates Talker and Code2Wav on GPU 1; 1-GPU, 3-GPU, and 8x4090 layouts are
+also provided.
 
 ## References
 
 - Default deploy configs (auto-loaded by HF `model_type=minicpmo` +
   `hf_config.version="4.5"`):
-  - 2-GPU layout (default):
+  - Default single-GPU compatibility layout (auto-loaded):
     [`vllm_omni/deploy/minicpmo_4_5.yaml`](../../vllm_omni/deploy/minicpmo_4_5.yaml)
-  - 3-GPU layout (thinker TP=2):
+  - 2-GPU and 3-GPU layouts:
+    [`vllm_omni/deploy/minicpmo_4_5_2gpu.yaml`](../../vllm_omni/deploy/minicpmo_4_5_2gpu.yaml),
     [`vllm_omni/deploy/minicpmo_4_5_3gpu.yaml`](../../vllm_omni/deploy/minicpmo_4_5_3gpu.yaml)
   - 8x RTX 4090 layout:
     [`vllm_omni/deploy/minicpmo_4_5_8x4090.yaml`](../../vllm_omni/deploy/minicpmo_4_5_8x4090.yaml)
 - Online example + Gradio demo:
   [`examples/online_serving/minicpmo/`](../../examples/online_serving/minicpmo/)
+- Offline end-to-end example:
+  [`examples/offline_inference/minicpmo/`](../../examples/offline_inference/minicpmo/)
 - Pipeline / talker source:
   [`vllm_omni/model_executor/models/minicpmo_4_5/`](../../vllm_omni/model_executor/models/minicpmo_4_5/)
-- Stage-input processor (thinker → talker bridge):
+- Stage-input processors (thinker → talker and talker → Code2Wav):
   [`vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py`](../../vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py)
 - Upstream model card:
   [`openbmb/MiniCPM-o-4_5`](https://huggingface.co/openbmb/MiniCPM-o-4_5)
@@ -45,28 +50,38 @@ selected via `--deploy-config`.
 
 ## Hardware Support
 
-Three GPU layouts ship with default deploy configs. Pick the layout that
-matches your hardware and pass it via `--deploy-config`; the talker
-(`MiniCPMTTS + Token2Wav`) always lives on its own GPU because of the
-in-process vocoder, and the thinker is the part that scales out via TP.
+Four hardware layouts ship with deploy configs. Every layout uses the
+same strict three-stage topology. The Talker emits codec chunks only;
+Code2Wav consumes them through a shared-memory async connector.
 
-| Layout | Thinker | Talker + Token2Wav | Typical hardware |
-| --- | --- | --- | --- |
-| 2-GPU (default) | GPU 0 | GPU 1 | 2x A100/H100/H200 80GB |
-| 3-GPU (thinker TP=2) | GPU 0,1 (TP=2) | GPU 2 | 3x mid-tier GPUs |
-| 8x RTX 4090 24GB | GPU 0–3 (TP=4) | GPU 4 | 8x RTX 4090 consumer |
+| Layout | Thinker | Talker | Code2Wav | Typical hardware |
+| --- | --- | --- | --- | --- |
+| 1-GPU (default) | GPU 0 | GPU 0 | GPU 0 | 1x large-memory GPU |
+| 2-GPU | GPU 0 | GPU 1 | GPU 1 | 2x large-memory GPU |
+| 3-GPU | GPU 0 | GPU 1 | GPU 2 | 3x GPU |
+| 8x RTX 4090 24GB | GPU 0–3 (TP=4) | GPU 4 | GPU 5 | 8x RTX 4090 consumer |
+
+### Migration from the fused deployment
+
+MiniCPM-o 4.5 now requires the three-stage topology: the Talker owns
+request-local codec generation and Code2Wav owns waveform state and
+reference-voice prompt features. `minicpmo_4_5.yaml` remains the stable
+single-GPU entry point; `minicpmo_4_5_2gpu.yaml` is the recommended
+two-GPU profile. The removed fused two-stage implementation is not retained as
+a fallback because it would duplicate state machines and correctness paths.
 
 ## GPU
 
-### 2 x GPU (default — single command)
+### 1 x GPU (default — single command)
 
 The default
 [`vllm_omni/deploy/minicpmo_4_5.yaml`](../../vllm_omni/deploy/minicpmo_4_5.yaml)
-puts the thinker on GPU 0 (`~70 %` memory, `enforce_eager: true`,
-`max_num_seqs: 1`) and the talker + Token2Wav vocoder on GPU 1
-(`~75 %` memory). This is the recommended starting layout — works on
-any pair of 80GB-class GPUs (A100, H100, H200) and on most 40GB+
-pairs as long as the thinker model weights fit.
+co-locates Thinker, codec-only Talker, and Code2Wav on GPU 0. Their
+`gpu_memory_utilization` budgets are 0.55, 0.15, and 0.15. The remaining
+device memory is left available for runtime workspaces such as the HiFi-GAN
+vocoder's cuDNN kernels. All stages admit
+up to four sequences. Startup video profiling is bounded to 32 frames per
+video. Use the two-GPU profile for production throughput.
 
 #### Environment
 
@@ -85,7 +100,41 @@ vllm serve openbmb/MiniCPM-o-4_5 --omni \
 ```
 
 The deploy config is auto-loaded by the model registry — no
-`--deploy-config` flag needed for this default 2-GPU layout.
+`--deploy-config` flag needed for this default single-GPU layout.
+
+For the recommended two-GPU layout, add:
+
+```bash
+--deploy-config vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
+```
+
+#### Performance comparison
+
+Compare text-only and text+audio separately. Text-only isolates Thinker
+generation; text+audio also schedules Talker and Code2Wav. The following full
+Daily-Omni runs used the same two GPUs, 1197 samples, concurrency 10, and
+identical `enable_thinking=false` / `use_tts_template=true` request settings.
+The `origin/main` fused Talker ran eager because its graph capture copied an
+unpinned CPU metadata tensor.
+
+| Metric | `origin/main` two-stage | Three-stage batching |
+| --- | ---: | ---: |
+| Accuracy | 64.83% | 64.83% |
+| Throughput | 0.62 req/s | 1.97 req/s |
+| Mean E2EL | 16.17 s | 5.07 s |
+| Mean serving TTFT | 0.92 s | 1.28 s |
+| Mean audio TTFP | 16.17 s | 3.24 s |
+| Mean audio RTF | 5.97 | 2.11 |
+| Stage 0 mean TPOT / ITL | 8.27 / 8.27 ms | 40.08 / 40.11 ms |
+| Stage 0 median TPOT / ITL | 7.23 / 7.24 ms | 7.43 / 7.53 ms |
+
+The split pipeline improves throughput 3.19x and lowers audio TTFP by 80%.
+Isolating the Thinker on GPU 0 also removes the prior single-GPU TPOT
+regression: 40.08 ms is slightly better than the pre-rebase report (~44 ms).
+Its median TPOT is effectively the same as main; the higher mean is queueing
+tail latency because this profile bounds each stage to four sequences while
+main's Thinker admits 16. Global TPOT/ITL remains zero when serving emits text
+as one aggregated chunk, so the table reports Stage 0 metrics.
 
 #### Verification
 
@@ -101,10 +150,10 @@ curl http://localhost:8099/v1/chat/completions \
     }'
 ```
 
-**Text + speech in one response** (the headline 4.5 feature). The TTS
-path is gated by a Jinja flag on the chat template. Pass
-`use_tts_template=true` via the **top-level** `chat_template_kwargs`
-field (curl does not flatten nested `extra_body`):
+**Text + speech in one response** (the headline 4.5 feature). The model
+bridge conditions the Talker from the generated assistant span, so the
+generic serving layer does not inject MiniCPM-specific template defaults.
+`use_tts_template=true` remains supported when explicitly requested:
 
 ```bash
 curl http://localhost:8099/v1/chat/completions \
@@ -126,6 +175,19 @@ in another choice's `message.audio.data` (24 kHz mono, see Notes). With
 `modalities: ["text", "audio"]` you typically get two `choices` entries
 (one text, one audio).
 
+**Streaming text + speech** (use `--stream`):
+
+```bash
+python examples/online_serving/minicpmo/openai_chat_completion_client_for_multimodal_generation.py \
+    --query-type text \
+    --prompt "Say hello, then introduce vLLM in one sentence." \
+    --port 8099 \
+    --stream
+```
+
+The client prints text deltas as they arrive and saves streamed audio chunks
+to WAV files.
+
 **Gradio demo (text + image + audio + video UI)**:
 
 ```bash
@@ -142,45 +204,36 @@ speech output (TTS)"** checkbox on / off.
 
 #### Notes
 
-- Memory budget: thinker weights occupy GPU 0 at `gpu_memory_utilization:
-  0.7`; talker + Token2Wav vocoder share GPU 1 at `0.75`.
+- Memory budget: Thinker, Talker, and Code2Wav reserve 0.55, 0.15, and
+  0.15 of GPU 0. The larger Thinker share protects its multimodal KV cache,
+  while the unreserved memory remains available to runtime kernels; all three
+  model processes still share one CUDA device.
 - `--trust-remote-code` is required — the HF repo ships a custom
   `MiniCPMO` config / model class.
-- Pin: `enforce_eager: true` on both stages (CUDA graph capture is off
-  by design for the talker's Token2Wav path).
-- Stage 1 (talker) is hard-capped to `max_num_seqs: 1`: the talker
-  only consumes `runtime_additional_information[0]`, so any value > 1
-  makes concurrent requests share request-0's audio. This is the same
-  cap baked into the deploy config.
-
-### 3 x GPU (thinker TP=2)
-
-Use
-[`vllm_omni/deploy/minicpmo_4_5_3gpu.yaml`](../../vllm_omni/deploy/minicpmo_4_5_3gpu.yaml)
-when you have a third GPU available and want the thinker on 2-way
-tensor parallel for higher throughput; the talker stays on its own
-GPU (talker has its own in-process Token2Wav vocoder, so co-locating
-it with the thinker risks OOM under load).
-
-#### Command
-
-```bash
-vllm serve openbmb/MiniCPM-o-4_5 --omni \
-    --deploy-config vllm_omni/deploy/minicpmo_4_5_3gpu.yaml \
-    --trust-remote-code \
-    --host 0.0.0.0 --port 8099
-```
-
-Verification and Notes mirror the 2-GPU section; thinker latency
-roughly halves under load thanks to TP=2.
+- Stage 0 Thinker and Stage 1 Talker enable vLLM CUDA Graphs. Stage 2 remains
+  eager because its request-owned Flow/HiFT caches and variable chunk/cache
+  shapes are not yet exposed through a static exact-shape graph wrapper.
+- All default stages use `max_num_seqs: 4` to reduce cross-process GPU
+  contention. Talker AR
+  state and Code2Wav caches are request-owned; Code2Wav batches only
+  exact-shape-compatible chunks and does not fall back to serial decode.
+- `limit_mm_per_prompt.video.num_frames: 32` bounds startup dummy profiling,
+  not runtime media decoding. Use `media_io_kwargs.video.num_frames` when a
+  matching URL/file video sampling limit is required.
+- `StageRequestStats.batch_size` is a request-scoped placeholder, not the
+  scheduler's execution batch.
+- Single-GPU co-location trades throughput for hardware density: Stage 0/1
+  CUDA Graph replay and eager Stage 2 vocoder kernels compete across three
+  CUDA contexts. Use the 8x4090 config or a custom multi-GPU mapping for
+  throughput-sensitive serving.
 
 ### 8 x RTX 4090 24GB (consumer-GPU layout)
 
 Use
 [`vllm_omni/deploy/minicpmo_4_5_8x4090.yaml`](../../vllm_omni/deploy/minicpmo_4_5_8x4090.yaml)
 on an 8x RTX 4090 host. Thinker uses 4-way TP across GPUs 0–3
-(`~85 %` mem each ≈ 20.4 GiB/card), talker + Token2Wav lives on GPU 4
-(`~90 %` mem). GPUs 5–7 are left free.
+(`~85 %` mem each ≈ 20.4 GiB/card), Talker uses GPU 4, and Code2Wav
+uses GPU 5. GPUs 6–7 are left free.
 
 #### Command
 
@@ -197,32 +250,38 @@ vllm serve openbmb/MiniCPM-o-4_5 --omni \
   4090s. Raise it if your cards have more headroom (e.g. 4090 D /
   custom 32 GB SKUs), but verify with a long-prompt run before
   promoting.
-- All other knobs match the 2-GPU section; the only difference is the
-  per-card memory pressure on the thinker shards.
+- All other knobs match the single-GPU section; the only difference is
+  the per-card memory pressure on the thinker shards.
 
 ## Notes (applies to all layouts)
 
-- **Talker dependency**: the `MiniCPM-o 4.5` talker calls
-  `from stepaudio2 import Token2wav` against the MiniCPM-o-flavored
+- **Code2Wav dependency**: Stage 2 loads `Token2wav` from the
+  MiniCPM-o-flavored
   vocoder (PyPI package `stepaudio2-minicpmo` — NOT the upstream
   `stepfun-ai/Step-Audio2`, whose `Token2wav.__init__` signature
   rejects `n_timesteps`). Install via the published extra:
 
   ```bash
-  pip install 'vllm-omni[minicpmo]'
+  pip install stepaudio2-minicpmo
   ```
 
-  Equivalent direct install: `pip install stepaudio2-minicpmo`. A
-  missing dep raises `ImportError` at first request with the same
+  A missing dep raises `ImportError` at first request with the same
   install hint instead of silently emitting empty audio.
 
-- **TTS trigger**: speech output requires
-  `chat_template_kwargs.use_tts_template=true` so the chat template
-  appends `<|tts_bos|>` before generation. Without it, Stage-1 talker
-  receives no TTS token span and returns silent audio (not text-only).
-  For **curl**, put `chat_template_kwargs` at the request root; nested
-  `extra_body.chat_template_kwargs` is ignored. The OpenAI Python SDK
-  may use `extra_body` because it flattens those fields into the root.
+- **TTS conditioning**: the MiniCPM stage bridge can condition speech from
+  the generated assistant span without changing shared serving code.
+  `chat_template_kwargs.use_tts_template=true` remains supported when an
+  explicit `<|tts_bos|>` boundary is desired. For **curl**, put
+  `chat_template_kwargs` at the request root; the OpenAI Python SDK may use
+  `extra_body` because it flattens those fields into the root.
+
+- **Reference voice**: request audio is carried on the first codec chunk.
+  Code2Wav owns the temporary prompt WAV and prompt-feature cache, and removes
+  both when the stream ends.
+
+- **Talker sampling**: codec-token sampling reads the checkpoint `tts_config`
+  and defaults to deterministic seed 42. Stage-1 deploy sampling parameters
+  control only vLLM's binary continue/stop token.
 
 - **Output audio**: 24 kHz mono WAV inside the OpenAI-style
   `message.audio.data` (base64). The Gradio demo's WAV player decodes
@@ -235,6 +294,9 @@ vllm serve openbmb/MiniCPM-o-4_5 --omni \
   with this recipe's `--deploy-config` will be rejected at startup
   rather than silently misrouted.
 
-- **Async chunking**: disabled in all three deploy configs
-  (`async_chunk: false`) — the talker batches a single full thinker
-  output, not chunks.
+- **Async chunking**: enabled in all deploy configs. Talker sends
+  25-code chunks with three-code left context to Code2Wav through
+  `SharedMemoryConnector`; terminal chunks flush held lookahead state.
+- **Response choices**: text and audio are separate choices. SDK clients
+  should select the choice whose `message.audio.data` is populated rather
+  than assuming `choices[0]` contains audio.
diff --git a/recipes/README.md b/recipes/README.md
index d335183ca..a6015d9b0 100644
--- a/recipes/README.md
+++ b/recipes/README.md
@@ -37,6 +37,7 @@ recipes/
 | [`audiox/AudioX.md`](./audiox/AudioX.md) | Offline + online unified text/video→audio diffusion | 1x L4 24GB |
 | [`Baidu/ERNIE-Image.md`](./Baidu/ERNIE-Image.md) | Text-to-image online serving (ERNIE-Image 8B) | 1x or 2x RTX 4090 24GB |
 | [`Bagel/BAGEL-7B-MoT.md`](./Bagel/BAGEL-7B-MoT.md) | Text-to-image with shared online/offline examples | 1x A100 80GB / 2x CUDA GPUs |
+| [`Boogu/Boogu-Image.md`](./Boogu/Boogu-Image.md) | Text-to-image online serving (Boogu-Image-0.1-Base) | 1x A100/H100 40GB+ |
 | [`BosonAI/Higgs-Audio-V3-TTS.md`](./BosonAI/Higgs-Audio-V3-TTS.md) | Online + offline multilingual TTS with voice cloning | 1x H100 80GB |
 | [`ByteDance/Lance.md`](./ByteDance/Lance.md) | Unified AR+diffusion: text/img/video gen + understanding (Lance 3B) | 1x B300 / A100 80GB |
 | [`fishaudio/Fish-Speech-S2-Pro.md`](./fishaudio/Fish-Speech-S2-Pro.md) | Online serving for TTS | 1x A800 80GB |
@@ -44,16 +45,20 @@ 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 |
+| [`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 |
-| [`LTX/LTX-2.md`](./LTX/LTX-2.md) | Text-to-video and image-to-video serving | 1x H200 141GB |
-| [`LTX/LTX-2.3.md`](./LTX/LTX-2.3.md) | Text-to-video with audio generation (22B) | 1x GPU (96GB VRAM) |
-| [`MammothModa2/MammothModa2-Preview.md`](./MammothModa2/MammothModa2-Preview.md) | Text-to-image with the shared offline image example (AR → DiT) | 1x L40S 48GB / 1x ≥40GB GPU |
+| [`LTX/LTX-2.md`](./LTX/LTX-2.md) | LTX-2/LTX-2.3 text-to-video and image-to-video with synchronized audio | H200 141GB / 96GB-class GPU |
+| [`MammothModa2/MammothModa2.md`](./MammothModa2/MammothModa2.md) | Preview and Dev text-to-image (AR → DiT); Dev text/image understanding | Preview: 1x L40S 48GB / 1x ≥40GB GPU; Dev: 1x NVIDIA GPU with sufficient cache headroom |
 | [`mistralai/Voxtral-TTS.md`](./mistralai/Voxtral-TTS.md) | Online serving for TTS | 1x RTX 4090 24GB |
+| [`Robbyant/LingBot-Video.md`](./Robbyant/LingBot-Video.md) | Native dense and MoE text-to-video serving | Dense: 1x L20X; MoE: 1x L20X (~67.7 GiB peak) |
 | [`cosmos3/Cosmos3-Nano.md`](./cosmos3/Cosmos3-Nano.md) | Text-to-image, text-to-video, image-to-video, video-to-video generation, text to video with sound, action policy | 1x H200 141GB / B300 |
+| [`cosmos3/Cosmos3-Edge.md`](./cosmos3/Cosmos3-Edge.md) | T2I / T2V / I2V + action (Physical-AI) generation on the Nemotron-based Edge transformer | 1x GPU (~8 GiB) |
 | [`cosmos3/Cosmos3-Super.md`](./cosmos3/Cosmos3-Super.md) | 64B T2I / T2V / I2V / V2V generation (+ optional audio) / Action policy | 8x H200/H100/A100 / 2x H200 / B300 |
 | [`OpenBMB/MiniCPM-o-4_5.md`](./OpenBMB/MiniCPM-o-4_5.md) | Online serving for omni multimodal chat (text / image / audio / video → text + 24 kHz speech) | 2x A100/H100 80GB / 3x mid-tier GPU / 8x RTX 4090 24GB |
 | [`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 |
 | [`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 |
@@ -63,6 +68,7 @@ recipes/
 | [`StabilityAI/Stable-Audio-Open.md`](./StabilityAI/Stable-Audio-Open.md) | Offline + online text-to-audio generation (Stable Audio Open) | 1x RTX 4090 24GB |
 | [`Tencent/Covo-Audio-Chat.md`](./Tencent/Covo-Audio-Chat.md) | Online serving for audio chat | 1x A100 80GB |
 | [`Tencent/HunyuanImage-3.0-Instruct.md`](./Tencent/HunyuanImage-3.0-Instruct.md) | DiT-only text-to-image serving and benchmark, including ModelOpt mixed FP8/NVFP4 | 4x H100/H800 80GB / 2x B200 |
+| [`Wan-AI/Wan2.2-T2V.md`](./Wan-AI/Wan2.2-T2V.md) | Text-to-video serving (Wan2.2 14B) with Skip-Softmax sparse attention | 1x datacenter Blackwell (B200/B300) |
 | [`Wan-AI/Wan2.2-I2V.md`](./Wan-AI/Wan2.2-I2V.md) | Image-to-video serving (Wan2.2 14B) | 8x Ascend NPU (A2/A3) |
 | [`Wan-AI/Wan2.2-S2V.md`](./Wan-AI/Wan2.2-S2V.md) | Speech-to-video serving (Wan2.2 14B) | 2x A100/H100 80GB |
 | [`Wan-AI/Wan2.1-VACE.md`](./Wan-AI/Wan2.1-VACE.md) | Unified T2V, I2V, V2LF, FLF2V, inpaint, and R2V | 1x RTX 5090 (1.3B) / 1x L40S 48GB with layerwise offload (14B) |
diff --git a/recipes/Robbyant/LingBot-Video.md b/recipes/Robbyant/LingBot-Video.md
new file mode 100644
index 000000000..289d36990
--- /dev/null
+++ b/recipes/Robbyant/LingBot-Video.md
@@ -0,0 +1,259 @@
+# LingBot-Video
+
+> Native dense and MoE text-to-video serving for LingBot-Video
+
+## Summary
+
+- Vendor: Robbyant
+- Models: `robbyant/lingbot-video-dense-1.3b` and `robbyant/lingbot-video-moe-30b-a3b`
+- Task: Text-to-video generation
+- Mode: Offline generation and online serving with the OpenAI-compatible `/v1/videos` API
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe when you want to run a dense or MoE LingBot-Video checkpoint
+with vLLM-Omni's native pipeline. The runtime path does not import the upstream
+`lingbot_video` Python package; it loads checkpoint components directly with
+the in-tree `LingBotVideoPipeline`, dense or routed-MoE DiT blocks, shared
+FlowUniPC scheduler, Qwen3-VL text encoder, and Wan VAE.
+
+This first MoE integration is intentionally text-to-video and single-GPU only.
+It targets the base BF16 checkpoint without its optional refiner or additional
+parallel, cache, quantized, or expert-kernel backends.
+
+## References
+
+- Dense checkpoint: <https://huggingface.co/robbyant/lingbot-video-dense-1.3b>
+- MoE checkpoint: <https://huggingface.co/robbyant/lingbot-video-moe-30b-a3b>
+- Upstream project: <https://github.com/Robbyant/lingbot-video>
+- Related offline example: [`examples/offline_inference/text_to_video/text_to_video_lingbot.py`](../../examples/offline_inference/text_to_video/text_to_video_lingbot.py)
+- Related online video API docs: [`docs/serving/videos_api.md`](../../docs/serving/videos_api.md)
+
+## Hardware Support
+
+This recipe documents the CUDA single-GPU dense and BF16 MoE checkpoint paths.
+Multi-GPU parallelism, Cache-DiT, quantization, and CPU offload are not
+validated for LingBot-Video in this PR.
+
+## GPU
+
+### 1 x NVIDIA L20X
+
+Both checkpoints have been smoke-tested on one NVIDIA L20X at `192x320`,
+9 frames, and 2 steps. The MoE smoke reserved approximately `67.70 GiB` of GPU
+memory, so use a GPU with at least about 70 GiB of available memory for this
+small validation shape. Larger resolutions, frame counts, or concurrent
+requests require additional headroom.
+
+The MoE path is validated with BF16 expert weights.
+
+#### Dense offline T2V
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python examples/offline_inference/text_to_video/text_to_video_lingbot.py \
+  --model robbyant/lingbot-video-dense-1.3b \
+  --prompt "a robotic arm picks up a red block" \
+  --output lingbot_t2v.mp4 \
+  --height 192 \
+  --width 320 \
+  --num-frames 9 \
+  --num-inference-steps 2 \
+  --guidance-scale 3.0 \
+  --flow-shift 3.0 \
+  --seed 42 \
+  --fps 24
+```
+
+#### MoE offline T2V
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python examples/offline_inference/text_to_video/text_to_video_lingbot.py \
+  --model robbyant/lingbot-video-moe-30b-a3b \
+  --prompt "a robotic arm picks up a red block" \
+  --output lingbot_moe_t2v.mp4 \
+  --height 192 \
+  --width 320 \
+  --num-frames 9 \
+  --num-inference-steps 2 \
+  --guidance-scale 3.0 \
+  --flow-shift 3.0 \
+  --seed 42 \
+  --fps 24
+```
+
+#### Online serving
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+vllm serve robbyant/lingbot-video-dense-1.3b \
+  --omni \
+  --model-class-name LingBotVideoPipeline \
+  --default-sampling-params \
+  '{"0":{"num_frames":81,"num_inference_steps":40,"guidance_scale":6.0}}' \
+  --port 8091
+```
+
+For the MoE checkpoint, use the same single-GPU pipeline:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+vllm serve robbyant/lingbot-video-moe-30b-a3b \
+  --omni \
+  --model-class-name LingBotVideoPipeline \
+  --default-sampling-params \
+  '{"0":{"num_frames":81,"num_inference_steps":40,"guidance_scale":6.0}}' \
+  --port 8091
+```
+
+These stage defaults match the LingBot reference pipeline. Request-level
+values continue to override them, so the smaller smoke request below remains
+unchanged.
+
+When serving MoE, replace the request's `model` form value below with
+`robbyant/lingbot-video-moe-30b-a3b`.
+
+After the server is ready, submit a text-to-video job:
+
+```bash
+create_response=$(curl -s http://localhost:8091/v1/videos \
+  -F "model=robbyant/lingbot-video-dense-1.3b" \
+  -F "prompt=a robotic arm picks up a red block" \
+  -F "width=320" \
+  -F "height=192" \
+  -F "num_frames=9" \
+  -F "fps=24" \
+  -F "num_inference_steps=2" \
+  -F "guidance_scale=3.0" \
+  -F "flow_shift=3.0" \
+  -F "seed=42")
+
+video_id=$(echo "${create_response}" | jq -r '.id')
+while true; do
+  status=$(curl -s "http://localhost:8091/v1/videos/${video_id}" | jq -r '.status')
+  if [ "${status}" = "completed" ]; then
+    break
+  fi
+  if [ "${status}" = "failed" ]; then
+    curl -s "http://localhost:8091/v1/videos/${video_id}" | jq .
+    exit 1
+  fi
+  sleep 2
+done
+
+curl -L "http://localhost:8091/v1/videos/${video_id}/content" -o lingbot_t2v.mp4
+```
+
+## Key Parameters
+
+| Parameter | Suggested smoke value | Notes |
+|-----------|-----------------------|-------|
+| `height` | `192` | Must be a multiple of 16 |
+| `width` | `320` | Must be a multiple of 16 |
+| `num_frames` | `9` | Must be `1` or `4n + 1`; this PR validates T2V with video outputs |
+| `num_inference_steps` | `2` | Use more steps for quality sweeps |
+| `guidance_scale` | `3.0` | CFG is active when this is greater than `1.0` |
+| `flow_shift` | `3.0` | Scheduler flow-shift; aliases the pipeline's internal `shift` |
+| `negative_prompt` | model default | Optional text describing artifacts to avoid |
+| `fps` | `24` | Output MP4 frame rate |
+
+## Validation
+
+Local dense smoke run:
+
+- Shape: 9 frames at `192x320`
+- Steps: 2
+- Request generation time: `0.2923s`
+- Peak reserved GPU memory: `14548 MiB`
+
+Local dense parity harness against the upstream repository:
+
+- Shape: `[9, 192, 320, 3]`
+- MAE: `0.0065238`
+- MSE: `0.00006650`
+- PSNR: `41.77 dB`
+- Native request time: `0.2875s`
+
+Local MoE validation on one NVIDIA L20X used checkpoint revision
+`f2e538f64afe00cc4ae674db2aeb52e2945edfd5`:
+
+- Loaded all `977` transformer state keys and `30,084,506,176` parameters.
+- Router weights and correction biases stayed in FP32; routed and shared
+  expert weights loaded in BF16.
+- The complete 48-layer transformer forward returned finite
+  `[1, 16, 1, 8, 8]` BF16 output.
+- With both implementations using matched math SDPA backends, the complete
+  native transformer matched the upstream implementation bitwise
+  (`max_abs=0`, `mean_abs=0`).
+- An isolated sparse MoE block exercising the router, grouped experts, scatter
+  restore, and shared expert also matched the upstream implementation bitwise.
+- The native pipeline generated a 9-frame `192x320` MP4 in 2 steps with
+  `69326 MiB` (`67.70 GiB`) peak reserved GPU memory.
+- The online `/v1/videos` smoke created, polled, and downloaded the generated
+  MP4 successfully (`1 passed`).
+
+Do not treat these as production benchmarks; they are functional smoke plus
+controlled numerical-parity evidence for small validation inputs.
+
+## Reproducing MoE numerical parity
+
+The in-tree parity harness compares the native MoE implementation with a local
+checkout of the upstream LingBot-Video implementation. It uses local files
+only and does not download checkpoints.
+
+Set paths for the upstream checkout and the cached MoE checkpoint:
+
+```bash
+export LINGBOT_VIDEO_REPO=/path/to/lingbot-video
+export LINGBOT_VIDEO_MOE_MODEL=/path/to/lingbot-video-moe-30b-a3b
+```
+
+Run the lightweight sparse-block comparison:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python benchmarks/lingbot_video/moe_transformer_parity.py \
+  --scope block \
+  --official-repo "${LINGBOT_VIDEO_REPO}" \
+  --output-json /tmp/lingbot_moe_block_parity.json
+```
+
+This path covers bias-corrected router selection, group-limited top-k, routed
+experts, FP32 scatter-weighted restore, padding masks, and the shared expert.
+It exits with a nonzero status unless the upstream and native block outputs are
+bitwise equal.
+
+The real-checkpoint transformer comparison requires one GPU with enough memory
+for the 30B checkpoint. Models are loaded sequentially, so two copies are not
+resident on the GPU at the same time:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+python benchmarks/lingbot_video/moe_transformer_parity.py \
+  --scope transformer \
+  --official-repo "${LINGBOT_VIDEO_REPO}" \
+  --model "${LINGBOT_VIDEO_MOE_MODEL}" \
+  --output-json /tmp/lingbot_moe_transformer_parity.json
+```
+
+Transformer parity fixes the official implementation to
+`diffusers:_native_math` and the native implementation to
+`TORCH_SDPA + SDPBackend.MATH`. The expected result is `exact=true`,
+`output.equal=true`, and zero max/mean/RMSE error. Different fused attention
+kernels can introduce BF16 rounding differences before MoE routing, so
+automatic attention-backend comparisons are diagnostic only and are not the
+bitwise correctness oracle.
+
+## Known Limitations
+
+- T2V base-transformer inference only. T2I, I2V, TI2V, and the checkpoint's
+  optional `refiner/` transformer are not supported by this PR.
+- Only the BF16 MoE checkpoint is validated in this first integration.
+- No HSDP, tensor, sequence, expert, or CFG parallelism is claimed.
+- No Cache-DiT, TeaCache, CPU offload, VAE patch parallelism, or quantized
+  inference is claimed.
+- Optional Triton, SGLang, FP8, and alternative fused-expert backends from the
+  upstream project are not included.
+- Only one request per LingBot pipeline batch is currently supported.
diff --git a/recipes/SenseNova/SenseNova-U1.md b/recipes/SenseNova/SenseNova-U1.md
index 5cb30a21d..be25df570 100644
--- a/recipes/SenseNova/SenseNova-U1.md
+++ b/recipes/SenseNova/SenseNova-U1.md
@@ -22,8 +22,10 @@ text-to-text chat.
 
 ## References
 
-- Offline example:
-  [`examples/offline_inference/sensenova_u1/end2end.py`](../../examples/offline_inference/sensenova_u1/end2end.py)
+- Offline text-to-image:
+  [`examples/offline_inference/text_to_image/text_to_image.py`](../../examples/offline_inference/text_to_image/text_to_image.py)
+- Offline image-to-image:
+  [`examples/offline_inference/image_to_image/image_edit.py`](../../examples/offline_inference/image_to_image/image_edit.py)
 - Online serving:
   [`examples/online_serving/sensenova_u1/`](../../examples/online_serving/sensenova_u1/)
 - E2E tests:
@@ -48,13 +50,14 @@ text-to-text chat.
 #### Command
 
 ```bash
-python examples/offline_inference/sensenova_u1/end2end.py \
+python examples/offline_inference/text_to_image/text_to_image.py \
+    --model SenseNova/SenseNova-U1-8B-MoT \
     --prompt "Close portrait of an elderly woman by a farmhouse window, textured skin, gentle smile, warm natural light, emotional documentary look. The portrait should feel polished and natural, with sharp eyes, realistic skin texture, accurate facial anatomy, and premium lighting that keeps the face as the main focus." \
     --width 1536 --height 2720 \
-    --seed 42 --num-steps 50 \
-    --cfg-scale 4.0 --timestep-shift 3.0 --cfg-norm none \
-    --think --print-think \
-    --output outputs
+    --seed 42 --num-inference-steps 50 \
+    --cfg-scale 4.0 \
+    --extra-body '{"think": true, "cfg_norm": "none", "timestep_shift": 3.0, "t_eps": 0.02}' \
+    --output outputs/sensenova_u1_output.png
 ```
 
 #### Verification
@@ -74,8 +77,7 @@ pytest -s -v tests/e2e/offline_inference/test_sensenova_u1_text2img.py \
 
 #### Text-to-Image via the shared example
 
-SenseNova-U1 is also registered with the shared text-to-image example, so you
-can run it through `text_to_image.py` instead of `end2end.py`. Forward the
+SenseNova-U1 is registered with the shared text-to-image example. Forward
 SenseNova-specific generation parameters as a JSON object through `--extra-body`:
 
 ```bash
@@ -94,48 +96,49 @@ The `--extra-body` keys are filtered against the model's declared
 [`vllm_omni/model_extras/sensenova_u1.py`](../../vllm_omni/model_extras/sensenova_u1.py)):
 `think`, `cfg_scale`, `cfg_norm`, `timestep_shift`, `t_eps`, `img_cfg_scale`,
 and `max_tokens`. No deploy YAML is needed — the engine auto-generates a
-single-stage diffusion config. For richer task modalities (img2text, text2text)
-and CPU offload, use the dedicated `end2end.py` script described above.
+single-stage diffusion config.
 
 #### Image-to-Image Editing (img2img)
 
 ```bash
-python examples/offline_inference/sensenova_u1/end2end.py \
+python examples/offline_inference/image_to_image/image_edit.py \
+    --model SenseNova/SenseNova-U1-8B-MoT \
     --prompt "Turn this into an oil painting" \
     --image input.png \
-    --width 2048 --height 2048 \
-    --seed 42 --num-steps 50 \
-    --cfg-scale 4.0 --img-cfg-scale 1.0 --cfg-norm none \
-    --think --print-think \
-    --output outputs
+    --resolution 2048 \
+    --seed 42 --num-inference-steps 50 \
+    --cfg-scale 4.0 \
+    --extra-args '{"think": true, "img_cfg_scale": 1.0, "cfg_norm": "none", "timestep_shift": 3.0}' \
+    --output outputs/sensenova_u1_edit.png
 ```
 
-- img2img uses dual CFG: `--cfg-scale` controls text guidance, `--img-cfg-scale`
-  controls image guidance (1.0 = image CFG disabled).
-- Pass multiple `--image` paths for multi-reference editing.
+- img2img uses dual CFG: `--cfg-scale` controls text guidance, while
+  `img_cfg_scale` in `--extra-args` controls image guidance (1.0 = image CFG
+  disabled).
+- Pass multiple `--image` paths for multi-reference editing when the underlying
+  pipeline supports them.
 
 #### Image Understanding (img2text)
 
 ```bash
-python examples/offline_inference/sensenova_u1/end2end.py \
-    --modality img2text \
+vllm serve SenseNova/SenseNova-U1-8B-MoT --omni --port 8091
+python examples/online_serving/sensenova_u1/openai_chat_client.py \
     --prompt "Describe this image in detail" \
-    --image photo.jpg \
-    --max-tokens 512
+    --modality img2text \
+    --image-url photo.jpg
 ```
 
 #### Text-to-Text Chat (text2text)
 
 ```bash
-python examples/offline_inference/sensenova_u1/end2end.py \
-    --modality text2text \
+vllm serve SenseNova/SenseNova-U1-8B-MoT --omni --port 8091
+python examples/online_serving/sensenova_u1/openai_chat_client.py \
     --prompt "Explain the theory of relativity in simple terms" \
-    --max-tokens 256
+    --modality text2text
 ```
 
-- For img2text and text2text, image generation parameters (height, width,
-  num-steps, cfg-scale) are ignored.
-- Use `--do-sample --temperature 0.7` for more diverse text responses.
+- For img2text and text2text, use the online chat-compatible example. The
+  offline generic image examples intentionally focus on image-producing tasks.
 
 ### 2x H200 (144GB) — TP=2
 
@@ -149,19 +152,20 @@ python examples/offline_inference/sensenova_u1/end2end.py \
 #### Command
 
 ```bash
-python examples/offline_inference/sensenova_u1/end2end.py \
+python examples/offline_inference/text_to_image/text_to_image.py \
+    --model SenseNova/SenseNova-U1-8B-MoT \
     --prompt "Close portrait of an elderly woman by a farmhouse window, textured skin, gentle smile, warm natural light, emotional documentary look. The portrait should feel polished and natural, with sharp eyes, realistic skin texture, accurate facial anatomy, and premium lighting that keeps the face as the main focus." \
     --width 1536 --height 2720 \
-    --seed 42 --num-steps 50 \
-    --cfg-scale 4.0 --timestep-shift 3.0 --cfg-norm none \
-    --think --print-think \
+    --seed 42 --num-inference-steps 50 \
+    --cfg-scale 4.0 \
+    --extra-body '{"think": true, "cfg_norm": "none", "timestep_shift": 3.0, "t_eps": 0.02}' \
     --tensor-parallel-size 2 \
-    --output outputs
+    --output outputs/sensenova_u1_output.png
 ```
 
 #### Verification
 
-Verify the output image is generated at `outputs/sensenova_u1_output_0.png`
+Verify the output image is generated at `outputs/sensenova_u1_output.png`
 with the expected 1536×2720 resolution.
 
 #### Notes
diff --git a/recipes/Tencent/HunyuanImage-3.0-Instruct.md b/recipes/Tencent/HunyuanImage-3.0-Instruct.md
index 3e6adf130..a9a63d5ce 100644
--- a/recipes/Tencent/HunyuanImage-3.0-Instruct.md
+++ b/recipes/Tencent/HunyuanImage-3.0-Instruct.md
@@ -8,8 +8,8 @@
 
 - Vendor: Tencent Hunyuan
 - Model: `tencent/HunyuanImage-3.0-Instruct`
-- Task: Text-to-image generation
-- Mode: Online serving and performance benchmarking, DiT stage only
+- Task: Text-to-image generation; text-to-text and image-to-text understanding
+- Mode: Offline understanding, online serving, and performance benchmarking
 - Maintainer: Community
 
 ## When to use this recipe
@@ -31,8 +31,10 @@ FP8/NVFP4 configuration:
 ## References
 
 - Model: <https://huggingface.co/tencent/HunyuanImage-3.0-Instruct>
-- Offline example:
+- Existing model-specific offline example:
   [`examples/offline_inference/hunyuan_image3`](../../examples/offline_inference/hunyuan_image3)
+- Shared T2T/I2T example:
+  [`examples/offline_inference/x_to_text/x_to_text.py`](../../examples/offline_inference/x_to_text/x_to_text.py)
 - Related PRs:
   [#2495](https://github.com/vllm-project/vllm-omni/pull/2495) for DiT performance CI,
   [#3055](https://github.com/vllm-project/vllm-omni/pull/3055) for GEBench accuracy CI,
@@ -42,6 +44,31 @@ FP8/NVFP4 configuration:
 
 ## GPU
 
+### Shared T2T/I2T offline example
+
+For text-to-text, the shared x-to-text example automatically selects the
+AR-only Hunyuan deploy config and applies the checkpoint's prompt tokens and
+stop-token rules:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --prompt "Explain why the sky appears blue."
+```
+
+Add `--image` for image-to-text:
+
+```bash
+python examples/offline_inference/x_to_text/x_to_text.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --image /path/to/input.jpg \
+  --prompt "Describe the content of this image."
+```
+
+The AR-only default uses four GPUs. Pass `--deploy-config` to override the
+layout. Image-output tasks remain documented by the existing model-specific
+example and the DiT sections below.
+
 ### 4x H100/H800 80GB
 
 #### Environment
@@ -137,10 +164,11 @@ curl -s http://localhost:8091/v1/chat/completions \
 PR [#2495](https://github.com/vllm-project/vllm-omni/pull/2495) adds
 performance CI configs for the same DiT-only settings. The CI step is
 currently opt-in (gated by `RUN_HUNYUAN_IMAGE3_PERF=1`) with `soft_fail`
-enabled, intended for initial data collection. Performance assertions are
-skipped (`skip-performance-assertion: true`); the baseline values in the
-JSON configs are reference-only and will be promoted to regression gates
-once enough nightly data has been collected.
+enabled, intended for initial data collection. Perf runners no longer
+compare metrics against JSON baselines at assert time; the `baseline`
+blocks in the configs are reference-only and are copied into result JSON
+for reporting. Regression gates can be reintroduced once enough nightly
+data has been collected.
 
 The user-facing equivalent is to launch one of the CLI commands above and
 generate 1024x1024 images with 50 denoising steps.
diff --git a/recipes/Wan-AI/Wan2.2-T2V.md b/recipes/Wan-AI/Wan2.2-T2V.md
new file mode 100644
index 000000000..640129a47
--- /dev/null
+++ b/recipes/Wan-AI/Wan2.2-T2V.md
@@ -0,0 +1,186 @@
+# Wan2.2 Text-to-Video
+
+> Text-to-video serving (Wan2.2 14B), with optional Skip-Softmax sparse attention on Blackwell
+
+## Summary
+
+- Vendor: Wan-AI
+- Model: `Wan-AI/Wan2.2-T2V-A14B-Diffusers`
+- Task: Text-to-video generation
+- Mode: Online serving with the OpenAI-compatible API (offline `Omni` also supported)
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to deploy the Wan2.2 14B text-to-video model with vLLM-Omni. The
+standard plan is multi-card serving with sequence/CFG parallelism (below). On
+**datacenter Blackwell** (sm_100 / sm_103) you can additionally enable
+**Skip-Softmax** through the `TRTLLM_ATTN` backend for extra speed — see the
+Blackwell section.
+
+## References
+
+- Upstream model card: <https://huggingface.co/Wan-AI/Wan2.2-T2V-A14B-Diffusers>
+- Attention backends guide: [`docs/user_guide/diffusion/attention_backends.md`](../../docs/user_guide/diffusion/attention_backends.md)
+- Skip-Softmax design: [`docs/design/feature/skip_softmax.md`](../../docs/design/feature/skip_softmax.md)
+
+## Hardware Support
+
+## GPU
+
+### 8x NVIDIA H20 / H100 / A100 (standard multi-card serving)
+
+The recommended parallel strategy depends on whether the checkpoint needs
+classifier-free guidance:
+
+1. **Distilled model (no CFG)** — higher throughput; use when the checkpoint does
+   not require negative-prompt computation.
+2. **Official open-source model (with CFG)** — uses CFG parallelism to run the
+   negative and positive samples for the original released weights.
+
+#### Environment
+
+- OS: Linux
+- Python: 3.10+
+- Driver / runtime: NVIDIA driver with a CUDA runtime supported by your PyTorch build
+- vLLM version: Match the repository requirements for your checkout
+- vLLM-Omni version or commit: Use the commit you are deploying from
+
+#### Command
+
+**Distilled model (no CFG, recommended for distilled checkpoints):**
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 \
+vllm serve Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --omni \
+  --use-hsdp \
+  --usp 8 \
+  --vae-patch-parallel-size 8 \
+  --vae-use-tiling
+```
+
+**Official open-source model (with CFG):**
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 \
+vllm serve Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --omni \
+  --use-hsdp \
+  --cfg-parallel-size 2 \
+  --usp 4 \
+  --vae-patch-parallel-size 8 \
+  --vae-use-tiling
+```
+
+The official model splits the positive and negative CFG branches with
+`--cfg-parallel-size 2`, keeping Ulysses sequence parallelism at `--usp 4` so the
+two branches cover all 8 GPUs (`usp * cfg = 8`).
+
+#### Verification
+
+For online serving client examples and request formats, see
+[`examples/online_serving/text_to_video`](../../examples/online_serving/text_to_video).
+
+#### Notes
+
+- **Key flags:**
+  - `--omni` — enables vLLM-Omni diffusion serving.
+  - `--use-hsdp` — Hybrid Sharded Data Parallelism for the 14B DiT weights.
+  - `--usp <N>` — Unified (Ulysses) Sequence Parallelism degree.
+  - `--cfg-parallel-size <N>` — CFG parallelism; set to 2 for the official model,
+    omit for distilled checkpoints.
+  - `--vae-patch-parallel-size 8` / `--vae-use-tiling` — parallel + tiled VAE
+    decoding; disabling patch parallelism can significantly increase VAE latency.
+
+## Accelerating with TRTLLM_ATTN + Skip-Softmax (datacenter Blackwell)
+
+On **datacenter Blackwell** (sm_100 / sm_103), the mask-free Wan pipeline
+auto-routes to the `TRTLLM_ATTN` backend, which can enable **Skip-Softmax** — a
+sparse-attention mode that trades a little fidelity for speed. This composes with
+the multi-card plan above (Ulysses SP is compatible; ring SP is not).
+
+### Environment
+
+- Same as above, plus: datacenter Blackwell (sm_100 / sm_103), `head_dim == 128`,
+  and `flashinfer` (already a hard dependency of vLLM — no extra install).
+
+### Command
+
+Dense BF16 (Skip-Softmax off — `TRTLLM_ATTN` is already the Blackwell auto-route
+for mask-free Wan, so no flags are needed):
+
+```bash
+vllm serve Wan-AI/Wan2.2-T2V-A14B-Diffusers --omni
+```
+
+With Skip-Softmax (calibrated curve — the `(a, b)` curve is read from the
+checkpoint's `sparse_attention_config`; you only pick the operating point):
+
+```bash
+vllm serve Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --omni \
+  --diffusion-attention-config '{"default": {"backend": "TRTLLM_ATTN",
+      "skip_softmax": {"target_sparsity": 0.65, "disabled_until_timestep": 0.86}}}'
+```
+
+Offline, the same config is a typed object (or the equivalent dict) — values are
+validated at construction:
+
+```python
+from vllm_omni import Omni
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, SkipSoftmaxSpec
+
+llm = Omni(
+    model="Wan-AI/Wan2.2-T2V-A14B-Diffusers",
+    diffusion_attention_config=AttentionConfig(
+        default=AttentionSpec(
+            backend="TRTLLM_ATTN",
+            skip_softmax=SkipSoftmaxSpec(target_sparsity=0.65, disabled_until_timestep=0.86),
+        ),
+    ),
+)
+```
+
+Calibration-free path (no checkpoint curve needed — set an absolute threshold
+instead of `target_sparsity`):
+
+```bash
+--diffusion-attention-config '{"default": {"backend": "TRTLLM_ATTN",
+    "skip_softmax": {"threshold": 0.02, "disabled_until_timestep": 0.86}}}'
+```
+
+### Skip-Softmax controls
+
+| Key | Valid values | Meaning |
+|---|---|---|
+| `target_sparsity` | finite, `[0, 1]` | Operating point on the checkpoint's calibrated curve (`a·exp(b·s)`). |
+| `threshold` | finite, `≥ 0` | Direct skip threshold, no calibration needed. Mutually exclusive with `target_sparsity`. |
+| `disabled_until_timestep` | finite, `[0, 1]` | Keeps early, high-noise steps dense; skip turns on once the normalized timestep `t ≤ D`. |
+
+**Start at `target_sparsity=0.65, disabled_until_timestep=0.86`** (near-lossless)
+and raise `target_sparsity` only as far as your quality bar allows — the output
+diverges from dense as it climbs. Gate the noisy early steps first (`D`), then
+raise sparsity; the timestep gate buys more speed per unit of divergence than
+sparsity does. The gain grows with sequence length, since Skip-Softmax only
+accelerates attention.
+
+Measured on B300 / SM103, 1280×720 / 81f / 50 steps, torch.compile, official
+ModelOpt calibration (speedup and divergence relative to dense):
+
+| config | speedup | LPIPS (divergence vs dense) |
+|---|---|---|
+| dense | 1.000x | - |
+| `s=0.65, D=0.86` | 1.062x | 0.041 |
+| `s=0.75, D=1.00` | 1.181x | 0.377 |
+| `s=1.00` | 1.202x | 0.597 |
+
+### Notes
+
+- **Requirements:** datacenter Blackwell (sm_100 / sm_103), `head_dim == 128`, and
+  `flashinfer`. Elsewhere, or without FlashInfer, selecting `TRTLLM_ATTN` raises
+  rather than silently degrading.
+- **Known limitations:**
+  - Skip-Softmax is not supported under ring sequence parallelism; use Ulysses SP
+    (`--usp`), or run Skip-Softmax without ring.
+  - `TRTLLM_ATTN` is BF16-only (no attention-level quantization).
diff --git a/recipes/cosmos3/Cosmos3-DistOffload.md b/recipes/cosmos3/Cosmos3-DistOffload.md
new file mode 100644
index 000000000..8eeea5cc2
--- /dev/null
+++ b/recipes/cosmos3/Cosmos3-DistOffload.md
@@ -0,0 +1,199 @@
+# Cosmos3 — Distributed Layerwise Offload
+
+> Sharding weights across DP ranks with H2D + AllGather overlap for multi-NPU/GPU deployment
+
+## When to use this recipe
+
+Use this recipe when deploying Cosmos3-Super (64B / 124 GB) or Cosmos3-Nano (17B / 33 GB) across multiple devices where the model does not fit on a single device's HBM, or when you need higher throughput via DP multi-concurrency.
+
+**Key benefits:**
+- Each rank stores only 1/dp_size of the model weights on host memory
+- Only 2 transformer blocks reside on each device at any time (fixed double-buffer)
+- DP multi-concurrency: N concurrent requests with near-linear throughput scaling
+- mmap weight loading: shared page cache eliminates O(dp_size × model_size) RSS
+
+## Prerequisites
+
+- 2+ NPU or GPU devices (Ascend 910B3, NVIDIA B300, etc.)
+- vLLM-Omni with distributed layerwise offload support
+- Cosmos3-Nano or Cosmos3-Super checkpoint (local path or HuggingFace repo ID)
+
+## Serve commands
+
+### Cosmos3-Nano with DP=4 + AllGather (recommended for max throughput)
+
+```bash
+vllm serve /path/to/Cosmos3-Nano \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --no-guardrails --init-timeout 3600 \
+  --vae-use-tiling --vae-patch-parallel-size 1 \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 4
+```
+
+### Cosmos3-Super with DP=2 + AllGather (for models > single-card HBM)
+
+```bash
+vllm serve /path/to/Cosmos3-Super \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --no-guardrails --init-timeout 3600 \
+  --vae-use-tiling --vae-patch-parallel-size 1 \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 2
+```
+
+### Cosmos3-Super with DP=4 + AllGather
+
+```bash
+vllm serve /path/to/Cosmos3-Super \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --no-guardrails --init-timeout 3600 \
+  --vae-use-tiling --vae-patch-parallel-size 1 \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 4
+```
+
+### Without DLO AllGather (rank-local weights, no DLO sharding)
+
+Use `--dlo-no-use-allgather` when you want each rank to stream the standard
+loader's rank-local weights independently — no DLO AllGather synchronization,
+no concurrent request requirement, but no DLO weight sharding and higher host
+memory use. In pure DP, this is equivalent to independent full-weight
+layerwise-offload replicas; with TP or HSDP, each rank retains the standard
+loader's local tensor layout.
+
+```bash
+vllm serve /path/to/Cosmos3-Nano \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --no-guardrails --init-timeout 3600 \
+  --vae-use-tiling --vae-patch-parallel-size 1 \
+  --enable-distributed-layerwise-offload \
+  --data-parallel-size 4 \
+  --dlo-no-use-allgather
+```
+
+### With SP (sequence parallel) instead of DP
+
+For long-sequence workloads where SP parallelism is preferred:
+
+```bash
+vllm serve /path/to/Cosmos3-Super \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --no-guardrails --init-timeout 3600 \
+  --vae-use-tiling --vae-patch-parallel-size 1 \
+  --enable-distributed-layerwise-offload \
+  --usp 4
+```
+
+## Request examples
+
+### Text-to-Image (T2I)
+
+```bash
+curl -s -o output.png -X POST "http://localhost:8000/v1/images/generations" \
+  -H "Content-Type: multipart/form-data" \
+  -F "model=/path/to/Cosmos3-Nano" \
+  -F "prompt=A robot arm cleaning a plate, cinematic" \
+  -F "size=1024x1024" \
+  -F "num_inference_steps=50" \
+  -F "guidance_scale=6.0" \
+  -F "seed=42"
+```
+
+### Text-to-Video (T2V)
+
+```bash
+curl -s -o output.mp4 -X POST "http://localhost:8000/v1/videos/sync" \
+  -H "Accept: video/mp4" \
+  -F "model=/path/to/Cosmos3-Nano" \
+  -F "prompt=A robot arm cleaning a plate, cinematic shot" \
+  -F "negative_prompt=blurry" \
+  -F "size=832x480" \
+  -F "num_frames=29" \
+  -F "fps=24" \
+  -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" \
+  -F "max_sequence_length=4096" \
+  -F "flow_shift=10.0" \
+  -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+  -F "seed=17"
+```
+
+> **Important:** When using DP multi-concurrency (AllGather mode), `num_inference_steps`
+> must be specified explicitly and must be the same for all concurrent requests.
+> `num_inference_steps=None` is not allowed because it may resolve differently
+> per request mode (e.g., T2V=35 vs action_mode=30), which would deadlock AllGather.
+
+### Multiple concurrent requests (DP multi-concurrency)
+
+With `--data-parallel-size 4`, send 4 concurrent requests to maximize throughput:
+
+```bash
+for i in 1 2 3 4; do
+  curl -s -o output_${i}.mp4 -X POST "http://localhost:8000/v1/videos/sync" \
+    -H "Accept: video/mp4" \
+    -F "model=/path/to/Cosmos3-Nano" \
+    -F "prompt=A robot arm cleaning a plate, shot ${i}" \
+    -F "negative_prompt=blurry" \
+    -F "size=832x480" \
+    -F "num_frames=29" \
+    -F "fps=24" \
+    -F "num_inference_steps=35" \
+    -F "guidance_scale=6.0" \
+    -F "max_sequence_length=4096" \
+    -F "flow_shift=10.0" \
+    -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+    -F "seed=17" &
+done
+wait
+```
+
+## CLI flags
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--enable-distributed-layerwise-offload` | Enable DLO with H2D + AllGather overlap | `false` |
+| `--data-parallel-size N` | Number of DP ranks; DLO weight sharding + concurrent requests when AllGather is enabled | `1` |
+| `--dlo-use-allgather` | Use shard + AllGather for weight reconstruction (recommended) | `true` |
+| `--dlo-no-use-allgather` | Stream standard-loader rank-local weights independently (no DLO sharding, no DLO AllGather) | `false` |
+| `--usp N` | Use SP instead of DP for weight sharding (long sequences) | `1` |
+
+## Mode comparison
+
+| Mode | CLI flags | CPU/rank | HBM/card | Throughput | Use case |
+|------|----------|---------|---------|-----------|----------|
+| DLO + AllGather (DP4) | `--enable-distributed-layerwise-offload --data-parallel-size 4` | 1/4 model | 2 blocks | **3.3× HSDP** | Max throughput, short sequences |
+| DLO + AllGather (DP2) | `--enable-distributed-layerwise-offload --data-parallel-size 2` | 1/2 model | 2 blocks | 2× HSDP | Balanced throughput + memory |
+| DLO + AllGather (SP4) | `--enable-distributed-layerwise-offload --usp 4` | 1/4 model | 2 blocks | 1× (single req) | Long sequences (720p+) |
+| DLO no-AllGather | `--enable-distributed-layerwise-offload --dlo-no-use-allgather` | Standard-loader rank-local weights | 2 blocks | 0.4× HSDP | No DLO AllGather overhead, high CPU |
+| HSDP | `--use-hsdp --hsdp-shard-size 4` | 0 | 1/4 model | 1× (baseline) | Weights fit in HBM |
+
+## Memory expectations
+
+| Model | Config | Host RAM (cgroup) | HBM/card |
+|-------|--------|-------------------|----------|
+| Nano (33 GB) | DP2 + AllGather | ~38 GB | ~10 GB |
+| Nano (33 GB) | DP4 + AllGather | ~47 GB | ~10 GB |
+| Super (124 GB) | DP2 + AllGather | ~157 GB | ~15 GB |
+| Super (124 GB) | DP4 + AllGather | ~172 GB | ~10 GB |
+
+> Host RAM is dominated by page cache (1× model_size, shared across ranks).
+> HBM only holds 2 transformer blocks + framework + activations, independent of model size.
+
+## Limitations
+
+- `--dlo-use-allgather` (default) requires all concurrent requests to have the same
+  `num_inference_steps` (AllGather is a collective that needs all ranks synchronized)
+- Online quantization (FP8) is incompatible with the DLO+AllGather mmap path;
+  use `--dlo-no-use-allgather` or disable online quantization
+- Tensor Parallel > 1 is rejected in the DLO+AllGather mmap path. TP with
+  `--dlo-no-use-allgather` retains the standard TP loader and should be treated
+  as an experimental compatibility path
+- HSDP + AllGather is rejected (would double-shard weights). HSDP with
+  `--dlo-no-use-allgather` is accepted at configuration level, but is not yet a
+  broadly validated production combination
diff --git a/recipes/cosmos3/Cosmos3-Edge.md b/recipes/cosmos3/Cosmos3-Edge.md
new file mode 100644
index 000000000..eeb5c3083
--- /dev/null
+++ b/recipes/cosmos3/Cosmos3-Edge.md
@@ -0,0 +1,104 @@
+# Cosmos3-Edge
+
+> Compact Nemotron-based Cosmos3 checkpoint for T2I / T2V / I2V and action-conditioned (Physical-AI) generation.
+
+## Summary
+
+- Vendor: NVIDIA
+- Model: `nvidia/Cosmos3-Edge`
+- Task: T2I, T2V, I2V, and action-conditioned generation (Physical-AI: `policy` / `forward_dynamics` / `inverse_dynamics`)
+- Mode: Online (OpenAI-compatible image/video APIs) plus offline generation
+- Maintainer: Community
+
+## When to use
+
+The small Cosmos3 checkpoint, for constrained deployments. It runs on the shared
+`Cosmos3OmniDiffusersPipeline` but differs from Nano/Super in two ways:
+
+- **Transformer**: `Cosmos3EdgeVFMTransformer` (Nemotron-based), auto-selected from
+  `backbone_type: cosmos3_edge_nemotron_dense` — nothing to pass.
+- **Defaults** differ. The offline examples auto-detect Edge (from `edge` in the model id /
+  transformer class) and apply the Edge column below, so you can omit `--height` / `--width` /
+  `--guidance-scale` / `--flow-shift` and still get native Edge output:
+
+| | Edge | Nano / Super |
+|---|---|---|
+| T2I | 640×640 | 1024² |
+| T2V / I2V | 480×832 | 1280×720 |
+| Video `guidance_scale` | 5.0 | 6.0 |
+| Video `flow_shift` | 3.0 | 10.0 |
+
+> **Important:** these auto-defaults live in the example CLIs
+> (`text_to_video.py` / `image_to_video.py`). Do **not** pass the Nano/Super numbers
+> (720p / `guidance_scale` 6.0 / `flow_shift` 10.0) to Edge — they produce degenerate output.
+
+For the larger checkpoints see [Cosmos3-Nano](./Cosmos3-Nano.md) and [Cosmos3-Super](./Cosmos3-Super.md).
+
+## Support notes
+
+- **Rejected** (raise at request time): video-to-video, transfer V2V
+  (`edge` / `blur` / `depth` / `seg` / `wsm`), sound (`generate_sound=true`).
+- **Acceleration**: `--quantization fp8` and attention-backend selection are supported. Cache-DiT and
+  Sequence Parallel are inherited from the base Cosmos3 transformer (Edge overrides neither) and act on
+  the shared GEN pathway — not separately benchmarked here. Tensor Parallel is untested on this checkpoint.
+
+## Usage
+
+Guardrails are on by default (gated `nvidia/Cosmos-1.0-Guardrail`; `pip install cosmos-guardrail` +
+an `HF_TOKEN`). The examples pass `"guardrails": false` for a quick local run — you own license
+compliance.
+
+### Offline
+
+```bash
+# Text-to-image -> 640x640
+python examples/offline_inference/text_to_image/text_to_image.py \
+  --model nvidia/Cosmos3-Edge \
+  --prompt "A photorealistic red sports car at golden hour, cinematic lighting." \
+  --extra-body '{"guardrails": false}' --output t2i.png
+
+# Text-to-video -> 480x832  (for I2V: use image_to_video.py + --image <ref>)
+python examples/offline_inference/text_to_video/text_to_video.py \
+  --model nvidia/Cosmos3-Edge \
+  --prompt "A robot arm is cleaning a plate in the kitchen." \
+  --num-frames 49 \
+  --extra-body '{"max_sequence_length": 4096, "guardrails": false}' --output t2v.mp4
+```
+
+### Online
+
+```bash
+vllm serve nvidia/Cosmos3-Edge --omni --host 0.0.0.0 --port 8000 --init-timeout 1800
+```
+
+Add `--no-guardrails` to skip the safety checker. Request formats match the
+[Cosmos3-Nano recipe](./Cosmos3-Nano.md#verification), minus the rejected modes above.
+
+### Action (Physical-AI)
+
+Action-conditioned generation uses the same shared pipeline — pass
+`extra_params={"action_mode": ...}`:
+
+- `forward_dynamics` — first frame/video **plus** an action trajectory → roll out the video
+  (sync `POST /v1/videos/sync`).
+- `policy` — first frame/video + a language instruction → **predict** the action trajectory
+  (async `POST /v1/videos`; read the top-level `action` field).
+- `inverse_dynamics` — a video → **recover** the action trajectory (async `POST /v1/videos`).
+
+See the [Cosmos3-Nano action section](./Cosmos3-Nano.md) for request/response shapes. For a
+DROID-specialized policy model, use `nvidia/Cosmos3-Edge-Policy-DROID`.
+
+## Verification
+
+```bash
+python -c "from PIL import Image; im=Image.open('t2i.png'); print('image', im.size, im.mode)"
+ffprobe -v error -select_streams v:0 -show_entries stream=codec_type,nb_frames,width,height -of csv=p=0 t2v.mp4
+```
+
+Expected: `image (640, 640) RGB` and `video,49,832,480`.
+
+## References
+
+- Model card: <https://huggingface.co/nvidia/Cosmos3-Edge>
+- Pipeline: [`pipeline_cosmos3.py`](../../vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py)
+- Edge transformer: [`transformer_cosmos3_edge.py`](../../vllm_omni/diffusion/models/cosmos3/transformer_cosmos3_edge.py)
diff --git a/recipes/cosmos3/Cosmos3-Nano.md b/recipes/cosmos3/Cosmos3-Nano.md
index c3282ba51..b27d1b473 100644
--- a/recipes/cosmos3/Cosmos3-Nano.md
+++ b/recipes/cosmos3/Cosmos3-Nano.md
@@ -423,6 +423,156 @@ ffprobe -v error -show_entries stream=codec_type,nb_frames,width,height cosmos3_
   once in `vllm_omni/model_extras/cosmos3.py` and forwarded through `--extra-body`;
   unknown keys for the model are dropped.
 
+## ROCm
+
+### 1x MI350X (Online serving)
+
+#### Environment
+
+- OS: Ubuntu 22.04+
+- Python: 3.12+
+- Driver / runtime: ROCm, HIP 7.2, **gfx942 or gfx950** (validated on gfx950 / MI350X,
+  which exposes 252 GiB of HBM to PyTorch)
+- PyTorch: 2.11.0 (ROCm build)
+- vLLM version: match the repository requirements from your current checkout
+- vLLM-Omni version or commit: use the commit you are deploying from
+
+No ROCm-specific patch or flag is needed: Cosmos3 runs on the stock code path.
+
+#### Command
+
+The NVIDIA command works unchanged. Guardrails need the gated
+`nvidia/Cosmos-1.0-Guardrail` repo, so the quick path is to disable them (you are
+then responsible for license compliance):
+
+```bash
+vllm serve nvidia/Cosmos3-Nano \
+  --omni \
+  --no-guardrails \
+  --host 0.0.0.0 --port 8000 \
+  --init-timeout 1800
+```
+
+For 720p video, add `--vae-use-tiling`: it cuts peak VRAM by ~68% for ~13%
+latency, which is the difference between needing a 120 GiB card and a 40 GiB one.
+`--quantization fp8` and `--enable-layerwise-offload` are also supported; see the
+Notes for the measured cost of each. For extra GPUs use `--ulysses-degree N` or
+`--tensor-parallel-size N` (not validated on ROCm yet).
+
+#### Verification
+
+Use the same `curl` requests as the CUDA section above. The ROCm images do not
+ship `ffprobe`, so the CUDA section's `ffprobe` line does not work here. `imageio`
+and `pyav` are already installed and report the same thing:
+
+```bash
+python -c "from PIL import Image; im=Image.open('cosmos3_t2i.png'); print(im.size, im.mode)"
+python -c "import imageio.v3 as iio; print(iio.improps('cosmos3_t2v.mp4', plugin='pyav').shape)"
+```
+
+Expect `(1024, 1024) RGB` and `(189, 720, 1280, 3)` for the requests above.
+Re-running the same request with the same seed reproduces a byte-identical mp4,
+so an md5 comparison across two runs also works as a smoke check.
+
+#### Notes
+
+- **Warm up once per output shape before timing anything.** The first generation
+  of a shape pays a one-time cost that is cached on disk and reused by later
+  processes in the same container: a ~250 s aiter attention-kernel JIT build plus
+  a ~390 s build of the VAE decode path *for that shape*, so warming 1024² images
+  does nothing for 189-frame video. At 720p / 189 frames / 35 steps this is
+  **540 s cold vs 161 s warm, with byte-identical output**.
+- **Measured on 1x MI350X (bf16, guardrails off, warm):** T2I 1024² @ 50 steps
+  **~2.7 s**; T2V 1280×720 / 189 frames @ 35 steps **~161 s**, of which ~92% is
+  the DiT denoise loop and ~4% VAE decode, so optimization effort belongs in the
+  denoise loop. The optional flags act on different terms of the memory bill and
+  are therefore complementary rather than redundant:
+
+  | Flag | Latency | Peak reserved | Peak allocated | Acts on |
+  |---|---|---|---|---|
+  | *(none)* | 161 s | 120 GiB | 95 GiB | — |
+  | `--vae-use-tiling` | 183 s (+13.5%) | **38 GiB** (−68%) | **36 GiB** (−62%) | decode activations |
+  | `--enable-layerwise-offload` | 162 s (+0.8%) | 84 GiB (−30%) | 69 GiB (−27%) | weights |
+  | `--quantization fp8` | 150 s (−6.6%) | 107 GiB (−11%) | 82 GiB (−14%) | weights (online, no calibration) |
+
+  Reserved is the caching-allocator high water mark and runs ~2–25 GiB above
+  allocated; allocated is the figure to compare against another platform.
+- **`--vae-use-tiling` is by far the biggest lever for video.** Of the 95 GiB
+  allocated by default only ~35 GiB is weights and fixed overhead; the remaining
+  **60 GiB is activations from decoding all 189 frames in one piece**, which is
+  why fp8 and offload cannot touch it and why tiling, which leaves under 5 GiB of
+  them, wins so much. `--vae-use-slicing` is a no-op for a single video request:
+  peak memory is bit-identical to the default.
+- **`--enable-layerwise-offload` is close to free on this part:** per-block DiT
+  compute is long enough to hide the weight transfer, so on a card this size it
+  buys headroom for concurrency or higher resolution rather than the
+  speed-for-memory trade it is on small cards.
+- **Attention backend:** the numbers above are aiter FlashAttention, not SDPA.
+  ROCm picks aiter when it is installed and the encoded device capability
+  satisfies `90 < major * 10 + minor < 100` (gfx942 and gfx950); otherwise it
+  falls back to `TORCH_SDPA` and says so only at debug level, which is easy to
+  miss. If you are reporting numbers, assert the choice instead of trusting the
+  default: `RocmOmniPlatform.get_diffusion_attn_backend_cls(None, 128)` returns
+  the resolved path.
+- **Determinism is per-configuration:** same seed and same flags reproduce a
+  byte-identical mp4 across processes, but different configurations do not match
+  each other — including offload, which nominally only relocates weights, so do
+  not use it as a bit-exact regression baseline. Quality was not evaluated for
+  any configuration.
+
+### 1x MI350X (Offline generation)
+
+#### Environment
+
+Same as the online serving section above.
+
+#### Command
+
+The standard task examples run unchanged:
+
+```bash
+# Text-to-image
+python examples/offline_inference/text_to_image/text_to_image.py \
+  --model nvidia/Cosmos3-Nano \
+  --prompt "A photorealistic red sports car at golden hour, cinematic lighting." \
+  --negative-prompt "blurry, distorted, low quality" \
+  --height 1024 --width 1024 --num-inference-steps 50 --guidance-scale 7.0 \
+  --extra-body '{"flow_shift": 3.0, "guardrails": false}' \
+  --output cosmos3_t2i.png
+
+# Text-to-video
+python examples/offline_inference/text_to_video/text_to_video.py \
+  --model nvidia/Cosmos3-Nano \
+  --prompt "A robot arm is cleaning a plate in the kitchen." \
+  --negative-prompt "blurry, distorted, low quality" \
+  --height 720 --width 1280 --num-frames 189 --fps 24 \
+  --num-inference-steps 35 --guidance-scale 6.0 --flow-shift 10.0 \
+  --extra-body '{"max_sequence_length": 4096, "guardrails": false,
+                 "use_resolution_template": false, "use_duration_template": false}' \
+  --output cosmos3_t2v.mp4
+```
+
+Both scripts print `Total generation time` and `Worker peak GPU memory
+(reserved)`, which is where the latency and reserved figures in the Notes above
+come from. Add `--vae-use-tiling`, `--quantization fp8` or
+`--enable-layerwise-offload` to reproduce the other rows. The allocated column
+needs `VLLM_LOGGING_LEVEL=DEBUG`, which enables a per-request line reporting
+reserved, allocated and pool overhead together.
+
+#### Verification
+
+Same as the online serving section above.
+
+#### Notes
+
+- Run each command twice and read the second run; the first pays the one-time
+  compilation described above. If you run in a container, keep the container
+  alive between runs (`docker run --rm` throws the JIT cache away and you pay
+  the ~250 s kernel build every time).
+- Latency and memory figures are identical to the online serving section — they
+  were taken from this path, because a single process has no client/server
+  timing ambiguity.
+
 ## NPU
 
 ### 1x Ascend 910B / 910C (Atlas A2 / A3) — Online serving
diff --git a/recipes/cosmos3/Cosmos3-Super.md b/recipes/cosmos3/Cosmos3-Super.md
index c692b100c..54d4d7e32 100644
--- a/recipes/cosmos3/Cosmos3-Super.md
+++ b/recipes/cosmos3/Cosmos3-Super.md
@@ -125,3 +125,134 @@ curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
   under the top-level `action` field. Verified on the 64B Super under
   `--cfg-parallel-size 2`: async `policy` returns the predicted action (`[16, 10]`)
   and the rollout video reliably.
+
+## NPU
+
+### 8× Ascend910 (A2, A3)
+
+#### Environment
+
+- OS: Linux
+- Python: 3.10+
+- Driver / runtime: Ascend NPU driver with CANN toolkit
+- Recommended operator library: **mindie-sd** (Ascend high-performance fused
+  operators — enables `adalayernorm` and other fused kernels automatically upon
+  installation)
+- vLLM version: Match the repository requirements for your checkout
+- vLLM-Omni version or commit: Use the commit you are deploying from
+
+A pre-built Docker image is available on
+[Docker Hub](https://hub.docker.com/r/vllm/vllm-omni) and
+[Quay.io](https://quay.io/ascend/vllm-omni). Ensure the image tag matches your
+vLLM-Omni checkout so that NPU-specific code is in sync with the container.
+
+#### Prerequisites
+
+Install the **mindie-sd** operator library to enable Ascend-optimized fused
+operators (`adalayernorm`, etc.):
+
+```bash
+git clone https://gitcode.com/Ascend/MindIE-SD.git && cd MindIE-SD
+
+# Comment out the tik_ops build step (not needed for this use case)
+sed -i 's|^\(\s*\)source ${current_script_dir}/build_tik_ops.sh|\1# source ${current_script_dir}/build_tik_ops.sh|' build/build_ops.sh
+
+python setup.py bdist_wheel
+cd dist
+pip install mindiesd-*.whl
+```
+
+After installation, enable the Laser Attention kernel for significant
+long-sequence speedups:
+
+```bash
+export MINDIE_SD_FA_TYPE=ascend_laser_attention
+```
+
+#### Command
+
+```bash
+export MINDIE_SD_FA_TYPE=ascend_laser_attention
+
+vllm serve nvidia/Cosmos3-Super \
+  --omni \
+  --host 0.0.0.0 --port 8000 \
+  --tensor-parallel-size 8 \
+  --model-class-name Cosmos3OmniDiffusersPipeline \
+  --no-guardrails \
+  --init-timeout 1800
+```
+
+#### Verification
+
+Same requests as the GPU section above — all modes (T2I, T2V, I2V, V2V,
+T2VS, I2VS) work identically on NPU. Quick reference with
+`--no-guardrails`:
+
+```bash
+curl http://localhost:8000/v1/models
+
+# T2I (1024x1024, 50 steps)
+curl -sS -X POST http://localhost:8000/v1/images/generations \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "nvidia/Cosmos3-Super",
+    "prompt": "A photorealistic red sports car on a city street at golden hour, cinematic lighting.",
+    "size": "1024x1024", "n": 1, "response_format": "b64_json",
+    "num_inference_steps": 50, "guidance_scale": 7.0, "seed": 42
+  }' | python3 -c "import sys,json,base64; open('cosmos3_super_t2i.png','wb').write(base64.b64decode(json.load(sys.stdin)['data'][0]['b64_json']))"
+
+# T2V (1280×720, 189 frames, 35 steps — official params)
+curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
+  -F "model=nvidia/Cosmos3-Super" -F "prompt=A robot arm is cleaning a plate in the kitchen" \
+  -F "size=1280x720" -F "num_frames=189" -F "fps=24" -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" -F "max_sequence_length=4096" -F "flow_shift=10.0" \
+  -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+  -F "seed=17" -o cosmos3_super_t2v.mp4
+
+# I2V — add an uploaded reference image
+curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
+  -F "model=nvidia/Cosmos3-Super" -F "prompt=The scene comes to life with smooth, natural motion." \
+  -F "size=1280x720" -F "num_frames=189" -F "fps=24" -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" -F "max_sequence_length=4096" -F "flow_shift=10.0" \
+  -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+  -F "seed=1111" -F "input_reference=@/path/to/reference.jpg;type=image/jpeg" \
+  -o cosmos3_super_i2v.mp4
+
+# V2V — add an uploaded reference video. condition_video_keep can be "first" or "last".
+curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
+  -F "model=nvidia/Cosmos3-Super" -F "prompt=Continue the same scene with smooth natural motion." \
+  -F "size=1280x720" -F "num_frames=189" -F "fps=24" -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" -F "max_sequence_length=4096" -F "flow_shift=10.0" \
+  -F 'extra_params={"condition_frame_indexes_vision":[0,1],"condition_video_keep":"first","guardrails":false}' \
+  -F "seed=2222" -F "input_reference=@/path/to/reference.mp4;type=video/mp4" \
+  -o cosmos3_super_v2v.mp4
+
+# T2V + sound — add generate_sound/sound_duration (output muxes AAC 48 kHz stereo)
+curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
+  -F "model=nvidia/Cosmos3-Super" -F "prompt=A robot arm is cleaning a plate in the kitchen" \
+  -F "size=1280x720" -F "num_frames=189" -F "fps=24" -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" -F "max_sequence_length=4096" -F "flow_shift=10.0" \
+  -F "generate_sound=true" -F "sound_duration=7.875" \
+  -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+  -F "seed=17" -o cosmos3_super_t2vs.mp4
+
+# I2V + sound — reference image with synchronized audio
+curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
+  -F "model=nvidia/Cosmos3-Super" -F "prompt=The scene comes to life with smooth, natural motion and ambient sound." \
+  -F "size=1280x720" -F "num_frames=189" -F "fps=24" -F "num_inference_steps=35" \
+  -F "guidance_scale=6.0" -F "max_sequence_length=4096" -F "flow_shift=10.0" \
+  -F "generate_sound=true" -F "sound_duration=7.875" \
+  -F 'extra_params={"use_resolution_template":false,"use_duration_template":false,"guardrails":false}' \
+  -F "seed=1111" -F "input_reference=@/path/to/reference.jpg;type=image/jpeg" \
+  -o cosmos3_super_i2vs.mp4
+```
+
+#### Notes
+
+- **Parallelism:** `--tensor-parallel-size 8` matches the model's 8 KV heads (`num_key_value_heads: 8`, `num_attention_heads: 64` → GQA). This uses 8 davinci devices (NPU 0–3, both cores each). The remaining NPU 4–7 stay idle.
+- **Model config:** 64 layers × 5120 hidden size × 64 attention heads, ~120 GB transformer on disk (27 shards). Each NPU device loads ~15 GB of model weights.
+- **Peak HBM:** ~22.7 GB per device at startup (bf16 weights). Additional memory is allocated per-generation for KV cache and activations — resolution and frame count drive the peak.
+- **Performance (verified on 8× Ascend910):** T2I 256² / 2 steps / guidance 1.0 → ~1.5 s.
+- **Guardrails** are disabled with `--no-guardrails` (guards are on by default). The gated `nvidia/Cosmos-1.0-Guardrail` model and `cosmos-guardrail` package are not shipped. Add `guardrails: false` in `extra_params` for per-request overrides when the server has guardrails enabled.
+- **Known limitations:** FP8 quantization not yet validated on Ascend NPU. `--enable-layerwise-offload` is available but untested on NPU.
diff --git a/tests/ar_diffusion/test_pipeline_bridge.py b/tests/ar_diffusion/test_pipeline_bridge.py
deleted file mode 100644
index 28c3c959d..000000000
--- a/tests/ar_diffusion/test_pipeline_bridge.py
+++ /dev/null
@@ -1,222 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Tests for the ARDiffusionKVState paged-attention pipeline bridge."""
-
-import pytest
-import torch
-
-from vllm_omni.experimental.ar_diffusion.kv_cache import (
-    ARDiffusionKVCache,
-    ARDiffusionKVConfig,
-    ARDiffusionPagedLayerContext,
-)
-from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
-
-BLOCK = 16
-N_HEADS = 4
-HEAD_DIM = 64
-
-
-def make_state(num_layers=1, window_chunks=4, cross_attn_length=0):
-    cfg = ARDiffusionKVConfig(enable=True, chunk_size=BLOCK, window_chunks=window_chunks)
-    kv = ARDiffusionKVCache(
-        cfg,
-        num_layers=num_layers,
-        num_kv_heads=N_HEADS,
-        head_size=HEAD_DIM,
-        dtype=torch.float32,
-        block_size=BLOCK,
-        max_model_len=4096,
-        available_bytes=1 << 24,
-        cross_attn_length=cross_attn_length,
-        device=torch.device("cpu"),
-    )
-    pos = kv.begin_request("r-pos")
-    neg = kv.begin_request("r-neg")
-    return kv, ARDiffusionKVState(kv, pos, neg, num_layers=num_layers)
-
-
-def _prepare_and_commit(st: ARDiffusionKVState, is_negative: bool, n_chunks: int) -> None:
-    ctx = st.get_kv_caches(is_negative, seq_len=n_chunks * BLOCK, commit_current=True)[0].forward_ctx
-    ctx.ensure_video_slots(torch.device("cpu"))
-    st.commit_paged_context(is_negative)
-
-
-def test_get_returns_paged_layer_contexts_when_nothing_committed():
-    _, st = make_state(num_layers=2)
-    for neg in (False, True):
-        contexts = st.get_kv_caches(neg, seq_len=BLOCK, commit_current=False)
-        assert len(contexts) == 2
-        assert all(isinstance(ctx, ARDiffusionPagedLayerContext) for ctx in contexts)
-        assert contexts[0].history_block_ids == []
-
-
-def test_managed_paged_context_commits_only_after_forward():
-    kv, st = make_state(num_layers=1)
-    contexts = st.get_kv_caches(False, seq_len=2 * BLOCK, commit_current=True)
-    ctx = contexts[0].forward_ctx
-
-    assert st.pos.completed_chunks == 0
-    assert kv.window_block_ids(st.pos) == []
-    ctx.ensure_video_slots(torch.device("cpu"))
-    assert st.pos.completed_chunks == 0
-    assert len(ctx.current_video_block_ids) == 2
-
-    st.commit_paged_context(False)
-
-    assert st.pos.completed_chunks == 2
-    assert st._committed[False] == 2 * BLOCK
-    assert len(kv.window_block_ids(st.pos)) == 2
-
-
-def test_scratch_paged_context_does_not_commit():
-    kv, st = make_state(num_layers=1)
-    contexts = st.get_kv_caches(False, seq_len=BLOCK, commit_current=False)
-    ctx = contexts[0].forward_ctx
-    ctx.ensure_video_slots(torch.device("cpu"))
-
-    assert ctx.current_video_block_ids == kv.scratch_block_ids(False, 0, 1)
-    st.commit_paged_context(False)
-
-    assert st.pos.completed_chunks == 0
-    assert st._committed[False] == 0
-    assert kv.window_block_ids(st.pos) == []
-
-
-def test_eviction_bounds_resident_window():
-    kv, st = make_state(num_layers=1, window_chunks=3)
-    _prepare_and_commit(st, False, 3)
-    assert len(kv.window_block_ids(st.pos)) == 3
-
-    _prepare_and_commit(st, False, 2)
-    ctx = st.get_kv_caches(False, seq_len=BLOCK, commit_current=False)[0].forward_ctx
-    visible_blocks, video_len = ctx.video_block_table(torch.device("cpu"))
-    assert len(visible_blocks) == 3
-    assert video_len == 3 * BLOCK
-
-
-def test_branches_are_independent():
-    kv, st = make_state()
-    _prepare_and_commit(st, False, 1)
-    assert len(kv.window_block_ids(st.pos)) == 1
-    assert kv.window_block_ids(st.neg) == []
-
-
-def test_reset_clears_session_window():
-    kv, st = make_state(num_layers=1, window_chunks=4)
-    _prepare_and_commit(st, False, 2)
-    _prepare_and_commit(st, True, 1)
-    assert st._committed[False] == 2 * BLOCK and st._committed[True] == BLOCK
-    free_before = kv.manager.block_pool.get_num_free_blocks()
-
-    st.reset()
-
-    assert st._committed == {False: 0, True: 0}
-    assert st._paged_pending == {False: None, True: None}
-    assert kv.window_block_ids(st.pos) == []
-    assert kv.window_block_ids(st.neg) == []
-    assert kv.manager.block_pool.get_num_free_blocks() > free_before
-    _prepare_and_commit(st, False, 1)
-    assert len(kv.window_block_ids(st.pos)) == 1
-
-
-def test_get_cross_kv_caches_raises_before_populate():
-    """Engine ownership guard: a cross-attn read before _kv_populate_cross must fail loud."""
-    _, st = make_state()  # cross_attn_length == 0, nothing populated
-    for neg in (False, True):
-        with pytest.raises(RuntimeError, match="cross-attn read before"):
-            st.get_cross_kv_caches(neg)
-    # Guards the full AND: the populated flag alone is not enough without a pool.
-    st._cross_text_populated[False] = True
-    with pytest.raises(RuntimeError, match="cross-attn read before"):
-        st.get_cross_kv_caches(False)
-
-
-def test_get_cross_kv_caches_returns_pool_dicts_when_populated():
-    L = 8
-    kv, st = make_state(num_layers=2, cross_attn_length=L)
-    written = []
-    for i in range(2):
-        k = torch.randn(1, L, N_HEADS, HEAD_DIM)
-        v = torch.randn(1, L, N_HEADS, HEAD_DIM)
-        kv.write_cross_kv(i, False, k, v)
-        written.append((k, v))
-    st._cross_text_populated[False] = True
-
-    out = st.get_cross_kv_caches(False)
-    assert len(out) == 2
-    for i, (k, v) in enumerate(written):
-        assert out[i]["is_init"] is True
-        assert out[i]["k"].shape == (1, L, N_HEADS, HEAD_DIM)
-        assert torch.equal(out[i]["k"], k)
-        assert torch.equal(out[i]["v"], v)
-
-
-def test_kv_create_is_noop_engine_owns_allocation():
-    from unittest.mock import MagicMock
-
-    from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import DreamZeroPipeline
-
-    p = DreamZeroPipeline.__new__(DreamZeroPipeline)
-    p._ar_diffusion_kv_state = object()
-    state = MagicMock()
-    p._kv_create(state, 1, "float32", "cpu", 24, 4, 64)
-    state.create_kv_caches.assert_not_called()
-
-
-def test_get_kv_cache_requires_frame_aligned_seqlen():
-    _, st = make_state()
-    with pytest.raises(AssertionError, match="frame-aligned"):
-        st.get_kv_caches(False, seq_len=BLOCK + 1, commit_current=True)
-
-
-def test_prepare_one_branch_allocates_nothing_for_the_other():
-    """CFG-parallel laziness: a rank prepares only the branch it runs."""
-    kv, st = make_state(num_layers=1, window_chunks=4)
-    pos_ctx = st.get_kv_caches(False, seq_len=BLOCK, commit_current=True)[0].forward_ctx
-    neg_ctx = st.get_kv_caches(True, seq_len=BLOCK, commit_current=True)[0].forward_ctx
-
-    pos_ctx.prepare(device=torch.device("cpu"), action_len=0, query_len=BLOCK)
-
-    assert pos_ctx._allocated_video
-    assert not neg_ctx._allocated_video
-    assert kv.window_block_ids(st.neg) == []
-
-
-def test_failed_forward_tears_down_session(monkeypatch):
-    """Review follow-up (hsliuustc0106): a forward that dies partway must not
-    leave allocated-but-uncommitted KV behind — the session is torn down (pool
-    blocks freed, model-local state dropped) and the error propagates."""
-    from types import SimpleNamespace
-
-    from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
-    from vllm_omni.experimental.ar_diffusion.runner import ARDiffusionModelRunner
-
-    kv, st = make_state(num_layers=1, window_chunks=4)
-    _prepare_and_commit(st, False, 2)  # session owns pool blocks
-    free_before_failure = kv.manager.block_pool.get_num_free_blocks()
-
-    runner = object.__new__(ARDiffusionModelRunner)
-    runner.kv_cache = kv
-    runner._ar_diffusion_states = __import__("collections").OrderedDict({"s1": st})
-    runner._max_ar_diffusion_states = 4
-    runner.pipeline = SimpleNamespace(_states={"s1": object()}, _ar_diffusion_kv_state=None)
-    runner.device = None
-    runner._perf_e2e_times = []
-
-    def boom(self, req, kv_prefetch_jobs=None):
-        raise RuntimeError("layer 17 exploded")
-
-    monkeypatch.setattr(DiffusionModelRunner, "execute_model", boom)
-    req = SimpleNamespace(
-        request_id="r0",
-        sampling_params=SimpleNamespace(extra_args={"session_id": "s1"}),
-    )
-
-    with pytest.raises(RuntimeError, match="layer 17 exploded"):
-        ARDiffusionModelRunner.execute_model(runner, req)
-
-    assert "s1" not in runner._ar_diffusion_states
-    assert "s1" not in runner.pipeline._states
-    assert runner.pipeline._ar_diffusion_kv_state is None
-    # close() freed the session's resident blocks.
-    assert kv.manager.block_pool.get_num_free_blocks() > free_before_failure
diff --git a/tests/assets/hunyuan/hunyuan_baseline_npu.png b/tests/assets/hunyuan/hunyuan_baseline_npu.png
new file mode 100644
index 000000000..1de1e8ff0
Binary files /dev/null and b/tests/assets/hunyuan/hunyuan_baseline_npu.png differ
diff --git a/tests/e2e/accuracy/assets/hunyuan_image_ref.png b/tests/assets/hunyuan/hunyuan_image_ref.png
similarity index 100%
rename from tests/e2e/accuracy/assets/hunyuan_image_ref.png
rename to tests/assets/hunyuan/hunyuan_image_ref.png
diff --git a/tests/assets/minicpmo_4_5/response_required_16k.wav b/tests/assets/minicpmo_4_5/response_required_16k.wav
new file mode 100644
index 000000000..ae4052493
Binary files /dev/null and b/tests/assets/minicpmo_4_5/response_required_16k.wav differ
diff --git a/tests/assets/minicpmo_4_5/soft_interrupt_16k.wav b/tests/assets/minicpmo_4_5/soft_interrupt_16k.wav
new file mode 100644
index 000000000..41b399af0
Binary files /dev/null and b/tests/assets/minicpmo_4_5/soft_interrupt_16k.wav differ
diff --git a/tests/e2e/accuracy/assets/qwen_image_edit_2511_test1.png b/tests/assets/qwen_image_edit/qwen_image_edit_2511_test1.png
similarity index 100%
rename from tests/e2e/accuracy/assets/qwen_image_edit_2511_test1.png
rename to tests/assets/qwen_image_edit/qwen_image_edit_2511_test1.png
diff --git a/tests/e2e/accuracy/assets/qwen_image_edit_2511_test2.png b/tests/assets/qwen_image_edit/qwen_image_edit_2511_test2.png
similarity index 100%
rename from tests/e2e/accuracy/assets/qwen_image_edit_2511_test2.png
rename to tests/assets/qwen_image_edit/qwen_image_edit_2511_test2.png
diff --git a/tests/attention/test_fish_kvcache_attn.py b/tests/attention/test_fish_kvcache_attn.py
index c82fd1858..d38380e13 100644
--- a/tests/attention/test_fish_kvcache_attn.py
+++ b/tests/attention/test_fish_kvcache_attn.py
@@ -100,8 +100,9 @@ def _decode_kv_cache(
     head_size: int = 128,
     dtype: torch.dtype = torch.float16,
 ) -> torch.Tensor:
-    # vLLM >=0.23.0 KV cache layout: key/value live on dim 1.
-    return torch.zeros((num_blocks, 2, block_size, num_kv_heads, head_size), dtype=dtype)
+    # vLLM >=0.23.0 KV cache layout: (num_blocks, num_kv_heads, block_size,
+    # 2*head_size) with K and V packed in the last dimension.
+    return torch.zeros((num_blocks, num_kv_heads, block_size, 2 * head_size), dtype=dtype)
 
 
 def test_fish_kvcache_enabled_by_default(monkeypatch):
@@ -221,10 +222,11 @@ def _vllm_kv_cache_shape(num_blocks, block_size, num_kv_heads, head_size):
 
 
 def test_fish_kvcache_backend_unbinds_kv_on_vllm_cache_layout(monkeypatch):
-    # vLLM >=0.23.0 lays the KV cache out as (num_blocks, 2, block_size,
-    # num_kv_heads, head_size). The backend must unbind on dim 1 so each of
-    # key/value comes back as the 4-D (num_blocks, block_size, num_kv_heads,
-    # head_size) tensor the decode kernel expects.
+    # vLLM >=0.23.0 lays out the KV cache as (num_blocks, num_kv_heads,
+    # block_size, 2*head_size) with K and V packed in the last dimension.
+    # The backend must split on the content dim so each of key/value comes
+    # back as the 4-D (num_blocks, block_size, num_kv_heads, head_size)
+    # tensor the decode kernel expects.
     monkeypatch.setenv("VLLM_OMNI_FISH_KVCACHE_ATTN", "1")
     monkeypatch.setattr(fish_kvcache_backend, "is_available", lambda: True)
     monkeypatch.setattr(fish_kvcache_backend, "load_error", lambda: None)
@@ -232,7 +234,8 @@ def test_fish_kvcache_backend_unbinds_kv_on_vllm_cache_layout(monkeypatch):
 
     num_blocks, block_size, num_kv_heads, head_size = 8, 16, 8, 128
     cache_shape = _vllm_kv_cache_shape(num_blocks, block_size, num_kv_heads, head_size)
-    assert cache_shape == (num_blocks, 2, block_size, num_kv_heads, head_size)
+    # Upstream now returns a 4-D packed shape: (B, H, N, 2*D).
+    assert cache_shape == (num_blocks, num_kv_heads, block_size, 2 * head_size)
 
     captured = {}
 
@@ -262,20 +265,21 @@ def test_fish_kvcache_backend_unbinds_kv_on_vllm_cache_layout(monkeypatch):
 def test_fish_kvcache_vllm_cache_unbinds_then_falls_back_until_contiguous(monkeypatch):
     # End-to-end with the real vLLM cache layout and the real (unmocked) guard.
     #
-    # The point of the unbind(1) fix: unbind(0) raised "too many values to
-    # unpack" on the 5-D vLLM 0.23.0 layout, so the request crashed outright.
-    # unbind(1) makes the request *work* again -- it unpacks cleanly and the
-    # backend gracefully falls back to the original attention with correct
-    # output. This test guards that fix and must NOT depend on the fast path
-    # firing.
+    # The point of the transpose+split fix: unbind(1) on the old 5-D layout
+    # raised "too many values to unpack" on the vLLM 0.23.0 layout, and the
+    # upstream now packs K/V into the last dimension (4-D shape). The
+    # transpose(1, 2) + split correctly unpacks into separate key/value tensors
+    # and the backend gracefully falls back to the original attention with
+    # correct output. This test guards that fix and must NOT depend on the fast
+    # path firing.
     #
-    # It also documents a known limitation (tracked separately): unbind(1) on
-    # the interleaved (num_blocks, 2, ...) layout yields *non-contiguous*
-    # key/value views, which the guard rejects on the is_contiguous() check.
-    # So the dimensions are compatible (4-D, block_size=16, head_size=128) --
-    # the only thing keeping the fast path from engaging is contiguity, not
-    # shape. Making the fast path actually fire would require a .contiguous()
-    # copy and is out of scope here.
+    # It also documents a known limitation (tracked separately):
+    # transpose(1, 2) on the interleaved (B, H, N, 2*D) layout yields
+    # *non-contiguous* key/value views, which the guard rejects on the
+    # is_contiguous() check. So the dimensions are compatible (4-D,
+    # block_size=16, head_size=128) -- the only thing keeping the fast path
+    # from engaging is contiguity, not shape. Making the fast path actually
+    # fire would require a .contiguous() copy and is out of scope here.
     fish_kvcache_backend.reset_fish_kvcache_attn_stats()
     monkeypatch.setenv("VLLM_OMNI_FISH_KVCACHE_ATTN", "1")
     monkeypatch.setattr(fish_kvcache_backend, "is_available", lambda: True)
@@ -300,13 +304,14 @@ def test_fish_kvcache_vllm_cache_unbinds_then_falls_back_until_contiguous(monkey
     output = torch.zeros_like(query)
     kv_cache = torch.zeros(cache_shape, dtype=torch.float16)
 
-    # Root cause record: unbind(1) gives the right 4-D shape but a non-contiguous view.
-    key_cache, value_cache = kv_cache.unbind(1)
+    # Root cause record: transpose(1,2) + split gives the right 4-D shape but
+    # a non-contiguous view.
+    key_cache, value_cache = kv_cache.transpose(1, 2).split(head_size, dim=-1)
     assert tuple(key_cache.shape) == (num_blocks, block_size, num_kv_heads, head_size)
     assert not key_cache.is_contiguous()
 
-    # unbind(1) no longer crashes (unbind(0) would have raised here) and the
-    # request completes via the correct fallback path.
+    # transpose+split no longer crashes (unbind(1) would have raised here) and
+    # the request completes via the correct fallback path.
     result = model.layers[0].self_attn.attn.impl.forward(None, query, None, None, kv_cache, _metadata(), output)
 
     assert result is output
diff --git a/tests/benchmarks/test_daily_omni_pack_modes.py b/tests/benchmarks/test_daily_omni_pack_modes.py
new file mode 100644
index 000000000..46ca369e5
--- /dev/null
+++ b/tests/benchmarks/test_daily_omni_pack_modes.py
@@ -0,0 +1,249 @@
+"""Tests for Daily-Omni ``--daily-omni-pack-mode`` packing recipes.
+
+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.
+
+vllm stubs are installed by tests/benchmarks/conftest.py before collection.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Load the data module directly (bypasses vllm_omni.__init__ heavy imports).
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_MODULE_PATH = _REPO_ROOT / "vllm_omni" / "benchmarks" / "data_modules" / "daily_omni_dataset.py"
+_MODULE_NAME = "vllm_omni.benchmarks.data_modules.daily_omni_dataset"
+
+if _MODULE_NAME not in sys.modules:
+    _spec = importlib.util.spec_from_file_location(_MODULE_NAME, _MODULE_PATH)
+    _mod = importlib.util.module_from_spec(_spec)
+    sys.modules[_MODULE_NAME] = _mod
+    _spec.loader.exec_module(_mod)
+
+from vllm_omni.benchmarks.data_modules.daily_omni_dataset import (  # noqa: E402
+    DailyOmniDataset,
+    _uniform_sample_indices,
+)
+
+_VIDEO_ID = "vid001"
+_NUM_FRAMES = 5
+
+
+@pytest.fixture
+def video_dir(tmp_path: Path) -> Path:
+    """Official Daily-Omni ``Videos/`` layout with placeholder media files."""
+    per_video = tmp_path / "Videos" / _VIDEO_ID
+    per_video.mkdir(parents=True)
+    (per_video / f"{_VIDEO_ID}_video.mp4").write_bytes(b"fake-mp4")
+    (per_video / f"{_VIDEO_ID}_audio.wav").write_bytes(b"fake-wav")
+    return tmp_path / "Videos"
+
+
+@pytest.fixture
+def qa_json(tmp_path: Path) -> Path:
+    path = tmp_path / "qa.json"
+    path.write_text(
+        json.dumps(
+            [
+                {
+                    "video_id": _VIDEO_ID,
+                    "question": "What happens first?",
+                    "choice": {"A": "a", "B": "b", "C": "c", "D": "d"},
+                    "answer": "A",
+                    "task_type": "AV Event Alignment",
+                    "video_duration": "30s",
+                }
+            ]
+        ),
+        encoding="utf-8",
+    )
+    return path
+
+
+def _make_dataset(qa_json: Path, video_dir: Path, **kwargs) -> DailyOmniDataset:
+    return DailyOmniDataset(
+        qa_json_path=str(qa_json),
+        video_dir=str(video_dir),
+        disable_shuffle=True,
+        **kwargs,
+    )
+
+
+def _stub_extract(monkeypatch, dataset: DailyOmniDataset, counter: list[int]) -> None:
+    """Replace decord/ffmpeg extraction with deterministic in-memory frames + segments."""
+    from PIL import Image
+
+    def fake_extract(video_path, *, audio_path, include_audio, **_kw):
+        counter.append(1)
+        frames = [Image.new("RGB", (16, 16), color=(i, i, i)) for i in range(_NUM_FRAMES)]
+        segments = [np.zeros(1600, dtype=np.float32) for _ in range(_NUM_FRAMES)] if include_audio else []
+        return frames, segments
+
+    monkeypatch.setattr(dataset, "_extract_minicpm_frame_audio_segments", fake_extract)
+
+
+# ---------------------------------------------------------------------------
+# _uniform_sample_indices
+# ---------------------------------------------------------------------------
+
+
+@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)."""
+    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
+
+
+def test_uniform_sample_indices_non_positive_k() -> None:
+    assert _uniform_sample_indices(10, 0) == []
+    assert _uniform_sample_indices(10, -1) == []
+
+
+# ---------------------------------------------------------------------------
+# minicpm-interleave packing
+# ---------------------------------------------------------------------------
+
+
+def test_minicpm_interleave_alternates_image_and_audio(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)
+
+    assert position == "first"
+    assert [p["type"] for p in parts] == ["image_url", "audio_url"] * _NUM_FRAMES
+    assert extra["mm_processor_kwargs"] == {
+        "use_audio_in_video": False,
+        "max_slice_nums": 1,
+        "use_image_id": False,
+    }
+
+
+def test_minicpm_interleave_visual_mode_emits_frames_only(monkeypatch, qa_json, video_dir) -> None:
+    ds = _make_dataset(qa_json, video_dir, pack_mode="minicpm-interleave", input_mode="visual")
+    _stub_extract(monkeypatch, ds, [])
+
+    parts, _extra, _position = ds._compose_daily_omni_multimodal(_VIDEO_ID, None)
+
+    assert [p["type"] for p in parts] == ["image_url"] * _NUM_FRAMES
+
+
+def test_minicpm_interleave_writes_file_urls_under_video_dir(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)
+
+    segment_dir = video_dir / ".minicpm_daily_omni_interleave" / _VIDEO_ID
+    for part in parts:
+        url = part[part["type"]]["url"]
+        assert url.startswith("file://")
+        assert Path(url[len("file://") :]).parent == segment_dir.resolve()
+    assert sorted(p.name for p in segment_dir.glob("frame_*.jpg")) == [f"frame_{i:04d}.jpg" for i in range(_NUM_FRAMES)]
+
+
+def test_minicpm_interleave_inline_mode_emits_data_urls(monkeypatch, qa_json, video_dir) -> None:
+    ds = _make_dataset(
+        qa_json,
+        video_dir,
+        pack_mode="minicpm-interleave",
+        input_mode="all",
+        inline_local_video=True,
+    )
+    _stub_extract(monkeypatch, ds, [])
+
+    parts, _extra, _position = ds._compose_daily_omni_multimodal(_VIDEO_ID, None)
+
+    assert parts[0]["image_url"]["url"].startswith("data:image/jpeg;base64,")
+    assert parts[1]["audio_url"]["url"].startswith("data:audio/wav;base64,")
+    assert not (video_dir / ".minicpm_daily_omni_interleave").exists()
+
+
+def test_minicpm_interleave_caches_file_parts_but_not_inline_payloads(monkeypatch, qa_json, video_dir) -> None:
+    """Inline base64 must not be retained: ~700 Daily-Omni videos would pin GBs of RSS."""
+    file_calls: list[int] = []
+    ds_file = _make_dataset(qa_json, video_dir, pack_mode="minicpm-interleave", input_mode="all")
+    _stub_extract(monkeypatch, ds_file, file_calls)
+    ds_file._compose_daily_omni_multimodal(_VIDEO_ID, None)
+    ds_file._compose_daily_omni_multimodal(_VIDEO_ID, None)
+    assert len(file_calls) == 1
+    assert ds_file._minicpm_interleave_cache
+
+    inline_calls: list[int] = []
+    ds_inline = _make_dataset(
+        qa_json,
+        video_dir,
+        pack_mode="minicpm-interleave",
+        input_mode="all",
+        inline_local_video=True,
+    )
+    _stub_extract(monkeypatch, ds_inline, inline_calls)
+    ds_inline._compose_daily_omni_multimodal(_VIDEO_ID, None)
+    ds_inline._compose_daily_omni_multimodal(_VIDEO_ID, None)
+    assert len(inline_calls) == 2
+    assert not ds_inline._minicpm_interleave_cache
+
+
+def test_minicpm_interleave_missing_local_video_returns_none(qa_json, tmp_path) -> None:
+    empty = tmp_path / "empty_videos"
+    empty.mkdir()
+    ds = _make_dataset(qa_json, empty, pack_mode="minicpm-interleave", input_mode="all")
+
+    parts, extra, _position = ds._compose_daily_omni_multimodal(_VIDEO_ID, None)
+
+    assert parts is None
+    assert extra is None
+
+
+# ---------------------------------------------------------------------------
+# System prompt selection
+# ---------------------------------------------------------------------------
+
+
+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."""
+    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"] == ""
+
+
+def test_qwen_pack_mode_keeps_system_message(qa_json, video_dir) -> None:
+    ds = _make_dataset(qa_json, video_dir, pack_mode="qwen", input_mode="all")
+
+    messages = ds._build_daily_omni_openai_messages([], "q?", {"A": "a"})
+
+    assert [m["role"] for m in messages] == ["system", "user"]
+    assert "Qwen" in messages[0]["content"][0]["text"]
+
+
+def test_invalid_pack_mode_rejected(qa_json, video_dir) -> None:
+    with pytest.raises(ValueError, match="pack_mode must be"):
+        _make_dataset(qa_json, video_dir, pack_mode="bogus")
diff --git a/tests/benchmarks/test_serve_cli.py b/tests/benchmarks/test_serve_cli.py
index 6970f6e2f..7dd12d000 100644
--- a/tests/benchmarks/test_serve_cli.py
+++ b/tests/benchmarks/test_serve_cli.py
@@ -1,3 +1,4 @@
+import argparse
 import json
 import os
 import subprocess
@@ -6,10 +7,157 @@ from pathlib import Path
 
 import pytest
 
+from vllm_omni.entrypoints.cli.benchmark.cli_args import (
+    add_omni_args,
+    extend_omni_choices,
+    preprocess_serve_args,
+    update_omni_help,
+)
+from vllm_omni.utils.tracking_parser import TrackingArgumentParser
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
+
+
+@pytest.mark.parametrize(
+    "dataset_name",
+    [
+        "daily-omni",
+        "seed-tts",
+        "seed-tts-text",
+        "seed-tts-design",
+        "ttsd",
+        "sound-effect",
+    ],
+)
+def test_extend_omni_choices_updates_tracking_parser_shadow(dataset_name: str) -> None:
+    parser = TrackingArgumentParser()
+    parser.add_argument("--dataset-name", choices=["random"])
+    parser.add_argument("--backend", choices=["openai-chat-omni"])
+
+    extend_omni_choices(parser)
+
+    args = parser.parse_args(
+        [
+            "--dataset-name",
+            dataset_name,
+            "--backend",
+            "openai-image-edits-omni",
+        ]
+    )
+
+    assert args.dataset_name == dataset_name
+    assert args.backend == "openai-image-edits-omni"
+    assert args.explicit_keys == {"dataset_name", "backend"}
+
+
+@pytest.mark.parametrize(
+    ("argv", "dest", "expected"),
+    [
+        (["--print-stage"], "print_stage", True),
+        (["--daily-omni-input-mode", "audio"], "daily_omni_input_mode", "audio"),
+        (["--seed-tts-locale", "zh"], "seed_tts_locale", "zh"),
+    ],
+)
+def test_add_omni_args_registers_arguments_on_tracking_parser(
+    argv: list[str],
+    dest: str,
+    expected: object,
+) -> None:
+    parser = TrackingArgumentParser()
+
+    add_omni_args(parser)
+
+    args = parser.parse_args(argv)
+    assert getattr(args, dest) == expected
+    assert args.explicit_keys == {dest}
+
+
+def test_add_omni_args_preserves_implicit_defaults() -> None:
+    parser = TrackingArgumentParser()
+
+    add_omni_args(parser)
+
+    args = parser.parse_args([])
+    assert args.print_stage is False
+    assert args.daily_omni_input_mode == "all"
+    assert args.seed_tts_locale == "en"
+    assert args.explicit_keys == set()
+
+
+def test_update_omni_help_updates_upstream_actions() -> None:
+    parser = TrackingArgumentParser()
+    parser.add_argument("--percentile-metrics", help="Upstream percentile help.")
+    parser.add_argument("--random-mm-limit-mm-per-prompt", help="Upstream limit help.")
+    parser.add_argument("--random-mm-bucket-config", help="Upstream bucket help.")
+
+    update_omni_help(parser)
+
+    actions = {action.dest: action for action in parser._actions}
+    assert all(metric in actions["percentile_metrics"].help for metric in ("ttfc", "tpop", "audio_rtf"))
+    assert "probabilities are renormalized" in actions["random_mm_limit_mm_per_prompt"].help
+    assert "Currently allows for 3 modalities" in actions["random_mm_bucket_config"].help
+
+
+@pytest.mark.parametrize(
+    ("backend", "extra_body", "bot_task", "expected"),
+    [
+        ("openai-chat-omni", None, "think", {}),
+        ("openai-image-edits-omni", None, "think", {"bot_task": "think"}),
+        ("openai-image-edits-omni", {"bot_task": "recaption"}, "think", {"bot_task": "recaption"}),
+        ("openai-image-edits-omni", {"custom": True}, None, {"custom": True}),
+    ],
+)
+def test_preprocess_serve_args_merges_bot_task_without_overriding_extra_body(
+    backend: str,
+    extra_body: dict | None,
+    bot_task: str | None,
+    expected: dict,
+) -> None:
+    args = argparse.Namespace(backend=backend, extra_body=extra_body, bot_task=bot_task)
+
+    preprocess_serve_args(args)
+
+    assert args.extra_body == expected
+
+
+@pytest.mark.parametrize(
+    ("argv", "expected_extra_body", "expected_explicit"),
+    [
+        (
+            [
+                "--backend",
+                "openai-image-edits-omni",
+                "--print-stage",
+                "--image-edits-bot-task",
+                "recaption",
+            ],
+            {"bot_task": "recaption"},
+            {"backend", "print_stage", "bot_task"},
+        ),
+        (
+            ["--extra-body", '{"bot_task":"vanilla"}'],
+            {"bot_task": "vanilla"},
+            {"extra_body"},
+        ),
+    ],
+)
+def test_omni_args_parse_and_preprocess(
+    argv: list[str],
+    expected_extra_body: dict,
+    expected_explicit: set[str],
+) -> None:
+    parser = TrackingArgumentParser()
+    parser.add_argument("--extra-body", type=json.loads, default=None)
+    parser.add_argument("--backend", default="openai-chat-omni")
+    add_omni_args(parser)
+
+    args = parser.parse_args(argv)
+    preprocess_serve_args(args)
+
+    assert args.extra_body == expected_extra_body
+    assert args.explicit_keys == expected_explicit
+
 
-@pytest.mark.core_model
-@pytest.mark.benchmark
-@pytest.mark.cpu
 def test_bench_serve_cli_mocks_http_request(tmp_path: Path):
     num_prompts = 5
     port = 18000
diff --git a/tests/buildkite/test_skip_ci.py b/tests/buildkite/test_skip_ci.py
new file mode 100644
index 000000000..ddefc7271
--- /dev/null
+++ b/tests/buildkite/test_skip_ci.py
@@ -0,0 +1,370 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+from dataclasses import asdict
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / ".buildkite" / "common" / "scripts"))
+
+from skip_ci import (  # noqa: E402
+    CiDecision,
+    _diff_only_contains_skip_mark_changes,
+    resolve_ci_decision,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _decision(changed_files: list[str]) -> CiDecision:
+    return resolve_ci_decision(changed_files)
+
+
+def _is_yaml_gated(decision: CiDecision) -> bool:
+    return decision.skip_l2_l3 and not decision.skip_all
+
+
+def _all_l23_skipped(decision: CiDecision) -> bool:
+    checks = (
+        ("cuda", "l2"),
+        ("cuda", "l3"),
+        ("amd", "l2"),
+        ("amd", "l3"),
+        ("intel", "l2"),
+        ("npu", "l2"),
+    )
+    return all(not decision.is_run(platform, level) for platform, level in checks)
+
+
+def test_docs_only_change() -> None:
+    assert _decision(["docs/foo.md", "README.md", "mkdocs.yml"]).skip_all
+
+
+def test_docs_only_rejects_product_code() -> None:
+    assert not _decision(["docs/foo.md", "vllm_omni/foo.py"]).skip_all
+
+
+def test_skip_mark_diff_only() -> None:
+    diff = """\
+diff --git a/tests/foo/test_bar.py b/tests/foo/test_bar.py
+--- a/tests/foo/test_bar.py
++++ b/tests/foo/test_bar.py
+@@ -1,3 +1,4 @@
+ import pytest
++
++@pytest.mark.skip(reason="temp")
+ def test_x():
+"""
+    assert _diff_only_contains_skip_mark_changes(diff)
+
+
+def test_skip_mark_removal_does_not_qualify() -> None:
+    """Removing a skip decorator re-enables the test; must not suppress CI."""
+    diff = """\
+diff --git a/tests/foo/test_bar.py b/tests/foo/test_bar.py
+--- a/tests/foo/test_bar.py
++++ b/tests/foo/test_bar.py
+@@ -1,5 +1,4 @@
+ import pytest
+-
+-@pytest.mark.skip(reason="temp")
+ def test_x():
+     assert True
+"""
+    assert not _diff_only_contains_skip_mark_changes(diff)
+
+
+def test_skip_mark_reason_edit_still_qualifies() -> None:
+    diff = """\
+diff --git a/tests/foo/test_bar.py b/tests/foo/test_bar.py
+--- a/tests/foo/test_bar.py
++++ b/tests/foo/test_bar.py
+@@ -1,4 +1,4 @@
+ import pytest
+-@pytest.mark.skip(reason="old")
++@pytest.mark.skip(reason="new")
+ def test_x():
+"""
+    assert _diff_only_contains_skip_mark_changes(diff)
+
+
+def test_skip_mark_diff_rejects_assertion_change() -> None:
+    diff = """\
+diff --git a/tests/foo/test_bar.py b/tests/foo/test_bar.py
+--- a/tests/foo/test_bar.py
++++ b/tests/foo/test_bar.py
+@@ -1,3 +1,3 @@
+ def test_x():
+-    assert 1 == 1
++    assert 2 == 2
+"""
+    assert not _diff_only_contains_skip_mark_changes(diff)
+
+
+def test_cuda_ready_only_runs_cuda_l2() -> None:
+    decision = _decision([".buildkite/cuda/test-ready.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert _all_l23_skipped(decision) is False
+
+
+def test_cuda_merge_only_runs_cuda_l3() -> None:
+    decision = _decision([".buildkite/cuda/test-merge.yml"])
+    assert _is_yaml_gated(decision)
+    assert not decision.is_run("cuda", "l2")
+    assert decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l3")
+
+
+def test_l4_only_skips_all_l23() -> None:
+    decision = _decision([".buildkite/cuda/test-nightly.yml"])
+    assert _is_yaml_gated(decision)
+    assert _all_l23_skipped(decision)
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+
+
+def test_weekly_only_skips_all_l23() -> None:
+    decision = _decision([".buildkite/cuda/test-weekly.yml"])
+    assert _is_yaml_gated(decision)
+    assert _all_l23_skipped(decision)
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+
+
+def test_npu_nightly_only_skips_all_l23() -> None:
+    decision = _decision([".buildkite/npu/test-npu-nightly.yml"])
+    assert _is_yaml_gated(decision)
+    assert _all_l23_skipped(decision)
+    assert not decision.is_run("npu", "l2")
+    assert not decision.is_run("npu", "l3")
+
+
+def test_nightly_and_weekly_skips_all_l23() -> None:
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-nightly.yml",
+            ".buildkite/cuda/test-weekly.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert _all_l23_skipped(decision)
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+
+
+def test_l2_and_l4_skips_l3() -> None:
+    files = [
+        ".buildkite/cuda/test-ready.yml",
+        ".buildkite/cuda/test-nightly.yml",
+    ]
+    decision = _decision(files)
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+
+
+def test_l3_and_l4_skips_l2() -> None:
+    files = [
+        ".buildkite/cuda/test-merge.yml",
+        ".buildkite/cuda/test-nightly.yml",
+    ]
+    decision = _decision(files)
+    assert _is_yaml_gated(decision)
+    assert not decision.is_run("cuda", "l2")
+    assert decision.is_run("cuda", "l3")
+
+
+def test_ready_and_merge_runs_cuda_l2_l3() -> None:
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-ready.yml",
+            ".buildkite/cuda/test-merge.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert decision.is_run("cuda", "l3")
+
+
+def test_cross_platform_cuda_l2_and_amd_l3_preserves_both() -> None:
+    """CUDA ready + AMD merge must keep cuda/l2 and amd/l3 (not wipe L2 outside L3 platforms)."""
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-ready.yml",
+            ".buildkite/amd/test-amd-merge.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l2")
+    assert decision.is_run("amd", "l3")
+    assert not decision.is_run("intel", "l2")
+    assert not decision.is_run("npu", "l2")
+    assert not decision.device.skip_cuda_l2
+    assert decision.device.skip_cuda_l3
+    assert decision.device.skip_amd_l2
+    assert not decision.device.skip_amd_l3
+
+
+def test_amd_ready_only_runs_amd_l2() -> None:
+    decision = _decision([".buildkite/amd/test-amd-ready.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("amd", "l2")
+    assert not decision.is_run("cuda", "l2")
+
+
+def test_npu_ready_only_runs_npu_l2() -> None:
+    decision = _decision([".buildkite/npu/test-npu-ready.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("npu", "l2")
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("npu", "l3")
+
+
+def test_amd_merge_only_runs_amd_l3() -> None:
+    decision = _decision([".buildkite/amd/test-amd-merge.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("amd", "l3")
+    assert not decision.is_run("amd", "l2")
+    assert not decision.is_run("cuda", "l3")
+
+
+def test_intel_pipeline_runs_intel_l2() -> None:
+    decision = _decision([".buildkite/intel/pipeline-intel.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("intel", "l2")
+    assert not decision.is_run("cuda", "l2")
+
+
+def test_cuda_and_amd_ready_runs_both_l2() -> None:
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-ready.yml",
+            ".buildkite/amd/test-amd-ready.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert decision.is_run("amd", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l3")
+    assert not decision.is_run("intel", "l2")
+    assert not decision.is_run("npu", "l2")
+
+
+def test_cuda_and_amd_merge_runs_both_l3() -> None:
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-merge.yml",
+            ".buildkite/amd/test-amd-merge.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l3")
+    assert decision.is_run("amd", "l3")
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("amd", "l2")
+
+
+def test_ready_merge_and_nightly_runs_cuda_l2_l3() -> None:
+    """G7: L2+L3+L45 → same matrix as ready+merge (L45 rescued by L2/L3 YAML)."""
+    decision = _decision(
+        [
+            ".buildkite/cuda/test-ready.yml",
+            ".buildkite/cuda/test-merge.yml",
+            ".buildkite/cuda/test-nightly.yml",
+        ],
+    )
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l2")
+    assert not decision.is_run("amd", "l3")
+
+
+def test_non_whitelist_buildkite_runs_normal_ci() -> None:
+    assert not _is_yaml_gated(_decision([".buildkite/common/scripts/skip_ci.py"]))
+    assert not _is_yaml_gated(_decision([".buildkite/cuda/pipeline.yml"]))
+
+
+def test_whitelist_plus_non_whitelist_buildkite_runs_normal_ci() -> None:
+    assert not _is_yaml_gated(
+        _decision(
+            [
+                ".buildkite/cuda/test-ready.yml",
+                ".buildkite/cuda/pipeline.yml",
+            ],
+        ),
+    )
+
+
+def test_mixed_product_code_disables_targeting() -> None:
+    assert not _is_yaml_gated(
+        _decision([".buildkite/cuda/test-ready.yml", "vllm_omni/x.py"]),
+    )
+
+
+def test_docs_mixed_with_ci_yaml_follows_yaml_gating() -> None:
+    decision = _decision(["docs/a.md", ".buildkite/cuda/test-ready.yml"])
+    assert _is_yaml_gated(decision)
+    assert not decision.skip_all
+    assert decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l2")
+    assert "follow CI YAML gating" in decision.message
+
+
+def test_docs_mixed_with_l45_yaml_skips_all_l23() -> None:
+    decision = _decision(["docs/a.md", ".buildkite/cuda/test-nightly.yml"])
+    assert _is_yaml_gated(decision)
+    assert not decision.skip_all
+    assert not decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l2")
+
+
+def test_non_whitelist_path_disables_targeting() -> None:
+    assert not _is_yaml_gated(_decision([".buildkite/unknown/foo.yml"]))
+    assert not _is_yaml_gated(_decision(["vllm_omni/x.py"]))
+
+
+def test_is_run_l23_when_not_yaml_gated() -> None:
+    decision = _decision(["vllm_omni/x.py"])
+    assert decision.is_run("cuda", "l2")
+    assert decision.is_run("amd", "l3")
+
+
+def test_is_run_l23_respects_decision() -> None:
+    decision = _decision([".buildkite/cuda/test-ready.yml"])
+    assert _is_yaml_gated(decision)
+    assert decision.is_run("cuda", "l2")
+    assert not decision.is_run("cuda", "l3")
+    assert not decision.is_run("amd", "l2")
+
+
+def test_docs_or_skip_mark_only_without_diff_range_helper() -> None:
+    assert _decision(["docs/a.md"]).skip_all
+    assert not _decision(["vllm_omni/a.py"]).skip_all
+
+
+def test_decision_serializes_to_dict() -> None:
+    decision = _decision([".buildkite/cuda/test-ready.yml"])
+    assert _is_yaml_gated(decision)
+    payload = asdict(decision)
+    assert payload["skip_l2_l3"] is True
+    assert payload["device"]["skip_cuda_l2"] is False
+    assert payload["device"]["skip_cuda_l3"] is True
+
+
+def test_yaml_gated_message_lists_changed_and_targets() -> None:
+    decision = _decision([".buildkite/cuda/test-ready.yml"])
+    assert decision.message.startswith("only CI config YAML changed")
+    assert "changed: L2=[.buildkite/cuda/test-ready.yml]" in decision.message
+    assert "run: cuda/l2" in decision.message
+    assert "skip: cuda/l3" in decision.message
+    assert "amd/l2" in decision.message
diff --git a/tests/buildkite/test_upload_pipeline.py b/tests/buildkite/test_upload_pipeline.py
new file mode 100644
index 000000000..24a2a731e
--- /dev/null
+++ b/tests/buildkite/test_upload_pipeline.py
@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / ".buildkite" / "common" / "scripts"))
+
+from skip_ci import resolve_ci_decision  # noqa: E402
+from upload_pipeline import (  # noqa: E402
+    _expand_mirror_hardwares,
+    _load_bootstrap_steps,
+    _render_bootstrap_pipeline,
+    _render_test_pipeline,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+CUDA_BOOTSTRAP_STEPS = Path(".buildkite/cuda/bootstrap-upload-steps.yml")
+BOOTSTRAP_STEPS_TEMPLATE = """steps:
+  - key: image-build
+  - key: upload-ready-pipeline
+  - key: upload-merge-pipeline
+  - key: upload-nightly-pipeline
+  - key: upload-weekly-pipeline
+"""
+
+
+def _render(changed_files: list[str]) -> str:
+    decision = resolve_ci_decision(changed_files)
+    return _render_bootstrap_pipeline(
+        BOOTSTRAP_STEPS_TEMPLATE,
+        decision=decision,
+        path=CUDA_BOOTSTRAP_STEPS,
+    )
+
+
+def test_bootstrap_if_injected_by_step_key() -> None:
+    import yaml
+
+    rendered = _render_bootstrap_pipeline(
+        BOOTSTRAP_STEPS_TEMPLATE,
+        decision=resolve_ci_decision([]),
+        path=Path(".buildkite/npu/bootstrap-upload-steps.yml"),
+    )
+    doc = yaml.safe_load(rendered)
+    by_key = {step["key"]: step for step in doc["steps"]}
+    assert "image-build" in by_key
+    # Unconditional image has no ``if`` (Buildkite rejects YAML bool if: true).
+    assert "if" not in by_key["image-build"]
+    assert isinstance(by_key["upload-ready-pipeline"]["if"], str)
+    assert isinstance(by_key["upload-nightly-pipeline"]["if"], str)
+
+
+def test_bootstrap_steps_loaded_from_file() -> None:
+    steps = _load_bootstrap_steps(CUDA_BOOTSTRAP_STEPS)
+    assert "key: image-build" in steps
+    assert "key: upload-ready-pipeline" in steps
+    assert "placeholder:" not in steps
+
+
+def test_docs_only_allows_main_scheduled_nightly_weekly_only() -> None:
+    """skip_all: no PR labels; main + NIGHTLY=1 / WEEKLY=1 still gates scheduled CI."""
+    rendered = _render(["docs/foo.md"])
+    assert "key: image-build" in rendered
+    assert "key: upload-nightly-pipeline" in rendered
+    assert "key: upload-weekly-pipeline" in rendered
+    # Scheduled nightly also uploads L2/L3 with --e2e
+    assert "key: upload-ready-pipeline" in rendered
+    assert "key: upload-merge-pipeline" in rendered
+    assert 'build.env("NIGHTLY") == "1"' in rendered
+    assert 'build.env("WEEKLY") == "1"' in rendered
+    assert "nightly-test" not in rendered
+    assert "weekly-test" not in rendered
+    assert "merge-test" not in rendered
+    assert 'labels includes "ready"' not in rendered
+    assert "if: false" not in rendered
+
+
+def test_yaml_gated_l45_only_does_not_unconditionally_build_image() -> None:
+    rendered = _render([".buildkite/cuda/test-nightly.yml"])
+    assert "if: true" not in rendered
+    assert 'build.pull_request.labels includes "nightly-test"' in rendered
+    assert 'build.pull_request.labels includes "weekly-test"' in rendered
+    # L2/L3 upload steps are unconditionally disabled → omitted from pipeline
+    assert "key: upload-ready-pipeline" not in rendered
+    assert "key: upload-merge-pipeline" not in rendered
+    assert "key: upload-weekly-pipeline" in rendered
+
+
+def test_yaml_gated_l2_still_enables_image_via_ready_base() -> None:
+    rendered = _render([".buildkite/cuda/test-ready.yml"])
+    assert 'build.pull_request.labels includes "ready"' in rendered
+    assert "if: true" not in rendered
+
+
+def test_mirror_hardwares_l4_1_expands_to_agents_and_plugins() -> None:
+    doc = {
+        "steps": [
+            {
+                "label": "Simple Test",
+                "mirror_hardwares": "l4_1",
+                "commands": ["pytest -sv tests/example"],
+            },
+        ],
+    }
+    rendered = _render_test_pipeline(doc, changed_files=None)
+    step = rendered["steps"][0]
+    assert "mirror_hardwares" not in step
+    assert step["agents"]["queue"] == "gpu_1_queue"
+    assert step["plugins"][0]["docker#v5.2.0"]["image"].endswith("$BUILDKITE_COMMIT")
+
+
+def test_mirror_hardwares_conflicts_with_explicit_agents() -> None:
+    with pytest.raises(ValueError, match="agents/plugins/image"):
+        _expand_mirror_hardwares(
+            {"label": "bad", "mirror_hardwares": "l4_1", "agents": {"queue": "gpu_1_queue"}},
+        )
+
+
+def test_mirror_hardwares_a2b3_npu_4_expands_agents_image_and_plugins() -> None:
+    doc = {
+        "steps": [
+            {
+                "label": "NPU X2V Test",
+                "mirror_hardwares": "a2b3_npu_4",
+                "commands": ["pytest -sv tests/example"],
+            },
+        ],
+    }
+    rendered = _render_test_pipeline(doc, changed_files=None)
+    step = rendered["steps"][0]
+    assert "mirror_hardwares" not in step
+    assert step["agents"]["queue"] == "ascend-a2b3"
+    assert step["agents"]["resource_class"] == "npu-4"
+    assert step["image"].endswith("${BUILDKITE_COMMIT}")
+    assert step["plugins"][0]["kubernetes"]["podSpecPatch"]["imagePullSecrets"] == [
+        {"name": "swr-secret"},
+    ]
diff --git a/tests/buildkite/test_vllm_omni_package_discovery.py b/tests/buildkite/test_vllm_omni_package_discovery.py
new file mode 100644
index 000000000..118aedb15
--- /dev/null
+++ b/tests/buildkite/test_vllm_omni_package_discovery.py
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Guard package discovery outside repo-root ``sys.path[0]``.
+
+Covers the same failure class as:
+- ``vllm ... --omni`` (upstream ``find_spec("vllm_omni")``) — see #5364
+- ``python examples/.../end2end.py`` / multimodal client subprocesses, where
+  ``sys.path[0]`` is the script directory (not the repo root), so a cwd-only
+  layout can start OmniServer via ``python -m vllm_omni...`` and still fail
+  example scripts with ``ModuleNotFoundError: No module named 'vllm_omni'``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from importlib.util import find_spec
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _assert_subprocess_ok(proc: subprocess.CompletedProcess[str], *, detail: str) -> None:
+    assert proc.returncode == 0, f"{detail} (exit={proc.returncode})\nstdout:\n{proc.stdout}\nstderr:\n{proc.stderr}"
+
+
+def test_find_spec_vllm_omni() -> None:
+    """Same probe as upstream ``vllm`` CLI before delegating to omni_main."""
+    assert find_spec("vllm_omni") is not None
+    assert find_spec("vllm_omni.entrypoints.cli.main") is not None
+
+
+def test_find_spec_vllm_omni_from_non_repo_cwd(tmp_path: Path) -> None:
+    """Console-script / ``python -c`` style: discovery when cwd is not the repo root."""
+    code = (
+        "from importlib.util import find_spec; "
+        "assert find_spec('vllm_omni') is not None; "
+        "assert find_spec('vllm_omni.entrypoints.cli.main') is not None"
+    )
+    proc = subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    _assert_subprocess_ok(proc, detail=f"find_spec failed from cwd={tmp_path}")
+
+
+def test_python_script_off_repo_root_sys_path(tmp_path: Path) -> None:
+    """``python path/to/script.py``: ``sys.path[0]`` is the script dir, not the repo root.
+
+    One case covers the end2end / online-client / orphan-dir layouts — they all
+    share this discovery constraint. Use ``find_spec`` only (no heavy imports)
+    so Simple Test stays fast.
+    """
+    script = tmp_path / "examples" / "offline_inference" / "hunyuan_image3" / "end2end_probe.py"
+    script.parent.mkdir(parents=True, exist_ok=True)
+    script.write_text(
+        "\n".join(
+            [
+                "from importlib.util import find_spec",
+                "import sys",
+                'print("initial_sys_path0", sys.path[0])',
+                'assert find_spec("vllm_omni") is not None, (sys.path[0], sys.path[:5])',
+                'assert find_spec("vllm_omni.entrypoints.cli.main") is not None',
+                'print("ok")',
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    cwd = tmp_path / "run_cwd"
+    cwd.mkdir()
+    proc = subprocess.run(
+        [sys.executable, str(script)],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    _assert_subprocess_ok(
+        proc,
+        detail=f"find_spec failed for python {script} with cwd={cwd}",
+    )
+    assert f"initial_sys_path0 {script.parent}" in proc.stdout
diff --git a/tests/config/composable_parallel/test_factory_integration.py b/tests/config/composable_parallel/test_factory_integration.py
index ea685541c..468b3db2c 100644
--- a/tests/config/composable_parallel/test_factory_integration.py
+++ b/tests/config/composable_parallel/test_factory_integration.py
@@ -100,8 +100,7 @@ def test_device_check_survives_cli_override():
     # guard: effective world=1, replicas=2 admits only 1 or 2 device ids.
     pipeline_cfg = OMNI_PIPELINES["qwen2_5_omni"]
     with pytest.raises(StrategyApplyError):
-        StageConfigFactory._create_from_registry(
-            "qwen2_5_omni",
+        StageConfigFactory._create_legacy_from_registry(
             pipeline_cfg,
             cli_overrides={"stage_1_devices": "0,1,2"},
             strategy_specs={"talker": [_stage_replica(2, "round_robin")]},
@@ -126,8 +125,7 @@ def test_cli_overrides_strategy_with_warning():
     log.addHandler(handler)
     try:
         pipeline_cfg = OMNI_PIPELINES["qwen2_5_omni"]
-        stages, _ = StageConfigFactory._create_from_registry(
-            "qwen2_5_omni",
+        stages, _ = StageConfigFactory._create_legacy_from_registry(
             pipeline_cfg,
             cli_overrides={"stage_1_num_replicas": 3},
             strategy_specs={"talker": [_stage_replica(2, "round_robin")]},
diff --git a/tests/test_config_factory.py b/tests/config/test_config_factory.py
similarity index 72%
rename from tests/test_config_factory.py
rename to tests/config/test_config_factory.py
index 54683e67c..33dcd0551 100644
--- a/tests/test_config_factory.py
+++ b/tests/config/test_config_factory.py
@@ -5,7 +5,6 @@ Unit tests for StageConfigFactory and related classes.
 """
 
 import importlib
-import inspect
 import warnings
 from dataclasses import dataclass, fields
 from pathlib import Path
@@ -17,8 +16,10 @@ from transformers import PretrainedConfig, Qwen3OmniMoeConfig
 from tests.helpers.stage_config import get_deploy_config_path, get_deploy_config_stage
 from vllm_omni.config.config_factory import StageConfigFactory
 from vllm_omni.config.endpoint_policy import EndpointRestriction, OmniServingCapability
-from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, register_pipeline
+from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, register_pipeline, resolve_pipeline_config
 from vllm_omni.config.stage_config import (
+    _DEPLOY_DIR,
     DeployConfig,
     PipelineConfig,
     StageConfig,
@@ -40,13 +41,21 @@ from vllm_omni.engine.arg_utils import SHARED_FIELDS, EngineArgs, internal_black
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+@pytest.fixture(autouse=True)
+def _stable_test_platform(monkeypatch):
+    from vllm_omni import platforms
+
+    platform = platforms.current_omni_platform
+    monkeypatch.setattr(platform, "device_name", "cpu", raising=False)
+    monkeypatch.setattr(platform, "device_type", "cpu", raising=False)
+
+
 @pytest.fixture(autouse=True)
 def clear_config_factory_caches():
     """Clear cached classmethods from the StageConfigFactory to prevent test pollution."""
     yield
     StageConfigFactory.get_hf_config.cache_clear()
     StageConfigFactory.try_infer_model_type.cache_clear()
-    StageConfigFactory.get_pipeline_config.cache_clear()
 
 
 Q3_OMNI_ALL_STAGES_HF_CONFIG = Qwen3OmniMoeConfig(enable_audio_output=True)
@@ -122,6 +131,18 @@ class TestStageConfig:
         assert "max_num_seqs" not in omega_config.engine_args
         # Legacy field name for backward compatibility
         assert omega_config.engine_input_source == []
+        assert omega_config.session_mode == "turn"
+
+    def test_to_omegaconf_duplex_session_mode(self):
+        """Test that session mode is preserved as stage metadata."""
+        config = StageConfig(
+            stage_id=0,
+            model_stage="thinker",
+            session_mode="duplex",
+        )
+        omega_config = config.to_omegaconf()
+
+        assert omega_config.session_mode == "duplex"
 
     def test_to_omegaconf_with_runtime_overrides(self):
         """Test that runtime overrides are applied to OmegaConf output."""
@@ -315,6 +336,31 @@ class TestStageConfig:
         assert "ring_degree" not in omega_config.engine_args
         assert "sequence_parallel_size" not in omega_config.engine_args
 
+    def test_to_omegaconf_diffusion_parallel_allgather_override_recomputes_sequence_parallel_size(self):
+        config = StageConfig(
+            stage_id=1,
+            model_stage="diffusion",
+            stage_type=StageType.DIFFUSION,
+            yaml_engine_args={
+                "parallel_config": {
+                    "sequence_parallel_size": 1,
+                    "ulysses_degree": 1,
+                    "ring_degree": 1,
+                    "allgather_degree": 1,
+                }
+            },
+            runtime_overrides={
+                "allgather_degree": 2,
+            },
+        )
+
+        omega_config = config.to_omegaconf()
+
+        assert omega_config.engine_args.parallel_config.allgather_degree == 2
+        assert omega_config.engine_args.parallel_config.sequence_parallel_size == 2
+        assert "allgather_degree" not in omega_config.engine_args
+        assert "sequence_parallel_size" not in omega_config.engine_args
+
     def test_to_omegaconf_diffusion_parallel_explicit_sequence_parallel_size_is_preserved(self):
         config = StageConfig(
             stage_id=1,
@@ -534,29 +580,51 @@ class TestPipelineDiscovery:
 
     def test_registry_resolver_qwen3_omni_all_stages(self):
         """Test that providing the HF config for qwen3 omni with audio enabled uses all stages."""
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
         assert isinstance(pipeline, PipelineConfig)
         assert pipeline.model_type == "qwen3_omni_moe"
+        assert pipeline.default_deploy_config_name == "qwen3_omni_moe.yaml"
         assert len(pipeline.stages) == 3  # thinker + talker + code2wav
 
     def test_registry_resolver_qwen3_omni_thinker_only(self):
         """Test that providing the HF config for qwen3 omni without audio is thinker only."""
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_THINKER_HF_CONFIG,
         )
         assert isinstance(pipeline, PipelineConfig)
         assert pipeline.model_type == "qwen3_omni_moe_thinker_only"
+        assert pipeline.default_deploy_config_name is None
         assert len(pipeline.stages) == 1  # thinker only
 
+    @pytest.mark.parametrize(
+        "pipeline",
+        [registered for registered in OMNI_PIPELINES.values() if isinstance(registered, PipelineConfig)],
+        ids=lambda pipeline: pipeline.model_type,
+    )
+    def test_registered_default_deploy_config_exists(self, pipeline):
+        if pipeline.default_deploy_config_name is None:
+            return
+        assert Path(get_deploy_config_path(pipeline.default_deploy_config_name)).is_file()
+
+    @pytest.mark.parametrize(
+        "deploy_path",
+        sorted(_DEPLOY_DIR.glob("*.yaml")),
+        ids=lambda deploy_path: deploy_path.name,
+    )
+    def test_explicit_deploy_pipeline_is_registered(self, deploy_path):
+        deploy = load_deploy_config(deploy_path)
+        if deploy.pipeline is not None:
+            assert deploy.pipeline in OMNI_PIPELINES
+
     def test_registry_returns_none_for_unknown(self):
         """Unknown model_types aren't found and resolve to `None`."""
         assert "definitely_not_a_real_model" not in OMNI_PIPELINES
         assert OMNI_PIPELINES.get("definitely_not_a_real_model") is None
-        assert StageConfigFactory.resolve_pipeline_config("definitely_not_a_real_model") is None
+        assert resolve_pipeline_config("definitely_not_a_real_model") is None
 
     def test_pipeline_config_supports_hf_architectures(self):
         """PipelineConfig accepts hf_architectures for HF-arch fallback
@@ -607,6 +675,236 @@ class TestPipelineConfigNew:
 
 
 class TestPipelineRegistration:
+    def test_resolve_pipeline_prefers_deploy_pipeline_key(self, clean_pipeline_registry, tmp_path):
+        deploy_key = "deploy_selected_pipeline"
+        model_type_key = "hf_model_type_pipeline"
+        deploy_pipe = PipelineConfig(model_type=deploy_key)
+        model_type_pipe = PipelineConfig(model_type=model_type_key)
+        register_pipeline(deploy_pipe)
+        register_pipeline(model_type_pipe)
+
+        deploy_path = tmp_path / "deploy.yaml"
+        deploy_path.write_text(f"pipeline: {deploy_key}\n", encoding="utf-8")
+
+        class FakeConfig(PretrainedConfig):
+            model_type = model_type_key
+
+        fake_config = FakeConfig()
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=str(deploy_path),
+            )
+
+        assert pipeline_cfg is deploy_pipe
+
+    def test_resolve_pipeline_rejects_invalid_deploy_pipeline_key(
+        self,
+        clean_pipeline_registry,
+        tmp_path,
+    ):
+        model_type_key = "registered_model_type_pipeline"
+        register_pipeline(PipelineConfig(model_type=model_type_key))
+
+        deploy_path = tmp_path / "deploy.yaml"
+        deploy_path.write_text("pipeline: missing_pipeline\n", encoding="utf-8")
+
+        class FakeConfig(PretrainedConfig):
+            model_type = model_type_key
+
+        with patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()):
+            with pytest.raises(KeyError, match="missing_pipeline"):
+                StageConfigFactory.get_pipeline_config(
+                    "fake/model",
+                    trust_remote_code=True,
+                    deploy_config_path=str(deploy_path),
+                )
+            with pytest.raises(KeyError, match="missing_pipeline"):
+                StageConfigFactory.create_from_model(
+                    "fake/model",
+                    trust_remote_code=False,
+                    cli_overrides={},
+                    deploy_config_path=str(deploy_path),
+                )
+            with pytest.raises(KeyError, match="missing_pipeline"):
+                StageConfigFactory.create_legacy_stage_configs_from_model(
+                    "fake/model",
+                    trust_remote_code=False,
+                    cli_overrides={},
+                    deploy_config_path=str(deploy_path),
+                )
+
+    def test_resolve_pipeline_matches_hf_architecture_fallback(self, clean_pipeline_registry):
+        pipeline_key = "architecture_fallback_pipeline"
+        pipe_cfg = PipelineConfig(
+            model_type=pipeline_key,
+            hf_architectures=("ArchitectureFallbackForTest",),
+        )
+        register_pipeline(pipe_cfg)
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered_model_type"
+
+        fake_config = FakeConfig()
+        fake_config.architectures = ["ArchitectureFallbackForTest"]
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=None,
+            )
+
+        assert pipeline_cfg is pipe_cfg
+
+    def test_resolve_pipeline_architecture_fallback_respects_predicates(self, clean_pipeline_registry):
+        shared_arch = "SharedPredicateArchitectureForTest"
+
+        def rejecting_predicate(_hf_config):
+            return False
+
+        def raising_predicate(_hf_config):
+            raise ValueError("predicate failure")
+
+        reject_cfg = PipelineConfig(
+            model_type="rejected_by_predicate",
+            hf_architectures=(shared_arch,),
+            hf_config_predicate=rejecting_predicate,
+        )
+        raises_cfg = PipelineConfig(
+            model_type="raises_in_predicate",
+            hf_architectures=(shared_arch,),
+            hf_config_predicate=raising_predicate,
+        )
+        accept_cfg = PipelineConfig(
+            model_type="accepted_by_predicate",
+            hf_architectures=(shared_arch,),
+        )
+        register_pipeline(reject_cfg)
+        register_pipeline(raises_cfg)
+        register_pipeline(accept_cfg)
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered_model_type"
+
+        fake_config = FakeConfig()
+        fake_config.architectures = [shared_arch]
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=None,
+            )
+
+        assert pipeline_cfg is accept_cfg
+
+    def test_resolve_pipeline_architecture_fallback_rejects_non_matching_architecture(
+        self,
+        clean_pipeline_registry,
+    ):
+        predicate_calls = []
+
+        def predicate(_hf_config):
+            predicate_calls.append(_hf_config)
+            return True
+
+        pipe_cfg = PipelineConfig(
+            model_type="predicate_without_arch_match",
+            hf_architectures=("DifferentArchitectureForTest",),
+            hf_config_predicate=predicate,
+        )
+        register_pipeline(pipe_cfg)
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered_model_type"
+
+        fake_config = FakeConfig()
+        fake_config.architectures = ["RequestedArchitectureForTest"]
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=None,
+            )
+
+        assert pipeline_cfg is None
+        assert predicate_calls == [fake_config]
+
+    def test_resolve_pipeline_architecture_fallback_resolves_callable_pipeline(self, clean_pipeline_registry):
+        pipeline_key = "callable_architecture_fallback"
+        resolved_cfg = PipelineConfig(
+            model_type="callable_resolved_pipeline",
+            hf_architectures=("CallableArchitectureForTest",),
+        )
+        seen_hf_configs = []
+
+        def resolver(hf_config):
+            seen_hf_configs.append(hf_config)
+            return resolved_cfg
+
+        register_pipeline(resolver, model_type=pipeline_key)
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered_model_type"
+
+        fake_config = FakeConfig()
+        fake_config.architectures = ["CallableArchitectureForTest"]
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=None,
+            )
+
+        assert pipeline_cfg is resolved_cfg
+        assert seen_hf_configs == [fake_config]
+
+    def test_resolve_pipeline_returns_none_without_registry_or_architecture_match(self, clean_pipeline_registry):
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered_model_type"
+
+        fake_config = FakeConfig()
+        fake_config.architectures = ["UnmatchedArchitectureForTest"]
+        with patch("vllm_omni.config.config_factory.get_config", return_value=fake_config):
+            pipeline_cfg = StageConfigFactory.get_pipeline_config(
+                "fake/model",
+                trust_remote_code=True,
+                deploy_config_path=None,
+            )
+
+        assert pipeline_cfg is None
+
+    def test_create_from_model_returns_structured_omni_config(self):
+        class FakeConfig(PretrainedConfig):
+            model_type = "qwen3_tts"
+
+        with patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()):
+            omni_config = StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=None,
+            )
+
+        assert isinstance(omni_config, VllmOmniConfig)
+        assert omni_config.pipeline_config is OMNI_PIPELINES["qwen3_tts"]
+        assert len(omni_config.stage_configs) == 2
+
+    def test_create_from_model_preserves_model_on_structured_diffusion_stage(self):
+        class FakeConfig(PretrainedConfig):
+            model_type = "dreamzero"
+
+        with patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()):
+            omni_config = StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=None,
+            )
+
+        assert isinstance(omni_config, VllmOmniConfig)
+        assert omni_config.stage_by_id(0).diffusion_config.model == "fake/model"
+
     def test_pipeline_registration(self, clean_pipeline_registry):
         """Ensure that we can register and create a custom pipeline config."""
         new_model_type = "new_model_type"
@@ -622,15 +920,23 @@ class TestPipelineRegistration:
             model_type = new_model_type
 
         # Create the model
+        fake_config = FakeConfig()
         with (
-            patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()),
-            patch.object(StageConfigFactory, "_create_from_registry") as mock_create,
+            patch("vllm_omni.config.config_factory.get_config", return_value=fake_config),
+            patch.object(VllmOmniConfig, "from_pipeline_config") as mock_create,
         ):
-            StageConfigFactory.create_from_model("fake/model")
+            StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=None,
+            )
             mock_create.assert_called_once()
-            # Ensure that the passed pipeline_config is the right type
-            pipeline_cfg = mock_create.call_args[0][1]
-        assert isinstance(pipeline_cfg, PipelineConfig)
+            assert mock_create.call_args.args == (pipe_cfg,)
+            assert mock_create.call_args.kwargs["cli_overrides"] == {
+                "trust_remote_code": False,
+                "model": "fake/model",
+            }
         assert pipe_cfg.model_type == new_model_type
 
     def test_resolver_registration(self, clean_pipeline_registry):
@@ -655,26 +961,125 @@ class TestPipelineRegistration:
         assert OMNI_PIPELINES[new_model_type] is custom_resolver
 
         # Create the model
+        fake_config = FakeConfig()
         with (
-            patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()),
-            patch.object(StageConfigFactory, "_create_from_registry") as mock_create,
+            patch("vllm_omni.config.config_factory.get_config", return_value=fake_config) as mock_get_config,
+            patch.object(VllmOmniConfig, "from_pipeline_config") as mock_create,
         ):
-            StageConfigFactory.create_from_model("fake/model")
+            StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=True,
+                cli_overrides={},
+                deploy_config_path=None,
+            )
             mock_create.assert_called_once()
-            # Ensure that the passed pipeline_config is the right type
-            pipeline_cfg = mock_create.call_args[0][1]
-        assert isinstance(pipeline_cfg, PipelineConfig)
-        assert pipeline_cfg.model_type == resolved_type
+            assert mock_create.call_args.args[0].model_type == resolved_type
+            assert mock_create.call_args.kwargs["cli_overrides"] == {
+                "trust_remote_code": True,
+                "model": "fake/model",
+            }
+            mock_get_config.assert_called_once_with("fake/model", trust_remote_code=True)
+
+        with patch.object(StageConfigFactory, "_create_legacy_from_registry", return_value=([], None)) as mock_legacy:
+            StageConfigFactory.create_legacy_stage_configs_from_model(
+                "fake/model",
+                trust_remote_code=True,
+                cli_overrides={},
+                deploy_config_path=None,
+            )
+
+        assert mock_legacy.call_args.args[0].model_type == resolved_type
+        assert mock_legacy.call_args.args[1]["trust_remote_code"] is True
 
     def test_resolve_when_autodetect_resolves_none(self):
         """Regression test for: https://github.com/vllm-project/vllm-omni/issues/4726"""
         deploy_path = get_deploy_config_path("ming_tts.yaml")
         resolved_config = StageConfigFactory.create_from_model(
             model="inclusionAI/Ming-omni-tts-0.5B",
+            trust_remote_code=False,
+            cli_overrides={},
             deploy_config_path=deploy_path,
         )
         assert resolved_config is not None
-        assert len(resolved_config) > 0
+        assert len(resolved_config.stage_configs) > 0
+
+    def test_legacy_and_structured_paths_share_deploy_pipeline_override(self, clean_pipeline_registry, tmp_path):
+        pipeline_key = "deploy_only_pipeline"
+        pipe_cfg = PipelineConfig(
+            model_type=pipeline_key,
+            model_arch="DeployOnlyArch",
+            stages=(StagePipelineConfig(stage_id=0, model_stage="diffusion"),),
+        )
+        register_pipeline(pipe_cfg)
+
+        deploy_path = tmp_path / "deploy_only.yaml"
+        deploy_path.write_text(f"pipeline: {pipeline_key}\n", encoding="utf-8")
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "dense"
+            architectures = ("UnregisteredArch",)
+
+        with patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()):
+            omni_config = StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=str(deploy_path),
+            )
+            legacy_configs, _ = StageConfigFactory.create_legacy_stage_configs_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=str(deploy_path),
+            )
+
+        assert omni_config is not None
+        assert omni_config.pipeline_config is pipe_cfg
+        assert legacy_configs is not None
+        assert len(legacy_configs) == 1
+        assert legacy_configs[0].yaml_engine_args["model_arch"] == "DeployOnlyArch"
+
+    def test_structured_path_loads_explicit_deploy_config_once(self, clean_pipeline_registry, tmp_path):
+        pipeline_key = "single_load_pipeline"
+        register_pipeline(PipelineConfig(model_type=pipeline_key))
+        deploy_path = tmp_path / "single_load.yaml"
+        deploy_path.write_text(f"pipeline: {pipeline_key}\n", encoding="utf-8")
+
+        class FakeConfig(PretrainedConfig):
+            model_type = "unregistered"
+
+        with (
+            patch("vllm_omni.config.config_factory.get_config", return_value=FakeConfig()),
+            patch(
+                "vllm_omni.config.config_factory.load_deploy_config",
+                wraps=load_deploy_config,
+            ) as mock_load,
+        ):
+            StageConfigFactory.create_from_model(
+                "fake/model",
+                trust_remote_code=False,
+                cli_overrides={},
+                deploy_config_path=str(deploy_path),
+            )
+
+        mock_load.assert_called_once_with(deploy_path)
+
+    def test_legacy_default_deploy_name_ignores_cwd(self, monkeypatch, tmp_path):
+        default_name = "pipeline_default.yaml"
+        (tmp_path / default_name).write_text("stages: []\n", encoding="utf-8")
+        monkeypatch.chdir(tmp_path)
+        pipeline = PipelineConfig(
+            model_type="pipeline_with_default",
+            default_deploy_config_name=default_name,
+        )
+
+        with patch(
+            "vllm_omni.config.config_factory.load_deploy_config",
+            return_value=DeployConfig(),
+        ) as mock_load:
+            StageConfigFactory._create_legacy_from_registry(pipeline, {})
+
+        mock_load.assert_called_once_with(_DEPLOY_DIR / default_name)
 
     def test_deploy_override_uses_correct_endpoint_restrictions(self, clean_pipeline_registry, tmp_path):
         """Ensure endpoint restrictions must come from the final pipeline
@@ -739,6 +1144,63 @@ class TestResolveScheduler:
 
 
 class TestDeployConfigLoading:
+    def test_load_minicpmo_duplex_deploy_config(self):
+        deploy_path = Path(get_deploy_config_path("minicpmo_4_5_duplex.yaml"))
+
+        deploy = load_deploy_config(deploy_path)
+        pipeline = resolve_pipeline_config("minicpmo_4_5")
+        assert isinstance(pipeline, PipelineConfig)
+
+        stages = merge_pipeline_deploy(pipeline, deploy)
+
+        assert deploy.session_mode == "duplex"
+        assert deploy.async_chunk is True
+        assert deploy.active_stream_window == 1
+        assert [stage.session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
+        assert [stage.to_omegaconf().session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
+        assert [stage.yaml_engine_args["async_scheduling"] for stage in stages] == [False, False, False]
+        assert all("Async" not in (stage.scheduler_cls or "") for stage in stages)
+        assert [stage.devices for stage in deploy.stages] == ["0", "0", "0"]
+        assert deploy.stages[1].enforce_eager is False
+        assert stages[1].yaml_extras["default_sampling_params"]["max_tokens"] == 2048
+        assert stages[1].yaml_extras["default_sampling_params"]["min_tokens"] == 0
+        assert stages[1].yaml_extras["default_sampling_params"]["stop_token_ids"] == [1]
+
+    @pytest.mark.parametrize(
+        ("filename", "stage0_devices", "stage1_devices", "stage2_devices", "stage1_replicas"),
+        [
+            ("minicpmo_4_5_3gpu_stage1_replicas.yaml", "0", "1,2", "0", 2),
+            ("minicpmo_4_5_4gpu_stage1_replicas.yaml", "0", "1,2,3", "0", 3),
+            ("minicpmo_4_5_8x4090_stage1_replicas.yaml", "0,1,2,3", "4,5,6,7", "5", 4),
+        ],
+    )
+    def test_load_minicpmo_replica_deploy_configs(
+        self,
+        filename: str,
+        stage0_devices: str,
+        stage1_devices: str,
+        stage2_devices: str,
+        stage1_replicas: int,
+    ):
+        deploy_path = Path(get_deploy_config_path(filename))
+
+        deploy = load_deploy_config(deploy_path)
+        pipeline = resolve_pipeline_config("minicpmo_4_5")
+        assert isinstance(pipeline, PipelineConfig)
+
+        stages = merge_pipeline_deploy(pipeline, deploy)
+
+        assert deploy.session_mode == "duplex"
+        assert [stage.yaml_runtime["devices"] for stage in stages] == [
+            stage0_devices,
+            stage1_devices,
+            stage2_devices,
+        ]
+        assert stages[0].yaml_runtime["num_replicas"] == 1
+        assert stages[1].yaml_runtime["num_replicas"] == stage1_replicas
+        assert all(stage.yaml_engine_args["async_scheduling"] is False for stage in stages[:2])
+        assert all("Async" not in (stage.scheduler_cls or "") for stage in stages[:2])
+
     def test_custom_voice_dir_is_pipeline_wide_engine_arg(self, tmp_path):
         deploy_path = tmp_path / "qwen3_tts_custom_voice.yaml"
         custom_voice_dir = tmp_path / "voices"
@@ -756,7 +1218,7 @@ stages:
         )
 
         deploy = load_deploy_config(deploy_path)
-        pipeline = StageConfigFactory.resolve_pipeline_config("qwen3_tts")
+        pipeline = resolve_pipeline_config("qwen3_tts")
         stages = merge_pipeline_deploy(pipeline, deploy)
         assert isinstance(pipeline, PipelineConfig)
 
@@ -764,15 +1226,54 @@ stages:
         assert {s.yaml_engine_args.get("custom_voice_dir") for s in stages} == {str(custom_voice_dir)}
 
     def test_load_qwen3_omni_moe_deploy_config(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         deploy = load_deploy_config(deploy_path)
         assert len(deploy.stages) == 3
         assert deploy.async_chunk is True
         assert deploy.connectors is not None
         assert deploy.platforms is not None
 
+    def test_qwen3_omni_thinker_only_deploy_config_uses_resolved_pipeline(self):
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe_thinking.yaml"))
+        with patch(
+            "vllm_omni.config.config_factory.get_config",
+            return_value=Q3_OMNI_THINKER_HF_CONFIG,
+        ):
+            pipeline = StageConfigFactory.get_pipeline_config(
+                "Qwen/Qwen3-Omni-30B-A3B-Thinking",
+                trust_remote_code=False,
+                deploy_config_path=str(deploy_path),
+            )
+
+        assert pipeline is not None
+        assert pipeline.model_type == "qwen3_omni_moe_thinker_only"
+
+        deploy = load_deploy_config(deploy_path)
+        stages = merge_pipeline_deploy(pipeline, deploy)
+
+        assert len(stages) == 1
+        thinker = stages[0]
+        assert thinker.model_stage == "thinker"
+        assert thinker.final_output is True
+        assert thinker.final_output_type == "text"
+        assert thinker.worker_type == "ar"
+        assert thinker.scheduler_cls == "vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler"
+        assert thinker.hf_config_name == "thinker_config"
+        assert thinker.is_comprehension is True
+        assert thinker.yaml_runtime["devices"] == "0,1"
+        assert thinker.yaml_engine_args["engine_output_type"] == "text"
+        assert thinker.yaml_engine_args["tensor_parallel_size"] == 2
+        assert thinker.yaml_engine_args["max_num_seqs"] == 1
+        assert thinker.yaml_engine_args["gpu_memory_utilization"] == 0.9
+        assert thinker.yaml_engine_args["enforce_eager"] is True
+        assert thinker.yaml_engine_args["async_scheduling"] is False
+        assert thinker.yaml_engine_args["distributed_executor_backend"] == "mp"
+        assert thinker.yaml_engine_args["enable_prefix_caching"] is True
+        assert thinker.yaml_engine_args["async_chunk"] is False
+        assert thinker.yaml_extras["default_sampling_params"]["detokenize"] is True
+
     def test_load_voxtral_tts_deploy_config_schema_fields(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "voxtral_tts.yaml"
+        deploy_path = Path(get_deploy_config_path("voxtral_tts.yaml"))
         deploy = load_deploy_config(deploy_path)
         assert deploy.stages[0].config_format == "mistral"
         assert deploy.stages[0].load_format == "mistral"
@@ -782,7 +1283,7 @@ stages:
         )
 
     def test_load_ming_flash_omni_deploy_config_schema_fields(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "ming_flash_omni.yaml"
+        deploy_path = Path(get_deploy_config_path("ming_flash_omni.yaml"))
         deploy = load_deploy_config(deploy_path)
         assert deploy.stages[0].compilation_config == {"pass_config": {"fuse_allreduce_rms": False}}
         assert "compilation_config" not in deploy.stages[0].engine_extras
@@ -797,11 +1298,18 @@ stages:
         assert runtime_config == expected_runtime_config
 
     @pytest.mark.parametrize(
-        ("deploy_name", "pipeline_name", "stage_count", "final_output_type"),
+        ("deploy_name", "pipeline_name", "stage_count", "final_output_type", "declared_pipeline"),
         [
-            ("mammoth_moda2.yaml", "mammoth_moda2", 2, "image"),
-            ("mammoth_moda2_ar.yaml", "mammoth_moda2_ar", 1, "text"),
-            ("omnivoice.yaml", "omnivoice", 1, "audio"),
+            ("mammoth_moda2.yaml", "mammoth_moda2", 2, "image", "mammoth_moda2"),
+            ("mammoth_moda2_ar.yaml", "mammoth_moda2_ar", 1, "text", "mammoth_moda2_ar"),
+            ("omnivoice.yaml", "omnivoice", 1, "audio", "omnivoice"),
+            ("mimo_audio.yaml", "mimo_audio", 2, "audio", None),
+            ("step_audio_2.yaml", "step_audio_2", 2, "audio", None),
+            ("step_audio_2_asr.yaml", "step_audio_2_asr", 1, "text", "step_audio_2_asr"),
+            ("step_audio_2_async_chunk.yaml", "step_audio_2", 2, "audio", None),
+            ("step_audio2_ci.yaml", "step_audio_2_asr", 1, "text", "step_audio_2_asr"),
+            ("hunyuan_video_15.yaml", "hunyuan_video_15", 1, "video", None),
+            ("wan2_2_ti2v.yaml", "wan2_2_ti2v", 1, "video", None),
         ],
     )
     def test_load_new_registry_backed_deploy_configs(
@@ -810,10 +1318,11 @@ stages:
         pipeline_name: str,
         stage_count: int,
         final_output_type: str,
+        declared_pipeline: str | None,
     ):
         deploy_path = Path(get_deploy_config_path(deploy_name))
         deploy = load_deploy_config(deploy_path)
-        assert deploy.pipeline == pipeline_name
+        assert deploy.pipeline == declared_pipeline
 
         with patch("vllm_omni.platforms.current_omni_platform") as platform:
             platform.device_name = "cuda"
@@ -821,13 +1330,104 @@ stages:
         assert len(stages) == stage_count
         assert stages[-1].final_output is True
         assert stages[-1].final_output_type == final_output_type
+        if deploy.trust_remote_code is not None:
+            assert {s.yaml_engine_args.get("trust_remote_code") for s in stages} == {deploy.trust_remote_code}
+
+    @pytest.mark.parametrize(
+        ("config_json", "model_index", "expected_pipeline"),
+        [
+            ({"model_type": "step_audio_2"}, None, "step_audio_2"),
+            (None, {"_class_name": "HunyuanVideo15Pipeline"}, "hunyuan_video_15"),
+            (None, {"_class_name": "WanPipeline"}, "wan2_2_ti2v"),
+        ],
+    )
+    def test_migrated_models_are_discovered_without_explicit_deploy(
+        self,
+        config_json,
+        model_index,
+        expected_pipeline,
+    ):
+        def get_model_file(filename, _model, revision=None):
+            del revision
+            if filename == "config.json":
+                return config_json
+            if filename == "model_index.json":
+                return model_index
+            return None
+
+        with (
+            patch.object(StageConfigFactory, "get_hf_config", return_value=None),
+            patch("vllm_omni.config.config_factory.get_hf_file_to_dict", side_effect=get_model_file),
+        ):
+            pipeline = StageConfigFactory.get_pipeline_config(
+                model="/models/unrelated-checkpoint-name",
+                trust_remote_code=False,
+            )
+
+        assert pipeline is not None
+        assert pipeline.model_type == expected_pipeline
+
+    @pytest.mark.parametrize("deploy_name", ["step_audio_2.yaml", "step_audio_2_async_chunk.yaml"])
+    def test_step_audio2_deploy_configs_fit_two_gpus(self, deploy_name):
+        deploy = load_deploy_config(Path(get_deploy_config_path(deploy_name)))
+
+        assert deploy.stages[0].devices == "0,1"
+        assert deploy.stages[0].tensor_parallel_size == 2
+        assert deploy.stages[1].devices == "1"
+
+    def test_step_audio2_online_ci_deploy_is_single_thinker(self):
+        deploy = load_deploy_config(Path(get_deploy_config_path("step_audio2_ci.yaml")))
+
+        assert deploy.pipeline == "step_audio_2_asr"
+        assert deploy.async_chunk is False
+        assert deploy.trust_remote_code is True
+        assert deploy.enable_prefix_caching is False
+        assert len(deploy.stages) == 1
+
+        stage = deploy.stages[0]
+        assert stage.devices == "0"
+        assert stage.tensor_parallel_size == 1
+        assert stage.max_model_len == 1024
+        assert stage.max_num_batched_tokens == 1024
+        assert stage.max_num_seqs == 1
+        assert stage.gpu_memory_utilization == 0.7
+        assert stage.skip_mm_profiling is True
+        assert stage.enforce_eager is True
+        assert stage.async_scheduling is False
+        assert stage.engine_extras["hf_overrides"]["architectures"] == ["StepAudio2ThinkerForConditionalGeneration"]
+
+        stages = merge_pipeline_deploy(OMNI_PIPELINES[deploy.pipeline], deploy)
+        assert len(stages) == 1
+        assert stages[0].final_output is True
+        assert stages[0].final_output_type == "text"
+        assert stages[0].yaml_engine_args["engine_output_type"] == "text"
+
+    def test_step_audio2_dispatches_sync_and_async_chunk_processors(self):
+        pipeline = resolve_pipeline_config("step_audio_2")
+        assert isinstance(pipeline, PipelineConfig)
+
+        sync_stages = merge_pipeline_deploy(pipeline, DeployConfig(async_chunk=False))
+        assert "custom_process_next_stage_input_func" not in sync_stages[0].yaml_engine_args
+        assert sync_stages[1].custom_process_input_func.endswith("thinker2token2wav")
+
+        async_stages = merge_pipeline_deploy(pipeline, DeployConfig(async_chunk=True))
+        assert (
+            async_stages[0]
+            .yaml_engine_args["custom_process_next_stage_input_func"]
+            .endswith("thinker2token2wav_async_chunk")
+        )
+        assert async_stages[1].custom_process_input_func is None
+
+    def test_no_bundled_legacy_stage_config_yamls(self):
+        stage_config_dir = Path(__file__).parent.parent / "vllm_omni" / "model_executor" / "stage_configs"
+        assert not list(stage_config_dir.glob("*.yaml"))
 
     def test_merge_pipeline_deploy(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -844,13 +1444,13 @@ stages:
         assert s0.yaml_extras["default_sampling_params"]["detokenize"] is True
 
     def test_merge_pipeline_deploy_preserves_num_replicas(self, tmp_path):
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
         assert isinstance(pipeline, PipelineConfig)
 
-        base = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        base = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not base.exists():
             pytest.skip("Deploy config not found")
 
@@ -1131,7 +1731,7 @@ stages:
 
 class TestQwen3OmniPipeline:
     def test_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config(
+        p = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1141,7 +1741,7 @@ class TestQwen3OmniPipeline:
         assert p.validate() == []
 
     def test_thinker(self):
-        p = StageConfigFactory.resolve_pipeline_config(
+        p = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1156,7 +1756,7 @@ class TestQwen3OmniPipeline:
         assert s.sampling_constraints["detokenize"] is True
 
     def test_talker(self):
-        p = StageConfigFactory.resolve_pipeline_config(
+        p = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1173,7 +1773,7 @@ class TestQwen3OmniPipeline:
         assert s.custom_process_next_stage_input_func is not None
 
     def test_code2wav(self):
-        p = StageConfigFactory.resolve_pipeline_config(
+        p = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1188,14 +1788,14 @@ class TestQwen3OmniPipeline:
 
 class TestQwen2_5OmniPipeline:
     def test_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen2_5_omni")
+        p = resolve_pipeline_config("qwen2_5_omni")
         assert isinstance(p, PipelineConfig)
         assert p.model_arch == "Qwen2_5OmniForConditionalGeneration"
         assert len(p.stages) == 3
         assert p.validate() == []
 
     def test_thinker(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen2_5_omni")
+        p = resolve_pipeline_config("qwen2_5_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(0)
@@ -1207,7 +1807,7 @@ class TestQwen2_5OmniPipeline:
         assert s.requires_multimodal_data is True
 
     def test_talker(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen2_5_omni")
+        p = resolve_pipeline_config("qwen2_5_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(1)
@@ -1221,7 +1821,7 @@ class TestQwen2_5OmniPipeline:
         assert s.sync_process_input_func is not None
 
     def test_code2wav(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen2_5_omni")
+        p = resolve_pipeline_config("qwen2_5_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(2)
@@ -1233,7 +1833,7 @@ class TestQwen2_5OmniPipeline:
 
 class TestQwen3TTSPipeline:
     def test_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen3_tts")
+        p = resolve_pipeline_config("qwen3_tts")
         assert isinstance(p, PipelineConfig)
         assert p is not None
         assert p.model_arch == "Qwen3TTSTalkerForConditionalGeneration"
@@ -1241,7 +1841,7 @@ class TestQwen3TTSPipeline:
         assert p.validate() == []
 
     def test_talker_stage(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen3_tts")
+        p = resolve_pipeline_config("qwen3_tts")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(0)
@@ -1255,7 +1855,7 @@ class TestQwen3TTSPipeline:
         assert s.model_arch is None
 
     def test_code2wav_stage_has_per_stage_model_arch(self):
-        p = StageConfigFactory.resolve_pipeline_config("qwen3_tts")
+        p = resolve_pipeline_config("qwen3_tts")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(1)
@@ -1270,7 +1870,7 @@ class TestQwen3TTSPipeline:
 
     def test_per_stage_model_arch_flows_through_merge(self, tmp_path):
         """Verify the new ps.model_arch override survives merge_pipeline_deploy."""
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_tts.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_tts.yaml"))
         if not deploy_path.exists():
             pytest.skip("qwen3_tts deploy yaml not found")
 
@@ -1314,14 +1914,14 @@ class TestQwen3TTSPipeline:
 
 class TestMingFlashOmniPipeline:
     def test_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        p = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(p, PipelineConfig)
         assert p.model_arch == "MingFlashOmniForConditionalGeneration"
         assert len(p.stages) == 2
         assert p.validate() == []
 
     def test_thinker_stage(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        p = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(0)
@@ -1335,7 +1935,7 @@ class TestMingFlashOmniPipeline:
         assert s.sampling_constraints["detokenize"] is True
 
     def test_talker_stage(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        p = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(1)
@@ -1361,7 +1961,7 @@ class TestMingFlashOmniPipeline:
         Lazy string references only fail at first inference otherwise — this
         catches typos in the pipeline declaration at import / registration time.
         """
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        p = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(1)
@@ -1371,14 +1971,14 @@ class TestMingFlashOmniPipeline:
         assert callable(getattr(module, attr))
 
     def test_tts_pipeline_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_tts")
+        p = resolve_pipeline_config("ming_flash_omni_tts")
         assert isinstance(p, PipelineConfig)
         assert p.model_arch == "MingFlashOmniTalkerForConditionalGeneration"
         assert len(p.stages) == 1
         assert p.validate() == []
 
     def test_tts_stage(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_tts")
+        p = resolve_pipeline_config("ming_flash_omni_tts")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(0)
@@ -1394,7 +1994,7 @@ class TestMingFlashOmniPipeline:
 
     def test_full_yaml_loads_and_merges(self):
         """deploy/ming_flash_omni.yaml parses and merges with the registered pipeline."""
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "ming_flash_omni.yaml"
+        deploy_path = Path(get_deploy_config_path("ming_flash_omni.yaml"))
         if not deploy_path.exists():
             pytest.skip("ming_flash_omni deploy yaml not found")
 
@@ -1405,7 +2005,7 @@ class TestMingFlashOmniPipeline:
         # We won't test stage 0/1 colocation contract here,
         # as there could exist more variant of custom device setup
 
-        pipeline = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        pipeline = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(pipeline, PipelineConfig)
         stages = merge_pipeline_deploy(pipeline, deploy)
         assert len(stages) == 2
@@ -1414,7 +2014,7 @@ class TestMingFlashOmniPipeline:
 
     def test_tts_yaml_loads_and_merges(self):
         """deploy/ming_flash_omni_tts.yaml parses and routes to the TTS-only pipeline."""
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "ming_flash_omni_tts.yaml"
+        deploy_path = Path(get_deploy_config_path("ming_flash_omni_tts.yaml"))
         if not deploy_path.exists():
             pytest.skip("ming_flash_omni_tts deploy yaml not found")
 
@@ -1428,14 +2028,14 @@ class TestMingFlashOmniPipeline:
         assert stages[0].yaml_engine_args["model_arch"] == "MingFlashOmniTalkerForConditionalGeneration"
 
     def test_thinker_only_pipeline_registered(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_thinker_only")
+        p = resolve_pipeline_config("ming_flash_omni_thinker_only")
         assert isinstance(p, PipelineConfig)
         assert p.model_arch == "MingFlashOmniForConditionalGeneration"
         assert len(p.stages) == 1
         assert p.validate() == []
 
     def test_thinker_only_stage(self):
-        p = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_thinker_only")
+        p = resolve_pipeline_config("ming_flash_omni_thinker_only")
         assert isinstance(p, PipelineConfig)
 
         s = p.get_stage(0)
@@ -1452,7 +2052,7 @@ class TestMingFlashOmniPipeline:
 
     def test_thinker_only_yaml_loads_and_merges(self):
         """deploy/ming_flash_omni_thinker_only.yaml parses and routes to the thinker-only pipeline."""
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "ming_flash_omni_thinker_only.yaml"
+        deploy_path = Path(get_deploy_config_path("ming_flash_omni_thinker_only.yaml"))
         if not deploy_path.exists():
             pytest.skip("ming_flash_omni_thinker_only deploy yaml not found")
 
@@ -1460,7 +2060,7 @@ class TestMingFlashOmniPipeline:
         assert len(deploy.stages) == 1
         assert deploy.pipeline == "ming_flash_omni_thinker_only"
 
-        pipeline = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_thinker_only")
+        pipeline = resolve_pipeline_config("ming_flash_omni_thinker_only")
         assert isinstance(pipeline, PipelineConfig)
         stages = merge_pipeline_deploy(pipeline, deploy)
         assert len(stages) == 1
@@ -1474,7 +2074,7 @@ class TestMingFlashOmniPipeline:
         assert p.validate() == []
 
     def test_image_thinker_stage(self):
-        s = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_image").get_stage(0)
+        s = resolve_pipeline_config("ming_flash_omni_image").get_stage(0)
         assert s.model_stage == "thinker"
         assert s.execution_type == StageExecutionType.LLM_AR
         assert s.input_sources == ()
@@ -1488,7 +2088,7 @@ class TestMingFlashOmniPipeline:
         assert s.prompt_expand_func is not None
 
     def test_image_dit_stage(self):
-        s = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_image").get_stage(1)
+        s = resolve_pipeline_config("ming_flash_omni_image").get_stage(1)
         assert s.model_stage == "dit"
         assert s.execution_type == StageExecutionType.DIFFUSION
         assert s.input_sources == (0,)
@@ -1500,7 +2100,7 @@ class TestMingFlashOmniPipeline:
 
     def test_image_processor_wiring_resolves(self):
         """The prompt_expand_func and custom_process_input_func strings must point to real callables."""
-        pipeline = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_image")
+        pipeline = resolve_pipeline_config("ming_flash_omni_image")
         assert isinstance(pipeline, PipelineConfig)
 
         thinker = pipeline.get_stage(0)
@@ -1512,7 +2112,7 @@ class TestMingFlashOmniPipeline:
 
     def test_image_yaml_loads_and_merges(self):
         """deploy/ming_flash_omni_image.yaml parses and routes to the image pipeline."""
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "ming_flash_omni_image.yaml"
+        deploy_path = Path(get_deploy_config_path("ming_flash_omni_image.yaml"))
         if not deploy_path.exists():
             pytest.skip("ming_flash_omni_image deploy yaml not found")
 
@@ -1523,7 +2123,7 @@ class TestMingFlashOmniPipeline:
         assert deploy.connectors is not None
         assert "shared_memory_connector" in deploy.connectors
 
-        pipeline = StageConfigFactory.resolve_pipeline_config("ming_flash_omni_image")
+        pipeline = resolve_pipeline_config("ming_flash_omni_image")
         assert isinstance(pipeline, PipelineConfig)
         stages = merge_pipeline_deploy(pipeline, deploy)
         assert len(stages) == 2
@@ -1574,7 +2174,7 @@ class TestBaseConfigInheritance:
 
     def test_pure_inheritance_overlay(self, tmp_path):
         """An overlay with only ``base_config`` inherits everything."""
-        base = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        base = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not base.exists():
             pytest.skip("Base deploy config not found")
 
@@ -1587,7 +2187,7 @@ class TestBaseConfigInheritance:
 
     def test_single_field_overlay(self, tmp_path):
         """An overlay overriding one stage field merges with the base."""
-        base = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        base = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not base.exists():
             pytest.skip("Base deploy config not found")
 
@@ -1603,8 +2203,45 @@ class TestBaseConfigInheritance:
 class TestPlatformOverrides:
     """Test platform-specific deploy config overrides."""
 
+    def test_qwen3_tts_rocm_disables_code2wav_outer_cudagraph(self):
+        deploy_path = Path(get_deploy_config_path("qwen3_tts.yaml"))
+
+        base = load_deploy_config(deploy_path)
+        assert base.stages[0].enforce_eager is None
+        assert base.stages[1].enforce_eager is False
+
+        rocm = _apply_platform_overrides(base, platform="rocm")
+        assert rocm.stages[0].enforce_eager is None
+        assert rocm.stages[1].enforce_eager is True
+
+    def test_minicpmo_4_5_cuda_caps_talker_kv_cache(self):
+        pipeline = resolve_pipeline_config("minicpmo_4_5")
+        assert isinstance(pipeline, PipelineConfig)
+        deploy_path = Path(get_deploy_config_path("minicpmo_4_5.yaml"))
+
+        cuda = _apply_platform_overrides(load_deploy_config(deploy_path), platform="cuda")
+        cuda_stages = merge_pipeline_deploy(pipeline, cuda)
+        assert cuda_stages[1].yaml_engine_args["kv_cache_memory_bytes"] == 2 * 1024**3
+
+        # The CUDA memory budget must not leak into the existing NPU profile.
+        npu = _apply_platform_overrides(load_deploy_config(deploy_path), platform="npu")
+        npu_stages = merge_pipeline_deploy(pipeline, npu)
+        assert "kv_cache_memory_bytes" not in npu_stages[1].yaml_engine_args
+
+        # Multi-GPU replica profiles place Talker on dedicated devices and
+        # preserve their previous automatic KV-cache sizing.
+        for filename in (
+            "minicpmo_4_5_3gpu_stage1_replicas.yaml",
+            "minicpmo_4_5_4gpu_stage1_replicas.yaml",
+        ):
+            replica = _apply_platform_overrides(
+                load_deploy_config(Path(get_deploy_config_path(filename))), platform="cuda"
+            )
+            replica_stages = merge_pipeline_deploy(pipeline, replica)
+            assert replica_stages[1].yaml_engine_args["kv_cache_memory_bytes"] is None
+
     def test_npu_overrides(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
@@ -1618,7 +2255,7 @@ class TestPlatformOverrides:
         assert deploy.stages[2].enforce_eager is False
 
     def test_xpu_overrides(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
@@ -1630,7 +2267,7 @@ class TestPlatformOverrides:
         assert deploy.stages[0].engine_extras.get("max_cudagraph_capture_size") == 0
 
     def test_unknown_platform_noop(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
@@ -1675,12 +2312,12 @@ class TestCLIOverrideFlow:
     """Test --stage-overrides JSON merge into StageConfig."""
 
     def test_stage_overrides_merge(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
         deploy = load_deploy_config(deploy_path)
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1693,12 +2330,12 @@ class TestCLIOverrideFlow:
         assert stages[0].runtime_overrides["gpu_memory_utilization"] == 0.5
 
     def test_global_override_applies_to_all(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
         deploy = load_deploy_config(deploy_path)
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
@@ -1713,19 +2350,18 @@ class TestCLIOverrideFlow:
 
 class TestAuraOmniDeploy:
     def test_aura_omni_deploy_forces_pipeline_override(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "aura_omni.yaml"
+        deploy_path = Path(get_deploy_config_path("aura_omni.yaml"))
         deploy = load_deploy_config(deploy_path)
 
         assert deploy.pipeline == "aura_omni"
 
     def test_aura_omni_deploy_resolves_four_native_stages(self):
-        pipeline_cfg = StageConfigFactory.resolve_pipeline_config("aura_omni")
+        pipeline_cfg = resolve_pipeline_config("aura_omni")
 
-        stages, _ = StageConfigFactory._create_from_registry(
-            "qwen3_tts",
+        stages, _ = StageConfigFactory._create_legacy_from_registry(
             pipeline_cfg,
             cli_overrides={},
-            deploy_config_path=str(Path(__file__).parent.parent / "vllm_omni" / "deploy" / "aura_omni.yaml"),
+            deploy_config_path=get_deploy_config_path("aura_omni.yaml"),
         )
 
         assert [stage.model_stage for stage in stages] == [
@@ -1939,12 +2575,11 @@ class TestSentinelDefaultPrecedence:
 
     def _stages(self, cli_overrides):
         model_type = "qwen3_omni_moe"
-        pipeline_cfg = StageConfigFactory.resolve_pipeline_config(
+        pipeline_cfg = resolve_pipeline_config(
             model_type,
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
-        stages, _ = StageConfigFactory._create_from_registry(
-            "qwen3_omni_moe",
+        stages, _ = StageConfigFactory._create_legacy_from_registry(
             pipeline_cfg,
             cli_overrides=cli_overrides,
         )
@@ -2002,16 +2637,11 @@ class TestSentinelDefaultPrecedence:
         for stage in stages:
             assert stage.runtime_overrides == {}
 
-    def test_create_from_registry_no_cli_explicit_keys_param(self):
-        sig = inspect.signature(StageConfigFactory._create_from_registry)
-        named = [p for p in sig.parameters.values() if p.kind != p.VAR_KEYWORD]
-        assert "cli_explicit_keys" not in {p.name for p in named}
-
     def test_async_chunk_dispatches_processors(self):
         """A single ``qwen3_tts`` pipeline picks per-chunk vs end-to-end
         processors based on ``deploy.async_chunk``, without needing a
         separate variant pipeline registration."""
-        pipeline = StageConfigFactory.resolve_pipeline_config("qwen3_tts")
+        pipeline = resolve_pipeline_config("qwen3_tts")
         assert isinstance(pipeline, PipelineConfig)
 
         # async_chunk=True → stage 0's per-chunk processor wires up, stage 1
@@ -2045,7 +2675,12 @@ class TestSentinelDefaultPrecedence:
         from vllm_omni.config.stage_config import DeployConfig, merge_pipeline_deploy
 
         pipeline_path = (
-            Path(__file__).parent.parent / "vllm_omni" / "model_executor" / "models" / "qwen3_omni" / "pipeline.py"
+            Path(__file__).parent.parent.parent
+            / "vllm_omni"
+            / "model_executor"
+            / "models"
+            / "qwen3_omni"
+            / "pipeline.py"
         )
         pipeline = runpy.run_path(str(pipeline_path))["QWEN3_OMNI_PIPELINE"]
 
@@ -2082,7 +2717,7 @@ class TestSentinelDefaultPrecedence:
         called ``_build_talker_inputs`` identically.
         Merge under either async_chunk mode must not re-introduce a
         stage-0 full-payload hook."""
-        pipeline = StageConfigFactory.resolve_pipeline_config("ming_flash_omni")
+        pipeline = resolve_pipeline_config("ming_flash_omni")
         assert isinstance(pipeline, PipelineConfig)
 
         stage0, stage1 = pipeline.stages
@@ -2115,12 +2750,12 @@ class TestSamplingConstraintsPrecedence:
     """Test that pipeline sampling_constraints override deploy defaults."""
 
     def test_constraints_win(self):
-        deploy_path = Path(__file__).parent.parent / "vllm_omni" / "deploy" / "qwen3_omni_moe.yaml"
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():
             pytest.skip("Deploy config not found")
 
         deploy = load_deploy_config(deploy_path)
-        pipeline = StageConfigFactory.resolve_pipeline_config(
+        pipeline = resolve_pipeline_config(
             "qwen3_omni_moe",
             Q3_OMNI_ALL_STAGES_HF_CONFIG,
         )
diff --git a/tests/config/test_omni_config.py b/tests/config/test_omni_config.py
index bf2dba701..c0a3f20e8 100644
--- a/tests/config/test_omni_config.py
+++ b/tests/config/test_omni_config.py
@@ -9,7 +9,9 @@ from pathlib import Path
 
 import pytest
 from pydantic import ValidationError
+from transformers import Qwen3OmniMoeConfig
 
+from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.config import omni_config as omni_config_module
 from vllm_omni.config.omni_config import (
     BaseVllmOmniStageConfig,
@@ -26,7 +28,7 @@ from vllm_omni.config.omni_config import (
     VllmOmniDiffusionStageConfig,
     VllmOmniGenerationStageConfig,
 )
-from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
 from vllm_omni.config.stage_config import (
     _STAGE_DEPLOY_FIELDS,
     PIPELINE_WIDE_ENGINE_FIELDS,
@@ -37,7 +39,7 @@ from vllm_omni.config.stage_config import (
     load_deploy_config,
     merge_pipeline_deploy,
 )
-from vllm_omni.engine.stage_init_utils import build_engine_args_dict
+from vllm_omni.engine.stage_init_utils import build_legacy_engine_args_dict
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -53,28 +55,54 @@ def _stable_test_platform(monkeypatch):
     monkeypatch.setattr(platform, "device_type", "cpu", raising=False)
 
 
-def _load_default_deploy(model_type: str) -> DeployConfig:
-    deploy_path = _DEPLOY_DIR / f"{model_type}.yaml"
-    if deploy_path.exists():
-        return load_deploy_config(deploy_path)
+def _load_default_deploy(pipeline: PipelineConfig) -> DeployConfig:
+    if pipeline.default_deploy_config_name is not None:
+        return load_deploy_config(_DEPLOY_DIR / pipeline.default_deploy_config_name)
     return DeployConfig()
 
 
-def _resolve_pipeline_or_skip(model_type: str) -> PipelineConfig:
-    registered = OMNI_PIPELINES[model_type]
-    pipeline = registered(None) if callable(registered) else registered
+def _resolve_pipeline_or_skip(model_type: str, hf_config=None) -> PipelineConfig:
+    pipeline = resolve_pipeline_config(model_type, hf_config)
     if pipeline is None:
         pytest.skip(f"Pipeline {model_type!r} requires an HF config to resolve")
     return pipeline
 
 
+def _from_pipeline_key(
+    model_type: str,
+    hf_config=None,
+    deploy_config_path: str | None = None,
+    cli_overrides: dict | None = None,
+) -> VllmOmniConfig:
+    return VllmOmniConfig.from_pipeline_config(
+        _resolve_pipeline_or_skip(model_type, hf_config),
+        deploy_config_path=deploy_config_path,
+        cli_overrides=cli_overrides,
+    )
+
+
+def test_duplex_session_capacity_propagates_to_every_structured_stage() -> None:
+    omni_config = _from_pipeline_key("personaplex")
+
+    assert [stage.model_config.duplex_max_sessions for stage in omni_config.stage_configs] == [2, 2]
+
+
+def test_non_duplex_deploy_keeps_model_session_capacity_at_one(tmp_path: Path) -> None:
+    deploy_path = tmp_path / "personaplex-turn.yaml"
+    deploy_path.write_text("session_mode: turn\n", encoding="utf-8")
+
+    omni_config = _from_pipeline_key("personaplex", deploy_config_path=str(deploy_path))
+
+    assert [stage.model_config.duplex_max_sessions for stage in omni_config.stage_configs] == [1, 1]
+
+
 @pytest.mark.parametrize("model_type", sorted(OMNI_PIPELINES))
-def test_vllm_omni_config_from_registry_matches_merge_pipeline_deploy(model_type: str):
+def test_vllm_omni_config_from_pipeline_config_matches_merge_pipeline_deploy(model_type: str):
     pipeline = _resolve_pipeline_or_skip(model_type)
-    legacy_deploy = _load_default_deploy(model_type)
+    legacy_deploy = _load_default_deploy(pipeline)
 
     legacy_stages = merge_pipeline_deploy(pipeline, legacy_deploy)
-    omni_config = VllmOmniConfig.from_registry(model_type)
+    omni_config = VllmOmniConfig.from_pipeline_config(pipeline)
 
     assert omni_config.pipeline_config is pipeline
     assert len(omni_config.stage_configs) == len(legacy_stages)
@@ -92,13 +120,20 @@ def test_vllm_omni_config_from_registry_matches_merge_pipeline_deploy(model_type
         assert omni_stage.runtime_config.num_replicas == legacy_stage.yaml_runtime.get("num_replicas", 1)
 
         engine_args = legacy_stage.yaml_engine_args
+        assert omni_stage.model_config.duplex_max_sessions == engine_args.get("duplex_max_sessions", 1)
         assert omni_stage.model_config.enforce_eager == engine_args.get("enforce_eager", False)
         assert omni_stage.load_config.load_format == engine_args.get("load_format", "auto")
         assert omni_stage.load_config.tokenizer_mode == engine_args.get("tokenizer_mode", "auto")
-        assert omni_stage.cache_config.gpu_memory_utilization == engine_args.get("gpu_memory_utilization", 0.90)
-        assert omni_stage.scheduler_config.max_num_seqs == engine_args.get("max_num_seqs", 128)
+        assert omni_stage.cache_config.gpu_memory_utilization == engine_args.get("gpu_memory_utilization")
+        assert omni_stage.cache_config.enable_prefix_caching == engine_args.get("enable_prefix_caching")
+        expected_disable_hybrid = engine_args.get("disable_hybrid_kv_cache_manager")
+        if omni_stage.stage_pipeline_config.execution_type == StageExecutionType.LLM_GENERATION:
+            expected_disable_hybrid = True if expected_disable_hybrid is None else expected_disable_hybrid
+        assert omni_stage.cache_config.disable_hybrid_kv_cache_manager == expected_disable_hybrid
+        assert omni_stage.scheduler_config.max_num_seqs == engine_args.get("max_num_seqs")
         assert omni_stage.scheduler_config.max_num_batched_tokens == engine_args.get("max_num_batched_tokens")
-        assert omni_stage.scheduler_config.async_scheduling == engine_args.get("async_scheduling", True)
+        assert omni_stage.scheduler_config.enable_chunked_prefill == engine_args.get("enable_chunked_prefill")
+        assert omni_stage.scheduler_config.async_scheduling == engine_args.get("async_scheduling")
         legacy_parallel_config = engine_args.get("parallel_config") or {}
         assert omni_stage.parallel_config.tensor_parallel_size == legacy_parallel_config.get(
             "tensor_parallel_size",
@@ -119,7 +154,7 @@ def test_vllm_omni_config_from_registry_matches_merge_pipeline_deploy(model_type
 
 
 def test_stage_by_id_raises_for_unknown_stage():
-    omni_config = VllmOmniConfig.from_registry("qwen3_tts")
+    omni_config = _from_pipeline_key("qwen3_tts")
 
     with pytest.raises(KeyError, match="no stage 99"):
         omni_config.stage_by_id(99)
@@ -130,8 +165,8 @@ def test_resolve_execution_mode_rejects_unknown_execution_type():
         omni_config_module._resolve_execution_mode("unknown_execution_type")
 
 
-def test_from_registry_preserves_current_pipeline_config_object():
-    omni_config = VllmOmniConfig.from_registry("minicpmo_4_5")
+def test_from_pipeline_config_preserves_current_pipeline_config_object():
+    omni_config = _from_pipeline_key("minicpmo_4_5")
     pipeline = _resolve_pipeline_or_skip("minicpmo_4_5")
 
     assert omni_config.pipeline_config is pipeline
@@ -140,11 +175,11 @@ def test_from_registry_preserves_current_pipeline_config_object():
     assert omni_config.pipeline_config.hf_config_predicate is pipeline.hf_config_predicate
 
 
-def test_from_registry_normalizes_stage_engine_extras_without_expanding_stage_deploy_config():
+def test_from_pipeline_config_normalizes_stage_engine_extras_without_expanding_stage_deploy_config():
     assert not hasattr(StageDeployConfig, "model_config")
     assert not hasattr(StageDeployConfig, "parallel_config")
 
-    stage = VllmOmniConfig.from_registry("dreamzero", deploy_config_path="dreamzero_tp1_cfg2").stage_by_id(0)
+    stage = _from_pipeline_key("dreamzero", deploy_config_path="dreamzero_tp1_cfg2").stage_by_id(0)
 
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
     assert stage.parallel_config.tensor_parallel_size == 1
@@ -152,8 +187,8 @@ def test_from_registry_normalizes_stage_engine_extras_without_expanding_stage_de
     assert stage.diffusion_config.model_config["default_robot_embodiment"] == "roboarena"
 
 
-def test_from_registry_applies_cli_overrides_without_stage_config_runtime_bridge():
-    omni_config = VllmOmniConfig.from_registry(
+def test_from_pipeline_config_applies_cli_overrides_without_stage_config_runtime_bridge():
+    omni_config = _from_pipeline_key(
         "qwen3_tts",
         cli_overrides={
             "stage_0_max_num_seqs": 7,
@@ -169,8 +204,66 @@ def test_from_registry_applies_cli_overrides_without_stage_config_runtime_bridge
     assert stage1.runtime_config.num_gpus == stage1.parallel_config.world_size
 
 
+@pytest.mark.parametrize(
+    "cli_overrides",
+    [
+        {"enable_lora": True},
+        {"stage_0_enable_lora": True},
+    ],
+    ids=["global", "stage-scoped"],
+)
+def test_from_pipeline_config_rejects_explicit_unowned_engine_cli_fields(cli_overrides):
+    with pytest.raises(ValueError, match=r"no structured config owner: enable_lora"):
+        _from_pipeline_key("qwen3_tts", cli_overrides=cli_overrides)
+
+
+@pytest.mark.parametrize(
+    ("engine_extras", "unowned_field"),
+    [
+        ({"enable_lora": True}, "enable_lora"),
+        ({"parallel_config": {"cfg_parallel_size": 2}}, "parallel_config.cfg_parallel_size"),
+    ],
+    ids=["top-level", "nested-parallel-config"],
+)
+def test_from_pipeline_config_rejects_unowned_deploy_engine_extras(engine_extras, unowned_field):
+    pipeline = _resolve_pipeline_or_skip("qwen3_tts")
+    deploy = DeployConfig(stages=[StageDeployConfig(stage_id=0, engine_extras=engine_extras)])
+
+    with pytest.raises(ValueError, match=rf"no structured config owner: {unowned_field}"):
+        VllmOmniConfig.from_pipeline_config(pipeline, user_deploy_config=deploy)
+
+
+@pytest.mark.parametrize(
+    ("cli_overrides", "stage_id"),
+    [
+        ({"kv_cache_dtype": "fp8"}, 0),
+        ({"stage_0_kv_cache_dtype": "fp8"}, 0),
+        ({"stage_1_kv_cache_dtype": "fp8"}, 1),
+    ],
+    ids=["global", "ar-stage", "generation-stage"],
+)
+def test_from_pipeline_config_rejects_diffusion_only_cli_fields_for_llm_stages(cli_overrides, stage_id):
+    with pytest.raises(ValueError, match=rf"Stage {stage_id} .*no structured config owner: kv_cache_dtype"):
+        _from_pipeline_key("qwen3_tts", cli_overrides=cli_overrides)
+
+
+def test_from_pipeline_config_accepts_diffusion_only_cli_fields_for_diffusion_stage():
+    stage = _from_pipeline_key(
+        "dreamzero",
+        deploy_config_path="dreamzero_tp1_cfg2",
+        cli_overrides={"kv_cache_dtype": "fp8"},
+    ).stage_by_id(0)
+
+    assert isinstance(stage, VllmOmniDiffusionStageConfig)
+    assert stage.diffusion_config.diffusion_kv_cache_dtype == "fp8"
+
+
+def test_stage_cli_field_selection_defers_ownership_validation_until_sources_are_merged():
+    assert omni_config_module._stage_cli_overrides(0, {"enable_lora": True}) == {"enable_lora": True}
+
+
 def test_runtime_num_gpus_is_derived_from_parallel_world_size():
-    omni_config = VllmOmniConfig.from_registry("hunyuan_image3_dit")
+    omni_config = _from_pipeline_key("hunyuan_image3_dit")
     stage = omni_config.stage_by_id(0)
 
     assert stage.parallel_config.tensor_parallel_size == 4
@@ -179,7 +272,7 @@ def test_runtime_num_gpus_is_derived_from_parallel_world_size():
 
 
 def test_runtime_num_gpus_ignores_stale_runtime_override():
-    omni_config = VllmOmniConfig.from_registry(
+    omni_config = _from_pipeline_key(
         "hunyuan_image3_dit",
         cli_overrides={
             "stage_0_num_gpus": 1,
@@ -191,8 +284,8 @@ def test_runtime_num_gpus_ignores_stale_runtime_override():
     assert stage.runtime_config.num_gpus == 4
 
 
-def test_from_registry_does_not_route_server_cli_keys_to_diffusion_stage():
-    omni_config = VllmOmniConfig.from_registry(
+def test_from_pipeline_config_does_not_route_server_cli_keys_to_diffusion_stage():
+    omni_config = _from_pipeline_key(
         "dreamzero",
         deploy_config_path="dreamzero_tp1_cfg2",
         cli_overrides={
@@ -220,7 +313,7 @@ def test_pipeline_deploy_cli_fields_reuse_legacy_pipeline_wide_engine_fields():
 
 def test_pipeline_wide_model_fields_are_retained_on_structured_stage_configs(tmp_path):
     custom_voice_dir = tmp_path / "voices"
-    omni_config = VllmOmniConfig.from_registry(
+    omni_config = _from_pipeline_key(
         "qwen3_tts",
         cli_overrides={
             "active_stream_window": 2,
@@ -267,8 +360,8 @@ def test_public_config_exports_use_stage_specific_sub_config_names():
     }.issubset(config_pkg.__all__)
 
 
-def test_from_registry_keeps_worker_backend_separate_from_distributed_executor_backend():
-    omni_config = VllmOmniConfig.from_registry("dreamzero", deploy_config_path="dreamzero_tp1_cfg2")
+def test_from_pipeline_config_keeps_worker_backend_separate_from_distributed_executor_backend():
+    omni_config = _from_pipeline_key("dreamzero", deploy_config_path="dreamzero_tp1_cfg2")
 
     stage = omni_config.stage_by_id(0)
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
@@ -276,8 +369,8 @@ def test_from_registry_keeps_worker_backend_separate_from_distributed_executor_b
     assert omni_config.orchestrator_config.worker_backend == "multi_process"
 
 
-def test_from_registry_maps_orchestrator_cli_overrides():
-    omni_config = VllmOmniConfig.from_registry(
+def test_from_pipeline_config_maps_orchestrator_cli_overrides():
+    omni_config = _from_pipeline_key(
         "qwen3_tts",
         cli_overrides={
             "stage_init_timeout": 1200,
@@ -289,7 +382,6 @@ def test_from_registry_maps_orchestrator_cli_overrides():
             "omni_dp_size_local": 2,
             "omni_lb_policy": "round_robin",
             "omni_heartbeat_timeout": 9.5,
-            "shm_threshold_bytes": 4096,
             "batch_timeout": 3,
         },
     )
@@ -304,25 +396,24 @@ def test_from_registry_maps_orchestrator_cli_overrides():
     assert orchestrator_config.omni_dp_size_local == 2
     assert orchestrator_config.omni_lb_policy == "round_robin"
     assert orchestrator_config.omni_heartbeat_timeout == 9.5
-    assert orchestrator_config.shm_threshold_bytes == 4096
     assert orchestrator_config.batch_timeout == 3
 
 
-def test_from_registry_records_loaded_deploy_path_on_orchestrator_config():
-    omni_config = VllmOmniConfig.from_registry("dreamzero", deploy_config_path="dreamzero_tp1_cfg2")
+def test_from_pipeline_config_records_loaded_deploy_path_on_orchestrator_config():
+    omni_config = _from_pipeline_key("dreamzero", deploy_config_path="dreamzero_tp1_cfg2")
 
     assert omni_config.pipeline_config.model_type == "dreamzero"
     assert omni_config.orchestrator_config.deploy_config_path == str(_DEPLOY_DIR / "dreamzero_tp1_cfg2.yaml")
 
 
-def test_from_registry_dispatches_async_chunk_processors_without_mutating_topology():
+def test_from_pipeline_config_dispatches_async_chunk_processors_without_mutating_topology():
     pipeline = _resolve_pipeline_or_skip("qwen3_tts")
 
-    async_config = VllmOmniConfig.from_registry("qwen3_tts")
+    async_config = _from_pipeline_key("qwen3_tts")
     assert async_config.stage_by_id(0).custom_process_next_stage_input_func.endswith("talker2code2wav_async_chunk")
     assert async_config.stage_by_id(1).custom_process_input_func is None
 
-    sync_config = VllmOmniConfig.from_registry("qwen3_tts", cli_overrides={"async_chunk": False})
+    sync_config = _from_pipeline_key("qwen3_tts", cli_overrides={"async_chunk": False})
     assert sync_config.stage_by_id(0).custom_process_next_stage_input_func.endswith("talker2code2wav_full_payload")
     assert sync_config.stage_by_id(1).custom_process_input_func.endswith("talker2code2wav_token_only")
 
@@ -353,8 +444,10 @@ def test_vllm_omni_stage_config_public_fields_use_typed_stage_realizations():
     assert {f.name for f in fields(VllmOmniGenerationStageConfig)} == public_fields
 
 
-def test_runtime_config_fields_match_rfc_runtime_scope():
+def test_runtime_config_fields_match_structured_runtime_scope():
     assert {f.name for f in fields(OmniStageRuntimeConfig)} == {
+        "distributed_executor_backend",
+        "worker_cls",
         "devices",
         "num_replicas",
         "env",
@@ -365,9 +458,23 @@ def test_runtime_config_fields_match_rfc_runtime_scope():
     }
 
 
-def test_sub_config_fields_match_rfc_scopes():
+def test_sub_config_fields_match_structured_scopes():
     assert {f.name for f in fields(OmniStageModelConfig)} == {
+        "model",
+        "model_arch",
+        "revision",
+        "tokenizer_revision",
+        "code_revision",
+        "seed",
+        "logits_processors",
+        "trust_remote_code",
+        "dtype",
+        "attention_backend",
+        "moe_backend",
+        "hf_overrides",
+        "limit_mm_per_prompt",
         "active_stream_window",
+        "duplex_max_sessions",
         "enable_sleep_mode",
         "default_sampling_params",
         "subtalker_sampling_params",
@@ -376,19 +483,29 @@ def test_sub_config_fields_match_rfc_scopes():
         "task_type",
         "codec_frame_rate_hz",
         "enforce_eager",
+        "max_cudagraph_capture_size",
         "enable_flashinfer_autotune",
         "compilation_config",
         "enable_multithread_weight_load",
         "num_weight_load_threads",
         "disable_autocast",
+        # Per-stage checkpoint resolution for repos whose stages live in
+        # subfolders (e.g. Audex): mirrors StagePipelineConfig on the
+        # legacy engine-args path.
+        "model_subdir",
+        "tokenizer_subdir",
     }
     assert {f.name for f in fields(OmniStageLoadConfig)} == {
+        "tokenizer",
+        "download_dir",
+        "skip_tokenizer_init",
         "load_format",
         "tokenizer_mode",
         "config_format",
         "skip_mm_profiling",
     }
     assert {f.name for f in fields(OmniStageCacheConfig)} == {
+        "kv_cache_memory_bytes",
         "gpu_memory_utilization",
         "enable_prefix_caching",
         "disable_hybrid_kv_cache_manager",
@@ -402,6 +519,8 @@ def test_sub_config_fields_match_rfc_scopes():
         "async_scheduling",
     }
     assert {f.name for f in fields(OmniStageConnectorConfig)} == {
+        "async_chunk",
+        "omni_kv_config",
         "stage_connector",
         "output_connectors",
         "input_connectors",
@@ -420,9 +539,11 @@ def test_sub_config_fields_match_rfc_scopes():
         "sequence_parallel_size",
         "ulysses_degree",
         "ring_degree",
+        "allgather_degree",
         "ulysses_mode",
         "cfg_parallel_size",
         "vae_patch_parallel_size",
+        "text_encoder_tp_size",
         "vae_parallel_mode",
         "use_hsdp",
         "mask_sp_padding",
@@ -503,8 +624,8 @@ def test_diffusion_parallel_config_rejects_hsdp_with_tp_or_dp():
         OmniStageDiffusionParallelConfig(data_parallel_size=2, use_hsdp=True, hsdp_shard_size=2)
 
 
-def test_from_registry_preserves_legacy_pp_dp_for_world_size():
-    cfg = VllmOmniConfig.from_registry("hunyuan_image3_dit").stage_by_id(0).parallel_config
+def test_from_pipeline_config_preserves_legacy_pp_dp_for_world_size():
+    cfg = _from_pipeline_key("hunyuan_image3_dit").stage_by_id(0).parallel_config
 
     assert cfg.pipeline_parallel_size == 1
     assert cfg.data_parallel_size == 1
@@ -512,7 +633,7 @@ def test_from_registry_preserves_legacy_pp_dp_for_world_size():
     assert cfg.world_size == 4
 
 
-def test_from_registry_derives_sequence_parallel_size_from_degrees(tmp_path):
+def test_from_pipeline_config_derives_sequence_parallel_size_from_degrees(tmp_path):
     deploy_path = tmp_path / "dreamzero_derived_parallel.yaml"
     deploy_path.write_text(
         "\n".join(
@@ -529,23 +650,54 @@ def test_from_registry_derives_sequence_parallel_size_from_degrees(tmp_path):
         )
     )
 
-    stage = VllmOmniConfig.from_registry("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
+    stage = _from_pipeline_key("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
 
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
     assert stage.parallel_config.sequence_parallel_size == 6
     assert stage.parallel_config.world_size == 6
 
 
-def test_diffusion_parallel_config_rejects_cfg_parallel_size_outside_current_bound():
+def test_from_pipeline_config_derives_sequence_parallel_size_from_allgather_degree(tmp_path):
+    deploy_path = tmp_path / "dreamzero_allgather_parallel.yaml"
+    deploy_path.write_text(
+        "\n".join(
+            [
+                "pipeline: dreamzero",
+                "async_chunk: false",
+                "stages:",
+                "  - stage_id: 0",
+                "    parallel_config:",
+                "      sequence_parallel_size: 99",
+                "      allgather_degree: 2",
+            ]
+        )
+    )
+
+    stage = _from_pipeline_key("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
+
+    assert isinstance(stage, VllmOmniDiffusionStageConfig)
+    assert stage.parallel_config.allgather_degree == 2
+    assert stage.parallel_config.sequence_parallel_size == 2
+    assert stage.parallel_config.world_size == 2
+
+
+def test_diffusion_parallel_config_accepts_four_way_guidance_parallelism():
+    cfg = OmniStageDiffusionParallelConfig(cfg_parallel_size=4)
+
+    assert cfg.cfg_parallel_size == 4
+    assert cfg.world_size == 4
+
+
+def test_diffusion_parallel_config_rejects_allgather_with_ulysses_or_ring():
     with pytest.raises(ValidationError):
-        OmniStageDiffusionParallelConfig(cfg_parallel_size=4)
+        OmniStageDiffusionParallelConfig(allgather_degree=2, ulysses_degree=2)
 
 
 def test_stage_realizations_use_stage_specific_parallel_config_types():
-    qwen_config = VllmOmniConfig.from_registry("qwen3_tts")
+    qwen_config = _from_pipeline_key("qwen3_tts")
     ar_stage = qwen_config.stage_by_id(0)
     generation_stage = qwen_config.stage_by_id(1)
-    diffusion_stage = VllmOmniConfig.from_registry("hunyuan_image3_dit").stage_by_id(0)
+    diffusion_stage = _from_pipeline_key("hunyuan_image3_dit").stage_by_id(0)
 
     assert isinstance(ar_stage, VllmOmniARStageConfig)
     assert type(ar_stage.parallel_config) is OmniStageParallelConfig
@@ -566,7 +718,7 @@ def test_stage_realizations_use_stage_specific_parallel_config_types():
     assert diffusion_stage.parallel_config.ulysses_degree == 1
 
 
-def test_from_registry_preserves_diffusion_parallel_mask_sp_padding(tmp_path):
+def test_from_pipeline_config_preserves_diffusion_parallel_mask_sp_padding(tmp_path):
     deploy_path = tmp_path / "dreamzero_mask_sp_padding.yaml"
     deploy_path.write_text(
         "\n".join(
@@ -581,17 +733,58 @@ def test_from_registry_preserves_diffusion_parallel_mask_sp_padding(tmp_path):
         )
     )
 
-    stage = VllmOmniConfig.from_registry("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
+    stage = _from_pipeline_key("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
 
     assert isinstance(stage, VllmOmniDiffusionStageConfig)
     assert stage.parallel_config.mask_sp_padding is True
 
 
-def test_from_registry_matches_stage_config_to_omegaconf_behavior_for_representative_stage():
+def test_from_pipeline_config_routes_regional_compile_dynamic(tmp_path):
+    deploy_path = tmp_path / "dreamzero_compile.yaml"
+    deploy_path.write_text(
+        "\n".join(
+            [
+                "pipeline: dreamzero",
+                "async_chunk: false",
+                "stages:",
+                "  - stage_id: 0",
+                "    diffusion_compile_granularity: regional",
+                "    diffusion_compile_dynamic: false",
+            ]
+        )
+    )
+
+    configured_stage = _from_pipeline_key("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
+    overridden_stage = _from_pipeline_key(
+        "dreamzero",
+        deploy_config_path=str(deploy_path),
+        cli_overrides={
+            "diffusion_compile_granularity": "full",
+            "diffusion_compile_dynamic": True,
+        },
+    ).stage_by_id(0)
+
+    assert configured_stage.diffusion_config.diffusion_compile_granularity == "regional"
+    assert configured_stage.diffusion_config.diffusion_compile_dynamic is False
+    assert overridden_stage.diffusion_config.diffusion_compile_granularity == "full"
+    assert overridden_stage.diffusion_config.diffusion_compile_dynamic is True
+
+
+def test_structured_diffusion_config_rejects_non_boolean_compile_dynamic():
+    with pytest.raises(ValidationError, match="diffusion_compile_dynamic"):
+        omni_config_module._DiffusionConfigProjection(diffusion_compile_dynamic="false")
+
+
+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")
+
+
+def test_from_pipeline_config_matches_stage_config_to_omegaconf_behavior_for_representative_stage():
     pipeline = _resolve_pipeline_or_skip("qwen3_tts")
-    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy("qwen3_tts"))[0]
+    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy(pipeline))[0]
     omega_stage = legacy_stage.to_omegaconf()
-    omni_stage = VllmOmniConfig.from_registry("qwen3_tts").stage_by_id(legacy_stage.stage_id)
+    omni_stage = _from_pipeline_key("qwen3_tts").stage_by_id(legacy_stage.stage_id)
 
     assert omega_stage.stage_id == omni_stage.stage_id
     assert omega_stage.stage_type == omni_stage.stage_type.value
@@ -606,11 +799,93 @@ def test_from_registry_matches_stage_config_to_omegaconf_behavior_for_representa
     assert omega_stage.runtime.requires_multimodal_data == omni_stage.requires_multimodal_data
 
 
-def test_from_registry_matches_to_omegaconf_diffusion_parallel_config():
+def test_from_pipeline_config_uses_hf_config_for_callable_resolver():
+    hf_config = Qwen3OmniMoeConfig()
+    hf_config.enable_audio_output = False
+
+    omni_config = _from_pipeline_key("qwen3_omni_moe", hf_config=hf_config)
+
+    assert omni_config.pipeline_config.model_type == "qwen3_omni_moe_thinker_only"
+    assert len(omni_config.stage_configs) == 1
+    assert omni_config.orchestrator_config.deploy_config_path is None
+
+    thinker = omni_config.stage_configs[0]
+    assert thinker.model_stage == "thinker"
+    assert thinker.model_config.default_sampling_params == {"detokenize": True}
+
+
+def test_from_pipeline_config_accepts_pre_resolved_pipeline():
+    resolved_pipeline = PipelineConfig(model_type="callable_resolved_variant")
+
+    omni_config = VllmOmniConfig.from_pipeline_config(resolved_pipeline)
+
+    assert omni_config.pipeline_config is resolved_pipeline
+
+
+def test_from_pipeline_config_prefers_loaded_user_deploy_config(monkeypatch):
+    pipeline = _resolve_pipeline_or_skip("qwen3_tts")
+    user_deploy_config = DeployConfig(
+        stages=[StageDeployConfig(stage_id=0, max_num_seqs=7)],
+    )
+    monkeypatch.setattr(
+        omni_config_module,
+        "load_deploy_config",
+        lambda _path: pytest.fail("default deploy config should not be loaded"),
+    )
+
+    omni_config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=user_deploy_config,
+    )
+
+    assert omni_config.stage_by_id(0).scheduler_config.max_num_seqs == 7
+
+
+def test_from_pipeline_config_default_deploy_name_ignores_cwd(monkeypatch, tmp_path):
+    default_name = "pipeline_default.yaml"
+    (tmp_path / default_name).write_text("stages: []\n", encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    pipeline = PipelineConfig(
+        model_type="pipeline_with_default",
+        default_deploy_config_name=default_name,
+    )
+    loaded_paths = []
+
+    def _load_deploy_config(path):
+        loaded_paths.append(Path(path))
+        return DeployConfig()
+
+    monkeypatch.setattr(omni_config_module, "load_deploy_config", _load_deploy_config)
+
+    omni_config = VllmOmniConfig.from_pipeline_config(pipeline)
+
+    assert omni_config.orchestrator_config.deploy_config_path == str(_DEPLOY_DIR / default_name)
+    assert loaded_paths == [_DEPLOY_DIR / default_name]
+
+
+def test_from_pipeline_config_uses_resolved_deploy_pipeline():
+    deploy_path = get_deploy_config_path("aura_omni.yaml")
+    pipeline = _resolve_pipeline_or_skip("aura_omni")
+
+    omni_config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        deploy_config_path=str(deploy_path),
+    )
+
+    assert omni_config.pipeline_config.model_type == "aura_omni"
+    assert [stage.model_stage for stage in omni_config.stage_configs] == [
+        "asr",
+        "aura",
+        "qwen3_tts",
+        "code2wav",
+    ]
+
+
+def test_from_pipeline_config_matches_to_omegaconf_diffusion_parallel_config():
     pipeline = _resolve_pipeline_or_skip("hunyuan_image3_dit")
-    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy("hunyuan_image3_dit"))[0]
+    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy(pipeline))[0]
     omega_stage = legacy_stage.to_omegaconf()
-    omni_stage = VllmOmniConfig.from_registry("hunyuan_image3_dit").stage_by_id(legacy_stage.stage_id)
+    omni_stage = _from_pipeline_key("hunyuan_image3_dit").stage_by_id(legacy_stage.stage_id)
 
     assert (
         omega_stage.engine_args.parallel_config.pipeline_parallel_size
@@ -631,19 +906,19 @@ def test_from_registry_matches_to_omegaconf_diffusion_parallel_config():
     )
 
 
-def test_from_registry_matches_build_engine_args_dict_behavior_for_representative_stage(monkeypatch):
+def test_from_pipeline_config_matches_build_engine_args_dict_behavior_for_representative_stage(monkeypatch):
     from vllm_omni.engine import stage_init_utils
 
     monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", lambda engine_args: None)
     pipeline = _resolve_pipeline_or_skip("qwen3_tts")
-    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy("qwen3_tts"))[0]
+    legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy(pipeline))[0]
     omega_stage = legacy_stage.to_omegaconf()
-    legacy_engine_args = build_engine_args_dict(
+    legacy_engine_args = build_legacy_engine_args_dict(
         omega_stage,
         model="/tmp/qwen3-tts",
         stage_connector_spec={"name": "SharedMemoryConnector", "extra": {}},
     )
-    omni_stage = VllmOmniConfig.from_registry("qwen3_tts").stage_by_id(legacy_stage.stage_id)
+    omni_stage = _from_pipeline_key("qwen3_tts").stage_by_id(legacy_stage.stage_id)
 
     assert legacy_engine_args["model"] == "/tmp/qwen3-tts"
     assert legacy_engine_args["stage_id"] == omni_stage.stage_id
@@ -657,8 +932,8 @@ def test_from_registry_matches_build_engine_args_dict_behavior_for_representativ
     assert omni_stage.model_config.has_sampling_extra_args == legacy_engine_args["has_sampling_extra_args"]
 
 
-def test_from_registry_derives_has_sampling_extra_args_from_stage_defaults():
-    stage = VllmOmniConfig.from_registry("voxtral_tts").stage_by_id(0)
+def test_from_pipeline_config_derives_has_sampling_extra_args_from_stage_defaults():
+    stage = _from_pipeline_key("voxtral_tts").stage_by_id(0)
 
     assert (stage.model_config.default_sampling_params or {}).get("extra_args")
     assert stage.model_config.has_sampling_extra_args is True
@@ -709,7 +984,7 @@ def test_diffusion_config_from_kwargs_reuses_legacy_normalization(monkeypatch):
     assert cfg.diffusers_call_kwargs == {}
 
 
-def test_from_registry_normalizes_diffusion_config_aliases_from_engine_args(tmp_path):
+def test_from_pipeline_config_normalizes_diffusion_config_aliases_from_engine_args(tmp_path):
     deploy_path = tmp_path / "dreamzero_diffusion_aliases.yaml"
     deploy_path.write_text(
         "\n".join(
@@ -723,7 +998,7 @@ def test_from_registry_normalizes_diffusion_config_aliases_from_engine_args(tmp_
         )
     )
 
-    stage = VllmOmniConfig.from_registry(
+    stage = _from_pipeline_key(
         "dreamzero",
         deploy_config_path=str(deploy_path),
     ).stage_by_id(0)
@@ -733,6 +1008,8 @@ def test_from_registry_normalizes_diffusion_config_aliases_from_engine_args(tmp_
 
 
 def test_diffusion_config_field_classification_covers_current_fields():
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+
     classified_fields = (
         omni_config_module._DIFFUSION_SHARED_CONFIG_FIELDS
         | omni_config_module._DIFFUSION_RUNTIME_CONFIG_FIELDS
@@ -740,8 +1017,12 @@ def test_diffusion_config_field_classification_covers_current_fields():
     )
 
     assert classified_fields == {f.name for f in fields(omni_config_module._DiffusionConfigProjection)}
+    assert {f.name for f in fields(OmniDiffusionConfig)} <= (
+        classified_fields | omni_config_module._DIFFUSION_MOVED_SHARED_FIELDS
+    )
     assert {
         "enable_prompt_embed_cache",
+        "enable_session_state_manager",
         "prompt_embed_cache_size",
         "diffusion_kv_cache_dtype",
     } <= omni_config_module._DIFFUSION_ONLY_CONFIG_FIELDS
diff --git a/tests/conftest.py b/tests/conftest.py
index 11619b782..b453bbcbf 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -3,6 +3,7 @@ Root pytest entrypoint for the vLLM-Omni test suite.
 
 - `tests/conftest.py` stays thin: plugin registration + compatibility re-exports.
 - Importable utilities live under `tests/helpers/`.
+- Helper unit tests live under `tests/helpers/tests/`.
 - Fixtures live under `tests/helpers/fixtures/` and are loaded via `pytest_plugins`.
 """
 
diff --git a/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py b/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py
new file mode 100644
index 000000000..73c71fd63
--- /dev/null
+++ b/tests/core/sched/test_omni_ar_scheduler_free_request_cleanup.py
@@ -0,0 +1,74 @@
+"""Regression tests for vllm-project/vllm-omni#5349 (P1): normal completion
+goes through _free_request(), not finish_requests() (the external
+abort/cancel entry point). Without a cleanup_receiver() call there,
+_active_streams never releases on ordinary completion, so the bounded-K
+window fills with stale entries after K completions.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+# Imports must run in this order: vllm_omni applies patches to vllm.v1.request before
+# Request / RequestStatus are bound in this module. Ruff isort would reorder them.
+# isort: off
+import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
+from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
+
+# isort: on
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_scheduler(*, chunk_transfer_adapter=None) -> OmniARScheduler:
+    """Minimal OmniARScheduler exercising _free_request()'s no-KV-transfer
+    happy path."""
+    sched = OmniARScheduler.__new__(OmniARScheduler)
+    sched._omits_kv_transfer_cache = {}
+    sched._connector_finished = lambda request: (False, None)
+    sched.encoder_cache_manager = MagicMock()
+    sched.finished_req_ids = set()
+    sched._new_prompt_len_snapshot = {}
+    sched.finished_req_ids_dict = None
+    sched._should_transfer_kv_for_request = lambda req_id: False
+    sched._free_blocks = MagicMock()
+    sched._free_input_coordinator_request = MagicMock()
+    sched.chunk_transfer_adapter = chunk_transfer_adapter
+    return sched
+
+
+class _FakeFinishedRequest:
+    """Not a SimpleNamespace: SimpleNamespace defines __eq__, which makes it
+    unhashable, and _free_request() puts the request in a set."""
+
+    def __init__(self, request_id: str) -> None:
+        self.request_id = request_id
+
+    def is_finished(self) -> bool:
+        return True
+
+
+def _make_finished_request(request_id: str = "req-1"):
+    return _FakeFinishedRequest(request_id)
+
+
+def test_free_request_releases_chunk_transfer_adapter_receiver_state():
+    adapter = MagicMock()
+    sched = _make_scheduler(chunk_transfer_adapter=adapter)
+    request = _make_finished_request("req-1")
+
+    sched._free_request(request)
+
+    adapter.cleanup_receiver.assert_called_once_with("req-1")
+
+
+def test_free_request_is_safe_without_a_chunk_transfer_adapter():
+    """Most stages have no chunk transfer adapter configured."""
+    sched = _make_scheduler(chunk_transfer_adapter=None)
+    request = _make_finished_request("req-1")
+
+    sched._free_request(request)  # must not raise
+
+    sched._free_input_coordinator_request.assert_called_once_with("req-1")
diff --git a/tests/core/sched/test_omni_ar_scheduler_kv_transfer.py b/tests/core/sched/test_omni_ar_scheduler_kv_transfer.py
new file mode 100644
index 000000000..cffe3f289
--- /dev/null
+++ b/tests/core/sched/test_omni_ar_scheduler_kv_transfer.py
@@ -0,0 +1,57 @@
+from types import SimpleNamespace
+
+import pytest
+from vllm import SamplingParams
+from vllm.v1.engine import EngineCoreRequest
+
+from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
+from vllm_omni.engine.async_engine_utils import apply_omni_final_stage_metadata
+from vllm_omni.engine.serialization import deserialize_additional_information
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_engine_request() -> EngineCoreRequest:
+    return EngineCoreRequest(
+        request_id="req",
+        prompt_token_ids=[1],
+        mm_features=None,
+        sampling_params=SamplingParams(max_tokens=1),
+        pooling_params=None,
+        arrival_time=0.0,
+        lora_request=None,
+        cache_salt=None,
+        data_parallel_rank=None,
+    )
+
+
+def _request_omits_kv_transfer(*, force_kv_transfer: bool) -> tuple[bool, dict]:
+    tagged = apply_omni_final_stage_metadata(
+        _make_engine_request(),
+        final_stage_id=0,
+        force_kv_transfer=force_kv_transfer,
+    )
+    scheduler = OmniARScheduler.__new__(OmniARScheduler)
+    scheduler._omits_kv_transfer_cache = {}
+    request = SimpleNamespace(
+        request_id="req",
+        additional_information=tagged.additional_information,
+    )
+    result = scheduler._request_omits_kv_transfer_to_next_stage(request)
+    metadata = deserialize_additional_information(tagged.additional_information)
+    return result, metadata
+
+
+def test_stage_zero_request_omits_kv_transfer():
+    omits_transfer, metadata = _request_omits_kv_transfer(force_kv_transfer=False)
+
+    assert omits_transfer
+    assert "omni_force_kv_transfer" not in metadata
+
+
+def test_cfg_companion_forces_kv_transfer_without_downstream_payload():
+    omits_transfer, metadata = _request_omits_kv_transfer(force_kv_transfer=True)
+
+    assert not omits_transfer
+    assert metadata["omni_final_stage_id"] == 0
+    assert metadata["omni_force_kv_transfer"] is True
diff --git a/tests/core/sched/test_omni_ar_scheduler_logprobs.py b/tests/core/sched/test_omni_ar_scheduler_logprobs.py
new file mode 100644
index 000000000..b8dc2ee9e
--- /dev/null
+++ b/tests/core/sched/test_omni_ar_scheduler_logprobs.py
@@ -0,0 +1,266 @@
+"""Tests for the AR sampled-token logprob contract."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable
+from types import MethodType, SimpleNamespace
+
+import numpy as np
+import pytest
+from vllm.v1.engine import FinishReason
+from vllm.v1.outputs import LogprobsLists
+from vllm.v1.request import RequestStatus
+
+from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler, _slice_sampled_logprobs
+from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Shared update_from_output helpers moved onto OmniSchedulerMixin; bind them on
+# the lightweight stub so direct method calls still exercise the real paths.
+_MIXIN_UPDATE_HELPERS = (
+    "_remove_stopped_requests_from_queues",
+    "_handle_failed_kv_load_outputs",
+    "_aggregate_kv_connector_stats",
+    "_publish_kv_cache_events",
+    "_attach_finished_request_sets",
+    "_attach_scheduler_stats",
+    "_capture_omni_connector_output",
+)
+
+
+def _logprobs(
+    token_ids: list[list[int]],
+    values: list[list[float]],
+    *,
+    cumulative_rows: list[int] | None = None,
+) -> LogprobsLists:
+    return LogprobsLists(
+        logprob_token_ids=np.asarray(token_ids, dtype=np.int32),
+        logprobs=np.asarray(values, dtype=np.float32),
+        sampled_token_ranks=np.zeros(len(token_ids), dtype=np.int32),
+        cu_num_generated_tokens=cumulative_rows,
+    )
+
+
+def test_slices_requested_rows_and_preserves_sampled_token_values() -> None:
+    all_logprobs = _logprobs(
+        [[3, 8], [4, 9], [11, 2], [12, 1]],
+        [[-0.3, -1.0], [-0.4, -1.1], [-0.11, -2.0], [-0.12, -2.1]],
+        cumulative_rows=[0, 2],
+    )
+
+    sliced = _slice_sampled_logprobs(all_logprobs, req_index=1, sampled_token_ids=[11, 12])
+
+    np.testing.assert_array_equal(sliced.logprob_token_ids[:, 0], [11, 12])
+    np.testing.assert_allclose(sliced.logprobs[:, 0], [-0.11, -0.12])
+
+
+def test_rejects_missing_logprobs() -> None:
+    with pytest.raises(RuntimeError, match="model runner returned none"):
+        _slice_sampled_logprobs(None, req_index=0, sampled_token_ids=[7])
+
+
+def test_rejects_row_count_mismatch() -> None:
+    logprobs = _logprobs([[7, 1]], [[-0.7, -1.0]])
+
+    with pytest.raises(RuntimeError, match="row count does not match"):
+        _slice_sampled_logprobs(logprobs, req_index=0, sampled_token_ids=[7, 8])
+
+
+def test_rejects_sampled_token_mismatch() -> None:
+    logprobs = _logprobs([[9, 7]], [[-0.9, -1.0]])
+
+    with pytest.raises(RuntimeError, match="generated_token=7 logprob_token=9"):
+        _slice_sampled_logprobs(logprobs, req_index=0, sampled_token_ids=[7])
+
+
+def test_rejects_non_finite_sampled_logprob() -> None:
+    logprobs = _logprobs([[7, 1]], [[float("nan"), -1.0]])
+
+    with pytest.raises(RuntimeError, match="non-finite values at rows \\[0\\]"):
+        _slice_sampled_logprobs(logprobs, req_index=0, sampled_token_ids=[7])
+
+
+class _Request:
+    def __init__(self, request_id: str) -> None:
+        self.request_id = request_id
+        self.client_index = 0
+        self.status = RequestStatus.RUNNING
+        self.sampling_params = SimpleNamespace(num_logprobs=1)
+        self.num_computed_tokens = 0
+        self.num_in_flight_tokens = 0
+        self.num_output_placeholders = 0
+        self.has_encoder_inputs = False
+        self.pooling_params = None
+        self.resumable = True
+        self.stop_reason = None
+        self.trace_headers = None
+        self.num_nans_in_logits = 0
+
+    def is_finished(self) -> bool:
+        return RequestStatus.is_finished(self.status)
+
+    def get_finished_reason(self):
+        return RequestStatus.get_finished_reason(self.status)
+
+    def take_events(self):
+        return None
+
+    def take_prefill_stats(self):
+        return None
+
+
+class _RequestQueue(list):
+    def remove_requests(self, requests) -> None:
+        for request in requests:
+            if request in self:
+                self.remove(request)
+
+
+def _make_scheduler_stub(requests: list[_Request]) -> SimpleNamespace:
+    """Build a minimal stub for OmniARScheduler.update_from_output()."""
+    scheduler = SimpleNamespace(
+        perf_metrics=None,
+        connector=None,
+        chunk_transfer_adapter=None,
+        requests={request.request_id: request for request in requests},
+        running=list(requests),
+        waiting=_RequestQueue(),
+        skipped_waiting=_RequestQueue(),
+        structured_output_manager=SimpleNamespace(should_advance=lambda _request: False),
+        transfer_triggered_requests=set(),
+        active_kv_transfers=set(),
+        pending_stop_after_extraction=set(),
+        waiting_for_transfer_free=set(),
+        _new_prompt_len_snapshot={},
+        finished_req_ids=set(),
+        finished_req_ids_dict=defaultdict(set),
+        kv_cache_manager=SimpleNamespace(take_events=lambda: None),
+        kv_event_publisher=SimpleNamespace(publish=lambda _events: None),
+        recompute_kv_load_failures=False,
+    )
+    for name in _MIXIN_UPDATE_HELPERS:
+        setattr(scheduler, name, MethodType(getattr(OmniSchedulerMixin, name), scheduler))
+    scheduler._cleanup_kv_tracking = MethodType(OmniARScheduler._cleanup_kv_tracking, scheduler)
+    scheduler.make_spec_decoding_stats = lambda *args, **kwargs: None
+    scheduler.make_stats = lambda *args, **kwargs: None
+    return scheduler
+
+
+def _bind_request_lifecycle(
+    scheduler: SimpleNamespace,
+    *,
+    update_request: Callable,
+    handle_stopped: Callable | None = None,
+) -> None:
+    def free_request(request):
+        scheduler.requests.pop(request.request_id, None)
+        scheduler.finished_req_ids.add(request.request_id)
+        scheduler.finished_req_ids_dict[request.client_index].add(request.request_id)
+        # vLLM 0.26 contract: (kv_xfer_params, ec_xfer_params)
+        return None, None
+
+    scheduler._update_request_with_output = update_request
+    scheduler._process_kv_transfer_trigger = lambda _request, _tokens: False
+    scheduler._handle_stopped_request = handle_stopped or (lambda _request: True)
+    scheduler._free_request = free_request
+
+
+def test_mid_step_stop_trims_logprob_rows_with_token_ids() -> None:
+    """Spec decode can sample tokens past a stop; the trailing tokens are
+    trimmed by _update_request_with_output, and the emitted logprob rows must
+    be trimmed with them (upstream slices logprobs after the trim)."""
+    request = _Request("req")
+    request.num_computed_tokens = 8
+    scheduler = _make_scheduler_stub([request])
+
+    def update_request_trimming(req, token_ids):
+        # Mirror vllm Scheduler._update_request_with_output: the first sampled
+        # token hits EOS, so the spec-accepted tokens behind it are trimmed
+        # in place and the request stops.
+        del token_ids[1:]
+        req.status = RequestStatus.FINISHED_STOPPED
+        return token_ids, True
+
+    _bind_request_lifecycle(scheduler, update_request=update_request_trimming)
+
+    scheduler_output = SimpleNamespace(
+        num_scheduled_tokens={"req": 3},
+        scheduled_spec_decode_tokens={"req": [8, 9]},
+        num_invalid_spec_tokens=0,
+    )
+    model_runner_output = SimpleNamespace(
+        sampled_token_ids=[[7, 8, 9]],
+        logprobs=_logprobs(
+            [[7, 1], [8, 2], [9, 3]],
+            [[-0.7, -1.0], [-0.8, -1.1], [-0.9, -1.2]],
+            cumulative_rows=[0],
+        ),
+        prompt_logprobs_dict={},
+        pooler_output=None,
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        cudagraph_stats=None,
+        req_id_to_index={"req": 0},
+        routed_experts=None,
+    )
+
+    outputs = OmniARScheduler.update_from_output(scheduler, scheduler_output, model_runner_output)
+    (output,) = outputs[0].outputs
+
+    assert output.new_token_ids == [7]
+    assert output.finish_reason is FinishReason.STOP
+    token_rows = np.asarray(output.new_logprobs.logprob_token_ids)
+    value_rows = np.asarray(output.new_logprobs.logprobs)
+    assert token_rows.shape[0] == len(output.new_token_ids)
+    assert value_rows.shape[0] == len(output.new_token_ids)
+    np.testing.assert_array_equal(token_rows[:, 0], [7])
+
+
+def test_invalid_logprobs_finish_only_the_affected_scheduler_request() -> None:
+    """A bad runner response must not bring down unrelated batch requests."""
+    bad = _Request("bad")
+    good = _Request("good")
+    scheduler = _make_scheduler_stub([bad, good])
+    update_calls: list[str] = []
+
+    def update_request(request, token_ids):
+        update_calls.append(request.request_id)
+        return token_ids, False
+
+    _bind_request_lifecycle(scheduler, update_request=update_request)
+
+    scheduler_output = SimpleNamespace(
+        num_scheduled_tokens={"bad": 1, "good": 1},
+        scheduled_spec_decode_tokens={},
+        num_invalid_spec_tokens=0,
+    )
+    model_runner_output = SimpleNamespace(
+        sampled_token_ids=[[7], [8]],
+        logprobs=_logprobs(
+            [[9, 1], [8, 2]],
+            [[-0.9, -1.0], [-0.8, -1.0]],
+            cumulative_rows=[0, 1],
+        ),
+        prompt_logprobs_dict={},
+        pooler_output=None,
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        cudagraph_stats=None,
+        req_id_to_index={"bad": 0, "good": 1},
+        routed_experts=None,
+    )
+
+    outputs = OmniARScheduler.update_from_output(scheduler, scheduler_output, model_runner_output)
+    output_by_id = {output.request_id: output for output in outputs[0].outputs}
+
+    assert update_calls == ["good"]
+    assert bad.status is RequestStatus.FINISHED_ERROR
+    assert bad.stop_reason is not None and "misaligned" in bad.stop_reason
+    assert "bad" not in scheduler.requests
+    assert output_by_id["bad"].finish_reason is FinishReason.ERROR
+    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])
diff --git a/tests/core/sched/test_omni_ar_scheduler_streaming.py b/tests/core/sched/test_omni_ar_scheduler_streaming.py
index 41fb414cb..ca80323a7 100644
--- a/tests/core/sched/test_omni_ar_scheduler_streaming.py
+++ b/tests/core/sched/test_omni_ar_scheduler_streaming.py
@@ -1,8 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
 """Unit tests for Omni AR streaming-session async placeholder handling."""
 
 from __future__ import annotations
 
 from types import SimpleNamespace
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -11,6 +15,8 @@ import pytest
 # 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
 
@@ -26,6 +32,7 @@ def _make_scheduler(*, stage_id: int = 0) -> OmniARScheduler:
     sched.num_waiting_for_streaming_input = 0
     sched.log_stats = False
     sched.chunk_transfer_adapter = None
+    sched.skipped_waiting = set()
     return sched
 
 
@@ -50,6 +57,156 @@ def _make_update(prompt_token_ids: list[int] | None = None) -> StreamingUpdate:
     )
 
 
+def _run_resumable_segment_stop(
+    session: Request,
+    *,
+    session_finished: bool = False,
+):
+    sched = MagicMock()
+    sched.requests = {session.request_id: session}
+    sched.perf_metrics = None
+    sched.structured_output_manager.should_advance.return_value = False
+
+    def stop_request(request: Request, _token_ids: list[int]):
+        request.status = RequestStatus.FINISHED_STOPPED
+        return [42], True
+
+    sched._update_request_with_output.side_effect = stop_request
+    sched._handle_stopped_request.return_value = session_finished
+    # vLLM 0.26 returns (kv_xfer_params, ec_xfer_params); an unconfigured
+    # MagicMock iterates empty and fails to unpack at the call site.
+    sched._free_request.return_value = (None, None)
+    sched.chunk_transfer_adapter = None
+    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
+
+    scheduler_output = MagicMock(spec=SchedulerOutput)
+    scheduler_output.num_scheduled_tokens = {session.request_id: 1}
+    scheduler_output.scheduled_spec_decode_tokens = {}
+    scheduler_output.num_invalid_spec_tokens = 0
+
+    model_runner_output = MagicMock(spec=ModelRunnerOutput)
+    model_runner_output.sampled_token_ids = [[42]]
+    model_runner_output.logprobs = None
+    model_runner_output.prompt_logprobs_dict = {}
+    model_runner_output.pooler_output = None
+    model_runner_output.num_nans_in_logits = None
+    model_runner_output.kv_connector_output = None
+    model_runner_output.cudagraph_stats = None
+    model_runner_output.req_id_to_index = {session.request_id: 0}
+    model_runner_output.routed_experts = None
+
+    return OmniARScheduler.update_from_output(sched, scheduler_output, model_runner_output)
+
+
+@pytest.mark.parametrize("outstanding_async_tokens", [0, 1, 2])
+def test_resumable_segment_stop_reconciles_async_placeholders(
+    outstanding_async_tokens: int,
+) -> None:
+    """A segment stop discards and rolls back only in-flight async tokens."""
+    session = _make_request()
+    session.status = RequestStatus.RUNNING
+    session.resumable = True
+    session.append_output_token_ids([7, 8])
+    session.num_computed_tokens = session.num_tokens + outstanding_async_tokens
+    session.num_output_placeholders = outstanding_async_tokens
+    session.spec_token_ids = [-1] * outstanding_async_tokens
+
+    _run_resumable_segment_stop(session)
+
+    assert session.async_tokens_to_discard == outstanding_async_tokens
+    assert session.num_computed_tokens == session.num_tokens
+    assert session.num_output_placeholders == 0
+    assert session.spec_token_ids == []
+    assert session._output_token_ids == []
+
+
+def test_resumable_session_terminal_is_not_marked_as_segment_boundary() -> None:
+    session = _make_request()
+    session.status = RequestStatus.RUNNING
+    session.resumable = True
+
+    outputs = _run_resumable_segment_stop(session, session_finished=True)
+
+    output = outputs[session.client_index].outputs[0]
+    assert output.finish_reason is not None
+    assert output.is_segment_finished is False
+
+
+def test_update_from_output_settles_in_flight_tokens() -> None:
+    """vLLM 0.26: schedule() increments num_in_flight_tokens per scheduled
+    token; update_from_output must decrement it symmetrically. If the
+    decrement is dropped the counter grows monotonically and both readers
+    (allocate_slots, _connector_finished) clamp
+    max(0, num_computed_tokens - num_in_flight_tokens) to zero forever,
+    silently freezing sliding-window block freeing.
+    """
+    session = _make_request()
+    session.status = RequestStatus.RUNNING
+    session.num_in_flight_tokens = 1  # as left by schedule() for this step
+
+    _run_resumable_segment_stop(session)
+
+    assert session.num_in_flight_tokens == 0
+
+
+def test_running_decode_step_without_inter_stage_payload_does_not_raise() -> None:
+    """A decode step that neither stops nor carries an inter-stage payload.
+
+    ``finished`` is only assigned when the request stops, yet the async-chunk
+    save condition reads it for every request, so this step used to raise
+    ``UnboundLocalError: cannot access local variable 'finished'``.
+    """
+    session = _make_request()
+    session.status = RequestStatus.RUNNING
+
+    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
+
+    scheduler_output = MagicMock(spec=SchedulerOutput)
+    scheduler_output.num_scheduled_tokens = {session.request_id: 1}
+    scheduler_output.scheduled_spec_decode_tokens = {}
+    scheduler_output.num_invalid_spec_tokens = 0
+
+    model_runner_output = MagicMock(spec=ModelRunnerOutput)
+    model_runner_output.sampled_token_ids = [[42]]
+    model_runner_output.logprobs = None
+    model_runner_output.prompt_logprobs_dict = {}
+    model_runner_output.pooler_output = None
+    model_runner_output.num_nans_in_logits = None
+    model_runner_output.kv_connector_output = None
+    model_runner_output.cudagraph_stats = None
+    model_runner_output.req_id_to_index = {session.request_id: 0}
+    model_runner_output.routed_experts = None
+    model_runner_output.inter_stage_outputs = None
+
+    OmniARScheduler.update_from_output(sched, scheduler_output, model_runner_output)
+
+    # Nothing to hand downstream: no payload, no segment boundary, not finished.
+    sched.chunk_transfer_adapter.save_async.assert_not_called()
+
+
 def test_stage0_streaming_update_discards_outstanding_async_placeholder_token() -> None:
     sched = _make_scheduler(stage_id=0)
     session = _make_request()
@@ -90,3 +247,67 @@ def test_stage0_streaming_update_keeps_all_computed_tokens_without_placeholder()
     assert session._output_token_ids == []
     assert session.num_prompt_tokens == 8
     assert sched._new_prompt_len_snapshot[session.request_id] == 2
+
+
+def test_explicit_streaming_payload_replaces_placeholder_prompt() -> None:
+    sched = _make_scheduler(stage_id=1)
+    sched.chunk_transfer_adapter = SimpleNamespace(
+        receives_chunks=False,
+        segment_finished_requests=set(),
+    )
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    update = _make_update([10, 20])
+    update.additional_information = {
+        "tts_token_ids": [10, 20],
+        "meta": {"replace_streaming_prompt": True},
+    }
+    update.model_intermediate_buffer = {
+        "ids": {"tts": [41, 42, 99]},
+        "meta": {"turn_eos_token_id": 99},
+    }
+
+    sched._update_request_as_session(session, update)
+
+    assert session.prompt_token_ids == [10, 20]
+    assert session.additional_information == update.additional_information
+    assert session.model_intermediate_buffer == {
+        "ids": {"tts": [41, 42, 99]},
+        "meta": {"turn_eos_token_id": 99},
+    }
+    assert session.status == RequestStatus.WAITING
+
+
+def test_model_intermediate_streaming_payload_replaces_computed_prompt() -> None:
+    sched = _make_scheduler(stage_id=1)
+    sched.chunk_transfer_adapter = SimpleNamespace(
+        receives_chunks=False,
+        segment_finished_requests=set(),
+    )
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    session.prompt_token_ids = [0] * 59
+    session._all_token_ids.clear()
+    session._all_token_ids.extend(session.prompt_token_ids)
+    session.num_prompt_tokens = 59
+    session.num_computed_tokens = 59
+    update = _make_update([0] * 10)
+    update.additional_information = None
+    update.model_intermediate_buffer = {
+        "ids": {"tts": list(range(8))},
+        "hidden_states": {"tts": [[0.0]] * 8},
+        "meta": {
+            "replace_streaming_prompt": True,
+            "next_stage_prompt_len": 10,
+        },
+    }
+
+    sched._update_request_as_session(session, update)
+
+    assert session.prompt_token_ids == [0] * 10
+    assert list(session._all_token_ids) == [0] * 10
+    assert session.num_prompt_tokens == 10
+    assert session.num_computed_tokens == 0
+    assert session.additional_information is None
+    assert session.model_intermediate_buffer == update.model_intermediate_buffer
+    assert session.status == RequestStatus.WAITING
diff --git a/tests/core/sched/test_omni_generation_scheduler_update_session.py b/tests/core/sched/test_omni_generation_scheduler_update_session.py
index d94996014..0f654715a 100644
--- a/tests/core/sched/test_omni_generation_scheduler_update_session.py
+++ b/tests/core/sched/test_omni_generation_scheduler_update_session.py
@@ -9,6 +9,8 @@ update payloads early.
 from __future__ import annotations
 
 from dataclasses import replace
+from types import SimpleNamespace
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -17,7 +19,10 @@ import pytest
 # 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.engine import EngineCoreEventType
+from vllm.v1.metrics.stats import PrefillStats
+from vllm.v1.outputs import ModelRunnerOutput
 from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
@@ -50,6 +55,18 @@ class _SchedulerStub(OmniGenerationScheduler):
         raise AssertionError("unexpected enqueue for skipped_waiting miss")
 
 
+class _AsyncChunkStopSchedulerStub(OmniGenerationScheduler):
+    def __init__(self) -> None:
+        self.num_waiting_for_streaming_input = 0
+        self.chunk_transfer_adapter = SimpleNamespace(receives_chunks=True)
+        self.enqueued: list[Request] = []
+        self.enqueued_statuses: list[RequestStatus] = []
+
+    def _enqueue_waiting_request(self, session: Request) -> None:
+        self.enqueued.append(session)
+        self.enqueued_statuses.append(session.status)
+
+
 def _make_request(**kwargs) -> Request:
     sp = SamplingParams(max_tokens=8)
     defaults = dict(
@@ -77,6 +94,97 @@ def _make_update(**kwargs) -> StreamingUpdate:
     return StreamingUpdate(**defaults)
 
 
+def test_generation_scheduler_records_prefill_stats_for_metrics() -> None:
+    request = _make_request(prompt_token_ids=[1, 2, 3, 4])
+    request.prefill_stats = PrefillStats()
+
+    OmniGenerationScheduler._record_prefill_stats(request)
+
+    assert request.prefill_stats.num_prompt_tokens == 4
+    assert request.prefill_stats.num_computed_tokens == 4
+    assert request.prefill_stats.num_cached_tokens == 0
+
+
+def test_resumable_generation_stop_marks_segment_boundary() -> None:
+    session = _make_request(request_id="req-generation-segment")
+    session.status = RequestStatus.RUNNING
+    session.resumable = True
+    session.num_computed_tokens = len(session.prompt_token_ids)
+    # schedule() has counted this step's token as in flight; update_from_output()
+    # must settle it before handling the segment boundary.
+    session.num_in_flight_tokens = 1
+
+    sched = MagicMock()
+    sched.requests = {session.request_id: session}
+    sched.perf_metrics = None
+    sched.chunk_transfer_adapter = SimpleNamespace(
+        is_done_receiving_chunks=lambda _request_id: True,
+        segment_finished_requests={session.request_id},
+    )
+
+    def rearm_resumable_request(request: Request) -> bool:
+        request.status = RequestStatus.WAITING
+        return False
+
+    sched._handle_stopped_request.side_effect = rearm_resumable_request
+    sched.running = [session]
+    sched.waiting = MagicMock()
+    sched.skipped_waiting = MagicMock()
+    sched.structured_output_manager.should_advance.return_value = False
+    # Async scheduling can observe the segment boundary in the next schedule()
+    # before this model output is applied and defer the same request for finish.
+    # update_from_output() must not re-arm the resumable request twice.
+    sched._pending_finish_reqs = [session]
+    sched.recompute_kv_load_failures = False
+    sched.connector = None
+    sched.kv_cache_manager.take_events.return_value = None
+    sched.finished_req_ids_dict = {}
+    sched.make_stats.return_value = None
+
+    scheduler_output = MagicMock(spec=SchedulerOutput)
+    scheduler_output.num_scheduled_tokens = {session.request_id: 1}
+    scheduler_output.scheduled_spec_decode_tokens = {}
+    scheduler_output.num_invalid_spec_tokens = 0
+
+    model_runner_output = MagicMock(spec=ModelRunnerOutput)
+    model_runner_output.sampled_token_ids = [[]]
+    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
+
+    outputs = OmniGenerationScheduler.update_from_output(
+        sched,
+        scheduler_output,
+        model_runner_output,
+    )
+
+    output = outputs[session.client_index].outputs[0]
+    assert output.finish_reason is not None
+    assert output.is_segment_finished is True
+    sched._handle_stopped_request.assert_called_once_with(session)
+    assert sched._pending_finish_reqs == []
+
+
+def test_async_chunk_resumable_stop_rearms_connector_polling() -> None:
+    sched = _AsyncChunkStopSchedulerStub()
+    session = _make_request(request_id="req-async-chunk-next-segment")
+    session.status = RequestStatus.FINISHED_STOPPED
+    session.resumable = True
+
+    finished = sched._handle_stopped_request(session)
+
+    assert finished is False
+    assert sched.enqueued == [session]
+    assert sched.enqueued_statuses == [RequestStatus.WAITING]
+    assert session.status == RequestStatus.WAITING
+    assert sched.num_waiting_for_streaming_input == 0
+
+
 class TestReplaceSessionWithStreamingUpdate:
     def test_resets_tokens_and_prompt_from_update(self) -> None:
         sched = _SchedulerStub()
diff --git a/tests/core/sched/test_omni_scheduler_finish_requests_purge.py b/tests/core/sched/test_omni_scheduler_finish_requests_purge.py
index 9b564d7d5..fbfeb384f 100644
--- a/tests/core/sched/test_omni_scheduler_finish_requests_purge.py
+++ b/tests/core/sched/test_omni_scheduler_finish_requests_purge.py
@@ -76,8 +76,9 @@ def test_finish_requests_purges_finished_request_from_running(
     )
 
     def fake_finish_requests(self, request_ids, finished_status):
-        # super() returning the abort tuple but leaving self.running untouched
-        return [(finished.request_id, 0)]
+        # vLLM 0.26 super() returns the finished Request objects but here
+        # leaves self.running untouched to simulate the missed removal.
+        return [finished]
 
     monkeypatch.setattr(scheduler_mod.VLLMScheduler, "finish_requests", fake_finish_requests)
 
@@ -88,7 +89,7 @@ def test_finish_requests_purges_finished_request_from_running(
     )
 
     assert scheduler.running == []
-    assert result == [(finished.request_id, 0)]
+    assert result == [finished]
 
 
 @pytest.mark.parametrize(("scheduler_cls", "scheduler_mod"), _SCHEDULER_PARAMS)
@@ -111,7 +112,7 @@ def test_finish_requests_purges_untracked_request_from_running(
     )
 
     def fake_finish_requests(self, request_ids, finished_status):
-        return [(untracked.request_id, 0)]
+        return [untracked]
 
     monkeypatch.setattr(scheduler_mod.VLLMScheduler, "finish_requests", fake_finish_requests)
 
@@ -122,7 +123,7 @@ def test_finish_requests_purges_untracked_request_from_running(
     )
 
     assert scheduler.running == []
-    assert result == [(untracked.request_id, 0)]
+    assert result == [untracked]
 
 
 @pytest.mark.parametrize(("scheduler_cls", "scheduler_mod"), _SCHEDULER_PARAMS)
@@ -136,7 +137,7 @@ def test_finish_requests_leaves_healthy_running_intact(
     is conservative and won't aggressively drop healthy entries.
     """
     alive = _StubRequest("req-alive", RequestStatus.RUNNING)
-    leaving_id = "req-leaving"
+    leaving = _StubRequest("req-leaving", RequestStatus.FINISHED_STOPPED)
     scheduler = _make_scheduler(
         scheduler_cls,
         requests={alive.request_id: alive},
@@ -145,13 +146,13 @@ def test_finish_requests_leaves_healthy_running_intact(
     )
 
     def fake_finish_requests(self, request_ids, finished_status):
-        return [(leaving_id, 0)]
+        return [leaving]
 
     monkeypatch.setattr(scheduler_mod.VLLMScheduler, "finish_requests", fake_finish_requests)
 
     scheduler_cls.finish_requests(
         scheduler,
-        [leaving_id],
+        [leaving.request_id],
         RequestStatus.FINISHED_STOPPED,
     )
 
diff --git a/tests/core/sched/test_omni_scheduler_input_coordinator_cleanup.py b/tests/core/sched/test_omni_scheduler_input_coordinator_cleanup.py
index fcac8172b..008e52636 100644
--- a/tests/core/sched/test_omni_scheduler_input_coordinator_cleanup.py
+++ b/tests/core/sched/test_omni_scheduler_input_coordinator_cleanup.py
@@ -53,7 +53,11 @@ def test_finish_requests_cleans_input_coordinator_for_finished_ids(
     def fake_finish_requests(self, request_ids, finished_status):
         assert request_ids == ["req-a", "req-b"]
         assert finished_status == RequestStatus.FINISHED_STOPPED
-        return [("req-a", 0), ("req-b", 1)]
+        # vLLM 0.26 returns the finished Request objects, not (req_id, client_index) tuples.
+        return [
+            SimpleNamespace(request_id="req-a", client_index=0),
+            SimpleNamespace(request_id="req-b", client_index=1),
+        ]
 
     monkeypatch.setattr(scheduler_mod.VLLMScheduler, "finish_requests", fake_finish_requests)
 
@@ -63,7 +67,7 @@ def test_finish_requests_cleans_input_coordinator_for_finished_ids(
         RequestStatus.FINISHED_STOPPED,
     )
 
-    assert result == [("req-a", 0), ("req-b", 1)]
+    assert [(r.request_id, r.client_index) for r in result] == [("req-a", 0), ("req-b", 1)]
     assert coordinator.freed == ["req-a", "req-b"]
 
 
@@ -71,6 +75,7 @@ def test_ar_free_request_cleans_input_coordinator_on_normal_free() -> None:
     coordinator = FakeInputCoordinator()
     scheduler = OmniARScheduler.__new__(OmniARScheduler)
     scheduler.input_coordinator = coordinator
+    scheduler.chunk_transfer_adapter = None
     scheduler._omits_kv_transfer_cache = {"req-free": True}
     scheduler.encoder_cache_manager = SimpleNamespace(free=lambda request: None)
     scheduler.finished_req_ids = set()
@@ -82,7 +87,7 @@ def test_ar_free_request_cleans_input_coordinator_on_normal_free() -> None:
 
     result = OmniARScheduler._free_request(scheduler, DummyRequest())
 
-    assert result is None
+    assert result == (None, None)
     assert coordinator.freed == ["req-free"]
     assert scheduler._omits_kv_transfer_cache == {}
     assert scheduler._new_prompt_len_snapshot == {}
diff --git a/tests/core/sched/test_omni_scheduler_mixin_shared.py b/tests/core/sched/test_omni_scheduler_mixin_shared.py
new file mode 100644
index 000000000..9aaa4c656
--- /dev/null
+++ b/tests/core/sched/test_omni_scheduler_mixin_shared.py
@@ -0,0 +1,90 @@
+from collections import defaultdict
+from types import SimpleNamespace
+
+import pytest
+from vllm.v1.engine import FinishReason
+
+from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
+from vllm_omni.core.sched.output import OmniChunkRecvHandle
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Scheduler(OmniSchedulerMixin):
+    pass
+
+
+def test_schedule_lifecycle_helpers_process_and_restore_both_input_paths():
+    calls = []
+    scheduler = _Scheduler()
+    scheduler.waiting = ["waiting"]
+    scheduler.running = ["running"]
+    scheduler.requests = {"request": object()}
+    scheduler._consume_pending_connector_output = lambda mode: calls.append(("consume", mode))
+    scheduler._process_pending_input_timeouts = lambda: calls.append(("timeouts",))
+    scheduler.chunk_transfer_adapter = SimpleNamespace(
+        process_pending_chunks=lambda waiting, running, scheduler_requests: calls.append(
+            ("process", waiting, running, scheduler_requests)
+        ),
+        restore_queues=lambda waiting, running, scheduler_requests: calls.append(
+            ("restore-chunks", waiting, running, scheduler_requests)
+        ),
+    )
+    scheduler.input_coordinator = SimpleNamespace(
+        restore_queues=lambda waiting: calls.append(("restore-full", waiting))
+    )
+
+    scheduler._process_pending_omni_inputs("ar")
+    scheduler._restore_omni_wait_queues()
+
+    assert calls == [
+        ("consume", "ar"),
+        ("timeouts",),
+        ("process", scheduler.waiting, scheduler.running, scheduler.requests),
+        ("restore-chunks", scheduler.waiting, scheduler.running, scheduler.requests),
+        ("restore-full", scheduler.waiting),
+    ]
+
+
+@pytest.mark.parametrize(
+    ("synthesize_abort_outputs", "expected_finish_reason"),
+    [(False, None), (True, FinishReason.ABORT)],
+)
+def test_finished_request_attachment_keeps_ar_abort_policy_explicit(
+    synthesize_abort_outputs,
+    expected_finish_reason,
+):
+    scheduler = _Scheduler()
+    scheduler.finished_req_ids_dict = defaultdict(set, {2: {"req-finished"}})
+    outputs = {}
+
+    scheduler._attach_finished_request_sets(
+        outputs,
+        synthesize_abort_outputs=synthesize_abort_outputs,
+    )
+
+    assert outputs[2].finished_requests == {"req-finished"}
+    if expected_finish_reason is None:
+        assert outputs[2].outputs == []
+    else:
+        assert outputs[2].outputs[0].finish_reason == expected_finish_reason
+    assert scheduler.finished_req_ids_dict == {}
+
+
+def test_chunk_receive_handle_carries_minimal_registration_fields():
+    handle = OmniChunkRecvHandle(request_id="req", external_req_id="external")
+    assert handle.request_id == "req"
+    assert handle.external_req_id == "external"
+
+
+def test_output_helper_preserves_required_nan_counter_default():
+    scheduler = _Scheduler()
+    request = SimpleNamespace(
+        request_id="req-output",
+        trace_headers=None,
+        take_events=lambda: [],
+    )
+
+    output = scheduler._make_omni_engine_output(request, new_token_ids=[])
+
+    assert output.num_nans_in_logits == 0
diff --git a/tests/core/sched/test_omni_scheduler_mixin_timeouts.py b/tests/core/sched/test_omni_scheduler_mixin_timeouts.py
index 053c926cc..5fad4340c 100644
--- a/tests/core/sched/test_omni_scheduler_mixin_timeouts.py
+++ b/tests/core/sched/test_omni_scheduler_mixin_timeouts.py
@@ -18,6 +18,8 @@ import pytest
 
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 class _FakeCoordinator:
     def __init__(self, timed_out_ids):
diff --git a/tests/core/sched/test_omni_scheduling_coordinator.py b/tests/core/sched/test_omni_scheduling_coordinator.py
index 068cbd362..a36a94e7d 100644
--- a/tests/core/sched/test_omni_scheduling_coordinator.py
+++ b/tests/core/sched/test_omni_scheduling_coordinator.py
@@ -4,6 +4,9 @@
 
 These tests use mock request objects and mock queues.  They do not require
 GPU, vLLM runtime, or any connector.
+
+Chunk waiting (WAITING_FOR_CHUNK / process_pending_chunks) lives on
+OmniChunkTransferAdapter — see tests/distributed/omni_connectors/.
 """
 
 from __future__ import annotations
@@ -11,6 +14,7 @@ from __future__ import annotations
 import unittest
 from types import SimpleNamespace
 
+import pytest
 import torch
 
 import vllm_omni.core.sched.omni_scheduling_coordinator as coord_mod
@@ -19,6 +23,8 @@ from vllm_omni.core.sched.omni_scheduling_coordinator import (
     uses_full_payload_input_coordinator,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 # ------------------------------------------------------------------ #
 #  Mock helpers
 # ------------------------------------------------------------------ #
@@ -27,7 +33,6 @@ from vllm_omni.core.sched.omni_scheduling_coordinator import (
 class _RequestStatus:
     WAITING = "waiting"
     RUNNING = "running"
-    WAITING_FOR_CHUNK = "waiting_for_chunk"
     WAITING_FOR_INPUT = "waiting_for_input"
     FINISHED_STOPPED = "finished_stopped"
 
@@ -114,7 +119,12 @@ class TestFullPayloadCoordinatorSelection(unittest.TestCase):
             ("CovoAudioForConditionalGeneration", "code2wav"),
             ("MiMoAudioModel", "code2wav"),
             ("Qwen3TTSCode2Wav", "code2wav"),
+            ("MiniCPMO45Code2Wav", "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"),
             ("DyninOmniForConditionalGeneration", "token2image"),
             ("DyninOmniForConditionalGeneration", "token2audio"),
@@ -185,105 +195,12 @@ class TestFullPayloadCoordinatorSelection(unittest.TestCase):
             )
 
 
-class TestChunkCoordinatorStateTransition(unittest.TestCase):
-    """Test 5: process_pending_chunks transitions WAITING_FOR_CHUNK → target."""
-
-    def test_ready_request_transitions_to_waiting(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1, async_chunk=True)
-
-        req = _make_request("r1", status=RequestStatus.WAITING_FOR_CHUNK)
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids={"r1"},
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertEqual(req.status, RequestStatus.WAITING)
-        self.assertIn("r1", coord.requests_with_ready_chunks)
-
-    def test_non_ready_stays_waiting_for_chunk(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1, async_chunk=True)
-
-        req = _make_request("r1", status=RequestStatus.WAITING_FOR_CHUNK)
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids=set(),
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertEqual(req.status, RequestStatus.WAITING_FOR_CHUNK)
-
-    def test_stage_0_is_noop(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=0)
-        req = _make_request("r1")
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids={"r1"},
-            chunk_finished_req_ids=set(),
-        )
-        self.assertNotEqual(req.status, RequestStatus.WAITING_FOR_CHUNK)
-
-
-class TestChunkCoordinatorRestoreQueues(unittest.TestCase):
-    """Test 6: restore_queues returns waiting-for-chunk requests."""
-
-    def test_restore(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
-
-        r1 = _make_request("r1")
-        r2 = _make_request("r2")
-        coord._waiting_for_chunk_waiting.append(r1)
-        coord._waiting_for_chunk_running.append(r2)
-
-        waiting = MockQueue()
-        running: list = []
-
-        coord.restore_queues(waiting, running)
-
-        self.assertIn(r1, waiting)
-        self.assertIn(r2, running)
-        self.assertEqual(len(coord._waiting_for_chunk_waiting), 0)
-        self.assertEqual(len(coord._waiting_for_chunk_running), 0)
-
-
-class TestChunkCoordinatorFinishedSignal(unittest.TestCase):
-    """Test 8: chunk_finished_req_ids → finished_requests."""
-
-    def test_finished_signal(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1, async_chunk=True)
-
-        req = _make_request("r1", status=RequestStatus.WAITING_FOR_CHUNK)
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids={"r1"},
-            chunk_finished_req_ids={"r1"},
-        )
-
-        self.assertIn("r1", coord.finished_requests)
-
-
-class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
+class TestCoordinatorUpdateRequestMetadata(unittest.TestCase):
     """Test update_request_metadata applies scheduling metadata to requests."""
 
     def test_ar_mode_no_longer_sets_additional_information(self):
         """AR mode only processes scheduling metadata, not full payloads."""
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1")
         requests = {"r1": req}
@@ -300,7 +217,7 @@ class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
         self.assertIsNone(getattr(req, "additional_information", None))
 
     def test_generation_mode(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1")
         req.prompt_token_ids = [0, 0, 0]
@@ -313,7 +230,6 @@ class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
         request_metadata = {
             "r1": {
                 "code_predictor_codes": [10, 20, 30],
-                "left_context_size": 25,
             }
         }
 
@@ -325,10 +241,9 @@ class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
         self.assertEqual(req._all_token_ids, [10, 20, 30])
         self.assertEqual(req._output_token_ids, [])
         self.assertIsNone(req.additional_information)
-        self.assertEqual(req._omni_initial_model_buffer, {"meta": {"left_context_size": 25}})
 
     def test_generation_mode_flattens_tensor_code_predictor_codes(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1")
         req.prompt_token_ids = [9]
@@ -349,7 +264,7 @@ class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
         self.assertEqual(req._output_token_ids, [])
 
     def test_generation_mode_flattens_nested_code_predictor_codes(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1")
         req.prompt_token_ids = [9]
@@ -370,53 +285,30 @@ class TestChunkCoordinatorUpdateRequestMetadata(unittest.TestCase):
         self.assertEqual(req._output_token_ids, [])
 
 
-class TestChunkCoordinatorPostprocess(unittest.TestCase):
-    """Test postprocess_scheduler_output clears ready chunks."""
-
-    def test_clear_ready(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
-        coord.requests_with_ready_chunks = {"r1", "r2"}
-
-        new_req = SimpleNamespace(req_id="r1")
-        cached_reqs = SimpleNamespace(req_ids=["r2"])
-        scheduler_output = SimpleNamespace(
-            scheduled_new_reqs=[new_req],
-            scheduled_cached_reqs=cached_reqs,
-        )
-
-        coord.postprocess_scheduler_output(scheduler_output)
-
-        self.assertEqual(coord.requests_with_ready_chunks, set())
-
-
 class TestWaitingForInputTransition(unittest.TestCase):
-    """Test B8: process_pending_full_payload_inputs transitions WAITING_FOR_INPUT."""
+    """Test process_pending_full_payload_inputs transitions WAITING_FOR_INPUT."""
 
     def test_transition_on_recv(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
         waiting = MockQueue([req])
-        running: list = []
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            running,
             stage_recv_req_ids={"r1"},
         )
 
         self.assertEqual(req.status, RequestStatus.WAITING)
 
     def test_stays_waiting_for_input_if_not_received(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
         waiting = MockQueue([req])
-        running: list = []
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            running,
             stage_recv_req_ids=set(),
         )
 
@@ -424,49 +316,39 @@ class TestWaitingForInputTransition(unittest.TestCase):
         self.assertEqual(len(coord._waiting_for_input), 1)
 
     def test_stage_0_is_noop(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=0)
+        coord = OmniSchedulingCoordinator(stage_id=0)
 
         req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
         waiting = MockQueue([req])
-        running: list = []
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            running,
             stage_recv_req_ids={"r1"},
         )
         self.assertEqual(req.status, RequestStatus.WAITING_FOR_INPUT)
 
     def test_restore_queues_includes_waiting_for_input(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         r1 = _make_request("r1")
         coord._waiting_for_input.append(r1)
 
         waiting = MockQueue()
-        running: list = []
 
-        coord.restore_queues(waiting, running)
+        coord.restore_queues(waiting)
 
         self.assertIn(r1, waiting)
         self.assertEqual(len(coord._waiting_for_input), 0)
 
     def test_full_payload_mode_auto_transitions_waiting_to_waiting_for_input(self):
-        """In full_payload_mode (async_chunk=False), fresh WAITING requests on
-        non-Stage-0 should be transitioned to WAITING_FOR_INPUT."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=False,
-        )
+        """Fresh downstream WAITING requests enter WAITING_FOR_INPUT."""
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1", status=RequestStatus.WAITING)
         waiting = MockQueue([req])
-        running: list = []
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            running,
             stage_recv_req_ids=set(),
         )
 
@@ -474,37 +356,14 @@ class TestWaitingForInputTransition(unittest.TestCase):
         self.assertEqual(len(coord._waiting_for_input), 1)
         self.assertEqual(len(coord.pending_input_registrations), 1)
 
-    def test_async_chunk_mode_does_not_auto_transition(self):
-        """In async_chunk mode, fresh WAITING requests should NOT be
-        transitioned to WAITING_FOR_INPUT."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=True,
-        )
-
-        req = _make_request("r1", status=RequestStatus.WAITING)
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_full_payload_inputs(
-            waiting,
-            running,
-            stage_recv_req_ids=set(),
-        )
-
-        self.assertEqual(req.status, RequestStatus.WAITING)
-
     def test_pending_input_registrations(self):
-        coord = OmniSchedulingCoordinator(scheduler_max_num_seqs=10, stage_id=1)
+        coord = OmniSchedulingCoordinator(stage_id=1)
 
         req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
         waiting = MockQueue([req])
-        running: list = []
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            running,
             stage_recv_req_ids=set(),
         )
 
@@ -512,18 +371,13 @@ class TestWaitingForInputTransition(unittest.TestCase):
         self.assertEqual(coord.pending_input_registrations[0].request_id, "r1")
 
     def test_idle_cycles_retain_received_marker_before_request_appears(self):
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=False,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         coord._full_payload_input_received.add("late")
         coord.finished_requests.add("late")
 
         waiting = MockQueue()
-        running: list = []
 
-        coord.process_pending_full_payload_inputs(waiting, running, stage_recv_req_ids=set())
+        coord.process_pending_full_payload_inputs(waiting, stage_recv_req_ids=set())
 
         self.assertIn("late", coord._full_payload_input_received)
         self.assertIn("late", coord.finished_requests)
@@ -531,7 +385,7 @@ class TestWaitingForInputTransition(unittest.TestCase):
         late_req = _make_request("late", status=RequestStatus.WAITING)
         waiting.add_request(late_req)
 
-        coord.process_pending_full_payload_inputs(waiting, running, stage_recv_req_ids=set())
+        coord.process_pending_full_payload_inputs(waiting, stage_recv_req_ids=set())
 
         self.assertEqual(late_req.status, RequestStatus.WAITING)
         self.assertEqual(coord.pending_input_registrations, [])
@@ -542,65 +396,18 @@ class TestWaitingForInputTransition(unittest.TestCase):
 class TestTimeoutDetection(unittest.TestCase):
     """Regression tests for orphaned pending-recv timeout detection.
 
-    Covers the full lifecycle:
-      1. Request enters WAITING_FOR_CHUNK from either waiting or running queue
-      2. restore_queues() moves it back to the scheduler queue
-      3. Timeout fires via collect_timed_out_request_ids()
-      4. Scheduler removes from both queues and calls _free_request()
+    Covers WAITING_FOR_INPUT lifecycle timeouts. Chunk waiting timeouts are
+    covered by OmniChunkTransferAdapter tests.
     """
 
-    def test_waiting_since_recorded_on_chunk_wait(self):
-        """_waiting_since is set when a request enters WAITING_FOR_CHUNK."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=True,
-        )
-        req = _make_request("r1", status=RequestStatus.WAITING)
-        waiting = MockQueue([req])
-
-        coord.process_pending_chunks(
-            waiting,
-            [],
-            chunk_ready_req_ids=set(),
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertIn("r1", coord._waiting_since)
-        self.assertEqual(req.status, RequestStatus.WAITING_FOR_CHUNK)
-
-    def test_waiting_since_cleared_on_chunk_arrival(self):
-        """_waiting_since is cleared when a chunk arrives."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=True,
-        )
-        req = _make_request("r1", status=RequestStatus.WAITING_FOR_CHUNK)
-        waiting = MockQueue([req])
-
-        coord.process_pending_chunks(
-            waiting,
-            [],
-            chunk_ready_req_ids={"r1"},
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertNotIn("r1", coord._waiting_since)
-
     def test_waiting_since_recorded_on_input_wait(self):
         """_waiting_since is set when a request enters WAITING_FOR_INPUT."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=False,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         req = _make_request("r1", status=RequestStatus.WAITING)
         waiting = MockQueue([req])
 
         coord.process_pending_full_payload_inputs(
             waiting,
-            [],
             stage_recv_req_ids=set(),
         )
 
@@ -608,11 +415,7 @@ class TestTimeoutDetection(unittest.TestCase):
 
     def test_waiting_since_cleared_on_input_arrival(self):
         """_waiting_since is cleared when input data arrives."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=False,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
         coord._waiting_for_input.append(req)
         coord._waiting_since["r1"] = 0.0
@@ -620,7 +423,6 @@ class TestTimeoutDetection(unittest.TestCase):
         waiting = MockQueue()
         coord.process_pending_full_payload_inputs(
             waiting,
-            [],
             stage_recv_req_ids={"r1"},
         )
 
@@ -629,10 +431,7 @@ class TestTimeoutDetection(unittest.TestCase):
 
     def test_collect_timed_out_request_ids_no_timeout(self):
         """No IDs returned when nothing has timed out."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         import time
 
         coord._waiting_since["r1"] = time.monotonic()
@@ -642,10 +441,7 @@ class TestTimeoutDetection(unittest.TestCase):
 
     def test_collect_timed_out_request_ids_expired(self):
         """Timed-out IDs are returned and _waiting_since is cleared."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         coord._waiting_since["r1"] = 0.0  # epoch → definitely expired
         coord._waiting_since["r2"] = 0.0
 
@@ -662,29 +458,19 @@ class TestTimeoutDetection(unittest.TestCase):
 
     def test_collect_removes_from_coordinator_queues(self):
         """Timed-out requests are defensively removed from internal queues."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         r1 = _make_request("r1")
-        r2 = _make_request("r2")
-        coord._waiting_for_chunk_waiting.append(r1)
-        coord._waiting_for_input.append(r2)
+        coord._waiting_for_input.append(r1)
         coord._waiting_since["r1"] = 0.0
-        coord._waiting_since["r2"] = 0.0
 
         result = coord.collect_timed_out_request_ids(timeout_s=1.0)
 
-        self.assertEqual(result, {"r1", "r2"})
-        self.assertEqual(len(coord._waiting_for_chunk_waiting), 0)
+        self.assertEqual(result, {"r1"})
         self.assertEqual(len(coord._waiting_for_input), 0)
 
     def test_free_finished_request_clears_waiting_since(self):
         """free_finished_request clears coordinator lifecycle markers."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-        )
+        coord = OmniSchedulingCoordinator(stage_id=1)
         coord._waiting_since["r1"] = 0.0
         coord._full_payload_input_received.add("r1")
         coord.finished_requests.add("r1")
@@ -693,174 +479,6 @@ class TestTimeoutDetection(unittest.TestCase):
         self.assertNotIn("r1", coord._full_payload_input_received)
         self.assertNotIn("r1", coord.finished_requests)
 
-    def test_timeout_from_running_queue_full_lifecycle(self):
-        """End-to-end: request from running → WAITING_FOR_CHUNK → restore →
-        timeout → removed from running list.
-
-        This is the critical regression case: WAITING_FOR_CHUNK requests
-        that originated from self.running are placed back into self.running
-        by restore_queues(), but their status remains WAITING_FOR_CHUNK.
-        The scheduler must remove from BOTH queues unconditionally.
-        """
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=True,
-        )
-
-        # 1) Request starts in running queue with WAITING status
-        req = _make_request("r1", status=RequestStatus.WAITING)
-        running = [req]
-        waiting = MockQueue()
-
-        # 2) process_pending_chunks: moves to WAITING_FOR_CHUNK
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids=set(),
-            chunk_finished_req_ids=set(),
-        )
-        self.assertEqual(req.status, RequestStatus.WAITING_FOR_CHUNK)
-        self.assertIn("r1", coord._waiting_since)
-        self.assertEqual(len(coord._waiting_for_chunk_running), 1)
-
-        # 3) restore_queues: back to running (status stays WAITING_FOR_CHUNK)
-        coord.restore_queues(waiting, running)
-        self.assertIn(req, running)
-        self.assertEqual(len(coord._waiting_for_chunk_running), 0)
-        self.assertEqual(req.status, RequestStatus.WAITING_FOR_CHUNK)
-
-        # 4) Force timeout by setting _waiting_since to epoch
-        coord._waiting_since["r1"] = 0.0
-
-        timed_out_ids = coord.collect_timed_out_request_ids(timeout_s=1.0)
-        self.assertEqual(timed_out_ids, {"r1"})
-
-        # 5) Scheduler removes from both queues (simulating the scheduler path)
-        timed_out_id_set = {id(req)}
-        running = [r for r in running if id(r) not in timed_out_id_set]
-        waiting.remove_requests([req])
-
-        self.assertNotIn(req, running)
-        self.assertEqual(len(waiting), 0)
-
-    def test_timeout_from_waiting_queue_full_lifecycle(self):
-        """End-to-end: request from waiting → WAITING_FOR_CHUNK → restore →
-        timeout → removed from waiting queue."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=10,
-            stage_id=1,
-            async_chunk=True,
-        )
-
-        req = _make_request("r1", status=RequestStatus.WAITING)
-        waiting = MockQueue([req])
-        running: list = []
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids=set(),
-            chunk_finished_req_ids=set(),
-        )
-        self.assertEqual(len(coord._waiting_for_chunk_waiting), 1)
-
-        coord.restore_queues(waiting, running)
-        self.assertIn(req, waiting)
-
-        coord._waiting_since["r1"] = 0.0
-        timed_out_ids = coord.collect_timed_out_request_ids(timeout_s=1.0)
-        self.assertEqual(timed_out_ids, {"r1"})
-
-        waiting.remove_requests([req])
-        self.assertEqual(len(waiting), 0)
-
-
-class TestOverflowPreemption(unittest.TestCase):
-    """Tests for P1-1: overflow requests must get WAITING status.
-
-    Overflow happens when multiple WAITING_FOR_CHUNK requests in
-    ``_waiting_for_chunk_running`` receive their chunk in the same cycle.
-    ``_process_chunk_queue`` restores them to RUNNING (``continue``
-    path) while RUNNING requests without chunks are moved out.  If the
-    net result exceeds ``scheduler_max_num_seqs``, the tail is pushed
-    to ``waiting_queue`` and must have status == WAITING.
-    """
-
-    def test_overflow_sets_waiting_status(self):
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=1,
-            stage_id=1,
-            async_chunk=True,
-        )
-
-        # r1 is currently RUNNING in the queue.
-        # r2, r3 were previously moved to _waiting_for_chunk_running.
-        r1 = _make_request("r1", status=RequestStatus.RUNNING)
-        r2 = _make_request("r2", status=RequestStatus.WAITING_FOR_CHUNK)
-        r3 = _make_request("r3", status=RequestStatus.WAITING_FOR_CHUNK)
-
-        running = [r1]
-        waiting = MockQueue([])
-        coord._waiting_for_chunk_running.extend([r2, r3])
-
-        # restore_queues puts r2, r3 back into running
-        coord.restore_queues(waiting, running)
-        self.assertEqual(len(running), 3)
-
-        # Now process_pending_chunks with r2, r3 chunks ready:
-        # _process_chunk_queue will:
-        #   r1 (RUNNING) → no chunk → move to _waiting_for_chunk_running
-        #   r2 (WAITING_FOR_CHUNK, chunk ready) → set RUNNING, stay in running
-        #   r3 (WAITING_FOR_CHUNK, chunk ready) → set RUNNING, stay in running
-        # running = [r2, r3], len=2 > max=1 → overflow
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids={"r2", "r3"},
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertEqual(len(running), 1)
-        self.assertEqual(len(waiting), 1)
-        overflow_req = list(waiting)[0]
-        self.assertEqual(
-            overflow_req.status,
-            RequestStatus.WAITING,
-            f"Overflowed request should have WAITING status, got {overflow_req.status}",
-        )
-
-    def test_overflow_does_not_strand_request(self):
-        """Without the fix, the overflowed request would keep its
-        RUNNING status in the waiting queue and never be re-scheduled."""
-        coord = OmniSchedulingCoordinator(
-            scheduler_max_num_seqs=1,
-            stage_id=1,
-            async_chunk=True,
-        )
-
-        r1 = _make_request("r1", status=RequestStatus.WAITING_FOR_CHUNK)
-        r2 = _make_request("r2", status=RequestStatus.WAITING_FOR_CHUNK)
-        coord._waiting_for_chunk_running.extend([r1, r2])
-
-        running: list = []
-        waiting = MockQueue([])
-
-        coord.restore_queues(waiting, running)
-        self.assertEqual(len(running), 2)
-
-        coord.process_pending_chunks(
-            waiting,
-            running,
-            chunk_ready_req_ids={"r1", "r2"},
-            chunk_finished_req_ids=set(),
-        )
-
-        self.assertEqual(len(running), 1)
-        self.assertEqual(len(waiting), 1)
-        for req in waiting:
-            self.assertNotEqual(req.status, RequestStatus.RUNNING, "Overflowed request must not keep RUNNING status")
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/core/sched/test_sched_package_imports.py b/tests/core/sched/test_sched_package_imports.py
new file mode 100644
index 000000000..bc4ec9d44
--- /dev/null
+++ b/tests/core/sched/test_sched_package_imports.py
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_importing_scheduler_output_does_not_eagerly_import_scheduler_implementations() -> None:
+    package_init = Path(__file__).parents[3] / "vllm_omni/core/sched/__init__.py"
+    module = ast.parse(package_init.read_text())
+    eager_modules = {
+        node.module
+        for node in ast.walk(module)
+        if isinstance(node, ast.ImportFrom)
+        and node.level == 1
+        and node.module in {"omni_ar_scheduler", "omni_generation_scheduler"}
+    }
+
+    assert eager_modules == set()
+    assert any(isinstance(node, ast.FunctionDef) and node.name == "__getattr__" for node in module.body)
diff --git a/tests/core/test_prefix_cache.py b/tests/core/test_prefix_cache.py
index 2111556f2..4f91a95b7 100644
--- a/tests/core/test_prefix_cache.py
+++ b/tests/core/test_prefix_cache.py
@@ -1,8 +1,14 @@
+import math
+from typing import NamedTuple
+
 import pytest
 import torch
 
 from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 DEFAULT_SEQ_LEN = 15
 NUM_BLOCKS = 10
 BLOCK_SIZE = 4
@@ -314,6 +320,103 @@ def test_deferred_multimodal_cache_write_commits_on_completion():
     assert torch.equal(rows[8:16], expected)
 
 
+def test_discard_deferred_mm_outputs_drops_pending_chunks():
+    """discard_deferred_mm_outputs is the abort path: a request that
+    leaves without a cache commit must not leak its staged chunks into
+    the cache if commit_deferred_mm_outputs is later called for it."""
+    cache = get_omni_pcache()
+    mm_key = "codes.audio"
+    block_table = torch.tensor(
+        [
+            [2, 3, 4, 5],
+            [6, 7, 8, 9],
+        ],
+        dtype=torch.long,
+    )
+    input_batch = MockInputBatch(
+        num_computed_tokens_cpu=torch.tensor([4, 0], dtype=torch.long),
+        block_table=block_table,
+    )
+
+    cache.update_omni_tensor_prefix_cache(
+        hidden_states=None,
+        multimodal_outputs={mm_key: torch.arange(8, dtype=torch.long).reshape(4, 2)},
+        num_tokens_unpadded=4,
+        slot_mapping=torch.arange(8, 12),
+        skip_mm_cache_keys={mm_key},
+    )
+
+    chunk = torch.arange(8, dtype=torch.long).reshape(4, 2)
+    cache.stage_deferred_mm_outputs(
+        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
+        input_batch=input_batch,
+        multimodal_outputs={mm_key: chunk},
+        num_scheduled_tokens={"req1": 4, "req2": 0},
+        deferred_mm_cache_keys={mm_key},
+    )
+    assert "req1" in cache._deferred_mm_outputs
+
+    cache.discard_deferred_mm_outputs("req1")
+    assert "req1" not in cache._deferred_mm_outputs
+
+    # A later commit call for the now-discarded req_id must be a no-op,
+    # not a resurrection of the dropped chunk.
+    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
+    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
+    assert torch.all(rows[8:12] == 0)
+
+
+def test_deferred_mm_outputs_request_id_reused_after_discard():
+    """A request ID reused after discard_deferred_mm_outputs must start
+    clean: the new occupant's committed data must not be mixed with the
+    previous (discarded) occupant's staged chunks."""
+    cache = get_omni_pcache()
+    mm_key = "codes.audio"
+    block_table = torch.tensor(
+        [
+            [2, 3, 4, 5],
+            [6, 7, 8, 9],
+        ],
+        dtype=torch.long,
+    )
+    input_batch = MockInputBatch(
+        num_computed_tokens_cpu=torch.tensor([4, 0], dtype=torch.long),
+        block_table=block_table,
+    )
+
+    cache.update_omni_tensor_prefix_cache(
+        hidden_states=None,
+        multimodal_outputs={mm_key: torch.arange(8, dtype=torch.long).reshape(4, 2)},
+        num_tokens_unpadded=4,
+        slot_mapping=torch.arange(8, 12),
+        skip_mm_cache_keys={mm_key},
+    )
+
+    stale_chunk = torch.full((4, 2), -1, dtype=torch.long)
+    cache.stage_deferred_mm_outputs(
+        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
+        input_batch=input_batch,
+        multimodal_outputs={mm_key: stale_chunk},
+        num_scheduled_tokens={"req1": 4, "req2": 0},
+        deferred_mm_cache_keys={mm_key},
+    )
+    cache.discard_deferred_mm_outputs("req1")
+
+    # "req1" is reused by a brand-new request with different data.
+    fresh_chunk = torch.arange(8, dtype=torch.long).reshape(4, 2)
+    cache.stage_deferred_mm_outputs(
+        query_start_loc=torch.tensor([0, 4], dtype=torch.long),
+        input_batch=input_batch,
+        multimodal_outputs={mm_key: fresh_chunk},
+        num_scheduled_tokens={"req1": 4, "req2": 0},
+        deferred_mm_cache_keys={mm_key},
+    )
+    cache.commit_deferred_mm_outputs({"req1"}, input_batch)
+
+    rows = cache.mm_outputs_cache[mm_key].view(-1, 2)
+    assert torch.equal(rows[8:12], fresh_chunk)
+
+
 def test_deferred_multimodal_cache_can_be_merged_on_full_block_hit():
     cache = get_omni_pcache()
     mm_key = "codes.audio"
@@ -596,3 +699,219 @@ def test_get_merged_multimodal_outputs(feat_dims, num_tokens_padded, mocker):
 
             assert req2_merged_mm_outputs.shape == torch.Size([num_new_toks_req2, curr_feat_dim])
             assert torch.all(req2_merged_mm_outputs == req2_new_mm_outputs)
+
+
+@pytest.mark.parametrize(
+    "passthrough_shape",
+    [(5,), (5, 3)],
+    ids=["1d_token_metadata", "2d_feature_tensor"],
+)
+def test_get_merged_multimodal_outputs_slices_passthrough_tensor_per_request(passthrough_shape, mocker):
+    """A passthrough key that is itself a real tensor (not the string/list
+    passthrough already covered above) must be sliced per request through
+    to_payload_element's tensor branch, under the same mixed cache
+    hit/miss + uneven scheduled-length batch as test_get_merged_multimodal_outputs.
+
+    Covers both a 1D token-aligned metadata tensor (e.g. ref_code_len,
+    codec_streaming -- shape (total_tokens,)) and a 2D per-token feature
+    tensor (shape (total_tokens, feat_dim)), since W2's batching could
+    easily special-case one and silently mishandle the other.
+    """
+    feat_dims = {"foo": 100, "bar": 100}
+    cache = get_omni_pcache_with_mm_tensors(feat_dims, seq_len=DEFAULT_SEQ_LEN)
+
+    orig_num_tokens_unpadded = 8
+    slot_offset = 8
+    orig_slot_mapping = torch.arange(slot_offset, slot_offset + orig_num_tokens_unpadded)
+    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
+    orig_mm_outputs = {
+        key: torch.rand((orig_num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
+    }
+
+    cache.update_omni_tensor_prefix_cache(
+        hidden_states=None,
+        multimodal_outputs=orig_mm_outputs,
+        num_tokens_unpadded=orig_num_tokens_unpadded,
+        slot_mapping=orig_slot_mapping,
+        num_tokens_padded=None,
+    )
+
+    num_new_toks_req1 = 3
+    num_new_toks_req2 = 2
+    cache.add_prefix_cached_new_req_id("req1")
+
+    num_scheduled_tokens = {
+        "req1": num_new_toks_req1,
+        "req2": num_new_toks_req2,
+    }
+
+    new_mm_outputs = {}
+    for mm_key in cache.mm_cache_keys:
+        new_mm_outputs[mm_key] = torch.rand(
+            (num_new_toks_req1 + num_new_toks_req2, feature_dims[mm_key]),
+            dtype=DTYPE,
+        )
+    total_scheduled_tokens = num_new_toks_req1 + num_new_toks_req2
+    assert passthrough_shape[0] == total_scheduled_tokens
+    passthrough_tensor = torch.arange(int(torch.prod(torch.tensor(passthrough_shape))), dtype=DTYPE).reshape(
+        passthrough_shape
+    )
+    new_mm_outputs["passthrough_tensor"] = passthrough_tensor
+
+    input_batch = MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0]))
+
+    mocker.patch(
+        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
+        new=fake_get_cached_block_ids,
+    )
+    merged_mm_outputs = cache.get_merged_multimodal_states(
+        query_start_loc=[0, num_new_toks_req1],
+        input_batch=input_batch,
+        multimodal_outputs=new_mm_outputs,
+        num_scheduled_tokens=num_scheduled_tokens,
+    )
+
+    assert "passthrough_tensor" not in cache.mm_cache_keys
+
+    passthrough_out = merged_mm_outputs["passthrough_tensor"]
+    # req1 (cache hit) gets tokens [0:3), req2 (cache miss) gets tokens [3:5) --
+    # a passthrough tensor is sliced by scheduled position, not merged with
+    # any cached history (unlike the mm_cache_keys tensors above).
+    assert torch.equal(passthrough_out["req1"], passthrough_tensor[0:num_new_toks_req1])
+    assert torch.equal(passthrough_out["req2"], passthrough_tensor[num_new_toks_req1:total_scheduled_tokens])
+
+
+class MergeHarness(NamedTuple):
+    """A primed cache plus the arguments get_merged_multimodal_states needs."""
+
+    cache: OmniTensorPrefixCache
+    input_batch: MockInputBatch
+    num_scheduled_tokens: dict[str, int]
+    query_start_loc: list[int]
+    total_scheduled_tokens: int
+    new_mm_outputs: dict[str, object]
+
+
+def build_mixed_hit_miss_harness(mocker, num_new_toks_req1: int = 3, num_new_toks_req2: int = 2) -> MergeHarness:
+    """Two requests over one cache key: req1 hits 8 cached tokens, req2 misses,
+    and their scheduled lengths differ -- the same batch shape as
+    test_get_merged_multimodal_outputs, which is what makes a per-request
+    boundary error observable. Callers add their passthrough keys to
+    ``new_mm_outputs`` before calling get_merged_multimodal_states.
+    """
+    cache = get_omni_pcache_with_mm_tensors({"foo": 100}, seq_len=DEFAULT_SEQ_LEN)
+
+    orig_num_tokens_unpadded = 8
+    feature_dims = {key: val.shape[-1] for key, val in cache.mm_outputs_cache.items()}
+    cache.update_omni_tensor_prefix_cache(
+        hidden_states=None,
+        multimodal_outputs={
+            key: torch.rand((orig_num_tokens_unpadded, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
+        },
+        num_tokens_unpadded=orig_num_tokens_unpadded,
+        slot_mapping=torch.arange(8, 8 + orig_num_tokens_unpadded),
+        num_tokens_padded=None,
+    )
+    cache.add_prefix_cached_new_req_id("req1")
+
+    total_scheduled_tokens = num_new_toks_req1 + num_new_toks_req2
+    mocker.patch(
+        "vllm_omni.core.prefix_cache.OmniTensorPrefixCache._get_cached_block_ids",
+        new=fake_get_cached_block_ids,
+    )
+    return MergeHarness(
+        cache=cache,
+        input_batch=MockInputBatch(num_computed_tokens_cpu=torch.Tensor([orig_num_tokens_unpadded, 0])),
+        num_scheduled_tokens={"req1": num_new_toks_req1, "req2": num_new_toks_req2},
+        query_start_loc=[0, num_new_toks_req1],
+        total_scheduled_tokens=total_scheduled_tokens,
+        new_mm_outputs={
+            key: torch.rand((total_scheduled_tokens, feature_dims[key]), dtype=DTYPE) for key in cache.mm_cache_keys
+        },
+    )
+
+
+def test_get_merged_multimodal_outputs_passes_per_request_tensor_list_through(mocker):
+    """The passthrough shape qwen3-tts actually emits: a nested ``codes``/``meta``
+    dict whose ``codes.ref`` holds one tensor per request
+    (qwen3_tts_talker.make_omni_output), carried through to_payload_element's
+    pass_lists_through branch beside 1D int metadata that IS sliced per request.
+
+    Each request must receive the list *whole*. Per-request indexing happens
+    later, in the runner's _unwrap_lists; a W2 that split the list here would
+    make that second index select a different request's reference codes. The
+    existing list coverage passes a list of strings, which cannot catch a
+    tensor-specific regression, and no other test covers an int dtype.
+    """
+    harness = build_mixed_hit_miss_harness(mocker)
+
+    ref_codes = [torch.tensor([11, 12], dtype=torch.long), torch.tensor([21], dtype=torch.long)]
+    ref_code_len = torch.arange(harness.total_scheduled_tokens, dtype=torch.int32)
+    harness.new_mm_outputs["codes"] = {"ref": ref_codes}
+    harness.new_mm_outputs["meta"] = {"ref_code_len": ref_code_len}
+
+    merged = harness.cache.get_merged_multimodal_states(
+        query_start_loc=harness.query_start_loc,
+        input_batch=harness.input_batch,
+        multimodal_outputs=harness.new_mm_outputs,
+        num_scheduled_tokens=harness.num_scheduled_tokens,
+    )
+
+    assert "codes" not in harness.cache.mm_cache_keys
+    for req_id in ("req1", "req2"):
+        req_refs = merged["codes"][req_id]["ref"]
+        assert len(req_refs) == len(ref_codes)
+        for got, want in zip(req_refs, ref_codes):
+            assert torch.equal(got, want)
+            assert got.dtype == torch.long
+
+    # Per-request clones: the branch exists so one request's downstream mutation
+    # cannot reach another request's payload or the source list.
+    merged["codes"]["req1"]["ref"][0] += 100
+    assert torch.equal(merged["codes"]["req2"]["ref"][0], torch.tensor([11, 12], dtype=torch.long))
+    assert torch.equal(ref_codes[0], torch.tensor([11, 12], dtype=torch.long))
+
+    # Token-aligned 1D metadata is still split per request, unlike the list.
+    req1_len = harness.num_scheduled_tokens["req1"]
+    assert torch.equal(merged["meta"]["req1"]["ref_code_len"], ref_code_len[:req1_len])
+    assert torch.equal(merged["meta"]["req2"]["ref_code_len"], ref_code_len[req1_len:])
+    assert merged["meta"]["req1"]["ref_code_len"].dtype == torch.int32
+
+
+@pytest.mark.parametrize(
+    "passthrough_shape",
+    [(3, 4), (1, 4), (7,)],
+    ids=["shorter_2d", "single_row_2d", "longer_1d"],
+)
+def test_get_merged_multimodal_outputs_broadcasts_non_token_aligned_passthrough(passthrough_shape, mocker):
+    """A passthrough tensor whose first dimension is not the scheduled-token
+    count is request-invariant: to_payload_element hands every request the whole
+    tensor, cloned, rather than slicing it.
+
+    W2 batching most plausibly breaks by assuming every passthrough tensor is
+    token-aligned; that assumption would slice these and give each request a
+    truncated view, or an empty one once start exceeds the first dimension.
+    """
+    harness = build_mixed_hit_miss_harness(mocker)
+    assert passthrough_shape[0] != harness.total_scheduled_tokens
+
+    passthrough = torch.arange(math.prod(passthrough_shape), dtype=DTYPE).reshape(passthrough_shape)
+    expected = passthrough.clone()
+    harness.new_mm_outputs["speaker_embedding"] = passthrough
+
+    merged = harness.cache.get_merged_multimodal_states(
+        query_start_loc=harness.query_start_loc,
+        input_batch=harness.input_batch,
+        multimodal_outputs=harness.new_mm_outputs,
+        num_scheduled_tokens=harness.num_scheduled_tokens,
+    )
+
+    assert "speaker_embedding" not in harness.cache.mm_cache_keys
+    out = merged["speaker_embedding"]
+    for req_id in ("req1", "req2"):
+        assert out[req_id].shape == passthrough_shape
+        assert torch.equal(out[req_id], expected)
+
+    out["req1"] += 100
+    assert torch.equal(out["req2"], expected)
+    assert torch.equal(passthrough, expected)
diff --git a/tests/core/test_prefix_cache_async_write.py b/tests/core/test_prefix_cache_async_write.py
new file mode 100644
index 000000000..fa1980227
--- /dev/null
+++ b/tests/core/test_prefix_cache_async_write.py
@@ -0,0 +1,119 @@
+import pytest
+import torch
+
+from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
+
+# `cpu` is the lane selector, not a hardware claim: the only Buildkite steps that
+# reach tests/ select `core_model and cpu`, and they run on GPU hardware (l4_1).
+# Marking this `cuda` collects it nowhere. Real hardware need is the skipif below.
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.cpu,
+    pytest.mark.skipif(not torch.cuda.is_available(), reason="requires a CUDA device"),
+]
+
+NUM_BLOCKS = 10
+BLOCK_SIZE = 4
+HIDDEN_SIZE = 2
+DTYPE = torch.float32
+
+
+def get_omni_pcache() -> OmniTensorPrefixCache:
+    """Build an OmniTensorPrefixCache, but don't init mm tensors."""
+    return OmniTensorPrefixCache(
+        num_blocks=NUM_BLOCKS,
+        block_size=BLOCK_SIZE,
+        hidden_size=HIDDEN_SIZE,
+        hs_dtype=DTYPE,
+    )
+
+
+def test_drain_ready_async_writes_is_a_noop_before_the_event_is_ready(monkeypatch):
+    """drain_ready_async_writes() must not touch the cache while the
+    scheduled D2H's event has not completed, and must consume it exactly
+    once after it has.
+
+    Real GPU timing (e.g. via torch.cuda._sleep to stall the copy stream)
+    was tried and found unreliable on this box: cross-stream wait_stream/
+    wait_event did not reliably delay event.query() from reporting ready
+    immediately, likely a virtualization/driver quirk of this cloud GPU.
+    Forcing the event's query() result directly tests the branching logic
+    in drain_ready_async_writes/_consume_pending_write deterministically,
+    independent of real CUDA scheduling behavior.
+    """
+    cache = get_omni_pcache()
+    mm_key = "codes.audio"
+    cache.maybe_init_missing_mm_cache_keys({mm_key: torch.zeros(4, HIDDEN_SIZE)}, seq_len=4)
+
+    num_tokens = 4
+    slot_mapping_gpu = torch.arange(8, 8 + num_tokens, dtype=torch.int64, device="cuda")
+    mm_gpu = {
+        mm_key: torch.arange(num_tokens * HIDDEN_SIZE, dtype=torch.float32, device="cuda").reshape(
+            num_tokens, HIDDEN_SIZE
+        )
+    }
+
+    cache.schedule_async_write(
+        hidden_states_gpu=None,
+        multimodal_outputs_gpu=mm_gpu,
+        slot_mapping_gpu=slot_mapping_gpu,
+        num_tokens_unpadded=num_tokens,
+        num_tokens_padded=num_tokens,
+    )
+
+    pending_event = cache._pending_write.event
+    rows = cache.mm_outputs_cache[mm_key].view(-1, HIDDEN_SIZE)
+
+    monkeypatch.setattr(pending_event, "query", lambda: False)
+    assert cache.drain_ready_async_writes() == 0
+    assert torch.all(rows[8 : 8 + num_tokens] == 0)
+    assert cache._pending_write is not None
+
+    monkeypatch.setattr(pending_event, "query", lambda: True)
+    assert cache.drain_ready_async_writes() == 1
+    assert torch.equal(rows[8 : 8 + num_tokens], mm_gpu[mm_key].cpu())
+    assert cache._pending_write is None
+
+    # Nothing pending anymore: a second drain is a no-op, not a re-scatter.
+    assert cache.drain_ready_async_writes() == 0
+
+
+def test_schedule_async_write_consumes_previous_pending_write_first():
+    """Scheduling step N+1's write must first consume (scatter) step N's
+    pending write, even if the caller never explicitly called
+    drain_ready_async_writes() in between -- otherwise step N's data would
+    be silently dropped when overwritten by step N+1's pending write."""
+    cache = get_omni_pcache()
+    mm_key = "codes.audio"
+    cache.maybe_init_missing_mm_cache_keys({mm_key: torch.zeros(4, HIDDEN_SIZE)}, seq_len=4)
+
+    num_tokens = 4
+    first_slots = torch.arange(8, 8 + num_tokens, dtype=torch.int64, device="cuda")
+    first_gpu = {mm_key: torch.full((num_tokens, HIDDEN_SIZE), 1.0, device="cuda")}
+    second_slots = torch.arange(12, 12 + num_tokens, dtype=torch.int64, device="cuda")
+    second_gpu = {mm_key: torch.full((num_tokens, HIDDEN_SIZE), 2.0, device="cuda")}
+
+    cache.schedule_async_write(
+        hidden_states_gpu=None,
+        multimodal_outputs_gpu=first_gpu,
+        slot_mapping_gpu=first_slots,
+        num_tokens_unpadded=num_tokens,
+        num_tokens_padded=num_tokens,
+    )
+    torch.accelerator.synchronize()
+
+    # This call's internal _consume_pending_write() must flush the FIRST
+    # write before the second one is scheduled; the caller never drained.
+    cache.schedule_async_write(
+        hidden_states_gpu=None,
+        multimodal_outputs_gpu=second_gpu,
+        slot_mapping_gpu=second_slots,
+        num_tokens_unpadded=num_tokens,
+        num_tokens_padded=num_tokens,
+    )
+    torch.accelerator.synchronize()
+    cache.drain_ready_async_writes()
+
+    rows = cache.mm_outputs_cache[mm_key].view(-1, HIDDEN_SIZE)
+    assert torch.all(rows[8:12] == 1.0)
+    assert torch.all(rows[12:16] == 2.0)
diff --git a/tests/dfx/conftest.py b/tests/dfx/conftest.py
index a22f760b2..f81dee11c 100644
--- a/tests/dfx/conftest.py
+++ b/tests/dfx/conftest.py
@@ -3,19 +3,160 @@ import os
 import re
 import subprocess
 import threading
-import time
 from datetime import datetime
 from pathlib import Path
 from typing import Any
 
 import pytest
 
-from tests.dfx.reliability.helpers import list_remote_process_pids_by_pattern, post_chat_completions_raw
+from tests.helpers.mark import get_hardware_mark_list, hardware_marks
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import modify_stage_config
 from vllm_omni.platforms import current_omni_platform
 
 
+def _named_pytest_marks(names: list[str]) -> list[pytest.MarkDecorator]:
+    marks: list[pytest.MarkDecorator] = []
+    for name in names:
+        name = name.strip()
+        if not name:
+            raise ValueError("mark name must be a non-empty string")
+        marks.append(getattr(pytest.mark, name))
+    return marks
+
+
+def _hardware_marks_from_dict(hw: Any) -> list[pytest.MarkDecorator]:
+    if not isinstance(hw, dict):
+        raise ValueError(f"mark.hardware_marks must be a dict, got {type(hw).__name__}")
+    res = hw.get("res")
+    if not isinstance(res, dict):
+        raise ValueError(f"mark.hardware_marks.res must be a dict, got {type(res).__name__}")
+    num_cards = hw.get("num_cards", 1)
+    return list(hardware_marks(res=res, num_cards=num_cards))
+
+
+def resolve_pytest_marks(mark_field: Any) -> list[pytest.MarkDecorator]:
+    """Convert a JSON ``mark`` field into pytest mark decorators.
+
+    Supported form (per test-case object in perf/stability JSON)::
+
+        "mark": [
+            {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}},
+            "full_model",
+            "diffusion"
+        ]
+
+    Exactly one ``hardware_marks`` object is required when ``mark`` is present.
+    ``hardware_marks`` delegates to :func:`tests.helpers.mark.hardware_marks`
+    (same shape as ``@hardware_test``). Additional array entries are registered
+    pytest marker names (strings).
+    """
+    if mark_field is None:
+        return []
+
+    if isinstance(mark_field, list):
+        marks: list[pytest.MarkDecorator] = []
+        hw_seen = False
+        for item in mark_field:
+            if isinstance(item, dict) and "hardware_marks" in item:
+                if hw_seen:
+                    raise ValueError("mark array must contain at most one hardware_marks object")
+                hw_seen = True
+                marks.extend(_hardware_marks_from_dict(item["hardware_marks"]))
+                unknown_keys = set(item) - {"hardware_marks"}
+                if unknown_keys:
+                    raise ValueError(
+                        f"mark hardware_marks object only allows hardware_marks; unknown keys: {sorted(unknown_keys)}"
+                    )
+            elif isinstance(item, str):
+                item = item.strip()
+                if not item:
+                    raise ValueError("mark name must be a non-empty string")
+                marks.extend(_named_pytest_marks([item]))
+            else:
+                raise ValueError(
+                    f"mark array entries must be hardware_marks objects or marker name strings; got {type(item).__name__}"
+                )
+        if not hw_seen:
+            raise ValueError("mark array must contain a hardware_marks object")
+        return marks
+
+    raise ValueError(f"mark must be a list; got {type(mark_field).__name__}")
+
+
+def _mark_names(mark_field: Any) -> set[str]:
+    if isinstance(mark_field, list):
+        return {str(item) for item in mark_field if isinstance(item, str)}
+    return set()
+
+
+def is_diffusion_perf_config(cfg: dict[str, Any]) -> bool:
+    """True for perf JSON cases intended for ``run_diffusion_benchmark.py``."""
+    if cfg.get("server_type") is not None:
+        return True
+    return "diffusion" in _mark_names(cfg.get("mark"))
+
+
+def _marks_by_test_name(configs: list[dict[str, Any]]) -> dict[str, list[pytest.MarkDecorator]]:
+    return {str(cfg["test_name"]): resolve_pytest_marks(cfg.get("mark")) for cfg in configs}
+
+
+def create_unique_server_pytest_params(
+    configs: list[dict[str, Any]],
+    stage_configs_dir: Path,
+) -> list[Any]:
+    """Like :func:`create_unique_server_params`, but wrap each row in ``pytest.param`` with JSON marks."""
+    marks_by_name = _marks_by_test_name(configs)
+    return [
+        pytest.param(
+            row,
+            marks=marks_by_name.get(row[0], []),
+            id=row[0],
+        )
+        for row in create_unique_server_params(configs, stage_configs_dir)
+    ]
+
+
+def create_paired_benchmark_pytest_params(
+    server_entries: list[tuple[Any, str]],
+    params_by_test_name: dict[str, list[Any]],
+    marks_by_name: dict[str, list[pytest.MarkDecorator]],
+) -> list[Any]:
+    """One ``pytest.param`` per ``(server entry, benchmark index)`` pair.
+
+    Pass ``server_entry`` and ``(test_name, idx)`` as separate ``pytest.param``
+    arguments for ``@pytest.mark.parametrize("server_fixture,benchmark_params", ...)``.
+    """
+    pairs: list[Any] = []
+    for server_entry, test_name in server_entries:
+        params_list = params_by_test_name.get(test_name, [])
+        id_suffixes = _unique_benchmark_param_id_suffixes(params_list)
+        for idx, id_suffix in enumerate(id_suffixes):
+            pairs.append(
+                pytest.param(
+                    server_entry,
+                    (test_name, idx),
+                    marks=marks_by_name.get(test_name, []),
+                    id=f"{test_name}-{id_suffix}",
+                )
+            )
+    return pairs
+
+
+def create_paired_omni_benchmark_pytest_params(
+    configs: list[dict[str, Any]],
+    stage_configs_dir: Path,
+) -> list[Any]:
+    """Paired params for ``run_benchmark.py`` (omni/tts)."""
+    mapping = create_test_parameter_mapping(configs)
+    marks_by_name = _marks_by_test_name(configs)
+    server_entries = [(row, row[0]) for row in create_unique_server_params(configs, stage_configs_dir)]
+    params_by_test_name = {
+        test_name: get_benchmark_params_for_server(test_name, mapping) for _, test_name in server_entries
+    }
+    return create_paired_benchmark_pytest_params(server_entries, params_by_test_name, marks_by_name)
+
+
 def load_configs(config_path: str) -> list[dict[str, Any]]:
     try:
         abs_path = Path(config_path).resolve()
@@ -32,6 +173,29 @@ def load_configs(config_path: str) -> list[dict[str, Any]]:
         raise RuntimeError(f"Failed to load configuration file: {str(e)}")
 
 
+def load_benchmark_configs(
+    config_path: str | None = None,
+    *,
+    config_dir: Path | None = None,
+) -> list[dict[str, Any]]:
+    """Load one benchmark JSON file, or merge all ``*.json`` under *config_dir*.
+
+    When *config_path* is omitted, every ``*.json`` in *config_dir* is loaded and
+    concatenated. Pytest ``-m`` expressions then select cases via each entry's
+    ``mark`` field (e.g. ``-m tts`` after bulk load).
+    """
+    if config_path is not None:
+        return load_configs(config_path)
+    if config_dir is None:
+        raise ValueError("load_benchmark_configs requires config_path or config_dir")
+    configs: list[dict[str, Any]] = []
+    for path in sorted(config_dir.glob("*.json")):
+        configs.extend(load_configs(str(path)))
+    if not configs:
+        raise ValueError(f"No benchmark JSON files found under {config_dir}")
+    return configs
+
+
 def modify_stage(default_path: str, updates: dict[str, Any] | None, deletes: dict[str, Any] | None) -> str:
     kwargs: dict[str, Any] = {}
     if updates is not None:
@@ -165,10 +329,6 @@ def supports_video_generation(model_name: str) -> bool:
     return any(key in lower for key in ("wan", "video", "i2v", "t2v"))
 
 
-def supports_chat_generation(model_name: str) -> bool:
-    return not supports_video_generation(model_name)
-
-
 def parse_stage_devices(stage_config_path: str) -> str:
     text = Path(stage_config_path).read_text(encoding="utf-8")
     raw_devices: list[str] = re.findall(r"^\s*devices:\s*\"?([0-9,\s]+)\"?\s*$", text, flags=re.MULTILINE)
@@ -197,48 +357,6 @@ def assert_fault_exception(exc: Exception, error_keywords: tuple[str, ...]) -> N
     assert any(key in text for key in error_keywords), f"unexpected error under fault injection: {exc}"
 
 
-def wait_chat_request_ready(host: str, port: int, model: str, timeout_sec: int = 180) -> None:
-    """Poll a minimal chat request until success."""
-    deadline = time.time() + timeout_sec
-    payload = json.dumps(
-        {
-            "model": model,
-            "messages": [{"role": "user", "content": "Say hello in one short sentence."}],
-            "stream": False,
-            "modalities": ["text"],
-        }
-    )
-    last_error: str | None = None
-    while time.time() < deadline:
-        try:
-            status, body = post_chat_completions_raw(host, port, payload)
-            if status == 200:
-                return
-            last_error = f"http={status} body={body[:200]!r}"
-        except Exception as exc:  # noqa: BLE001
-            last_error = str(exc)
-        time.sleep(2)
-    raise TimeoutError(f"runtime-teardown warmup request did not succeed within {timeout_sec}s: {last_error}")
-
-
-def assert_no_extra_worker_processes(
-    baseline_pids: set[int],
-    worker_pattern: str,
-    timeout_sec: int = 60,
-) -> None:
-    """Ensure no extra worker PIDs remain after teardown."""
-    deadline = time.time() + timeout_sec
-    while time.time() < deadline:
-        current = set(list_remote_process_pids_by_pattern(worker_pattern))
-        extra = current - baseline_pids
-        if not extra:
-            return
-        time.sleep(2)
-    current = set(list_remote_process_pids_by_pattern(worker_pattern))
-    extra = sorted(current - baseline_pids)
-    assert not extra, f"orphan worker processes remain after container teardown: {extra}"
-
-
 def create_test_parameter_mapping(configs: list[dict[str, Any]]) -> dict[str, dict]:
     mapping = {}
     for config in configs:
@@ -293,28 +411,167 @@ def _safe_filename_token(value: Any | None, *, default: str = "na") -> str:
     return s if s else default
 
 
+def _benchmark_param_id_suffix(param: dict[str, Any], *, idx: int) -> str:
+    """Derive a readable pytest id suffix from one ``benchmark_params`` entry."""
+    name = param.get("name")
+    if isinstance(name, str) and name.strip():
+        return _safe_filename_token(name.strip())
+
+    parts: list[str] = []
+    for key in ("task", "eval_phase", "dataset_name", "dataset"):
+        value = param.get(key)
+        if value is None or value == "":
+            continue
+        token = _safe_filename_token(str(value))
+        if token != "na":
+            parts.append(token)
+    if parts:
+        return "_".join(parts)
+
+    return f"case{idx}"
+
+
+def _unique_benchmark_param_id_suffixes(params_list: list[dict[str, Any]]) -> list[str]:
+    """Return unique pytest id suffixes for a server's benchmark param list."""
+    raw = [_benchmark_param_id_suffix(param, idx=idx) for idx, param in enumerate(params_list)]
+    seen: dict[str, int] = {}
+    unique: list[str] = []
+    for suffix in raw:
+        count = seen.get(suffix, 0)
+        seen[suffix] = count + 1
+        if count == 0:
+            unique.append(suffix)
+        else:
+            unique.append(f"{suffix}_{count}")
+    return unique
+
+
+# Device marketing-name tokens for ``get_runtime_resource_label`` only.
+# Longer / more specific tokens must appear before shorter substrings
+# (e.g. ``H200`` before ``H20``, ``910B4`` before ``910``).
+_RUNTIME_DEVICE_ALIASES: tuple[str, ...] = (
+    "H100",
+    "H800",
+    "H200",
+    "H20",
+    "B200",
+    "GB200",
+    "L40S",
+    "L40",
+    "L4",
+    "A100",
+    "A800",
+    "A10G",
+    "A10",
+    "A30",
+    "MI325",
+    "MI300",
+    "MI250",
+    "B60",
+    "S5000",
+    "910B4",
+    "910B",
+    "910",
+    "310P",
+    "A2",
+    "A3",
+)
+_RUNTIME_RESOURCE_LABEL: str | None = None
+
+
+def _normalize_runtime_device_label(raw: str) -> str:
+    """Map a platform device name to a short filename-safe resource token."""
+    if not raw or not str(raw).strip():
+        return "na"
+    upper = str(raw).upper()
+    for token in _RUNTIME_DEVICE_ALIASES:
+        if token.upper() in upper:
+            return _safe_filename_token(token)
+    compact = re.sub(r"[^a-zA-Z0-9]+", "", str(raw))
+    for prefix in ("NVIDIA", "AMD", "ASCEND", "HUAWEI"):
+        if compact.upper().startswith(prefix):
+            compact = compact[len(prefix) :]
+            break
+    return _safe_filename_token(compact[:48]) if compact else "na"
+
+
+def _read_runtime_device_name(*, device_id: int = 0) -> str | None:
+    """Device name from the active Omni platform."""
+    if current_omni_platform.device_count() <= device_id:
+        return None
+    get_name = getattr(current_omni_platform, "get_device_name", None)
+    if not callable(get_name):
+        return None
+    raw = get_name(device_id)
+    if isinstance(raw, str) and raw.strip():
+        return raw.strip()
+    return None
+
+
+def get_runtime_resource_label(*, device_id: int = 0, refresh: bool = False) -> str:
+    """Return a filename-safe hardware label detected on the running machine."""
+    global _RUNTIME_RESOURCE_LABEL
+    if not refresh and _RUNTIME_RESOURCE_LABEL is not None:
+        return _RUNTIME_RESOURCE_LABEL
+    raw = _read_runtime_device_name(device_id=device_id)
+    label = _normalize_runtime_device_label(raw) if raw else "na"
+    if not refresh:
+        _RUNTIME_RESOURCE_LABEL = label
+    return label
+
+
+_FILENAME_OMIT_RESOURCE_LABELS = frozenset({"H100"})
+
+
+def hardware_json_value(resource_label: str | None) -> str:
+    """Hardware token stored in perf result JSON (empty when unknown)."""
+    token = _safe_filename_token(resource_label)
+    return "" if token == "na" else token
+
+
+def resource_label_for_filename(resource_label: str | None) -> str:
+    """Hardware token embedded in result filenames (H100 omitted on default CI pool)."""
+    token = _safe_filename_token(resource_label)
+    if token in _FILENAME_OMIT_RESOURCE_LABELS:
+        return ""
+    return token
+
+
+def is_hardware_nested_baseline(baseline: dict[str, Any]) -> bool:
+    """True for ``{"H100": {"metric": ...}, "A3": {...}}`` baselines.
+
+    Detection is structural + hardware-label allowlist (not metric-name hints):
+
+    - every top-level value is a non-empty dict (per-hardware metric map);
+    - every top-level key is in :func:`tests.helpers.mark.get_hardware_mark_list`
+      (``[hardware-resource]`` markers from ``pyproject.toml``).
+
+    Metric names under each hardware bucket are unconstrained.
+    Runtime device aliases (:data:`_RUNTIME_DEVICE_ALIASES`) are unrelated.
+    """
+    if not baseline:
+        return False
+    if not all(isinstance(value, dict) and bool(value) for value in baseline.values()):
+        return False
+    allowed = {label.upper() for label in get_hardware_mark_list()}
+    return all((token := str(key).strip()) and token.upper() in allowed for key in baseline.keys())
+
+
 def resolve_baseline_value(
     baseline_raw: Any,
     *,
     sweep_index: int | None,
-    max_concurrency: Any = None,
-    request_rate: Any = None,
 ) -> Any:
-    """Pick the baseline threshold for this sweep step."""
+    """Pick the baseline threshold for one metric at this sweep step.
+
+    Accepts a sweep-aligned list/tuple (indexed by ``sweep_index``) or a scalar.
+    """
     if baseline_raw is None:
-        return 100000
+        return None
     if isinstance(baseline_raw, dict):
-        if max_concurrency is not None:
-            for key in (max_concurrency, str(max_concurrency)):
-                if key in baseline_raw:
-                    return baseline_raw[key]
-        if request_rate is not None:
-            for key in (request_rate, str(request_rate)):
-                if key in baseline_raw:
-                    return baseline_raw[key]
-        raise KeyError(
-            f"baseline dict has no key for max_concurrency={max_concurrency!r} "
-            f"or request_rate={request_rate!r}; keys={list(baseline_raw.keys())!r}"
+        raise TypeError(
+            "per-metric baseline dict keyed by concurrency/request-rate is not supported; "
+            "use a sweep-aligned list or a scalar under each hardware bucket"
         )
     if isinstance(baseline_raw, (list, tuple)):
         if sweep_index is None:
@@ -325,22 +582,62 @@ def resolve_baseline_value(
     return baseline_raw
 
 
-def _baseline_thresholds_for_step(
-    baseline_data: dict[str, Any],
+def resolve_baseline_for_sweep(
+    baseline_config: dict[str, Any] | None,
     *,
     sweep_index: int | None = None,
-    max_concurrency: Any = None,
-    request_rate: Any = None,
 ) -> dict[str, Any]:
-    """Resolve baseline config to one threshold per metric for this iteration."""
-    return {
-        metric_name: resolve_baseline_value(
-            baseline_raw,
-            sweep_index=sweep_index,
-            max_concurrency=max_concurrency,
-            request_rate=request_rate,
+    """Resolve sweep-dependent baselines while keeping every hardware bucket.
+
+    Expects hardware-nested input only::
+
+        {"H100": {"throughput_qps": [a, b, c]}, "A3": {"throughput_qps": [x, y, z]}}
+
+    with ``sweep_index=2`` (e.g. concurrency 32) becomes::
+
+        {"H100": {"throughput_qps": c}, "A3": {"throughput_qps": z}}
+
+    Per-metric values may be a sweep-aligned list or a scalar.
+    """
+    if not baseline_config:
+        return {}
+    if not is_hardware_nested_baseline(baseline_config):
+        allowed = sorted(get_hardware_mark_list())
+        unknown = [
+            str(key).strip()
+            for key in baseline_config.keys()
+            if str(key).strip().upper() not in {label.upper() for label in allowed}
+        ]
+        nested_shape = all(isinstance(value, dict) and bool(value) for value in baseline_config.values())
+        if nested_shape and unknown:
+            raise ValueError(
+                "baseline top-level keys must be [hardware-resource] pytest markers from "
+                "pyproject.toml (tool.pytest.ini_options.markers). "
+                f"Unknown hardware label(s): {unknown!r}. "
+                f"Known markers: {allowed!r}. "
+                "Add a marker such as '\"A100: [hardware-resource] Tests that require A100 GPU\"' "
+                "to pyproject.toml, then retry."
+            )
+        raise ValueError(
+            "baseline must be hardware-nested with [hardware-resource] marker names as "
+            "top-level keys, e.g. "
+            '{"H100": {"throughput_qps": [...]}, "A3": {"custom_metric": 1.0}}. '
+            f"got top-level keys={list(baseline_config.keys())!r}; "
+            f"known markers={allowed!r}. "
+            "If you need a new hardware bucket, add it to pyproject.toml markers with "
+            "the [hardware-resource] tag."
         )
-        for metric_name, baseline_raw in baseline_data.items()
+
+    return {
+        hardware: {
+            metric_name: resolve_baseline_value(
+                baseline_raw,
+                sweep_index=sweep_index,
+            )
+            for metric_name, baseline_raw in metrics.items()
+        }
+        for hardware, metrics in baseline_config.items()
+        if isinstance(metrics, dict)
     }
 
 
@@ -353,21 +650,26 @@ def run_benchmark(
     *,
     baseline_config: dict[str, Any] | None = None,
     sweep_index: int | None = None,
-    request_rate: Any | None = None,
-    max_concurrency: Any | None = None,
     random_input_len: Any | None = None,
     random_output_len: Any | None = None,
+    resource_label: str | None = None,
 ) -> dict[str, Any]:
     """Run one ``vllm bench serve --omni`` iteration and return parsed metrics.
 
-    After ``vllm bench`` writes the JSON, ``result["baseline"]`` holds the resolved per-metric thresholds
-    (when ``baseline_config`` is provided). If the benchmark exits without writing a result file,
-    ``result_omni_template.json`` is used as a fallback.
+    After ``vllm bench`` writes the JSON, ``result["baseline"]`` stores the
+    sweep-resolved baseline (when ``baseline_config`` is provided). Hardware-nested
+    maps keep every hardware bucket, but each metric is reduced to the value for
+    this concurrency / request-rate step. If the benchmark exits without writing a
+    result file, ``result_omni_template.json`` is used as a fallback.
     """
     current_dt = datetime.now().strftime("%Y%m%d-%H%M%S")
     ri = _safe_filename_token(random_input_len)
     ro = _safe_filename_token(random_output_len)
-    result_filename = f"result_{test_name}_{dataset_name}_{flow}_{num_prompt}_in{ri}_out{ro}_{current_dt}.json"
+    hw = resource_label_for_filename(resource_label)
+    if hw:
+        result_filename = f"result_{test_name}_{hw}_{dataset_name}_{flow}_{num_prompt}_in{ri}_out{ro}_{current_dt}.json"
+    else:
+        result_filename = f"result_{test_name}_{dataset_name}_{flow}_{num_prompt}_in{ri}_out{ro}_{current_dt}.json"
     if "--result-filename" in args:
         print(f"The result file will be overwritten by {result_filename}")
     command = (
@@ -425,11 +727,10 @@ def run_benchmark(
             result = json.load(f)
 
     if baseline_config:
-        result["baseline"] = _baseline_thresholds_for_step(
+        # Keep every hardware bucket; resolve list metrics to this sweep step.
+        result["baseline"] = resolve_baseline_for_sweep(
             baseline_config,
             sweep_index=sweep_index,
-            request_rate=request_rate,
-            max_concurrency=max_concurrency,
         )
     else:
         result["baseline"] = {}
@@ -437,6 +738,7 @@ def run_benchmark(
         result["random_input_len"] = random_input_len
     if random_output_len is not None:
         result["random_output_len"] = random_output_len
+    result["Hardware"] = hardware_json_value(resource_label)
     with open(result_path, "w", encoding="utf-8") as f:
         json.dump(result, f, ensure_ascii=False, indent=2)
     return result
@@ -450,12 +752,3 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         default=None,
         help=("Path to benchmark config JSON. Example: --test-config-file tests/dfx/perf/tests/test_tts.json"),
     )
-    parser.addoption(
-        "--assert-baseline",
-        action="store_true",
-        default=False,
-        help=(
-            "When set, omni/diffusion perf runners compare metrics against the baseline block in the JSON config "
-            "(default: off)."
-        ),
-    )
diff --git a/tests/dfx/perf/scripts/diffusion_result_template.json b/tests/dfx/perf/scripts/diffusion_result_template.json
index ba16a993d..abb41c48b 100644
--- a/tests/dfx/perf/scripts/diffusion_result_template.json
+++ b/tests/dfx/perf/scripts/diffusion_result_template.json
@@ -21,10 +21,12 @@
       "num-input-images": 0,
       "enable-negative-prompt": false,
       "baseline": {
-        "throughput_qps": 0,
-        "latency_mean": 0,
-        "peak_memory_mb_max": 0,
-        "peak_memory_mb_mean": 0
+        "H100": {
+          "throughput_qps": 0,
+          "latency_mean": 0,
+          "peak_memory_mb_max": 0,
+          "peak_memory_mb_mean": 0
+        }
       }
     },
     "result": {
diff --git a/tests/dfx/perf/scripts/result_omni_template.json b/tests/dfx/perf/scripts/result_omni_template.json
index 1d6132140..ca94be0f7 100644
--- a/tests/dfx/perf/scripts/result_omni_template.json
+++ b/tests/dfx/perf/scripts/result_omni_template.json
@@ -46,9 +46,11 @@
   "median_audio_duration_s": 0,
   "p99_audio_duration_s": 0,
   "baseline": {
-    "mean_ttft_ms": 0,
-    "mean_audio_ttfp_ms": 0,
-    "mean_audio_rtf": 0
+    "H100": {
+      "mean_ttft_ms": 0,
+      "mean_audio_ttfp_ms": 0,
+      "mean_audio_rtf": 0
+    }
   },
   "random_input_len": 0,
   "random_output_len": 0
diff --git a/tests/dfx/perf/scripts/run_benchmark.py b/tests/dfx/perf/scripts/run_benchmark.py
index 13329a209..4ab7959d2 100644
--- a/tests/dfx/perf/scripts/run_benchmark.py
+++ b/tests/dfx/perf/scripts/run_benchmark.py
@@ -1,27 +1,27 @@
 import json
 import os
 import threading
+from collections.abc import Callable
+from contextlib import AbstractContextManager, ExitStack, contextmanager
 from pathlib import Path
 from typing import Any
 
 import pytest
 
 from tests.dfx.conftest import (
-    create_benchmark_indices,
+    create_paired_omni_benchmark_pytest_params,
     create_test_parameter_mapping,
-    create_unique_server_params,
     get_benchmark_params_for_server,
-    load_configs,
-    resolve_baseline_value,
+    get_runtime_resource_label,
+    is_diffusion_perf_config,
+    load_benchmark_configs,
     run_benchmark,
 )
 from tests.helpers.runtime import OmniServer
 
-pytestmark = [pytest.mark.full_model]
-
-# Compare metrics to each test JSON ``baseline`` block only when pytest is run with ``--assert-baseline``
-# (registered in ``tests/dfx/conftest.py``; default: off). ``run_benchmark`` and ``_resolve_baseline_value`` are
-# defined in the same module.
+# Optional JSON field ``mark`` is applied as pytest marks via
+# ``create_paired_omni_benchmark_pytest_params`` (e.g. ``"mark": [{"hardware_marks":
+# {"res": {"cuda": "H100"}, "num_cards": 2}}, "full_model", "omni"]``).
 
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
@@ -40,67 +40,104 @@ def _get_config_file_from_argv() -> str | None:
 
 
 _PERF_TESTS_DIR = Path(__file__).resolve().parent.parent / "tests"
-_DEFAULT_CONFIG_FILE = str(_PERF_TESTS_DIR / "test_qwen_omni.json")
 
 CONFIG_FILE_PATH = _get_config_file_from_argv()
 if CONFIG_FILE_PATH is None:
+    _all_configs = load_benchmark_configs(config_dir=_PERF_TESTS_DIR)
+    BENCHMARK_CONFIGS = [cfg for cfg in _all_configs if not is_diffusion_perf_config(cfg)]
     print(
-        "No --test-config-file in argv, using default: tests/dfx/perf/tests/test_qwen_omni.json "
-        "(override with e.g. --test-config-file tests/dfx/perf/tests/test_tts.json)"
+        f"No --test-config-file: loaded {len(BENCHMARK_CONFIGS)} omni/tts case(s) from "
+        f"{_PERF_TESTS_DIR}/*.json (skipped {len(_all_configs) - len(BENCHMARK_CONFIGS)} diffusion; "
+        f"use -m to filter, e.g. -m tts)"
     )
-    CONFIG_FILE_PATH = _DEFAULT_CONFIG_FILE
-
-BENCHMARK_CONFIGS = load_configs(CONFIG_FILE_PATH)
-
+else:
+    BENCHMARK_CONFIGS = load_benchmark_configs(CONFIG_FILE_PATH)
 
 DEPLOY_CONFIGS_DIR = Path(__file__).parent.parent / "deploy"
-test_params = create_unique_server_params(BENCHMARK_CONFIGS, DEPLOY_CONFIGS_DIR)
 server_to_benchmark_mapping = create_test_parameter_mapping(BENCHMARK_CONFIGS)
+paired_benchmark_params = create_paired_omni_benchmark_pytest_params(BENCHMARK_CONFIGS, DEPLOY_CONFIGS_DIR)
 
 _omni_server_lock = threading.Lock()
 
 
+class _SingleActiveContext:
+    """Reuse one active context while its configuration key is unchanged."""
+
+    def __init__(self) -> None:
+        self._key: Any = None
+        self._stack: ExitStack | None = None
+        self._value: Any = None
+
+    def acquire(self, key: Any, factory: Callable[[], AbstractContextManager[Any]]) -> Any:
+        if self._stack is not None and key == self._key:
+            return self._value
+
+        self.close()
+        stack = ExitStack()
+        value = stack.enter_context(factory())
+        self._key = key
+        self._stack = stack
+        self._value = value
+        return value
+
+    def close(self) -> None:
+        stack = self._stack
+        self._key = None
+        self._stack = None
+        self._value = None
+        if stack is not None:
+            stack.close()
+
+
+@contextmanager
+def _start_omni_server(server_param):
+    test_name, model, stage_config_path, stage_overrides, extra_cli_args, use_omni = server_param
+
+    print(f"Starting OmniServer with test: {test_name}, model: {model}")
+
+    server_args: list[str] = []
+    if use_omni:
+        server_args += ["--stage-init-timeout", "600", "--init-timeout", "900"]
+    # --deploy-config and --stage-overrides compose at the CLI (see vllm_omni/entrypoints/utils.py):
+    # deploy-config sets the base; stage-overrides are applied on top. Both can be set.
+    if stage_config_path:
+        server_args = ["--deploy-config", stage_config_path] + server_args
+    if stage_overrides:
+        server_args = ["--stage-overrides", stage_overrides] + server_args
+    if extra_cli_args:
+        server_args = list(extra_cli_args) + server_args
+    with OmniServer(model, server_args, use_omni=use_omni) as server:
+        server.test_name = test_name
+        print("OmniServer started successfully")
+        yield server
+        print("OmniServer stopping...")
+
+    print("OmniServer stopped")
+
+
 @pytest.fixture(scope="module")
-def omni_server(request):
+def omni_server_context():
     """Start vLLM-Omni server as a subprocess with actual model weights.
-    Uses session scope so the server starts only once for the entire test session.
+    Reuse it for adjacent benchmark cases with the same server configuration.
     Multi-stage initialization can take 10-20+ minutes.
     """
     with _omni_server_lock:
-        test_name, model, stage_config_path, stage_overrides, extra_cli_args, use_omni = request.param
-
-        print(f"Starting OmniServer with test: {test_name}, model: {model}")
-
-        server_args: list[str] = []
-        if use_omni:
-            server_args += ["--stage-init-timeout", "600", "--init-timeout", "900"]
-        # --deploy-config and --stage-overrides compose at the CLI (see vllm_omni/entrypoints/utils.py):
-        # deploy-config sets the base; stage-overrides are applied on top. Both can be set.
-        if stage_config_path:
-            server_args = ["--deploy-config", stage_config_path] + server_args
-        if stage_overrides:
-            server_args = ["--stage-overrides", stage_overrides] + server_args
-        if extra_cli_args:
-            server_args = list(extra_cli_args) + server_args
-        with OmniServer(model, server_args, use_omni=use_omni) as server:
-            server.test_name = test_name
-            print("OmniServer started successfully")
-            yield server
-            print("OmniServer stopping...")
-
-        print("OmniServer stopped")
-
-
-benchmark_indices = create_benchmark_indices(BENCHMARK_CONFIGS, server_to_benchmark_mapping)
+        active_context = _SingleActiveContext()
+        try:
+            yield active_context
+        finally:
+            active_context.close()
 
 
 @pytest.fixture
-def benchmark_params(request, omni_server):
-    """Benchmark parameters fixture with proper parametrization"""
-    test_name, param_index = request.param
+def omni_server(request, omni_server_context):
+    return omni_server_context.acquire(request.param, lambda: _start_omni_server(request.param))
 
-    if test_name != omni_server.test_name:
-        pytest.skip(f"Skipping parameter for {test_name} - current server is {omni_server.test_name}")
+
+@pytest.fixture
+def benchmark_params(request):
+    """Benchmark parameters fixture; paired with ``omni_server`` via parametrization."""
+    test_name, param_index = request.param
 
     all_params = get_benchmark_params_for_server(test_name, server_to_benchmark_mapping)
 
@@ -120,42 +157,17 @@ def benchmark_params(request, omni_server):
     }
 
 
-def assert_result(
-    result,
-    params,
-    num_prompt,
-    *,
-    assert_baseline: bool,
-    sweep_index: int | None = None,
-    max_concurrency: Any | None = None,
-    request_rate: Any | None = None,
-) -> None:
+def assert_result(result, num_prompt) -> None:
     assert result["completed"] == num_prompt, "Request failures exist"
-    if not assert_baseline:
-        return
-    baseline_data = params.get("baseline", {})
-    for metric_name, baseline_raw in baseline_data.items():
-        current_value = result[metric_name]
-        baseline_value = resolve_baseline_value(
-            baseline_raw,
-            sweep_index=sweep_index,
-            max_concurrency=max_concurrency,
-            request_rate=request_rate,
-        )
-        if "throughput" in metric_name:
-            if current_value <= baseline_value:
-                print(
-                    f"ERROR: Throughput test results were below baseline: {metric_name}: {current_value} > {baseline_value}"
-                )
-        else:
-            if current_value >= baseline_value:
-                print(f"ERROR: Test results exceeded baseline: {metric_name}: {current_value} < {baseline_value}")
 
 
 @pytest.mark.benchmark
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
-@pytest.mark.parametrize("benchmark_params", benchmark_indices, indirect=True)
-def test_performance_benchmark(omni_server, benchmark_params, request):
+@pytest.mark.parametrize(
+    "omni_server,benchmark_params",
+    paired_benchmark_params,
+    indirect=["omni_server", "benchmark_params"],
+)
+def test_performance_benchmark(omni_server, benchmark_params):
     test_name = benchmark_params["test_name"]
     params = benchmark_params["params"]
     dataset_name = params.get("dataset_name", "")
@@ -167,7 +179,7 @@ def test_performance_benchmark(omni_server, benchmark_params, request):
     print(f"Running benchmark for model: {model}")
     print(f"Benchmark parameters: {benchmark_params}")
 
-    assert_baseline = request.config.getoption("--assert-baseline", default=False)
+    resource_label = get_runtime_resource_label()
 
     def to_list(value, default=None):
         if value is None:
@@ -225,7 +237,7 @@ def test_performance_benchmark(omni_server, benchmark_params, request):
         break
 
     # QPS / request-rate sweep
-    for i, (qps, num_prompt) in enumerate(zip(qps_list, num_prompt_list)):
+    for sweep_index, (qps, num_prompt) in enumerate(zip(qps_list, num_prompt_list)):
         args = args + ["--request-rate", str(qps), "--num-prompts", str(num_prompt)]
         result = run_benchmark(
             args=args,
@@ -234,23 +246,15 @@ def test_performance_benchmark(omni_server, benchmark_params, request):
             dataset_name=dataset_name,
             num_prompt=num_prompt,
             baseline_config=params.get("baseline"),
-            sweep_index=i,
-            request_rate=qps,
-            max_concurrency=None,
+            sweep_index=sweep_index,
             random_input_len=params.get("random_input_len"),
             random_output_len=params.get("random_output_len"),
+            resource_label=resource_label,
         )
-        assert_result(
-            result,
-            params,
-            num_prompt,
-            assert_baseline=assert_baseline,
-            sweep_index=i,
-            request_rate=qps,
-        )
+        assert_result(result, num_prompt)
 
     # concurrency test
-    for i, (concurrency, num_prompt) in enumerate(zip(max_concurrency_list, num_prompt_list)):
+    for sweep_index, (concurrency, num_prompt) in enumerate(zip(max_concurrency_list, num_prompt_list)):
         args = args + ["--max-concurrency", str(concurrency), "--num-prompts", str(num_prompt), "--request-rate", "inf"]
         result = run_benchmark(
             args=args,
@@ -259,17 +263,9 @@ def test_performance_benchmark(omni_server, benchmark_params, request):
             dataset_name=dataset_name,
             num_prompt=num_prompt,
             baseline_config=params.get("baseline"),
-            sweep_index=i,
-            request_rate=None,
-            max_concurrency=concurrency,
+            sweep_index=sweep_index,
             random_input_len=params.get("random_input_len"),
             random_output_len=params.get("random_output_len"),
+            resource_label=resource_label,
         )
-        assert_result(
-            result,
-            params,
-            num_prompt,
-            assert_baseline=assert_baseline,
-            sweep_index=i,
-            max_concurrency=concurrency,
-        )
+        assert_result(result, num_prompt)
diff --git a/tests/dfx/perf/scripts/run_diffusion_benchmark.py b/tests/dfx/perf/scripts/run_diffusion_benchmark.py
index b0860978b..75d1bdc21 100644
--- a/tests/dfx/perf/scripts/run_diffusion_benchmark.py
+++ b/tests/dfx/perf/scripts/run_diffusion_benchmark.py
@@ -8,15 +8,19 @@ This runner separates two concepts:
 2. ``benchmark_endpoint``: which serving API the benchmark client calls.
    Examples: ``/v1/chat/completions`` and ``/v1/videos``.
 
-A config JSON file is REQUIRED via --test-config-file:
+A config JSON file may be passed via --test-config-file. If omitted, every ``*.json`` under
+``tests/dfx/perf/tests/`` is loaded and pytest ``-m`` filters by each case's ``mark``:
+  pytest run_diffusion_benchmark.py -m "diffusion"
   pytest run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
 
-Optional: ``--assert-baseline`` compares metrics to the ``baseline`` block in each benchmark entry (default: off).
+Optional JSON field ``mark`` is applied as pytest marks on that case via
+``pytest.param`` (e.g. ``"mark": [{"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}}, "full_model", "diffusion"]``).
 
-All benchmark results for a session are consolidated into a single JSON file under
-BENCHMARK_RESULT_DIR (override via the DIFFUSION_BENCHMARK_DIR environment variable).
-Each entry in the file contains the test metadata (test_name, endpoint, benchmark_params,
-timestamp) together with the raw metrics returned by the benchmark script.
+All benchmark results are written under BENCHMARK_RESULT_DIR (override via the
+DIFFUSION_BENCHMARK_DIR environment variable). Each source JSON file gets one
+aggregated ``diffusion_result_{config_stem}_{hardware}_{timestamp}.json`` (JSON array
+of all runs from cases in that file). Bulk load without ``--test-config-file`` uses
+the same per-file aggregation; ``-m`` only selects which cases run.
 """
 
 import json
@@ -35,8 +39,16 @@ import psutil
 import pytest
 
 from benchmarks.diffusion.backends import endpoint_filename_token, normalize_endpoint
-
-pytestmark = [pytest.mark.diffusion, pytest.mark.full_model, pytest.mark.local_model]
+from tests.dfx.conftest import (
+    create_paired_benchmark_pytest_params,
+    get_runtime_resource_label,
+    hardware_json_value,
+    is_diffusion_perf_config,
+    resolve_baseline_for_sweep,
+    resolve_pytest_marks,
+    resource_label_for_filename,
+)
+from tests.helpers.runtime import get_open_port
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 os.environ.setdefault("DIFFUSION_ATTENTION_BACKEND", "FLASH_ATTN")
@@ -126,6 +138,10 @@ _BRANCHPOINT_COMMIT_SHA: str | None = None
 DIFFUSION_RESULT_TEMPLATE_PATH = Path(__file__).parent / "diffusion_result_template.json"
 
 
+_DIFFUSION_SOURCE_CONFIG_KEY = "_source_config_file"
+_PERF_TESTS_DIR = Path(__file__).resolve().parent.parent / "tests"
+
+
 def _get_config_file_from_argv() -> str | None:
     """Read --test-config-file from sys.argv at import time so pytest parametrize can use it.
 
@@ -142,9 +158,6 @@ def _get_config_file_from_argv() -> str | None:
 
 
 CONFIG_FILE_PATH = _get_config_file_from_argv()
-if CONFIG_FILE_PATH is None:
-    print("No config file provided, using default config file: tests/dfx/perf/tests/test_qwen_image_vllm_omni.json")
-    CONFIG_FILE_PATH = "tests/dfx/perf/tests/test_qwen_image_vllm_omni.json"
 
 # ---------------------------------------------------------------------------
 # Config loading
@@ -184,28 +197,80 @@ def load_configs(config_path: str) -> list[dict[str, Any]]:
         raise RuntimeError(f"Failed to load configuration file: {str(e)}")
 
 
-BENCHMARK_CONFIGS = load_configs(CONFIG_FILE_PATH)
-
-_config_stem = Path(CONFIG_FILE_PATH).stem  # e.g. "test_qwen_image_vllm_omni"
-AGGREGATED_RESULT_FILE = BENCHMARK_RESULT_DIR / f"diffusion_result_{_config_stem}_{_SESSION_TIMESTAMP}.json"
+def load_diffusion_benchmark_configs(
+    config_path: str | None = None,
+    *,
+    config_dir: Path | None = None,
+) -> list[dict[str, Any]]:
+    """Load one diffusion benchmark JSON, or merge all ``*.json`` under *config_dir*."""
+    if config_path is not None:
+        configs = load_configs(config_path)
+        source = str(Path(config_path).resolve())
+        for cfg in configs:
+            cfg.setdefault(_DIFFUSION_SOURCE_CONFIG_KEY, source)
+        return configs
+    if config_dir is None:
+        raise ValueError("load_diffusion_benchmark_configs requires config_path or config_dir")
+    configs: list[dict[str, Any]] = []
+    for path in sorted(config_dir.glob("*.json")):
+        source = str(path.resolve())
+        for cfg in load_configs(str(path)):
+            cfg[_DIFFUSION_SOURCE_CONFIG_KEY] = source
+            configs.append(cfg)
+    if not configs:
+        raise ValueError(f"No benchmark JSON files found under {config_dir}")
+    return configs
 
 
-def _append_to_aggregated_file(record: dict[str, Any]) -> None:
-    """Thread-safe append of *record* to the session-level aggregated JSON file.
+if CONFIG_FILE_PATH is None:
+    _all_configs = load_diffusion_benchmark_configs(config_dir=_PERF_TESTS_DIR)
+    BENCHMARK_CONFIGS = [cfg for cfg in _all_configs if is_diffusion_perf_config(cfg)]
+    print(
+        f"No --test-config-file: loaded {len(BENCHMARK_CONFIGS)} diffusion case(s) from "
+        f"{_PERF_TESTS_DIR}/*.json (skipped {len(_all_configs) - len(BENCHMARK_CONFIGS)} omni/tts; "
+        f"use -m to filter, e.g. -m diffusion)"
+    )
+else:
+    BENCHMARK_CONFIGS = load_diffusion_benchmark_configs(CONFIG_FILE_PATH)
 
-    The file contains a JSON array; each call loads the existing array (or
-    starts a new one), appends the record, and writes the file back atomically.
-    """
+_AGGREGATED_RESULT_FILES_BY_SOURCE: dict[str, Path] = {}
+
+
+def _normalized_source_path(source_file: str) -> str:
+    return str(Path(source_file).resolve())
+
+
+def _aggregated_result_file_for_source(source_file: str) -> Path:
+    """One session aggregate per source JSON (same naming as single ``--test-config-file``)."""
+    key = _normalized_source_path(source_file)
+    if key not in _AGGREGATED_RESULT_FILES_BY_SOURCE:
+        stem = Path(key).stem
+        resource = resource_label_for_filename(get_runtime_resource_label())
+        if resource:
+            result_name = f"diffusion_result_{stem}_{resource}_{_SESSION_TIMESTAMP}.json"
+        else:
+            result_name = f"diffusion_result_{stem}_{_SESSION_TIMESTAMP}.json"
+        _AGGREGATED_RESULT_FILES_BY_SOURCE[key] = BENCHMARK_RESULT_DIR / result_name
+    return _AGGREGATED_RESULT_FILES_BY_SOURCE[key]
+
+
+def _write_result_record(record: dict[str, Any]) -> Path:
+    """Append one benchmark record to the aggregate file for its source JSON."""
+    source_file = record.get("source_file") or CONFIG_FILE_PATH
+    if not source_file:
+        raise ValueError("benchmark record missing source_file")
+    target = _aggregated_result_file_for_source(str(source_file))
     with _RESULT_LOCK:
         BENCHMARK_RESULT_DIR.mkdir(parents=True, exist_ok=True)
-        if AGGREGATED_RESULT_FILE.exists():
-            with open(AGGREGATED_RESULT_FILE, encoding="utf-8") as f:
+        if target.exists():
+            with open(target, encoding="utf-8") as f:
                 records: list[dict] = json.load(f)
         else:
             records = []
         records.append(record)
-        with open(AGGREGATED_RESULT_FILE, "w", encoding="utf-8") as f:
+        with open(target, "w", encoding="utf-8") as f:
             json.dump(records, f, indent=2, ensure_ascii=False)
+    return target
 
 
 _server_lock = threading.Lock()
@@ -215,14 +280,6 @@ _server_lock = threading.Lock()
 # ---------------------------------------------------------------------------
 
 
-def _get_open_port() -> int:
-    """Return an available TCP port on localhost."""
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("", 0))
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        return s.getsockname()[1]
-
-
 def _wait_for_port(host: str, port: int, timeout: int = 1200, proc: subprocess.Popen | None = None) -> None:
     """Block until the given host:port accepts connections or timeout expires.
 
@@ -292,6 +349,56 @@ def _kill_process_tree(pid: int) -> None:
 # ---------------------------------------------------------------------------
 
 
+def _resolve_offline_model(model: str) -> str:
+    """Resolve a model string to a local directory.
+
+    Local paths pass through unchanged. HF repo ids are resolved to their local
+    snapshot dir when ``HF_HUB_OFFLINE`` is set. ``repo_id/subfolder`` (e.g.
+    ``MiniMaxAI/MiniMax-H3/FL2VA``) is resolved to the matching partition
+    subfolder of the snapshot, downloading only that subfolder when online.
+    """
+    import huggingface_hub
+
+    if not model or os.path.isdir(model):
+        return model
+
+    # MiniMax-H3 custom code uses relative imports across files, which breaks
+    # when the HF cache snapshot is symlinked (``get_class_from_dynamic_module``
+    # resolves ``realpath`` into the blobs dir). Mirror the accuracy test's env
+    # overrides so CI / local runs can point at a materialized partition. The
+    # repo-root key (used with ``--task-type fl2va|ref2va``) expects a
+    # materialized root containing the FL2VA/Ref2VA subfolders.
+    model_env_overrides = {
+        "MiniMaxAI/MiniMax-H3": "VLLM_TEST_MINIMAX_H3_MODEL",
+        "MiniMaxAI/MiniMax-H3/FL2VA": "VLLM_TEST_MINIMAX_H3_FL2VA_MODEL",
+        "MiniMaxAI/MiniMax-H3/Ref2VA": "VLLM_TEST_MINIMAX_H3_REF2VA_MODEL",
+    }
+    env_name = model_env_overrides.get(model)
+    if env_name:
+        env_model = os.environ.get(env_name)
+        if env_model:
+            return env_model
+
+    parts = model.split("/")
+    if len(parts) >= 3:
+        repo_id = "/".join(parts[:2])
+        subfolder = "/".join(parts[2:])
+        from huggingface_hub import snapshot_download
+
+        snapshot_root = snapshot_download(
+            repo_id,
+            allow_patterns=[f"{subfolder}/**"],
+            local_files_only=huggingface_hub.constants.HF_HUB_OFFLINE,
+        )
+        return str(Path(snapshot_root) / subfolder)
+
+    if not huggingface_hub.constants.HF_HUB_OFFLINE:
+        return model
+    from huggingface_hub import snapshot_download
+
+    return snapshot_download(model, local_files_only=True)
+
+
 class DiffusionServer:
     """Start a vLLM-Omni diffusion model server as a subprocess.
 
@@ -309,16 +416,21 @@ class DiffusionServer:
         port: int | None = None,
     ) -> None:
         self.server_cfg: dict[str, Any] = server_cfg
-        self.model = server_cfg["model"]
+        self.model = _resolve_offline_model(server_cfg["model"])
         self.serve_args = server_cfg["serve_args"]
         self.host = "127.0.0.1"
-        self.port = port if port is not None else _get_open_port()
+        self.port = port if port is not None else get_open_port(self.host)
         self.proc: subprocess.Popen | None = None
         self.test_name: str = ""
 
     def _start_server(self) -> None:
         env = os.environ.copy()
         env["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+        # Give each run its own writable video-storage dir. The server default
+        # (/tmp/storage) may be missing or not writable on shared hosts / CI.
+        storage_path = Path(os.environ.get("VLLM_OMNI_STORAGE_PATH", str(BENCHMARK_RESULT_DIR / "storage")))
+        storage_path.mkdir(parents=True, exist_ok=True)
+        env["VLLM_OMNI_STORAGE_PATH"] = str(storage_path)
 
         cmd = [
             sys.executable,
@@ -482,6 +594,7 @@ def _unique_server_params(configs: list[dict[str, Any]]) -> list[dict[str, Any]]
                 "serve_args": _build_serve_args(serve_args_dict),
                 "benchmark_endpoint": cfg.get("benchmark_endpoint", cfg.get("benchmark_backend")),
                 "server_params": cfg["server_params"],
+                "mark": cfg.get("mark"),
             }
         )
     return result
@@ -496,19 +609,29 @@ def _test_param_mapping(configs: list[dict[str, Any]]) -> dict[str, list[dict]]:
     return mapping
 
 
-def _make_server(server_cfg: dict[str, Any]) -> DiffusionServer:
-    """Factory: return a vLLM-Omni diffusion server instance for the config."""
-    return DiffusionServer(server_cfg=server_cfg)
+def _marks_by_test_name(configs: list[dict[str, Any]]) -> dict[str, list[pytest.MarkDecorator]]:
+    return {str(cfg["test_name"]): resolve_pytest_marks(cfg.get("mark")) for cfg in configs}
+
+
+def _paired_diffusion_benchmark_pytest_params(configs: list[dict[str, Any]]) -> list[Any]:
+    """Paired params for ``run_diffusion_benchmark.py``; same shape as omni runner."""
+    test_param_map = _test_param_mapping(configs)
+    server_entries = [(cfg, cfg["test_name"]) for cfg in _unique_server_params(configs)]
+    return create_paired_benchmark_pytest_params(server_entries, test_param_map, _marks_by_test_name(configs))
 
 
 # ---------------------------------------------------------------------------
 # Parametrize data
 # ---------------------------------------------------------------------------
 
-server_params = _unique_server_params(BENCHMARK_CONFIGS)
 test_param_map = _test_param_mapping(BENCHMARK_CONFIGS)
+paired_benchmark_params = _paired_diffusion_benchmark_pytest_params(BENCHMARK_CONFIGS)
+
+
+def _make_server(server_cfg: dict[str, Any]) -> DiffusionServer:
+    """Factory: return a vLLM-Omni diffusion server instance for the config."""
+    return DiffusionServer(server_cfg=server_cfg)
 
-benchmark_indices: list[int] = list(range(max(len(v) for v in test_param_map.values())))
 
 # ---------------------------------------------------------------------------
 # Pytest fixtures
@@ -534,16 +657,13 @@ def diffusion_server(request):
 
 
 @pytest.fixture
-def benchmark_params(request, diffusion_server):
-    """Yield the benchmark params dict for the current (server, index) pair."""
-    param_index: int = request.param
-    test_name = diffusion_server.test_name
+def benchmark_params(request):
+    """Benchmark params for the paired server/index parametrization."""
+    test_name, param_index = request.param
 
     params_list = test_param_map.get(test_name, [])
     if not params_list:
         raise ValueError(f"No benchmark params for test: {test_name}")
-    if param_index >= len(params_list):
-        pytest.skip(f"Param index {param_index} out of range for {test_name} (has {len(params_list)} params)")
 
     current = param_index + 1
     total = len(params_list)
@@ -575,8 +695,8 @@ def run_benchmark(
     The raw metrics are written to a temporary file by the subprocess.  After
     the run completes the metrics are merged with full metadata (test_name,
     endpoint, benchmark_params, timestamp, flat reporting fields) and appended
-    to the session-wide aggregated JSON file (AGGREGATED_RESULT_FILE).  The
-    temporary file is removed afterwards.  Subprocess stdout/stderr are tee'd
+    to ``diffusion_result_{config_stem}_{hardware}_{timestamp}.json`` for the
+    source JSON file. The temporary file is removed afterwards.  Subprocess stdout/stderr are tee'd
     to a .log file under BENCHMARK_RESULT_DIR/logs/; its path is stored in
     the record.
     """
@@ -586,12 +706,17 @@ def run_benchmark(
     log_dir = BENCHMARK_RESULT_DIR / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
     endpoint_label = endpoint_filename_token(endpoint)
-    log_file = log_dir / f"{test_name}_{endpoint_label}_{timestamp}.log"
+    resource_label = get_runtime_resource_label()
+    hw_for_filename = resource_label_for_filename(resource_label)
+    if hw_for_filename:
+        log_file = log_dir / f"{test_name}_{hw_for_filename}_{endpoint_label}_{timestamp}.log"
+    else:
+        log_file = log_dir / f"{test_name}_{endpoint_label}_{timestamp}.log"
 
     with tempfile.NamedTemporaryFile(mode="w", suffix=".json", prefix="diffusion_bench_tmp_", delete=False) as tmp:
         tmp_result_file = Path(tmp.name)
 
-    exclude_keys = {"baseline", "dataset", "task", "name", "skip-performance-assertion"}
+    exclude_keys = {"baseline", "dataset", "task", "name"}
 
     cmd = [
         sys.executable,
@@ -685,18 +810,23 @@ def run_benchmark(
     completed = metrics.get("completed_requests", metrics.get("completed", 0))
     failed = metrics.get("failed_requests", metrics.get("failed", 0))
 
+    # Persist sweep-resolved baseline from params (already narrowed in _build_run_params).
+    baseline = params.get("baseline") or {}
+    metrics["baseline"] = baseline
+
     record: dict[str, Any] = {
         "test_name": test_name,
         "endpoint": endpoint,
         "timestamp": timestamp,
         "server_params": server_cfg.get("server_params"),
         "benchmark_params": params,
+        "baseline": baseline,
         "result": metrics,
         "log_file": str(log_file),
         "Model": model,
         "Framework": server_type,
         "API Endpoint": endpoint,
-        "Hardware": "",
+        "Hardware": hardware_json_value(resource_label),
         "Deployment": "",
         "Task": params.get("task", "t2i"),
         "Dataset": params.get("dataset", "random"),
@@ -728,8 +858,8 @@ def run_benchmark(
         "build_url": os.environ.get("BUILDKITE_BUILD_URL", ""),
         "source_file": source_file,
     }
-    _append_to_aggregated_file(record)
-    print(f"\n  Result appended to: {AGGREGATED_RESULT_FILE}")
+    result_path = _write_result_record(record)
+    print(f"\n  Result saved to: {result_path}")
     print(f"  Log saved to:       {log_file}")
 
     return metrics
@@ -740,70 +870,14 @@ def run_benchmark(
 # ---------------------------------------------------------------------------
 
 
-def _resolve_baseline_value(
-    baseline_raw: Any,
-    *,
-    sweep_index: int | None,
-    max_concurrency: Any = None,
-    request_rate: Any = None,
-) -> Any:
-    """Pick the baseline threshold for this sweep step."""
-    if baseline_raw is None:
-        return 100000
-    if isinstance(baseline_raw, dict):
-        if max_concurrency is not None:
-            for key in (max_concurrency, str(max_concurrency)):
-                if key in baseline_raw:
-                    return baseline_raw[key]
-        if request_rate is not None:
-            for key in (request_rate, str(request_rate)):
-                if key in baseline_raw:
-                    return baseline_raw[key]
-        raise KeyError(
-            f"baseline dict has no key for max_concurrency={max_concurrency!r} "
-            f"or request_rate={request_rate!r}; keys={list(baseline_raw.keys())!r}"
-        )
-    if isinstance(baseline_raw, (list, tuple)):
-        if sweep_index is None:
-            raise ValueError("sweep_index is required when baseline is a list or tuple")
-        return baseline_raw[sweep_index]
-    return baseline_raw
-
-
 def assert_result(
     result: dict[str, Any],
-    params: dict[str, Any],
     num_prompts: int,
-    *,
-    sweep_index: int | None = None,
-    max_concurrency: Any = None,
-    request_rate: Any = None,
-    assert_baseline: bool = True,
 ) -> None:
-    """Assert that benchmark metrics satisfy the configured baselines."""
+    """Assert that the expected number of requests completed."""
     completed = result.get("completed_requests", result.get("completed", 0))
     assert completed == num_prompts, f"Expected {num_prompts} completed requests, got {completed}"
 
-    if not assert_baseline:
-        return
-    if params.get("skip-performance-assertion", False):
-        print("Skipping performance assertions.")
-        return
-
-    for metric, baseline_raw in params.get("baseline", {}).items():
-        current = result.get(metric)
-        assert current is not None, f"Metric '{metric}' not found in result: {list(result.keys())}"
-        threshold = _resolve_baseline_value(
-            baseline_raw,
-            sweep_index=sweep_index,
-            max_concurrency=max_concurrency,
-            request_rate=request_rate,
-        )
-        if "throughput" in metric:
-            assert current >= threshold, f"{metric}: {current:.4f} < baseline {threshold}"
-        else:
-            assert current <= threshold, f"{metric}: {current:.4f} > baseline {threshold}"
-
 
 def _default_benchmark_endpoint_for_task(task: str) -> str:
     """Return the default client-side benchmark endpoint for a diffusion task."""
@@ -845,15 +919,11 @@ def _build_run_params(
     if max_concurrency is not None:
         run_params["max-concurrency"] = max_concurrency
     if "baseline" in params:
-        run_params["baseline"] = {
-            metric: _resolve_baseline_value(
-                baseline_raw,
-                sweep_index=sweep_index,
-                max_concurrency=max_concurrency,
-                request_rate=request_rate,
-            )
-            for metric, baseline_raw in params["baseline"].items()
-        }
+        # Keep all hardware buckets; pick the metric value for this sweep step only.
+        run_params["baseline"] = resolve_baseline_for_sweep(
+            params.get("baseline"),
+            sweep_index=sweep_index,
+        )
     return run_params
 
 
@@ -876,36 +946,30 @@ def _iter_sweep_runs(params: dict[str, Any]) -> list[dict[str, Any]]:
 
     sweep_runs: list[dict[str, Any]] = []
 
-    for i, (request_rate, num_prompts) in enumerate(zip(request_rate_list, num_prompt_list)):
+    for sweep_index, (request_rate, num_prompts) in enumerate(zip(request_rate_list, num_prompt_list)):
         sweep_runs.append(
             {
                 "params": _build_run_params(
                     params,
                     request_rate=request_rate,
                     num_prompts=num_prompts,
-                    sweep_index=i,
+                    sweep_index=sweep_index,
                 ),
                 "num_prompts": num_prompts,
-                "sweep_index": i,
-                "request_rate": request_rate,
-                "max_concurrency": None,
             }
         )
 
-    for i, (max_concurrency, num_prompts) in enumerate(zip(max_concurrency_list, num_prompt_list)):
+    for sweep_index, (max_concurrency, num_prompts) in enumerate(zip(max_concurrency_list, num_prompt_list)):
         sweep_runs.append(
             {
                 "params": _build_run_params(
                     params,
                     max_concurrency=max_concurrency,
                     num_prompts=num_prompts,
-                    sweep_index=i,
                     request_rate="inf",
+                    sweep_index=sweep_index,
                 ),
                 "num_prompts": num_prompts,
-                "sweep_index": i,
-                "request_rate": None,
-                "max_concurrency": max_concurrency,
             }
         )
 
@@ -916,11 +980,9 @@ def _iter_sweep_runs(params: dict[str, Any]) -> list[dict[str, Any]]:
                 "params": _build_run_params(
                     params,
                     num_prompts=default_num_prompts,
+                    sweep_index=0,
                 ),
                 "num_prompts": default_num_prompts,
-                "sweep_index": None,
-                "request_rate": None,
-                "max_concurrency": None,
             }
         )
 
@@ -932,20 +994,16 @@ def _iter_sweep_runs(params: dict[str, Any]) -> list[dict[str, Any]]:
 # ---------------------------------------------------------------------------
 @pytest.mark.benchmark
 @pytest.mark.parametrize(
-    "diffusion_server",
-    server_params,
-    ids=[p["test_name"] for p in server_params],
-    indirect=True,
+    "diffusion_server,benchmark_params",
+    paired_benchmark_params,
+    indirect=["diffusion_server", "benchmark_params"],
 )
-@pytest.mark.parametrize("benchmark_params", benchmark_indices, indirect=True)
-def test_diffusion_performance_benchmark(diffusion_server, benchmark_params, request):
+def test_diffusion_performance_benchmark(diffusion_server, benchmark_params):
     """Run the diffusion performance benchmark and verify request completion.
 
     One server is started per unique parallel configuration (module scope).
     For each server, all benchmark parameter sets defined in the config JSON
     are executed sequentially; metrics are recorded to the aggregated result file.
-
-    Pass ``--assert-baseline`` to compare ``throughput_qps``, ``latency_mean``, etc. to the JSON ``baseline`` block.
     """
     test_name = benchmark_params["test_name"]
     params = benchmark_params["params"]
@@ -962,7 +1020,10 @@ def test_diffusion_performance_benchmark(diffusion_server, benchmark_params, req
             test_name=test_name,
             endpoint=endpoint,
             server_cfg=server_cfg,
-            source_file=cast(str, CONFIG_FILE_PATH),
+            source_file=server_cfg.get(
+                _DIFFUSION_SOURCE_CONFIG_KEY,
+                CONFIG_FILE_PATH or f"{_PERF_TESTS_DIR}/*.json",
+            ),
         )
 
         print(f"\n{'=' * 60}")
@@ -980,17 +1041,9 @@ def test_diffusion_performance_benchmark(diffusion_server, benchmark_params, req
             if key in result:
                 print(f"  {key}: {result[key]:.4f}")
 
-        print(f"\n  Aggregated results: {AGGREGATED_RESULT_FILE}")
+        source = server_cfg.get(_DIFFUSION_SOURCE_CONFIG_KEY) or CONFIG_FILE_PATH
+        if source:
+            print(f"\n  Aggregated results: {_aggregated_result_file_for_source(str(source))}")
         print("=" * 60)
 
-        assert_baseline = request.config.getoption("--assert-baseline", default=False)
-
-        assert_result(
-            result,
-            params,
-            sweep_run["num_prompts"],
-            sweep_index=sweep_run["sweep_index"],
-            max_concurrency=sweep_run["max_concurrency"],
-            request_rate=sweep_run["request_rate"],
-            assert_baseline=assert_baseline,
-        )
+        assert_result(result, sweep_run["num_prompts"])
diff --git a/tests/dfx/perf/tests/test_bagel_vllm_omni.json b/tests/dfx/perf/tests/test_bagel_vllm_omni.json
index 09fc96030..9f6ff0241 100644
--- a/tests/dfx/perf/tests/test_bagel_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_bagel_vllm_omni.json
@@ -1,6 +1,18 @@
 [
   {
     "test_name": "test_bagel_single_device_single_stage_t2i",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
     "description": "Single-stage BAGEL (TP=1, CFG=1), t2i Task",
     "server_type": "vllm-omni",
     "server_params": {
@@ -28,16 +40,30 @@
         "max-concurrency": 1,
         "enable-negative-prompt": true,
         "baseline": {
-          "throughput_qps": 0.3678,
-          "latency_mean": 2.691,
-          "peak_memory_mb_max": 33083.6,
-          "peak_memory_mb_mean": 33082.5
+          "H100": {
+            "throughput_qps": 0.495,
+            "latency_mean": 2.0238,
+            "peak_memory_mb_max": 29393.4286,
+            "peak_memory_mb_mean": 29392.7143
+          }
         }
       }
     ]
   },
   {
     "test_name": "test_bagel_single_device_single_stage_i2i",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
     "description": "Single-stage BAGEL (TP=1, CFG=1), i2i Task",
     "server_type": "vllm-omni",
     "server_params": {
@@ -66,16 +92,30 @@
         "enable-negative-prompt": true,
         "num-input-images": 1,
         "baseline": {
-          "throughput_qps": 0.3124,
-          "latency_mean": 3.1686,
-          "peak_memory_mb_max": 33448.8,
-          "peak_memory_mb_mean": 33447.7
+          "H100": {
+            "throughput_qps": 0.3451,
+            "latency_mean": 2.9031,
+            "peak_memory_mb_max": 30480.2857,
+            "peak_memory_mb_mean": 30479.2857
+          }
         }
       }
     ]
   },
   {
     "test_name": "test_bagel_single_device_multi_stage_t2i",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
     "description": "Two-stage BAGEL (bagel.yaml), TP=1, CFG=1, t2i Task",
     "server_type": "vllm-omni",
     "server_params": {
@@ -103,16 +143,30 @@
         "max-concurrency": 1,
         "enable-negative-prompt": true,
         "baseline": {
-          "throughput_qps": 0.3746,
-          "latency_mean": 2.6425,
-          "peak_memory_mb_max": 33077.0,
-          "peak_memory_mb_mean": 33077.0
+          "H100": {
+            "throughput_qps": 0.5048,
+            "latency_mean": 1.987,
+            "peak_memory_mb_max": 29380.0,
+            "peak_memory_mb_mean": 29380.0
+          }
         }
       }
     ]
   },
   {
     "test_name": "test_bagel_single_device_multi_stage_i2i",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
     "description": "Two-stage BAGEL (bagel.yaml), TP=1, CFG=1, i2i Task",
     "server_type": "vllm-omni",
     "server_params": {
@@ -141,10 +195,12 @@
         "enable-negative-prompt": true,
         "num-input-images": 1,
         "baseline": {
-          "throughput_qps": 0.1349,
-          "latency_mean": 7.339,
-          "peak_memory_mb_max": 33321.2,
-          "peak_memory_mb_mean": 33321.2
+          "H100": {
+            "throughput_qps": 0.149,
+            "latency_mean": 6.7157,
+            "peak_memory_mb_max": 30574.0,
+            "peak_memory_mb_mean": 30574.0
+          }
         }
       }
     ]
diff --git a/tests/dfx/perf/tests/test_boogu_image_edit_vllm_omni.json b/tests/dfx/perf/tests/test_boogu_image_edit_vllm_omni.json
new file mode 100644
index 000000000..e2f96f626
--- /dev/null
+++ b/tests/dfx/perf/tests/test_boogu_image_edit_vllm_omni.json
@@ -0,0 +1,37 @@
+[
+    {
+        "test_name": "test_boogu_image_edit_single_device",
+        "description": "Single-device baseline (no parallelism), concurrency sweep 1/2/4 at 512x512, 28 steps. Text-only edit path (2 predictions/step); a double-guidance (guidance_scale_2) case is a follow-up since the random dataset cannot inject extra_body params. Baselines recorded on 1x A40 46GB (measured c1/c2/c4: qps 0.0337/0.0336/0.0336, latency_mean 29.64/56.50/101.48 s, peak mem 36754 MB) with ~10% margin.",
+        "server_type": "vllm-omni",
+        "server_params": {
+            "model": "Boogu/Boogu-Image-0.1-Edit",
+            "serve_args": {
+                "enable-diffusion-pipeline-profiler": true
+            }
+        },
+        "benchmark_params": [
+            {
+                "name": "512x512_steps28_i2i",
+                "dataset": "random",
+                "task": "i2i",
+                "width": 512,
+                "height": 512,
+                "num-inference-steps": 28,
+                "num-prompts": 10,
+                "max-concurrency": [1, 2, 4],
+                "warmup-requests": 4,
+                "warmup-concurrency": 4,
+                "warmup-num-inference-steps": 28,
+                "enable-negative-prompt": true,
+                "baseline": {
+                    "H100": {
+                        "throughput_qps": [0.0303, 0.0302, 0.0302],
+                        "latency_mean": [32.6, 62.2, 111.7],
+                        "peak_memory_mb_max": 40500,
+                        "peak_memory_mb_mean": 40500
+                    }
+                }
+            }
+        ]
+    }
+]
diff --git a/tests/dfx/perf/tests/test_boogu_image_vllm_omni.json b/tests/dfx/perf/tests/test_boogu_image_vllm_omni.json
new file mode 100644
index 000000000..22218268e
--- /dev/null
+++ b/tests/dfx/perf/tests/test_boogu_image_vllm_omni.json
@@ -0,0 +1,37 @@
+[
+    {
+        "test_name": "test_boogu_image_single_device",
+        "description": "Single-device baseline (no parallelism), concurrency sweep 1/2/4 at 512x512, 28 steps. Baselines recorded on 1x A40 46GB (measured c1/c2/c4: qps 0.0611/0.0609/0.0611, latency_mean 16.37/31.22/55.77 s, peak mem 36754 MB) with ~10% margin.",
+        "server_type": "vllm-omni",
+        "server_params": {
+            "model": "Boogu/Boogu-Image-0.1-Base",
+            "serve_args": {
+                "enable-diffusion-pipeline-profiler": true
+            }
+        },
+        "benchmark_params": [
+            {
+                "name": "512x512_steps28",
+                "dataset": "random",
+                "task": "t2i",
+                "width": 512,
+                "height": 512,
+                "num-inference-steps": 28,
+                "num-prompts": 10,
+                "max-concurrency": [1, 2, 4],
+                "warmup-requests": 4,
+                "warmup-concurrency": 4,
+                "warmup-num-inference-steps": 28,
+                "enable-negative-prompt": true,
+                "baseline": {
+                    "H100": {
+                        "throughput_qps": [0.0549, 0.0547, 0.0549],
+                        "latency_mean": [18.0, 34.3, 61.4],
+                        "peak_memory_mb_max": 40500,
+                        "peak_memory_mb_mean": 40500
+                    }
+                }
+            }
+        ]
+    }
+]
diff --git a/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json b/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
index b0fc9a5a4..c4d2305e6 100644
--- a/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
@@ -1,213 +1,269 @@
 [
-    {
-        "test_name": "test_cosmos3_t2i_official_demo_2gpu",
-        "description": "Cosmos3-Nano text-to-image official demo workload on 2 GPUs",
-        "server_type": "vllm-omni",
-        "benchmark_endpoint": "/v1/images/generations",
-        "server_params": {
-            "model": "nvidia/Cosmos3-Nano",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "use-hsdp": true,
-                "hsdp-shard-size": 2,
-                "vae-patch-parallel-size": 2,
-                "vae-use-tiling": true,
-                "model-class-name": "Cosmos3OmniDiffusersPipeline",
-                "no-guardrails": true,
-                "stage-init-timeout": 900,
-                "init-timeout": 1200,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1024x1024_steps4",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1024,
-                "height": 1024,
-                "num-inference-steps": 4,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "seed": 42,
-                "extra-body": {
-                    "guidance_scale": 7.0,
-                    "flow_shift": 3.0,
-                    "guardrails": false
-                },
-                "baseline": {
-                    "throughput_qps": 1.107,
-                    "latency_mean": 0.8929,
-                    "peak_memory_mb_mean": 80000.0
-                }
-            }
-        ]
+  {
+    "test_name": "test_cosmos3_t2i_official_demo_2gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Cosmos3-Nano text-to-image official demo workload on 2 GPUs",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/images/generations",
+    "server_params": {
+      "model": "nvidia/Cosmos3-Nano",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "use-hsdp": true,
+        "hsdp-shard-size": 2,
+        "vae-patch-parallel-size": 2,
+        "vae-use-tiling": true,
+        "model-class-name": "Cosmos3OmniDiffusersPipeline",
+        "no-guardrails": true,
+        "stage-init-timeout": 900,
+        "init-timeout": 1200,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_cosmos3_t2v_official_demo_2gpu",
-        "description": "Cosmos3-Nano text-to-video official demo workload on 2 GPUs",
-        "server_type": "vllm-omni",
-        "benchmark_endpoint": "/v1/videos",
-        "server_params": {
-            "model": "nvidia/Cosmos3-Nano",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "use-hsdp": true,
-                "hsdp-shard-size": 2,
-                "vae-patch-parallel-size": 2,
-                "vae-use-tiling": true,
-                "model-class-name": "Cosmos3OmniDiffusersPipeline",
-                "no-guardrails": true,
-                "stage-init-timeout": 900,
-                "init-timeout": 1200,
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1024x1024_steps4",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1024,
+        "height": 1024,
+        "num-inference-steps": 4,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "seed": 42,
+        "extra-body": {
+          "guidance_scale": 7.0,
+          "flow_shift": 3.0,
+          "guardrails": false
         },
-        "benchmark_params": [
-            {
-                "name": "1280x720_frames189_steps4",
-                "dataset": "random",
-                "task": "t2v",
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "seed": 42,
-                "random-request-config": [
-                    {
-                        "width": 1280,
-                        "height": 720,
-                        "prompt": "A robot arm is cleaning a plate in the kitchen.",
-                        "num_inference_steps": 4,
-                        "num_frames": 189,
-                        "fps": 24,
-                        "weight": 1
-                    }
-                ],
-                "extra-body": {
-                    "guidance_scale": 6.0,
-                    "flow_shift": 10.0,
-                    "max_sequence_length": 4096,
-                    "guardrails": false,
-                    "use_resolution_template": false,
-                    "use_duration_template": false
-                },
-                "baseline": {
-                    "throughput_qps": 0.027,
-                    "latency_mean": 36.6824,
-                    "peak_memory_mb_mean": 30155.4
-                }
-            }
-        ]
+        "baseline": {
+          "H100": {
+            "throughput_qps": 1.107,
+            "latency_mean": 0.8929,
+            "peak_memory_mb_mean": 80000.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_cosmos3_t2v_official_demo_2gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Cosmos3-Nano text-to-video official demo workload on 2 GPUs",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "nvidia/Cosmos3-Nano",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "use-hsdp": true,
+        "hsdp-shard-size": 2,
+        "vae-patch-parallel-size": 2,
+        "vae-use-tiling": true,
+        "model-class-name": "Cosmos3OmniDiffusersPipeline",
+        "no-guardrails": true,
+        "stage-init-timeout": 900,
+        "init-timeout": 1200,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_cosmos3_i2v_official_demo_2gpu",
-        "description": "Cosmos3-Nano image-to-video official demo workload on 2 GPUs",
-        "server_type": "vllm-omni",
-        "benchmark_endpoint": "/v1/videos",
-        "server_params": {
-            "model": "nvidia/Cosmos3-Nano",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "use-hsdp": true,
-                "hsdp-shard-size": 2,
-                "vae-patch-parallel-size": 2,
-                "vae-use-tiling": true,
-                "model-class-name": "Cosmos3OmniDiffusersPipeline",
-                "no-guardrails": true,
-                "stage-init-timeout": 900,
-                "init-timeout": 1200,
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1280x720_frames189_steps4",
+        "dataset": "random",
+        "task": "t2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1280,
+            "height": 720,
+            "prompt": "A robot arm is cleaning a plate in the kitchen.",
+            "num_inference_steps": 4,
+            "num_frames": 189,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "guidance_scale": 6.0,
+          "flow_shift": 10.0,
+          "max_sequence_length": 4096,
+          "guardrails": false,
+          "use_resolution_template": false,
+          "use_duration_template": false
         },
-        "benchmark_params": [
-            {
-                "name": "1280x720_frames189_steps4",
-                "dataset": "random",
-                "task": "i2v",
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "num-input-images": 1,
-                "seed": 42,
-                "random-request-config": [
-                    {
-                        "width": 1280,
-                        "height": 720,
-                        "prompt": "The scene comes to life with smooth, natural motion.",
-                        "num_inference_steps": 4,
-                        "num_frames": 189,
-                        "fps": 24,
-                        "weight": 1
-                    }
-                ],
-                "extra-body": {
-                    "guidance_scale": 6.0,
-                    "flow_shift": 10.0,
-                    "max_sequence_length": 4096,
-                    "guardrails": false
-                },
-                "baseline": {
-                    "throughput_qps": 0.027,
-                    "latency_mean": 36.968,
-                    "peak_memory_mb_mean": 30443.6
-                }
-            }
-        ]
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.027,
+            "latency_mean": 36.6824,
+            "peak_memory_mb_mean": 30155.4
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_cosmos3_i2v_official_demo_2gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Cosmos3-Nano image-to-video official demo workload on 2 GPUs",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "nvidia/Cosmos3-Nano",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "use-hsdp": true,
+        "hsdp-shard-size": 2,
+        "vae-patch-parallel-size": 2,
+        "vae-use-tiling": true,
+        "model-class-name": "Cosmos3OmniDiffusersPipeline",
+        "no-guardrails": true,
+        "stage-init-timeout": 900,
+        "init-timeout": 1200,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_cosmos3_v2v_official_demo_2gpu",
-        "description": "Cosmos3-Nano video-to-video official demo workload on 2 GPUs",
-        "server_type": "vllm-omni",
-        "benchmark_endpoint": "/v1/videos",
-        "server_params": {
-            "model": "nvidia/Cosmos3-Nano",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "use-hsdp": true,
-                "hsdp-shard-size": 2,
-                "vae-patch-parallel-size": 2,
-                "vae-use-tiling": true,
-                "model-class-name": "Cosmos3OmniDiffusersPipeline",
-                "no-guardrails": true,
-                "stage-init-timeout": 900,
-                "init-timeout": 1200,
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1280x720_frames189_steps4",
+        "dataset": "random",
+        "task": "i2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "num-input-images": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1280,
+            "height": 720,
+            "prompt": "The scene comes to life with smooth, natural motion.",
+            "num_inference_steps": 4,
+            "num_frames": 189,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "guidance_scale": 6.0,
+          "flow_shift": 10.0,
+          "max_sequence_length": 4096,
+          "guardrails": false
         },
-        "benchmark_params": [
-            {
-                "name": "1280x720_frames189_steps4",
-                "dataset": "random",
-                "task": "v2v",
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "seed": 42,
-                "random-request-config": [
-                    {
-                        "width": 1280,
-                        "height": 720,
-                        "prompt": "Continue the same scene with smooth natural motion.",
-                        "num_inference_steps": 4,
-                        "num_frames": 189,
-                        "fps": 24,
-                        "weight": 1
-                    }
-                ],
-                "extra-body": {
-                    "guidance_scale": 6.0,
-                    "flow_shift": 10.0,
-                    "max_sequence_length": 4096,
-                    "guardrails": false,
-                    "condition_frame_indexes_vision": [
-                        0,
-                        1
-                    ],
-                    "condition_video_keep": "first"
-                },
-                "baseline": {
-                    "throughput_qps": 0.027,
-                    "latency_mean": 37.2117,
-                    "peak_memory_mb_mean": 30135.6
-                }
-            }
-        ]
-    }
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.027,
+            "latency_mean": 36.968,
+            "peak_memory_mb_mean": 30443.6
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_cosmos3_v2v_official_demo_2gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Cosmos3-Nano video-to-video official demo workload on 2 GPUs",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "nvidia/Cosmos3-Nano",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "use-hsdp": true,
+        "hsdp-shard-size": 2,
+        "vae-patch-parallel-size": 2,
+        "vae-use-tiling": true,
+        "model-class-name": "Cosmos3OmniDiffusersPipeline",
+        "no-guardrails": true,
+        "stage-init-timeout": 900,
+        "init-timeout": 1200,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1280x720_frames189_steps4",
+        "dataset": "random",
+        "task": "v2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1280,
+            "height": 720,
+            "prompt": "Continue the same scene with smooth natural motion.",
+            "num_inference_steps": 4,
+            "num_frames": 189,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "guidance_scale": 6.0,
+          "flow_shift": 10.0,
+          "max_sequence_length": 4096,
+          "guardrails": false,
+          "condition_frame_indexes_vision": [
+            0,
+            1
+          ],
+          "condition_video_keep": "first"
+        },
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.027,
+            "latency_mean": 37.2117,
+            "peak_memory_mb_mean": 30135.6
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_higgs_audio_v3.json b/tests/dfx/perf/tests/test_higgs_audio_v3.json
index 6fdaec580..75e5983b0 100644
--- a/tests/dfx/perf/tests/test_higgs_audio_v3.json
+++ b/tests/dfx/perf/tests/test_higgs_audio_v3.json
@@ -1,6 +1,18 @@
 [
   {
     "test_name": "test_higgs_audio_v3",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "tts"
+    ],
     "server_params": {
       "model": "bosonai/higgs-audio-v3-tts-4b",
       "stage_overrides": {
@@ -34,12 +46,14 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            3000
-          ],
-          "median_audio_rtf": [
-            0.5
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              223.3584
+            ],
+            "median_audio_rtf": [
+              0.4393
+            ]
+          }
         }
       },
       {
@@ -58,15 +72,17 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            5000
-          ],
-          "median_audio_rtf": [
-            1.2
-          ],
-          "audio_throughput": [
-            30
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              276.575
+            ],
+            "median_audio_rtf": [
+              0.5073
+            ],
+            "audio_throughput": [
+              27.3728
+            ]
+          }
         }
       }
     ]
diff --git a/tests/dfx/perf/tests/test_hunyuan_image3_it2i.json b/tests/dfx/perf/tests/test_hunyuan_image3_it2i.json
index fa955c763..c4ef34b96 100644
--- a/tests/dfx/perf/tests/test_hunyuan_image3_it2i.json
+++ b/tests/dfx/perf/tests/test_hunyuan_image3_it2i.json
@@ -1,140 +1,148 @@
 [
-    {
-        "test_name": "test_hunyuan_image3_ti2i_inline",
-        "description": "AR (TP=2) + 2 * DiT (TP=2) - using inline dataset and deploy-config",
-        "server_type": "vllm-omni",
-        "benchmark_endpoint": "/v1/images/edits",
-        "server_params": {
-            "model": "tencent/HunyuanImage-3.0-Instruct",
-            "serve_args": {
-                "trust-remote-code": true,
-                "deploy-config-inline": {
-                    "type": "yaml",
-                    "content": {
-                        "pipeline": "hunyuan_image_3_moe",
-                        "async_chunk": false,
-                        "trust_remote_code": true,
-                        "connectors": {
-                            "rdma_connector": {
-                                "name": "MooncakeTransferEngineConnector",
-                                "extra": {
-                                    "host": "auto",
-                                    "zmq_port": 50051,
-                                    "protocol": "rdma",
-                                    "device_name": "",
-                                    "memory_pool_size": 17179869184,
-                                    "memory_pool_device": "cpu"
-                                }
-                            }
-                        },
-                        "stages": [
-                            {
-                                "stage_id": 0,
-                                "is_comprehension": true,
-                                "final_output": true,
-                                "final_output_type": "text",
-                                "max_num_seqs": 16,
-                                "gpu_memory_utilization": 0.95,
-                                "enforce_eager": false,
-                                "enable_prefix_caching": false,
-                                "max_num_batched_tokens": 32768,
-                                "devices": "0,1",
-                                "tensor_parallel_size": 2,
-                                "hf_overrides": {
-                                    "rope_parameters": {
-                                        "mrope_section": [
-                                            0,
-                                            32,
-                                            32
-                                        ],
-                                        "rope_type": "default"
-                                    }
-                                },
-                                "omni_kv_config": {
-                                    "need_send_cache": true
-                                },
-                                "output_connectors": {
-                                    "to_stage_1": "rdma_connector"
-                                },
-                                "default_sampling_params": {
-                                    "temperature": 0.0,
-                                    "top_p": 1,
-                                    "top_k": -1,
-                                    "max_tokens": 8192,
-                                    "detokenize": true,
-                                    "skip_special_tokens": false,
-                                    "stop_token_ids": [
-                                        128025
-                                    ]
-                                }
-                            },
-                            {
-                                "stage_id": 1,
-                                "max_num_seqs": 1,
-                                "enforce_eager": true,
-                                "devices": "2,3",
-                                "distributed_executor_backend": "mp",
-                                "omni_kv_config": {
-                                    "need_recv_cache": true
-                                },
-                                "parallel_config": {
-                                    "tensor_parallel_size": 2,
-                                    "vae_patch_parallel_size": 2,
-                                    "enable_expert_parallel": true
-                                },
-                                "input_connectors": {
-                                    "from_stage_0": "rdma_connector"
-                                },
-                                "default_sampling_params": {
-                                    "num_inference_steps": 50,
-                                    "guidance_scale": 0
-                                }
-                            }
-                        ],
-                        "edges": [
-                            {
-                                "from": 0,
-                                "to": 1,
-                                "window_size": -1,
-                                "max_inflight": 1
-                            }
-                        ]
-                    }
+  {
+    "test_name": "test_hunyuan_image3_ti2i_inline",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 4
+        }
+      },
+      "diffusion",
+      "local_model"
+    ],
+    "description": "AR (TP=2) + 2 * DiT (TP=2) - using inline dataset and deploy-config",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/images/edits",
+    "server_params": {
+      "model": "tencent/HunyuanImage-3.0-Instruct",
+      "serve_args": {
+        "trust-remote-code": true,
+        "deploy-config-inline": {
+          "type": "yaml",
+          "content": {
+            "pipeline": "hunyuan_image_3_moe",
+            "async_chunk": false,
+            "trust_remote_code": true,
+            "connectors": {
+              "shared_mem_connector": {
+                "name": "SharedMemoryConnector",
+                "extra": {}
+              }
+            },
+            "stages": [
+              {
+                "stage_id": 0,
+                "is_comprehension": true,
+                "final_output": true,
+                "final_output_type": "text",
+                "max_num_seqs": 16,
+                "gpu_memory_utilization": 0.95,
+                "enforce_eager": false,
+                "enable_prefix_caching": false,
+                "max_num_batched_tokens": 32768,
+                "devices": "0,1",
+                "tensor_parallel_size": 2,
+                "hf_overrides": {
+                  "rope_parameters": {
+                    "mrope_section": [
+                      0,
+                      32,
+                      32
+                    ],
+                    "rope_type": "default"
+                  }
                 },
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "inline_dataset_5_requests",
-                "dataset": "custom",
-                "dataset-path-inline": {
-                    "type": "jsonl",
-                    "content": [
-                        {
-                            "prompt": "新年宠物海报，Q版圆润的可爱标题“新年快乐汪”，副标题“HAPPY NEW YEAR”。 鱼眼镜头，背景是房间门口，近景，上传的主体歪头笑，围着红色围巾，戴着红色毛线帽，高清，绒毛细节，面部特写。 宝丽莱相纸，超现实主义，写实主义，胶片摄影，打印颗粒感肌理。肌理，超写实，复古感。",
-                            "image_urls": [
-                                "https://raw.githubusercontent.com/Tencent-Hunyuan/HunyuanImage-3.0/main/assets/demo_instruct_imgs/input_0_0.png"
-                            ],
-                            "num_inference_steps": 8,
-                            "seed": 42,
-                            "guidance_scale": 1.0
-                        }
-                    ]
+                "omni_kv_config": {
+                  "need_send_cache": true
                 },
-                "task": "ti2i",
-                "bot-task": "think_recaption",
-                "max-concurrency": 16,
-                "num-prompts": 96,
-                "skip-performance-assertion": true,
-                "baseline": {
-                    "throughput_qps": 0.1874,
-                    "latency_p99": 101.852,
-                    "latency_mean": 79.0385,
-                    "peak_memory_mb_max": 70000,
-                    "peak_memory_mb_mean": 70000
+                "output_connectors": {
+                  "to_stage_1": "shared_mem_connector"
+                },
+                "default_sampling_params": {
+                  "temperature": 0.0,
+                  "top_p": 1,
+                  "top_k": -1,
+                  "max_tokens": 8192,
+                  "detokenize": true,
+                  "skip_special_tokens": false,
+                  "stop_token_ids": [
+                    128025
+                  ]
                 }
+              },
+              {
+                "stage_id": 1,
+                "max_num_seqs": 1,
+                "enforce_eager": true,
+                "devices": "2,3",
+                "distributed_executor_backend": "mp",
+                "omni_kv_config": {
+                  "need_recv_cache": true
+                },
+                "parallel_config": {
+                  "tensor_parallel_size": 2,
+                  "vae_patch_parallel_size": 2,
+                  "enable_expert_parallel": true
+                },
+                "vae_use_tiling": true,
+                "input_connectors": {
+                  "from_stage_0": "shared_mem_connector"
+                },
+                "default_sampling_params": {
+                  "num_inference_steps": 50,
+                  "guidance_scale": 0
+                }
+              }
+            ],
+            "edges": [
+              {
+                "from": 0,
+                "to": 1,
+                "window_size": -1,
+                "max_inflight": 1
+              }
+            ]
+          }
+        },
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "inline_dataset_5_requests",
+        "dataset": "custom",
+        "dataset-path-inline": {
+          "type": "jsonl",
+          "content": [
+            {
+              "prompt": "新年宠物海报，Q版圆润的可爱标题“新年快乐汪”，副标题“HAPPY NEW YEAR”。 鱼眼镜头，背景是房间门口，近景，上传的主体歪头笑，围着红色围巾，戴着红色毛线帽，高清，绒毛细节，面部特写。 宝丽莱相纸，超现实主义，写实主义，胶片摄影，打印颗粒感肌理。肌理，超写实，复古感。",
+              "image_urls": [
+                "https://raw.githubusercontent.com/Tencent-Hunyuan/HunyuanImage-3.0/main/assets/demo_instruct_imgs/input_0_0.png"
+              ],
+              "num_inference_steps": 8,
+              "seed": 42,
+              "guidance_scale": 1.0
             }
-        ]
-    }
+          ]
+        },
+        "task": "ti2i",
+        "bot-task": "think_recaption",
+        "max-concurrency": 16,
+        "num-prompts": 96,
+        "baseline": {
+          "H200": {
+            "throughput_qps": 0.1874,
+            "latency_p99": 101.852,
+            "latency_mean": 79.0385,
+            "peak_memory_mb_max": 70000,
+            "peak_memory_mb_mean": 70000
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json b/tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json
index e6d7ce659..a86a6a3d5 100644
--- a/tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json
+++ b/tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json
@@ -1,35 +1,51 @@
 [
-    {
-        "test_name": "test_hunyuan_image_tp2_cfgp2",
-        "description": "TP=2 CfgP=2 baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "tencent/HunyuanImage-3.0-Instruct",
-            "serve_args": {
-                "deploy_config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
-                "tensor-parallel-size": 2,
-                "cfg-parallel-size": 2,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1024x1024_steps8",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1024,
-                "height": 1024,
-                "num-inference-steps": 8,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "skip-performance-assertion": true,
-                "baseline": {
-                    "throughput_qps": 0.21,
-                    "latency_p99": 4.7469,
-                    "peak_memory_mb_max": 101100,
-                    "peak_memory_mb_mean": 101100
-                }
-            }
-        ]
-    }
+  {
+    "test_name": "test_hunyuan_image_tp2_cfgp2",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 4
+        }
+      },
+      "diffusion",
+      "local_model"
+    ],
+    "description": "TP=2 CfgP=2 baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "tencent/HunyuanImage-3.0-Instruct",
+      "serve_args": {
+        "deploy_config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
+        "tensor-parallel-size": 2,
+        "cfg-parallel-size": 2,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1024x1024_steps8",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1024,
+        "height": 1024,
+        "num-inference-steps": 8,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "baseline": {
+          "H200": {
+            "throughput_qps": 0.21,
+            "latency_p99": 4.7469,
+            "peak_memory_mb_max": 101100,
+            "peak_memory_mb_mean": 101100
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json b/tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json
index fbbe1643e..e49cd0543 100644
--- a/tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json
+++ b/tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json
@@ -1,35 +1,51 @@
 [
-    {
-        "test_name": "test_hunyuan_image_tp2_sp2",
-        "description": "TP=2 SP=2 baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "tencent/HunyuanImage-3.0-Instruct",
-            "serve_args": {
-                "deploy-config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
-                "tensor-parallel-size": 2,
-                "ulysses-degree": 2,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1024x1024_steps8",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1024,
-                "height": 1024,
-                "num-inference-steps": 8,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "skip-performance-assertion": true,
-                "baseline": {
-                    "throughput_qps": 0.20,
-                    "latency_p99": 5.1025,
-                    "peak_memory_mb_max": 97402,
-                    "peak_memory_mb_mean": 97402
-                }
-            }
-        ]
-    }
+  {
+    "test_name": "test_hunyuan_image_tp2_sp2",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 4
+        }
+      },
+      "diffusion",
+      "local_model"
+    ],
+    "description": "TP=2 SP=2 baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "tencent/HunyuanImage-3.0-Instruct",
+      "serve_args": {
+        "deploy-config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
+        "tensor-parallel-size": 2,
+        "ulysses-degree": 2,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1024x1024_steps8",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1024,
+        "height": 1024,
+        "num-inference-steps": 8,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "baseline": {
+          "H200": {
+            "throughput_qps": 0.20,
+            "latency_p99": 5.1025,
+            "peak_memory_mb_max": 97402,
+            "peak_memory_mb_mean": 97402
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_hunyuan_image_tp4.json b/tests/dfx/perf/tests/test_hunyuan_image_tp4.json
index eb37f7a22..54631471a 100644
--- a/tests/dfx/perf/tests/test_hunyuan_image_tp4.json
+++ b/tests/dfx/perf/tests/test_hunyuan_image_tp4.json
@@ -1,35 +1,51 @@
 [
-    {
-        "test_name": "test_hunyuan_image_tp4",
-        "description": "TP=4 baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "tencent/HunyuanImage-3.0-Instruct",
-            "serve_args": {
-                "deploy-config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
-                "tensor-parallel-size": 4,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1024x1024_steps8",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1024,
-                "height": 1024,
-                "num-inference-steps": 8,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "skip-performance-assertion": true,
-                "baseline": {
-                    "throughput_qps": 0.213,
-                    "latency_mean": 4.6953,
-                    "latency_p99": 4.8601,
-                    "peak_memory_mb_max": 56912.0,
-                    "peak_memory_mb_mean": 56912.0
-                }
-            }
-        ]
-    }
+  {
+    "test_name": "test_hunyuan_image_tp4",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 4
+        }
+      },
+      "diffusion",
+      "local_model"
+    ],
+    "description": "TP=4 baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "tencent/HunyuanImage-3.0-Instruct",
+      "serve_args": {
+        "deploy-config": "../vllm_omni/deploy/hunyuan_image3_dit.yaml",
+        "tensor-parallel-size": 4,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1024x1024_steps8",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1024,
+        "height": 1024,
+        "num-inference-steps": 8,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "baseline": {
+          "H200": {
+            "throughput_qps": 0.213,
+            "latency_mean": 4.6953,
+            "latency_p99": 4.8601,
+            "peak_memory_mb_max": 56912.0,
+            "peak_memory_mb_mean": 56912.0
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_lingbot_video_vllm_omni.json b/tests/dfx/perf/tests/test_lingbot_video_vllm_omni.json
new file mode 100644
index 000000000..07403e78f
--- /dev/null
+++ b/tests/dfx/perf/tests/test_lingbot_video_vllm_omni.json
@@ -0,0 +1,33 @@
+[
+    {
+        "test_name": "test_lingbot_video_single_device",
+        "description": "Single-device LingBot dense T2V baseline at 320x192, 9 frames, 2 steps.",
+        "server_type": "vllm-omni",
+        "server_params": {
+            "model": "robbyant/lingbot-video-dense-1.3b",
+            "serve_args": {
+                "model-class-name": "LingBotVideoPipeline",
+                "enable-diffusion-pipeline-profiler": true
+            }
+        },
+        "benchmark_params": [
+            {
+                "name": "320x192_frames9_steps2",
+                "dataset": "random",
+                "task": "t2v",
+                "backend": "v1/videos",
+                "width": 320,
+                "height": 192,
+                "num-frames": 9,
+                "fps": 24,
+                "num-inference-steps": 2,
+                "num-prompts": 3,
+                "max-concurrency": 1,
+                "warmup-requests": 1,
+                "warmup-concurrency": 1,
+                "warmup-num-inference-steps": 2,
+                "enable-negative-prompt": true
+            }
+        ]
+    }
+]
diff --git a/tests/dfx/perf/tests/test_ltx2_vllm_omni.json b/tests/dfx/perf/tests/test_ltx2_vllm_omni.json
index 4a6f9e350..1a0f31e98 100644
--- a/tests/dfx/perf/tests/test_ltx2_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_ltx2_vllm_omni.json
@@ -1,217 +1,273 @@
 [
-    {
-        "test_name": "test_ltx2_baseline_eager",
-        "description": "Single-device baseline with enforce-eager (no torch.compile)",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Lightricks/LTX-2",
-            "serve_args": {
-                "enforce-eager": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "256x256_145f_steps6",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 256,
-                "height": 256,
-                "num-frames": 145,
-                "fps": 24,
-                "num-inference-steps": 6,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            },
-            {
-                "name": "480x768_41f_steps20",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 768,
-                "height": 480,
-                "num-frames": 41,
-                "fps": 24,
-                "num-inference-steps": 20,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            }
-        ]
+  {
+    "test_name": "test_ltx2_baseline_eager",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline with enforce-eager (no torch.compile)",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Lightricks/LTX-2",
+      "serve_args": {
+        "enforce-eager": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-
-    {
-        "test_name": "test_ltx2_torch_compile",
-        "description": "Single-device with torch.compile (default, no enforce-eager)",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Lightricks/LTX-2",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "256x256_145f_steps6",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 256,
-                "height": 256,
-                "num-frames": 145,
-                "fps": 24,
-                "num-inference-steps": 6,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            },
-            {
-                "name": "480x768_41f_steps20",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 768,
-                "height": 480,
-                "num-frames": 41,
-                "fps": 24,
-                "num-inference-steps": 20,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "256x256_145f_steps6",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 256,
+        "height": 256,
+        "num-frames": 145,
+        "fps": 24,
+        "num-inference-steps": 6,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      },
+      {
+        "name": "480x768_41f_steps20",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 768,
+        "height": 480,
+        "num-frames": 41,
+        "fps": 24,
+        "num-inference-steps": 20,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      }
+    ]
+  },
+  {
+    "test_name": "test_ltx2_torch_compile",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device with torch.compile (default, no enforce-eager)",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Lightricks/LTX-2",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-
-    {
-        "test_name": "test_ltx2_cfg2_eager",
-        "description": "CFG-parallel=2 with enforce-eager",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Lightricks/LTX-2",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "enforce-eager": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "256x256_145f_steps6",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 256,
-                "height": 256,
-                "num-frames": 145,
-                "fps": 24,
-                "num-inference-steps": 6,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            },
-            {
-                "name": "480x768_41f_steps20",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 768,
-                "height": 480,
-                "num-frames": 41,
-                "fps": 24,
-                "num-inference-steps": 20,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "256x256_145f_steps6",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 256,
+        "height": 256,
+        "num-frames": 145,
+        "fps": 24,
+        "num-inference-steps": 6,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      },
+      {
+        "name": "480x768_41f_steps20",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 768,
+        "height": 480,
+        "num-frames": 41,
+        "fps": 24,
+        "num-inference-steps": 20,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      }
+    ]
+  },
+  {
+    "test_name": "test_ltx2_cfg2_eager",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "CFG-parallel=2 with enforce-eager",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Lightricks/LTX-2",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "enforce-eager": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-
-    {
-        "test_name": "test_ltx2_cfg2_compile",
-        "description": "CFG-parallel=2 with torch.compile",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Lightricks/LTX-2",
-            "serve_args": {
-                "cfg-parallel-size": 2,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "256x256_145f_steps6",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 256,
-                "height": 256,
-                "num-frames": 145,
-                "fps": 24,
-                "num-inference-steps": 6,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            },
-            {
-                "name": "480x768_41f_steps20",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 768,
-                "height": 480,
-                "num-frames": 41,
-                "fps": 24,
-                "num-inference-steps": 20,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "256x256_145f_steps6",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 256,
+        "height": 256,
+        "num-frames": 145,
+        "fps": 24,
+        "num-inference-steps": 6,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      },
+      {
+        "name": "480x768_41f_steps20",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 768,
+        "height": 480,
+        "num-frames": 41,
+        "fps": 24,
+        "num-inference-steps": 20,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      }
+    ]
+  },
+  {
+    "test_name": "test_ltx2_cfg2_compile",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "CFG-parallel=2 with torch.compile",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Lightricks/LTX-2",
+      "serve_args": {
+        "cfg-parallel-size": 2,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-
-    {
-        "test_name": "test_ltx2_cache_dit_eager",
-        "description": "CacheDiT with enforce-eager",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Lightricks/LTX-2",
-            "serve_args": {
-                "cache-backend": "cache_dit",
-                "enforce-eager": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "256x256_145f_steps6",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 256,
-                "height": 256,
-                "num-frames": 145,
-                "fps": 24,
-                "num-inference-steps": 6,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            },
-            {
-                "name": "480x768_41f_steps20",
-                "dataset": "random",
-                "task": "t2v",
-                "backend": "v1/videos",
-                "width": 768,
-                "height": 480,
-                "num-frames": 41,
-                "fps": 24,
-                "num-inference-steps": 20,
-                "num-prompts": 3,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true
-            }
-        ]
-    }
+    "benchmark_params": [
+      {
+        "name": "256x256_145f_steps6",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 256,
+        "height": 256,
+        "num-frames": 145,
+        "fps": 24,
+        "num-inference-steps": 6,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      },
+      {
+        "name": "480x768_41f_steps20",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 768,
+        "height": 480,
+        "num-frames": 41,
+        "fps": 24,
+        "num-inference-steps": 20,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      }
+    ]
+  },
+  {
+    "test_name": "test_ltx2_cache_dit_eager",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "CacheDiT with enforce-eager",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Lightricks/LTX-2",
+      "serve_args": {
+        "cache-backend": "cache_dit",
+        "enforce-eager": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "256x256_145f_steps6",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 256,
+        "height": 256,
+        "num-frames": 145,
+        "fps": 24,
+        "num-inference-steps": 6,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      },
+      {
+        "name": "480x768_41f_steps20",
+        "dataset": "random",
+        "task": "t2v",
+        "backend": "v1/videos",
+        "width": 768,
+        "height": 480,
+        "num-frames": 41,
+        "fps": 24,
+        "num-inference-steps": 20,
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json b/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
new file mode 100644
index 000000000..a28aab96c
--- /dev/null
+++ b/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
@@ -0,0 +1,295 @@
+[
+  {
+    "test_name": "test_minimax_h3_t2v_4gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "MiniMax-H3 T2VA text-to-video+audio on 4 GPUs (USP4 + HSDP4, encoder-TP4, VAE-PP4 tile)",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "MiniMaxAI/MiniMax-H3",
+      "serve_args": {
+        "trust-remote-code": true,
+        "task-type": "fl2va",
+        "num-gpus": 4,
+        "usp": 4,
+        "ring": 1,
+        "use-hsdp": true,
+        "hsdp-shard-size": 4,
+        "text-encoder-tp-size": 4,
+        "vae-patch-parallel-size": 4,
+        "vae-parallel-mode": "tile",
+        "vae-use-tiling": true,
+        "diffusion-attention-backend": "FLASH_ATTN",
+        "stage-init-timeout": 1800,
+        "init-timeout": 1800,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1344x768_frames209_steps8",
+        "dataset": "random",
+        "task": "t2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "warmup-requests": 1,
+        "warmup-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1344,
+            "height": 768,
+            "prompt": "Cinematic drone shot pushing through misty mountain ridges at sunrise, golden light catching the clouds, slow and smooth.",
+            "num_inference_steps": 8,
+            "num_frames": 209,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "flow_shift": 12.0,
+          "extra_params": "{\"task\":\"t2va\",\"duration\":8.7,\"aspect_ratio\":\"16:9\",\"audio_flow_shift\":3.0}"
+        },
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0211,
+            "latency_mean": 38.3252,
+            "peak_memory_mb_mean": 54219.6
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_minimax_h3_ti2v_4gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "MiniMax-H3 FL2VA first-frame image-to-video+audio on 4 GPUs (USP4 + HSDP4, encoder-TP4, VAE-PP4 tile)",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "MiniMaxAI/MiniMax-H3",
+      "serve_args": {
+        "trust-remote-code": true,
+        "task-type": "fl2va",
+        "num-gpus": 4,
+        "usp": 4,
+        "ring": 1,
+        "use-hsdp": true,
+        "hsdp-shard-size": 4,
+        "text-encoder-tp-size": 4,
+        "vae-patch-parallel-size": 4,
+        "vae-parallel-mode": "tile",
+        "vae-use-tiling": true,
+        "diffusion-attention-backend": "FLASH_ATTN",
+        "stage-init-timeout": 1800,
+        "init-timeout": 1800,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1344x768_frames209_steps8",
+        "dataset": "random",
+        "task": "ti2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "warmup-requests": 1,
+        "warmup-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1344,
+            "height": 768,
+            "prompt": "Continue the scene: the camera slowly pushes in on the subject as the background city lights drift and blur, with the actor singing softly and emotionally.",
+            "num_inference_steps": 8,
+            "num_frames": 209,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "flow_shift": 12.0,
+          "extra_params": "{\"task\":\"fl2va\",\"duration\":8.7,\"audio_flow_shift\":3.0}"
+        },
+        "num-input-images": 1,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0212,
+            "latency_mean": 38.1385,
+            "peak_memory_mb_mean": 54622.8
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_minimax_h3_v2v_4gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "MiniMax-H3 Ref2VA video-reference-to-video+audio on 4 GPUs (USP4 + HSDP4, encoder-TP4, VAE-PP4 tile)",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "MiniMaxAI/MiniMax-H3",
+      "serve_args": {
+        "trust-remote-code": true,
+        "task-type": "ref2va",
+        "num-gpus": 4,
+        "usp": 4,
+        "ring": 1,
+        "use-hsdp": true,
+        "hsdp-shard-size": 4,
+        "text-encoder-tp-size": 4,
+        "vae-patch-parallel-size": 4,
+        "vae-parallel-mode": "tile",
+        "vae-use-tiling": true,
+        "diffusion-attention-backend": "FLASH_ATTN",
+        "stage-init-timeout": 1800,
+        "init-timeout": 1800,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1344x768_frames209_steps8",
+        "dataset": "random",
+        "task": "v2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "warmup-requests": 1,
+        "warmup-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1344,
+            "height": 768,
+            "prompt": "Restyle the reference footage into a cinematic night scene with neon reflections, keeping the same camera motion and subject.",
+            "num_inference_steps": 8,
+            "num_frames": 209,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "flow_shift": 12.0,
+          "extra_params": "{\"task\":\"ref2va\",\"duration\":8.7,\"aspect_ratio\":\"16:9\",\"audio_flow_shift\":3.0}"
+        },
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0077,
+            "latency_mean": 105.7508,
+            "peak_memory_mb_mean": 55180.8
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_minimax_h3_t2v_dlo_4gpu",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "MiniMax-H3 T2VA with 4-card distributed layerwise offload (DLO), 8 denoise steps (USP4 + HSDP4, encoder-TP4, VAE-PP4 tile)",
+    "server_type": "vllm-omni",
+    "benchmark_endpoint": "/v1/videos",
+    "server_params": {
+      "model": "MiniMaxAI/MiniMax-H3",
+      "serve_args": {
+        "trust-remote-code": true,
+        "task-type": "fl2va",
+        "num-gpus": 4,
+        "usp": 4,
+        "ring": 1,
+        "use-hsdp": true,
+        "hsdp-shard-size": 4,
+        "text-encoder-tp-size": 4,
+        "vae-patch-parallel-size": 4,
+        "vae-parallel-mode": "tile",
+        "vae-use-tiling": true,
+        "diffusion-attention-backend": "FLASH_ATTN",
+        "stage-init-timeout": 1800,
+        "init-timeout": 1800,
+        "enable-diffusion-pipeline-profiler": true,
+        "enable-distributed-layerwise-offload": true,
+        "dlo-no-use-allgather": true,
+        "dlo-resident-layers": 8,
+        "enforce-eager": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "1344x768_frames209_steps8",
+        "dataset": "random",
+        "task": "t2v",
+        "num-prompts": 3,
+        "max-concurrency": 1,
+        "warmup-requests": 1,
+        "warmup-concurrency": 1,
+        "seed": 42,
+        "random-request-config": [
+          {
+            "width": 1344,
+            "height": 768,
+            "prompt": "Cinematic drone shot pushing through misty mountain ridges at sunrise, golden light catching the clouds, slow and smooth.",
+            "num_inference_steps": 8,
+            "num_frames": 209,
+            "fps": 24,
+            "weight": 1
+          }
+        ],
+        "extra-body": {
+          "flow_shift": 12.0,
+          "extra_params": "{\"task\":\"t2va\",\"duration\":8.7,\"aspect_ratio\":\"16:9\",\"audio_flow_shift\":3.0}"
+        },
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0212,
+            "latency_mean": 38.2089,
+            "peak_memory_mb_mean": 36218.4
+          }
+        }
+      }
+    ]
+  }
+]
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json b/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
index 459554f63..a73abc5fb 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
@@ -1,331 +1,360 @@
 [
-    {
-        "test_name": "test_qwen3_omni_chunk",
-        "server_params": {
-            "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-            "extra_cli_args": [
-                "--async-chunk"
+  {
+    "test_name": "test_qwen3_omni_chunk",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "omni"
+    ],
+    "server_params": {
+      "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+      "extra_cli_args": [
+        "--async-chunk"
+      ]
+    },
+    "benchmark_params": [
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              96.4061,
+              140.8147,
+              271.9025,
+              362.2916,
+              507.776
+            ],
+            "mean_e2el_ms": [
+              18507.4582,
+              28365.4956,
+              31907.9613,
+              48161.5829,
+              72630.8601
+            ],
+            "mean_audio_rtf": [
+              0.1175,
+              0.18,
+              0.2359,
+              0.3278,
+              0.6296
             ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          10
+        ],
+        "request_rate": [
+          0.1
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 1,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "audio": 1
         },
-        "benchmark_params": [
-            {
-                "dataset_name": "random",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    4,
-                    16,
-                    32,
-                    64,
-                    128
-                ],
-                "max_concurrency": [
-                    1,
-                    4,
-                    8,
-                    16,
-                    32
-                ],
-                "random_input_len": 2500,
-                "random_output_len": 900,
-                "ignore_eos": true,
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        135.4379,
-                        187.0896,
-                        400,
-                        435.675,
-                        724.6836
-                    ],
-                    "mean_e2el_ms": [
-                        17619.9851,
-                        34811.8335,
-                        43656.9501,
-                        56657.1548,
-                        85097.6016
-                    ],
-                    "mean_audio_rtf": [
-                        0.1279,
-                        0.2238,
-                        0.2735,
-                        0.3712,
-                        0.5634
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    10
-                ],
-                "request_rate": [
-                    0.1
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 1,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(0, 60, 3)": 1.0
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        340.329
-                    ],
-                    "mean_e2el_ms": [
-                        4305.477
-                    ],
-                    "mean_audio_rtf": [
-                        0.1305
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    40
-                ],
-                "request_rate": [
-                    0.5
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 2,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.5,
-                    "(720, 1280, 2)": 0.5
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        220.0909
-                    ],
-                    "mean_e2el_ms": [
-                        5475.9565
-                    ],
-                    "mean_audio_rtf": [
-                        0.1818
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    100
-                ],
-                "request_rate": [
-                    1.0
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 3,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1,
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.34,
-                    "(720, 1280, 2)": 0.33,
-                    "(0, 60, 3)": 0.33
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        450.0155
-                    ],
-                    "mean_e2el_ms": [
-                        8516.8316
-                    ],
-                    "mean_audio_rtf": [
-                        0.2717
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    4,
-                    16,
-                    32,
-                    64,
-                    128
-                ],
-                "max_concurrency": [
-                    1,
-                    4,
-                    8,
-                    16,
-                    32
-                ],
-                "random_input_len": 2500,
-                "random_output_len": 900,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        78.4278,
-                        195.8037,
-                        333.7318,
-                        561.805,
-                        1038.043
-                    ],
-                    "mean_e2el_ms": [
-                        4288.3029,
-                        7429.9429,
-                        9451.6184,
-                        12607.5292,
-                        18153.2547
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    10
-                ],
-                "request_rate": [
-                    0.1
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 1,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(0, 60, 3)": 1.0
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        275.3875
-                    ],
-                    "mean_e2el_ms": [
-                        730.6995
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    40
-                ],
-                "request_rate": [
-                    0.5
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 2,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.5,
-                    "(720, 1280, 2)": 0.5
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        166.2201
-                    ],
-                    "mean_e2el_ms": [
-                        673.5789
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    100
-                ],
-                "request_rate": [
-                    1.0
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 3,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1,
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.34,
-                    "(720, 1280, 2)": 0.33,
-                    "(0, 60, 3)": 0.33
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        357.7781
-                    ],
-                    "mean_e2el_ms": [
-                        953.3493
-                    ]
-                }
-            }
-        ]
-    }
+        "random_mm_bucket_config": {
+          "(0, 60, 3)": 1.0
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              354.0951
+            ],
+            "mean_e2el_ms": [
+              3952.5615
+            ],
+            "mean_audio_rtf": [
+              0.117
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          40
+        ],
+        "request_rate": [
+          0.5
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              259.6317
+            ],
+            "mean_e2el_ms": [
+              4253.3009
+            ],
+            "mean_audio_rtf": [
+              0.1448
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          100
+        ],
+        "request_rate": [
+          1.0
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 3,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1,
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.34,
+          "(720, 1280, 2)": 0.33,
+          "(0, 60, 3)": 0.33
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              457.4453
+            ],
+            "mean_e2el_ms": [
+              5912.5623
+            ],
+            "mean_audio_rtf": [
+              0.1967
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              90.8033,
+              202.1779,
+              326.5864,
+              544.8914,
+              961.3929
+            ],
+            "mean_e2el_ms": [
+              4517.3411,
+              7857.9711,
+              9861.1687,
+              13283.3363,
+              19541.0736
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          10
+        ],
+        "request_rate": [
+          0.1
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 1,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(0, 60, 3)": 1.0
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              318.048
+            ],
+            "mean_e2el_ms": [
+              807.6114
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          40
+        ],
+        "request_rate": [
+          0.5
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              186.168
+            ],
+            "mean_e2el_ms": [
+              726.1137
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          100
+        ],
+        "request_rate": [
+          1.0
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 3,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1,
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.34,
+          "(720, 1280, 2)": 0.33,
+          "(0, 60, 3)": 0.33
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              375.5282
+            ],
+            "mean_e2el_ms": [
+              1006.1663
+            ]
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json b/tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
index bee799a77..a3d8aaea8 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
@@ -1,115 +1,135 @@
 [
-    {
-        "test_name": "test_qwen3_omni_3gpu_replica2",
-        "server_params": {
-            "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-            "stage_overrides": {
-                "1": {"num_replicas": 2, "devices": "1,2"},
-                "2": {"num_replicas": 2, "devices": "1,2"}
-            },
-            "extra_cli_args": [
-                "--async-chunk"
-            ]
-        },
-        "benchmark_params": [
-            {
-                "dataset_name": "random",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [128, 128, 128, 128],
-                "max_concurrency": [8, 16, 24, 32],
-                "random_input_len": 2500,
-                "random_output_len": 900,
-                "ignore_eos": true,
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [203, 283, 470, 869],
-                    "mean_tpot_ms": [28, 36, 41, 45],
-                    "mean_audio_ttfp_ms": [861, 1200, 1528, 2100],
-                    "mean_audio_rtf": [0.24, 0.30, 0.35, 0.39]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [10],
-                "request_rate": [0.1],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 1,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(0, 60, 3)": 1.0
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [377],
-                    "mean_audio_ttfp_ms": [684],
-                    "mean_audio_rtf": [0.14]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [40],
-                "request_rate": [0.5],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 2,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.5,
-                    "(720, 1280, 2)": 0.5
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [228],
-                    "mean_audio_ttfp_ms": [686],
-                    "mean_audio_rtf": [0.16]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [100],
-                "request_rate": [1.0],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 3,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1,
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.34,
-                    "(720, 1280, 2)": 0.33,
-                    "(0, 60, 3)": 0.33
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [522],
-                    "mean_audio_ttfp_ms": [1119],
-                    "mean_audio_rtf": [0.21]
-                }
+  {
+    "test_name": "test_qwen3_omni_3gpu_replica2",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 3
+        }
+      },
+      "full_model",
+      "omni"
+    ],
+    "server_params": {
+      "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+      "stage_overrides": {
+          "1": {"num_replicas": 2, "devices": "1,2"},
+          "2": {"num_replicas": 2, "devices": "1,2"}
+      },
+      "extra_cli_args": [
+        "--async-chunk"
+      ]
+    },
+    "benchmark_params": [
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [128, 128, 128, 128],
+        "max_concurrency": [8, 16, 24, 32],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+            "H100": {
+                "mean_ttft_ms": [130.5751, 278.6469, 324.7249, 911.6085],
+                "mean_tpot_ms": [7.9854, 11.1209, 16.1507, 20.7485],
+                "mean_audio_ttfp_ms": [486.486, 954.1791, 1289.6514, 2196.8275],
+                "mean_audio_rtf": [0.1896, 0.3962, 0.4098, 0.7322]
             }
-        ]
-    }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [10],
+        "request_rate": [0.1],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 1,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(0, 60, 3)": 1.0
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+            "H100": {
+                "mean_ttft_ms": [340.5122],
+                "mean_audio_ttfp_ms": [463.0752],
+                "mean_audio_rtf": [0.1153]
+            }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [40],
+        "request_rate": [0.5],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+            "H100": {
+                "mean_ttft_ms": [236.926],
+                "mean_audio_ttfp_ms": [395.2182],
+                "mean_audio_rtf": [0.1259]
+            }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [100],
+        "request_rate": [1.0],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 3,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1,
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.34,
+          "(720, 1280, 2)": 0.33,
+          "(0, 60, 3)": 0.33
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+            "H100": {
+                "mean_ttft_ms": [470.6126],
+                "mean_audio_ttfp_ms": [665.5474],
+                "mean_audio_rtf": [0.166]
+            }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json b/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
index d01ca06b4..38dbfb2e3 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
@@ -1,170 +1,191 @@
 [
-    {
-        "test_name": "test_qwen3_omni",
-        "server_params": {
-            "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-            "extra_cli_args": [
-                "--no-async-chunk"
+  {
+    "test_name": "test_qwen3_omni",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "omni"
+    ],
+    "server_params": {
+      "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+      "extra_cli_args": [
+        "--no-async-chunk"
+      ]
+    },
+    "benchmark_params": [
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              115.8348,
+              173.1823,
+              446.672,
+              464.5985,
+              3420.0634
+            ],
+            "mean_e2el_ms": [
+              25070.9523,
+              31992.0646,
+              37619.7669,
+              50393.8257,
+              136619.2743
+            ],
+            "mean_audio_rtf": [
+              0.169,
+              0.2111,
+              0.2475,
+              0.3551,
+              0.9266
             ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          10
+        ],
+        "request_rate": [
+          0.1
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 1,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "audio": 1
         },
-        "benchmark_params": [
-            {
-                "dataset_name": "random",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    4,
-                    16,
-                    32,
-                    64,
-                    128
-                ],
-                "max_concurrency": [
-                    1,
-                    4,
-                    8,
-                    16,
-                    32
-                ],
-                "random_input_len": 2500,
-                "random_output_len": 900,
-                "ignore_eos": true,
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        109.1218,
-                        247.4411,
-                        354.9384,
-                        447.7885,
-                        694.7487
-                    ],
-                    "mean_e2el_ms": [
-                        22413.667,
-                        30808.9715,
-                        35677.844,
-                        46345.8978,
-                        68350.4853
-                    ],
-                    "mean_audio_rtf": [
-                        0.1695,
-                        0.2033,
-                        0.2467,
-                        0.3234,
-                        0.4438
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    10
-                ],
-                "request_rate": [
-                    0.1
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 1,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(0, 60, 3)": 1.0
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        323.3573
-                    ],
-                    "mean_e2el_ms": [
-                        4623.4173
-                    ],
-                    "mean_audio_rtf": [
-                        0.1406
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    40
-                ],
-                "request_rate": [
-                    0.5
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 2,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.5,
-                    "(720, 1280, 2)": 0.5
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        215.4502
-                    ],
-                    "mean_e2el_ms": [
-                        4924.149
-                    ],
-                    "mean_audio_rtf": [
-                        0.1637
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "openai-chat-omni",
-                "endpoint": "/v1/chat/completions",
-                "num_prompts": [
-                    100
-                ],
-                "request_rate": [
-                    1.0
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "random_mm_base_items_per_request": 3,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1,
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.34,
-                    "(720, 1280, 2)": 0.33,
-                    "(0, 60, 3)": 0.33
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        442.5815
-                    ],
-                    "mean_e2el_ms": [
-                        6441.0986
-                    ],
-                    "mean_audio_rtf": [
-                        0.2091
-                    ]
-                }
-            }
-        ]
-    }
+        "random_mm_bucket_config": {
+          "(0, 60, 3)": 1.0
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              343.1377
+            ],
+            "mean_e2el_ms": [
+              4811.1123
+            ],
+            "mean_audio_rtf": [
+              0.1463
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          40
+        ],
+        "request_rate": [
+          0.5
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              245.5446
+            ],
+            "mean_e2el_ms": [
+              5019.1256
+            ],
+            "mean_audio_rtf": [
+              0.1713
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          100
+        ],
+        "request_rate": [
+          1.0
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "random_mm_base_items_per_request": 3,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1,
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.34,
+          "(720, 1280, 2)": 0.33,
+          "(0, 60, 3)": 0.33
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              506.1407
+            ],
+            "mean_e2el_ms": [
+              6814.9656
+            ],
+            "mean_audio_rtf": [
+              0.2213
+            ]
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json b/tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
index f608eca0e..8775ee381 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
@@ -1,180 +1,200 @@
 [
-    {
-        "test_name": "test_qwen3_omni_vllm_text",
-        "server_params": {
-            "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-            "use_omni": false,
-            "extra_cli_args": [
-                "--no-enable-prefix-caching",
-                "--skip-mm-profiling"
-            ]
+  {
+    "test_name": "test_qwen3_omni_vllm_text",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "omni"
+    ],
+    "server_params": {
+      "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+      "use_omni": false,
+      "extra_cli_args": [
+        "--no-enable-prefix-caching",
+        "--skip-mm-profiling"
+      ]
+    },
+    "benchmark_params": [
+      {
+        "dataset_name": "random",
+        "backend": "vllm",
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "endpoint": "/v1/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
         },
-        "benchmark_params": [
-            {
-                "dataset_name": "random",
-                "backend": "vllm",
-                "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-                "endpoint": "/v1/completions",
-                "num_prompts": [
-                    4,
-                    16,
-                    32,
-                    64,
-                    128
-                ],
-                "max_concurrency": [
-                    1,
-                    4,
-                    8,
-                    16,
-                    32
-                ],
-                "random_input_len": 2500,
-                "random_output_len": 900,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        69.1276,
-                        255.1882,
-                        310.639,
-                        422.0337,
-                        532.0582
-                    ],
-                    "mean_e2el_ms": [
-                        4382.7211,
-                        7510.3815,
-                        9440.4854,
-                        12553.0186,
-                        16932.6065
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "vllm",
-                "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-                "endpoint": "/v1/completions",
-                "num_prompts": [
-                    10
-                ],
-                "request_rate": [
-                    0.1
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 1,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(0, 60, 3)": 1.0
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        26.3381
-                    ],
-                    "mean_e2el_ms": [
-                        485.2436
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "vllm",
-                "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-                "endpoint": "/v1/completions",
-                "num_prompts": [
-                    40
-                ],
-                "request_rate": [
-                    0.5
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 2,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.5,
-                    "(720, 1280, 2)": 0.5
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        26.4517
-                    ],
-                    "mean_e2el_ms": [
-                        517.2017
-                    ]
-                }
-            },
-            {
-                "dataset_name": "random-mm",
-                "backend": "vllm",
-                "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-                "endpoint": "/v1/completions",
-                "num_prompts": [
-                    100
-                ],
-                "request_rate": [
-                    1.0
-                ],
-                "random_input_len": 100,
-                "random_output_len": 100,
-                "random_range_ratio": 0.0,
-                "ignore_eos": true,
-                "extra_body": {
-                    "modalities": [
-                        "text"
-                    ]
-                },
-                "random_mm_base_items_per_request": 3,
-                "random_mm_num_mm_items_range_ratio": 0.5,
-                "random_mm_limit_mm_per_prompt": {
-                    "image": 1,
-                    "video": 1,
-                    "audio": 1
-                },
-                "random_mm_bucket_config": {
-                    "(256, 256, 1)": 0.34,
-                    "(720, 1280, 2)": 0.33,
-                    "(0, 60, 3)": 0.33
-                },
-                "percentile-metrics": "ttft,tpot,itl,e2el",
-                "baseline": {
-                    "mean_ttft_ms": [
-                        27.6972
-                    ],
-                    "mean_e2el_ms": [
-                        561.3684
-                    ]
-                }
-            }
-        ]
-    }
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              69.8081,
+              173.0651,
+              271.8108,
+              413.4079,
+              497.2546
+            ],
+            "mean_e2el_ms": [
+              4720.8225,
+              7937.2532,
+              9962.3566,
+              13724.5479,
+              18324.091
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "vllm",
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "endpoint": "/v1/completions",
+        "num_prompts": [
+          10
+        ],
+        "request_rate": [
+          0.1
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 1,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(0, 60, 3)": 1.0
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              25.9477
+            ],
+            "mean_e2el_ms": [
+              517.3155
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "vllm",
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "endpoint": "/v1/completions",
+        "num_prompts": [
+          40
+        ],
+        "request_rate": [
+          0.5
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              26.7056
+            ],
+            "mean_e2el_ms": [
+              551.308
+            ]
+          }
+        }
+      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "vllm",
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "endpoint": "/v1/completions",
+        "num_prompts": [
+          100
+        ],
+        "request_rate": [
+          1.0
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 3,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1,
+          "audio": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.34,
+          "(720, 1280, 2)": 0.33,
+          "(0, 60, 3)": 0.33
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_ttft_ms": [
+              27.6906
+            ],
+            "mean_e2el_ms": [
+              596.5284
+            ]
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json b/tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
index 118fa6733..dcd2188c5 100644
--- a/tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_qwen_image_edit_2511_vllm_omni.json
@@ -1,149 +1,196 @@
 [
-    {
-        "test_name": "test_qwen_image_edit_2511_single_device",
-        "description": "Single-device baseline (two input images)",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit-2511",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20_i2i_2img",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 2,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0721,
-                    "latency_mean": 13.8398,
-                    "peak_memory_mb_max": 54731.4,
-                    "peak_memory_mb_mean": 54731.4
-                }
-            },
-            {
-                "name": "1536x1536_steps35_i2i_2img",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 2,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0186,
-                    "latency_mean": 53.6942,
-                    "peak_memory_mb_max": 64402.4,
-                    "peak_memory_mb_mean": 64402.4
-                }
-            }
-        ]
+  {
+    "test_name": "test_qwen_image_edit_2511_single_device",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline (two input images)",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit-2511",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_edit_2511_ulysses2_cfg2_vae_patch4",
-        "description": "Ulysses SP=2 + CFG=2 + VAE patch parallel=4",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit-2511",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "vae-patch-parallel-size": 4,
-                "vae-use-tiling": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1536x1536_steps35_i2i_2img",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 2,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0538,
-                    "latency_mean": 18.5591,
-                    "peak_memory_mb_max": 53485.0,
-                    "peak_memory_mb_mean": 53485.0
-                }
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_i2i_2img",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 2,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0721,
+            "latency_mean": 13.8398,
+            "peak_memory_mb_max": 57610.0,
+            "peak_memory_mb_mean": 57610.0
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35_i2i_2img",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 2,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0186,
+            "latency_mean": 53.6942,
+            "peak_memory_mb_max": 67790.0,
+            "peak_memory_mb_mean": 67790.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_edit_2511_ulysses2_cfg2_vae_patch4",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG=2 + VAE patch parallel=4",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit-2511",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_edit_2511_ulysses2_cfg2_cache_dit",
-        "description": "Ulysses SP=2 + CFG=2 + CacheDiT",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit-2511",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "cache-backend": "cache_dit",
-                "cache-config": {
-                    "Fn_compute_blocks": 1,
-                    "Bn_compute_blocks": 0,
-                    "max_warmup_steps": 4,
-                    "residual_diff_threshold": 0.24,
-                    "max_continuous_cached_steps": 3,
-                    "enable_taylorseer": false,
-                    "taylorseer_order": 1,
-                    "scm_steps_mask_policy": null,
-                    "scm_steps_policy": "dynamic"
-                },
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1536x1536_steps35_i2i_2img",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 2,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0538,
+            "latency_mean": 18.5591,
+            "peak_memory_mb_max": 56449.4286,
+            "peak_memory_mb_mean": 56449.4286
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_edit_2511_ulysses2_cfg2_cache_dit",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG=2 + CacheDiT",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit-2511",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "cache-backend": "cache_dit",
+        "cache-config": {
+          "Fn_compute_blocks": 1,
+          "Bn_compute_blocks": 0,
+          "max_warmup_steps": 4,
+          "residual_diff_threshold": 0.24,
+          "max_continuous_cached_steps": 3,
+          "enable_taylorseer": false,
+          "taylorseer_order": 1,
+          "scm_steps_mask_policy": null,
+          "scm_steps_policy": "dynamic"
         },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20_i2i_2img",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 2,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.2776,
-                    "latency_mean": 3.5938,
-                    "peak_memory_mb_max": 55214.0,
-                    "peak_memory_mb_mean": 55214.0
-                }
-            },
-            {
-                "name": "1536x1536_steps35_i2i_2img",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 2,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.1051,
-                    "latency_mean": 9.4918,
-                    "peak_memory_mb_max": 64265.6,
-                    "peak_memory_mb_mean": 64265.6
-                }
-            }
-        ]
-    }
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_i2i_2img",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 2,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.2776,
+            "latency_mean": 3.5938,
+            "peak_memory_mb_max": 58113.7143,
+            "peak_memory_mb_mean": 58075.1429
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35_i2i_2img",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 2,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.1051,
+            "latency_mean": 9.4918,
+            "peak_memory_mb_max": 68107.4286,
+            "peak_memory_mb_mean": 68107.4286
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json b/tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json
index da3288182..686bd6160 100644
--- a/tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_qwen_image_edit_vllm_omni.json
@@ -1,144 +1,190 @@
 [
-    {
-        "test_name": "test_qwen_image_edit_single_device",
-        "description": "Single-device baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.1129,
-                    "latency_mean": 8.8352,
-                    "peak_memory_mb_max": 55356.5,
-                    "peak_memory_mb_mean": 55356.5
-                }
-            },
-            {
-                "name": "1536x1536_steps35_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0240,
-                    "latency_mean": 41.5686,
-                    "peak_memory_mb_max": 62762.7,
-                    "peak_memory_mb_mean": 62762.7
-                }
-            }
-        ]
+  {
+    "test_name": "test_qwen_image_edit_single_device",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_edit_ulysses2_cfg2_vae_patch4",
-        "description": "Ulysses SP=2 + CFG=2 + VAE patch parallel=4",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "vae-patch-parallel-size": 4,
-                "vae-use-tiling": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1536x1536_steps35_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0672,
-                    "latency_mean": 14.8517,
-                    "peak_memory_mb_max": 53931.5,
-                    "peak_memory_mb_mean": 53931.5
-                }
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.1129,
+            "latency_mean": 8.8352,
+            "peak_memory_mb_max": 58572.0,
+            "peak_memory_mb_mean": 58572.0
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.024,
+            "latency_mean": 41.5686,
+            "peak_memory_mb_max": 66368.0,
+            "peak_memory_mb_mean": 66368.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_edit_ulysses2_cfg2_vae_patch4",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG=2 + VAE patch parallel=4",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_edit_ulysses2_cfg2_cache_dit",
-        "description": "Ulysses SP=2 + CFG=2 + CacheDiT",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Edit",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "cache-backend": "cache_dit",
-                "cache-config": {
-                    "Fn_compute_blocks": 1,
-                    "Bn_compute_blocks": 0,
-                    "max_warmup_steps": 4,
-                    "residual_diff_threshold": 0.24,
-                    "max_continuous_cached_steps": 3,
-                    "enable_taylorseer": false,
-                    "taylorseer_order": 1,
-                    "scm_steps_mask_policy": null,
-                    "scm_steps_policy": "dynamic"
-                },
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1536x1536_steps35_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0672,
+            "latency_mean": 14.8517,
+            "peak_memory_mb_max": 57076.0,
+            "peak_memory_mb_mean": 57076.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_edit_ulysses2_cfg2_cache_dit",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG=2 + CacheDiT",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Edit",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "cache-backend": "cache_dit",
+        "cache-config": {
+          "Fn_compute_blocks": 1,
+          "Bn_compute_blocks": 0,
+          "max_warmup_steps": 4,
+          "residual_diff_threshold": 0.24,
+          "max_continuous_cached_steps": 3,
+          "enable_taylorseer": false,
+          "taylorseer_order": 1,
+          "scm_steps_mask_policy": null,
+          "scm_steps_policy": "dynamic"
         },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.2879,
-                    "latency_mean": 3.4701,
-                    "peak_memory_mb_max": 55525.6,
-                    "peak_memory_mb_mean": 55525.6
-                }
-            },
-            {
-                "name": "1536x1536_steps35_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.1113,
-                    "latency_mean": 8.9656,
-                    "peak_memory_mb_max": 63758.3,
-                    "peak_memory_mb_mean": 63758.3
-                }
-            }
-        ]
-    }
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.2879,
+            "latency_mean": 3.4701,
+            "peak_memory_mb_max": 58758.0,
+            "peak_memory_mb_mean": 58758.0
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.1113,
+            "latency_mean": 8.9656,
+            "peak_memory_mb_max": 67424.0,
+            "peak_memory_mb_mean": 67424.0
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json b/tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json
index a94db56f5..bc4d93a24 100644
--- a/tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_qwen_image_layered_vllm_omni.json
@@ -1,49 +1,65 @@
 [
-    {
-        "test_name": "test_qwen_image_layered_single_device",
-        "description": "Single-device baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image-Layered",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "640x640_steps20_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 640,
-                "height": 640,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0703,
-                    "latency_mean": 14.208,
-                    "peak_memory_mb_max": 60543.5,
-                    "peak_memory_mb_mean": 60543.5
-                }
-            },
-            {
-                "name": "1024x1024_steps35_i2i",
-                "dataset": "random",
-                "task": "i2i",
-                "width": 1024,
-                "height": 1024,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0417,
-                    "latency_mean": 23.914,
-                    "peak_memory_mb_max": 60543.5,
-                    "peak_memory_mb_mean": 60543.5
-                }
-            }
-        ]
-    }
+  {
+    "test_name": "test_qwen_image_layered_single_device",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image-Layered",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "640x640_steps20_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 640,
+        "height": 640,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0703,
+            "latency_mean": 14.208,
+            "peak_memory_mb_max": 63225.1429,
+            "peak_memory_mb_mean": 63225.1429
+          }
+        }
+      },
+      {
+        "name": "1024x1024_steps35_i2i",
+        "dataset": "random",
+        "task": "i2i",
+        "width": 1024,
+        "height": 1024,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0417,
+            "latency_mean": 23.914,
+            "peak_memory_mb_max": 63225.1429,
+            "peak_memory_mb_mean": 63225.1429
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json b/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
index 5ca6ed61a..ebf9ccc29 100644
--- a/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
@@ -1,219 +1,295 @@
 [
-    {
-        "test_name": "test_qwen_image_single_device",
-        "description": "Single-device baseline (no parallelism)",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.4153,
-                    "latency_mean": 2.4065,
-                    "peak_memory_mb_mean": 52289.9
-                }
-            },
-            {
-                "name": "1536x1536_steps35",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0423,
-                    "latency_mean": 23.5991,
-                    "peak_memory_mb_mean": 61360.5
-                }
-            }
-        ]
+  {
+    "test_name": "test_qwen_image_single_device",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline (no parallelism)",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_single_device_step_execution",
-        "description": "Single-device baseline (no parallelism) with step execution",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true,
-                "step-execution": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.4175,
-                    "latency_mean": 2.3953,
-                    "peak_memory_mb_mean": 56000
-                }
-            },
-            {
-                "name": "1536x1536_steps35",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.0423,
-                    "latency_mean": 23.5768,
-                    "peak_memory_mb_mean": 65000
-                }
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.4153,
+            "latency_mean": 2.4065,
+            "peak_memory_mb_mean": 55121.4286
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0423,
+            "latency_mean": 23.5991,
+            "peak_memory_mb_mean": 65118.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_single_device_step_execution",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline (no parallelism) with step execution",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true,
+        "step-execution": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_ulysses2_cfg2_vae_patch4",
-        "description": "Ulysses SP=2 + CFG-parallel=2 + VAE Patch Parallel=4",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "vae-patch-parallel-size": 4,
-                "vae-use-tiling": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "1536x1536_steps35",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.1214,
-                    "latency_mean": 8.2211,
-                    "peak_memory_mb_mean": 51704.7
-                }
-            }
-        ]
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.4175,
+            "latency_mean": 2.3953,
+            "peak_memory_mb_mean": 55088.5714
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0423,
+            "latency_mean": 23.5768,
+            "peak_memory_mb_mean": 66012.2857
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_ulysses2_cfg2_vae_patch4",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG-parallel=2 + VAE Patch Parallel=4",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "vae-patch-parallel-size": 4,
+        "vae-use-tiling": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_ulysses2_cfg2_cache_dit",
-        "description": "Ulysses SP=2 + CFG-parallel=2 + CacheDiT acceleration",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image",
-            "serve_args": {
-                "ulysses-degree": 2,
-                "cfg-parallel-size": 2,
-                "cache-backend": "cache_dit",
-                "cache-config": {
-                    "Fn_compute_blocks": 1,
-                    "Bn_compute_blocks": 0,
-                    "max_warmup_steps": 4,
-                    "residual_diff_threshold": 0.24,
-                    "max_continuous_cached_steps": 3,
-                    "enable_taylorseer": false,
-                    "taylorseer_order": 1,
-                    "scm_steps_mask_policy": null,
-                    "scm_steps_policy": "dynamic"
-                },
-                "enable-diffusion-pipeline-profiler": true
-            }
+    "benchmark_params": [
+      {
+        "name": "1536x1536_steps35",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.1214,
+            "latency_mean": 8.2211,
+            "peak_memory_mb_mean": 54501.1429
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_ulysses2_cfg2_cache_dit",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 4
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Ulysses SP=2 + CFG-parallel=2 + CacheDiT acceleration",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "ulysses-degree": 2,
+        "cfg-parallel-size": 2,
+        "cache-backend": "cache_dit",
+        "cache-config": {
+          "Fn_compute_blocks": 1,
+          "Bn_compute_blocks": 0,
+          "max_warmup_steps": 4,
+          "residual_diff_threshold": 0.24,
+          "max_continuous_cached_steps": 3,
+          "enable_taylorseer": false,
+          "taylorseer_order": 1,
+          "scm_steps_mask_policy": null,
+          "scm_steps_policy": "dynamic"
         },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.559,
-                    "latency_mean": 1.794,
-                    "peak_memory_mb_mean": 52397.6775
-                }
-            },
-            {
-                "name": "1536x1536_steps35",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 1536,
-                "height": 1536,
-                "num-inference-steps": 35,
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": 0.1918,
-                    "latency_mean": 5.2022,
-                    "peak_memory_mb_mean": 61468.8
-                }
-            }
-        ]
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_qwen_image_single_device_step_execution_high_concurrency",
-        "description": "Single-device Qwen-Image step-level execution benchmark at 512x512, 20 steps, concurrency sweep",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Qwen/Qwen-Image",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true,
-                "step-execution": true,
-                "max-num-seqs": 8
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.559,
+            "latency_mean": 1.794,
+            "peak_memory_mb_mean": 55290.5714
+          }
+        }
+      },
+      {
+        "name": "1536x1536_steps35",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 1536,
+        "height": 1536,
+        "num-inference-steps": 35,
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "enable-negative-prompt": true,
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.1918,
+            "latency_mean": 5.2022,
+            "peak_memory_mb_mean": 64838.8571
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_qwen_image_single_device_step_execution_high_concurrency",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device Qwen-Image step-level execution benchmark at 512x512, 20 steps, concurrency sweep",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true,
+        "step-execution": true,
+        "max-num-seqs": 8
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_high_concurrency",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": [20, 40, 80, 160],
+        "max-concurrency": [1, 2, 4, 8],
+        "warmup-requests": 8,
+        "warmup-concurrency": 8,
+        "warmup-num-inference-steps": 20,
+        "enable-negative-prompt": true,
+        "baseline": {
+            "H100": {
+                "throughput_qps": [0.4125, 0.6714, 0.6674, 0.8159],
+                "latency_mean": [2.4215, 2.992, 5.9293, 9.656],
+                "peak_memory_mb_mean": [55147.4286, 55148.0, 55150.4643, 55152.3821]
             }
-        },
-        "benchmark_params": [
-            {
-                "name": "512x512_steps20_high_concurrency",
-                "dataset": "random",
-                "task": "t2i",
-                "width": 512,
-                "height": 512,
-                "num-inference-steps": 20,
-                "num-prompts": [20, 40, 80, 160],
-                "max-concurrency": [1, 2, 4, 8],
-                "warmup-requests": 8,
-                "warmup-concurrency": 8,
-                "warmup-num-inference-steps": 20,
-                "enable-negative-prompt": true,
-                "baseline": {
-                    "throughput_qps": [0.4125, 0.6714, 0.6674, 0.8159],
-                    "latency_mean": [2.4215, 2.992, 5.9293, 9.656],
-                    "peak_memory_mb_mean": [67000, 67000, 67000, 67000]
-                }
-            }
-        ]
-    }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/perf/tests/test_runner_metadata.py b/tests/dfx/perf/tests/test_runner_metadata.py
index a195c4546..81035a272 100644
--- a/tests/dfx/perf/tests/test_runner_metadata.py
+++ b/tests/dfx/perf/tests/test_runner_metadata.py
@@ -1,6 +1,8 @@
 """Tests for DFX runner metadata field exclusion."""
 
 import json
+from contextlib import contextmanager
+from types import SimpleNamespace
 
 import pytest
 
@@ -15,7 +17,7 @@ def test_task_excluded_from_cli_args():
         "backend": "openai-audio-speech",
         "endpoint": "/v1/audio/speech",
         "percentile-metrics": "audio_rtf,audio_ttfp",
-        "baseline": {"mean_audio_rtf": [0.5]},
+        "baseline": {"H100": {"mean_audio_rtf": [0.5]}},
     }
     exclude_keys = {
         "request_rate",
@@ -86,3 +88,400 @@ def test_enabled_false_entry_is_skipped():
     # Only the enabled=True entry should appear
     assert len(params) == 1
     assert params[0].get("task") == "voice_clone"
+
+
+def test_resolve_pytest_marks_hardware_dict_with_extra():
+    from tests.dfx.conftest import resolve_pytest_marks
+
+    marks = resolve_pytest_marks(
+        [
+            {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 2}},
+            "full_model",
+            "diffusion",
+            "local_model",
+        ]
+    )
+    names = {m.name for m in marks}
+    assert "H100" in names
+    assert "cuda" in names
+    assert "gpu" in names
+    assert "distributed_cuda" in names
+    assert "full_model" in names
+    assert "diffusion" in names
+    assert "local_model" in names
+
+
+def test_resolve_pytest_marks_rejects_legacy_object_format():
+    from tests.dfx.conftest import resolve_pytest_marks
+
+    with pytest.raises(ValueError, match="mark must be a list"):
+        resolve_pytest_marks(
+            {
+                "hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1},
+                "marks": ["full_model"],
+            }
+        )
+
+
+def test_resource_label_for_filename():
+    from tests.dfx.conftest import resource_label_for_filename
+
+    assert resource_label_for_filename("H100") == ""
+    assert resource_label_for_filename("L4") == "L4"
+    assert resource_label_for_filename("910B") == "910B"
+    assert resource_label_for_filename("na") == "na"
+
+
+def test_hardware_json_value():
+    from tests.dfx.conftest import hardware_json_value
+
+    assert hardware_json_value("H100") == "H100"
+    assert hardware_json_value("na") == ""
+    assert hardware_json_value(None) == ""
+
+
+def test_get_runtime_resource_label(monkeypatch):
+    from tests.dfx.conftest import get_runtime_resource_label
+
+    monkeypatch.setattr(
+        "tests.dfx.conftest._read_runtime_device_name",
+        lambda *, device_id=0: "NVIDIA H100 80GB HBM3",
+    )
+    assert get_runtime_resource_label(refresh=True) == "H100"
+    monkeypatch.setattr(
+        "tests.dfx.conftest._read_runtime_device_name",
+        lambda *, device_id=0: "Ascend910B2",
+    )
+    assert get_runtime_resource_label(refresh=True) == "910B"
+
+
+def test_load_benchmark_configs_from_dir(tmp_path):
+    from tests.dfx.conftest import load_benchmark_configs
+
+    (tmp_path / "a.json").write_text(
+        json.dumps([{"test_name": "test_a", "server_params": {"model": "m/a"}, "benchmark_params": []}]),
+        encoding="utf-8",
+    )
+    (tmp_path / "b.json").write_text(
+        json.dumps([{"test_name": "test_b", "server_params": {"model": "m/b"}, "benchmark_params": []}]),
+        encoding="utf-8",
+    )
+    configs = load_benchmark_configs(config_dir=tmp_path)
+    assert [c["test_name"] for c in configs] == ["test_a", "test_b"]
+
+
+def test_create_unique_server_pytest_params_applies_marks(tmp_path):
+    from tests.dfx.conftest import create_unique_server_pytest_params
+
+    configs = [
+        {
+            "test_name": "test_with_mark",
+            "mark": [
+                {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}},
+                "full_model",
+            ],
+            "server_params": {"model": "some/model"},
+            "benchmark_params": [{"name": "p0", "num_prompts": 1}],
+        },
+        {
+            "test_name": "test_without_mark",
+            "server_params": {"model": "other/model"},
+            "benchmark_params": [{"name": "p0", "num_prompts": 1}],
+        },
+    ]
+    params = create_unique_server_pytest_params(configs, tmp_path)
+    by_id = {p.id: p for p in params}
+    assert len(by_id["test_with_mark"].values) == 1
+    assert isinstance(by_id["test_with_mark"].values[0], tuple)
+    assert any(m.name == "H100" for m in by_id["test_with_mark"].marks)
+    assert not any(m.name == "H100" for m in by_id["test_without_mark"].marks)
+
+
+def test_is_diffusion_perf_config():
+    from tests.dfx.conftest import is_diffusion_perf_config
+
+    assert not is_diffusion_perf_config(
+        {"test_name": "omni_a", "mark": [{"hardware_marks": {"res": {"cuda": "H100"}}}, "omni"]}
+    )
+    assert is_diffusion_perf_config(
+        {
+            "test_name": "diff_a",
+            "server_type": "vllm-omni",
+            "mark": [{"hardware_marks": {"res": {"cuda": "H100"}}}, "diffusion"],
+        }
+    )
+
+
+def test_benchmark_param_id_suffix_from_task_eval_phase():
+    from tests.dfx.conftest import _unique_benchmark_param_id_suffixes
+
+    params = [
+        {"task": "default_voice", "eval_phase": "latency"},
+        {"task": "default_voice", "eval_phase": "throughput"},
+    ]
+    assert _unique_benchmark_param_id_suffixes(params) == [
+        "default_voice_latency",
+        "default_voice_throughput",
+    ]
+
+
+def test_paired_omni_benchmark_reuses_server_and_preserves_case_metadata(tmp_path, monkeypatch):
+    from tests.dfx.conftest import create_paired_omni_benchmark_pytest_params
+    from tests.dfx.perf.scripts import run_benchmark
+
+    configs = [
+        {
+            "test_name": "test_omni",
+            "mark": [
+                {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}},
+                "omni",
+            ],
+            "server_params": {"model": "m/omni"},
+            "benchmark_params": [{"name": "p0", "num_prompts": 1}, {"name": "p1", "num_prompts": 2}],
+        },
+        {
+            "test_name": "test_tts",
+            "mark": [
+                {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}},
+                "tts",
+            ],
+            "server_params": {"model": "m/tts"},
+            "benchmark_params": [{"name": "p0", "num_prompts": 1}],
+        },
+    ]
+    params = create_paired_omni_benchmark_pytest_params(configs, tmp_path)
+    by_id = {p.id: p for p in params}
+    assert set(by_id) == {"test_omni-p0", "test_omni-p1", "test_tts-p0"}
+    omni_row, bench_row = by_id["test_tts-p0"].values
+    assert omni_row[0] == "test_tts"
+    assert bench_row == ("test_tts", 0)
+    assert any(m.name == "tts" for m in by_id["test_tts-p0"].marks)
+    assert not any(m.name == "tts" for m in by_id["test_omni-p0"].marks)
+
+    omni_p0_server = by_id["test_omni-p0"].values[0]
+    omni_p1_server = by_id["test_omni-p1"].values[0]
+    tts_server = by_id["test_tts-p0"].values[0]
+    assert omni_p0_server == omni_p1_server
+    assert omni_p0_server != tts_server
+
+    events = []
+
+    @contextmanager
+    def fake_start(server_param):
+        events.append(("start", server_param))
+        yield object()
+        events.append(("stop", server_param))
+
+    monkeypatch.setattr(run_benchmark, "_start_omni_server", fake_start)
+    active_context = run_benchmark._SingleActiveContext()
+    try:
+        first = run_benchmark.omni_server.__wrapped__(
+            SimpleNamespace(param=omni_p0_server),
+            active_context,
+        )
+        second = run_benchmark.omni_server.__wrapped__(
+            SimpleNamespace(param=omni_p1_server),
+            active_context,
+        )
+        assert first is second
+        assert events == [("start", omni_p0_server)]
+
+        third = run_benchmark.omni_server.__wrapped__(
+            SimpleNamespace(param=tts_server),
+            active_context,
+        )
+        assert third is not first
+        assert events == [
+            ("start", omni_p0_server),
+            ("stop", omni_p0_server),
+            ("start", tts_server),
+        ]
+    finally:
+        active_context.close()
+
+    assert events == [
+        ("start", omni_p0_server),
+        ("stop", omni_p0_server),
+        ("start", tts_server),
+        ("stop", tts_server),
+    ]
+
+
+def test_is_hardware_nested_baseline():
+    from tests.dfx.conftest import (
+        _RUNTIME_DEVICE_ALIASES,
+        is_hardware_nested_baseline,
+    )
+    from tests.helpers.mark import get_hardware_mark_list
+
+    hardware_marks = get_hardware_mark_list()
+    assert hardware_marks
+    assert {"H100", "L4", "A3", "MI325", "B200"} <= hardware_marks
+    assert "cuda" not in hardware_marks
+    assert "full_model" not in hardware_marks
+
+    # Runtime aliases are a full static list (independent of baseline allowlist).
+    assert "H100" in _RUNTIME_DEVICE_ALIASES
+    assert "A100" in _RUNTIME_DEVICE_ALIASES
+
+    assert is_hardware_nested_baseline(
+        {
+            "H100": {"mean_ttft_ms": [1.0, 2.0], "mean_e2el_ms": [10.0, 20.0]},
+            "A3": {"mean_ttft_ms": [0.9, 1.8], "mean_e2el_ms": [9.0, 18.0]},
+        }
+    )
+    # Custom metric names under a known hardware label are allowed.
+    assert is_hardware_nested_baseline({"H100": {"custom_stage_ms": 12.0, "foo_bar": [1.0, 2.0]}})
+    assert is_hardware_nested_baseline({"A3": {"request_throughput": 0.5}})
+    # Flat metric maps / concurrency-keyed maps are not hardware-nested.
+    assert not is_hardware_nested_baseline({"mean_ttft_ms": [1.0, 2.0], "mean_e2el_ms": [10.0, 20.0]})
+    assert not is_hardware_nested_baseline({"mean_ttft_ms": {"1": 1.0, "32": 2.0}})
+    assert not is_hardware_nested_baseline({})
+    # Alias-only labels (not [hardware-resource] markers) are rejected for baselines.
+    assert not is_hardware_nested_baseline({"A100": {"throughput_qps": 1.0}})
+    # Unknown top-level hardware label is rejected.
+    assert not is_hardware_nested_baseline({"UnknownGPU": {"throughput_qps": 1.0}})
+    # Empty per-hardware metric map is rejected.
+    assert not is_hardware_nested_baseline({"H100": {}})
+
+
+def test_resolve_baseline_for_sweep_keeps_all_hardware_for_one_concurrency():
+    from tests.dfx.conftest import resolve_baseline_for_sweep
+
+    baseline = {
+        "H100": {
+            "mean_ttft_ms": [96.4, 140.8, 271.9, 362.3, 507.8],
+            "mean_e2el_ms": [18507.0, 28365.0, 31907.0, 48161.0, 72630.0],
+        },
+        "A3": {
+            "mean_ttft_ms": [90.0, 130.0, 250.0, 340.0, 480.0],
+            "mean_e2el_ms": [17000.0, 26000.0, 30000.0, 45000.0, 70000.0],
+        },
+    }
+    # max_concurrency=[1,4,8,16,32] -> index 4 is concurrency 32
+    got = resolve_baseline_for_sweep(baseline, sweep_index=4)
+    assert got == {
+        "H100": {"mean_ttft_ms": 507.8, "mean_e2el_ms": 72630.0},
+        "A3": {"mean_ttft_ms": 480.0, "mean_e2el_ms": 70000.0},
+    }
+    # First sweep step keeps both hardware buckets too.
+    got0 = resolve_baseline_for_sweep(baseline, sweep_index=0)
+    assert set(got0) == {"H100", "A3"}
+    assert got0["H100"]["mean_ttft_ms"] == 96.4
+    assert got0["A3"]["mean_ttft_ms"] == 90.0
+
+
+def test_resolve_baseline_for_sweep_rejects_flat_baseline():
+    from tests.dfx.conftest import resolve_baseline_for_sweep
+
+    with pytest.raises(ValueError, match=r"hardware-nested.*pyproject\.toml"):
+        resolve_baseline_for_sweep(
+            {"throughput_qps": [0.4, 0.6], "latency_mean": [1.0, 2.0]},
+            sweep_index=1,
+        )
+
+
+def test_resolve_baseline_for_sweep_rejects_unknown_hardware_label():
+    from tests.dfx.conftest import resolve_baseline_for_sweep
+
+    with pytest.raises(ValueError, match=r"Unknown hardware label\(s\): \['A100'\].*pyproject\.toml"):
+        resolve_baseline_for_sweep(
+            {"A100": {"throughput_qps": 1.0}},
+            sweep_index=0,
+        )
+
+
+def test_resolve_baseline_for_sweep_supports_list_and_scalar_under_hardware():
+    from tests.dfx.conftest import resolve_baseline_for_sweep
+
+    # Sweep-aligned lists under each hardware bucket (canonical form).
+    listed = {
+        "H100": {"throughput_qps": [0.4, 0.6, 0.8], "latency_mean": [1.0, 2.0, 3.0]},
+        "A3": {"throughput_qps": [0.5, 0.7, 0.9], "latency_mean": [0.9, 1.8, 2.7]},
+    }
+    assert resolve_baseline_for_sweep(listed, sweep_index=1) == {
+        "H100": {"throughput_qps": 0.6, "latency_mean": 2.0},
+        "A3": {"throughput_qps": 0.7, "latency_mean": 1.8},
+    }
+
+    # Scalars under hardware stay as-is (single-concurrency cases).
+    scalar = {"H100": {"throughput_qps": 0.5}}
+    assert resolve_baseline_for_sweep(scalar, sweep_index=0) == {"H100": {"throughput_qps": 0.5}}
+    # Custom metric names are preserved.
+    custom = {"H100": {"custom_stage_ms": [10.0, 20.0]}}
+    assert resolve_baseline_for_sweep(custom, sweep_index=1) == {"H100": {"custom_stage_ms": 20.0}}
+    assert resolve_baseline_for_sweep(None) == {}
+    assert resolve_baseline_for_sweep({}) == {}
+
+
+def test_resolve_baseline_value_errors():
+    from tests.dfx.conftest import resolve_baseline_value
+
+    with pytest.raises(ValueError, match="sweep_index"):
+        resolve_baseline_value([1.0, 2.0], sweep_index=None)
+    with pytest.raises(IndexError):
+        resolve_baseline_value([1.0], sweep_index=1)
+    with pytest.raises(TypeError, match="not supported"):
+        resolve_baseline_value({"1": 0.4}, sweep_index=0)
+
+
+def test_diffusion_build_run_params_resolves_baseline_per_sweep(tmp_path, monkeypatch):
+    """``_build_run_params`` / ``_iter_sweep_runs`` narrow list baselines per concurrency."""
+    import importlib
+    import sys
+
+    cfg = tmp_path / "mini_diffusion_perf.json"
+    cfg.write_text(
+        json.dumps(
+            [
+                {
+                    "test_name": "test_mini",
+                    "server_type": "vllm-omni",
+                    "mark": [
+                        {"hardware_marks": {"res": {"cuda": "H100"}, "num_cards": 1}},
+                        "diffusion",
+                        "full_model",
+                    ],
+                    "server_params": {"model": "m/mini"},
+                    "benchmark_params": [{"name": "p0", "num-prompts": 1, "max-concurrency": 1}],
+                }
+            ]
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(sys, "argv", ["pytest", "--test-config-file", str(cfg)])
+    sys.modules.pop("tests.dfx.perf.scripts.run_diffusion_benchmark", None)
+    from tests.dfx.perf.scripts import run_diffusion_benchmark as rdb
+
+    importlib.reload(rdb)
+
+    params = {
+        "name": "c_sweep",
+        "dataset": "random",
+        "task": "t2i",
+        "num-prompts": [8, 16, 32],
+        "max-concurrency": [1, 8, 32],
+        "baseline": {
+            "H100": {"throughput_qps": [0.1, 0.2, 0.3], "latency_mean": [10.0, 20.0, 30.0]},
+            "A3": {"throughput_qps": [0.11, 0.22, 0.33], "latency_mean": [9.0, 19.0, 29.0]},
+        },
+    }
+    run32 = rdb._build_run_params(
+        params,
+        num_prompts=32,
+        max_concurrency=32,
+        request_rate="inf",
+        sweep_index=2,
+    )
+    assert run32["max-concurrency"] == 32
+    assert run32["baseline"] == {
+        "H100": {"throughput_qps": 0.3, "latency_mean": 30.0},
+        "A3": {"throughput_qps": 0.33, "latency_mean": 29.0},
+    }
+
+    sweeps = rdb._iter_sweep_runs(params)
+    assert len(sweeps) == 3
+    assert sweeps[2]["params"]["max-concurrency"] == 32
+    assert sweeps[2]["params"]["baseline"]["H100"]["throughput_qps"] == 0.3
+    assert "A3" in sweeps[2]["params"]["baseline"]
+    assert not isinstance(sweeps[2]["params"]["baseline"]["H100"]["throughput_qps"], list)
diff --git a/tests/dfx/perf/tests/test_tts.json b/tests/dfx/perf/tests/test_tts.json
index 1ba273a2c..f398e3271 100644
--- a/tests/dfx/perf/tests/test_tts.json
+++ b/tests/dfx/perf/tests/test_tts.json
@@ -1,6 +1,19 @@
 [
   {
     "test_name": "test_qwen3_tts_base",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "tts"
+    ],
     "server_params": {
       "model": "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
       "stage_overrides": {
@@ -26,12 +39,14 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            139.9434
-          ],
-          "median_audio_rtf": [
-            0.1683
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              141.2791
+            ],
+            "median_audio_rtf": [
+              0.1591
+            ]
+          }
         }
       },
       {
@@ -54,21 +69,23 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            227.5653,
-            647.1272,
-            4777.2714
-          ],
-          "median_audio_rtf": [
-            0.3313,
-            0.3642,
-            1.2282
-          ],
-          "audio_throughput": [
-            23.501,
-            40.634,
-            43.0758
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              226.747,
+              647.1272,
+              4777.2714
+            ],
+            "median_audio_rtf": [
+              0.3313,
+              0.3642,
+              1.2282
+            ],
+            "audio_throughput": [
+              24.2296,
+              40.3552,
+              43.2572
+            ]
+          }
         }
       },
       {
@@ -89,15 +106,29 @@
         "seed_tts_wer_eval": true,
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "mean_audio_rtf": [
-            0.45
-          ]
+          "H100": {
+            "mean_audio_rtf": [
+              0.45
+            ]
+          }
         }
       }
     ]
   },
   {
     "test_name": "test_qwen3_tts_customvoice",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "tts"
+    ],
     "server_params": {
       "model": "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
       "stage_overrides": {
@@ -128,12 +159,14 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            49.7908
-          ],
-          "median_audio_rtf": [
-            0.1425
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              46.8434
+            ],
+            "median_audio_rtf": [
+              0.1367
+            ]
+          }
         }
       },
       {
@@ -161,21 +194,23 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            75.3341,
-            713.7727,
-            5941.7179
-          ],
-          "median_audio_rtf": [
-            0.1859,
-            0.3148,
-            1.1662
-          ],
-          "audio_throughput": [
-            36.465,
-            49.6268,
-            48.3091
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              75.3341,
+              713.7727,
+              5941.7179
+            ],
+            "median_audio_rtf": [
+              0.1859,
+              0.3148,
+              1.1662
+            ],
+            "audio_throughput": [
+              38.3858,
+              55.3523,
+              68.7032
+            ]
+          }
         }
       },
       {
@@ -201,9 +236,11 @@
         "seed_tts_wer_eval": true,
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "mean_audio_rtf": [
-            0.35
-          ]
+          "H100": {
+            "mean_audio_rtf": [
+              0.35
+            ]
+          }
         }
       },
       {
@@ -227,15 +264,17 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            56.6977
-          ],
-          "median_audio_rtf": [
-            0.1555
-          ],
-          "audio_throughput": [
-            11.5292
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              56.746
+            ],
+            "median_audio_rtf": [
+              0.1571
+            ],
+            "audio_throughput": [
+              11.1226
+            ]
+          }
         }
       },
       {
@@ -258,12 +297,14 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            52.0447
-          ],
-          "median_audio_rtf": [
-            0.1452
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              46.3479
+            ],
+            "median_audio_rtf": [
+              0.1352
+            ]
+          }
         }
       },
       {
@@ -290,21 +331,23 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            75.5967,
-            587.5877,
-            4960.3726
-          ],
-          "median_audio_rtf": [
-            0.1871,
-            0.3143,
-            1.1703
-          ],
-          "audio_throughput": [
-            40.2198,
-            48.9046,
-            48.0505
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              75.5967,
+              587.5877,
+              4960.3726
+            ],
+            "median_audio_rtf": [
+              0.1871,
+              0.3143,
+              1.1703
+            ],
+            "audio_throughput": [
+              38.9378,
+              55.1846,
+              71.5708
+            ]
+          }
         }
       },
       {
@@ -327,21 +370,35 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            56.3961
-          ],
-          "median_audio_rtf": [
-            0.1542
-          ],
-          "audio_throughput": [
-            9.6672
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              55.5029
+            ],
+            "median_audio_rtf": [
+              0.1508
+            ],
+            "audio_throughput": [
+              9.4885
+            ]
+          }
         }
       }
     ]
   },
   {
     "test_name": "test_voxtral_tts",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "tts"
+    ],
     "server_params": {
       "model": "mistralai/Voxtral-4B-TTS-2603"
     },
@@ -365,12 +422,14 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            150
-          ],
-          "median_audio_rtf": [
-            0.15
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              82.1886
+            ],
+            "median_audio_rtf": [
+              0.1241
+            ]
+          }
         }
       },
       {
@@ -392,15 +451,17 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            1500
-          ],
-          "median_audio_rtf": [
-            0.3
-          ],
-          "audio_throughput": [
-            30.0
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              160.9168
+            ],
+            "median_audio_rtf": [
+              0.1907
+            ],
+            "audio_throughput": [
+              39.2332
+            ]
+          }
         }
       },
       {
@@ -422,15 +483,17 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            3000
-          ],
-          "median_audio_rtf": [
-            0.25
-          ],
-          "audio_throughput": [
-            4.0
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              100.1265
+            ],
+            "median_audio_rtf": [
+              0.1437
+            ],
+            "audio_throughput": [
+              11.7605
+            ]
+          }
         }
       }
     ]
diff --git a/tests/dfx/perf/tests/test_voxcpm2.json b/tests/dfx/perf/tests/test_voxcpm2.json
index 5c99f2596..e5163e5bb 100644
--- a/tests/dfx/perf/tests/test_voxcpm2.json
+++ b/tests/dfx/perf/tests/test_voxcpm2.json
@@ -1,6 +1,18 @@
 [
   {
     "test_name": "test_voxcpm2",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "tts"
+    ],
     "server_params": {
       "model": "openbmb/VoxCPM2",
       "trust_remote_code": true,
@@ -25,12 +37,14 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            130.2115
-          ],
-          "median_audio_rtf": [
-            0.0488
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              137.645
+            ],
+            "median_audio_rtf": [
+              0.0497
+            ]
+          }
         }
       },
       {
@@ -49,15 +63,17 @@
         "seed_tts_locale": "en",
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            475.3357
-          ],
-          "median_audio_rtf": [
-            0.1671
-          ],
-          "audio_throughput": [
-            22.8717
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              475.3357
+            ],
+            "median_audio_rtf": [
+              0.1243
+            ],
+            "audio_throughput": [
+              36.6358
+            ]
+          }
         }
       },
       {
@@ -78,9 +94,11 @@
         "seed_tts_wer_eval": true,
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "mean_audio_rtf": [
-            0.45
-          ]
+          "H100": {
+            "mean_audio_rtf": [
+              0.45
+            ]
+          }
         }
       },
       {
@@ -102,12 +120,14 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            75.7427
-          ],
-          "median_audio_rtf": [
-            0.0419
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              79.6927
+            ],
+            "median_audio_rtf": [
+              0.0423
+            ]
+          }
         }
       },
       {
@@ -129,15 +149,17 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            351.5855
-          ],
-          "median_audio_rtf": [
-            0.1207
-          ],
-          "audio_throughput": [
-            73.7632
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              262.6212
+            ],
+            "median_audio_rtf": [
+              0.0753
+            ],
+            "audio_throughput": [
+              103.5843
+            ]
+          }
         }
       },
       {
@@ -159,15 +181,17 @@
         },
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "median_audio_ttfp_ms": [
-            80.1095
-          ],
-          "median_audio_rtf": [
-            0.0485
-          ],
-          "audio_throughput": [
-            18.3715
-          ]
+          "H100": {
+            "median_audio_ttfp_ms": [
+              80.1095
+            ],
+            "median_audio_rtf": [
+              0.0479
+            ],
+            "audio_throughput": [
+              17.2918
+            ]
+          }
         }
       },
       {
@@ -191,9 +215,11 @@
         "seed_tts_wer_eval": true,
         "percentile-metrics": "ttft,e2el,audio_rtf,audio_ttfp,audio_duration",
         "baseline": {
-          "mean_audio_rtf": [
-            0.35
-          ]
+          "H100": {
+            "mean_audio_rtf": [
+              0.35
+            ]
+          }
         }
       }
     ]
diff --git a/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json b/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
index 07873a64b..5cea0c013 100644
--- a/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
@@ -1,107 +1,138 @@
 [
-    {
-        "test_name": "test_wan22_i2v_single_device",
-        "description": "Single-device baseline",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Wan-AI/Wan2.2-I2V-A14B-Diffusers",
-            "serve_args": {
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "832x480_frames81_steps4",
-                "dataset": "random",
-                "task": "i2v",
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 1,
-                "seed": 42,
-                "enable-negative-prompt": true,
-                "random-request-config": [
-                    {
-                        "width": 832,
-                        "height": 480,
-                        "num_inference_steps": 4,
-                        "num_frames": 81,
-                        "fps": 16,
-                        "weight": 1
-                    }
-                ],
-                "baseline": {
-                    "throughput_qps": 0.0465,
-                    "latency_mean": 21.4354,
-                    "peak_memory_mb_mean": 72557.58
-                }
-            }
-        ]
+  {
+    "test_name": "test_wan22_i2v_single_device",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device baseline",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true
+      }
     },
-    {
-        "test_name": "test_wan22_i2v_usp2_vae_patch2_hsdp_slicing",
-        "description": "USP=2 + VAE patch parallel=2 + HSDP + VAE slicing",
-        "server_type": "vllm-omni",
-        "server_params": {
-            "model": "Wan-AI/Wan2.2-I2V-A14B-Diffusers",
-            "serve_args": {
-                "usp": 2,
-                "vae-patch-parallel-size": 2,
-                "use-hsdp": true,
-                "vae-use-slicing": true,
-                "enable-diffusion-pipeline-profiler": true
-            }
-        },
-        "benchmark_params": [
-            {
-                "name": "832x480_frames81_steps4",
-                "dataset": "random",
-                "task": "i2v",
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 1,
-                "seed": 42,
-                "enable-negative-prompt": true,
-                "random-request-config": [
-                    {
-                        "width": 832,
-                        "height": 480,
-                        "num_inference_steps": 4,
-                        "num_frames": 81,
-                        "fps": 16,
-                        "weight": 1
-                    }
-                ],
-                "baseline": {
-                    "throughput_qps": 0.0642,
-                    "latency_mean": 15.5589,
-                    "peak_memory_mb_mean": 45742.88
-                }
-            },
-            {
-                "name": "1280x720_frames121_steps4",
-                "dataset": "random",
-                "task": "i2v",
-                "num-prompts": 10,
-                "max-concurrency": 1,
-                "num-input-images": 1,
-                "seed": 42,
-                "enable-negative-prompt": true,
-                "random-request-config": [
-                    {
-                        "width": 1280,
-                        "height": 720,
-                        "num_inference_steps": 4,
-                        "num_frames": 121,
-                        "fps": 16,
-                        "weight": 1
-                    }
-                ],
-                "baseline": {
-                    "throughput_qps": 0.0128,
-                    "latency_mean": 77.8565,
-                    "peak_memory_mb_mean": 53947.84
-                }
-            }
-        ]
-    }
+    "benchmark_params": [
+      {
+        "name": "832x480_frames81_steps4",
+        "dataset": "random",
+        "task": "i2v",
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 1,
+        "seed": 42,
+        "enable-negative-prompt": true,
+        "random-request-config": [
+          {
+            "width": 832,
+            "height": 480,
+            "num_inference_steps": 4,
+            "num_frames": 81,
+            "fps": 16,
+            "weight": 1
+          }
+        ],
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0434,
+            "latency_mean": 23.0654,
+            "peak_memory_mb_mean": 76360.0
+          }
+        }
+      }
+    ]
+  },
+  {
+    "test_name": "test_wan22_i2v_usp2_vae_patch2_hsdp_slicing",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 2
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "USP=2 + VAE patch parallel=2 + HSDP + VAE slicing",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+      "serve_args": {
+        "usp": 2,
+        "vae-patch-parallel-size": 2,
+        "use-hsdp": true,
+        "vae-use-slicing": true,
+        "enable-diffusion-pipeline-profiler": true
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "832x480_frames81_steps4",
+        "dataset": "random",
+        "task": "i2v",
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 1,
+        "seed": 42,
+        "enable-negative-prompt": true,
+        "random-request-config": [
+          {
+            "width": 832,
+            "height": 480,
+            "num_inference_steps": 4,
+            "num_frames": 81,
+            "fps": 16,
+            "weight": 1
+          }
+        ],
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0606,
+            "latency_mean": 16.4928,
+            "peak_memory_mb_mean": 47164.8
+          }
+        }
+      },
+      {
+        "name": "1280x720_frames121_steps4",
+        "dataset": "random",
+        "task": "i2v",
+        "num-prompts": 10,
+        "max-concurrency": 1,
+        "num-input-images": 1,
+        "seed": 42,
+        "enable-negative-prompt": true,
+        "random-request-config": [
+          {
+            "width": 1280,
+            "height": 720,
+            "num_inference_steps": 4,
+            "num_frames": 121,
+            "fps": 16,
+            "weight": 1
+          }
+        ],
+        "baseline": {
+          "H100": {
+            "throughput_qps": 0.0124,
+            "latency_mean": 80.7784,
+            "peak_memory_mb_mean": 55374.3429
+          }
+        }
+      }
+    ]
+  }
 ]
diff --git a/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py b/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
index 0de862ae0..61cd30ec8 100644
--- a/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
+++ b/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""HTTP + WebSocket validation for Qwen3-TTS Base and Higgs Audio V3 ``/v1/audio/speech`` (and related routes)."""
+"""HTTP + WebSocket validation for Qwen3-TTS Base, Higgs Audio V3 and Audex TTA ``/v1/audio/speech`` (and related routes)."""
 
 from __future__ import annotations
 
@@ -70,6 +70,19 @@ _HIGGS_AUDIO_V3_SPEECH = [
     ),
 ]
 
+_AUDEX_TTA_CAPTION = "Heavy rain falling on a tin roof."
+_AUDEX_TTA_SPEECH = [
+    pytest.param(
+        OmniServerParams(
+            model="nvidia/Nemotron-Labs-Audex-2B",
+            stage_config_path=get_deploy_config_path("audex_tta.yaml"),
+            server_args=_SPEECH_SERVER_ARGS,
+        ),
+        id="audex_tta",
+        marks=_L4_SPEECH_HW,
+    ),
+]
+
 
 def _apply_batch_overrides(body: dict[str, object], *, loc: str, overrides: dict[str, object]) -> None:
     if loc == "batch":
@@ -325,6 +338,37 @@ def test_speech_higgs_invalid_field_values(
     )
 
 
+# Audex TTA (``audex_tta`` deployment): the serving layer builds the caption
+# prompt and injects the RVQ phase contract + default guidance server-side, so
+# guidance knobs and speech-only fields must be rejected before generation.
+@pytest.mark.parametrize(
+    "overrides, err_message",
+    [
+        pytest.param({"extra_params": {"cfg_scale": 99}}, "cfg_scale", id="cfg_scale_out_of_range"),
+        pytest.param({"extra_params": {"cfg_scale": "big"}}, "cfg_scale", id="cfg_scale_wrong_type"),
+        pytest.param({"extra_params": {"tta_rvq": {}}}, "tta_rvq", id="tta_rvq_not_overridable"),
+        pytest.param({"input": "   "}, "caption", id="caption_whitespace_only"),
+        pytest.param({"voice": "alloy"}, "voice", id="voice_not_supported"),
+        pytest.param(
+            {"ref_audio": "https://example.com/ref.wav"},
+            "reference audio",
+            id="ref_audio_not_supported",
+        ),
+    ],
+)
+@pytest.mark.parametrize("omni_server", _AUDEX_TTA_SPEECH, indirect=True)
+def test_speech_audex_tta_invalid_field_values(
+    omni_server: OmniServer,
+    openai_client: OpenAIClientHandler,
+    overrides: dict[str, object],
+    err_message: str | tuple[str, ...],
+) -> None:
+    body = {"model": omni_server.model, "input": _AUDEX_TTA_CAPTION, **overrides}
+    openai_client.send_audio_speech_http_request(
+        {"json": body, "timeout": 120, "err_code": 400, "err_message": err_message}
+    )
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # POST /v1/audio/speech/batch (JSON)
 # ─────────────────────────────────────────────────────────────────────────────
diff --git a/tests/dfx/reliability/invalid_param_test/test_invalid_minicpmo_4_5_omni.py b/tests/dfx/reliability/invalid_param_test/test_invalid_minicpmo_4_5_omni.py
new file mode 100644
index 000000000..9c6880d68
--- /dev/null
+++ b/tests/dfx/reliability/invalid_param_test/test_invalid_minicpmo_4_5_omni.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Invalid audio format rejection on MiniCPM-o 4.5: ``POST /v1/chat/completions``."""
+
+import os
+
+os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.slow, pytest.mark.omni, pytest.mark.full_model]
+
+_MINICPMO_DEPLOY = get_deploy_config_path("minicpmo_4_5.yaml")
+
+_MINICPMO_SERVER = [
+    pytest.param(
+        OmniServerParams(
+            model="openbmb/MiniCPM-o-4_5",
+            stage_config_path=_MINICPMO_DEPLOY,
+            use_stage_cli=False,
+            server_args=[
+                "--trust-remote-code",
+            ],
+        ),
+        id="minicpmo_4_5",
+    )
+]
+
+
+def _system_prompt() -> dict[str, object]:
+    return {
+        "role": "system",
+        "content": [
+            {
+                "type": "text",
+                "text": (
+                    "You are MiniCPM-o 4.5, a virtual human capable of perceiving "
+                    "auditory and visual inputs, as well as generating text and speech."
+                ),
+            }
+        ],
+    }
+
+
+def _prompt() -> str:
+    return "What is the capital of China? Answer in 20 words."
+
+
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", _MINICPMO_SERVER, indirect=True)
+def test_invalid_audio_format_rejected(omni_server: OmniServerParams, openai_client: OpenAIClientHandler) -> None:
+    """
+    Test that invalid audio format is properly rejected.
+    Deploy Setting: default 2GPU
+    Input Modal: text + invalid audio format
+    Output Modal: error
+    """
+    fake_base64 = "AAAA"  # not a real audio file
+
+    responses = openai_client.send_chat_completions_http_request(
+        {
+            "json": {
+                "model": omni_server.model,
+                "messages": dummy_messages_from_mix_data(
+                    system_prompt=_system_prompt(),
+                    audio_data_url=f"data:audio/invalid;base64,{fake_base64}",
+                    content_text=_prompt(),
+                ),
+                "stream": True,
+            },
+        },
+        err_code=400,
+        err_message="Invalid or unsupported audio file",
+    )
+    assert not responses[0].success
diff --git a/tests/dfx/reliability/invalid_param_test/test_invalid_server_control.py b/tests/dfx/reliability/invalid_param_test/test_invalid_server_control.py
index 0a8240c4b..ad3f659f1 100644
--- a/tests/dfx/reliability/invalid_param_test/test_invalid_server_control.py
+++ b/tests/dfx/reliability/invalid_param_test/test_invalid_server_control.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Omni sleep/wakeup JSON validation (live ``Qwen/Qwen-Image`` process)."""
+"""Omni sleep/wakeup JSON validation and level-2 wake contract (live ``Qwen/Qwen-Image``)."""
 
 from __future__ import annotations
 
@@ -15,9 +15,17 @@ pytestmark = [pytest.mark.slow, pytest.mark.diffusion, pytest.mark.omni]
 
 _SKIP_ISSUE_3649 = pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/3649")
 
+# One module-scoped server for this file. ``--enable-sleep-mode`` is required by the
+# level-2 wake contract test; invalid-JSON cases only hit request validation and are
+# unaffected. Do not mix ``omni_server`` (module) with ``omni_server_function`` here:
+# ``iter_omni_server`` holds ``omni_fixture_lock`` across the module yield, so a
+# function-scoped second server would deadlock / contend for the GPU.
 _QWEN_IMAGE = [
     pytest.param(
-        OmniServerParams(model="Qwen/Qwen-Image"),
+        OmniServerParams(
+            model="Qwen/Qwen-Image",
+            server_args=["--enable-sleep-mode"],
+        ),
         id="qwen_image",
         marks=hardware_marks(res={"cuda": "H100"}),
     ),
@@ -93,3 +101,37 @@ def test_omni_sleep_wakeup_invalid_requests(
         openai_client.send_omni_sleep_http_request(cfg)
     else:
         openai_client.send_omni_wakeup_http_request(cfg)
+
+
+# Keep this after the invalid-JSON cases: sleep(level=2) discards weights and the
+# shared module server is not usable afterward; module teardown then stops it.
+@pytest.mark.parametrize("omni_server", _QWEN_IMAGE, indirect=True)
+def test_wakeup_after_level2_sleep_fails(
+    omni_server: OmniServer,
+    openai_client: OpenAIClientHandler,
+) -> None:
+    """Regression for #4473 Repro A via HTTP: wake after sleep(level=2) → 501.
+
+    Moved from ``tests/entrypoints/test_omni_sleep_mode.py`` (BAGEL cold start).
+    Live serve surfaces ``NotImplementedError`` as OpenAI-style JSON with code 501.
+    """
+    assert omni_server is not None
+    sleep_resps = openai_client.send_omni_sleep_http_request(
+        {
+            "json": {"stage_ids": [0], "level": 2},
+            "timeout": 180,
+        }
+    )
+    sleep_resp = sleep_resps[0]
+    assert sleep_resp.status_code == 200, sleep_resp
+    assert sleep_resp.json_body is not None
+    assert sleep_resp.json_body.get("status") == "SUCCESS", sleep_resp.json_body
+
+    openai_client.send_omni_wakeup_http_request(
+        {
+            "json": {"stage_ids": [0]},
+            "timeout": 120,
+            "err_code": 501,
+            "err_message": ("sleep(level=2)", "not yet implemented"),
+        }
+    )
diff --git a/tests/dfx/reliability/test_reliability_qwen3_omni.py b/tests/dfx/reliability/test_reliability_qwen3_omni.py
index 28e8dedf7..428323638 100644
--- a/tests/dfx/reliability/test_reliability_qwen3_omni.py
+++ b/tests/dfx/reliability/test_reliability_qwen3_omni.py
@@ -241,12 +241,12 @@ def _fault_keywords_match_response(*, status: int, body: bytes) -> bool:
     return any(key in text for key in body_fault_hints)
 
 
-def _stage_config_path_from_omni_server(omni_server: _HasServeArgs) -> str | None:
+def _deploy_config_path_from_omni_server(omni_server: _HasServeArgs) -> str | None:
     args: list[str] = omni_server.serve_args
     for i, arg in enumerate(args):
-        if arg == "--stage-configs-path" and i + 1 < len(args):
+        if arg == "--deploy-config" and i + 1 < len(args):
             return args[i + 1]
-        if arg.startswith("--stage-configs-path="):
+        if arg.startswith("--deploy-config="):
             return arg.split("=", 1)[1]
     return None
 
@@ -331,7 +331,7 @@ def test_reliability_fault_gpu_oom_error_contract_consistent_chat_speech(
     """
     device_spec = resolve_oom_device_spec(
         OOM_INJECTION_CONFIG,
-        _stage_config_path_from_omni_server(omni_server_function),
+        _deploy_config_path_from_omni_server(omni_server_function),
     )
     handle = inject_gpu_oom(
         device=device_spec,
@@ -394,7 +394,7 @@ def test_reliability_fault_gpu_oom_error_contract_consistent_chat_speech(
 def test_reliability_fault_gpu_oom_chat_large_payload_failure(omni_server_function, openai_client_function) -> None:
     device_spec = resolve_oom_device_spec(
         OOM_INJECTION_CONFIG,
-        _stage_config_path_from_omni_server(omni_server_function),
+        _deploy_config_path_from_omni_server(omni_server_function),
     )
     handle = inject_gpu_oom(
         device=device_spec,
@@ -437,7 +437,7 @@ def test_reliability_fault_gpu_oom_chat_large_payload_failure(omni_server_functi
 def test_reliability_fault_gpu_oom_concurrent_pressure_failure(omni_server_function, openai_client_function) -> None:
     device_spec = resolve_oom_device_spec(
         OOM_INJECTION_CONFIG,
-        _stage_config_path_from_omni_server(omni_server_function),
+        _deploy_config_path_from_omni_server(omni_server_function),
     )
     handle = inject_gpu_oom(
         device=device_spec,
@@ -791,7 +791,7 @@ def test_reliability_fault_gpu_oom_state_converges_after_fault_removed(
     """
     device_spec = resolve_oom_device_spec(
         OOM_RECOVER_INJECTION_CONFIG,
-        _stage_config_path_from_omni_server(omni_server_function),
+        _deploy_config_path_from_omni_server(omni_server_function),
     )
     handle = inject_gpu_oom(
         device=device_spec,
diff --git a/tests/dfx/reliability/test_reliability_voxcpm2.py b/tests/dfx/reliability/test_reliability_voxcpm2.py
index 014bb4e89..632c51081 100644
--- a/tests/dfx/reliability/test_reliability_voxcpm2.py
+++ b/tests/dfx/reliability/test_reliability_voxcpm2.py
@@ -43,6 +43,9 @@ RELIABILITY_SCENARIOS: list[dict[str, Any]] = [
         "server_params": {
             "model": "openbmb/VoxCPM2",
             "stage_config_name": "voxcpm2.yaml",
+            # VoxCPM2 uses a custom HF tokenizer; CLI default trust_remote_code=False
+            # would otherwise override deploy YAML settings during server startup.
+            "server_args": ["--trust-remote-code", "--disable-log-stats"],
         },
     },
 ]
diff --git a/tests/ar_diffusion/__init__.py b/tests/diffusion/ar_diffusion/__init__.py
similarity index 100%
rename from tests/ar_diffusion/__init__.py
rename to tests/diffusion/ar_diffusion/__init__.py
diff --git a/tests/diffusion/ar_diffusion/test_capability_runner.py b/tests/diffusion/ar_diffusion/test_capability_runner.py
new file mode 100644
index 000000000..7b94fe80f
--- /dev/null
+++ b/tests/diffusion/ar_diffusion/test_capability_runner.py
@@ -0,0 +1,317 @@
+# SPDX-License-Identifier: Apache-2.0
+"""CPU contracts for capability-driven AR-Diffusion sessions."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from contextlib import contextmanager
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
+from vllm_omni.experimental.ar_diffusion.capability import (
+    ARDiffusionCrossAttentionKVSpec,
+    ARDiffusionKVBranchSpec,
+    ARDiffusionKVCacheSpec,
+)
+from vllm_omni.experimental.ar_diffusion.kv_cache import ARDiffusionKVConfig
+from vllm_omni.experimental.ar_diffusion.runner import ARDiffusionModelRunner
+
+BLOCK = 16
+POS = "positive"
+NEG = "negative"
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def lingbot_like_spec(*, capacity: int = 2) -> ARDiffusionKVCacheSpec:
+    """Single-kv_branch causal DMD: 3 latent frames/block + sink/window + text KV."""
+    return ARDiffusionKVCacheSpec(
+        num_layers=2,
+        num_kv_heads=4,  # already TP-local
+        head_size=64,
+        tokens_per_frame=BLOCK,
+        frames_per_block=3,
+        window_frames=5,
+        sink_frames=1,
+        kv_branches=(ARDiffusionKVBranchSpec("main", 0),),
+        session_capacity=capacity,
+        cross_attention=(ARDiffusionCrossAttentionKVSpec("text", 8),),
+    )
+
+
+def dreamzero_like_spec(*, capacity: int = 2) -> ARDiffusionKVCacheSpec:
+    return ARDiffusionKVCacheSpec(
+        num_layers=2,
+        num_kv_heads=4,
+        head_size=64,
+        tokens_per_frame=BLOCK,
+        frames_per_block=4,
+        window_frames=6,
+        kv_branches=(ARDiffusionKVBranchSpec(POS, 0), ARDiffusionKVBranchSpec(NEG, 1)),
+        session_capacity=capacity,
+        cross_attention=(ARDiffusionCrossAttentionKVSpec("text", 8),),
+    )
+
+
+class CapablePipeline:
+    def __init__(self, spec: ARDiffusionKVCacheSpec) -> None:
+        self.spec = spec
+        self.bound_state = None
+        self.binds: list[str] = []
+        self.resets: list[str] = []
+        self.closes: list[str] = []
+
+    def ar_diffusion_kv_cache_spec(self) -> ARDiffusionKVCacheSpec:
+        return self.spec
+
+    @contextmanager
+    def bind_ar_diffusion_state(self, session_id: str, state):
+        assert self.bound_state is None
+        self.bound_state = state
+        self.binds.append(session_id)
+        try:
+            yield
+        finally:
+            self.bound_state = None
+
+    def reset_ar_diffusion_session(self, session_id: str) -> None:
+        self.resets.append(session_id)
+
+    def close_ar_diffusion_session(self, session_id: str) -> None:
+        self.closes.append(session_id)
+
+
+class WarmupPipeline(CapablePipeline):
+    def __init__(self, spec: ARDiffusionKVCacheSpec, requests: list[object]) -> None:
+        super().__init__(spec)
+        self.requests = requests
+
+    def ar_diffusion_warmup_requests(self, session_id: str):
+        assert session_id == ARDiffusionModelRunner._WARMUP_SID
+        return iter(self.requests)
+
+
+class BatchCapablePipeline(CapablePipeline):
+    supports_request_batch = True
+
+
+def make_runner(
+    pipeline: object,
+    *,
+    available_bytes: int = 1 << 28,
+    step_execution: bool = False,
+) -> ARDiffusionModelRunner:
+    runner = object.__new__(ARDiffusionModelRunner)
+    runner.od_config = SimpleNamespace(
+        max_num_seqs=1,
+        dtype=torch.float32,
+        enforce_eager=True,
+        step_execution=step_execution,
+    )
+    runner.device = torch.device("cpu")
+    runner.pipeline = pipeline
+    runner.ar_diffusion_kv_config = ARDiffusionKVConfig(enable=True)
+    runner.kv_cache = None
+    runner._ar_diffusion_capability = None
+    runner._ar_diffusion_kv_cache_spec = None
+    runner._sessions = OrderedDict()
+    runner._session_capacity = 0
+    runner._perf_e2e_times = []
+    runner._preallocate_kv_cache(available_bytes=available_bytes)
+    return runner
+
+
+def commit_one_frame(runner: ARDiffusionModelRunner, session_id: str, kv_branch: str):
+    state = runner._get_or_create_session(session_id)
+    ctx = state.get_kv_caches(kv_branch, seq_len=BLOCK, commit_current=True)[0].forward_ctx
+    ctx.ensure_video_slots(torch.device("cpu"))
+    state.commit_paged_context(kv_branch)
+    return state
+
+
+def test_ar_runner_rejects_pipeline_without_capability():
+    runner = object.__new__(ARDiffusionModelRunner)
+    runner.od_config = SimpleNamespace(max_num_seqs=1)
+    runner.pipeline = object()
+    with pytest.raises(TypeError, match="SupportsARDiffusionPipeline"):
+        runner._preallocate_kv_cache(available_bytes=1 << 20)
+
+
+def test_lingbot_like_single_branch_session_reuse_reset_and_close():
+    pipeline = CapablePipeline(lingbot_like_spec())
+    runner = make_runner(pipeline)
+    kv = runner.kv_cache
+    assert kv is not None
+    assert kv.num_local_kv_branches == 1
+    assert kv.frames_per_block == 3
+    assert kv.spec.window_chunks == 5
+    assert kv.spec.sink_chunks == 1
+    assert kv.cross_attention_lengths == {"text": 8}
+
+    first = commit_one_frame(runner, "s1", "main")
+    assert runner._get_or_create_session("s1") is first
+    k = torch.randn(1, 8, 4, 64)
+    v = torch.randn(1, 8, 4, 64)
+    first.populate_cross_attention("main", "text", [(k, v)] * first.num_layers)
+    assert first.get_cross_attention_kv("main", "text")[0]["k"].shape == k.shape
+
+    runner.reset_session("s1")
+    assert "s1" not in runner._sessions
+    assert "s1" not in kv._cross_sessions
+    assert pipeline.resets == ["s1"]
+    second = runner._get_or_create_session("s1")
+    assert second is not first
+
+    runner.close_session("s1")
+    assert "s1" not in runner._sessions
+    assert pipeline.closes == ["s1"]
+
+
+def test_lingbot_like_sink_survives_sliding_window_eviction():
+    runner = make_runner(CapablePipeline(lingbot_like_spec()))
+    kv = runner.kv_cache
+    assert kv is not None
+
+    for _ in range(8):
+        state = commit_one_frame(runner, "s1", "main")
+
+    table = kv.block_table(state.adapter("main"))
+    assert table[0] != kv.null_block_id
+    assert table[1] == kv.null_block_id
+
+    ctx = state.get_kv_caches("main", seq_len=BLOCK, commit_current=False)[0].forward_ctx
+    visible, _ = ctx.video_block_table(torch.device("cpu"))
+    assert visible[0] == table[0]
+    assert len(visible) == 6  # sink + recent window, including current scratch
+
+
+def test_dreamzero_like_two_branches_are_independent():
+    runner = make_runner(CapablePipeline(dreamzero_like_spec()))
+    kv = runner.kv_cache
+    assert kv is not None and kv.num_local_kv_branches == 2
+    state = commit_one_frame(runner, "s1", POS)
+    assert len(kv.window_block_ids(state.adapter(POS))) == 1
+    assert kv.window_block_ids(state.adapter(NEG)) == []
+
+
+def test_lru_eviction_releases_blocks_and_notifies_pipeline():
+    pipeline = CapablePipeline(lingbot_like_spec(capacity=8))
+    runner = make_runner(pipeline)
+    kv = runner.kv_cache
+    assert kv is not None
+    assert runner._session_capacity == 1
+    assert kv.session_capacity == 1
+    free_total = kv.manager.block_pool.get_num_free_blocks()
+    old = commit_one_frame(runner, "old", "main")
+    k = torch.randn(1, 8, 4, 64)
+    old.populate_cross_attention("main", "text", [(k, k)] * old.num_layers)
+    assert kv.manager.block_pool.get_num_free_blocks() < free_total
+
+    runner._get_or_create_session("new")
+
+    assert tuple(runner._sessions) == ("new",)
+    assert pipeline.closes == ["old"]
+    assert "old" not in kv._cross_sessions
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
+
+
+def test_forward_exception_releases_pending_allocation_and_model_state(monkeypatch):
+    pipeline = CapablePipeline(lingbot_like_spec())
+    runner = make_runner(pipeline)
+    kv = runner.kv_cache
+    assert kv is not None
+    free_total = kv.manager.block_pool.get_num_free_blocks()
+
+    def boom(self, req, kv_prefetch_job=None):
+        state = pipeline.bound_state
+        ctx = state.get_kv_caches("main", seq_len=BLOCK, commit_current=True)[0].forward_ctx
+        ctx.ensure_video_slots(torch.device("cpu"))
+        raise RuntimeError("layer exploded")
+
+    monkeypatch.setattr(DiffusionModelRunner, "execute_model", boom)
+    request = SimpleNamespace(sampling_params=SimpleNamespace(extra_args={"session_id": "broken"}))
+
+    with pytest.raises(RuntimeError, match="layer exploded"):
+        runner.execute_model(request)
+
+    assert pipeline.bound_state is None
+    assert pipeline.closes == ["broken"]
+    assert not runner._sessions
+    assert not kv._adapters
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
+
+
+def test_synchronize_exception_uses_forward_cleanup_path(monkeypatch):
+    pipeline = CapablePipeline(lingbot_like_spec())
+    runner = make_runner(pipeline)
+    kv = runner.kv_cache
+    assert kv is not None
+    free_total = kv.manager.block_pool.get_num_free_blocks()
+
+    def return_after_allocation(self, req, kv_prefetch_job=None):
+        state = pipeline.bound_state
+        ctx = state.get_kv_caches("main", seq_len=BLOCK, commit_current=True)[0].forward_ctx
+        ctx.ensure_video_slots(torch.device("cpu"))
+        return object()
+
+    def synchronize_boom(device):
+        raise RuntimeError("asynchronous kernel failed")
+
+    monkeypatch.setattr(DiffusionModelRunner, "execute_model", return_after_allocation)
+    monkeypatch.setattr(torch.accelerator, "synchronize", synchronize_boom)
+    runner.device = torch.device("cuda")
+    request = SimpleNamespace(sampling_params=SimpleNamespace(extra_args={"session_id": "broken"}))
+
+    with pytest.raises(RuntimeError, match="asynchronous kernel failed"):
+        runner.execute_model(request)
+
+    assert pipeline.bound_state is None
+    assert pipeline.closes == ["broken"]
+    assert not runner._sessions
+    assert not kv._adapters
+    assert not runner._perf_e2e_times
+    assert kv.manager.block_pool.get_num_free_blocks() == free_total
+
+
+def test_ar_runner_rejects_step_and_request_batch_modes():
+    with pytest.raises(ValueError, match="step_execution=True"):
+        make_runner(CapablePipeline(lingbot_like_spec()), step_execution=True)
+    with pytest.raises(ValueError, match="request-batch execution"):
+        make_runner(BatchCapablePipeline(lingbot_like_spec()))
+
+
+def test_ar_runner_defensively_rejects_inherited_batch_and_step_entrypoints():
+    runner = object.__new__(ARDiffusionModelRunner)
+    with pytest.raises(RuntimeError, match="request-batch execution"):
+        runner.execute_model_batch(None, None)
+    with pytest.raises(RuntimeError, match="step execution"):
+        runner.execute_stepwise(None)
+
+
+def test_model_specific_warmup_provider_is_consumed(monkeypatch):
+    requests = [object(), object()]
+    pipeline = WarmupPipeline(lingbot_like_spec(), requests)
+    runner = make_runner(pipeline)
+    seen: list[object] = []
+    monkeypatch.setattr(runner, "execute_model", seen.append)
+
+    runner._warmup_ar_rollout()
+
+    assert seen == requests
+    assert pipeline.closes == [runner._WARMUP_SID]
+
+
+def test_pipeline_without_warmup_provider_is_safely_skipped(monkeypatch):
+    pipeline = CapablePipeline(lingbot_like_spec())
+    runner = make_runner(pipeline)
+    execute = SimpleNamespace(called=False)
+
+    def fail_if_called(request):
+        execute.called = True
+
+    monkeypatch.setattr(runner, "execute_model", fail_if_called)
+    runner._warmup_ar_rollout()
+    assert execute.called is False
diff --git a/tests/ar_diffusion/test_engine_routing.py b/tests/diffusion/ar_diffusion/test_engine_routing.py
similarity index 95%
rename from tests/ar_diffusion/test_engine_routing.py
rename to tests/diffusion/ar_diffusion/test_engine_routing.py
index fb55e01e9..19c4cb529 100644
--- a/tests/ar_diffusion/test_engine_routing.py
+++ b/tests/diffusion/ar_diffusion/test_engine_routing.py
@@ -21,6 +21,8 @@ from vllm_omni.experimental.ar_diffusion.engine import (
     ARDiffusionEngine,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def _cfg(backend):
     return SimpleNamespace(engine_backend=backend)
@@ -136,8 +138,8 @@ def test_runner_rejects_multi_sequence_config():
         ARDiffusionModelRunner._preallocate_kv_cache(fake)
 
 
-def test_execute_model_accepts_kv_prefetch_jobs_kwarg():
-    """Regression: the worker passes ``kv_prefetch_jobs`` to every runner
+def test_execute_model_accepts_kv_prefetch_job_kwarg():
+    """Regression: the worker passes ``kv_prefetch_job`` to every runner
     (added with the KV prefetch path, #4448); the AR-Diffusion override must
     accept and forward it or DreamZero crashes on the warm-up dummy run."""
     import inspect
@@ -147,4 +149,4 @@ def test_execute_model_accepts_kv_prefetch_jobs_kwarg():
 
     for cls in (DiffusionModelRunner, ARDiffusionModelRunner):
         params = inspect.signature(cls.execute_model).parameters
-        assert "kv_prefetch_jobs" in params, cls
+        assert "kv_prefetch_job" in params, cls
diff --git a/tests/ar_diffusion/test_kv_cache.py b/tests/diffusion/ar_diffusion/test_kv_cache.py
similarity index 73%
rename from tests/ar_diffusion/test_kv_cache.py
rename to tests/diffusion/ar_diffusion/test_kv_cache.py
index beb575a0b..d09c1c1b6 100644
--- a/tests/ar_diffusion/test_kv_cache.py
+++ b/tests/diffusion/ar_diffusion/test_kv_cache.py
@@ -12,6 +12,7 @@ from vllm.v1.kv_cache_interface import KVCacheSpecKind, get_kv_cache_spec_kind
 from vllm.v1.kv_cache_spec_registry import KVCacheSpecRegistry
 from vllm.v1.request import RequestStatus
 
+from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
 from vllm_omni.experimental.ar_diffusion.kv_cache import (
     ARDiffusionKVCache,
     ARDiffusionKVConfig,
@@ -24,6 +25,9 @@ from vllm_omni.experimental.ar_diffusion.kv_cache import (
 )
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged import chunk_window_skipped_tokens
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 BLOCK = 16
 
 
@@ -194,16 +198,29 @@ def test_cross_attn_pool_deducted_from_self_attn_budget():
         block_size=BLOCK,
         max_model_len=4096,
         available_bytes=avail,
-        cross_attn_length=L,
+        kv_branches=(ARDiffusionKVBranchSpec("positive", 0), ARDiffusionKVBranchSpec("negative", 0)),
+        session_capacity=1,
+        cross_attention_lengths={"text": L},
         device=torch.device("cpu"),
     )
     cross_bytes = 2 * 2 * L * 4 * 64 * torch.float16.itemsize * 2  # K+V, pos+neg, layers
     expected = compute_num_blocks(avail - cross_bytes, 0.5, kv.spec.page_size_bytes * 2)
     assert kv.num_blocks == expected
-    assert expected > 2 * (2 + 1) + 2  # above the min-blocks floor, so the deduction is what's tested
+    assert expected > 1 * (2 + 1) + 2  # above the local-slot floor, so the cross deduction is what's tested
 
 
-def _make_kv(*, local_branches, num_frame_per_block=2, window_chunks=9):
+def _make_kv(
+    *,
+    local_branches,
+    num_frame_per_block=2,
+    window_chunks=9,
+    max_scratch_tokens_per_branch=0,
+):
+    kv_branches = (
+        (ARDiffusionKVBranchSpec("positive", 0), ARDiffusionKVBranchSpec("negative", 0))
+        if local_branches == 1
+        else (ARDiffusionKVBranchSpec("positive", 0), ARDiffusionKVBranchSpec("negative", 1))
+    )
     return ARDiffusionKVCache(
         ARDiffusionKVConfig(enable=True, chunk_size=BLOCK, window_chunks=window_chunks),
         num_layers=1,
@@ -214,41 +231,75 @@ def _make_kv(*, local_branches, num_frame_per_block=2, window_chunks=9):
         max_model_len=4096,
         available_bytes=1 << 16,  # tiny -> the floor binds
         device=torch.device("cpu"),
-        local_branches=local_branches,
-        num_frame_per_block=num_frame_per_block,
+        kv_branches=kv_branches,
+        session_capacity=1,
+        frames_per_block=num_frame_per_block,
+        max_scratch_tokens_per_branch=max_scratch_tokens_per_branch,
     )
 
 
 def test_pool_floor_is_branch_aware():
-    """CFG-parallel rank (one local branch) sizes for one window + in-flight chunk;
-    a single-process run (both branches) sizes for two. Scratch scales the same way."""
+    """CFG-parallel rank (one local kv_branch) sizes for one window + in-flight chunk;
+    a single-process run (both kv_branches) sizes for two. Scratch scales the same way."""
     one = _make_kv(local_branches=1)
     two = _make_kv(local_branches=2)
 
     assert one.managed_num_blocks == 1 * (9 + 2) + 2  # 13
     assert two.managed_num_blocks == 2 * (9 + 2) + 2  # 24
-    assert one.scratch_num_blocks == one.scratch_blocks_per_branch
-    assert two.scratch_num_blocks == 2 * two.scratch_blocks_per_branch
-    assert one.num_blocks_total == 13 + one.scratch_blocks_per_branch
+    assert one.scratch_num_blocks == one.scratch_blocks_per_kv_branch
+    assert two.scratch_num_blocks == 2 * two.scratch_blocks_per_kv_branch
+    assert one.scratch_blocks_per_kv_branch == 2
+    assert one.num_blocks_total == 13 + one.scratch_blocks_per_kv_branch
+
+
+def test_scratch_capacity_is_derived_from_declared_geometry(monkeypatch):
+    monkeypatch.delenv("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH", raising=False)
+    kv = _make_kv(
+        local_branches=1,
+        num_frame_per_block=6,
+        max_scratch_tokens_per_branch=BLOCK + 1,
+    )
+    assert kv.scratch_blocks_per_kv_branch == 8  # six video blocks + two auxiliary blocks
+
+
+def test_scratch_env_override_cannot_reduce_declared_minimum(monkeypatch):
+    monkeypatch.setenv("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH", "1")
+    kv = _make_kv(
+        local_branches=1,
+        num_frame_per_block=6,
+        max_scratch_tokens_per_branch=BLOCK + 1,
+    )
+    assert kv.scratch_blocks_per_kv_branch == 8
 
 
 def test_scratch_maps_to_slot_zero_with_one_local_branch():
-    """A CFG-parallel rank runs exactly one branch: whichever CFG side it is,
+    """A CFG-parallel rank runs exactly one kv_branch: whichever CFG side it is,
     its scratch lands in the rank's single slot (no dead second slot)."""
     one = _make_kv(local_branches=1)
-    assert one.scratch_block_ids(True, 0, 2) == one.scratch_block_ids(False, 0, 2)
+    assert one.scratch_block_ids("positive", 0, 2) == one.scratch_block_ids("negative", 0, 2)
 
     two = _make_kv(local_branches=2)
-    assert two.scratch_block_ids(True, 0, 2) != two.scratch_block_ids(False, 0, 2)
+    assert two.scratch_block_ids("positive", 0, 2) != two.scratch_block_ids("negative", 0, 2)
 
 
 def test_scratch_exhaustion_still_raises():
     one = _make_kv(local_branches=1)
-    cap = one.scratch_blocks_per_branch
+    cap = one.scratch_blocks_per_kv_branch
     with pytest.raises(RuntimeError, match="scratch blocks exhausted"):
-        one.scratch_block_ids(False, 0, cap + 1)
+        one.scratch_block_ids("positive", 0, cap + 1)
 
 
-def test_invalid_local_branches_rejected():
-    with pytest.raises(ValueError, match="local_branches"):
-        _make_kv(local_branches=3)
+def test_non_contiguous_branch_indices_rejected():
+    with pytest.raises(ValueError, match="contiguous"):
+        ARDiffusionKVCache(
+            ARDiffusionKVConfig(enable=True, chunk_size=BLOCK, window_chunks=2),
+            num_layers=1,
+            num_kv_heads=4,
+            head_size=64,
+            dtype=torch.float32,
+            block_size=BLOCK,
+            max_model_len=4096,
+            available_bytes=1 << 16,
+            kv_branches=(ARDiffusionKVBranchSpec("main", 1),),
+            session_capacity=1,
+        )
diff --git a/tests/ar_diffusion/test_kv_orchestration.py b/tests/diffusion/ar_diffusion/test_kv_orchestration.py
similarity index 83%
rename from tests/ar_diffusion/test_kv_orchestration.py
rename to tests/diffusion/ar_diffusion/test_kv_orchestration.py
index 4ba5cb49b..32603bf88 100644
--- a/tests/ar_diffusion/test_kv_orchestration.py
+++ b/tests/diffusion/ar_diffusion/test_kv_orchestration.py
@@ -4,9 +4,19 @@
 import pytest
 import torch
 
+from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
 from vllm_omni.experimental.ar_diffusion.kv_cache import ARDiffusionKVCache, ARDiffusionKVConfig
 
-DIMS = dict(num_layers=2, num_kv_heads=4, head_size=64, dtype=torch.float16, block_size=16)
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+DIMS = dict(
+    num_layers=2,
+    num_kv_heads=4,
+    head_size=64,
+    dtype=torch.float16,
+    block_size=16,
+    kv_branches=(ARDiffusionKVBranchSpec("positive", 0), ARDiffusionKVBranchSpec("negative", 1)),
+    session_capacity=2,
+)
 
 
 def make_cache(*, chunk_size=16, window_chunks=2, available_bytes=1 << 24):
@@ -67,7 +77,7 @@ def test_num_computed_advances_per_chunk():
 
 
 def test_state_close_frees_both_branch_blocks():
-    """ARDiffusionKVState.close() returns both CFG branches' pool blocks to the pool.
+    """ARDiffusionKVState.close() returns both CFG kv_branches' pool blocks to the pool.
 
     This is the primitive the runner's LRU eviction relies on: when a session is
     evicted, close() must free the blocks both adapters hold, or session churn
@@ -80,12 +90,17 @@ def test_state_close_frees_both_branch_blocks():
 
     pos = kv.begin_request("bde__s")
     neg = kv.begin_request("bde__s__neg")
-    state = ARDiffusionKVState(kv, pos, neg, num_layers=kv.num_layers)
+    state = ARDiffusionKVState(
+        kv,
+        "s",
+        {"positive": pos, "negative": neg},
+        num_layers=kv.num_layers,
+    )
     for _ in range(3):
         for adapter in (pos, neg):
             kv.allocate_chunk(adapter)
             kv.commit_chunk(adapter)
-    # Both branches hold resident blocks now.
+    # Both kv_branches hold resident blocks now.
     assert kv.manager.block_pool.get_num_free_blocks() < free_total
 
     state.close()
diff --git a/tests/ar_diffusion/test_paged_attention.py b/tests/diffusion/ar_diffusion/test_paged_attention.py
similarity index 81%
rename from tests/ar_diffusion/test_paged_attention.py
rename to tests/diffusion/ar_diffusion/test_paged_attention.py
index 1836656f9..0b66c01a0 100644
--- a/tests/ar_diffusion/test_paged_attention.py
+++ b/tests/diffusion/ar_diffusion/test_paged_attention.py
@@ -11,6 +11,7 @@ from unittest.mock import MagicMock
 import pytest
 import torch
 
+from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
 from vllm_omni.experimental.ar_diffusion.kv_cache import (
     ARDiffusionKVCache,
     ARDiffusionKVConfig,
@@ -21,9 +22,14 @@ from vllm_omni.experimental.ar_diffusion.kv_cache import (
 )
 from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 BLOCK = 16
 N_HEADS = 4
 HEAD_DIM = 64
+POS = "positive"
+NEG = "negative"
 
 
 def make_state(*, num_layers=1, window_chunks=2, dtype=torch.float32, device=torch.device("cpu")):
@@ -37,11 +43,15 @@ def make_state(*, num_layers=1, window_chunks=2, dtype=torch.float32, device=tor
         block_size=BLOCK,
         max_model_len=4096,
         available_bytes=1 << 26,
+        kv_branches=(ARDiffusionKVBranchSpec(POS, 0), ARDiffusionKVBranchSpec(NEG, 1)),
+        session_capacity=2,
+        frames_per_block=2,
+        max_scratch_tokens_per_branch=BLOCK,
         device=device,
     )
     pos = kv.begin_request("r-pos")
     neg = kv.begin_request("r-neg")
-    return kv, ARDiffusionKVState(kv, pos, neg, num_layers=num_layers)
+    return kv, ARDiffusionKVState(kv, "s1", {POS: pos, NEG: neg}, num_layers=num_layers)
 
 
 def _dense_attention(query: torch.Tensor, key: torch.Tensor, value: torch.Tensor) -> torch.Tensor:
@@ -79,51 +89,51 @@ def _commit_video_span(
     kv: ARDiffusionKVCache,
     st: ARDiffusionKVState,
     *,
-    is_negative: bool,
+    kv_branch: str,
     n_chunks: int,
     dtype: torch.dtype,
     device: torch.device,
 ) -> tuple[torch.Tensor, torch.Tensor]:
-    ctx = st.get_kv_caches(is_negative, seq_len=n_chunks * BLOCK, commit_current=True)[0].forward_ctx
+    ctx = st.get_kv_caches(kv_branch, seq_len=n_chunks * BLOCK, commit_current=True)[0].forward_ctx
     ctx.ensure_video_slots(device)
     k = torch.randn(1, n_chunks * BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
     v = torch.randn(1, n_chunks * BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
     kv._k_pools[0][ctx.current_video_slot_mapping] = k[0]
     kv._v_pools[0][ctx.current_video_slot_mapping] = v[0]
-    st.commit_paged_context(is_negative)
+    st.commit_paged_context(kv_branch)
     return k, v
 
 
 def test_paged_context_allocates_lazily_and_commits_after_forward():
     _, st = make_state()
 
-    contexts = st.get_kv_caches(False, seq_len=BLOCK, commit_current=True)
+    contexts = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=True)
     ctx = contexts[0].forward_ctx
     assert isinstance(contexts[0], ARDiffusionPagedLayerContext)
-    assert st.pos.completed_chunks == 0
+    assert st.adapter(POS).completed_chunks == 0
     assert ctx.current_video_slot_mapping is None
 
     ctx.ensure_video_slots(torch.device("cpu"))
-    assert st.pos.completed_chunks == 0
+    assert st.adapter(POS).completed_chunks == 0
     assert len(ctx.current_video_block_ids) == 1
 
-    st.commit_paged_context(False)
-    assert st.pos.completed_chunks == 1
-    assert st._committed[False] == BLOCK
+    st.commit_paged_context(POS)
+    assert st.adapter(POS).completed_chunks == 1
+    assert st._committed[POS] == BLOCK
 
 
 def test_scratch_video_and_action_blocks_do_not_commit():
     kv, st = make_state()
 
-    ctx = st.get_kv_caches(False, seq_len=2 * BLOCK, commit_current=False)[0].forward_ctx
+    ctx = st.get_kv_caches(POS, seq_len=2 * BLOCK, commit_current=False)[0].forward_ctx
     ctx.ensure_video_slots(torch.device("cpu"))
     ctx.ensure_action_slots(3, torch.device("cpu"))
 
-    assert ctx.current_video_block_ids == kv.scratch_block_ids(False, 0, 2)
-    assert ctx.action_scratch_block_ids == kv.scratch_block_ids(False, 2, 1)
-    st.commit_paged_context(False)
-    assert st.pos.completed_chunks == 0
-    assert st._committed[False] == 0
+    assert ctx.current_video_block_ids == kv.scratch_block_ids(POS, 0, 2)
+    assert ctx.action_scratch_block_ids == kv.scratch_block_ids(POS, 2, 1)
+    st.commit_paged_context(POS)
+    assert st.adapter(POS).completed_chunks == 0
+    assert st._committed[POS] == 0
 
 
 def test_pipeline_kv_get_paged_path_has_no_gather_backend():
@@ -155,7 +165,7 @@ def test_paged_attention_matches_dense_reference_cpu(history_chunks, action_len,
         k, v = _commit_video_span(
             kv,
             st,
-            is_negative=False,
+            kv_branch=POS,
             n_chunks=history_chunks,
             dtype=dtype,
             device=device,
@@ -163,7 +173,7 @@ def test_paged_attention_matches_dense_reference_cpu(history_chunks, action_len,
         history_k_parts.append(k)
         history_v_parts.append(v)
 
-    ctx = st.get_kv_caches(False, seq_len=BLOCK, commit_current=commit_current)[0].forward_ctx
+    ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=commit_current)[0].forward_ctx
     ctx.ensure_video_slots(device)
     current_k = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
     current_v = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
@@ -212,9 +222,9 @@ def test_paged_attention_matches_dense_reference_cpu(history_chunks, action_len,
 
     torch.testing.assert_close(paged, ref, rtol=1e-5, atol=1e-5)
 
-    before = st.pos.completed_chunks
-    st.commit_paged_context(False)
-    assert st.pos.completed_chunks == before + (1 if commit_current else 0)
+    before = st.adapter(POS).completed_chunks
+    st.commit_paged_context(POS)
+    assert st.adapter(POS).completed_chunks == before + (1 if commit_current else 0)
 
 
 @pytest.mark.skipif(not _cuda_flash_attn_usable(), reason="usable CUDA FlashAttention is required")
@@ -231,13 +241,13 @@ def test_paged_attention_matches_dense_reference_gpu(history_chunks, action_len,
     history_k, history_v = _commit_video_span(
         kv,
         st,
-        is_negative=False,
+        kv_branch=POS,
         n_chunks=history_chunks,
         dtype=dtype,
         device=device,
     )
 
-    layer_ctx = st.get_kv_caches(False, seq_len=BLOCK, commit_current=commit_current)[0]
+    layer_ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=commit_current)[0]
     ctx = layer_ctx.forward_ctx
     current_k = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
     current_v = torch.randn(1, BLOCK, N_HEADS, HEAD_DIM, dtype=dtype, device=device)
@@ -294,13 +304,13 @@ def test_block_table_padded_to_fixed_width():
     device = torch.device("cpu")
     kv, st = make_state(window_chunks=2)
 
-    ctx1 = st.get_kv_caches(False, seq_len=BLOCK, commit_current=True)[0].forward_ctx
+    ctx1 = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=True)[0].forward_ctx
     ctx1.prepare(device=device, action_len=0, query_len=BLOCK)
-    st.commit_paged_context(False)
+    st.commit_paged_context(POS)
 
-    ctx2 = st.get_kv_caches(False, seq_len=BLOCK, commit_current=True)[0].forward_ctx
+    ctx2 = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=True)[0].forward_ctx
     ctx2.prepare(device=device, action_len=0, query_len=BLOCK)
-    st.commit_paged_context(False)
+    st.commit_paged_context(POS)
 
     # 1-block vs 2-block visible history: same table width, same max_seq_len.
     assert ctx1.block_table.shape == ctx2.block_table.shape
@@ -315,7 +325,7 @@ def test_block_table_padded_to_fixed_width():
 def test_prepare_is_idempotent_and_layers_share_metadata():
     device = torch.device("cpu")
     _, st = make_state(num_layers=2)
-    contexts = st.get_kv_caches(False, seq_len=BLOCK, commit_current=False)
+    contexts = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)
     fctx = contexts[0].forward_ctx
     fctx.prepare(device=device, action_len=0, query_len=BLOCK)
     table = fctx.block_table
@@ -335,7 +345,7 @@ def test_prepare_is_idempotent_and_layers_share_metadata():
 
 def test_layer_inputs_before_prepare_raises():
     _, st = make_state()
-    layer_ctx = st.get_kv_caches(False, seq_len=BLOCK, commit_current=False)[0]
+    layer_ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)[0]
     with pytest.raises(RuntimeError, match="before prepare"):
         layer_ctx.to_layer_inputs()
 
@@ -363,7 +373,7 @@ def test_custom_op_compiles_fullgraph_without_recompile_on_value_change():
     kv, st = make_state(num_layers=2, window_chunks=2)
 
     def run_one_forward(commit):
-        contexts = st.get_kv_caches(False, seq_len=BLOCK, commit_current=commit)
+        contexts = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=commit)
         fctx = contexts[0].forward_ctx
         fctx.prepare(device=device, action_len=0, query_len=BLOCK)
         q = torch.randn(BLOCK, N_HEADS, HEAD_DIM)
@@ -374,21 +384,26 @@ def test_custom_op_compiles_fullgraph_without_recompile_on_value_change():
         # block-forward code object in production).
         for layer_ctx in contexts:
             out = compiled(layer_ctx.to_layer_inputs(), q, k, v)
-        st.commit_paged_context(False)
+        st.commit_paged_context(POS)
         return out
 
     torch._dynamo.reset()
-    from torch._dynamo.testing import CompileCounter
+    try:
+        from torch._dynamo.testing import CompileCounter
 
-    counter = CompileCounter()
+        counter = CompileCounter()
 
-    def fn(inputs, q, k, v):
-        return paged_write_attn(inputs, q, k, v, None, None, HEAD_DIM**-0.5) * 1.0
+        def fn(inputs, q, k, v):
+            return paged_write_attn(inputs, q, k, v, None, None, HEAD_DIM**-0.5) * 1.0
 
-    compiled = torch.compile(fn, backend=counter, fullgraph=True)
+        compiled = torch.compile(fn, backend=counter, fullgraph=True)
 
-    run_one_forward(commit=True)  # history grows between calls ->
-    run_one_forward(commit=True)  # block-table VALUES change, shapes don't
-    run_one_forward(commit=False)
+        run_one_forward(commit=True)  # history grows between calls ->
+        run_one_forward(commit=True)  # block-table VALUES change, shapes don't
+        run_one_forward(commit=False)
 
-    assert counter.frame_count == 1, f"recompiled: frame_count={counter.frame_count}"
+        assert counter.frame_count == 1, f"recompiled: frame_count={counter.frame_count}"
+    finally:
+        # Leave a clean dynamo state for later suites in the same pytest process
+        # (e.g. model_executor transformers models).
+        torch._dynamo.reset()
diff --git a/tests/diffusion/ar_diffusion/test_pipeline_bridge.py b/tests/diffusion/ar_diffusion/test_pipeline_bridge.py
new file mode 100644
index 000000000..ec60290b9
--- /dev/null
+++ b/tests/diffusion/ar_diffusion/test_pipeline_bridge.py
@@ -0,0 +1,280 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for the ARDiffusionKVState paged-attention pipeline bridge."""
+
+import pytest
+import torch
+
+from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
+from vllm_omni.experimental.ar_diffusion.kv_cache import (
+    ARDiffusionKVCache,
+    ARDiffusionKVConfig,
+    ARDiffusionPagedLayerContext,
+)
+from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+BLOCK = 16
+N_HEADS = 4
+HEAD_DIM = 64
+POS = "positive"
+NEG = "negative"
+
+
+def make_state(num_layers=1, window_chunks=4, cross_attn_length=0, shared_local_index=False):
+    cfg = ARDiffusionKVConfig(enable=True, chunk_size=BLOCK, window_chunks=window_chunks)
+    kv = ARDiffusionKVCache(
+        cfg,
+        num_layers=num_layers,
+        num_kv_heads=N_HEADS,
+        head_size=HEAD_DIM,
+        dtype=torch.float32,
+        block_size=BLOCK,
+        max_model_len=4096,
+        available_bytes=1 << 24,
+        kv_branches=(
+            ARDiffusionKVBranchSpec(POS, 0),
+            ARDiffusionKVBranchSpec(NEG, 0 if shared_local_index else 1),
+        ),
+        session_capacity=2,
+        cross_attention_lengths={"text": cross_attn_length} if cross_attn_length else None,
+        device=torch.device("cpu"),
+    )
+    pos = kv.begin_request("r-pos")
+    neg = kv.begin_request("r-neg")
+    return kv, ARDiffusionKVState(kv, "s1", {POS: pos, NEG: neg}, num_layers=num_layers)
+
+
+def _prepare_and_commit(st: ARDiffusionKVState, kv_branch: str, n_chunks: int) -> None:
+    ctx = st.get_kv_caches(kv_branch, seq_len=n_chunks * BLOCK, commit_current=True)[0].forward_ctx
+    ctx.ensure_video_slots(torch.device("cpu"))
+    st.commit_paged_context(kv_branch)
+
+
+def test_get_returns_paged_layer_contexts_when_nothing_committed():
+    _, st = make_state(num_layers=2)
+    for kv_branch in (POS, NEG):
+        contexts = st.get_kv_caches(kv_branch, seq_len=BLOCK, commit_current=False)
+        assert len(contexts) == 2
+        assert all(isinstance(ctx, ARDiffusionPagedLayerContext) for ctx in contexts)
+        assert contexts[0].history_block_ids == []
+
+
+def test_managed_paged_context_commits_only_after_forward():
+    kv, st = make_state(num_layers=1)
+    contexts = st.get_kv_caches(POS, seq_len=2 * BLOCK, commit_current=True)
+    ctx = contexts[0].forward_ctx
+
+    assert st.adapter(POS).completed_chunks == 0
+    assert kv.window_block_ids(st.adapter(POS)) == []
+    ctx.ensure_video_slots(torch.device("cpu"))
+    assert st.adapter(POS).completed_chunks == 0
+    assert len(ctx.current_video_block_ids) == 2
+
+    st.commit_paged_context(POS)
+
+    assert st.adapter(POS).completed_chunks == 2
+    assert st._committed[POS] == 2 * BLOCK
+    assert len(kv.window_block_ids(st.adapter(POS))) == 2
+
+
+def test_scratch_paged_context_does_not_commit():
+    kv, st = make_state(num_layers=1)
+    contexts = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)
+    ctx = contexts[0].forward_ctx
+    ctx.ensure_video_slots(torch.device("cpu"))
+
+    assert ctx.current_video_block_ids == kv.scratch_block_ids(POS, 0, 1)
+    st.commit_paged_context(POS)
+
+    assert st.adapter(POS).completed_chunks == 0
+    assert st._committed[POS] == 0
+    assert kv.window_block_ids(st.adapter(POS)) == []
+
+
+def test_eviction_bounds_resident_window():
+    kv, st = make_state(num_layers=1, window_chunks=3)
+    _prepare_and_commit(st, POS, 3)
+    assert len(kv.window_block_ids(st.adapter(POS))) == 3
+
+    _prepare_and_commit(st, POS, 2)
+    ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=False)[0].forward_ctx
+    visible_blocks, video_len = ctx.video_block_table(torch.device("cpu"))
+    assert len(visible_blocks) == 3
+    assert video_len == 3 * BLOCK
+
+
+def test_branches_are_independent():
+    kv, st = make_state()
+    _prepare_and_commit(st, POS, 1)
+    assert len(kv.window_block_ids(st.adapter(POS))) == 1
+    assert kv.window_block_ids(st.adapter(NEG)) == []
+
+
+def test_reset_clears_session_window():
+    kv, st = make_state(num_layers=1, window_chunks=4)
+    _prepare_and_commit(st, POS, 2)
+    _prepare_and_commit(st, NEG, 1)
+    assert st._committed[POS] == 2 * BLOCK and st._committed[NEG] == BLOCK
+    free_before = kv.manager.block_pool.get_num_free_blocks()
+
+    st.reset()
+
+    assert st._committed == {POS: 0, NEG: 0}
+    assert st._paged_pending == {POS: None, NEG: None}
+    assert kv.window_block_ids(st.adapter(POS)) == []
+    assert kv.window_block_ids(st.adapter(NEG)) == []
+    assert kv.manager.block_pool.get_num_free_blocks() > free_before
+    _prepare_and_commit(st, POS, 1)
+    assert len(kv.window_block_ids(st.adapter(POS))) == 1
+
+
+def test_get_cross_attention_kv_raises_before_populate():
+    _, st = make_state(cross_attn_length=8)
+    for kv_branch in (POS, NEG):
+        with pytest.raises(RuntimeError, match="before it was populated"):
+            st.get_cross_attention_kv(kv_branch, "text")
+
+
+def test_get_cross_attention_kv_returns_session_pool_dicts_when_populated():
+    L = 8
+    kv, st = make_state(num_layers=2, cross_attn_length=L)
+    written = []
+    for _ in range(2):
+        k = torch.randn(1, L, N_HEADS, HEAD_DIM)
+        v = torch.randn(1, L, N_HEADS, HEAD_DIM)
+        written.append((k, v))
+    st.populate_cross_attention(POS, "text", written)
+
+    out = st.get_cross_attention_kv(POS, "text")
+    assert len(out) == 2
+    for i, (k, v) in enumerate(written):
+        assert out[i]["is_init"] is True
+        assert out[i]["k"].shape == (1, L, N_HEADS, HEAD_DIM)
+        assert torch.equal(out[i]["k"], k)
+        assert torch.equal(out[i]["v"], v)
+
+
+def test_window_reset_can_keep_named_cross_attention_cache():
+    kv, st = make_state(num_layers=1, cross_attn_length=8)
+    k = torch.randn(1, 8, N_HEADS, HEAD_DIM)
+    v = torch.randn(1, 8, N_HEADS, HEAD_DIM)
+    st.populate_cross_attention(POS, "text", [(k, v)])
+    old_adapter = st.adapter(POS)
+
+    st.reset(keep_cross_attention=("text",))
+
+    assert st.adapter(POS) is not old_adapter
+    assert torch.equal(st.get_cross_attention_kv(POS, "text")[0]["k"], k)
+    assert "s1" in kv._cross_sessions
+
+    st.reset()
+    assert "s1" not in kv._cross_sessions
+    assert not st.is_cross_attention_populated(POS, "text")
+
+
+def test_cross_attention_uses_logical_branch_when_local_slot_is_shared():
+    _, st = make_state(num_layers=2, cross_attn_length=8, shared_local_index=True)
+    assert st.kv_cache.num_local_kv_branches == 1
+    pos_layers = [
+        (torch.full((1, 8, N_HEADS, HEAD_DIM), 1.0), torch.full((1, 8, N_HEADS, HEAD_DIM), 2.0)) for _ in range(2)
+    ]
+    neg_layers = [
+        (torch.full((1, 8, N_HEADS, HEAD_DIM), 3.0), torch.full((1, 8, N_HEADS, HEAD_DIM), 4.0)) for _ in range(2)
+    ]
+
+    st.populate_cross_attention(POS, "text", pos_layers)
+    st.populate_cross_attention(NEG, "text", neg_layers)
+
+    for layer in st.get_cross_attention_kv(POS, "text"):
+        assert torch.count_nonzero(layer["k"] != 1.0) == 0
+        assert torch.count_nonzero(layer["v"] != 2.0) == 0
+    for layer in st.get_cross_attention_kv(NEG, "text"):
+        assert torch.count_nonzero(layer["k"] != 3.0) == 0
+        assert torch.count_nonzero(layer["v"] != 4.0) == 0
+
+
+def test_cross_attention_population_is_transactional():
+    kv, st = make_state(num_layers=2, cross_attn_length=8)
+    original = [
+        (torch.full((1, 8, N_HEADS, HEAD_DIM), value), torch.full((1, 8, N_HEADS, HEAD_DIM), -value))
+        for value in (1.0, 2.0)
+    ]
+    replacement = (
+        torch.full((1, 8, N_HEADS, HEAD_DIM), 9.0),
+        torch.full((1, 8, N_HEADS, HEAD_DIM), -9.0),
+    )
+
+    def interrupted_population():
+        yield replacement
+        raise RuntimeError("projection failed")
+
+    with pytest.raises(RuntimeError, match="projection failed"):
+        st.populate_cross_attention(POS, "text", interrupted_population())
+    assert not st.is_cross_attention_populated(POS, "text")
+    assert "s1" not in kv._cross_sessions
+
+    st.populate_cross_attention(POS, "text", original)
+
+    with pytest.raises(RuntimeError, match="projection failed"):
+        st.populate_cross_attention(POS, "text", interrupted_population())
+    out = st.get_cross_attention_kv(POS, "text")
+    for layer_index, layer in enumerate(out):
+        assert torch.equal(layer["k"], original[layer_index][0])
+        assert torch.equal(layer["v"], original[layer_index][1])
+
+    for invalid_layers in (original[:1], [*original, replacement]):
+        with pytest.raises(ValueError, match="expected 2 layers"):
+            st.populate_cross_attention(POS, "text", invalid_layers)
+        out = st.get_cross_attention_kv(POS, "text")
+        for layer_index, layer in enumerate(out):
+            assert torch.equal(layer["k"], original[layer_index][0])
+            assert torch.equal(layer["v"], original[layer_index][1])
+
+    invalid_shape = (torch.empty(1, 7, N_HEADS, HEAD_DIM), original[0][1])
+    with pytest.raises(ValueError, match="expected k/v shape"):
+        st.populate_cross_attention(POS, "text", [invalid_shape, original[1]])
+    out = st.get_cross_attention_kv(POS, "text")
+    assert torch.equal(out[0]["k"], original[0][0])
+
+
+def test_closed_state_cannot_repopulate_cross_attention():
+    kv, st = make_state(num_layers=1, cross_attn_length=8)
+    layer = (torch.ones(1, 8, N_HEADS, HEAD_DIM), torch.ones(1, 8, N_HEADS, HEAD_DIM))
+    st.close()
+
+    with pytest.raises(RuntimeError, match="is closed"):
+        st.populate_cross_attention(POS, "text", [layer])
+    assert "s1" not in kv._cross_sessions
+
+
+def test_kv_create_is_noop_engine_owns_allocation():
+    from unittest.mock import MagicMock
+
+    from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import DreamZeroPipeline
+
+    p = DreamZeroPipeline.__new__(DreamZeroPipeline)
+    p._ar_diffusion_kv_state = object()
+    state = MagicMock()
+    p._kv_create(state, 1, "float32", "cpu", 24, 4, 64)
+    state.create_kv_caches.assert_not_called()
+
+
+def test_get_kv_cache_requires_frame_aligned_seqlen():
+    _, st = make_state()
+    with pytest.raises(AssertionError, match="frame-aligned"):
+        st.get_kv_caches(POS, seq_len=BLOCK + 1, commit_current=True)
+
+
+def test_prepare_one_branch_allocates_nothing_for_the_other():
+    """CFG-parallel laziness: a rank prepares only the kv_branch it runs."""
+    kv, st = make_state(num_layers=1, window_chunks=4)
+    pos_ctx = st.get_kv_caches(POS, seq_len=BLOCK, commit_current=True)[0].forward_ctx
+    neg_ctx = st.get_kv_caches(NEG, seq_len=BLOCK, commit_current=True)[0].forward_ctx
+
+    pos_ctx.prepare(device=torch.device("cpu"), action_len=0, query_len=BLOCK)
+
+    assert pos_ctx._allocated_video
+    assert not neg_ctx._allocated_video
+    assert kv.window_block_ids(st.adapter(NEG)) == []
diff --git a/tests/ar_diffusion/test_slot_mapping.py b/tests/diffusion/ar_diffusion/test_slot_mapping.py
similarity index 97%
rename from tests/ar_diffusion/test_slot_mapping.py
rename to tests/diffusion/ar_diffusion/test_slot_mapping.py
index 061df4d9c..4c1f82537 100644
--- a/tests/ar_diffusion/test_slot_mapping.py
+++ b/tests/diffusion/ar_diffusion/test_slot_mapping.py
@@ -13,6 +13,9 @@ from vllm_omni.experimental.ar_diffusion.kv_cache import (
     resident_block_ids,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 BLOCK = 16
 
 
diff --git a/tests/diffusion/attention/test_attention_config.py b/tests/diffusion/attention/test_attention_config.py
index a4c67851a..4a2c65cbb 100644
--- a/tests/diffusion/attention/test_attention_config.py
+++ b/tests/diffusion/attention/test_attention_config.py
@@ -31,21 +31,94 @@ from vllm_omni.diffusion.data import (
     parse_attention_config,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 class TestAttentionSpec:
-    def test_construct_no_extra(self):
+    def test_construct_no_skip_softmax(self):
         spec = AttentionSpec(backend="FLASH_ATTN")
-        assert spec.extra == {}
+        assert spec.skip_softmax is None
 
-    def test_mapping_extra_normalized(self):
-        spec = AttentionSpec(backend="SAGE_ATTN", extra={"quant": "int8"})
-        assert spec.backend == "SAGE_ATTN"
-        assert spec.extra == {"quant": "int8"}
+    def test_skip_softmax_mapping_coerced(self):
+        spec = AttentionSpec(backend="TRTLLM_ATTN", skip_softmax={"target_sparsity": 0.5})
+        assert spec.backend == "TRTLLM_ATTN"
+        assert spec.skip_softmax.target_sparsity == 0.5
 
     def test_invalid_backend_type(self):
         with pytest.raises(TypeError):
             AttentionSpec(backend=123)  # type: ignore[arg-type]
 
+    def test_skip_softmax_rejected_on_non_trtllm(self):
+        with pytest.raises(ValueError, match="only supported by the TRTLLM_ATTN"):
+            AttentionSpec(backend="TORCH_SDPA", skip_softmax={"target_sparsity": 0.5})
+
+    def test_quant_serialized_with_defaults_and_overrides(self):
+        assert AttentionSpec(backend="TRTLLM_ATTN", quant={"dtype_qk": "fp8_e4m3"}).backend_kwargs()["quant"] == {
+            "dtype_qk": "fp8_e4m3",
+            "q_block_size": 1,
+            "k_block_size": 16,
+        }
+        assert AttentionSpec(
+            backend="TRTLLM_ATTN", quant={"dtype_qk": "int8", "q_block_size": 4, "k_block_size": 16}
+        ).backend_kwargs()["quant"] == {"dtype_qk": "int8", "q_block_size": 4, "k_block_size": 16}
+
+    def test_quant_superset_fields_passed_through(self):
+        # FLASHINFER_ATTN-style config (dtype_vo / flashinfer_backend) round-trips on the shared spec.
+        bk = AttentionSpec(
+            backend="FLASHINFER_ATTN",
+            quant={"dtype_qk": "bfloat16", "dtype_vo": "fp8_e4m3", "flashinfer_backend": "trtllm-gen"},
+        ).backend_kwargs()["quant"]
+        assert bk["dtype_qk"] == "bfloat16"
+        assert bk["dtype_vo"] == "fp8_e4m3"
+        assert bk["flashinfer_backend"] == "trtllm-gen"
+
+    def test_quant_and_skip_softmax_coexist(self):
+        bk = AttentionSpec(
+            backend="TRTLLM_ATTN", quant={"dtype_qk": "int8"}, skip_softmax={"target_sparsity": 0.5}
+        ).backend_kwargs()
+        assert bk["target_sparsity"] == 0.5 and bk["quant"]["dtype_qk"] == "int8"
+
+    @pytest.mark.parametrize(
+        "spec, match",
+        [
+            ({"backend": "TORCH_SDPA", "quant": {"dtype_qk": "int8"}}, "only supported by the TRTLLM_ATTN"),
+            ({"backend": "TRTLLM_ATTN", "quant": {"dtype_qk": "int4"}}, "quant.dtype_qk"),
+            ({"backend": "TRTLLM_ATTN", "quant": {"dtype_qk": "int8", "k_block_size": 8}}, "quant.k_block_size"),
+        ],
+    )
+    def test_quant_validation_rejects(self, spec, match):
+        with pytest.raises(ValueError, match=match):
+            AttentionSpec(**spec)
+
+    def test_block_sparse_defaults_applied_when_backend_selected(self):
+        spec = AttentionSpec(backend="RAINFUSION_ATTN")
+        assert spec.block_sparse.sparsity == 0.8
+        assert spec.backend_kwargs() == {"sparsity": 0.8, "start_step": 0}
+
+    def test_block_sparse_skip_layers_selector_expanded(self):
+        spec = AttentionSpec(
+            backend="RAINFUSION_ATTN",
+            block_sparse={"sparsity": 0.9, "start_step": 12, "skip_layers": "0-2,38"},
+        )
+        assert spec.block_sparse.skip_layer_indices == {0, 1, 2, 38}
+        assert spec.backend_kwargs() == {
+            "sparsity": 0.9,
+            "start_step": 12,
+            "skip_layers": [0, 1, 2, 38],
+        }
+
+    def test_block_sparse_rejected_on_dense_backend(self):
+        with pytest.raises(ValueError, match="block_sparse is only supported by"):
+            AttentionSpec(backend="FLASH_ATTN", block_sparse={"sparsity": 0.8})
+
+    @pytest.mark.parametrize(
+        "block_sparse",
+        [{"sparsity": 1.5}, {"start_step": -1}],
+    )
+    def test_block_sparse_invalid_values(self, block_sparse):
+        with pytest.raises(ValueError):
+            AttentionSpec(backend="RAINFUSION_ATTN", block_sparse=block_sparse)
+
 
 class TestAttentionConfig:
     def test_empty_config(self):
@@ -57,13 +130,13 @@ class TestAttentionConfig:
         config = AttentionConfig(
             default={"backend": "FLASH_ATTN"},
             per_role={
-                "self": {"backend": "SPARSE_BLOCK", "extra": {"block_size": 128}},
+                "self": {"backend": "TRTLLM_ATTN", "skip_softmax": {"target_sparsity": 0.5}},
                 "cross": "SAGE_ATTN",
             },
         )
         assert config.default.backend == "FLASH_ATTN"
-        assert config.per_role["self"].backend == "SPARSE_BLOCK"
-        assert config.per_role["self"].extra == {"block_size": 128}
+        assert config.per_role["self"].backend == "TRTLLM_ATTN"
+        assert config.per_role["self"].skip_softmax.target_sparsity == 0.5
         assert config.per_role["cross"].backend == "SAGE_ATTN"
 
     def test_constructor_flattens_nested_per_role_tree(self):
@@ -178,10 +251,10 @@ class TestAttentionConfig:
         config = AttentionConfig(
             default=AttentionSpec(backend="FLASH_ATTN"),
             per_role={
-                "self": AttentionSpec(backend="SPARSE_BLOCK", extra={"block_size": 128}),
+                "self": AttentionSpec(backend="SPARSE_BLOCK"),
                 "cross": AttentionSpec(backend="SAGE_ATTN"),
                 "ltx2.audio_self": AttentionSpec(backend="FLASH_ATTN"),
-                "ltx2.audio_to_video": AttentionSpec(backend="FLASH_ATTN", extra={"causal_window": 64}),
+                "ltx2.audio_to_video": AttentionSpec(backend="FLASH_ATTN"),
             },
         )
 
@@ -200,7 +273,6 @@ class TestAttentionConfig:
         # audio-to-video → exact match
         spec, _ = config.resolve_with_source("ltx2.audio_to_video", "cross")
         assert spec.backend == "FLASH_ATTN"
-        assert spec.extra == {"causal_window": 64}
 
         # video-to-audio → category fallback to "cross"
         assert config.resolve_with_source("ltx2.video_to_audio", "cross")[0].backend == "SAGE_ATTN"
@@ -283,6 +355,13 @@ class TestBuildAttentionConfig:
 class TestOmniDiffusionConfigAttentionParsing:
     """Test OmniDiffusionConfig attention shorthand and structured config."""
 
+    @pytest.fixture(autouse=True)
+    def _clear_diffusion_attention_backend_env(self, monkeypatch):
+        # OmniDiffusionConfig.__post_init__ applies DIFFUSION_ATTENTION_BACKEND via
+        # build_attention_config(); clear it so these tests assert config defaults,
+        # not whatever the process inherited from CI / sibling tests.
+        monkeypatch.delenv("DIFFUSION_ATTENTION_BACKEND", raising=False)
+
     def test_diffusion_attention_backend_sets_default(self):
         config = OmniDiffusionConfig.from_kwargs(diffusion_attention_backend="SAGE_ATTN")
         assert isinstance(config.diffusion_attention_config, AttentionConfig)
@@ -364,12 +443,13 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
             head_size,
             attention_config=None,
             role_category=None,
+            allow_trtllm_default=False,
         ):
             captured["role"] = role
             captured["head_size"] = head_size
             captured["role_category"] = role_category
             captured["attention_config"] = attention_config
-            return _FakeBackend, AttentionSpec(backend="TORCH_SDPA", extra={"block_size": 128})
+            return _FakeBackend, AttentionSpec(backend="TRTLLM_ATTN", skip_softmax={"target_sparsity": 0.5})
 
         class _FakeRingParallelAttention:
             def __init__(self, sp_group, attn_backend_pref=None):
@@ -391,7 +471,7 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
         od_config = SimpleNamespace(
             diffusion_attention_config=AttentionConfig(
                 default=AttentionSpec(backend="FLASH_ATTN"),
-                per_role={"cross": AttentionSpec(backend="TORCH_SDPA", extra={"block_size": 128})},
+                per_role={"cross": AttentionSpec(backend="TRTLLM_ATTN", skip_softmax={"target_sparsity": 0.5})},
             ),
             parallel_config=SimpleNamespace(ring_degree=2),
             diffusion_kv_cache_dtype=None,
@@ -414,12 +494,12 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
         assert captured["role_category"] == "cross"
         assert captured["head_size"] == 64
         assert captured["attention_config"] is od_config.diffusion_attention_config
-        assert attn.backend_pref == "TORCH_SDPA"
-        assert attn.attention.kwargs["backend_kwargs"] == {"block_size": 128}
+        assert attn.backend_pref == "TRTLLM_ATTN"
+        assert attn.attention.kwargs["backend_kwargs"] == {"target_sparsity": 0.5}
         assert attn.attention.kwargs["qkv_layout"] == "BSND"
         assert attn.use_ring is True
         assert attn.ring_runner is not None
-        assert attn.ring_runner.attn_backend_pref == "TORCH_SDPA"
+        assert attn.ring_runner.attn_backend_pref == "TRTLLM_ATTN"
 
 
 class TestDiffusionKvCacheQuantization:
@@ -453,7 +533,10 @@ class TestDiffusionKvCacheQuantization:
         monkeypatch.setattr(
             layer_mod,
             "get_attn_backend_for_role",
-            lambda role, head_size, attention_config=None, role_category=None: (_FakeBackend, None),
+            lambda role, head_size, attention_config=None, role_category=None, allow_trtllm_default=False: (
+                _FakeBackend,
+                None,
+            ),
         )
         monkeypatch.setattr(layer_mod.SDPABackend, "get_impl_cls", staticmethod(lambda: _FakeAttentionImpl))
         monkeypatch.setattr(layer_mod, "build_parallel_attention_strategy", lambda **kwargs: object())
diff --git a/tests/diffusion/attention/test_attention_sp.py b/tests/diffusion/attention/test_attention_sp.py
index e5fb93d71..0f1faacd1 100644
--- a/tests/diffusion/attention/test_attention_sp.py
+++ b/tests/diffusion/attention/test_attention_sp.py
@@ -31,7 +31,11 @@ import tempfile
 import pytest
 import torch
 
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata, QueryRange
 from vllm_omni.diffusion.attention.layer import Attention
+from vllm_omni.diffusion.attention.parallel.allgather_kv import (
+    AllGatherKVParallelAttention,
+)
 from vllm_omni.diffusion.config import set_current_diffusion_config
 from vllm_omni.diffusion.data import (
     DiffusionParallelConfig,
@@ -45,6 +49,8 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 from vllm_omni.diffusion.forward_context import set_forward_context
 from vllm_omni.platforms import current_omni_platform
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def update_environment_variables(envs_dict: dict[str, str]):
     """Update multiple environment variables with logging."""
@@ -155,14 +161,267 @@ class TestMultiLayerAttentionModel(torch.nn.Module):
         return hidden_states
 
 
+class _MockAllGatherSPGroup:
+    def __init__(self, *, rank: int, gather_chunks: list[list[torch.Tensor]]) -> None:
+        self.allgather_group = object()
+        self.allgather_world_size = len(gather_chunks[0])
+        self.allgather_rank = rank
+        self._gather_chunks = list(gather_chunks)
+        self.gathered_input_shapes: list[tuple[int, ...]] = []
+
+    def all_gather(self, input_: torch.Tensor, dim: int = 0, separate_tensors: bool = False, group=None):
+        assert not separate_tensors
+        assert group is self.allgather_group
+        self.gathered_input_shapes.append(tuple(input_.shape))
+        chunks = self._gather_chunks.pop(0)
+        return torch.cat(chunks, dim=dim)
+
+
+def test_allgather_kv_slices_full_dense_mask_to_local_query_rows():
+    rank = 1
+    joint_len = 1
+    img_seq_local = 2
+    img_seq_full = 4
+    key_chunks = [
+        torch.full((1, img_seq_local, 1, 1), 10.0),
+        torch.full((1, img_seq_local, 1, 1), 20.0),
+    ]
+    value_chunks = [
+        torch.full((1, img_seq_local, 1, 1), 30.0),
+        torch.full((1, img_seq_local, 1, 1), 40.0),
+    ]
+    strategy = AllGatherKVParallelAttention(
+        _MockAllGatherSPGroup(rank=rank, gather_chunks=[key_chunks, value_chunks]),
+    )
+
+    query = torch.zeros((1, img_seq_local, 1, 1))
+    key = key_chunks[rank]
+    value = value_chunks[rank]
+    joint = torch.ones((1, joint_len, 1, 1))
+    mask = torch.arange((joint_len + img_seq_full) * (joint_len + img_seq_full))
+    mask = (mask % 2 == 0).view(1, 1, joint_len + img_seq_full, joint_len + img_seq_full)
+    metadata = AttentionMetadata(
+        attn_mask=mask,
+        joint_query=joint,
+        joint_key=joint,
+        joint_value=joint,
+        joint_strategy="front",
+    )
+
+    q_local, k_full, v_full, metadata_local, _ = strategy.pre_attention(query, key, value, metadata)
+
+    expected_rows = torch.cat(
+        [
+            mask[..., :joint_len, :],
+            mask[
+                ...,
+                joint_len + rank * img_seq_local : joint_len + (rank + 1) * img_seq_local,
+                :,
+            ],
+        ],
+        dim=-2,
+    )
+    assert q_local.shape[1] == joint_len + img_seq_local
+    assert k_full.shape[1] == joint_len + img_seq_full
+    assert v_full.shape[1] == joint_len + img_seq_full
+    torch.testing.assert_close(k_full[:, joint_len:], torch.cat(key_chunks, dim=1))
+    torch.testing.assert_close(v_full[:, joint_len:], torch.cat(value_chunks, dim=1))
+    assert metadata_local is not None
+    assert torch.equal(metadata_local.attn_mask, expected_rows)
+
+
+def test_allgather_kv_slices_rear_joint_dense_mask():
+    rank = 1
+    joint_len = 1
+    img_seq_local = 2
+    img_seq_full = 4
+    key_chunks = [torch.zeros((1, img_seq_local, 1, 1)) for _ in range(2)]
+    value_chunks = [torch.zeros_like(chunk) for chunk in key_chunks]
+    strategy = AllGatherKVParallelAttention(
+        _MockAllGatherSPGroup(rank=rank, gather_chunks=[key_chunks, value_chunks]),
+    )
+    query = torch.zeros((1, img_seq_local, 1, 1))
+    joint = torch.ones((1, joint_len, 1, 1))
+    mask = torch.arange((img_seq_full + joint_len) ** 2)
+    mask = (mask % 2 == 0).view(1, 1, img_seq_full + joint_len, img_seq_full + joint_len)
+    metadata = AttentionMetadata(
+        attn_mask=mask,
+        joint_query=joint,
+        joint_key=joint,
+        joint_value=joint,
+        joint_strategy="rear",
+    )
+
+    q_local, _, _, metadata_local, _ = strategy.pre_attention(query, key_chunks[rank], value_chunks[rank], metadata)
+
+    img_start = rank * img_seq_local
+    expected_rows = torch.cat(
+        [
+            mask[..., img_start : img_start + img_seq_local, :],
+            mask[..., img_seq_full : img_seq_full + joint_len, :],
+        ],
+        dim=-2,
+    )
+    assert q_local.shape[1] == img_seq_local + joint_len
+    assert metadata_local is not None
+    assert torch.equal(metadata_local.attn_mask, expected_rows)
+
+
+def test_allgather_kv_rejects_invalid_joint_strategy():
+    chunks = [[torch.zeros((1, 2, 1, 1)) for _ in range(2)] for _ in range(2)]
+    strategy = AllGatherKVParallelAttention(_MockAllGatherSPGroup(rank=0, gather_chunks=chunks))
+    joint = torch.ones((1, 1, 1, 1))
+    metadata = AttentionMetadata(
+        joint_query=joint,
+        joint_key=joint,
+        joint_value=joint,
+        joint_strategy="back",
+    )
+
+    with pytest.raises(ValueError, match="Unsupported joint_strategy"):
+        strategy.pre_attention(torch.zeros((1, 2, 1, 1)), chunks[0][0], chunks[1][0], metadata)
+
+
+def test_allgather_kv_preserves_global_spans_and_sets_query_ranges():
+    strategy = AllGatherKVParallelAttention(
+        _MockAllGatherSPGroup(
+            rank=1,
+            gather_chunks=[
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+            ],
+        ),
+    )
+    query = torch.zeros((1, 2, 1, 1))
+    key = torch.zeros((1, 2, 1, 1))
+    value = torch.zeros((1, 2, 1, 1))
+    joint = torch.ones((1, 1, 1, 1))
+    metadata = AttentionMetadata(
+        joint_query=joint,
+        joint_key=joint,
+        joint_value=joint,
+        full_attn_spans=[
+            [
+                (0, 1),  # joint span: kept on every rank.
+                (2, 5),  # image span crossing rank 0 and rank 1 image shards.
+            ]
+        ],
+    )
+
+    _, _, _, metadata_out, _ = strategy.pre_attention(query, key, value, metadata)
+
+    assert metadata_out is not None
+    assert metadata_out.full_attn_spans == [[(0, 1), (2, 5)]]
+    assert metadata_out.query_ranges == (
+        QueryRange(0, 1, 0),
+        QueryRange(1, 3, 3),
+    )
+
+
+def test_allgather_kv_query_ranges_include_reused_prefix_offset():
+    strategy = AllGatherKVParallelAttention(
+        _MockAllGatherSPGroup(
+            rank=1,
+            gather_chunks=[
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+            ],
+        ),
+    )
+    query = torch.zeros((1, 2, 1, 1))
+    key = torch.zeros((1, 2, 1, 1))
+    value = torch.zeros((1, 2, 1, 1))
+    joint_query = torch.ones((1, 1, 1, 1))
+    # K/V retain two reused AR-prefix tokens that have already been removed
+    # from Q and from the attention mask's query rows.
+    joint_key = torch.ones((1, 3, 1, 1))
+    joint_value = torch.ones((1, 3, 1, 1))
+    mask = torch.arange(5 * 7).view(1, 1, 5, 7)
+    metadata = AttentionMetadata(
+        attn_mask=mask,
+        joint_query=joint_query,
+        joint_key=joint_key,
+        joint_value=joint_value,
+        full_attn_spans=[[(0, 7)]],
+    )
+
+    _, _, _, metadata_out, _ = strategy.pre_attention(query, key, value, metadata)
+
+    assert metadata_out is not None
+    assert metadata_out.query_ranges == (
+        QueryRange(0, 1, 2),
+        QueryRange(1, 3, 5),
+    )
+    expected_mask = torch.cat([mask[..., :1, :], mask[..., 3:5, :]], dim=-2)
+    assert torch.equal(metadata_out.attn_mask, expected_mask)
+
+
+def test_allgather_kv_allows_empty_full_attn_spans():
+    strategy = AllGatherKVParallelAttention(
+        _MockAllGatherSPGroup(
+            rank=0,
+            gather_chunks=[
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+                [torch.zeros((1, 2, 1, 1)), torch.zeros((1, 2, 1, 1))],
+            ],
+        ),
+    )
+    query = torch.zeros((1, 2, 1, 1))
+    key = torch.zeros((1, 2, 1, 1))
+    value = torch.zeros((1, 2, 1, 1))
+    metadata = AttentionMetadata(full_attn_spans=[[]])
+
+    _, _, _, metadata_out, _ = strategy.pre_attention(query, key, value, metadata)
+
+    assert metadata_out is not None
+    assert metadata_out.full_attn_spans == [[]]
+    assert metadata_out.query_ranges == (QueryRange(0, 2, 0),)
+
+
+def test_allgather_kv_keeps_gathered_kv_compressed_for_gqa():
+    rank = 0
+    img_seq_local = 2
+    kv_heads = 2
+    repeat_num = 2
+    q_heads = kv_heads * repeat_num
+    key_chunks = [
+        torch.arange(1 * img_seq_local * kv_heads * 1, dtype=torch.float32).view(1, img_seq_local, kv_heads, 1),
+        torch.arange(100, 100 + 1 * img_seq_local * kv_heads * 1, dtype=torch.float32).view(
+            1, img_seq_local, kv_heads, 1
+        ),
+    ]
+    value_chunks = [chunk + 1000 for chunk in key_chunks]
+    sp_group = _MockAllGatherSPGroup(rank=rank, gather_chunks=[key_chunks, value_chunks])
+    strategy = AllGatherKVParallelAttention(sp_group)
+
+    query = torch.zeros((1, img_seq_local, q_heads, 1))
+    _, k_full, v_full, _, _ = strategy.pre_attention(query, key_chunks[rank], value_chunks[rank], AttentionMetadata())
+
+    assert sp_group.gathered_input_shapes == [
+        (1, img_seq_local, kv_heads, 1),
+        (1, img_seq_local, kv_heads, 1),
+    ]
+    assert k_full.shape == (1, img_seq_local * 2, kv_heads, 1)
+    assert v_full.shape == (1, img_seq_local * 2, kv_heads, 1)
+    expected_key = torch.cat(key_chunks, dim=1)
+    expected_value = torch.cat(value_chunks, dim=1)
+    torch.testing.assert_close(k_full, expected_key)
+    torch.testing.assert_close(v_full, expected_value)
+
+
 @pytest.mark.parametrize(
     "test_model_cls",
     [
         TestMultiLayerAttentionModel,
     ],
 )
-@pytest.mark.parametrize("ulysses_degree", [2])
-@pytest.mark.parametrize("ring_degree", [2])
+@pytest.mark.parametrize(
+    ("ulysses_degree", "ring_degree", "allgather_degree"),
+    [
+        pytest.param(2, 2, 1, id="ulysses-ring"),
+        pytest.param(1, 1, 2, id="allgather-kv"),
+    ],
+)
 @pytest.mark.parametrize("batch_size", [2])
 @pytest.mark.parametrize("seq_len", [16])
 @pytest.mark.parametrize("num_heads", [8])
@@ -175,6 +434,7 @@ class TestMultiLayerAttentionModel(torch.nn.Module):
 def test_sequence_parallel(
     ulysses_degree: int,
     ring_degree: int,
+    allgather_degree: int,
     test_model_cls: type[torch.nn.Module],
     dtype: torch.dtype,
     causal: bool,
@@ -186,8 +446,8 @@ def test_sequence_parallel(
     num_heads: int,
     head_size: int,
 ):
-    """Test Ulysses attention by comparing with and without SP enabled."""
-    sequence_parallel_size = ulysses_degree * ring_degree
+    """Compare Ulysses/Ring and AllGather-KV SP against a single-rank run."""
+    sequence_parallel_size = allgather_degree if allgather_degree > 1 else ulysses_degree * ring_degree
 
     # Skip if not enough GPUs available
     available_gpus = current_omni_platform.get_device_count()
@@ -223,6 +483,7 @@ def test_sequence_parallel(
                 use_compile,
                 1,  # ulysses_degree = 1
                 1,  # ring_degree = 1
+                1,  # allgather_degree = 1 (baseline: no AllGather-KV SP)
                 1,  # sequence_parallel_size = 1
                 baseline_output_file,
                 model_state_file,
@@ -233,7 +494,10 @@ def test_sequence_parallel(
         )
 
         # Step 2: Run with SP enabled
-        print(f"\n[SP Test] Running with SP (ulysses_degree={ulysses_degree}, ring_degree={ring_degree})...")
+        print(
+            "\n[SP Test] Running with SP "
+            f"(ulysses={ulysses_degree}, ring={ring_degree}, allgather={allgather_degree})..."
+        )
         torch.multiprocessing.spawn(
             ulysses_attention_on_test_model,
             args=(
@@ -250,6 +514,7 @@ def test_sequence_parallel(
                 use_compile,
                 ulysses_degree,
                 ring_degree,
+                allgather_degree,
                 sequence_parallel_size,
                 sp_output_file,
                 model_state_file,
@@ -345,6 +610,7 @@ def ulysses_attention_on_test_model(
     use_compile: bool,
     ulysses_degree: int,
     ring_degree: int,
+    allgather_degree: int,
     sequence_parallel_size: int,
     output_file: str,
     model_state_file: str,
@@ -356,7 +622,11 @@ def ulysses_attention_on_test_model(
     RANDOM_SEED = 42
     seed_everything(RANDOM_SEED)
 
-    mode_str = "Baseline (no SP)" if is_baseline else f"SP (ulysses={ulysses_degree}, ring={ring_degree})"
+    if allgather_degree > 1:
+        sp_kind = f"allgather={allgather_degree}"
+    else:
+        sp_kind = f"ulysses={ulysses_degree}, ring={ring_degree}"
+    mode_str = "Baseline (no SP)" if is_baseline else f"SP ({sp_kind})"
     print(f"\n[{mode_str}] Rank {local_rank}/{world_size} - Random seed set to {RANDOM_SEED}")
 
     device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
@@ -384,6 +654,7 @@ def ulysses_attention_on_test_model(
         sequence_parallel_size=sequence_parallel_size,
         ulysses_degree=ulysses_degree,
         ring_degree=ring_degree,
+        allgather_degree=allgather_degree,
         cfg_parallel_size=1,
     )
 
@@ -400,6 +671,7 @@ def ulysses_attention_on_test_model(
         sequence_parallel_size=sequence_parallel_size,
         ulysses_degree=ulysses_degree,
         ring_degree=ring_degree,
+        allgather_degree=allgather_degree,
         tensor_parallel_size=1,
         pipeline_parallel_size=1,
     )
@@ -519,7 +791,11 @@ def ulysses_attention_on_test_model(
             with open(output_file, "wb") as f:
                 pickle.dump(output_np, f)
 
-            mode_str = "baseline (no SP)" if is_baseline else f"SP (ulysses={ulysses_degree}, ring={ring_degree})"
+            if allgather_degree > 1:
+                sp_kind = f"allgather={allgather_degree}"
+            else:
+                sp_kind = f"ulysses={ulysses_degree}, ring={ring_degree}"
+            mode_str = "baseline (no SP)" if is_baseline else f"SP ({sp_kind})"
             print(
                 f"\n[{mode_str}] ✓ Saved output with shape {full_output.shape}:\n"
                 f"  - batch_size={batch_size}, seq_len={seq_len}\n"
diff --git a/tests/diffusion/attention/test_cudnn_attn.py b/tests/diffusion/attention/test_cudnn_attn.py
new file mode 100644
index 000000000..de1adf8c7
--- /dev/null
+++ b/tests/diffusion/attention/test_cudnn_attn.py
@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from contextlib import nullcontext
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.cudnn_attn import CuDNNAttentionImpl
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
+
+
+def test_cudnn_slices_valid_kv_prefix_without_padding_mask(monkeypatch):
+    observed = {}
+
+    def fake_sdpa(query, key, value, **kwargs):
+        observed.update(query=query, key=key, value=value, kwargs=kwargs)
+        return query
+
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.attention.backends.cudnn_attn.sdpa_kernel",
+        lambda _backends: nullcontext(),
+    )
+    monkeypatch.setattr(torch.nn.functional, "scaled_dot_product_attention", fake_sdpa)
+    impl = CuDNNAttentionImpl(
+        num_heads=2,
+        head_size=4,
+        softmax_scale=0.5,
+    )
+    query = torch.randn(1, 8, 2, 4)
+    key = torch.randn_like(query)
+    value = torch.randn_like(query)
+
+    output = impl.forward_cuda(
+        query,
+        key,
+        value,
+        AttentionMetadata(extra={"valid_kv_length": 5}),
+    )
+
+    assert output.shape == query.shape
+    assert observed["query"].shape == (1, 2, 8, 4)
+    assert observed["key"].shape == (1, 2, 5, 4)
+    assert observed["value"].shape == (1, 2, 5, 4)
+    assert observed["kwargs"]["attn_mask"] is None
+
+
+def test_cudnn_rejects_invalid_valid_kv_length():
+    impl = CuDNNAttentionImpl(
+        num_heads=2,
+        head_size=4,
+        softmax_scale=0.5,
+    )
+    query = torch.randn(1, 8, 2, 4)
+
+    with pytest.raises(ValueError, match="valid_kv_length"):
+        impl.forward_cuda(
+            query,
+            query,
+            query,
+            AttentionMetadata(extra={"valid_kv_length": 9}),
+        )
diff --git a/tests/diffusion/attention/test_flash_attn.py b/tests/diffusion/attention/test_flash_attn.py
index a6fcf8fcb..53673dd58 100644
--- a/tests/diffusion/attention/test_flash_attn.py
+++ b/tests/diffusion/attention/test_flash_attn.py
@@ -18,6 +18,8 @@ from vllm_omni.diffusion.attention.backends.sdpa import SDPAImpl
 from vllm_omni.diffusion.attention.backends.utils import fa  # noqa: E402
 from vllm_omni.platforms import current_omni_platform
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 is_gpu = current_omni_platform.is_cuda_alike() or current_omni_platform.is_xpu()
 HAS_FLASH_ATTN = fa.HAS_FLASH_ATTN
 flash_attn_func = fa.flash_attn_func  # noqa: N813
@@ -297,6 +299,78 @@ def test_flash_attn_func_preferred_over_varlen():
     print("✓ flash_attn_func forward works correctly!")
 
 
+def test_piecewise_flash_attn_uses_varlen_fallback(monkeypatch):
+    calls = []
+
+    def fake_varlen_func(q, k, v, **kwargs):
+        assert q.shape[1] == 4
+        assert k.shape[1] == 2
+        assert v.shape[1] == 2
+        calls.append(kwargs)
+        return q
+
+    monkeypatch.setattr(fa, "flash_attn_func", None)
+    monkeypatch.setattr(fa, "flash_attn_varlen_func", fake_varlen_func)
+    monkeypatch.setattr(fa, "HAS_FLASH_ATTN", True)
+
+    impl = FlashAttentionImpl(num_heads=4, num_kv_heads=2, head_size=4, softmax_scale=0.5, causal=False)
+    query = torch.randn(1, 3, 4, 4)
+    key = torch.randn(1, 3, 2, 4)
+    value = torch.randn(1, 3, 2, 4)
+    metadata = AttentionMetadata(full_attn_spans=[[(0, 3)]])
+
+    output = impl.forward_cuda(query, key, value, metadata)
+
+    assert output.shape == query.shape
+    assert len(calls) == 1
+    assert calls[0]["max_seqlen_q"] == 3
+    assert calls[0]["max_seqlen_k"] == 3
+    assert calls[0]["causal"] is False
+    assert calls[0]["softmax_scale"] == 0.5
+
+
+def test_packed_varlen_metadata_bypasses_mask_unpadding(monkeypatch):
+    calls = []
+
+    def fake_varlen_func(q, k, v, **kwargs):
+        calls.append((q.shape, k.shape, v.shape, kwargs))
+        return q
+
+    monkeypatch.setattr(fa, "HAS_FLASH_ATTN", True)
+    monkeypatch.setattr(fa, "flash_attn_varlen_func", fake_varlen_func)
+
+    impl = FlashAttentionImpl(num_heads=2, head_size=4, softmax_scale=0.5, causal=False)
+    query = torch.randn(1, 8, 2, 4)
+    cu_seqlens = torch.tensor([0, 6, 8], dtype=torch.int32)
+    metadata = AttentionMetadata(
+        attn_mask=torch.tensor([[True] * 6 + [False] * 2]),
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": 6,
+            "max_seqlen_k": 6,
+        },
+    )
+
+    output = impl.forward_cuda(query, query, query, metadata)
+
+    assert torch.equal(output, query)
+    assert len(calls) == 1
+    assert calls[0][0] == torch.Size([8, 2, 4])
+    assert calls[0][3]["cu_seqlens_q"] is cu_seqlens
+    assert calls[0][3]["max_seqlen_q"] == 6
+
+
+def test_packed_varlen_metadata_must_be_complete(monkeypatch):
+    monkeypatch.setattr(fa, "HAS_FLASH_ATTN", True)
+    impl = FlashAttentionImpl(num_heads=2, head_size=4, softmax_scale=0.5, causal=False)
+    query = torch.randn(1, 8, 2, 4)
+    metadata = AttentionMetadata(extra={"cu_seqlens_q": torch.tensor([0, 8], dtype=torch.int32)})
+
+    with pytest.raises(ValueError, match="Incomplete packed FlashAttention metadata"):
+        impl.forward_cuda(query, query, query, metadata)
+
+
 if __name__ == "__main__":
     print("Running FlashAttention Padding Tests...")
     print("=" * 60)
diff --git a/tests/diffusion/attention/test_piecewise_attn.py b/tests/diffusion/attention/test_piecewise_attn.py
index 656087623..05967e28f 100644
--- a/tests/diffusion/attention/test_piecewise_attn.py
+++ b/tests/diffusion/attention/test_piecewise_attn.py
@@ -19,10 +19,17 @@ import pytest
 import torch
 import torch.nn.functional as F
 
+import vllm_omni.diffusion.attention.backends.utils.piecewise_attn as piecewise_module
+from vllm_omni.diffusion.attention.backends.abstract import QueryRange
 from vllm_omni.diffusion.attention.backends.utils.piecewise_attn import (
+    Segment,
+    build_segments,
     piecewise_attn,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 DEVICE = torch.device("cpu")
 
 
@@ -71,6 +78,12 @@ BATCH_CASES = [
 ]
 
 
+def test_build_segments_full_span_retains_global_kv_end():
+    segments = build_segments([(2, 7)], query_offset=4, query_len=2)
+
+    assert segments == [Segment(q_start=4, q_end=6, kv_end=7, mode="full")]
+
+
 @pytest.mark.parametrize("global_spans", SPAN_CASES)
 @pytest.mark.parametrize("q_range", Q_RANGE_CASES)
 @pytest.mark.parametrize("batch_size", BATCH_CASES)
@@ -124,3 +137,80 @@ def test_piecewise_span_fully_before_qstart():
     )
     expected = _full_reference(query, key, value, global_spans, q_start, q_end, softmax_scale)
     torch.testing.assert_close(got, expected, atol=1e-5, rtol=1e-5)
+
+
+def test_piecewise_noncontiguous_query_ranges_match_full_mask():
+    torch.manual_seed(0)
+    B, H, D, Sk = 1, 2, 8, 8
+    key = torch.randn(B, Sk, H, D, device=DEVICE)
+    value = torch.randn(B, Sk, H, D, device=DEVICE)
+    query = torch.randn(B, 4, H, D, device=DEVICE)
+    spans = [(2, 7)]
+    query_ranges = (
+        QueryRange(0, 1, 0),
+        QueryRange(1, 4, 4),
+    )
+    softmax_scale = D**-0.5
+
+    got = piecewise_attn(
+        query,
+        key,
+        value,
+        full_attn_spans=[spans],
+        softmax_scale=softmax_scale,
+        attn_func=_sdpa_attn_func,
+        query_ranges=query_ranges,
+    )
+    expected = torch.cat(
+        [
+            _full_reference(query[:, :1], key, value, spans, 0, 1, softmax_scale),
+            _full_reference(query[:, 1:], key, value, spans, 4, 7, softmax_scale),
+        ],
+        dim=1,
+    )
+    torch.testing.assert_close(got, expected, atol=1e-5, rtol=1e-5)
+
+
+def test_piecewise_rejects_incomplete_query_ranges():
+    query = torch.zeros(1, 3, 1, 2)
+    key = torch.zeros(1, 3, 1, 2)
+    value = torch.zeros_like(key)
+
+    with pytest.raises(ValueError, match="cover local query contiguously"):
+        piecewise_attn(
+            query,
+            key,
+            value,
+            full_attn_spans=[[]],
+            softmax_scale=1.0,
+            attn_func=_sdpa_attn_func,
+            query_ranges=(QueryRange(1, 3, 1),),
+        )
+
+
+def test_piecewise_combines_noncontiguous_query_ranges_with_one_cat(monkeypatch):
+    query = torch.randn(1, 4, 2, 8)
+    key = torch.randn(1, 8, 2, 8)
+    value = torch.randn_like(key)
+    cat_calls = 0
+    original_cat = torch.cat
+
+    def counted_cat(tensors, dim=0):
+        nonlocal cat_calls
+        cat_calls += 1
+        return original_cat(tensors, dim=dim)
+
+    monkeypatch.setattr(piecewise_module.torch, "cat", counted_cat)
+
+    output = piecewise_attn(
+        query,
+        key,
+        value,
+        full_attn_spans=[[(0, 8)]],
+        softmax_scale=1.0,
+        attn_func=lambda q, k, v, **kwargs: q,
+        query_ranges=(QueryRange(0, 1, 0), QueryRange(1, 4, 4)),
+    )
+
+    assert cat_calls == 1
+    torch.testing.assert_close(output, query)
diff --git a/tests/diffusion/attention/test_rainfusion_plan.py b/tests/diffusion/attention/test_rainfusion_plan.py
new file mode 100644
index 000000000..e88a973a9
--- /dev/null
+++ b/tests/diffusion/attention/test_rainfusion_plan.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Geometry contract RAINFUSION_ATTN enforces before handing a forward to rf_v2.
+
+The grids here are the ones MiniMax-H3 FL2VA actually produces for an 8.7s clip:
+1280x768 gives a 62x24x40 latent grid whose 59520 video rows land on the 128-row
+kernel block, and 1344x768 gives 62x24x42 whose 62496 rows straddle it. Only the
+first can run sparse: rf_v2 tiles the sequence as a whole but pools its block
+mask from the video and prefix segments separately, so the two only agree on the
+block count when the video segment ends on a boundary.
+"""
+
+import dataclasses
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata, VideoTokenLayout
+from vllm_omni.diffusion.attention.backends.rainfusion_attn import (
+    _BLOCK_SIZE,
+    RainFusionAttentionImpl,
+    RainFusionPlan,
+)
+from vllm_omni.platforms import current_omni_platform
+
+PREFIX_ROWS = 710  # 14 text rows + 696 audio rows
+ALIGNED_GRID = (62, 24, 40)  # 1280x768 -> 59520 video rows, 465 blocks
+MISALIGNED_GRID = (62, 24, 42)  # 1344x768 -> 62496 video rows, 488 blocks + 32 rows
+
+
+def make_impl(**backend_kwargs):
+    return RainFusionAttentionImpl(
+        num_heads=8,
+        head_size=128,
+        softmax_scale=128**-0.5,
+        prefix="transformer_blocks.0.attn",
+        qkv_layout="BSND",
+        backend_kwargs={"sparsity": 0.8, **backend_kwargs},
+    )
+
+
+def make_metadata(grid, prefix_len=PREFIX_ROWS, max_seqlen_q=None):
+    video_rows = grid[0] * grid[1] * grid[2]
+    return AttentionMetadata(
+        extra={"max_seqlen_q": prefix_len + video_rows if max_seqlen_q is None else max_seqlen_q},
+        video_layout=VideoTokenLayout(prefix_len=prefix_len, latent_grid=grid),
+    )
+
+
+def test_block_aligned_video_segment_runs_sparse():
+    plan = make_impl()._resolve_plan(make_metadata(ALIGNED_GRID))
+
+    assert plan is not None
+    assert plan.prefix_len == PREFIX_ROWS
+    assert plan.used_len == PREFIX_ROWS + 59520
+    assert plan.latent_shape == list(ALIGNED_GRID)
+
+
+def test_misaligned_video_segment_stays_dense():
+    # Realigning the sequence would mean padding it, and rf_v2 ignores attn_mask:
+    # pad keys would take a share of every real query's softmax denominator.
+    assert make_impl()._resolve_plan(make_metadata(MISALIGNED_GRID)) is None
+
+
+@pytest.mark.parametrize("prefix_len", [1, 127, _BLOCK_SIZE, 710, 900])
+def test_prefix_length_does_not_affect_alignment(prefix_len):
+    # Only the video segment has to land on a block boundary; rf_v2 pools the
+    # prefix separately and keeps every one of its blocks.
+    plan = make_impl()._resolve_plan(make_metadata(ALIGNED_GRID, prefix_len=prefix_len))
+
+    assert plan is not None
+    assert plan.prefix_len == prefix_len
+
+
+def test_sparsity_zero_never_resolves_a_plan():
+    assert make_impl(sparsity=0.0)._resolve_plan(make_metadata(ALIGNED_GRID)) is None
+
+
+def test_missing_video_layout_falls_back_to_dense():
+    assert make_impl()._resolve_plan(AttentionMetadata(extra={"max_seqlen_q": 60230})) is None
+
+
+def test_missing_max_seqlen_falls_back_to_dense():
+    metadata = AttentionMetadata(
+        video_layout=VideoTokenLayout(prefix_len=PREFIX_ROWS, latent_grid=ALIGNED_GRID),
+    )
+
+    assert make_impl()._resolve_plan(metadata) is None
+
+
+def test_video_segment_must_be_the_tail_of_packed_document_zero():
+    metadata = make_metadata(ALIGNED_GRID, max_seqlen_q=PREFIX_ROWS + 59520 + 128)
+
+    assert make_impl()._resolve_plan(metadata) is None
+
+
+@pytest.mark.parametrize("grid", [(4, 24, 40), (1, 24, 40)])
+def test_short_video_stays_dense(grid):
+    assert make_impl()._resolve_plan(make_metadata(grid)) is None
+
+
+@pytest.mark.parametrize("qkv_layout", ["BNSD", "BSH"])
+def test_explicitly_wrong_layout_is_rejected(qkv_layout):
+    with pytest.raises(ValueError, match="BSND"):
+        RainFusionAttentionImpl(
+            num_heads=8,
+            head_size=128,
+            softmax_scale=128**-0.5,
+            qkv_layout=qkv_layout,
+            backend_kwargs={"sparsity": 0.8},
+        )
+
+
+def test_undeclared_layout_stays_dense():
+    # An undeclared layout is not an error -- the layer keeps working, just
+    # densely, and the fallback sees the same absent layout plain FLASH_ATTN would.
+    impl = RainFusionAttentionImpl(
+        num_heads=8,
+        head_size=128,
+        softmax_scale=128**-0.5,
+        prefix="transformer_blocks.0.attn",
+        backend_kwargs={"sparsity": 0.8},
+    )
+
+    assert impl._resolve_plan(make_metadata(ALIGNED_GRID)) is None
+    assert impl.dense_fallback.qkv_layout is None
+
+
+@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="rf_v2 runs on Ascend NPU only.")
+def test_fully_populated_mask_reproduces_dense_attention():
+    """At sparsity=0 every key block is kept, so rf_v2 must match dense attention.
+
+    This is the guard on the geometry the backend hands the kernel: a wrong
+    prefix length or latent grid still produces plausible output under sparse
+    selection, but shows up here as a mismatch against SDPA.
+    """
+    torch.manual_seed(0)
+    prefix_len, grid = 384, (4, 16, 64)  # 4096 video rows = 32 blocks
+    video_len = grid[0] * grid[1] * grid[2]
+    used = prefix_len + video_len
+    heads, head_dim = 4, 128
+    q, k, v = (torch.randn(1, used, heads, head_dim, dtype=torch.bfloat16, device="npu") for _ in range(3))
+
+    impl = make_impl()
+    impl.rainfusion = dataclasses.replace(impl.rainfusion, sparsity=0.0)
+    plan = RainFusionPlan(prefix_len=prefix_len, used_len=used, latent_shape=list(grid))
+    out = impl._forward_sparse_npu(q, k, v, plan)
+
+    reference = torch.nn.functional.scaled_dot_product_attention(
+        q.transpose(1, 2),
+        k.transpose(1, 2),
+        v.transpose(1, 2),
+        scale=impl.softmax_scale,
+    ).transpose(1, 2)
+    error = (out.float() - reference.float()).abs().mean() / reference.float().abs().mean()
+    assert error < 2e-3, f"mean relative error {error:.4%} against dense attention"
diff --git a/tests/diffusion/attention/test_ring_fa4.py b/tests/diffusion/attention/test_ring_fa4.py
new file mode 100644
index 000000000..b24ce2f20
--- /dev/null
+++ b/tests/diffusion/attention/test_ring_fa4.py
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends.ring import ring_kernels
+from vllm_omni.diffusion.attention.backends.ring.ring_selector import AttnType
+from vllm_omni.diffusion.attention.parallel import ring as ring_parallel
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_fa4_wrapper_returns_lse_and_normalizes_unbounded_window(monkeypatch):
+    expected_out = object()
+    expected_lse = object()
+    captured = {}
+
+    def fake_fa4(q, k, v, **kwargs):
+        captured.update(q=q, k=k, v=v, **kwargs)
+        return expected_out, expected_lse
+
+    monkeypatch.setattr(ring_kernels, "HAS_FA4", True)
+    monkeypatch.setattr(ring_kernels, "fa4_attn_func", fake_fa4)
+
+    out, lse = ring_kernels.flash_attn4_func_forward(
+        "q",
+        "k",
+        "v",
+        softmax_scale=0.125,
+        causal=True,
+        window_size=(-1, -1),
+    )
+
+    assert (out, lse) == (expected_out, expected_lse)
+    assert captured == {
+        "q": "q",
+        "k": "k",
+        "v": "v",
+        "softmax_scale": 0.125,
+        "causal": True,
+        "window_size": (None, None),
+        "softcap": 0.0,
+        "return_lse": True,
+    }
+
+
+def test_ring_prefers_fa4_on_blackwell(monkeypatch):
+    captured = {}
+
+    def fake_ring_flash_attn_func(*args, **kwargs):
+        captured.update(kwargs)
+        return "output"
+
+    monkeypatch.setattr(ring_parallel, "HAS_FA4", True)
+    monkeypatch.setattr(ring_parallel, "HAS_FA3", True)
+    monkeypatch.setattr(torch.cuda, "get_device_capability", lambda _device: (10, 3))
+
+    from vllm_omni.diffusion.attention.backends import ring_flash_attn
+
+    monkeypatch.setattr(ring_flash_attn, "ring_flash_attn_func", fake_ring_flash_attn_func)
+
+    query = SimpleNamespace(
+        dtype=torch.bfloat16,
+        shape=(1, 16, 4, 128),
+        is_cuda=True,
+        device=torch.device("cuda:0"),
+    )
+    strategy = ring_parallel.RingParallelAttention(SimpleNamespace(ring_group=object()))
+
+    assert strategy.run_attention(query, "key", "value", None) == "output"
+    assert captured["attn_type"] is AttnType.FA4
diff --git a/tests/diffusion/attention/test_sage_attn3.py b/tests/diffusion/attention/test_sage_attn3.py
index e4d913974..5c46ea5d0 100644
--- a/tests/diffusion/attention/test_sage_attn3.py
+++ b/tests/diffusion/attention/test_sage_attn3.py
@@ -9,6 +9,9 @@ import pytest
 import torch
 from vllm.platforms import current_platform
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 SAGE_ATTN3_MODULE = "vllm_omni.diffusion.attention.backends.sage_attn3"
 
 
diff --git a/tests/diffusion/attention/test_sdpa.py b/tests/diffusion/attention/test_sdpa.py
new file mode 100644
index 000000000..d02642517
--- /dev/null
+++ b/tests/diffusion/attention/test_sdpa.py
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+
+import vllm_omni.diffusion.attention.backends.sdpa as sdpa_backend
+from vllm_omni.diffusion.attention.backends.sdpa import SDPAImpl
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_sdpa_expands_kv_when_native_gqa_kernel_is_unavailable(monkeypatch):
+    calls = []
+
+    def fake_sdpa(query, key, value, **kwargs):
+        calls.append((query.shape, key.shape, value.shape, kwargs))
+        return query
+
+    monkeypatch.setattr(sdpa_backend, "can_sdpa_use_fused_gqa", lambda *args: False)
+    monkeypatch.setattr(torch.nn.functional, "scaled_dot_product_attention", fake_sdpa)
+
+    impl = SDPAImpl(num_heads=4, num_kv_heads=2, head_size=8, softmax_scale=0.5)
+    output = impl.forward_cuda(
+        torch.randn(1, 3, 4, 8),
+        torch.randn(1, 3, 2, 8),
+        torch.randn(1, 3, 2, 8),
+    )
+
+    query_shape, key_shape, value_shape, kwargs = calls[0]
+    assert query_shape == key_shape == value_shape == (1, 4, 3, 8)
+    assert kwargs["enable_gqa"] is False
+    assert output.shape == (1, 3, 4, 8)
+
+
+def test_sdpa_keeps_compressed_kv_when_native_gqa_kernel_is_available(monkeypatch):
+    calls = []
+
+    def fake_sdpa(query, key, value, **kwargs):
+        calls.append((query.shape, key.shape, value.shape, kwargs))
+        return query
+
+    monkeypatch.setattr(sdpa_backend, "can_sdpa_use_fused_gqa", lambda *args: True)
+    monkeypatch.setattr(torch.nn.functional, "scaled_dot_product_attention", fake_sdpa)
+
+    impl = SDPAImpl(num_heads=4, num_kv_heads=2, head_size=8, softmax_scale=0.5)
+    output = impl.forward_cuda(
+        torch.randn(1, 3, 4, 8),
+        torch.randn(1, 3, 2, 8),
+        torch.randn(1, 3, 2, 8),
+    )
+
+    query_shape, key_shape, value_shape, kwargs = calls[0]
+    assert query_shape == (1, 4, 3, 8)
+    assert key_shape == value_shape == (1, 2, 3, 8)
+    assert kwargs["enable_gqa"] is True
+    assert output.shape == (1, 3, 4, 8)
diff --git a/tests/diffusion/attention/test_selector.py b/tests/diffusion/attention/test_selector.py
new file mode 100644
index 000000000..79755ac2e
--- /dev/null
+++ b/tests/diffusion/attention/test_selector.py
@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for diffusion attention backend selection."""
+
+from types import SimpleNamespace
+
+import pytest
+
+import vllm_omni.diffusion.attention.selector as selector
+from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+class _ConfiguredBackend:
+    @classmethod
+    def get_name(cls) -> str:
+        return "CONFIGURED"
+
+
+class _PlatformBackend:
+    @classmethod
+    def get_name(cls) -> str:
+        return "PLATFORM"
+
+
+@pytest.fixture(autouse=True)
+def clear_selector_caches():
+    selector._cached_get_backend_cls.cache_clear()
+    selector._log_backend_resolution.cache_clear()
+    yield
+    selector._cached_get_backend_cls.cache_clear()
+    selector._log_backend_resolution.cache_clear()
+
+
+@pytest.mark.parametrize(
+    ("role", "role_category", "expected_backend"),
+    [
+        ("ltx2.audio_to_video", "cross", "EXACT"),
+        ("ltx2.video_to_audio", "cross", "CATEGORY"),
+        ("joint", None, "DEFAULT"),
+    ],
+)
+def test_configured_selection_precedence(
+    monkeypatch,
+    role: str,
+    role_category: str | None,
+    expected_backend: str,
+):
+    config = AttentionConfig(
+        default=AttentionSpec(backend="DEFAULT"),
+        per_role={
+            "cross": AttentionSpec(backend="CATEGORY"),
+            "ltx2.audio_to_video": AttentionSpec(backend="EXACT"),
+        },
+    )
+    calls = []
+
+    def fake_get_backend(backend_name, head_size, allow_trtllm_default=True):
+        calls.append((backend_name, head_size, allow_trtllm_default))
+        return _ConfiguredBackend
+
+    monkeypatch.setattr(selector, "_cached_get_backend_cls", fake_get_backend)
+
+    backend, spec = selector.get_attn_backend_for_role(
+        role=role,
+        role_category=role_category,
+        head_size=128,
+        attention_config=config,
+    )
+
+    assert backend is _ConfiguredBackend
+    assert spec is not None
+    assert spec.backend == expected_backend
+    assert calls == [(expected_backend, 128, True)]
+
+
+@pytest.mark.parametrize("attention_config", [None, AttentionConfig()])
+def test_platform_default_used_without_resolved_spec(monkeypatch, attention_config):
+    calls = []
+
+    def fake_get_backend(backend_name, head_size, allow_trtllm_default=True):
+        calls.append((backend_name, head_size, allow_trtllm_default))
+        return _PlatformBackend
+
+    monkeypatch.setattr(selector, "_cached_get_backend_cls", fake_get_backend)
+
+    backend, spec = selector.get_attn_backend_for_role(
+        role="self",
+        head_size=64,
+        attention_config=attention_config,
+        allow_trtllm_default=False,
+    )
+
+    assert backend is _PlatformBackend
+    assert spec is None
+    assert calls == [(None, 64, False)]
+
+
+def test_backend_class_resolution_is_cached(monkeypatch):
+    platform_calls = []
+    load_calls = []
+    fake_platform = SimpleNamespace(
+        get_diffusion_attn_backend_cls=lambda **kwargs: (platform_calls.append(kwargs) or "fake.module.Backend")
+    )
+
+    monkeypatch.setattr("vllm_omni.platforms.current_omni_platform", fake_platform)
+
+    def fake_load_backend(path):
+        load_calls.append(path)
+        return _ConfiguredBackend
+
+    monkeypatch.setattr(selector, "_load_backend_cls", fake_load_backend)
+
+    first = selector._cached_get_backend_cls("FLASH_ATTN", 128, False)
+    second = selector._cached_get_backend_cls("FLASH_ATTN", 128, False)
+
+    assert first is second is _ConfiguredBackend
+    assert platform_calls == [
+        {
+            "selected_backend": "FLASH_ATTN",
+            "head_size": 128,
+            "allow_trtllm_default": False,
+        }
+    ]
+    assert load_calls == ["fake.module.Backend"]
+
+
+def test_load_backend_cls_reports_missing_module():
+    with pytest.raises(ImportError, match="Failed to import module missing_attention_backend"):
+        selector._load_backend_cls("missing_attention_backend.Backend")
+
+
+def test_load_backend_cls_reports_missing_class(monkeypatch):
+    monkeypatch.setattr(selector.importlib, "import_module", lambda _: SimpleNamespace())
+
+    with pytest.raises(AttributeError, match="Class MissingBackend not found in module"):
+        selector._load_backend_cls("fake.module.MissingBackend")
diff --git a/tests/diffusion/attention/test_trtllm_attn.py b/tests/diffusion/attention/test_trtllm_attn.py
new file mode 100644
index 000000000..76daf9d3b
--- /dev/null
+++ b/tests/diffusion/attention/test_trtllm_attn.py
@@ -0,0 +1,577 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import math
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from vllm_omni.diffusion.attention.backends import trtllm_attn as tg
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.trtllm_attn import TrtllmAttentionImpl
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cuda]
+
+
+def _has_trtllm_attn() -> bool:
+    if not torch.cuda.is_available():
+        return False
+    if torch.cuda.get_device_capability()[0] < 10:
+        return False
+    try:
+        import flashinfer  # noqa: F401
+    except Exception:
+        return False
+    return tg.HAS_FLASHINFER
+
+
+requires_trtllm_attn = pytest.mark.skipif(
+    not _has_trtllm_attn(), reason="requires Blackwell SM100+ GPU with flashinfer"
+)
+
+
+def _impl(**bk):
+    return TrtllmAttentionImpl(8, 128, 1.0 / math.sqrt(128), causal=False, num_kv_heads=8, backend_kwargs=bk)
+
+
+def test_skip_config_pure_resolution():
+    from vllm_omni.diffusion.attention.backends.trtllm_attn import SkipSoftmaxConfig
+
+    assert not SkipSoftmaxConfig().enabled
+    assert SkipSoftmaxConfig().resolve_factor(4096, timestep=0.3) is None
+
+    cfg = SkipSoftmaxConfig.from_backend_kwargs({"skip_softmax_threshold": 0.01, "disabled_until_timestep": 0.6})
+    assert cfg.enabled and cfg.gated
+    assert cfg.resolve_factor(4096, timestep=0.9) is None
+    assert cfg.resolve_factor(4096, timestep=0.3) == pytest.approx(0.01 * 4096)
+    assert cfg.resolve_factor(4096, timestep=None) == pytest.approx(0.01 * 4096)
+
+
+def test_quant_config_from_backend_kwargs():
+    from vllm_omni.diffusion.attention.backends.trtllm_attn import QuantConfig
+
+    assert not QuantConfig.from_backend_kwargs(None).enabled
+    assert not QuantConfig.from_backend_kwargs({}).enabled
+    assert QuantConfig.from_backend_kwargs({"quant": {"dtype_qk": "fp8_e4m3"}}) == QuantConfig("fp8_e4m3", 1, 16)
+    qc = QuantConfig.from_backend_kwargs({"quant": {"dtype_qk": "int8", "q_block_size": 4, "k_block_size": 16}})
+    assert qc.enabled and (qc.dtype_qk, qc.q_block_size, qc.k_block_size) == ("int8", 4, 16)
+
+
+def test_quant_rejects_non_sage_dtype():
+    with pytest.raises(RuntimeError, match="supports dtype_qk"):
+        _impl(quant={"dtype_qk": "bfloat16"})
+
+
+def test_quant_quantize_requires_flashinfer_routine(monkeypatch):
+    import vllm_omni.diffusion.attention.backends.trtllm_attn as mod
+
+    monkeypatch.setattr(mod, "_sage_kernel_available", lambda: True)
+    monkeypatch.setattr(mod, "_sage_quantize_fn", lambda: None)
+    with pytest.raises(RuntimeError, match="trtllm_sage_attention_quantize"):
+        _impl(quant={"dtype_qk": "int8"})
+
+
+def test_quant_quantize_calls_routine_and_shapes_sfs():
+    from vllm_omni.diffusion.attention.backends.trtllm_attn import QuantConfig
+
+    captured = {}
+
+    def fake_quantize(q, k, v, q_block_size, k_block_size, qk_quant_dtype):
+        captured.update(q_block_size=q_block_size, k_block_size=k_block_size, qk_quant_dtype=qk_quant_dtype)
+        return "qq", "kq", "vq", "qsfs", "ksfs", "vsfs"
+
+    q_q, k_q, v_q, sfs, blk = QuantConfig(dtype_qk="int8").quantize(object(), object(), object(), fake_quantize)
+    assert (q_q, k_q, v_q, sfs, blk) == ("qq", "kq", "vq", ("qsfs", "ksfs", None, "vsfs"), (1, 16, 0, 1))
+    assert captured == {"q_block_size": 1, "k_block_size": 16, "qk_quant_dtype": torch.int8}
+
+
+def test_skip_factor_none_without_curve():
+    assert _impl(target_sparsity=0.5)._resolve_skip_factor(4096) is None
+
+
+def _calibrated(a, b, **bk):
+    impl = _impl(**bk)
+    impl.set_layer_calibration(a, b)
+    return impl
+
+
+def test_skip_factor_from_curve():
+    assert _calibrated(100.0, 0.0, target_sparsity=0.5)._resolve_skip_factor(4096) == pytest.approx(100.0)
+    f2 = _calibrated(2.0, 1.0, target_sparsity=0.5)._resolve_skip_factor(4096)
+    assert f2 == pytest.approx(2.0 * math.exp(0.5))
+
+
+def test_skip_factor_none_until_stamped():
+    assert _impl(target_sparsity=0.5)._resolve_skip_factor(4096) is None
+
+
+def test_skip_factor_from_threshold_no_calibration():
+    impl = _impl(skip_softmax_threshold=0.01)
+    assert impl._resolve_skip_factor(4096) == pytest.approx(0.01 * 4096)
+    assert impl._resolve_skip_factor(8192) == pytest.approx(0.01 * 8192)
+
+    impl2 = _calibrated(100.0, 0.0, skip_softmax_threshold=0.02, target_sparsity=0.5)
+    assert impl2._resolve_skip_factor(4096) == pytest.approx(0.02 * 4096)
+
+
+def test_skip_timestep_gate(monkeypatch):
+    from vllm_omni.diffusion import forward_context as fc
+
+    impl = _calibrated(100.0, 0.0, target_sparsity=0.5, disabled_until_timestep=0.6)
+    ctx = fc.ForwardContext(denoise_timestep=0.9)
+    monkeypatch.setattr(fc, "_forward_context", ctx)
+    assert impl._resolve_skip_factor(4096) is None
+    ctx.denoise_timestep = 0.3
+    assert impl._resolve_skip_factor(4096) == pytest.approx(100.0)
+
+
+def test_denoise_progress_mixin(monkeypatch):
+    import types
+
+    from vllm_omni.diffusion import forward_context as fc
+
+    class _Pipe(fc.DenoiseProgressMixin):
+        scheduler = types.SimpleNamespace(config=types.SimpleNamespace(num_train_timesteps=1000))
+
+    ctx = fc.ForwardContext()
+    monkeypatch.setattr(fc, "_forward_context", ctx)
+    _Pipe().record_denoise_step(3, 250)
+    assert ctx.denoise_step_idx == 3
+    assert ctx.denoise_timestep == pytest.approx(0.25)
+
+    _Pipe().record_denoise_step(4)
+    assert ctx.denoise_step_idx == 4 and ctx.denoise_timestep == pytest.approx(0.25)
+
+    _Pipe().record_denoise_step(5, normalized_timestep=0.7)
+    assert ctx.denoise_step_idx == 5 and ctx.denoise_timestep == pytest.approx(0.7)
+
+
+@pytest.mark.parametrize(
+    "bk, field",
+    [
+        ({"target_sparsity": 1.5}, "target_sparsity"),
+        ({"target_sparsity": -0.1}, "target_sparsity"),
+        ({"disabled_until_timestep": 1.2}, "disabled_until_timestep"),
+        ({"skip_softmax_threshold": -1.0}, "skip_softmax_threshold"),
+        ({"target_sparsity": float("nan")}, "target_sparsity"),
+        ({"skip_softmax_threshold": float("inf")}, "skip_softmax_threshold"),
+    ],
+)
+def test_skip_control_validation_rejects_out_of_range(bk, field):
+    from vllm_omni.diffusion.attention.backends.trtllm_attn import SkipSoftmaxConfig
+
+    with pytest.raises(ValueError, match=field):
+        SkipSoftmaxConfig.from_backend_kwargs(bk)
+
+
+def test_skip_control_validation_accepts_valid():
+    from vllm_omni.diffusion.attention.backends.trtllm_attn import SkipSoftmaxConfig
+
+    cfg = SkipSoftmaxConfig.from_backend_kwargs(
+        {"target_sparsity": 0.65, "disabled_until_timestep": 0.86, "skip_softmax_threshold": 0.01}
+    )
+    assert cfg.target_sparsity == pytest.approx(0.65)
+    assert cfg.disabled_until_timestep == pytest.approx(0.86)
+    assert cfg.threshold == pytest.approx(0.01)
+
+
+def test_ring_sp_with_skip_softmax_rejected():
+    import types
+
+    from vllm_omni.diffusion.attention.layer import Attention
+
+    fake = types.SimpleNamespace(attention=_impl(target_sparsity=0.5), ring_runner=None)
+    with pytest.raises(NotImplementedError, match="ring sequence parallelism"):
+        Attention._run_ring_attention(fake, None, None, None, None)
+
+
+def test_mask_free_allowlist_gates_trtllm_default():
+    from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata as meta
+
+    assert meta("WanPipeline").attention_mask_free is True
+    assert meta("WanVACEPipeline").attention_mask_free is True
+    assert meta("MiniMaxH3Pipeline").attention_mask_free is True
+    assert meta("FluxPipeline").attention_mask_free is False
+    assert meta(None).attention_mask_free is False
+
+
+def test_masked_layer_raises():
+    b, s, h, d = 1, 8, 8, 128
+    q, k, v = (torch.zeros(b, s, h, d) for _ in range(3))
+    mask = torch.ones(b, s, dtype=torch.bool)
+    mask[:, s // 2 :] = False
+
+    class _Meta:
+        attn_mask = mask
+
+    with pytest.raises(ValueError, match="does not support attn_mask"):
+        _impl().forward_cuda(q, k, v, _Meta())
+
+
+def test_packed_metadata_trims_padding_mask(monkeypatch):
+    b, s, h, d = 1, 8, 8, 128
+    q, k, v = (torch.zeros(b, s, h, d) for _ in range(3))
+    mask = torch.tensor([[True, True, True, True, True, True, False, False]])
+    cu_seqlens = torch.tensor([0, 6, 8], dtype=torch.int32)
+    metadata = AttentionMetadata(
+        attn_mask=mask,
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": 6,
+            "max_seqlen_k": 6,
+        },
+    )
+    captured = {}
+
+    def fake_attention(**kwargs):
+        captured.update(kwargs)
+        return torch.zeros_like(kwargs["query"])
+
+    monkeypatch.setattr(tg, "HAS_FLASHINFER", True)
+    monkeypatch.setattr(tg, "trtllm_ragged_attention_deepseek", fake_attention)
+    monkeypatch.setattr(TrtllmAttentionImpl, "_get_workspace", classmethod(lambda cls, device: torch.empty(0)))
+
+    out = _impl().forward_cuda(q, k, v, metadata)
+
+    assert out.shape == q.shape
+    assert captured["query"].shape[0] == 6
+    assert captured["key"].shape[0] == 6
+    assert captured["value"].shape[0] == 6
+    assert captured["batch_size"] == 1
+    assert captured["seq_lens"].tolist() == [6]
+    assert captured["cum_seq_lens_q"].tolist() == [0, 6]
+    assert captured["cum_seq_lens_kv"].tolist() == [0, 6]
+    assert captured["max_q_len"] == 6
+    assert captured["max_kv_len"] == 6
+    assert torch.count_nonzero(out[:, 6:]) == 0
+
+
+def test_packed_metadata_rejects_non_prefix_mask(monkeypatch):
+    b, s, h, d = 1, 8, 8, 128
+    q, k, v = (torch.zeros(b, s, h, d) for _ in range(3))
+    cu_seqlens = torch.tensor([0, 6, 8], dtype=torch.int32)
+    metadata = AttentionMetadata(
+        attn_mask=torch.tensor([[True, True, False, True, True, True, False, False]]),
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": 6,
+            "max_seqlen_k": 6,
+        },
+    )
+    monkeypatch.setattr(tg, "HAS_FLASHINFER", True)
+
+    with pytest.raises(ValueError, match="prefix-valid"):
+        _impl().forward_cuda(q, k, v, metadata)
+
+
+def test_packed_metadata_must_be_complete():
+    b, s, h, d = 1, 8, 8, 128
+    q, k, v = (torch.zeros(b, s, h, d) for _ in range(3))
+    metadata = AttentionMetadata(extra={"cu_seqlens_q": torch.tensor([0, s], dtype=torch.int32)})
+
+    with pytest.raises(ValueError, match="Incomplete packed TRTLLM attention metadata"):
+        _impl().forward_cuda(q, k, v, metadata)
+
+
+def test_packed_metadata_must_cover_inputs(monkeypatch):
+    b, s, h, d = 1, 8, 8, 128
+    q, k, v = (torch.zeros(b, s, h, d) for _ in range(3))
+    cu_seqlens = torch.tensor([0, 6], dtype=torch.int32)
+    metadata = AttentionMetadata(
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": 6,
+            "max_seqlen_k": 6,
+        }
+    )
+    monkeypatch.setattr(tg, "HAS_FLASHINFER", True)
+
+    with pytest.raises(ValueError, match="must cover all Q/K/V tokens"):
+        _impl().forward_cuda(q, k, v, metadata)
+
+
+def test_propagate_calibration_045_schema(monkeypatch):
+    import types
+
+    from vllm_omni.diffusion.data import (
+        AttentionConfig,
+        AttentionSpec,
+        OmniDiffusionConfig,
+        TransformerConfig,
+    )
+
+    cfg = AttentionConfig(default=AttentionSpec(backend="TRTLLM_ATTN"))
+    tf = TransformerConfig.from_dict(
+        {
+            "sparse_attention_config": {
+                "config_groups": {
+                    "group_0": {
+                        "algorithm": "skip_softmax",
+                        "targets": ["WanAttention"],
+                        "ignore": ["blocks.0.attn2", "blocks.1.attn2"],
+                        "threshold_scale_factor": {
+                            "formula": "a * exp(b * target_sparsity)",
+                            "coefficients": {"a": 2142.7, "b": 4.28},
+                        },
+                        "target_sparsity": 0.5,
+                    }
+                }
+            }
+        }
+    )
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.attention.backends.trtllm_calibration.parse_secondary_expert_calibration",
+        lambda *a, **k: None,
+    )
+    OmniDiffusionConfig._propagate_skip_softmax_calibration(
+        types.SimpleNamespace(
+            diffusion_attention_config=cfg,
+            model="/x",
+        ),
+        tf,
+    )
+    spec, _ = cfg.resolve_with_source("self")
+    cal = spec.skip_calibration["by_expert"]["transformer"]
+    assert cal["a"] == pytest.approx(2142.7)
+    assert cal["b"] == pytest.approx(4.28)
+    assert cal["ignore"] == ["blocks.0.attn2", "blocks.1.attn2"]
+    assert "transformer_2" not in spec.skip_calibration["by_expert"]
+
+
+def test_target_sparsity_without_calibration_raises():
+    import types
+
+    from vllm_omni.diffusion.data import (
+        AttentionConfig,
+        AttentionSpec,
+        OmniDiffusionConfig,
+        TransformerConfig,
+    )
+
+    def _cfg(skip_softmax):
+        return types.SimpleNamespace(
+            diffusion_attention_config=AttentionConfig(
+                default=AttentionSpec(backend="TRTLLM_ATTN", skip_softmax=skip_softmax)
+            ),
+            model="/models/no-such-calibration",
+        )
+
+    with pytest.raises(ValueError, match="no skip-softmax calibration"):
+        OmniDiffusionConfig._propagate_skip_softmax_calibration(
+            _cfg({"target_sparsity": 0.5}), TransformerConfig.from_dict({})
+        )
+
+    OmniDiffusionConfig._propagate_skip_softmax_calibration(_cfg({"threshold": 0.02}), TransformerConfig.from_dict({}))
+
+
+def _sdpa_ref(q, k, v, scale):
+    qp, kp, vp = (x.permute(0, 2, 1, 3) for x in (q, k, v))
+    return F.scaled_dot_product_attention(qp, kp, vp, is_causal=False, scale=scale).permute(0, 2, 1, 3).float()
+
+
+@requires_trtllm_attn
+def test_bf16_dense_matches_sdpa():
+    torch.manual_seed(0)
+    B, S, H, D = 2, 256, 8, 128
+    scale = 1.0 / math.sqrt(D)
+    q, k, v = (torch.randn(B, S, H, D, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+    out = _impl().forward_cuda(q, k, v, None).float()
+    ref = _sdpa_ref(q, k, v, scale)
+    rel = (out - ref).abs().mean() / ref.abs().mean()
+    assert rel < 0.01, f"BF16 dense rel err {rel:.4f} too high"
+
+
+@requires_trtllm_attn
+def test_bf16_packed_padding_matches_sdpa():
+    torch.manual_seed(0)
+    b, s, used, h, d = 1, 256, 192, 8, 128
+    scale = 1.0 / math.sqrt(d)
+    q, k, v = (torch.randn(b, s, h, d, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+    cu_seqlens = torch.tensor([0, used, s], dtype=torch.int32, device="cuda")
+    metadata = AttentionMetadata(
+        attn_mask=torch.arange(s, device="cuda")[None] < used,
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": used,
+            "max_seqlen_k": used,
+        },
+    )
+
+    out = _impl().forward_cuda(q, k, v, metadata).float()
+    ref_used = _sdpa_ref(q[:, :used], k[:, :used], v[:, :used], scale)
+    used_rel = (out[:, :used] - ref_used).abs().mean() / ref_used.abs().mean()
+    assert used_rel < 0.01, f"BF16 packed valid-token rel err {used_rel:.4f} too high"
+    assert torch.count_nonzero(out[:, used:]) == 0
+
+
+requires_sage = pytest.mark.skipif(
+    not (_has_trtllm_attn() and tg._sage_quantize_fn() is not None),
+    reason="requires Blackwell SM100+ GPU with flashinfer >= 0.6.16rc1 (trtllm_sage_attention_quantize)",
+)
+
+
+@requires_sage
+@pytest.mark.parametrize("dtype_qk", ["fp8_e4m3", "int8"])
+def test_sage_quant_matches_sdpa(dtype_qk):
+    torch.manual_seed(0)
+    B, S, H, D = 2, 256, 8, 128
+    scale = 1.0 / math.sqrt(D)
+    q, k, v = (torch.randn(B, S, H, D, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+    impl = _impl(quant={"dtype_qk": dtype_qk, "q_block_size": 1, "k_block_size": 16})
+    try:
+        out = impl.forward_cuda(q, k, v, None)
+    except RuntimeError as e:  # pragma: no cover - arch-dependent (int8 is SM100-only)
+        if "Missing TRTLLM-GEN kernel" in str(e):
+            pytest.skip(f"no trtllm-gen SAGE kernel for dtype_qk={dtype_qk} on this GPU arch")
+        raise
+    assert out.shape == (B, S, H, D) and torch.isfinite(out).all()
+    ref = _sdpa_ref(q, k, v, scale)
+    rel = (out.float() - ref).abs().mean() / ref.abs().mean()
+    assert rel < 0.1, f"SAGE({dtype_qk}) rel err {rel:.4f} too high"
+
+
+@requires_sage
+def test_sage_packed_non_aligned_length_matches_sdpa():
+    torch.manual_seed(0)
+    b, s, used, h, d = 1, 208, 194, 8, 128
+    scale = 1.0 / math.sqrt(d)
+    q, k, v = (torch.randn(b, s, h, d, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+    cu_seqlens = torch.tensor([0, used, s], dtype=torch.int32, device="cuda")
+    metadata = AttentionMetadata(
+        attn_mask=torch.arange(s, device="cuda")[None] < used,
+        extra={
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_k": cu_seqlens,
+            "max_seqlen_q": used,
+            "max_seqlen_k": used,
+        },
+    )
+
+    out = _impl(quant={"dtype_qk": "fp8_e4m3", "q_block_size": 1, "k_block_size": 16}).forward_cuda(q, k, v, metadata)
+    assert torch.isfinite(out).all()
+    ref = _sdpa_ref(q[:, :used], k[:, :used], v[:, :used], scale)
+    rel = (out[:, :used].float() - ref).abs().mean() / ref.abs().mean()
+    assert rel < 0.2, f"SAGE packed valid-token rel err {rel:.4f} too high"
+    assert torch.count_nonzero(out[:, used:]) == 0
+
+
+@requires_sage
+def test_sage_short_sequence_uses_dense_kernel():
+    torch.manual_seed(0)
+    b, s, h, d = 1, 14, 8, 128
+    scale = 1.0 / math.sqrt(d)
+    q, k, v = (torch.randn(b, s, h, d, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+
+    impl = _impl(quant={"dtype_qk": "fp8_e4m3", "q_block_size": 1, "k_block_size": 16})
+    impl._sage_quantize_fn = lambda *args, **kwargs: pytest.fail("short sequence must not use SAGE")
+    out = impl.forward_cuda(q, k, v)
+    ref = _sdpa_ref(q, k, v, scale)
+    rel = (out.float() - ref).abs().mean() / ref.abs().mean()
+    assert torch.isfinite(out).all()
+    assert rel < 0.01, f"SAGE short-sequence dense fallback rel err {rel:.4f} too high"
+
+
+@requires_trtllm_attn
+def test_skip_tiny_threshold_matches_dense():
+    torch.manual_seed(0)
+    B, S, H, D = 2, 512, 8, 128
+    scale = 1.0 / math.sqrt(D)
+    q, k, v = (torch.randn(B, S, H, D, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+
+    out = _impl(skip_softmax_threshold=1e-9).forward_cuda(q, k, v, None).float()
+    ref = _sdpa_ref(q, k, v, scale)
+    rel = (out - ref).abs().mean() / ref.abs().mean()
+    assert rel < 0.02, f"skip(tiny) rel err {rel:.4f} should be ~dense"
+
+
+@requires_trtllm_attn
+def test_skip_threshold_engages():
+    torch.manual_seed(0)
+    B, S, H, D = 2, 512, 8, 128
+    q, k, v = (torch.randn(B, S, H, D, device="cuda", dtype=torch.bfloat16) for _ in range(3))
+    dense = _impl().forward_cuda(q, k, v, None).float()
+    skipped = _impl(skip_softmax_threshold=2.0).forward_cuda(q, k, v, None).float()
+    assert torch.isfinite(skipped).all()
+    assert (skipped - dense).abs().mean() / dense.abs().mean() > 0.02
+
+
+@requires_trtllm_attn
+def test_gqa_matches_sdpa():
+    torch.manual_seed(0)
+    B, S, Hq, Hkv, D = 1, 256, 64, 8, 128
+    scale = 1.0 / math.sqrt(D)
+    q = torch.randn(B, S, Hq, D, device="cuda", dtype=torch.bfloat16)
+    k = torch.randn(B, S, Hkv, D, device="cuda", dtype=torch.bfloat16)
+    v = torch.randn(B, S, Hkv, D, device="cuda", dtype=torch.bfloat16)
+    out = (
+        TrtllmAttentionImpl(Hq, D, scale, causal=False, num_kv_heads=Hkv, backend_kwargs={})
+        .forward_cuda(q, k, v, None)
+        .float()
+    )
+    qp, kp, vp = (x.permute(0, 2, 1, 3) for x in (q, k, v))
+    ref = (
+        F.scaled_dot_product_attention(qp, kp, vp, is_causal=False, scale=scale, enable_gqa=True)
+        .permute(0, 2, 1, 3)
+        .float()
+    )
+    rel = (out - ref).abs().mean() / ref.abs().mean()
+    assert rel < 0.01, f"GQA rel err {rel:.4f} vs SDPA(GQA) too high"
+
+
+@requires_trtllm_attn
+def test_unsupported_head_dim_raises():
+    q = k = v = torch.randn(1, 32, 8, 64, device="cuda", dtype=torch.bfloat16)
+    with pytest.raises(Exception, match="[Uu]nsupported head dim"):
+        _impl().forward_cuda(q, k, v, None)
+
+
+def test_skip_end_to_end_config_path(monkeypatch):
+    import types
+
+    from vllm_omni.diffusion import forward_context as fc
+    from vllm_omni.diffusion.data import (
+        AttentionConfig,
+        AttentionSpec,
+        OmniDiffusionConfig,
+        TransformerConfig,
+    )
+
+    cfg = AttentionConfig(
+        default=AttentionSpec(
+            backend="TRTLLM_ATTN",
+            skip_softmax={"target_sparsity": 0.65, "disabled_until_timestep": 0.86},
+        )
+    )
+
+    tf = TransformerConfig.from_dict(
+        {"sparse_attention_config": {"threshold_scale_factor": {"prefill": {"a": 7.93, "b": 8.61}}}}
+    )
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.attention.backends.trtllm_calibration.parse_secondary_expert_calibration",
+        lambda *a, **k: None,
+    )
+    OmniDiffusionConfig._propagate_skip_softmax_calibration(
+        types.SimpleNamespace(
+            diffusion_attention_config=cfg,
+            model="/x",
+        ),
+        tf,
+    )
+    spec, _ = cfg.resolve_with_source("self")
+    cal = spec.skip_calibration["by_expert"]["transformer"]
+    assert cal["a"] == 7.93 and cal["b"] == 8.61
+
+    impl = TrtllmAttentionImpl(
+        8, 128, 1.0 / math.sqrt(128), causal=False, num_kv_heads=8, backend_kwargs=spec.backend_kwargs()
+    )
+    impl.set_layer_calibration(cal["a"], cal["b"])
+    expected = 7.93 * math.exp(8.61 * 0.65)
+
+    ctx = fc.ForwardContext(denoise_timestep=0.3)
+    monkeypatch.setattr(fc, "_forward_context", ctx)
+    assert impl._resolve_skip_factor(4096) == pytest.approx(expected)
diff --git a/tests/diffusion/attention/test_trtllm_calibration.py b/tests/diffusion/attention/test_trtllm_calibration.py
new file mode 100644
index 000000000..4db7eaa16
--- /dev/null
+++ b/tests/diffusion/attention/test_trtllm_calibration.py
@@ -0,0 +1,224 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+
+from vllm_omni.diffusion.attention.backends.trtllm_calibration import (
+    is_ignored,
+    layer_match_names,
+    parse_sparse_attention_config,
+    resolve_layer_calibration,
+    select_expert,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def test_layer_match_names_strips_expert_prefix():
+    names = layer_match_names("transformer_2.blocks.5.attn1")
+    assert "transformer_2.blocks.5.attn1" in names
+    assert "blocks.5.attn1" in names
+
+
+def test_layer_match_names_strips_orig_mod():
+    names = layer_match_names("transformer.blocks.5._orig_mod.attn1")
+    assert "transformer.blocks.5.attn1" in names or "blocks.5.attn1" in names
+
+
+def test_is_ignored_matches_relative_pattern():
+    assert is_ignored("transformer.blocks.5.attn2", ["blocks.*.attn2"])
+    assert not is_ignored("transformer.blocks.5.attn1", ["blocks.*.attn2"])
+
+
+def test_is_ignored_empty_patterns():
+    assert not is_ignored("transformer.blocks.5.attn1", [])
+    assert not is_ignored("transformer.blocks.5.attn1", None)
+
+
+def test_is_ignored_ancestor_match_with_attn_suffix():
+    assert is_ignored("transformer.blocks.0.attn2.attn", ["blocks.0.attn2"])
+
+    assert not is_ignored("transformer.blocks.11.attn2.attn", ["blocks.1.attn2"])
+
+    assert not is_ignored("transformer.blocks.5.attn1.attn", ["blocks.0.attn2", "blocks.1.attn2"])
+
+
+def test_select_expert_longest_prefix_wins():
+    keys = ("transformer", "transformer_2")
+    assert select_expert("transformer_2.blocks.5.attn1", keys) == "transformer_2"
+    assert select_expert("transformer.blocks.5.attn1", keys) == "transformer"
+
+
+def test_select_expert_no_match():
+    assert select_expert("blocks.5.attn1", ("transformer", "transformer_2")) is None
+
+
+def _two_expert_calib():
+    return {
+        "by_expert": {
+            "transformer": {
+                "a": 2142.7,
+                "b": 4.28,
+                "target_sparsity": 0.45,
+                "formula": "a*exp(b*target_sparsity)",
+                "ignore": ["blocks.*.attn2"],
+            },
+            "transformer_2": {
+                "a": 314.68,
+                "b": 6.17,
+                "target_sparsity": 0.45,
+                "formula": "a*exp(b*target_sparsity)",
+                "ignore": ["blocks.*.attn2"],
+            },
+        }
+    }
+
+
+def test_resolve_routes_to_correct_expert():
+    calib = _two_expert_calib()
+    hi = resolve_layer_calibration("transformer.blocks.5.attn1", calib)
+    lo = resolve_layer_calibration("transformer_2.blocks.5.attn1", calib)
+    assert hi["a"] == pytest.approx(2142.7)
+    assert lo["a"] == pytest.approx(314.68)
+
+
+def test_resolve_ignored_layer_is_dense():
+    assert resolve_layer_calibration("transformer.blocks.5.attn2", _two_expert_calib()) is None
+
+
+def test_resolve_single_transformer():
+    calib = {
+        "a": 104.76,
+        "b": 7.81,
+        "target_sparsity": 0.45,
+        "formula": "a*exp(b*target_sparsity)",
+        "ignore": ["refiner_blocks.*"],
+    }
+    assert resolve_layer_calibration("transformer_blocks.5.attn", calib)["a"] == pytest.approx(104.76)
+    assert resolve_layer_calibration("refiner_blocks.0.attn", calib) is None
+
+
+def test_resolve_none_calibration():
+    assert resolve_layer_calibration("transformer.blocks.5.attn1", None) is None
+
+
+def test_resolve_unmatched_component_is_uncalibrated():
+    calib = {"by_expert": {"transformer": {"a": 1.0, "b": 2.0, "ignore": []}}}
+    assert resolve_layer_calibration("transformer.blocks.5.attn1", calib)["a"] == pytest.approx(1.0)
+    assert resolve_layer_calibration("transformer_2.blocks.5.attn1", calib) is None
+    assert resolve_layer_calibration("blocks.5.attn1", calib) is None
+
+
+def test_parse_045_config_groups_schema():
+    sac = {
+        "config_groups": {
+            "group_0": {
+                "algorithm": "skip_softmax",
+                "ignore": ["blocks.0.attn1"],
+                "target_sparsity": 0.45,
+                "threshold_scale_factor": {
+                    "formula": "a * exp(b * target_sparsity)",
+                    "coefficients": {"a": 2142.7, "b": 4.28},
+                },
+            }
+        }
+    }
+    parsed = parse_sparse_attention_config(sac)
+    assert parsed["a"] == pytest.approx(2142.7)
+    assert parsed["b"] == pytest.approx(4.28)
+    assert parsed["ignore"] == ["blocks.0.attn1"]
+
+
+def test_parse_unsupported_formula_raises():
+    sac = {
+        "config_groups": {
+            "group_0": {
+                "algorithm": "skip_softmax",
+                "threshold_scale_factor": {"formula": "a * b ** target_sparsity", "coefficients": {"a": 1.0, "b": 2.0}},
+            }
+        }
+    }
+    with pytest.raises(ValueError, match="unsupported skip-softmax formula"):
+        parse_sparse_attention_config(sac)
+
+
+def test_parse_empty_returns_none():
+    assert parse_sparse_attention_config(None) is None
+    assert parse_sparse_attention_config({}) is None
+
+
+class _FakeImpl:
+    def __init__(self):
+        self.stamped = None
+
+    def set_layer_calibration(self, a, b):
+        self.stamped = (a, b)
+
+
+def _fake_pipeline():
+    import torch.nn as nn
+
+    def _attn_layer():
+        layer = nn.Module()
+        layer.attention = _FakeImpl()
+        return layer
+
+    def _wan_attn():
+        wa = nn.Module()
+        wa.attn = _attn_layer()
+        return wa
+
+    def _transformer():
+        tf = nn.Module()
+        blocks = nn.ModuleList()
+        for _ in range(3):
+            blk = nn.Module()
+            blk.attn1 = _wan_attn()
+            blk.attn2 = _wan_attn()
+            blocks.append(blk)
+        tf.blocks = blocks
+        return tf
+
+    pipe = nn.Module()
+    pipe.transformer = _transformer()
+    pipe.transformer_2 = _transformer()
+    return pipe
+
+
+def test_apply_to_pipeline_routes_and_ignores():
+    from vllm_omni.diffusion.attention.backends.trtllm_calibration import apply_to_pipeline
+
+    pipe = _fake_pipeline()
+
+    calib = {
+        "by_expert": {
+            "transformer": {
+                "a": 2142.7,
+                "b": 4.28,
+                "target_sparsity": 0.5,
+                "formula": "a*exp(b*target_sparsity)",
+                "ignore": ["blocks.*.attn2", "blocks.0.attn1"],
+            },
+            "transformer_2": {
+                "a": 314.68,
+                "b": 6.17,
+                "target_sparsity": 0.5,
+                "formula": "a*exp(b*target_sparsity)",
+                "ignore": ["blocks.*.attn2", "blocks.0.attn1"],
+            },
+        }
+    }
+    stamped = apply_to_pipeline(pipe, calib)
+
+    assert stamped == 4
+
+    def impl(expert, blk, attn):
+        return getattr(getattr(pipe, expert).blocks[blk], attn).attn.attention
+
+    assert impl("transformer", 1, "attn1").stamped == pytest.approx((2142.7, 4.28))
+
+    assert impl("transformer_2", 1, "attn1").stamped == pytest.approx((314.68, 6.17))
+
+    assert impl("transformer", 1, "attn2").stamped is None
+
+    assert impl("transformer", 0, "attn1").stamped is None
diff --git a/tests/diffusion/attention/test_ulysses_uaa.py b/tests/diffusion/attention/test_ulysses_uaa.py
index a9e2021c3..6bb588156 100644
--- a/tests/diffusion/attention/test_ulysses_uaa.py
+++ b/tests/diffusion/attention/test_ulysses_uaa.py
@@ -22,6 +22,8 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 from vllm_omni.diffusion.forward_context import get_forward_context, set_forward_context
 from vllm_omni.platforms import current_omni_platform
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def _find_free_port() -> int:
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
diff --git a/tests/diffusion/cache/test_cache_backends.py b/tests/diffusion/cache/test_cache_backends.py
index f5981b927..1137cfbc0 100644
--- a/tests/diffusion/cache/test_cache_backends.py
+++ b/tests/diffusion/cache/test_cache_backends.py
@@ -17,13 +17,14 @@ import cache_dit
 import pytest
 from cache_dit import ForwardPattern
 
-from vllm_omni.diffusion.cache.cache_dit_backend import (
+from vllm_omni.diffusion.cache.cachedit import (
     CacheDiTAdapterConfig,
     CacheDiTBackend,
+    CacheDiTConfig,
 )
-from vllm_omni.diffusion.cache.magcache.backend import MagCacheBackend
+from vllm_omni.diffusion.cache.magcache import MagCacheBackend
 from vllm_omni.diffusion.cache.selector import get_cache_backend
-from vllm_omni.diffusion.cache.teacache.backend import TeaCacheBackend
+from vllm_omni.diffusion.cache.teacache import TeaCacheBackend
 from vllm_omni.diffusion.data import DiffusionCacheConfig
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -32,6 +33,19 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 class TestCacheDiTBackend:
     """Test CacheDiTBackend implementation."""
 
+    def test_config_projection_contains_only_cache_dit_fields(self):
+        shared_config = DiffusionCacheConfig(
+            Fn_compute_blocks=4,
+            max_warmup_steps=8,
+            rel_l1_thresh=0.3,
+        )
+
+        config = CacheDiTConfig.from_diffusion_config(shared_config)
+
+        assert config.Fn_compute_blocks == 4
+        assert config.max_warmup_steps == 8
+        assert not hasattr(config, "rel_l1_thresh")
+
     def test_init_with_dict(self):
         """Test initialization with dictionary config."""
         config_dict = {"Fn_compute_blocks": 4, "max_warmup_steps": 8}
@@ -47,8 +61,8 @@ class TestCacheDiTBackend:
         assert backend.config.Fn_compute_blocks == 4
         assert backend.enabled is False
 
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
     def test_enable_single_transformer(self, mock_cache_dit, mock_block_adapter):
         """Test enabling cache-dit on single-transformer pipeline."""
         # Mock pipeline
@@ -72,13 +86,90 @@ class TestCacheDiTBackend:
 
         # Verify cache-dit was enabled
         assert backend.enabled is True
-        assert backend._refresh_func is not None
+        assert backend._refresh_funcs
         mock_cache_dit.enable_cache.assert_called_once()
 
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
+    def test_enable_and_refresh_every_declared_dit(self, mock_cache_dit, mock_block_adapter):
+        """Combined pipelines enable and refresh Cache-DiT for every DiT."""
+        pipeline = Mock()
+        pipeline.__class__.__name__ = "MiniMaxH3Pipeline"
+        pipeline._dit_modules = ["transformer", "transformers_ref"]
+        pipeline.transformer = Mock()
+        pipeline.transformers_ref = Mock()
+        for transformer in (pipeline.transformer, pipeline.transformers_ref):
+            transformer._cache_dit_adapter_config = CacheDiTAdapterConfig(
+                block_forward_patterns={"blocks": ForwardPattern.Pattern_3}
+            )
+
+        backend = CacheDiTBackend({"Fn_compute_blocks": 2})
+        backend.enable(pipeline)
+        backend.refresh(pipeline, num_inference_steps=20)
+
+        assert len(backend._refresh_funcs) == 2
+        assert mock_cache_dit.enable_cache.call_count == 2
+        assert mock_cache_dit.refresh_context.call_count == 2
+        assert {call.args[0] for call in mock_cache_dit.refresh_context.call_args_list} == {
+            pipeline.transformer,
+            pipeline.transformers_ref,
+        }
+
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.logger")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
+    def test_enable_without_model_adapter_uses_cache_dit_registry(self, mock_cache_dit, mock_logger):
+        """A missing model-declared adapter falls back to Cache-DiT's registry."""
+
+        class BuiltinTransformer:
+            pass
+
+        class BuiltinPipeline:
+            transformer = BuiltinTransformer()
+
+        pipeline = BuiltinPipeline()
+        backend = CacheDiTBackend({"Fn_compute_blocks": 2})
+
+        backend.enable(pipeline)
+
+        assert backend.enabled is True
+        assert backend._refresh_funcs
+        assert mock_cache_dit.enable_cache.call_args.args[0] is pipeline.transformer
+        mock_logger.info.assert_any_call(
+            "Transformer %s does not declare _cache_dit_adapter_config; "
+            "falling back to Cache-DiT's built-in adapter registry.",
+            "BuiltinTransformer",
+        )
+
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
+    def test_enable_without_compatible_adapter_has_contextual_error(self, mock_cache_dit):
+        """An unsupported fallback reports both pipeline and transformer names."""
+
+        class UnsupportedTransformer:
+            pass
+
+        class UnsupportedPipeline:
+            transformer = UnsupportedTransformer()
+
+        pipeline = UnsupportedPipeline()
+        backend = CacheDiTBackend({"Fn_compute_blocks": 2})
+        mock_cache_dit.enable_cache.side_effect = ValueError("unsupported")
+
+        with pytest.raises(
+            ValueError,
+            match=(
+                "Failed to enable Cache-DiT for pipeline UnsupportedPipeline with transformer UnsupportedTransformer"
+            ),
+        ) as exc_info:
+            backend.enable(pipeline)
+
+        assert isinstance(exc_info.value.__cause__, ValueError)
+        assert backend.enabled is False
+        assert backend._refresh_funcs == []
+
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
     def test_refresh(self, mock_cache_dit, mock_block_adapter):
-        """Test refreshing cache context with SCM mask policy updates when num_inference_steps changes."""
+        """Test refreshing cache context with SCM mask policy updates."""
         # Mock pipeline
         mock_pipeline = Mock()
         mock_pipeline.__class__.__name__ = "DiTPipeline"
@@ -107,8 +198,6 @@ class TestCacheDiTBackend:
 
         # First refresh with 50 steps
         backend.refresh(mock_pipeline, num_inference_steps=50)
-        assert backend._last_num_inference_steps == 50
-
         # Verify steps_mask was called with mask policy (not direct steps mask)
         mock_cache_dit.steps_mask.assert_called_with(mask_policy="fast", total_steps=50)
         assert mock_cache_dit.steps_mask.call_count == 1
@@ -137,10 +226,28 @@ class TestCacheDiTBackend:
         call_args = mock_cache_dit.refresh_context.call_args
         assert call_args[0][0] == mock_transformer
         assert "cache_config" in call_args[1]
-        assert backend._last_num_inference_steps == 100
+        assert mock_cache_dit.refresh_context.call_count == 1
 
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
+    def test_refresh_resets_same_step_count(self, mock_cache_dit, mock_block_adapter):
+        """Every generation must reset context, even when the step count is unchanged."""
+        mock_pipeline = Mock()
+        mock_pipeline.__class__.__name__ = "DiTPipeline"
+        mock_pipeline.transformer = Mock()
+        mock_pipeline.transformer._cache_dit_adapter_config = CacheDiTAdapterConfig(
+            block_forward_patterns={"layers": ForwardPattern.Pattern_0}
+        )
+
+        backend = CacheDiTBackend(DiffusionCacheConfig())
+        backend.enable(mock_pipeline)
+        backend.refresh(mock_pipeline, num_inference_steps=20)
+        backend.refresh(mock_pipeline, num_inference_steps=20)
+
+        assert mock_cache_dit.refresh_context.call_count == 2
+
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
     def test_enable_hunyuan_pipeline_uses_model_transformer(self, mock_cache_dit, mock_block_adapter):
         """Test HunyuanImage3 uses pipeline.transformer for cache enable/refresh.
 
@@ -164,7 +271,7 @@ class TestCacheDiTBackend:
         backend.enable(mock_pipeline)
 
         assert backend.enabled is True
-        assert backend._refresh_func is not None
+        assert backend._refresh_funcs
         mock_block_adapter.assert_called_once()
         adapter_kwargs = mock_block_adapter.call_args.kwargs
         assert adapter_kwargs["transformer"] is mock_pipeline.model
@@ -179,8 +286,8 @@ class TestCacheDiTBackend:
         assert call_args[0][0] is mock_pipeline.model
         assert call_args[1]["num_inference_steps"] == 12
 
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
     def test_enable_dreamid_pipeline_uses_fused_blocks(self, mock_cache_dit, mock_block_adapter):
         """Test DreamID uses pipeline.transformer for cache enable/refresh.
 
@@ -204,7 +311,7 @@ class TestCacheDiTBackend:
         backend.enable(mock_pipeline)
 
         assert backend.enabled is True
-        assert backend._refresh_func is not None
+        assert backend._refresh_funcs
         mock_block_adapter.assert_called_once()
         adapter_kwargs = mock_block_adapter.call_args.kwargs
         assert adapter_kwargs["transformer"] is mock_pipeline.transformer
@@ -221,8 +328,8 @@ class TestCacheDiTBackend:
         assert call_args[1]["num_inference_steps"] == 12
 
     @pytest.mark.parametrize("num_inference_steps", [1, 7])
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-    @patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
     def test_refresh_scm_bypassed_for_unsupported_step_counts(
         self, mock_cache_dit, mock_block_adapter, num_inference_steps
     ):
@@ -362,8 +469,6 @@ class TestCacheSelector:
 class TestMagCacheBackend:
     """Test MagCacheBackend implementation."""
 
-    from vllm_omni.diffusion.cache.magcache.backend import MagCacheBackend
-
     def test_init(self):
         """Test initialization."""
         config = DiffusionCacheConfig(mag_threshold=0.1, mag_max_skip_steps=2, mag_calibrate=True)
diff --git a/tests/diffusion/cache/test_cache_dit.py b/tests/diffusion/cache/test_cache_dit.py
index 22f9b8611..fa224cf20 100644
--- a/tests/diffusion/cache/test_cache_dit.py
+++ b/tests/diffusion/cache/test_cache_dit.py
@@ -5,15 +5,18 @@
 Model specific tests for CacheDiT enablement.
 """
 
+import ast
 import sys
+from pathlib import Path
 from unittest.mock import Mock, patch
 
 import pytest
 import torch
 from cache_dit.caching.cache_blocks.pattern_0_1_2 import CachedBlocks_Pattern_0_1_2
 
-import vllm_omni.diffusion.cache.cache_dit_backend as cd_backend
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig, CacheDiTBackend, cache_summary
+import vllm_omni.diffusion.cache.cachedit as cd_backend
+import vllm_omni.diffusion.cache.cachedit.model_specific as cd_model_specific
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig, CacheDiTBackend, cache_summary
 from vllm_omni.diffusion.data import DiffusionCacheConfig
 from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import Cosmos3VFMTransformer
 from vllm_omni.diffusion.models.helios.helios_transformer import HeliosTransformer3DModel
@@ -42,8 +45,73 @@ SEPARATE_CFG_TRANSFORMERS = [
 SAMPLE_CACHE_CONFIG = DiffusionCacheConfig()
 
 
+def test_custom_cache_dit_enablers_are_registered_explicitly():
+    expected_enablers = {
+        "Wan22Pipeline": cd_model_specific.enable_cache_for_wan22,
+        "Wan22I2VPipeline": cd_model_specific.enable_cache_for_wan22,
+        "Wan22TI2VPipeline": cd_model_specific.enable_cache_for_wan22,
+        "Wan22VACEPipeline": cd_model_specific.enable_cache_for_wan22,
+        "Wan22S2VPipeline": cd_model_specific.enable_cache_for_wan22_s2v,
+        "Cosmos3OmniDiffusersPipeline": cd_model_specific.enable_cache_for_cosmos3,
+        "Cosmos3OmniPipeline": cd_model_specific.enable_cache_for_cosmos3,
+        "Krea2Pipeline": cd_model_specific.enable_cache_for_krea2,
+    }
+
+    with patch.dict(cd_backend.CUSTOM_DIT_ENABLERS, {}, clear=True):
+        cd_model_specific.register_custom_dit_enablers()
+        assert cd_backend.CUSTOM_DIT_ENABLERS == expected_enablers
+
+
 def test_wan22_vace_uses_wan22_custom_cache_dit_enabler():
-    assert cd_backend.CUSTOM_DIT_ENABLERS["Wan22VACEPipeline"] is cd_backend.enable_cache_for_wan22
+    assert cd_backend.CUSTOM_DIT_ENABLERS["Wan22VACEPipeline"] is cd_model_specific.enable_cache_for_wan22
+
+
+@pytest.mark.parametrize(
+    "pipeline_name",
+    ["Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"],
+)
+def test_cosmos3_aliases_use_cosmos3_custom_cache_dit_enabler(pipeline_name: str):
+    assert cd_backend.CUSTOM_DIT_ENABLERS[pipeline_name] is cd_model_specific.enable_cache_for_cosmos3
+
+
+def test_cachedit_public_api_is_explicit():
+    assert set(cd_backend.__all__) == {
+        "BagelCachedAdapter",
+        "CUSTOM_DIT_ENABLERS",
+        "CacheDiTAdapterConfig",
+        "CacheDiTBackend",
+        "CacheDiTConfig",
+        "SensenovaCachedAdapter",
+        "cache_summary",
+        "enable_cache_for_dit",
+    }
+    assert not hasattr(cd_backend, "enable_cache_for_wan22")
+    assert not hasattr(cd_backend, "enable_cache_for_wan22_s2v")
+
+
+def test_cachedit_consumers_use_package_api():
+    cache_dir = Path(cd_backend.__file__).resolve().parents[1]
+    package_root = cache_dir.parents[1]
+    legacy_module = "vllm_omni.diffusion.cache.cache_dit_backend"
+    internal_prefix = "vllm_omni.diffusion.cache.cachedit."
+
+    invalid_imports = []
+    for source_path in package_root.rglob("*.py"):
+        if source_path.is_relative_to(cache_dir):
+            continue
+        tree = ast.parse(source_path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            modules = []
+            if isinstance(node, ast.ImportFrom) and node.module is not None:
+                modules.append(node.module)
+            elif isinstance(node, ast.Import):
+                modules.extend(alias.name for alias in node.names)
+
+            for module in modules:
+                if module == legacy_module or module.startswith(internal_prefix):
+                    invalid_imports.append(f"{source_path.relative_to(package_root)}:{node.lineno}: {module}")
+
+    assert not invalid_imports, "Cache-DiT consumers must use the package API:\n" + "\n".join(invalid_imports)
 
 
 @pytest.mark.parametrize("transformer_model", SEPARATE_CFG_TRANSFORMERS)
@@ -54,12 +122,12 @@ def test_cache_dit_configs_have_separate_cfg(transformer_model):
     assert transformer_model._cache_dit_adapter_config.has_separate_cfg is True
 
 
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+@patch("vllm_omni.diffusion.cache.cachedit.model_specific.BlockAdapter")
+@patch("vllm_omni.diffusion.cache.cachedit.model_specific.cache_dit")
 def test_separate_wan22_custom_enabler_has_separate_cfg(mock_cache_dit, mock_block_adapter):
     """Ensure that Wan22, which has a custom enabler, setts custom CFG correctly."""
     mock_pipeline = Mock()
-    cd_backend.enable_cache_for_wan22(mock_pipeline, SAMPLE_CACHE_CONFIG)
+    cd_model_specific.enable_cache_for_wan22(mock_pipeline, SAMPLE_CACHE_CONFIG)
 
     mock_cache_dit.enable_cache.assert_called_once()
     adapter_kwargs = mock_block_adapter.call_args.kwargs
@@ -67,8 +135,8 @@ def test_separate_wan22_custom_enabler_has_separate_cfg(mock_cache_dit, mock_blo
 
 
 @pytest.mark.parametrize("has_transformer_2", [False, True])
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+@patch("vllm_omni.diffusion.cache.cachedit.model_specific.BlockAdapter")
+@patch("vllm_omni.diffusion.cache.cachedit.model_specific.cache_dit")
 def test_wan22_custom_enabler_passes_taylorseer_calibrator(
     mock_cache_dit,
     mock_block_adapter,
@@ -82,7 +150,7 @@ def test_wan22_custom_enabler_passes_taylorseer_calibrator(
         mock_pipeline.transformer_2 = None
     cache_config = DiffusionCacheConfig(enable_taylorseer=True, taylorseer_order=1)
 
-    cd_backend.enable_cache_for_wan22(mock_pipeline, cache_config)
+    cd_model_specific.enable_cache_for_wan22(mock_pipeline, cache_config)
 
     enable_cache_kwargs = mock_cache_dit.enable_cache.call_args.kwargs
     calibrator_config = enable_cache_kwargs["calibrator_config"]
@@ -94,8 +162,8 @@ def test_wan22_custom_enabler_passes_taylorseer_calibrator(
         assert modifier._context_kwargs["calibrator_config"] is calibrator_config
 
 
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.BlockAdapter")
-@patch("vllm_omni.diffusion.cache.cache_dit_backend.cache_dit")
+@patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
+@patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
 def test_cosmos3_cache_dit_wraps_gen_layers(mock_cache_dit, mock_block_adapter):
     """Cosmos3 should cache only the repeated GEN pathway blocks."""
     mock_pipeline = Mock()
@@ -103,7 +171,7 @@ def test_cosmos3_cache_dit_wraps_gen_layers(mock_cache_dit, mock_block_adapter):
     mock_pipeline.transformer.gen_layers = gen_layers
     mock_pipeline.transformer._cache_dit_adapter_config = Cosmos3VFMTransformer._cache_dit_adapter_config
 
-    cd_backend.enable_cache_for_cosmos3(mock_pipeline, SAMPLE_CACHE_CONFIG)
+    cd_model_specific.enable_cache_for_cosmos3(mock_pipeline, SAMPLE_CACHE_CONFIG)
 
     mock_cache_dit.enable_cache.assert_called_once()
     adapter_kwargs = mock_block_adapter.call_args.kwargs
diff --git a/tests/diffusion/cache/test_magcache_hook.py b/tests/diffusion/cache/test_magcache_hook.py
new file mode 100644
index 000000000..4a6fa0a76
--- /dev/null
+++ b/tests/diffusion/cache/test_magcache_hook.py
@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+Unit tests for the MagCache hook forward numerics.
+
+The cached MagCache residual is the residual of the whole block stack
+(tail output - head input). On a skipped step the head hook applies it
+once; every other hooked block must pass its inputs through unchanged,
+matching the reference implementation in diffusers.hooks.mag_cache.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.diffusion.cache.magcache.config import MagCacheConfig
+from vllm_omni.diffusion.cache.magcache.hook import (
+    _MAG_CACHE_LEADER_BLOCK_HOOK,
+    apply_mag_cache_hook,
+)
+from vllm_omni.diffusion.hooks.base import HookRegistry
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _CountingBlock(nn.Module):
+    """Toy dual-stream block: adds a constant delta to hidden_states.
+
+    Returns (encoder_hidden_states, hidden_states) to match the default
+    TransformerBlockMetadata(return_hidden_states_index=1,
+    return_encoder_hidden_states_index=0) registered by the hook.
+    """
+
+    def __init__(self, delta: float):
+        super().__init__()
+        self.delta = delta
+        self.forward_calls = 0
+
+    def forward(self, hidden_states, encoder_hidden_states):
+        self.forward_calls += 1
+        return encoder_hidden_states, hidden_states + self.delta
+
+
+class _ToyTransformer(nn.Module):
+    def __init__(self, n_blocks: int, delta: float = 1.0):
+        super().__init__()
+        self.blocks = nn.ModuleList(_CountingBlock(delta) for _ in range(n_blocks))
+
+    def forward(self, hidden_states, encoder_hidden_states):
+        for block in self.blocks:
+            encoder_hidden_states, hidden_states = block(hidden_states, encoder_hidden_states)
+        return hidden_states
+
+    @property
+    def total_forward_calls(self) -> int:
+        return sum(block.forward_calls for block in self.blocks)
+
+
+def _make_config(num_inference_steps: int = 2) -> MagCacheConfig:
+    # retention_ratio=0.5 with 2 steps -> retention_step = 1: step 0 always
+    # computes, step 1 with mag_ratio 1.0 accumulates zero error, which is a
+    # guaranteed cache hit.
+    return MagCacheConfig(
+        transformer_type="Toy",
+        threshold=0.24,
+        max_skip_steps=5,
+        retention_ratio=0.5,
+        num_inference_steps=num_inference_steps,
+        mag_ratios=torch.ones(num_inference_steps),
+    )
+
+
+def test_skipped_step_applies_full_stack_residual_once():
+    n_blocks, delta = 3, 1.0
+    model = _ToyTransformer(n_blocks=n_blocks, delta=delta)
+    apply_mag_cache_hook(model, _make_config())
+
+    x = torch.zeros(1, 4, 8)
+    e = torch.zeros(1, 2, 8)
+
+    # Step 0 computes and caches residual = tail_output - head_input.
+    out_computed = model(x, e)
+    assert torch.allclose(out_computed, x + n_blocks * delta)
+    assert model.total_forward_calls == n_blocks
+
+    # Step 1 is a cache hit: no block computes, and the cached residual is
+    # applied exactly once, so the output matches the computed step.
+    out_skipped = model(x, e)
+    assert model.total_forward_calls == n_blocks, "step 1 was not skipped"
+    assert torch.allclose(out_skipped, out_computed), (
+        f"cached residual over-applied on skip: expected "
+        f"{out_computed.flatten()[0].item()}, got {out_skipped.flatten()[0].item()}"
+    )
+
+
+def test_single_block_advances_schedule_on_skip():
+    model = _ToyTransformer(n_blocks=1)
+    apply_mag_cache_hook(model, _make_config(num_inference_steps=2))
+
+    x = torch.zeros(1, 4, 8)
+    e = torch.zeros(1, 2, 8)
+
+    model(x, e)  # step 0: computed
+    assert model.total_forward_calls == 1
+    model(x, e)  # step 1: cache hit
+    assert model.total_forward_calls == 1, "step 1 was not skipped"
+
+    # The head hook is also the tail here, so a skipped step must still
+    # advance the schedule; step 1 was the last step, which resets the
+    # state for the next inference run.
+    registry = HookRegistry.check_if_exists_or_initialize(model.blocks[0])
+    hook = registry.get_hook(_MAG_CACHE_LEADER_BLOCK_HOOK)
+    state = hook.state_manager.get_state()
+    assert state.step_index == 0
+    assert state._is_first_step
+    assert state.previous_residual is None
+
+    # A new run therefore starts by computing, not by replaying the stale
+    # residual from the previous run.
+    model(x, e)
+    assert model.total_forward_calls == 2, "new run reused stale skip state"
diff --git a/tests/diffusion/distributed/test_cfg_parallel.py b/tests/diffusion/distributed/test_cfg_parallel.py
index af81f00ef..8991ddec3 100644
--- a/tests/diffusion/distributed/test_cfg_parallel.py
+++ b/tests/diffusion/distributed/test_cfg_parallel.py
@@ -1,18 +1,23 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Unit tests for CFG (Classifier-Free Guidance) parallel functionality.
+"""Tests for CFG (Classifier-Free Guidance) parallel functionality.
 
-This test verifies that predict_noise_maybe_with_cfg and
-predict_noise_with_multi_branch_cfg produce numerically equivalent results
-with and without CFG parallel using fixed random inputs.
+CPU tests mock the CFG process group and validate mixin logic without GPUs.
+Nightly GPU parity tests compare sequential CFG (cfg_parallel_size=1) against
+real multi-GPU CFG parallel under fixed seeds.
 """
 
+from __future__ import annotations
+
 import os
+from typing import Any
 
 import pytest
 import torch
 
-from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
+from tests.helpers.mark import hardware_marks, hardware_test
+from vllm_omni.diffusion.distributed import parallel_state
+from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin, _dispatch_branches, _wrap
 from vllm_omni.diffusion.distributed.parallel_state import (
     destroy_distributed_env,
     get_classifier_free_guidance_rank,
@@ -22,445 +27,105 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 )
 from vllm_omni.platforms import current_omni_platform
 
+_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
+_L4_THREE_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=3)
 
-def update_environment_variables(envs_dict: dict[str, str]):
-    """Update multiple environment variables."""
-    for k, v in envs_dict.items():
-        os.environ[k] = v
+
+def _set_random_seeds(seed: int) -> None:
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def _init_model_weights(module: torch.nn.Module, seed: int) -> None:
+    _set_random_seeds(seed)
+    for param in module.parameters():
+        torch.nn.init.normal_(param, mean=0.0, std=0.02)
+
+
+def _cfg_close_tolerance(dtype: torch.dtype) -> tuple[float, float]:
+    if dtype == torch.float32:
+        return 1e-5, 1e-5
+    if dtype == torch.bfloat16:
+        return 1e-2, 1e-2
+    return 1e-3, 1e-3
+
+
+def _assert_cfg_outputs_close(
+    actual: torch.Tensor,
+    expected: torch.Tensor,
+    *,
+    dtype: torch.dtype,
+    msg: str,
+) -> None:
+    rtol, atol = _cfg_close_tolerance(dtype)
+    torch.testing.assert_close(actual, expected, rtol=rtol, atol=atol, msg=msg)
+
+
+def _update_environment_variables(envs_dict: dict[str, str]) -> None:
+    for key, value in envs_dict.items():
+        os.environ[key] = value
 
 
 class SimpleTransformer(torch.nn.Module):
-    """Simple transformer model for testing with random initialization.
-
-    Contains:
-    - Input projection (conv to hidden_dim)
-    - QKV projection layers
-    - Self-attention layer
-    - Output projection
-    """
-
     def __init__(self, in_channels: int = 4, hidden_dim: int = 128, num_heads: int = 8):
         super().__init__()
         self.hidden_dim = hidden_dim
         self.num_heads = num_heads
         self.head_dim = hidden_dim // num_heads
+        assert hidden_dim % num_heads == 0
 
-        assert hidden_dim % num_heads == 0, "hidden_dim must be divisible by num_heads"
-
-        # Input projection: (B, C, H, W) -> (B, hidden_dim, H, W)
         self.input_proj = torch.nn.Conv2d(in_channels, hidden_dim, 1)
-
-        # QKV projection layers
         self.q_proj = torch.nn.Linear(hidden_dim, hidden_dim)
         self.k_proj = torch.nn.Linear(hidden_dim, hidden_dim)
         self.v_proj = torch.nn.Linear(hidden_dim, hidden_dim)
-
-        # Output projection after attention
         self.out_proj = torch.nn.Linear(hidden_dim, hidden_dim)
-
-        # Final output projection: (B, hidden_dim, H, W) -> (B, C, H, W)
         self.final_proj = torch.nn.Conv2d(hidden_dim, in_channels, 1)
-
-        # Layer norm
         self.norm1 = torch.nn.LayerNorm(hidden_dim)
         self.norm2 = torch.nn.LayerNorm(hidden_dim)
 
     def forward(self, x: torch.Tensor, **kwargs) -> tuple[torch.Tensor]:
-        """Forward pass with self-attention.
-
-        Args:
-            x: Input tensor of shape (B, C, H, W)
-
-        Returns:
-            Output tensor of shape (B, C, H, W)
-        """
-        B, C, H, W = x.shape
-
-        # Input projection
-        x = self.input_proj(x)  # (B, hidden_dim, H, W)
-
-        # Reshape to sequence: (B, hidden_dim, H, W) -> (B, H*W, hidden_dim)
-        x = x.flatten(2).transpose(1, 2)  # (B, H*W, hidden_dim)
-
-        # Self-attention with residual connection
+        del kwargs
+        batch_size, _channels, height, width = x.shape
+        x = self.input_proj(x)
+        x = x.flatten(2).transpose(1, 2)
         residual = x
         x = self.norm1(x)
-
-        # QKV projection
-        q = self.q_proj(x)  # (B, H*W, hidden_dim)
-        k = self.k_proj(x)  # (B, H*W, hidden_dim)
-        v = self.v_proj(x)  # (B, H*W, hidden_dim)
-
-        # Reshape for multi-head attention: (B, H*W, hidden_dim) -> (B, num_heads, H*W, head_dim)
-        seq_len = H * W
-        q = q.view(B, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
-        k = k.view(B, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
-        v = v.view(B, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
-
-        # Scaled dot-product attention
+        q = self.q_proj(x)
+        k = self.k_proj(x)
+        v = self.v_proj(x)
+        seq_len = height * width
+        q = q.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
+        k = k.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
+        v = v.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
         scale = self.head_dim**-0.5
-        attn_scores = torch.matmul(q, k.transpose(-2, -1)) * scale  # (B, num_heads, H*W, H*W)
+        attn_scores = torch.matmul(q, k.transpose(-2, -1)) * scale
         attn_weights = torch.nn.functional.softmax(attn_scores, dim=-1)
         attn_output = torch.matmul(attn_weights, v)
-        attn_output = attn_output.transpose(1, 2).contiguous().view(B, seq_len, self.hidden_dim)
-
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_dim)
         attn_output = self.out_proj(attn_output)
-
         x = residual + attn_output
         residual = x
         x = self.norm2(x)
         x = residual + x
-        x = x.transpose(1, 2).view(B, self.hidden_dim, H, W)
-
-        out = self.final_proj(x)
-
-        return (out,)
+        x = x.transpose(1, 2).view(batch_size, self.hidden_dim, height, width)
+        return (self.final_proj(x),)
 
 
 class TestCFGPipeline(CFGParallelMixin):
-    """Test pipeline using CFGParallelMixin."""
-
     def __init__(self, in_channels: int = 4, hidden_dim: int = 128, seed: int = 42):
-        # Set seed BEFORE creating transformer to ensure consistent layer initialization
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-
+        _set_random_seeds(seed)
         self.transformer = SimpleTransformer(in_channels, hidden_dim)
-
-        # Re-initialize all parameters with fixed seed for full reproducibility
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-        for param in self.transformer.parameters():
-            torch.nn.init.normal_(param, mean=0.0, std=0.02)
-
-
-def _test_cfg_parallel_worker(
-    local_rank: int,
-    world_size: int,
-    cfg_parallel_size: int,
-    dtype: torch.dtype,
-    test_config: dict,
-    result_queue: torch.multiprocessing.Queue,
-):
-    """Worker function for CFG parallel test."""
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
-
-    update_environment_variables(
-        {
-            "RANK": str(local_rank),
-            "LOCAL_RANK": str(local_rank),
-            "WORLD_SIZE": str(world_size),
-            "MASTER_ADDR": "localhost",
-            "MASTER_PORT": "29502",
-        }
-    )
-
-    init_distributed_environment()
-    initialize_model_parallel(cfg_parallel_size=cfg_parallel_size)
-
-    cfg_rank = get_classifier_free_guidance_rank()
-    cfg_world_size = get_classifier_free_guidance_world_size()
-
-    assert cfg_world_size == cfg_parallel_size
-
-    # Create pipeline with same seed to ensure identical model weights across all ranks
-    # Note: model_seed is set inside TestCFGPipeline.__init__
-    pipeline = TestCFGPipeline(
-        in_channels=test_config["channels"],
-        hidden_dim=test_config["hidden_dim"],
-        seed=test_config["model_seed"],
-    )
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()  # Set to eval mode for deterministic behavior
-
-    # Create fixed inputs with explicit seed setting for reproducibility
-    # Set both CPU and CUDA seeds to ensure identical inputs across all ranks
-    torch.manual_seed(test_config["input_seed"])
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(test_config["input_seed"])
-
-    batch_size = test_config["batch_size"]
-    channels = test_config["channels"]
-    height = test_config["height"]
-    width = test_config["width"]
-
-    # Positive input
-    positive_input = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-
-    # Negative input with different seed
-    torch.manual_seed(test_config["input_seed"] + 1)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(test_config["input_seed"] + 1)
-    negative_input = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-
-    # Prepare kwargs for predict_noise_maybe_with_cfg
-    positive_kwargs = {"x": positive_input}
-    negative_kwargs = {"x": negative_input}
-
-    with torch.no_grad():
-        # Call predict_noise_maybe_with_cfg
-        noise_pred = pipeline.predict_noise_maybe_with_cfg(
-            do_true_cfg=True,
-            true_cfg_scale=test_config["cfg_scale"],
-            positive_kwargs=positive_kwargs,
-            negative_kwargs=negative_kwargs,
-            cfg_normalize=test_config["cfg_normalize"],
-            kwargs=test_config["kwargs"],
-        )
-
-    # CFG parallel returns the combined prediction on every rank.
-    assert noise_pred is not None
-    result_queue.put((cfg_rank, noise_pred.cpu()))
-
-    destroy_distributed_env()
-
-
-def _test_cfg_sequential_worker(
-    local_rank: int,
-    world_size: int,
-    dtype: torch.dtype,
-    test_config: dict,
-    result_queue: torch.multiprocessing.Queue,
-):
-    """Worker function for sequential CFG test (baseline)."""
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
-
-    update_environment_variables(
-        {
-            "RANK": str(local_rank),
-            "LOCAL_RANK": str(local_rank),
-            "WORLD_SIZE": str(world_size),
-            "MASTER_ADDR": "localhost",
-            "MASTER_PORT": "29503",
-        }
-    )
-
-    init_distributed_environment()
-    initialize_model_parallel(cfg_parallel_size=1)  # No CFG parallel
-
-    cfg_world_size = get_classifier_free_guidance_world_size()
-    assert cfg_world_size == 1
-
-    # Create pipeline with same seed to ensure identical model weights as CFG parallel
-    # Note: model_seed is set inside TestCFGPipeline.__init__
-    pipeline = TestCFGPipeline(
-        in_channels=test_config["channels"],
-        hidden_dim=test_config["hidden_dim"],
-        seed=test_config["model_seed"],
-    )
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()
-
-    # Create fixed inputs (same seed as CFG parallel to ensure identical inputs)
-    # Set both CPU and CUDA seeds for full reproducibility
-    torch.manual_seed(test_config["input_seed"])
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(test_config["input_seed"])
-
-    batch_size = test_config["batch_size"]
-    channels = test_config["channels"]
-    height = test_config["height"]
-    width = test_config["width"]
-
-    # Positive input
-    positive_input = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-
-    # Negative input with different seed
-    torch.manual_seed(test_config["input_seed"] + 1)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(test_config["input_seed"] + 1)
-    negative_input = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-
-    positive_kwargs = {"x": positive_input}
-    negative_kwargs = {"x": negative_input}
-
-    with torch.no_grad():
-        noise_pred = pipeline.predict_noise_maybe_with_cfg(
-            do_true_cfg=True,
-            true_cfg_scale=test_config["cfg_scale"],
-            positive_kwargs=positive_kwargs,
-            negative_kwargs=negative_kwargs,
-            cfg_normalize=test_config["cfg_normalize"],
-            kwargs=test_config["kwargs"],
-        )
-
-    # Sequential CFG always returns output
-    assert noise_pred is not None
-    result_queue.put(noise_pred.cpu())
-
-    destroy_distributed_env()
-
-
-@pytest.mark.parametrize("cfg_parallel_size", [2])
-@pytest.mark.parametrize("dtype", [torch.bfloat16])
-@pytest.mark.parametrize("batch_size", [2])
-@pytest.mark.parametrize("cfg_normalize", [False, True])
-@pytest.mark.parametrize("kwargs", [None, {"step_i": 1}])
-def test_predict_noise_maybe_with_cfg(
-    cfg_parallel_size: int, dtype: torch.dtype, batch_size: int, cfg_normalize: bool, kwargs: dict | None
-):
-    """
-    Test that predict_noise_maybe_with_cfg produces identical results
-    with and without CFG parallel.
-
-    Args:
-        cfg_parallel_size: Number of GPUs for CFG parallel
-        dtype: Data type for computation
-        batch_size: Batch size for testing
-        cfg_normalize: Whether to normalize CFG output
-    """
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < cfg_parallel_size:
-        pytest.skip(f"Test requires {cfg_parallel_size} GPUs but only {available_gpus} available")
-
-    test_config = {
-        "batch_size": batch_size,
-        "channels": 4,
-        "height": 16,
-        "width": 16,
-        "hidden_dim": 128,
-        "cfg_scale": 7.5,
-        "cfg_normalize": cfg_normalize,
-        "model_seed": 42,  # Fixed seed for model initialization
-        "input_seed": 123,  # Fixed seed for input generation
-        "kwargs": kwargs,  # Additional kwargs to test passing through CFG parallel
-    }
-
-    mp_context = torch.multiprocessing.get_context("spawn")
-
-    manager = mp_context.Manager()
-    baseline_queue = manager.Queue()
-    cfg_parallel_queue = manager.Queue()
-
-    # Run baseline (sequential CFG) on single GPU
-    torch.multiprocessing.spawn(
-        _test_cfg_sequential_worker,
-        args=(1, dtype, test_config, baseline_queue),
-        nprocs=1,
-    )
-
-    # Run CFG parallel on multiple GPUs
-    torch.multiprocessing.spawn(
-        _test_cfg_parallel_worker,
-        args=(cfg_parallel_size, cfg_parallel_size, dtype, test_config, cfg_parallel_queue),
-        nprocs=cfg_parallel_size,
-    )
-
-    # Get results from queues
-    baseline_output = baseline_queue.get()
-    cfg_parallel_outputs = [cfg_parallel_queue.get() for _ in range(cfg_parallel_size)]
-    cfg_parallel_outputs.sort(key=lambda item: item[0])
-    cfg_parallel_output = cfg_parallel_outputs[0][1]
-
-    for cfg_rank, rank_output in cfg_parallel_outputs[1:]:
-        torch.testing.assert_close(
-            rank_output,
-            cfg_parallel_output,
-            rtol=0,
-            atol=0,
-            msg=f"CFG parallel ranks produced different outputs (rank 0 vs rank {cfg_rank})",
-        )
-
-    # Verify shapes match
-    assert baseline_output.shape == cfg_parallel_output.shape, (
-        f"Shape mismatch: baseline {baseline_output.shape} vs CFG parallel {cfg_parallel_output.shape}"
-    )
-
-    # Verify numerical equivalence with appropriate tolerances
-    if dtype == torch.float32:
-        rtol, atol = 1e-5, 1e-5
-    elif dtype == torch.bfloat16:
-        rtol, atol = 1e-2, 1e-2
-    else:
-        rtol, atol = 1e-3, 1e-3
-
-    torch.testing.assert_close(
-        cfg_parallel_output,
-        baseline_output,
-        rtol=rtol,
-        atol=atol,
-        msg=(
-            f"CFG parallel output differs from sequential CFG\n"
-            f"  dtype={dtype}, batch_size={batch_size}, cfg_normalize={cfg_normalize}\n"
-            f"  Max diff: {(cfg_parallel_output - baseline_output).abs().max().item():.6e}"
-        ),
-    )
-
-    print(
-        f"✓ Test passed: cfg_size={cfg_parallel_size}, dtype={dtype}, "
-        f"batch_size={batch_size}, cfg_normalize={cfg_normalize}"
-    )
-
-
-@pytest.mark.parametrize("dtype", [torch.bfloat16])
-def test_predict_noise_without_cfg(dtype: torch.dtype):
-    """
-    Test predict_noise_maybe_with_cfg when do_true_cfg=False.
-
-    When CFG is disabled, only the positive branch should be computed.
-    This test runs on a single GPU without distributed environment.
-    """
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < 1:
-        pytest.skip("Test requires at least 1 GPU")
-
-    device = torch.device(f"{current_omni_platform.device_type}:0")
-    current_omni_platform.set_device(device)
-
-    # Create pipeline without distributed environment
-    pipeline = TestCFGPipeline(in_channels=4, hidden_dim=128, seed=42)
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()
-
-    # Set seed for input generation
-    torch.manual_seed(123)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(123)
-    positive_input = torch.randn(1, 4, 16, 16, dtype=dtype, device=device)
-
-    with torch.no_grad():
-        noise_pred = pipeline.predict_noise_maybe_with_cfg(
-            do_true_cfg=False,  # No CFG
-            true_cfg_scale=7.5,
-            positive_kwargs={"x": positive_input},
-            negative_kwargs=None,
-            cfg_normalize=False,
-        )
-
-    # Should always return output when do_true_cfg=False
-    assert noise_pred is not None
-    assert noise_pred.shape == (1, 4, 16, 16)
-
-    print(f"✓ Test passed: predict_noise without CFG (dtype={dtype})")
+        _init_model_weights(self.transformer, seed)
 
 
 class MultiBranchTestPipeline(CFGParallelMixin):
-    """Test pipeline with custom 3-branch combine logic (like OmniGen2)."""
-
     def __init__(self, in_channels: int = 4, hidden_dim: int = 128, seed: int = 42):
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-
+        _set_random_seeds(seed)
         self.transformer = SimpleTransformer(in_channels, hidden_dim)
-
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-        for param in self.transformer.parameters():
-            torch.nn.init.normal_(param, mean=0.0, std=0.02)
+        _init_model_weights(self.transformer, seed)
 
     def combine_multi_branch_cfg_noise(self, predictions, true_cfg_scale, cfg_normalize=False):
-        """N-branch combine with weighted sum for testing.
-
-        - 2-branch: standard CFG formula (true_cfg_scale is float)
-        - 3-branch: OmniGen2-style dual guidance scale (true_cfg_scale is dict)
-        - 4-branch: DreamID-style weighted sum (true_cfg_scale is dict)
-        """
         if len(predictions) == 4:
             text_scale = true_cfg_scale["text"]
             image_scale = true_cfg_scale["image"]
@@ -486,6 +151,561 @@ class MultiBranchTestPipeline(CFGParallelMixin):
         return combined
 
 
+class FakeCfgGroup:
+    def __init__(self, *, world_size: int, rank_in_group: int, rank_tensors: list[torch.Tensor]):
+        self.world_size = world_size
+        self.rank_in_group = rank_in_group
+        self._rank_tensors = rank_tensors
+
+    def all_gather(
+        self,
+        input_: torch.Tensor,
+        dim: int = 0,
+        separate_tensors: bool = False,
+    ) -> torch.Tensor | list[torch.Tensor]:
+        del dim, input_
+        assert separate_tensors
+        return [tensor.clone() for tensor in self._rank_tensors]
+
+
+class FakeMultiBranchCfgGroup:
+    def __init__(
+        self,
+        *,
+        world_size: int,
+        rank_in_group: int,
+        slots_per_rank: list[list[tuple[torch.Tensor, ...]]],
+    ):
+        self.world_size = world_size
+        self.rank_in_group = rank_in_group
+        self._slots_per_rank = slots_per_rank
+        # Production path re-runs predict_noise, so gathered tensors are value-equal
+        # but not identity-equal to the precomputed slot table. Index by call order
+        # instead: slot-major then element-major, matching _predict_multi_branch_parallel.
+        self._call_idx = 0
+
+    def all_gather(
+        self,
+        input_: torch.Tensor,
+        dim: int = 0,
+        separate_tensors: bool = False,
+    ) -> torch.Tensor | list[torch.Tensor]:
+        del dim, input_
+        assert separate_tensors
+        n_elems = len(self._slots_per_rank[0][0])
+        slot_idx, elem_idx = divmod(self._call_idx, n_elems)
+        self._call_idx += 1
+        assert slot_idx < len(self._slots_per_rank[self.rank_in_group]), (
+            f"all_gather call {self._call_idx} exceeds slot table "
+            f"(slot_idx={slot_idx}, n_slots={len(self._slots_per_rank[self.rank_in_group])})"
+        )
+        return [self._slots_per_rank[rank][slot_idx][elem_idx].clone() for rank in range(self.world_size)]
+
+
+def _patch_cfg_state(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    world_size: int,
+    rank: int,
+    fake_group: FakeCfgGroup | FakeMultiBranchCfgGroup,
+) -> None:
+    # Patch both the source module and cfg_parallel's bound imports.
+    # cfg_parallel does `from ...parallel_state import get_cfg_group`, so
+    # patching parallel_state alone does not affect CFGParallelMixin.
+    from vllm_omni.diffusion.distributed import cfg_parallel as cfg_parallel_mod
+
+    for module in (parallel_state, cfg_parallel_mod):
+        monkeypatch.setattr(module, "get_classifier_free_guidance_world_size", lambda: world_size)
+        monkeypatch.setattr(module, "get_classifier_free_guidance_rank", lambda: rank)
+        monkeypatch.setattr(module, "get_cfg_group", lambda: fake_group)
+
+
+def _make_two_branch_inputs(
+    *,
+    batch_size: int,
+    channels: int,
+    height: int,
+    width: int,
+    dtype: torch.dtype,
+    device: torch.device,
+    input_seed: int,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    _set_random_seeds(input_seed)
+    positive = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
+    _set_random_seeds(input_seed + 1)
+    negative = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
+    return {"x": positive}, {"x": negative}
+
+
+def _make_multi_branch_inputs(
+    *,
+    n_branches: int,
+    batch_size: int,
+    channels: int,
+    height: int,
+    width: int,
+    dtype: torch.dtype,
+    device: torch.device,
+    input_seed: int,
+) -> list[dict[str, Any]]:
+    branches_kwargs: list[dict[str, Any]] = []
+    for branch_idx in range(n_branches):
+        _set_random_seeds(input_seed + branch_idx)
+        x = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
+        branches_kwargs.append({"x": x})
+    return branches_kwargs
+
+
+def _multi_branch_cfg_scale(n_branches: int) -> float | dict[str, float]:
+    if n_branches == 2:
+        return 5.0
+    if n_branches == 3:
+        return {"text": 5.0, "image": 2.0}
+    return {"text": 5.0, "image": 2.0, "vid_ref": 1.5}
+
+
+def _build_multi_branch_slot_table(
+    *,
+    n_branches: int,
+    cfg_world_size: int,
+    branch_preds: list[torch.Tensor | tuple[torch.Tensor, ...]],
+) -> list[list[tuple[torch.Tensor, ...]]]:
+    assignments = _dispatch_branches(n_branches, cfg_world_size)
+    max_per_rank = max(len(branch_ids) for branch_ids in assignments)
+    ref_pred = _wrap(branch_preds[0])
+    slots_per_rank: list[list[tuple[torch.Tensor, ...]]] = []
+    for branch_ids in assignments:
+        slots = [_wrap(branch_preds[branch_id]) for branch_id in branch_ids]
+        while len(slots) < max_per_rank:
+            slots.append(tuple(torch.zeros_like(tensor) for tensor in ref_pred))
+        slots_per_rank.append(slots)
+    return slots_per_rank
+
+
+def _run_two_branch_cfg_parallel_mock(
+    pipeline: TestCFGPipeline,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    cfg_world_size: int,
+    positive_kwargs: dict[str, Any],
+    negative_kwargs: dict[str, Any],
+    true_cfg_scale: float,
+    cfg_normalize: bool,
+    extra_kwargs: dict[str, Any] | None,
+) -> torch.Tensor:
+    with torch.no_grad():
+        pos_tensor = _wrap(pipeline.predict_noise(**positive_kwargs))[0]
+        neg_tensor = _wrap(pipeline.predict_noise(**negative_kwargs))[0]
+
+    outputs: list[torch.Tensor] = []
+    for cfg_rank in range(cfg_world_size):
+        fake_group = FakeCfgGroup(
+            world_size=cfg_world_size,
+            rank_in_group=cfg_rank,
+            rank_tensors=[pos_tensor, neg_tensor],
+        )
+        _patch_cfg_state(monkeypatch, world_size=cfg_world_size, rank=cfg_rank, fake_group=fake_group)
+        with torch.no_grad():
+            output = pipeline.predict_noise_maybe_with_cfg(
+                do_true_cfg=True,
+                true_cfg_scale=true_cfg_scale,
+                positive_kwargs=positive_kwargs,
+                negative_kwargs=negative_kwargs,
+                cfg_normalize=cfg_normalize,
+                kwargs=extra_kwargs,
+            )
+        assert output is not None
+        outputs.append(output)
+
+    for rank_output in outputs[1:]:
+        torch.testing.assert_close(
+            rank_output,
+            outputs[0],
+            rtol=0,
+            atol=0,
+            msg="CFG parallel ranks produced different outputs in mock path",
+        )
+    return outputs[0]
+
+
+def _run_multi_branch_cfg_parallel_mock(
+    pipeline: MultiBranchTestPipeline,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    cfg_world_size: int,
+    branches_kwargs: list[dict[str, Any]],
+    true_cfg_scale: float | dict[str, float],
+    cfg_normalize: bool,
+) -> torch.Tensor:
+    with torch.no_grad():
+        branch_preds = [pipeline.predict_noise(**kwargs) for kwargs in branches_kwargs]
+    slots_per_rank = _build_multi_branch_slot_table(
+        n_branches=len(branches_kwargs),
+        cfg_world_size=cfg_world_size,
+        branch_preds=branch_preds,
+    )
+
+    outputs: list[torch.Tensor] = []
+    for cfg_rank in range(cfg_world_size):
+        fake_group = FakeMultiBranchCfgGroup(
+            world_size=cfg_world_size,
+            rank_in_group=cfg_rank,
+            slots_per_rank=slots_per_rank,
+        )
+        _patch_cfg_state(monkeypatch, world_size=cfg_world_size, rank=cfg_rank, fake_group=fake_group)
+        with torch.no_grad():
+            output = pipeline.predict_noise_with_multi_branch_cfg(
+                do_true_cfg=True,
+                true_cfg_scale=true_cfg_scale,
+                branches_kwargs=branches_kwargs,
+                cfg_normalize=cfg_normalize,
+            )
+        assert output is not None
+        outputs.append(output)
+
+    for rank_output in outputs[1:]:
+        torch.testing.assert_close(
+            rank_output,
+            outputs[0],
+            rtol=0,
+            atol=0,
+            msg="Multi-branch CFG parallel ranks produced different outputs in mock path",
+        )
+    return outputs[0]
+
+
+def _build_pipeline_on_device(
+    pipeline_cls: type,
+    *,
+    hidden_dim: int,
+    model_seed: int,
+    dtype: torch.dtype,
+    device: torch.device,
+):
+    pipeline = pipeline_cls(in_channels=4, hidden_dim=hidden_dim, seed=model_seed)
+    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
+    pipeline.transformer.eval()
+    return pipeline
+
+
+# ---------------------------------------------------------------------------
+# CPU: mixin logic via mocked CFG groups (no GPU / no torch.distributed spawn)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("batch_size", [2])
+@pytest.mark.parametrize("cfg_normalize", [False, True])
+@pytest.mark.parametrize("extra_kwargs", [None, {"step_i": 1}])
+def test_predict_noise_with_cfg(
+    monkeypatch: pytest.MonkeyPatch,
+    batch_size: int,
+    cfg_normalize: bool,
+    extra_kwargs: dict[str, Any] | None,
+):
+    dtype = torch.float32
+    device = torch.device("cpu")
+    pipeline = _build_pipeline_on_device(TestCFGPipeline, hidden_dim=128, model_seed=42, dtype=dtype, device=device)
+    positive_kwargs, negative_kwargs = _make_two_branch_inputs(
+        batch_size=batch_size,
+        channels=4,
+        height=16,
+        width=16,
+        dtype=dtype,
+        device=device,
+        input_seed=123,
+    )
+
+    _patch_cfg_state(
+        monkeypatch,
+        world_size=1,
+        rank=0,
+        fake_group=FakeCfgGroup(world_size=1, rank_in_group=0, rank_tensors=[]),
+    )
+    with torch.no_grad():
+        baseline = pipeline.predict_noise_maybe_with_cfg(
+            do_true_cfg=True,
+            true_cfg_scale=7.5,
+            positive_kwargs=positive_kwargs,
+            negative_kwargs=negative_kwargs,
+            cfg_normalize=cfg_normalize,
+            kwargs=extra_kwargs,
+        )
+
+    parallel = _run_two_branch_cfg_parallel_mock(
+        pipeline,
+        monkeypatch,
+        cfg_world_size=2,
+        positive_kwargs=positive_kwargs,
+        negative_kwargs=negative_kwargs,
+        true_cfg_scale=7.5,
+        cfg_normalize=cfg_normalize,
+        extra_kwargs=extra_kwargs,
+    )
+    assert baseline is not None
+    _assert_cfg_outputs_close(
+        parallel,
+        baseline,
+        dtype=dtype,
+        msg=f"mock CFG parallel differs from sequential (cfg_normalize={cfg_normalize})",
+    )
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+def test_predict_noise_without_cfg():
+    dtype = torch.float32
+    device = torch.device("cpu")
+    pipeline = _build_pipeline_on_device(TestCFGPipeline, hidden_dim=128, model_seed=42, dtype=dtype, device=device)
+    positive_kwargs, _ = _make_two_branch_inputs(
+        batch_size=1,
+        channels=4,
+        height=16,
+        width=16,
+        dtype=dtype,
+        device=device,
+        input_seed=123,
+    )
+
+    with torch.no_grad():
+        noise_pred = pipeline.predict_noise_maybe_with_cfg(
+            do_true_cfg=False,
+            true_cfg_scale=7.5,
+            positive_kwargs=positive_kwargs,
+            negative_kwargs=None,
+            cfg_normalize=False,
+        )
+
+    assert noise_pred is not None
+    assert noise_pred.shape == (1, 4, 16, 16)
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    "cfg_parallel_size,n_branches",
+    [(2, 2), (2, 3), (3, 3), (2, 4)],
+)
+@pytest.mark.parametrize("batch_size", [2])
+@pytest.mark.parametrize("cfg_normalize", [False, True])
+def test_predict_noise_with_multi_branch_cfg(
+    monkeypatch: pytest.MonkeyPatch,
+    cfg_parallel_size: int,
+    n_branches: int,
+    batch_size: int,
+    cfg_normalize: bool,
+):
+    dtype = torch.float32
+    device = torch.device("cpu")
+    pipeline = _build_pipeline_on_device(
+        MultiBranchTestPipeline,
+        hidden_dim=128,
+        model_seed=42,
+        dtype=dtype,
+        device=device,
+    )
+    branches_kwargs = _make_multi_branch_inputs(
+        n_branches=n_branches,
+        batch_size=batch_size,
+        channels=4,
+        height=16,
+        width=16,
+        dtype=dtype,
+        device=device,
+        input_seed=123,
+    )
+    cfg_scale = _multi_branch_cfg_scale(n_branches)
+
+    _patch_cfg_state(
+        monkeypatch,
+        world_size=1,
+        rank=0,
+        fake_group=FakeCfgGroup(world_size=1, rank_in_group=0, rank_tensors=[]),
+    )
+    with torch.no_grad():
+        baseline = pipeline.predict_noise_with_multi_branch_cfg(
+            do_true_cfg=True,
+            true_cfg_scale=cfg_scale,
+            branches_kwargs=branches_kwargs,
+            cfg_normalize=cfg_normalize,
+        )
+
+    parallel = _run_multi_branch_cfg_parallel_mock(
+        pipeline,
+        monkeypatch,
+        cfg_world_size=cfg_parallel_size,
+        branches_kwargs=branches_kwargs,
+        true_cfg_scale=cfg_scale,
+        cfg_normalize=cfg_normalize,
+    )
+    assert baseline is not None
+    _assert_cfg_outputs_close(
+        parallel,
+        baseline,
+        dtype=dtype,
+        msg=(
+            f"mock multi-branch CFG parallel differs from sequential "
+            f"(n_branches={n_branches}, cfg_parallel_size={cfg_parallel_size})"
+        ),
+    )
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+def test_multi_branch_without_cfg():
+    dtype = torch.float32
+    device = torch.device("cpu")
+    pipeline = _build_pipeline_on_device(
+        MultiBranchTestPipeline,
+        hidden_dim=128,
+        model_seed=42,
+        dtype=dtype,
+        device=device,
+    )
+    branches_kwargs = _make_multi_branch_inputs(
+        n_branches=3,
+        batch_size=1,
+        channels=4,
+        height=16,
+        width=16,
+        dtype=dtype,
+        device=device,
+        input_seed=123,
+    )
+
+    with torch.no_grad():
+        noise_pred = pipeline.predict_noise_with_multi_branch_cfg(
+            do_true_cfg=False,
+            true_cfg_scale=5.0,
+            branches_kwargs=branches_kwargs,
+            cfg_normalize=False,
+        )
+
+    assert noise_pred is not None
+    assert noise_pred.shape == (1, 4, 16, 16)
+
+
+# ---------------------------------------------------------------------------
+# GPU nightly: same-seed sequential vs real multi-GPU CFG parallel parity
+# ---------------------------------------------------------------------------
+
+
+def _test_cfg_parallel_worker(
+    local_rank: int,
+    world_size: int,
+    cfg_parallel_size: int,
+    dtype: torch.dtype,
+    test_config: dict,
+    result_queue: torch.multiprocessing.Queue,
+):
+    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
+    current_omni_platform.set_device(device)
+    _update_environment_variables(
+        {
+            "RANK": str(local_rank),
+            "LOCAL_RANK": str(local_rank),
+            "WORLD_SIZE": str(world_size),
+            "MASTER_ADDR": "localhost",
+            "MASTER_PORT": "29502",
+        }
+    )
+
+    init_distributed_environment()
+    initialize_model_parallel(cfg_parallel_size=cfg_parallel_size)
+    assert get_classifier_free_guidance_world_size() == cfg_parallel_size
+
+    pipeline = _build_pipeline_on_device(
+        TestCFGPipeline,
+        hidden_dim=test_config["hidden_dim"],
+        model_seed=test_config["model_seed"],
+        dtype=dtype,
+        device=device,
+    )
+    positive_kwargs, negative_kwargs = _make_two_branch_inputs(
+        batch_size=test_config["batch_size"],
+        channels=test_config["channels"],
+        height=test_config["height"],
+        width=test_config["width"],
+        dtype=dtype,
+        device=device,
+        input_seed=test_config["input_seed"],
+    )
+
+    with torch.no_grad():
+        noise_pred = pipeline.predict_noise_maybe_with_cfg(
+            do_true_cfg=True,
+            true_cfg_scale=test_config["cfg_scale"],
+            positive_kwargs=positive_kwargs,
+            negative_kwargs=negative_kwargs,
+            cfg_normalize=test_config["cfg_normalize"],
+            kwargs=test_config["kwargs"],
+        )
+
+    assert noise_pred is not None
+    result_queue.put((get_classifier_free_guidance_rank(), noise_pred.cpu()))
+    destroy_distributed_env()
+
+
+def _test_cfg_sequential_worker(
+    local_rank: int,
+    world_size: int,
+    dtype: torch.dtype,
+    test_config: dict,
+    result_queue: torch.multiprocessing.Queue,
+):
+    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
+    current_omni_platform.set_device(device)
+    _update_environment_variables(
+        {
+            "RANK": str(local_rank),
+            "LOCAL_RANK": str(local_rank),
+            "WORLD_SIZE": str(world_size),
+            "MASTER_ADDR": "localhost",
+            "MASTER_PORT": "29503",
+        }
+    )
+
+    init_distributed_environment()
+    initialize_model_parallel(cfg_parallel_size=1)
+    assert get_classifier_free_guidance_world_size() == 1
+
+    pipeline = _build_pipeline_on_device(
+        TestCFGPipeline,
+        hidden_dim=test_config["hidden_dim"],
+        model_seed=test_config["model_seed"],
+        dtype=dtype,
+        device=device,
+    )
+    positive_kwargs, negative_kwargs = _make_two_branch_inputs(
+        batch_size=test_config["batch_size"],
+        channels=test_config["channels"],
+        height=test_config["height"],
+        width=test_config["width"],
+        dtype=dtype,
+        device=device,
+        input_seed=test_config["input_seed"],
+    )
+
+    with torch.no_grad():
+        noise_pred = pipeline.predict_noise_maybe_with_cfg(
+            do_true_cfg=True,
+            true_cfg_scale=test_config["cfg_scale"],
+            positive_kwargs=positive_kwargs,
+            negative_kwargs=negative_kwargs,
+            cfg_normalize=test_config["cfg_normalize"],
+            kwargs=test_config["kwargs"],
+        )
+
+    assert noise_pred is not None
+    result_queue.put(noise_pred.cpu())
+    destroy_distributed_env()
+
+
 def _test_multi_branch_parallel_worker(
     local_rank: int,
     world_size: int,
@@ -494,11 +714,9 @@ def _test_multi_branch_parallel_worker(
     test_config: dict,
     result_queue: torch.multiprocessing.Queue,
 ):
-    """Worker function for multi-branch CFG parallel test."""
     device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
     current_omni_platform.set_device(device)
-
-    update_environment_variables(
+    _update_environment_variables(
         {
             "RANK": str(local_rank),
             "LOCAL_RANK": str(local_rank),
@@ -510,33 +728,25 @@ def _test_multi_branch_parallel_worker(
 
     init_distributed_environment()
     initialize_model_parallel(cfg_parallel_size=cfg_parallel_size)
+    assert get_classifier_free_guidance_world_size() == cfg_parallel_size
 
-    cfg_rank = get_classifier_free_guidance_rank()
-    cfg_world_size = get_classifier_free_guidance_world_size()
-    assert cfg_world_size == cfg_parallel_size
-
-    pipeline = MultiBranchTestPipeline(
-        in_channels=test_config["channels"],
+    pipeline = _build_pipeline_on_device(
+        MultiBranchTestPipeline,
         hidden_dim=test_config["hidden_dim"],
-        seed=test_config["model_seed"],
+        model_seed=test_config["model_seed"],
+        dtype=dtype,
+        device=device,
+    )
+    branches_kwargs = _make_multi_branch_inputs(
+        n_branches=test_config["n_branches"],
+        batch_size=test_config["batch_size"],
+        channels=test_config["channels"],
+        height=test_config["height"],
+        width=test_config["width"],
+        dtype=dtype,
+        device=device,
+        input_seed=test_config["input_seed"],
     )
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()
-
-    n_branches = test_config["n_branches"]
-    batch_size = test_config["batch_size"]
-    channels = test_config["channels"]
-    height = test_config["height"]
-    width = test_config["width"]
-
-    # Create N branch inputs with distinct seeds
-    branches_kwargs = []
-    for b in range(n_branches):
-        torch.manual_seed(test_config["input_seed"] + b)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(test_config["input_seed"] + b)
-        x = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-        branches_kwargs.append({"x": x})
 
     with torch.no_grad():
         noise_pred = pipeline.predict_noise_with_multi_branch_cfg(
@@ -547,8 +757,7 @@ def _test_multi_branch_parallel_worker(
         )
 
     assert noise_pred is not None
-    result_queue.put((cfg_rank, noise_pred.cpu()))
-
+    result_queue.put((get_classifier_free_guidance_rank(), noise_pred.cpu()))
     destroy_distributed_env()
 
 
@@ -559,11 +768,9 @@ def _test_multi_branch_sequential_worker(
     test_config: dict,
     result_queue: torch.multiprocessing.Queue,
 ):
-    """Worker function for sequential multi-branch CFG test (baseline)."""
     device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
     current_omni_platform.set_device(device)
-
-    update_environment_variables(
+    _update_environment_variables(
         {
             "RANK": str(local_rank),
             "LOCAL_RANK": str(local_rank),
@@ -575,31 +782,25 @@ def _test_multi_branch_sequential_worker(
 
     init_distributed_environment()
     initialize_model_parallel(cfg_parallel_size=1)
+    assert get_classifier_free_guidance_world_size() == 1
 
-    cfg_world_size = get_classifier_free_guidance_world_size()
-    assert cfg_world_size == 1
-
-    pipeline = MultiBranchTestPipeline(
-        in_channels=test_config["channels"],
+    pipeline = _build_pipeline_on_device(
+        MultiBranchTestPipeline,
         hidden_dim=test_config["hidden_dim"],
-        seed=test_config["model_seed"],
+        model_seed=test_config["model_seed"],
+        dtype=dtype,
+        device=device,
+    )
+    branches_kwargs = _make_multi_branch_inputs(
+        n_branches=test_config["n_branches"],
+        batch_size=test_config["batch_size"],
+        channels=test_config["channels"],
+        height=test_config["height"],
+        width=test_config["width"],
+        dtype=dtype,
+        device=device,
+        input_seed=test_config["input_seed"],
     )
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()
-
-    n_branches = test_config["n_branches"]
-    batch_size = test_config["batch_size"]
-    channels = test_config["channels"]
-    height = test_config["height"]
-    width = test_config["width"]
-
-    branches_kwargs = []
-    for b in range(n_branches):
-        torch.manual_seed(test_config["input_seed"] + b)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(test_config["input_seed"] + b)
-        x = torch.randn(batch_size, channels, height, width, dtype=dtype, device=device)
-        branches_kwargs.append({"x": x})
 
     with torch.no_grad():
         noise_pred = pipeline.predict_noise_with_multi_branch_cfg(
@@ -611,58 +812,86 @@ def _test_multi_branch_sequential_worker(
 
     assert noise_pred is not None
     result_queue.put(noise_pred.cpu())
-
     destroy_distributed_env()
 
 
-@pytest.mark.parametrize(
-    "cfg_parallel_size,n_branches",
-    [
-        (2, 2),  # 2 branches on 2 GPUs: [[0],[1]]
-        (2, 3),  # 3 branches on 2 GPUs: [[0,2],[1]]
-        (3, 3),  # 3 branches on 3 GPUs: [[0],[1],[2]]
-        (2, 4),  # 4 branches on 2 GPUs: [[0,2],[1,3]]
-    ],
-)
-@pytest.mark.parametrize("dtype", [torch.bfloat16])
-@pytest.mark.parametrize("batch_size", [2])
-@pytest.mark.parametrize("cfg_normalize", [False, True])
-def test_predict_noise_with_multi_branch_cfg(
+def _run_two_branch_gpu_parity(
+    *,
     cfg_parallel_size: int,
-    n_branches: int,
     dtype: torch.dtype,
     batch_size: int,
     cfg_normalize: bool,
-):
-    """
-    Test that predict_noise_with_multi_branch_cfg produces identical results
-    with and without CFG parallel for N-branch models.
-
-    Args:
-        cfg_parallel_size: Number of GPUs for CFG parallel
-        n_branches: Number of CFG branches
-        dtype: Data type for computation
-        batch_size: Batch size for testing
-        cfg_normalize: Whether to normalize CFG output
-    """
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < cfg_parallel_size:
-        pytest.skip(f"Test requires {cfg_parallel_size} GPUs but only {available_gpus} available")
-
-    if n_branches == 2:
-        cfg_scale = 5.0
-    elif n_branches == 3:
-        cfg_scale = {"text": 5.0, "image": 2.0}
-    else:
-        cfg_scale = {"text": 5.0, "image": 2.0, "vid_ref": 1.5}
-
+    extra_kwargs: dict[str, Any] | None,
+) -> None:
     test_config = {
         "batch_size": batch_size,
         "channels": 4,
         "height": 16,
         "width": 16,
         "hidden_dim": 128,
-        "cfg_scale": cfg_scale,
+        "cfg_scale": 7.5,
+        "cfg_normalize": cfg_normalize,
+        "model_seed": 42,
+        "input_seed": 123,
+        "kwargs": extra_kwargs,
+    }
+
+    mp_context = torch.multiprocessing.get_context("spawn")
+    manager = mp_context.Manager()
+    baseline_queue = manager.Queue()
+    cfg_parallel_queue = manager.Queue()
+
+    torch.multiprocessing.spawn(
+        _test_cfg_sequential_worker,
+        args=(1, dtype, test_config, baseline_queue),
+        nprocs=1,
+    )
+    torch.multiprocessing.spawn(
+        _test_cfg_parallel_worker,
+        args=(cfg_parallel_size, cfg_parallel_size, dtype, test_config, cfg_parallel_queue),
+        nprocs=cfg_parallel_size,
+    )
+
+    baseline_output = baseline_queue.get()
+    cfg_parallel_outputs = [cfg_parallel_queue.get() for _ in range(cfg_parallel_size)]
+    cfg_parallel_outputs.sort(key=lambda item: item[0])
+    cfg_parallel_output = cfg_parallel_outputs[0][1]
+
+    for cfg_rank, rank_output in cfg_parallel_outputs[1:]:
+        torch.testing.assert_close(
+            rank_output,
+            cfg_parallel_output,
+            rtol=0,
+            atol=0,
+            msg=f"CFG parallel ranks differ (rank 0 vs rank {cfg_rank})",
+        )
+
+    _assert_cfg_outputs_close(
+        cfg_parallel_output,
+        baseline_output,
+        dtype=dtype,
+        msg=(
+            f"GPU CFG parallel output differs from sequential CFG "
+            f"(cfg_parallel_size={cfg_parallel_size}, cfg_normalize={cfg_normalize})"
+        ),
+    )
+
+
+def _run_multi_branch_gpu_parity(
+    *,
+    cfg_parallel_size: int,
+    n_branches: int,
+    dtype: torch.dtype,
+    batch_size: int,
+    cfg_normalize: bool,
+) -> None:
+    test_config = {
+        "batch_size": batch_size,
+        "channels": 4,
+        "height": 16,
+        "width": 16,
+        "hidden_dim": 128,
+        "cfg_scale": _multi_branch_cfg_scale(n_branches),
         "cfg_normalize": cfg_normalize,
         "model_seed": 42,
         "input_seed": 123,
@@ -674,14 +903,11 @@ def test_predict_noise_with_multi_branch_cfg(
     baseline_queue = manager.Queue()
     cfg_parallel_queue = manager.Queue()
 
-    # Run baseline (sequential, cfgp=1)
     torch.multiprocessing.spawn(
         _test_multi_branch_sequential_worker,
         args=(1, dtype, test_config, baseline_queue),
         nprocs=1,
     )
-
-    # Run CFG parallel
     torch.multiprocessing.spawn(
         _test_multi_branch_parallel_worker,
         args=(cfg_parallel_size, cfg_parallel_size, dtype, test_config, cfg_parallel_queue),
@@ -693,7 +919,6 @@ def test_predict_noise_with_multi_branch_cfg(
     cfg_parallel_outputs.sort(key=lambda item: item[0])
     cfg_parallel_output = cfg_parallel_outputs[0][1]
 
-    # All ranks should produce identical output
     for cfg_rank, rank_output in cfg_parallel_outputs[1:]:
         torch.testing.assert_close(
             rank_output,
@@ -703,73 +928,62 @@ def test_predict_noise_with_multi_branch_cfg(
             msg=f"Multi-branch CFG parallel ranks differ (rank 0 vs rank {cfg_rank})",
         )
 
-    assert baseline_output.shape == cfg_parallel_output.shape, (
-        f"Shape mismatch: baseline {baseline_output.shape} vs CFG parallel {cfg_parallel_output.shape}"
-    )
-
-    if dtype == torch.float32:
-        rtol, atol = 1e-5, 1e-5
-    elif dtype == torch.bfloat16:
-        rtol, atol = 1e-2, 1e-2
-    else:
-        rtol, atol = 1e-3, 1e-3
-
-    torch.testing.assert_close(
+    _assert_cfg_outputs_close(
         cfg_parallel_output,
         baseline_output,
-        rtol=rtol,
-        atol=atol,
+        dtype=dtype,
         msg=(
-            f"Multi-branch CFG parallel output differs from sequential\n"
-            f"  n_branches={n_branches}, cfg_parallel_size={cfg_parallel_size}\n"
-            f"  dtype={dtype}, cfg_normalize={cfg_normalize}\n"
-            f"  Max diff: {(cfg_parallel_output - baseline_output).abs().max().item():.6e}"
+            f"GPU multi-branch CFG parallel differs from sequential "
+            f"(n_branches={n_branches}, cfg_parallel_size={cfg_parallel_size})"
         ),
     )
 
-    print(
-        f"✓ Test passed: multi_branch n_branches={n_branches}, "
-        f"cfg_size={cfg_parallel_size}, dtype={dtype}, cfg_normalize={cfg_normalize}"
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "L4"}, num_cards=2)
+@pytest.mark.parametrize("batch_size", [2])
+@pytest.mark.parametrize("cfg_normalize", [False, True])
+@pytest.mark.parametrize("extra_kwargs", [None, {"step_i": 1}])
+def test_predict_noise_with_cfg_parity(
+    batch_size: int,
+    cfg_normalize: bool,
+    extra_kwargs: dict[str, Any] | None,
+):
+    _run_two_branch_gpu_parity(
+        cfg_parallel_size=2,
+        dtype=torch.bfloat16,
+        batch_size=batch_size,
+        cfg_normalize=cfg_normalize,
+        extra_kwargs=extra_kwargs,
     )
 
 
-@pytest.mark.parametrize("dtype", [torch.bfloat16])
-def test_multi_branch_without_cfg(dtype: torch.dtype):
-    """
-    Test predict_noise_with_multi_branch_cfg when do_true_cfg=False.
-
-    When CFG is disabled, only the first branch (positive) should be computed.
-    This test runs on a single GPU without distributed environment.
-    """
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < 1:
-        pytest.skip("Test requires at least 1 GPU")
-
-    device = torch.device(f"{current_omni_platform.device_type}:0")
-    current_omni_platform.set_device(device)
-
-    pipeline = MultiBranchTestPipeline(in_channels=4, hidden_dim=128, seed=42)
-    pipeline.transformer = pipeline.transformer.to(device=device, dtype=dtype)
-    pipeline.transformer.eval()
-
-    # Create 3 branch inputs (only first should be used)
-    branches_kwargs = []
-    for b in range(3):
-        torch.manual_seed(123 + b)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(123 + b)
-        x = torch.randn(1, 4, 16, 16, dtype=dtype, device=device)
-        branches_kwargs.append({"x": x})
-
-    with torch.no_grad():
-        noise_pred = pipeline.predict_noise_with_multi_branch_cfg(
-            do_true_cfg=False,  # No CFG
-            true_cfg_scale=5.0,
-            branches_kwargs=branches_kwargs,
-            cfg_normalize=False,
-        )
-
-    assert noise_pred is not None
-    assert noise_pred.shape == (1, 4, 16, 16)
-
-    print(f"✓ Test passed: multi_branch predict_noise without CFG (dtype={dtype})")
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "cfg_parallel_size,n_branches",
+    [
+        pytest.param(2, 2, marks=_L4_TWO_GPU),
+        pytest.param(2, 3, marks=_L4_TWO_GPU),
+        pytest.param(3, 3, marks=_L4_THREE_GPU),
+        pytest.param(2, 4, marks=_L4_TWO_GPU),
+    ],
+)
+@pytest.mark.parametrize("batch_size", [2])
+@pytest.mark.parametrize("cfg_normalize", [False, True])
+def test_predict_noise_with_multi_branch_cfg_parity(
+    cfg_parallel_size: int,
+    n_branches: int,
+    batch_size: int,
+    cfg_normalize: bool,
+):
+    _run_multi_branch_gpu_parity(
+        cfg_parallel_size=cfg_parallel_size,
+        n_branches=n_branches,
+        dtype=torch.bfloat16,
+        batch_size=batch_size,
+        cfg_normalize=cfg_normalize,
+    )
diff --git a/tests/diffusion/distributed/test_comm.py b/tests/diffusion/distributed/test_comm.py
index 3e408c10a..647389048 100644
--- a/tests/diffusion/distributed/test_comm.py
+++ b/tests/diffusion/distributed/test_comm.py
@@ -1,12 +1,20 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Unit tests for SeqAllToAll4D and SeqAllToAll5D communication primitives."""
+"""Tests for SeqAllToAll4D, SeqAllToAll5D, and RingComm communication primitives.
+
+CPU tests use gloo on CPU tensors (no GPU). Nightly parity tests run the same
+checks on real multi-GPU NCCL collectives.
+"""
+
+from __future__ import annotations
 
 import os
+from typing import Literal
 
 import pytest
 import torch
 
+from tests.helpers.mark import hardware_marks
 from vllm_omni.diffusion.distributed.comm import RingComm, SeqAllToAll4D, SeqAllToAll5D
 from vllm_omni.diffusion.distributed.parallel_state import (
     destroy_distributed_env,
@@ -16,56 +24,51 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 )
 from vllm_omni.platforms import current_omni_platform
 
+_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
+_L4_FOUR_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=4)
 
-def update_environment_variables(envs_dict: dict[str, str]):
-    """Update multiple environment variables with logging."""
-    for k, v in envs_dict.items():
-        os.environ[k] = v
+DeviceKind = Literal["cpu", "cuda"]
 
 
-@pytest.mark.parametrize("world_size", [2, 4])
-@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
-@pytest.mark.parametrize("batch_size", [2])
-@pytest.mark.parametrize("seq_len_per_rank", [8])
-@pytest.mark.parametrize("num_heads", [8])
-@pytest.mark.parametrize("head_size", [32])
-@pytest.mark.parametrize("use_sync", [False, True])
-def test_4d_identity(
+def _update_environment_variables(envs_dict: dict[str, str]) -> None:
+    for key, value in envs_dict.items():
+        os.environ[key] = value
+
+
+def _worker_device(local_rank: int, device_kind: DeviceKind) -> torch.device:
+    if device_kind == "cpu":
+        return torch.device("cpu")
+    return torch.device(f"{current_omni_platform.device_type}:{local_rank}")
+
+
+def _init_worker(
+    local_rank: int,
     world_size: int,
-    dtype: torch.dtype,
-    batch_size: int,
-    seq_len_per_rank: int,
-    num_heads: int,
-    head_size: int,
-    use_sync: bool,
-):
-    """Test that two consecutive all-to-all operations return the original input."""
-    # Skip if not enough GPUs available
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < world_size:
-        pytest.skip(f"Test requires {world_size} GPUs but only {available_gpus} available")
-
-    # Ensure num_heads is divisible by world_size
-    if num_heads % world_size != 0:
-        pytest.skip(f"num_heads ({num_heads}) not divisible by world_size ({world_size})")
-
-    # Run test with multiprocessing spawn
-    torch.multiprocessing.spawn(
-        _test_4d_identity_worker,
-        args=(
-            world_size,
-            dtype,
-            batch_size,
-            seq_len_per_rank,
-            num_heads,
-            head_size,
-            use_sync,
-        ),
-        nprocs=world_size,
+    master_port: int,
+    device_kind: DeviceKind,
+) -> None:
+    _update_environment_variables(
+        {
+            "RANK": str(local_rank),
+            "LOCAL_RANK": str(local_rank),
+            "WORLD_SIZE": str(world_size),
+            "MASTER_ADDR": "localhost",
+            "MASTER_PORT": str(master_port),
+        }
     )
+    backend = "gloo" if device_kind == "cpu" else None
+    init_distributed_environment(backend=backend)
 
 
-def _test_4d_identity_worker(
+def _close_tolerance(dtype: torch.dtype) -> tuple[float, float]:
+    if dtype == torch.bfloat16:
+        return 1e-3, 1e-3
+    if dtype == torch.float16:
+        return 1e-3, 1e-3
+    return 1e-5, 1e-5
+
+
+def _run_4d_identity(
     local_rank: int,
     world_size: int,
     dtype: torch.dtype,
@@ -74,29 +77,17 @@ def _test_4d_identity_worker(
     num_heads: int,
     head_size: int,
     use_sync: bool,
-):
-    """Worker function for test_4d_identity."""
-    # Set device
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    device = _worker_device(local_rank, device_kind)
+    if device_kind == "cuda":
+        current_omni_platform.set_device(device)
 
-    # Set environment variables for distributed training
-    update_environment_variables(
-        {
-            "RANK": str(local_rank),
-            "LOCAL_RANK": str(local_rank),
-            "WORLD_SIZE": str(world_size),
-            "MASTER_ADDR": "localhost",
-            "MASTER_PORT": "29500",
-        }
-    )
+    _init_worker(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(ulysses_degree=world_size)
+    sp_group = get_sp_group().ulysses_group
 
-    # Initialize distributed environment
-    init_distributed_environment()
-    initialize_model_parallel(ulysses_degree=world_size)  # test ulysses sp by default
-    sp_group = get_sp_group().ulysses_group  # get ulysses sp group not ring sp group
-
-    # Create input tensor: (bs, seqlen/P, hc, hs)
     torch.manual_seed(42 + local_rank)
     input_tensor = torch.randn(
         batch_size,
@@ -106,100 +97,36 @@ def _test_4d_identity_worker(
         dtype=dtype,
         device=device,
     )
-
-    # Save original input for comparison
     original_input = input_tensor.clone()
 
-    # First all-to-all: (bs, seqlen/P, hc, hs) -> (bs, seqlen, hc/P, hs)
-    intermediate = SeqAllToAll4D.apply(
-        sp_group,
-        input_tensor,
-        2,  # scatter head dimension
-        1,  # gather sequence dimension
-        use_sync,
-    )
-
-    # Verify intermediate shape
-    expected_shape = (
+    intermediate = SeqAllToAll4D.apply(sp_group, input_tensor, 2, 1, use_sync)
+    expected_intermediate_shape = (
         batch_size,
         seq_len_per_rank * world_size,
         num_heads // world_size,
         head_size,
     )
-    assert intermediate.shape == expected_shape, (
-        f"Intermediate shape mismatch: expected {expected_shape}, got {intermediate.shape}"
+    assert intermediate.shape == expected_intermediate_shape, (
+        f"Intermediate shape mismatch: expected {expected_intermediate_shape}, got {intermediate.shape}"
     )
 
-    # Second all-to-all: (bs, seqlen, hc/P, hs) -> (bs, seqlen/P, hc, hs)
-    output = SeqAllToAll4D.apply(
-        sp_group,
-        intermediate,
-        1,  # scatter sequence dimension
-        2,  # gather head dimension
-        use_sync,
-    )
-
-    # Verify output shape matches input
+    output = SeqAllToAll4D.apply(sp_group, intermediate, 1, 2, use_sync)
     assert output.shape == original_input.shape, (
         f"Output shape mismatch: expected {original_input.shape}, got {output.shape}"
     )
 
-    # Verify output matches original input
+    rtol, atol = _close_tolerance(dtype)
     torch.testing.assert_close(
         output,
         original_input,
-        rtol=1e-5,
-        atol=1e-5,
+        rtol=rtol,
+        atol=atol,
         msg="Output does not match original input after two all-to-all operations",
     )
-
-    # Cleanup distributed environment
     destroy_distributed_env()
 
 
-@pytest.mark.parametrize("world_size", [2, 4])
-@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
-@pytest.mark.parametrize("batch_size", [2])
-@pytest.mark.parametrize("seq_len_per_rank", [8])
-@pytest.mark.parametrize("num_heads", [8])
-@pytest.mark.parametrize("head_size", [32])
-@pytest.mark.parametrize("use_sync", [False, True])
-def test_5d_identity(
-    world_size: int,
-    dtype: torch.dtype,
-    batch_size: int,
-    seq_len_per_rank: int,
-    num_heads: int,
-    head_size: int,
-    use_sync: bool,
-):
-    """Test that two consecutive all-to-all operations return the original input."""
-    # Skip if not enough GPUs available
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < world_size:
-        pytest.skip(f"Test requires {world_size} GPUs but only {available_gpus} available")
-
-    # Ensure num_heads is divisible by world_size
-    if num_heads % world_size != 0:
-        pytest.skip(f"num_heads ({num_heads}) not divisible by world_size ({world_size})")
-
-    # Run test with multiprocessing spawn
-    torch.multiprocessing.spawn(
-        _test_5d_identity_worker,
-        args=(
-            world_size,
-            dtype,
-            batch_size,
-            seq_len_per_rank,
-            num_heads,
-            head_size,
-            use_sync,
-        ),
-        nprocs=world_size,
-    )
-
-
-def _test_5d_identity_worker(
+def _run_5d_identity(
     local_rank: int,
     world_size: int,
     dtype: torch.dtype,
@@ -208,199 +135,329 @@ def _test_5d_identity_worker(
     num_heads: int,
     head_size: int,
     use_sync: bool,
-):
-    """Worker function for test_5d_identity."""
-    # Set device
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    device = _worker_device(local_rank, device_kind)
+    if device_kind == "cuda":
+        current_omni_platform.set_device(device)
 
-    # Set environment variables for distributed training
-    update_environment_variables(
-        {
-            "RANK": str(local_rank),
-            "LOCAL_RANK": str(local_rank),
-            "WORLD_SIZE": str(world_size),
-            "MASTER_ADDR": "localhost",
-            "MASTER_PORT": "29500",
-        }
-    )
+    _init_worker(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(ulysses_degree=world_size)
+    sp_group = get_sp_group().ulysses_group
 
-    # Initialize distributed environment
-    init_distributed_environment()
-    initialize_model_parallel(ulysses_degree=world_size)  # test ulysses sp by default
-    sp_group = get_sp_group().ulysses_group  # get ulysses sp group not ring sp group
-
-    # Create input tensor: (bs, seqlen/P, 3, hc, hs)
-    # The '3' dimension is for Q, K, V
     torch.manual_seed(42 + local_rank)
     input_tensor = torch.randn(
         batch_size,
         seq_len_per_rank,
-        3,  # Q, K, V
+        3,
         num_heads,
         head_size,
         dtype=dtype,
         device=device,
     )
-
-    # Save original input for comparison
     original_input = input_tensor.clone()
 
-    # First all-to-all: (bs, seqlen/P, 3, hc, hs) -> (bs, seqlen, 3, hc/P, hs)
-    intermediate = SeqAllToAll5D.apply(
-        sp_group,
-        input_tensor,
-        3,  # scatter head dimension
-        1,  # gather sequence dimension
-        use_sync,
-    )
-
-    # Verify intermediate shape
-    expected_shape = (
+    intermediate = SeqAllToAll5D.apply(sp_group, input_tensor, 3, 1, use_sync)
+    expected_intermediate_shape = (
         batch_size,
         seq_len_per_rank * world_size,
         3,
         num_heads // world_size,
         head_size,
     )
-    assert intermediate.shape == expected_shape, (
-        f"Intermediate shape mismatch: expected {expected_shape}, got {intermediate.shape}"
+    assert intermediate.shape == expected_intermediate_shape, (
+        f"Intermediate shape mismatch: expected {expected_intermediate_shape}, got {intermediate.shape}"
     )
 
-    # Second all-to-all: (bs, seqlen, 3, hc/P, hs) -> (bs, seqlen/P, 3, hc, hs)
-    output = SeqAllToAll5D.apply(
-        sp_group,
-        intermediate,
-        1,  # scatter sequence dimension
-        3,  # gather head dimension
-        use_sync,
-    )
-
-    # Verify output shape matches input
+    output = SeqAllToAll5D.apply(sp_group, intermediate, 1, 3, use_sync)
     assert output.shape == original_input.shape, (
         f"Output shape mismatch: expected {original_input.shape}, got {output.shape}"
     )
 
-    # Verify output matches original input
+    rtol, atol = _close_tolerance(dtype)
     torch.testing.assert_close(
         output,
         original_input,
-        rtol=1e-5,
-        atol=1e-5,
+        rtol=rtol,
+        atol=atol,
         msg="Output does not match original input after two all-to-all operations",
     )
-
-    # Cleanup distributed environment
     destroy_distributed_env()
 
 
-@pytest.mark.parametrize("world_size", [2, 4])
-@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
-@pytest.mark.parametrize("batch_size", [2])
-@pytest.mark.parametrize("num_heads", [8])
-@pytest.mark.parametrize("head_size", [128])
-def test_ring_p2p(
-    world_size: int,
-    dtype: torch.dtype,
-    batch_size: int,
-    num_heads: int,
-    head_size: int,
-):
-    """Test Ring P2P communication (send_recv)."""
-    # Skip if not enough GPUs available
-    available_gpus = current_omni_platform.get_device_count()
-    if available_gpus < world_size:
-        pytest.skip(f"Test requires {world_size} GPUs but only {available_gpus} available")
-
-    torch.multiprocessing.spawn(
-        _test_ring_p2p_worker,
-        args=(world_size, dtype, batch_size, num_heads, head_size),
-        nprocs=world_size,
-    )
-
-
-def _test_ring_p2p_worker(
+def _run_ring_p2p(
     local_rank: int,
     world_size: int,
     dtype: torch.dtype,
     batch_size: int,
     num_heads: int,
     head_size: int,
-):
-    """Worker for Ring P2P test."""
-    import sys
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    device = _worker_device(local_rank, device_kind)
+    if device_kind == "cuda":
+        current_omni_platform.set_device(device)
 
-    # Set device
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
-
-    # Set env vars
-    # Use a different port to avoid conflict with other tests if run in parallel
-    update_environment_variables(
-        {
-            "RANK": str(local_rank),
-            "LOCAL_RANK": str(local_rank),
-            "WORLD_SIZE": str(world_size),
-            "MASTER_ADDR": "localhost",
-            "MASTER_PORT": "29501",
-        }
-    )
-
-    # Init distributed
     try:
-        init_distributed_environment()
-        # Ring degree = world_size to test ring group
+        _init_worker(local_rank, world_size, master_port, device_kind)
         initialize_model_parallel(ring_degree=world_size)
         sp_group = get_sp_group()
-
-        print(f"[Rank {local_rank}] Initialized. Ring group size: {sp_group.ring_group.size()}")
-        sys.stdout.flush()
-
-        # Create RingComm
         comm = RingComm(sp_group.ring_group)
 
-        # Create tensor: rank-specific data
-        # (batch, num_heads, head_size)
-        # Fill with rank value + 1 to avoid 0 and make verification easy
         input_tensor = torch.full(
-            (batch_size, num_heads, head_size), fill_value=float(local_rank + 1), dtype=dtype, device=device
+            (batch_size, num_heads, head_size),
+            fill_value=float(local_rank + 1),
+            dtype=dtype,
+            device=device,
         )
-
-        print(f"[Rank {local_rank}] Input sum: {input_tensor.sum().item()}")
-        sys.stdout.flush()
-
-        # Send input, receive from prev
-        # RingComm.send_recv sends to next, receives from prev
-        t0 = __import__("time").time()
         recv_tensor = comm.send_recv(input_tensor)
         comm.commit()
         comm.wait()
-        t1 = __import__("time").time()
 
-        print(f"[Rank {local_rank}] Communication done in {t1 - t0:.4f}s")
-
-        # Verify
-        # Expected value: from (rank - 1) % world_size
         prev_rank = (local_rank - 1 + world_size) % world_size
         expected_value = float(prev_rank + 1)
-
-        recv_sum = recv_tensor.sum().item()
-        print(f"[Rank {local_rank}] Received sum: {recv_sum}, Expected value: {expected_value}")
-        sys.stdout.flush()
-
         expected_tensor = torch.full_like(recv_tensor, fill_value=expected_value)
-
-        # Use a slightly loose tolerance for bfloat16
+        rtol, atol = _close_tolerance(dtype)
         torch.testing.assert_close(
-            recv_tensor, expected_tensor, rtol=1e-3, atol=1e-3, msg=f"[Rank {local_rank}] Data mismatch!"
+            recv_tensor,
+            expected_tensor,
+            rtol=rtol,
+            atol=atol,
+            msg=f"[Rank {local_rank}] Ring P2P data mismatch",
         )
-        print(f"[Rank {local_rank}] Verification PASSED")
-
-    except Exception as e:
-        print(f"[Rank {local_rank}] FAILED with error: {e}")
-        import traceback
-
-        traceback.print_exc()
-        raise e
     finally:
         destroy_distributed_env()
+
+
+def _spawn_4d_identity(
+    *,
+    world_size: int,
+    dtype: torch.dtype,
+    batch_size: int,
+    seq_len_per_rank: int,
+    num_heads: int,
+    head_size: int,
+    use_sync: bool,
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    torch.multiprocessing.spawn(
+        _run_4d_identity,
+        args=(
+            world_size,
+            dtype,
+            batch_size,
+            seq_len_per_rank,
+            num_heads,
+            head_size,
+            use_sync,
+            device_kind,
+            master_port,
+        ),
+        nprocs=world_size,
+    )
+
+
+def _spawn_5d_identity(
+    *,
+    world_size: int,
+    dtype: torch.dtype,
+    batch_size: int,
+    seq_len_per_rank: int,
+    num_heads: int,
+    head_size: int,
+    use_sync: bool,
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    torch.multiprocessing.spawn(
+        _run_5d_identity,
+        args=(
+            world_size,
+            dtype,
+            batch_size,
+            seq_len_per_rank,
+            num_heads,
+            head_size,
+            use_sync,
+            device_kind,
+            master_port,
+        ),
+        nprocs=world_size,
+    )
+
+
+def _spawn_ring_p2p(
+    *,
+    world_size: int,
+    dtype: torch.dtype,
+    batch_size: int,
+    num_heads: int,
+    head_size: int,
+    device_kind: DeviceKind,
+    master_port: int,
+) -> None:
+    torch.multiprocessing.spawn(
+        _run_ring_p2p,
+        args=(world_size, dtype, batch_size, num_heads, head_size, device_kind, master_port),
+        nprocs=world_size,
+    )
+
+
+def _require_heads_divisible(num_heads: int, world_size: int) -> None:
+    if num_heads % world_size != 0:
+        pytest.skip(f"num_heads ({num_heads}) not divisible by world_size ({world_size})")
+
+
+def _require_gpus(world_size: int) -> None:
+    available_gpus = current_omni_platform.get_device_count()
+    if available_gpus < world_size:
+        pytest.skip(f"Test requires {world_size} GPUs but only {available_gpus} available")
+
+
+# ---------------------------------------------------------------------------
+# CPU: gloo collectives on CPU tensors (no GPU)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("world_size", [2, 4])
+@pytest.mark.parametrize("use_sync", [False, True])
+def test_4d_identity(world_size: int, use_sync: bool):
+    _require_heads_divisible(8, world_size)
+    _spawn_4d_identity(
+        world_size=world_size,
+        dtype=torch.float32,
+        batch_size=2,
+        seq_len_per_rank=8,
+        num_heads=8,
+        head_size=32,
+        use_sync=use_sync,
+        device_kind="cpu",
+        master_port=29610,
+    )
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("world_size", [2, 4])
+@pytest.mark.parametrize("use_sync", [False, True])
+def test_5d_identity(world_size: int, use_sync: bool):
+    _require_heads_divisible(8, world_size)
+    _spawn_5d_identity(
+        world_size=world_size,
+        dtype=torch.float32,
+        batch_size=2,
+        seq_len_per_rank=8,
+        num_heads=8,
+        head_size=32,
+        use_sync=use_sync,
+        device_kind="cpu",
+        master_port=29611,
+    )
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("world_size", [2, 4])
+def test_ring_p2p(world_size: int):
+    _spawn_ring_p2p(
+        world_size=world_size,
+        dtype=torch.float32,
+        batch_size=2,
+        num_heads=8,
+        head_size=128,
+        device_kind="cpu",
+        master_port=29612,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Nightly: same checks on real multi-GPU NCCL collectives
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "world_size",
+    [
+        pytest.param(2, marks=_L4_TWO_GPU),
+        pytest.param(4, marks=_L4_FOUR_GPU),
+    ],
+)
+@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+@pytest.mark.parametrize("use_sync", [False, True])
+def test_4d_identity_parity(world_size: int, dtype: torch.dtype, use_sync: bool):
+    _require_gpus(world_size)
+    _require_heads_divisible(8, world_size)
+    _spawn_4d_identity(
+        world_size=world_size,
+        dtype=dtype,
+        batch_size=2,
+        seq_len_per_rank=8,
+        num_heads=8,
+        head_size=32,
+        use_sync=use_sync,
+        device_kind="cuda",
+        master_port=29500,
+    )
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "world_size",
+    [
+        pytest.param(2, marks=_L4_TWO_GPU),
+        pytest.param(4, marks=_L4_FOUR_GPU),
+    ],
+)
+@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+@pytest.mark.parametrize("use_sync", [False, True])
+def test_5d_identity_parity(world_size: int, dtype: torch.dtype, use_sync: bool):
+    _require_gpus(world_size)
+    _require_heads_divisible(8, world_size)
+    _spawn_5d_identity(
+        world_size=world_size,
+        dtype=dtype,
+        batch_size=2,
+        seq_len_per_rank=8,
+        num_heads=8,
+        head_size=32,
+        use_sync=use_sync,
+        device_kind="cuda",
+        master_port=29502,
+    )
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "world_size",
+    [
+        pytest.param(2, marks=_L4_TWO_GPU),
+        pytest.param(4, marks=_L4_FOUR_GPU),
+    ],
+)
+@pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+def test_ring_p2p_parity(world_size: int, dtype: torch.dtype):
+    _require_gpus(world_size)
+    _spawn_ring_p2p(
+        world_size=world_size,
+        dtype=dtype,
+        batch_size=2,
+        num_heads=8,
+        head_size=128,
+        device_kind="cuda",
+        master_port=29501,
+    )
diff --git a/tests/diffusion/distributed/test_expert_parallel_layout.py b/tests/diffusion/distributed/test_expert_parallel_layout.py
index c4d3c6ae7..bea7e9ccf 100644
--- a/tests/diffusion/distributed/test_expert_parallel_layout.py
+++ b/tests/diffusion/distributed/test_expert_parallel_layout.py
@@ -193,7 +193,7 @@ def test_moe_ep_maps_diffusion_sp_cfg_dp_to_vllm_groups(monkeypatch):
 @pytest.mark.cpu
 @pytest.mark.core_model
 def test_cfg_parallel_keeps_diffusion_dp_without_ep(monkeypatch):
-    """vLLM DP should keep diffusion DP when expert parallelism is not enabled."""
+    """Without EP, keep diffusion DP and retain rank metadata for MC2."""
     local_rank = 0
     world_size = 8
 
@@ -249,7 +249,9 @@ def test_cfg_parallel_keeps_diffusion_dp_without_ep(monkeypatch):
     assert parallel_state.vllm_parallel_state._DP.local_group == [0, 4]
     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
+    assert parallel_state._EXPERT_PARALLEL_GROUP_RANKS == [
+        [0, 1, 2, 3, 4, 5, 6, 7],
+    ]
 
 
 @pytest.mark.cpu
diff --git a/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py b/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py
new file mode 100644
index 000000000..e861bd61a
--- /dev/null
+++ b/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py
@@ -0,0 +1,210 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""FLUX.2-dev VAE patch-parallel correctness tests.
+
+Compares vae_patch_parallel_size=1 vs 2 on TP=2 with tiling enabled:
+- Text-to-image decode path
+- Image-to-image encode + decode path (conditioning image)
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+from PIL import Image
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniRunner
+from vllm_omni.diffusion.data import DiffusionParallelConfig
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.outputs import OmniRequestOutput
+from vllm_omni.platforms import current_omni_platform
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+PROMPT = "a photo of a cat sitting on a laptop keyboard"
+NEGATIVE_PROMPT = "blurry, low quality"
+
+VAE_PP_MEAN_THRESHOLD = 3e-2
+VAE_PP_P99_THRESHOLD = 1e-1
+
+
+def _get_flux2_dev_model() -> str:
+    return os.environ.get("VLLM_TEST_FLUX2_DEV_MODEL", "black-forest-labs/FLUX.2-dev")
+
+
+def _pil_to_float_rgb_tensor(img: Image.Image) -> torch.Tensor:
+    arr = np.asarray(img.convert("RGB"), dtype=np.float32) / 255.0
+    return torch.from_numpy(arr)
+
+
+def _diff_metrics(a: Image.Image, b: Image.Image) -> tuple[float, float]:
+    ta = _pil_to_float_rgb_tensor(a)
+    tb = _pil_to_float_rgb_tensor(b)
+    assert ta.shape == tb.shape, f"Image shapes differ: {ta.shape} vs {tb.shape}"
+    abs_diff = torch.abs(ta - tb)
+    p99_abs_diff = torch.quantile(abs_diff.flatten(), 0.99).item()
+    return abs_diff.mean().item(), p99_abs_diff
+
+
+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:
+        raise ValueError("No request_output found in OmniRequestOutput")
+
+    req_out = first_output.request_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
+    if images is None or len(images) != 1:
+        raise ValueError(f"Expected 1 image, got {0 if images is None else len(images)}")
+    return images[0]
+
+
+def _run_flux2_generate(
+    *,
+    tp_size: int,
+    height: int,
+    width: int,
+    num_inference_steps: int,
+    seed: int,
+    vae_patch_parallel_size: int,
+    conditioning_image: Image.Image | None = None,
+) -> Image.Image:
+    current_omni_platform.empty_cache()
+
+    request: dict = {"prompt": PROMPT, "negative_prompt": NEGATIVE_PROMPT}
+    if conditioning_image is not None:
+        request["multi_modal_data"] = {"image": conditioning_image}
+
+    with OmniRunner(
+        _get_flux2_dev_model(),
+        parallel_config=DiffusionParallelConfig(
+            tensor_parallel_size=tp_size,
+            vae_patch_parallel_size=vae_patch_parallel_size,
+        ),
+        enable_cpu_offload=True,
+        vae_use_tiling=True,
+    ) as runner:
+        outputs = list(
+            runner.omni.generate(
+                request,
+                OmniDiffusionSamplingParams(
+                    height=height,
+                    width=width,
+                    num_inference_steps=num_inference_steps,
+                    guidance_scale=4.0,
+                    seed=seed,
+                    num_outputs_per_prompt=1,
+                ),
+            )
+        )
+
+    return _extract_single_image(outputs)
+
+
+@pytest.mark.advanced_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+def test_flux2_vae_patch_parallel_decode_tp2(tmp_path: Path):
+    if not current_omni_platform.is_available() or current_omni_platform.device_count() < 2:
+        pytest.skip("FLUX.2-dev VAE patch parallel requires >= 2 devices.")
+
+    height = 1152
+    width = 1152
+    num_inference_steps = 2
+    seed = 42
+
+    baseline_img = _run_flux2_generate(
+        tp_size=2,
+        height=height,
+        width=width,
+        num_inference_steps=num_inference_steps,
+        seed=seed,
+        vae_patch_parallel_size=1,
+    )
+    pp2_img = _run_flux2_generate(
+        tp_size=2,
+        height=height,
+        width=width,
+        num_inference_steps=num_inference_steps,
+        seed=seed,
+        vae_patch_parallel_size=2,
+    )
+
+    baseline_path = tmp_path / "flux2_tp2_vae_pp1.png"
+    pp2_path = tmp_path / "flux2_tp2_vae_pp2.png"
+    baseline_img.save(baseline_path)
+    pp2_img.save(pp2_path)
+
+    assert baseline_img.width == width and baseline_img.height == height
+    assert pp2_img.width == width and pp2_img.height == height
+
+    mean_abs_diff, p99_abs_diff = _diff_metrics(baseline_img, pp2_img)
+    print(
+        "FLUX.2-dev VAE patch parallel decode diff (TP=2, pp=1 vs pp=2): "
+        f"mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e}; "
+        f"thresholds: mean<={VAE_PP_MEAN_THRESHOLD:.6e}, p99<={VAE_PP_P99_THRESHOLD:.6e}; "
+        f"pp1_img={baseline_path}, pp2_img={pp2_path}"
+    )
+    assert mean_abs_diff <= VAE_PP_MEAN_THRESHOLD and p99_abs_diff <= VAE_PP_P99_THRESHOLD, (
+        f"Image diff exceeded threshold: mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e} "
+        f"(thresholds: mean<={VAE_PP_MEAN_THRESHOLD:.6e}, p99<={VAE_PP_P99_THRESHOLD:.6e})"
+    )
+
+
+@pytest.mark.advanced_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+def test_flux2_vae_patch_parallel_i2i_tp2(tmp_path: Path):
+    if not current_omni_platform.is_available() or current_omni_platform.device_count() < 2:
+        pytest.skip("FLUX.2-dev VAE patch parallel I2I requires >= 2 devices.")
+
+    height = 1152
+    width = 1152
+    num_inference_steps = 2
+    seed = 42
+    conditioning_image = Image.new("RGB", (width, height), (120, 80, 40))
+
+    baseline_img = _run_flux2_generate(
+        tp_size=2,
+        height=height,
+        width=width,
+        num_inference_steps=num_inference_steps,
+        seed=seed,
+        vae_patch_parallel_size=1,
+        conditioning_image=conditioning_image,
+    )
+    pp2_img = _run_flux2_generate(
+        tp_size=2,
+        height=height,
+        width=width,
+        num_inference_steps=num_inference_steps,
+        seed=seed,
+        vae_patch_parallel_size=2,
+        conditioning_image=conditioning_image,
+    )
+
+    baseline_path = tmp_path / "flux2_i2i_tp2_vae_pp1.png"
+    pp2_path = tmp_path / "flux2_i2i_tp2_vae_pp2.png"
+    baseline_img.save(baseline_path)
+    pp2_img.save(pp2_path)
+
+    mean_abs_diff, p99_abs_diff = _diff_metrics(baseline_img, pp2_img)
+    print(
+        "FLUX.2-dev VAE patch parallel I2I diff (TP=2, pp=1 vs pp=2): "
+        f"mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e}; "
+        f"thresholds: mean<={VAE_PP_MEAN_THRESHOLD:.6e}, p99<={VAE_PP_P99_THRESHOLD:.6e}; "
+        f"pp1_img={baseline_path}, pp2_img={pp2_path}"
+    )
+    assert mean_abs_diff <= VAE_PP_MEAN_THRESHOLD and p99_abs_diff <= VAE_PP_P99_THRESHOLD, (
+        f"Image diff exceeded threshold: mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e} "
+        f"(thresholds: mean<={VAE_PP_MEAN_THRESHOLD:.6e}, p99<={VAE_PP_P99_THRESHOLD:.6e})"
+    )
diff --git a/tests/diffusion/distributed/test_parallel_state_sp_groups.py b/tests/diffusion/distributed/test_parallel_state_sp_groups.py
index 9dda5610b..c12882a22 100644
--- a/tests/diffusion/distributed/test_parallel_state_sp_groups.py
+++ b/tests/diffusion/distributed/test_parallel_state_sp_groups.py
@@ -40,7 +40,7 @@ def test_set_seq_parallel_pg_uses_explicit_sp_groups(rank, expected_ulysses, exp
     # tp=2, sp=2 -> SP groups are non-contiguous: [0,2] and [1,3]
     sp_group_ranks = RankGenerator(2, 2, 1, 1, 1, "tp-sp-pp-cfg-dp").get_ranks("sp")
 
-    ulysses_pg, ring_pg = set_seq_parallel_pg(
+    ulysses_pg, ring_pg, allgather_pg = set_seq_parallel_pg(
         sp_ulysses_degree=2,
         sp_ring_degree=1,
         rank=rank,
@@ -50,6 +50,43 @@ def test_set_seq_parallel_pg_uses_explicit_sp_groups(rank, expected_ulysses, exp
 
     assert ulysses_pg.ranks == expected_ulysses
     assert ring_pg.ranks == expected_ring
+    assert allgather_pg.ranks == [rank]
+
+
+@pytest.mark.cpu
+@pytest.mark.parametrize("rank", [0, 1, 2, 3])
+def test_set_seq_parallel_pg_builds_independent_allgather_group(rank, monkeypatch):
+    created_groups: list[SimpleNamespace] = []
+    monkeypatch.setattr(torch.distributed, "new_group", _fake_new_group_factory(created_groups))
+    sp_group_ranks = [[0, 2], [1, 3]]
+
+    ulysses_pg, ring_pg, allgather_pg = set_seq_parallel_pg(
+        sp_ulysses_degree=1,
+        sp_ring_degree=1,
+        sp_allgather_degree=2,
+        rank=rank,
+        world_size=4,
+        sp_group_ranks=sp_group_ranks,
+    )
+
+    assert ulysses_pg.ranks == [rank]
+    assert ring_pg.ranks == [rank]
+    assert allgather_pg.ranks == ([0, 2] if rank % 2 == 0 else [1, 3])
+
+
+@pytest.mark.cpu
+def test_set_seq_parallel_pg_rejects_allgather_with_ulysses_or_ring(monkeypatch):
+    created_groups: list[SimpleNamespace] = []
+    monkeypatch.setattr(torch.distributed, "new_group", _fake_new_group_factory(created_groups))
+
+    with pytest.raises(ValueError, match="mutually exclusive"):
+        set_seq_parallel_pg(
+            sp_ulysses_degree=2,
+            sp_ring_degree=1,
+            sp_allgather_degree=2,
+            rank=0,
+            world_size=4,
+        )
 
 
 @pytest.mark.cpu
diff --git a/tests/diffusion/distributed/test_pipeline_parallel.py b/tests/diffusion/distributed/test_pipeline_parallel.py
index b76bf8c89..0b48ed266 100644
--- a/tests/diffusion/distributed/test_pipeline_parallel.py
+++ b/tests/diffusion/distributed/test_pipeline_parallel.py
@@ -1,8 +1,17 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Tests for PipelineParallelMixin and related PP communication helpers.
+
+CPU unit tests exercise mixin logic without a process group. Distributed CPU
+tests use gloo on CPU tensors; nightly parity tests run the same checks on
+real multi-GPU NCCL collectives.
+"""
+
+from __future__ import annotations
 
 import os
 import socket
+from typing import Literal
 
 import pytest
 import torch
@@ -11,6 +20,7 @@ from vllm.sequence import IntermediateTensors
 from vllm.v1.worker.gpu_worker import AsyncIntermediateTensors
 
 import vllm_omni.diffusion.distributed.pipeline_parallel as pp_module
+from tests.helpers.mark import hardware_marks
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.parallel_state import (
     destroy_distributed_env,
@@ -22,7 +32,12 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 from vllm_omni.diffusion.distributed.pipeline_parallel import AsyncLatents, PipelineParallelMixin
 from vllm_omni.platforms import current_omni_platform
 
-pytestmark = [pytest.mark.parallel]
+_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
+_L4_THREE_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=3)
+_L4_FOUR_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=4)
+
+DeviceKind = Literal["cpu", "cuda"]
+_UNIT_MARKS = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
 
 def _find_free_port() -> str:
@@ -36,6 +51,22 @@ def update_environment_variables(envs_dict: dict[str, str]) -> None:
         os.environ[k] = v
 
 
+def _cleanup_distributed() -> None:
+    """Destroy omni distributed state and clear test-process leftovers.
+
+    ``destroy_distributed_env`` leaves ``vllm.distributed.parallel_state._PP``
+    aliased to the destroyed group. Parent-process baselines must clear that
+    dangling reference (and RANK/MASTER_* env) so later unit tests that call
+    ``vllm.distributed.initialize_model_parallel`` do not see stale state.
+    """
+    destroy_distributed_env()
+    import vllm.distributed.parallel_state as vllm_parallel_state
+
+    vllm_parallel_state._PP = None
+    for key in ("MASTER_ADDR", "MASTER_PORT", "RANK", "WORLD_SIZE", "LOCAL_RANK"):
+        os.environ.pop(key, None)
+
+
 # ---------------------------------------------------------------------------
 # Shared stubs used by both unit and distributed tests
 # ---------------------------------------------------------------------------
@@ -143,7 +174,7 @@ class MockPipelineParallel(PipelineParallelMixin, CFGParallelMixin):
 class TestAsyncLatents:
     """Verifies the lazy-resolution behaviour of AsyncLatents without a real process group."""
 
-    pytestmark = [pytest.mark.cpu]
+    pytestmark = _UNIT_MARKS
 
     def _make(self, tensor: torch.Tensor, handles: list | None = None, postproc: list | None = None) -> AsyncLatents:
         return AsyncLatents({"latents": tensor}, handles or [], postproc or [])
@@ -214,7 +245,7 @@ class TestAsyncLatents:
 class TestSyncPPSend:
     """Verifies PipelineParallelMixin's internal PP-send flush."""
 
-    pytestmark = [pytest.mark.cpu]
+    pytestmark = _UNIT_MARKS
 
     @staticmethod
     def _make_pipeline() -> PipelineParallelMixin:
@@ -247,7 +278,7 @@ class TestSyncPPSend:
 class TestDiffuseWrapper:
     """Verifies that PipelineParallelMixin flushes pending sends when diffuse() exits."""
 
-    pytestmark = [pytest.mark.cpu]
+    pytestmark = _UNIT_MARKS
 
     def test_diffuse_flushes_pending_sends_on_success(self):
         work = FakeWork()
@@ -289,7 +320,7 @@ class TestDiffuseWrapper:
 
 
 class TestVaeDecodeGuard:
-    pytestmark = [pytest.mark.cpu]
+    pytestmark = _UNIT_MARKS
 
     @staticmethod
     def _make_pipeline(distributed_enabled: bool = False) -> PipelineParallelMixin:
@@ -351,6 +382,8 @@ class TestVaeDecodeGuard:
         assert pipeline.vae.decode.__doc__ == "Original decode docstring."
 
 
+@pytest.mark.core_model
+@pytest.mark.diffusion
 @pytest.mark.cpu
 def test_pipeline_parallel_requires_cfg_mixin():
     with pytest.raises(TypeError, match="inherits PipelineParallelMixin but not CFGParallelMixin"):
@@ -359,6 +392,8 @@ def test_pipeline_parallel_requires_cfg_mixin():
             pass
 
 
+@pytest.mark.core_model
+@pytest.mark.diffusion
 @pytest.mark.cpu
 def test_pipeline_parallel_requires_mro_before_cfg_mixin():
     with pytest.raises(TypeError, match="must inherit PipelineParallelMixin before CFGParallelMixin"):
@@ -372,10 +407,22 @@ def test_pipeline_parallel_requires_mro_before_cfg_mixin():
 # ---------------------------------------------------------------------------
 
 
-def init_dist(local_rank: int, world_size: int, master_port: str) -> torch.device:
+def _worker_device(local_rank: int, device_kind: DeviceKind) -> torch.device:
+    if device_kind == "cpu":
+        return torch.device("cpu")
+    return torch.device(f"{current_omni_platform.device_type}:{local_rank}")
+
+
+def init_dist(
+    local_rank: int,
+    world_size: int,
+    master_port: str,
+    device_kind: DeviceKind,
+) -> torch.device:
     """Initialise the distributed environment for a spawned worker."""
-    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
-    current_omni_platform.set_device(device)
+    device = _worker_device(local_rank, device_kind)
+    if device_kind == "cuda":
+        current_omni_platform.set_device(device)
     update_environment_variables(
         {
             "RANK": str(local_rank),
@@ -385,13 +432,31 @@ def init_dist(local_rank: int, world_size: int, master_port: str) -> torch.devic
             "MASTER_PORT": master_port,
         }
     )
-    init_distributed_environment()
+    backend = "gloo" if device_kind == "cpu" else None
+    init_distributed_environment(backend=backend)
     return device
 
 
+def _mp_backend(device_kind: DeviceKind) -> str | None:
+    """Backend for model-parallel process groups.
+
+    ``GroupCoordinator.all_gather`` always uses ``device_group``. CPU tensors
+    therefore require gloo device groups; otherwise a CUDA host's default NCCL
+    backend breaks PP+CFG CPU tests at CFG all_gather (pp2-cfg2).
+    isend/irecv of CPU tensors can already fall back to ``cpu_group``.
+    """
+    return "gloo" if device_kind == "cpu" else None
+
+
+def _seed_device(input_seed: int, device: torch.device) -> None:
+    torch.manual_seed(input_seed)
+    if device.type == "cuda":
+        torch.cuda.manual_seed_all(input_seed)
+
+
 def make_pipeline_and_inputs(
     test_config: dict, dtype: torch.dtype, device: torch.device, do_true_cfg: bool = False
-) -> tuple["MockPipelineParallel", dict, dict | None]:
+) -> tuple[MockPipelineParallel, dict, dict | None]:
     """Create a MockPipelineParallel and seeded inputs from a test_config dict.
 
     Must be called after ``initialize_model_parallel`` so that ``make_layers``
@@ -408,16 +473,12 @@ def make_pipeline_and_inputs(
         dtype=dtype,
     )
 
-    torch.manual_seed(test_config["input_seed"])
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(test_config["input_seed"])
+    _seed_device(test_config["input_seed"], device)
     pos_x = {"x": torch.randn(test_config["batch_size"], test_config["dim"], dtype=dtype, device=device)}
 
     negative_kwargs = None
     if do_true_cfg:
-        torch.manual_seed(test_config["input_seed"] + 1)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(test_config["input_seed"] + 1)
+        _seed_device(test_config["input_seed"] + 1, device)
         neg_x = torch.randn(test_config["batch_size"], test_config["dim"], dtype=dtype, device=device)
         negative_kwargs = {"x": neg_x}
 
@@ -425,19 +486,23 @@ def make_pipeline_and_inputs(
 
 
 # ---------------------------------------------------------------------------
-# 3.  isend_tensor_dict / irecv_tensor_dict  (2 GPUs)
+# 3.  isend_tensor_dict / irecv_tensor_dict
 # ---------------------------------------------------------------------------
 
 
-def isend_irecv_worker(local_rank: int, world_size: int, master_port: str, result_queue):
-    device = init_dist(local_rank, world_size, master_port)
-    initialize_model_parallel(pipeline_parallel_size=world_size)
+def isend_irecv_worker(
+    local_rank: int,
+    world_size: int,
+    master_port: str,
+    device_kind: DeviceKind,
+    result_queue,
+):
+    device = init_dist(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(pipeline_parallel_size=world_size, backend=_mp_backend(device_kind))
     pp_group = get_pp_group()
 
     if pp_group.is_first_rank:
-        torch.manual_seed(77)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(77)
+        _seed_device(77, device)
         tensor = torch.randn(3, 5, dtype=torch.float32, device=device)
         handles = pp_group.isend_tensor_dict({"t": tensor})
         for h in handles:
@@ -449,27 +514,42 @@ def isend_irecv_worker(local_rank: int, world_size: int, master_port: str, resul
 
     if torch.distributed.is_initialized():
         torch.distributed.barrier()
-    destroy_distributed_env()
+    _cleanup_distributed()
 
 
-@pytest.mark.gpu
-@pytest.mark.skipif(current_omni_platform.get_device_count() < 2, reason="Need at least 2 GPUs")
-@pytest.mark.parametrize("pp_size", [2])
-def test_isend_irecv_tensor_dict(pp_size: int):
-    """isend_tensor_dict / irecv_tensor_dict transfer a tensor dict without loss."""
+def _run_isend_irecv(pp_size: int, device_kind: DeviceKind, master_port: str) -> None:
     mp_context = torch.multiprocessing.get_context("spawn")
     manager = mp_context.Manager()
     q = manager.Queue()
-
-    port = _find_free_port()
-    torch.multiprocessing.spawn(isend_irecv_worker, args=(pp_size, port, q), nprocs=pp_size)
-
+    torch.multiprocessing.spawn(
+        isend_irecv_worker,
+        args=(pp_size, master_port, device_kind, q),
+        nprocs=pp_size,
+    )
     results = {label: tensor for label, tensor in [q.get(), q.get()]}
     torch.testing.assert_close(
         results["received"], results["sent"], rtol=0, atol=0, msg="isend/irecv transferred tensor incorrectly"
     )
 
 
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize("pp_size", [2])
+def test_isend_irecv_tensor_dict(pp_size: int):
+    """isend_tensor_dict / irecv_tensor_dict transfer a tensor dict without loss."""
+    _run_isend_irecv(pp_size, device_kind="cpu", master_port=_find_free_port())
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize("pp_size", [pytest.param(2, marks=_L4_TWO_GPU)])
+def test_isend_irecv_tensor_dict_parity(pp_size: int):
+    """Nightly: isend/irecv on real multi-GPU NCCL."""
+    _run_isend_irecv(pp_size, device_kind="cuda", master_port=_find_free_port())
+
+
 # ---------------------------------------------------------------------------
 # 4.  predict_noise_maybe_with_cfg
 # ---------------------------------------------------------------------------
@@ -477,12 +557,13 @@ def test_isend_irecv_tensor_dict(pp_size: int):
 _baseline_cache: dict[tuple, torch.Tensor] = {}
 
 
-def compute_single_gpu_baseline(test_config: dict, dtype: torch.dtype, do_true_cfg: bool) -> torch.Tensor:
-    """Compute expected single-GPU output using the same MockPipelineParallel.
-
-    Initializes a trivial distributed env (world_size=1) so that ``make_layers`` and the PP/CFG mixins work normally.
-    Results are cached so identical configs are only computed once.
-    """
+def compute_single_gpu_baseline(
+    test_config: dict,
+    dtype: torch.dtype,
+    do_true_cfg: bool,
+    device_kind: DeviceKind,
+) -> torch.Tensor:
+    """Compute expected single-process output using the same MockPipelineParallel."""
     key = (
         test_config["num_layers"],
         test_config["dim"],
@@ -492,27 +573,29 @@ def compute_single_gpu_baseline(test_config: dict, dtype: torch.dtype, do_true_c
         test_config["cfg_scale"],
         dtype,
         do_true_cfg,
+        device_kind,
     )
     if key in _baseline_cache:
         return _baseline_cache[key]
 
-    device = init_dist(0, 1, _find_free_port())
-    initialize_model_parallel(pipeline_parallel_size=1)
+    device = init_dist(0, 1, _find_free_port(), device_kind)
+    try:
+        initialize_model_parallel(pipeline_parallel_size=1, backend=_mp_backend(device_kind))
 
-    pipeline, positive_kwargs, negative_kwargs = make_pipeline_and_inputs(
-        test_config, dtype, device, do_true_cfg=do_true_cfg
-    )
-
-    with torch.inference_mode():
-        noise_pred = pipeline.predict_noise_maybe_with_cfg(
-            do_true_cfg=do_true_cfg,
-            true_cfg_scale=test_config["cfg_scale"],
-            positive_kwargs=positive_kwargs,
-            negative_kwargs=negative_kwargs,
-            cfg_normalize=False,
+        pipeline, positive_kwargs, negative_kwargs = make_pipeline_and_inputs(
+            test_config, dtype, device, do_true_cfg=do_true_cfg
         )
 
-    destroy_distributed_env()
+        with torch.inference_mode():
+            noise_pred = pipeline.predict_noise_maybe_with_cfg(
+                do_true_cfg=do_true_cfg,
+                true_cfg_scale=test_config["cfg_scale"],
+                positive_kwargs=positive_kwargs,
+                negative_kwargs=negative_kwargs,
+                cfg_normalize=False,
+            )
+    finally:
+        _cleanup_distributed()
 
     _baseline_cache[key] = noise_pred.cpu()
     return _baseline_cache[key]
@@ -527,11 +610,16 @@ def predict_noise_worker(
     do_true_cfg: bool,
     dtype: torch.dtype,
     test_config: dict,
+    device_kind: DeviceKind,
     result_queue,
 ):
     """Generic predict-noise worker parameterized by PP and CFG topology."""
-    device = init_dist(local_rank, world_size, master_port)
-    initialize_model_parallel(pipeline_parallel_size=pp_size, cfg_parallel_size=cfg_size)
+    device = init_dist(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(
+        pipeline_parallel_size=pp_size,
+        cfg_parallel_size=cfg_size,
+        backend=_mp_backend(device_kind),
+    )
 
     pp_group = get_pp_group()
     cfg_rank = get_classifier_free_guidance_rank()
@@ -548,8 +636,6 @@ def predict_noise_worker(
             negative_kwargs=negative_kwargs,
             cfg_normalize=False,
         )
-    # This worker exercises predict_noise_maybe_with_cfg directly, bypassing diffuse().
-    # Flush the non-last PP rank's async send before barrier / process teardown.
     pipeline._sync_pp_send()
 
     if pp_group.is_last_rank:
@@ -561,77 +647,22 @@ def predict_noise_worker(
 
     if torch.distributed.is_initialized():
         torch.distributed.barrier()
-    destroy_distributed_env()
+    _cleanup_distributed()
 
 
-@pytest.mark.gpu
-@pytest.mark.parametrize(
-    "pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_seed, rtol, atol",
-    [
-        pytest.param(
-            2,
-            1,
-            False,
-            torch.float32,
-            4,
-            100,
-            1e-5,
-            1e-5,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 2, reason="Need at least 2 GPUs"),
-            id="pp2-no_cfg-float32",
-        ),
-        pytest.param(
-            2,
-            1,
-            False,
-            torch.bfloat16,
-            4,
-            100,
-            1e-2,
-            1e-2,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 2, reason="Need at least 2 GPUs"),
-            id="pp2-no_cfg-bfloat16",
-        ),
-        pytest.param(
-            2,
-            1,
-            True,
-            torch.bfloat16,
-            4,
-            100,
-            1e-2,
-            1e-2,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 2, reason="Need at least 2 GPUs"),
-            id="pp2-seq_cfg-bfloat16",
-        ),
-        pytest.param(
-            2,
-            2,
-            True,
-            torch.bfloat16,
-            4,
-            100,
-            1e-2,
-            1e-2,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 4, reason="Need at least 4 GPUs"),
-            id="pp2-cfg2-bfloat16",
-        ),
-        pytest.param(
-            3,
-            1,
-            False,
-            torch.bfloat16,
-            6,
-            100,
-            1e-2,
-            1e-2,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 3, reason="Need at least 3 GPUs"),
-            id="pp3-no_cfg-bfloat16",
-        ),
-    ],
-)
-def test_predict_noise(pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_seed, rtol, atol):
-    """predict_noise_maybe_with_cfg output matches the single-GPU baseline across PP / CFG topologies."""
+def _run_predict_noise(
+    *,
+    pp_size: int,
+    cfg_size: int,
+    do_true_cfg: bool,
+    dtype: torch.dtype,
+    num_layers: int,
+    input_seed: int,
+    rtol: float,
+    atol: float,
+    device_kind: DeviceKind,
+    master_port: str,
+) -> None:
     test_config = {
         "num_layers": num_layers,
         "dim": 64,
@@ -641,22 +672,20 @@ def test_predict_noise(pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_
         "input_seed": input_seed,
     }
 
-    baseline_out = compute_single_gpu_baseline(test_config, dtype, do_true_cfg)
+    baseline_out = compute_single_gpu_baseline(test_config, dtype, do_true_cfg, device_kind)
 
     mp_context = torch.multiprocessing.get_context("spawn")
     manager = mp_context.Manager()
     pp_q = manager.Queue()
 
     world_size = pp_size * cfg_size
-    port = _find_free_port()
     torch.multiprocessing.spawn(
         predict_noise_worker,
-        args=(world_size, port, pp_size, cfg_size, do_true_cfg, dtype, test_config, pp_q),
+        args=(world_size, master_port, pp_size, cfg_size, do_true_cfg, dtype, test_config, device_kind, pp_q),
         nprocs=world_size,
     )
 
     pp_out = pp_q.get()
-
     assert baseline_out.shape == pp_out.shape
     torch.testing.assert_close(
         pp_out,
@@ -667,35 +696,157 @@ def test_predict_noise(pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_
     )
 
 
+_CPU_PREDICT_NOISE_CASES = [
+    pytest.param(2, 1, False, 4, 100, 1e-5, 1e-5, id="pp2-no_cfg"),
+    pytest.param(2, 1, True, 4, 100, 1e-5, 1e-5, id="pp2-seq_cfg"),
+    pytest.param(2, 2, True, 4, 100, 1e-5, 1e-5, id="pp2-cfg2"),
+    pytest.param(3, 1, False, 6, 100, 1e-5, 1e-5, id="pp3-no_cfg"),
+]
+
+_GPU_PREDICT_NOISE_CASES = [
+    pytest.param(
+        2,
+        1,
+        False,
+        torch.float32,
+        4,
+        100,
+        1e-5,
+        1e-5,
+        marks=_L4_TWO_GPU,
+        id="pp2-no_cfg-float32",
+    ),
+    pytest.param(
+        2,
+        1,
+        False,
+        torch.bfloat16,
+        4,
+        100,
+        1e-2,
+        1e-2,
+        marks=_L4_TWO_GPU,
+        id="pp2-no_cfg-bfloat16",
+    ),
+    pytest.param(
+        2,
+        1,
+        True,
+        torch.bfloat16,
+        4,
+        100,
+        1e-2,
+        1e-2,
+        marks=_L4_TWO_GPU,
+        id="pp2-seq_cfg-bfloat16",
+    ),
+    pytest.param(
+        2,
+        2,
+        True,
+        torch.bfloat16,
+        4,
+        100,
+        1e-2,
+        1e-2,
+        marks=_L4_FOUR_GPU,
+        id="pp2-cfg2-bfloat16",
+    ),
+    pytest.param(
+        3,
+        1,
+        False,
+        torch.bfloat16,
+        6,
+        100,
+        1e-2,
+        1e-2,
+        marks=_L4_THREE_GPU,
+        id="pp3-no_cfg-bfloat16",
+    ),
+]
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    "pp_size, cfg_size, do_true_cfg, num_layers, input_seed, rtol, atol",
+    _CPU_PREDICT_NOISE_CASES,
+)
+def test_predict_noise(pp_size, cfg_size, do_true_cfg, num_layers, input_seed, rtol, atol):
+    """predict_noise_maybe_with_cfg output matches baseline across PP / CFG topologies."""
+    _run_predict_noise(
+        pp_size=pp_size,
+        cfg_size=cfg_size,
+        do_true_cfg=do_true_cfg,
+        dtype=torch.float32,
+        num_layers=num_layers,
+        input_seed=input_seed,
+        rtol=rtol,
+        atol=atol,
+        device_kind="cpu",
+        master_port=_find_free_port(),
+    )
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_seed, rtol, atol",
+    _GPU_PREDICT_NOISE_CASES,
+)
+def test_predict_noise_parity(pp_size, cfg_size, do_true_cfg, dtype, num_layers, input_seed, rtol, atol):
+    """Nightly: predict_noise parity on real multi-GPU NCCL."""
+    _run_predict_noise(
+        pp_size=pp_size,
+        cfg_size=cfg_size,
+        do_true_cfg=do_true_cfg,
+        dtype=dtype,
+        num_layers=num_layers,
+        input_seed=input_seed,
+        rtol=rtol,
+        atol=atol,
+        device_kind="cuda",
+        master_port=_find_free_port(),
+    )
+
+
 # ---------------------------------------------------------------------------
 # 5.  scheduler_step_maybe_with_cfg
 # ---------------------------------------------------------------------------
 
 
-def compute_scheduler_step_baseline(test_config: dict, do_true_cfg: bool) -> torch.Tensor:
-    """Single-GPU reference: predict_noise + scheduler_step."""
-    device = init_dist(0, 1, _find_free_port())
-    initialize_model_parallel(pipeline_parallel_size=1)
+def compute_scheduler_step_baseline(
+    test_config: dict,
+    do_true_cfg: bool,
+    device_kind: DeviceKind,
+) -> torch.Tensor:
+    """Single-process reference: predict_noise + scheduler_step."""
+    device = init_dist(0, 1, _find_free_port(), device_kind)
+    try:
+        initialize_model_parallel(pipeline_parallel_size=1, backend=_mp_backend(device_kind))
 
-    pipeline, positive_kwargs, negative_kwargs = make_pipeline_and_inputs(
-        test_config, torch.float32, device, do_true_cfg=do_true_cfg
-    )
-    latents = positive_kwargs["x"]
-    t = torch.tensor(500, device=device)
-
-    with torch.inference_mode():
-        noise_pred = pipeline.predict_noise_maybe_with_cfg(
-            do_true_cfg=do_true_cfg,
-            true_cfg_scale=test_config["cfg_scale"],
-            positive_kwargs=positive_kwargs,
-            negative_kwargs=negative_kwargs,
-            cfg_normalize=False,
-        )
-        result = pipeline.scheduler_step_maybe_with_cfg(
-            noise_pred=noise_pred, t=t, latents=latents, do_true_cfg=do_true_cfg
+        pipeline, positive_kwargs, negative_kwargs = make_pipeline_and_inputs(
+            test_config, torch.float32, device, do_true_cfg=do_true_cfg
         )
+        latents = positive_kwargs["x"]
+        t = torch.tensor(500, device=device)
 
-    destroy_distributed_env()
+        with torch.inference_mode():
+            noise_pred = pipeline.predict_noise_maybe_with_cfg(
+                do_true_cfg=do_true_cfg,
+                true_cfg_scale=test_config["cfg_scale"],
+                positive_kwargs=positive_kwargs,
+                negative_kwargs=negative_kwargs,
+                cfg_normalize=False,
+            )
+            result = pipeline.scheduler_step_maybe_with_cfg(
+                noise_pred=noise_pred, t=t, latents=latents, do_true_cfg=do_true_cfg
+            )
+    finally:
+        _cleanup_distributed()
     return result.cpu()
 
 
@@ -707,10 +858,15 @@ def scheduler_step_worker(
     cfg_size: int,
     do_true_cfg: bool,
     test_config: dict,
+    device_kind: DeviceKind,
     result_queue,
 ):
-    device = init_dist(local_rank, world_size, master_port)
-    initialize_model_parallel(pipeline_parallel_size=pp_size, cfg_parallel_size=cfg_size)
+    device = init_dist(local_rank, world_size, master_port, device_kind)
+    initialize_model_parallel(
+        pipeline_parallel_size=pp_size,
+        cfg_parallel_size=cfg_size,
+        backend=_mp_backend(device_kind),
+    )
 
     pp_group = get_pp_group()
     cfg_rank = get_classifier_free_guidance_rank()
@@ -732,43 +888,25 @@ def scheduler_step_worker(
         latents = pipeline.scheduler_step_maybe_with_cfg(
             noise_pred=noise_pred, t=t, latents=latents, do_true_cfg=do_true_cfg
         )
-    # This worker exercises scheduler_step_maybe_with_cfg directly, bypassing diffuse().
-    # Flush the last PP rank's async latent send before barrier / process teardown.
     pipeline._sync_pp_send()
 
     if pp_group.is_first_rank and cfg_rank == 0:
-        resolved = latents.contiguous()
-        result_queue.put(resolved.cpu())
+        result_queue.put(latents.contiguous().cpu())
 
     if torch.distributed.is_initialized():
         torch.distributed.barrier()
-    destroy_distributed_env()
+    _cleanup_distributed()
 
 
-@pytest.mark.gpu
-@pytest.mark.parametrize(
-    "pp_size, cfg_size, do_true_cfg, input_seed",
-    [
-        pytest.param(
-            2,
-            1,
-            False,
-            300,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 2, reason="Need at least 2 GPUs"),
-            id="pp2-no_cfg",
-        ),
-        pytest.param(
-            2,
-            2,
-            True,
-            600,
-            marks=pytest.mark.skipif(current_omni_platform.get_device_count() < 4, reason="Need at least 4 GPUs"),
-            id="pp2-cfg2-true_cfg",
-        ),
-    ],
-)
-def test_scheduler_step(pp_size, cfg_size, do_true_cfg, input_seed):
-    """Rank 0 latents after scheduler_step match the single-GPU baseline across PP / CFG topologies."""
+def _run_scheduler_step(
+    *,
+    pp_size: int,
+    cfg_size: int,
+    do_true_cfg: bool,
+    input_seed: int,
+    device_kind: DeviceKind,
+    master_port: str,
+) -> None:
     test_config = {
         "num_layers": 4,
         "dim": 64,
@@ -778,17 +916,16 @@ def test_scheduler_step(pp_size, cfg_size, do_true_cfg, input_seed):
         "input_seed": input_seed,
     }
 
-    baseline = compute_scheduler_step_baseline(test_config, do_true_cfg)
+    baseline = compute_scheduler_step_baseline(test_config, do_true_cfg, device_kind)
 
     mp_context = torch.multiprocessing.get_context("spawn")
     manager = mp_context.Manager()
     q = manager.Queue()
 
-    port = _find_free_port()
     world_size = pp_size * cfg_size
     torch.multiprocessing.spawn(
         scheduler_step_worker,
-        args=(world_size, port, pp_size, cfg_size, do_true_cfg, test_config, q),
+        args=(world_size, master_port, pp_size, cfg_size, do_true_cfg, test_config, device_kind, q),
         nprocs=world_size,
     )
 
@@ -800,3 +937,47 @@ def test_scheduler_step(pp_size, cfg_size, do_true_cfg, input_seed):
         atol=0,
         msg=f"PP={pp_size} CFG={cfg_size} scheduler step latents on rank 0 do not match single-GPU baseline",
     )
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    "pp_size, cfg_size, do_true_cfg, input_seed",
+    [
+        pytest.param(2, 1, False, 300, id="pp2-no_cfg"),
+        pytest.param(2, 2, True, 600, id="pp2-cfg2-true_cfg"),
+    ],
+)
+def test_scheduler_step(pp_size, cfg_size, do_true_cfg, input_seed):
+    """Rank 0 latents after scheduler_step match baseline across PP / CFG topologies."""
+    _run_scheduler_step(
+        pp_size=pp_size,
+        cfg_size=cfg_size,
+        do_true_cfg=do_true_cfg,
+        input_seed=input_seed,
+        device_kind="cpu",
+        master_port=_find_free_port(),
+    )
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@pytest.mark.parametrize(
+    "pp_size, cfg_size, do_true_cfg, input_seed",
+    [
+        pytest.param(2, 1, False, 300, marks=_L4_TWO_GPU, id="pp2-no_cfg"),
+        pytest.param(2, 2, True, 600, marks=_L4_FOUR_GPU, id="pp2-cfg2-true_cfg"),
+    ],
+)
+def test_scheduler_step_parity(pp_size, cfg_size, do_true_cfg, input_seed):
+    """Nightly: scheduler_step parity on real multi-GPU NCCL."""
+    _run_scheduler_step(
+        pp_size=pp_size,
+        cfg_size=cfg_size,
+        do_true_cfg=do_true_cfg,
+        input_seed=input_seed,
+        device_kind="cuda",
+        master_port=_find_free_port(),
+    )
diff --git a/tests/diffusion/distributed/test_zimage_parallelism.py b/tests/diffusion/distributed/test_tensor_parallel.py
similarity index 53%
rename from tests/diffusion/distributed/test_zimage_parallelism.py
rename to tests/diffusion/distributed/test_tensor_parallel.py
index ab330ee9a..9f39112ae 100644
--- a/tests/diffusion/distributed/test_zimage_parallelism.py
+++ b/tests/diffusion/distributed/test_tensor_parallel.py
@@ -1,16 +1,14 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""Z-Image end-to-end tests for diffusion parallelism.
+"""DiT tensor-parallel parity and perf checks for diffusion models.
 
-This file currently covers:
-- DiT tensor parallelism (TP=2) vs TP=1.
-- VAE patch parallelism (vae_patch_parallel_size=2) vs baseline on TP=2.
-
-Note: CUDA-only (>=2 GPUs). We use `enforce_eager=False` (default) to enable
-`torch.compile`.
+Compares TP=2 against TP=1 on output correctness, latency, and peak memory.
+Uses ``Tongyi-MAI/Z-Image-Turbo`` as the parity model.
 """
 
+from __future__ import annotations
+
 import os
 import time
 from pathlib import Path
@@ -31,22 +29,15 @@ from vllm_omni.platforms import current_omni_platform
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
 PROMPT = "a photo of a cat sitting on a laptop keyboard"
-
-
-def _get_zimage_model() -> str:
-    # Allow overriding the model for local/offline environments.
-    # Can be either a HuggingFace repo id or a local path.
-    return os.environ.get("VLLM_TEST_ZIMAGE_MODEL", "Tongyi-MAI/Z-Image-Turbo")
+DEFAULT_MODEL = "Tongyi-MAI/Z-Image-Turbo"
 
 
 def _pil_to_float_rgb_tensor(img: Image.Image) -> torch.Tensor:
-    """Convert PIL image to float32 RGB tensor in [0, 1] with shape [H, W, 3]."""
     arr = np.asarray(img.convert("RGB"), dtype=np.float32) / 255.0
     return torch.from_numpy(arr)
 
 
 def _diff_metrics(a: Image.Image, b: Image.Image) -> tuple[float, float]:
-    """Return (mean_abs_diff, p99_abs_diff) over RGB pixels in [0, 1]."""
     ta = _pil_to_float_rgb_tensor(a)
     tb = _pil_to_float_rgb_tensor(b)
     assert ta.shape == tb.shape, f"Image shapes differ: {ta.shape} vs {tb.shape}"
@@ -71,7 +62,7 @@ def _extract_single_image(outputs) -> Image.Image:
     return images[0]
 
 
-def _run_zimage_generate(
+def _run_generate(
     *,
     tp_size: int,
     height: int,
@@ -79,8 +70,6 @@ def _run_zimage_generate(
     num_inference_steps: int,
     seed: int,
     enforce_eager: bool,
-    vae_use_tiling: bool = False,
-    vae_patch_parallel_size: int = 1,
     num_requests: int = 4,
 ) -> tuple[Image.Image, float, float]:
     if num_requests < 2:
@@ -91,25 +80,11 @@ def _run_zimage_generate(
     monitor = DeviceMemoryMonitor(device_index=device_index, interval=0.02)
     monitor.start()
     try:
-        # Each run needs a distinct DiffusionParallelConfig; use OmniRunner per call (not the
-        # parametrized omni_runner fixture, which is fixed per module).
         with OmniRunner(
-            _get_zimage_model(),
-            parallel_config=DiffusionParallelConfig(
-                tensor_parallel_size=tp_size,
-                vae_patch_parallel_size=vae_patch_parallel_size,
-            ),
+            DEFAULT_MODEL,
+            parallel_config=DiffusionParallelConfig(tensor_parallel_size=tp_size),
             enforce_eager=enforce_eager,
-            vae_use_tiling=vae_use_tiling,
         ) as runner:
-            # NOTE: Omni closes itself when a generate() call is exhausted.
-            # To avoid measuring teardown time (process shutdown, memory cleanup),
-            # we measure the latency to produce *subsequent* outputs within a single
-            # generator run.
-            #
-            # This also serves as a warmup: the first output may include extra
-            # compilation/caching overhead, while later outputs are closer to
-            # steady-state inference.
             gen = runner.omni.generate(
                 [PROMPT] * num_requests,
                 OmniDiffusionSamplingParams(
@@ -134,14 +109,11 @@ def _run_zimage_generate(
                 per_request_times_s.append(t_now - t_prev)
                 t_prev = t_now
 
-            # Ensure the generator is fully consumed so it can clean up.
             for _ in gen:
                 pass
 
             median_time_s = float(np.median(per_request_times_s))
-
             peak_memory_mb = monitor.peak_used_mb
-
             return _extract_single_image([last_output]), median_time_s, peak_memory_mb
     finally:
         monitor.stop()
@@ -151,20 +123,20 @@ def _run_zimage_generate(
 @pytest.mark.diffusion
 @pytest.mark.parallel
 @hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
-def test_zimage_tensor_parallel_tp2(tmp_path: Path):
+def test_tensor_parallel_tp2(tmp_path: Path):
     if current_omni_platform.is_npu():
-        pytest.skip("Z-Image TP e2e test is only supported on CUDA and ROCm for now.")
+        pytest.skip("Tensor parallel parity test is only supported on CUDA and ROCm for now.")
     if not current_omni_platform.is_available() or current_omni_platform.device_count() < 2:
-        pytest.skip("Z-Image TP=2 requires >= 2 devices.")
+        pytest.skip("Tensor parallel TP=2 requires >= 2 devices.")
 
+    model_name = DEFAULT_MODEL
     enforce_eager = False
-
     height = 512
     width = 512
     num_inference_steps = 2
     seed = 42
 
-    tp1_img, tp1_time_s, tp1_peak_mem = _run_zimage_generate(
+    tp1_img, tp1_time_s, tp1_peak_mem = _run_generate(
         tp_size=1,
         height=height,
         width=width,
@@ -172,7 +144,7 @@ def test_zimage_tensor_parallel_tp2(tmp_path: Path):
         seed=seed,
         enforce_eager=enforce_eager,
     )
-    tp2_img, tp2_time_s, tp2_peak_mem = _run_zimage_generate(
+    tp2_img, tp2_time_s, tp2_peak_mem = _run_generate(
         tp_size=2,
         height=height,
         width=width,
@@ -181,8 +153,8 @@ def test_zimage_tensor_parallel_tp2(tmp_path: Path):
         enforce_eager=enforce_eager,
     )
 
-    tp1_path = tmp_path / "zimage_tp1.png"
-    tp2_path = tmp_path / "zimage_tp2.png"
+    tp1_path = tmp_path / "tp1.png"
+    tp2_path = tmp_path / "tp2.png"
     tp1_img.save(tp1_path)
     tp2_img.save(tp2_path)
 
@@ -193,7 +165,7 @@ def test_zimage_tensor_parallel_tp2(tmp_path: Path):
     mean_threshold = 3e-2
     p99_threshold = 2.5e-1
     print(
-        "Z-Image TP image diff stats (TP=1 vs TP=2): "
+        f"{model_name} TP image diff (TP=1 vs TP=2): "
         f"mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e}; "
         f"thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e}; "
         f"tp1_img={tp1_path}, tp2_img={tp2_path}"
@@ -203,73 +175,11 @@ def test_zimage_tensor_parallel_tp2(tmp_path: Path):
         f"(thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e})"
     )
 
-    print(f"Z-Image TP perf (lower is better): tp1_time_s={tp1_time_s:.6f}, tp2_time_s={tp2_time_s:.6f}")
-    # ROCm is not optimized TP2 can be slower than TP1
+    print(f"TP perf (lower is better): tp1_time_s={tp1_time_s:.6f}, tp2_time_s={tp2_time_s:.6f}")
     if not current_omni_platform.is_rocm():
         assert tp2_time_s < tp1_time_s, f"Expected TP=2 to be faster than TP=1 (tp1={tp1_time_s}, tp2={tp2_time_s})"
 
-    print(f"Z-Image TP peak memory (MB): tp1_peak_mem={tp1_peak_mem:.2f}, tp2_peak_mem={tp2_peak_mem:.2f}")
+    print(f"TP peak memory (MB): tp1_peak_mem={tp1_peak_mem:.2f}, tp2_peak_mem={tp2_peak_mem:.2f}")
     assert tp2_peak_mem < tp1_peak_mem, (
         f"Expected TP=2 to use less peak memory than TP=1 (tp1={tp1_peak_mem}, tp2={tp2_peak_mem})"
     )
-
-
-@pytest.mark.advanced_model
-@pytest.mark.diffusion
-@pytest.mark.parallel
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
-def test_zimage_vae_patch_parallel_tp2(tmp_path: Path):
-    if current_omni_platform.is_npu():
-        pytest.skip("Z-Image VAE patch parallel e2e test is only supported on CUDA and ROCm for now.")
-    if not current_omni_platform.is_available() or current_omni_platform.device_count() < 2:
-        pytest.skip("Z-Image VAE patch parallel TP=2 requires >= 2 devices.")
-
-    enforce_eager = False
-
-    # Use a larger image to ensure there are multiple VAE tiles.
-    height = 1152
-    width = 1152
-    num_inference_steps = 2
-    seed = 42
-
-    baseline_img, _baseline_time_s, _baseline_peak_mem = _run_zimage_generate(
-        tp_size=2,
-        height=height,
-        width=width,
-        num_inference_steps=num_inference_steps,
-        seed=seed,
-        enforce_eager=enforce_eager,
-        vae_use_tiling=True,
-        vae_patch_parallel_size=1,
-        num_requests=2,
-    )
-    pp2_img, _pp2_time_s, _pp2_peak_mem = _run_zimage_generate(
-        tp_size=2,
-        height=height,
-        width=width,
-        num_inference_steps=num_inference_steps,
-        seed=seed,
-        enforce_eager=enforce_eager,
-        vae_use_tiling=True,
-        vae_patch_parallel_size=2,
-        num_requests=2,
-    )
-
-    baseline_path = tmp_path / "zimage_tp2_vae_pp1.png"
-    pp2_path = tmp_path / "zimage_tp2_vae_pp2.png"
-    baseline_img.save(baseline_path)
-    pp2_img.save(pp2_path)
-
-    mean_abs_diff, p99_abs_diff = _diff_metrics(baseline_img, pp2_img)
-    mean_threshold = 5e-3
-    p99_threshold = 1e-1
-    print(
-        "Z-Image VAE patch parallel image diff stats (TP=2, pp=1 vs pp=2): "
-        f"mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e}; "
-        f"thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e}; "
-        f"pp1_img={baseline_path}, pp2_img={pp2_path}"
-    )
-    assert mean_abs_diff <= mean_threshold and p99_abs_diff <= p99_threshold, (
-        f"Image diff exceeded threshold: mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e} "
-        f"(thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e})"
-    )
diff --git a/tests/diffusion/distributed/test_vae_decode_parallelism.py b/tests/diffusion/distributed/test_vae_decode_parallelism.py
index 2fd531e3e..c3996fc23 100644
--- a/tests/diffusion/distributed/test_vae_decode_parallelism.py
+++ b/tests/diffusion/distributed/test_vae_decode_parallelism.py
@@ -1,151 +1,181 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""VAE patch-parallel decode parity tests for diffusion models.
+
+Compares ``vae_patch_parallel_size=2`` against ``vae_patch_parallel_size=1`` on
+TP=2 with VAE tiling enabled. Covers one video model (Wan T2V) and one image
+model (Qwen-Image). CUDA/ROCm-only (>=2 devices).
+"""
+
+from __future__ import annotations
+
 import os
-import sys
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 import pytest
 import torch
 from PIL import Image
-from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
 
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniRunner
 from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-# ruff: noqa: E402
-REPO_ROOT = Path(__file__).resolve().parents[2]
-if str(REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(REPO_ROOT))
-
-import time
-
-from tests.helpers.runtime import OmniRunner
 from vllm_omni.platforms import current_omni_platform
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
-all_model_configs = [
-    {
-        "model_name": "Wan-AI/Wan2.2-TI2V-5B-Diffusers",
-        "out_width": 1280,
-        "out_height": 720,
-        "out_frames": 16,
-    },
-    {
-        "model_name": "Wan-AI/Wan2.2-T2V-A14B-Diffusers",
-        "out_width": 1280,
-        "out_height": 720,
-        "out_frames": 16,
-    },
-    {
-        "model_name": "Wan-AI/Wan2.2-I2V-A14B-Diffusers",
-        "out_width": 1280,
-        "out_height": 720,
-        "out_frames": 16,
-    },
-    {
-        "model_name": "Qwen/Qwen-Image",
-        "out_width": 3072,
-        "out_height": 3072,
-        "out_frames": 1,
-    },
-    # {
-    #     "model_name": "stepfun-ai/NextStep-1.1",
-    #     "out_width": 3072,
-    #     "out_height": 3072,
-    #     "out_frames": 1,
-    # },
+PROMPT = "A cat sitting on a table"
+
+MODEL_CASES = [
+    pytest.param(
+        {
+            "model_name": "Wan-AI/Wan2.2-T2V-A14B-Diffusers",
+            "height": 512,
+            "width": 512,
+            "num_frames": 5,
+            "needs_image": False,
+            "is_moe": False,
+            "mean_threshold": 3e-2,
+            "p99_threshold": 4e-2,
+        },
+        id="wan22_t2v_a14b",
+    ),
+    pytest.param(
+        {
+            "model_name": "Qwen/Qwen-Image",
+            "height": 1152,
+            "width": 1152,
+            "num_frames": 1,
+            "needs_image": False,
+            "is_moe": False,
+            "mean_threshold": 5e-3,
+            "p99_threshold": 1e-1,
+        },
+        id="qwen_image",
+    ),
 ]
 
 
-def is_nextstep_model(model_name: str) -> bool:
-    """Check if the model is a NextStep model by reading its config."""
-    from vllm.transformers_utils.config import get_hf_file_to_dict
-
-    try:
-        cfg = get_hf_file_to_dict("config.json", model_name)
-        if cfg and cfg.get("model_type") == "nextstep":
-            return True
-    except Exception:
-        pass
-    return False
+def _to_float_array(data: Any) -> np.ndarray:
+    if isinstance(data, Image.Image):
+        return np.asarray(data.convert("RGB"), dtype=np.float32) / 255.0
+    if isinstance(data, torch.Tensor):
+        arr = data.detach().cpu().numpy()
+    else:
+        arr = np.asarray(data)
+    if arr.dtype == np.uint8:
+        return arr.astype(np.float32) / 255.0
+    return arr.astype(np.float32)
 
 
-def model_run(model_configs, tp, out_height, out_width, out_frames, using_tile, vae_patch_parallel_size=1):
+def _extract_output_array(output: Any) -> np.ndarray:
+    req_out = output.request_output
+    payload = req_out.images[0]
+    return _to_float_array(payload)
+
+
+def _diff_metrics(a: np.ndarray, b: np.ndarray) -> tuple[float, float]:
+    assert a.shape == b.shape, f"Output shapes differ: {a.shape} vs {b.shape}"
+    abs_diff = np.abs(a - b)
+    return float(abs_diff.mean()), float(np.quantile(abs_diff, 0.99))
+
+
+def _save_preview(arr: np.ndarray, path: Path) -> None:
+    """Save a single RGB frame preview; video tensors use the first frame."""
+    preview = np.asarray(arr)
+    # (B, T, H, W, C) video
+    if preview.ndim == 5:
+        preview = preview[0, 0]
+    # (T, H, W, C) video or (B, H, W, C) image batch
+    elif preview.ndim == 4:
+        preview = preview[0]
+    if preview.ndim != 3 or preview.shape[-1] not in (3, 4):
+        raise ValueError(f"Expected HWC RGB(A) preview, got shape {arr.shape} -> {preview.shape}")
+    preview = np.clip(preview[..., :3], 0.0, 1.0)
+    Image.fromarray((preview * 255.0).astype(np.uint8)).save(path)
+
+
+def _build_sampling_params(model_case: dict[str, Any], seed: int) -> OmniDiffusionSamplingParams:
+    kwargs: dict[str, Any] = {
+        "height": model_case["height"],
+        "width": model_case["width"],
+        "num_frames": model_case["num_frames"],
+        "num_inference_steps": 2,
+        "seed": seed,
+    }
+    if model_case["model_name"].startswith("Wan-AI/"):
+        kwargs["guidance_scale"] = 4.0
+    if model_case["is_moe"]:
+        kwargs["guidance_scale_2"] = 1.0
+        kwargs["boundary_ratio"] = 0.5
+    return OmniDiffusionSamplingParams(**kwargs)
+
+
+def _run_generate(
+    *,
+    model_case: dict[str, Any],
+    vae_patch_parallel_size: int,
+    seed: int,
+) -> np.ndarray:
+    current_omni_platform.empty_cache()
     parallel_config = DiffusionParallelConfig(
-        tensor_parallel_size=tp,
+        tensor_parallel_size=2,
         vae_patch_parallel_size=vae_patch_parallel_size,
     )
-
-    omni_kwargs = {
-        "vae_use_tiling": using_tile,
-        "parallel_config": parallel_config,
-    }
-    use_nextstep = is_nextstep_model(model_configs["model_name"])
-    if use_nextstep:
-        # NextStep-1.1 requires explicit pipeline class
-        omni_kwargs["model_class_name"] = "NextStep11Pipeline"
-
-    with OmniRunner(model_configs["model_name"], **omni_kwargs) as runner:
-        m = runner.omni
-        image = Image.new("RGB", (out_width, out_height), (0, 0, 0))
-        start = time.perf_counter()
-        outputs = m.generate(
-            {
-                "prompt": "A cat sitting on a table",
-                "multi_modal_data": {"image": image},
-            },
-            sampling_params_list=OmniDiffusionSamplingParams(
-                height=model_configs["out_height"],
-                width=model_configs["out_width"],
-                num_frames=model_configs["out_frames"],
-                num_inference_steps=2,
-                generator=torch.Generator(current_omni_platform.device_type).manual_seed(42),
-            ),
+    with OmniRunner(
+        model_case["model_name"],
+        parallel_config=parallel_config,
+        vae_use_tiling=True,
+        enforce_eager=False,
+    ) as runner:
+        request: dict[str, Any] = {"prompt": model_case.get("prompt", PROMPT)}
+        if model_case["needs_image"]:
+            request["multi_modal_data"] = {
+                "image": Image.new("RGB", (model_case["width"], model_case["height"]), (0, 0, 0))
+            }
+        outputs = runner.omni.generate(
+            request,
+            sampling_params_list=_build_sampling_params(model_case, seed),
         )
-        end = time.perf_counter()
-        first_output = outputs[0]
-        req_out = first_output.request_output
-        frames = req_out.images[0]
-        if isinstance(frames, torch.Tensor):
-            frames = frames.detach().cpu().numpy()
-        elif isinstance(frames, Image.Image):
-            frames = np.array(frames)
-        # frames shape: (batch, num_frames, height, width, channels)
-        cost = (end - start) * 1000
-        return frames, cost
-        cleanup_dist_env_and_memory()
+        return _extract_output_array(outputs[0])
 
 
-@pytest.mark.parametrize("model_configs", all_model_configs)
-def test_vae_parallel_model(model_configs: str):
-    parallel_result, parallel_time = model_run(
-        model_configs=model_configs,
-        tp=2,
-        out_width=1280,
-        out_height=704,
-        out_frames=5,
-        using_tile=True,
-        vae_patch_parallel_size=2,
-    )
-    non_parallel_result, non_parallel_time = model_run(
-        model_configs=model_configs,
-        tp=2,
-        out_width=1280,
-        out_height=704,
-        out_frames=5,
-        using_tile=True,
-        vae_patch_parallel_size=1,
-    )
-    result_diff = np.abs(non_parallel_result - parallel_result)
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "H100"}, num_cards={"cuda": 4})
+@pytest.mark.parametrize("model_case", MODEL_CASES)
+def test_vae_patch_parallel_tp2(model_case: dict[str, Any], tmp_path: Path):
+    if current_omni_platform.is_npu():
+        pytest.skip("VAE patch parallel test is only supported on CUDA and ROCm for now.")
+    if not current_omni_platform.is_available() or current_omni_platform.device_count() < 2:
+        pytest.skip("VAE patch parallel TP=2 requires >= 2 devices.")
 
-    mean_threshold = 3e-2
-    max_threshold = 3e-2  # they should be totally same
+    seed = 42
+    model_id = model_case["model_name"].split("/")[-1]
+
+    baseline = _run_generate(model_case=model_case, vae_patch_parallel_size=1, seed=seed)
+    parallel = _run_generate(model_case=model_case, vae_patch_parallel_size=2, seed=seed)
+
+    baseline_path = tmp_path / f"{model_id}_tp2_vae_pp1.png"
+    parallel_path = tmp_path / f"{model_id}_tp2_vae_pp2.png"
+    _save_preview(baseline, baseline_path)
+    _save_preview(parallel, parallel_path)
+
+    mean_abs_diff, p99_abs_diff = _diff_metrics(baseline, parallel)
+    mean_threshold = model_case["mean_threshold"]
+    p99_threshold = model_case["p99_threshold"]
     print(
-        f"{model_configs['model_name']} TP = 2 (tile + parallel vs tile): "
-        f"mean_abs_diff={result_diff.mean():.6e}, max_abs_diff={result_diff.max():.6e}; "
-        f"thresholds: mean<={mean_threshold:.6e}, max<={max_threshold:.6e}; "
-        f"parallel generate take time: {parallel_time:.2f} ms, non-parallel take time: {non_parallel_time:.2f} ms"
+        f"{model_case['model_name']} VAE patch parallel diff (TP=2, pp=1 vs pp=2): "
+        f"mean_abs_diff={mean_abs_diff:.6e}, p99_abs_diff={p99_abs_diff:.6e}; "
+        f"thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e}; "
+        f"pp1_preview={baseline_path}, pp2_preview={parallel_path}"
+    )
+    assert mean_abs_diff <= mean_threshold and p99_abs_diff <= p99_threshold, (
+        f"Output diff exceeded threshold: mean_abs_diff={mean_abs_diff:.6e}, "
+        f"p99_abs_diff={p99_abs_diff:.6e} "
+        f"(thresholds: mean<={mean_threshold:.6e}, p99<={p99_threshold:.6e})"
     )
-    # assert non_parallel_time > parallel_time
-    assert result_diff.mean() < mean_threshold
-    assert result_diff.max() < max_threshold
diff --git a/tests/diffusion/distributed/test_wan_spatial_shard.py b/tests/diffusion/distributed/test_wan_spatial_shard.py
index 6d668df3a..72a2a45f5 100644
--- a/tests/diffusion/distributed/test_wan_spatial_shard.py
+++ b/tests/diffusion/distributed/test_wan_spatial_shard.py
@@ -6,18 +6,19 @@ import torch
 import torch.distributed as dist
 import torch.multiprocessing as mp
 
+from tests.helpers.mark import hardware_test
 from vllm_omni.diffusion.distributed.autoencoders import wan_spatial_shard
 from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan import (
     DistributedAutoencoderKLWan,
 )
 from vllm_omni.platforms import current_omni_platform
 
-# Module-level markers apply to the CPU unit tests below. The multi-GPU
-# correctness test at the end of the file adds the nightly/distributed markers
-# and a skip guard so it only runs where >= 2 CUDA devices are available.
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+# CPU unit tests are marked core_model + cpu. The multi-GPU correctness test at
+# the end uses hardware_test (H100 x2) plus full_model / diffusion / parallel.
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_split_for_parallel_decode_pads_uneven_height():
     x = torch.arange(1 * 1 * 1 * 5 * 2, dtype=torch.float32).reshape(1, 1, 1, 5, 2)
 
@@ -34,6 +35,8 @@ def test_split_for_parallel_decode_pads_uneven_height():
     assert torch.equal(local[..., 1, :], torch.zeros_like(local[..., 1, :]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_split_for_parallel_decode_pads_uneven_width():
     x = torch.arange(1 * 1 * 1 * 2 * 5, dtype=torch.float32).reshape(1, 1, 1, 2, 5)
 
@@ -51,6 +54,8 @@ def test_split_for_parallel_decode_pads_uneven_width():
     assert torch.equal(local[..., :, 1], torch.zeros_like(local[..., :, 1]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_split_for_parallel_decode_rejects_invalid_split_dim():
     x = torch.zeros((1, 1, 1, 4, 4), dtype=torch.float32)
 
@@ -64,6 +69,8 @@ def test_split_for_parallel_decode_rejects_invalid_split_dim():
         )
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_split_for_parallel_decode_rejects_zero_world_size():
     x = torch.zeros((1, 1, 1, 4, 4), dtype=torch.float32)
 
@@ -76,6 +83,8 @@ def test_split_for_parallel_decode_rejects_zero_world_size():
         )
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_split_for_parallel_decode_rejects_rank_out_of_range():
     x = torch.zeros((1, 1, 1, 4, 4), dtype=torch.float32)
 
@@ -88,6 +97,8 @@ def test_split_for_parallel_decode_rejects_rank_out_of_range():
         )
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_gather_and_trim_height(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 3))
 
@@ -104,6 +115,8 @@ def test_gather_and_trim_height(monkeypatch: pytest.MonkeyPatch):
     assert torch.equal(out.flatten(), torch.tensor([0.0, 0.0, 1.0, 1.0, 2.0]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_gather_and_trim_width(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 3))
 
@@ -120,6 +133,8 @@ def test_gather_and_trim_width(monkeypatch: pytest.MonkeyPatch):
     assert torch.equal(out.flatten(), torch.tensor([0.0, 0.0, 1.0, 1.0, 2.0]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_gather_and_trim_rank0_only_assembles_on_rank0(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 3))
 
@@ -136,6 +151,8 @@ def test_gather_and_trim_rank0_only_assembles_on_rank0(monkeypatch: pytest.Monke
     assert torch.equal(out.flatten(), torch.tensor([0.0, 0.0, 1.0, 1.0, 2.0]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_gather_and_trim_rank0_only_returns_empty_on_non_zero_rank(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (1, 3))
 
@@ -156,6 +173,8 @@ def test_gather_and_trim_rank0_only_returns_empty_on_non_zero_rank(monkeypatch:
     assert out.numel() == 0
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_reshard_from_trimmed_height_pads_invalid_rows(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (2, 3))
 
@@ -183,6 +202,8 @@ def test_reshard_from_trimmed_height_pads_invalid_rows(monkeypatch: pytest.Monke
     assert torch.equal(out.flatten(), torch.tensor([4.0, 0.0]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_reshard_from_trimmed_width_pads_invalid_columns(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (2, 3))
 
@@ -210,6 +231,8 @@ 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
 def test_halo_exchange_single_rank_noop(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 1))
 
@@ -225,6 +248,8 @@ def test_halo_exchange_single_rank_noop(monkeypatch: pytest.MonkeyPatch):
     assert recv_bottom is None
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_dist_zero_pad_only_applies_global_height_edges(monkeypatch: pytest.MonkeyPatch):
     x = torch.ones((1, 1, 2, 2))
 
@@ -239,6 +264,8 @@ def test_dist_zero_pad_only_applies_global_height_edges(monkeypatch: pytest.Monk
     assert last.shape == (1, 1, 3, 3)
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_dist_zero_pad_only_applies_global_width_edges(monkeypatch: pytest.MonkeyPatch):
     x = torch.ones((1, 1, 2, 2))
 
@@ -253,6 +280,8 @@ def test_dist_zero_pad_only_applies_global_width_edges(monkeypatch: pytest.Monke
     assert last.shape == (1, 1, 2, 3)
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_spatial_shard_height_gate_falls_back_for_partial_group(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(
         "vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan.dist.get_world_size",
@@ -270,6 +299,8 @@ def test_spatial_shard_height_gate_falls_back_for_partial_group(monkeypatch: pyt
     assert vae._spatial_shard_decode_enabled(z) is False
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_spatial_shard_width_gate_selects_width(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(
         "vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan.dist.get_world_size",
@@ -286,6 +317,8 @@ def test_spatial_shard_width_gate_selects_width(monkeypatch: pytest.MonkeyPatch)
     assert vae._spatial_shard_decode_enabled(z) is True
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_tile_mode_disables_spatial_shard_decode():
     vae = DistributedAutoencoderKLWan.__new__(DistributedAutoencoderKLWan)
     vae.distributed_executor = SimpleNamespace(group=object(), parallel_size=2, parallel_mode="tile")
@@ -298,7 +331,7 @@ def test_tile_mode_disables_spatial_shard_decode():
 
 
 # =============================================================================
-# Multi-GPU numerical-correctness test (nightly / full_model, distributed CUDA)
+# Multi-GPU numerical-correctness test (nightly Diffusion Test group, H100 x2)
 #
 # Spawns a small process group and verifies that spatial_shard_height/spatial_shard_width decode match
 # a single-process (non-distributed) reference decode of the same latent within
@@ -383,11 +416,7 @@ def _spatial_shard_decode_worker(rank: int, split_dim: str, return_dict, master_
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@pytest.mark.distributed_cuda
-@pytest.mark.skipif(
-    current_omni_platform.get_device_count() < _SPATIAL_SHARD_WORLD_SIZE,
-    reason="Requires >= 2 accelerator devices",
-)
+@hardware_test(res={"cuda": "H100"}, num_cards=_SPATIAL_SHARD_WORLD_SIZE)
 @pytest.mark.parametrize("split_dim", ["height", "width"])
 def test_spatial_shard_decode_matches_reference(split_dim: str):
     manager = mp.get_context("spawn").Manager()
diff --git a/tests/diffusion/hooks/test_hook_registry.py b/tests/diffusion/hooks/test_hook_registry.py
index 6c8535cfe..3ee93a073 100644
--- a/tests/diffusion/hooks/test_hook_registry.py
+++ b/tests/diffusion/hooks/test_hook_registry.py
@@ -12,6 +12,9 @@ from torch import nn
 
 from vllm_omni.diffusion.hooks.base import HookRegistry, ModelHook
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 DEFAULT_OUT = "ECHO"
 OVERRIDE_OUT = "OVERRIDE"
 INPUT_KWARG = "inp"
diff --git a/tests/diffusion/layers/test_fused_moe.py b/tests/diffusion/layers/test_fused_moe.py
new file mode 100644
index 000000000..983e146ef
--- /dev/null
+++ b/tests/diffusion/layers/test_fused_moe.py
@@ -0,0 +1,215 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for the diffusion FusedMoE adapter."""
+
+import sys
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class TestSetForwardContextNumTokens:
+    """Test _set_forward_context_num_tokens defensive fix for vLLM 0.18.0."""
+
+    def test_sets_num_tokens_when_context_available(self, mocker):
+        """num_tokens should be set on ForwardContext when available."""
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        mock_ctx = mocker.MagicMock()
+        del mock_ctx.in_profile_run  # simulate missing attr
+        mocker.patch.object(fused_moe._vllm_fc, "is_forward_context_available", return_value=True)
+        mocker.patch.object(fused_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
+
+        fused_moe._set_forward_context_num_tokens(1024)
+
+        assert mock_ctx.num_tokens == 1024
+        assert mock_ctx.in_profile_run is False
+
+    def test_sets_in_profile_run_only_if_missing(self, mocker):
+        """in_profile_run should not be overwritten if already set."""
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        mock_ctx = mocker.MagicMock()
+        mock_ctx.in_profile_run = True  # already set
+        mocker.patch.object(fused_moe._vllm_fc, "is_forward_context_available", return_value=True)
+        mocker.patch.object(fused_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
+
+        fused_moe._set_forward_context_num_tokens(512)
+
+        assert mock_ctx.num_tokens == 512
+        assert mock_ctx.in_profile_run is True  # not overwritten
+
+    def test_noop_when_context_unavailable(self, mocker):
+        """Should do nothing when ForwardContext is not available."""
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        mocker.patch.object(fused_moe._vllm_fc, "is_forward_context_available", return_value=False)
+        mock_get = mocker.patch.object(fused_moe._vllm_fc, "get_forward_context")
+
+        fused_moe._set_forward_context_num_tokens(256)
+
+        mock_get.assert_not_called()
+
+
+class TestSetForwardContextDPMetadata:
+    """Test diffusion MoE DP metadata setup for vLLM 0.24 dispatch."""
+
+    def test_sets_dp_metadata_from_vllm_dp_group(self, mocker):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        mock_ctx = mocker.MagicMock()
+        mock_ctx.dp_metadata = None
+        fake_group = mocker.MagicMock()
+        fake_group.world_size = 2
+        fake_group.cpu_group = object()
+
+        def _all_gather_object(output, obj, group):
+            assert group is fake_group.cpu_group
+            output[:] = [obj, obj + 1]
+
+        mocker.patch.object(fused_moe._vllm_fc, "is_forward_context_available", return_value=True)
+        mocker.patch.object(fused_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
+        mocker.patch.object(fused_moe._vllm_ps, "_DP", fake_group, create=True)
+        mocker.patch.object(fused_moe.torch.distributed, "all_gather_object", side_effect=_all_gather_object)
+
+        fused_moe._set_forward_context_dp_metadata(1024)
+
+        assert mock_ctx.dp_metadata is not None
+        assert mock_ctx.dp_metadata.num_tokens_across_dp_cpu.tolist() == [1024, 1025]
+
+    def test_keeps_existing_dp_metadata(self, mocker):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        existing_metadata = object()
+        mock_ctx = mocker.MagicMock()
+        mock_ctx.dp_metadata = existing_metadata
+        mocker.patch.object(fused_moe._vllm_fc, "is_forward_context_available", return_value=True)
+        mocker.patch.object(fused_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
+        mock_all_gather = mocker.patch.object(fused_moe.torch.distributed, "all_gather_object")
+
+        fused_moe._set_forward_context_dp_metadata(1024)
+
+        assert mock_ctx.dp_metadata is existing_metadata
+        mock_all_gather.assert_not_called()
+
+
+class TestFusedMoEFactory:
+    """Test FusedMoE factory __new__ and mapping delegation."""
+
+    def test_new_returns_vllm_runner_and_registers_hooks(self, mocker, monkeypatch):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        mock_platform = mocker.MagicMock()
+        mocker.patch.object(fused_moe, "current_omni_platform", mock_platform)
+
+        mock_runner = mocker.MagicMock()
+        mock_vllm_fused_moe = mocker.MagicMock(return_value=mock_runner)
+        monkeypatch.setitem(
+            sys.modules,
+            "vllm.model_executor.layers.fused_moe",
+            SimpleNamespace(FusedMoE=mock_vllm_fused_moe),
+        )
+
+        result = fused_moe.FusedMoE(prefix="test", a=1, reduce_results=True)
+
+        assert result is mock_runner
+        mock_platform.prepare_diffusion_op_runtime.assert_called_once_with("fused_moe")
+        mock_vllm_fused_moe.assert_called_once_with(prefix="test", a=1)
+        mock_runner.register_forward_pre_hook.assert_called_once_with(
+            mocker.ANY,
+            with_kwargs=True,
+        )
+        mock_platform.register_additional_diffusion_fused_moe_hooks.assert_called_once_with(mock_runner)
+
+    def test_num_tokens_pre_hook_uses_kwargs_hidden_states(self, mocker, monkeypatch):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        captured_hook = None
+
+        class MockRunner:
+            def register_forward_pre_hook(self, hook, *, with_kwargs):
+                nonlocal captured_hook
+                assert with_kwargs is True
+                captured_hook = hook
+
+        mock_runner = MockRunner()
+        monkeypatch.setitem(
+            sys.modules,
+            "vllm.model_executor.layers.fused_moe",
+            SimpleNamespace(FusedMoE=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")
+        mock_set_dp_metadata = mocker.patch.object(fused_moe, "_set_forward_context_dp_metadata")
+
+        fused_moe.FusedMoE(prefix="")
+        assert captured_hook is not None
+
+        hidden_states = torch.empty(17, 32)
+        captured_hook(mock_runner, (), {"hidden_states": hidden_states})
+
+        mock_set_num_tokens.assert_called_once_with(17)
+        mock_set_dp_metadata.assert_called_once_with(17)
+
+    def test_num_tokens_pre_hook_uses_positional_hidden_states(self, mocker, monkeypatch):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        captured_hook = None
+
+        class MockRunner:
+            def register_forward_pre_hook(self, hook, *, with_kwargs):
+                nonlocal captured_hook
+                assert with_kwargs is True
+                captured_hook = hook
+
+        mock_runner = MockRunner()
+        monkeypatch.setitem(
+            sys.modules,
+            "vllm.model_executor.layers.fused_moe",
+            SimpleNamespace(FusedMoE=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")
+        mock_set_dp_metadata = mocker.patch.object(fused_moe, "_set_forward_context_dp_metadata")
+
+        fused_moe.FusedMoE(prefix="")
+        assert captured_hook is not None
+
+        hidden_states = torch.empty(23, 32)
+        captured_hook(mock_runner, (hidden_states,), {})
+
+        mock_set_num_tokens.assert_called_once_with(23)
+        mock_set_dp_metadata.assert_called_once_with(23)
+
+    def test_make_expert_params_mapping_delegates_to_vllm_function(self, mocker, monkeypatch):
+        import vllm_omni.diffusion.layers.fused_moe as fused_moe
+
+        expected_mapping = [("a", "b", 0, "c")]
+        mock_mapping_fn = mocker.MagicMock(return_value=expected_mapping)
+        monkeypatch.setitem(
+            sys.modules,
+            "vllm.model_executor.layers.fused_moe",
+            SimpleNamespace(fused_moe_make_expert_params_mapping=mock_mapping_fn),
+        )
+
+        result = fused_moe.FusedMoE.make_expert_params_mapping(
+            model=None,
+            ckpt_gate_proj_name="gate",
+            ckpt_down_proj_name="down",
+            ckpt_up_proj_name="up",
+            num_experts=4,
+            num_redundant_experts=0,
+        )
+
+        assert result == expected_mapping
+        mock_mapping_fn.assert_called_once_with(
+            None,
+            ckpt_gate_proj_name="gate",
+            ckpt_down_proj_name="down",
+            ckpt_up_proj_name="up",
+            num_experts=4,
+            num_redundant_experts=0,
+        )
diff --git a/tests/diffusion/layers/test_norm.py b/tests/diffusion/layers/test_norm.py
index 694f8f8e9..71125684b 100644
--- a/tests/diffusion/layers/test_norm.py
+++ b/tests/diffusion/layers/test_norm.py
@@ -2,6 +2,9 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Unit tests for LayerNorm and RMSNorm custom ops in diffusion layers."""
 
+import sys
+import types
+
 import pytest
 import torch
 from pytest_mock import MockerFixture
@@ -299,6 +302,44 @@ def test_rmsnorm_numerical_correctness():
     torch.testing.assert_close(out, expected, atol=1e-5, rtol=1e-5)
 
 
+def test_rmsnorm_dtype_matches_parameter_and_fp32_accumulation_contract():
+    """dtype controls gamma storage; reduced-precision inputs still use fp32 accumulation."""
+    from vllm_omni.diffusion.layers.norm import RMSNorm
+
+    hidden_size = 64
+    eps = 1e-6
+    norm = RMSNorm(hidden_size, eps=eps, dtype=torch.bfloat16)
+    x = torch.randn(2, 4, hidden_size, dtype=torch.bfloat16)
+
+    assert norm.weight.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)
+
+    torch.testing.assert_close(norm.forward_native(x), expected, atol=0, rtol=0)
+
+
+def test_rmsnorm_npu_receives_gamma_with_configured_dtype(monkeypatch: pytest.MonkeyPatch):
+    """The NPU fused op receives the bf16 checkpoint gamma used by H3."""
+    from vllm_omni.diffusion.layers.norm import RMSNorm
+
+    captured: dict[str, torch.Tensor] = {}
+
+    def npu_rms_norm(x: torch.Tensor, gamma: torch.Tensor, epsilon: float):
+        captured["gamma"] = gamma
+        captured["epsilon"] = torch.tensor(epsilon)
+        return (x,)
+
+    monkeypatch.setitem(sys.modules, "torch_npu", types.SimpleNamespace(npu_rms_norm=npu_rms_norm))
+    norm = RMSNorm(64, eps=1e-5, dtype=torch.bfloat16)
+    x = torch.randn(2, 4, 64, dtype=torch.bfloat16)
+
+    assert norm.forward_npu(x) is x
+    assert captured["gamma"] is norm.weight
+    assert captured["gamma"].dtype == torch.bfloat16
+    assert captured["epsilon"].item() == pytest.approx(1e-5)
+
+
 # ── RMSNorm compile-path regression tests ──
 
 
diff --git a/tests/diffusion/layers/test_rope_broadcast.py b/tests/diffusion/layers/test_rope_broadcast.py
index 29fcf1804..e1238ba44 100644
--- a/tests/diffusion/layers/test_rope_broadcast.py
+++ b/tests/diffusion/layers/test_rope_broadcast.py
@@ -10,10 +10,13 @@ forward_hip, and apply_rotary_emb_mindiesd paths.
 
 from __future__ import annotations
 
+import sys
+import types
+
 import pytest
 import torch
 
-from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+from vllm_omni.diffusion.layers.rope import RotaryEmbedding, apply_rotary_emb_mindiesd
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -234,3 +237,33 @@ class TestRotaryEmbeddingNativeShapeRegression:
         output = rope.forward_native(x, cos, sin)
         assert output.shape == x.shape
         assert not torch.isnan(output).any()
+
+
+def test_mindie_full_dim_rope_keeps_h3_cos_sin_layout(monkeypatch: pytest.MonkeyPatch) -> None:
+    """H3 passes complete rotary dims to MindIE instead of the CUDA half-dim layout."""
+    captured: dict[str, object] = {}
+
+    def rotary_position_embedding(x, cos, sin, **kwargs):
+        captured.update(x=x, cos=cos, sin=sin, kwargs=kwargs)
+        return x
+
+    monkeypatch.setitem(
+        sys.modules,
+        "mindiesd",
+        types.SimpleNamespace(rotary_position_embedding=rotary_position_embedding),
+    )
+    x = torch.randn(11, 3, 96, dtype=torch.bfloat16)
+    cos = torch.randn(11, 96, dtype=torch.bfloat16)
+    sin = torch.randn(11, 96, dtype=torch.bfloat16)
+
+    actual = apply_rotary_emb_mindiesd(x, cos, sin, interleaved=False, half_head_dim=False)
+
+    assert actual is x
+    assert captured["x"] is x
+    assert captured["cos"] is cos
+    assert captured["sin"] is sin
+    assert captured["kwargs"] == {
+        "rotated_mode": "rotated_half",
+        "head_first": False,
+        "fused": True,
+    }
diff --git a/tests/diffusion/layers/test_rotary_emb_equivalence.py b/tests/diffusion/layers/test_rotary_emb_equivalence.py
index 2fbb7a31f..09aef0373 100644
--- a/tests/diffusion/layers/test_rotary_emb_equivalence.py
+++ b/tests/diffusion/layers/test_rotary_emb_equivalence.py
@@ -13,6 +13,8 @@ from __future__ import annotations
 import pytest
 import torch
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def _apply_rotary_emb_helios_original(
     hidden_states: torch.Tensor,
diff --git a/tests/diffusion/model_loader/test_modelopt_fp8_adapter.py b/tests/diffusion/model_loader/test_modelopt_fp8_adapter.py
index 66fa87a3c..8c429a00f 100644
--- a/tests/diffusion/model_loader/test_modelopt_fp8_adapter.py
+++ b/tests/diffusion/model_loader/test_modelopt_fp8_adapter.py
@@ -9,6 +9,7 @@ import torch.nn as nn
 
 from vllm_omni.diffusion.model_loader.checkpoint_adapters import (
     ModelOptFp8CheckpointAdapter,
+    ModelOptNvFp4CheckpointAdapter,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
@@ -89,6 +90,23 @@ class _QuantizedRemappedModelOptModel(nn.Module):
         return name
 
 
+class _RemappedNvFp4Model(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.runtime = nn.Module()
+        self.runtime.proj = nn.Module()
+        self.runtime.proj.register_parameter(
+            "weight",
+            nn.Parameter(torch.empty(1, 1, dtype=torch.uint8), requires_grad=False),
+        )
+        for name in ("input_scale", "weight_scale", "weight_scale_2"):
+            self.runtime.proj.register_parameter(name, nn.Parameter(torch.empty(1), requires_grad=False))
+
+    @staticmethod
+    def remap_checkpoint_key(name: str) -> str:
+        return name.replace("transformer.orig.proj.", "runtime.proj.")
+
+
 def _make_source() -> SimpleNamespace:
     return SimpleNamespace(
         subfolder="transformer",
@@ -188,13 +206,36 @@ def test_modelopt_adapter_remaps_and_keeps_scales_for_quantized_target():
     emitted = dict(adapted)
     assert len(adapted) == len(emitted) == 3
 
-    # Both scales are retained (the dropped-scale regression). They keep their
-    # source-checkpoint names; the model's load_weights remaps them downstream.
-    assert torch.equal(emitted["transformer.orig.proj.weight_scale"], weight_scale)
-    assert torch.equal(emitted["transformer.orig.proj.input_scale"], input_scale)
+    # Both scales are retained and emitted under the remapped runtime names.
+    assert torch.equal(emitted["runtime.proj.weight_scale"], weight_scale)
+    assert torch.equal(emitted["runtime.proj.input_scale"], input_scale)
 
     # The FP8 weight is passed through unchanged under the remapped target name
     # (the quantized param is FP8, so it must NOT be dequantized). Compare via
     # float32 since torch.equal has no FP8 CPU kernel.
     assert emitted["runtime.proj.weight"].dtype == torch.float8_e4m3fn
     assert torch.equal(emitted["runtime.proj.weight"].to(torch.float32), fp8_weight.to(torch.float32))
+
+
+def test_modelopt_nvfp4_adapter_remaps_quantized_weights_and_scales():
+    adapter = ModelOptNvFp4CheckpointAdapter(_RemappedNvFp4Model(), _make_source())
+    prefix = "transformer.orig.proj"
+    checkpoint_tensors = [
+        (f"{prefix}.input_scale", torch.tensor([1.0])),
+        (f"{prefix}.weight_scale", torch.tensor([0.5])),
+        (f"{prefix}.weight_scale_2", torch.tensor([0.25])),
+        (f"{prefix}.weight", torch.tensor([[1]], dtype=torch.uint8)),
+    ]
+
+    adapted = list(adapter.adapt(iter(checkpoint_tensors)))
+
+    assert [name for name, _ in adapted] == [
+        name.replace(f"{prefix}.", "runtime.proj.") for name, _ in checkpoint_tensors
+    ]
+
+
+def test_modelopt_nvfp4_adapter_rejects_unconsumed_pre_quant_scale():
+    adapter = ModelOptNvFp4CheckpointAdapter(nn.Module(), _make_source())
+
+    with pytest.raises(ValueError, match="does not consume pre_quant_scale"):
+        list(adapter.adapt(iter([("transformer.proj.pre_quant_scale", torch.tensor([1.0]))])))
diff --git a/tests/diffusion/models/bagel/test_negative_prompt.py b/tests/diffusion/models/bagel/test_negative_prompt.py
new file mode 100644
index 000000000..37715600c
--- /dev/null
+++ b/tests/diffusion/models/bagel/test_negative_prompt.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+from pytest_mock import MockerFixture
+
+from vllm_omni.diffusion.models.bagel.pipeline_bagel import BagelPipeline
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _NegativePromptPreparedError(Exception):
+    pass
+
+
+@pytest.mark.parametrize(
+    ("prompt_negative", "extra_negative", "expected"),
+    [
+        ("prompt negative", "legacy negative", "prompt negative"),
+        (None, "legacy negative", "legacy negative"),
+    ],
+    ids=["prompt-owner", "legacy-extra-args"],
+)
+def test_forward_reads_negative_prompt_from_prompt_with_legacy_fallback(
+    mocker: MockerFixture,
+    prompt_negative: str | None,
+    extra_negative: str,
+    expected: str,
+) -> None:
+    pipeline = object.__new__(BagelPipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.od_config = mocker.Mock(dtype=torch.float32)
+    pipeline.tokenizer = mocker.sentinel.tokenizer
+    pipeline.new_token_ids = {}
+    pipeline.language_model = mocker.Mock(vocab_size=10)
+    pipeline.image_processor = None
+    pipeline.vae = None
+
+    bagel = mocker.MagicMock()
+    bagel.max_latent_size = 32
+    bagel.latent_downsample = 8
+    bagel.config.llm_config.num_hidden_layers = 1
+    prepared_prompts: list[str] = []
+
+    def prepare_prompts(*, prompts, **_):
+        prepared_prompts.append(prompts[0])
+        if len(prepared_prompts) == 1:
+            return {"packed_text_ids": torch.tensor([1])}, [1], [1]
+        raise _NegativePromptPreparedError
+
+    bagel.prepare_prompts.side_effect = prepare_prompts
+    pipeline.bagel = bagel
+
+    prompt = {
+        "prompt": "positive",
+        "negative_prompt": prompt_negative,
+    }
+    request = DiffusionRequestBatch(
+        requests=[
+            OmniDiffusionRequest(
+                prompt=prompt,
+                sampling_params=OmniDiffusionSamplingParams(
+                    extra_args={"negative_prompt": extra_negative},
+                ),
+                request_id="test",
+            )
+        ]
+    )
+
+    with pytest.raises(_NegativePromptPreparedError):
+        pipeline.forward(request)
+
+    assert prepared_prompts == ["positive", expected]
diff --git a/tests/e2e/offline_inference/rlhf_test/__init__.py b/tests/diffusion/models/boogu_image/__init__.py
similarity index 100%
rename from tests/e2e/offline_inference/rlhf_test/__init__.py
rename to tests/diffusion/models/boogu_image/__init__.py
diff --git a/tests/diffusion/models/boogu_image/test_boogu_image_scheduler.py b/tests/diffusion/models/boogu_image/test_boogu_image_scheduler.py
new file mode 100644
index 000000000..a92d9e979
--- /dev/null
+++ b/tests/diffusion/models/boogu_image/test_boogu_image_scheduler.py
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+"""L1 unit tests for the Boogu time-shifting flow-match Euler scheduler.
+
+Golden values were generated from the upstream boogu scheduler
+(scripts/test_ported_scheduler_parity.py) with the released checkpoint's
+scheduler_config.json, so CI does not need the `boogu` package installed.
+"""
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.boogu_image import FlowMatchEulerDiscreteScheduler
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Ground truth from the released checkpoint's scheduler/scheduler_config.json.
+CHECKPOINT_CONFIG = dict(
+    num_train_timesteps=1000,
+    do_shift=True,
+    dynamic_time_shift=False,
+    time_shift_version="v1",
+    seq_len=4096,
+    base_shift=0.5,
+    max_shift=1.15,
+)
+
+NUM_TOKENS = 4096 * 4  # 1024x1024 resolution
+
+# Generated from the upstream boogu scheduler with CHECKPOINT_CONFIG.
+GOLDEN_TIMESTEPS = {
+    4: [0.00000000, 0.09546924, 0.24048907, 0.48715585],
+    10: [
+        0.00000000,
+        0.03398621,
+        0.07335263,
+        0.11948693,
+        0.17429835,
+        0.24048907,
+        0.32201332,
+        0.42489707,
+        0.55880034,
+        0.74024153,
+    ],
+}
+
+
+def make_scheduler(**overrides) -> FlowMatchEulerDiscreteScheduler:
+    return FlowMatchEulerDiscreteScheduler(**{**CHECKPOINT_CONFIG, **overrides})
+
+
+@pytest.mark.parametrize("n_steps", sorted(GOLDEN_TIMESTEPS))
+def test_golden_timesteps_checkpoint_config(n_steps):
+    scheduler = make_scheduler()
+    scheduler.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+    np.testing.assert_allclose(
+        scheduler.timesteps.numpy(),
+        np.asarray(GOLDEN_TIMESTEPS[n_steps], dtype=np.float32),
+        atol=1e-7,
+    )
+
+
+@pytest.mark.parametrize("n_steps", [4, 10, 30])
+def test_timestep_grid_structure(n_steps):
+    scheduler = make_scheduler()
+    scheduler.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+
+    assert scheduler.timesteps.shape == (n_steps,)
+    assert scheduler._timesteps.shape == (n_steps + 1,)
+    # Ascending 0 -> 1 convention with the terminal 1.0 appended.
+    assert scheduler.timesteps[0].item() == 0.0
+    assert torch.all(scheduler._timesteps[1:] > scheduler._timesteps[:-1])
+    assert scheduler._timesteps[-1].item() == 1.0
+    assert torch.equal(scheduler._timesteps[:-1], scheduler.timesteps)
+
+
+def test_no_shift_is_uniform_grid():
+    n_steps = 8
+    scheduler = make_scheduler(do_shift=False)
+    scheduler.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+    expected = np.linspace(0, 1, n_steps + 1, dtype=np.float32)[:-1]
+    np.testing.assert_allclose(scheduler.timesteps.numpy(), expected, atol=1e-7)
+
+
+def test_static_shift_ignores_num_tokens():
+    # dynamic_time_shift=False: the shift comes from configured seq_len, so
+    # per-call num_tokens must not change the schedule.
+    scheduler_a = make_scheduler()
+    scheduler_a.set_timesteps(num_inference_steps=10, num_tokens=NUM_TOKENS)
+    scheduler_b = make_scheduler()
+    scheduler_b.set_timesteps(num_inference_steps=10, num_tokens=320 * 320)
+    assert torch.equal(scheduler_a.timesteps, scheduler_b.timesteps)
+
+
+def test_step_arithmetic_and_index_advancement():
+    n_steps = 4
+    scheduler = make_scheduler()
+    scheduler.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+
+    sample = torch.zeros(1, 4, 8, 8)
+    model_output = torch.ones(1, 4, 8, 8)
+
+    assert scheduler.step_index is None
+    out = scheduler.step(model_output, scheduler.timesteps[0], sample)
+    assert scheduler.step_index == 1
+
+    # prev_sample = sample + (t_next - t) * model_output
+    expected_dt = scheduler._timesteps[1] - scheduler._timesteps[0]
+    assert torch.allclose(out.prev_sample, expected_dt * model_output)
+
+    # Full loop reaches the end of the grid.
+    sample = out.prev_sample
+    for t in scheduler.timesteps[1:]:
+        sample = scheduler.step(model_output, t, sample, return_dict=False)[0]
+    assert scheduler.step_index == n_steps
+    # Integrating a constant velocity of 1 over t in [0, 1] gives exactly 1.
+    assert torch.allclose(sample, torch.ones_like(sample), atol=1e-6)
+
+
+def test_step_rejects_integer_timestep():
+    scheduler = make_scheduler()
+    scheduler.set_timesteps(num_inference_steps=4, num_tokens=NUM_TOKENS)
+    with pytest.raises(ValueError, match="integer indices"):
+        scheduler.step(torch.zeros(1), 0, torch.zeros(1))
+
+
+def test_set_begin_index():
+    scheduler = make_scheduler()
+    scheduler.set_timesteps(num_inference_steps=4, num_tokens=NUM_TOKENS)
+    scheduler.set_begin_index(2)
+    assert scheduler.begin_index == 2
+
+    scheduler.step(torch.zeros(1), scheduler.timesteps[2], torch.zeros(1))
+    assert scheduler.step_index == 3
+
+
+def test_len_and_config_roundtrip():
+    scheduler = make_scheduler()
+    assert len(scheduler) == CHECKPOINT_CONFIG["num_train_timesteps"]
+    # ConfigMixin must retain the checkpoint config (needed for from_pretrained).
+    assert scheduler.config.do_shift is True
+    assert scheduler.config.dynamic_time_shift is False
+    assert scheduler.config.time_shift_version == "v1"
+    assert scheduler.config.seq_len == 4096
+
+
+def test_matches_upstream_boogu_scheduler():
+    """Differential check against the upstream boogu package, when installed."""
+    boogu_schedulers = pytest.importorskip("boogu.schedulers.scheduling_flow_match_euler_discrete_time_shifting")
+    UpstreamScheduler = boogu_schedulers.FlowMatchEulerDiscreteScheduler
+
+    for dynamic in (False, True):
+        for version in ("v1", "v2"):
+            for n_steps in (4, 10, 30):
+                config = {**CHECKPOINT_CONFIG, "dynamic_time_shift": dynamic, "time_shift_version": version}
+                upstream = UpstreamScheduler(**config)
+                ported = make_scheduler(**config)
+                upstream.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+                ported.set_timesteps(num_inference_steps=n_steps, num_tokens=NUM_TOKENS)
+                assert torch.equal(upstream.timesteps, ported.timesteps), (dynamic, version, n_steps)
+                assert torch.equal(upstream._timesteps, ported._timesteps), (dynamic, version, n_steps)
diff --git a/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py b/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py
new file mode 100644
index 000000000..08ba4af09
--- /dev/null
+++ b/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py
@@ -0,0 +1,450 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import logging
+import os
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+# Small mock dimensions (head_dim = HIDDEN_SIZE / NUM_HEADS = 16 must equal
+# sum(AXES_DIM_ROPE)).
+HIDDEN_SIZE = 64
+NUM_HEADS = 4
+NUM_KV_HEADS = 2
+HEAD_DIM = HIDDEN_SIZE // NUM_HEADS
+AXES_DIM_ROPE = (8, 4, 4)
+AXES_LENS = (32, 16, 16)
+MULTIPLE_OF = 32
+NORM_EPS = 1e-5
+
+
+@pytest.fixture(autouse=True)
+def _init_distributed():
+    """Initialize the minimal single-rank distributed environment required by
+    the vLLM parallel linear layers (tensor-parallel group must exist)."""
+    from vllm.distributed.parallel_state import (
+        cleanup_dist_env_and_memory,
+        init_distributed_environment,
+        initialize_model_parallel,
+    )
+
+    os.environ.setdefault("MASTER_ADDR", "localhost")
+    os.environ.setdefault("MASTER_PORT", "29512")
+    init_distributed_environment(
+        world_size=1,
+        rank=0,
+        local_rank=0,
+        distributed_init_method="env://",
+    )
+    initialize_model_parallel()
+    yield
+    cleanup_dist_env_and_memory()
+
+
+@pytest.fixture(autouse=True)
+def _force_default_gemm(monkeypatch):
+    """Force CPU-compatible GEMM dispatch for tests using CPU tensors.
+
+    vLLM's dispatch_unquantized_gemm() selects the backend by platform, not by
+    tensor device; CPU test tensors can crash on non-default backends."""
+    from vllm.model_executor.layers.utils import default_unquantized_gemm
+
+    monkeypatch.setattr(
+        "vllm.model_executor.layers.linear.dispatch_unquantized_gemm",
+        lambda: default_unquantized_gemm,
+    )
+
+
+def _randomize_parameters(module: torch.nn.Module) -> None:
+    """Fill parameters with small random values.
+
+    vLLM parallel linears allocate weights with `torch.empty` (real weights
+    arrive via `load_weights`), so uninitialized memory must be overwritten
+    before a forward pass."""
+    with torch.no_grad():
+        for param in module.parameters():
+            param.uniform_(-0.02, 0.02)
+
+
+def _identity_rotary_emb(batch_size: int, seq_len: int) -> torch.Tensor:
+    """Complex rotary frequencies encoding a zero rotation."""
+    return torch.polar(
+        torch.ones(batch_size, seq_len, HEAD_DIM // 2),
+        torch.zeros(batch_size, seq_len, HEAD_DIM // 2),
+    )
+
+
+def _tiny_tf_model_config(**overrides):
+    config = {
+        "patch_size": 2,
+        "in_channels": 4,
+        "hidden_size": HIDDEN_SIZE,
+        "num_layers": 4,
+        "num_double_stream_layers": 2,
+        "num_refiner_layers": 2,
+        "num_attention_heads": NUM_HEADS,
+        "num_kv_heads": NUM_KV_HEADS,
+        "multiple_of": MULTIPLE_OF,
+        "norm_eps": NORM_EPS,
+        "axes_dim_rope": list(AXES_DIM_ROPE),
+        "axes_lens": list(AXES_LENS),
+        "instruction_feature_configs": {
+            "instruction_feat_dim": 32,
+            "reduce_type": "mean",
+            "num_instruction_feature_layers": 1,
+        },
+        "prompt_tuning_configs": {"use_prompt_tuning": False},
+        "timestep_scale": 1.0,
+    }
+    config.update(overrides)
+    return config
+
+
+def _tiny_od_config(**overrides):
+    from vllm_omni.diffusion.data import TransformerConfig
+
+    return SimpleNamespace(
+        tf_model_config=TransformerConfig.from_dict(_tiny_tf_model_config(**overrides)),
+        dtype=torch.float32,
+    )
+
+
+def test_boogu_image_transformer_import():
+    from vllm_omni.diffusion.models.boogu_image import BooguImageTransformer2DModel
+
+    assert BooguImageTransformer2DModel is not None
+
+
+def test_single_stream_block_shape():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformerBlock,
+    )
+
+    block = BooguImageTransformerBlock(
+        dim=HIDDEN_SIZE,
+        num_attention_heads=NUM_HEADS,
+        num_kv_heads=NUM_KV_HEADS,
+        multiple_of=MULTIPLE_OF,
+        ffn_dim_multiplier=None,
+        norm_eps=NORM_EPS,
+        modulation=True,
+    )
+    _randomize_parameters(block)
+
+    batch_size, seq_len = 1, 16
+    hidden_states = torch.randn(batch_size, seq_len, HIDDEN_SIZE)
+    attention_mask = torch.ones(batch_size, seq_len, dtype=torch.bool)
+    rotary_emb = _identity_rotary_emb(batch_size, seq_len)
+    temb = torch.randn(batch_size, min(HIDDEN_SIZE, 1024))
+
+    out = block(hidden_states, attention_mask, rotary_emb, temb)
+    assert out.shape == hidden_states.shape
+    assert torch.isfinite(out).all()
+
+    with pytest.raises(ValueError, match="temb"):
+        block(hidden_states, attention_mask, rotary_emb, None)
+
+
+def test_single_stream_block_no_modulation():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformerBlock,
+    )
+
+    block = BooguImageTransformerBlock(
+        dim=HIDDEN_SIZE,
+        num_attention_heads=NUM_HEADS,
+        num_kv_heads=NUM_KV_HEADS,
+        multiple_of=MULTIPLE_OF,
+        ffn_dim_multiplier=None,
+        norm_eps=NORM_EPS,
+        modulation=False,
+    )
+    _randomize_parameters(block)
+
+    batch_size, seq_len = 2, 8
+    hidden_states = torch.randn(batch_size, seq_len, HIDDEN_SIZE)
+    out = block(hidden_states, None, _identity_rotary_emb(batch_size, seq_len))
+    assert out.shape == hidden_states.shape
+    assert torch.isfinite(out).all()
+
+
+def test_double_stream_block_shape():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageDoubleStreamTransformerBlock,
+    )
+
+    block = BooguImageDoubleStreamTransformerBlock(
+        dim=HIDDEN_SIZE,
+        num_attention_heads=NUM_HEADS,
+        num_kv_heads=NUM_KV_HEADS,
+        multiple_of=MULTIPLE_OF,
+        ffn_dim_multiplier=None,
+        norm_eps=NORM_EPS,
+        modulation=True,
+    )
+    _randomize_parameters(block)
+
+    batch_size = 1
+    img_len, instruct_len = 16, 8
+    total_len = img_len + instruct_len
+
+    img_hidden_states = torch.randn(batch_size, img_len, HIDDEN_SIZE)
+    instruct_hidden_states = torch.randn(batch_size, instruct_len, HIDDEN_SIZE)
+    img_attention_mask = torch.ones(batch_size, img_len, dtype=torch.bool)
+    joint_attention_mask = torch.ones(batch_size, total_len, dtype=torch.bool)
+    image_rotary_emb = _identity_rotary_emb(batch_size, img_len)
+    rotary_emb = _identity_rotary_emb(batch_size, total_len)
+    temb = torch.randn(batch_size, min(HIDDEN_SIZE, 1024))
+
+    img_out, instruct_out = block(
+        img_hidden_states,
+        instruct_hidden_states,
+        img_attention_mask,
+        joint_attention_mask,
+        image_rotary_emb,
+        rotary_emb,
+        temb=temb,
+        encoder_seq_lengths=[instruct_len] * batch_size,
+        seq_lengths=[total_len] * batch_size,
+    )
+
+    assert img_out.shape == img_hidden_states.shape
+    assert instruct_out.shape == instruct_hidden_states.shape
+    assert torch.isfinite(img_out).all()
+    assert torch.isfinite(instruct_out).all()
+
+
+def test_transformer_instantiates():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+
+    assert BooguImageTransformer2DModel._repeated_blocks == [
+        "BooguImageTransformerBlock",
+        "BooguImageContextRefinerTransformerBlock",
+        "BooguImageSingleStreamTransformerBlock",
+    ]
+    assert BooguImageTransformer2DModel._layerwise_offload_blocks_attrs == [
+        "single_stream_layers",
+        "double_stream_layers",
+    ]
+
+    assert len(model.noise_refiner) == 2
+    assert len(model.ref_image_refiner) == 2
+    assert len(model.context_refiner) == 2
+    assert len(model.double_stream_layers) == 2
+    assert len(model.single_stream_layers) == 2  # num_layers - num_double_stream_layers
+    assert model.image_index_embedding.shape == (5, HIDDEN_SIZE)
+    # patch_size^2 * in_channels -> hidden_size
+    assert model.x_embedder.in_features == 2 * 2 * 4
+    assert model.x_embedder.out_features == HIDDEN_SIZE
+
+
+def test_transformer_preprocesses_multiple_instruction_feature_layers():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    instruction_feature_configs = {
+        "instruction_feat_dim": 32,
+        "reduce_type": "concat",
+        "num_instruction_feature_layers": 2,
+    }
+    model = BooguImageTransformer2DModel(
+        od_config=_tiny_od_config(instruction_feature_configs=instruction_feature_configs)
+    )
+    hidden_states = [torch.randn(1, 8, 32), torch.randn(1, 8, 32)]
+
+    processed = model.preprocess_instruction_hidden_states(hidden_states)
+
+    assert model.preprocessed_instruction_feat_dim == 64
+    assert processed.shape == (1, 8, 64)
+    assert torch.equal(processed, torch.cat(hidden_states, dim=-1))
+
+
+def test_transformer_validates_rope_dims():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    with pytest.raises(ValueError, match="axes_dim_rope"):
+        BooguImageTransformer2DModel(od_config=_tiny_od_config(axes_dim_rope=[8, 8, 8]))
+
+
+def test_transformer_rejects_prompt_tuning():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    with pytest.raises(NotImplementedError, match="[Pp]rompt tuning"):
+        BooguImageTransformer2DModel(od_config=_tiny_od_config(prompt_tuning_configs={"use_prompt_tuning": True}))
+
+
+def _native_to_checkpoint_name(name: str) -> str:
+    """Inverse of ``load_weights`` remapping: native param name -> diffusers name.
+
+    - ``.to_out.<suffix>`` -> ``.to_out.0.<suffix>`` (diffusers ModuleList wrap).
+    - promoted joint-attention projections move back under ``.processor.``.
+    """
+    if ".to_out." in name:
+        name = name.replace(".to_out.", ".to_out.0.")
+    for proj in (
+        "img_to_q",
+        "img_to_k",
+        "img_to_v",
+        "instruct_to_q",
+        "instruct_to_k",
+        "instruct_to_v",
+        "instruct_out",
+        "img_out",
+    ):
+        token = f".img_instruct_attn.{proj}."
+        if token in name:
+            name = name.replace(token, f".img_instruct_attn.processor.{proj}.")
+            break
+    return name
+
+
+def test_transformer_load_weights_round_trip():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+    native_params = dict(model.named_parameters())
+
+    # Build synthetic diffusers-named weights (one per native parameter).
+    checkpoint_weights = {}
+    for native_name, param in native_params.items():
+        checkpoint_weights[_native_to_checkpoint_name(native_name)] = torch.randn_like(param)
+
+    # The remapping must be a bijection over the parameter set.
+    assert len(checkpoint_weights) == len(native_params)
+
+    loaded = model.load_weights(list(checkpoint_weights.items()))
+
+    # No missing / unexpected parameters.
+    assert loaded == set(native_params.keys())
+
+    # Values landed on the right parameters (TP=1: weight_loader copies verbatim).
+    reloaded = dict(model.named_parameters())
+    for native_name in native_params:
+        expected = checkpoint_weights[_native_to_checkpoint_name(native_name)]
+        assert torch.allclose(reloaded[native_name], expected)
+
+
+def test_transformer_load_weights_warns_for_unexpected_and_unloaded():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    # vllm_omni's logger hierarchy hangs off vLLM's `vllm` logger, which sets
+    # propagate=False, so records never reach the root logger that pytest's
+    # caplog listens on. Capture at the emitting logger instead.
+    messages: list[str] = []
+
+    class _Capture(logging.Handler):
+        def emit(self, record: logging.LogRecord) -> None:
+            messages.append(record.getMessage())
+
+    log = logging.getLogger("vllm_omni.diffusion.models.boogu_image.boogu_image_transformer")
+    handler = _Capture(level=logging.WARNING)
+    log.addHandler(handler)
+    try:
+        model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+        native_params = dict(model.named_parameters())
+        loaded_name = next(iter(native_params))
+        checkpoint_name = _native_to_checkpoint_name(loaded_name)
+
+        loaded = model.load_weights(
+            [
+                (checkpoint_name, torch.randn_like(native_params[loaded_name])),
+                ("unexpected.weight", torch.ones(1)),
+            ]
+        )
+    finally:
+        log.removeHandler(handler)
+
+    text = "\n".join(messages)
+    assert loaded == {loaded_name}
+    assert "Skipping unexpected checkpoint weight unexpected.weight" in text
+    assert "Model parameters not loaded from checkpoint" in text
+    assert next(name for name in native_params if name != loaded_name) in text
+
+
+def test_transformer_forward_t2i_shape():
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageDoubleStreamRotaryPosEmbed,
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+    _randomize_parameters(model)
+    model.eval()
+
+    batch_size = 1
+    in_channels = 4
+    latent_h = latent_w = 8  # multiples of patch_size (2)
+    instruct_len = 8
+    instruction_feat_dim = 32  # matches _tiny_tf_model_config
+
+    latents = torch.randn(batch_size, in_channels, latent_h, latent_w)
+    timestep = torch.full((batch_size,), 0.5)
+    instruction_hidden_states = torch.randn(batch_size, instruct_len, instruction_feat_dim)
+    instruction_attention_mask = torch.ones(batch_size, instruct_len, dtype=torch.bool)
+    freqs_cis = BooguImageDoubleStreamRotaryPosEmbed.get_freqs_cis(model.axes_dim_rope, model.axes_lens, theta=10000)
+
+    with torch.no_grad():
+        out = model(latents, timestep, instruction_hidden_states, freqs_cis, instruction_attention_mask)
+
+    assert out.shape == (batch_size, model.out_channels, latent_h, latent_w)
+    assert torch.isfinite(out).all()
+
+
+def test_transformer_forward_ti2i_shape():
+    """Editing path: a non-empty ``ref_image_hidden_states`` exercises the
+    reference-image patch embedder + refiner and must not change the output
+    shape (the output tracks the noise-latent dimensions)."""
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageDoubleStreamRotaryPosEmbed,
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+    _randomize_parameters(model)
+    model.eval()
+
+    batch_size = 1
+    in_channels = 4
+    latent_h = latent_w = 8
+    ref_h, ref_w = 6, 10  # a differently-sized reference latent
+    instruct_len = 8
+    instruction_feat_dim = 32
+
+    latents = torch.randn(batch_size, in_channels, latent_h, latent_w)
+    timestep = torch.full((batch_size,), 0.5)
+    instruction_hidden_states = torch.randn(batch_size, instruct_len, instruction_feat_dim)
+    instruction_attention_mask = torch.ones(batch_size, instruct_len, dtype=torch.bool)
+    freqs_cis = BooguImageDoubleStreamRotaryPosEmbed.get_freqs_cis(model.axes_dim_rope, model.axes_lens, theta=10000)
+
+    # One sample, one reference image (Boogu editing supports a single ref).
+    ref_image_hidden_states = [[torch.randn(in_channels, ref_h, ref_w)]]
+
+    with torch.no_grad():
+        out = model(
+            latents,
+            timestep,
+            instruction_hidden_states,
+            freqs_cis,
+            instruction_attention_mask,
+            ref_image_hidden_states=ref_image_hidden_states,
+        )
+
+    assert out.shape == (batch_size, model.out_channels, latent_h, latent_w)
+    assert torch.isfinite(out).all()
diff --git a/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py b/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py
new file mode 100644
index 000000000..d38be97fa
--- /dev/null
+++ b/tests/diffusion/models/boogu_image/test_pipeline_boogu_image.py
@@ -0,0 +1,900 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""L1 unit tests for the native Boogu-Image pipeline.
+
+Two groups:
+
+1. Constructor tests: all ``from_pretrained`` calls are mocked (Ovis pattern)
+   so the pipeline ``__init__`` wiring is exercised without downloading
+   weights or building the real transformer.
+2. Prompt-encoding tests: a pipeline shell (``object.__new__``) is wired with
+   small deterministic fakes so the ported chat templating, processor kwargs,
+   CFG handling, and reshape logic can be verified numerically on CPU.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig, TransformerConfig
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+_MODULE = "vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image"
+
+_EMBED_DIM = 8
+_SEQ_LEN = 6
+
+
+# ---------------------------------------------------------------------------
+# Constructor tests (mocked from_pretrained)
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def mock_dependencies(mocker, monkeypatch):
+    """Mock external components so ``__init__`` runs without real weights."""
+    # The full VLM wrapper has an ``lm_head``; the pipeline must strip it and
+    # keep the inner ``.model`` as the encoder.
+    inner_encoder = mocker.MagicMock(name="inner_qwen3vl_model")
+    inner_encoder.dtype = torch.float32
+    mllm_wrapper = mocker.MagicMock(name="qwen3vl_wrapper")
+    mllm_wrapper.model.to.return_value = inner_encoder
+
+    mock_processor = mocker.MagicMock(name="processor")
+
+    mock_vae = mocker.MagicMock(name="vae")
+    mock_vae.config.block_out_channels = [128, 256, 512, 512]  # scale factor 8
+    mock_vae.to.return_value = mock_vae
+
+    mock_scheduler = mocker.MagicMock(name="scheduler")
+
+    monkeypatch.setattr(
+        f"{_MODULE}.FlowMatchEulerDiscreteScheduler.from_pretrained",
+        lambda *a, **k: mock_scheduler,
+    )
+    monkeypatch.setattr(
+        f"{_MODULE}.Qwen3VLForConditionalGeneration.from_pretrained",
+        lambda *a, **k: mllm_wrapper,
+    )
+    monkeypatch.setattr(
+        f"{_MODULE}.Qwen3VLProcessor.from_pretrained",
+        lambda *a, **k: mock_processor,
+    )
+    monkeypatch.setattr(
+        f"{_MODULE}.AutoencoderKL.from_pretrained",
+        lambda *a, **k: mock_vae,
+    )
+
+    mock_transformer_cls = mocker.MagicMock(name="transformer_cls")
+    mock_transformer_instance = mocker.MagicMock(name="transformer")
+    mock_transformer_cls.return_value = mock_transformer_instance
+    monkeypatch.setattr(f"{_MODULE}.BooguImageTransformer2DModel", mock_transformer_cls)
+
+    # Treat the dummy model id as a local path: skips hub prefetch.
+    mocker.patch("os.path.exists", return_value=True)
+
+    return {
+        "inner_encoder": inner_encoder,
+        "mllm_wrapper": mllm_wrapper,
+        "processor": mock_processor,
+        "vae": mock_vae,
+        "scheduler": mock_scheduler,
+        "transformer": mock_transformer_instance,
+    }
+
+
+@pytest.fixture
+def boogu_pipeline(mock_dependencies):
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        BooguImagePipeline,
+    )
+
+    od_config = OmniDiffusionConfig(
+        model="dummy-boogu",
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.float32,
+        num_gpus=1,
+    )
+    return BooguImagePipeline(od_config=od_config)
+
+
+def test_boogu_image_pipeline_import():
+    from vllm_omni.diffusion.models.boogu_image import BooguImagePipeline
+
+    assert BooguImagePipeline is not None
+
+
+def test_component_discovery_declarations():
+    from vllm_omni.diffusion.models.boogu_image import BooguImagePipeline
+
+    # CPU offload / HSDP discovery must find ``mllm`` (there is no
+    # ``text_encoder`` attribute on this pipeline).
+    assert BooguImagePipeline._dit_modules == ["transformer"]
+    assert BooguImagePipeline._encoder_modules == ["mllm"]
+    assert BooguImagePipeline._vae_modules == ["vae"]
+
+
+def test_constructor_wires_components(boogu_pipeline, mock_dependencies):
+    assert boogu_pipeline.scheduler is mock_dependencies["scheduler"]
+    assert boogu_pipeline.processor is mock_dependencies["processor"]
+    assert boogu_pipeline.vae is mock_dependencies["vae"]
+    assert boogu_pipeline.transformer is mock_dependencies["transformer"]
+    assert boogu_pipeline.vae_scale_factor == 8
+    assert boogu_pipeline.default_sample_size == 128
+    assert hasattr(boogu_pipeline, "load_weights")
+
+
+def test_constructor_strips_mllm_lm_head(boogu_pipeline, mock_dependencies):
+    # Upstream encodes with the inner Qwen3VLModel, not the generation wrapper.
+    assert boogu_pipeline.mllm is mock_dependencies["inner_encoder"]
+
+
+def test_constructor_weights_sources(boogu_pipeline):
+    (source,) = boogu_pipeline.weights_sources
+    assert source.model_or_path == "dummy-boogu"
+    assert source.subfolder == "transformer"
+    assert source.prefix == "transformer."
+    assert source.fall_back_to_pt is True
+
+
+@pytest.mark.parametrize(
+    ("parallel_config", "cache_backend", "message"),
+    [
+        (DiffusionParallelConfig(tensor_parallel_size=2), "none", "Tensor parallelism"),
+        (DiffusionParallelConfig(ulysses_degree=2), "none", "Sequence parallelism"),
+        (DiffusionParallelConfig(ring_degree=2), "none", "Sequence parallelism"),
+        (DiffusionParallelConfig(cfg_parallel_size=2), "none", "CFG parallelism"),
+        (
+            DiffusionParallelConfig(use_hsdp=True, hsdp_shard_size=2),
+            "none",
+            "HSDP",
+        ),
+        (DiffusionParallelConfig(), "cache_dit", "Cache backend 'cache_dit'"),
+        (DiffusionParallelConfig(), "tea_cache", "Cache backend 'tea_cache'"),
+    ],
+)
+def test_constructor_rejects_unsupported_execution_modes(
+    mock_dependencies,
+    parallel_config,
+    cache_backend,
+    message,
+):
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        BooguImagePipeline,
+    )
+
+    od_config = OmniDiffusionConfig(
+        model="dummy-boogu",
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.float32,
+        parallel_config=parallel_config,
+        cache_backend=cache_backend,
+    )
+
+    with pytest.raises(NotImplementedError, match=message):
+        BooguImagePipeline(od_config=od_config)
+
+    # Validation happens before any checkpoint component is constructed.
+    mock_dependencies["mllm_wrapper"].model.to.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# Prompt-encoding tests (deterministic fakes, no constructor)
+# ---------------------------------------------------------------------------
+
+
+class _RecordingProcessor:
+    """Fake Qwen3VLProcessor: deterministic token ids derived from the text."""
+
+    def __init__(self):
+        self.calls = []
+
+    def apply_chat_template(self, prompts, **kwargs):
+        self.calls.append({"prompts": prompts, "kwargs": kwargs})
+        batch = len(prompts)
+        input_ids = torch.zeros(batch, _SEQ_LEN, dtype=torch.long)
+        for i, messages in enumerate(prompts):
+            system_text = messages[0]["content"][0]["text"]
+            user_text = messages[1]["content"][0]["text"]
+            input_ids[i, 0] = len(system_text) % 997
+            input_ids[i, 1] = len(user_text) % 997
+            input_ids[i, 2:] = torch.arange(2, _SEQ_LEN) + i
+        attention_mask = torch.ones(batch, _SEQ_LEN, dtype=torch.long)
+        attention_mask[:, -1] = 0  # fake right-padding
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+
+class _FakeMLLM:
+    """Fake Qwen3VLModel: hidden states are a deterministic function of ids."""
+
+    dtype = torch.bfloat16
+
+    def __init__(self):
+        self.calls = []
+
+    def __call__(self, input_ids=None, attention_mask=None, output_hidden_states=False, **kwargs):
+        self.calls.append({"output_hidden_states": output_hidden_states, **kwargs})
+        base = input_ids.to(torch.float32).unsqueeze(-1).repeat(1, 1, _EMBED_DIM)
+        hidden = base + torch.arange(_EMBED_DIM, dtype=torch.float32)
+        return SimpleNamespace(last_hidden_state=hidden, hidden_states=(hidden - 1, hidden))
+
+
+def _make_encode_pipeline(num_instruction_feature_layers: int = 1):
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        SYSTEM_PROMPT_4_T2I_UNIFIED,
+        SYSTEM_PROMPT_4_TI2I_UNIFIED,
+        BooguImagePipeline,
+    )
+
+    pipeline = object.__new__(BooguImagePipeline)
+    nn.Module.__init__(pipeline)
+    pipeline._execution_device = torch.device("cpu")
+    pipeline.processor = _RecordingProcessor()
+    pipeline.mllm = _FakeMLLM()
+    pipeline.transformer = SimpleNamespace(
+        instruction_feature_configs={
+            "instruction_feat_dim": _EMBED_DIM,
+            "num_instruction_feature_layers": num_instruction_feature_layers,
+            "reduce_type": "mean",
+        },
+        dtype=torch.float32,
+    )
+    pipeline.SYSTEM_PROMPT_4_T2I = SYSTEM_PROMPT_4_T2I_UNIFIED
+    pipeline.SYSTEM_PROMPT_DROP = SYSTEM_PROMPT_4_TI2I_UNIFIED
+    return pipeline
+
+
+def test_apply_chat_template_system_prompt_selection():
+    pipeline = _make_encode_pipeline()
+
+    messages = pipeline._apply_chat_template("a cat on a mat")
+    assert messages[0]["role"] == "system"
+    assert messages[0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_4_T2I
+    assert messages[1]["role"] == "user"
+    assert messages[1]["content"][0]["text"] == "a cat on a mat"
+
+    # Empty and whitespace-only instructions select the DROP prompt (this is
+    # the path the default negative prompt "" takes).
+    for empty in ("", "   ", None):
+        messages = pipeline._apply_chat_template(empty)
+        assert messages[0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_DROP
+
+
+def test_processor_called_with_upstream_kwargs():
+    pipeline = _make_encode_pipeline()
+    pipeline.encode_prompt("a dog", do_classifier_free_guidance=False)
+
+    (call,) = pipeline.processor.calls
+    kwargs = call["kwargs"]
+    assert kwargs["padding"] == "longest"
+    assert kwargs["padding_side"] == "right"
+    assert kwargs["truncation"] is False
+    assert kwargs["max_length"] == 1280  # upstream __call__ default
+    assert kwargs["tokenize"] is True
+    assert kwargs["return_dict"] is True
+    assert kwargs["return_tensors"] == "pt"
+
+
+def test_encode_prompt_shapes_and_dtype():
+    pipeline = _make_encode_pipeline()
+    embeds, mask, neg_embeds, neg_mask = pipeline.encode_prompt(["a dog", "a cat"])
+
+    assert embeds.shape == (2, _SEQ_LEN, _EMBED_DIM)
+    assert mask.shape == (2, _SEQ_LEN)
+    assert neg_embeds.shape == (2, _SEQ_LEN, _EMBED_DIM)
+    assert neg_mask.shape == (2, _SEQ_LEN)
+    # Cast to the MLLM dtype, mask passed through from the processor.
+    assert embeds.dtype == torch.bfloat16
+    assert neg_embeds.dtype == torch.bfloat16
+    assert torch.equal(mask[:, -1], torch.zeros(2, dtype=torch.long))
+
+
+def test_single_layer_encoding_requests_hidden_states_once():
+    pipeline = _make_encode_pipeline()
+
+    pipeline._get_instruction_feature_embeds("a dog")
+
+    assert pipeline.mllm.calls == [{"output_hidden_states": True, "return_dict": True}]
+
+
+def test_single_layer_encoding_propagates_mllm_failure():
+    pipeline = _make_encode_pipeline()
+    failure = RuntimeError("mllm failed")
+
+    class _FailingMLLM:
+        dtype = torch.bfloat16
+
+        def __init__(self):
+            self.calls = 0
+
+        def __call__(self, **kwargs):
+            self.calls += 1
+            raise failure
+
+    pipeline.mllm = _FailingMLLM()
+
+    with pytest.raises(RuntimeError, match="mllm failed") as exc_info:
+        pipeline._get_instruction_feature_embeds("a dog")
+
+    assert exc_info.value is failure
+    assert pipeline.mllm.calls == 1
+
+
+def test_encode_prompt_cfg_negative_default_is_empty_string():
+    pipeline = _make_encode_pipeline()
+    pipeline.encode_prompt("a dog")
+
+    assert len(pipeline.processor.calls) == 2
+    negative_messages = pipeline.processor.calls[1]["prompts"]
+    assert len(negative_messages) == 1
+    # The default "" negative prompt goes through the DROP system prompt.
+    assert negative_messages[0][0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_DROP
+    assert negative_messages[0][1]["content"][0]["text"] == ""
+
+
+def test_encode_prompt_without_cfg_skips_negative():
+    pipeline = _make_encode_pipeline()
+    embeds, mask, neg_embeds, neg_mask = pipeline.encode_prompt("a dog", do_classifier_free_guidance=False)
+
+    assert len(pipeline.processor.calls) == 1
+    assert embeds.shape == (1, _SEQ_LEN, _EMBED_DIM)
+    assert neg_embeds is None
+    assert neg_mask is None
+
+
+def test_encode_prompt_explicit_negative_prompt():
+    pipeline = _make_encode_pipeline()
+    pipeline.encode_prompt("a dog", negative_prompt="blurry, low quality")
+
+    negative_messages = pipeline.processor.calls[1]["prompts"]
+    assert negative_messages[0][0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_4_T2I
+    assert negative_messages[0][1]["content"][0]["text"] == "blurry, low quality"
+
+
+def test_encode_prompt_negative_batch_mismatch_raises():
+    pipeline = _make_encode_pipeline()
+    with pytest.raises(ValueError, match="batch size"):
+        pipeline.encode_prompt(["a dog", "a cat"], negative_prompt=["only one"])
+
+
+def test_encode_prompt_num_images_per_prompt_repeats_embeds():
+    pipeline = _make_encode_pipeline()
+    embeds, mask, neg_embeds, neg_mask = pipeline.encode_prompt("a dog", num_images_per_prompt=3)
+
+    assert embeds.shape == (3, _SEQ_LEN, _EMBED_DIM)
+    assert mask.shape == (3, _SEQ_LEN)
+    assert torch.equal(embeds[0], embeds[1])
+    assert torch.equal(embeds[0], embeds[2])
+    assert torch.equal(mask[0], mask[1])
+    assert neg_embeds.shape == (3, _SEQ_LEN, _EMBED_DIM)
+
+
+def test_encode_prompt_precomputed_embeds_bypass_encoder():
+    pipeline = _make_encode_pipeline()
+    precomputed = torch.randn(1, _SEQ_LEN, _EMBED_DIM)
+    precomputed_mask = torch.ones(1, _SEQ_LEN, dtype=torch.long)
+    neg_precomputed = torch.randn(1, _SEQ_LEN, _EMBED_DIM)
+
+    embeds, mask, neg_embeds, _ = pipeline.encode_prompt(
+        "ignored",
+        prompt_embeds=precomputed,
+        prompt_attention_mask=precomputed_mask,
+        negative_prompt_embeds=neg_precomputed,
+    )
+
+    assert len(pipeline.processor.calls) == 0
+    assert torch.equal(embeds, precomputed)
+    assert torch.equal(neg_embeds, neg_precomputed)
+
+
+def test_reshape_embeds_and_mask_list_branch():
+    # Multi-layer configs return a list of per-layer tensors; the reshape
+    # helper must handle both forms.
+    pipeline = _make_encode_pipeline()
+    layer = torch.arange(2 * _SEQ_LEN * _EMBED_DIM, dtype=torch.float32).view(2, _SEQ_LEN, _EMBED_DIM)
+    mask = torch.ones(2, _SEQ_LEN, dtype=torch.long)
+
+    batch_size, seq_len, reshaped, reshaped_mask = pipeline._reshape_embeds_and_mask([layer, layer + 1], mask, 2)
+
+    assert batch_size == 2
+    assert seq_len == _SEQ_LEN
+    assert isinstance(reshaped, list) and len(reshaped) == 2
+    assert reshaped[0].shape == (4, _SEQ_LEN, _EMBED_DIM)
+    # repeat(1, n, 1).view(b*n, ...) interleaves per-sample: rows [s0, s0, s1, s1]
+    assert torch.equal(reshaped[0][0], reshaped[0][1])
+    assert torch.equal(reshaped[0][2], reshaped[0][3])
+
+
+class _FakeTransformer:
+    """Fake denoiser: velocity 0 (identity flow) with the config the loop reads."""
+
+    in_channels = 4
+    axes_dim_rope = (8, 4, 4)
+    axes_lens = (32, 16, 16)
+    dtype = torch.float32
+    instruction_feature_configs = {
+        "instruction_feat_dim": _EMBED_DIM,
+        "num_instruction_feature_layers": 1,
+        "reduce_type": "mean",
+    }
+
+    def __call__(self, latents, timestep, instruction_embeds, freqs_cis, instruction_attention_mask, **kwargs):
+        return torch.zeros_like(latents)
+
+
+class _FakeScheduler:
+    def set_timesteps(self, num_inference_steps, device=None, num_tokens=None):
+        self.timesteps = torch.linspace(0, 1, num_inference_steps + 1)[:-1]
+
+    def step(self, model_output, t, latents, return_dict=False):
+        return (latents,)
+
+
+class _FakeDecodeVAE:
+    dtype = torch.float32
+
+    def __init__(self):
+        self.config = SimpleNamespace(scaling_factor=1.0, shift_factor=0.0, block_out_channels=[128, 256, 512, 512])
+
+    def decode(self, latents, return_dict=False):
+        batch = latents.shape[0]
+        return (torch.zeros(batch, 3, 16, 16),)
+
+
+def _make_forward_pipeline():
+    pipeline = _make_encode_pipeline()
+    pipeline.transformer = _FakeTransformer()
+    pipeline.scheduler = _FakeScheduler()
+    pipeline.vae = _FakeDecodeVAE()
+    pipeline.vae_scale_factor = 8
+    pipeline.default_sample_size = 128
+    return pipeline
+
+
+def _make_request_batch(prompt, **sampling_overrides):
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    sampling = OmniDiffusionSamplingParams(**sampling_overrides)
+    return SimpleNamespace(prompts=[prompt], sampling_params=sampling)
+
+
+def test_forward_returns_diffusion_output():
+    from vllm_omni.diffusion.data import DiffusionOutput
+
+    pipeline = _make_forward_pipeline()
+    req = _make_request_batch("a cat", height=64, width=64, num_inference_steps=2)
+
+    out = pipeline.forward(req)
+
+    assert isinstance(out, DiffusionOutput)
+    assert isinstance(out.output, torch.Tensor)
+    assert out.output.shape[0] == 1
+    assert torch.isfinite(out.output).all()
+    # CFG default is on (text guidance 4.0), so the encoder ran twice (pos + neg).
+    assert len(pipeline.processor.calls) == 2
+
+
+def test_forward_cfg_off_when_guidance_one():
+    pipeline = _make_forward_pipeline()
+    req = _make_request_batch("a cat", height=64, width=64, num_inference_steps=2, guidance_scale=1.0)
+    # guidance_scale=1.0 is falsy-adjacent but explicitly disables CFG; the
+    # request layer would set guidance_scale_provided, so emulate that here.
+    req.sampling_params.guidance_scale_provided = True
+
+    pipeline.forward(req)
+
+    # Only the positive prompt is encoded when CFG is off.
+    assert len(pipeline.processor.calls) == 1
+
+
+# ---------------------------------------------------------------------------
+# Editing / TI2I: pre-process function
+# ---------------------------------------------------------------------------
+
+
+def _make_edit_od_config(tmp_path, block_out_channels=(128, 256, 512, 512)):
+    import json
+
+    vae_dir = tmp_path / "vae"
+    vae_dir.mkdir(parents=True, exist_ok=True)
+    (vae_dir / "config.json").write_text(json.dumps({"block_out_channels": list(block_out_channels)}))
+    return OmniDiffusionConfig(
+        model=str(tmp_path),
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.float32,
+        num_gpus=1,
+    )
+
+
+@pytest.mark.parametrize(
+    "factory_name",
+    ["get_boogu_image_pre_process_func", "get_boogu_image_post_process_func"],
+)
+@pytest.mark.parametrize("config_contents", [None, "{not valid json"])
+def test_process_factory_reports_invalid_vae_config(tmp_path, factory_name, config_contents):
+    import importlib
+
+    vae_dir = tmp_path / "vae"
+    vae_dir.mkdir()
+    if config_contents is not None:
+        (vae_dir / "config.json").write_text(config_contents)
+
+    od_config = OmniDiffusionConfig(
+        model=str(tmp_path),
+        tf_model_config=TransformerConfig(params={}),
+        dtype=torch.float32,
+        num_gpus=1,
+    )
+    factory = getattr(importlib.import_module(_MODULE), factory_name)
+
+    with pytest.raises(RuntimeError, match=r"Failed to load Boogu VAE config from .*vae/config\.json"):
+        factory(od_config)
+
+
+@pytest.mark.parametrize(("height", "width"), [(0, 16), (16, 0), (0, 0)])
+def test_image_processor_rejects_non_positive_dimensions(height, width):
+    from vllm_omni.diffusion.models.boogu_image.image_processor import BooguImageProcessor
+
+    image_processor = BooguImageProcessor()
+    image = torch.zeros(1, 3, 16, 16)
+
+    with pytest.raises(ValueError, match=rf"height={height}, width={width}"):
+        image_processor.get_new_height_width(image, height=height, width=width)
+
+
+def _make_diffusion_request(prompt, **sampling_overrides):
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    sampling = OmniDiffusionSamplingParams(**sampling_overrides)
+    return OmniDiffusionRequest(prompt=prompt, sampling_params=sampling, request_id="req-0")
+
+
+def test_pre_process_no_image_is_noop(tmp_path):
+    import PIL.Image  # noqa: F401  (import guard: PIL must be available)
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        get_boogu_image_pre_process_func,
+    )
+
+    pre = get_boogu_image_pre_process_func(_make_edit_od_config(tmp_path))
+
+    # Text-to-image request: no multimodal image -> returned unchanged.
+    req = _make_diffusion_request({"prompt": "a cat"}, height=123, width=456)
+    out = pre(req)
+    assert "additional_information" not in out.prompt
+    assert out.sampling_params.height == 123
+    assert out.sampling_params.width == 456
+
+    # A plain-string prompt cannot carry an image either.
+    str_req = _make_diffusion_request("a cat")
+    assert pre(str_req).prompt == "a cat"
+
+
+def test_pre_process_populates_reference_and_align_res(tmp_path):
+    import PIL.Image
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        get_boogu_image_pre_process_func,
+    )
+
+    pre = get_boogu_image_pre_process_func(_make_edit_od_config(tmp_path))
+
+    image = PIL.Image.new("RGB", (1000, 500))  # (width, height)
+    req = _make_diffusion_request({"prompt": "make it winter", "multi_modal_data": {"image": image}})
+    out = pre(req)
+
+    ai = out.prompt["additional_information"]
+    assert "prompt_image" in ai and "preprocessed_image" in ai
+
+    # VLM copy is a PIL image, downscaled, never upscaled, aligned to 16.
+    prompt_image = ai["prompt_image"]
+    assert isinstance(prompt_image, PIL.Image.Image)
+    assert prompt_image.width % 16 == 0 and prompt_image.height % 16 == 0
+    assert prompt_image.width <= 1000 and prompt_image.height <= 500
+    assert max(prompt_image.width, prompt_image.height) <= 768
+
+    # VAE copy is a normalized [1, C, H, W] tensor aligned to 16.
+    vae = ai["preprocessed_image"]
+    assert isinstance(vae, torch.Tensor) and vae.ndim == 4 and vae.shape[0] == 1
+    assert vae.shape[-1] % 16 == 0 and vae.shape[-2] % 16 == 0
+    assert -1.0 <= float(vae.min()) and float(vae.max()) <= 1.0
+
+    # align_res: the request resolution follows the VAE-encoded reference dims.
+    assert out.sampling_params.height == vae.shape[-2]
+    assert out.sampling_params.width == vae.shape[-1]
+
+
+def test_pre_process_rejects_multiple_images(tmp_path):
+    import PIL.Image
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        get_boogu_image_pre_process_func,
+    )
+
+    pre = get_boogu_image_pre_process_func(_make_edit_od_config(tmp_path))
+    imgs = [PIL.Image.new("RGB", (64, 64)), PIL.Image.new("RGB", (64, 64))]
+    req = _make_diffusion_request({"prompt": "combine", "multi_modal_data": {"image": imgs}})
+
+    with pytest.raises(ValueError, match="single reference image"):
+        pre(req)
+
+
+def test_pre_process_single_image_in_list_is_accepted(tmp_path):
+    import PIL.Image
+
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        get_boogu_image_pre_process_func,
+    )
+
+    pre = get_boogu_image_pre_process_func(_make_edit_od_config(tmp_path))
+    req = _make_diffusion_request({"prompt": "edit", "multi_modal_data": {"image": [PIL.Image.new("RGB", (128, 128))]}})
+    out = pre(req)
+    assert "preprocessed_image" in out.prompt["additional_information"]
+
+
+# ---------------------------------------------------------------------------
+# Editing / TI2I: chat template + image-aware encoding
+# ---------------------------------------------------------------------------
+
+
+def _make_edit_encode_pipeline():
+    from vllm_omni.diffusion.models.boogu_image.pipeline_boogu_image import (
+        SYSTEM_PROMPT_4_TI2I_UNIFIED,
+    )
+
+    pipeline = _make_encode_pipeline()
+    pipeline.SYSTEM_PROMPT_4_TI2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
+    pipeline.SYSTEM_PROMPT_4_I2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
+    return pipeline
+
+
+def test_apply_chat_template_ti2i_places_image_before_text():
+    import PIL.Image
+
+    pipeline = _make_edit_encode_pipeline()
+    image = PIL.Image.new("RGB", (16, 16))
+
+    messages = pipeline._apply_chat_template("turn day into night", [image])
+    assert messages[0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_4_TI2I
+    user_content = messages[1]["content"]
+    # Image content comes first, then the instruction text.
+    assert user_content[0]["type"] == "image"
+    assert user_content[0]["image"] is image
+    assert user_content[-1] == {"type": "text", "text": "turn day into night"}
+
+    # Empty instruction with an image selects the I2I system prompt.
+    empty_messages = pipeline._apply_chat_template("", [image])
+    assert empty_messages[0]["content"][0]["text"] == pipeline.SYSTEM_PROMPT_4_I2I
+
+
+class _ImageAwareRecordingProcessor:
+    """Records whether reference images reached the processor."""
+
+    def __init__(self):
+        self.calls = []
+
+    def apply_chat_template(self, prompts, **kwargs):
+        has_image = []
+        for messages in prompts:
+            user_content = messages[1]["content"]
+            has_image.append(any(c.get("type") == "image" for c in user_content))
+        self.calls.append({"prompts": prompts, "kwargs": kwargs, "has_image": has_image})
+        batch = len(prompts)
+        input_ids = torch.arange(batch * _SEQ_LEN, dtype=torch.long).view(batch, _SEQ_LEN)
+        attention_mask = torch.ones(batch, _SEQ_LEN, dtype=torch.long)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+
+def test_encode_prompt_attaches_images_to_positive_only():
+    import PIL.Image
+
+    pipeline = _make_edit_encode_pipeline()
+    pipeline.processor = _ImageAwareRecordingProcessor()
+    image = PIL.Image.new("RGB", (16, 16))
+
+    pipeline.encode_prompt(
+        "add a rainbow",
+        do_classifier_free_guidance=True,
+        input_images=[[image]],
+    )
+
+    # Positive call carries the image; the negative (CFG) call is image-free.
+    assert pipeline.processor.calls[0]["has_image"] == [True]
+    assert pipeline.processor.calls[1]["has_image"] == [False]
+
+
+# ---------------------------------------------------------------------------
+# Editing / TI2I: reference-latent VAE encode
+# ---------------------------------------------------------------------------
+
+
+class _FakeRefVAE:
+    """Fake VAE whose ``encode`` yields a known latent for shape/scaling checks."""
+
+    dtype = torch.float32
+
+    def __init__(self, scaling_factor=2.0, shift_factor=0.5):
+        self.config = SimpleNamespace(scaling_factor=scaling_factor, shift_factor=shift_factor)
+        self._latent = torch.ones(1, 4, 3, 5)
+
+    def encode(self, img):
+        dist = SimpleNamespace(sample=lambda generator=None: self._latent.clone())
+        return SimpleNamespace(latent_dist=dist)
+
+
+def test_build_ref_latents_shape_and_scaling():
+    pipeline = _make_encode_pipeline()
+    pipeline.vae = _FakeRefVAE(scaling_factor=2.0, shift_factor=0.5)
+
+    preprocessed = torch.zeros(1, 3, 48, 80)  # normalized image tensor
+    ref_latents = pipeline._build_ref_latents([preprocessed], num_images_per_prompt=1, device=torch.device("cpu"))
+
+    assert len(ref_latents) == 1
+    (sample_latents,) = ref_latents
+    assert isinstance(sample_latents, list) and len(sample_latents) == 1
+    latent = sample_latents[0]
+    # squeeze(0) -> [C, H, W]; (1 - shift) * scaling = (1 - 0.5) * 2 = 1.0
+    assert latent.shape == (4, 3, 5)
+    assert torch.allclose(latent, torch.ones(4, 3, 5))
+
+
+def test_build_ref_latents_expands_per_output_and_handles_none():
+    pipeline = _make_encode_pipeline()
+    pipeline.vae = _FakeRefVAE()
+
+    preprocessed = torch.zeros(1, 3, 48, 80)
+    ref_latents = pipeline._build_ref_latents([preprocessed, None], num_images_per_prompt=2, device=torch.device("cpu"))
+
+    # Two samples x 2 outputs each = 4 entries; the None sample stays None.
+    assert len(ref_latents) == 4
+    assert ref_latents[0] is ref_latents[1]  # same sample repeated
+    assert ref_latents[2] is None and ref_latents[3] is None
+
+
+# ---------------------------------------------------------------------------
+# Editing / TI2I: forward CFG branch selection
+# ---------------------------------------------------------------------------
+
+
+class _RecordingRefTransformer(_FakeTransformer):
+    """Counts predictions per step and records the reference-latent argument."""
+
+    def __init__(self):
+        self.calls = []
+
+    def __call__(self, latents, timestep, instruction_embeds, freqs_cis, instruction_attention_mask, **kwargs):
+        self.calls.append(kwargs.get("ref_image_hidden_states"))
+        return torch.zeros_like(latents)
+
+
+class _EditForwardVAE(_FakeDecodeVAE):
+    """Adds a fake ``encode`` so the editing forward path can build ref latents."""
+
+    def encode(self, img):
+        dist = SimpleNamespace(sample=lambda generator=None: torch.zeros(1, 4, 8, 8))
+        return SimpleNamespace(latent_dist=dist)
+
+
+def _make_edit_forward_pipeline():
+    pipeline = _make_edit_encode_pipeline()
+    # Image-aware processor: reference images appear as ``{"type": "image"}``
+    # content entries, which the default text-first fake cannot parse.
+    pipeline.processor = _ImageAwareRecordingProcessor()
+    pipeline.transformer = _RecordingRefTransformer()
+    pipeline.scheduler = _FakeScheduler()
+    pipeline.vae = _EditForwardVAE()
+    pipeline.vae_scale_factor = 8
+    pipeline.default_sample_size = 128
+    return pipeline
+
+
+def _make_edit_request(**sampling_overrides):
+    import PIL.Image
+
+    image = PIL.Image.new("RGB", (64, 64))
+    prompt = {
+        "prompt": "make it winter",
+        "additional_information": {
+            "prompt_image": image,
+            "preprocessed_image": torch.zeros(1, 3, 64, 64),
+        },
+    }
+    sampling = _sampling(**sampling_overrides)
+    return SimpleNamespace(prompts=[prompt], sampling_params=sampling)
+
+
+def _sampling(**overrides):
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    return OmniDiffusionSamplingParams(**overrides)
+
+
+def _count_per_step(calls, num_steps):
+    assert len(calls) % num_steps == 0
+    return len(calls) // num_steps
+
+
+def test_forward_ti2i_text_only_two_predictions_with_ref():
+    pipeline = _make_edit_forward_pipeline()
+    num_steps = 2
+    req = _make_edit_request(height=64, width=64, num_inference_steps=num_steps, guidance_scale=5.0)
+    req.sampling_params.guidance_scale_provided = True
+
+    pipeline.forward(req)
+
+    # Text-only ti2i: cond+ref and neg+ref -> 2 predictions/step, both carry ref.
+    assert _count_per_step(pipeline.transformer.calls, num_steps) == 2
+    assert all(ref is not None for ref in pipeline.transformer.calls)
+
+
+def test_forward_ti2i_double_guidance_three_predictions():
+    pipeline = _make_edit_forward_pipeline()
+    num_steps = 2
+    req = _make_edit_request(
+        height=64, width=64, num_inference_steps=num_steps, guidance_scale=5.0, guidance_scale_2=2.0
+    )
+    req.sampling_params.guidance_scale_provided = True
+    req.sampling_params.guidance_scale_2_provided = True
+
+    pipeline.forward(req)
+
+    # Double guidance: cond+ref, neg+ref, neg+no-ref -> 3 predictions/step.
+    assert _count_per_step(pipeline.transformer.calls, num_steps) == 3
+    # Exactly one of the three per step drops the reference (neg+no-ref).
+    per_step = [pipeline.transformer.calls[i : i + 3] for i in range(0, len(pipeline.transformer.calls), 3)]
+    for step_calls in per_step:
+        assert sum(ref is None for ref in step_calls) == 1
+
+
+def test_forward_ti2i_image_only_two_predictions_drop_ref():
+    pipeline = _make_edit_forward_pipeline()
+    num_steps = 2
+    # text guidance 1.0 (off, provided) + image guidance 2.0 (provided).
+    req = _make_edit_request(
+        height=64, width=64, num_inference_steps=num_steps, guidance_scale=1.0, guidance_scale_2=2.0
+    )
+    req.sampling_params.guidance_scale_provided = True
+    req.sampling_params.guidance_scale_2_provided = True
+
+    pipeline.forward(req)
+
+    # Image-only ti2i: cond+ref and cond+no-ref -> 2 predictions/step.
+    assert _count_per_step(pipeline.transformer.calls, num_steps) == 2
+    per_step = [pipeline.transformer.calls[i : i + 2] for i in range(0, len(pipeline.transformer.calls), 2)]
+    for step_calls in per_step:
+        assert sum(ref is None for ref in step_calls) == 1
+
+
+def test_forward_ti2i_no_guidance_single_prediction_with_ref():
+    pipeline = _make_edit_forward_pipeline()
+    num_steps = 2
+    # Both guidances off/unprovided -> image guidance forced to 1.0, no CFG.
+    req = _make_edit_request(height=64, width=64, num_inference_steps=num_steps, guidance_scale=1.0)
+    req.sampling_params.guidance_scale_provided = True
+
+    pipeline.forward(req)
+
+    assert _count_per_step(pipeline.transformer.calls, num_steps) == 1
+    assert all(ref is not None for ref in pipeline.transformer.calls)
+
+
+def test_forward_image_guidance_ignored_without_reference():
+    # guidance_scale_2 is set but there is no reference image (t2i request);
+    # image guidance must be forced off so this stays plain t2i CFG.
+    pipeline = _make_edit_forward_pipeline()
+    num_steps = 2
+    sampling = _sampling(height=64, width=64, num_inference_steps=num_steps, guidance_scale=5.0, guidance_scale_2=2.0)
+    sampling.guidance_scale_provided = True
+    sampling.guidance_scale_2_provided = True
+    req = SimpleNamespace(prompts=[{"prompt": "a cat"}], sampling_params=sampling)
+
+    pipeline.forward(req)
+
+    # t2i text CFG: cond + uncond -> 2 predictions/step, no ref anywhere.
+    assert _count_per_step(pipeline.transformer.calls, num_steps) == 2
+    assert all(ref is None for ref in pipeline.transformer.calls)
diff --git a/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py b/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
index ba482e793..3093e6ceb 100644
--- a/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
+++ b/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
@@ -36,20 +36,36 @@ class StubScheduler:
         timesteps: list[int] | None = None,
         *,
         flow_shift: float = 1.0,
-        use_karras_sigmas: bool = True,
     ) -> None:
         self.timesteps = torch.tensor(timesteps or [9, 3], dtype=torch.int64)
         self.config = SimpleNamespace(
             num_train_timesteps=1000,
             flow_shift=flow_shift,
-            use_karras_sigmas=use_karras_sigmas,
         )
-        self.set_timesteps_calls: list[tuple[int, torch.device]] = []
+        self.set_timesteps_calls: list[dict[str, Any]] = []
         self.step_calls: list[tuple[torch.Tensor, torch.Tensor, torch.Tensor]] = []
 
-    def set_timesteps(self, num_steps: int, device: torch.device) -> None:
-        self.set_timesteps_calls.append((num_steps, device))
-        self.timesteps = torch.arange(num_steps, 0, -1, dtype=torch.int64, device=device)
+    def set_timesteps(
+        self,
+        num_inference_steps: int | None = None,
+        device: str | torch.device | None = None,
+        *,
+        shift: float | None = None,
+        sigmas: list[float] | None = None,
+    ) -> None:
+        self.set_timesteps_calls.append(
+            {
+                "num_inference_steps": num_inference_steps,
+                "device": device,
+                "shift": shift,
+                "sigmas": sigmas,
+            }
+        )
+        if sigmas is not None:
+            self.timesteps = torch.tensor(sigmas, device=device)
+        else:
+            assert num_inference_steps is not None
+            self.timesteps = torch.arange(num_inference_steps, 0, -1, dtype=torch.int64, device=device)
 
     def step(self, noise_pred: torch.Tensor, timestep: torch.Tensor, latents: torch.Tensor, **kwargs):
         del kwargs
@@ -200,6 +216,7 @@ def fake_cosmos3_guardrails(monkeypatch: pytest.MonkeyPatch):
 def make_cosmos3_pipeline():
     def _make():
         from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+            COSMOS3_VIDEO_DEFAULT_FLOW_SHIFT,
             Cosmos3OmniDiffusersPipeline,
         )
 
@@ -213,11 +230,10 @@ def make_cosmos3_pipeline():
         pipeline.vae_scale_factor_temporal = 4
         pipeline.vae_scale_factor_spatial = 8
         pipeline.scheduler = StubScheduler([9, 3], flow_shift=1.0)
-        pipeline._base_scheduler_config = pipeline.scheduler.config
-        pipeline._engine_init_flow_shift = 1.0
-        pipeline._current_flow_shift = 1.0
-        pipeline._base_scheduler_use_karras_sigmas = True
-        pipeline._current_scheduler_use_karras_sigmas = True
+        pipeline._engine_init_flow_shift = COSMOS3_VIDEO_DEFAULT_FLOW_SHIFT
+        pipeline._current_flow_shift = COSMOS3_VIDEO_DEFAULT_FLOW_SHIFT
+        pipeline.is_distilled_model = False
+        pipeline.is_edge_model = False
         pipeline._guidance_scale = None
         pipeline._num_timesteps = None
         pipeline._cosmos3_branch_caches = None
@@ -243,6 +259,7 @@ def make_sampling_params(**overrides: Any) -> SimpleNamespace:
         "num_frames": None,
         "num_inference_steps": None,
         "guidance_scale": None,
+        "guidance_scale_provided": False,
         "generator": None,
         "seed": 123,
         "num_outputs_per_prompt": 1,
@@ -288,8 +305,167 @@ def _mask() -> torch.Tensor:
     return torch.ones(1, 1, dtype=torch.long)
 
 
+def _capture_tokenize_calls(pipeline: Any) -> list[dict[str, Any]]:
+    calls: list[dict[str, Any]] = []
+
+    def _tokenize(
+        text: str,
+        max_sequence_length: int,
+        use_system_prompt: bool = False,
+        system_prompt: str | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        index = len(calls) + 1
+        calls.append(
+            {
+                "text": text,
+                "max_sequence_length": max_sequence_length,
+                "use_system_prompt": use_system_prompt,
+                "system_prompt": system_prompt,
+            }
+        )
+        return _ids(index), torch.full((1, 1), index, dtype=torch.long)
+
+    pipeline._tokenize_prompt = _tokenize
+    return calls
+
+
+@pytest.mark.parametrize(
+    ("provided", "value", "default", "is_distilled", "expected"),
+    [
+        (False, 1.0, 7.0, False, 7.0),
+        (True, 1.0, 7.0, False, 1.0),
+        (True, 4.5, 7.0, False, 4.5),
+        (False, 1.0, 7.0, True, 1.0),
+        (True, 4.5, 7.0, True, 1.0),
+    ],
+)
+def test_resolve_guidance_scale(
+    make_cosmos3_pipeline,
+    provided: bool,
+    value: float,
+    default: float,
+    is_distilled: bool,
+    expected: float,
+) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_distilled_model = is_distilled
+    sp = make_sampling_params(
+        guidance_scale=value,
+        guidance_scale_provided=provided,
+    )
+
+    assert pipeline._resolve_guidance_scale(sp, default) == expected
+
+
+def test_distilled_generation_accepts_t2i_and_i2v(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_distilled_model = True
+    common = {
+        "action_enabled": False,
+        "transfer_config": None,
+        "is_v2v": False,
+        "sound_enabled": False,
+    }
+
+    pipeline._validate_distilled_generation_mode(
+        is_t2i=True,
+        image_tensor=None,
+        **common,
+    )
+    pipeline._validate_distilled_generation_mode(
+        is_t2i=False,
+        image_tensor=torch.zeros(1),
+        **common,
+    )
+
+
+@pytest.mark.parametrize(
+    ("overrides", "message"),
+    [
+        ({"action_enabled": True}, "action requests are unsupported"),
+        ({"transfer_config": SimpleNamespace()}, "transfer requests are unsupported"),
+        ({"is_v2v": True}, "video-to-video requests are unsupported"),
+        ({"sound_enabled": True}, "sound generation is unsupported"),
+        (
+            {"is_t2i": False, "image_tensor": None},
+            "text-to-video requests are unsupported",
+        ),
+        (
+            {"is_t2i": True, "image_tensor": torch.zeros(1)},
+            "image-conditioned image generation is unsupported",
+        ),
+    ],
+)
+def test_distilled_generation_rejects_unsupported_modes(
+    make_cosmos3_pipeline,
+    overrides: dict[str, Any],
+    message: str,
+) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_distilled_model = True
+    kwargs = {
+        "is_t2i": True,
+        "image_tensor": None,
+        "action_enabled": False,
+        "transfer_config": None,
+        "is_v2v": False,
+        "sound_enabled": False,
+    }
+    kwargs.update(overrides)
+
+    with pytest.raises(ValueError, match=message):
+        pipeline._validate_distilled_generation_mode(**kwargs)
+
+
+def test_distilled_generation_rejects_robolab_policy(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_distilled_model = True
+
+    with pytest.raises(ValueError, match="RoboLab/action policy requests are unsupported"):
+        pipeline._forward_robolab_policy(make_sampling_params(), None, 0.0)
+
+
+@pytest.mark.parametrize(
+    ("prompt", "sampling_params", "message"),
+    [
+        (
+            {"prompt": "x", "modalities": ["video"], "generate_sound": True},
+            make_sampling_params(),
+            "do not support sound generation",
+        ),
+        (
+            {"prompt": "x", "modalities": ["video"]},
+            make_sampling_params(extra_args={"edge": {"control_path": "/tmp/control.mp4"}}),
+            "do not support transfer inference",
+        ),
+        (
+            {
+                "prompt": "x",
+                "modalities": ["video"],
+                "additional_information": {
+                    "preprocessed_video": torch.zeros(1, 3, 5, 16, 16),
+                },
+            },
+            make_sampling_params(height=16, width=16, num_frames=5),
+            "do not support video-to-video generation",
+        ),
+    ],
+)
+def test_edge_forward_rejects_unsupported_modes(
+    make_cosmos3_pipeline,
+    prompt: dict[str, Any],
+    sampling_params: SimpleNamespace,
+    message: str,
+) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_edge_model = True
+
+    with pytest.raises(ValueError, match=message):
+        pipeline.forward(SimpleNamespace(prompts=[prompt], sampling_params=sampling_params))
+
+
 def test_pipeline_registered_and_exported() -> None:
-    from vllm_omni.diffusion.cache.cache_dit_backend import CUSTOM_DIT_ENABLERS
+    from vllm_omni.diffusion.cache.cachedit import CUSTOM_DIT_ENABLERS
     from vllm_omni.diffusion.models import cosmos3
     from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
     from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
@@ -303,17 +479,45 @@ def test_pipeline_registered_and_exported() -> None:
     assert issubclass(Cosmos3OmniDiffusersPipeline, nn.Module)
     assert issubclass(Cosmos3OmniDiffusersPipeline, ProgressBarMixin)
     assert Cosmos3OmniDiffusersPipeline.support_image_input is True
-    assert _DIFFUSION_MODELS["Cosmos3OmniDiffusersPipeline"] == (
-        "cosmos3",
-        "pipeline_cosmos3",
-        "Cosmos3OmniDiffusersPipeline",
-    )
-    assert _DIFFUSION_PRE_PROCESS_FUNCS["Cosmos3OmniDiffusersPipeline"] == "get_cosmos3_pre_process_func"
-    assert _DIFFUSION_POST_PROCESS_FUNCS["Cosmos3OmniDiffusersPipeline"] == "get_cosmos3_post_process_func"
-    assert _DIFFUSION_IR_OP_PRIORITY_FUNCS["Cosmos3OmniDiffusersPipeline"] == "get_cosmos3_ir_op_priority_func"
-    assert "Cosmos3OmniDiffusersPipeline" in CUSTOM_DIT_ENABLERS
     assert "Cosmos3OmniDiffusersPipeline" in cosmos3.__all__
 
+    for pipeline_name in ("Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"):
+        assert _DIFFUSION_MODELS[pipeline_name] == (
+            "cosmos3",
+            "pipeline_cosmos3",
+            "Cosmos3OmniDiffusersPipeline",
+        )
+        assert _DIFFUSION_PRE_PROCESS_FUNCS[pipeline_name] == "get_cosmos3_pre_process_func"
+        assert _DIFFUSION_POST_PROCESS_FUNCS[pipeline_name] == "get_cosmos3_post_process_func"
+        assert _DIFFUSION_IR_OP_PRIORITY_FUNCS[pipeline_name] == "get_cosmos3_ir_op_priority_func"
+        assert pipeline_name in CUSTOM_DIT_ENABLERS
+
+
+@pytest.mark.parametrize(
+    "pipeline_name",
+    ["Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"],
+)
+def test_cosmos3_model_index_resolves_pipeline(
+    tmp_path,
+    pipeline_name: str,
+) -> None:
+    import json
+
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+        Cosmos3OmniDiffusersPipeline,
+    )
+    from vllm_omni.diffusion.registry import DiffusionModelRegistry
+
+    (tmp_path / "model_index.json").write_text(json.dumps({"_class_name": pipeline_name}))
+
+    config = OmniDiffusionConfig(model=str(tmp_path))
+    config.enrich_config()
+
+    assert config.model_class_name == pipeline_name
+    resolved_pipeline_cls = DiffusionModelRegistry._try_load_model_cls(config.model_class_name)
+    assert resolved_pipeline_cls is Cosmos3OmniDiffusersPipeline
+
 
 @pytest.fixture
 def stub_real_pipeline_init(monkeypatch: pytest.MonkeyPatch):
@@ -335,25 +539,24 @@ def stub_real_pipeline_init(monkeypatch: pytest.MonkeyPatch):
             return self
 
     class _StubDiffusersScheduler:
+        load_config_calls: list[dict[str, Any]] = []
         from_config_calls: list[dict[str, Any]] = []
 
-        def __init__(self, *, flow_shift: float = 1.0, use_karras_sigmas: bool = True) -> None:
-            self.config = SimpleNamespace(flow_shift=flow_shift, use_karras_sigmas=use_karras_sigmas)
+        def __init__(self, *, flow_shift: float = 1.0) -> None:
+            self.config = SimpleNamespace(flow_shift=flow_shift)
 
         @classmethod
-        def from_pretrained(cls, *args, **kwargs):
-            return cls()
+        def load_config(cls, *args, **kwargs):
+            cls.load_config_calls.append({"args": args, "kwargs": dict(kwargs)})
+            return {
+                "_class_name": "UniPCMultistepScheduler",
+                "flow_shift": 1.0,
+            }
 
         @classmethod
         def from_config(cls, config, **kwargs):
             cls.from_config_calls.append({"config": config, "kwargs": dict(kwargs)})
-            return cls(
-                flow_shift=kwargs.get("flow_shift", getattr(config, "flow_shift", 1.0)),
-                use_karras_sigmas=kwargs.get(
-                    "use_karras_sigmas",
-                    getattr(config, "use_karras_sigmas", True),
-                ),
-            )
+            return cls(flow_shift=kwargs.get("shift", config.get("flow_shift", 1.0)))
 
     class _StubVideoProcessor:
         def __init__(self, *args, **kwargs) -> None:
@@ -361,13 +564,18 @@ def stub_real_pipeline_init(monkeypatch: pytest.MonkeyPatch):
 
     monkeypatch.setattr(pipeline_cosmos3, "AutoTokenizer", _StubAutoTokenizer)
     monkeypatch.setattr(pipeline_cosmos3, "DistributedAutoencoderKLWan", _StubDiffusersVAE)
-    monkeypatch.setattr(pipeline_cosmos3, "UniPCMultistepScheduler", _StubDiffusersScheduler)
+    monkeypatch.setattr(pipeline_cosmos3, "FlowUniPCMultistepScheduler", _StubDiffusersScheduler)
     monkeypatch.setattr(pipeline_cosmos3, "VideoProcessor", _StubVideoProcessor)
     monkeypatch.setattr(pipeline_cosmos3, "get_local_device", lambda: torch.device("cpu"))
     return _StubDiffusersScheduler
 
 
-def _make_od_config(*, sound_gen: bool) -> SimpleNamespace:
+def _make_od_config(
+    *,
+    sound_gen: bool,
+    tf_model_config_overrides: dict[str, Any] | None = None,
+    model_config: dict[str, Any] | None = None,
+) -> SimpleNamespace:
     tf_model_config = {
         "hidden_size": 8,
         "num_hidden_layers": 0,
@@ -382,6 +590,8 @@ def _make_od_config(*, sound_gen: bool) -> SimpleNamespace:
     }
     if sound_gen:
         tf_model_config["sound_gen"] = True
+    if tf_model_config_overrides:
+        tf_model_config.update(tf_model_config_overrides)
     return SimpleNamespace(
         enable_cpu_offload=False,
         enable_diffusion_pipeline_profiler=False,
@@ -390,7 +600,7 @@ def _make_od_config(*, sound_gen: bool) -> SimpleNamespace:
         flow_shift=None,
         quantization_config=None,
         custom_pipeline_args={},
-        model_config={},
+        model_config=model_config or {},
         tf_model_config=tf_model_config,
     )
 
@@ -400,16 +610,13 @@ def test_pipeline_init_skips_tokenizer_when_sound_disabled(stub_real_pipeline_in
 
     pipeline = Cosmos3OmniDiffusersPipeline(od_config=_make_od_config(sound_gen=False))
 
-    assert stub_real_pipeline_init.from_config_calls == []
     assert pipeline._sound_tokenizer is None
     assert pipeline.transformer.sound_gen is False
     assert not hasattr(pipeline.transformer, "audio_proj_in")
     assert not hasattr(pipeline.transformer, "audio_proj_out")
-    assert pipeline._base_scheduler_use_karras_sigmas is True
-    assert pipeline._current_scheduler_use_karras_sigmas is True
 
 
-def test_pipeline_init_rebuilds_scheduler_with_cosmos3_defaults(stub_real_pipeline_init) -> None:
+def test_pipeline_init_uses_flow_unipc_with_cosmos3_defaults(stub_real_pipeline_init) -> None:
     from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
 
     od_config = _make_od_config(sound_gen=False)
@@ -417,55 +624,301 @@ def test_pipeline_init_rebuilds_scheduler_with_cosmos3_defaults(stub_real_pipeli
 
     pipeline = Cosmos3OmniDiffusersPipeline(od_config=od_config)
 
-    assert stub_real_pipeline_init.from_config_calls
-    call = stub_real_pipeline_init.from_config_calls[-1]
-    assert getattr(call["config"], "flow_shift") == 1.0
-    assert call["kwargs"] == {"flow_shift": 2.5}
+    assert len(stub_real_pipeline_init.load_config_calls) == 1
+    assert len(stub_real_pipeline_init.from_config_calls) == 1
+    call = stub_real_pipeline_init.from_config_calls[0]
+    assert call["config"]["_class_name"] == "UniPCMultistepScheduler"
+    assert call["kwargs"] == {
+        "shift": 1.0,
+        "use_dynamic_shifting": False,
+        "prediction_type": "flow_prediction",
+    }
+    assert pipeline.is_distilled_model is False
     assert pipeline._engine_init_flow_shift == 2.5
-    assert pipeline._base_scheduler_use_karras_sigmas is True
 
 
-def test_set_flow_shift_restores_checkpoint_scheduler_mode(
-    make_cosmos3_pipeline,
+@pytest.mark.parametrize(
+    ("scheduler_class_name", "expected_distilled"),
+    [
+        ("FlowMatchEulerDiscreteScheduler", True),
+        ("UniPCMultistepScheduler", False),
+    ],
+)
+def test_pipeline_resolves_scheduler_class_from_checkpoint_file(
+    tmp_path,
+    stub_real_pipeline_init,
     monkeypatch: pytest.MonkeyPatch,
+    scheduler_class_name: str,
+    expected_distilled: bool,
 ) -> None:
+    import json
+
     from vllm_omni.diffusion.models.cosmos3 import pipeline_cosmos3
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
+    from vllm_omni.diffusion.models.schedulers.scheduling_flow_unipc_multistep import (
+        FlowUniPCMultistepScheduler as RealFlowUniPCMultistepScheduler,
+    )
 
-    class RecordingScheduler:
-        from_config_calls: list[dict[str, Any]] = []
+    t_list = [1.0, 0.75, 0.5, 0.25]
+    scheduler_dir = tmp_path / "scheduler"
+    scheduler_dir.mkdir()
+    scheduler_config = {"_class_name": scheduler_class_name}
+    if expected_distilled:
+        scheduler_config["fixed_step_sampler_config"] = {"sample_type": "sde", "t_list": t_list}
+    (scheduler_dir / "scheduler_config.json").write_text(json.dumps(scheduler_config))
 
-        def __init__(self, *, flow_shift: float, use_karras_sigmas: bool) -> None:
-            self.config = SimpleNamespace(flow_shift=flow_shift, use_karras_sigmas=use_karras_sigmas)
+    class StubFlowUniPCScheduler(StubScheduler):
+        from_config_calls: list[tuple[Any, dict[str, Any]]] = []
+
+        @classmethod
+        def load_config(cls, *args, **kwargs):
+            return RealFlowUniPCMultistepScheduler.load_config(*args, **kwargs)
 
         @classmethod
         def from_config(cls, config, **kwargs):
-            cls.from_config_calls.append({"config": config, "kwargs": dict(kwargs)})
-            return cls(
-                flow_shift=kwargs.get("flow_shift", getattr(config, "flow_shift", 1.0)),
-                use_karras_sigmas=kwargs.get(
-                    "use_karras_sigmas",
-                    getattr(config, "use_karras_sigmas", True),
-                ),
-            )
+            cls.from_config_calls.append((config, dict(kwargs)))
+            return cls()
 
-    monkeypatch.setattr(pipeline_cosmos3, "UniPCMultistepScheduler", RecordingScheduler)
-    pipeline = make_cosmos3_pipeline()
+    class StubFlowMatchScheduler(StubScheduler):
+        from_config_calls: list[tuple[Any, dict[str, Any]]] = []
 
-    pipeline._set_flow_shift(10.0, use_karras_sigmas=False)
-    assert RecordingScheduler.from_config_calls[-1]["kwargs"] == {
-        "flow_shift": 10.0,
-        "use_karras_sigmas": False,
+        @classmethod
+        def from_config(cls, config, **kwargs):
+            cls.from_config_calls.append((config, dict(kwargs)))
+            scheduler = cls()
+            scheduler.config.fixed_step_sampler_config = config["fixed_step_sampler_config"]
+            return scheduler
+
+    monkeypatch.setattr(pipeline_cosmos3, "FlowUniPCMultistepScheduler", StubFlowUniPCScheduler)
+    monkeypatch.setattr(
+        pipeline_cosmos3,
+        "FlowMatchEulerDiscreteScheduler",
+        StubFlowMatchScheduler,
+    )
+
+    od_config = _make_od_config(sound_gen=False)
+    od_config.model = str(tmp_path)
+    pipeline = Cosmos3OmniDiffusersPipeline(od_config=od_config)
+
+    assert pipeline.is_distilled_model is expected_distilled
+    if expected_distilled:
+        assert len(StubFlowMatchScheduler.from_config_calls) == 1
+        assert StubFlowMatchScheduler.from_config_calls[0][1] == {"stochastic_sampling": True}
+        assert StubFlowUniPCScheduler.from_config_calls == []
+        assert pipeline._scheduler_init_t_list == t_list
+    else:
+        assert len(StubFlowUniPCScheduler.from_config_calls) == 1
+        assert StubFlowMatchScheduler.from_config_calls == []
+        assert not hasattr(pipeline, "_scheduler_init_t_list")
+
+
+def test_distilled_pipeline_initializes_sde_scheduler(
+    stub_real_pipeline_init,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+        Cosmos3OmniDiffusersPipeline,
+        FlowMatchEulerDiscreteScheduler,
+    )
+
+    t_list = [1.0, 0.9375, 0.8333333333333334, 0.625]
+    scheduler_config = {
+        "_class_name": "FlowMatchEulerDiscreteScheduler",
+        "shift": 1.0,
+        "stochastic_sampling": False,
+        "fixed_step_sampler_config": {
+            "sample_type": "sde",
+            "t_list": t_list,
+        },
     }
-    assert pipeline._current_flow_shift == 10.0
-    assert pipeline._current_scheduler_use_karras_sigmas is False
+    monkeypatch.setattr(
+        stub_real_pipeline_init,
+        "load_config",
+        classmethod(lambda cls, *args, **kwargs: scheduler_config),
+    )
 
-    pipeline._set_flow_shift(10.0)
-    assert RecordingScheduler.from_config_calls[-1]["kwargs"] == {"flow_shift": 10.0}
-    assert pipeline._current_flow_shift == 10.0
-    assert pipeline._current_scheduler_use_karras_sigmas is True
+    pipeline = Cosmos3OmniDiffusersPipeline(od_config=_make_od_config(sound_gen=False))
+    assert pipeline.is_distilled_model is True
+    assert isinstance(pipeline.scheduler, FlowMatchEulerDiscreteScheduler)
+    assert pipeline.scheduler.config.stochastic_sampling is True
+    assert pipeline._scheduler_init_t_list == t_list
 
-    pipeline._set_flow_shift(10.0)
-    assert len(RecordingScheduler.from_config_calls) == 2
+
+@pytest.mark.parametrize(
+    ("fixed_step_config", "error_pattern"),
+    [
+        pytest.param(
+            {"t_list": [1.0, 0.5]},
+            r"fixed_step_sampler_config\.sample_type=sde",
+            id="missing-sample-type",
+        ),
+        pytest.param(
+            {"sample_type": "ode", "t_list": [1.0, 0.5]},
+            r"fixed_step_sampler_config\.sample_type=sde",
+            id="unsupported-sample-type",
+        ),
+        pytest.param(
+            {"sample_type": "sde"},
+            r"non-empty fixed_step_sampler_config\.t_list",
+            id="missing-t-list",
+        ),
+        pytest.param(
+            {"sample_type": "sde", "t_list": []},
+            r"non-empty fixed_step_sampler_config\.t_list",
+            id="empty-t-list",
+        ),
+    ],
+)
+def test_distilled_scheduler_validates_fixed_step_config(
+    stub_real_pipeline_init,
+    monkeypatch: pytest.MonkeyPatch,
+    fixed_step_config: dict[str, Any],
+    error_pattern: str,
+) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+        Cosmos3OmniDiffusersPipeline,
+    )
+
+    scheduler_config = {
+        "_class_name": "FlowMatchEulerDiscreteScheduler",
+        "fixed_step_sampler_config": fixed_step_config,
+    }
+    monkeypatch.setattr(
+        stub_real_pipeline_init,
+        "load_config",
+        classmethod(lambda cls, *args, **kwargs: scheduler_config),
+    )
+
+    with pytest.raises(ValueError, match=error_pattern):
+        Cosmos3OmniDiffusersPipeline(od_config=_make_od_config(sound_gen=False))
+
+
+def test_pipeline_init_selects_edge_transformer_from_backbone_type(stub_real_pipeline_init) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+        COSMOS3_EDGE_VIDEO_DEFAULT_FLOW_SHIFT,
+        Cosmos3OmniDiffusersPipeline,
+    )
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        COSMOS3_EDGE_BACKBONE_TYPE,
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    pipeline = Cosmos3OmniDiffusersPipeline(
+        od_config=_make_od_config(
+            sound_gen=False,
+            tf_model_config_overrides={
+                "backbone_type": COSMOS3_EDGE_BACKBONE_TYPE,
+                "qk_norm_for_text": False,
+                "latent_channel": 48,
+                "latent_patch_size": 2,
+                "temporal_compression_factor": 4,
+                "layer_norm_epsilon": 1e-5,
+            },
+        )
+    )
+
+    assert isinstance(pipeline.transformer, Cosmos3EdgeVFMTransformer)
+    assert pipeline.is_edge_model is True
+    assert pipeline._engine_init_flow_shift == COSMOS3_EDGE_VIDEO_DEFAULT_FLOW_SHIFT
+
+
+def test_pipeline_init_does_not_select_edge_from_model_index_class_name(stub_real_pipeline_init) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import Cosmos3VFMTransformer
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import Cosmos3EdgeVFMTransformer
+
+    pipeline = Cosmos3OmniDiffusersPipeline(
+        od_config=_make_od_config(
+            sound_gen=False,
+            model_config={"_class_name": "Cosmos3EdgeOmniDiffusersPipeline"},
+        )
+    )
+
+    assert isinstance(pipeline.transformer, Cosmos3VFMTransformer)
+    assert not isinstance(pipeline.transformer, Cosmos3EdgeVFMTransformer)
+
+
+def test_flow_unipc_reuses_scheduler_and_forwards_each_request_shift(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    scheduler = pipeline.scheduler
+
+    assert pipeline._engine_init_flow_shift == 10.0
+    assert pipeline._current_flow_shift == 10.0
+    assert scheduler.config.flow_shift == 1.0
+
+    for shift in (3.0, 10.0):
+        pipeline._set_flow_shift(shift)
+        pipeline._set_timesteps(4, torch.device("cpu"), shift=pipeline._current_flow_shift)
+
+    assert pipeline.scheduler is scheduler
+    assert pipeline._current_flow_shift == 10.0
+    assert [call["shift"] for call in scheduler.set_timesteps_calls] == [3.0, 10.0]
+    assert all(call["num_inference_steps"] == 4 for call in scheduler.set_timesteps_calls)
+    assert all(call["sigmas"] is None for call in scheduler.set_timesteps_calls)
+
+
+def test_flow_unipc_reproducible_with_same_seed(make_cosmos3_pipeline) -> None:
+    from vllm_omni.diffusion.models.schedulers.scheduling_flow_unipc_multistep import (
+        FlowUniPCMultistepScheduler,
+    )
+
+    pipeline = make_cosmos3_pipeline()
+    pipeline.scheduler = FlowUniPCMultistepScheduler(
+        shift=1.0,
+        use_dynamic_shifting=False,
+        prediction_type="flow_prediction",
+    )
+    pipeline._format_and_tokenize_prompts = lambda *args, **kwargs: (
+        _ids(1),
+        _mask(),
+        _ids(0),
+        _mask(),
+    )
+
+    def run(seed: int) -> torch.Tensor:
+        request = make_request_batch(
+            {"prompt": "A test video.", "modalities": ["video"]},
+            make_sampling_params(
+                seed=seed,
+                guidance_scale=1.0,
+                guidance_scale_provided=True,
+                num_inference_steps=4,
+                num_frames=5,
+                height=16,
+                width=16,
+                extra_args={"flow_shift": 3.0},
+            ),
+        )
+        output = pipeline.forward(request)
+        return output.output["video"]
+
+    first = run(123)
+    second = run(123)
+    different_seed = run(456)
+
+    torch.testing.assert_close(first, second)
+    assert not torch.equal(first, different_seed)
+
+
+def test_distilled_set_timesteps_uses_fixed_sigma_schedule(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.is_distilled_model = True
+    pipeline._scheduler_init_t_list = [1.0, 0.75, 0.5, 0.25]
+
+    pipeline._set_timesteps(
+        num_inference_steps=99,
+        device=torch.device("cpu"),
+        shift=7.0,
+    )
+
+    assert pipeline.scheduler.set_timesteps_calls == [
+        {
+            "num_inference_steps": None,
+            "device": torch.device("cpu"),
+            "shift": None,
+            "sigmas": pipeline._scheduler_init_t_list,
+        }
+    ]
 
 
 def test_pipeline_init_passes_tokenizer_attrs_into_transformer(
@@ -806,12 +1259,35 @@ def test_ir_op_priority_hook_preserves_platform_fields(monkeypatch: pytest.Monke
     assert merged.custom_op == ["platform_kernel", "native"]
 
 
-def test_prompt_formatting_and_checkpoint_key_remap(make_cosmos3_pipeline) -> None:
-    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
+def test_format_and_tokenize_prompts_leaves_plain_prompts_unchanged_by_default(make_cosmos3_pipeline) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import COSMOS3_SYSTEM_PROMPT
 
     pipeline = make_cosmos3_pipeline()
-    captured: list[str] = []
-    pipeline._tokenize_prompt = lambda text, *args, **kwargs: (captured.append(text) or _ids(len(captured)), _mask())
+    calls = _capture_tokenize_calls(pipeline)
+
+    result = pipeline._format_and_tokenize_prompts(
+        "  A robot.  ",
+        "  bad.  ",
+        num_frames=48,
+        frame_rate=24,
+        height=720,
+        width=1280,
+        max_sequence_length=32,
+        sp=SimpleNamespace(extra_args={}),
+        use_system_prompt=False,
+        is_t2i=False,
+    )
+
+    assert [call["text"] for call in calls] == ["A robot.", "bad."]
+    assert all(call["max_sequence_length"] == 32 for call in calls)
+    assert all(call["use_system_prompt"] is False for call in calls)
+    assert all(call["system_prompt"] == COSMOS3_SYSTEM_PROMPT for call in calls)
+    assert [tensor.item() for tensor in result] == [1, 1, 2, 2]
+
+
+def test_format_and_tokenize_prompts_applies_video_templates_and_system_override(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    calls = _capture_tokenize_calls(pipeline)
 
     pipeline._format_and_tokenize_prompts(
         "A robot",
@@ -821,21 +1297,167 @@ def test_prompt_formatting_and_checkpoint_key_remap(make_cosmos3_pipeline) -> No
         height=720,
         width=1280,
         max_sequence_length=32,
+        sp=SimpleNamespace(
+            system_prompt="direct system prompt",
+            extra_args={
+                "use_duration_template": True,
+                "use_resolution_template": True,
+                "system_prompt": "API system prompt",
+            },
+        ),
+        use_system_prompt=True,
+        is_t2i=False,
+    )
+
+    assert calls == [
+        {
+            "text": ("A robot. The video is 2.0 seconds long and is of 24 FPS. This video is of 720x1280 resolution."),
+            "max_sequence_length": 32,
+            "use_system_prompt": True,
+            "system_prompt": "API system prompt",
+        },
+        {
+            "text": (
+                "bad. The video is not 2.0 seconds long and is not of 24 FPS. This video is not of 720x1280 resolution."
+            ),
+            "max_sequence_length": 32,
+            "use_system_prompt": True,
+            "system_prompt": "API system prompt",
+        },
+    ]
+
+
+def test_format_and_tokenize_prompts_uses_image_templates_for_t2i(make_cosmos3_pipeline) -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import COSMOS3_T2I_SYSTEM_PROMPT
+
+    pipeline = make_cosmos3_pipeline()
+    calls = _capture_tokenize_calls(pipeline)
+
+    pipeline._format_and_tokenize_prompts(
+        "A robot",
+        "bad",
+        num_frames=1,
+        frame_rate=24,
+        height=1024,
+        width=768,
+        max_sequence_length=64,
         sp=SimpleNamespace(
             extra_args={
-                "negative_metadata_mode": "inverse",
-                # Duration/resolution metadata templates are off by default
-                # (commit "Change resolution and duration templates to off by
-                # default"); enable them explicitly to exercise the formatting.
                 "use_duration_template": True,
                 "use_resolution_template": True,
             }
         ),
         use_system_prompt=True,
+        is_t2i=True,
+    )
+
+    assert [call["text"] for call in calls] == [
+        "A robot. This image is of 1024x768 resolution.",
+        "bad. This image is not of 1024x768 resolution.",
+    ]
+    assert all("seconds" not in call["text"] and "FPS" not in call["text"] for call in calls)
+    assert all(call["system_prompt"] == COSMOS3_T2I_SYSTEM_PROMPT for call in calls)
+
+
+def test_format_and_tokenize_prompts_rewrites_json_object_metadata(make_cosmos3_pipeline) -> None:
+    import json
+
+    pipeline = make_cosmos3_pipeline()
+    calls = _capture_tokenize_calls(pipeline)
+
+    pipeline._format_and_tokenize_prompts(
+        ('{"caption": "A robot", "duration": "old", "fps": 1, "resolution": {"H": 1, "W": 2}, "aspect_ratio": "1:1"}'),
+        "bad",
+        num_frames=48,
+        frame_rate=24,
+        height=720,
+        width=1280,
+        max_sequence_length=32,
+        sp=SimpleNamespace(
+            extra_args={
+                "aspect_ratio": "16:9",
+                "use_duration_template": True,
+                "use_resolution_template": True,
+            }
+        ),
         is_t2i=False,
     )
-    assert "The video is 2.0 seconds long" in captured[0]
-    assert "The video is not 2.0 seconds long" in captured[1]
+
+    assert json.loads(calls[0]["text"]) == {
+        "caption": "A robot",
+        "duration": "2s",
+        "fps": 24.0,
+        "resolution": {"H": 720, "W": 1280},
+        "aspect_ratio": "16:9",
+    }
+    assert "The video is 2.0 seconds long" not in calls[0]["text"]
+    assert calls[1]["text"] == (
+        "bad. The video is not 2.0 seconds long and is not of 24 FPS. This video is not of 720x1280 resolution."
+    )
+
+
+def test_format_and_tokenize_prompts_removes_video_metadata_from_t2i_json(make_cosmos3_pipeline) -> None:
+    import json
+
+    pipeline = make_cosmos3_pipeline()
+    calls = _capture_tokenize_calls(pipeline)
+
+    pipeline._format_and_tokenize_prompts(
+        '{"caption": "A robot", "duration": "2s", "fps": 24}',
+        "",
+        num_frames=1,
+        frame_rate=24,
+        height=1024,
+        width=768,
+        max_sequence_length=32,
+        sp=SimpleNamespace(extra_args={}),
+        is_t2i=True,
+    )
+
+    assert json.loads(calls[0]["text"]) == {
+        "caption": "A robot",
+        "resolution": {"H": 1024, "W": 768},
+    }
+
+
+@pytest.mark.parametrize(
+    "prompt",
+    [
+        "{malformed",
+        '["A robot"]',
+    ],
+)
+def test_format_and_tokenize_prompts_falls_back_for_non_object_json(
+    make_cosmos3_pipeline,
+    prompt: str,
+) -> None:
+    pipeline = make_cosmos3_pipeline()
+    calls = _capture_tokenize_calls(pipeline)
+
+    pipeline._format_and_tokenize_prompts(
+        prompt,
+        "",
+        num_frames=48,
+        frame_rate=24,
+        height=720,
+        width=1280,
+        max_sequence_length=32,
+        sp=SimpleNamespace(
+            extra_args={
+                "use_duration_template": True,
+                "use_resolution_template": True,
+            }
+        ),
+        is_t2i=False,
+    )
+
+    assert calls[0]["text"] == (
+        f"{prompt}. The video is 2.0 seconds long and is of 24 FPS. This video is of 720x1280 resolution."
+    )
+
+
+def test_checkpoint_key_remap() -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
 
     remaps = {
         "embed_tokens.weight": "transformer.language_model.embed_tokens.weight",
@@ -847,9 +1469,14 @@ def test_prompt_formatting_and_checkpoint_key_remap(make_cosmos3_pipeline) -> No
         "layers.3.self_attn.to_q.weight": "transformer.language_model.layers.3.self_attn.to_q.weight",
         "layers.3.self_attn.to_out.weight": "transformer.language_model.layers.3.self_attn.to_out.weight",
         "layers.3.self_attn.norm_q.weight": "transformer.language_model.layers.3.self_attn.norm_q.weight",
+        "layers.3.self_attn.k_norm_und_for_gen.weight": (
+            "transformer.language_model.layers.3.self_attn.k_norm_und_for_gen.weight"
+        ),
         "layers.3.self_attn.add_q_proj.weight": "transformer.gen_layers.3.cross_attention.to_q.weight",
         "layers.3.self_attn.to_add_out.weight": "transformer.gen_layers.3.cross_attention.to_out.weight",
         "layers.3.self_attn.norm_added_q.weight": "transformer.gen_layers.3.cross_attention.norm_q.weight",
+        "layers.3.mlp_moe_gen.up_proj.weight": "transformer.gen_layers.3.mlp.up_proj.weight",
+        "layers.3.mlp_moe_gen.down_proj.weight": "transformer.gen_layers.3.mlp.down_proj.weight",
         "transformer.model.layers.3.self_attn.add_k_proj.weight": (
             "transformer.gen_layers.3.cross_attention.to_k.weight"
         ),
@@ -1193,9 +1820,9 @@ def test_forward_transfer_uses_source_fps_except_wsm(make_cosmos3_pipeline, hint
     pipeline._prepare_transfer_latents = fake_prepare
     pipeline.diffuse_transfer = fake_diffuse_transfer
 
-    def fake_set_flow_shift(target, *, use_karras_sigmas=None):
+    def fake_set_flow_shift(target):
         captured.setdefault("flow_shifts", []).append(target)
-        captured.setdefault("scheduler_use_karras_sigmas", []).append(use_karras_sigmas)
+        pipeline._current_flow_shift = float(target)
 
     pipeline._set_flow_shift = fake_set_flow_shift
     pipeline._decode_latents = lambda latents: torch.zeros(1, 3, 5, 16, 16, device="meta")
@@ -1230,8 +1857,8 @@ def test_forward_transfer_uses_source_fps_except_wsm(make_cosmos3_pipeline, hint
     assert captured["format_frame_rate"] == expected_fps
     assert captured["shared_kwargs"]["fps"] == expected_fps
     assert captured["flow_shifts"] == [10.0]
-    # Transfer uses the V2V flow-sigma schedule (karras off) so flow_shift applies.
-    assert captured["scheduler_use_karras_sigmas"] == [False]
+    # Transfer applies the V2V flow shift when building its timestep schedule.
+    assert [call["shift"] for call in pipeline.scheduler.set_timesteps_calls] == [10.0]
     assert output.output["metadata"]["video"]["fps"] == expected_fps
     assert output.output["payload"]["video"].device.type == "meta"
 
@@ -1391,9 +2018,9 @@ class TestForwardRouting:
         pipeline._format_and_tokenize_prompts = fake_format
         pipeline._prepare_latents = fake_prepare
 
-        def fake_set_flow_shift(target, *, use_karras_sigmas=None):
+        def fake_set_flow_shift(target):
             captured.setdefault("flow_shifts", []).append(target)
-            captured.setdefault("scheduler_use_karras_sigmas", []).append(use_karras_sigmas)
+            pipeline._current_flow_shift = float(target)
 
         pipeline._set_flow_shift = fake_set_flow_shift
         pipeline.diffuse = fake_diffuse
@@ -1420,7 +2047,7 @@ class TestForwardRouting:
                 {
                     "key": "video",
                     "is_t2i": False,
-                    "flow": [1.0],
+                    "flow": [10.0],
                     "steps": [35],
                     "frames": 189,
                 },
@@ -1443,8 +2070,8 @@ class TestForwardRouting:
         assert captured["format"]["is_t2i"] is expected["is_t2i"]
         assert captured["format"]["num_frames"] == expected["frames"]
         assert captured["flow_shifts"] == expected["flow"]
-        assert captured["scheduler_use_karras_sigmas"] == [None]
-        assert [call[0] for call in pipeline.scheduler.set_timesteps_calls] == expected["steps"]
+        assert [call["num_inference_steps"] for call in pipeline.scheduler.set_timesteps_calls] == expected["steps"]
+        assert all(call["shift"] == expected["flow"][0] for call in pipeline.scheduler.set_timesteps_calls)
 
     def test_forward_i2v_sound_and_action_routes(self, make_cosmos3_pipeline) -> None:
         pipeline = make_cosmos3_pipeline()
@@ -1491,7 +2118,6 @@ class TestForwardRouting:
             )
         )
         assert captured["flow_shifts"][-1] == 10.0
-        assert captured["scheduler_use_karras_sigmas"][-1] is False
         assert captured["format"]["negative_prompt"] == ""
         assert captured["diffuse_calls"][-1]["shared_kwargs"]["noisy_frame_mask"] is v2v_mask
         assert captured["diffuse_calls"][-1]["condition_latents"] is v2v_condition
diff --git a/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py b/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py
index 13d1c399b..5dd8a875a 100644
--- a/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py
+++ b/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py
@@ -15,6 +15,25 @@ from vllm_omni.platforms import current_omni_platform
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
+@pytest.fixture(autouse=True)
+def _single_rank_tensor_parallel(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Provide the TP metadata required by vLLM parallel linear layers."""
+    from vllm.model_executor import parameter
+    from vllm.model_executor.layers import linear
+
+    from vllm_omni.diffusion.models.cosmos3 import (
+        transformer_cosmos3,
+        transformer_cosmos3_edge,
+    )
+
+    monkeypatch.setattr(linear, "get_tensor_model_parallel_rank", lambda: 0)
+    monkeypatch.setattr(linear, "get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(parameter, "get_tensor_model_parallel_rank", lambda: 0)
+    monkeypatch.setattr(parameter, "get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(transformer_cosmos3, "get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(transformer_cosmos3_edge, "get_tensor_model_parallel_world_size", lambda: 1)
+
+
 @pytest.fixture
 def accelerator_device() -> torch.device:
     """Provide an accelerator device, skipping when none is available."""
@@ -40,6 +59,22 @@ def _tiny_cosmos3_config(**overrides):
     return config
 
 
+def _tiny_cosmos3_edge_config(**overrides):
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        COSMOS3_EDGE_BACKBONE_TYPE,
+    )
+
+    config = _tiny_cosmos3_config(
+        latent_patch_size=2,
+        latent_channel=48,
+        temporal_compression_factor=4,
+        backbone_type=COSMOS3_EDGE_BACKBONE_TYPE,
+        qk_norm_for_text=False,
+    )
+    config.update(overrides)
+    return config
+
+
 def test_mrope_position_ids_cover_text_video_sound_and_action() -> None:
     from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import (
         compute_mrope_position_ids_action,
@@ -78,6 +113,16 @@ def test_mrope_position_ids_cover_text_video_sound_and_action() -> None:
     assert action_offset == 14
 
 
+def test_timestep_embedder_stores_frequencies_in_fp32() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import (
+        TimestepEmbedder,
+    )
+
+    embedder = TimestepEmbedder(hidden_size=8, frequency_embedding_size=16)
+
+    assert embedder.freqs.dtype == torch.float32
+
+
 @pytest.mark.parametrize(
     ("key", "value"),
     [
@@ -97,30 +142,245 @@ def test_validate_supported_config_rejects_unsupported_flags(key: str, value) ->
     Cosmos3VFMTransformer._validate_supported_config(None)
 
 
+def test_edge_config_resolves_nemotron_defaults() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    model = Cosmos3EdgeVFMTransformer(
+        SimpleNamespace(
+            tf_model_config=_tiny_cosmos3_edge_config(
+                layer_norm_epsilon=1e-5,
+                rope_scaling={},
+                rope_parameters={"mrope_section": [24, 20, 20]},
+            ),
+            dtype=torch.float32,
+        )
+    )
+
+    assert model.rms_norm_eps == 1e-5
+    assert model.rope_theta == 100_000_000
+    assert model.mrope_section == [24, 20, 20]
+    assert model.latent_channel_size == 48
+    assert model.latent_patch_size == 2
+    assert model.temporal_compression_factor == 4
+
+
+def test_edge_config_requires_backbone_type() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    config = _tiny_cosmos3_edge_config()
+    config.pop("backbone_type")
+
+    with pytest.raises(ValueError, match="must declare backbone_type"):
+        Cosmos3EdgeVFMTransformer(
+            SimpleNamespace(
+                tf_model_config=config,
+                dtype=torch.float32,
+            )
+        )
+
+
+def test_edge_und_and_gen_use_relu2_and_no_und_qk_norm() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+        Cosmos3Relu2MLP,
+    )
+
+    model = Cosmos3EdgeVFMTransformer(
+        SimpleNamespace(
+            tf_model_config=_tiny_cosmos3_edge_config(
+                num_hidden_layers=1,
+                use_und_k_norm_for_gen=False,
+            ),
+            dtype=torch.float32,
+        )
+    )
+
+    layer = model.language_model.layers[0]
+    gen_layer = model.gen_layers[0]
+    assert isinstance(layer.mlp, Cosmos3Relu2MLP)
+    assert not hasattr(layer.mlp, "gate_proj")
+    assert isinstance(gen_layer.mlp, Cosmos3Relu2MLP)
+    assert not hasattr(gen_layer.mlp, "gate_proj")
+    assert not hasattr(layer.self_attn, "norm_q")
+    assert not hasattr(layer.self_attn, "norm_k")
+    assert layer.self_attn.k_norm_und_for_gen is None
+
+
+def test_edge_creates_gen_k_norm_when_enabled() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import RMSNorm
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    model = Cosmos3EdgeVFMTransformer(
+        SimpleNamespace(
+            tf_model_config=_tiny_cosmos3_edge_config(
+                num_hidden_layers=1,
+                qk_norm_for_diffusion=True,
+                use_und_k_norm_for_gen=True,
+            ),
+            dtype=torch.float32,
+        )
+    )
+
+    k_norm = model.language_model.layers[0].self_attn.k_norm_und_for_gen
+    assert model.use_und_k_norm_for_gen is True
+    assert isinstance(k_norm, RMSNorm)
+    assert isinstance(model.gen_layers[0].cross_attention.norm_q, RMSNorm)
+    assert isinstance(model.gen_layers[0].cross_attention.norm_k, RMSNorm)
+
+
+def test_edge_supports_no_gen_qk_norm_variant() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    model = Cosmos3EdgeVFMTransformer(
+        SimpleNamespace(
+            tf_model_config=_tiny_cosmos3_edge_config(
+                num_hidden_layers=1,
+                qk_norm_for_diffusion=False,
+                use_und_k_norm_for_gen=False,
+            ),
+            dtype=torch.float32,
+        )
+    )
+
+    assert model.qk_norm_for_diffusion is False
+    assert model.language_model.layers[0].self_attn.k_norm_und_for_gen is None
+    assert model.gen_layers[0].cross_attention.qk_norm is False
+    assert not hasattr(model.gen_layers[0].cross_attention, "norm_q")
+    assert not hasattr(model.gen_layers[0].cross_attention, "norm_k")
+
+
+def test_edge_validates_required_relu2_weights() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeVFMTransformer,
+    )
+
+    model = object.__new__(Cosmos3EdgeVFMTransformer)
+    nn.Module.__init__(model)
+    model.num_hidden_layers = 1
+    model.qk_norm_for_diffusion = True
+    model.use_und_k_norm_for_gen = True
+
+    complete = {
+        "transformer.language_model.layers.0.mlp.up_proj.weight",
+        "transformer.language_model.layers.0.mlp.down_proj.weight",
+        "transformer.language_model.layers.0.self_attn.k_norm_und_for_gen.weight",
+        "transformer.gen_layers.0.mlp.up_proj.weight",
+        "transformer.gen_layers.0.mlp.down_proj.weight",
+    }
+    model.validate_loaded_weights(complete)
+
+    mlp_weights = complete - {
+        "transformer.language_model.layers.0.self_attn.k_norm_und_for_gen.weight",
+    }
+    for missing_weight in mlp_weights:
+        with pytest.raises(ValueError, match="missing required weights"):
+            model.validate_loaded_weights(complete - {missing_weight})
+
+    missing_k_norm = complete - {"transformer.language_model.layers.0.self_attn.k_norm_und_for_gen.weight"}
+    with pytest.raises(ValueError, match=r"self_attn\.k_norm_und_for_gen"):
+        model.validate_loaded_weights(missing_k_norm)
+
+    model.use_und_k_norm_for_gen = False
+    model.validate_loaded_weights(missing_k_norm)
+
+
+def test_edge_gen_cached_k_is_normalized_but_reasoner_uses_raw_k() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import RMSNorm
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeCausalAttention,
+    )
+
+    class ScaleProjection(nn.Module):
+        def __init__(self, scale: float) -> None:
+            super().__init__()
+            self.scale = scale
+
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            return x * self.scale
+
+    class IdentityOutput(nn.Module):
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            return x
+
+    class RawKAttention(nn.Module):
+        def forward(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+            del v
+            return q + k
+
+    attn = object.__new__(Cosmos3EdgeCausalAttention)
+    nn.Module.__init__(attn)
+    attn.hidden_size = 4
+    attn.num_heads = 2
+    attn.num_kv_heads = 2
+    attn.head_dim = 2
+    attn.num_heads_local = 2
+    attn.num_kv_heads_local = 2
+    attn.to_q = ScaleProjection(1.0)
+    attn.to_k = ScaleProjection(1.0)
+    attn.to_v = ScaleProjection(1.0)
+    attn.to_out = IdentityOutput()
+    attn.k_norm_und_for_gen = RMSNorm(2, eps=1e-5)
+    attn.attn = RawKAttention()
+
+    hidden_states = torch.tensor(
+        [[[1.0, 2.0, 3.0, 4.0], [2.0, 1.0, 4.0, 3.0]]],
+        dtype=torch.float32,
+    )
+    freqs_cos = torch.ones(1, 2, 1, 2)
+    freqs_sin = torch.zeros(1, 2, 1, 2)
+
+    reasoner_out, gen_k, gen_v = attn(hidden_states, freqs_cos, freqs_sin)
+    attn.to_k.scale = 3.0
+    scaled_reasoner_out, scaled_gen_k, scaled_gen_v = attn(hidden_states, freqs_cos, freqs_sin)
+
+    torch.testing.assert_close(gen_k, scaled_gen_k)
+    torch.testing.assert_close(gen_v, scaled_gen_v)
+    assert not torch.allclose(reasoner_out, scaled_reasoner_out)
+
+
 def test_transformer_sharding_offload_and_patch_round_trip_contracts() -> None:
     from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import Cosmos3LanguageModel, Cosmos3VFMTransformer
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3_edge import (
+        Cosmos3EdgeLanguageModel,
+        Cosmos3EdgeVFMTransformer,
+    )
 
-    model = object.__new__(Cosmos3VFMTransformer)
-    nn.Module.__init__(model)
-    model.language_model = nn.Module()
-    model.language_model.layers = nn.ModuleList([nn.Linear(2, 2) for _ in range(2)])
-    model.gen_layers = nn.ModuleList([nn.Linear(2, 2)])
-    model.norm_moe_gen = nn.LayerNorm(2)
+    for transformer_cls, language_model_cls in (
+        (Cosmos3VFMTransformer, Cosmos3LanguageModel),
+        (Cosmos3EdgeVFMTransformer, Cosmos3EdgeLanguageModel),
+    ):
+        model = object.__new__(transformer_cls)
+        nn.Module.__init__(model)
+        model.language_model = nn.Module()
+        model.language_model.layers = nn.ModuleList([nn.Linear(2, 2) for _ in range(2)])
+        model.gen_layers = nn.ModuleList([nn.Linear(2, 2)])
+        model.norm_moe_gen = nn.LayerNorm(2)
 
-    matched = [
-        name
-        for name, module in model.named_modules()
-        if any(condition(name, module) for condition in model._hsdp_shard_conditions)
-    ]
-    assert matched == ["language_model.layers.0", "language_model.layers.1", "gen_layers.0"]
-    assert Cosmos3VFMTransformer._layerwise_offload_blocks_attrs == ["gen_layers"]
-    assert Cosmos3LanguageModel._layerwise_offload_blocks_attrs == ["layers"]
-    assert Cosmos3VFMTransformer._repeated_blocks == ["Cosmos3GenDecoderLayer"]
+        matched = [
+            name
+            for name, module in model.named_modules()
+            if any(condition(name, module) for condition in model._hsdp_shard_conditions)
+        ]
+        assert matched == ["language_model.layers.0", "language_model.layers.1", "gen_layers.0"]
+        assert transformer_cls._layerwise_offload_blocks_attrs == ["gen_layers"]
+        assert language_model_cls._layerwise_offload_blocks_attrs == ["layers"]
+        assert transformer_cls._repeated_blocks == ["Cosmos3GenDecoderLayer"]
 
-    model.latent_patch_size = 2
-    model.latent_channel_size = 3
-    latents = torch.arange(1 * 3 * 1 * 3 * 5, dtype=torch.float32).reshape(1, 3, 1, 3, 5)
-    torch.testing.assert_close(model.unpatchify(model.patchify(latents, t=1, h=3, w=5), t=1, h=3, w=5), latents)
+        model.latent_patch_size = 2
+        model.latent_channel_size = 3
+        latents = torch.arange(1 * 3 * 1 * 3 * 5, dtype=torch.float32).reshape(1, 3, 1, 3, 5)
+        torch.testing.assert_close(
+            model.unpatchify(model.patchify(latents, t=1, h=3, w=5), t=1, h=3, w=5),
+            latents,
+        )
 
 
 def test_forward_returns_video_prediction(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -142,6 +402,17 @@ def test_forward_returns_video_prediction(monkeypatch: pytest.MonkeyPatch) -> No
     assert tuple(output.shape) == (1, 2, 1, 2, 2)
 
 
+def test_qwen_gen_mlp_remains_gated() -> None:
+    from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import Cosmos3GatedMLP, Cosmos3VFMTransformer
+
+    model = Cosmos3VFMTransformer(
+        SimpleNamespace(tf_model_config=_tiny_cosmos3_config(num_hidden_layers=1), dtype=torch.float32)
+    )
+
+    assert isinstance(model.gen_layers[0].mlp, Cosmos3GatedMLP)
+    assert hasattr(model.gen_layers[0].mlp, "gate_proj")
+
+
 def test_model_cpu_offload_swaps_back_to_generator(monkeypatch: pytest.MonkeyPatch) -> None:
     from vllm_omni.diffusion.models.cosmos3 import transformer_cosmos3
 
diff --git a/tests/diffusion/models/dmd2/test_dmd2_request_sanitization.py b/tests/diffusion/models/dmd2/test_dmd2_request_sanitization.py
index 21679b5b7..5fe027a20 100644
--- a/tests/diffusion/models/dmd2/test_dmd2_request_sanitization.py
+++ b/tests/diffusion/models/dmd2/test_dmd2_request_sanitization.py
@@ -6,12 +6,16 @@ import pytest
 import torch
 
 from vllm_omni.diffusion.models.flux.pipeline_flux import FluxDMD2Pipeline, FluxPipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline, LTX2T2VDMD2Pipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_image2video import LTX2I2VDMD2Pipeline, LTX2ImageToVideoPipeline
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import (
+    LTX2I2VDMD2Pipeline,
+    LTX2Pipeline,
+    LTX2T2VDMD2Pipeline,
+)
 from vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image import QwenImageDMD2Pipeline, QwenImagePipeline
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import Wan22Pipeline, WanT2VDMD2Pipeline
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_i2v import Wan22I2VPipeline, WanI2VDMD2Pipeline
 from vllm_omni.diffusion.request import OmniDiffusionRequest, OmniDiffusionSamplingParams
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -20,7 +24,7 @@ _DMD2_BASE = {
     WanT2VDMD2Pipeline: Wan22Pipeline,
     WanI2VDMD2Pipeline: Wan22I2VPipeline,
     LTX2T2VDMD2Pipeline: LTX2Pipeline,
-    LTX2I2VDMD2Pipeline: LTX2ImageToVideoPipeline,
+    LTX2I2VDMD2Pipeline: LTX2Pipeline,
     FluxDMD2Pipeline: FluxPipeline,
     QwenImageDMD2Pipeline: QwenImagePipeline,
 }
@@ -152,6 +156,28 @@ def test_string_prompt_not_mutated(pipeline):
     assert req.prompt == "a cat dancing"
 
 
+def test_request_batch_sanitizes_each_request(pipeline):
+    requests = [
+        _make_request(
+            prompt={"prompt": f"prompt-{index}", "negative_prompt": "blurry"},
+            num_inference_steps=40 + index,
+            guidance_scale=5.0 + index,
+            guidance_scale_provided=True,
+        )
+        for index in range(2)
+    ]
+
+    pipeline._sanitize_dmd2_request(DiffusionRequestBatch(requests))
+
+    for request in requests:
+        assert request.sampling_params.num_inference_steps == pipeline.dmd2_config.num_inference_steps
+        assert request.sampling_params.guidance_scale == pipeline.dmd2_config.guidance_scale
+        assert request.sampling_params.guidance_scale_provided is False
+        assert request.sampling_params.do_classifier_free_guidance is False
+        assert request.sampling_params.is_cfg_negative is False
+        assert "negative_prompt" not in request.prompt
+
+
 # ---------------------------------------------------------------------------
 # Clean request — nothing changes
 # ---------------------------------------------------------------------------
diff --git a/tests/diffusion/models/dmd2/test_dmd2_scheduler.py b/tests/diffusion/models/dmd2/test_dmd2_scheduler.py
index 0b6ca3a9e..4df65f1fe 100644
--- a/tests/diffusion/models/dmd2/test_dmd2_scheduler.py
+++ b/tests/diffusion/models/dmd2/test_dmd2_scheduler.py
@@ -6,8 +6,11 @@ import pytest
 import torch
 
 from vllm_omni.diffusion.models.flux.pipeline_flux import FluxDMD2Pipeline, FluxPipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline, LTX2T2VDMD2Pipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_image2video import LTX2I2VDMD2Pipeline, LTX2ImageToVideoPipeline
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import (
+    LTX2I2VDMD2Pipeline,
+    LTX2Pipeline,
+    LTX2T2VDMD2Pipeline,
+)
 from vllm_omni.diffusion.models.qwen_image.pipeline_qwen_image import QwenImageDMD2Pipeline, QwenImagePipeline
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import Wan22Pipeline, WanT2VDMD2Pipeline
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_i2v import Wan22I2VPipeline, WanI2VDMD2Pipeline
@@ -23,7 +26,7 @@ _DMD2_BASE = {
     WanT2VDMD2Pipeline: Wan22Pipeline,
     WanI2VDMD2Pipeline: Wan22I2VPipeline,
     LTX2T2VDMD2Pipeline: LTX2Pipeline,
-    LTX2I2VDMD2Pipeline: LTX2ImageToVideoPipeline,
+    LTX2I2VDMD2Pipeline: LTX2Pipeline,
     FluxDMD2Pipeline: FluxPipeline,
     QwenImageDMD2Pipeline: QwenImagePipeline,
 }
diff --git a/tests/unit/higgs_audio_v3/__init__.py b/tests/diffusion/models/dreamzero/__init__.py
similarity index 100%
rename from tests/unit/higgs_audio_v3/__init__.py
rename to tests/diffusion/models/dreamzero/__init__.py
diff --git a/tests/dreamzero/test_crossattn_cache.py b/tests/diffusion/models/dreamzero/test_crossattn_cache.py
similarity index 100%
rename from tests/dreamzero/test_crossattn_cache.py
rename to tests/diffusion/models/dreamzero/test_crossattn_cache.py
diff --git a/tests/diffusion/models/dreamzero/test_deploy_configs.py b/tests/diffusion/models/dreamzero/test_deploy_configs.py
new file mode 100644
index 000000000..8f9770add
--- /dev/null
+++ b/tests/diffusion/models/dreamzero/test_deploy_configs.py
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Every shipped DreamZero deploy config must select the AR-Diffusion engine.
+
+``DreamZeroPipeline.__init__`` rejects any other engine, so a config missing
+``engine_backend`` fails at worker startup rather than at request time. That
+only surfaces in slow multi-GPU e2e serving tests (see issue #5046), so assert
+it here on CPU instead.
+"""
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+import yaml
+
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
+from vllm_omni.experimental.ar_diffusion.engine import ARDiffusionEngine
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Discover siblings of a known config so a future dreamzero*.yaml is covered
+# without editing this test.
+DEPLOY_DIR = Path(get_deploy_config_path("dreamzero.yaml")).parent
+
+
+def _dreamzero_stages() -> list[tuple[str, int, dict]]:
+    stages = []
+    for name in sorted(path.name for path in DEPLOY_DIR.glob("dreamzero*.yaml")):
+        config = yaml.safe_load(Path(get_deploy_config_path(name)).read_text())
+        for index, stage in enumerate(config.get("stages") or []):
+            stages.append((name, index, stage))
+    return stages
+
+
+def test_dreamzero_deploy_configs_exist() -> None:
+    assert _dreamzero_stages(), f"no DreamZero deploy configs found under {DEPLOY_DIR}"
+
+
+@pytest.mark.parametrize(
+    ("config_name", "stage_index", "stage"),
+    _dreamzero_stages(),
+    ids=lambda value: value if isinstance(value, str) else None,
+)
+def test_dreamzero_stage_selects_ar_diffusion_engine(config_name: str, stage_index: int, stage: dict) -> None:
+    backend = stage.get("engine_backend")
+    assert backend, (
+        f"{config_name} stage {stage_index} does not set engine_backend; "
+        "DreamZeroPipeline requires the AR-Diffusion engine"
+    )
+    # Resolving also proves the import path is real, not just a lookalike string.
+    engine_class = DiffusionEngine.resolve_engine_class(SimpleNamespace(engine_backend=backend))
+    assert issubclass(engine_class, ARDiffusionEngine), (
+        f"{config_name} stage {stage_index} resolves to {engine_class.__name__}, not an AR-Diffusion engine"
+    )
diff --git a/tests/dreamzero/test_dreamzero_utils.py b/tests/diffusion/models/dreamzero/test_dreamzero_utils.py
similarity index 100%
rename from tests/dreamzero/test_dreamzero_utils.py
rename to tests/diffusion/models/dreamzero/test_dreamzero_utils.py
diff --git a/tests/dreamzero/test_fused_qk_rms_norm.py b/tests/diffusion/models/dreamzero/test_fused_qk_rms_norm.py
similarity index 100%
rename from tests/dreamzero/test_fused_qk_rms_norm.py
rename to tests/diffusion/models/dreamzero/test_fused_qk_rms_norm.py
diff --git a/tests/diffusion/models/dreamzero/test_pipeline_state.py b/tests/diffusion/models/dreamzero/test_pipeline_state.py
new file mode 100644
index 000000000..366876ef7
--- /dev/null
+++ b/tests/diffusion/models/dreamzero/test_pipeline_state.py
@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from collections import OrderedDict
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import DreamZeroPipeline
+from vllm_omni.diffusion.models.dreamzero.state_dreamzero import DreamZeroState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _empty_pipeline() -> DreamZeroPipeline:
+    pipeline = DreamZeroPipeline.__new__(DreamZeroPipeline)
+    pipeline._states = OrderedDict()
+    return pipeline
+
+
+def test_dreamzero_pipeline_state_is_session_keyed() -> None:
+    pipeline = _empty_pipeline()
+
+    session_a = pipeline._get_or_create_state("session-a")
+    session_b = pipeline._get_or_create_state("session-b")
+    session_a.call_count = 7
+    session_b.call_count = 3
+
+    assert pipeline._get_or_create_state("session-a") is session_a
+    assert pipeline._get_or_create_state("session-b") is session_b
+    assert session_a.call_count == 7
+    assert session_b.call_count == 3
+
+
+def test_dreamzero_pipeline_state_follows_runner_lifecycle_notifications() -> None:
+    pipeline = _empty_pipeline()
+
+    session_a = pipeline._get_or_create_state("session-a")
+    session_b = pipeline._get_or_create_state("session-b")
+    pipeline.state = session_b
+
+    pipeline.close_ar_diffusion_session("session-a")
+    assert pipeline.state is session_b
+    pipeline.reset_ar_diffusion_session("session-b")
+
+    assert not pipeline._states
+    assert pipeline.state is None
+    assert pipeline._get_or_create_state("session-a") is not session_a
+    assert pipeline._get_or_create_state("session-b") is not session_b
+
+
+def test_close_session_clears_active_state_alias() -> None:
+    pipeline = _empty_pipeline()
+    session_a = pipeline._get_or_create_state("session-a")
+    pipeline.state = session_a
+
+    pipeline.close_ar_diffusion_session("session-a")
+
+    assert not pipeline._states
+    assert pipeline.state is None
+
+
+def test_dreamzero_warmup_provider_builds_session_scoped_requests() -> None:
+    provider = SimpleNamespace(
+        ar_diffusion_kv_cache_spec=lambda: SimpleNamespace(window_frames=5, frames_per_block=4),
+        od_config=SimpleNamespace(
+            ar_diffusion_kv_config=None,
+            model_config={"policy_server_config": {"image_resolution": [8, 16]}},
+        ),
+        _ar_warmup_robot_obs=DreamZeroPipeline._ar_warmup_robot_obs,
+    )
+
+    requests = list(DreamZeroPipeline.ar_diffusion_warmup_requests(provider, "warmup-session"))
+
+    assert [request.prompt for request in requests] == ["warmup", "warmup"]
+    assert all(request.sampling_params.extra_args["session_id"] == "warmup-session" for request in requests)
+    assert requests[0].sampling_params.extra_args["robot_obs"]["observation/exterior_image_0_left"].shape == (
+        8,
+        16,
+        3,
+    )
+    assert requests[1].sampling_params.extra_args["robot_obs"]["observation/exterior_image_0_left"].shape == (
+        4,
+        8,
+        16,
+        3,
+    )
+
+
+def test_dreamzero_state_owns_no_kv_caches() -> None:
+    """KV (self- and cross-attention) is engine-owned since the AR-Diffusion
+    paged backend: the model-local cache accessors must be gone so nothing can
+    silently bypass the engine pool."""
+    state = DreamZeroState()
+
+    for removed in ("get_kv_caches", "create_kv_caches", "update_kv_cache", "get_crossattn_caches"):
+        assert not hasattr(state, removed)
diff --git a/tests/dreamzero/test_qkv_fusion.py b/tests/diffusion/models/dreamzero/test_qkv_fusion.py
similarity index 100%
rename from tests/dreamzero/test_qkv_fusion.py
rename to tests/diffusion/models/dreamzero/test_qkv_fusion.py
diff --git a/tests/diffusion/models/dreamzero/test_session_state_accounting.py b/tests/diffusion/models/dreamzero/test_session_state_accounting.py
new file mode 100644
index 000000000..443a02404
--- /dev/null
+++ b/tests/diffusion/models/dreamzero/test_session_state_accounting.py
@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Per-device byte accounting and the bounded VAE encoder ring (RFC #4480).
+
+Two things are pinned here. First, that a session reports the bytes it actually
+holds: both buckets walked, storages rather than logical element counts, and
+aliases counted once. Second, that bounding the adapter's VAE encoder history
+changes no numbers -- ``quant_conv`` is pointwise in time, so the frames the
+reader keeps do not depend on the ones the ring drops.
+
+All CPU, tiny tensors, no model.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.experimental.world_models.adapters.state_dreamzero_adapter import (
+    DreamZeroStateAdapter,
+)
+from vllm_omni.experimental.world_models.session_state import (
+    LatentBuffer,
+    SessionStateManager,
+    device_bytes,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _bytes(value: object) -> dict[str, int]:
+    return device_bytes(value, set())
+
+
+# -- device_bytes ------------------------------------------------------------
+
+
+def test_counts_tensor_storage_under_its_device() -> None:
+    tensor = torch.zeros(64, dtype=torch.float32)
+    assert _bytes(tensor) == {"cpu": 256}
+
+
+def test_views_on_one_storage_counted_once() -> None:
+    tensor = torch.zeros(64, dtype=torch.float32)
+    seen: set[tuple[str, int]] = set()
+    first = device_bytes(tensor, seen)
+    second = device_bytes(tensor[:8], seen)
+    assert first == {"cpu": 256}
+    assert second == {}
+
+
+def test_slice_reports_the_storage_it_pins() -> None:
+    # The whole point of counting storages: this slice keeps all 256 bytes
+    # alive, and ``numel() * element_size()`` would claim 32.
+    sliced = torch.zeros(64, dtype=torch.float32)[:8]
+    assert _bytes(sliced) == {"cpu": 256}
+
+
+def test_containers_recurse_and_scalars_contribute_nothing() -> None:
+    payload = {
+        "tensors": [torch.zeros(16, dtype=torch.float32), None],
+        "count": 7,
+        "flag": True,
+        "name": "not-a-buffer",
+    }
+    assert _bytes(payload) == {"cpu": 64}
+
+
+def test_numpy_arrays_land_on_the_host() -> None:
+    assert _bytes(np.zeros(32, dtype=np.float32)) == {"cpu": 128}
+
+
+# -- SessionState / manager --------------------------------------------------
+
+
+def test_session_counts_both_buckets_and_dedupes_across_them() -> None:
+    manager = SessionStateManager()
+    session = manager.get_or_create_session("s")
+
+    buffer: LatentBuffer[torch.Tensor] = LatentBuffer()
+    buffer.allocate(maxlen=None)
+    shared = torch.zeros(64, dtype=torch.float32)  # 256 bytes
+    buffer.append(shared)
+    session.put("latents", buffer)
+    session.attrs["conditioning"] = torch.zeros(16, dtype=torch.float32)  # 64 bytes
+
+    assert session.nbytes_by_device() == {"cpu": 320}
+
+    # The same storage reachable from both buckets is one allocation, not two.
+    session.attrs["alias"] = shared
+    assert session.nbytes_by_device() == {"cpu": 320}
+
+
+def test_stats_reports_per_device_totals() -> None:
+    manager = SessionStateManager()
+    manager.get_or_create_session("s").attrs["x"] = torch.zeros(64, dtype=torch.float32)
+
+    stats = manager.stats()
+    assert stats["nbytes:cpu"] == 256
+    assert stats["total_nbytes"] == 256
+
+
+def test_attribute_bytes_were_previously_invisible() -> None:
+    """The defect behind tzhouam's review comment on PR #4487.
+
+    Every byte here lives in ``attrs``, and the old ``nbytes`` walked only the
+    typed objects -- so a session holding real memory reported zero.
+    """
+    manager = SessionStateManager()
+    session = manager.get_or_create_session("s")
+    session.attrs["conv_cache"] = [torch.zeros(1024, dtype=torch.float32)]
+
+    assert session.nbytes_by_device() == {"cpu": 4096}
+
+
+# -- the largest value DreamZero holds ---------------------------------------
+
+
+def test_feat_map_bytes_are_counted() -> None:
+    """``vae_enc_feat_map`` is the largest thing a DreamZero session holds --
+    603 MiB at the shipped config -- and it stays an attribute, so this is
+    exactly the memory the old accounting missed."""
+    manager = SessionStateManager()
+    adapter = DreamZeroStateAdapter("s", manager)
+    adapter.vae_enc_feat_map = [torch.zeros(1024, dtype=torch.float32), None]
+
+    assert manager.stats()["nbytes:cpu"] == 4096
+
+    # Freeing it piecemeal is not something the manager can do: the cache has no
+    # recompute source and the stream breaks without it. Ending the stream (or
+    # the session) is the only release, and that reclaims attributes too.
+    adapter.reset_vae_encoder_stream()
+    assert manager.stats().get("nbytes:cpu", 0) == 0
+
+
+# -- bounded VAE encoder ring ------------------------------------------------
+
+
+def _quantize(encoder_out: torch.Tensor) -> torch.Tensor:
+    """Stand-in for ``_vae_quantize_encoder_out``.
+
+    The real one is ``WanCausalConv3d(z_dim*2, z_dim*2, 1)`` followed by a
+    per-channel affine rescale. Every operation is pointwise in time, which is
+    the property the ring relies on; a 1x1x1 convolution reproduces it.
+    """
+    weight = torch.arange(1, encoder_out.shape[1] + 1, dtype=encoder_out.dtype).view(1, -1, 1, 1, 1)
+    return encoder_out * weight + 0.5
+
+
+def test_ring_is_bounded() -> None:
+    adapter = DreamZeroStateAdapter("s", SessionStateManager(), vae_encoder_window=2)
+    adapter.vae_encoder_out = torch.randn(1, 4, 1, 2, 2)
+    for _ in range(10):
+        adapter.append_vae_encoder_chunk(torch.randn(1, 4, 1, 2, 2))
+
+    assert adapter.vae_encoder_out is not None
+    assert adapter.vae_encoder_out.shape[2] == 2
+
+
+def test_ring_matches_unbounded_history_for_the_frames_that_are_read() -> None:
+    window = 2
+    adapter = DreamZeroStateAdapter("s", SessionStateManager(), vae_encoder_window=window)
+    seed = torch.randn(1, 4, 1, 2, 2)
+    chunks = [torch.randn(1, 4, 1, 2, 2) for _ in range(9)]
+
+    adapter.vae_encoder_out = seed
+    unbounded = seed
+    for chunk in chunks:
+        adapter.append_vae_encoder_chunk(chunk)
+        unbounded = torch.cat([unbounded, chunk], dim=2)
+
+    # What the reader actually returns: quantise, then keep the last `window`.
+    from_ring = _quantize(adapter.vae_encoder_out)[:, :, -window:]
+    from_history = _quantize(unbounded)[:, :, -window:]
+    torch.testing.assert_close(from_ring, from_history, rtol=0, atol=0)
+
+
+def test_ring_holds_a_single_frame_before_the_first_body_chunk() -> None:
+    # After `_vae_stream_seed` there is exactly one latent frame, which is what
+    # sends the reader down its padding branch.
+    adapter = DreamZeroStateAdapter("s", SessionStateManager(), vae_encoder_window=2)
+    seed = torch.randn(1, 4, 1, 2, 2)
+    adapter.vae_encoder_out = seed
+
+    assert adapter.vae_encoder_out is not None
+    assert adapter.vae_encoder_out.shape[2] == 1
+    torch.testing.assert_close(adapter.vae_encoder_out, seed, rtol=0, atol=0)
+
+
+def test_resetting_the_stream_clears_the_ring() -> None:
+    adapter = DreamZeroStateAdapter("s", SessionStateManager(), vae_encoder_window=2)
+    adapter.vae_encoder_out = torch.randn(1, 4, 1, 2, 2)
+    adapter.reset_vae_encoder_stream()
+
+    assert adapter.vae_encoder_out is None
+
+
+def test_window_must_be_positive() -> None:
+    with pytest.raises(ValueError, match="vae_encoder_window"):
+        DreamZeroStateAdapter("s", SessionStateManager(), vae_encoder_window=0)
diff --git a/tests/diffusion/models/dreamzero/test_session_state_equivalence.py b/tests/diffusion/models/dreamzero/test_session_state_equivalence.py
new file mode 100644
index 000000000..a346a4039
--- /dev/null
+++ b/tests/diffusion/models/dreamzero/test_session_state_equivalence.py
@@ -0,0 +1,257 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Bit-equivalence tests: DreamZeroStateAdapter vs bespoke DreamZeroState.
+
+These drive both state objects directly with tiny CPU tensors -- no model, no
+GPU -- and assert the adapter (backed by the SessionStateManager) stores and
+returns exactly what the bespoke DreamZeroState does. This gates routing
+DreamZero through the shared session state manager (RFC #4480).
+
+DreamZero's attention KV is engine-owned (AR-Diffusion paged pool, PR #4534)
+and out of the adapter's scope; the state surface tested here is the model's
+non-KV session state.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.dreamzero.state_dreamzero import (
+    FRAMES_PER_CHUNK,
+    DreamZeroState,
+)
+from vllm_omni.experimental.world_models.adapters.state_dreamzero_adapter import DreamZeroStateAdapter
+from vllm_omni.experimental.world_models.session_state import SessionStateManager
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _create_both() -> tuple[DreamZeroState, DreamZeroStateAdapter]:
+    return DreamZeroState(), DreamZeroStateAdapter("session-0", SessionStateManager())
+
+
+def test_accumulate_frames_and_call_count_match() -> None:
+    bespoke, adapter = _create_both()
+    rng = np.random.default_rng(0)
+    for _ in range(2 * FRAMES_PER_CHUNK + 1):
+        frame = rng.integers(0, 255, size=(5, 6, 3), dtype=np.uint8)
+        b_out = bespoke.accumulate_frames(frame)
+        a_out = adapter.accumulate_frames(frame)
+        np.testing.assert_array_equal(b_out, a_out)
+        assert bespoke.call_count == adapter.call_count
+        assert len(bespoke.stitched_buffer) == len(adapter.stitched_buffer)
+    # Deque rollover capped at FRAMES_PER_CHUNK.
+    assert len(adapter.stitched_buffer) == FRAMES_PER_CHUNK
+
+
+def test_accumulate_frames_4d_extend_matches() -> None:
+    bespoke, adapter = _create_both()
+    clip = np.random.default_rng(1).integers(0, 255, size=(3, 5, 6, 3), dtype=np.uint8)
+    np.testing.assert_array_equal(bespoke.accumulate_frames(clip), adapter.accumulate_frames(clip))
+    assert len(bespoke.stitched_buffer) == len(adapter.stitched_buffer)
+
+
+def test_video_latents_roundtrip_matches() -> None:
+    bespoke, adapter = _create_both()
+    assert bespoke.get_concatenated_video_latents() is None
+    assert adapter.get_concatenated_video_latents() is None
+
+    rng = torch.Generator().manual_seed(0)
+    for _ in range(3):
+        # (B, T, C, H, W) as returned by the denoise loop.
+        chunk = torch.randn(1, 2, 3, 4, 4, generator=rng)
+        bespoke.append_video_latents(chunk)
+        adapter.append_video_latents(chunk)
+        torch.testing.assert_close(
+            bespoke.get_concatenated_video_latents(),
+            adapter.get_concatenated_video_latents(),
+        )
+
+    bespoke.clear_video_latents()
+    adapter.clear_video_latents()
+    assert bespoke.get_concatenated_video_latents() is None
+    assert adapter.get_concatenated_video_latents() is None
+
+
+def test_vae_stream_fields_match_bespoke() -> None:
+    bespoke, adapter = _create_both()
+    for state in (bespoke, adapter):
+        assert state.vae_stream_initialized is False
+        assert state.vae_enc_feat_map is None
+        assert state.vae_encoder_out is None
+        assert state.vae_pending_body_frames is None
+
+    feat_map: list[torch.Tensor | None] = [torch.ones(1, 2), None]
+    encoder_out = torch.randn(1, 4, 2, 3, 3)
+    pending = torch.randn(1, 3, 2, 8, 8)
+    for state in (bespoke, adapter):
+        state.vae_enc_feat_map = feat_map
+        state.vae_encoder_out = encoder_out
+        state.vae_pending_body_frames = pending
+        state.vae_stream_initialized = True
+
+    assert adapter.vae_stream_initialized is bespoke.vae_stream_initialized is True
+    torch.testing.assert_close(adapter.vae_encoder_out, bespoke.vae_encoder_out)
+    torch.testing.assert_close(adapter.vae_pending_body_frames, bespoke.vae_pending_body_frames)
+    assert adapter.vae_enc_feat_map is feat_map
+
+    for state in (bespoke, adapter):
+        state.reset_vae_encoder_stream()
+        assert state.vae_stream_initialized is False
+        assert state.vae_enc_feat_map is None
+        assert state.vae_encoder_out is None
+        assert state.vae_pending_body_frames is None
+
+
+def test_reset_clears_state_and_should_reset_matches() -> None:
+    bespoke, adapter = _create_both()
+    tokens = torch.tensor([1, 2, 3])
+    # language unset -> both want reset.
+    assert bespoke.should_reset(tokens, 4, -1) is adapter.should_reset(tokens, 4, -1) is True
+
+    for state in (bespoke, adapter):
+        state.language = tokens
+        state.current_start_frame = 2
+    # same language -> no reset; both agree.
+    assert bespoke.should_reset(tokens, 4, -1) == adapter.should_reset(tokens, 4, -1) is False
+    # language change -> reset.
+    other = torch.tensor([9, 9])
+    assert bespoke.should_reset(other, 4, -1) == adapter.should_reset(other, 4, -1) is True
+    # local_attn_size exceeded -> reset ("inference", not "session").
+    assert bespoke.reset_reason(tokens, 4, 1) == adapter.reset_reason(tokens, 4, 1) == "inference"
+
+    # A session reset clears everything, including the prompt-embed cache and
+    # the VAE encoder stream (mirrors DreamZeroState.reset()).
+    for state in (bespoke, adapter):
+        state.prompt_embeds = torch.ones(1, 2)
+        state.vae_encoder_out = torch.ones(1, 4, 1, 2, 2)
+        state.vae_stream_initialized = True
+        state.reset()
+        assert state.language is None
+        assert state.prompt_embeds is None
+        assert state.current_start_frame == 0
+        assert state.call_count == 0
+        assert state.vae_stream_initialized is False
+        assert state.vae_encoder_out is None
+
+
+def test_window_reset_preserves_latents_prompt_and_vae_stream() -> None:
+    # reset(clear_video_latents=False) is the window ("inference") reset: the
+    # prompt is unchanged and the VAE feat_cache history is independent of the
+    # DiT attention window, so both survive alongside the video latents.
+    bespoke, adapter = _create_both()
+    tokens = torch.tensor([1, 2, 3])
+    embeds = torch.randn(1, 4)
+    encoder_out = torch.randn(1, 4, 2, 3, 3)
+    chunk = torch.randn(1, 2, 3, 4, 4)
+    for state in (bespoke, adapter):
+        state.language = tokens
+        state.prompt_embeds = embeds
+        state.vae_encoder_out = encoder_out
+        state.vae_stream_initialized = True
+        state.current_start_frame = 7
+        state.append_video_latents(chunk)
+
+        state.reset_inference_state()
+
+        assert state.current_start_frame == 0
+        assert state.call_count == 0
+        assert state.clip_feas is None
+        torch.testing.assert_close(state.language, tokens)
+        torch.testing.assert_close(state.prompt_embeds, embeds)
+        assert state.vae_stream_initialized is True
+        torch.testing.assert_close(state.vae_encoder_out, encoder_out)
+        assert state.get_concatenated_video_latents() is not None
+
+    torch.testing.assert_close(
+        bespoke.get_concatenated_video_latents(),
+        adapter.get_concatenated_video_latents(),
+    )
+
+
+def test_metadata_fields_persist_across_adapter_instances() -> None:
+    # A fresh adapter for the same session must see prior metadata (the manager
+    # is the single source of truth).
+    manager = SessionStateManager()
+    first = DreamZeroStateAdapter("s", manager)
+    first.current_start_frame = 5
+    first.clip_feas = torch.ones(2, 2)
+    first.append_video_latents(torch.ones(1, 2, 3, 4, 4))
+
+    second = DreamZeroStateAdapter("s", manager)
+    assert second.current_start_frame == 5
+    torch.testing.assert_close(second.clip_feas, torch.ones(2, 2))
+    # Video latents appended via `first` are visible via `second`.
+    assert second.get_concatenated_video_latents() is not None
+
+
+def test_session_lru_caps_retained_sessions() -> None:
+    manager = SessionStateManager(max_sessions=3)
+    for i in range(5):
+        DreamZeroStateAdapter(f"s{i}", manager)
+    assert len(manager) == 3
+    # Oldest two evicted; newest three retained.
+    assert "s0" not in manager
+    assert "s1" not in manager
+    for i in (2, 3, 4):
+        assert f"s{i}" in manager
+
+
+def test_adapter_keeps_state_when_its_session_is_evicted() -> None:
+    # Regression: an adapter mid-generation must not lose its data when the
+    # manager evicts its session to make room for newer ones. The adapter pins
+    # the session, so its stored latents survive eviction from the lookup table.
+    manager = SessionStateManager(max_sessions=2)
+    adapter = DreamZeroStateAdapter("active", manager)
+    chunk = torch.randn(1, 2, 3, 4, 4)
+    adapter.append_video_latents(chunk)
+    adapter.language = torch.tensor([1, 2, 3])
+
+    # Push "active" out of the manager's table with newer sessions.
+    for i in range(3):
+        DreamZeroStateAdapter(f"other{i}", manager)
+    assert "active" not in manager
+
+    # The in-use adapter still returns its own data.
+    assert adapter.get_concatenated_video_latents() is not None
+    torch.testing.assert_close(adapter.language, torch.tensor([1, 2, 3]))
+
+
+def test_session_reset_clears_metadata() -> None:
+    # Regression: resetting a session must not leave stale metadata behind, so a
+    # fresh adapter for the same session sees defaults, not the old values.
+    manager = SessionStateManager()
+    adapter = DreamZeroStateAdapter("s", manager)
+    adapter.language = torch.tensor([1, 2, 3])
+    adapter.current_start_frame = 5
+    adapter.clip_feas = torch.ones(2, 2)
+    adapter.prompt_embeds = torch.ones(1, 2)
+
+    adapter.reset()
+
+    fresh = DreamZeroStateAdapter("s", manager)
+    assert fresh.language is None
+    assert fresh.current_start_frame == 0
+    assert fresh.clip_feas is None
+    assert fresh.prompt_embeds is None
+
+
+def test_bespoke_path_without_memory_manager() -> None:
+    # Regression: a pipeline built via __new__ (lightweight fixtures) seeds only
+    # the bespoke fields and never sets _memory_manager; _get_or_create_state
+    # must fall through to the bespoke DreamZeroState path without AttributeError.
+    from collections import OrderedDict
+
+    from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import (
+        MAX_DREAMZERO_SESSIONS,
+        DreamZeroPipeline,
+    )
+
+    pipe = DreamZeroPipeline.__new__(DreamZeroPipeline)
+    pipe._states = OrderedDict()
+    pipe._max_session_states = MAX_DREAMZERO_SESSIONS
+
+    state = DreamZeroPipeline._get_or_create_state(pipe, "x")
+    assert isinstance(state, DreamZeroState)
diff --git a/tests/diffusion/models/dreamzero/test_session_state_lifecycle.py b/tests/diffusion/models/dreamzero/test_session_state_lifecycle.py
new file mode 100644
index 000000000..a67578cc7
--- /dev/null
+++ b/tests/diffusion/models/dreamzero/test_session_state_lifecycle.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Session end-of-life routing (RFC #4480, adapting to #5271).
+
+The AR-Diffusion runner raises an explicit end-of-session signal on reset,
+close, eviction, and failed forwards (``reset_ar_diffusion_session`` /
+``close_ar_diffusion_session``). On the bespoke path those pop ``_states``; on
+the opt-in manager path the session lives in the manager instead, so the hooks
+must release it there or every closed session leaks its buffers.
+
+All CPU, tiny tensors, no model.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import DreamZeroPipeline
+from vllm_omni.diffusion.models.dreamzero.state_dreamzero import DreamZeroState
+from vllm_omni.experimental.world_models.adapters.state_dreamzero_adapter import (
+    DreamZeroStateAdapter,
+)
+from vllm_omni.experimental.world_models.session_state import (
+    LatentBuffer,
+    SessionStateManager,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+# -- SessionStateManager.drop_session ---------------------------------------
+
+
+def test_drop_session_absent_returns_false() -> None:
+    manager = SessionStateManager()
+    assert manager.drop_session("missing") is False
+
+
+def test_drop_session_removes_and_frees() -> None:
+    manager = SessionStateManager()
+    session = manager.get_or_create_session("s")
+    buffer: LatentBuffer[torch.Tensor] = LatentBuffer()
+    buffer.allocate(maxlen=None)
+    buffer.append(torch.zeros(256, dtype=torch.float32))
+    session.put("payload", buffer)
+    assert manager.nbytes_by_device().get("cpu", 0) >= 1024
+
+    assert manager.drop_session("s") is True
+    assert "s" not in manager
+    assert len(manager) == 0
+    # The session is gone from the table and its buffers were reset, so the
+    # manager reports no held bytes.
+    assert manager.nbytes_by_device() == {}
+
+
+def test_drop_session_recreates_fresh() -> None:
+    manager = SessionStateManager()
+    manager.get_or_create_session("s").attrs["k"] = 1
+    manager.drop_session("s")
+    assert manager.get_or_create_session("s").attrs == {}
+
+
+# -- pipeline hook routing ---------------------------------------------------
+
+
+def _manager_pipe(manager: SessionStateManager, session_id: str) -> DreamZeroPipeline:
+    """A pipeline built via __new__ whose state is a manager-backed adapter."""
+    pipe = DreamZeroPipeline.__new__(DreamZeroPipeline)
+    pipe._states = OrderedDict()
+    pipe._memory_manager = manager
+    pipe.state = DreamZeroStateAdapter(session_id, manager, vae_encoder_window=2)
+    return pipe
+
+
+@pytest.mark.parametrize("hook", ["close_ar_diffusion_session", "reset_ar_diffusion_session"])
+def test_hook_releases_manager_session_and_clears_alias(hook: str) -> None:
+    manager = SessionStateManager()
+    pipe = _manager_pipe(manager, "sess")
+    assert "sess" in manager
+
+    getattr(DreamZeroPipeline, hook)(pipe, "sess")
+
+    assert "sess" not in manager
+    # The alias viewed the released session, so it is dropped and rebuilt lazily.
+    assert pipe.state is None
+
+
+def test_hook_keeps_alias_for_a_different_session() -> None:
+    manager = SessionStateManager()
+    pipe = _manager_pipe(manager, "default")
+    manager.get_or_create_session("other")
+
+    DreamZeroPipeline.close_ar_diffusion_session(pipe, "other")
+
+    assert "other" not in manager
+    # The alias views "default", not the closed session, so it survives.
+    assert isinstance(pipe.state, DreamZeroStateAdapter)
+    assert pipe.state.session_id == "default"
+
+
+def test_bespoke_hook_pops_states_and_clears_alias() -> None:
+    pipe = DreamZeroPipeline.__new__(DreamZeroPipeline)
+    pipe._states = OrderedDict()
+    pipe._memory_manager = None
+    state = DreamZeroState()
+    pipe._states["sess"] = state
+    pipe.state = state
+
+    DreamZeroPipeline.close_ar_diffusion_session(pipe, "sess")
+
+    assert "sess" not in pipe._states
+    assert pipe.state is None
diff --git a/tests/diffusion/models/flux2/test_flux2_transformer_tp.py b/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
index c613bb0b4..c935871a0 100644
--- a/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
+++ b/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
@@ -253,3 +253,28 @@ class TestFlux2PackedModuleMapping:
         assert len(loaded_params) == 2, "Should load two weights"
         assert "x_embedder.weight" in loaded_params
         assert any("to_qkv" in p for p in loaded_params), "to_q should be mapped to to_qkv"
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+class TestFlux2TransformerLayerwiseOffload:
+    def test_layerwise_offload_blocks_attrs(self):
+        assert Flux2Transformer2DModel._layerwise_offload_blocks_attrs == [
+            "transformer_blocks",
+            "single_transformer_blocks",
+        ]
+
+    def test_get_blocks_from_dit(self):
+        from vllm_omni.diffusion.offloader.layerwise_backend import LayerWiseOffloadBackend
+
+        # Block discovery only needs the ModuleList structure, not production dims.
+        model = Flux2Transformer2DModel(
+            num_layers=2,
+            num_single_layers=2,
+            num_attention_heads=2,
+            attention_head_dim=4,
+            joint_attention_dim=16,
+        )
+        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        assert attr_names == ["transformer_blocks", "single_transformer_blocks"]
+        assert len(blocks) == 4
diff --git a/tests/diffusion/models/flux2/test_pipeline_flux2_quantization.py b/tests/diffusion/models/flux2/test_pipeline_flux2_quantization.py
new file mode 100644
index 000000000..3900c0c94
--- /dev/null
+++ b/tests/diffusion/models/flux2/test_pipeline_flux2_quantization.py
@@ -0,0 +1,50 @@
+from unittest.mock import Mock, patch
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.flux2.pipeline_flux2 import (
+    Flux2Pipeline,
+    _resolve_component_quant_config,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_resolve_component_quant_config_routes_components():
+    text_encoder_config = object()
+    component_config = Mock()
+    component_config.resolve.side_effect = {
+        "text_encoder": text_encoder_config,
+        "transformer": None,
+    }.get
+
+    assert _resolve_component_quant_config(component_config, "text_encoder") is text_encoder_config
+    assert _resolve_component_quant_config(component_config, "transformer") is None
+
+
+def test_resolve_component_quant_config_preserves_global_config():
+    global_config = object()
+    assert _resolve_component_quant_config(global_config, "transformer") is global_config
+    assert _resolve_component_quant_config(None, "text_encoder") is None
+
+
+def test_offload_transformer_before_text_encoder_weights():
+    pipeline = object.__new__(Flux2Pipeline)
+    pipeline.transformer = Mock()
+    weights = [
+        ("transformer.layer.weight", torch.empty(1)),
+        ("text_encoder.layer.weight", torch.empty(1)),
+        ("text_encoder.layer.bias", torch.empty(1)),
+    ]
+
+    iterator = iter(pipeline._offload_transformer_before_text_encoder(weights))
+    assert next(iterator)[0] == "transformer.layer.weight"
+    pipeline.transformer.to.assert_not_called()
+
+    with patch("vllm_omni.diffusion.models.flux2.pipeline_flux2.current_omni_platform.empty_cache") as empty_cache:
+        assert next(iterator)[0] == "text_encoder.layer.weight"
+        assert next(iterator)[0] == "text_encoder.layer.bias"
+
+    pipeline.transformer.to.assert_called_once_with("cpu")
+    empty_cache.assert_called_once_with()
diff --git a/tests/diffusion/models/hunyuan_image3/test_hunyuan_fused_moe.py b/tests/diffusion/models/hunyuan_image3/test_hunyuan_fused_moe.py
deleted file mode 100644
index e8ade2e51..000000000
--- a/tests/diffusion/models/hunyuan_image3/test_hunyuan_fused_moe.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Unit tests for HunyuanFusedMoE (Support HunyuanImage3 Diffusion Model, 5a779b4)."""
-
-import pytest
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class TestSetForwardContextNumTokens:
-    """Test _set_forward_context_num_tokens defensive fix for vLLM 0.18.0."""
-
-    def test_sets_num_tokens_when_context_available(self, mocker):
-        """num_tokens should be set on ForwardContext when available."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        mock_ctx = mocker.MagicMock()
-        del mock_ctx.in_profile_run  # simulate missing attr
-        mocker.patch.object(hunyuan_moe._vllm_fc, "is_forward_context_available", return_value=True)
-        mocker.patch.object(hunyuan_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
-
-        hunyuan_moe._set_forward_context_num_tokens(1024)
-
-        assert mock_ctx.num_tokens == 1024
-        assert mock_ctx.in_profile_run is False
-
-    def test_sets_in_profile_run_only_if_missing(self, mocker):
-        """in_profile_run should not be overwritten if already set."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        mock_ctx = mocker.MagicMock()
-        mock_ctx.in_profile_run = True  # already set
-        mocker.patch.object(hunyuan_moe._vllm_fc, "is_forward_context_available", return_value=True)
-        mocker.patch.object(hunyuan_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
-
-        hunyuan_moe._set_forward_context_num_tokens(512)
-
-        assert mock_ctx.num_tokens == 512
-        assert mock_ctx.in_profile_run is True  # not overwritten
-
-    def test_noop_when_context_unavailable(self, mocker):
-        """Should do nothing when ForwardContext is not available."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        mocker.patch.object(hunyuan_moe._vllm_fc, "is_forward_context_available", return_value=False)
-        mock_get = mocker.patch.object(hunyuan_moe._vllm_fc, "get_forward_context")
-
-        hunyuan_moe._set_forward_context_num_tokens(256)
-
-        mock_get.assert_not_called()
-
-
-class TestSetForwardContextDPMetadata:
-    """Test diffusion MoE DP metadata setup for vLLM 0.24 all2all dispatch."""
-
-    def test_sets_dp_metadata_from_vllm_dp_group(self, mocker):
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        mock_ctx = mocker.MagicMock()
-        mock_ctx.dp_metadata = None
-        fake_group = mocker.MagicMock()
-        fake_group.world_size = 2
-        fake_group.cpu_group = object()
-
-        def _all_gather_object(output, obj, group):
-            assert group is fake_group.cpu_group
-            output[:] = [obj, obj + 1]
-
-        mocker.patch.object(hunyuan_moe._vllm_fc, "is_forward_context_available", return_value=True)
-        mocker.patch.object(hunyuan_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
-        mocker.patch.object(hunyuan_moe._vllm_ps, "_DP", fake_group, create=True)
-        mocker.patch.object(hunyuan_moe.torch.distributed, "all_gather_object", side_effect=_all_gather_object)
-
-        hunyuan_moe._set_forward_context_dp_metadata(1024)
-
-        assert mock_ctx.dp_metadata is not None
-        assert mock_ctx.dp_metadata.num_tokens_across_dp_cpu.tolist() == [1024, 1025]
-
-    def test_keeps_existing_dp_metadata(self, mocker):
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        existing_metadata = object()
-        mock_ctx = mocker.MagicMock()
-        mock_ctx.dp_metadata = existing_metadata
-        mocker.patch.object(hunyuan_moe._vllm_fc, "is_forward_context_available", return_value=True)
-        mocker.patch.object(hunyuan_moe._vllm_fc, "get_forward_context", return_value=mock_ctx)
-        mock_all_gather = mocker.patch.object(hunyuan_moe.torch.distributed, "all_gather_object")
-
-        hunyuan_moe._set_forward_context_dp_metadata(1024)
-
-        assert mock_ctx.dp_metadata is existing_metadata
-        mock_all_gather.assert_not_called()
-
-
-class TestHunyuanFusedMoEPlatformDispatch:
-    """Test platform dispatch via platform qualname hooks."""
-
-    def test_default_platform_uses_default_impl_qualname(self, mocker):
-        """HunyuanFusedMoE should resolve the impl class from the platform hook."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        mock_platform = mocker.MagicMock()
-        mock_platform.get_diffusion_model_impl_qualname.return_value = (
-            "vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe.HunyuanFusedMoEDefault"
-        )
-
-        mocker.patch.object(
-            hunyuan_moe,
-            "current_omni_platform",
-            mock_platform,
-        )
-        mock_resolve = mocker.patch.object(hunyuan_moe, "resolve_obj_by_qualname")
-        mock_impl = mocker.MagicMock()
-        mock_resolve.return_value = mock_impl
-
-        from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe import (
-            HunyuanFusedMoE,
-        )
-
-        HunyuanFusedMoE(prefix="")
-
-        mock_platform.prepare_diffusion_op_runtime.assert_called_once_with("hunyuan_fused_moe")
-        mock_platform.get_diffusion_model_impl_qualname.assert_called_once_with("hunyuan_fused_moe")
-        mock_resolve.assert_called_once_with(
-            "vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe.HunyuanFusedMoEDefault"
-        )
-        mock_impl.assert_called_once_with(prefix="")
-
-
-class TestHunyuanFusedMoEFactory:
-    """Test HunyuanFusedMoE factory __new__ and make_expert_params_mapping delegation."""
-
-    def test_new_delegates_to_impl_class(self, mocker):
-        """HunyuanFusedMoE(prefix=..., **kwargs) should instantiate and return impl instance."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        class MockImpl:
-            def __init__(self, *, prefix: str = "", **kwargs):
-                self.prefix = prefix
-                self.kwargs = kwargs
-
-        mock_platform = mocker.MagicMock()
-        mock_platform.get_diffusion_model_impl_qualname.return_value = "mock.impl.Qualname"
-        mocker.patch.object(hunyuan_moe, "current_omni_platform", mock_platform)
-
-        mock_impl_class = mocker.MagicMock(return_value=MockImpl(prefix="test", a=1))
-        mocker.patch.object(hunyuan_moe, "resolve_obj_by_qualname", return_value=mock_impl_class)
-
-        from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe import (
-            HunyuanFusedMoE,
-        )
-
-        result = HunyuanFusedMoE(prefix="test", a=1)
-
-        assert isinstance(result, MockImpl)
-        assert result.prefix == "test"
-        assert result.kwargs == {"a": 1}
-        mock_platform.prepare_diffusion_op_runtime.assert_called_once_with("hunyuan_fused_moe")
-        mock_platform.get_diffusion_model_impl_qualname.assert_called_once_with("hunyuan_fused_moe")
-        mock_impl_class.assert_called_once_with(prefix="test", a=1)
-
-    def test_make_expert_params_mapping_delegates_to_impl(self, mocker):
-        """make_expert_params_mapping should delegate to impl class method."""
-        import vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe as hunyuan_moe
-
-        expected_mapping = [("a", "b", 0, "c")]
-        mock_platform = mocker.MagicMock()
-        mock_platform.get_diffusion_model_impl_qualname.return_value = "mock.impl.Qualname"
-        mocker.patch.object(hunyuan_moe, "current_omni_platform", mock_platform)
-
-        mock_impl_class = mocker.MagicMock()
-        mock_impl_class.make_expert_params_mapping = mocker.MagicMock(return_value=expected_mapping)
-        mocker.patch.object(hunyuan_moe, "resolve_obj_by_qualname", return_value=mock_impl_class)
-
-        from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe import (
-            HunyuanFusedMoE,
-        )
-
-        result = HunyuanFusedMoE.make_expert_params_mapping(
-            model=None,
-            ckpt_gate_proj_name="gate",
-            ckpt_down_proj_name="down",
-            ckpt_up_proj_name="up",
-            num_experts=4,
-            num_redundant_experts=0,
-        )
-
-        assert result == expected_mapping
-        mock_platform.get_diffusion_model_impl_qualname.assert_called_once_with("hunyuan_fused_moe")
-        mock_impl_class.make_expert_params_mapping.assert_called_once_with(
-            None,
-            ckpt_gate_proj_name="gate",
-            ckpt_down_proj_name="down",
-            ckpt_up_proj_name="up",
-            num_experts=4,
-            num_redundant_experts=0,
-        )
diff --git a/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_step_execution.py b/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_step_execution.py
index b4f1e7493..d9d310ee4 100644
--- a/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_step_execution.py
+++ b/tests/diffusion/models/hunyuan_image3/test_hunyuan_image3_step_execution.py
@@ -20,7 +20,7 @@ from vllm_omni.diffusion.models.hunyuan_image3.pipeline_hunyuan_image3 import (
 )
 from vllm_omni.diffusion.worker.input_batch import InputBatch
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+from vllm_omni.diffusion.worker.utils import StepRequestState
 
 pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
@@ -38,8 +38,8 @@ def _pipeline():
     return pipeline
 
 
-def _state(request_id: str, step_index: int) -> DiffusionRequestState:
-    state = DiffusionRequestState(
+def _state(request_id: str, step_index: int) -> StepRequestState:
+    state = StepRequestState(
         request_id=request_id,
         sampling=SimpleNamespace(),
         prompt="prompt",
@@ -133,7 +133,7 @@ def test_prepare_encode_preserves_normal_hunyuan_bot_task_semantics(
 
     monkeypatch.setattr(hy3_module, "get_system_prompt", fake_get_system_prompt)
     pipeline.prepare_model_inputs = fake_prepare_model_inputs
-    state = DiffusionRequestState(
+    state = StepRequestState(
         request_id="req-bot-task",
         sampling=sampling,
         prompt=prompt_item,
diff --git a/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py b/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
index 8a35d8aaa..543b93a25 100644
--- a/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
+++ b/tests/diffusion/models/hunyuan_image3/test_image_kv_cache_manager.py
@@ -45,6 +45,8 @@ def patched_mgr_env(sp_size=1):
     target = _TRANSFORMER_MODULE
     patches = [
         patch(f"{target}.get_sequence_parallel_world_size", return_value=sp_size),
+        patch(f"{target}.get_allgather_parallel_world_size", return_value=sp_size),
+        patch(f"{target}.get_ulysses_parallel_world_size", return_value=1, create=True),
         patch(f"{target}.get_sequence_parallel_rank", return_value=0),
         patch(f"{target}.Attention", MockAttention),
     ]
diff --git a/tests/gr00t/__init__.py b/tests/diffusion/models/lingbot_video/__init__.py
similarity index 100%
rename from tests/gr00t/__init__.py
rename to tests/diffusion/models/lingbot_video/__init__.py
diff --git a/tests/diffusion/models/lingbot_video/test_lingbot_video_moe_cuda.py b/tests/diffusion/models/lingbot_video/test_lingbot_video_moe_cuda.py
new file mode 100644
index 000000000..5ea19948b
--- /dev/null
+++ b/tests/diffusion/models/lingbot_video/test_lingbot_video_moe_cuda.py
@@ -0,0 +1,183 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from tests.helpers.mark import hardware_test
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+
+def _upstream_sparse_moe_reference(block, hidden_states, padding_mask=None):
+    """Independent eager reference for the upstream LingBot sparse MoE path."""
+    batch_size, _, hidden_size = hidden_states.shape
+    tokens = hidden_states.reshape(-1, hidden_size)
+
+    logits = F.linear(tokens.float(), block.router.weight.float())
+    if block.router.score_func == "softmax":
+        scores = F.softmax(logits, dim=-1)
+    else:
+        scores = logits.sigmoid()
+    scores_for_choice = scores + block.router.e_score_correction_bias.unsqueeze(0)
+
+    if block.router.n_group is not None and block.router.n_group > 1:
+        experts_per_group = block.router.num_experts // block.router.n_group
+        grouped = scores_for_choice.view(-1, block.router.n_group, experts_per_group)
+        group_scores = grouped.topk(2, dim=-1)[0].sum(dim=-1)
+        group_idx = torch.topk(
+            group_scores,
+            k=block.router.topk_group,
+            dim=-1,
+            sorted=False,
+        )[1]
+        group_mask = torch.zeros_like(group_scores)
+        group_mask.scatter_(1, group_idx, 1)
+        score_mask = group_mask.unsqueeze(-1).expand_as(grouped).reshape_as(scores_for_choice)
+        scores_for_choice = scores_for_choice.masked_fill(~score_mask.bool(), float("-inf"))
+
+    top_indices = torch.topk(
+        scores_for_choice,
+        k=block.router.top_k,
+        dim=-1,
+        sorted=False,
+    )[1]
+    top_scores = scores.gather(1, top_indices)
+    if block.router.top_k > 1 and block.router.norm_topk_prob:
+        top_scores = top_scores / (top_scores.sum(dim=-1, keepdim=True) + 1e-20)
+    top_scores = top_scores.to(tokens.dtype) * block.router.route_scale
+
+    if padding_mask is not None:
+        mask = padding_mask.unsqueeze(-1).to(top_scores.dtype)
+        top_scores = top_scores * mask
+        top_scores = top_scores / (top_scores.sum(dim=-1, keepdim=True) + 1e-9)
+        top_scores = top_scores * block.router.route_scale
+
+    routed = torch.zeros(
+        tokens.shape,
+        dtype=torch.float32,
+        device=tokens.device,
+    )
+    for expert_idx in range(block.router.num_experts):
+        token_idx, route_idx = torch.where(top_indices == expert_idx)
+        if token_idx.numel() == 0:
+            continue
+        expert_tokens = tokens[token_idx]
+        h = F.silu(expert_tokens @ block.experts.w1[expert_idx].transpose(-2, -1))
+        h = h * (expert_tokens @ block.experts.w3[expert_idx].transpose(-2, -1))
+        expert_output = h @ block.experts.w2[expert_idx].transpose(-2, -1)
+        weighted = expert_output.float() * top_scores[token_idx, route_idx, None].float()
+        routed.index_add_(0, token_idx, weighted)
+
+    output = routed.to(tokens.dtype).reshape(batch_size, -1, hidden_size)
+    if block.shared_experts is not None:
+        shared = F.linear(hidden_states, block.shared_experts.gate_proj.weight)
+        shared = F.silu(shared) * F.linear(hidden_states, block.shared_experts.up_proj.weight)
+        shared = F.linear(shared, block.shared_experts.down_proj.weight)
+        output = output + shared
+    return output, top_indices, top_scores
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_grouped_mm_matches_per_expert_reference() -> None:
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    if not hasattr(torch, "_grouped_mm"):
+        pytest.skip("torch._grouped_mm is unavailable")
+
+    torch.manual_seed(42)
+    block = module.LingBotVideoSparseMoeBlock(
+        hidden_size=16,
+        num_experts=4,
+        top_k=2,
+        moe_intermediate_size=8,
+        score_func="sigmoid",
+        norm_topk_prob=True,
+        n_group=None,
+        topk_group=None,
+        routed_scaling_factor=1.0,
+        n_shared_experts=None,
+    ).to(device="cuda", dtype=torch.bfloat16)
+    with torch.no_grad():
+        block.experts.w1.normal_(mean=0.0, std=0.02)
+        block.experts.w2.normal_(mean=0.0, std=0.02)
+        block.experts.w3.normal_(mean=0.0, std=0.02)
+    tokens = torch.randn(23, 16, device="cuda", dtype=torch.bfloat16)
+    counts = torch.tensor([5, 0, 9, 9], device="cuda", dtype=torch.int64)
+
+    expected = block._run_experts_for_loop(tokens, counts)
+    actual = block._run_grouped_experts(tokens, counts)
+
+    torch.testing.assert_close(actual, expected)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_sparse_moe_block_matches_upstream_reference() -> None:
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    if not hasattr(torch, "_grouped_mm"):
+        pytest.skip("torch._grouped_mm is unavailable")
+
+    torch.manual_seed(42)
+    block = module.LingBotVideoSparseMoeBlock(
+        hidden_size=16,
+        num_experts=8,
+        top_k=2,
+        moe_intermediate_size=8,
+        score_func="sigmoid",
+        norm_topk_prob=True,
+        n_group=4,
+        topk_group=1,
+        routed_scaling_factor=1.5,
+        n_shared_experts=1,
+    )
+    with torch.no_grad():
+        block.router.weight.zero_()
+        block.router.e_score_correction_bias.copy_(torch.tensor([0.9, 0.8, 1.0, 0.0, 0.7, 0.6, 0.5, 0.4]))
+        for parameter in (
+            block.experts.w1,
+            block.experts.w2,
+            block.experts.w3,
+            block.shared_experts.gate_proj.weight,
+            block.shared_experts.up_proj.weight,
+            block.shared_experts.down_proj.weight,
+        ):
+            parameter.normal_(mean=0.0, std=0.02)
+    block = block.to(device="cuda", dtype=torch.bfloat16)
+
+    hidden_states = torch.randn(2, 5, 16, device="cuda", dtype=torch.bfloat16)
+    padding_mask = torch.tensor(
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+        device="cuda",
+        dtype=torch.float32,
+    )
+
+    with torch.no_grad():
+        expected, expected_indices, expected_scores = _upstream_sparse_moe_reference(
+            block,
+            hidden_states,
+            padding_mask,
+        )
+        actual_indices, actual_scores = block.router(hidden_states.reshape(-1, 16))
+        actual_scores = actual_scores * padding_mask.unsqueeze(-1).to(actual_scores.dtype)
+        actual_scores = actual_scores / (actual_scores.sum(dim=-1, keepdim=True) + 1e-9)
+        actual_scores = actual_scores * block.router.route_scale
+        actual = block(hidden_states, padding_mask=padding_mask)
+
+    corrected_scores = (
+        torch.full(
+            (8,),
+            0.5,
+            device="cuda",
+        )
+        + block.router.e_score_correction_bias
+    )
+    unrestricted_indices = torch.topk(corrected_scores, k=2, sorted=False)[1]
+
+    assert set(actual_indices[0].tolist()) == {0, 1}
+    assert set(unrestricted_indices.tolist()) == {0, 2}
+    assert torch.equal(actual_indices, expected_indices)
+    torch.testing.assert_close(actual_scores, expected_scores, rtol=0, atol=0)
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+    assert torch.isfinite(actual).all()
diff --git a/tests/diffusion/models/lingbot_video/test_lingbot_video_transformer.py b/tests/diffusion/models/lingbot_video/test_lingbot_video_transformer.py
new file mode 100644
index 000000000..e9fad3825
--- /dev/null
+++ b/tests/diffusion/models/lingbot_video/test_lingbot_video_transformer.py
@@ -0,0 +1,266 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def _tiny_transformer(**overrides):
+    from vllm_omni.diffusion.models.lingbot_video import LingBotVideoTransformer3DModel
+
+    config = {
+        "patch_size": (1, 1, 1),
+        "in_channels": 2,
+        "out_channels": 2,
+        "hidden_size": 16,
+        "num_attention_heads": 1,
+        "depth": 0,
+        "intermediate_size": 32,
+        "text_dim": 8,
+        "freq_dim": 8,
+        "axes_dims": (4, 4, 8),
+        "axes_lens": (32, 32, 32),
+    }
+    config.update(overrides)
+    return LingBotVideoTransformer3DModel(**config)
+
+
+def test_joint_position_ids_video_then_text_order():
+    from vllm_omni.diffusion.models.lingbot_video.lingbot_video_transformer import make_joint_position_ids
+
+    positions = make_joint_position_ids(text_len=3, grid_t=1, grid_h=2, grid_w=2, device=torch.device("cpu"))
+
+    assert positions.shape == (7, 3)
+    assert positions[:4, 0].tolist() == [4, 4, 4, 4]
+    assert positions[:4, 1:].tolist() == [[0, 0], [0, 1], [1, 0], [1, 1]]
+    assert positions[4:].tolist() == [[1, 0, 0], [2, 0, 0], [3, 0, 0]]
+
+
+def test_tiny_transformer_depth_zero_forward_shape():
+    model = _tiny_transformer()
+    hidden_states = torch.randn(1, 2, 1, 2, 2)
+    timestep = torch.tensor([300.0])
+    encoder_hidden_states = torch.randn(1, 3, 8)
+    encoder_attention_mask = torch.ones(1, 3, dtype=torch.long)
+
+    with torch.no_grad():
+        out = model(
+            hidden_states,
+            timestep,
+            encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            return_dict=False,
+        )[0]
+
+    assert out.shape == hidden_states.shape
+    assert torch.isfinite(out).all()
+
+
+def test_packed_attention_uses_sdpa_fallback_without_flash_varlen(monkeypatch):
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    monkeypatch.setattr(module, "flash_attn_varlen_func_v3", None)
+    attn = module.LingBotVideoAttention(
+        hidden_size=8,
+        num_heads=2,
+        norm_eps=1e-6,
+        qkv_bias=False,
+        out_bias=False,
+    )
+    captured = {}
+
+    def fake_sdpa_forward(query, key, value, attn_metadata):
+        captured["mask"] = attn_metadata.attn_mask
+        return torch.zeros_like(query)
+
+    monkeypatch.setattr(attn.attn.sdpa_fallback, "forward", fake_sdpa_forward)
+    x = torch.randn(1, 5, 8)
+    rotary = torch.ones(1, 5, 2, dtype=torch.complex64)
+    packed_indices = {
+        "cu_seqlens_kv": torch.tensor([0, 2, 5], dtype=torch.int32),
+        "max_seqlen_in_batch_kv": 3,
+        "attention_mask": module._packed_block_attention_mask([2, 3], x.device),
+    }
+
+    out = attn(x, rotary, packed_indices=packed_indices)
+
+    assert out.shape == x.shape
+    mask = captured["mask"]
+    assert mask.shape == (1, 1, 5, 5)
+    assert mask[0, 0, :2, :2].all()
+    assert mask[0, 0, 2:, 2:].all()
+    assert not mask[0, 0, :2, 2:].any()
+    assert not mask[0, 0, 2:, :2].any()
+
+
+def test_tiny_transformer_rejects_invalid_rope_dims():
+    from vllm_omni.diffusion.models.lingbot_video import LingBotVideoTransformer3DModel
+
+    with pytest.raises(AssertionError, match="head_dim"):
+        LingBotVideoTransformer3DModel(
+            hidden_size=16,
+            num_attention_heads=1,
+            axes_dims=(4, 4, 4),
+            depth=0,
+        )
+
+
+def test_transformer_to_keeps_sensitive_modules_in_fp32():
+    model = _tiny_transformer()
+
+    model.to(dtype=torch.bfloat16)
+
+    assert model.patch_embedder.weight.dtype == torch.bfloat16
+    assert model.time_embedder.linear_1.weight.dtype == torch.float32
+    assert model.norm_out_modulation[1].weight.dtype == torch.float32
+
+
+def test_router_group_limited_topk_uses_bias_corrected_choice():
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    router = module.LingBotVideoRouter(
+        hidden_size=2,
+        num_experts=4,
+        top_k=2,
+        score_func="sigmoid",
+        norm_topk_prob=True,
+        n_group=2,
+        topk_group=1,
+        route_scale=2.5,
+    )
+    with torch.no_grad():
+        router.weight.copy_(
+            torch.tensor(
+                [
+                    [8.0, 0.0],
+                    [7.0, 0.0],
+                    [-8.0, 0.0],
+                    [-7.0, 0.0],
+                ]
+            )
+        )
+        router.e_score_correction_bias.copy_(torch.tensor([0.0, 0.0, 2.0, 2.0]))
+
+    top_indices, top_scores = router(torch.tensor([[1.0, 0.0]]))
+
+    assert set(top_indices[0].tolist()) == {2, 3}
+    assert torch.allclose(top_scores.sum(dim=-1), torch.tensor([2.5]))
+    low_score, high_score = sorted(top_scores[0].tolist())
+    assert low_score < 0.8
+    assert high_score > 1.7
+
+
+def test_sparse_moe_block_masks_padding_tokens():
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    block = module.LingBotVideoSparseMoeBlock(
+        hidden_size=4,
+        num_experts=2,
+        top_k=1,
+        moe_intermediate_size=3,
+        score_func="sigmoid",
+        norm_topk_prob=True,
+        n_group=None,
+        topk_group=None,
+        routed_scaling_factor=1.0,
+        n_shared_experts=None,
+    )
+    with torch.no_grad():
+        block.router.weight.copy_(
+            torch.tensor(
+                [
+                    [8.0, 0.0, 0.0, 0.0],
+                    [-8.0, 0.0, 0.0, 0.0],
+                ]
+            )
+        )
+        block.router.e_score_correction_bias.zero_()
+        block.experts.w1.fill_(0.5)
+        block.experts.w2.fill_(0.5)
+        block.experts.w3.fill_(0.5)
+
+    hidden_states = torch.tensor([[[1.0, 0.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 0.0]]])
+    padding_mask = torch.tensor([1.0, 0.0])
+
+    out = block(hidden_states, padding_mask=padding_mask)
+
+    assert out.shape == hidden_states.shape
+    assert torch.isfinite(out).all()
+    assert not torch.allclose(out[0, 0], torch.zeros_like(out[0, 0]))
+    assert torch.allclose(out[0, 1], torch.zeros_like(out[0, 1]))
+
+
+@pytest.mark.parametrize(
+    "counts_list",
+    [
+        [0, 0, 0, 0],
+        [1, 0, 7, 8, 9],
+        [16, 0, 1, 0],
+        [0, 0, 33, 0],
+    ],
+)
+def test_grouped_padding_matches_reference(counts_list):
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    align = 8
+    counts = torch.tensor(counts_list, dtype=torch.int64)
+    num_tokens = int(counts.sum())
+    tokens = torch.arange(num_tokens * 4, dtype=torch.float32).reshape(num_tokens, 4)
+
+    actual = module.LingBotVideoSparseMoeBlock._pad_grouped_tokens(
+        tokens,
+        counts,
+        align,
+    )
+
+    num_experts = len(counts_list)
+    max_len = ((num_tokens + num_experts * align + align - 1) // align) * align
+    aligned_counts = [((max(count, align) + align - 1) // align) * align for count in counts_list]
+    expected_indices = [num_tokens] * max_len
+    source_start = 0
+    write_start = 0
+    for count, aligned_count in zip(counts_list, aligned_counts):
+        expected_indices[write_start : write_start + count] = range(
+            source_start,
+            source_start + count,
+        )
+        source_start += count
+        write_start += aligned_count
+
+    expected_indices_tensor = torch.tensor(expected_indices, dtype=torch.int64)
+    tokens_with_pad = torch.vstack((tokens, tokens.new_zeros((tokens.shape[-1],))))
+    expected_aligned_counts = torch.tensor(aligned_counts, dtype=torch.int32)
+
+    assert actual[0] == tokens_with_pad.shape
+    torch.testing.assert_close(actual[1], tokens_with_pad[expected_indices_tensor])
+    torch.testing.assert_close(actual[2], expected_indices_tensor)
+    torch.testing.assert_close(actual[3], expected_aligned_counts)
+
+
+def test_tiny_transformer_constructs_moe_and_dense_layers():
+    from vllm_omni.diffusion.models.lingbot_video import lingbot_video_transformer as module
+
+    model = _tiny_transformer(
+        depth=2,
+        num_experts=4,
+        num_experts_per_tok=2,
+        moe_intermediate_size=8,
+        decoder_sparse_step=1,
+        mlp_only_layers=(1,),
+        n_shared_experts=1,
+        n_group=2,
+        topk_group=1,
+        routed_scaling_factor=2.5,
+    )
+
+    assert isinstance(model.blocks[0].ffn, module.LingBotVideoSparseMoeBlock)
+    assert isinstance(model.blocks[1].ffn, module.LingBotVideoMLP)
+    assert "blocks.0.ffn.experts.w1" in model.state_dict()
+    assert "blocks.0.ffn.shared_experts.gate_proj.weight" in model.state_dict()
+
+    model.to(dtype=torch.bfloat16)
+
+    assert model.blocks[0].ffn.router.weight.dtype == torch.float32
+    assert model.blocks[0].ffn.experts.w1.dtype == torch.bfloat16
diff --git a/tests/diffusion/models/lingbot_video/test_pipeline_lingbot_video.py b/tests/diffusion/models/lingbot_video/test_pipeline_lingbot_video.py
new file mode 100644
index 000000000..1322a542f
--- /dev/null
+++ b/tests/diffusion/models/lingbot_video/test_pipeline_lingbot_video.py
@@ -0,0 +1,219 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def _make_pipeline():
+    from vllm_omni.diffusion.models.lingbot_video.pipeline_lingbot_video import LingBotVideoPipeline
+
+    pipeline = object.__new__(LingBotVideoPipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.default_negative_prompt = "default negative"
+    pipeline.od_config = SimpleNamespace(flow_shift=None)
+    return pipeline
+
+
+def _make_request_batch(prompt, **sampling_overrides):
+    sampling = OmniDiffusionSamplingParams(**sampling_overrides)
+    request = OmniDiffusionRequest(prompt=prompt, sampling_params=sampling, request_id="lingbot-test")
+    return DiffusionRequestBatch([request])
+
+
+def test_lingbot_video_pipeline_import_and_registry():
+    from vllm_omni.diffusion.models.lingbot_video import (
+        LingBotVideoPipeline,
+        LingBotVideoTransformer3DModel,
+        get_lingbot_video_post_process_func,
+    )
+    from vllm_omni.diffusion.registry import _DIFFUSION_MODELS, _DIFFUSION_POST_PROCESS_FUNCS
+
+    assert LingBotVideoPipeline is not None
+    assert LingBotVideoTransformer3DModel is not None
+    assert get_lingbot_video_post_process_func is not None
+    assert _DIFFUSION_MODELS["LingBotVideoPipeline"] == (
+        "lingbot_video",
+        "pipeline_lingbot_video",
+        "LingBotVideoPipeline",
+    )
+    assert _DIFFUSION_POST_PROCESS_FUNCS["LingBotVideoPipeline"] == "get_lingbot_video_post_process_func"
+
+
+def test_component_discovery_declarations():
+    from vllm_omni.diffusion.models.lingbot_video import LingBotVideoPipeline
+
+    assert LingBotVideoPipeline._dit_modules == ["transformer"]
+    assert LingBotVideoPipeline._encoder_modules == ["text_encoder"]
+    assert LingBotVideoPipeline._vae_modules == ["vae"]
+    assert LingBotVideoPipeline.supports_step_execution is False
+
+
+def test_extra_body_params_include_video_flow_shift_alias():
+    from vllm_omni.model_extras import get_extra_body_params
+
+    params = get_extra_body_params("LingBotVideoPipeline")
+    assert "shift" in params
+    assert "flow_shift" in params
+    assert "batch_cfg" in params
+
+
+def test_extract_prompt_string_and_mapping():
+    from vllm_omni.diffusion.models.lingbot_video.pipeline_lingbot_video import _extract_prompt
+
+    string_req = SimpleNamespace(prompt="a robot waves")
+    assert _extract_prompt(string_req) == ("a robot waves", None)
+
+    mapping_req = SimpleNamespace(prompt={"prompt": "a robot walks", "negative_prompt": "low quality"})
+    assert _extract_prompt(mapping_req) == ("a robot walks", "low quality")
+
+    with pytest.raises(TypeError, match="Unsupported LingBot prompt type"):
+        _extract_prompt(SimpleNamespace(prompt=["not", "supported"]))
+
+
+def test_check_inputs_accepts_t2v_shapes_and_rejects_invalid_values():
+    from vllm_omni.diffusion.models.lingbot_video import LingBotVideoPipeline
+
+    LingBotVideoPipeline.check_inputs(height=192, width=320, num_frames=1)
+    LingBotVideoPipeline.check_inputs(height=192, width=320, num_frames=9)
+
+    with pytest.raises(ValueError, match="num_frames"):
+        LingBotVideoPipeline.check_inputs(height=192, width=320, num_frames=8)
+    with pytest.raises(ValueError, match="height"):
+        LingBotVideoPipeline.check_inputs(height=190, width=320, num_frames=9)
+
+
+def test_postprocess_keeps_torch_by_default_and_converts_np_when_requested():
+    from vllm_omni.diffusion.models.lingbot_video import get_lingbot_video_post_process_func
+
+    frames = torch.ones(2, 4, 4, 3)
+    post = get_lingbot_video_post_process_func(SimpleNamespace())
+
+    assert post(frames, SimpleNamespace(output_type="pt")) is frames
+    array = post(frames, SimpleNamespace(output_type="np"))
+    assert isinstance(array, np.ndarray)
+    assert array.shape == (2, 4, 4, 3)
+
+
+def test_forward_resolves_t2v_sampling_and_flow_shift_alias():
+    pipeline = _make_pipeline()
+    calls = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        return torch.zeros(9, 192, 320, 3)
+
+    pipeline._generate = fake_generate
+    req = _make_request_batch(
+        {"prompt": "a robot arm", "negative_prompt": "bad hands"},
+        height=192,
+        width=320,
+        num_frames=9,
+        num_inference_steps=2,
+        guidance_scale=3.0,
+        seed=42,
+        output_type="pt",
+        extra_args={"flow_shift": 4.0, "batch_cfg": True},
+    )
+
+    out = pipeline.forward(req)
+
+    assert torch.equal(out.output, torch.zeros(9, 192, 320, 3))
+    assert len(calls) == 1
+    call = calls[0]
+    assert call["prompt"] == "a robot arm"
+    assert call["negative_prompt"] == "bad hands"
+    assert call["height"] == 192
+    assert call["width"] == 320
+    assert call["num_frames"] == 9
+    assert call["num_inference_steps"] == 2
+    assert call["guidance_scale"] == 3.0
+    assert call["shift"] == 4.0
+    assert call["batch_cfg"] is True
+    assert call["output_type"] == "pt"
+
+
+def test_forward_uses_lingbot_guidance_default_when_omitted():
+    pipeline = _make_pipeline()
+    calls = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        return torch.zeros(1)
+
+    pipeline._generate = fake_generate
+    req = _make_request_batch(
+        "a robot arm",
+        height=192,
+        width=320,
+        num_frames=81,
+        num_inference_steps=2,
+        seed=42,
+    )
+
+    pipeline.forward(req)
+
+    assert calls[0]["num_frames"] == 81
+    assert calls[0]["guidance_scale"] == 6.0
+
+
+def test_forward_prefers_shift_over_flow_shift_and_defaults_negative_prompt():
+    pipeline = _make_pipeline()
+    calls = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        return torch.zeros(5, 192, 192, 3)
+
+    pipeline._generate = fake_generate
+    req = _make_request_batch(
+        "a robot arm",
+        height=192,
+        width=192,
+        num_frames=5,
+        num_inference_steps=2,
+        guidance_scale=1.0,
+        seed=42,
+        extra_args={"shift": 5.0, "flow_shift": 4.0},
+    )
+
+    pipeline.forward(req)
+
+    assert calls[0]["shift"] == 5.0
+    assert calls[0]["negative_prompt"] == "default negative"
+
+
+def test_forward_rejects_multi_request_batches():
+    pipeline = _make_pipeline()
+    first = OmniDiffusionRequest(
+        prompt="first",
+        sampling_params=OmniDiffusionSamplingParams(seed=1),
+        request_id="lingbot-first",
+    )
+    second = OmniDiffusionRequest(
+        prompt="second",
+        sampling_params=OmniDiffusionSamplingParams(seed=2),
+        request_id="lingbot-second",
+    )
+
+    with pytest.raises(ValueError, match="only supports one request"):
+        pipeline.forward(DiffusionRequestBatch([first, second]))
+
+
+def test_load_weights_rejects_external_weight_stream():
+    pipeline = _make_pipeline()
+
+    assert pipeline.load_weights([]) == set()
+    with pytest.raises(RuntimeError, match="components are loaded directly"):
+        pipeline.load_weights([("transformer.weight", torch.zeros(1))])
diff --git a/tests/diffusion/models/ltx2/test_ltx2_3_image2video_pipeline.py b/tests/diffusion/models/ltx2/test_ltx2_3_image2video_pipeline.py
deleted file mode 100644
index 9b883ff34..000000000
--- a/tests/diffusion/models/ltx2/test_ltx2_3_image2video_pipeline.py
+++ /dev/null
@@ -1,244 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""Unit tests for the LTX-2.3 image-to-video pipeline."""
-
-from types import SimpleNamespace
-
-import pytest
-import torch
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _make_ltx23_request_pipe(cls):
-    pipe = object.__new__(cls)
-    torch.nn.Module.__init__(pipe)
-    pipe.device = torch.device("cpu")
-    pipe.tokenizer_max_length = 99
-    return pipe
-
-
-class TestLTX23ImageToVideoForwardStages:
-    def test_forward_resolves_request_image_and_delegates_to_shared_forward_impl(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-        from vllm_omni.diffusion.request import OmniDiffusionRequest
-        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-        pipe = _make_ltx23_request_pipe(LTX23ImageToVideoPipeline)
-        image = torch.zeros(3, 8, 8)
-        req = DiffusionRequestBatch(
-            [
-                OmniDiffusionRequest(
-                    prompt={
-                        "prompt": "make the image move",
-                        "negative_prompt": "jitter",
-                        "multi_modal_data": {"image": image},
-                    },
-                    sampling_params=OmniDiffusionSamplingParams(
-                        height=384,
-                        width=512,
-                        num_frames=25,
-                        num_inference_steps=2,
-                    ),
-                    request_id="ltx23-i2v-forward-stage-delegation",
-                )
-            ]
-        )
-        seen = {}
-
-        def fake_forward_impl(req_arg, request_inputs, **kwargs):
-            seen["req"] = req_arg
-            seen["request_inputs"] = request_inputs
-            seen["kwargs"] = kwargs
-            return ["i2v-delegated"]
-
-        object.__setattr__(pipe, "_forward_impl", fake_forward_impl)
-
-        output = pipe.forward(req, noise_scale=0.5)
-
-        assert output == ["i2v-delegated"]
-        assert seen["req"] is req
-        assert seen["request_inputs"].prompt == ["make the image move"]
-        assert seen["request_inputs"].negative_prompt == ["jitter"]
-        assert seen["kwargs"]["image"] is image
-        assert seen["kwargs"]["noise_scale"] == 0.5
-
-    def test_denoise_timestep_kwargs_masks_video_only(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        pipe = object.__new__(LTX23ImageToVideoPipeline)
-        ts = torch.tensor([2.0, 4.0])
-        denoise_ctx = SimpleNamespace(
-            conditioning_mask=torch.tensor([[1.0, 0.0]]),
-            conditioning_mask_for_model=torch.tensor([[1.0, 0.0], [0.0, 1.0]]),
-        )
-
-        kwargs = pipe._denoise_timestep_kwargs(
-            ts,
-            SimpleNamespace(cfg_parallel_ready=False),
-            denoise_ctx,
-        )
-
-        torch.testing.assert_close(kwargs["timestep"], torch.tensor([[0.0, 2.0], [4.0, 0.0]]))
-        torch.testing.assert_close(kwargs["audio_timestep"], ts)
-        torch.testing.assert_close(kwargs["sigma"], ts)
-
-
-class TestLTX23ImageToVideoPipeline:
-    def test_ltx23_i2v_pipeline_reuses_ltx23_semantics(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        assert issubclass(LTX23ImageToVideoPipeline, LTX23Pipeline)
-        assert LTX23ImageToVideoPipeline.support_image_input is True
-
-    def test_ltx23_i2v_rejects_multi_image_prompt_list(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        image = object()
-
-        assert LTX23ImageToVideoPipeline._resolve_single_prompt_image([image]) is image
-        with pytest.raises(ValueError, match="exactly one image per prompt"):
-            LTX23ImageToVideoPipeline._resolve_single_prompt_image([object(), object()])
-
-    def test_ltx23_i2v_additional_image_resolution_is_tensor_safe(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        image = torch.zeros(1, 3, 4, 4)
-        additional = {
-            "preprocessed_image": None,
-            "pixel_values": image,
-            "image": torch.ones_like(image),
-        }
-
-        assert LTX23ImageToVideoPipeline._resolve_additional_image(additional) is image
-
-    def test_ltx23_i2v_packed_latents_are_not_noised(self, monkeypatch):
-        import vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video as ltx23_i2v
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        pipe = object.__new__(LTX23ImageToVideoPipeline)
-        torch.nn.Module.__init__(pipe)
-        pipe.vae_spatial_compression_ratio = 1
-        pipe.vae_temporal_compression_ratio = 1
-        pipe.transformer_spatial_patch_size = 1
-        pipe.transformer_temporal_patch_size = 1
-
-        def fake_randn_tensor(shape, generator=None, device=None, dtype=None):
-            raise AssertionError("packed I2V latents should not be noised")
-
-        monkeypatch.setattr(ltx23_i2v, "randn_tensor", fake_randn_tensor)
-
-        latents = torch.tensor([[[10.0, 11.0], [20.0, 21.0], [30.0, 31.0]]])
-
-        out, conditioning_mask = pipe.prepare_latents(
-            image=None,
-            batch_size=1,
-            num_channels_latents=2,
-            height=1,
-            width=1,
-            num_frames=3,
-            noise_scale=1.0,
-            dtype=torch.float32,
-            device=torch.device("cpu"),
-            latents=latents,
-        )
-
-        torch.testing.assert_close(conditioning_mask, torch.tensor([[1.0, 0.0, 0.0]]))
-        torch.testing.assert_close(out, latents)
-
-    def test_ltx23_i2v_5d_latents_noise_preserves_conditioning_frame(self, monkeypatch):
-        import vllm_omni.diffusion.models.ltx2.pipeline_ltx2 as ltx2
-        import vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video as ltx23_i2v
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        pipe = object.__new__(LTX23ImageToVideoPipeline)
-        torch.nn.Module.__init__(pipe)
-        pipe.vae_spatial_compression_ratio = 1
-        pipe.vae_temporal_compression_ratio = 1
-        pipe.transformer_spatial_patch_size = 1
-        pipe.transformer_temporal_patch_size = 1
-        pipe.vae = SimpleNamespace(
-            latents_mean=torch.zeros(2),
-            latents_std=torch.ones(2),
-            config=SimpleNamespace(scaling_factor=1.0),
-        )
-
-        def fake_randn_tensor(shape, generator=None, device=None, dtype=None):
-            return torch.ones(shape, device=device, dtype=dtype)
-
-        monkeypatch.setattr(ltx23_i2v, "randn_tensor", fake_randn_tensor)
-        monkeypatch.setattr(ltx2, "randn_tensor", fake_randn_tensor)
-
-        latents = torch.tensor([[[[[10.0]], [[20.0]], [[30.0]]], [[[11.0]], [[21.0]], [[31.0]]]]])
-
-        out, conditioning_mask = pipe.prepare_latents(
-            image=None,
-            batch_size=1,
-            num_channels_latents=2,
-            height=1,
-            width=1,
-            num_frames=3,
-            noise_scale=1.0,
-            dtype=torch.float32,
-            device=torch.device("cpu"),
-            latents=latents,
-        )
-
-        torch.testing.assert_close(conditioning_mask, torch.tensor([[1.0, 0.0, 0.0]]))
-        torch.testing.assert_close(out, torch.tensor([[[10.0, 11.0], [1.0, 1.0], [1.0, 1.0]]]))
-
-    def test_ltx23_i2v_video_step_preserves_conditioning_frame(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        pipe = object.__new__(LTX23ImageToVideoPipeline)
-        torch.nn.Module.__init__(pipe)
-        pipe.transformer_spatial_patch_size = 1
-        pipe.transformer_temporal_patch_size = 1
-
-        class FakeScheduler:
-            def step(self, noise_pred, t, latents, return_dict=False):
-                return (latents + noise_pred + t,)
-
-        pipe.scheduler = FakeScheduler()
-        latents = torch.tensor([[[1.0], [2.0], [3.0]]])
-        noise_pred = torch.full_like(latents, 10.0)
-
-        out = pipe._step_video_latents_i2v(
-            noise_pred,
-            latents,
-            torch.tensor(0.5),
-            latent_num_frames=3,
-            latent_height=1,
-            latent_width=1,
-        )
-
-        torch.testing.assert_close(out[:, :1], latents[:, :1])
-        torch.testing.assert_close(out[:, 1:], latents[:, 1:] + noise_pred[:, 1:] + 0.5)
-
-
-class TestLTX23ImageToVideoModule:
-    """Test that pipeline_ltx2_3_image2video.py exposes I2V entry points."""
-
-    def test_i2v_classes_importable(self):
-        """I2V classes must be importable from the implementation module."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-
-        assert LTX23ImageToVideoPipeline is not None
-
-    def test_post_process_func_importable(self):
-        """get_ltx2_post_process_func must be importable for registry lookup."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import get_ltx2_post_process_func
-
-        assert callable(get_ltx2_post_process_func)
-
-    def test_i2v_class_matches_package_export(self):
-        """Package export must point at the I2V implementation module."""
-        from vllm_omni.diffusion.models.ltx2 import LTX23ImageToVideoPipeline as PackageExported
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import (
-            LTX23ImageToVideoPipeline as ModuleExported,
-        )
-
-        assert PackageExported is ModuleExported
diff --git a/tests/diffusion/models/ltx2/test_ltx2_3_pipeline.py b/tests/diffusion/models/ltx2/test_ltx2_3_pipeline.py
deleted file mode 100644
index 25aae4510..000000000
--- a/tests/diffusion/models/ltx2/test_ltx2_3_pipeline.py
+++ /dev/null
@@ -1,646 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""Unit tests for LTX-2.3 pipeline integration.
-
-These tests verify:
-- Pipeline is properly registered in the diffusion registry
-- Post-process function is registered
-- Cache-DiT enablers are registered
-- Pipeline does NOT inherit from LTX2Pipeline
-- Vocoder sample rate detection logic
-- Re-export module works correctly
-"""
-
-import json
-import os
-import tempfile
-from types import SimpleNamespace
-
-import pytest
-import torch
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _make_ltx23_pipeline(sequence_parallel_size: int = 1):
-    from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-
-    pipeline = object.__new__(LTX23Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.audio_vae_temporal_compression_ratio = 4
-    pipeline.audio_vae_mel_compression_ratio = 4
-    pipeline.od_config = SimpleNamespace(parallel_config=SimpleNamespace(sequence_parallel_size=sequence_parallel_size))
-    pipeline.audio_vae = SimpleNamespace(
-        latents_mean=torch.tensor(0.0),
-        latents_std=torch.tensor(1.0),
-    )
-    return pipeline
-
-
-def _make_ltx23_request_pipe(cls):
-    pipe = object.__new__(cls)
-    torch.nn.Module.__init__(pipe)
-    pipe.device = torch.device("cpu")
-    pipe.tokenizer_max_length = 99
-    return pipe
-
-
-def _resolve_request_inputs_for_test(pipe, req):
-    return pipe._resolve_request_inputs(
-        req,
-        prompt=None,
-        negative_prompt=None,
-        height=None,
-        width=None,
-        num_frames=None,
-        frame_rate=None,
-        num_inference_steps=None,
-        timesteps=None,
-        guidance_scale=4.0,
-        num_videos_per_prompt=1,
-        generator=None,
-        latents=None,
-        audio_latents=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-        decode_timestep=0.0,
-        decode_noise_scale=None,
-        output_type="np",
-        max_sequence_length=None,
-    )
-
-
-class TestLTX23RequestParsing:
-    def test_t2v_and_i2v_share_request_input_resolution(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-        from vllm_omni.diffusion.request import OmniDiffusionRequest
-        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-        prompt_embeds = torch.tensor([[1.0, 2.0]])
-        negative_prompt_embeds = torch.tensor([[3.0, 4.0]])
-        prompt_attention_mask = torch.tensor([True, False])
-        negative_attention_mask = torch.tensor([False, True])
-        video_latents = torch.ones(1, 2, 3)
-        audio_latents = torch.zeros(1, 2, 3)
-        generator = torch.Generator().manual_seed(123)
-
-        req = DiffusionRequestBatch(
-            [
-                OmniDiffusionRequest(
-                    prompt={
-                        "prompt": "shared prompt",
-                        "negative_prompt": "shared negative",
-                        "additional_information": {
-                            "prompt_embeds": prompt_embeds,
-                            "negative_prompt_embeds": negative_prompt_embeds,
-                            "attention_mask": prompt_attention_mask,
-                            "negative_attention_mask": negative_attention_mask,
-                        },
-                    },
-                    sampling_params=OmniDiffusionSamplingParams(
-                        height=384,
-                        width=512,
-                        num_frames=25,
-                        frame_rate=12.5,
-                        num_inference_steps=1,
-                        num_outputs_per_prompt=2,
-                        guidance_scale=6.0,
-                        generator=generator,
-                        latents=video_latents,
-                        extra_args={"audio_latents": audio_latents},
-                        decode_timestep=[0.1],
-                        decode_noise_scale=[0.2],
-                        output_type="latent",
-                        max_sequence_length=17,
-                    ),
-                    request_id="ltx23-shared-request-inputs",
-                )
-            ]
-        )
-
-        resolved_t2v = _resolve_request_inputs_for_test(
-            _make_ltx23_request_pipe(LTX23Pipeline),
-            req,
-        )
-        resolved_i2v = _resolve_request_inputs_for_test(
-            _make_ltx23_request_pipe(LTX23ImageToVideoPipeline),
-            req,
-        )
-
-        assert resolved_i2v.prompt == resolved_t2v.prompt is None
-        assert resolved_i2v.negative_prompt == resolved_t2v.negative_prompt is None
-        assert resolved_i2v.height == resolved_t2v.height == 384
-        assert resolved_i2v.width == resolved_t2v.width == 512
-        assert resolved_i2v.num_frames == resolved_t2v.num_frames == 25
-        assert resolved_i2v.frame_rate == resolved_t2v.frame_rate == 12.5
-        assert resolved_i2v.num_inference_steps == resolved_t2v.num_inference_steps == 2
-        assert resolved_i2v.guidance_scale == resolved_t2v.guidance_scale == 6.0
-        assert resolved_i2v.num_videos_per_prompt == resolved_t2v.num_videos_per_prompt == 2
-        assert isinstance(resolved_i2v.generator, list)
-        assert isinstance(resolved_t2v.generator, list)
-        assert [gen.initial_seed() for gen in resolved_i2v.generator] == [123, 123]
-        assert [gen.initial_seed() for gen in resolved_t2v.generator] == [123, 123]
-        assert resolved_i2v.decode_timestep == resolved_t2v.decode_timestep == [0.1]
-        assert resolved_i2v.decode_noise_scale == resolved_t2v.decode_noise_scale == [0.2]
-        assert resolved_i2v.output_type == resolved_t2v.output_type == "latent"
-        assert resolved_i2v.max_sequence_length == resolved_t2v.max_sequence_length == 17
-        torch.testing.assert_close(resolved_i2v.latents, video_latents)
-        torch.testing.assert_close(resolved_t2v.latents, video_latents)
-        torch.testing.assert_close(resolved_i2v.audio_latents, audio_latents)
-        torch.testing.assert_close(resolved_t2v.audio_latents, audio_latents)
-        torch.testing.assert_close(resolved_i2v.prompt_embeds, torch.stack([prompt_embeds]))
-        torch.testing.assert_close(resolved_t2v.prompt_embeds, torch.stack([prompt_embeds]))
-        torch.testing.assert_close(resolved_i2v.negative_prompt_embeds, torch.stack([negative_prompt_embeds]))
-        torch.testing.assert_close(resolved_t2v.negative_prompt_embeds, torch.stack([negative_prompt_embeds]))
-        torch.testing.assert_close(resolved_i2v.prompt_attention_mask, torch.stack([prompt_attention_mask]))
-        torch.testing.assert_close(resolved_t2v.prompt_attention_mask, torch.stack([prompt_attention_mask]))
-        torch.testing.assert_close(
-            resolved_i2v.negative_prompt_attention_mask,
-            torch.stack([negative_attention_mask]),
-        )
-        torch.testing.assert_close(
-            resolved_t2v.negative_prompt_attention_mask,
-            torch.stack([negative_attention_mask]),
-        )
-
-    def test_request_input_resolution_rejects_mixed_precomputed_prompt_fields(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.request import OmniDiffusionRequest
-        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-        pipe = _make_ltx23_request_pipe(LTX23Pipeline)
-        req = DiffusionRequestBatch(
-            [
-                OmniDiffusionRequest(
-                    prompt={
-                        "prompt": "with embeds",
-                        "additional_information": {"prompt_embeds": torch.tensor([[1.0]])},
-                    },
-                    sampling_params=OmniDiffusionSamplingParams(
-                        height=384,
-                        width=512,
-                        num_frames=25,
-                        num_inference_steps=2,
-                    ),
-                    request_id="ltx23-mixed-precomputed-fields-0",
-                ),
-                OmniDiffusionRequest(
-                    prompt={"prompt": "without embeds"},
-                    sampling_params=OmniDiffusionSamplingParams(
-                        height=384,
-                        width=512,
-                        num_frames=25,
-                        num_inference_steps=2,
-                    ),
-                    request_id="ltx23-mixed-precomputed-fields-1",
-                ),
-            ]
-        )
-
-        with pytest.raises(ValueError, match="mix of provided and missing prompt_embeds"):
-            _resolve_request_inputs_for_test(pipe, req)
-
-
-class TestLTX23ForwardStages:
-    def test_encode_prompt_repeats_precomputed_embeds_for_num_outputs(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-
-        pipe = _make_ltx23_request_pipe(LTX23Pipeline)
-        prompt_embeds = torch.tensor([[[1.0], [2.0]], [[3.0], [4.0]]])
-        negative_prompt_embeds = torch.tensor([[[-1.0], [-2.0]], [[-3.0], [-4.0]]])
-        prompt_attention_mask = torch.tensor([[True, False], [False, True]])
-        negative_prompt_attention_mask = torch.tensor([[False, False], [True, True]])
-
-        (
-            repeated_prompt_embeds,
-            repeated_prompt_attention_mask,
-            repeated_negative_prompt_embeds,
-            repeated_negative_prompt_attention_mask,
-        ) = pipe.encode_prompt(
-            prompt=None,
-            do_classifier_free_guidance=True,
-            num_videos_per_prompt=2,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            device=torch.device("cpu"),
-        )
-
-        torch.testing.assert_close(
-            repeated_prompt_embeds,
-            torch.tensor([[[1.0], [2.0]], [[1.0], [2.0]], [[3.0], [4.0]], [[3.0], [4.0]]]),
-        )
-        torch.testing.assert_close(
-            repeated_negative_prompt_embeds,
-            torch.tensor([[[-1.0], [-2.0]], [[-1.0], [-2.0]], [[-3.0], [-4.0]], [[-3.0], [-4.0]]]),
-        )
-        torch.testing.assert_close(
-            repeated_prompt_attention_mask,
-            torch.tensor([[True, False], [True, False], [False, True], [False, True]]),
-        )
-        torch.testing.assert_close(
-            repeated_negative_prompt_attention_mask,
-            torch.tensor([[False, False], [False, False], [True, True], [True, True]]),
-        )
-
-    def test_t2v_forward_delegates_to_shared_forward_impl(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.request import OmniDiffusionRequest
-        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-        pipe = _make_ltx23_request_pipe(LTX23Pipeline)
-        req = DiffusionRequestBatch(
-            [
-                OmniDiffusionRequest(
-                    prompt="stage refactor prompt",
-                    sampling_params=OmniDiffusionSamplingParams(
-                        height=384,
-                        width=512,
-                        num_frames=25,
-                        frame_rate=16,
-                        num_inference_steps=3,
-                        guidance_scale=4.5,
-                        output_type="latent",
-                    ),
-                    request_id="ltx23-t2v-forward-stage-delegation",
-                )
-            ]
-        )
-        sigmas = [1.0, 0.5]
-        timesteps = [1000, 500]
-        attention_kwargs = {"scale": 1.0}
-        seen = {}
-
-        def fake_forward_impl(req_arg, request_inputs, **kwargs):
-            seen["req"] = req_arg
-            seen["request_inputs"] = request_inputs
-            seen["kwargs"] = kwargs
-            return ["delegated"]
-
-        object.__setattr__(pipe, "_forward_impl", fake_forward_impl)
-
-        output = pipe.forward(
-            req,
-            sigmas=sigmas,
-            timesteps=timesteps,
-            noise_scale=0.25,
-            attention_kwargs=attention_kwargs,
-        )
-
-        assert output == ["delegated"]
-        assert seen["req"] is req
-        assert seen["request_inputs"].height == 384
-        assert seen["request_inputs"].width == 512
-        assert seen["request_inputs"].num_frames == 25
-        assert seen["request_inputs"].frame_rate == 16.0
-        assert seen["request_inputs"].guidance_scale == 4.5
-        assert seen["request_inputs"].output_type == "latent"
-        assert seen["kwargs"] == {
-            "noise_scale": 0.25,
-            "sigmas": sigmas,
-            "timesteps": timesteps,
-            "attention_kwargs": attention_kwargs,
-        }
-
-
-class TestPipelineIndependence:
-    """Verify LTX23Pipeline is fully independent from LTX2Pipeline."""
-
-    def test_ltx23_pipeline_does_not_inherit_from_ltx2(self):
-        """LTX23Pipeline must NOT inherit from LTX2Pipeline."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-
-        assert not issubclass(LTX23Pipeline, LTX2Pipeline), (
-            "LTX23Pipeline should be fully independent and not inherit from LTX2Pipeline"
-        )
-
-    def test_ltx23_pipeline_is_nn_module(self):
-        """LTX23Pipeline must be an nn.Module."""
-        import torch.nn as nn
-
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-
-        assert issubclass(LTX23Pipeline, nn.Module)
-
-    def test_ltx23_pipeline_has_progress_bar(self):
-        """LTX23Pipeline must mix in ProgressBarMixin."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
-
-        assert issubclass(LTX23Pipeline, ProgressBarMixin)
-
-    def test_ltx23_pipeline_declares_offload_components(self):
-        """LTX23Pipeline must expose LTX-2.3-specific modules to offload discovery."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
-
-        pipe = object.__new__(LTX23Pipeline)
-        torch.nn.Module.__init__(pipe)
-        pipe.transformer = torch.nn.Linear(1, 1)
-        pipe.text_encoder = torch.nn.Linear(1, 1)
-        pipe.connectors = torch.nn.Linear(1, 1)
-        pipe.vae = torch.nn.Linear(1, 1)
-        pipe.audio_vae = torch.nn.Linear(1, 1)
-        pipe.vocoder = torch.nn.Linear(1, 1)
-
-        modules = ModuleDiscovery.discover(pipe)
-
-        assert LTX23Pipeline._dit_modules == ["transformer"]
-        assert LTX23Pipeline._encoder_modules == ["text_encoder", "connectors"]
-        assert LTX23Pipeline._vae_modules == ["vae", "audio_vae"]
-        assert LTX23Pipeline._resident_modules == ["vocoder"]
-        assert modules.dit_names == ["transformer"]
-        assert modules.encoder_names == ["text_encoder", "connectors"]
-        assert modules.resident_names == ["vocoder"]
-        assert len(modules.vaes) == 2
-
-    def test_ltx23_pipeline_has_diffusion_pipeline_profiler_mixin(self):
-        """LTX23Pipeline must support lightweight stage timing."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-        from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
-
-        assert issubclass(LTX23Pipeline, DiffusionPipelineProfilerMixin)
-
-
-class TestLTX23DecodeConditioning:
-    def test_decode_conditioning_expands_per_prompt_values_to_effective_batch(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import _expand_per_prompt_decode_value
-
-        assert _expand_per_prompt_decode_value(
-            [0.1, 0.2],
-            prompt_batch_size=2,
-            effective_batch_size=4,
-            field_name="decode_timestep",
-        ) == [0.1, 0.1, 0.2, 0.2]
-        assert _expand_per_prompt_decode_value(
-            [0.3],
-            prompt_batch_size=2,
-            effective_batch_size=4,
-            field_name="decode_timestep",
-        ) == [0.3, 0.3, 0.3, 0.3]
-        assert _expand_per_prompt_decode_value(
-            [0.1, 0.2, 0.3, 0.4],
-            prompt_batch_size=2,
-            effective_batch_size=4,
-            field_name="decode_timestep",
-        ) == [0.1, 0.2, 0.3, 0.4]
-
-    def test_decode_conditioning_rejects_ambiguous_lengths(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import _expand_per_prompt_decode_value
-
-        with pytest.raises(ValueError, match="decode_timestep"):
-            _expand_per_prompt_decode_value(
-                [0.1, 0.2, 0.3],
-                prompt_batch_size=2,
-                effective_batch_size=4,
-                field_name="decode_timestep",
-            )
-
-
-class TestRegistryIntegration:
-    """Verify all LTX-2.3 pipeline variants are registered."""
-
-    def test_pipeline_models_registered(self):
-        """LTX-2.3 pipeline variants must be in _DIFFUSION_MODELS."""
-        from vllm_omni.diffusion.registry import _DIFFUSION_MODELS
-
-        expected = [
-            "LTX23Pipeline",
-            "LTX23ImageToVideoPipeline",
-        ]
-        for name in expected:
-            assert name in _DIFFUSION_MODELS, f"{name} not found in _DIFFUSION_MODELS"
-
-    def test_pipeline_module_paths(self):
-        """Registry entries must point to the correct modules."""
-        from vllm_omni.diffusion.registry import _DIFFUSION_MODELS
-
-        # T2V -> pipeline_ltx2_3
-        assert _DIFFUSION_MODELS["LTX23Pipeline"] == ("ltx2", "pipeline_ltx2_3", "LTX23Pipeline")
-
-        # I2V -> pipeline_ltx2_3_image2video
-        assert _DIFFUSION_MODELS["LTX23ImageToVideoPipeline"] == (
-            "ltx2",
-            "pipeline_ltx2_3_image2video",
-            "LTX23ImageToVideoPipeline",
-        )
-
-    def test_post_process_funcs_registered(self):
-        """Pipeline variants must map to get_ltx2_post_process_func."""
-        from vllm_omni.diffusion.registry import _DIFFUSION_POST_PROCESS_FUNCS
-
-        expected = [
-            "LTX23Pipeline",
-            "LTX23ImageToVideoPipeline",
-        ]
-        for name in expected:
-            assert name in _DIFFUSION_POST_PROCESS_FUNCS, f"{name} not in _DIFFUSION_POST_PROCESS_FUNCS"
-            assert _DIFFUSION_POST_PROCESS_FUNCS[name] == "get_ltx2_post_process_func"
-
-    def test_cache_dit_for_ltx2_does_not_have_custom_enablers_registered(self):
-        """Pipeline variants are *not* registered in CUSTOM_DIT_ENABLERS."""
-        from vllm_omni.diffusion.cache.cache_dit_backend import CUSTOM_DIT_ENABLERS
-
-        # NOTE: We used to have custom enablers for this model, but refactored to handle
-        # it more generically. Now we only need to ensure it has git cache adapter config.
-        expected = [
-            "LTX23Pipeline",
-            "LTX23ImageToVideoPipeline",
-        ]
-        for name in expected:
-            assert name not in CUSTOM_DIT_ENABLERS, f"{name} not in CUSTOM_DIT_ENABLERS"
-
-
-class TestVocoderSampleRateDetection:
-    """Test _detect_vocoder_output_sample_rate logic."""
-
-    def test_detects_48khz_from_config(self):
-        """Should detect output_sampling_rate=48000 from vocoder/config.json."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import _detect_vocoder_output_sample_rate
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            vocoder_dir = os.path.join(tmpdir, "vocoder")
-            os.makedirs(vocoder_dir)
-            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
-                json.dump({"output_sampling_rate": 48000, "input_sampling_rate": 16000}, f)
-
-            result = _detect_vocoder_output_sample_rate(tmpdir)
-            assert result == 48000
-
-    def test_returns_none_for_no_output_sr(self):
-        """Should return None if vocoder config has no output_sampling_rate."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import _detect_vocoder_output_sample_rate
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            vocoder_dir = os.path.join(tmpdir, "vocoder")
-            os.makedirs(vocoder_dir)
-            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
-                json.dump({"sampling_rate": 16000}, f)
-
-            result = _detect_vocoder_output_sample_rate(tmpdir)
-            assert result is None
-
-    def test_returns_none_for_missing_directory(self):
-        """Should return None if vocoder directory doesn't exist."""
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import _detect_vocoder_output_sample_rate
-
-        result = _detect_vocoder_output_sample_rate("/nonexistent/path")
-        assert result is None
-
-
-class TestPostProcessFunction:
-    """Test the post-process function factory."""
-
-    def test_post_process_includes_audio_sample_rate(self):
-        """Post-process func should include audio_sample_rate when detected."""
-        import torch
-
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import get_ltx2_post_process_func
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            vocoder_dir = os.path.join(tmpdir, "vocoder")
-            os.makedirs(vocoder_dir)
-            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
-                json.dump({"output_sampling_rate": 48000}, f)
-
-            # Create a minimal od_config mock
-            class MockConfig:
-                model = tmpdir
-
-            func = get_ltx2_post_process_func(MockConfig())
-
-            video = torch.zeros(1, 3, 4, 64, 64)
-            audio = torch.zeros(1, 1, 48000)
-            result = func((video, audio))
-
-            assert isinstance(result, dict)
-            assert "video" in result
-            assert "audio" in result
-            assert result["audio_sample_rate"] == 48000
-
-    def test_post_process_without_vocoder_config(self):
-        """Post-process func should work without vocoder config (no audio_sample_rate key)."""
-        import torch
-
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import get_ltx2_post_process_func
-
-        class MockConfig:
-            model = "/nonexistent/path"
-
-        func = get_ltx2_post_process_func(MockConfig())
-
-        video = torch.zeros(1, 3, 4, 64, 64)
-        audio = torch.zeros(1, 1, 16000)
-        result = func((video, audio))
-
-        assert isinstance(result, dict)
-        assert "video" in result
-        assert "audio" in result
-        assert "audio_sample_rate" not in result
-
-
-class TestInitExports:
-    """Test that __init__.py exports all LTX-2.3 classes."""
-
-    def test_all_ltx23_classes_exported(self):
-        """All LTX-2.3 pipeline classes must be in the ltx2 package __all__."""
-        from vllm_omni.diffusion.models import ltx2
-
-        expected_classes = [
-            "LTX23Pipeline",
-            "LTX23ImageToVideoPipeline",
-        ]
-        for name in expected_classes:
-            assert hasattr(ltx2, name), f"{name} not exported from ltx2 package"
-            assert name in ltx2.__all__, f"{name} not in ltx2.__all__"
-
-
-class TestAudioLatentSPPadding:
-    def test_prepare_audio_latents_pads_generated_dummy_length_for_sp(self):
-        pipeline = _make_ltx23_pipeline(sequence_parallel_size=2)
-
-        latents, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
-            batch_size=1,
-            num_channels_latents=8,
-            num_mel_bins=64,
-            audio_latent_length=1,
-            dtype=torch.float32,
-            device=torch.device("cpu"),
-        )
-
-        assert original_num_frames == 1
-        assert padded_num_frames == 2
-        assert latents.shape == (1, 2, 128)
-
-    def test_prepare_audio_latents_pads_provided_packed_sequence_dim_for_sp(self):
-        pipeline = _make_ltx23_pipeline(sequence_parallel_size=4)
-        latents = torch.arange(40, dtype=torch.float32).view(1, 10, 4)
-
-        padded, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
-            batch_size=1,
-            num_channels_latents=2,
-            num_mel_bins=8,
-            audio_latent_length=10,
-            dtype=torch.float32,
-            device=torch.device("cpu"),
-            latents=latents,
-        )
-
-        assert original_num_frames == 10
-        assert padded_num_frames == 12
-        assert padded.shape == (1, 12, 4)
-        torch.testing.assert_close(padded[:, :10], latents)
-        torch.testing.assert_close(padded[:, 10:], torch.zeros(1, 2, 4))
-
-    def test_prepare_audio_latents_accepts_already_padded_4d_latents_for_sp(self):
-        pipeline = _make_ltx23_pipeline(sequence_parallel_size=4)
-        latents = torch.arange(96, dtype=torch.float32).view(1, 2, 12, 4)
-
-        audio_latent_length = pipeline._resolve_audio_latent_length(10, latents)
-        padded, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
-            batch_size=1,
-            num_channels_latents=2,
-            num_mel_bins=16,
-            audio_latent_length=audio_latent_length,
-            dtype=torch.float32,
-            device=torch.device("cpu"),
-            latents=latents,
-        )
-
-        assert audio_latent_length == 10
-        assert original_num_frames == 10
-        assert padded_num_frames == 12
-        assert padded.shape == (1, 12, 8)
-        torch.testing.assert_close(padded, pipeline._pack_audio_latents(latents))
-
-    def test_resolve_audio_latent_length_preserves_legacy_4d_shape_inference(self):
-        pipeline = _make_ltx23_pipeline(sequence_parallel_size=4)
-        latents = torch.zeros(1, 2, 13, 4)
-
-        audio_latent_length = pipeline._resolve_audio_latent_length(10, latents)
-
-        assert audio_latent_length == 13
-
-    def test_prepare_audio_latents_rejects_incompatible_provided_length(self):
-        pipeline = _make_ltx23_pipeline(sequence_parallel_size=4)
-        latents = torch.zeros(1, 11, 4)
-
-        with pytest.raises(ValueError, match="incompatible audio frame count"):
-            pipeline.prepare_audio_latents(
-                batch_size=1,
-                num_channels_latents=2,
-                num_mel_bins=8,
-                audio_latent_length=10,
-                dtype=torch.float32,
-                device=torch.device("cpu"),
-                latents=latents,
-            )
diff --git a/tests/diffusion/models/ltx2/test_ltx2_cfg_parallel_adaptation.py b/tests/diffusion/models/ltx2/test_ltx2_cfg_parallel_adaptation.py
deleted file mode 100644
index bbfe63dfa..000000000
--- a/tests/diffusion/models/ltx2/test_ltx2_cfg_parallel_adaptation.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from types import SimpleNamespace
-
-import pytest
-import torch
-
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _make_pipeline(sequence_parallel_size: int = 1) -> LTX2Pipeline:
-    pipeline = object.__new__(LTX2Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.audio_vae_temporal_compression_ratio = 4
-    pipeline.audio_vae_mel_compression_ratio = 4
-    pipeline.od_config = SimpleNamespace(parallel_config=SimpleNamespace(sequence_parallel_size=sequence_parallel_size))
-    # Mock audio_vae with identity normalization (mean=0, std=1) so
-    # _normalize_audio_latents is a no-op and test values are preserved.
-    pipeline.audio_vae = SimpleNamespace(
-        latents_mean=torch.tensor(0.0),
-        latents_std=torch.tensor(1.0),
-    )
-    return pipeline
-
-
-def test_prepare_audio_latents_pads_packed_sequence_dim_for_provided_latents():
-    pipeline = _make_pipeline(sequence_parallel_size=4)
-    latents = torch.arange(40, dtype=torch.float32).view(1, 10, 4)
-
-    padded, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
-        batch_size=1,
-        num_channels_latents=2,
-        num_mel_bins=8,
-        audio_latent_length=10,
-        dtype=torch.float32,
-        device=torch.device("cpu"),
-        latents=latents,
-    )
-
-    assert original_num_frames == 10
-    assert padded_num_frames == 12
-    assert padded.shape == (1, 12, 4)
-    torch.testing.assert_close(padded[:, :10], latents)
-    torch.testing.assert_close(padded[:, 10:], torch.zeros(1, 2, 4))
-
-
-def test_unpad_audio_latents_restores_original_frames_before_unpack():
-    pipeline = _make_pipeline()
-    original = torch.arange(40, dtype=torch.float32).view(1, 10, 4)
-    padded = torch.cat([original, torch.full((1, 2, 4), 999.0)], dim=1)
-
-    unpadded = pipeline._unpad_audio_latents(padded, 10)
-    unpacked = pipeline._unpack_audio_latents(unpadded, latent_length=10, num_mel_bins=2)
-    expected = pipeline._unpack_audio_latents(original, latent_length=10, num_mel_bins=2)
-
-    assert unpacked.shape == (1, 2, 10, 2)
-    assert not (unpacked == 999.0).any()
-    torch.testing.assert_close(unpacked, expected)
diff --git a/tests/diffusion/models/ltx2/test_ltx2_conditioning.py b/tests/diffusion/models/ltx2/test_ltx2_conditioning.py
new file mode 100644
index 000000000..e309dbf47
--- /dev/null
+++ b/tests/diffusion/models/ltx2/test_ltx2_conditioning.py
@@ -0,0 +1,403 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Unit tests for LTX image-to-video input and conditioning behavior."""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from PIL import Image
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_ltx23_request_pipe(cls):
+    pipe = object.__new__(cls)
+    torch.nn.Module.__init__(pipe)
+    pipe.device = torch.device("cpu")
+    pipe.tokenizer_max_length = 99
+    pipe.vae_spatial_compression_ratio = 32
+    pipe.vae_temporal_compression_ratio = 8
+    return pipe
+
+
+class TestLTXImageToVideoForwardStages:
+    def test_i2v_pil_preprocessing_matches_official_center_crop(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_conditioning import _preprocess_i2v_pil_images
+
+        pixels = torch.zeros(4, 8, 3, dtype=torch.uint8)
+        pixels[:, :, 0] = torch.arange(8, dtype=torch.uint8)
+        image = Image.fromarray(pixels.numpy())
+
+        actual = _preprocess_i2v_pil_images(image, height=4, width=4)
+        expected = pixels[:, 2:6].permute(2, 0, 1).unsqueeze(0).float() / 127.5 - 1.0
+
+        torch.testing.assert_close(actual, expected)
+
+    def test_forward_resolves_request_image_and_delegates_to_shared_recipe_runtime(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        pipe = _make_ltx23_request_pipe(LTX2Pipeline)
+        image = torch.zeros(3, 8, 8)
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt={
+                        "prompt": "make the image move",
+                        "negative_prompt": "jitter",
+                        "multi_modal_data": {"image": image},
+                    },
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=384,
+                        width=512,
+                        num_frames=25,
+                        num_inference_steps=2,
+                    ),
+                    request_id="ltx23-i2v-forward-stage-delegation",
+                )
+            ]
+        )
+        seen = {}
+
+        def fake_run_recipe(req_arg, request_inputs, **kwargs):
+            seen["req"] = req_arg
+            seen["request_inputs"] = request_inputs
+            seen["kwargs"] = kwargs
+            return ["i2v-delegated"]
+
+        object.__setattr__(pipe, "_run_recipe", fake_run_recipe)
+
+        output = pipe.forward(req)
+
+        assert output == ["i2v-delegated"]
+        assert seen["req"] is req
+        assert seen["request_inputs"].prompt == ["make the image move"]
+        assert seen["request_inputs"].negative_prompt == ["jitter"]
+        assert seen["kwargs"]["image"] is image
+        assert seen["kwargs"]["request_sigmas"] is None
+
+    def test_unified_entry_selects_t2v_without_images_and_rejects_mixed_batches(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        request_inputs = SimpleNamespace(latents=None)
+        t2v_req = SimpleNamespace(prompts=["text only", {"prompt": "also text only"}])
+
+        assert pipe._resolve_request_image(t2v_req, None, request_inputs) is None
+
+        mixed_req = SimpleNamespace(
+            prompts=[
+                "text only",
+                {"prompt": "image conditioned", "multi_modal_data": {"image": torch.zeros(3, 8, 8)}},
+            ]
+        )
+        with pytest.raises(ValueError, match="cannot mix text-to-video and image-to-video"):
+            pipe._resolve_request_image(mixed_req, None, request_inputs)
+
+    def test_denoise_timestep_kwargs_masks_video_only(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        ts = torch.tensor([2.0, 4.0])
+        denoise_ctx = SimpleNamespace(
+            conditioning_mask=torch.tensor([[1.0, 0.0]]),
+            conditioning_mask_for_model=torch.tensor([[1.0, 0.0], [0.0, 1.0]]),
+        )
+
+        kwargs = pipe._denoise_timestep_kwargs(
+            ts,
+            SimpleNamespace(guidance_parallel_ready=False),
+            denoise_ctx,
+            video_token_count=2,
+            audio_token_count=1,
+        )
+
+        torch.testing.assert_close(kwargs["timestep"], torch.tensor([[0.0, 2.0], [4.0, 0.0]]))
+        torch.testing.assert_close(kwargs["audio_timestep"], ts[:, None])
+        torch.testing.assert_close(kwargs["sigma"], ts)
+
+
+class TestLTXImageToVideoConditioning:
+    def test_ltx23_i2v_supports_image_input(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        assert LTX2Pipeline.support_image_input is True
+
+    def test_ltx23_i2v_rejects_multi_image_prompt_list(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        image = object()
+
+        assert LTX2Pipeline._resolve_single_prompt_image([image]) is image
+        with pytest.raises(ValueError, match="exactly one image per prompt"):
+            LTX2Pipeline._resolve_single_prompt_image([object(), object()])
+
+    def test_ltx23_i2v_additional_image_resolution_is_tensor_safe(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        image = torch.zeros(1, 3, 4, 4)
+        additional = {
+            "preprocessed_image": None,
+            "pixel_values": image,
+            "image": torch.ones_like(image),
+        }
+
+        assert LTX2Pipeline._resolve_additional_image(additional) is image
+
+    def test_ltx23_i2v_packed_latents_are_not_noised(self, monkeypatch):
+        import vllm_omni.diffusion.models.ltx2.ltx2_conditioning as ltx2_conditioning
+        import vllm_omni.diffusion.models.ltx2.ltx2_latents as ltx2_latents
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.vae_spatial_compression_ratio = 1
+        pipe.vae_temporal_compression_ratio = 1
+        pipe.transformer_spatial_patch_size = 1
+        pipe.transformer_temporal_patch_size = 1
+        object.__setattr__(
+            pipe,
+            "_encode_i2v_image_latents",
+            lambda *_args, **_kwargs: torch.tensor([[[[[40.0]]], [[[41.0]]]]]),
+        )
+
+        def fake_randn_tensor(shape, generator=None, device=None, dtype=None):
+            raise AssertionError("packed I2V latents should not be noised")
+
+        monkeypatch.setattr(ltx2_conditioning, "randn_tensor", fake_randn_tensor)
+        monkeypatch.setattr(ltx2_latents, "randn_tensor", fake_randn_tensor)
+
+        latents = torch.tensor([[[10.0, 11.0], [20.0, 21.0], [30.0, 31.0]]])
+
+        out, conditioning_mask = pipe.prepare_latents(
+            image=torch.zeros(1, 3, 1, 1),
+            batch_size=1,
+            num_channels_latents=2,
+            height=1,
+            width=1,
+            num_frames=3,
+            noise_scale=1.0,
+            dtype=torch.float32,
+            device=torch.device("cpu"),
+            latents=latents,
+        )
+
+        torch.testing.assert_close(conditioning_mask, torch.tensor([[1.0, 0.0, 0.0]]))
+        torch.testing.assert_close(out, torch.tensor([[[40.0, 41.0], [20.0, 21.0], [30.0, 31.0]]]))
+
+    def test_ltx23_i2v_5d_latents_noise_preserves_conditioning_frame(self, monkeypatch):
+        import vllm_omni.diffusion.models.ltx2.ltx2_conditioning as ltx2_conditioning
+        import vllm_omni.diffusion.models.ltx2.ltx2_latents as ltx2_latents
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.vae_spatial_compression_ratio = 1
+        pipe.vae_temporal_compression_ratio = 1
+        pipe.transformer_spatial_patch_size = 1
+        pipe.transformer_temporal_patch_size = 1
+        pipe.vae = SimpleNamespace(
+            latents_mean=torch.zeros(2),
+            latents_std=torch.ones(2),
+            config=SimpleNamespace(scaling_factor=1.0),
+        )
+        object.__setattr__(
+            pipe,
+            "_encode_i2v_image_latents",
+            lambda *_args, **_kwargs: torch.tensor([[[[[40.0]]], [[[41.0]]]]]),
+        )
+
+        sampled_shapes = []
+
+        def fake_randn_tensor(shape, generator=None, device=None, dtype=None):
+            sampled_shapes.append(tuple(shape))
+            return torch.ones(shape, device=device, dtype=dtype)
+
+        monkeypatch.setattr(ltx2_conditioning, "randn_tensor", fake_randn_tensor)
+        monkeypatch.setattr(ltx2_latents, "randn_tensor", fake_randn_tensor)
+
+        latents = torch.tensor([[[[[10.0]], [[20.0]], [[30.0]]], [[[11.0]], [[21.0]], [[31.0]]]]])
+
+        out, conditioning_mask = pipe.prepare_latents(
+            image=torch.zeros(1, 3, 1, 1),
+            batch_size=1,
+            num_channels_latents=2,
+            height=1,
+            width=1,
+            num_frames=3,
+            noise_scale=1.0,
+            dtype=torch.float32,
+            device=torch.device("cpu"),
+            latents=latents,
+        )
+
+        torch.testing.assert_close(conditioning_mask, torch.tensor([[1.0, 0.0, 0.0]]))
+        torch.testing.assert_close(out, torch.tensor([[[40.0, 41.0], [1.0, 1.0], [1.0, 1.0]]]))
+        assert sampled_shapes == [(1, 3, 2)]
+
+    def test_ltx23_i2v_image_noise_is_sampled_after_packing(self, monkeypatch):
+        import vllm_omni.diffusion.models.ltx2.ltx2_conditioning as ltx2_conditioning
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.vae_spatial_compression_ratio = 1
+        pipe.vae_temporal_compression_ratio = 1
+        pipe.transformer_spatial_patch_size = 1
+        pipe.transformer_temporal_patch_size = 1
+        pipe.vae = SimpleNamespace(
+            encode=lambda image: image,
+            latents_mean=torch.zeros(2),
+            latents_std=torch.ones(2),
+        )
+        monkeypatch.setattr(
+            ltx2_conditioning,
+            "retrieve_latents",
+            lambda *_args, **_kwargs: torch.tensor([[[[[10.0]]], [[[11.0]]]]]),
+        )
+        sampled_shapes = []
+
+        def fake_randn_tensor(shape, generator=None, device=None, dtype=None):
+            sampled_shapes.append(tuple(shape))
+            return torch.ones(shape, device=device, dtype=dtype)
+
+        monkeypatch.setattr(ltx2_conditioning, "randn_tensor", fake_randn_tensor)
+
+        out, conditioning_mask = pipe.prepare_latents(
+            image=torch.zeros(1, 3, 1, 1),
+            batch_size=1,
+            num_channels_latents=2,
+            height=1,
+            width=1,
+            num_frames=3,
+            noise_scale=1.0,
+            dtype=torch.float32,
+            device=torch.device("cpu"),
+        )
+
+        assert sampled_shapes == [(1, 3, 2)]
+        torch.testing.assert_close(conditioning_mask, torch.tensor([[1.0, 0.0, 0.0]]))
+        torch.testing.assert_close(out, torch.tensor([[[10.0, 11.0], [1.0, 1.0], [1.0, 1.0]]]))
+
+    def test_ltx23_i2v_video_step_preserves_conditioning_frame(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.transformer_spatial_patch_size = 1
+        pipe.transformer_temporal_patch_size = 1
+
+        class FakeScheduler:
+            sigmas = torch.tensor([1.0, 0.5])
+
+        pipe.scheduler = FakeScheduler()
+        latents = torch.tensor([[[1.0], [2.0], [3.0]]])
+        noise_pred = torch.full_like(latents, 10.0)
+
+        out = pipe._step_video_latents_i2v(
+            noise_pred,
+            latents,
+            0,
+            latent_num_frames=3,
+            latent_height=1,
+            latent_width=1,
+        )
+
+        torch.testing.assert_close(out[:, :1], latents[:, :1])
+        torch.testing.assert_close(out[:, 1:], latents[:, 1:] - 0.5 * noise_pred[:, 1:])
+
+    def test_shared_step_adapter_uses_official_euler_for_t2v(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_denoise import LTXVideoAudioStepAdapter
+
+        pipeline = SimpleNamespace(scheduler=SimpleNamespace(sigmas=torch.tensor([1.0, 0.5])))
+        adapter = LTXVideoAudioStepAdapter(
+            pipeline,
+            SimpleNamespace(sigmas=torch.tensor([1.0, 0.25])),
+            latent_num_frames=1,
+            latent_height=1,
+            latent_width=1,
+            image_conditioned=False,
+        )
+        video = torch.tensor([[[2.0]]])
+        audio = torch.tensor([[[4.0]]])
+
+        ((video, audio),) = adapter.step(
+            (torch.tensor([[[2.0]]]), torch.tensor([[[4.0]]])),
+            (torch.tensor(1.0), torch.tensor(1.0)),
+            (video, audio),
+        )
+
+        torch.testing.assert_close(video, torch.tensor([[[1.0]]]))
+        torch.testing.assert_close(audio, torch.tensor([[[1.0]]]))
+
+    def test_shared_step_adapter_uses_official_euler_for_i2v_audio(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_denoise import LTXVideoAudioStepAdapter
+
+        class FakePipeline:
+            scheduler = object()
+
+            def __init__(self):
+                self.step_indices = []
+
+            def _step_video_latents_i2v(
+                self,
+                noise_pred,
+                latents,
+                step_index,
+                latent_num_frames,
+                latent_height,
+                latent_width,
+            ):
+                del noise_pred, latent_num_frames, latent_height, latent_width
+                self.step_indices.append(step_index)
+                return latents
+
+        pipeline = FakePipeline()
+        adapter = LTXVideoAudioStepAdapter(
+            pipeline,
+            SimpleNamespace(sigmas=torch.tensor([1.0, 0.5, 0.0])),
+            latent_num_frames=1,
+            latent_height=1,
+            latent_width=1,
+            image_conditioned=True,
+        )
+        video = torch.tensor([[[1.0]]])
+        audio = torch.tensor([[[2.0]]])
+        video_velocity = torch.zeros_like(video)
+        audio_velocity = torch.tensor([[[4.0]]])
+
+        ((video, audio),) = adapter.step(
+            (video_velocity, audio_velocity),
+            (torch.tensor(1.0), torch.tensor(1.0)),
+            (video, audio),
+        )
+        torch.testing.assert_close(audio, torch.tensor([[[0.0]]]))
+
+        ((video, audio),) = adapter.step(
+            (video_velocity, audio_velocity),
+            (torch.tensor(0.5), torch.tensor(0.5)),
+            (video, audio),
+        )
+        torch.testing.assert_close(audio, torch.tensor([[[-2.0]]]))
+        assert pipeline.step_indices == [0, 1]
+
+    def test_i2v_guidance_uses_zero_sigma_for_conditioned_tokens(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_denoise import LTXDenoiseContext
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = object.__new__(LTX2Pipeline)
+        denoise_ctx = LTXDenoiseContext(
+            latents=torch.empty(1, 3, 1),
+            audio_latents=torch.empty(1, 1, 1),
+            video_coords=torch.empty(1),
+            audio_coords=torch.empty(1),
+            conditioning_mask=torch.tensor([[1.0, 0.0, 0.0]]),
+        )
+
+        actual = pipe._video_guidance_model_sigma(torch.tensor(0.75), denoise_ctx)
+
+        torch.testing.assert_close(actual, torch.tensor([[[0.0], [0.75], [0.75]]]))
diff --git a/tests/diffusion/models/ltx2/test_ltx2_hsdp.py b/tests/diffusion/models/ltx2/test_ltx2_hsdp.py
deleted file mode 100644
index 4dd07e1bf..000000000
--- a/tests/diffusion/models/ltx2/test_ltx2_hsdp.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import pytest
-import torch.nn as nn
-
-from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def test_ltx2_exposes_hsdp_shard_conditions_for_transformer_blocks():
-    model = object.__new__(LTX2VideoTransformer3DModel)
-    nn.Module.__init__(model)
-    model.transformer_blocks = nn.ModuleList([nn.Linear(4, 4) for _ in range(2)])
-    model.norm_out = nn.LayerNorm(4)
-
-    conditions = getattr(model, "_hsdp_shard_conditions", None)
-
-    assert conditions is not None
-    assert len(conditions) == 1
-
-    matched = []
-    for name, module in model.named_modules():
-        if any(cond(name, module) for cond in conditions):
-            matched.append(name)
-
-    assert matched == ["transformer_blocks.0", "transformer_blocks.1"]
diff --git a/tests/diffusion/models/ltx2/test_ltx2_latents.py b/tests/diffusion/models/ltx2/test_ltx2_latents.py
new file mode 100644
index 000000000..36f7e9687
--- /dev/null
+++ b/tests/diffusion/models/ltx2/test_ltx2_latents.py
@@ -0,0 +1,165 @@
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.ltx2 import ltx2_latents as latent_ops
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_pipeline(pipeline_cls, sequence_parallel_size: int = 1):
+    pipeline = object.__new__(pipeline_cls)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.audio_vae_temporal_compression_ratio = 4
+    pipeline.audio_vae_mel_compression_ratio = 4
+    pipeline.od_config = SimpleNamespace(parallel_config=SimpleNamespace(sequence_parallel_size=sequence_parallel_size))
+    # Mock audio_vae with identity normalization (mean=0, std=1).
+    pipeline.audio_vae = SimpleNamespace(
+        latents_mean=torch.tensor(0.0),
+        latents_std=torch.tensor(1.0),
+    )
+    return pipeline
+
+
+def test_prepare_video_latents_samples_directly_in_packed_token_space():
+    pipeline = _make_pipeline(LTX2Pipeline)
+    pipeline.vae_spatial_compression_ratio = 8
+    pipeline.vae_temporal_compression_ratio = 8
+    pipeline.transformer_spatial_patch_size = 2
+    pipeline.transformer_temporal_patch_size = 1
+
+    expected_generator = torch.Generator().manual_seed(42)
+    expected = torch.randn((1, 32, 16), generator=expected_generator)
+    actual = pipeline.prepare_latents(
+        batch_size=1,
+        num_channels_latents=4,
+        height=64,
+        width=64,
+        num_frames=9,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+        generator=torch.Generator().manual_seed(42),
+    )
+
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+def test_prepare_audio_latents_samples_directly_in_packed_token_space():
+    pipeline = _make_pipeline(LTX2Pipeline)
+
+    expected_generator = torch.Generator().manual_seed(42)
+    expected = torch.randn((1, 3, 32), generator=expected_generator)
+    actual, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
+        batch_size=1,
+        num_channels_latents=2,
+        num_mel_bins=64,
+        audio_latent_length=3,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+        generator=torch.Generator().manual_seed(42),
+    )
+
+    assert original_num_frames == 3
+    assert padded_num_frames == 3
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+def test_prepare_audio_latents_pads_generated_dummy_length_for_sp():
+    pipeline = _make_pipeline(LTX2Pipeline, sequence_parallel_size=2)
+
+    latents, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
+        batch_size=1,
+        num_channels_latents=8,
+        num_mel_bins=64,
+        audio_latent_length=1,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+    )
+
+    assert original_num_frames == 1
+    assert padded_num_frames == 2
+    assert latents.shape == (1, 2, 128)
+
+
+def test_prepare_audio_latents_pads_packed_sequence_dim_for_provided_latents():
+    pipeline = _make_pipeline(LTX2Pipeline, sequence_parallel_size=4)
+    latents = torch.arange(40, dtype=torch.float32).view(1, 10, 4)
+
+    padded, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
+        batch_size=1,
+        num_channels_latents=2,
+        num_mel_bins=8,
+        audio_latent_length=10,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+        latents=latents,
+    )
+
+    assert original_num_frames == 10
+    assert padded_num_frames == 12
+    assert padded.shape == (1, 12, 4)
+    torch.testing.assert_close(padded[:, :10], latents)
+    torch.testing.assert_close(padded[:, 10:], torch.zeros(1, 2, 4))
+
+
+def test_unpad_audio_latents_restores_original_frames_before_unpack():
+    original = torch.arange(40, dtype=torch.float32).view(1, 10, 4)
+    padded = torch.cat([original, torch.full((1, 2, 4), 999.0)], dim=1)
+
+    unpadded = latent_ops.unpad_audio_latents(padded, 10)
+    unpacked = latent_ops.unpack_audio_latents(unpadded, num_mel_bins=2)
+    expected = latent_ops.unpack_audio_latents(original, num_mel_bins=2)
+
+    assert unpacked.shape == (1, 2, 10, 2)
+    assert not (unpacked == 999.0).any()
+    torch.testing.assert_close(unpacked, expected)
+
+
+def test_prepare_audio_latents_accepts_already_padded_4d_latents_for_sp():
+    pipeline = _make_pipeline(LTX2Pipeline, sequence_parallel_size=4)
+    pipeline.preserve_sp_padded_audio_duration = True
+    latents = torch.arange(96, dtype=torch.float32).view(1, 2, 12, 4)
+
+    audio_latent_length = pipeline._resolve_audio_latent_length(10, latents)
+    padded, original_num_frames, padded_num_frames = pipeline.prepare_audio_latents(
+        batch_size=1,
+        num_channels_latents=2,
+        num_mel_bins=16,
+        audio_latent_length=audio_latent_length,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+        latents=latents,
+    )
+
+    assert audio_latent_length == 10
+    assert original_num_frames == 10
+    assert padded_num_frames == 12
+    assert padded.shape == (1, 12, 8)
+    torch.testing.assert_close(padded, latent_ops.pack_audio_latents(latents))
+
+
+def test_resolve_audio_latent_length_preserves_legacy_4d_shape_inference():
+    pipeline = _make_pipeline(LTX2Pipeline, sequence_parallel_size=4)
+    latents = torch.zeros(1, 2, 13, 4)
+
+    audio_latent_length = pipeline._resolve_audio_latent_length(10, latents)
+
+    assert audio_latent_length == 13
+
+
+def test_prepare_audio_latents_rejects_incompatible_provided_length():
+    pipeline = _make_pipeline(LTX2Pipeline, sequence_parallel_size=4)
+    latents = torch.zeros(1, 11, 4)
+
+    with pytest.raises(ValueError, match="incompatible audio frame count"):
+        pipeline.prepare_audio_latents(
+            batch_size=1,
+            num_channels_latents=2,
+            num_mel_bins=8,
+            audio_latent_length=10,
+            dtype=torch.float32,
+            device=torch.device("cpu"),
+            latents=latents,
+        )
diff --git a/tests/diffusion/models/ltx2/test_ltx2_3_forward_parallel.py b/tests/diffusion/models/ltx2/test_ltx2_parallel.py
similarity index 57%
rename from tests/diffusion/models/ltx2/test_ltx2_3_forward_parallel.py
rename to tests/diffusion/models/ltx2/test_ltx2_parallel.py
index 3e592f14b..8d8c22e79 100644
--- a/tests/diffusion/models/ltx2/test_ltx2_3_forward_parallel.py
+++ b/tests/diffusion/models/ltx2/test_ltx2_parallel.py
@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""Unit tests for LTX-2.3 forward-parallel behavior."""
+"""Unit tests for LTX guidance and forward-parallel behavior."""
 
+from contextlib import nullcontext
 from types import SimpleNamespace
 
 import pytest
@@ -11,31 +12,13 @@ import torch
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
-class TestCFGParallelIntegration:
-    def test_ltx23_pipeline_has_cfg_parallel_mixin(self):
-        """LTX23Pipeline must use the shared CFG parallel implementation."""
-        from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-
-        assert issubclass(LTX23Pipeline, CFGParallelMixin)
-
-    def test_ltx2_transformer_has_dit_cache_config(self):
-        """Ensure LTX2 has a Cache DiT adapter config and that it uses separate CFG."""
-        from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
-        from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel
-
-        adapter_config = getattr(LTX2VideoTransformer3DModel, "_cache_dit_adapter_config")
-        assert isinstance(adapter_config, CacheDiTAdapterConfig)
-        assert adapter_config.has_separate_cfg
-
-
 class TestCFGParallelHelpers:
     """Test LTX-2.3 CFG helper math without loading model weights."""
 
     def test_combine_cfg_noise_matches_x0_space_formula(self):
-        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
 
-        pipe = object.__new__(LTX23Pipeline)
+        pipe = object.__new__(LTX2Pipeline)
         video_sample = torch.tensor([[[1.0, -2.0]]])
         audio_sample = torch.tensor([[[0.5, 3.0]]])
         video_pos = torch.tensor([[[0.2, -0.3]]])
@@ -68,89 +51,208 @@ class TestCFGParallelHelpers:
         assert torch.allclose(video_combined, expected_video)
         assert torch.allclose(audio_combined, expected_audio)
 
-    def test_two_rank_cfg_parallel_smoke_uses_rank_local_branch_and_x0_formula(self, monkeypatch):
-        from vllm_omni.diffusion.models.ltx2 import pipeline_ltx2_3 as ltx23
+    @pytest.mark.parametrize("guidance_world_size", [1, 2, 3, 4])
+    def test_guidance_parallel_accepts_official_guidance(self, guidance_world_size):
+        from vllm_omni.diffusion.models.ltx2.ltx2_guidance import (
+            LTX_GUIDANCE_EXECUTOR,
+            LTXGuidancePlan,
+        )
+        from vllm_omni.diffusion.models.ltx2.ltx2_recipes import LTX23_ONE_STAGE_RECIPE
 
-        pipe = object.__new__(ltx23.LTX23Pipeline)
-        video_sample = torch.tensor([[[1.0, -2.0]]])
-        audio_sample = torch.tensor([[[0.5, 3.0, -1.0]]])
-        video_pos = torch.tensor([[[0.2, -0.3]]])
-        video_neg = torch.tensor([[[-0.4, 0.1]]])
-        audio_pos = torch.tensor([[[0.7, -0.2, 0.3]]])
-        audio_neg = torch.tensor([[[0.1, 0.4, -0.5]]])
-        video_sigma = torch.tensor(0.25)
-        audio_sigma = torch.tensor(0.5)
-        scale = 4.0
+        plan = LTXGuidancePlan.build(LTX23_ONE_STAGE_RECIPE.request_guidance)
+
+        LTX_GUIDANCE_EXECUTOR.validate_guidance_world_size(plan, guidance_world_size)
+
+    def test_guidance_parallel_dummy_warms_full_guidance_plan(self, monkeypatch):
+        from vllm_omni.diffusion.models.ltx2 import ltx2_runtime
+        from vllm_omni.diffusion.models.ltx2.ltx2_recipes import LTX23_ONE_STAGE_RECIPE
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        monkeypatch.setattr(ltx2_runtime, "get_guidance_parallel_world_size", lambda: 2)
+        pipe = object.__new__(LTX2Pipeline)
+        req = SimpleNamespace(is_dummy_run=lambda: True)
+        request_inputs = SimpleNamespace(guidance=LTX23_ONE_STAGE_RECIPE.request_guidance)
+
+        guidance_parallel_ready = pipe._setup_forward_runtime(req, request_inputs, attention_kwargs=None)
+
+        assert guidance_parallel_ready is True
+        assert pipe._guidance_plan.names == ("cond", "uncond", "ptb", "mod")
+        assert pipe._guidance_plan.spec.video.cfg_scale == 3.0
+        assert pipe._guidance_plan.spec.audio.cfg_scale == 7.0
+
+    def test_guidance_parallel_warns_for_imbalanced_passes(self, monkeypatch):
+        from vllm_omni.diffusion.models.ltx2 import ltx2_guidance
+
+        spec = ltx2_guidance.LTXGuidanceSpec(
+            video=ltx2_guidance.LTXModalityGuidance(
+                cfg_scale=3.0,
+                stg_scale=1.0,
+                stg_blocks=(1,),
+            )
+        )
+        plan = ltx2_guidance.LTXGuidancePlan.build(spec)
+        captured = []
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_rank", lambda: 0)
+        monkeypatch.setattr(ltx2_guidance.logger, "warning_once", lambda *args: captured.append(args))
+
+        ltx2_guidance.LTX_GUIDANCE_EXECUTOR.warn_if_imbalanced(plan, 4, "hq_generate")
+
+        assert plan.names == ("cond", "uncond", "ptb")
+        assert len(captured) == 1
+        assert captured[0][1:] == ("hq_generate", 3, 4, 1, 75.0)
+
+    @pytest.mark.parametrize("guidance_rank", [0, 1])
+    def test_default_guidance_is_sharded_and_combined(self, monkeypatch, guidance_rank):
+        from vllm_omni.diffusion.models.ltx2 import ltx2_guidance
+        from vllm_omni.diffusion.models.ltx2.ltx2_denoise import LTXDenoiseContext
+        from vllm_omni.diffusion.models.ltx2.ltx2_latents import LTXAVState
+        from vllm_omni.diffusion.models.ltx2.ltx2_recipes import LTX23_ONE_STAGE_RECIPE
+
+        executor = ltx2_guidance.LTX_GUIDANCE_EXECUTOR
+        plan = ltx2_guidance.LTXGuidancePlan.build(LTX23_ONE_STAGE_RECIPE.request_guidance)
+        video_predictions = {
+            "cond": torch.tensor([[[0.2, -0.3]]]),
+            "uncond": torch.tensor([[[-0.4, 0.1]]]),
+            "ptb": torch.tensor([[[0.5, -0.2]]]),
+            "mod": torch.tensor([[[-0.1, 0.6]]]),
+        }
+        audio_predictions = {
+            "cond": torch.tensor([[[0.7, -0.2]]]),
+            "uncond": torch.tensor([[[0.1, 0.4]]]),
+            "ptb": torch.tensor([[[-0.3, 0.2]]]),
+            "mod": torch.tensor([[[0.4, -0.5]]]),
+        }
+        state = LTXAVState(
+            video=torch.tensor([[[1.0, -2.0]]]),
+            audio=torch.tensor([[[0.5, 3.0]]]),
+        )
+        denoise_ctx = LTXDenoiseContext(
+            latents=state.video,
+            audio_latents=state.audio,
+            video_coords=torch.zeros(1, 1, 3),
+            audio_coords=torch.zeros(1, 1, 1),
+        )
+        executor.prepare_denoise_context(plan, True, 2, denoise_ctx)
+
+        class FakeGuidanceGroup:
+            def __init__(self):
+                self.call_index = 0
 
-        class FakeCfgGroup:
             def all_gather(self, tensor, separate_tensors=True):
                 assert separate_tensors
-                if tensor.shape == video_pos.shape:
-                    return [video_pos, video_neg]
-                return [audio_pos, audio_neg]
+                gathered = (
+                    [video_predictions["cond"], video_predictions["uncond"]],
+                    [video_predictions["ptb"], video_predictions["mod"]],
+                    [audio_predictions["cond"], audio_predictions["uncond"]],
+                    [audio_predictions["ptb"], audio_predictions["mod"]],
+                )[self.call_index]
+                torch.testing.assert_close(tensor, gathered[guidance_rank])
+                self.call_index += 1
+                return gathered
 
-        monkeypatch.setattr(ltx23, "get_classifier_free_guidance_world_size", lambda: 2)
-        monkeypatch.setattr(ltx23, "get_cfg_group", lambda: FakeCfgGroup())
+        group = FakeGuidanceGroup()
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_world_size", lambda: 2)
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_rank", lambda: guidance_rank)
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_group", lambda: group)
 
-        expected_video = ltx23.LTX23Pipeline._combine_x0_space_cfg(
-            video_sample,
-            video_pos,
-            video_neg,
+        local_names = ("cond", "ptb") if guidance_rank == 0 else ("uncond", "mod")
+        captured = {}
+
+        class FakeTransformer:
+            def __call__(self, **kwargs):
+                captured.update(kwargs)
+                return (
+                    torch.cat([video_predictions[name] for name in local_names]),
+                    torch.cat([audio_predictions[name] for name in local_names]),
+                )
+
+        video_sigma = torch.tensor(0.25)
+        audio_sigma = torch.tensor(0.5)
+
+        class FakePipeline:
+            scheduler = SimpleNamespace(sigmas=torch.stack([video_sigma]))
+            transformer = FakeTransformer()
+
+            @staticmethod
+            def _transformer_cache_context(name):
+                assert name == "guided"
+                return nullcontext()
+
+            @staticmethod
+            def _build_transformer_kwargs(forward_ctx, denoise_ctx, **kwargs):
+                del forward_ctx, denoise_ctx
+                return kwargs
+
+            @staticmethod
+            def _video_guidance_model_sigma(sigma, denoise_ctx):
+                del denoise_ctx
+                return sigma
+
+        positive_context = torch.ones(1, 1, 1)
+        negative_context = torch.zeros(1, 1, 1)
+        forward_ctx = SimpleNamespace(
+            prompt_context=SimpleNamespace(
+                positive_connector_prompt_embeds=positive_context,
+                positive_connector_audio_prompt_embeds=positive_context,
+                negative_connector_prompt_embeds=negative_context,
+                negative_connector_audio_prompt_embeds=negative_context,
+            ),
+            attention_kwargs=None,
+            audio_scheduler=SimpleNamespace(sigmas=torch.stack([audio_sigma])),
+        )
+
+        actual_video, actual_audio = executor.predict_parallel_guidance(
+            FakePipeline(),
+            plan,
+            index=0,
+            timestep=torch.tensor(1.0),
+            state=state,
+            forward_ctx=forward_ctx,
+            denoise_ctx=denoise_ctx,
+        )
+
+        expected_video = executor._guide_modality(
+            state.video,
+            video_predictions,
             video_sigma,
-            scale,
+            plan.spec.video,
         )
-        expected_audio = ltx23.LTX23Pipeline._combine_x0_space_cfg(
-            audio_sample,
-            audio_pos,
-            audio_neg,
+        expected_audio = executor._guide_modality(
+            state.audio,
+            audio_predictions,
             audio_sigma,
-            scale,
+            plan.spec.audio,
         )
-
-        for rank, expected_branch in ((0, "positive"), (1, "negative")):
-            calls = []
-            monkeypatch.setattr(ltx23, "get_classifier_free_guidance_rank", lambda rank=rank: rank)
-
-            def fake_predict_noise(**kwargs):
-                calls.append(kwargs["branch"])
-                if kwargs["branch"] == "positive":
-                    return video_pos, audio_pos
-                return video_neg, audio_neg
-
-            object.__setattr__(pipe, "predict_noise", fake_predict_noise)
-            video_combined, audio_combined = pipe.predict_noise_with_parallel_cfg(
-                true_cfg_scale=scale,
-                positive_kwargs={"branch": "positive"},
-                negative_kwargs={"branch": "negative"},
-                cfg_normalize=False,
-                video_latents=video_sample,
-                audio_latents=audio_sample,
-                video_sigma=video_sigma,
-                audio_sigma=audio_sigma,
-            )
-
-            assert calls == [expected_branch]
-            torch.testing.assert_close(video_combined, expected_video)
-            torch.testing.assert_close(audio_combined, expected_audio)
-
-        assert "_cfg_video_latents" not in pipe.__dict__
-        assert "_cfg_audio_latents" not in pipe.__dict__
+        torch.testing.assert_close(actual_video, expected_video)
+        torch.testing.assert_close(actual_audio, expected_audio)
+        assert group.call_index == 4
+        assert captured["hidden_states"].shape[0] == 2
+        perturbations = captured["attention_kwargs"]["ltx_perturbation_kwargs"]
+        if guidance_rank == 0:
+            assert "video_self_attention_mask" in perturbations
+            assert "a2v_cross_attention_mask" not in perturbations
+        else:
+            assert "video_self_attention_mask" not in perturbations
+            assert "a2v_cross_attention_mask" in perturbations
 
 
 class TestCFGParallelForwardPath:
     """Test the LTX-2.3 CFG-parallel denoising path without loading model weights."""
 
     def test_forward_collates_request_prompt_embeds_and_mask_aliases(self, monkeypatch):
-        from vllm_omni.diffusion.models.ltx2 import pipeline_ltx2_3 as ltx23
+        from vllm_omni.diffusion.models.ltx2 import ltx2_runtime
+        from vllm_omni.diffusion.models.ltx2 import pipeline_ltx2 as ltx23
         from vllm_omni.diffusion.request import OmniDiffusionRequest
         from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
         from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
-        pipe = object.__new__(ltx23.LTX23Pipeline)
+        pipe = object.__new__(ltx23.LTX2Pipeline)
         torch.nn.Module.__init__(pipe)
         pipe.device = torch.device("cpu")
         pipe.tokenizer_max_length = 4
-        monkeypatch.setattr(ltx23, "get_classifier_free_guidance_world_size", lambda: 1)
+        pipe.vae_spatial_compression_ratio = 32
+        pipe.vae_temporal_compression_ratio = 8
+        monkeypatch.setattr(ltx2_runtime, "get_guidance_parallel_world_size", lambda: 1)
 
         class StopAtEncodePromptError(Exception):
             pass
@@ -238,7 +340,7 @@ class TestCFGParallelForwardPath:
         ("frame_rate_input", "audio_sampling_rate", "expected_frame_rate"),
         [(1.0, 1, 1.0), (None, 24, 24.0)],
     )
-    def test_forward_cfg_parallel_steps_video_and_audio_scheduler(
+    def test_forward_cfg_parallel_uses_shared_video_audio_euler_step(
         self,
         monkeypatch,
         cfg_rank,
@@ -247,12 +349,13 @@ class TestCFGParallelForwardPath:
         audio_sampling_rate,
         expected_frame_rate,
     ):
-        from vllm_omni.diffusion.models.ltx2 import pipeline_ltx2_3 as ltx23
+        from vllm_omni.diffusion.models.ltx2 import ltx2_denoise, ltx2_guidance, ltx2_runtime
+        from vllm_omni.diffusion.models.ltx2 import pipeline_ltx2 as ltx23
         from vllm_omni.diffusion.request import OmniDiffusionRequest
         from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
         from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
-        pipe = object.__new__(ltx23.LTX23Pipeline)
+        pipe = object.__new__(ltx23.LTX2Pipeline)
         torch.nn.Module.__init__(pipe)
         pipe.device = torch.device("cpu")
         pipe.tokenizer_max_length = 1
@@ -291,15 +394,16 @@ class TestCFGParallelForwardPath:
                     return [audio_pos, audio_neg]
                 raise AssertionError(f"Unexpected gathered tensor: {tensor}")
 
-        monkeypatch.setattr(ltx23, "get_classifier_free_guidance_world_size", lambda: 2)
-        monkeypatch.setattr(ltx23, "get_classifier_free_guidance_rank", lambda: cfg_rank)
-        monkeypatch.setattr(ltx23, "get_cfg_group", lambda: FakeCfgGroup())
+        monkeypatch.setattr(ltx2_runtime, "get_guidance_parallel_world_size", lambda: 2)
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_world_size", lambda: 2)
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_rank", lambda: cfg_rank)
+        monkeypatch.setattr(ltx2_guidance, "get_guidance_parallel_group", lambda: FakeCfgGroup())
 
         def fake_retrieve_timesteps(scheduler, num_inference_steps, device, timesteps, sigmas=None, mu=None):
             scheduler.sigmas = torch.tensor([0.25, 0.25], device=device)
             return torch.tensor([1.0, 0.5], device=device), 2
 
-        monkeypatch.setattr(ltx23, "retrieve_timesteps", fake_retrieve_timesteps)
+        monkeypatch.setattr(ltx2_denoise, "retrieve_timesteps", fake_retrieve_timesteps)
 
         class FakeScheduler:
             def __init__(self, name="video", calls=None):
@@ -326,7 +430,7 @@ class TestCFGParallelForwardPath:
 
             def __call__(self, prompt_embeds, prompt_attention_mask, padding_side):
                 assert padding_side == "left"
-                assert prompt_embeds.shape[0] == 2
+                assert prompt_embeds.shape[0] == 1
                 return prompt_embeds, prompt_embeds, prompt_attention_mask
 
         rope_video_fps: list[float] = []
@@ -392,7 +496,16 @@ class TestCFGParallelForwardPath:
                 num_frames=1,
                 frame_rate=frame_rate_input,
                 num_inference_steps=2,
-                guidance_scale=4.0,
+                extra_args={
+                    "video_cfg_scale": 3.0,
+                    "audio_cfg_scale": 7.0,
+                    "video_stg_scale": 0.0,
+                    "audio_stg_scale": 0.0,
+                    "video_modality_scale": 1.0,
+                    "audio_modality_scale": 1.0,
+                    "video_rescale_scale": 0.0,
+                    "audio_rescale_scale": 0.0,
+                },
                 latents=video_latents,
                 audio_latents=audio_latents,
                 output_type="latent",
@@ -400,35 +513,31 @@ class TestCFGParallelForwardPath:
             request_id="ltx23-cfg-parallel-forward-test",
         )
 
-        output = pipe.forward(DiffusionRequestBatch(requests=[req]))[0]
+        output = pipe.forward(DiffusionRequestBatch(requests=[req]), sigmas=[0.25, 0.25])[0]
 
-        expected_video_noise = ltx23.LTX23Pipeline._combine_x0_space_cfg(
+        expected_video_noise = ltx2_guidance.combine_velocity_via_x0(
             video_latents,
             video_pos,
             video_neg,
             pipe.scheduler.sigmas[0],
-            4.0,
+            3.0,
         )
-        expected_audio_noise = ltx23.LTX23Pipeline._combine_x0_space_cfg(
+        expected_audio_noise = ltx2_guidance.combine_velocity_via_x0(
             audio_latents,
             audio_pos,
             audio_neg,
             pipe.scheduler.sigmas[0],
-            4.0,
+            7.0,
         )
-        scheduler_call_names = [call[0] for call in pipe.scheduler.calls]
-        assert scheduler_call_names == ["video", "audio", "video", "audio"]
+        assert pipe.scheduler.calls == []
         assert len(pipe.transformer.calls) == 2
-        torch.testing.assert_close(pipe.scheduler.calls[0][1], expected_video_noise)
-        torch.testing.assert_close(pipe.scheduler.calls[1][1], expected_audio_noise)
-        torch.testing.assert_close(pipe.scheduler.calls[2][1], expected_video_noise)
-        torch.testing.assert_close(pipe.scheduler.calls[3][1], expected_audio_noise)
-        torch.testing.assert_close(pipe.scheduler.calls[2][3], video_latents - expected_video_noise)
-        torch.testing.assert_close(pipe.scheduler.calls[3][3], audio_latents - expected_audio_noise)
 
         video_out, audio_out = output.output
-        torch.testing.assert_close(video_out, (video_latents - 2 * expected_video_noise).reshape(1, 2, 1, 1, 1))
-        torch.testing.assert_close(audio_out, (audio_latents - 2 * expected_audio_noise).reshape(1, 1, 1, 2))
+        sigma_delta = pipe.scheduler.sigmas[-1] - pipe.scheduler.sigmas[0]
+        expected_video = video_latents + expected_video_noise * sigma_delta
+        expected_audio = audio_latents + expected_audio_noise * sigma_delta
+        torch.testing.assert_close(video_out, expected_video.reshape(1, 2, 1, 1, 1))
+        torch.testing.assert_close(audio_out, expected_audio.reshape(1, 1, 1, 2))
 
         # fps regression guard: an omitted request fps (frame_rate_input=None) must resolve
         # to the model's own 24.0 default, not crash on None; a provided rate is passed through.
diff --git a/tests/diffusion/models/ltx2/test_ltx2_pipeline.py b/tests/diffusion/models/ltx2/test_ltx2_pipeline.py
new file mode 100644
index 000000000..d70820f41
--- /dev/null
+++ b/tests/diffusion/models/ltx2/test_ltx2_pipeline.py
@@ -0,0 +1,1629 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Unit tests for the shared LTX pipeline runtime and public contracts."""
+
+import json
+import os
+import tempfile
+from dataclasses import replace
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.models.ltx2 import ltx2_components
+from vllm_omni.diffusion.models.ltx2.ltx2_components import (
+    LTX2_COMPONENT_PROFILE,
+    LTX2_DISTILLED_COMPONENT_PROFILE,
+    LTX23_COMPONENT_PROFILE,
+    _install_connector_attention,
+    detect_ltx_model_version,
+)
+from vllm_omni.diffusion.models.ltx2.ltx2_conditioning import LTXI2VConditioningMixin
+from vllm_omni.diffusion.models.ltx2.ltx2_denoise import (
+    LTXDenoiseExecutor,
+    LTXPhaseResult,
+    _official_ltx_sigmas,
+    prepare_scheduler_stage,
+)
+from vllm_omni.diffusion.models.ltx2.ltx2_guidance import (
+    LTX_GUIDANCE_EXECUTOR,
+    LTXGuidancePlan,
+    LTXGuidanceSpec,
+    LTXModalityGuidance,
+    build_perturbation_kwargs,
+    combine_guided_x0,
+)
+from vllm_omni.diffusion.models.ltx2.ltx2_latents import LTXAVState
+from vllm_omni.diffusion.models.ltx2.ltx2_recipes import (
+    LTX2_DISTILLED_TWO_STAGE_RECIPE,
+    LTX2_ONE_STAGE_RECIPE,
+    LTX23_ONE_STAGE_RECIPE,
+    LTX_DEFAULT_NEGATIVE_PROMPT,
+    LTX_POSITIVE_ONLY_RECIPE,
+)
+from vllm_omni.diffusion.models.ltx2.ltx2_request import LTXRequestInputs, validate_pipeline_request
+from vllm_omni.diffusion.models.ltx2.ltx2_runtime import LTXRuntime
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import (
+    LTX2I2VDMD2Pipeline,
+    LTX2Pipeline,
+    LTX2T2VDMD2Pipeline,
+)
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_two_stage import LTX2DistilledPipeline
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_ltx_request_pipe(cls):
+    pipe = object.__new__(cls)
+    torch.nn.Module.__init__(pipe)
+    pipe.device = torch.device("cpu")
+    pipe.tokenizer_max_length = 99
+    pipe.vae_spatial_compression_ratio = 32
+    pipe.vae_temporal_compression_ratio = 8
+    return pipe
+
+
+def _resolve_request_inputs_for_test(
+    pipe,
+    req,
+    *,
+    guidance_scale=4.0,
+    negative_prompt=None,
+):
+    return pipe._resolve_request_inputs(
+        req,
+        prompt=None,
+        negative_prompt=negative_prompt,
+        height=None,
+        width=None,
+        num_frames=None,
+        frame_rate=None,
+        num_inference_steps=None,
+        guidance_scale=guidance_scale,
+        num_videos_per_prompt=1,
+        generator=None,
+        latents=None,
+        audio_latents=None,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        prompt_attention_mask=None,
+        negative_prompt_attention_mask=None,
+        decode_timestep=0.0,
+        decode_noise_scale=None,
+        output_type="np",
+        max_sequence_length=None,
+    )
+
+
+def test_ltx_public_entries_share_runtime_and_keep_recipe_boundaries():
+    from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 import (
+        DistributedAutoencoderKLLTX2Video,
+    )
+
+    assert issubclass(LTX2Pipeline, LTXRuntime)
+    assert issubclass(LTX2DistilledPipeline, LTXRuntime)
+    assert LTX2Pipeline.component_profile is LTX2_COMPONENT_PROFILE
+    assert LTX2Pipeline.pipeline_recipe is LTX2_ONE_STAGE_RECIPE
+    assert LTX2DistilledPipeline.component_profile is LTX2_DISTILLED_COMPONENT_PROFILE
+    assert LTX2_COMPONENT_PROFILE.video_vae_cls is DistributedAutoencoderKLLTX2Video
+    assert LTX23_COMPONENT_PROFILE.video_vae_cls is DistributedAutoencoderKLLTX2Video
+
+
+def test_ltx_checkpoint_version_detection_uses_metadata(tmp_path):
+    (tmp_path / "model_index.json").write_text(json.dumps({"vocoder": ["ltx2", "LTX2VocoderWithBWE"]}))
+    assert detect_ltx_model_version(str(tmp_path)) == "2.3"
+
+    (tmp_path / "model_index.json").write_text(json.dumps({"model_version": "2.3.1"}))
+    assert detect_ltx_model_version(str(tmp_path)) == "2.3"
+
+    (tmp_path / "model_index.json").write_text(json.dumps({"vocoder": ["ltx2", "LTX2Vocoder"]}))
+    assert detect_ltx_model_version(str(tmp_path)) == "2"
+
+
+def test_ltx23_checkpoint_selects_version_specific_one_stage_profile(tmp_path, monkeypatch):
+    from vllm_omni.diffusion.models.ltx2 import ltx2_runtime
+
+    (tmp_path / "model_index.json").write_text(json.dumps({"vocoder": ["ltx2", "LTX2VocoderWithBWE"]}))
+
+    def stub_components(pipe, od_config):
+        pipe.od_config = od_config
+        pipe.vae_spatial_compression_ratio = 32
+
+    monkeypatch.setattr(ltx2_runtime, "initialize_pipeline_components", stub_components)
+    monkeypatch.setattr(LTXRuntime, "setup_diffusion_pipeline_profiler", lambda *_args, **_kwargs: None)
+
+    pipe = LTX2Pipeline(od_config=SimpleNamespace(model=str(tmp_path), enable_diffusion_pipeline_profiler=False))
+
+    assert pipe.model_version == "2.3"
+    assert pipe.component_profile is LTX23_COMPONENT_PROFILE
+    assert pipe.pipeline_recipe is LTX23_ONE_STAGE_RECIPE
+    assert pipe.preserve_sp_padded_audio_duration
+    assert pipe.reports_stage_durations
+
+
+def test_ltx_one_stage_entry_exposes_batch_image_and_distributed_decode_contracts():
+    assert LTX2Pipeline.supports_request_batch
+    assert LTX2Pipeline.support_image_input
+    assert LTX2Pipeline.unified_text_image_entry
+    assert LTX2Pipeline.distributed_video_decode
+    assert not LTX2DistilledPipeline.supports_request_batch
+    assert LTX2DistilledPipeline.support_image_input
+    assert LTX2DistilledPipeline.unified_text_image_entry
+
+
+def test_ltx_dmd2_entries_retain_their_task_boundaries():
+    assert not LTX2T2VDMD2Pipeline.support_image_input
+    assert LTX2I2VDMD2Pipeline.support_image_input
+    assert not LTX2I2VDMD2Pipeline.unified_text_image_entry
+
+
+def test_ltx_request_batch_decode_splits_video_and_audio_per_request():
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    requests = [
+        OmniDiffusionRequest(
+            prompt=f"prompt-{index}",
+            sampling_params=OmniDiffusionSamplingParams(),
+            request_id=f"request-{index}",
+        )
+        for index in range(2)
+    ]
+    request_batch = DiffusionRequestBatch(requests)
+    video = torch.tensor([[1.0], [2.0]])
+    audio = torch.tensor([[3.0], [4.0]])
+    pipe = object.__new__(LTX2Pipeline)
+    torch.nn.Module.__init__(pipe)
+    object.__setattr__(pipe, "_decode_output", lambda **_kwargs: DiffusionOutput(output=(video, audio)))
+    forward_ctx = SimpleNamespace(
+        req=request_batch,
+        request_inputs=SimpleNamespace(
+            output_type="np",
+            generator=None,
+            decode_timestep=0.0,
+            decode_noise_scale=None,
+        ),
+        prompt_context=SimpleNamespace(connector_prompt_embeds=torch.empty(2, 1)),
+        device=torch.device("cpu"),
+        batch_size=2,
+        num_videos_per_prompt=1,
+    )
+
+    outputs = pipe.decode_phase(
+        LTXPhaseResult(
+            forward_context=forward_ctx,
+            video=video,
+            audio=audio,
+        )
+    )
+
+    assert len(outputs) == 2
+    torch.testing.assert_close(outputs[0].output[0], video[:1])
+    torch.testing.assert_close(outputs[0].output[1], audio[:1])
+    torch.testing.assert_close(outputs[1].output[0], video[1:])
+    torch.testing.assert_close(outputs[1].output[1], audio[1:])
+
+
+def test_ltx_public_entries_share_runtime_forward_template():
+    assert "_forward_request" not in LTX2Pipeline.__dict__
+    assert "forward" not in LTX2Pipeline.__dict__
+    assert LTX2Pipeline._forward_request is LTXRuntime._forward_request
+    assert LTX2Pipeline._run_recipe is LTXRuntime._run_recipe
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "field_name"),
+    [
+        ({"timesteps": [1]}, "timesteps"),
+        ({"guidance_rescale": 0.5}, "guidance_rescale"),
+        ({"noise_scale": 1.0}, "noise_scale"),
+        ({"return_dict": False}, "return_dict"),
+        ({"attention_kwargs": {}}, "attention_kwargs"),
+    ],
+)
+def test_ltx_public_forward_rejects_unsupported_generic_options(kwargs, field_name):
+    pipe = object.__new__(LTX2Pipeline)
+
+    with pytest.raises(ValueError, match=field_name):
+        pipe.forward(SimpleNamespace(), **kwargs)
+
+
+def test_ltx2_canonical_forward_requires_keyword_arguments():
+    pipe = object.__new__(LTX2Pipeline)
+
+    with pytest.raises(TypeError):
+        pipe.forward(SimpleNamespace(), "prompt")
+
+
+def test_ltx_versions_share_request_prompt_and_step_templates():
+    shared_methods = (
+        "_get_gemma_prompt_embeds",
+        "encode_prompt",
+        "check_inputs",
+        "_resolve_request_inputs",
+        "_prepare_prompt_context",
+        "_denoise_step",
+    )
+    for method_name in shared_methods:
+        base_method = getattr(LTXRuntime, method_name)
+        assert getattr(LTX2Pipeline, method_name) is base_method
+
+
+def test_ltx_versions_select_guidance_without_overriding_control_flow():
+    assert LTX2Pipeline.guidance_executor is LTX_GUIDANCE_EXECUTOR
+    assert LTX2Pipeline._predict_noise_for_step is LTXRuntime._predict_noise_for_step
+    assert LTX2Pipeline.combine_cfg_noise is LTXRuntime.combine_cfg_noise
+
+
+def test_ltx_official_recipes_build_all_guidance_passes():
+    ltx2_plan = LTXGuidancePlan.build(LTX2_ONE_STAGE_RECIPE.request_guidance)
+    ltx23_plan = LTXGuidancePlan.build(LTX23_ONE_STAGE_RECIPE.request_guidance)
+
+    assert ltx2_plan.names == ltx23_plan.names == ("cond", "uncond", "ptb", "mod")
+    assert LTX2_ONE_STAGE_RECIPE.request_guidance.video.stg_blocks == (29,)
+    assert LTX23_ONE_STAGE_RECIPE.request_guidance.video.stg_blocks == (28,)
+    assert LTX23_ONE_STAGE_RECIPE.request_guidance.video.cfg_scale == 3.0
+    assert LTX23_ONE_STAGE_RECIPE.request_guidance.audio.cfg_scale == 7.0
+    assert LTX2_ONE_STAGE_RECIPE.phases[0].use_official_sigma_schedule
+    assert LTX23_ONE_STAGE_RECIPE.phases[0].use_official_sigma_schedule
+    assert not LTX_POSITIVE_ONLY_RECIPE.phases[0].use_official_sigma_schedule
+
+
+def test_ltx_guidance_combines_official_x0_deltas_in_fp32():
+    cond = torch.tensor([[1.0, 3.0]], dtype=torch.bfloat16)
+    uncond = torch.tensor([[0.0, 1.0]], dtype=torch.bfloat16)
+    perturbed = torch.tensor([[0.5, 2.0]], dtype=torch.bfloat16)
+    isolated = torch.tensor([[0.25, 2.5]], dtype=torch.bfloat16)
+    guidance = LTXModalityGuidance(
+        cfg_scale=3.0,
+        stg_scale=0.5,
+        modality_scale=2.0,
+        stg_blocks=(0,),
+    )
+
+    actual = combine_guided_x0(
+        cond=cond,
+        uncond_text=uncond,
+        uncond_perturbed=perturbed,
+        uncond_modality=isolated,
+        guidance=guidance,
+    )
+    expected = (
+        cond.float()
+        + 2.0 * (cond.float() - uncond.float())
+        + 0.5 * (cond.float() - perturbed.float())
+        + (cond.float() - isolated.float())
+    ).to(cond.dtype)
+
+    torch.testing.assert_close(actual, expected)
+
+
+def test_ltx_guidance_skips_stg_without_perturbed_blocks():
+    cond = torch.tensor([[[1.0, 2.0], [3.0, 4.0]]])
+    guidance = LTXModalityGuidance(stg_scale=1.0, stg_blocks=())
+
+    plan = LTXGuidancePlan.build(LTXGuidanceSpec(video=guidance))
+    actual = combine_guided_x0(
+        cond=cond,
+        uncond_text=0.0,
+        uncond_perturbed=0.0,
+        uncond_modality=0.0,
+        guidance=guidance,
+    )
+
+    assert plan.names == ("cond",)
+    torch.testing.assert_close(actual, cond)
+
+
+def test_ltx_guidance_uses_official_close_to_disabled_semantics():
+    guidance = LTXModalityGuidance(
+        cfg_scale=1.0 + 1e-10,
+        stg_scale=0.0,
+        modality_scale=1.0 + 1e-10,
+        stg_blocks=(0,),
+    )
+
+    assert LTXGuidancePlan.build(LTXGuidanceSpec(video=guidance)).names == ("cond",)
+
+
+def test_ltx_guidance_rescale_is_invariant_to_request_batching():
+    cond = torch.tensor(
+        [
+            [[1.0, 2.0], [3.0, 4.0]],
+            [[10.0, 30.0], [50.0, 70.0]],
+        ]
+    )
+    uncond = torch.stack((torch.zeros_like(cond[0]), cond[1]))
+    guidance = LTXModalityGuidance(cfg_scale=2.0, rescale_scale=1.0)
+
+    actual = combine_guided_x0(
+        cond=cond,
+        uncond_text=uncond,
+        uncond_perturbed=0.0,
+        uncond_modality=0.0,
+        guidance=guidance,
+    )
+    individually = torch.cat(
+        [
+            combine_guided_x0(
+                cond=cond[index : index + 1],
+                uncond_text=uncond[index : index + 1],
+                uncond_perturbed=0.0,
+                uncond_modality=0.0,
+                guidance=guidance,
+            )
+            for index in range(cond.shape[0])
+        ]
+    )
+
+    # Fusing independent requests must not change either request's output.
+    torch.testing.assert_close(actual, individually)
+
+
+def test_ltx_guidance_rescale_handles_zero_variance_prediction():
+    cond = torch.tensor([[[1.0, 2.0], [3.0, 4.0]]])
+    guidance = LTXModalityGuidance(cfg_scale=2.0, rescale_scale=1.0)
+
+    actual = combine_guided_x0(
+        cond=cond,
+        uncond_text=2 * cond,
+        uncond_perturbed=0.0,
+        uncond_modality=0.0,
+        guidance=guidance,
+    )
+
+    assert torch.isfinite(actual).all()
+    torch.testing.assert_close(actual, torch.zeros_like(cond))
+
+
+def test_ltx_guidance_builds_per_sample_stg_and_modality_masks():
+    plan = LTXGuidancePlan.build(LTX23_ONE_STAGE_RECIPE.request_guidance)
+    perturbations = build_perturbation_kwargs(plan, batch_size=2, reference=torch.ones(8, 1, 1))
+
+    assert perturbations["video_self_attention_blocks"] == (28,)
+    assert perturbations["audio_self_attention_blocks"] == (28,)
+    assert perturbations["video_self_attention_mask"].flatten().tolist() == [1, 1, 1, 1, 0, 0, 1, 1]
+    assert perturbations["a2v_cross_attention_mask"].flatten().tolist() == [1, 1, 1, 1, 1, 1, 0, 0]
+    torch.testing.assert_close(
+        perturbations["a2v_cross_attention_mask"],
+        perturbations["v2a_cross_attention_mask"],
+    )
+
+
+def test_ltx_default_sigma_schedule_matches_official_shift_and_stretch():
+    scheduler = SimpleNamespace(
+        config={
+            "base_image_seq_len": 1024,
+            "max_image_seq_len": 4096,
+            "base_shift": 0.95,
+            "max_shift": 2.05,
+            "shift_terminal": 0.1,
+        }
+    )
+
+    sigmas = _official_ltx_sigmas(scheduler, steps=4, device=torch.device("cpu"))
+
+    torch.testing.assert_close(
+        sigmas,
+        torch.tensor([1.0, 0.8671, 0.6316, 0.1, 0.0]),
+        rtol=1e-4,
+        atol=1e-4,
+    )
+
+
+def test_ltx_sigma_schedule_does_not_stretch_when_terminal_config_is_missing():
+    scheduler = SimpleNamespace(
+        config={
+            "base_image_seq_len": 1024,
+            "max_image_seq_len": 4096,
+            "base_shift": 0.95,
+            "max_shift": 2.05,
+        }
+    )
+
+    sigmas = _official_ltx_sigmas(scheduler, steps=4, device=torch.device("cpu"))
+
+    torch.testing.assert_close(
+        sigmas,
+        torch.tensor([1.0, 0.9589, 0.8859, 0.7214, 0.0]),
+        rtol=1e-4,
+        atol=1e-4,
+    )
+
+
+def test_ltx_sigma_schedule_does_not_stretch_when_terminal_is_disabled():
+    scheduler = SimpleNamespace(
+        config={
+            "base_image_seq_len": 1024,
+            "max_image_seq_len": 4096,
+            "base_shift": 0.95,
+            "max_shift": 2.05,
+            "shift_terminal": None,
+        }
+    )
+
+    sigmas = _official_ltx_sigmas(scheduler, steps=4, device=torch.device("cpu"))
+
+    torch.testing.assert_close(
+        sigmas,
+        torch.tensor([1.0, 0.9589, 0.8859, 0.7214, 0.0]),
+        rtol=1e-4,
+        atol=1e-4,
+    )
+
+
+def test_ltx_component_loader_installs_omni_connector_attention(monkeypatch):
+    installed = []
+    kernels = []
+
+    class OmniAttention:
+        def __init__(self, **kwargs):
+            kernels.append(kwargs)
+
+    class Attention:
+        heads = 32
+        head_dim = 128
+        inner_kv_dim = 4096
+
+        def set_processor(self, processor):
+            installed.append(processor)
+
+    monkeypatch.setattr(ltx2_components, "OmniAttention", OmniAttention)
+    connectors = SimpleNamespace(
+        video_connector=SimpleNamespace(
+            learnable_registers=object(),
+            transformer_blocks=[SimpleNamespace(attn1=Attention())],
+        ),
+        audio_connector=SimpleNamespace(
+            learnable_registers=object(),
+            transformer_blocks=[SimpleNamespace(attn1=Attention())],
+        ),
+    )
+
+    _install_connector_attention(connectors)
+
+    assert len(installed) == 2
+    assert all(processor.__class__.__name__ == "_LTXConnectorAttnProcessor" for processor in installed)
+    assert all(processor.has_learned_registers for processor in installed)
+    assert all(kernel["role"] == "ltx2.connector" for kernel in kernels)
+    assert all(kernel["role_category"] == "self" for kernel in kernels)
+    assert all(kernel["skip_sequence_parallel"] for kernel in kernels)
+    assert all(kernel["disable_kv_quant"] for kernel in kernels)
+
+
+@pytest.mark.parametrize("has_learned_registers", [False, True])
+def test_ltx_connector_attention_dispatches_through_omni_kernel(has_learned_registers):
+    calls = []
+
+    class Backend:
+        @staticmethod
+        def get_name():
+            return "FLASH_ATTN"
+
+    class OmniAttention:
+        attn_backend = Backend
+
+        def __call__(self, query, key, value, metadata):
+            calls.append((query, key, value, metadata))
+            return query
+
+    attention = SimpleNamespace(
+        heads=2,
+        head_dim=4,
+        inner_kv_dim=8,
+        norm_q=torch.nn.Identity(),
+        norm_k=torch.nn.Identity(),
+        to_q=torch.nn.Identity(),
+        to_k=torch.nn.Identity(),
+        to_v=torch.nn.Identity(),
+        to_out=(torch.nn.Identity(), torch.nn.Identity()),
+        to_gate_logits=None,
+        rope_type="split",
+        omni_attention=OmniAttention(),
+    )
+    hidden_states = torch.randn(2, 3, 8)
+    additive_mask = torch.zeros(2, 1, 3, 3)
+
+    output = ltx2_components._LTXConnectorAttnProcessor(has_learned_registers=has_learned_registers)(
+        attention,
+        hidden_states,
+        attention_mask=additive_mask,
+    )
+
+    query, key, value, metadata = calls[0]
+    assert query.shape == key.shape == value.shape == (2, 3, 2, 4)
+    if has_learned_registers:
+        assert metadata is None
+    else:
+        assert metadata.attn_mask.shape == (2, 3)
+        assert metadata.attn_mask.dtype == torch.bool
+        assert metadata.attn_mask.all()
+    torch.testing.assert_close(output, hidden_states)
+
+
+def test_ltx2_distilled_pipeline_shares_recipe_runtime():
+    assert issubclass(LTX2DistilledPipeline, LTXI2VConditioningMixin)
+    assert issubclass(LTX2DistilledPipeline, LTX2Pipeline)
+    assert LTX2DistilledPipeline._run_recipe is LTXRuntime._run_recipe
+    assert "_forward_request" not in LTX2DistilledPipeline.__dict__
+
+
+def test_ltx_variants_share_denoise_loop_and_i2v_conditioning():
+    assert "_denoise_loop" not in LTX2Pipeline.__dict__
+    assert issubclass(LTX2Pipeline, LTXI2VConditioningMixin)
+    assert LTX2Pipeline.prepare_latents is LTXI2VConditioningMixin.prepare_latents
+    assert LTX2Pipeline.prepare_audio_latents is LTXRuntime.prepare_audio_latents
+    assert LTX2Pipeline.decode_phase is LTXRuntime.decode_phase
+
+
+def test_denoise_executor_owns_progress_and_interrupt():
+    updates = []
+
+    class Progress:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, traceback):
+            return False
+
+        def update(self):
+            updates.append(True)
+
+    pipeline = SimpleNamespace(
+        interrupt=False,
+        progress_bar=lambda total: Progress(),
+    )
+    seen: list[tuple[int, float]] = []
+    timesteps = torch.tensor([3.0, 2.0, 1.0])
+    initial_state = LTXAVState(video=torch.tensor(0.0), audio=torch.tensor(10.0))
+
+    def step(index, timestep, state):
+        seen.append((index, timestep.item()))
+        pipeline.interrupt = True
+        return LTXAVState(video=state.video + 1, audio=state.audio + 1)
+
+    state = LTXDenoiseExecutor.run(pipeline, initial_state, timesteps, step)
+
+    assert seen == [(0, 3.0)]
+    assert updates == [True]
+    torch.testing.assert_close(state.video, torch.tensor(1.0))
+    torch.testing.assert_close(state.audio, torch.tensor(11.0))
+
+
+def test_ltx2_distilled_two_stage_executes_declarative_phase_plan():
+    request_inputs = LTXRequestInputs(
+        prompt="prompt",
+        negative_prompt="",
+        height=64,
+        width=64,
+        num_frames=1,
+        frame_rate=24.0,
+        num_inference_steps=8,
+        guidance=LTXGuidanceSpec.positive_only(),
+        num_videos_per_prompt=1,
+        generator=None,
+        latents=None,
+        audio_latents=None,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        prompt_attention_mask=None,
+        negative_prompt_attention_mask=None,
+        decode_timestep=0.25,
+        decode_noise_scale=0.5,
+        output_type="np",
+        max_sequence_length=16,
+    )
+    prompt_context = object()
+    phase_calls = []
+
+    def resolve_request_inputs(req, **kwargs):
+        return request_inputs
+
+    def run_phase(req, inputs, *, prompt_context=None, **kwargs):
+        phase_recipe = kwargs["phase_recipe"]
+        assert kwargs["image"] is source_image
+        phase_calls.append((phase_recipe, inputs, prompt_context))
+        if len(phase_calls) == 1:
+            assert prompt_context is None
+            assert inputs.decode_timestep == 0.25
+            assert inputs.decode_noise_scale == 0.5
+            context = prompt_context_sentinel
+            assert phase_recipe.name == "generate_lowres"
+            assert (inputs.height, inputs.width) == (32, 32)
+            assert inputs.num_inference_steps == 8
+            assert kwargs["noise_scale"] == 1.0
+            video = torch.ones(1, 128, 1, 1, 1)
+            audio = torch.full((1, 8, 1, 2), 2.0)
+            audio_for_next_phase = torch.full((1, 8, 1, 2), 5.0)
+        else:
+            assert prompt_context is prompt_context_sentinel
+            assert phase_recipe.name == "refine"
+            assert (inputs.height, inputs.width) == (64, 64)
+            assert inputs.latents.shape == (1, 128, 1, 2, 2)
+            torch.testing.assert_close(inputs.audio_latents, torch.full((1, 8, 1, 2), 5.0))
+            assert inputs.audio_latents_normalized
+            assert inputs.guidance_scale == 1.0
+            assert inputs.num_inference_steps == 3
+            assert inputs.decode_timestep == 0.0
+            assert inputs.decode_noise_scale is None
+            context = prompt_context
+            video = torch.full((1, 128, 1, 2, 2), 3.0)
+            audio = torch.full((1, 8, 1, 2), 4.0)
+            audio_for_next_phase = None
+        return LTXPhaseResult(
+            forward_context=SimpleNamespace(prompt_context=context),
+            video=video,
+            audio=audio,
+            audio_for_next_phase=audio_for_next_phase,
+        )
+
+    def decode_phase(phase):
+        return DiffusionOutput(output=(phase.video, phase.audio))
+
+    class FakeUpsampler(torch.nn.Module):
+        dtype = torch.float32
+
+        def forward(self, latents):
+            return latents.repeat_interleave(2, dim=-2).repeat_interleave(2, dim=-1)
+
+    prompt_context_sentinel = prompt_context
+    pipeline = object.__new__(LTX2DistilledPipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.vae_spatial_compression_ratio = 32
+    pipeline.vae_temporal_compression_ratio = 8
+    pipeline.latent_upsampler = FakeUpsampler()
+    object.__setattr__(pipeline, "_resolve_request_inputs", resolve_request_inputs)
+    object.__setattr__(pipeline, "run_phase", run_phase)
+    object.__setattr__(pipeline, "decode_phase", decode_phase)
+
+    source_image = object()
+    output = pipeline.forward(SimpleNamespace(sampling_params_list=[], prompts=[]), image=source_image)
+
+    assert len(phase_calls) == 2
+    assert phase_calls[1][2] is prompt_context_sentinel
+    torch.testing.assert_close(output.output[0], torch.full((1, 128, 1, 2, 2), 3.0))
+    torch.testing.assert_close(output.output[1], torch.full((1, 8, 1, 2), 4.0))
+
+
+def test_ltx2_distilled_stage2_reapplies_final_resolution_i2v_conditioning():
+    from vllm_omni.diffusion.models.ltx2 import ltx2_latents
+
+    pipeline = object.__new__(LTX2DistilledPipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.vae_spatial_compression_ratio = 32
+    pipeline.vae_temporal_compression_ratio = 8
+    pipeline.transformer_spatial_patch_size = 1
+    pipeline.transformer_temporal_patch_size = 1
+    pipeline.vae = SimpleNamespace(
+        latents_mean=torch.zeros(2),
+        latents_std=torch.ones(2),
+        config=SimpleNamespace(scaling_factor=1.0),
+    )
+    object.__setattr__(
+        pipeline,
+        "_encode_i2v_image_latents",
+        lambda image, **_kwargs: torch.full((image.shape[0], 2, 1, 2, 2), 7.0),
+    )
+
+    packed, conditioning_mask = pipeline.prepare_latents(
+        image=torch.zeros(1, 3, 64, 64),
+        batch_size=1,
+        num_channels_latents=2,
+        height=64,
+        width=64,
+        num_frames=9,
+        noise_scale=0.0,
+        dtype=torch.float32,
+        device=torch.device("cpu"),
+        latents=torch.ones(1, 2, 2, 2, 2),
+    )
+    unpacked = ltx2_latents.unpack_latents(packed, 2, 2, 2)
+
+    torch.testing.assert_close(unpacked[:, :, :1], torch.full((1, 2, 1, 2, 2), 7.0))
+    torch.testing.assert_close(unpacked[:, :, 1:], torch.ones(1, 2, 1, 2, 2))
+    assert conditioning_mask.shape == (1, 8)
+    assert conditioning_mask[:, :4].all()
+    assert not conditioning_mask[:, 4:].any()
+
+
+def test_ltx2_distilled_two_stage_recipe_is_fixed_positive_only():
+    stage1, stage2 = LTX2_DISTILLED_TWO_STAGE_RECIPE.phases
+
+    assert stage1.spatial_downscale == 2
+    assert stage1.guidance == stage2.guidance == LTXGuidanceSpec.positive_only()
+    assert LTXGuidancePlan.build(stage1.guidance).names == ("cond",)
+    assert LTXGuidancePlan.build(stage2.guidance).names == ("cond",)
+    assert not stage1.allow_guidance_override
+    assert not stage2.allow_guidance_override
+    assert stage1.noise_scale == 1.0
+    assert stage1.sigmas == (1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0)
+    assert stage2.sigmas == (0.909375, 0.725, 0.421875, 0.0)
+    assert not LTX2_DISTILLED_TWO_STAGE_RECIPE.allow_request_sigmas
+    assert not LTX2_DISTILLED_TWO_STAGE_RECIPE.allow_request_latents
+    assert not LTX2_DISTILLED_TWO_STAGE_RECIPE.allow_negative_prompt
+    assert LTX2_DISTILLED_TWO_STAGE_RECIPE.fixed_num_inference_steps
+    assert (LTX2_DISTILLED_TWO_STAGE_RECIPE.height, LTX2_DISTILLED_TWO_STAGE_RECIPE.width) == (1024, 1536)
+
+
+@pytest.mark.parametrize(
+    ("request_inputs", "error"),
+    [
+        (lambda request: replace(request, height=32), "divisible by 64"),
+        (lambda request: replace(request, num_frames=8), "8 \\* k \\+ 1"),
+        (lambda request: replace(request, num_inference_steps=7), "uses 8 fixed Stage 1"),
+        (lambda request: replace(request, latents=torch.empty(1)), "request-provided"),
+        (lambda request: replace(request, audio_latents=torch.empty(1)), "request-provided"),
+        (lambda request: replace(request, negative_prompt="negative"), "negative conditioning"),
+        (lambda request: replace(request, negative_prompt_embeds=torch.empty(1)), "negative conditioning"),
+        (lambda request: replace(request, guidance=LTX2_ONE_STAGE_RECIPE.request_guidance), "positive-only"),
+    ],
+)
+def test_ltx_two_stage_recipe_rejects_unsupported_request_values(request_inputs, error):
+    request = LTXRequestInputs(
+        prompt="prompt",
+        negative_prompt="",
+        height=64,
+        width=64,
+        num_frames=1,
+        frame_rate=24.0,
+        num_inference_steps=8,
+        guidance=LTXGuidanceSpec.positive_only(),
+        num_videos_per_prompt=1,
+        generator=None,
+        latents=None,
+        audio_latents=None,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        prompt_attention_mask=None,
+        negative_prompt_attention_mask=None,
+        decode_timestep=0.0,
+        decode_noise_scale=None,
+        output_type="np",
+        max_sequence_length=16,
+    )
+
+    with pytest.raises(ValueError, match=error):
+        validate_pipeline_request(
+            request_inputs(request),
+            pipeline_recipe=LTX2_DISTILLED_TWO_STAGE_RECIPE,
+            vae_spatial_compression_ratio=32,
+            vae_temporal_compression_ratio=8,
+            pipeline_name="LTX2DistilledPipeline",
+        )
+
+
+def test_ltx_two_stage_recipe_rejects_sigmas():
+    request = LTXRequestInputs(
+        prompt="prompt",
+        negative_prompt="",
+        height=64,
+        width=64,
+        num_frames=1,
+        frame_rate=24.0,
+        num_inference_steps=8,
+        guidance=LTXGuidanceSpec.positive_only(),
+        num_videos_per_prompt=1,
+        generator=None,
+        latents=None,
+        audio_latents=None,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        prompt_attention_mask=None,
+        negative_prompt_attention_mask=None,
+        decode_timestep=0.0,
+        decode_noise_scale=None,
+        output_type="np",
+        max_sequence_length=16,
+    )
+
+    with pytest.raises(ValueError, match="fixed phase sigma schedules"):
+        validate_pipeline_request(
+            request,
+            pipeline_recipe=LTX2_DISTILLED_TWO_STAGE_RECIPE,
+            vae_spatial_compression_ratio=32,
+            vae_temporal_compression_ratio=8,
+            pipeline_name="LTX2DistilledPipeline",
+            request_sigmas=[1.0, 0.0],
+        )
+
+
+@pytest.mark.parametrize(
+    ("direct_kwargs", "sampling_kwargs", "error"),
+    [
+        ({"sigmas": [1.0, 0.0]}, {}, "fixed phase sigma schedules"),
+        ({}, {"sigmas": [1.0, 0.0]}, "fixed phase sigma schedules"),
+        ({"latents": torch.empty(1)}, {}, "request-provided video or audio latents"),
+        ({}, {"latents": torch.empty(1)}, "request-provided video or audio latents"),
+        ({"audio_latents": torch.empty(1)}, {}, "request-provided video or audio latents"),
+        (
+            {},
+            {"extra_args": {"audio_latents": torch.empty(1)}},
+            "request-provided video or audio latents",
+        ),
+        ({"negative_prompt": "negative"}, {}, "negative conditioning"),
+        ({"negative_prompt_embeds": torch.empty(1)}, {}, "negative conditioning"),
+        ({}, {"num_inference_steps": 7}, "uses 8 fixed Stage 1"),
+        ({"guidance_scale": 4.0}, {}, "fixed positive-only guidance"),
+        ({}, {"guidance_scale": 4.0}, "fixed positive-only guidance"),
+    ],
+    ids=(
+        "direct-sigmas",
+        "request-sigmas",
+        "direct-video-latents",
+        "request-video-latents",
+        "direct-audio-latents",
+        "request-audio-latents",
+        "direct-negative-prompt",
+        "direct-negative-embeds",
+        "request-num-steps",
+        "direct-guidance",
+        "request-guidance",
+    ),
+)
+def test_ltx_distilled_forward_rejects_fixed_recipe_overrides(direct_kwargs, sampling_kwargs, error):
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    sampling_values = {
+        "height": 64,
+        "width": 64,
+        "num_frames": 1,
+        "num_inference_steps": 8,
+        **sampling_kwargs,
+    }
+    sampling = OmniDiffusionSamplingParams(**sampling_values)
+    req = DiffusionRequestBatch(
+        [
+            OmniDiffusionRequest(
+                prompt="prompt",
+                sampling_params=sampling,
+                request_id="ltx-distilled-fixed-inputs",
+            )
+        ]
+    )
+    pipeline = _make_ltx_request_pipe(LTX2DistilledPipeline)
+
+    with pytest.raises(ValueError, match=error):
+        pipeline.forward(req, **direct_kwargs)
+
+
+def test_ltx_distilled_dummy_run_uses_fixed_recipe_values():
+    from vllm_omni.diffusion.request import DUMMY_DIFFUSION_REQUEST_ID, OmniDiffusionRequest
+    from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    req = DiffusionRequestBatch(
+        [
+            OmniDiffusionRequest(
+                prompt="dummy run",
+                sampling_params=OmniDiffusionSamplingParams(
+                    height=512,
+                    width=512,
+                    num_frames=LTX2DistilledPipeline.dummy_run_num_frames,
+                    num_inference_steps=1,
+                    guidance_scale=0.0,
+                ),
+                request_id=DUMMY_DIFFUSION_REQUEST_ID,
+            )
+        ]
+    )
+    pipeline = _make_ltx_request_pipe(LTX2DistilledPipeline)
+    seen = {}
+
+    def fake_run_recipe(_req, request_inputs, **_kwargs):
+        seen["request_inputs"] = request_inputs
+        return "dummy-output"
+
+    object.__setattr__(pipeline, "_run_recipe", fake_run_recipe)
+
+    assert pipeline.forward(req) == "dummy-output"
+    assert seen["request_inputs"].num_frames == 1
+    assert seen["request_inputs"].num_inference_steps == 8
+    assert seen["request_inputs"].guidance == LTXGuidanceSpec.positive_only()
+
+
+def test_ltx_custom_sigmas_bypass_scheduler_shifting():
+    from diffusers import FlowMatchEulerDiscreteScheduler
+
+    scheduler = FlowMatchEulerDiscreteScheduler(
+        use_dynamic_shifting=True,
+        base_shift=0.95,
+        max_shift=2.05,
+        shift_terminal=0.1,
+    )
+    pipeline = SimpleNamespace(scheduler=scheduler)
+    sigmas = [1.0, 0.75, 0.25, 0.0]
+
+    audio_scheduler, _, timesteps = prepare_scheduler_stage(
+        pipeline,
+        SimpleNamespace(num_inference_steps=3),
+        device=torch.device("cpu"),
+        sigmas=sigmas,
+        timesteps=None,
+        latent_num_frames=1,
+        latent_height=1,
+        latent_width=1,
+        use_official_sigma_schedule=False,
+    )
+
+    expected = torch.tensor(sigmas, dtype=torch.float32)
+    torch.testing.assert_close(pipeline.scheduler.sigmas, expected)
+    torch.testing.assert_close(audio_scheduler.sigmas, expected)
+    torch.testing.assert_close(timesteps, expected[:-1] * scheduler.config.num_train_timesteps)
+
+
+class TestLTXRequestParsing:
+    def test_request_resolves_official_and_explicit_negative_prompts_per_sample(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt=prompt,
+                    sampling_params=OmniDiffusionSamplingParams(num_inference_steps=2),
+                    request_id=f"ltx-negative-prompt-{index}",
+                )
+                for index, prompt in enumerate(
+                    (
+                        "use the official default",
+                        {"prompt": "disable the default", "negative_prompt": ""},
+                        {"prompt": "custom negative", "negative_prompt": "custom"},
+                    )
+                )
+            ]
+        )
+
+        resolved = _resolve_request_inputs_for_test(_make_ltx_request_pipe(LTX2Pipeline), req)
+
+        assert resolved.negative_prompt == [LTX_DEFAULT_NEGATIVE_PROMPT, "", "custom"]
+
+    def test_forward_negative_prompt_fallback_is_not_discarded(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt="prompt",
+                    sampling_params=OmniDiffusionSamplingParams(num_inference_steps=2),
+                    request_id="ltx-forward-negative-prompt",
+                )
+            ]
+        )
+
+        resolved = _resolve_request_inputs_for_test(
+            _make_ltx_request_pipe(LTX2Pipeline),
+            req,
+            negative_prompt="forward fallback",
+        )
+
+        assert resolved.negative_prompt == ["forward fallback"]
+
+    def test_unified_t2v_i2v_entry_resolves_request_inputs(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        prompt_embeds = torch.tensor([[1.0, 2.0]])
+        negative_prompt_embeds = torch.tensor([[3.0, 4.0]])
+        prompt_attention_mask = torch.tensor([True, False])
+        negative_attention_mask = torch.tensor([False, True])
+        video_latents = torch.ones(1, 2, 3)
+        audio_latents = torch.zeros(1, 2, 3)
+        generator = torch.Generator().manual_seed(123)
+
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt={
+                        "prompt": "shared prompt",
+                        "negative_prompt": "shared negative",
+                        "additional_information": {
+                            "prompt_embeds": prompt_embeds,
+                            "negative_prompt_embeds": negative_prompt_embeds,
+                            "attention_mask": prompt_attention_mask,
+                            "negative_attention_mask": negative_attention_mask,
+                        },
+                    },
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=384,
+                        width=512,
+                        num_frames=25,
+                        frame_rate=12.5,
+                        num_inference_steps=1,
+                        num_outputs_per_prompt=2,
+                        guidance_scale=6.0,
+                        generator=generator,
+                        latents=video_latents,
+                        extra_args={"audio_latents": audio_latents},
+                        decode_timestep=[0.1],
+                        decode_noise_scale=[0.2],
+                        output_type="latent",
+                        max_sequence_length=17,
+                    ),
+                    request_id="ltx23-shared-request-inputs",
+                )
+            ]
+        )
+
+        resolved = _resolve_request_inputs_for_test(_make_ltx_request_pipe(LTX2Pipeline), req)
+
+        assert resolved.prompt is None
+        assert resolved.negative_prompt is None
+        assert resolved.height == 384
+        assert resolved.width == 512
+        assert resolved.num_frames == 25
+        assert resolved.frame_rate == 12.5
+        assert resolved.num_inference_steps == 2
+        assert resolved.guidance_scale == 6.0
+        assert resolved.num_videos_per_prompt == 2
+        assert isinstance(resolved.generator, list)
+        assert [gen.initial_seed() for gen in resolved.generator] == [123, 123]
+        assert resolved.decode_timestep == [0.1]
+        assert resolved.decode_noise_scale == [0.2]
+        assert resolved.output_type == "latent"
+        assert resolved.max_sequence_length == 17
+        torch.testing.assert_close(resolved.latents, video_latents)
+        torch.testing.assert_close(resolved.audio_latents, audio_latents)
+        torch.testing.assert_close(resolved.prompt_embeds, torch.stack([prompt_embeds]))
+        torch.testing.assert_close(resolved.negative_prompt_embeds, torch.stack([negative_prompt_embeds]))
+        torch.testing.assert_close(resolved.prompt_attention_mask, torch.stack([prompt_attention_mask]))
+        torch.testing.assert_close(resolved.negative_prompt_attention_mask, torch.stack([negative_attention_mask]))
+
+    def test_nonbatch_distilled_request_uses_precomputed_positive_embeddings(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        prompt_embeds = torch.tensor([[1.0, 2.0]])
+        prompt_attention_mask = torch.tensor([True, False])
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt={
+                        "prompt": "must not be forwarded with embeddings",
+                        "additional_information": {
+                            "prompt_embeds": prompt_embeds,
+                            "attention_mask": prompt_attention_mask,
+                        },
+                    },
+                    sampling_params=OmniDiffusionSamplingParams(num_inference_steps=8),
+                    request_id="ltx-distilled-prompt-embeds",
+                )
+            ]
+        )
+
+        resolved = _resolve_request_inputs_for_test(
+            _make_ltx_request_pipe(LTX2DistilledPipeline),
+            req,
+            guidance_scale=None,
+        )
+
+        assert resolved.prompt is None
+        assert resolved.negative_prompt == [""]
+        torch.testing.assert_close(resolved.prompt_embeds, torch.stack([prompt_embeds]))
+        torch.testing.assert_close(resolved.prompt_attention_mask, torch.stack([prompt_attention_mask]))
+
+    def test_request_resolves_per_modality_guidance_and_common_cfg_override(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt={"prompt": "prompt", "negative_prompt": "negative"},
+                    sampling_params=OmniDiffusionSamplingParams(
+                        num_inference_steps=2,
+                        extra_args={
+                            "video_cfg_scale": 4.0,
+                            "audio_cfg_guidance_scale": 6.0,
+                            "video_stg_guidance_scale": 0.5,
+                            "audio_stg_scale": 0.25,
+                            "a2v_guidance_scale": 2.0,
+                            "v2a_guidance_scale": 4.0,
+                            "video_rescale_scale": 0.2,
+                            "audio_rescale_scale": 0.3,
+                            "video_stg_blocks": [3, 4],
+                            "audio_stg_blocks": 5,
+                        },
+                    ),
+                    request_id="ltx-guidance-overrides",
+                )
+            ]
+        )
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+
+        resolved = _resolve_request_inputs_for_test(pipe, req, guidance_scale=None)
+
+        assert resolved.guidance.video == LTXModalityGuidance(4.0, 0.5, 2.0, 0.2, (3, 4))
+        assert resolved.guidance.audio == LTXModalityGuidance(6.0, 0.25, 4.0, 0.3, (5,))
+
+        common = _resolve_request_inputs_for_test(pipe, req, guidance_scale=2.0)
+        assert common.guidance.video.cfg_scale == common.guidance.audio.cfg_scale == 2.0
+        # LTX exposes independent video/audio rescale controls, not the
+        # model-agnostic sampling field.
+        assert common.guidance.video.rescale_scale == 0.2
+        assert common.guidance.audio.rescale_scale == 0.3
+
+    def test_request_rejects_unsupported_generic_scheduler_and_rescale_controls(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        cases = (
+            (OmniDiffusionSamplingParams(timesteps=torch.tensor([1.0])), "timesteps"),
+            (OmniDiffusionSamplingParams(guidance_rescale=0.5), "guidance_rescale"),
+            (OmniDiffusionSamplingParams(extra_args={"flow_shift": 3.0}), "flow_shift"),
+        )
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+
+        for index, (sampling, field_name) in enumerate(cases):
+            req = DiffusionRequestBatch(
+                [
+                    OmniDiffusionRequest(
+                        prompt="prompt",
+                        sampling_params=sampling,
+                        request_id=f"ltx-unsupported-{index}",
+                    )
+                ]
+            )
+            with pytest.raises(ValueError, match=field_name):
+                _resolve_request_inputs_for_test(pipe, req)
+
+    def test_request_batch_rejects_mixed_guidance_specs(self):
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt="prompt-0",
+                    sampling_params=OmniDiffusionSamplingParams(
+                        num_inference_steps=2,
+                        extra_args={"video_cfg_scale": scale},
+                    ),
+                    request_id=f"ltx-mixed-guidance-{index}",
+                )
+                for index, scale in enumerate((3.0, 4.0))
+            ]
+        )
+
+        with pytest.raises(ValueError, match="identical video/audio guidance"):
+            _resolve_request_inputs_for_test(
+                _make_ltx_request_pipe(LTX2Pipeline),
+                req,
+                guidance_scale=None,
+            )
+
+    def test_request_input_resolution_rejects_mixed_precomputed_prompt_fields(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt={
+                        "prompt": "with embeds",
+                        "additional_information": {"prompt_embeds": torch.tensor([[1.0]])},
+                    },
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=384,
+                        width=512,
+                        num_frames=25,
+                        num_inference_steps=2,
+                    ),
+                    request_id="ltx23-mixed-precomputed-fields-0",
+                ),
+                OmniDiffusionRequest(
+                    prompt={"prompt": "without embeds"},
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=384,
+                        width=512,
+                        num_frames=25,
+                        num_inference_steps=2,
+                    ),
+                    request_id="ltx23-mixed-precomputed-fields-1",
+                ),
+            ]
+        )
+
+        with pytest.raises(ValueError, match="mix of provided and missing prompt_embeds"):
+            _resolve_request_inputs_for_test(pipe, req)
+
+
+class TestLTXForwardStages:
+    def test_encode_prompt_batches_positive_and_negative_gemma_inputs(self):
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+        calls = []
+
+        def fake_get_gemma_prompt_embeds(**kwargs):
+            calls.append(kwargs)
+            count = len(kwargs["prompt"])
+            embeds = torch.arange(count, dtype=torch.float32).view(count, 1, 1)
+            mask = torch.arange(count).view(count, 1)
+            return embeds, mask
+
+        object.__setattr__(pipe, "_get_gemma_prompt_embeds", fake_get_gemma_prompt_embeds)
+
+        prompt_embeds, prompt_mask, negative_embeds, negative_mask = pipe.encode_prompt(
+            prompt=["positive-0", "positive-1"],
+            negative_prompt=["negative-0", "negative-1"],
+            do_classifier_free_guidance=True,
+            num_videos_per_prompt=2,
+            device=torch.device("cpu"),
+        )
+
+        assert len(calls) == 1
+        assert calls[0]["prompt"] == ["positive-0", "positive-1", "negative-0", "negative-1"]
+        assert calls[0]["num_videos_per_prompt"] == 1
+        torch.testing.assert_close(prompt_embeds.flatten(), torch.tensor([0.0, 0.0, 1.0, 1.0]))
+        torch.testing.assert_close(negative_embeds.flatten(), torch.tensor([2.0, 2.0, 3.0, 3.0]))
+        torch.testing.assert_close(prompt_mask.flatten(), torch.tensor([0, 0, 1, 1]))
+        torch.testing.assert_close(negative_mask.flatten(), torch.tensor([2, 2, 3, 3]))
+
+    def test_encode_prompt_repeats_precomputed_embeds_for_num_outputs(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+        prompt_embeds = torch.tensor([[[1.0], [2.0]], [[3.0], [4.0]]])
+        negative_prompt_embeds = torch.tensor([[[-1.0], [-2.0]], [[-3.0], [-4.0]]])
+        prompt_attention_mask = torch.tensor([[True, False], [False, True]])
+        negative_prompt_attention_mask = torch.tensor([[False, False], [True, True]])
+
+        (
+            repeated_prompt_embeds,
+            repeated_prompt_attention_mask,
+            repeated_negative_prompt_embeds,
+            repeated_negative_prompt_attention_mask,
+        ) = pipe.encode_prompt(
+            prompt=None,
+            do_classifier_free_guidance=True,
+            num_videos_per_prompt=2,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            prompt_attention_mask=prompt_attention_mask,
+            negative_prompt_attention_mask=negative_prompt_attention_mask,
+            device=torch.device("cpu"),
+        )
+
+        torch.testing.assert_close(
+            repeated_prompt_embeds,
+            torch.tensor([[[1.0], [2.0]], [[1.0], [2.0]], [[3.0], [4.0]], [[3.0], [4.0]]]),
+        )
+        torch.testing.assert_close(
+            repeated_negative_prompt_embeds,
+            torch.tensor([[[-1.0], [-2.0]], [[-1.0], [-2.0]], [[-3.0], [-4.0]], [[-3.0], [-4.0]]]),
+        )
+        torch.testing.assert_close(
+            repeated_prompt_attention_mask,
+            torch.tensor([[True, False], [True, False], [False, True], [False, True]]),
+        )
+        torch.testing.assert_close(
+            repeated_negative_prompt_attention_mask,
+            torch.tensor([[False, False], [False, False], [True, True], [True, True]]),
+        )
+
+    def test_t2v_forward_delegates_to_shared_recipe_runtime(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+        request_sigmas = [1.0, 0.4]
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt="stage refactor prompt",
+                    sampling_params=OmniDiffusionSamplingParams(
+                        height=384,
+                        width=512,
+                        num_frames=25,
+                        frame_rate=16,
+                        num_inference_steps=3,
+                        guidance_scale=4.5,
+                        output_type="latent",
+                        sigmas=request_sigmas,
+                    ),
+                    request_id="ltx23-t2v-forward-stage-delegation",
+                )
+            ]
+        )
+        fallback_sigmas = [1.0, 0.5]
+        seen = {}
+
+        def fake_run_recipe(req_arg, request_inputs, **kwargs):
+            seen["req"] = req_arg
+            seen["request_inputs"] = request_inputs
+            seen["kwargs"] = kwargs
+            return ["delegated"]
+
+        object.__setattr__(pipe, "_run_recipe", fake_run_recipe)
+
+        output = pipe.forward(req, sigmas=fallback_sigmas)
+
+        assert output == ["delegated"]
+        assert seen["req"] is req
+        assert seen["request_inputs"].height == 384
+        assert seen["request_inputs"].width == 512
+        assert seen["request_inputs"].num_frames == 25
+        assert seen["request_inputs"].frame_rate == 16.0
+        assert seen["request_inputs"].guidance_scale == 4.5
+        assert seen["request_inputs"].output_type == "latent"
+        assert seen["kwargs"] == {
+            "request_sigmas": request_sigmas,
+            "image": None,
+        }
+
+    def test_t2v_forward_prefers_request_sigmas(self):
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+        from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+        request_sigmas = [1.0, 0.25]
+        req = DiffusionRequestBatch(
+            [
+                OmniDiffusionRequest(
+                    prompt="custom sigma schedule",
+                    sampling_params=OmniDiffusionSamplingParams(
+                        num_inference_steps=2,
+                        sigmas=request_sigmas,
+                    ),
+                    request_id="ltx23-request-sigmas",
+                )
+            ]
+        )
+        pipe = _make_ltx_request_pipe(LTX2Pipeline)
+        seen = {}
+
+        def fake_run_recipe(req_arg, request_inputs, **kwargs):
+            del req_arg, request_inputs
+            seen.update(kwargs)
+            return ["delegated"]
+
+        object.__setattr__(pipe, "_run_recipe", fake_run_recipe)
+
+        output = pipe.forward(req, sigmas=[1.0, 0.5])
+
+        assert output == ["delegated"]
+        assert seen["request_sigmas"] == request_sigmas
+
+
+class TestPipelineComponents:
+    def test_ltx_pipeline_declares_offload_components(self):
+        """LTX2Pipeline exposes all one-stage modules to offload discovery."""
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
+        from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
+
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.transformer = torch.nn.Linear(1, 1)
+        pipe.text_encoder = torch.nn.Linear(1, 1)
+        pipe.connectors = torch.nn.Linear(1, 1)
+        pipe.vae = torch.nn.Linear(1, 1)
+        pipe.audio_vae = torch.nn.Linear(1, 1)
+        pipe.vocoder = torch.nn.Linear(1, 1)
+
+        modules = ModuleDiscovery.discover(pipe)
+
+        assert LTX2Pipeline._dit_modules == ["transformer"]
+        assert LTX2Pipeline._encoder_modules == ["text_encoder", "connectors"]
+        assert LTX2Pipeline._vae_modules == ["vae", "audio_vae"]
+        assert LTX2Pipeline._resident_modules == ["vocoder"]
+        assert modules.dit_names == ["transformer"]
+        assert modules.encoder_names == ["text_encoder", "connectors"]
+        assert modules.resident_names == ["vocoder"]
+        assert len(modules.vaes) == 2
+
+    def test_distilled_profile_keeps_upsampler_in_managed_resident_components(self):
+        assert LTX2_DISTILLED_COMPONENT_PROFILE.resident_modules == ("vocoder", "latent_upsampler")
+
+
+class TestLTX23DecodeConditioning:
+    def test_decode_conditioning_expands_per_prompt_values_to_effective_batch(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_runtime import _expand_per_prompt_decode_value
+
+        assert _expand_per_prompt_decode_value(
+            [0.1, 0.2],
+            prompt_batch_size=2,
+            effective_batch_size=4,
+            field_name="decode_timestep",
+        ) == [0.1, 0.1, 0.2, 0.2]
+        assert _expand_per_prompt_decode_value(
+            [0.3],
+            prompt_batch_size=2,
+            effective_batch_size=4,
+            field_name="decode_timestep",
+        ) == [0.3, 0.3, 0.3, 0.3]
+        assert _expand_per_prompt_decode_value(
+            [0.1, 0.2, 0.3, 0.4],
+            prompt_batch_size=2,
+            effective_batch_size=4,
+            field_name="decode_timestep",
+        ) == [0.1, 0.2, 0.3, 0.4]
+
+    def test_decode_conditioning_rejects_ambiguous_lengths(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_runtime import _expand_per_prompt_decode_value
+
+        with pytest.raises(ValueError, match="decode_timestep"):
+            _expand_per_prompt_decode_value(
+                [0.1, 0.2, 0.3],
+                prompt_batch_size=2,
+                effective_batch_size=4,
+                field_name="decode_timestep",
+            )
+
+
+class TestRegistryIntegration:
+    """Verify the unified one-stage and existing two-stage entries."""
+
+    def test_pipeline_module_paths(self):
+        """Registry entries must point to the correct modules."""
+        from vllm_omni.diffusion.registry import _DIFFUSION_MODELS
+
+        assert _DIFFUSION_MODELS["LTX2Pipeline"] == ("ltx2", "pipeline_ltx2", "LTX2Pipeline")
+        assert _DIFFUSION_MODELS["LTX2DistilledPipeline"] == (
+            "ltx2",
+            "pipeline_ltx2_two_stage",
+            "LTX2DistilledPipeline",
+        )
+        removed_entries = {
+            "LTX2ImageToVideoPipeline",
+            "LTX23Pipeline",
+            "LTX23ImageToVideoPipeline",
+            "LTX2TwoStagesPipeline",
+            "LTX2ImageToVideoTwoStagesPipeline",
+        }
+        assert removed_entries.isdisjoint(_DIFFUSION_MODELS)
+
+    def test_post_process_funcs_registered(self):
+        """Pipeline variants must map to get_ltx2_post_process_func."""
+        from vllm_omni.diffusion.registry import _DIFFUSION_POST_PROCESS_FUNCS
+
+        expected = [
+            "LTX2Pipeline",
+            "LTX2DistilledPipeline",
+            "LTX2T2VDMD2Pipeline",
+            "LTX2I2VDMD2Pipeline",
+        ]
+        for name in expected:
+            assert name in _DIFFUSION_POST_PROCESS_FUNCS, f"{name} not in _DIFFUSION_POST_PROCESS_FUNCS"
+            assert _DIFFUSION_POST_PROCESS_FUNCS[name] == "get_ltx2_post_process_func"
+
+    @pytest.mark.parametrize(
+        "model_class_name",
+        [
+            "LTX2Pipeline",
+            "LTX2DistilledPipeline",
+            "LTX2T2VDMD2Pipeline",
+            "LTX2I2VDMD2Pipeline",
+        ],
+    )
+    def test_post_process_func_resolves_from_every_entry_module(self, model_class_name):
+        from vllm_omni.diffusion.registry import get_diffusion_post_process_func
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            vocoder_dir = os.path.join(tmpdir, "vocoder")
+            os.makedirs(vocoder_dir)
+            with open(os.path.join(vocoder_dir, "config.json"), "w") as config_file:
+                json.dump({"output_sampling_rate": 48000}, config_file)
+
+            post_process = get_diffusion_post_process_func(
+                SimpleNamespace(model_class_name=model_class_name, model=tmpdir)
+            )
+
+        result = post_process((torch.zeros(1), torch.zeros(1)))
+        assert result["audio_sample_rate"] == 48000
+
+    def test_cache_dit_for_ltx2_does_not_have_custom_enablers_registered(self):
+        """Pipeline variants are *not* registered in CUSTOM_DIT_ENABLERS."""
+        from vllm_omni.diffusion.cache.cachedit import CUSTOM_DIT_ENABLERS
+
+        # NOTE: We used to have custom enablers for this model, but refactored to handle
+        # it more generically. Now we only need to ensure it has git cache adapter config.
+        expected = ["LTX2Pipeline"]
+        for name in expected:
+            assert name not in CUSTOM_DIT_ENABLERS, f"{name} not in CUSTOM_DIT_ENABLERS"
+
+
+class TestVocoderSampleRateDetection:
+    """Test _detect_vocoder_output_sample_rate logic."""
+
+    def test_detects_48khz_from_config(self):
+        """Should detect output_sampling_rate=48000 from vocoder/config.json."""
+        from vllm_omni.diffusion.models.ltx2.ltx2_components import _detect_vocoder_output_sample_rate
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            vocoder_dir = os.path.join(tmpdir, "vocoder")
+            os.makedirs(vocoder_dir)
+            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
+                json.dump({"output_sampling_rate": 48000, "input_sampling_rate": 16000}, f)
+
+            result = _detect_vocoder_output_sample_rate(tmpdir)
+            assert result == 48000
+
+    def test_returns_none_for_no_output_sr(self):
+        """Should return None if vocoder config has no output_sampling_rate."""
+        from vllm_omni.diffusion.models.ltx2.ltx2_components import _detect_vocoder_output_sample_rate
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            vocoder_dir = os.path.join(tmpdir, "vocoder")
+            os.makedirs(vocoder_dir)
+            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
+                json.dump({"sampling_rate": 16000}, f)
+
+            result = _detect_vocoder_output_sample_rate(tmpdir)
+            assert result is None
+
+    def test_returns_none_for_missing_directory(self):
+        """Should return None if vocoder directory doesn't exist."""
+        from vllm_omni.diffusion.models.ltx2.ltx2_components import _detect_vocoder_output_sample_rate
+
+        result = _detect_vocoder_output_sample_rate("/nonexistent/path")
+        assert result is None
+
+
+class TestPostProcessFunction:
+    """Test the post-process function factory."""
+
+    def test_post_process_includes_audio_sample_rate(self):
+        """Post-process func should include audio_sample_rate when detected."""
+        import torch
+
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import get_ltx2_post_process_func
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            vocoder_dir = os.path.join(tmpdir, "vocoder")
+            os.makedirs(vocoder_dir)
+            with open(os.path.join(vocoder_dir, "config.json"), "w") as f:
+                json.dump({"output_sampling_rate": 48000}, f)
+
+            # Create a minimal od_config mock
+            class MockConfig:
+                model = tmpdir
+
+            func = get_ltx2_post_process_func(MockConfig())
+
+            video = torch.zeros(1, 3, 4, 64, 64)
+            audio = torch.zeros(1, 1, 48000)
+            result = func((video, audio))
+
+            assert isinstance(result, dict)
+            assert "video" in result
+            assert "audio" in result
+            assert result["audio_sample_rate"] == 48000
+
+    def test_post_process_without_vocoder_config(self):
+        """Post-process func should work without vocoder config (no audio_sample_rate key)."""
+        import torch
+
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import get_ltx2_post_process_func
+
+        class MockConfig:
+            model = "/nonexistent/path"
+
+        func = get_ltx2_post_process_func(MockConfig())
+
+        video = torch.zeros(1, 3, 4, 64, 64)
+        audio = torch.zeros(1, 1, 16000)
+        result = func((video, audio))
+
+        assert isinstance(result, dict)
+        assert "video" in result
+        assert "audio" in result
+        assert "audio_sample_rate" not in result
diff --git a/tests/diffusion/models/ltx2/test_ltx2_transformer.py b/tests/diffusion/models/ltx2/test_ltx2_transformer.py
index e71253297..73e10463e 100644
--- a/tests/diffusion/models/ltx2/test_ltx2_transformer.py
+++ b/tests/diffusion/models/ltx2/test_ltx2_transformer.py
@@ -1,16 +1,23 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+import pytest
 from torch import nn
 
-from vllm_omni.diffusion.models.ltx2.ltx2_transformer import _make_rms_norm
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
+from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel, _make_rms_norm
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
 
-def test_ltx_rms_norm_no_affine_identity_weight_is_non_persistent_buffer():
+def test_ltx_rms_norm_no_affine_matches_official_torch_module():
     norm = _make_rms_norm(8, eps=1e-6, elementwise_affine=False)
 
     assert "weight" not in dict(norm.named_parameters())
-    assert "weight" in dict(norm.named_buffers())
+    assert norm.weight is None
+    assert "weight" not in dict(norm.named_buffers())
     assert "weight" not in norm.state_dict()
 
 
@@ -20,3 +27,42 @@ def test_ltx_rms_norm_affine_weight_remains_parameter():
     assert isinstance(dict(norm.named_parameters())["weight"], nn.Parameter)
     assert "weight" not in dict(norm.named_buffers())
     assert "weight" in norm.state_dict()
+
+
+def test_ltx_transformer_has_separate_cfg_cache_dit_config():
+    adapter_config = getattr(LTX2VideoTransformer3DModel, "_cache_dit_adapter_config")
+
+    assert isinstance(adapter_config, CacheDiTAdapterConfig)
+    assert adapter_config.has_separate_cfg
+
+
+def test_ltx_transformer_exposes_hsdp_shard_conditions_for_blocks():
+    model = object.__new__(LTX2VideoTransformer3DModel)
+    nn.Module.__init__(model)
+    model.transformer_blocks = nn.ModuleList([nn.Linear(4, 4) for _ in range(2)])
+    model.norm_out = nn.LayerNorm(4)
+
+    conditions = getattr(model, "_hsdp_shard_conditions", None)
+
+    assert conditions is not None
+    assert len(conditions) == 1
+
+    matched = []
+    for name, module in model.named_modules():
+        if any(condition(name, module) for condition in conditions):
+            matched.append(name)
+
+    assert matched == ["transformer_blocks.0", "transformer_blocks.1"]
+
+
+@pytest.mark.parametrize("rope_type", ["interleaved", "split"])
+def test_ltx_sp_plan_shards_video_and_audio_timesteps_together(rope_type):
+    root_plan = LTX2VideoTransformer3DModel._build_sp_plan(rope_type)[""]
+
+    video_timestep = root_plan["timestep"]
+    audio_timestep = root_plan["audio_timestep"]
+
+    assert video_timestep.split_dim == audio_timestep.split_dim == 1
+    assert video_timestep.expected_dims == audio_timestep.expected_dims == 2
+    assert not video_timestep.split_output
+    assert not audio_timestep.split_output
diff --git a/tests/diffusion/models/ltx2/test_ltx2_3_vae_tiling.py b/tests/diffusion/models/ltx2/test_ltx2_vae.py
similarity index 82%
rename from tests/diffusion/models/ltx2/test_ltx2_3_vae_tiling.py
rename to tests/diffusion/models/ltx2/test_ltx2_vae.py
index 9b53bb4f8..108bb960d 100644
--- a/tests/diffusion/models/ltx2/test_ltx2_3_vae_tiling.py
+++ b/tests/diffusion/models/ltx2/test_ltx2_vae.py
@@ -11,24 +11,64 @@ import torch
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
-class TestLTX23OutputRank:
-    def test_single_process_rank_is_output_rank(self, monkeypatch):
-        import vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 as ltx23
+class TestLTXOutputRank:
+    @pytest.mark.parametrize(
+        ("distributed_vae_state", "expected_decode_calls"),
+        [(False, 0), (True, 1), (RuntimeError("unavailable"), None)],
+    )
+    def test_non_output_rank_only_enters_collective_vae_decode(
+        self,
+        monkeypatch,
+        distributed_vae_state,
+        expected_decode_calls,
+    ):
+        import vllm_omni.diffusion.models.ltx2.ltx2_runtime as ltx_runtime
+        from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import LTX2Pipeline
 
-        monkeypatch.setattr(ltx23.torch.distributed, "is_initialized", lambda: False)
+        class FakeVae:
+            dtype = torch.float32
+            config = SimpleNamespace(timestep_conditioning=False)
 
-        assert ltx23._is_output_rank() is True
-        assert ltx23._should_decode_video_on_rank(SimpleNamespace(is_distributed_enabled=lambda: False)) is True
+            def __init__(self):
+                self.decode_calls = 0
 
-    def test_non_output_rank_skips_decode_unless_vae_decode_is_distributed(self, monkeypatch):
-        import vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 as ltx23
+            def is_distributed_enabled(self):
+                if isinstance(distributed_vae_state, Exception):
+                    raise distributed_vae_state
+                return distributed_vae_state
 
-        monkeypatch.setattr(ltx23.torch.distributed, "is_initialized", lambda: True)
-        monkeypatch.setattr(ltx23.torch.distributed, "get_rank", lambda: 1)
+            def decode(self, *_args, **_kwargs):
+                self.decode_calls += 1
+                return (torch.ones(1, 1),)
 
-        assert ltx23._is_output_rank() is False
-        assert ltx23._should_decode_video_on_rank(SimpleNamespace(is_distributed_enabled=lambda: False)) is False
-        assert ltx23._should_decode_video_on_rank(SimpleNamespace(is_distributed_enabled=lambda: True)) is True
+        monkeypatch.setattr(ltx_runtime.torch.distributed, "is_initialized", lambda: True)
+        monkeypatch.setattr(ltx_runtime.torch.distributed, "get_rank", lambda: 1)
+        pipe = object.__new__(LTX2Pipeline)
+        torch.nn.Module.__init__(pipe)
+        pipe.vae = FakeVae()
+
+        decode_kwargs = {
+            "latents": torch.ones(1, 1),
+            "audio_latents": torch.ones(1, 1),
+            "output_type": "np",
+            "connector_prompt_embeds": torch.ones(1, 1),
+            "generator": None,
+            "device": torch.device("cpu"),
+            "decode_timestep": 0.0,
+            "decode_noise_scale": None,
+            "prompt_batch_size": 1,
+        }
+        if isinstance(distributed_vae_state, Exception):
+            with pytest.raises(RuntimeError, match="unavailable"):
+                pipe._decode_output(**decode_kwargs)
+            assert pipe.vae.decode_calls == 0
+            return
+
+        output = pipe._decode_output(**decode_kwargs)
+
+        assert pipe.vae.decode_calls == expected_decode_calls
+        assert output.output[0].numel() == 0
+        assert output.output[1].numel() == 0
 
 
 class TestLTX23VaeDistributedDecode:
diff --git a/tests/diffusion/models/minimax_h3/__init__.py b/tests/diffusion/models/minimax_h3/__init__.py
new file mode 100644
index 000000000..208f01a7c
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
new file mode 100644
index 000000000..70f00f4b7
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
@@ -0,0 +1,1403 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import json
+from multiprocessing.reduction import ForkingPickler
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import numpy as np
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_pipeline_import_registry_and_component_discovery():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.registry import (
+        _DIFFUSION_MODELS,
+        _DIFFUSION_POST_PROCESS_FUNCS,
+    )
+
+    assert _DIFFUSION_MODELS["MiniMaxH3Pipeline"] == (
+        "minimax_h3",
+        "pipeline_minimax_h3",
+        "MiniMaxH3Pipeline",
+    )
+    assert _DIFFUSION_MODELS["MiniMaxH3ModularPipeline"] == _DIFFUSION_MODELS["MiniMaxH3Pipeline"]
+    assert _DIFFUSION_POST_PROCESS_FUNCS["MiniMaxH3Pipeline"] == "get_minimax_h3_post_process_func"
+    assert (
+        _DIFFUSION_POST_PROCESS_FUNCS["MiniMaxH3ModularPipeline"] == _DIFFUSION_POST_PROCESS_FUNCS["MiniMaxH3Pipeline"]
+    )
+    assert MiniMaxH3Pipeline._dit_modules == ["transformer", "transformers_ref"]
+    assert MiniMaxH3Pipeline._encoder_modules == ["text_encoder"]
+    assert MiniMaxH3Pipeline._vae_modules == ["video_vae", "audio_vae"]
+
+
+def _write_partition_index(path, *, partition, tasks):
+    path.mkdir(parents=True)
+    (path / "model_index.json").write_text(
+        json.dumps(
+            {
+                "_class_name": "MiniMaxH3Pipeline",
+                "_diffusers_version": "0.32.2",
+                "_minimax_h3": {
+                    "partition": partition,
+                    "tasks": tasks,
+                    "sigma_shift_scales": {"video": 12.0, "audio": 3.0},
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def test_modular_diffusers_index_is_resolved_generically(tmp_path):
+    from vllm_omni.diffusion.data import OmniDiffusionConfig, resolve_model_class_name
+    from vllm_omni.diffusion.utils.hf_utils import is_diffusion_model
+    from vllm_omni.entrypoints.utils import resolve_model_config_path
+
+    (tmp_path / "modular_model_index.json").write_text(
+        json.dumps(
+            {
+                "_class_name": "MiniMaxH3ModularPipeline",
+                "_diffusers_version": "0.36.0.dev0",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    assert is_diffusion_model(str(tmp_path))
+    assert resolve_model_class_name(str(tmp_path)) == "MiniMaxH3ModularPipeline"
+    assert resolve_model_config_path(str(tmp_path)) is None
+
+    config = OmniDiffusionConfig(model=str(tmp_path))
+    config.enrich_config()
+    assert config.model_class_name == "MiniMaxH3ModularPipeline"
+    assert config.supports_multimodal_inputs
+    assert config.max_multimodal_image_inputs == 9
+    assert config.supports_mixed_reference_inputs
+
+
+@pytest.mark.parametrize(
+    ("task_type", "partition"),
+    [
+        (None, "combined"),
+        ("auto", "combined"),
+        ("t2va", "fl2va"),
+        ("fl2va", "fl2va"),
+        ("ref2va", "ref2va"),
+    ],
+)
+def test_startup_task_selects_weight_partition(task_type, partition):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import _minimax_h3_partition_for_task
+
+    assert _minimax_h3_partition_for_task(task_type) == partition
+
+
+def test_startup_auto_task_uses_explicit_local_partition(tmp_path):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import _minimax_h3_partition_for_task
+
+    for directory, partition, tasks in (
+        ("FL2VA", "fl2va", ["t2va", "fl2va"]),
+        ("Ref2VA", "ref2va", ["ref2va"]),
+    ):
+        model_path = tmp_path / directory
+        _write_partition_index(model_path, partition=partition, tasks=tasks)
+        assert _minimax_h3_partition_for_task(None, str(model_path)) == partition
+        assert _minimax_h3_partition_for_task("auto", str(model_path)) == partition
+        assert _minimax_h3_partition_for_task("combined", str(model_path)) == "combined"
+
+
+def test_startup_task_rejects_unsupported_value():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import _minimax_h3_partition_for_task
+
+    with pytest.raises(ValueError, match="task_type must be one of"):
+        _minimax_h3_partition_for_task("unsupported")
+
+
+def test_combined_task_inference_and_transformer_routing():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.partition = "combined"
+    pipeline.supported_tasks = frozenset({"t2va", "fl2va", "ref2va"})
+    pipeline.transformer = torch.nn.Identity()
+    pipeline.transformers_ref = torch.nn.Linear(1, 1)
+    assert pipeline._resolve_task(None, {}) == "t2va"
+    assert pipeline._resolve_task(None, {"image": object()}) == "fl2va"
+    assert pipeline._resolve_task(None, {"audio": object()}) == "ref2va"
+    assert pipeline._resolve_task(None, {"video": object()}) == "ref2va"
+    pipeline.partition = "ref2va"
+    pipeline.supported_tasks = frozenset({"ref2va"})
+    assert pipeline._resolve_task(None, {"image": object()}) == "ref2va"
+
+    pipeline.partition = "combined"
+    pipeline.supported_tasks = frozenset({"t2va", "fl2va", "ref2va"})
+    assert pipeline._transformer_for_task("fl2va") is pipeline.transformer
+    assert pipeline._transformer_for_task("ref2va") is pipeline.transformers_ref
+
+
+@pytest.mark.parametrize(
+    (
+        "task_type",
+        "expected_partition",
+        "expected_dits",
+        "component_partition",
+        "source_partitions",
+        "expected_tasks",
+    ),
+    [
+        (None, "combined", 2, "FL2VA", ["FL2VA", "Ref2VA"], {"t2va", "fl2va", "ref2va"}),
+        ("fl2va", "fl2va", 1, "FL2VA", ["FL2VA"], {"t2va", "fl2va"}),
+        ("ref2va", "ref2va", 1, "Ref2VA", ["Ref2VA"], {"ref2va"}),
+    ],
+)
+def test_pipeline_loads_task_selected_dits_and_shared_components_once(
+    monkeypatch,
+    tmp_path,
+    task_type,
+    expected_partition,
+    expected_dits,
+    component_partition,
+    source_partitions,
+    expected_tasks,
+):
+    from vllm_omni.diffusion.data import (
+        DiffusionParallelConfig,
+        OmniDiffusionConfig,
+    )
+    from vllm_omni.diffusion.models.minimax_h3 import (
+        pipeline_minimax_h3 as pipeline_module,
+    )
+
+    _write_partition_index(
+        tmp_path / "FL2VA",
+        partition="fl2va",
+        tasks=["t2va", "fl2va"],
+    )
+    _write_partition_index(
+        tmp_path / "Ref2VA",
+        partition="ref2va",
+        tasks=["ref2va"],
+    )
+    for partition_name in ("FL2VA", "Ref2VA"):
+        for component in (
+            "transformer",
+            "tokenizer",
+            "processor",
+            "text_encoder",
+            "video_vae",
+            "audio_vae",
+        ):
+            (tmp_path / partition_name / component).mkdir()
+
+    created = {"dit": [], "text_encoder": [], "video_vae": [], "audio_vae": []}
+
+    class FakeModule(torch.nn.Module):
+        def __init__(self, *args, **kwargs):
+            super().__init__()
+
+    class FakeDiT(FakeModule):
+        def __init__(self, *args, **kwargs):
+            super().__init__()
+            created["dit"].append((args, kwargs))
+
+    def component_factory(name):
+        def create(path, *args, **kwargs):
+            created[name].append(str(path))
+            return FakeModule()
+
+        return create
+
+    tokenizer_calls = []
+    processor_calls = []
+    tokenizer_cls = Mock(spec=pipeline_module.Qwen2TokenizerFast)
+    tokenizer_cls.from_pretrained.side_effect = lambda *args, **kwargs: (
+        tokenizer_calls.append((args, kwargs)) or object()
+    )
+    processor_cls = Mock(spec=pipeline_module.Qwen3VLProcessor)
+    processor_cls.from_pretrained.side_effect = lambda *args, **kwargs: (
+        processor_calls.append((args, kwargs)) or object()
+    )
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3DiTModel", FakeDiT)
+    monkeypatch.setattr(
+        pipeline_module,
+        "MiniMaxH3Qwen3VLEncoder",
+        component_factory("text_encoder"),
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "MiniMaxH3VideoVAE",
+        component_factory("video_vae"),
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "MiniMaxH3AudioVAE",
+        component_factory("audio_vae"),
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "Qwen2TokenizerFast",
+        tokenizer_cls,
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "Qwen3VLProcessor",
+        processor_cls,
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "_dit_rank_world",
+        lambda: (None, 0, 1),
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "get_local_device",
+        lambda: torch.device("cpu"),
+    )
+    download_calls = []
+
+    def fake_download(**kwargs):
+        download_calls.append(kwargs)
+        return str(tmp_path)
+
+    monkeypatch.setattr(
+        pipeline_module,
+        "download_weights_from_hf_specific",
+        fake_download,
+    )
+
+    od_config = OmniDiffusionConfig(
+        model="MiniMaxAI/MiniMax-H3",
+        revision=None,
+        task_type=task_type,
+        quantization_config=None,
+        parallel_config=DiffusionParallelConfig(
+            cfg_parallel_size=1,
+            text_encoder_tp_size=1,
+        ),
+    )
+    pipeline = pipeline_module.MiniMaxH3Pipeline(od_config=od_config)
+
+    assert pipeline.partition == expected_partition
+    assert pipeline.supported_tasks == expected_tasks
+    assert len(created["dit"]) == expected_dits
+    component_path = tmp_path / component_partition
+    assert created["text_encoder"] == [str(component_path / "text_encoder")]
+    assert created["video_vae"] == [str(component_path / "video_vae")]
+    assert created["audio_vae"] == [str(component_path / "audio_vae")]
+    assert len(tokenizer_calls) == 1
+    assert len(processor_calls) == 1
+    expected_dit_modules = ["transformer", "transformers_ref"] if expected_dits == 2 else ["transformer"]
+    assert pipeline._dit_modules == expected_dit_modules
+    assert hasattr(pipeline, "transformers_ref") is (expected_dits == 2)
+    if expected_partition == "ref2va":
+        assert pipeline._transformer_for_task("ref2va") is pipeline.transformer
+    assert [source.model_or_path for source in pipeline.weights_sources] == [
+        str(tmp_path / partition_name) for partition_name in source_partitions
+    ]
+    expected_patterns = (
+        pipeline_module.MINIMAX_H3_DOWNLOAD_PATTERNS
+        if expected_partition == "combined"
+        else pipeline_module.MINIMAX_H3_TASK_DOWNLOAD_PATTERNS[expected_partition]
+    )
+    assert download_calls == [
+        {
+            "model_name_or_path": "MiniMaxAI/MiniMax-H3",
+            "cache_dir": None,
+            "allow_patterns": expected_patterns,
+            "revision": None,
+            "require_all": True,
+        }
+    ]
+
+
+def test_combined_weight_loader_routes_each_contiguous_partition():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    class FakeTransformer(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.loaded = []
+            self.post_load_calls = 0
+
+        def load_weights(self, weights):
+            self.loaded = [name for name, _ in weights]
+            return set(self.loaded)
+
+        def post_load_weights(self):
+            self.post_load_calls += 1
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.transformer = FakeTransformer()
+    pipeline.transformers_ref = FakeTransformer()
+    pipeline.text_encoder = torch.nn.Identity()
+    pipeline.video_vae = torch.nn.Identity()
+    pipeline.audio_vae = torch.nn.Identity()
+    loaded = pipeline.load_weights(
+        iter(
+            [
+                ("transformer.a", torch.ones(1)),
+                ("transformer.b", torch.ones(1)),
+                ("transformers_ref.a", torch.ones(1)),
+            ]
+        )
+    )
+
+    assert pipeline.transformer.loaded == ["a", "b"]
+    assert pipeline.transformers_ref.loaded == ["a"]
+    assert pipeline.transformer.post_load_calls == 1
+    assert pipeline.transformers_ref.post_load_calls == 1
+    assert loaded == {"transformer.a", "transformer.b", "transformers_ref.a"}
+
+
+def test_dlo_offload_plan_includes_token_refiner():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    assert MiniMaxH3Pipeline._offload_plan.offload_submodules == {"token_refiner": "blocks"}
+    assert MiniMaxH3Pipeline._offload_plan.resident_dit_paths == frozenset({"transformer"})
+
+
+def test_joint_postprocess_is_multiprocessing_picklable():
+    from vllm_omni.diffusion.models.minimax_h3 import (
+        get_minimax_h3_post_process_func,
+    )
+
+    postprocess = get_minimax_h3_post_process_func(SimpleNamespace())
+    postprocess = ForkingPickler.loads(ForkingPickler.dumps(postprocess))
+    video = torch.linspace(0, 1, 2 * 3 * 2 * 4 * 5).reshape(2, 3, 2, 4, 5)
+    audio = torch.arange(12, dtype=torch.float32).reshape(1, 2, 6)
+
+    result = postprocess((video, audio), output_type="np")
+
+    assert isinstance(result["video"], list)
+    assert result["video"][0].shape == (2, 4, 5, 3)
+    np.testing.assert_array_equal(result["audio"], audio.numpy())
+    assert result["audio_sample_rate"] == 32000
+    assert result["fps"] == 24
+
+
+def test_cfg_parallel_is_rejected_for_distilled_checkpoint():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    od_config = SimpleNamespace(
+        parallel_config=SimpleNamespace(cfg_parallel_size=2),
+    )
+    with pytest.raises(ValueError, match="CFG-distilled"):
+        MiniMaxH3Pipeline(od_config=od_config)
+
+
+def test_shape_contract_matches_three_reference_tasks():
+    from vllm_omni.diffusion.models.minimax_h3.time_request import (
+        MINIMAX_H3_SHAPE_PLANNER,
+        minimax_h3_align_frame_count,
+    )
+
+    assert minimax_h3_align_frame_count(round(8.7 * 24)) == 209
+    assert MINIMAX_H3_SHAPE_PLANNER.video_latent_t(209) == 62
+    assert MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(8.7) == 348
+    assert minimax_h3_align_frame_count(round(5.0 * 24)) == 124
+    assert MINIMAX_H3_SHAPE_PLANNER.video_latent_t(124) == 37
+    assert MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(5.0) == 200
+    assert MINIMAX_H3_SHAPE_PLANNER.frame_count_from_video_latent_t(62) == 209
+
+
+def test_shifted_sigma_schedule_matches_reference_values():
+    from vllm_omni.diffusion.models.minimax_h3.time_request import (
+        minimax_h3_time_shift_sigmas,
+    )
+
+    sigmas = minimax_h3_time_shift_sigmas(num_steps=5, shift_scale=12.0)
+
+    assert sigmas == pytest.approx(
+        [1.0, 0.9729729891, 0.9230769277, 0.8000000119, 0.0],
+        abs=1e-7,
+    )
+
+
+def test_cudnn_packed_attention_uses_python_length_without_padding_mask():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3Attention,
+    )
+
+    class FakeBackend:
+        supports_prefix_kv_slicing = True
+
+    class FakeAttention(torch.nn.Module):
+        attn_backend = FakeBackend
+
+        def __init__(self):
+            super().__init__()
+            self.metadata = None
+
+        def forward(self, query, key, value, metadata):
+            self.metadata = metadata
+            return query
+
+    attention = object.__new__(MiniMaxH3Attention)
+    torch.nn.Module.__init__(attention)
+    attention.attention = FakeAttention()
+    # Model-side Ulysses shards rows before Attention gathers them again.
+    # The Python packed_total must therefore remain global even though q is
+    # local here.
+    q = torch.randn(4, 2, 4)
+    cu_seqlens = torch.tensor([0, 5, 8], dtype=torch.int32)
+
+    output = attention._run_packed_attention(
+        q,
+        q,
+        q,
+        cu_seqlens=cu_seqlens,
+        max_seqlen=5,
+        packed_total=8,
+    )
+
+    assert output.shape == q.shape
+    assert attention.attention.metadata.attn_mask is None
+    assert attention.attention.metadata.extra["valid_kv_length"] == 5
+
+
+def test_packed_attention_keeps_padding_mask_for_other_backends():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3Attention,
+    )
+
+    class FakeBackend:
+        supports_prefix_kv_slicing = False
+
+    class FakeAttention(torch.nn.Module):
+        attn_backend = FakeBackend
+
+        def __init__(self):
+            super().__init__()
+            self.metadata = None
+
+        def forward(self, query, key, value, metadata):
+            self.metadata = metadata
+            return query
+
+    attention = object.__new__(MiniMaxH3Attention)
+    torch.nn.Module.__init__(attention)
+    attention.attention = FakeAttention()
+    q = torch.randn(8, 2, 4)
+
+    attention._run_packed_attention(
+        q,
+        q,
+        q,
+        cu_seqlens=torch.tensor([0, 5, 8], dtype=torch.int32),
+        max_seqlen=5,
+        packed_total=8,
+    )
+
+    assert torch.equal(
+        attention.attention.metadata.attn_mask,
+        torch.tensor([[True, True, True, True, True, False, False, False]]),
+    )
+
+
+def test_reference_image_resize_contract():
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _reference_image_shape,
+    )
+
+    assert _reference_image_shape(Image.new("RGB", (1080, 1440))) == (
+        2048,
+        2720,
+    )
+    with pytest.raises(ValueError, match="aspect ratio"):
+        _reference_image_shape(Image.new("RGB", (100, 501)))
+
+
+def test_fl2va_supports_first_last_and_explicit_frame_index_contracts():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_fl2va_keyframe_indices,
+    )
+
+    assert _resolve_fl2va_keyframe_indices({}, 1) == [0]
+    assert _resolve_fl2va_keyframe_indices({}, 2) == [0, -1]
+    assert _resolve_fl2va_keyframe_indices({"frame_index": -1}, 1) == [-1]
+    assert _resolve_fl2va_keyframe_indices({"frame_indices": [0, -1]}, 2) == [0, -1]
+    with pytest.raises(ValueError, match="frame_indices"):
+        _resolve_fl2va_keyframe_indices({"frame_indices": [0, 1]}, 2)
+
+
+def test_minimax_h3_uses_the_official_output_canvas_policy():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_output_canvas,
+    )
+
+    assert _resolve_output_canvas(21 / 9, 768) == (672, 1536)
+    assert _resolve_output_canvas(16 / 9, 768) == (768, 1344)
+    assert _resolve_output_canvas(9 / 16, 768) == (1344, 768)
+    with pytest.raises(ValueError, match="short_edge"):
+        _resolve_output_canvas(16 / 9, 720)
+
+
+def test_minimax_h3_accepts_sglang_auto_aspect_ratio_alias():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    sampling = SimpleNamespace(
+        fps=24,
+        num_frames=1,
+        height=None,
+        width=None,
+        extra_args={"duration": 5.0, "aspect_ratio": "auto"},
+    )
+    height, width, *_ = pipeline._resolve_shape("ref2va", sampling, None)
+    assert (height, width) == (768, 1344)
+
+
+def test_minimax_h3_advertises_the_official_ref2va_image_limit():
+    from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
+
+    assert get_diffusion_model_metadata("MiniMaxH3Pipeline").max_multimodal_image_inputs == 9
+
+
+def test_encoder_forward_uses_hook_compatible_encode_entrypoint():
+    from vllm_omni.diffusion.models.minimax_h3.encoder import (
+        MiniMaxH3Qwen3VLEncoder,
+    )
+
+    encoder = object.__new__(MiniMaxH3Qwen3VLEncoder)
+    torch.nn.Module.__init__(encoder)
+    expected = torch.ones(2, 3)
+    encoder.encode_ids = Mock(return_value=expected)
+    input_ids = torch.tensor([1, 2])
+    pixel_values = torch.ones(1, 4)
+    image_grid_thw = torch.tensor([[1, 1, 1]])
+
+    actual = encoder(
+        input_ids,
+        pixel_values=pixel_values,
+        image_grid_thw=image_grid_thw,
+    )
+
+    assert actual is expected
+    encoder.encode_ids.assert_called_once_with(
+        input_ids,
+        pixel_values=pixel_values,
+        image_grid_thw=image_grid_thw,
+    )
+
+
+def test_encoder_forward_forwards_video_inputs():
+    from vllm_omni.diffusion.models.minimax_h3.encoder import (
+        MiniMaxH3Qwen3VLEncoder,
+    )
+
+    encoder = object.__new__(MiniMaxH3Qwen3VLEncoder)
+    torch.nn.Module.__init__(encoder)
+    expected = torch.ones(2, 3)
+    encoder.encode_ids = Mock(return_value=expected)
+    input_ids = torch.tensor([1, 2])
+    pixel_values_videos = torch.ones(1, 4)
+    video_grid_thw = torch.tensor([[2, 1, 1]])
+
+    actual = encoder(
+        input_ids,
+        pixel_values_videos=pixel_values_videos,
+        video_grid_thw=video_grid_thw,
+    )
+
+    assert actual is expected
+    encoder.encode_ids.assert_called_once_with(
+        input_ids,
+        pixel_values=None,
+        image_grid_thw=None,
+        pixel_values_videos=pixel_values_videos,
+        video_grid_thw=video_grid_thw,
+    )
+
+
+def test_reference_video_shape_uses_h3_adapt_shape_policy():
+    from vllm_omni.diffusion.models.minimax_h3.reference_video import (
+        _reference_video_shape,
+    )
+
+    assert _reference_video_shape(1280, 720) == (1344, 768)
+    assert _reference_video_shape(3844, 2160) == (1344, 768)
+
+
+def test_text_encoder_stub_constructs_without_group_or_weights():
+    from vllm_omni.diffusion.models.minimax_h3.encoder import (
+        MiniMaxH3Qwen3VLEncoder,
+    )
+
+    encoder = MiniMaxH3Qwen3VLEncoder(
+        "/nonexistent/text_encoder",
+        device=torch.device("cpu"),
+        load_model=False,
+        encoder_group=None,
+    )
+    assert not encoder.is_loaded
+    assert encoder.tp_size == 1
+    # The stub has no parameters, so it never contributes to the runner's
+    # strict missing-parameter check on non-encoder ranks.
+    assert list(encoder.named_parameters()) == []
+
+
+def test_no_offload_keeps_text_encoder_resident():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+    input_ids = torch.tensor([1, 2])
+
+    actual = pipeline._encode_text_hidden(input_ids, {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_not_called()
+
+
+def test_model_offload_uses_hooked_text_encoder_call():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=True,
+        enable_layerwise_offload=False,
+    )
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder = Mock(return_value=expected)
+    input_ids = torch.tensor([1, 2])
+    vision_kwargs = {"pixel_values": torch.ones(1, 4)}
+
+    actual = pipeline._encode_text_hidden(input_ids, vision_kwargs)
+
+    assert actual is expected
+    pipeline.text_encoder.assert_called_once_with(input_ids, **vision_kwargs)
+    pipeline.text_encoder.load_to_device.assert_not_called()
+
+
+def test_layerwise_offload_releases_text_encoder():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=True,
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
+
+
+def test_distributed_layerwise_offload_releases_text_encoder():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=True,
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
+
+
+def test_distributed_layerwise_offload_stages_vae_component():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=True,
+    )
+    component = Mock()
+
+    with pipeline._component_on_device(component):
+        component.load_to_device.assert_called_once_with()
+        component.offload_to_cpu.assert_not_called()
+
+    component.offload_to_cpu.assert_called_once_with()
+
+
+def test_distributed_layerwise_resident_blocks_are_stage_scoped():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    controller = Mock()
+    pipeline._dlo_residency_controller = controller
+
+    with pipeline._resident_dit_layers_on_device():
+        controller.load_resident_layers.assert_called_once_with()
+        controller.offload_resident_layers.assert_not_called()
+
+    controller.offload_resident_layers.assert_called_once_with()
+
+
+def test_distributed_layerwise_resident_blocks_release_on_failure():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    controller = Mock()
+    pipeline._dlo_residency_controller = controller
+
+    with pytest.raises(RuntimeError, match="denoise failed"):
+        with pipeline._resident_dit_layers_on_device():
+            raise RuntimeError("denoise failed")
+
+    controller.load_resident_layers.assert_called_once_with()
+    controller.offload_resident_layers.assert_called_once_with()
+
+
+def test_distributed_layerwise_resident_blocks_can_be_skipped():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    controller = Mock()
+    pipeline._dlo_residency_controller = controller
+
+    with pipeline._resident_dit_layers_on_device(enabled=False):
+        pass
+
+    controller.load_resident_layers.assert_not_called()
+    controller.offload_resident_layers.assert_not_called()
+
+
+def test_encoder_layerwise_offload_keeps_tp_blocks_rank_local(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3.encoder import (
+        MiniMaxH3Qwen3VLEncoder,
+    )
+
+    class Stack(torch.nn.Module):
+        def __init__(self, count):
+            super().__init__()
+            self.blocks = torch.nn.ModuleList([torch.nn.Linear(2, 2) for _ in range(count)])
+
+    class TextStack(torch.nn.Module):
+        def __init__(self, count):
+            super().__init__()
+            self.layers = torch.nn.ModuleList([torch.nn.Linear(2, 2) for _ in range(count)])
+
+    hooks = []
+
+    def fake_apply(block, next_block, device, stream, pin_memory):
+        hook = SimpleNamespace(
+            block=block,
+            next_block=next_block,
+            device=device,
+            stream=stream,
+            pin_memory=pin_memory,
+            _prev_hook=None,
+            offload_layer=Mock(),
+        )
+        hooks.append(hook)
+        return hook
+
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.offloader.layerwise_backend.apply_block_hook",
+        fake_apply,
+    )
+    monkeypatch.setattr(
+        "vllm_omni.platforms.current_omni_platform.Stream",
+        Mock(return_value="copy-stream"),
+    )
+    encoder = object.__new__(MiniMaxH3Qwen3VLEncoder)
+    torch.nn.Module.__init__(encoder)
+    encoder.device_target = torch.device("cpu")
+    encoder.vision = Stack(2)
+    encoder.text_model = TextStack(3)
+
+    encoder.enable_omni_layerwise_offload(pin_memory=False)
+
+    assert len(hooks) == 5
+    assert all(hook._prev_hook is not None for hook in hooks)
+    assert all(hook.device == torch.device("cpu") for hook in hooks)
+
+
+def test_video_vae_keeps_reference_fp32_weights(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    class FakeRemote(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.model = torch.nn.Linear(1, 1).half()
+
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda _path: {
+            "latent_channels": 1,
+            "latents_mean": [0.0],
+            "latents_std": [1.0],
+        },
+    )
+    monkeypatch.setattr(
+        vae_module,
+        "_load_remote_component",
+        lambda _path, _config: FakeRemote(),
+    )
+
+    video_vae = vae_module.MiniMaxH3VideoVAE(
+        "unused",
+        device=torch.device("cpu"),
+    )
+
+    assert next(video_vae.parameters()).dtype == torch.float32
+
+
+def test_video_vae_can_load_on_cpu_for_staged_gpu_residency(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    class FakeRemote(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.model = torch.nn.Linear(1, 1)
+
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda _path: {
+            "latent_channels": 1,
+            "latents_mean": [0.0],
+            "latents_std": [1.0],
+        },
+    )
+    monkeypatch.setattr(
+        vae_module,
+        "_load_remote_component",
+        lambda _path, _config: FakeRemote(),
+    )
+
+    video_vae = vae_module.MiniMaxH3VideoVAE(
+        "unused",
+        device=torch.device("meta"),
+        load_device=torch.device("cpu"),
+    )
+
+    assert next(video_vae.parameters()).device.type == "cpu"
+    assert video_vae._device_target.type == "meta"
+
+
+def test_video_vae_uses_snapshot_stager_for_accelerator_target(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    class FakeRemote(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.model = torch.nn.Linear(1, 1)
+
+    stager = Mock()
+    stager_cls = Mock(return_value=stager)
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda _path: {
+            "latent_channels": 1,
+            "latents_mean": [0.0],
+            "latents_std": [1.0],
+        },
+    )
+    monkeypatch.setattr(
+        vae_module,
+        "_load_remote_component",
+        lambda _path, _config: FakeRemote(),
+    )
+    monkeypatch.setattr(vae_module, "PinnedModuleStager", stager_cls)
+
+    video_vae = vae_module.MiniMaxH3VideoVAE(
+        "unused",
+        device=torch.device("cuda"),
+        load_device=torch.device("cpu"),
+    )
+    video_vae.load_to_device()
+    video_vae.offload_to_cpu()
+
+    stager_cls.assert_called_once_with(
+        video_vae.remote,
+        torch.device("cuda"),
+        pin_memory=True,
+    )
+    stager.load.assert_called_once_with()
+    stager.offload.assert_called_once_with()
+
+
+def test_video_vae_encode_uses_configured_parallel_tiling():
+    from vllm_omni.diffusion.models.minimax_h3.vae import (
+        MiniMaxH3VideoVAE,
+    )
+
+    class FakeModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.weight = torch.nn.Parameter(torch.ones(1))
+            self.parallel_tiling = True
+            self.encode_calls = []
+
+        def encode_videos(self, frames, *, use_fp16_latent):
+            assert self.parallel_tiling
+            self.encode_calls.append((frames, use_fp16_latent))
+            return [torch.ones(1, 1, 2, 2, 2)]
+
+    video_vae = object.__new__(MiniMaxH3VideoVAE)
+    torch.nn.Module.__init__(video_vae)
+    video_vae.model = FakeModel()
+    video_vae.config_dict = {
+        "latent_channels": 1,
+        "latents_mean": [0.0],
+        "latents_std": [1.0],
+    }
+
+    rows, shape = video_vae.encode_video("frames")
+
+    assert video_vae.model.parallel_tiling
+    assert video_vae.model.encode_calls == [("frames", True)]
+    assert rows.shape == (2, 4)
+    assert shape == (2, 2, 2)
+
+
+def test_distributed_video_vae_encodes_references_sequentially(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.models.minimax_h3 import (
+        pipeline_minimax_h3 as pipeline_module,
+    )
+
+    prepared = [
+        {"prepared_path": "video-1.mp4"},
+        {"prepared_path": "video-2.mp4"},
+    ]
+
+    class FakeVideoVAE:
+        def __init__(self):
+            self.calls = []
+
+        def is_distributed_enabled(self):
+            return True
+
+        def encode_video(self, frames):
+            self.calls.append(frames)
+            index = len(self.calls)
+            return torch.full((1, 2), index, dtype=torch.float32), (index, 2, 3)
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.video_vae = FakeVideoVAE()
+
+    monkeypatch.setattr(
+        pipeline_module,
+        "_dit_rank_world",
+        lambda: ("dit-group", 1, 4),
+    )
+
+    def fake_broadcast_object_list(values, *, src, group, device):
+        assert values == [None]
+        assert (src, group, device) == (0, "dit-group", torch.device("cpu"))
+        values[0] = prepared
+
+    monkeypatch.setattr(
+        pipeline_module.dist,
+        "broadcast_object_list",
+        fake_broadcast_object_list,
+    )
+    monkeypatch.setattr(
+        pipeline_module,
+        "load_video_frames",
+        lambda path: f"frames:{path}",
+    )
+
+    rows, shapes = pipeline._encode_video_conditions(None, count=2)
+
+    assert pipeline.video_vae.calls == [
+        "frames:video-1.mp4",
+        "frames:video-2.mp4",
+    ]
+    torch.testing.assert_close(
+        rows,
+        torch.tensor([[1.0, 1.0], [2.0, 2.0]]),
+    )
+    assert shapes == [(1, 2, 3), (2, 2, 3)]
+
+
+@pytest.mark.parametrize(
+    ("case", "extra", "image_count", "expected"),
+    [
+        ("F1", {"frame_index": -1}, 1, [-1]),
+        ("F2", {"frame_indices": [0, -1]}, 2, [0, -1]),
+    ],
+)
+def test_f1_f2_official_fl2va_keyframe_matrix(case, extra, image_count, expected):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_fl2va_keyframe_indices,
+    )
+
+    assert case in {"F1", "F2"}
+    assert _resolve_fl2va_keyframe_indices(extra, image_count) == expected
+
+
+@pytest.mark.parametrize(
+    ("case", "counts"),
+    [
+        ("R1", (3, 0, 0)),
+        ("R2", (1, 0, 0)),
+        ("R3", (1, 1, 0)),
+        ("R4", (0, 1, 1)),
+        ("R5", (1, 1, 1)),
+        ("R6", (1, 0, 2)),
+    ],
+)
+def test_r1_r6_ref2va_reference_count_matrix(case, counts):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _validate_ref2va_reference_counts,
+    )
+
+    assert case.startswith("R")
+    _validate_ref2va_reference_counts(*counts)
+
+
+def test_ref2va_reference_count_validation_preserves_client_error_metadata():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _validate_ref2va_reference_counts,
+    )
+    from vllm_omni.errors import OmniClientError
+
+    with pytest.raises(OmniClientError, match="at least one image or video"):
+        _validate_ref2va_reference_counts(0, 0, 0)
+
+
+@pytest.mark.parametrize(
+    ("case", "start_time", "expected_duration"),
+    [
+        ("R7", None, 10.0),
+        ("R8", 4.0, 6.0),
+    ],
+)
+def test_r7_r8_ref2va_video_segment_matrix(monkeypatch, tmp_path, case, start_time, expected_duration):
+    from vllm_omni.diffusion.models.minimax_h3 import reference_video as reference_video_module
+
+    source = tmp_path / f"{case}.mp4"
+    source.touch()
+    metadata = {
+        "width": 1280,
+        "height": 720,
+        "fps": 24.0,
+        "frame_count": 240,
+        "duration": 10.0,
+        "format_names": ("mp4",),
+        "video_codec": "h264",
+        "audio_codecs": (),
+        "file_size": 1024,
+    }
+    transcode_calls = []
+    monkeypatch.setattr(reference_video_module, "_probe_video", lambda _path: metadata)
+    monkeypatch.setattr(
+        reference_video_module,
+        "_transcode_reference_video",
+        lambda source, **kwargs: transcode_calls.append((source, kwargs)) or "prepared.mp4",
+    )
+
+    prepared = reference_video_module.prepare_reference_videos(
+        [str(source)],
+        target_frame_count=209,
+        workdir=str(tmp_path / "work"),
+        start_time_seconds=start_time,
+    )
+
+    assert prepared[0]["duration_seconds"] == pytest.approx(expected_duration)
+    assert prepared[0]["start_time_seconds"] == pytest.approx(start_time or 0.0)
+    assert transcode_calls[0][1]["duration_seconds"] == pytest.approx(expected_duration)
+
+
+def test_ref2va_two_video_recipe_tolerates_container_rounding(monkeypatch, tmp_path):
+    from vllm_omni.diffusion.models.minimax_h3 import reference_video as reference_video_module
+
+    first = tmp_path / "first.mp4"
+    second = tmp_path / "second.mp4"
+    first.touch()
+    second.touch()
+    metadata = {
+        str(first): {
+            "width": 1280,
+            "height": 720,
+            "fps": 24.0,
+            "frame_count": 241,
+            "duration": 10.041667,
+            "format_names": ("mp4",),
+            "video_codec": "h264",
+            "audio_codecs": (),
+            "file_size": 1024,
+        },
+        str(second): {
+            "width": 1280,
+            "height": 720,
+            "fps": 24.0,
+            "frame_count": 120,
+            "duration": 4.966667,
+            "format_names": ("mp4",),
+            "video_codec": "h264",
+            "audio_codecs": (),
+            "file_size": 1024,
+        },
+    }
+    transcode_calls = []
+    monkeypatch.setattr(reference_video_module, "_probe_video", lambda path: metadata[str(path)])
+    monkeypatch.setattr(
+        reference_video_module,
+        "_transcode_reference_video",
+        lambda source, **kwargs: transcode_calls.append((source, kwargs)) or f"{source}.prepared.mp4",
+    )
+
+    prepared = reference_video_module.prepare_reference_videos(
+        [str(first), str(second)],
+        target_frame_count=124,
+        workdir=str(tmp_path / "work"),
+    )
+
+    assert [item["duration_seconds"] for item in prepared] == pytest.approx([10.041667, 4.958333])
+    assert sum(item["duration_seconds"] for item in prepared) == pytest.approx(15.0)
+    assert transcode_calls[1][1]["duration_seconds"] == pytest.approx(4.958333)
+
+
+def test_ref2va_two_video_recipe_rejects_real_duration_overflow(monkeypatch, tmp_path):
+    from vllm_omni.diffusion.models.minimax_h3 import reference_video as reference_video_module
+    from vllm_omni.errors import OmniClientError
+
+    first = tmp_path / "first.mp4"
+    second = tmp_path / "second.mp4"
+    first.touch()
+    second.touch()
+    metadata = {
+        str(first): {
+            "width": 1280,
+            "height": 720,
+            "fps": 24.0,
+            "frame_count": 240,
+            "duration": 10.0,
+            "format_names": ("mp4",),
+            "video_codec": "h264",
+            "audio_codecs": (),
+            "file_size": 1024,
+        },
+        str(second): {
+            "width": 1280,
+            "height": 720,
+            "fps": 24.0,
+            "frame_count": 120,
+            "duration": 5.02,
+            "format_names": ("mp4",),
+            "video_codec": "h264",
+            "audio_codecs": (),
+            "file_size": 1024,
+        },
+    }
+    monkeypatch.setattr(reference_video_module, "_probe_video", lambda path: metadata[str(path)])
+    monkeypatch.setattr(reference_video_module, "_transcode_reference_video", lambda source, **kwargs: "prepared.mp4")
+
+    with pytest.raises(OmniClientError, match="15 seconds"):
+        reference_video_module.prepare_reference_videos(
+            [str(first), str(second)],
+            target_frame_count=124,
+            workdir=str(tmp_path / "work"),
+        )
+
+
+@pytest.mark.parametrize("duration", [4.0, 15.0])
+def test_g2_output_duration_accepts_official_boundaries(duration):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    sampling = SimpleNamespace(
+        fps=24,
+        num_frames=1,
+        height=None,
+        width=None,
+        extra_args={"duration": duration},
+    )
+
+    height, width, *_ = pipeline._resolve_shape("ref2va", sampling, None)
+    assert height > 0 and width > 0
+
+
+@pytest.mark.parametrize("duration", [3.99, 15.01, float("nan"), "not-a-duration"])
+def test_g2_output_duration_rejects_out_of_contract_values(duration):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    sampling = SimpleNamespace(
+        fps=24,
+        num_frames=1,
+        height=None,
+        width=None,
+        extra_args={"duration": duration},
+    )
+    with pytest.raises(ValueError, match="duration"):
+        pipeline._resolve_shape("ref2va", sampling, None)
+
+
+def test_g1_fanout_uses_incrementing_output_seeds():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _minimax_h3_output_seeds,
+        _resolve_minimax_h3_num_outputs,
+    )
+
+    assert _resolve_minimax_h3_num_outputs(3) == 3
+    assert _minimax_h3_output_seeds(100, 3) == [100, 101, 102]
+    with pytest.raises(ValueError, match="num_outputs_per_prompt"):
+        _resolve_minimax_h3_num_outputs(11)
+
+
+def test_g3_task_specific_aspect_ratio_policy():
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_minimax_h3_aspect_ratio,
+    )
+
+    image = Image.new("RGB", (1280, 720))
+    assert _resolve_minimax_h3_aspect_ratio("fl2va", "9:16", image) == pytest.approx(16 / 9)
+    assert _resolve_minimax_h3_aspect_ratio("ref2va", None, None) == pytest.approx(16 / 9)
+    assert _resolve_minimax_h3_aspect_ratio("ref2va", "auto", None) == pytest.approx(16 / 9)
+    with pytest.raises(ValueError, match="requires an explicit"):
+        _resolve_minimax_h3_aspect_ratio("t2va", None, None)
+    with pytest.raises(ValueError, match="one of"):
+        _resolve_minimax_h3_aspect_ratio("t2va", "2:1", None)
+
+
+def test_g3_t2va_shape_requires_a_named_ratio_and_fl2va_ignores_override():
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    t2va_sampling = SimpleNamespace(
+        fps=24,
+        num_frames=1,
+        height=None,
+        width=None,
+        extra_args={"duration": 5.0},
+    )
+    with pytest.raises(ValueError, match="requires an explicit aspect_ratio"):
+        pipeline._resolve_shape("t2va", t2va_sampling, None)
+
+    fl2va_sampling = SimpleNamespace(
+        fps=24,
+        num_frames=1,
+        height=None,
+        width=None,
+        extra_args={"duration": 5.0, "aspect_ratio": "9:16"},
+    )
+    height, width, *_ = pipeline._resolve_shape("fl2va", fl2va_sampling, Image.new("RGB", (1280, 720)))
+    assert (height, width) == (768, 1344)
+
+
+def test_g4_reference_image_boundaries_and_aspect_ratio():
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _validate_reference_image,
+    )
+
+    _validate_reference_image(Image.new("RGB", (256, 256)))
+    _validate_reference_image(Image.new("RGB", (5760, 2304)))
+    with pytest.raises(ValueError, match="dimensions"):
+        _validate_reference_image(Image.new("RGB", (255, 255)))
+    with pytest.raises(ValueError, match="aspect ratio"):
+        _validate_reference_image(Image.new("RGB", (256, 641)))
+
+
+def test_g4_reference_image_file_format_and_size_contract(tmp_path):
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _load_image,
+    )
+
+    valid_path = tmp_path / "reference.png"
+    Image.new("RGB", (256, 256)).save(valid_path)
+    assert _load_image(valid_path).size == (256, 256)
+
+    invalid_path = tmp_path / "reference.bmp"
+    Image.new("RGB", (256, 256)).save(invalid_path)
+    with pytest.raises(ValueError, match="must use"):
+        _load_image(invalid_path)
+
+
+def test_g4_standalone_audio_duration_and_total_duration_contract():
+    from vllm_omni.diffusion.models.minimax_h3.reference_video import (
+        validate_reference_audio_waveforms,
+    )
+
+    sample_rate = 16000
+    validate_reference_audio_waveforms(
+        [
+            (torch.zeros(1, 2 * sample_rate), sample_rate),
+            (torch.zeros(1, 13 * sample_rate), sample_rate),
+        ]
+    )
+    with pytest.raises(ValueError, match="duration"):
+        validate_reference_audio_waveforms([(torch.zeros(1, int(1.9 * sample_rate)), sample_rate)])
+    with pytest.raises(ValueError, match="at most 15 seconds in total"):
+        validate_reference_audio_waveforms(
+            [
+                (torch.zeros(1, 8 * sample_rate), sample_rate),
+                (torch.zeros(1, 8 * sample_rate), sample_rate),
+            ]
+        )
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    [
+        ("fps", 23.0, "FPS"),
+        ("duration", 1.0, "duration"),
+        ("format_names", ("avi",), "container"),
+        ("video_codec", "vp9", "H.264"),
+        ("audio_codecs", ("opus",), "AAC"),
+        ("file_size", 50 * 1024 * 1024 + 1, "size"),
+    ],
+)
+def test_g4_reference_video_metadata_validation(field, value, message, tmp_path):
+    from vllm_omni.diffusion.models.minimax_h3.reference_video import (
+        _validate_reference_video_metadata,
+    )
+
+    metadata = {
+        "width": 1280,
+        "height": 720,
+        "fps": 24.0,
+        "duration": 10.0,
+        "format_names": ("mp4",),
+        "video_codec": "h264",
+        "audio_codecs": ("aac",),
+        "file_size": 1024,
+    }
+    metadata[field] = value
+    with pytest.raises(ValueError, match=message):
+        _validate_reference_video_metadata(metadata, index=0, source=str(tmp_path / "reference.mp4"))
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_e2e.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_e2e.py
new file mode 100644
index 000000000..ec9d378ff
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_e2e.py
@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import os
+
+import numpy as np
+import pytest
+
+pytestmark = [
+    pytest.mark.local_model,
+    pytest.mark.cuda,
+    pytest.mark.diffusion,
+    pytest.mark.parallel,
+]
+
+MODEL_ENV = "VLLM_TEST_MINIMAX_H3_FL2VA_MODEL"
+
+
+def _assert_joint_output(outputs):
+    assert len(outputs) == 1
+    frames = np.asarray(outputs[0].images[0])
+    assert frames.shape == (39, 256, 448, 3)
+    multimodal = outputs[0].multimodal_output
+    assert multimodal is not None
+    assert np.asarray(multimodal["audio"]).shape[1] == 2
+    assert multimodal["audio_sample_rate"] == 32000
+    assert multimodal["fps"] == 24
+
+
+@pytest.mark.skipif(
+    not os.environ.get(MODEL_ENV),
+    reason=f"set {MODEL_ENV} to an authorized FL2VA checkpoint path",
+)
+def test_minimax_h3_t2va_ulysses8_smoke():
+    import torch
+
+    from vllm_omni.diffusion.data import DiffusionParallelConfig
+    from vllm_omni.entrypoints.omni import Omni
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    if torch.accelerator.device_count() < 8:
+        pytest.skip("MiniMax H3 Ulysses smoke requires eight GPUs")
+
+    engine = Omni(
+        model=os.environ[MODEL_ENV],
+        parallel_config=DiffusionParallelConfig(ulysses_degree=8),
+        trust_remote_code=True,
+        enable_cpu_offload=True,
+        enforce_eager=True,
+    )
+    try:
+        outputs = engine.generate(
+            "A quiet cinematic night scene with matching ambient sound.",
+            OmniDiffusionSamplingParams(
+                height=256,
+                width=448,
+                num_frames=29,
+                fps=24,
+                num_inference_steps=2,
+                seed=42,
+                output_type="np",
+                extra_args={
+                    "task": "t2va",
+                    "duration": 4.0,
+                    "aspect_ratio": "16:9",
+                    "flow_shift": 12.0,
+                    "audio_flow_shift": 3.0,
+                },
+            ),
+            use_tqdm=False,
+        )
+    finally:
+        engine.close()
+
+    assert len(outputs) == 1
+    frames = np.asarray(outputs[0].images[0])
+    assert frames.shape == (107, 256, 448, 3)
+    multimodal = outputs[0].multimodal_output
+    assert multimodal is not None
+    assert np.asarray(multimodal["audio"]).shape[1] == 2
+    assert multimodal["audio_sample_rate"] == 32000
+    assert multimodal["fps"] == 24
+
+
+@pytest.mark.skipif(
+    not os.environ.get(MODEL_ENV),
+    reason=f"set {MODEL_ENV} to an authorized FL2VA checkpoint path",
+)
+def test_minimax_h3_t2va_fp8_single_gpu_smoke():
+    import torch
+
+    from vllm_omni.diffusion.data import DiffusionParallelConfig
+    from vllm_omni.entrypoints.omni import Omni
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    if torch.accelerator.device_count() < 1:
+        pytest.skip("MiniMax H3 FP8 smoke requires a CUDA device")
+
+    engine = Omni(
+        model=os.environ[MODEL_ENV],
+        quantization_config={
+            "transformer": {"method": "fp8"},
+            "text_encoder": None,
+            "video_vae": None,
+            "audio_vae": None,
+        },
+        parallel_config=DiffusionParallelConfig(ulysses_degree=1),
+        trust_remote_code=True,
+        enable_cpu_offload=True,
+        enforce_eager=True,
+    )
+    try:
+        outputs = engine.generate(
+            "A quiet cinematic night scene with matching ambient sound.",
+            OmniDiffusionSamplingParams(
+                height=256,
+                width=448,
+                num_frames=29,
+                fps=24,
+                num_inference_steps=2,
+                seed=42,
+                output_type="np",
+                extra_args={
+                    "task": "t2va",
+                    "flow_shift": 12.0,
+                    "audio_flow_shift": 3.0,
+                },
+            ),
+            use_tqdm=False,
+        )
+    finally:
+        engine.close()
+
+    _assert_joint_output(outputs)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py
new file mode 100644
index 000000000..efe53f826
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py
@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_video_patchify_round_trip_preserves_values():
+    from vllm_omni.diffusion.models.minimax_h3.packed_tokens import (
+        minimax_h3_patchify_video_latent,
+        minimax_h3_unpatchify_video_tokens,
+    )
+
+    latent = torch.arange(2 * 3 * 2 * 4 * 6).reshape(2, 3, 2, 4, 6)
+    rows = minimax_h3_patchify_video_latent(
+        latent,
+        patch_size=(1, 2, 2),
+    )
+    restored = minimax_h3_unpatchify_video_tokens(
+        rows,
+        latent_shape=(2, 2, 3, 3),
+        patch_size=(1, 2, 2),
+    )
+
+    torch.testing.assert_close(restored, latent)
+
+
+def test_audio_pack_round_trip_preserves_channel_major_order():
+    from vllm_omni.diffusion.models.minimax_h3.packed_tokens import (
+        minimax_h3_pack_audio_latent,
+        minimax_h3_unpack_audio_tokens,
+    )
+
+    latent = torch.arange(2 * 4 * 5).reshape(2, 4, 5)
+    rows = minimax_h3_pack_audio_latent(latent)
+    restored = minimax_h3_unpack_audio_tokens(
+        rows,
+        audio_t=10,
+        audio_channel=2,
+    )
+
+    torch.testing.assert_close(restored, latent)
+
+
+def test_t2va_and_fl2va_packing_keep_update_rows_separate():
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        minimax_h3_packed_sequence,
+    )
+
+    common = dict(
+        text_len=4,
+        latent_t=2,
+        latent_h=4,
+        latent_w=6,
+        audio_t=3,
+    )
+    t2va = minimax_h3_packed_sequence(
+        **common,
+        include_keyframe_cond=False,
+    )
+    fl2va = minimax_h3_packed_sequence(
+        **common,
+        include_keyframe_cond=True,
+        keyframe_frame_indices=[0],
+        frame_count=5,
+    )
+
+    assert int(t2va["seq_len"]) == 64
+    assert t2va["img_pos"].numel() == 12
+    assert t2va["update_mask"].all()
+    assert fl2va["img_pos"].numel() == 18
+    assert fl2va["update_mask"].sum().item() == 12
+    assert (~fl2va["update_mask"]).sum().item() == 6
+    assert t2va["audio_pos"].numel() == fl2va["audio_pos"].numel() == 6
+
+
+def test_ref2va_packing_tracks_video_and_audio_update_masks():
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        minimax_h3_packed_sequence_ref2va_blocks,
+    )
+
+    packed = minimax_h3_packed_sequence_ref2va_blocks(
+        text_len=4,
+        latent_t=2,
+        latent_h=4,
+        latent_w=6,
+        audio_t=3,
+        ref_blocks=[
+            {"kind": "image", "latent_h": 4, "latent_w": 4},
+            {"kind": "audio", "ref_audio_t": 2},
+        ],
+    )
+
+    assert int(packed["seq_len"]) == 64
+    assert packed["img_pos"].numel() == 16
+    assert packed["update_mask"].sum().item() == 12
+    assert packed["audio_pos"].numel() == 10
+    assert packed["audio_update_mask"].sum().item() == 6
+    assert packed["cu_seqlens"].tolist() == [0, 30, 64]
+
+
+def test_condition_noise_is_seeded_and_keeps_clean_anchor_at_timestep_one():
+    from vllm_omni.diffusion.models.minimax_h3.condition_noise import (
+        minimax_h3_audio_cond_noise_aug_rows,
+        minimax_h3_imgvid_cond_noise_aug_rows,
+    )
+
+    image_rows = torch.randn(4, 96)
+    audio_rows = torch.randn(6, 32)
+
+    torch.testing.assert_close(
+        minimax_h3_imgvid_cond_noise_aug_rows(
+            image_rows,
+            condition_shapes=[(1, 4, 4)],
+            target_latent_t=2,
+            imgvid_cond_num_frames=1,
+            seed=42,
+            noise_aug=1.0,
+        ),
+        image_rows,
+    )
+    torch.testing.assert_close(
+        minimax_h3_audio_cond_noise_aug_rows(
+            audio_rows,
+            condition_audio_t=[3],
+            seed=42,
+            noise_aug=1.0,
+        ),
+        audio_rows,
+    )
+
+    first = minimax_h3_audio_cond_noise_aug_rows(
+        audio_rows,
+        condition_audio_t=[3],
+        seed=42,
+        noise_aug=0.25,
+    )
+    second = minimax_h3_audio_cond_noise_aug_rows(
+        audio_rows,
+        condition_audio_t=[3],
+        seed=42,
+        noise_aug=0.25,
+    )
+    torch.testing.assert_close(first, second)
+
+
+def test_condition_noise_accepts_a_reference_video_longer_than_the_target():
+    from vllm_omni.diffusion.models.minimax_h3.condition_noise import (
+        minimax_h3_imgvid_cond_noise_aug_rows,
+    )
+
+    rows = torch.zeros(4 * 2 * 2, 96)
+    result = minimax_h3_imgvid_cond_noise_aug_rows(
+        rows,
+        condition_shapes=[(4, 4, 4)],
+        target_latent_t=2,
+        imgvid_cond_num_frames=1,
+        seed=7,
+        noise_aug=0.5,
+    )
+    assert result.shape == rows.shape
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_parallel.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_parallel.py
new file mode 100644
index 000000000..bcd074483
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_parallel.py
@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+import torch.nn as nn
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_grouped_qkv_checkpoint_reorder():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        _reorder_grouped_qkv_to_qkv,
+    )
+
+    # Two groups with rows [q, k, v] become [q0, q1, k0, k1, v0, v1].
+    grouped = torch.arange(6, dtype=torch.float32).reshape(6, 1)
+    reordered = _reorder_grouped_qkv_to_qkv(
+        grouped,
+        num_query_groups=2,
+        heads_per_group=1,
+        head_dim=1,
+    )
+
+    assert reordered[:, 0].tolist() == [0, 3, 1, 4, 2, 5]
+
+
+def test_transformer_declares_cache_sp_layerwise_offload_and_hsdp():
+    from cache_dit import ForwardPattern
+
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3DiTModel,
+    )
+
+    assert MiniMaxH3DiTModel._repeated_blocks == ["MiniMaxH3DiTBlock"]
+    assert MiniMaxH3DiTModel._layerwise_offload_blocks_attrs == ["blocks"]
+    assert MiniMaxH3DiTModel._cache_dit_adapter_config.block_forward_patterns["blocks"] == ForwardPattern.Pattern_3
+    assert not MiniMaxH3DiTModel._cache_dit_adapter_config.has_separate_cfg
+    assert set(MiniMaxH3DiTModel._sp_plan) == {"sp_prepare", "sp_gather"}
+
+    model = object.__new__(MiniMaxH3DiTModel)
+    nn.Module.__init__(model)
+    model.blocks = nn.ModuleList([nn.Linear(4, 4) for _ in range(2)])
+    model.token_refiner = nn.Module()
+    model.token_refiner.blocks = nn.ModuleList([nn.Linear(4, 4)])
+    model.final_layer = nn.Linear(4, 4)
+
+    matched = [
+        name
+        for name, module in model.named_modules()
+        if any(condition(name, module) for condition in MiniMaxH3DiTModel._hsdp_shard_conditions)
+    ]
+    assert matched == ["blocks.0", "blocks.1"]
+
+
+def test_packed_attention_is_a_regional_compile_boundary():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3Attention,
+    )
+
+    assert getattr(MiniMaxH3Attention._run_packed_attention, "_torchdynamo_disable", False)
+
+
+def test_h3_fused_rope_matches_reference_and_preserves_unrotated_dims():
+    from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3Attention,
+    )
+
+    attention = object.__new__(MiniMaxH3Attention)
+    nn.Module.__init__(attention)
+    attention.rope = RotaryEmbedding(is_neox_style=True, half_head_dim=False)
+    attention.rope._forward_method = attention.rope.forward_native
+
+    x = torch.randn(11, 3, 128, dtype=torch.bfloat16)
+    freqs_half = torch.randn(11, 48)
+    freqs = torch.cat((freqs_half, freqs_half), dim=-1)
+    actual = attention._apply_rope(x, freqs)
+
+    cos = torch.cos(freqs).to(x.dtype).unsqueeze(1)
+    sin = torch.sin(freqs).to(x.dtype).unsqueeze(1)
+    x_rot = x[..., :96]
+    x1, x2 = x_rot.chunk(2, dim=-1)
+    expected_rot = x_rot * cos + torch.cat((-x2, x1), dim=-1) * sin
+    expected = torch.cat((expected_rot, x[..., 96:]), dim=-1)
+
+    torch.testing.assert_close(actual, expected, atol=0, rtol=0)
+    torch.testing.assert_close(actual[..., 96:], x[..., 96:], atol=0, rtol=0)
+
+
+@pytest.mark.parametrize(
+    ("tp_size", "message"),
+    [
+        (3, "num_attention_heads"),
+        (5, "num_attention_heads"),
+    ],
+)
+def test_tp_rejects_non_divisible_head_counts(tp_size, message):
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3DiTArchConfig,
+        MiniMaxH3DiTModel,
+    )
+
+    model = object.__new__(MiniMaxH3DiTModel)
+    with pytest.raises(ValueError, match=message):
+        model._validate_tp_config(
+            arch=MiniMaxH3DiTArchConfig(),
+            tp_size=tp_size,
+        )
+
+
+def test_tp_accepts_checkpoint_supported_sizes():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3DiTArchConfig,
+        MiniMaxH3DiTModel,
+    )
+
+    model = object.__new__(MiniMaxH3DiTModel)
+    arch = MiniMaxH3DiTArchConfig()
+    for tp_size in (1, 2, 4, 7):
+        model._validate_tp_config(arch=arch, tp_size=tp_size)
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py
new file mode 100644
index 000000000..b9ae3335c
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization.py
@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+import torch
+import torch.nn as nn
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+class _FakeLinear(nn.Module):
+    def __init__(
+        self,
+        *args,
+        bias=False,
+        params_dtype=None,
+        quant_config=None,
+        prefix="",
+        total_num_heads=None,
+        total_num_kv_heads=None,
+        **kwargs,
+    ):
+        del args, kwargs
+        super().__init__()
+        self.prefix = prefix
+        self.quant_config = quant_config
+        self.weight = nn.Parameter(torch.empty(1, dtype=params_dtype))
+        if bias:
+            self.bias = nn.Parameter(torch.empty(1, dtype=params_dtype))
+        else:
+            self.register_parameter("bias", None)
+        self.num_heads = total_num_heads
+        self.num_kv_heads = total_num_kv_heads
+
+
+class _FakeAttention(nn.Module):
+    def __init__(self, **kwargs):
+        del kwargs
+        super().__init__()
+
+
+def _small_od_config():
+    arch = {
+        "num_layers": 1,
+        "token_refiner_num_layers": 1,
+        "hidden_size": 8,
+        "num_attention_heads": 2,
+        "attention_head_dim": 4,
+        "ffn_hidden_size": 16,
+        "latents_dim": 2,
+        "audio_latents_dim": 2,
+        "patch_size": (1, 2, 2),
+        "text_dim": 6,
+        "timestep_input_dim": 4,
+        "time_embed_hidden_size": 8,
+        "time_embed_dim": 4,
+        "adaln_out_features": 18 * 8,
+        "final_adaln_out_features": 2 * 8,
+        "rope_inv_freq_len": 2,
+    }
+    return SimpleNamespace(
+        tf_model_config=arch,
+        parallel_config=SimpleNamespace(ulysses_degree=1),
+    )
+
+
+def test_fp8_scope_and_prefix_propagation(monkeypatch):
+    from vllm.model_executor.layers.linear import LinearBase, UnquantizedLinearMethod
+    from vllm.model_executor.layers.quantization.fp8 import Fp8Config
+    from vllm.model_executor.layers.quantization.utils.quant_utils import (
+        is_layer_skipped,
+    )
+
+    from vllm_omni.diffusion.models.minimax_h3 import minimax_h3_transformer as h3
+
+    monkeypatch.setattr(h3, "ColumnParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "MergedColumnParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "QKVParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "RowParallelLinear", _FakeLinear)
+    monkeypatch.setattr(h3, "Attention", _FakeAttention)
+    monkeypatch.setattr(h3, "get_tensor_model_parallel_world_size", lambda: 1)
+
+    ignored_layers = {
+        "token_refiner.blocks.0.mlp.fc2",
+        "blocks.0.attn.qkv_proj",
+        "condition_proj",
+        "blocks.0.adaln_proj.linear",
+        "final_layer.adaln_proj.linear",
+    }
+    fp8_config = Fp8Config(ignored_layers=sorted(ignored_layers))
+    model = h3.MiniMaxH3DiTModel(
+        _small_od_config(),
+        quant_config=fp8_config,
+    )
+    linears = {module.prefix: module.quant_config for module in model.modules() if isinstance(module, _FakeLinear)}
+
+    quantized = {
+        "token_refiner.blocks.0.attn.qkv_proj",
+        "token_refiner.blocks.0.attn.out_proj",
+        "token_refiner.blocks.0.mlp.fc1",
+        "token_refiner.blocks.0.mlp.fc2",
+        "blocks.0.attn.qkv_proj",
+        "blocks.0.attn.out_proj",
+        "blocks.0.mlp.fc1",
+        "blocks.0.mlp.fc2",
+        "condition_proj",
+        "blocks.0.adaln_proj.linear",
+        "final_layer.adaln_proj.linear",
+    }
+    full_precision = {
+        "video_patch_proj",
+        "audio_patch_proj",
+        "time_embedder.proj_in",
+        "time_embedder.proj_out",
+        "final_layer.video_out",
+        "final_layer.audio_out",
+    }
+
+    assert quantized <= linears.keys()
+    assert full_precision <= linears.keys()
+    assert all(linears[prefix] is fp8_config for prefix in quantized)
+    assert all(linears[prefix] is None for prefix in full_precision)
+    assert {prefix for prefix in quantized if is_layer_skipped(prefix, fp8_config.ignored_layers)} == ignored_layers
+    linear = Mock(spec=LinearBase)
+    assert all(
+        isinstance(
+            fp8_config.get_quant_method(linear, prefix),
+            UnquantizedLinearMethod,
+        )
+        for prefix in ignored_layers
+    )
+
+
+class _WeightTarget(nn.Module):
+    def __init__(self, loader):
+        super().__init__()
+        self.weight = nn.Parameter(torch.empty(1))
+        self.weight.weight_loader = loader
+
+
+def test_model_load_weights_transforms_before_calling_vllm_loader():
+    from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
+        MiniMaxH3DiTArchConfig,
+        MiniMaxH3DiTModel,
+    )
+
+    qkv_calls = []
+    fc1_calls = []
+
+    def qkv_loader(param, loaded_weight):
+        del param
+        qkv_calls.append(loaded_weight.clone())
+
+    def fc1_loader(param, loaded_weight, shard_id):
+        del param
+        fc1_calls.append((shard_id, loaded_weight.clone()))
+
+    model = object.__new__(MiniMaxH3DiTModel)
+    nn.Module.__init__(model)
+    model.arch = MiniMaxH3DiTArchConfig(
+        hidden_size=1,
+        num_attention_heads=2,
+        attention_head_dim=1,
+        ffn_hidden_size=2,
+    )
+    model.blocks = nn.ModuleList([nn.Module()])
+    model.blocks[0].attn = nn.Module()
+    model.blocks[0].attn.qkv_proj = _WeightTarget(qkv_loader)
+    model.blocks[0].mlp = nn.Module()
+    model.blocks[0].mlp.fc1 = _WeightTarget(fc1_loader)
+
+    qkv = torch.arange(6, dtype=torch.float32).reshape(6, 1)
+    fc1 = torch.arange(4, dtype=torch.float32).reshape(4, 1)
+    loaded = model.load_weights(
+        [
+            ("blocks.0.attn.qkv_proj.weight", qkv),
+            ("blocks.0.mlp.fc1.weight", fc1),
+        ]
+    )
+
+    assert loaded == {
+        "blocks.0.attn.qkv_proj.weight",
+        "blocks.0.mlp.fc1.weight",
+    }
+    assert qkv_calls[0][:, 0].tolist() == [0, 3, 1, 4, 2, 5]
+    assert [(shard_id, tensor[:, 0].tolist()) for shard_id, tensor in fc1_calls] == [
+        (0, [0, 1]),
+        (1, [2, 3]),
+    ]
+
+
+def test_pipeline_resolves_transformer_component_quant_config():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_component_quant_config,
+    )
+    from vllm_omni.quantization import build_quant_config
+
+    ignored_layers = ["blocks.0.attn.qkv_proj"]
+    component_config = build_quant_config(
+        {
+            "transformer": {
+                "method": "fp8",
+                "ignored_layers": ignored_layers,
+            }
+        }
+    )
+    transformer_config = component_config.resolve("transformer")
+
+    assert transformer_config.ignored_layers == ignored_layers
+    assert _resolve_component_quant_config(component_config, "transformer") is transformer_config
+    assert _resolve_component_quant_config(transformer_config, "transformer") is transformer_config
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py
new file mode 100644
index 000000000..80d99895f
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py
@@ -0,0 +1,298 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+
+from tests.diffusion.quantization.test_quantization_quality import (
+    _OUTPUT_DIR,
+    QualityTestConfig,
+    _compute_lpips,
+    _compute_psnr_and_mae,
+    _free_gpu_memory,
+    _maybe_save_output,
+)
+from tests.helpers.mark import hardware_marks
+
+_MINIMAX_H3_REPO = "MiniMaxAI/MiniMax-H3"
+_MINIMAX_H3_REVISION = "48d93ede732756e404a3b1b2f3b3a9b5a22f6cfc"
+_MINIMAX_H3_AUDIO_SAMPLE_RATE = 32000
+_MIN_AUDIO_SPECTRAL_COSINE = 0.80
+_MIN_AUDIO_RMS_RATIO = 0.50
+_MAX_AUDIO_RMS_RATIO = 2.00
+
+_QUALITY_CONFIG = QualityTestConfig(
+    id="fp8_minimax_h3_fl2va",
+    model=_MINIMAX_H3_REPO,
+    quantization={"transformer": {"method": "fp8"}},
+    task="t2v",
+    prompt=(
+        "A bright daytime cinematic tracking shot of a golden retriever running through a sunlit meadow "
+        "filled with colorful wildflowers, vivid blue sky, crisp natural colors."
+    ),
+    max_lpips=0.20,
+    height=384,
+    width=672,
+    num_frames=107,
+    num_inference_steps=10,
+)
+
+
+def _resolve_fl2va_model_ref() -> str:
+    from huggingface_hub import snapshot_download
+
+    repo_root = Path(
+        snapshot_download(
+            repo_id=_MINIMAX_H3_REPO,
+            revision=_MINIMAX_H3_REVISION,
+            allow_patterns=["FL2VA/**"],
+        )
+    )
+    fl2va_root = repo_root / "FL2VA"
+    if not (fl2va_root / "model_index.json").is_file():
+        raise FileNotFoundError(f"MiniMax H3 FL2VA model_index.json not found under {repo_root}")
+    return str(fl2va_root)
+
+
+def _canonical_audio(audio: object) -> np.ndarray:
+    """Return H3 audio as float32 [channels, samples]."""
+    array = np.asarray(audio, dtype=np.float32)
+    while array.ndim > 2 and array.shape[0] == 1:
+        array = array[0]
+    if array.ndim == 1:
+        array = array[None, :]
+    if array.ndim != 2:
+        raise ValueError(f"Expected mono/stereo audio, got shape {array.shape}")
+    if array.shape[0] > array.shape[1] and array.shape[1] <= 8:
+        array = array.T
+    if not 1 <= array.shape[0] <= 8:
+        raise ValueError(f"Expected channel-first audio, got shape {array.shape}")
+    if not np.isfinite(array).all():
+        raise ValueError("Audio contains non-finite samples")
+    return np.ascontiguousarray(array)
+
+
+def _audio_quality_metrics(baseline: object, quantized: object) -> tuple[float, float]:
+    """Compare phase-tolerant spectral structure and overall signal energy."""
+    baseline_array = _canonical_audio(baseline)
+    quantized_array = _canonical_audio(quantized)
+    if baseline_array.shape != quantized_array.shape:
+        raise ValueError(
+            "Audio shapes do not match for metric computation: "
+            f"baseline={baseline_array.shape}, quantized={quantized_array.shape}"
+        )
+
+    baseline_tensor = torch.from_numpy(baseline_array)
+    quantized_tensor = torch.from_numpy(quantized_array)
+    similarities: list[float] = []
+    for n_fft in (512, 1024, 2048):
+        window = torch.hann_window(n_fft)
+        baseline_magnitude = torch.stft(
+            baseline_tensor,
+            n_fft=n_fft,
+            hop_length=n_fft // 4,
+            window=window,
+            return_complex=True,
+        ).abs()
+        quantized_magnitude = torch.stft(
+            quantized_tensor,
+            n_fft=n_fft,
+            hop_length=n_fft // 4,
+            window=window,
+            return_complex=True,
+        ).abs()
+        cosine = torch.nn.functional.cosine_similarity(
+            baseline_magnitude.flatten(1),
+            quantized_magnitude.flatten(1),
+            dim=1,
+            eps=1e-12,
+        )
+        similarities.extend(float(value) for value in cosine)
+
+    baseline_rms = float(torch.sqrt(torch.mean(baseline_tensor.square())))
+    quantized_rms = float(torch.sqrt(torch.mean(quantized_tensor.square())))
+    rms_ratio = quantized_rms / max(baseline_rms, 1e-12)
+    return float(np.mean(similarities)), rms_ratio
+
+
+def _generate_joint_output(omni, config: QualityTestConfig):
+    """Generate H3 video/audio, returning both payloads and peak GPU memory."""
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.platforms import current_omni_platform
+
+    generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(config.seed)
+    torch.accelerator.reset_peak_memory_stats()
+    outputs = omni.generate(
+        {"prompt": config.prompt, "negative_prompt": config.negative_prompt},
+        OmniDiffusionSamplingParams(
+            height=config.height,
+            width=config.width,
+            generator=generator,
+            num_inference_steps=config.num_inference_steps,
+            num_frames=config.num_frames,
+            guidance_scale=config.guidance_scale,
+            sigmas=config.sigmas,
+            extra_args={"aspect_ratio": "16:9"},
+        ),
+    )
+    main_process_peak_mem = torch.accelerator.max_memory_allocated() / (1024**3)
+
+    first = outputs[0]
+    worker_peak_memory_mb = float(getattr(first, "peak_memory_mb", 0.0) or 0.0)
+    if hasattr(first, "request_output") and isinstance(first.request_output, list):
+        first = first.request_output[0]
+        worker_peak_memory_mb = max(
+            worker_peak_memory_mb,
+            float(getattr(first, "peak_memory_mb", 0.0) or 0.0),
+        )
+    if not hasattr(first, "images") or not first.images:
+        raise ValueError("Could not extract video frames from H3 output")
+    frames = first.images[0]
+    if isinstance(frames, torch.Tensor):
+        frames = frames.detach().cpu()
+        if frames.dim() == 5:
+            frames = frames[0]
+        if frames.dim() == 4 and frames.shape[0] in (3, 4):
+            frames = frames.permute(1, 2, 3, 0)
+        if frames.is_floating_point():
+            frames = frames.clamp(-1, 1) * 0.5 + 0.5
+        video = frames.float().numpy()
+    else:
+        video = np.asarray(frames)
+        if video.ndim == 5:
+            video = video[0]
+
+    multimodal = getattr(first, "multimodal_output", None)
+    if not multimodal or "audio" not in multimodal:
+        raise ValueError("Could not extract audio from H3 output")
+    sample_rate = int(multimodal.get("audio_sample_rate", 0))
+    peak_mem = worker_peak_memory_mb / 1024 if worker_peak_memory_mb > 0 else main_process_peak_mem
+    return video, _canonical_audio(multimodal["audio"]), sample_rate, peak_mem
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parametrize(
+    "config",
+    [
+        pytest.param(
+            _QUALITY_CONFIG,
+            id=_QUALITY_CONFIG.id,
+            marks=hardware_marks(res={"cuda": _QUALITY_CONFIG.gpu}, num_cards=2),
+        )
+    ],
+)
+def test_minimax_h3_quantization_quality(config: QualityTestConfig):
+    from vllm_omni.entrypoints.omni import Omni
+
+    model_ref = _resolve_fl2va_model_ref()
+    common_kwargs = {
+        "model": model_ref,
+        "enforce_eager": True,
+        "tensor_parallel_size": 2,
+        "text_encoder_tp_size": 2,
+        "vae_use_tiling": True,
+    }
+
+    omni_bl = Omni(**common_kwargs)
+    baseline_out, baseline_audio, baseline_sample_rate, bl_mem = _generate_joint_output(omni_bl, config)
+    omni_bl.shutdown()
+    del omni_bl
+    _free_gpu_memory()
+    _maybe_save_output(_OUTPUT_DIR, config, "baseline", baseline_out)
+
+    quantization = config.quantization_ref()
+    omni_qt = Omni(**common_kwargs, quantization_config=quantization)
+    quant_out, quant_audio, quant_sample_rate, qt_mem = _generate_joint_output(omni_qt, config)
+    omni_qt.shutdown()
+    del omni_qt
+    _free_gpu_memory()
+    _maybe_save_output(_OUTPUT_DIR, config, "quantized", quant_out)
+
+    lpips_score = _compute_lpips(baseline_out, quant_out, config.task)
+    psnr_score, mae_score = _compute_psnr_and_mae(baseline_out, quant_out, config.task)
+    if baseline_sample_rate != _MINIMAX_H3_AUDIO_SAMPLE_RATE or quant_sample_rate != baseline_sample_rate:
+        raise AssertionError(
+            f"Unexpected H3 audio sample rate: baseline={baseline_sample_rate}, quantized={quant_sample_rate}"
+        )
+    audio_spectral_cosine, audio_rms_ratio = _audio_quality_metrics(baseline_audio, quant_audio)
+    assert lpips_score <= config.max_lpips, (
+        f"LPIPS {lpips_score:.4f} exceeds threshold {config.max_lpips} "
+        f"for {config.quantization_ref()} on {config.quantized_ref()}"
+    )
+    assert audio_spectral_cosine >= _MIN_AUDIO_SPECTRAL_COSINE, (
+        f"Audio spectral cosine {audio_spectral_cosine:.4f} is below threshold "
+        f"{_MIN_AUDIO_SPECTRAL_COSINE} for {config.id}"
+    )
+    assert _MIN_AUDIO_RMS_RATIO <= audio_rms_ratio <= _MAX_AUDIO_RMS_RATIO, (
+        f"Audio RMS ratio {audio_rms_ratio:.4f} is outside "
+        f"[{_MIN_AUDIO_RMS_RATIO}, {_MAX_AUDIO_RMS_RATIO}] for {config.id}"
+    )
+
+    mem_reduction = (bl_mem - qt_mem) / bl_mem * 100 if bl_mem > 0 else 0
+    print(f"\n{'=' * 60}")
+    print(f"Quantization Quality: {config.id}")
+    print(f"{'=' * 60}")
+    print(f"  Baseline:      {config.baseline_ref()}")
+    print(f"  Quantized:     {config.quantized_ref()}")
+    print(f"  Method:        {config.quantization_ref()}")
+    print(f"  LPIPS:         {lpips_score:.4f}  (threshold: {config.max_lpips})")
+    print(f"  PSNR:          {psnr_score:.4f} dB  (higher is better)")
+    print(f"  MAE:           {mae_score:.6f}  (lower is better)")
+    print(f"  Audio cosine:  {audio_spectral_cosine:.4f}  (threshold: {_MIN_AUDIO_SPECTRAL_COSINE})")
+    print(f"  Audio RMS:     {audio_rms_ratio:.4f}x  (range: {_MIN_AUDIO_RMS_RATIO}-{_MAX_AUDIO_RMS_RATIO})")
+    print(f"  BF16 memory:   {bl_mem:.2f} GiB")
+    print(f"  Quant memory:  {qt_mem:.2f} GiB  ({mem_reduction:.0f}% reduction)")
+    print("  Result:        PASS")
+    print(f"{'=' * 60}\n")
+
+    assert np.isfinite(psnr_score) or np.isinf(psnr_score), f"PSNR is invalid for {config.id}: {psnr_score}"
+    assert np.isfinite(mae_score), f"MAE is not finite for {config.id}: {mae_score}"
+
+
+def test_resolve_fl2va_model_ref(tmp_path, monkeypatch):
+    fl2va_root = tmp_path / "FL2VA"
+    fl2va_root.mkdir()
+    (fl2va_root / "model_index.json").write_text("{}", encoding="utf-8")
+
+    def fake_snapshot_download(*, repo_id, revision, allow_patterns):
+        assert repo_id == _MINIMAX_H3_REPO
+        assert revision == _MINIMAX_H3_REVISION
+        assert allow_patterns == ["FL2VA/**"]
+        return str(tmp_path)
+
+    monkeypatch.setattr("huggingface_hub.snapshot_download", fake_snapshot_download)
+    assert _resolve_fl2va_model_ref() == str(fl2va_root)
+
+
+def test_audio_quality_metrics_ignore_phase_but_reject_spectral_drift():
+    sample_rate = _MINIMAX_H3_AUDIO_SAMPLE_RATE
+    time = np.arange(sample_rate, dtype=np.float32) / sample_rate
+    baseline = np.stack(
+        [
+            np.sin(2 * np.pi * 440 * time),
+            np.sin(2 * np.pi * 880 * time),
+        ]
+    )
+    phase_shifted = np.stack(
+        [
+            np.sin(2 * np.pi * 440 * time + np.pi / 2),
+            np.sin(2 * np.pi * 880 * time + np.pi / 2),
+        ]
+    )
+    different = np.stack(
+        [
+            np.sin(2 * np.pi * 3000 * time),
+            np.sin(2 * np.pi * 4000 * time),
+        ]
+    )
+
+    phase_cosine, phase_rms_ratio = _audio_quality_metrics(baseline, phase_shifted)
+    different_cosine, _ = _audio_quality_metrics(baseline, different)
+
+    assert phase_cosine >= _MIN_AUDIO_SPECTRAL_COSINE
+    assert phase_rms_ratio == pytest.approx(1.0, abs=1e-5)
+    assert different_cosine < _MIN_AUDIO_SPECTRAL_COSINE
diff --git a/tests/diffusion/models/mistral_encoder/test_mistral_encoder_tp.py b/tests/diffusion/models/mistral_encoder/test_mistral_encoder_tp.py
index 27d1e757e..20024abe7 100644
--- a/tests/diffusion/models/mistral_encoder/test_mistral_encoder_tp.py
+++ b/tests/diffusion/models/mistral_encoder/test_mistral_encoder_tp.py
@@ -5,6 +5,7 @@ from types import SimpleNamespace
 import pytest
 import torch
 from vllm.config import DeviceConfig, VllmConfig, set_current_vllm_config
+from vllm.model_executor.layers.linear import UnquantizedLinearMethod
 
 from vllm_omni.diffusion.models.mistral_encoder.mistral_encoder import (
     MistralEncoderModel,
@@ -491,3 +492,57 @@ class TestComputeLogits:
         assert logits.dim() == 3
         assert logits.shape[0] == 1
         assert logits.shape[1] == 4
+
+
+class TestQuantConfig:
+    """Verify quant_config is threaded into weight linears only, with correct prefixes."""
+
+    def test_quant_config_on_weight_linears(self, mocker):
+        quant_config = mocker.MagicMock(name="QuantizationConfig")
+        # Keep construction on the CPU-safe unquantized path while still
+        # verifying LinearBase consults the supplied quant_config.
+        quant_config.get_quant_method.return_value = UnquantizedLinearMethod()
+
+        config = _make_config(num_hidden_layers=1)
+        model = MistralEncoderModel(config, prefix="text_encoder", quant_config=quant_config)
+
+        layer = model.language_model.model.layers[0]
+        for linear in (
+            layer.self_attn.qkv_proj,
+            layer.self_attn.o_proj,
+            layer.mlp.gate_up_proj,
+            layer.mlp.down_proj,
+        ):
+            assert linear.quant_config is quant_config
+
+        # get_quant_method should be consulted for the four weight linears.
+        assert quant_config.get_quant_method.call_count == 4
+        seen_prefixes = set()
+        for call in quant_config.get_quant_method.call_args_list:
+            if "prefix" in call.kwargs:
+                seen_prefixes.add(call.kwargs["prefix"])
+            elif len(call.args) > 1:
+                seen_prefixes.add(call.args[1])
+        assert any(p.endswith("self_attn.qkv_proj") for p in seen_prefixes)
+        assert any(p.endswith("self_attn.o_proj") for p in seen_prefixes)
+        assert any(p.endswith("mlp.gate_up_proj") for p in seen_prefixes)
+        assert any(p.endswith("mlp.down_proj") for p in seen_prefixes)
+
+        # Embeddings / lm_head stay unquantized (quant_config never passed).
+        embed = model.language_model.model.embed_tokens
+        lm_head = model.language_model.lm_head
+        assert getattr(embed, "quant_config", None) is None
+        assert getattr(lm_head, "quant_config", None) is None
+
+    def test_layer_prefixes_include_text_encoder(self):
+        config = _make_config(num_hidden_layers=2)
+        model = MistralEncoderModel(config, prefix="text_encoder")
+
+        layer0 = model.language_model.model.layers[0]
+        assert layer0.self_attn.qkv_proj.prefix.startswith("text_encoder.language_model.model.layers.0")
+        assert layer0.self_attn.o_proj.prefix.startswith("text_encoder.language_model.model.layers.0")
+        assert layer0.mlp.gate_up_proj.prefix.startswith("text_encoder.language_model.model.layers.0")
+        assert layer0.mlp.down_proj.prefix.startswith("text_encoder.language_model.model.layers.0")
+
+        layer1 = model.language_model.model.layers[1]
+        assert "layers.1" in layer1.self_attn.qkv_proj.prefix
diff --git a/tests/diffusion/models/sensenova_u1/test_sensenova_u1_cfg.py b/tests/diffusion/models/sensenova_u1/test_sensenova_u1_cfg.py
index 818d3d7c0..276e9e059 100644
--- a/tests/diffusion/models/sensenova_u1/test_sensenova_u1_cfg.py
+++ b/tests/diffusion/models/sensenova_u1/test_sensenova_u1_cfg.py
@@ -6,6 +6,8 @@ import torch
 
 from vllm_omni.diffusion.models.sensenova_u1.pipeline_sensenova_u1 import SenseNovaU1Pipeline
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def _pipeline_without_init() -> SenseNovaU1Pipeline:
     return object.__new__(SenseNovaU1Pipeline)
diff --git a/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py b/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
index 198c31908..8c06df034 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
@@ -9,7 +9,9 @@ import torch
 from torch import nn
 
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import Wan22Pipeline
+from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
@@ -91,7 +93,20 @@ def _make_pipeline() -> Wan22Pipeline:
     return pipeline
 
 
-def test_forward_delegates_denoising_to_diffuse() -> None:
+@pytest.mark.parametrize(
+    ("sampling_params_kwargs", "expected_low", "expected_high"),
+    [
+        ({}, 4.0, 4.0),
+        ({"guidance_scale": 0.0}, 0.0, 0.0),
+        ({"guidance_scale": 1.0}, 1.0, 1.0),
+        ({"guidance_scale": 3.0, "guidance_scale_2": 5.0}, 3.0, 5.0),
+    ],
+)
+def test_forward_delegates_denoising_to_diffuse(
+    sampling_params_kwargs: dict[str, float],
+    expected_low: float,
+    expected_high: float,
+) -> None:
     pipeline = _make_pipeline()
     captured: dict[str, object] = {}
 
@@ -101,25 +116,15 @@ def test_forward_delegates_denoising_to_diffuse() -> None:
 
     pipeline.diffuse = _fake_diffuse  # type: ignore[method-assign]
 
-    mock_req = SimpleNamespace(
+    mock_req = OmniDiffusionRequest(
         prompt="prompt",
         request_id="test-req",
-        sampling_params=SimpleNamespace(
-            height=None,
-            width=None,
+        sampling_params=OmniDiffusionSamplingParams(
             num_frames=1,
             num_inference_steps=2,
-            guidance_scale_provided=True,
-            guidance_scale=1.0,
-            guidance_scale_2=None,
-            boundary_ratio=None,
-            generator=None,
-            seed=None,
-            num_outputs_per_prompt=1,
             max_sequence_length=32,
-            latents=None,
             output_type="latent",
-            extra_args={},
+            **sampling_params_kwargs,
         ),
     )
     batch = DiffusionRequestBatch(requests=[mock_req])
@@ -129,8 +134,8 @@ def test_forward_delegates_denoising_to_diffuse() -> None:
     assert torch.equal(output.output, torch.ones((1, 4, 1, 8, 8)))
     assert torch.equal(captured["prompt_embeds"], torch.zeros(1, 32, 8))
     assert torch.equal(captured["timesteps"], pipeline.scheduler.timesteps)
-    assert captured["guidance_low"] == 1.0
-    assert captured["guidance_high"] == 1.0
+    assert captured["guidance_low"] == expected_low
+    assert captured["guidance_high"] == expected_high
     assert captured["boundary_timestep"] == pytest.approx(875.0)
     assert captured["latent_condition"] is None
     assert captured["first_frame_mask"] is None
diff --git a/tests/diffusion/offloader/test_diffusion_cpu_offload.py b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
index 22f6839fd..549a98142 100644
--- a/tests/diffusion/offloader/test_diffusion_cpu_offload.py
+++ b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
@@ -5,7 +5,6 @@ import pytest
 import torch
 from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
 
-from tests.helpers import skip_if_gated_repo_inaccessible
 from tests.helpers.env import DeviceMemoryMonitor
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
@@ -16,25 +15,26 @@ AUDIO_MODEL = {
     "stabilityai/stable-audio-open-1.0": {"cuda": 100, "rocm": None},
 }
 
-IMAGE_VIDEO_MODELS = {
+IMAGE_MODELS = {
     "riverclouds/qwen_image_random": {"cuda": 2200, "rocm": 2100},
-    "Tongyi-MAI/Z-Image-Turbo": {"cuda": 2500, "rocm": 2100},
-    "OmniGen2/OmniGen2": {"cuda": 2500, "rocm": 2100},
 }
 
-MODELS = {**AUDIO_MODEL, **IMAGE_VIDEO_MODELS}
+MODELS = {**AUDIO_MODEL, **IMAGE_MODELS}
+
+MODEL_MARKS = {
+    "riverclouds/qwen_image_random": pytest.mark.core_model,
+    "stabilityai/stable-audio-open-1.0": pytest.mark.full_model,
+}
 
 _GATED_MODELS = {"stabilityai/stable-audio-open-1.0"}
 
-# Aliased for backward compatibility (imported by test_diffusion_layerwise_offload.py).
-_skip_if_gated_repo_inaccessible = skip_if_gated_repo_inaccessible
 
 AUDIO_MODEL_PARAMS = {
     "runner_params": {},
     "sampler_params": {},
 }
 
-IMAGE_VIDEO_MODELS_PARAMS = {
+IMAGE_MODEL_PARAMS = {
     "runner_params": {},
     "sampler_params": {
         "height": 256,
@@ -53,7 +53,7 @@ def inference(model_name: str, offload: bool = True):
     if model_name in AUDIO_MODEL:
         params = AUDIO_MODEL_PARAMS
     else:
-        params = IMAGE_VIDEO_MODELS_PARAMS
+        params = IMAGE_MODEL_PARAMS
 
     with OmniRunner(
         model_name,
@@ -97,24 +97,19 @@ def check_audio_determinism(audio1, audio2, atol=1e-2):
     return True
 
 
-@pytest.mark.core_model
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "L4", "rocm": "MI325"})
-@pytest.mark.parametrize("model_name", list(MODELS.keys()))
+@pytest.mark.parametrize(
+    "model_name",
+    [pytest.param(name, marks=MODEL_MARKS[name]) for name in MODELS],
+)
 def test_cpu_offload_diffusion_model(model_name: str):
-    if model_name == "OmniGen2/OmniGen2":
-        pytest.skip("issue #4537")
-    if model_name in _GATED_MODELS:
-        _skip_if_gated_repo_inaccessible(model_name)
     try:
         offload_peak_memory, output_offload = inference(model_name, offload=True)
         cleanup_dist_env_and_memory()
         no_offload_peak_memory, output_no_offload = inference(model_name, offload=False)
     except ValueError as exc:
-        # omni_snapshot_download wraps GatedRepoError in a ValueError.
-        # If the pre-flight guard above did not catch it (e.g. partial
-        # HF_TOKEN where config.json is accessible but weight shards are
-        # blocked), skip instead of failing.
+        # omni_snapshot_download wraps GatedRepoError in a ValueError; skip instead of failing.
         if "Access to model" in str(exc) and "is restricted" in str(exc):
             pytest.skip(
                 f"Skipping: gated HF repo {model_name!r} inaccessible "
diff --git a/tests/diffusion/offloader/test_diffusion_layerwise_offload.py b/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
index f02da6fab..342c9833b 100644
--- a/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
+++ b/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
@@ -3,11 +3,8 @@ import pytest
 import torch
 from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
 
-from tests.diffusion.offloader.test_diffusion_cpu_offload import (
-    _GATED_MODELS,
-    _skip_if_gated_repo_inaccessible,
-)
 from tests.helpers.env import DeviceMemoryMonitor
+from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.platforms import current_omni_platform
@@ -23,6 +20,19 @@ IMAGE_VIDEO_MODELS = {
 
 MODELS = {**AUDIO_MODEL, **IMAGE_VIDEO_MODELS}
 
+LAYERWISE_MODEL_CASES = [
+    pytest.param(
+        "stabilityai/stable-audio-open-1.0",
+        marks=[pytest.mark.full_model, pytest.mark.diffusion],
+        id="stable_audio",
+    ),
+    pytest.param(
+        "riverclouds/qwen_image_random",
+        marks=[pytest.mark.core_model, pytest.mark.diffusion],
+        id="qwen_image_random",
+    ),
+]
+
 AUDIO_MODEL_PARAMS = {
     "runner_params": {},
     "sampler_params": {},
@@ -91,7 +101,8 @@ def run_inference(
     return peak, output
 
 
-@pytest.mark.parametrize("model_name", list(MODELS.keys()))
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"})
+@pytest.mark.parametrize("model_name", LAYERWISE_MODEL_CASES)
 def test_layerwise_offload_diffusion_model(model_name: str):
     """Test that layerwise offloading reduces GPU memory usage.
 
@@ -100,8 +111,6 @@ def test_layerwise_offload_diffusion_model(model_name: str):
     offloader keeps only a single transformer block on GPU at a time, with
     prefetching for compute-memory overlap.
     """
-    if model_name in _GATED_MODELS:
-        _skip_if_gated_repo_inaccessible(model_name)
     try:
         # Run without layerwise offloading (baseline)
         no_offload_peak_memory, output_no_offload = run_inference(model_name, layerwise_offload=False)
@@ -111,10 +120,7 @@ def test_layerwise_offload_diffusion_model(model_name: str):
         layerwise_offload_peak_memory, output_offload = run_inference(model_name, layerwise_offload=True)
         cleanup_dist_env_and_memory()
     except ValueError as exc:
-        # omni_snapshot_download wraps GatedRepoError in a ValueError.
-        # If the pre-flight guard above did not catch it (e.g. partial
-        # HF_TOKEN where config.json is accessible but weight shards are
-        # blocked), skip instead of failing.
+        # omni_snapshot_download wraps GatedRepoError in a ValueError; skip instead of failing.
         if "Access to model" in str(exc) and "is restricted" in str(exc):
             pytest.skip(
                 f"Skipping: gated HF repo {model_name!r} inaccessible "
diff --git a/tests/diffusion/offloader/test_distributed_layerwise_backend.py b/tests/diffusion/offloader/test_distributed_layerwise_backend.py
new file mode 100644
index 000000000..fd004d056
--- /dev/null
+++ b/tests/diffusion/offloader/test_distributed_layerwise_backend.py
@@ -0,0 +1,1331 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Unit tests for DistributedLayerwiseOffloadHook and backend utilities."""
+
+import gc
+import json
+import os
+import socket
+from contextlib import contextmanager
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.distributed as dist
+from safetensors.torch import save_file
+from torch import nn
+from torch.distributed.tensor import DeviceMesh, DTensor, Replicate
+
+import vllm_omni.diffusion.offloader.distributed_layerwise_backend as dist_backend_module
+from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+from vllm_omni.diffusion.offloader.block_discovery import (
+    get_blocks_attr_names,
+    get_blocks_from_dit,
+    set_blocks_attr_names,
+)
+from vllm_omni.diffusion.offloader.distributed_layerwise_backend import (
+    DistributedLayerwiseOffloadBackend,
+    DistributedLayerwiseOffloadHook,
+    PinnedResidentLayerGroup,
+)
+from vllm_omni.diffusion.offloader.module_residency import PinnedModuleStager
+from vllm_omni.diffusion.offloader.offload_plan import OffloadPlan, get_offload_plan
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
+
+
+class DummyStream:
+    def wait_stream(self, _stream) -> None:
+        return None
+
+    def wait_event(self, _event) -> None:
+        return None
+
+
+class DummyEvent:
+    def record(self, _stream) -> None:
+        return None
+
+
+@contextmanager
+def dummy_stream(_stream):
+    yield None
+
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return int(s.getsockname()[1])
+
+
+def _set_dist_env(*, rank: int, world_size: int, master_port: int) -> None:
+    os.environ["RANK"] = str(rank)
+    os.environ["LOCAL_RANK"] = str(rank)
+    os.environ["WORLD_SIZE"] = str(world_size)
+    os.environ["MASTER_ADDR"] = "127.0.0.1"
+    os.environ["MASTER_PORT"] = str(master_port)
+
+
+def _cleanup_distributed() -> None:
+    if dist.is_initialized():
+        dist.destroy_process_group()
+
+    for key in ["MASTER_ADDR", "MASTER_PORT", "RANK", "WORLD_SIZE", "LOCAL_RANK"]:
+        os.environ.pop(key, None)
+
+    gc.collect()
+    if current_omni_platform.is_available():
+        current_omni_platform.empty_cache()
+        current_omni_platform.synchronize()
+
+
+@pytest.fixture(scope="module")
+def dist_group():
+    master_port = _find_free_port()
+    _set_dist_env(rank=0, world_size=1, master_port=master_port)
+
+    dist.init_process_group("gloo", rank=0, world_size=1)
+    try:
+        yield
+    finally:
+        _cleanup_distributed()
+
+
+@pytest.fixture
+def patched_offload_runtime(monkeypatch):
+    monkeypatch.setattr(dist_backend_module.current_omni_platform, "Stream", DummyStream)
+    monkeypatch.setattr(dist_backend_module.current_omni_platform, "Event", DummyEvent)
+    monkeypatch.setattr(dist_backend_module.current_omni_platform, "current_stream", lambda: DummyStream())
+    monkeypatch.setattr(dist_backend_module.current_omni_platform, "stream", dummy_stream)
+    monkeypatch.setattr(dist_backend_module.current_omni_platform, "synchronize", lambda: None)
+
+
+class TinyBlock(nn.Module):
+    def __init__(self, values: torch.Tensor):
+        super().__init__()
+        mesh = DeviceMesh("cpu", [0])
+        dtensor = DTensor.from_local(values, mesh, [Replicate()])
+        self.weight = nn.Parameter(dtensor)
+
+
+def _make_values(start: float) -> torch.Tensor:
+    return torch.arange(start, start + 4, dtype=torch.float32)
+
+
+class TestDistributedLayerwiseOffloadHook:
+    def test_shard_and_pin_single_rank(self, dist_group, patched_offload_runtime):
+        """With dp_size=1, the shard should equal the full weights."""
+        current_block = TinyBlock(_make_values(1.0))
+        next_block = TinyBlock(_make_values(10.0))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+
+        hook.initialize_hook(current_block)
+
+        # With dp_size=1, the CPU shard should contain all 4 elements
+        assert next_block.weight.dtype in hook.cpu_shards
+        shard = hook.cpu_shards[next_block.weight.dtype]
+        assert shard.numel() == 4
+        assert torch.equal(shard, _make_values(10.0))
+
+    def test_dtensor_wrapper_preserved_across_prefetch_and_offload(self, dist_group, patched_offload_runtime):
+        """DTensor wrapper should be preserved through prefetch/offload cycle."""
+        current_block = TinyBlock(_make_values(1.0))
+        next_block = TinyBlock(_make_values(10.0))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+
+        hook.initialize_hook(current_block)
+
+        # After init, next_block weights should be placeholders
+        assert isinstance(next_block.weight, DTensor)
+        assert next_block.weight.to_local().is_meta
+
+        # Prefetch into slot 0
+        hook.prefetch_layer(slot=0, non_blocking=False)
+
+        # After prefetch, next_block weights should be materialized
+        assert isinstance(next_block.weight, DTensor)
+        assert torch.equal(next_block.weight.to_local(), _make_values(10.0))
+
+        # Offload current block
+        hook.offload_layer()
+        assert isinstance(current_block.weight, DTensor)
+        assert current_block.weight.to_local().is_meta
+        assert not hook.is_materialized
+
+    def test_double_buffer_slot_swapping(self, dist_group, patched_offload_runtime):
+        """Verify slot swapping works correctly after each layer."""
+        current_block = TinyBlock(_make_values(1.0))
+        next_block = TinyBlock(_make_values(10.0))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+
+        hook.initialize_hook(current_block)
+
+        assert hook.current_slot == 0
+
+        # Prefetch into slot 1 (next slot)
+        hook.prefetch_layer(slot=1, non_blocking=False)
+
+        # Simulate post_forward: offload + swap
+        hook.offload_layer()
+        hook.current_slot = 1 - hook.current_slot
+
+        assert hook.current_slot == 1
+
+        # Next iteration: prefetch into slot 0
+        hook.prefetch_layer(slot=0, non_blocking=False)
+        hook.offload_layer()
+        hook.current_slot = 1 - hook.current_slot
+
+        assert hook.current_slot == 0
+
+    def test_device_buffers_allocated(self, dist_group, patched_offload_runtime):
+        """Verify exactly two device buffers are allocated."""
+        current_block = TinyBlock(_make_values(1.0))
+        next_block = TinyBlock(_make_values(10.0))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            pin_memory=False,
+        )
+
+        hook.initialize_hook(current_block)
+
+        # Two slots should be allocated
+        assert hook.gpu_buffers[0] is not None
+        assert hook.gpu_buffers[1] is not None
+
+        # Each slot should have one dtype entry (float32)
+        assert len(hook.gpu_buffers[0]) == 1
+        assert len(hook.gpu_buffers[1]) == 1
+
+        # Buffer size should match total numel
+        dtype = next_block.weight.dtype
+        assert hook.gpu_buffers[0][dtype].numel() == 4
+        assert hook.gpu_buffers[1][dtype].numel() == 4
+
+    def test_sharding_multiple_ranks(self, dist_group, patched_offload_runtime):
+        """Verify weight sharding splits correctly across ranks."""
+        block = nn.Module()
+        block.weight = nn.Parameter(torch.arange(8, dtype=torch.float32))
+
+        next_block = nn.Module()
+        next_block.weight = nn.Parameter(torch.arange(100, 108, dtype=torch.float32))
+
+        # Simulate dp_size=4, rank=1
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=4,
+            rank=1,
+            pin_memory=False,
+        )
+
+        hook.initialize_hook(block)
+
+        shard = hook.cpu_shards[torch.float32]
+        # 8 elements / 4 ranks = 2 elements per shard
+        assert shard.numel() == 2
+        # Rank 1 should have elements [102, 103]
+        assert torch.equal(shard, torch.tensor([102.0, 103.0]))
+
+    def test_sharding_with_remainder(self, dist_group, patched_offload_runtime):
+        """Verify sharding handles non-even division with padding."""
+        block = nn.Module()
+        block.weight = nn.Parameter(torch.arange(3, dtype=torch.float32))
+
+        next_block = nn.Module()
+        next_block.weight = nn.Parameter(torch.arange(100, 103, dtype=torch.float32))
+
+        # 3 elements, dp_size=2: both ranks get ceil(3/2)=2 elements (padded)
+        hook0 = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=2,
+            rank=0,
+            pin_memory=False,
+        )
+        # Need fresh next_block for each hook since init replaces tensors
+        next_block0 = nn.Module()
+        next_block0.weight = nn.Parameter(torch.arange(100, 103, dtype=torch.float32))
+        hook0.next_block = next_block0
+        hook0.initialize_hook(block)
+
+        shard0 = hook0.cpu_shards[torch.float32]
+        assert shard0.numel() == 2
+        assert torch.equal(shard0, torch.tensor([100.0, 101.0]))
+
+        next_block1 = nn.Module()
+        next_block1.weight = nn.Parameter(torch.arange(100, 103, dtype=torch.float32))
+        block1 = nn.Module()
+        block1.weight = nn.Parameter(torch.arange(3, dtype=torch.float32))
+        hook1 = DistributedLayerwiseOffloadHook(
+            next_block=next_block1,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=2,
+            rank=1,
+            pin_memory=False,
+        )
+        hook1.initialize_hook(block1)
+
+        shard1 = hook1.cpu_shards[torch.float32]
+        # Equal-sized shards: rank 1 gets [102, 0] (zero-padded)
+        assert shard1.numel() == 2
+        assert torch.equal(shard1, torch.tensor([102.0, 0.0]))
+
+    def test_mmap_layout_transform_is_applied_before_sharding(self, dist_group, patched_offload_runtime):
+        block = nn.Module()
+        block.weight = nn.Parameter(torch.zeros(4, dtype=torch.float32))
+        next_block = nn.Module()
+        next_block.weight = nn.Parameter(torch.arange(4, dtype=torch.float32))
+        next_block.weight.mmap_weight_transform = lambda tensor: tensor.flip(0)
+        next_block.weight.mmap_weight_transform_pending = True
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=2,
+            rank=0,
+            pin_memory=False,
+        )
+        hook.initialize_hook(block)
+
+        assert torch.equal(hook.cpu_shards[torch.float32], torch.tensor([3.0, 2.0]))
+
+    def test_regular_loader_weight_does_not_reapply_mmap_transform(self, dist_group, patched_offload_runtime):
+        block = nn.Module()
+        block.weight = nn.Parameter(torch.zeros(4, dtype=torch.float32))
+        next_block = nn.Module()
+        next_block.weight = nn.Parameter(torch.arange(4, dtype=torch.float32))
+        next_block.weight.mmap_weight_transform = lambda tensor: tensor.flip(0)
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=2,
+            rank=0,
+            pin_memory=False,
+        )
+        hook.initialize_hook(block)
+
+        assert torch.equal(hook.cpu_shards[torch.float32], torch.tensor([0.0, 1.0]))
+
+
+class TestPinnedResidentLayerGroup:
+    def test_load_offload_reuses_pinned_master_weights(self, patched_offload_runtime):
+        blocks = [nn.Linear(2, 2), nn.Linear(2, 2)]
+        expected = []
+        for index, block in enumerate(blocks):
+            block.weight.data.fill_(index + 1)
+            block.bias.data.fill_(index + 3)
+            expected.append((block.weight.detach().clone(), block.bias.detach().clone()))
+
+        group = PinnedResidentLayerGroup(
+            blocks,
+            device=torch.device("cpu"),
+            copy_stream=DummyStream(),
+            pin_memory=False,
+        )
+
+        assert all(block.weight.numel() == 0 for block in blocks)
+
+        group.load()
+        for block, (weight, bias) in zip(blocks, expected):
+            assert torch.equal(block.weight, weight)
+            assert torch.equal(block.bias, bias)
+
+        # Device-side changes must not overwrite the persistent host master.
+        blocks[0].weight.data.zero_()
+        group.offload()
+        assert all(block.weight.numel() == 0 for block in blocks)
+
+        group.load()
+        for block, (weight, bias) in zip(blocks, expected):
+            assert torch.equal(block.weight, weight)
+            assert torch.equal(block.bias, bias)
+
+        group.offload()
+
+    def test_mmap_loader_attrs_survive_to_empty_parameter_replacement(self):
+        module = nn.Linear(2, 2, bias=False)
+
+        def transform(tensor):
+            return tensor.flip(0)
+
+        module.weight.mmap_weight_transform = transform
+
+        backend = object.__new__(DistributedLayerwiseOffloadBackend)
+        backend._remember_mmap_param_attrs(module)
+        module.to_empty(device="meta")
+
+        replacement = nn.Parameter(torch.arange(4).reshape(2, 2).float())
+        backend._attach_mmap_param_attrs("weight", replacement, module.weight)
+
+        assert replacement.mmap_weight_transform is transform
+        assert replacement.mmap_weight_transform_pending is True
+
+    def test_shared_allgather_output_is_narrowed_to_current_block(
+        self, dist_group, patched_offload_runtime, monkeypatch
+    ):
+        block = nn.Module()
+        block.weight = nn.Parameter(torch.zeros(3, dtype=torch.float32))
+        next_block = nn.Module()
+        next_block.weight = nn.Parameter(torch.arange(3, dtype=torch.float32))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=object(),
+            dp_size=2,
+            rank=0,
+            pin_memory=False,
+        )
+        hook.initialize_hook(block)
+        # Simulate unified buffers sized for a larger heterogeneous block.
+        hook.gpu_buffers = [
+            {torch.float32: torch.empty(12)},
+            {torch.float32: torch.empty(12)},
+        ]
+        hook.gpu_shard_buffers = [
+            {torch.float32: torch.empty(6)},
+            {torch.float32: torch.empty(6)},
+        ]
+        output_sizes = []
+
+        def fake_allgather(output, local_shard, *, group):
+            del group
+            output_sizes.append(output.numel())
+            output.zero_()
+            output[: local_shard.numel()].copy_(local_shard)
+
+        monkeypatch.setattr(torch.distributed, "all_gather_into_tensor", fake_allgather)
+
+        hook.prefetch_layer(slot=0, non_blocking=False)
+
+        assert output_sizes == [4]
+
+
+class TestPinnedModuleStager:
+    def test_offload_rebinds_immutable_cpu_master(self, patched_offload_runtime):
+        module = nn.Linear(2, 2)
+        expected_weight = module.weight.detach().clone()
+        expected_bias = module.bias.detach().clone()
+        stager = PinnedModuleStager(
+            module,
+            torch.device("cpu"),
+            pin_memory=False,
+            copy_stream=DummyStream(),
+        )
+
+        stager.load()
+        module.weight.data.zero_()
+        module.bias.data.zero_()
+        stager.offload()
+
+        assert torch.equal(module.weight, expected_weight)
+        assert torch.equal(module.bias, expected_bias)
+        stager.load()
+        assert torch.equal(module.weight, expected_weight)
+        assert torch.equal(module.bias, expected_bias)
+        stager.offload()
+
+
+class _DummyBlock(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.weight = nn.Parameter(torch.randn(10, 10))
+
+
+class _SingleBlockModel(nn.Module):
+    _layerwise_offload_blocks_attrs = ["blocks"]
+
+    def __init__(self, num_blocks: int = 3):
+        super().__init__()
+        self.blocks = nn.ModuleList([_DummyBlock() for _ in range(num_blocks)])
+
+
+class _MultiBlockModel(nn.Module):
+    _layerwise_offload_blocks_attrs = ["transformer_blocks", "single_transformer_blocks"]
+
+    def __init__(self, num_transformer: int = 2, num_single: int = 2):
+        super().__init__()
+        self.transformer_blocks = nn.ModuleList([_DummyBlock() for _ in range(num_transformer)])
+        self.single_transformer_blocks = nn.ModuleList([_DummyBlock() for _ in range(num_single)])
+
+
+class _EmptyBlocksModel(nn.Module):
+    _layerwise_offload_blocks_attrs = ["blocks"]
+
+    def __init__(self):
+        super().__init__()
+        self.blocks = nn.ModuleList([])
+
+
+class _NoAttrsModel(nn.Module):
+    def __init__(self, num_blocks: int = 2):
+        super().__init__()
+        self.blocks = nn.ModuleList([_DummyBlock() for _ in range(num_blocks)])
+
+
+class _MmapPostLoadModel(nn.Module):
+    _layerwise_offload_blocks_attrs = ["blocks"]
+
+    def __init__(self):
+        super().__init__()
+        self.time_embedder = nn.Linear(2, 2, bias=False)
+        self.blocks = nn.ModuleList([nn.Linear(2, 2, bias=False) for _ in range(2)])
+        self.post_load_calls = 0
+
+    def post_load_weights(self) -> None:
+        self.time_embedder.to(torch.float32)
+        self.post_load_calls += 1
+
+
+class _MmapPostLoadPipeline(nn.Module):
+    def __init__(self):
+        super().__init__()
+        with torch.device("meta"):
+            self.transformer = _MmapPostLoadModel()
+
+    @staticmethod
+    def _remap_ckpt_key(key: str) -> str:
+        return key
+
+
+class TestMmapWeightLoading:
+    def test_runs_model_post_load_hook(self, tmp_path, patched_offload_runtime):
+        pipeline = _MmapPostLoadPipeline()
+        weights = {name: torch.ones(param.shape, dtype=torch.bfloat16) for name, param in pipeline.named_parameters()}
+        weight_file = tmp_path / "model.safetensors"
+        save_file(weights, str(weight_file))
+        weight_map = {name: weight_file.name for name in weights}
+        (tmp_path / "model.safetensors.index.json").write_text(json.dumps({"weight_map": weight_map}))
+
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+                pin_cpu_memory=False,
+                model_path=str(tmp_path),
+            ),
+            torch.device("cpu"),
+        )
+        modules = SimpleNamespace(
+            dits=[pipeline.transformer],
+            dit_names=["transformer"],
+        )
+
+        backend._load_weights_via_mmap(pipeline, modules)
+
+        assert pipeline.transformer.post_load_calls == 1
+        assert pipeline.transformer.time_embedder.weight.dtype == torch.float32
+        assert pipeline.transformer.blocks[0].weight.dtype == torch.bfloat16
+
+
+class TestGetBlocksFromDit:
+    def test_get_blocks_from_dit_single_block_attr(self):
+        model = _SingleBlockModel(num_blocks=3)
+        attr_names, blocks = get_blocks_from_dit(model)
+        assert attr_names == ["blocks"]
+        assert len(blocks) == 3
+        assert all(isinstance(b, _DummyBlock) for b in blocks)
+
+    def test_get_blocks_from_dit_multi_block_attrs(self):
+        model = _MultiBlockModel(num_transformer=2, num_single=3)
+        attr_names, blocks = get_blocks_from_dit(model)
+        assert set(attr_names) == {"transformer_blocks", "single_transformer_blocks"}
+        assert len(blocks) == 5
+
+    def test_get_blocks_from_dit_empty_blocks(self):
+        model = _EmptyBlocksModel()
+        attr_names, blocks = get_blocks_from_dit(model)
+        assert attr_names == []
+        assert blocks == []
+
+    def test_get_blocks_from_dit_no_attrs_defined(self):
+        model = _NoAttrsModel(num_blocks=3)
+        attr_names, blocks = get_blocks_from_dit(model)
+        assert attr_names == []
+        assert blocks == []
+
+
+class TestGetBlocksAttrNames:
+    def test_get_blocks_attr_names_new_format(self):
+        model = _MultiBlockModel()
+        attrs = get_blocks_attr_names(model)
+        assert attrs == ["transformer_blocks", "single_transformer_blocks"]
+
+    def test_get_blocks_attr_names_no_attrs(self):
+        model = _NoAttrsModel()
+        attrs = get_blocks_attr_names(model)
+        assert attrs == []
+
+    def test_set_blocks_attr_names(self):
+        model = _NoAttrsModel()
+        set_blocks_attr_names(model, ["new_blocks"])
+        assert hasattr(model.__class__, "_layerwise_offload_blocks_attrs")
+        assert model.__class__._layerwise_offload_blocks_attrs == ["new_blocks"]
+
+
+class TestCrossGroupSharedBuffer:
+    """Regression test: when multiple DiT groups share the same 2 GPU
+    buffers, the first block of each group must always sync-prefetch on
+    entry, because another group may have overwritten the shared slot.
+    """
+
+    def test_group_first_hook_forces_sync_prefetch(self, dist_group, patched_offload_runtime):
+        """Verify _is_group_first=True forces sync-prefetch in pre_forward
+        even when is_materialized returns True."""
+        block_a = TinyBlock(_make_values(1.0))
+        block_b = TinyBlock(_make_values(10.0))
+
+        hook_a = DistributedLayerwiseOffloadHook(
+            next_block=block_b,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            pin_memory=False,
+        )
+        hook_a.initialize_hook(block_a)
+
+        # Prefetch to make block_a "materialized" (non-empty params)
+        hook_a.prefetch_layer(hook_a.current_slot, non_blocking=False)
+        assert hook_a.is_materialized
+
+        # Track sync-prefetch calls
+        sync_called = [False]
+        orig = hook_a.prefetch_layer
+
+        def tracking(slot, non_blocking=True):
+            if not non_blocking:
+                sync_called[0] = True
+            orig(slot, non_blocking=non_blocking)
+
+        hook_a.prefetch_layer = tracking
+
+        # Case 1: _is_group_first=False, materialized → no sync-prefetch
+        hook_a._is_group_first = False
+        sync_called[0] = False
+        hook_a.pre_forward(block_a)
+        assert not sync_called[0], "Materialized block should not sync-prefetch without _is_group_first"
+
+        # Case 2: _is_group_first=True, materialized, slot contaminated
+        # (no _shared_slot_group set → defaults to contaminated) → MUST sync-prefetch
+        hook_a._is_group_first = True
+        hook_a._prev_hook = hook_a
+        sync_called[0] = False
+        hook_a.pre_forward(block_a)
+        assert sync_called[0], "_is_group_first must force sync-prefetch when slot is contaminated"
+
+        # Case 3: _is_group_first=True, slot NOT contaminated (same group owns slot)
+        # → skip sync-prefetch, just wait for async event
+        hook_a._shared_slot_group = [hook_a._group_id, -1]
+        sync_called[0] = False
+        hook_a.pre_forward(block_a)
+        assert not sync_called[0], "Should skip sync-prefetch when slot_group matches (non-contaminated)"
+
+
+class TestAllGatherOutputSlicing:
+    """Regression test: with heterogeneous block sizes (e.g. MiniMax H3's
+    token_refiner with blocks of ~1231MB and ~239MB), the shared AllGather
+    output buffers are sized to the *largest* block across all groups.
+    prefetch_layer must slice the output buffer down to each block's actual
+    AllGather output size, otherwise output.numel() != dp_size * input.numel()
+    and all_gather_into_tensor raises during enable()'s first prefetch.
+    """
+
+    def test_prefetch_slices_shared_output_buffer_to_block_size(self, dist_group, patched_offload_runtime, monkeypatch):
+        dp_size = 2
+
+        # Heterogeneous block sizes: 8 vs 32 elements.
+        small_block = nn.Module()
+        small_block.weight = nn.Parameter(torch.arange(8, dtype=torch.float32))
+        large_block = nn.Module()
+        large_block.weight = nn.Parameter(torch.arange(100, 132, dtype=torch.float32))
+
+        def make_hook(next_block: nn.Module) -> DistributedLayerwiseOffloadHook:
+            hook = DistributedLayerwiseOffloadHook(
+                next_block=next_block,
+                device=torch.device("cpu"),
+                dp_group=dist.group.WORLD,  # non-None -> AllGather path (mocked below)
+                dp_size=dp_size,
+                rank=0,
+                pin_memory=False,
+            )
+            current_block = nn.Module()
+            current_block.weight = nn.Parameter(torch.zeros(4, dtype=torch.float32))
+            hook.initialize_hook(current_block)
+            return hook
+
+        hook_small = make_hook(small_block)
+        hook_large = make_hook(large_block)
+        hooks = [hook_small, hook_large]
+
+        # Assign max-sized shared buffers exactly as backend.enable() does.
+        shared_buffers = DistributedLayerwiseOffloadBackend._allocate_shared_buffers(hooks)
+        shared_shard_buffers = DistributedLayerwiseOffloadBackend._allocate_shared_shard_buffers(hooks)
+        for hook in hooks:
+            hook.gpu_buffers = shared_buffers
+            hook.gpu_shard_buffers = shared_shard_buffers
+
+        # Shared output buffer must be sized to the largest block (32).
+        assert shared_buffers[0][torch.float32].numel() == 32
+
+        # Fake AllGather that enforces the real torch size contract and
+        # emulates reconstruction of the full block from all ranks' shards.
+        full_values = {
+            8: torch.arange(8, dtype=torch.float32),
+            32: torch.arange(100, 132, dtype=torch.float32),
+        }
+        ag_output_numels: list[int] = []
+
+        def fake_all_gather(output, input, group=None):
+            assert output.numel() == dp_size * input.numel(), (
+                f"AllGather contract violated: output.numel()={output.numel()} "
+                f"!= {dp_size} * input.numel()={input.numel()}"
+            )
+            ag_output_numels.append(output.numel())
+            output.copy_(full_values[output.numel()])
+
+        monkeypatch.setattr(dist, "all_gather_into_tensor", fake_all_gather)
+
+        # Small block: output must be sliced to dp_size * shard = 8, not 32.
+        hook_small.prefetch_layer(slot=0, non_blocking=False)
+        assert ag_output_numels[-1] == 8
+        assert torch.equal(small_block.weight, full_values[8])
+
+        # Large block: uses the full max-sized buffer.
+        hook_large.prefetch_layer(slot=1, non_blocking=False)
+        assert ag_output_numels[-1] == 32
+        assert torch.equal(large_block.weight, full_values[32])
+
+
+class TestOffloadPlan:
+    """Test declarative OffloadPlan metadata."""
+
+    def test_get_offload_plan_returns_none_when_not_declared(self):
+        """Pipelines without _offload_plan should return None."""
+        model = _SingleBlockModel(num_blocks=3)
+        assert get_offload_plan(model) is None
+
+    def test_get_offload_plan_returns_declared_plan(self):
+        """Pipelines with _offload_plan should return it."""
+        plan = OffloadPlan(
+            block_attrs={"transformer": ("gen_layers",)},
+            offload_submodules={"context_encoder": "layers"},
+            resident_dit_paths=frozenset({"transformer"}),
+        )
+
+        class PipelineWithPlan(nn.Module):
+            _offload_plan = plan
+
+        model = PipelineWithPlan()
+        result = get_offload_plan(model)
+        assert result is plan
+        assert result.block_attrs == {"transformer": ("gen_layers",)}
+        assert result.offload_submodules == {"context_encoder": "layers"}
+        assert result.resident_dit_paths == frozenset({"transformer"})
+
+    def test_offload_plan_defaults_to_empty(self):
+        """OffloadPlan with no arguments should have empty dicts."""
+        plan = OffloadPlan()
+        assert plan.block_attrs == {}
+        assert plan.offload_submodules == {}
+        assert plan.resident_dit_paths == frozenset()
+
+    def test_offload_plan_is_frozen(self):
+        """OffloadPlan should be immutable (frozen=True)."""
+        plan = OffloadPlan()
+        with pytest.raises(Exception):
+            plan.block_attrs = {"x": ("y",)}  # type: ignore
+
+    def test_all_resident_dit_still_prepares_planned_submodules(self, patched_offload_runtime):
+        class TokenRefiner(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+
+        class Transformer(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(2, 2), nn.Linear(2, 2)])
+                self.token_refiner = TokenRefiner()
+
+        class Pipeline(nn.Module):
+            _offload_plan = OffloadPlan(
+                offload_submodules={"token_refiner": "blocks"},
+                resident_dit_paths=frozenset({"transformer"}),
+            )
+
+            def __init__(self):
+                super().__init__()
+                self.transformer = Transformer()
+
+        pipeline = Pipeline()
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+                pin_cpu_memory=False,
+                dlo_use_allgather=False,
+                dlo_resident_layers=2,
+            ),
+            torch.device("cpu"),
+        )
+
+        backend.enable(pipeline)
+
+        assert len(backend._resident_blocks) == 2
+        assert len(backend._all_hook_groups) == 1
+        assert len(backend._all_hook_groups[0]) == 2
+        assert backend.enabled
+
+        backend.disable()
+
+
+class TestMmapValidation:
+    """Tests for mmap loader validation: TP rejection, strict check, validate_loaded_weights."""
+
+    def test_tp_rejected_when_tp_world_size_gt_1(self, tmp_path, patched_offload_runtime, monkeypatch):
+        """DLO+AllGather should reject when TP world size > 1."""
+        import json
+        from types import SimpleNamespace
+
+        from safetensors.torch import save_file
+
+        from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+
+        # Mock TP world size = 2
+        monkeypatch.setattr(
+            "vllm.distributed.parallel_state.get_tensor_model_parallel_world_size",
+            lambda: 2,
+        )
+
+        class SimpleModel(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(4, 4, bias=False)])
+
+        class SimplePipeline(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.transformer = SimpleModel()
+
+            @staticmethod
+            def _remap_ckpt_key(key):
+                return key
+
+        pipeline = SimplePipeline()
+        weights = {name: torch.ones(p.shape, dtype=p.dtype) for name, p in pipeline.named_parameters() if not p.is_meta}
+        save_file(weights, str(tmp_path / "model.safetensors"))
+        (tmp_path / "model.safetensors.index.json").write_text(
+            json.dumps({"weight_map": {k: "model.safetensors" for k in weights}})
+        )
+
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+                pin_cpu_memory=False,
+                model_path=str(tmp_path),
+            ),
+            torch.device("cpu"),
+        )
+        modules = SimpleNamespace(dits=[pipeline.transformer], dit_names=["transformer"])
+
+        with pytest.raises(ValueError, match="Tensor Parallel"):
+            backend._load_weights_via_mmap(pipeline, modules)
+
+    def test_tp_allowed_when_tp_world_size_eq_1(self, tmp_path, patched_offload_runtime, monkeypatch):
+        """DLO+AllGather should work when TP world size = 1, even if params
+        have custom weight_loader attributes (e.g. QKVParallelLinear at TP=1)."""
+        import json
+        from types import SimpleNamespace
+
+        from safetensors.torch import save_file
+
+        from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+
+        # Mock TP world size = 1 (default)
+        monkeypatch.setattr(
+            "vllm.distributed.parallel_state.get_tensor_model_parallel_world_size",
+            lambda: 1,
+        )
+
+        def custom_weight_loader(param, weight):
+            param.data.copy_(weight)
+
+        class ModelWithCustomLoader(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+
+            def __init__(self):
+                super().__init__()
+                self.linear = nn.Linear(4, 4, bias=False)
+                # Simulate QKVParallelLinear: custom weight_loader even at TP=1
+                self.linear.weight.weight_loader = custom_weight_loader
+                self.blocks = nn.ModuleList([nn.Linear(4, 4, bias=False)])
+
+        class PipelineWithLoader(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.transformer = ModelWithCustomLoader()
+
+            @staticmethod
+            def _remap_ckpt_key(key):
+                return key
+
+        pipeline = PipelineWithLoader()
+        weights = {name: torch.ones(p.shape, dtype=p.dtype) for name, p in pipeline.named_parameters() if not p.is_meta}
+        save_file(weights, str(tmp_path / "model.safetensors"))
+        (tmp_path / "model.safetensors.index.json").write_text(
+            json.dumps({"weight_map": {k: "model.safetensors" for k in weights}})
+        )
+
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+                pin_cpu_memory=False,
+                model_path=str(tmp_path),
+            ),
+            torch.device("cpu"),
+        )
+        modules = SimpleNamespace(dits=[pipeline.transformer], dit_names=["transformer"])
+
+        # Should NOT raise — TP=1 is allowed even with custom weight_loader
+        backend._load_weights_via_mmap(pipeline, modules)
+
+    def test_validate_loaded_weights_called(self, tmp_path, patched_offload_runtime):
+        """validate_loaded_weights should be called after mmap loading."""
+        import json
+        from types import SimpleNamespace
+
+        from safetensors.torch import save_file
+
+        from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+
+        class ModelWithValidate(nn.Module):
+            _layerwise_offload_blocks_attrs = ["blocks"]
+            validate_called = False
+
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([nn.Linear(4, 4, bias=False) for _ in range(2)])
+
+            def post_load_weights(self):
+                pass
+
+            def validate_loaded_weights(self, loaded):
+                self.validate_called = True
+                assert len(loaded) > 0, "Should have loaded weights"
+
+        class PipelineWithValidate(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.transformer = ModelWithValidate()
+
+            @staticmethod
+            def _remap_ckpt_key(key):
+                return key
+
+        pipeline = PipelineWithValidate()
+        # Save on meta to trigger mmap path
+        with torch.device("meta"):
+            pipeline.transformer = ModelWithValidate()
+
+        weights = {
+            name: torch.ones(param.shape, dtype=param.dtype if not param.is_meta else torch.float32)
+            for name, param in pipeline.named_parameters()
+        }
+        save_file(weights, str(tmp_path / "model.safetensors"))
+        (tmp_path / "model.safetensors.index.json").write_text(
+            json.dumps({"weight_map": {k: "model.safetensors" for k in weights}})
+        )
+
+        backend = DistributedLayerwiseOffloadBackend(
+            OffloadConfig(
+                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE, pin_cpu_memory=False, model_path=str(tmp_path)
+            ),
+            torch.device("cpu"),
+        )
+        modules = SimpleNamespace(dits=[pipeline.transformer], dit_names=["transformer"])
+
+        backend._load_weights_via_mmap(pipeline, modules)
+        assert pipeline.transformer.validate_called, "validate_loaded_weights should be called"
+
+
+class TestConfigValidation:
+    """Tests for configuration validation in OffloadConfig / execute_request."""
+
+    def test_hsdp_with_allgather_rejected(self):
+        """HSDP + DLO + AllGather should raise ValueError (double sharding)."""
+        from vllm_omni.diffusion.offloader.base import OffloadConfig
+
+        class FakePC:
+            data_parallel_size = 1
+            use_hsdp = True
+            hsdp_shard_size = 2
+            hsdp_replicate_size = 1
+            sequence_parallel_size = 1
+            tensor_parallel_size = 1
+            cfg_parallel_size = 1
+            pipeline_parallel_size = 1
+            ulysses_degree = 1
+            ring_degree = 1
+            allgather_degree = 1
+            enable_expert_parallel = False
+
+        class FakeODConfig:
+            enable_cpu_offload = False
+            enable_layerwise_offload = False
+            enable_distributed_layerwise_offload = True
+            dlo_use_allgather = True
+            pin_cpu_memory = True
+            parallel_config = FakePC()
+            model = "/fake/path"
+
+        with pytest.raises(ValueError, match="incompatible with HSDP"):
+            OffloadConfig.from_od_config(FakeODConfig())
+
+    def test_hsdp_without_allgather_allowed(self):
+        """HSDP + DLO + no-AllGather uses standard-loader rank-local weights."""
+        from vllm_omni.diffusion.offloader.base import OffloadConfig
+
+        class FakePC:
+            data_parallel_size = 1
+            use_hsdp = True
+            hsdp_shard_size = 2
+            hsdp_replicate_size = 1
+            sequence_parallel_size = 1
+            tensor_parallel_size = 1
+            cfg_parallel_size = 1
+            pipeline_parallel_size = 1
+            ulysses_degree = 1
+            ring_degree = 1
+            allgather_degree = 1
+            enable_expert_parallel = False
+
+        class FakeODConfig:
+            enable_cpu_offload = False
+            enable_layerwise_offload = False
+            enable_distributed_layerwise_offload = True
+            dlo_use_allgather = False  # no AllGather → should be allowed
+            dlo_resident_layers = 20
+            pin_cpu_memory = True
+            parallel_config = FakePC()
+            model = "/fake/path"
+
+        config = OffloadConfig.from_od_config(FakeODConfig())
+        assert config.dp_size == 1  # forced to 1 when no AllGather
+        assert config.dlo_resident_layers == 20
+
+    def test_resident_layers_with_allgather_rejected(self):
+        class FakePC:
+            data_parallel_size = 2
+            use_hsdp = False
+            sequence_parallel_size = 1
+
+        class FakeODConfig:
+            enable_cpu_offload = False
+            enable_layerwise_offload = False
+            enable_distributed_layerwise_offload = True
+            dlo_use_allgather = True
+            dlo_resident_layers = 20
+            pin_cpu_memory = True
+            parallel_config = FakePC()
+            model = "/fake/path"
+
+        with pytest.raises(ValueError, match="requires --dlo-no-use-allgather"):
+            OffloadConfig.from_od_config(FakeODConfig())
+
+    def test_num_inference_steps_none_rejected(self):
+        """DP multi-concurrency should reject None num_inference_steps."""
+        from types import SimpleNamespace
+
+        # Mock requests with None steps
+        reqs = [
+            SimpleNamespace(
+                req=SimpleNamespace(
+                    request_id=f"req-{i}",
+                    sampling_params=SimpleNamespace(num_inference_steps=None),
+                )
+            )
+            for i in range(2)
+        ]
+
+        # We can't easily instantiate the full executor, but we can test
+        # the validation logic by checking that the code path raises.
+        # The validation is in execute_request, which needs self._ensure_open().
+        # Instead, test the validation logic directly:
+        step_counts = {
+            r.req.sampling_params.num_inference_steps
+            for r in reqs
+            if r.req.sampling_params.num_inference_steps is not None
+        }
+        has_none = any(r.req.sampling_params.num_inference_steps is None for r in reqs)
+        assert has_none, "Test setup: should have None steps"
+        assert len(step_counts) == 0, "Test setup: no explicit steps"
+
+        # The validation condition: (len(step_counts) > 1) or has_none → should reject
+        should_reject = (len(step_counts) > 1) or has_none
+        assert should_reject, "None steps should trigger rejection"
+
+    def test_num_inference_steps_same_explicit_allowed(self):
+        """DP multi-concurrency should allow same explicit num_inference_steps."""
+        from types import SimpleNamespace
+
+        reqs = [
+            SimpleNamespace(
+                req=SimpleNamespace(
+                    request_id=f"req-{i}",
+                    sampling_params=SimpleNamespace(num_inference_steps=35),
+                )
+            )
+            for i in range(4)
+        ]
+
+        step_counts = {
+            r.req.sampling_params.num_inference_steps
+            for r in reqs
+            if r.req.sampling_params.num_inference_steps is not None
+        }
+        has_none = any(r.req.sampling_params.num_inference_steps is None for r in reqs)
+
+        should_reject = (len(step_counts) > 1) or has_none
+        assert not should_reject, "Same explicit steps should be allowed"
+        assert step_counts == {35}
+
+    def test_num_inference_steps_different_explicit_rejected(self):
+        """DP multi-concurrency should reject different explicit steps."""
+        from types import SimpleNamespace
+
+        reqs = [
+            SimpleNamespace(
+                req=SimpleNamespace(
+                    request_id="req-0",
+                    sampling_params=SimpleNamespace(num_inference_steps=35),
+                )
+            ),
+            SimpleNamespace(
+                req=SimpleNamespace(
+                    request_id="req-1",
+                    sampling_params=SimpleNamespace(num_inference_steps=30),
+                )
+            ),
+        ]
+
+        step_counts = {
+            r.req.sampling_params.num_inference_steps
+            for r in reqs
+            if r.req.sampling_params.num_inference_steps is not None
+        }
+        has_none = any(r.req.sampling_params.num_inference_steps is None for r in reqs)
+
+        should_reject = (len(step_counts) > 1) or has_none
+        assert should_reject, "Different steps should trigger rejection"
+        assert len(step_counts) == 2
+
+
+class TestDynamicSlotTracking:
+    """Tests for dynamic slot tracking with odd and even block counts.
+
+    With i%2 initialization alone, odd block counts cause the circular
+    tail→head prefetch to collide with the head's read slot (both map
+    to slot 0).  Dynamic slot tracking via _prefetched_slot corrects
+    this by reading the actual slot from the previous hook's prefetch.
+    """
+
+    @staticmethod
+    def _trace_slots(num_blocks: int, num_iterations: int = 1):
+        """Trace slot assignments through forward passes (pure logic, no hooks).
+
+        Returns a list of (read_slot, write_slot) per block per iteration.
+        """
+        # Initial i%2 assignment (same as enable())
+        current_slots = [i % 2 for i in range(num_blocks)]
+        prefetched_slots: list[int | None] = [None] * num_blocks
+
+        # Sync-prefetch: tail hook prefetches into slot 0
+        prefetched_slots[-1] = 0
+
+        results = []
+        for _ in range(num_iterations):
+            for i in range(num_blocks):
+                prev_idx = (i - 1) % num_blocks
+
+                # Dynamic slot tracking: read from prev's prefetched slot
+                if prefetched_slots[prev_idx] is not None:
+                    current_slots[i] = prefetched_slots[prev_idx]
+
+                read_slot = current_slots[i]
+
+                # Prefetch into other slot
+                next_slot = 1 - read_slot
+                current_slots[i] = next_slot
+                prefetched_slots[i] = next_slot
+
+                results.append((read_slot, next_slot))
+
+        return results
+
+    def test_odd_block_count_no_collision(self):
+        """3 blocks (odd): no read/write slot collision."""
+        results = self._trace_slots(3)
+        for i, (read, write) in enumerate(results):
+            assert read != write, f"Block {i % 3} (step {i}): read={read} == write={write}"
+
+    def test_even_block_count_no_collision(self):
+        """4 blocks (even): no read/write slot collision."""
+        results = self._trace_slots(4)
+        for i, (read, write) in enumerate(results):
+            assert read != write, f"Block {i % 4} (step {i}): read={read} == write={write}"
+
+    def test_large_odd_block_count(self):
+        """7 blocks (odd): no collision across all blocks."""
+        results = self._trace_slots(7)
+        for i, (read, write) in enumerate(results):
+            assert read != write, f"Block {i % 7} (step {i}): read={read} == write={write}"
+
+    def test_5_blocks_two_iterations(self):
+        """5 blocks (odd), 2 iterations: no collision in either pass."""
+        results = self._trace_slots(5, num_iterations=2)
+        n = 5
+        for iteration in range(2):
+            for i in range(n):
+                idx = iteration * n + i
+                read, write = results[idx]
+                assert read != write, f"Iter {iteration} block {i}: read={read} == write={write}"
+
+    def test_3_blocks_three_iterations(self):
+        """3 blocks (odd), 3 iterations: no collision across all passes."""
+        results = self._trace_slots(3, num_iterations=3)
+        n = 3
+        for iteration in range(3):
+            for i in range(n):
+                idx = iteration * n + i
+                read, write = results[idx]
+                assert read != write, f"Iter {iteration} block {i}: read={read} == write={write}"
+
+    def test_72_blocks_cosmos3(self):
+        """72 blocks (Cosmos3, even): no collision."""
+        results = self._trace_slots(72)
+        for i, (read, write) in enumerate(results):
+            assert read != write, f"Block {i % 72} (step {i}): read={read} == write={write}"
+
+    def test_slots_alternate_within_iteration(self):
+        """Within one iteration, consecutive blocks should use alternating slots."""
+        results = self._trace_slots(6)
+        for i in range(6):
+            read, write = results[i]
+            # Each block reads from one slot and writes to the other
+            assert {read, write} == {0, 1}, f"Block {i}: slots {read},{write} don't cover both"
+
+    def test_prefetched_slot_set_after_prefetch(self, dist_group, patched_offload_runtime):
+        """prefetch_layer should set _prefetched_slot to the slot argument."""
+        block = TinyBlock(_make_values(1.0))
+        next_block = TinyBlock(_make_values(2.0))
+
+        hook = DistributedLayerwiseOffloadHook(
+            next_block=next_block,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+        hook.initialize_hook(block)
+
+        assert hook._prefetched_slot is None  # initially None
+
+        hook.prefetch_layer(slot=0, non_blocking=False)
+        assert hook._prefetched_slot == 0
+
+        hook.prefetch_layer(slot=1, non_blocking=False)
+        assert hook._prefetched_slot == 1
+
+    def test_dynamic_slot_overrides_initial_assignment(self, dist_group, patched_offload_runtime):
+        """When _prev_hook._prefetched_slot is set, pre_forward should use
+        that value instead of the initial i%2 assignment."""
+        block_a = TinyBlock(_make_values(1.0))
+        block_b = TinyBlock(_make_values(2.0))
+
+        hook_a = DistributedLayerwiseOffloadHook(
+            next_block=block_b,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+        hook_a.initialize_hook(block_a)
+
+        hook_b = DistributedLayerwiseOffloadHook(
+            next_block=block_a,
+            device=torch.device("cpu"),
+            dp_group=None,
+            dp_size=1,
+            rank=0,
+            copy_stream=DummyStream(),
+            comm_stream=DummyStream(),
+            pin_memory=False,
+        )
+        hook_b.initialize_hook(block_b)
+
+        # Wire: hook_b._prev_hook = hook_a
+        hook_b._prev_hook = hook_a
+
+        # hook_a prefetched into slot 1
+        hook_a.prefetch_layer(slot=1, non_blocking=False)
+        assert hook_a._prefetched_slot == 1
+
+        # hook_b's initial slot is 0 (from i%2)
+        hook_b.current_slot = 0
+
+        # pre_forward should override to slot 1
+        hook_b.pre_forward(block_b)
+        assert hook_b.current_slot == 1, "pre_forward should read _prev_hook._prefetched_slot=1, not keep initial 0"
diff --git a/tests/plugin/test_gguf_diffusion.py b/tests/diffusion/quantization/test_gguf_diffusion.py
similarity index 97%
rename from tests/plugin/test_gguf_diffusion.py
rename to tests/diffusion/quantization/test_gguf_diffusion.py
index 44de4a1fb..fa87e8a7c 100644
--- a/tests/plugin/test_gguf_diffusion.py
+++ b/tests/diffusion/quantization/test_gguf_diffusion.py
@@ -5,10 +5,10 @@
 Validates that GGUF-quantized diffusion models generate valid images and
 use less peak GPU memory than BF16 baseline.
 
-Requires vllm-omni to be installed alongside the plugin.
+Requires vllm-omni to be installed alongside the vllm-gguf-plugin package.
 
 Usage:
-    pytest tests/diffusion/test_gguf_memory.py -v
+    pytest tests/diffusion/quantization/test_gguf_diffusion.py -v
 """
 
 from __future__ import annotations
@@ -112,7 +112,6 @@ def _generate_single_stage_image(
 @hardware_test(res={"cuda": "L4"})
 @pytest.mark.full_model
 @pytest.mark.diffusion
-@pytest.mark.slow
 @pytest.mark.parametrize("model", [Z_IMAGE_CONFIG, FLUX_CONFIG], ids=["Z-Image-Turbo", "FLUX.2-klein"])
 def test_single_stage_diffusion_gguf(model: DiffusionGGUFTestConfig, monkeypatch: pytest.MonkeyPatch) -> None:
     """Z-Image-Turbo GGUF generates valid images and uses less memory than BF16."""
diff --git a/tests/diffusion/quantization/test_int8_config.py b/tests/diffusion/quantization/test_int8_config.py
index 875277ece..f706cc68b 100644
--- a/tests/diffusion/quantization/test_int8_config.py
+++ b/tests/diffusion/quantization/test_int8_config.py
@@ -147,6 +147,130 @@ def test_get_npu_quant_method(mocker: MockerFixture, monkeypatch: pytest.MonkeyP
     assert isinstance(method, UnquantizedLinearMethod)
 
 
+def test_fused_layer_can_be_ignored_by_its_prefix(monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture):
+    """A layer opts out of quantization under the prefix its module was built with.
+
+    MiniMax H3 stores qkv as one checkpoint tensor, so the fused name is the
+    only handle a user has on it.
+    """
+    from vllm_omni.quantization.int8_config import NPUInt8OnlineLinearMethod
+
+    monkeypatch.setattr(current_omni_platform, "is_cuda", lambda: False)
+    monkeypatch.setattr(current_omni_platform, "is_npu", lambda: True)
+    config = build_quant_config("int8", ignored_layers=["blocks.0.attn.qkv_proj"])
+    layer = mocker.Mock(spec=LinearBase)
+
+    assert isinstance(config.get_quant_method(layer, "blocks.0.attn.qkv_proj"), UnquantizedLinearMethod)
+    assert isinstance(config.get_quant_method(layer, "blocks.1.attn.qkv_proj"), NPUInt8OnlineLinearMethod)
+    assert isinstance(config.get_quant_method(layer, "blocks.0.mlp.fc1"), NPUInt8OnlineLinearMethod)
+
+
+class TestNPUQuantMatmulShapeFallback:
+    """npu_quant_matmul rejects wide outputs, so those layers stay unquantized.
+
+    The limit applies to the per-rank shard, which is what the kernel sees. The
+    same layer can therefore be quantized at a higher TP degree.
+    """
+
+    @pytest.fixture(autouse=True)
+    def _mock_tp(self, mocker):
+        # The fallback delegates to UnquantizedLinearMethod, which reads the TP
+        # group; stand one in so the shape gating can be tested without a
+        # distributed init.
+        mock_group = mocker.Mock()
+        mock_group.rank_in_group = 0
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_world_size", return_value=1)
+        mocker.patch("vllm.model_executor.layers.linear.get_tensor_model_parallel_rank", return_value=0)
+        mocker.patch("vllm.distributed.parallel_state.get_tp_group", return_value=mock_group)
+
+    @pytest.fixture
+    def quant_config(self):
+        from vllm_omni.quantization.int8_config import DiffusionInt8Config
+
+        return DiffusionInt8Config(is_checkpoint_int8_serialized=False, activation_scheme="dynamic")
+
+    def create_weights(self, method, layer, output_partition_sizes):
+        # Narrow input dim: the fallback path allocates for real, and only the
+        # output dimension is under test.
+        method.create_weights(
+            layer,
+            input_size_per_partition=8,
+            output_partition_sizes=output_partition_sizes,
+            input_size=8,
+            output_size=sum(output_partition_sizes),
+            params_dtype=torch.bfloat16,
+            weight_loader=lambda param, loaded_weight, *args, **kwargs: None,
+        )
+
+    @pytest.mark.parametrize(
+        "method_name",
+        ["NPUInt8LinearMethod", "NPUInt8OnlineLinearMethod"],
+    )
+    def test_over_wide_layer_falls_back_to_unquantized(self, quant_config, method_name):
+        import vllm_omni.quantization.int8_config as int8_config
+
+        method = getattr(int8_config, method_name)(quant_config)
+        layer = Module()
+        layer.quant_method = method
+
+        self.create_weights(method, layer, [int8_config.NPU_QUANT_MATMUL_MAX_OUT_FEATURES + 1])
+
+        assert isinstance(layer.quant_method, UnquantizedLinearMethod)
+        assert layer.weight.dtype == torch.bfloat16
+
+    def test_layer_within_the_limit_keeps_int8(self, quant_config):
+        from vllm_omni.quantization.int8_config import (
+            NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
+            NPUInt8OnlineLinearMethod,
+        )
+
+        method = NPUInt8OnlineLinearMethod(quant_config)
+        layer = Module()
+        layer.quant_method = method
+
+        self.create_weights(method, layer, [NPU_QUANT_MATMUL_MAX_OUT_FEATURES])
+
+        assert layer.quant_method is method
+
+    def test_tensor_parallel_sharding_brings_a_wide_layer_back(self, quant_config):
+        from vllm_omni.quantization.int8_config import (
+            NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
+            NPUInt8OnlineLinearMethod,
+        )
+
+        global_out_features = 4 * NPU_QUANT_MATMUL_MAX_OUT_FEATURES
+        method = NPUInt8OnlineLinearMethod(quant_config)
+        layer = Module()
+        layer.quant_method = method
+
+        self.create_weights(method, layer, [global_out_features // 4])
+
+        assert layer.quant_method is method
+
+
+class TestOffloadAfterQuant:
+    def test_only_methods_advertising_the_capability_are_asked(self):
+        from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
+        from vllm_omni.quantization.int8_config import DiffusionInt8Config, NPUInt8OnlineLinearMethod
+
+        class MetaDeviceOnlyMethod:
+            """Stands in for upstream online FP8: lazy, but no offload hook."""
+
+            uses_meta_device = True
+
+        model = torch.nn.Sequential(Module(), Module())
+        lazy_int8 = NPUInt8OnlineLinearMethod(
+            DiffusionInt8Config(is_checkpoint_int8_serialized=False, activation_scheme="dynamic")
+        )
+        model[0].quant_method = lazy_int8
+        model[1].quant_method = MetaDeviceOnlyMethod()
+
+        marked = DiffusersPipelineLoader._request_offload_after_quant(model)
+
+        assert marked == 1
+        assert lazy_int8._offload_after_quant
+
+
 class TestInt8LinearMethod:
     @pytest.fixture
     def mock_quant_config(self, mocker):
diff --git a/tests/diffusion/quantization/test_quantization_quality.py b/tests/diffusion/quantization/test_quantization_quality.py
index 5f0dc4d62..d3cee6b6a 100644
--- a/tests/diffusion/quantization/test_quantization_quality.py
+++ b/tests/diffusion/quantization/test_quantization_quality.py
@@ -82,6 +82,8 @@ class QualityTestConfig:
     gpu: str = "H100"  # minimum GPU requirement
     negative_prompt: str = ""
     guidance_scale: float | None = None
+    sigmas: list[float] | None = None
+    enable_cpu_offload: bool = False
 
     def baseline_ref(self) -> str:
         return self.baseline_model or self.model or ""
@@ -181,6 +183,18 @@ QUALITY_CONFIGS = [
         max_lpips=0.20,
         num_inference_steps=10,
     ),
+    QualityTestConfig(
+        id="fp8_flux2_dev_text_encoder",
+        model="black-forest-labs/FLUX.2-dev",
+        quantization={"text_encoder": "fp8", "transformer": None, "vae": None},
+        task="t2i",
+        prompt="a cup of coffee on a wooden table, morning light",
+        max_lpips=0.15,
+        num_inference_steps=10,
+        enable_cpu_offload=True,
+        height=1024,
+        width=1024,
+    ),
     QualityTestConfig(
         id="fp8_qwen_image",
         model="Qwen/Qwen-Image",
@@ -202,6 +216,19 @@ QUALITY_CONFIGS = [
         width=256,
         num_frames=25,
         num_inference_steps=8,
+        # Preserve the final scheduler trajectory used when this FP8 quality
+        # gate was established. Explicit LTX sigmas bypass dynamic shifting.
+        sigmas=[
+            1.0,
+            0.92185378074646,
+            0.8327768445014954,
+            0.7303033471107483,
+            0.6111654043197632,
+            0.4709382653236389,
+            0.30347853899002075,
+            0.10000002384185791,
+            0.0,
+        ],
     ),
 ]
 
@@ -309,6 +336,7 @@ def _generate_video(omni, config: QualityTestConfig):
             num_inference_steps=config.num_inference_steps,
             num_frames=config.num_frames,
             guidance_scale=config.guidance_scale,
+            sigmas=config.sigmas,
         ),
     )
 
@@ -403,6 +431,8 @@ def _free_gpu_memory():
 # ---------------------------------------------------------------------------
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
 def test_benchmark_generate_image_unwraps_nested_omni_request_output(monkeypatch):
     from benchmarks.diffusion.quantization_quality import _generate_image as benchmark_generate_image
     from vllm_omni.outputs import OmniRequestOutput
@@ -433,6 +463,33 @@ def test_benchmark_generate_image_unwraps_nested_omni_request_output(monkeypatch
     assert peak_mem == 0.0
 
 
+def test_generate_video_forwards_sigmas(monkeypatch):
+    from vllm_omni.platforms import current_omni_platform
+
+    monkeypatch.setattr(current_omni_platform, "device_type", "cpu", raising=False)
+    monkeypatch.setattr(torch.accelerator, "reset_peak_memory_stats", lambda: None, raising=False)
+    monkeypatch.setattr(torch.accelerator, "max_memory_allocated", lambda: 0, raising=False)
+    captured = SimpleNamespace(sampling=None)
+
+    class DummyOmni:
+        def generate(self, _prompt, sampling):
+            captured.sampling = sampling
+            return [SimpleNamespace(images=[np.zeros((1, 2, 2, 3), dtype=np.float32)])]
+
+    config = QualityTestConfig(
+        id="ltx-sigmas",
+        model="unused",
+        quantization="fp8",
+        task="t2v",
+        prompt="test",
+        max_lpips=0.1,
+        sigmas=[1.0, 0.5],
+    )
+    _generate_video(DummyOmni(), config)
+
+    assert captured.sampling.sigmas == [1.0, 0.5]
+
+
 _marks = hardware_marks(res={"cuda": "H100"})
 _OUTPUT_DIR = Path(os.environ["VLLM_OMNI_QUALITY_OUTPUT_DIR"]) if "VLLM_OMNI_QUALITY_OUTPUT_DIR" in os.environ else None
 
@@ -459,7 +516,10 @@ def test_quantization_quality(config: QualityTestConfig):
     generate_fn = _generate_video if config.task == "t2v" else _generate_image
 
     # --- BF16 baseline ---
-    omni_bl = Omni(model=config.baseline_ref())
+    bl_kwargs: dict = {"model": config.baseline_ref()}
+    if config.enable_cpu_offload:
+        bl_kwargs["enable_cpu_offload"] = True
+    omni_bl = Omni(**bl_kwargs)
     baseline_out, bl_mem = generate_fn(omni_bl, config)
     omni_bl.shutdown()
     del omni_bl
@@ -468,10 +528,13 @@ def test_quantization_quality(config: QualityTestConfig):
 
     # --- Quantized ---
     quantization = config.quantization_ref()
+    qt_kwargs: dict = {"model": config.quantized_ref()}
+    if config.enable_cpu_offload:
+        qt_kwargs["enable_cpu_offload"] = True
     if quantization is None:
-        omni_qt = Omni(model=config.quantized_ref())
+        omni_qt = Omni(**qt_kwargs)
     else:
-        omni_qt = Omni(model=config.quantized_ref(), quantization_config=quantization)
+        omni_qt = Omni(**qt_kwargs, quantization_config=quantization)
     quant_out, qt_mem = generate_fn(omni_qt, config)
     omni_qt.shutdown()
     del omni_qt
diff --git a/tests/diffusion/quantization/test_trajectory_similarity_tool.py b/tests/diffusion/quantization/test_trajectory_similarity_tool.py
index 252e6f1c1..963ed5685 100644
--- a/tests/diffusion/quantization/test_trajectory_similarity_tool.py
+++ b/tests/diffusion/quantization/test_trajectory_similarity_tool.py
@@ -22,6 +22,8 @@ from vllm_omni.quantization.tools.compare_diffusion_trajectory_similarity import
     summarize_output_image_metrics,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
 
 def test_compute_tensor_metrics_identical_tensors():
     metrics = compute_tensor_metrics(torch.ones(2, 3), torch.ones(2, 3))
diff --git a/tests/diffusion/test_async_output_worker.py b/tests/diffusion/test_async_output_worker.py
new file mode 100644
index 000000000..8cda3be1c
--- /dev/null
+++ b/tests/diffusion/test_async_output_worker.py
@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for WorkerProc async output logic."""
+
+import queue
+from unittest.mock import MagicMock
+
+import pytest
+
+from vllm_omni.diffusion.data import (
+    AsyncDiffusionOutput,
+    AsyncOutputKind,
+    DiffusionOutput,
+    OmniACK,
+)
+from vllm_omni.diffusion.worker.diffusion_worker import WorkerProc
+from vllm_omni.diffusion.worker.utils import BatchRunnerOutput, RunnerOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_worker_proc(step_execution=False):
+    """Create a minimal WorkerProc-like object with async output state."""
+    proc = object.__new__(WorkerProc)
+    proc.od_config = MagicMock()
+    proc.od_config.step_execution = step_execution
+    proc.gpu_id = 0
+    proc.result_mq = MagicMock()
+    proc._running = True
+    proc._async_output_queue = queue.Queue() if not step_execution else None
+    proc._async_output_thread = None
+    return proc
+
+
+class TestGenerateAsyncOutputId:
+    """Test _generate_async_output_id uniqueness."""
+
+    def test_returns_hex_string(self):
+        id1 = WorkerProc._generate_async_output_id()
+        assert isinstance(id1, str)
+        assert len(id1) == 32  # uuid4 hex is 32 chars
+
+    def test_ids_are_unique(self):
+        ids = {WorkerProc._generate_async_output_id() for _ in range(100)}
+        assert len(ids) == 100
+
+
+class TestReturnResultAsyncPath:
+    """Test _return_result in request-mode (step_execution=False)."""
+
+    def test_omni_ack_bypasses_async_path(self):
+        """OmniACK should always use sync path regardless of step_execution."""
+        proc = _make_worker_proc(step_execution=False)
+        ack = OmniACK(task_id="task1", status="done")
+
+        proc._return_result(ack)
+        proc.result_mq.enqueue.assert_called_once_with(ack)
+        assert proc._async_output_queue.empty()  # nothing enqueued for bg thread
+
+    def test_diffusion_output_triggers_async_path(self, mocker):
+        """DiffusionOutput in request-mode should enqueue compute_done + bg work."""
+        proc = _make_worker_proc(step_execution=False)
+
+        mock_platform = mocker.MagicMock()
+        mock_platform.record_device_event.return_value = MagicMock()
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.current_omni_platform",
+            mock_platform,
+        )
+
+        output = DiffusionOutput(output="data")
+        proc._return_result(output, rpc_id="1")
+
+        # Should have enqueued COMPUTE_DONE to result_mq
+        enqueued_msg = proc.result_mq.enqueue.call_args[0][0]
+        assert isinstance(enqueued_msg, AsyncDiffusionOutput)
+        assert enqueued_msg.kind == AsyncOutputKind.COMPUTE_DONE
+        assert enqueued_msg.rpc_id == "1"
+        assert enqueued_msg.async_output_id is not None
+
+        # Should have placed work item in async_output_queue
+        assert not proc._async_output_queue.empty()
+        item = proc._async_output_queue.get_nowait()
+        assert item[0] is output
+        assert item[1] == enqueued_msg.async_output_id
+
+    def test_batch_runner_output_triggers_async_path(self, mocker):
+        """BatchRunnerOutput in request-mode should also go through async path."""
+        proc = _make_worker_proc(step_execution=False)
+
+        mock_platform = mocker.MagicMock()
+        mock_platform.record_device_event.return_value = MagicMock()
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.current_omni_platform",
+            mock_platform,
+        )
+
+        batch = BatchRunnerOutput(
+            runner_outputs=[RunnerOutput(request_id="r1", finished=True)],
+        )
+        proc._return_result(batch)
+
+        enqueued_msg = proc.result_mq.enqueue.call_args[0][0]
+        assert isinstance(enqueued_msg, AsyncDiffusionOutput)
+        assert enqueued_msg.kind == AsyncOutputKind.COMPUTE_DONE
+
+    def test_none_result_mq_skips_all_paths(self):
+        """If result_mq is None, _return_result should do nothing."""
+        proc = _make_worker_proc(step_execution=False)
+        proc.result_mq = None
+
+        proc._return_result(DiffusionOutput())
+        # No crash, no enqueue attempted
+
+
+class TestReturnResultSyncPath:
+    """Test _return_result in step-execution mode (sync)."""
+
+    def test_diffusion_output_uses_sync_path_when_step_execution(self, mocker):
+        """In step_execution mode, DiffusionOutput goes through sync SHM pack."""
+        proc = _make_worker_proc(step_execution=True)
+        proc._async_output_queue = None  # step mode doesn't have async queue
+
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+        )
+        output = DiffusionOutput(output="data")
+        proc._return_result(output)
+
+        mock_pack.assert_called_once_with(output)
+        proc.result_mq.enqueue.assert_called_once_with(output)
+
+    def test_non_diffusion_output_skips_async_in_request_mode(self, mocker):
+        """Non-DiffusionOutput/BatchRunnerOutput in request mode uses sync path."""
+        proc = _make_worker_proc(step_execution=False)
+
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+        )
+        # A plain dict is neither DiffusionOutput nor BatchRunnerOutput
+        output = {"type": "other"}
+        proc._return_result(output)
+
+        mock_pack.assert_called_once_with(output)
+        proc.result_mq.enqueue.assert_called_once_with(output)
+
+
+class TestAsyncOutputLoopLogic:
+    """Test _async_output_loop background thread logic (mocked, no device)."""
+
+    def test_bg_thread_enqueues_output_ready_after_pack(self, mocker):
+        """The real _async_output_loop packs via SHM with d2h_stream and
+        enqueues an OUTPUT_READY message."""
+        import threading
+        import time
+
+        proc = _make_worker_proc(step_execution=False)
+
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+        )
+        # Mock torch to avoid device initialization
+        mock_torch = mocker.MagicMock()
+        mock_stream = mocker.MagicMock()
+        mock_torch.Stream.return_value = mock_stream
+        mock_torch.accelerator.current_accelerator.return_value.type = "cpu"
+        mock_torch.device.return_value = mocker.MagicMock()
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.torch",
+            mock_torch,
+        )
+
+        output = DiffusionOutput(output="data")
+        gpu_event = mocker.MagicMock()
+        proc._async_output_queue.put((output, "abc123", gpu_event))
+
+        # Run the real _async_output_loop in a background thread.
+        t = threading.Thread(target=proc._async_output_loop, daemon=True)
+        t.start()
+
+        # Give the loop time to process, then unblock and stop.
+        time.sleep(0.5)
+        proc._running = False
+        proc._async_output_queue.put((DiffusionOutput(), "sentinel", None))
+        t.join(timeout=2.0)
+
+        mock_pack.assert_called()
+        # Verify an OUTPUT_READY with the correct async_output_id was enqueued.
+        output_ready_enqueued = any(
+            c[0][0].kind == AsyncOutputKind.OUTPUT_READY and c[0][0].async_output_id == "abc123"
+            for c in proc.result_mq.enqueue.call_args_list
+        )
+        assert output_ready_enqueued, "Expected OUTPUT_READY with async_output_id='abc123' in enqueue calls"
diff --git a/tests/diffusion/test_compile.py b/tests/diffusion/test_compile.py
index ca898da95..447d8c75f 100644
--- a/tests/diffusion/test_compile.py
+++ b/tests/diffusion/test_compile.py
@@ -54,3 +54,23 @@ def test_regionally_compile_matches_wrapped_blocks_by_declared_container_attr(mo
     assert all(not block.compile_called for block in model.transformer_blocks)
     assert not model.other_blocks[0].compile_called
     assert model.transformer_blocks[0].forward("ok") == "compiled:ok"
+
+
+def test_regionally_compile_does_not_partially_mutate_on_setup_failure(monkeypatch):
+    model = _ModelWithWrappedRepeatedBlocks()
+    original_forwards = [block.forward.__func__ for block in model.transformer_blocks]
+    compile_calls = 0
+
+    def _compile(fn, *args, **kwargs):
+        nonlocal compile_calls
+        compile_calls += 1
+        if compile_calls == 2:
+            raise RuntimeError("compile setup failed")
+        return lambda *fn_args, **fn_kwargs: fn(*fn_args, **fn_kwargs)
+
+    monkeypatch.setattr(compile_module.torch, "compile", _compile)
+
+    with pytest.raises(RuntimeError, match="compile setup failed"):
+        regionally_compile(model, dynamic=True)
+
+    assert [block.forward.__func__ for block in model.transformer_blocks] == original_forwards
diff --git a/tests/test_diffusion_config_fields.py b/tests/diffusion/test_diffusion_config_fields.py
similarity index 97%
rename from tests/test_diffusion_config_fields.py
rename to tests/diffusion/test_diffusion_config_fields.py
index b87ceec1d..d62e7bdc8 100644
--- a/tests/test_diffusion_config_fields.py
+++ b/tests/diffusion/test_diffusion_config_fields.py
@@ -29,7 +29,7 @@ def test_diffusion_stage_configs_only_contain_valid_fields():
     Regression test for https://github.com/vllm-project/vllm-omni/issues/2563
     """
     # Scan both main configs and test configs
-    repo_root = Path(__file__).parent.parent
+    repo_root = Path(__file__).parent.parent.parent
     config_dirs = [
         repo_root / "vllm_omni" / "model_executor" / "stage_configs",
     ]
diff --git a/tests/test_diffusion_config_propagation.py b/tests/diffusion/test_diffusion_config_propagation.py
similarity index 97%
rename from tests/test_diffusion_config_propagation.py
rename to tests/diffusion/test_diffusion_config_propagation.py
index 10fe00168..205b2e491 100644
--- a/tests/test_diffusion_config_propagation.py
+++ b/tests/diffusion/test_diffusion_config_propagation.py
@@ -131,6 +131,11 @@ def test_qwen_image_edit_plus_sets_generic_multimodal_limit():
     assert od_config.max_multimodal_image_inputs == QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES
 
 
+def test_task_type_roundtrip():
+    od = _roundtrip_diffusion_config(model="x", task_type="model-defined-task")
+    assert od.task_type == "model-defined-task"
+
+
 def test_additional_config_roundtrip():
     additional_config = {"torchair_graph_config": {"enabled": True}}
     od = _roundtrip_diffusion_config(model="x", additional_config=additional_config)
diff --git a/tests/diffusion/test_diffusion_engine.py b/tests/diffusion/test_diffusion_engine.py
index 5f9a5a5c0..e26211e9c 100644
--- a/tests/diffusion/test_diffusion_engine.py
+++ b/tests/diffusion/test_diffusion_engine.py
@@ -14,8 +14,13 @@ import torch
 from pytest_mock import MockerFixture
 
 import vllm_omni.diffusion.diffusion_engine as diffusion_engine_module
+from tests.helpers.mark import hardware_test
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, _move_tensor_tree_to_cpu
+from vllm_omni.diffusion.diffusion_engine import (
+    DiffusionEngine,
+    DiffusionExecutionMode,
+    _move_tensor_tree_to_cpu,
+)
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched.interface import (
     CachedRequestData,
@@ -26,6 +31,8 @@ from vllm_omni.diffusion.sched.interface import (
 )
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
 
 @dataclass
 class DiffusionSchedulerOutput:
@@ -52,6 +59,8 @@ class MockScheduler:
     def __init__(self):
         self._waiting_queue = []
         self._step_id = 0
+        # Match RequestScheduler API used by request-batch admission wait.
+        self.max_num_running_reqs = 5
 
     def add_request(self, request):
         self._waiting_queue.append(request)
@@ -60,6 +69,12 @@ class MockScheduler:
     def has_requests(self):
         return len(self._waiting_queue) > 0
 
+    def num_waiting_requests(self) -> int:
+        return len(self._waiting_queue)
+
+    def num_running_requests(self) -> int:
+        return 0
+
     def schedule(self) -> DiffusionSchedulerOutput:
         if not self._waiting_queue:
             return DiffusionSchedulerOutput(step_id=self._step_id)
@@ -77,6 +92,21 @@ class MockScheduler:
         # assume all new req finished
         return [req.request_id for req in sched_output.scheduled_new_reqs]
 
+    def get_request_state(self, request_id):
+        return None
+
+    def pop_request_state(self, request_id):
+        return None
+
+    def finish_requests(self, request_id, status):
+        pass
+
+    def close(self):
+        pass
+
+    def initialize(self, od_config):
+        pass
+
 
 class _BatchCapablePipeline:
     supports_request_batch = True
@@ -221,7 +251,7 @@ class TestRequestBatchCapability:
             diffusion_engine_module.supports_request_batch(od_config)
         registry_load.assert_not_called()
 
-    def test_engine_disables_batch_dispatch_for_single_request_pipeline(
+    def test_engine_uses_request_batch_mode_for_single_request_pipeline(
         self,
         monkeypatch: pytest.MonkeyPatch,
         mocker: MockerFixture,
@@ -230,6 +260,7 @@ class TestRequestBatchCapability:
             model_class_name="SinglePipeline",
             custom_pipeline_args=None,
             streaming_output=False,
+            max_num_seqs=1,
         )
         fake_executor = SimpleNamespace(
             execute_request=mocker.Mock(return_value="per-request"),
@@ -255,15 +286,50 @@ class TestRequestBatchCapability:
             "_try_load_model_cls",
             lambda model_class_name: _SingleRequestPipeline,
         )
-        monkeypatch.setattr(DiffusionEngine, "_dummy_run", lambda self: None)
 
         engine = DiffusionEngine(od_config)
-        output = engine.execute_fn(_make_request_mode_sched_output("req-a", "req-b"))
+        output = engine.execute_fn(_make_request_mode_sched_output("req-a"))
 
+        assert engine.execution_mode == DiffusionExecutionMode.REQUEST_BATCH
         assert engine.supports_request_batch is False
-        assert output == "per-request"
-        fake_executor.execute_request.assert_called_once()
-        fake_executor.execute_batch.assert_not_called()
+        assert output == "batch"
+        fake_executor.execute_batch.assert_called_once()
+        fake_executor.execute_request.assert_not_called()
+
+    def test_engine_rejects_multi_seq_request_batch_for_single_request_pipeline(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        mocker: MockerFixture,
+    ) -> None:
+        od_config = SimpleNamespace(
+            model_class_name="SinglePipeline",
+            custom_pipeline_args=None,
+            streaming_output=False,
+            max_num_seqs=2,
+        )
+        fake_executor_cls = mocker.Mock()
+
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.get_diffusion_post_process_func",
+            lambda *args, **kwargs: None,
+        )
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.get_diffusion_pre_process_func",
+            lambda *args, **kwargs: None,
+        )
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.DiffusionExecutor.get_class",
+            lambda *args, **kwargs: fake_executor_cls,
+        )
+        monkeypatch.setattr(
+            diffusion_engine_module.DiffusionModelRegistry,
+            "_try_load_model_cls",
+            lambda model_class_name: _SingleRequestPipeline,
+        )
+
+        with pytest.raises(ValueError, match="max_num_seqs=1"):
+            DiffusionEngine(od_config)
+        fake_executor_cls.assert_not_called()
 
     @pytest.mark.parametrize("request_ids", [("req-a",), ("req-a", "req-b")])
     def test_engine_enables_batch_dispatch_for_request_batch_pipeline(
@@ -276,6 +342,7 @@ class TestRequestBatchCapability:
             model_class_name="BatchPipeline",
             custom_pipeline_args=None,
             streaming_output=False,
+            max_num_seqs=2,
         )
         fake_executor = SimpleNamespace(
             execute_request=mocker.Mock(return_value="per-request"),
@@ -301,16 +368,106 @@ class TestRequestBatchCapability:
             "_try_load_model_cls",
             lambda model_class_name: _BatchCapablePipeline,
         )
-        monkeypatch.setattr(DiffusionEngine, "_dummy_run", lambda self: None)
 
         engine = DiffusionEngine(od_config)
         output = engine.execute_fn(_make_request_mode_sched_output(*request_ids))
 
+        assert engine.execution_mode == DiffusionExecutionMode.REQUEST_BATCH
         assert engine.supports_request_batch is True
         assert output == "batch"
         fake_executor.execute_batch.assert_called_once()
         fake_executor.execute_request.assert_not_called()
 
+    def test_make_engine_runs_startup_warmup(self, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture) -> None:
+        od_config = SimpleNamespace(
+            model_class_name="SinglePipeline",
+            custom_pipeline_args=None,
+            engine_backend="default",
+            streaming_output=False,
+        )
+        fake_executor = SimpleNamespace(
+            execute_request=mocker.Mock(),
+            execute_batch=mocker.Mock(),
+            execute_step=mocker.Mock(),
+        )
+        fake_executor_cls = mocker.Mock(return_value=fake_executor)
+        warmup = mocker.Mock()
+
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.get_diffusion_post_process_func",
+            lambda *args, **kwargs: None,
+        )
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.get_diffusion_pre_process_func",
+            lambda *args, **kwargs: None,
+        )
+        monkeypatch.setattr(
+            "vllm_omni.diffusion.diffusion_engine.DiffusionExecutor.get_class",
+            lambda *args, **kwargs: fake_executor_cls,
+        )
+        monkeypatch.setattr(
+            diffusion_engine_module.DiffusionModelRegistry,
+            "_try_load_model_cls",
+            lambda model_class_name: _SingleRequestPipeline,
+        )
+        monkeypatch.setattr(DiffusionEngine, "run_startup_warmup", warmup)
+
+        engine = DiffusionEngine.make_engine(od_config)
+
+        assert isinstance(engine, DiffusionEngine)
+        warmup.assert_called_once_with()
+
+
+class TestDiffusionCompileConfig:
+    pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+    def test_config_defaults_to_dynamic_regional_compile(self) -> None:
+        config = OmniDiffusionConfig(model="test")
+
+        assert config.diffusion_compile_granularity == "regional"
+        assert config.diffusion_compile_dynamic is True
+
+    def test_from_kwargs_preserves_compile_controls(self) -> None:
+        config = OmniDiffusionConfig.from_kwargs(
+            model="test",
+            diffusion_compile_granularity="full",
+            diffusion_compile_dynamic=False,
+        )
+
+        assert config.diffusion_compile_granularity == "full"
+        assert config.diffusion_compile_dynamic is False
+
+    def test_config_rejects_invalid_compile_granularity(self) -> None:
+        with pytest.raises(ValueError, match="diffusion_compile_granularity"):
+            OmniDiffusionConfig(model="test", diffusion_compile_granularity="block")
+
+    def test_config_rejects_non_boolean_compile_dynamic(self) -> None:
+        with pytest.raises(TypeError, match="diffusion_compile_dynamic"):
+            OmniDiffusionConfig(model="test", diffusion_compile_dynamic="false")
+
+    @pytest.mark.parametrize(
+        "kwargs, feature",
+        [
+            ({"parallel_config": {"ulysses_degree": 2}, "num_gpus": 2}, "sequence parallelism"),
+            (
+                {
+                    "parallel_config": {"use_hsdp": True, "hsdp_shard_size": 2},
+                    "num_gpus": 2,
+                },
+                "HSDP",
+            ),
+            ({"enable_cpu_offload": True}, "CPU offload"),
+            ({"enable_layerwise_offload": True}, "layerwise offload"),
+        ],
+    )
+    def test_full_compile_rejects_incompatible_features(self, kwargs, feature) -> None:
+        with pytest.raises(ValueError, match=feature):
+            OmniDiffusionConfig(
+                model="test",
+                diffusion_compile_granularity="full",
+                **kwargs,
+            )
+
 
 class TestRequestBatchAdmission:
     pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
@@ -451,9 +608,7 @@ def test_move_tensor_tree_returns_non_tensor_values_unchanged() -> None:
     assert moved is value
 
 
-@pytest.mark.diffusion
-@pytest.mark.cuda
-@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_move_tensor_tree_moves_nested_cuda_tensors_to_cpu() -> None:
     tensor = torch.arange(8, dtype=torch.float32, device="cuda")
     other = torch.arange(4, dtype=torch.int64, device="cuda")
@@ -470,23 +625,45 @@ def test_move_tensor_tree_moves_nested_cuda_tensors_to_cpu() -> None:
     assert moved["items"][1][0] == "keep"
 
 
+async def _consume_final_output(generator):
+    final_output = None
+    async for output in generator:
+        final_output = output
+    if final_output is None:
+        raise RuntimeError("Diffusion execution finished without output.")
+    return final_output
+
+
+@pytest.mark.cpu
 @pytest.mark.asyncio
-async def test_async_add_req_and_wait_for_response():
+async def test_async_add_req_and_stream_response():
     engine = object.__new__(DiffusionEngine)
     engine.scheduler = MockScheduler()
-    engine._out_queue = {}
+    engine._out_streams = {}
     engine.abort_queue: queue.Queue[str] = queue.Queue()
     engine._rpc_queue = queue.Queue()
     engine._rpc_lock = threading.RLock()
     engine._cv = threading.Condition(engine._rpc_lock)
     engine._init_lock = asyncio.Lock()
     engine._closed = False
-    engine.od_config = SimpleNamespace(streaming_output=False)
+    # Enable admission wait so concurrent adds land in one schedule wave;
+    # otherwise the first request can execute alone (~1s) and the rest in a
+    # second wave (~2s), failing the latency-spread assertion.
+    engine.od_config = SimpleNamespace(
+        streaming_output=False,
+        request_batch_max_wait_ms=500.0,
+    )
     engine._loop_started = False
     engine.main_loop = None
-    engine.supports_request_batch = False
+    engine.supports_request_batch = True
+    engine.step_execution = False
+    engine.execution_mode = DiffusionExecutionMode.REQUEST_BATCH
 
-    engine._finalize_finished_request = lambda rid, out, err: out.result
+    def _finalize(rid, out, err=None, **kwargs):
+        # Stream consumers stop on ``finished``; keep result_data for assertions.
+        return SimpleNamespace(result_data=out.result.result_data, finished=True)
+
+    engine._finalize_finished_request = _finalize
 
     def mock_execute_batch(sched_output):
         request_ids = sched_output.scheduled_request_ids
@@ -512,7 +689,7 @@ async def test_async_add_req_and_wait_for_response():
     async def run_task(rid):
         req = SimpleNamespace(request_id=rid)
         start = time.time()
-        res = await engine.async_add_req_and_wait_for_response(req)
+        res = await _consume_final_output(engine.async_add_req_and_stream_response(req))
         return rid, res, time.time() - start
 
     task_ids = [f"req_{i}" for i in range(5)]
diff --git a/tests/diffusion/test_diffusion_engine_cleanup.py b/tests/diffusion/test_diffusion_engine_cleanup.py
index 3cc3d48f7..b7a9a345f 100644
--- a/tests/diffusion/test_diffusion_engine_cleanup.py
+++ b/tests/diffusion/test_diffusion_engine_cleanup.py
@@ -5,15 +5,17 @@ import asyncio
 import queue
 import threading
 from types import SimpleNamespace
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 import pytest
 
+from vllm_omni.diffusion import diffusion_engine as diffusion_engine_module
 from vllm_omni.diffusion.data import DiffusionOutput
-from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
+from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, DiffusionExecutionMode
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched import DiffusionRequestStatus, RequestScheduler
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.outputs import OmniRequestOutput
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
@@ -33,8 +35,7 @@ def _make_engine() -> DiffusionEngine:
     engine.executor = SimpleNamespace(shutdown=Mock())
     engine._rpc_lock = threading.RLock()
     engine._cv = threading.Condition(engine._rpc_lock)
-    engine._out_queue = {}
-    engine._out_queue_streaming = {}
+    engine._out_streams = {}
     engine._closed = False
     engine._shutdown_complete = False
     engine.abort_queue = queue.Queue()
@@ -44,28 +45,13 @@ def _make_engine() -> DiffusionEngine:
     return engine
 
 
-def test_close_completes_pending_async_waiters() -> None:
-    engine = _make_engine()
-    event_loop = asyncio.new_event_loop()
-    try:
-        future = event_loop.create_future()
-        engine._out_queue["pending-req"] = future
-
-        engine.close()
-
-        assert future.done()
-        assert future.result().error == "DiffusionEngine is closed."
-    finally:
-        event_loop.close()
-
-
-def test_close_completes_pending_streaming_waiters() -> None:
+def test_close_completes_pending_output_streams() -> None:
     engine = _make_engine()
     event_loop = asyncio.new_event_loop()
     try:
         engine.main_loop = event_loop
         queue: asyncio.Queue[DiffusionOutput] = asyncio.Queue()
-        engine._out_queue_streaming["pending-stream"] = queue
+        engine._out_streams["pending-stream"] = queue
 
         engine.close()
 
@@ -76,21 +62,101 @@ def test_close_completes_pending_streaming_waiters() -> None:
         event_loop.close()
 
 
-def test_handle_finished_requests_ignores_already_drained_waiter() -> None:
+def test_emit_finished_outputs_finalizes_already_drained_waiter() -> None:
     class RacingOutQueue(dict):
-        def __contains__(self, key):
-            return True
-
-        def pop(self, key, default=None):
+        def get(self, key, default=None):
             return default
 
     engine = _make_engine()
-    engine._out_queue = RacingOutQueue()
-    engine._finalize_finished_request = Mock(side_effect=AssertionError("should not finalize drained waiters"))
+    request_id = engine.scheduler.add_request(_make_request("pending-req"))
+    engine.scheduler.finish_requests(request_id, DiffusionRequestStatus.FINISHED_ABORTED)
+    engine._out_streams = RacingOutQueue()
 
-    engine._handle_finished_requests({"pending-req"})
+    engine._emit_finished_outputs({request_id})
 
-    engine._finalize_finished_request.assert_not_called()
+    assert engine.scheduler.get_request_state(request_id) is None
+
+
+def test_emit_step_outputs_finalizes_finished_request_without_stream() -> None:
+    engine = _make_engine()
+    engine.execution_mode = DiffusionExecutionMode.STEP_BATCH
+    request_id = engine.scheduler.add_request(_make_request("step-drained"))
+    engine.scheduler.finish_requests(request_id, DiffusionRequestStatus.FINISHED_ABORTED)
+
+    engine._emit_outputs({request_id}, [request_id], SimpleNamespace(get_request_output=lambda _request_id: None))
+
+    assert engine.scheduler.get_request_state(request_id) is None
+
+
+def test_init_accepts_custom_scheduler(monkeypatch: pytest.MonkeyPatch) -> None:
+    od_config = SimpleNamespace(
+        custom_pipeline_args=None,
+        model_class_name="CustomSchedulerPipeline",
+        streaming_output=False,
+    )
+    custom_scheduler = RequestScheduler()
+    fake_executor = SimpleNamespace(
+        execute_request=Mock(),
+        execute_batch=Mock(),
+        execute_step=Mock(),
+    )
+
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.diffusion_engine.get_diffusion_post_process_func",
+        lambda *args, **kwargs: None,
+    )
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.diffusion_engine.get_diffusion_pre_process_func",
+        lambda *args, **kwargs: None,
+    )
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.diffusion_engine.DiffusionExecutor.get_class",
+        lambda *args, **kwargs: Mock(return_value=fake_executor),
+    )
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.diffusion_engine.supports_request_batch",
+        lambda *args, **kwargs: False,
+    )
+
+    engine = DiffusionEngine(od_config, scheduler=custom_scheduler)
+
+    assert engine.scheduler is custom_scheduler
+
+
+@pytest.mark.asyncio
+async def test_step_compatibility_wrapper_returns_final_batch() -> None:
+    engine = _make_engine()
+    first = [OmniRequestOutput.from_diffusion(request_id="req", images=[], finished=False)]
+    final = [OmniRequestOutput.from_diffusion(request_id="req", images=[], finished=True)]
+
+    async def _step_streaming(_request):
+        yield first
+        yield final
+
+    engine.step_streaming = _step_streaming  # type: ignore[method-assign]
+    with patch.object(diffusion_engine_module.logger, "warning_once") as warning_once:
+        output = await engine.step(_make_request("req"))
+
+    assert output is final
+    warning_once.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_async_wait_compatibility_wrapper_returns_final_output() -> None:
+    engine = _make_engine()
+    first = DiffusionOutput(output="chunk", finished=False)
+    final = DiffusionOutput(output="final", finished=True)
+
+    async def _stream_response(_request):
+        yield first
+        yield final
+
+    engine.async_add_req_and_stream_response = _stream_response  # type: ignore[method-assign]
+    with patch.object(diffusion_engine_module.logger, "warning_once") as warning_once:
+        output = await engine.async_add_req_and_wait_for_response(_make_request("req"))
+
+    assert output is final
+    warning_once.assert_called_once()
 
 
 def test_abort_request_id_aborts_scheduler_request() -> None:
diff --git a/tests/diffusion/test_diffusion_engine_metrics.py b/tests/diffusion/test_diffusion_engine_metrics.py
index 2e8eae242..8f434c0e2 100644
--- a/tests/diffusion/test_diffusion_engine_metrics.py
+++ b/tests/diffusion/test_diffusion_engine_metrics.py
@@ -12,6 +12,11 @@ from __future__ import annotations
 import ast
 import os
 
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
 _ENGINE_PATH = os.path.normpath(
     os.path.join(
         os.path.dirname(__file__),
@@ -80,27 +85,23 @@ class TestMetricKeys:
             "format_diffusion_outputs() — should only use 'preprocess_time_ms'"
         )
 
-    def test_metric_key_naming_consistency(self) -> None:
-        """Metric keys should map to the explicit timing fields."""
+    def test_timing_metric_key_naming_consistency(self) -> None:
+        """Timing metrics should be attached by the engine orchestration path."""
         source = _read_source(_FORMATTER_PATH)
         formatter_source = _get_function_source(source, None, "format_diffusion_outputs")
+        engine_source = _read_source(_ENGINE_PATH)
+        step_streaming_source = _get_function_source(engine_source, "DiffusionEngine", "step_streaming")
         lines = formatter_source.split("\n")
 
-        found_exec = False
-        found_total = False
         for line in lines:
             if '"diffusion_engine_exec_time_ms"' in line:
-                found_exec = True
-                assert "timings.exec_time_s" in line, (
-                    "diffusion_engine_exec_time_ms should measure executor time only (timings.exec_time_s)"
-                )
+                raise AssertionError("diffusion_engine_exec_time_ms should be attached in step_streaming()")
             if '"diffusion_engine_total_time_ms"' in line:
-                found_total = True
-                assert "timings.total_time_ms" in line, (
-                    "diffusion_engine_total_time_ms should measure full step time (timings.total_time_ms)"
-                )
-        assert found_exec, "diffusion_engine_exec_time_ms key not found in format_diffusion_outputs()"
-        assert found_total, "diffusion_engine_total_time_ms key not found in format_diffusion_outputs()"
+                raise AssertionError("diffusion_engine_total_time_ms should be attached in step_streaming()")
+
+        assert '"diffusion_engine_exec_time_ms": exec_total_time * 1000' in step_streaming_source
+        assert '"diffusion_engine_total_time_ms": step_total_ms' in step_streaming_source
+        assert '"postprocess_time_ms": postprocess_time * 1000' in step_streaming_source
 
 
 class TestDummyRunAllocation:
diff --git a/tests/diffusion/test_diffusion_engine_rpc_routing.py b/tests/diffusion/test_diffusion_engine_rpc_routing.py
index 4b7d0efbb..dff5ac7bc 100644
--- a/tests/diffusion/test_diffusion_engine_rpc_routing.py
+++ b/tests/diffusion/test_diffusion_engine_rpc_routing.py
@@ -30,16 +30,16 @@ from typing import Any
 import pytest
 
 from vllm_omni.diffusion.data import DiffusionOutput
-from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, _RpcTask
+from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, DiffusionExecutionMode, _RpcTask
 from vllm_omni.diffusion.sched import RequestScheduler
 from vllm_omni.diffusion.sched.interface import RequestBatchSamplingParamsKey
 from vllm_omni.diffusion.worker.utils import RunnerOutput
 
 # Default values for every batch-key field, so SimpleNamespace-based
-# sampling_params satisfy ``get_sampling_params_key``'s attribute lookups.
+# sampling_params satisfy ``RequestScheduler._build_sampling_params_key``'s attribute lookups.
 _SAMPLING_KEY_DEFAULTS = {f.name: f.default for f in _dc_fields(RequestBatchSamplingParamsKey)}
 
-pytestmark = [pytest.mark.diffusion, pytest.mark.cpu]
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
 
 
 # ───────────────────────────────────────── helpers ─────────────────────────
@@ -91,7 +91,7 @@ class _ConcurrencyTrackingExecutor:
                 # args[0] is the request-like object for execute_model.
                 req = args[0] if args else None
                 tag = req.request_id if req is not None and hasattr(req, "request_id") else "unknown"
-                return DiffusionOutput(error=f"result_for_{tag}")
+                return DiffusionOutput(error=f"result_for_{tag}", finished=True)
             tag = args[0] if args else method
             return DiffusionOutput(error=f"rpc_result_for_{tag}")
         finally:
@@ -149,12 +149,12 @@ def _make_engine_with_loop(
     engine.scheduler = sched
     engine.step_execution = False
     engine.supports_request_batch = False
+    engine.execution_mode = DiffusionExecutionMode.REQUEST_BATCH
     engine.execute_fn = engine.executor.execute_request
 
     engine._rpc_lock = threading.RLock()
     engine._cv = threading.Condition(engine._rpc_lock)
-    engine._out_queue = {}
-    engine._out_queue_streaming = {}
+    engine._out_streams = {}
     engine._closed = False
     engine.abort_queue = queue.Queue()
     engine._rpc_queue = queue.Queue()
@@ -187,6 +187,15 @@ def _stop_engine(engine: DiffusionEngine) -> None:
     assert not engine.worker_thread.is_alive(), "Busy loop thread did not stop"
 
 
+async def _consume_final_output(generator):
+    final_output = None
+    async for output in generator:
+        final_output = output
+    if final_output is None:
+        raise RuntimeError("Diffusion execution finished without output.")
+    return final_output
+
+
 # ─────────────────────── single-thread invariant ───────────────────────────
 
 
@@ -199,7 +208,7 @@ async def test_executor_only_called_from_busy_loop_thread():
     busy_tid = engine.worker_thread.ident
     try:
         # Per-request path
-        await engine.async_add_req_and_wait_for_response(_make_request("req1"))
+        await _consume_final_output(engine.async_add_req_and_stream_response(_make_request("req1")))
         # Raw RPC path (sync from a worker thread)
         result = await asyncio.to_thread(engine.collective_rpc, "ping", args=("a",), unique_reply_rank=0)
         assert result.error == "rpc_result_for_a"
@@ -228,7 +237,7 @@ async def test_executor_calls_never_overlap_under_load():
             return await engine.async_collective_rpc("ping", args=(f"x{i}",), unique_reply_rank=0)
 
         async def _request(i: int):
-            return await engine.async_add_req_and_wait_for_response(_make_request(f"r{i}"))
+            return await _consume_final_output(engine.async_add_req_and_stream_response(_make_request(f"r{i}")))
 
         tasks = [_rpc(i) for i in range(20)] + [_request(i) for i in range(5)]
         results = await asyncio.gather(*tasks)
@@ -510,7 +519,9 @@ async def test_rpc_and_request_results_do_not_swap():
     engine = _make_engine_with_loop(loop, rpc_delay=0.02)
     try:
         rpc_task = asyncio.create_task(engine.async_collective_rpc("ping", args=("rpc1",), unique_reply_rank=0))
-        req_task = asyncio.create_task(engine.async_add_req_and_wait_for_response(_make_request("req1")))
+        req_task = asyncio.create_task(
+            _consume_final_output(engine.async_add_req_and_stream_response(_make_request("req1")))
+        )
         rpc_res, req_res = await asyncio.gather(rpc_task, req_task)
     finally:
         _stop_engine(engine)
diff --git a/tests/diffusion/test_diffusion_model_runner.py b/tests/diffusion/test_diffusion_model_runner.py
index 5d4ef5d72..a7f230d93 100644
--- a/tests/diffusion/test_diffusion_model_runner.py
+++ b/tests/diffusion/test_diffusion_model_runner.py
@@ -98,7 +98,39 @@ class _ChunkStepPipeline:
         return output
 
 
-def _make_request(skip_cache_refresh: bool = True):
+class _FinalOnlyStepPipeline:
+    device = torch.device("cpu")
+    supports_step_execution = True
+
+    def prepare_encode(self, state):
+        state.prompt_embeds = torch.zeros(1, 1, 1)
+        state.latents = torch.zeros(1, 1)
+        state.timesteps = torch.tensor([1.0])
+        state.step_index = 0
+        return state
+
+    def denoise_step(self, input_batch, states):
+        del states
+        return torch.ones_like(input_batch.latents)
+
+    def step_scheduler(self, state, noise_pred):
+        state.latents = noise_pred
+        state.step_index += 1
+
+    def post_decode(self, state):
+        return DiffusionOutput(output=state.latents.clone())
+
+
+class _CompileTrackingModel:
+    def __init__(self):
+        self.compile_calls = []
+
+    def compile(self, *args, **kwargs):
+        self.compile_calls.append((args, kwargs))
+        return self
+
+
+def _make_request():
     sampling_params = SimpleNamespace(
         generator=None,
         seed=None,
@@ -109,7 +141,6 @@ def _make_request(skip_cache_refresh: bool = True):
         request_id="req-test",
         prompt="a prompt",
         sampling_params=sampling_params,
-        skip_cache_refresh=skip_cache_refresh,
         kv_sender_info=None,
     )
 
@@ -120,7 +151,6 @@ def _make_request_with_params(req_id: str, sampling_params):
         prompt=f"prompt-{req_id}",
         prompts=[f"prompt-{req_id}"],
         sampling_params=sampling_params,
-        skip_cache_refresh=True,
     )
 
 
@@ -156,10 +186,20 @@ def _make_runner(cache_backend, cache_backend_name: str, enable_cache_dit_summar
     return runner
 
 
-def _make_compile_runner(*, use_hsdp: bool):
+def _make_compile_runner(
+    model=None,
+    *,
+    compile_granularity: str = "regional",
+    compile_dynamic: bool = True,
+    use_hsdp: bool = False,
+):
     runner = object.__new__(DiffusionModelRunner)
-    runner.pipeline = SimpleNamespace(transformer=SimpleNamespace())
-    runner.od_config = SimpleNamespace(parallel_config=SimpleNamespace(use_hsdp=use_hsdp))
+    runner.pipeline = SimpleNamespace(transformer=model or SimpleNamespace())
+    runner.od_config = SimpleNamespace(
+        diffusion_compile_granularity=compile_granularity,
+        diffusion_compile_dynamic=compile_dynamic,
+        parallel_config=SimpleNamespace(use_hsdp=use_hsdp),
+    )
     return runner
 
 
@@ -187,6 +227,65 @@ def test_compile_transformer_regionally_compiles_blocks(monkeypatch, use_hsdp):
     ]
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_compile_transformer_uses_regional_dynamic_false_config(monkeypatch):
+    model = _CompileTrackingModel()
+    runner = _make_compile_runner(model, compile_dynamic=False)
+    compiled_model = object()
+    regional_calls = []
+
+    def _regionally_compile(target, **kwargs):
+        regional_calls.append((target, kwargs))
+        return compiled_model
+
+    monkeypatch.setattr(model_runner_module, "regionally_compile", _regionally_compile)
+
+    DiffusionModelRunner._compile_transformer(runner, "transformer")
+
+    assert regional_calls == [(model, {"dynamic": False})]
+    assert model.compile_calls == []
+    assert runner.pipeline.transformer is compiled_model
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_compile_transformer_uses_full_granularity(monkeypatch):
+    model = _CompileTrackingModel()
+    runner = _make_compile_runner(model, compile_granularity="full", compile_dynamic=False)
+    regional_calls = []
+
+    monkeypatch.setattr(
+        model_runner_module,
+        "regionally_compile",
+        lambda *args, **kwargs: regional_calls.append((args, kwargs)),
+    )
+
+    DiffusionModelRunner._compile_transformer(runner, "transformer")
+
+    assert model.compile_calls == [((), {"dynamic": False})]
+    assert regional_calls == []
+    assert runner.pipeline.transformer is model
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_compile_transformer_falls_back_after_synchronous_setup_failure(monkeypatch, caplog):
+    model = _CompileTrackingModel()
+    runner = _make_compile_runner(model)
+
+    def _regionally_compile(*args, **kwargs):
+        raise RuntimeError("compile setup failed")
+
+    monkeypatch.setattr(model_runner_module, "regionally_compile", _regionally_compile)
+
+    DiffusionModelRunner._compile_transformer(runner, "transformer")
+
+    assert runner.pipeline.transformer is model
+    assert "failed before activation" in caplog.text
+    assert "lazy compilation errors" in caplog.text
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_execute_stepwise_streaming_returns_chunks_at_boundaries(monkeypatch):
@@ -199,7 +298,7 @@ def test_execute_stepwise_streaming_returns_chunks_at_boundaries(monkeypatch):
     runner.pipeline = _ChunkStepPipeline(chunks)
     runner.od_config.streaming_output = True
     runner.od_config.step_execution = True
-    req = _make_request(skip_cache_refresh=True)
+    req = _make_request()
     req.request_id = "req"
 
     monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
@@ -230,12 +329,41 @@ def test_execute_stepwise_streaming_returns_chunks_at_boundaries(monkeypatch):
     assert fourth.get_request_output("req").finished is True
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_execute_stepwise_streaming_decodes_final_only_pipeline(monkeypatch):
+    """Step streaming still returns a final output when no chunk boundaries exist."""
+    runner = _make_runner(cache_backend=None, cache_backend_name=None)
+    runner.pipeline = _FinalOnlyStepPipeline()
+    runner.od_config.streaming_output = True
+    runner.od_config.step_execution = True
+    req = _make_request()
+    req.request_id = "req"
+    req.sampling_params.num_inference_steps = 1
+
+    monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "reset_peak_memory_stats", lambda: None)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "max_memory_reserved", lambda: 0)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "max_memory_allocated", lambda: 0)
+    scheduler_output = SimpleNamespace(
+        finished_req_ids=set(),
+        scheduled_new_reqs=[SimpleNamespace(request_id="req", req=req)],
+        scheduled_cached_reqs=SimpleNamespace(request_ids=[]),
+    )
+
+    output = DiffusionModelRunner.execute_stepwise(runner, scheduler_output).get_request_output("req")
+
+    assert output.finished is True
+    assert output.result is not None
+    assert torch.equal(output.result.output, torch.ones(1, 1))
+
+
 @pytest.mark.core_model
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_execute_model_skips_cache_summary_without_active_cache_backend(monkeypatch):
     """Guard cache diagnostics with runtime backend state to avoid stale-config crashes."""
     runner = _make_runner(cache_backend=None, cache_backend_name="cache_dit")
-    req = _make_request(skip_cache_refresh=True)
+    req = _make_request()
 
     cache_summary_calls = []
 
@@ -259,11 +387,18 @@ def test_execute_model_skips_cache_summary_without_active_cache_backend(monkeypa
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_execute_model_emits_cache_summary_with_active_cache_dit_backend(monkeypatch):
     class _EnabledCacheBackend:
+        def __init__(self):
+            self.refresh_calls = []
+
         def is_enabled(self):
             return True
 
-    runner = _make_runner(cache_backend=_EnabledCacheBackend(), cache_backend_name="cache_dit")
-    req = _make_request(skip_cache_refresh=True)
+        def refresh(self, pipeline, num_inference_steps, verbose=True):
+            self.refresh_calls.append((pipeline, num_inference_steps, verbose))
+
+    cache_backend = _EnabledCacheBackend()
+    runner = _make_runner(cache_backend=cache_backend, cache_backend_name="cache_dit")
+    req = _make_request()
 
     cache_summary_calls = []
 
@@ -281,6 +416,7 @@ def test_execute_model_emits_cache_summary_with_active_cache_dit_backend(monkeyp
 
     assert output.output == "ok"
     assert cache_summary_calls == [(runner.pipeline, True)]
+    assert cache_backend.refresh_calls == [(runner.pipeline, 4, True)]
 
 
 @pytest.mark.core_model
@@ -288,7 +424,7 @@ def test_execute_model_emits_cache_summary_with_active_cache_dit_backend(monkeyp
 def test_execute_model_passes_single_request_batch_to_non_admission_pipeline(monkeypatch):
     runner = _make_runner(cache_backend=None, cache_backend_name="none")
     runner.pipeline = _SingleRequestBatchPipeline()
-    req = _make_request(skip_cache_refresh=True)
+    req = _make_request()
 
     monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
 
@@ -304,7 +440,7 @@ def test_execute_model_passes_single_request_batch_to_non_admission_pipeline(mon
 def test_execute_model_accepts_bare_diffusion_output_from_single_request_pipeline(monkeypatch):
     runner = _make_runner(cache_backend=None, cache_backend_name="none")
     runner.pipeline = _SingleRequestDiffusionOutputPipeline()
-    req = _make_request(skip_cache_refresh=True)
+    req = _make_request()
 
     monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
 
@@ -515,7 +651,7 @@ def test_execute_model_runs_forward_after_kv_receive(monkeypatch):
     """execute_model runs the pipeline forward after the KV receive step."""
     runner = _make_runner(cache_backend=None, cache_backend_name=None)
     runner.kv_transfer_manager.receive_multi_kv_cache_distributed = lambda *a, **k: True
-    req = _make_request(skip_cache_refresh=True)
+    req = _make_request()
 
     monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
     monkeypatch.setattr(model_runner_module.current_omni_platform, "reset_peak_memory_stats", lambda: None)
diff --git a/tests/diffusion/test_diffusion_output_formatter.py b/tests/diffusion/test_diffusion_output_formatter.py
index 22b305eab..eea53210c 100644
--- a/tests/diffusion/test_diffusion_output_formatter.py
+++ b/tests/diffusion/test_diffusion_output_formatter.py
@@ -11,7 +11,6 @@ import torch
 from vllm_omni.diffusion import output_formatter
 from vllm_omni.diffusion.data import DiffusionOutput
 from vllm_omni.diffusion.output_formatter import (
-    DiffusionStepTimings,
     format_diffusion_outputs,
     format_empty_diffusion_outputs,
     normalize_diffusion_postprocess_output,
@@ -42,15 +41,6 @@ def _config(model_class_name: str = "mock_model") -> SimpleNamespace:
     return SimpleNamespace(model_class_name=model_class_name)
 
 
-def _timings() -> DiffusionStepTimings:
-    return DiffusionStepTimings(
-        preprocess_time_s=0.01,
-        exec_time_s=0.02,
-        postprocess_time_s=0.03,
-        total_time_ms=60.0,
-    )
-
-
 def test_formatter_preserves_single_video_audio_actions_and_metadata(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -80,7 +70,6 @@ def test_formatter_preserves_single_video_audio_actions_and_metadata(
         ),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert len(results) == 1
@@ -102,12 +91,10 @@ def test_formatter_preserves_single_video_audio_actions_and_metadata(
     assert result.stage_durations == {"execute": 1.25}
     assert result.peak_memory_mb == 321.0
     assert result.metrics == {
-        "preprocess_time_ms": 10.0,
-        "diffusion_engine_exec_time_ms": 20.0,
-        "diffusion_engine_total_time_ms": 60.0,
         "image_num": 1,
         "resolution": 512,
-        "postprocess_time_ms": 30.0,
+        "width": None,
+        "height": None,
     }
 
 
@@ -160,7 +147,6 @@ def test_formatter_normalizes_payload_metadata_envelope(
         diffusion_output=DiffusionOutput(output=None),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.multimodal_output == {
@@ -196,7 +182,6 @@ def test_formatter_maps_trajectory_payload_to_request_output(
         diffusion_output=DiffusionOutput(output=None),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == ["image-0"]
@@ -229,7 +214,6 @@ def test_formatter_preserves_text_envelope_metadata(monkeypatch: pytest.MonkeyPa
         diffusion_output=DiffusionOutput(output=None),
         output_data={"payload": {"text": "caption"}},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == []
@@ -241,6 +225,40 @@ def test_formatter_preserves_text_envelope_metadata(monkeypatch: pytest.MonkeyPa
     }
 
 
+@pytest.mark.parametrize(
+    "text_metadata",
+    [
+        pytest.param({"think_text": "reasoning"}, id="sensenova-bagel-thinking"),
+        pytest.param({"ar_generated_text": "reasoning"}, id="hunyuan-image3-cot"),
+    ],
+)
+def test_formatter_preserves_image_with_reasoning_metadata(
+    monkeypatch: pytest.MonkeyPatch,
+    text_metadata: dict[str, str],
+) -> None:
+    monkeypatch.setattr(output_formatter, "supports_audio_output", lambda _: False)
+    metadata = {"text": text_metadata}
+    postprocess_output = normalize_diffusion_postprocess_output(
+        {
+            "payload": {"image": "image-0"},
+            "metadata": metadata,
+        }
+    )
+
+    [result] = format_diffusion_outputs(
+        request=_request("generate an image"),
+        od_config=_config(),
+        diffusion_output=DiffusionOutput(output=None),
+        output_data=None,
+        postprocess_output=postprocess_output,
+    )
+
+    assert postprocess_output.primary_key == "image"
+    assert result.images == ["image-0"]
+    assert result.final_output_type == "image"
+    assert result.multimodal_output == {"metadata": metadata}
+
+
 def test_formatter_preserves_audio_output_with_model_sample_rate_fallback(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -261,7 +279,6 @@ def test_formatter_preserves_audio_output_with_model_sample_rate_fallback(
         diffusion_output=DiffusionOutput(output=["waveform"]),
         output_data=["waveform"],
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == []
@@ -293,7 +310,6 @@ def test_formatter_preserves_audio_model_video_audio_and_actions(
         diffusion_output=DiffusionOutput(output=None),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == ["frame-0"]
@@ -328,7 +344,6 @@ def test_formatter_preserves_audio_only_postprocess_dict(
         diffusion_output=DiffusionOutput(output=None),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == []
@@ -360,7 +375,6 @@ def test_formatter_preserves_single_prompt_multiple_audio_outputs(
         diffusion_output=DiffusionOutput(output=["waveform-0", "waveform-1"]),
         output_data=["waveform-0", "waveform-1"],
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert result.images == []
@@ -388,7 +402,6 @@ def test_formatter_preserves_single_prompt_audio_and_action_payloads(
         diffusion_output=DiffusionOutput(output=None),
         output_data={"raw": "output"},
         postprocess_output=postprocess_output,
-        timings=_timings(),
     )
 
     assert len(results) == 1
diff --git a/tests/diffusion/test_diffusion_request.py b/tests/diffusion/test_diffusion_request.py
index ffaab3c53..259492c1e 100644
--- a/tests/diffusion/test_diffusion_request.py
+++ b/tests/diffusion/test_diffusion_request.py
@@ -72,3 +72,40 @@ def test_tp_seed_same_across_ranks_and_varies_across_requests():
 
     # Seeds must vary across requests (non-determinism preserved).
     assert len(set(seeds)) == n_requests, f"Expected {n_requests} unique seeds but got {len(set(seeds))}: {seeds}"
+
+
+def _request_with_guidance(**sampling_kwargs) -> OmniDiffusionRequest:
+    return OmniDiffusionRequest(
+        prompt={"prompt": "a cup of coffee on a table"},
+        sampling_params=OmniDiffusionSamplingParams(num_inference_steps=1, **sampling_kwargs),
+        request_id="request-test",
+    )
+
+
+def test_omitted_guidance_scale_is_unset_and_resolved_to_one():
+    # No guidance_scale passed: the caller did not set it, so it must NOT count as
+    # "provided" (each pipeline applies its own default), and __post_init__ resolves the
+    # None "unset" sentinel to a concrete float so no consumer ever observes None.
+    req = _request_with_guidance()
+
+    assert req.sampling_params.guidance_scale_provided is False
+    assert req.sampling_params.guidance_scale == 1.0
+
+
+def test_explicit_zero_guidance_scale_is_honored():
+    # Regression (#4998): an explicit guidance_scale=0 (disable CFG) must be honored,
+    # not mistaken for "unset" and overridden by the pipeline's model default. This is
+    # the sentinel collision that the None default + ``is not None`` check fixes.
+    req = _request_with_guidance(guidance_scale=0.0)
+
+    assert req.sampling_params.guidance_scale_provided is True
+    assert req.sampling_params.guidance_scale == 0.0
+
+
+@pytest.mark.parametrize("value", [0.999, 1.0, 5.0])
+def test_explicit_nonzero_guidance_scale_is_honored(value):
+    # Any explicitly-set value (truthy or not) is honored as provided and preserved.
+    req = _request_with_guidance(guidance_scale=value)
+
+    assert req.sampling_params.guidance_scale_provided is True
+    assert req.sampling_params.guidance_scale == value
diff --git a/tests/diffusion/test_diffusion_scheduler.py b/tests/diffusion/test_diffusion_scheduler.py
index 7d6d2d11b..43ce7a45b 100644
--- a/tests/diffusion/test_diffusion_scheduler.py
+++ b/tests/diffusion/test_diffusion_scheduler.py
@@ -11,13 +11,13 @@ import torch
 from pytest_mock import MockerFixture
 
 from vllm_omni.diffusion.data import DiffusionOutput, DiffusionRequestAbortedError
-from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
+from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, DiffusionExecutionMode
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched import (
+    BaseScheduler,
     DiffusionRequestStatus,
     RequestScheduler,
     Scheduler,
-    SchedulerInterface,
     StepScheduler,
 )
 from vllm_omni.diffusion.sched.interface import CachedRequestData, NewRequestData
@@ -85,7 +85,7 @@ def _cached_ids(sched_output) -> list[str]:
     return list(sched_output.scheduled_cached_reqs.request_ids)
 
 
-class _StubScheduler(SchedulerInterface):
+class _StubScheduler:
     def __init__(self, request: OmniDiffusionRequest, output) -> None:
         self._request = request
         self._output = output
@@ -154,8 +154,14 @@ class _StubScheduler(SchedulerInterface):
         return None
 
 
-class TestGetSamplingParamsKey:
-    """Pure-function tests for the batch-compatibility key builder."""
+class _ConcreteScheduler(BaseScheduler):
+    def update_from_output(self, sched_output, output) -> set[str]:
+        del sched_output, output
+        return set()
+
+
+class TestGetStepBatchSamplingParamsKey:
+    """Tests for the step-batch compatibility key builder on BaseScheduler."""
 
     @staticmethod
     def _make(lora_int_id: int | None = None, lora_scale: float = 1.0) -> OmniDiffusionRequest:
@@ -176,34 +182,32 @@ class TestGetSamplingParamsKey:
         )
 
     def test_distinguishes_lora_id(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_sampling_params_key
-
-        assert get_sampling_params_key(self._make(lora_int_id=1)) != get_sampling_params_key(self._make(lora_int_id=2))
+        scheduler = _ConcreteScheduler()
+        assert scheduler._build_sampling_params_key(self._make(lora_int_id=1)) != scheduler._build_sampling_params_key(
+            self._make(lora_int_id=2)
+        )
 
     def test_distinguishes_lora_scale(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_sampling_params_key
-
-        assert get_sampling_params_key(self._make(lora_int_id=1, lora_scale=0.5)) != get_sampling_params_key(
-            self._make(lora_int_id=1, lora_scale=1.0)
-        )
+        scheduler = _ConcreteScheduler()
+        assert scheduler._build_sampling_params_key(
+            self._make(lora_int_id=1, lora_scale=0.5)
+        ) != scheduler._build_sampling_params_key(self._make(lora_int_id=1, lora_scale=1.0))
 
     def test_treats_no_lora_as_distinct_bucket(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_sampling_params_key
-
-        assert get_sampling_params_key(self._make(lora_int_id=None)) != get_sampling_params_key(
-            self._make(lora_int_id=1)
-        )
+        scheduler = _ConcreteScheduler()
+        assert scheduler._build_sampling_params_key(
+            self._make(lora_int_id=None)
+        ) != scheduler._build_sampling_params_key(self._make(lora_int_id=1))
 
     def test_equal_for_same_lora_identity(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_sampling_params_key
-
-        a = get_sampling_params_key(self._make(lora_int_id=1, lora_scale=0.5))
-        b = get_sampling_params_key(self._make(lora_int_id=1, lora_scale=0.5))
+        scheduler = _ConcreteScheduler()
+        a = scheduler._build_sampling_params_key(self._make(lora_int_id=1, lora_scale=0.5))
+        b = scheduler._build_sampling_params_key(self._make(lora_int_id=1, lora_scale=0.5))
         assert a == b
 
 
 class TestGetRequestBatchSamplingParamsKey:
-    """Pure-function tests for the request-batch compatibility key builder."""
+    """Tests for the request-batch compatibility key builder on RequestScheduler."""
 
     @staticmethod
     def _make(
@@ -220,21 +224,19 @@ class TestGetRequestBatchSamplingParamsKey:
         return OmniDiffusionRequest(prompt="prompt", sampling_params=sp, request_id=f"req-{num_inference_steps}")
 
     def test_distinguishes_num_inference_steps(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_request_batch_sampling_params_key
-
-        assert get_request_batch_sampling_params_key(
+        scheduler = RequestScheduler()
+        assert scheduler._build_sampling_params_key(
             self._make(num_inference_steps=2)
-        ) != get_request_batch_sampling_params_key(self._make(num_inference_steps=4))
+        ) != scheduler._build_sampling_params_key(self._make(num_inference_steps=4))
 
     def test_ignores_seed_and_generator(self) -> None:
-        from vllm_omni.diffusion.sched.base_scheduler import get_request_batch_sampling_params_key
-
+        scheduler = RequestScheduler()
         gen_a = torch.Generator(device="cpu").manual_seed(1)
         gen_b = torch.Generator(device="cpu").manual_seed(2)
 
-        assert get_request_batch_sampling_params_key(
+        assert scheduler._build_sampling_params_key(
             self._make(seed=1, generator=gen_a)
-        ) == get_request_batch_sampling_params_key(self._make(seed=2, generator=gen_b))
+        ) == scheduler._build_sampling_params_key(self._make(seed=2, generator=gen_b))
 
 
 class TestRequestScheduler:
@@ -530,13 +532,11 @@ class TestDiffusionEngine:
         assert output is runner_output.result
         engine.execute_fn.assert_called_once()
 
-    def test_initializes_injected_scheduler(
+    def test_initializes_default_request_scheduler(
         self,
         monkeypatch: pytest.MonkeyPatch,
         mocker: MockerFixture,
     ) -> None:
-        request = _make_request("init")
-        scheduler = _StubScheduler(request, DiffusionOutput(output=None))
         od_config = SimpleNamespace(model_class_name="mock_model", streaming_output=False)
         fake_executor_cls = mocker.Mock(return_value=mocker.Mock())
 
@@ -552,11 +552,11 @@ class TestDiffusionEngine:
             "vllm_omni.diffusion.diffusion_engine.DiffusionExecutor.get_class",
             lambda *args, **kwargs: fake_executor_cls,
         )
-        monkeypatch.setattr(DiffusionEngine, "_dummy_run", lambda self: None)
 
-        DiffusionEngine(od_config, scheduler=scheduler)
+        engine = DiffusionEngine(od_config)
 
-        assert scheduler.initialized_with is od_config
+        assert isinstance(engine.scheduler, RequestScheduler)
+        assert engine.scheduler.max_num_running_reqs == 1
         fake_executor_cls.assert_called_once_with(od_config)
 
     def test_scheduler_alias_keeps_default_request_scheduler(self) -> None:
@@ -571,16 +571,19 @@ class TestDiffusionEngine:
         assert scheduler.get_request_state(req_id).status == DiffusionRequestStatus.FINISHED_COMPLETED
 
     @pytest.mark.asyncio
-    async def test_step_raises_aborted_error(self, mocker: MockerFixture) -> None:
+    async def test_step_streaming_raises_aborted_error(self, mocker: MockerFixture) -> None:
         engine = DiffusionEngine.__new__(DiffusionEngine)
         engine._check_and_start_background_loop = mocker.AsyncMock()
         engine.pre_process_func = None
-        engine.async_add_req_and_wait_for_response = mocker.AsyncMock(
-            return_value=DiffusionOutput(aborted=True, abort_message="Request req-abort aborted.")
-        )
+
+        async def _stream(_request):
+            yield DiffusionOutput(aborted=True, abort_message="Request req-abort aborted.")
+
+        engine.async_add_req_and_stream_response = mocker.Mock(return_value=_stream(None))
 
         with pytest.raises(DiffusionRequestAbortedError, match="Request req-abort aborted"):
-            await engine.step(_make_request("req-abort"))
+            async for _ in engine.step_streaming(_make_request("req-abort")):
+                pass
 
     def test_abort_queue_marks_request_finished_aborted(self) -> None:
         engine = DiffusionEngine.__new__(DiffusionEngine)
@@ -617,12 +620,13 @@ class TestDiffusionEngine:
         engine.scheduler.initialize(SimpleNamespace())
         engine._rpc_lock = threading.RLock()
         engine._cv = threading.Condition(engine._rpc_lock)
-        engine._out_queue_streaming = {}
+        engine._out_streams = {}
+        engine.execution_mode = DiffusionExecutionMode.STEP_BATCH
         engine.main_loop = asyncio.get_running_loop()
 
         req_id = engine.scheduler.add_request(_make_request("stream-engine"))
         queue: asyncio.Queue[DiffusionOutput] = asyncio.Queue()
-        engine._out_queue_streaming[req_id] = queue
+        engine._out_streams[req_id] = queue
         sched_output = engine.scheduler.schedule()
 
         chunk = RunnerOutput(
@@ -632,7 +636,7 @@ class TestDiffusionEngine:
             result=DiffusionOutput(output="chunk-0", finished=False, chunk_index=0, total_chunks=2),
         )
         finished_req_ids = engine.scheduler.update_from_output(sched_output, chunk)
-        engine._handle_step_streaming_runner_output(finished_req_ids, sched_output.scheduled_request_ids, chunk)
+        engine._emit_outputs(finished_req_ids, sched_output.scheduled_request_ids, chunk)
 
         notified_chunk = await asyncio.wait_for(queue.get(), timeout=1)
         assert notified_chunk.output == "chunk-0"
@@ -646,7 +650,7 @@ class TestDiffusionEngine:
             result=DiffusionOutput(output="chunk-1", finished=True, chunk_index=1, total_chunks=2),
         )
         finished_req_ids = engine.scheduler.update_from_output(sched_output, final_chunk)
-        engine._handle_step_streaming_runner_output(finished_req_ids, sched_output.scheduled_request_ids, final_chunk)
+        engine._emit_outputs(finished_req_ids, sched_output.scheduled_request_ids, final_chunk)
 
         notified_final = await asyncio.wait_for(queue.get(), timeout=1)
         assert notified_final.output == "chunk-1"
@@ -660,15 +664,15 @@ class TestDiffusionEngine:
         engine.scheduler.initialize(SimpleNamespace())
         engine._rpc_lock = threading.RLock()
         engine._cv = threading.Condition(engine._rpc_lock)
-        engine._out_queue_streaming = {}
+        engine._out_streams = {}
         engine.main_loop = asyncio.get_running_loop()
 
         req_id = engine.scheduler.add_request(_make_request("stream-abort"))
         queue: asyncio.Queue[DiffusionOutput] = asyncio.Queue()
-        engine._out_queue_streaming[req_id] = queue
+        engine._out_streams[req_id] = queue
         engine.scheduler.finish_requests(req_id, DiffusionRequestStatus.FINISHED_ABORTED)
 
-        engine._handle_empty_streaming_requests({req_id})
+        engine._emit_finished_outputs({req_id})
 
         output = await asyncio.wait_for(queue.get(), timeout=1)
         assert output.aborted is True
@@ -697,9 +701,9 @@ class TestDiffusionEngine:
             "vllm_omni.diffusion.diffusion_engine.DiffusionExecutor.get_class",
             lambda *args, **kwargs: fake_executor_cls,
         )
-        monkeypatch.setattr(DiffusionEngine, "_dummy_run", lambda self: None)
         engine = DiffusionEngine(od_config)
 
+        assert engine.execution_mode == DiffusionExecutionMode.STEP_BATCH
         assert isinstance(engine.scheduler, StepScheduler)
         assert engine.execute_fn is fake_executor.execute_step
         fake_executor_cls.assert_called_once_with(od_config)
diff --git a/tests/diffusion/test_diffusion_step_pipeline.py b/tests/diffusion/test_diffusion_step_pipeline.py
index 7e18996ed..0964833d7 100644
--- a/tests/diffusion/test_diffusion_step_pipeline.py
+++ b/tests/diffusion/test_diffusion_step_pipeline.py
@@ -43,7 +43,7 @@ from vllm_omni.diffusion.sched.interface import (
 from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
 from vllm_omni.diffusion.worker.diffusion_worker import DiffusionWorker
 from vllm_omni.diffusion.worker.input_batch import InputBatch
-from vllm_omni.diffusion.worker.utils import DiffusionRequestState, RunnerOutput
+from vllm_omni.diffusion.worker.utils import RunnerOutput, StepRequestState
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.platforms import current_omni_platform
@@ -369,8 +369,8 @@ def _make_batch_scheduler_output(reqs, *, step_id=0, finished_req_ids=None):
     )
 
 
-def _make_input_batch_state(request_id: str, latent_value: float) -> DiffusionRequestState:
-    state = DiffusionRequestState(
+def _make_input_batch_state(request_id: str, latent_value: float) -> StepRequestState:
+    state = StepRequestState(
         request_id=request_id,
         sampling=SimpleNamespace(),
         prompt=None,
diff --git a/tests/diffusion/test_diffusion_streaming_output.py b/tests/diffusion/test_diffusion_streaming_output.py
index ae5f9eee8..824902ad4 100644
--- a/tests/diffusion/test_diffusion_streaming_output.py
+++ b/tests/diffusion/test_diffusion_streaming_output.py
@@ -341,7 +341,9 @@ class TestPipelineStreamingOutputToEntrypoint:
                 with client.websocket_connect("/v1/realtime/video") as ws:
                     ws.send_json({"type": "session.start", "prompt": "integration test"})
                     assert ws.receive_json()["type"] == "video.start"
+                    assert ws.receive_json()["type"] == "video.chunk_metadata"
                     assert ws.receive_bytes() == b"pipeline-fmp4-0"
+                    assert ws.receive_json()["type"] == "video.chunk_metadata"
                     assert ws.receive_bytes() == b"pipeline-fmp4-1"
                     done = ws.receive_json()
                     assert done["type"] == "session.done"
@@ -453,7 +455,6 @@ class TestPipelineStreamingOutputToEntrypoint:
         omni.final_output_task = None
         omni.event_resolver = AsyncEventResolver()
         omni._enable_ar_profiler = False
-        omni._is_sleeping = False
         omni.prom_metrics = MagicMock()
         omni.mod_metrics = MagicMock()
         omni.resolve_sampling_params_list = lambda params, allow_delta_coercion: params
diff --git a/tests/diffusion/test_diffusion_worker.py b/tests/diffusion/test_diffusion_worker.py
index fb45cd41d..6a49d0909 100644
--- a/tests/diffusion/test_diffusion_worker.py
+++ b/tests/diffusion/test_diffusion_worker.py
@@ -5,7 +5,6 @@
 Unit tests for DiffusionWorker class.
 
 This module tests the DiffusionWorker implementation:
-- load_weights: Loading model weights
 - sleep: Putting worker into sleep mode (levels 1 and 2)
 - wake_up: Waking worker from sleep mode
 """
@@ -59,38 +58,6 @@ def mock_gpu_worker(mocker: MockerFixture, mock_od_config):
     return worker
 
 
-class TestDiffusionWorkerLoadWeights:
-    """Test DiffusionWorker.load_weights method."""
-
-    def test_load_weights_calls_pipeline(self, mocker: MockerFixture, mock_gpu_worker):
-        """Test that load_weights delegates to model_runner.load_weights."""
-        # Setup mock weights
-        mock_weights = [
-            ("layer1.weight", torch.randn(10, 10)),
-            ("layer2.weight", torch.randn(20, 20)),
-        ]
-        expected_loaded = {"layer1.weight", "layer2.weight"}
-
-        # Configure model_runner mock
-        mock_gpu_worker.model_runner.load_weights = mocker.Mock(return_value=expected_loaded)
-
-        # Call load_weights
-        result = mock_gpu_worker.load_weights(mock_weights)
-
-        # Verify model_runner.load_weights was called with the weights
-        mock_gpu_worker.model_runner.load_weights.assert_called_once_with(mock_weights)
-        assert result == expected_loaded
-
-    def test_load_weights_empty_iterable(self, mocker: MockerFixture, mock_gpu_worker):
-        """Test load_weights with empty weights iterable."""
-        mock_gpu_worker.model_runner.load_weights = mocker.Mock(return_value=set())
-
-        result = mock_gpu_worker.load_weights([])
-
-        mock_gpu_worker.model_runner.load_weights.assert_called_once_with([])
-        assert result == set()
-
-
 def test_diffusion_vllm_model_config_supplies_dtype_for_quant_methods():
     from types import SimpleNamespace
 
diff --git a/tests/diffusion/test_inline_stage_diffusion_client.py b/tests/diffusion/test_inline_stage_diffusion_client.py
index b94f86db0..4981f7f92 100644
--- a/tests/diffusion/test_inline_stage_diffusion_client.py
+++ b/tests/diffusion/test_inline_stage_diffusion_client.py
@@ -54,9 +54,12 @@ def client(mock_engine):
 
 @pytest.mark.asyncio
 async def test_inline_dispatch_request_success(client, mock_engine):
-    # Setup mock engine step to return a successful result
     mock_result = OmniRequestOutput.from_diffusion(request_id="req-1", images=[MagicMock()])
-    mock_engine.step.return_value = [mock_result]
+
+    async def _step_streaming(_request):
+        yield [mock_result]
+
+    mock_engine.step_streaming = _step_streaming
 
     sampling_params = OmniDiffusionSamplingParams()
     await client.add_request_async("req-1", "A test prompt", sampling_params)
@@ -70,7 +73,6 @@ async def test_inline_dispatch_request_success(client, mock_engine):
 
     assert output is not None
     assert output.request_id == "req-1"
-    mock_engine.step.assert_called_once()
 
 
 @pytest.mark.asyncio
@@ -104,8 +106,11 @@ async def test_inline_dispatch_request_streaming_success(client, mock_engine):
 
 @pytest.mark.asyncio
 async def test_inline_dispatch_request_error(client, mock_engine):
-    # Setup mock engine step to raise an exception
-    mock_engine.step.side_effect = RuntimeError("Engine failure")
+    async def _step_streaming(_request):
+        raise RuntimeError("Engine failure")
+        yield  # pragma: no cover
+
+    mock_engine.step_streaming = _step_streaming
 
     sampling_params = OmniDiffusionSamplingParams()
     await client.add_request_async("req-err", "A test prompt", sampling_params)
diff --git a/tests/diffusion/test_input_batch_txt_seq_lens.py b/tests/diffusion/test_input_batch_txt_seq_lens.py
index 315f0f703..88fb60a5e 100644
--- a/tests/diffusion/test_input_batch_txt_seq_lens.py
+++ b/tests/diffusion/test_input_batch_txt_seq_lens.py
@@ -2,14 +2,14 @@ import pytest
 import torch
 
 from vllm_omni.diffusion.worker.input_batch import _prepare_request_prompt_field
-from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+from vllm_omni.diffusion.worker.utils import StepRequestState
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
-pytestmark = [pytest.mark.cpu]
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
 
 def test_prepare_request_prompt_field_refreshes_txt_seq_lens_after_padding():
-    state = DiffusionRequestState(
+    state = StepRequestState(
         request_id="req-0",
         sampling=OmniDiffusionSamplingParams(),
         prompt_embeds=torch.randn(1, 10, 4),
diff --git a/tests/diffusion/test_ipc_async.py b/tests/diffusion/test_ipc_async.py
new file mode 100644
index 000000000..c54d2f793
--- /dev/null
+++ b/tests/diffusion/test_ipc_async.py
@@ -0,0 +1,159 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for IPC async D2H stream packing."""
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.ipc import (
+    _pack_diffusion_fields,
+    _pack_tensor_if_large,
+    _pack_value_if_large,
+    pack_diffusion_output_shm,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class TestPackTensorIfLargeWithD2hStream:
+    """Test _pack_tensor_if_large with mock d2h_stream parameter."""
+
+    def test_small_tensor_not_packed_with_stream(self, mocker):
+        """Small tensors pass through even when d2h_stream is provided."""
+        small_tensor = torch.zeros(10)  # way below threshold
+        mock_stream = mocker.MagicMock()
+        result = _pack_tensor_if_large(small_tensor, d2h_stream=mock_stream)
+        # Small tensor should be returned as-is (not a SHM handle dict)
+        assert isinstance(result, torch.Tensor)
+
+    def test_large_tensor_packed_without_stream(self, mocker):
+        """Large tensor is packed via SHM when no d2h_stream."""
+        large_tensor = torch.randn(500_000)  # > 1MB for float32
+        result = _pack_tensor_if_large(large_tensor, d2h_stream=None)
+        assert isinstance(result, dict)
+        assert result.get("__tensor_shm__") is True
+
+    def test_pack_value_if_large_passes_stream_to_tensor_pack(self, mocker):
+        """_pack_value_if_large propagates d2h_stream to _pack_tensor_if_large."""
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_tensor_if_large",
+            return_value="packed",
+        )
+        tensor = torch.zeros(1)
+        d2h = mocker.MagicMock()
+        _pack_value_if_large(tensor, d2h_stream=d2h)
+        mock_pack.assert_called_once_with(tensor, d2h_stream=d2h)
+
+    def test_pack_value_if_large_passes_stream_through_dict(self, mocker):
+        """d2h_stream propagates through dict container packing."""
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_tensor_if_large",
+            return_value="packed",
+        )
+        d2h = mocker.MagicMock()
+        data = {"image": torch.zeros(1), "video": torch.zeros(1)}
+        _pack_value_if_large(data, d2h_stream=d2h)
+        assert mock_pack.call_count == 2
+        for call in mock_pack.call_args_list:
+            assert call.kwargs.get("d2h_stream") is d2h or call.args[1] is d2h
+
+    def test_pack_value_if_large_passes_stream_through_list(self, mocker):
+        """d2h_stream propagates through list container packing."""
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_tensor_if_large",
+            return_value="packed",
+        )
+        d2h = mocker.MagicMock()
+        data = [torch.zeros(1), torch.zeros(1)]
+        _pack_value_if_large(data, d2h_stream=d2h)
+        assert mock_pack.call_count == 2
+
+    def test_pack_value_if_large_passes_stream_through_tuple(self, mocker):
+        """d2h_stream propagates through tuple container packing."""
+        mock_pack = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_tensor_if_large",
+            return_value="packed",
+        )
+        d2h = mocker.MagicMock()
+        data = (torch.zeros(1), torch.zeros(1))
+        result = _pack_value_if_large(data, d2h_stream=d2h)
+        assert isinstance(result, tuple)
+        assert mock_pack.call_count == 2
+
+
+class TestPackDiffusionFieldsWithD2hStream:
+    """Test _pack_diffusion_fields propagates d2h_stream."""
+
+    def test_output_field_packed_with_stream(self, mocker):
+        mock_pack_value = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_value_if_large",
+            return_value="packed",
+        )
+        d2h = mocker.MagicMock()
+        out = DiffusionOutput(output=torch.zeros(1))
+        _pack_diffusion_fields(out, d2h_stream=d2h)
+        mock_pack_value.assert_called_once_with(torch.zeros(1), d2h_stream=d2h)
+
+    def test_trajectory_fields_packed_with_stream(self, mocker):
+        mock_pack_tensor = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_tensor_if_large",
+            return_value="packed",
+        )
+        d2h = mocker.MagicMock()
+        out = DiffusionOutput(
+            trajectory_latents=torch.zeros(1),
+            trajectory_log_probs=torch.zeros(1),
+        )
+        _pack_diffusion_fields(out, d2h_stream=d2h)
+        # Should pack trajectory_latents and trajectory_log_probs
+        assert mock_pack_tensor.call_count == 2
+
+
+class TestPackDiffusionOutputShmWithD2hStream:
+    """Test pack_diffusion_output_shm top-level dispatch with d2h_stream."""
+
+    def test_diffusion_output_path_with_stream(self, mocker):
+        mock_pack_fields = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_diffusion_fields",
+        )
+        d2h = mocker.MagicMock()
+        out = DiffusionOutput()
+        pack_diffusion_output_shm(out, d2h_stream=d2h)
+        mock_pack_fields.assert_called_once_with(out, d2h_stream=d2h)
+
+    def test_rpc_envelope_path_with_stream(self, mocker):
+        mock_pack_fields = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_diffusion_fields",
+        )
+        d2h = mocker.MagicMock()
+        result = DiffusionOutput()
+        envelope = {"type": "diffusion_rpc_result", "result": result}
+        pack_diffusion_output_shm(envelope, d2h_stream=d2h)
+        # envelope["result"] is replaced in-place by pack_diffusion_output_shm;
+        # assert with the original reference, not the replaced one.
+        mock_pack_fields.assert_called_once_with(
+            result,
+            d2h_stream=d2h,
+        )
+
+    def test_runner_output_path_with_stream(self, mocker):
+        mock_pack_fields = mocker.patch(
+            "vllm_omni.diffusion.ipc._pack_diffusion_fields",
+        )
+        d2h = mocker.MagicMock()
+
+        from vllm_omni.diffusion.worker.utils import RunnerOutput
+
+        result = DiffusionOutput()
+        runner_out = RunnerOutput(
+            request_id="req1",
+            result=result,
+        )
+        pack_diffusion_output_shm(runner_out, d2h_stream=d2h)
+        # runner_out.result is replaced in-place by pack_diffusion_output_shm;
+        # assert with the original reference, not the replaced one.
+        mock_pack_fields.assert_called_once_with(
+            result,
+            d2h_stream=d2h,
+        )
diff --git a/tests/diffusion/test_multiproc_engine_concurrency.py b/tests/diffusion/test_multiproc_engine_concurrency.py
index 070d899e6..f1c48ba30 100644
--- a/tests/diffusion/test_multiproc_engine_concurrency.py
+++ b/tests/diffusion/test_multiproc_engine_concurrency.py
@@ -56,11 +56,9 @@ def _make_executor(num_gpus: int = 1):
 
     Returns ``(executor, request_queue, result_queue)``.
     """
-    od_cfg = SimpleNamespace(num_gpus=num_gpus, streaming_output=False)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(MultiprocDiffusionExecutor, "_init_executor", lambda self: None)
-    executor = MultiprocDiffusionExecutor(od_cfg)
-    monkeypatch.undo()
+    od_cfg = SimpleNamespace(num_gpus=num_gpus, streaming_output=False, step_execution=True)
+    executor = object.__new__(MultiprocDiffusionExecutor)
+    executor.od_config = od_cfg
 
     req_q: queue.Queue = queue.Queue()
     res_q: queue.Queue = queue.Queue()
@@ -73,7 +71,7 @@ def _make_executor(num_gpus: int = 1):
     executor._result_mq = mock_rmq
     executor._closed = False
     executor._processes = []
-    executor.is_failed = False
+    executor._is_failed = False
     executor._failure_callbacks = []
     return executor, req_q, res_q
 
@@ -93,7 +91,7 @@ def _make_engine(num_gpus: int = 1):
     engine._loop_started = False
     engine._rpc_queue = queue.Queue()
     engine.abort_queue = queue.Queue()
-    engine.execute_fn = executor.execute_request
+    engine.execute_fn = executor.execute_batch
     return engine, executor, req_q, res_q
 
 
@@ -104,7 +102,10 @@ def _start_worker(req_q, res_q, count=2):
 
     def _run():
         for _ in range(count):
-            req = req_q.get(timeout=10)
+            try:
+                req = req_q.get(timeout=10)
+            except queue.Empty:
+                break
             method = req.get("method", "")
             args = req.get("args", ())
             if method == "execute_model_batch" and args and isinstance(args[0], DiffusionSchedulerOutput):
@@ -148,7 +149,7 @@ def _inject_interleave(executor):
         orig_enqueue(item)
         if threading.current_thread().name == "thread_a":
             a_enqueued.set()  # tell B: "A has enqueued"
-            b_complete.wait(5)  # block A until B finishes
+            b_complete.wait(1)  # block A until B finishes
 
     executor._broadcast_mq.enqueue = _controlled
     return a_enqueued, b_complete
@@ -175,8 +176,8 @@ class TestConcurrentRequestExecution:
             results["B"] = engine.add_req_and_wait_for_response(_mock_request("B"))
             b_complete.set()  # release A
 
-        ta = threading.Thread(target=_a, name="thread_a")
-        tb = threading.Thread(target=_b, name="thread_b")
+        ta = threading.Thread(target=_a, name="thread_a", daemon=True)
+        tb = threading.Thread(target=_b, name="thread_b", daemon=True)
         ta.start()
         tb.start()
         ta.join(10)
@@ -246,6 +247,56 @@ class TestRequestModeDispatch:
         results = {ro.request_id: ro.result.error for ro in out.runner_outputs}
         assert results == {request_id: f"result_for_{request_id}" for request_id in request_ids}
 
+    def test_dlo_dp_routes_multiple_requests_without_pipeline_batching(self):
+        executor, _, _ = _make_executor(num_gpus=2)
+        executor.od_config = SimpleNamespace(
+            step_execution=False,
+            parallel_config=SimpleNamespace(data_parallel_size=2),
+            enable_distributed_layerwise_offload=True,
+            dlo_use_allgather=True,
+        )
+        executor.execute_request = Mock(return_value="dlo-dp")
+        executor.collective_rpc = Mock()
+        scheduler_output = _make_sched_output("A", "B")
+
+        result = executor.execute_batch(scheduler_output)
+
+        assert result == "dlo-dp"
+        executor.execute_request.assert_called_once_with(scheduler_output)
+        executor.collective_rpc.assert_not_called()
+
+    def test_dlo_dp_multi_rank_reply_uses_synchronous_rpc_collection(self):
+        executor, req_q, res_q = _make_executor(num_gpus=2)
+        executor.od_config = SimpleNamespace(
+            step_execution=False,
+            parallel_config=SimpleNamespace(data_parallel_size=2),
+        )
+        executor._sync_result_buffer = res_q
+
+        def worker():
+            request = req_q.get(timeout=2)
+            assert "rpc_id" not in request
+            wave_id = request["wave_id"]
+            for dp_rank in range(2):
+                res_q.put(
+                    {
+                        "dp_rank": dp_rank,
+                        "output": _tagged_output(str(dp_rank)),
+                        "wave_id": wave_id,
+                    }
+                )
+
+        thread = threading.Thread(target=worker, daemon=True)
+        thread.start()
+        results = executor.collective_rpc(
+            "execute_model",
+            unique_reply_rank=None,
+            exec_all_ranks=True,
+        )
+        thread.join(timeout=2)
+
+        assert [result.error for result in results] == ["0", "1"]
+
 
 # ───────────────── concurrent collective RPC ─────────────────
 
@@ -276,8 +327,8 @@ class TestConcurrentCollectiveRpc:
             )
             b_complete.set()
 
-        ta = threading.Thread(target=_a, name="thread_a")
-        tb = threading.Thread(target=_b, name="thread_b")
+        ta = threading.Thread(target=_a, name="thread_a", daemon=True)
+        tb = threading.Thread(target=_b, name="thread_b", daemon=True)
         ta.start()
         tb.start()
         ta.join(10)
@@ -313,8 +364,8 @@ class TestConcurrentRequestExecutionAndCollectiveRpc:
             )
             b_complete.set()
 
-        ta = threading.Thread(target=_a, name="thread_a")
-        tb = threading.Thread(target=_b, name="thread_b")
+        ta = threading.Thread(target=_a, name="thread_a", daemon=True)
+        tb = threading.Thread(target=_b, name="thread_b", daemon=True)
         ta.start()
         tb.start()
         ta.join(10)
@@ -528,7 +579,7 @@ class TestWorkerProcRpcRankStatus:
 
         monkeypatch.setattr(torch.distributed, "all_gather_object", _all_gather_object)
 
-        result, should_reply = proc.execute_rpc(
+        result, should_reply = proc._execute_rpc(
             {
                 "method": "remove_lora",
                 "args": (),
@@ -551,7 +602,7 @@ class TestWorkerProcRpcRankStatus:
         proc.worker.execute_method = Mock(side_effect=RuntimeError("local boom"))
         monkeypatch.setattr(torch.distributed, "is_initialized", lambda: False)
 
-        result, should_reply = proc.execute_rpc(
+        result, should_reply = proc._execute_rpc(
             {
                 "method": "add_lora",
                 "args": (),
@@ -577,7 +628,7 @@ class TestWorkerProcRpcRankStatus:
         proc = self._make_worker_proc()
 
         with pytest.raises(ValueError, match="collect_rank_status requires exec_all_ranks=True"):
-            proc.execute_rpc(
+            proc._execute_rpc(
                 {
                     "method": "ping",
                     "args": (),
@@ -596,7 +647,7 @@ class TestWorkerProcRpcRankStatus:
         proc.worker.execute_method = Mock(side_effect=original)
 
         with pytest.raises(ValueError) as excinfo:
-            proc.execute_rpc(
+            proc._execute_rpc(
                 {
                     "method": "bad",
                     "args": (),
@@ -618,11 +669,12 @@ class TestMultiprocExecutorRaisesEngineDeadError:
 
     def test_collective_rpc_raises_when_is_failed(self):
         executor = object.__new__(MultiprocDiffusionExecutor)
+        executor.od_config = SimpleNamespace(step_execution=True)
         executor._closed = False
         executor._broadcast_mq = MagicMock()
         executor._result_mq = MagicMock()
         executor._result_mq.dequeue = MagicMock(side_effect=TimeoutError)
-        executor.is_failed = True
+        executor._is_failed = True
 
         with pytest.raises(EngineDeadError):
             executor.collective_rpc(
@@ -643,7 +695,7 @@ class TestMultiprocExecutorRaisesEngineDeadError:
             nonlocal call_count
             call_count += 1
             if call_count == 1:
-                executor.is_failed = True
+                executor._is_failed = True
                 raise TimeoutError
             return orig_dequeue(timeout=timeout)
 
@@ -663,7 +715,7 @@ class TestMultiprocExecutorStepStreamingOutput:
 
     def test_execute_step_allows_streaming_output_mode(self):
         executor, req_q, res_q = _make_executor()
-        executor.od_config = SimpleNamespace(streaming_output=True)  # pyright: ignore[reportAttributeAccessIssue]
+        executor.od_config = SimpleNamespace(streaming_output=True, step_execution=True)  # pyright: ignore[reportAttributeAccessIssue]
         runner_outputs = [
             RunnerOutput(
                 request_id="sched-stream",
@@ -684,7 +736,10 @@ class TestMultiprocExecutorStepStreamingOutput:
 
         def _worker():
             for runner_output in runner_outputs:
-                req_q.get(timeout=10)
+                try:
+                    req_q.get(timeout=10)
+                except queue.Empty:
+                    break
                 res_q.put(runner_output)
 
         thread = threading.Thread(target=_worker, daemon=True)
@@ -920,7 +975,7 @@ def _make_short_lived_process() -> mp.Process:
 
 
 class TestMultiprocExecutorWorkerMonitor:
-    """Integration tests for ``start_worker_monitor``.
+    """Integration tests for ``_start_worker_monitor``.
 
     Uses real short-lived subprocesses so that OS-level sentinel fd
     readiness is exercised end-to-end.
@@ -928,19 +983,27 @@ class TestMultiprocExecutorWorkerMonitor:
 
     def test_worker_monitor_sets_is_failed_and_calls_callbacks_on_death(self):
         """When a worker process dies, the monitor thread must:
-        1. Set ``is_failed = True``
+        1. Set ``_is_failed = True``
         2. Call ``shutdown()`` (which sets ``_closed = True``)
         3. Invoke all registered failure callbacks
         """
         executor = object.__new__(MultiprocDiffusionExecutor)
         executor._closed = False
-        executor.is_failed = False
+        executor._is_failed = False
         executor._failure_callbacks = []
         executor._broadcast_mq = None
         executor._result_mq = None
-        executor.resources = None
+        executor._shutdown_cleaner = None
         # Use a no-op so shutdown() doesn't crash on None resources.
         executor._finalizer = lambda: None
+        # ------------------------------------------------------------------
+        # Attributes added by remove_bubble_v2 (async D2H); shutdown() iterates
+        # over them, so they need to exist even when constructed via __new__.
+        executor._pump_stop = threading.Event()
+        executor._futures_lock = threading.RLock()
+        executor._rpc_futures = {}
+        executor._output_futures = {}
+        executor._batch_split_map = {}
 
         proc = _make_short_lived_process()
         executor._processes = [proc]
@@ -948,35 +1011,38 @@ class TestMultiprocExecutorWorkerMonitor:
         callback_called = threading.Event()
         executor.register_failure_callback(callback_called.set)
 
-        executor.start_worker_monitor()
+        executor._start_worker_monitor()
 
         # Wait for the process to exit and the monitor to react.
         proc.join(5)
-        assert _poll_flag(lambda: executor.is_failed), "is_failed was not set"
+        assert _poll_flag(lambda: executor._is_failed), "_is_failed was not set"
         assert executor._closed, "shutdown() was not called"
         assert callback_called.wait(timeout=2), "failure callback was not invoked"
+        assert executor.is_dead
 
     def test_worker_monitor_noop_when_already_closed(self):
         """If ``_closed`` is already True when the process dies (orderly
-        shutdown), the monitor must *not* set ``is_failed``."""
+        shutdown), the monitor must *not* set ``_is_failed``."""
         executor = object.__new__(MultiprocDiffusionExecutor)
         executor._closed = True  # already shut down
-        executor.is_failed = False
+        executor._is_failed = False
         executor._failure_callbacks = []
         executor._broadcast_mq = None
         executor._result_mq = None
-        executor.resources = None
+        executor._shutdown_cleaner = None
         executor._finalizer = lambda: None
 
         proc = _make_short_lived_process()
         executor._processes = [proc]
 
-        executor.start_worker_monitor()
+        executor._start_worker_monitor()
         proc.join(5)
 
         # Give the monitor thread a chance to run (it should early-return).
         time.sleep(0.3)
-        assert not executor.is_failed, "is_failed should remain False on orderly shutdown"
+        assert not executor._is_failed, "_is_failed should remain False on orderly shutdown"
+        # Orderly close still reports dead via the public accessor.
+        assert executor.is_dead
 
 
 class TestStageDiffusionClientProcMonitor:
diff --git a/tests/diffusion/test_omni_diffusion_config_offline_model_path.py b/tests/diffusion/test_omni_diffusion_config_offline_model_path.py
new file mode 100644
index 000000000..674f8d93f
--- /dev/null
+++ b/tests/diffusion/test_omni_diffusion_config_offline_model_path.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for OmniDiffusionConfig HF-offline model-path resolution."""
+
+import os
+
+import huggingface_hub
+import pytest
+
+import vllm_omni.diffusion.data as diffusion_data
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_LOCAL_SNAPSHOT = "/root/.cache/huggingface/hub/models--foo--bar/snapshots/deadbeef"
+
+
+@pytest.fixture
+def record_get_model_path(monkeypatch: pytest.MonkeyPatch):
+    calls: list[tuple[str, str | None]] = []
+
+    def fake_get_model_path(model, revision=None):
+        calls.append((model, revision))
+        if os.path.exists(model):
+            return model
+        return _LOCAL_SNAPSHOT
+
+    monkeypatch.setattr(diffusion_data, "get_model_path", fake_get_model_path)
+    return calls
+
+
+class TestOmniDiffusionConfigOfflineModelPath:
+    def test_offline_repo_id_replaced_with_local_path(
+        self, monkeypatch: pytest.MonkeyPatch, record_get_model_path
+    ) -> None:
+        monkeypatch.setattr(huggingface_hub.constants, "HF_HUB_OFFLINE", True)
+        config = OmniDiffusionConfig(model="foo/bar")
+        assert config.model == _LOCAL_SNAPSHOT
+        assert record_get_model_path == [("foo/bar", None)]
+
+    def test_online_leaves_model_untouched(self, monkeypatch: pytest.MonkeyPatch, record_get_model_path) -> None:
+        monkeypatch.setattr(huggingface_hub.constants, "HF_HUB_OFFLINE", False)
+        config = OmniDiffusionConfig(model="foo/bar")
+        assert config.model == "foo/bar"
+        assert record_get_model_path == []
+
+    def test_offline_local_path_unchanged(self, monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+        monkeypatch.setattr(huggingface_hub.constants, "HF_HUB_OFFLINE", True)
+        local = str(tmp_path)
+        config = OmniDiffusionConfig(model=local)
+        assert config.model == local
+
+    @pytest.mark.parametrize("model", [None, ""])
+    def test_offline_empty_model_unchanged(
+        self, monkeypatch: pytest.MonkeyPatch, record_get_model_path, model: str | None
+    ) -> None:
+        monkeypatch.setattr(huggingface_hub.constants, "HF_HUB_OFFLINE", True)
+        config = OmniDiffusionConfig(model=model)
+        assert config.model == model
+        assert record_get_model_path == []
diff --git a/tests/diffusion/test_prompt_update.py b/tests/diffusion/test_prompt_update.py
new file mode 100644
index 000000000..cdee35979
--- /dev/null
+++ b/tests/diffusion/test_prompt_update.py
@@ -0,0 +1,574 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Tests for midway prompt update across runner, batch, pipeline, and entrypoint layers."""
+
+from __future__ import annotations
+
+import asyncio
+import queue
+import time
+from types import SimpleNamespace
+from typing import Any, cast
+from unittest.mock import MagicMock, patch
+
+import pytest
+import torch
+
+from tests.engine.test_orchestrator import (
+    OrchestratorFixture,
+    _build_harness,
+    _wait_for,
+)
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.inline_stage_diffusion_client import InlineStageDiffusionClient
+from vllm_omni.diffusion.models.helios.pipeline_helios import HeliosPipeline
+from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
+from vllm_omni.diffusion.worker.input_batch import InputBatch
+from vllm_omni.diffusion.worker.utils import StepRequestState
+from vllm_omni.engine.async_omni_engine import StageRuntimeInfo
+from vllm_omni.engine.messages import (
+    ErrorMessage,
+    InteractionMessage,
+    ShutdownRequestMessage,
+    StageSubmissionMessage,
+)
+from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorRequestState
+from vllm_omni.engine.stage_client import StagePoolClient
+from vllm_omni.engine.stage_init_utils import StageMetadata
+from vllm_omni.engine.stage_pool import StagePool
+from vllm_omni.entrypoints.async_omni import AsyncEventResolver, AsyncOmni
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniInteractionPrompt
+from vllm_omni.outputs import OmniRequestOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@pytest.fixture
+def pipeline() -> HeliosPipeline:
+    pipeline = object.__new__(HeliosPipeline)
+    pipeline.device = torch.device("cpu")
+    pipeline.transformer = SimpleNamespace(dtype=torch.float32)  # pyright: ignore[reportAttributeAccessIssue]
+    pipeline.encode_prompt = MagicMock(
+        return_value=(
+            torch.full((1, 4, 2), 2.0),
+            None,
+        )
+    )
+    pipeline._prepare_next_chunk = MagicMock()
+    return pipeline
+
+
+def _make_diffusion_request_state(*, request_id: str = "req-1") -> StepRequestState:
+    state = StepRequestState(
+        request_id=request_id,
+        sampling=SimpleNamespace(num_outputs_per_prompt=1, max_sequence_length=226),  # pyright: ignore[reportArgumentType]
+        prompt="hello",
+    )
+    state.prompt_embeds = torch.zeros(1, 4, 2)
+    state.extra = {}
+    return state
+
+
+def _make_diffusion_model_runner(*, pipeline, streaming_output: bool = True) -> DiffusionModelRunner:
+    runner = object.__new__(DiffusionModelRunner)
+    runner.pipeline = pipeline
+    runner.state_cache = {}
+    runner.od_config = SimpleNamespace(  # pyright: ignore[reportAttributeAccessIssue]
+        model_class_name="HeliosPipeline",
+        streaming_output=streaming_output,
+    )
+    runner._supports_step_mode = lambda: True
+    return runner
+
+
+def _prompt_interaction(
+    prompt: str = "updated",
+    *,
+    event_id: str = "ui-update-1",
+    transition_chunks: int | None = None,
+) -> OmniInteractionPrompt:
+    interaction: dict[str, Any] = {
+        "event_id": event_id,
+        "event": {"prompt": prompt},
+    }
+    if transition_chunks is not None:
+        interaction["transition_chunks"] = transition_chunks
+    return cast(OmniInteractionPrompt, interaction)
+
+
+class TestPromptUpdateExecution:
+    """Runner, InputBatch cache, and pipeline chunk-boundary behavior."""
+
+    def test_runner_interaction_delegates_to_helios_pipeline(self, pipeline: HeliosPipeline) -> None:
+        """Runner encodes the new prompt and queues pending embeds on the request state."""
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        state = _make_diffusion_request_state()
+        runner.state_cache["req-1"] = state
+
+        runner.submit_interaction("req-1", _prompt_interaction(transition_chunks=2))
+
+        pipeline.encode_prompt.assert_called_once()  # pyright: ignore[reportAttributeAccessIssue]
+        pending = state.extra["pending_prompt_update"]
+        assert pending["event_id"] == "ui-update-1"
+        assert pending["transition_chunks"] == 2
+        assert torch.equal(pending["target_prompt_embeds"], torch.full((1, 4, 2), 2.0))
+
+    def test_runner_prompt_update_rejects_unsupported_pipeline(self) -> None:
+        """Runner rejects prompt updates when the pipeline lacks prompt-update support."""
+
+        class _UnsupportedPipeline:
+            supports_step_execution = True
+
+        runner = _make_diffusion_model_runner(pipeline=_UnsupportedPipeline())
+        with pytest.raises(ValueError, match="not supported"):
+            runner.submit_interaction("req-1", _prompt_interaction())
+
+    def test_runner_prompt_update_rejects_missing_request(self, pipeline) -> None:
+        """Runner rejects prompt updates when no active request state exists."""
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        with pytest.raises(ValueError, match="No active request state"):
+            runner.submit_interaction("missing", _prompt_interaction())
+
+    @pytest.mark.parametrize(
+        "interaction",
+        [
+            {},
+            {"multi_modal_data": {"camera": {"type": "pose"}}},
+            {"event": {"prompt": "updated", "multi_modal_data": {"camera": {"type": "pose"}}}},
+        ],
+    )
+    def test_runner_interaction_rejects_structural_payloads_until_implemented(
+        self,
+        pipeline: HeliosPipeline,
+        interaction: dict[str, Any],
+    ) -> None:
+        """Unsupported interaction dict shapes are preserved to and rejected by the runner."""
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        runner.state_cache["req-1"] = _make_diffusion_request_state()
+
+        with pytest.raises(NotImplementedError, match="Only text-only prompt update interactions"):
+            runner.submit_interaction("req-1", cast(Any, interaction))
+
+    def test_input_batch_refreshes_prompt_embeds_on_version_change(self) -> None:
+        """InputBatch rebuilds prompt_embeds when prompt_update_version changes."""
+        state = StepRequestState(
+            request_id="req-1",
+            sampling=SimpleNamespace(),  # pyright: ignore[reportArgumentType]
+            prompt="hello",
+        )
+        state.prompt_embeds = torch.zeros(1, 2, 3)
+        state.latents = torch.zeros(1, 2)
+        state.timesteps = torch.tensor([1.0])
+        state.extra["prompt_update_version"] = 0
+
+        batch = InputBatch.make_batch([state])
+        assert torch.equal(batch.prompt_embeds, torch.zeros(1, 2, 3))  # pyright: ignore[reportArgumentType]
+
+        state.prompt_embeds = torch.ones(1, 2, 3)
+        state.extra["prompt_update_version"] = 1
+        refreshed = InputBatch.make_batch([state], cached_batch=batch)
+        assert torch.equal(refreshed.prompt_embeds, torch.ones(1, 2, 3))  # pyright: ignore[reportArgumentType]
+
+    def test_helios_prepare_prompt_update_queues_pending_target(self, pipeline: HeliosPipeline) -> None:
+        """HeliosPipeline queues target embeds without mutating current prompt_embeds."""
+        state = _make_diffusion_request_state()
+
+        pipeline.prepare_prompt_update(state, "new scene", "ui-update-1", transition_chunks=2)
+
+        pending = state.extra["pending_prompt_update"]
+        assert torch.equal(pending["target_prompt_embeds"], torch.full((1, 4, 2), 2.0))
+        assert pending["transition_chunks"] == 2
+        assert torch.equal(state.prompt_embeds, torch.zeros(1, 4, 2))  # pyright: ignore[reportArgumentType]
+
+    def test_helios_prepare_prompt_update_rejects_before_initial_generation(self, pipeline: HeliosPipeline) -> None:
+        """Reject prompt updates submitted before initial prompt embeds exist."""
+        state = _make_diffusion_request_state()
+        state.prompt_embeds = None
+
+        with pytest.raises(
+            ValueError,
+            match="prompt_update is not allowed before initial generation has started",
+        ):
+            pipeline.prepare_prompt_update(state, "new scene", "ui-update-1", transition_chunks=2)
+
+        assert "pending_prompt_update" not in state.extra
+
+    def test_helios_apply_prompt_update_at_chunk_boundary_starts_transition(self, pipeline: HeliosPipeline) -> None:
+        """At chunk boundary, starts transition state and bumps prompt_update_version."""
+        state = _make_diffusion_request_state()
+        pipeline.prepare_prompt_update(state, "new scene", "ui-update-1", transition_chunks=2)
+
+        pipeline._apply_prompt_update_at_chunk_boundary(state)
+
+        assert state.extra.get("prompt_update_state") is not None
+        assert torch.equal(state.prompt_embeds, torch.ones(1, 4, 2))  # pyright: ignore[reportArgumentType]
+        assert state.extra["prompt_update_version"] == 1
+        assert state.extra["prompt_update_chunk_metadata"] == {
+            "started_event_ids": ["ui-update-1"],
+            "active_event_ids": ["ui-update-1"],
+            "completed_event_ids": [],
+        }
+
+    def test_helios_apply_prompt_update_advances_transition_over_chunks(self, pipeline: HeliosPipeline) -> None:
+        """At chunk boundary, interpolates embeds until the target prompt is reached."""
+        state = _make_diffusion_request_state()
+        pipeline.prepare_prompt_update(state, "new scene", "ui-update-1", transition_chunks=3)
+        pipeline._apply_prompt_update_at_chunk_boundary(state)
+
+        assert torch.allclose(state.prompt_embeds, torch.full((1, 4, 2), 2.0 / 3.0))  # pyright: ignore[reportArgumentType]
+
+        for _ in range(2):
+            pipeline._apply_prompt_update_at_chunk_boundary(state)
+
+        assert torch.allclose(state.prompt_embeds, torch.full((1, 4, 2), 2.0))  # pyright: ignore[reportArgumentType]
+        assert state.extra["prompt_update_version"] == 3
+
+        # Further chunk boundaries after completion must not bump the version.
+        pipeline._apply_prompt_update_at_chunk_boundary(state)
+        assert state.extra["prompt_update_version"] == 3
+
+
+class TestPromptUpdateIntegration:
+    """AsyncOmni prompt update through orchestrator, inline client, and runner."""
+
+    @pytest.mark.asyncio
+    async def test_orchestrator_prompt_update_failure_surfaces_non_fatal_error(
+        self,
+    ) -> None:
+        """Worker-side prompt_update rejection is reported without crashing the orchestrator."""
+
+        class _RejectingStagePool:
+            async def submit_interaction(self, *args: Any, **kwargs: Any) -> None:
+                del args, kwargs
+                raise ValueError("prompt embeds are not ready")
+
+        output_queue: asyncio.Queue[ErrorMessage] = asyncio.Queue()
+        orchestrator = object.__new__(Orchestrator)
+        orchestrator.stage_pools = [_RejectingStagePool()]  # pyright: ignore[reportAttributeAccessIssue]
+        orchestrator.output_async_queue = output_queue  # pyright: ignore[reportAttributeAccessIssue]
+        orchestrator.request_states = {"req-1": OrchestratorRequestState(request_id="req-1")}
+
+        await orchestrator._handle_interaction(
+            InteractionMessage(
+                request_id="req-1",
+                interaction=_prompt_interaction("new scene", event_id="ui-update-1", transition_chunks=2),
+            )
+        )
+
+        msg = output_queue.get_nowait()
+        assert msg == ErrorMessage(
+            error="Failed interaction for request req-1: prompt embeds are not ready",
+            fatal=False,
+            request_id="req-1",
+            event_id="ui-update-1",
+            stage_id=0,
+        )
+
+    @pytest.mark.asyncio
+    async def test_runner_prompt_update_failure_surfaces_non_fatal_error(self, pipeline: HeliosPipeline) -> None:
+        """Runner-side prepare_prompt_update rejection is reported through the orchestrator."""
+        pipeline.prepare_prompt_update = MagicMock(  # pyright: ignore[reportAttributeAccessIssue, reportMethodAssignment]
+            side_effect=ValueError("prompt embeds are not ready")
+        )
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        runner.state_cache["req-1"] = _make_diffusion_request_state(request_id="req-1")
+        prompt_update_engine = self._PromptUpdateEngine(self._IncrementalStreamingPipeline(), runner)
+        inline_client = self._make_inline_pipeline_client(prompt_update_engine)
+
+        output_queue: asyncio.Queue[ErrorMessage] = asyncio.Queue()
+        orchestrator = object.__new__(Orchestrator)
+        orchestrator.stage_pools = [  # pyright: ignore[reportAttributeAccessIssue]
+            StagePool(0, cast(StagePoolClient, inline_client))
+        ]
+        orchestrator.output_async_queue = output_queue  # pyright: ignore[reportAttributeAccessIssue]
+        orchestrator.request_states = {"req-1": OrchestratorRequestState(request_id="req-1")}
+
+        try:
+            await orchestrator._handle_interaction(
+                InteractionMessage(
+                    request_id="req-1",
+                    interaction=_prompt_interaction("new scene", event_id="ui-update-1", transition_chunks=2),
+                )
+            )
+        finally:
+            inline_client.shutdown()
+
+        pipeline.prepare_prompt_update.assert_called_once_with(  # pyright: ignore[reportAttributeAccessIssue]
+            runner.state_cache["req-1"],
+            "new scene",
+            "ui-update-1",
+            2,
+        )
+        msg = output_queue.get_nowait()
+        assert msg == ErrorMessage(
+            error="Failed interaction for request req-1: prompt embeds are not ready",
+            fatal=False,
+            request_id="req-1",
+            event_id="ui-update-1",
+            stage_id=0,
+        )
+
+    @pytest.mark.asyncio
+    async def test_prompt_update_reaches_runner_from_async_omni(self, pipeline: HeliosPipeline) -> None:
+        """Midway prompt update submitted via AsyncOmni reaches the diffusion runner."""
+        streaming_pipeline = self._IncrementalStreamingPipeline()
+        runner = _make_diffusion_model_runner(pipeline=pipeline)
+        prompt_update_engine = self._PromptUpdateEngine(streaming_pipeline, runner)
+        inline_client = self._make_inline_pipeline_client(prompt_update_engine)
+        fixture = _build_harness([inline_client])
+        omni = self._make_async_omni(self._OrchestratorBridgeEngine(fixture))
+
+        generate_task: asyncio.Task[list[OmniRequestOutput]] | None = None
+        try:
+            generate_task = asyncio.create_task(self._collect_generate_outputs(omni))
+
+            await _wait_for(
+                lambda: (
+                    len(runner.state_cache) > 0
+                    and any(state.external_request_id == "req-omni" for state in omni.request_states.values())
+                )
+            )
+            internal_request_id = next(iter(runner.state_cache))
+
+            await omni.submit_interaction_async(
+                "req-omni",
+                interaction=_prompt_interaction("new scene", event_id="ui-update-1", transition_chunks=2),
+            )
+
+            outputs = await generate_task
+
+            pending = runner.state_cache[internal_request_id].extra["pending_prompt_update"]
+            assert pending["transition_chunks"] == 2
+            assert torch.equal(pending["target_prompt_embeds"], torch.full((1, 4, 2), 2.0))
+            pipeline.encode_prompt.assert_called_once()  # pyright: ignore[reportAttributeAccessIssue]
+            assert [output.custom_output["chunk"] for output in outputs] == [0, 1]
+        finally:
+            if generate_task is not None and not generate_task.done():
+                generate_task.cancel()
+                await asyncio.gather(generate_task, return_exceptions=True)
+            await self._shutdown_pipeline_omni_harness(omni, fixture, inline_client)
+
+    @staticmethod
+    async def _collect_generate_outputs(omni: AsyncOmni) -> list[OmniRequestOutput]:
+        outputs: list[OmniRequestOutput] = []
+        async for output in omni.generate(
+            prompt={"prompt": "a cat"},
+            request_id="req-omni",
+            sampling_params_list=[OmniDiffusionSamplingParams()],
+            output_modalities=["image"],
+        ):
+            outputs.append(output)
+        return outputs
+
+    @classmethod
+    def _make_inline_pipeline_client(cls, engine: _PromptUpdateEngine) -> InlineStageDiffusionClient:
+        metadata = StageMetadata(
+            stage_id=0,
+            stage_type="diffusion",
+            engine_output_type="image",
+            is_comprehension=False,
+            requires_multimodal_data=False,
+            engine_input_source=[],
+            final_output=True,
+            final_output_type="image",
+            default_sampling_params=OmniDiffusionSamplingParams(),
+            custom_process_input_func=None,
+            model_stage=None,
+            runtime_cfg=None,
+        )
+        with patch.object(InlineStageDiffusionClient, "_enrich_config"):
+            with patch(
+                "vllm_omni.diffusion.inline_stage_diffusion_client.DiffusionEngine.make_engine",
+                return_value=engine,
+            ):
+                od_config = MagicMock(spec=OmniDiffusionConfig)
+                od_config.streaming_output = True
+                return InlineStageDiffusionClient(
+                    model="test_model",
+                    od_config=od_config,
+                    metadata=metadata,
+                    batch_size=1,
+                )
+
+    @staticmethod
+    def _make_async_omni(engine: _OrchestratorBridgeEngine) -> AsyncOmni:
+        omni = object.__new__(AsyncOmni)
+        omni.engine = engine  # pyright: ignore[reportAttributeAccessIssue]
+        omni.log_stats = False
+        omni._pause_cond = asyncio.Condition()
+        omni._paused = False
+        omni.request_states = {}
+        omni.final_output_task = None
+        omni.event_resolver = AsyncEventResolver()
+        omni._enable_ar_profiler = False
+        omni.prom_metrics = MagicMock()
+        omni.mod_metrics = MagicMock()
+        omni.resolve_sampling_params_list = lambda params, allow_delta_coercion: params  # pyright: ignore[reportAttributeAccessIssue]
+        omni._compute_final_stage_id = lambda output_modalities: 0
+        omni._compute_final_output_stage_ids = lambda output_modalities: [0]
+        omni.default_sampling_params_list = engine.default_sampling_params_list  # pyright: ignore[reportAttributeAccessIssue]
+        omni._log_summary_and_cleanup = lambda request_id: omni.request_states.pop(request_id, None)  # pyright: ignore[reportAttributeAccessIssue]
+        return omni
+
+    @staticmethod
+    async def _shutdown_pipeline_omni_harness(
+        omni: AsyncOmni,
+        fixture: OrchestratorFixture,
+        inline_client: InlineStageDiffusionClient,
+    ) -> None:
+        if omni.final_output_task is not None:
+            omni.final_output_task.cancel()
+            await asyncio.gather(omni.final_output_task, return_exceptions=True)
+        inline_client.shutdown()
+        fixture.request_sync_q.put_nowait(ShutdownRequestMessage())
+        await asyncio.to_thread(fixture.thread.join, 5)
+
+    class _IncrementalStreamingPipeline:
+        """Returns one streaming chunk per ``step_outputs`` call."""
+
+        supports_step_execution = True
+
+        def __init__(self) -> None:
+            self.requests: list[Any] = []
+            self._step_index = 0
+
+        def step_outputs(self, request):
+            self.requests.append(request)
+            if self._step_index == 0:
+                self._step_index += 1
+                return [DiffusionOutput(output={"chunk": 0}, finished=False)]
+            return [DiffusionOutput(output={"chunk": 1}, finished=True)]
+
+    class _OrchestratorBridgeEngine:
+        """Minimal AsyncOmni engine facade backed by a live Orchestrator harness."""
+
+        def __init__(self, fixture: OrchestratorFixture) -> None:
+            self._fixture = fixture
+            self.stage_metadata = [
+                StageRuntimeInfo(
+                    stage_type="diffusion",
+                    final_output=True,
+                    final_output_type="image",
+                )
+            ]
+            self.stage_configs: list[Any] = [SimpleNamespace(stage_type="diffusion")]
+            self.default_sampling_params_list = [OmniDiffusionSamplingParams()]
+            self.num_stages = 1
+            self.supported_tasks = ("generate",)
+            self._alive = True
+
+        async def add_request_async(
+            self,
+            *,
+            request_id: str,
+            prompt: Any,
+            sampling_params_list: list[Any],
+            final_stage_id: int,
+            **kwargs: Any,
+        ) -> None:
+            self._fixture.request_sync_q.put_nowait(
+                StageSubmissionMessage(
+                    type="add_request",
+                    request_id=request_id,
+                    prompt=prompt,
+                    original_prompt=prompt,
+                    output_prompt_text=None,
+                    sampling_params_list=sampling_params_list,
+                    final_stage_id=final_stage_id,
+                    final_output_stage_ids=kwargs.get("final_output_stage_ids"),
+                    preprocess_ms=0.0,
+                    request_timestamp=kwargs.get("arrival_time", time.time()),
+                    enqueue_ts=time.perf_counter(),
+                )
+            )
+
+        async def submit_interaction_async(
+            self,
+            request_id: str,
+            *,
+            interaction: dict[str, Any],
+        ) -> None:
+            self._fixture.request_sync_q.put_nowait(
+                InteractionMessage(
+                    request_id=request_id,
+                    interaction=cast(Any, interaction),
+                )
+            )
+
+        async def try_get_output_async(self) -> Any | None:
+            try:
+                return self._fixture.output_sync_q.get_nowait()
+            except queue.Empty:
+                return None
+
+        def get_stage_metadata(self, stage_id: int) -> StageRuntimeInfo:
+            return self.stage_metadata[stage_id]
+
+        def is_alive(self) -> bool:
+            return self._fixture.thread.is_alive()
+
+        async def abort_async(self, request_ids: list[str]) -> None:
+            del request_ids
+
+    class _PromptUpdateEngine:
+        """DiffusionEngine stand-in that streams chunks and routes prompt_update to a runner."""
+
+        def __init__(
+            self,
+            streaming_pipeline: TestPromptUpdateIntegration._IncrementalStreamingPipeline,
+            runner: DiffusionModelRunner,
+        ) -> None:
+            self.streaming_pipeline = streaming_pipeline
+            self._runner = runner
+            self.executor = SimpleNamespace(
+                register_failure_callback=MagicMock(),
+                check_health=MagicMock(),
+            )
+
+        async def step_streaming(self, request):
+            if request.request_id not in self._runner.state_cache:
+                state = _make_diffusion_request_state(request_id=request.request_id)
+                self._runner.state_cache[request.request_id] = state
+
+            state = self._runner.state_cache[request.request_id]
+
+            outputs = self.streaming_pipeline.step_outputs(request)
+            output = outputs[0]
+            custom_output = cast(dict[str, Any], output.output) or {}
+            yield [
+                OmniRequestOutput.from_diffusion(
+                    request_id=request.request_id,
+                    images=list(custom_output.get("images") or []),
+                    custom_output=custom_output,
+                    finished=output.finished,
+                )
+            ]
+
+            deadline = time.monotonic() + 5.0
+            while "pending_prompt_update" not in state.extra:
+                if time.monotonic() >= deadline:
+                    raise TimeoutError("timed out waiting for prompt update during streaming")
+                await asyncio.sleep(0.01)
+
+            outputs = self.streaming_pipeline.step_outputs(request)
+            output = outputs[0]
+            custom_output = cast(dict[str, Any], output.output) or {}
+            yield [
+                OmniRequestOutput.from_diffusion(
+                    request_id=request.request_id,
+                    images=list(custom_output.get("images") or []),
+                    custom_output=custom_output,
+                    finished=output.finished,
+                )
+            ]
+
+        def collective_rpc(self, method, timeout, args, kwargs, unique_reply_rank):
+            del timeout, kwargs, unique_reply_rank
+            if method == "submit_interaction":
+                request_id, interaction = args
+                self._runner.submit_interaction(request_id, interaction)
+                return None
+            raise NotImplementedError(f"collective_rpc not mocked for {method!r}")
+
+        def abort(self, request_id: str) -> None:
+            del request_id
diff --git a/tests/diffusion/test_result_pump.py b/tests/diffusion/test_result_pump.py
new file mode 100644
index 000000000..fe49df47e
--- /dev/null
+++ b/tests/diffusion/test_result_pump.py
@@ -0,0 +1,256 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for MultiprocDiffusionExecutor async result pump and wait_output_ready."""
+
+import concurrent.futures
+import queue
+import threading
+import time
+from unittest.mock import MagicMock
+
+import pytest
+
+from vllm_omni.diffusion.data import AsyncDiffusionOutput, AsyncOutputKind, DiffusionOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_executor(step_execution=False):
+    """Create a minimal MultiprocDiffusionExecutor-like object with pump state."""
+    from vllm_omni.diffusion.executor.multiproc_executor import MultiprocDiffusionExecutor
+
+    od_config = MagicMock()
+    od_config.step_execution = step_execution
+
+    executor = object.__new__(MultiprocDiffusionExecutor)
+    executor.od_config = od_config
+    executor._rpc_id_counter = 0
+    executor._rpc_id_lock = threading.Lock()
+    executor._rpc_futures = {}
+    executor._output_futures = {}
+    executor._completed_outputs = {}
+    executor._batch_split_map = {}
+    executor._futures_lock = threading.RLock()
+    executor._pump_running = False
+    executor._pump_stop = threading.Event()
+    executor._sync_result_buffer = queue.Queue()
+    executor._result_mq = MagicMock()
+    executor._broadcast_mq = MagicMock()
+    executor._closed = False
+    executor._is_failed = False
+    executor._finalizer = MagicMock()  # no-op in tests
+    executor._shutdown_cleaner = None
+    executor._processes = []
+    return executor
+
+
+def _feed_one_msg_to_pump(executor, msg):
+    """Run _result_pump in a daemon thread, feed one *msg*, then stop."""
+    call_count = [0]
+
+    def mock_dequeue(timeout=None):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            return msg
+        executor._pump_stop.set()
+        time.sleep(0.05)
+        raise TimeoutError
+
+    executor._result_mq.dequeue = mock_dequeue
+    t = threading.Thread(target=executor._result_pump, daemon=True)
+    t.start()
+    t.join(timeout=2.0)
+
+
+@pytest.fixture(autouse=True)
+def _mock_unpack(mocker):
+    """Real _result_pump calls unpack_diffusion_output_shm; mock it away."""
+    mocker.patch(
+        "vllm_omni.diffusion.executor.multiproc_executor.unpack_diffusion_output_shm",
+    )
+
+
+class TestNextRpcId:
+    """Test _next_rpc_id counter."""
+
+    def test_counter_increments(self):
+        executor = _make_executor()
+        id1 = executor._next_rpc_id()
+        id2 = executor._next_rpc_id()
+        id3 = executor._next_rpc_id()
+        assert id1 == "1"
+        assert id2 == "2"
+        assert id3 == "3"
+
+    def test_counter_is_threadsafe(self):
+        executor = _make_executor()
+        ids = []
+
+        def get_id():
+            ids.append(executor._next_rpc_id())
+
+        threads = [threading.Thread(target=get_id) for _ in range(10)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # All IDs should be unique
+        assert len(set(ids)) == 10
+
+
+class TestWaitOutputReady:
+    """Test wait_output_ready future creation and caching."""
+
+    def test_returns_new_future_when_not_cached(self):
+        executor = _make_executor()
+        fut = executor.wait_output_ready("abc123")
+        assert isinstance(fut, concurrent.futures.Future)
+        assert not fut.done()
+
+    def test_future_resolves_when_output_arrives(self):
+        executor = _make_executor()
+        fut = executor.wait_output_ready("abc123")
+        output = DiffusionOutput(output="data")
+
+        # Simulate pump resolving the future
+        with executor._futures_lock:
+            executor._output_futures.pop("abc123")
+        if not fut.done():
+            fut.set_result(output)
+
+        assert fut.result(timeout=1.0) is output
+
+    def test_returns_cached_future_when_already_completed(self):
+        executor = _make_executor()
+        output = DiffusionOutput(output="cached_data")
+        fut = concurrent.futures.Future()
+        fut.set_result(output)
+        with executor._futures_lock:
+            executor._completed_outputs["abc123"] = fut
+
+        fut = executor.wait_output_ready("abc123")
+        assert fut.done()
+        assert fut.result(timeout=1.0) is output
+
+    def test_removes_from_cache_after_retrieval(self):
+        executor = _make_executor()
+        output = DiffusionOutput(output="cached_data")
+        with executor._futures_lock:
+            executor._completed_outputs["abc123"] = output
+
+        executor.wait_output_ready("abc123")
+        # Second call should not find cached result
+        with executor._futures_lock:
+            assert "abc123" not in executor._completed_outputs
+
+
+class TestResultPumpDispatch:
+    """Test _result_pump message routing (running the real pump in a thread)."""
+
+    def test_non_async_message_placed_in_sync_buffer(self):
+        executor = _make_executor()
+        msg = DiffusionOutput(output="sync_result")
+        _feed_one_msg_to_pump(executor, msg)
+
+        assert not executor._sync_result_buffer.empty()
+        retrieved = executor._sync_result_buffer.get_nowait()
+        assert isinstance(retrieved, DiffusionOutput)
+
+    def test_compute_done_routes_to_rpc_future(self):
+        executor = _make_executor()
+        rpc_id = "42"
+        fut = concurrent.futures.Future()
+        with executor._futures_lock:
+            executor._rpc_futures[rpc_id] = fut
+
+        msg = AsyncDiffusionOutput(
+            kind=AsyncOutputKind.COMPUTE_DONE,
+            rpc_id=rpc_id,
+            async_output_id="abc",
+        )
+        _feed_one_msg_to_pump(executor, msg)
+
+        assert fut.done()
+        result = fut.result(timeout=1.0)
+        assert result.kind == AsyncOutputKind.COMPUTE_DONE
+
+    def test_output_ready_routes_to_output_future(self):
+        executor = _make_executor()
+        async_output_id = "abc123"
+        output = DiffusionOutput(output="final")
+        fut = concurrent.futures.Future()
+        with executor._futures_lock:
+            executor._output_futures[async_output_id] = fut
+
+        msg = AsyncDiffusionOutput(
+            kind=AsyncOutputKind.OUTPUT_READY,
+            async_output_id=async_output_id,
+            output=output,
+        )
+        _feed_one_msg_to_pump(executor, msg)
+
+        assert fut.done()
+        assert fut.result(timeout=1.0) is output
+
+    def test_output_ready_with_error_routes_to_future_as_exception(self):
+        executor = _make_executor()
+        async_output_id = "abc123"
+        fut = concurrent.futures.Future()
+        with executor._futures_lock:
+            executor._output_futures[async_output_id] = fut
+
+        msg = AsyncDiffusionOutput(
+            kind=AsyncOutputKind.OUTPUT_READY,
+            async_output_id=async_output_id,
+            error="Background D2H/SHM packing failed",
+        )
+        _feed_one_msg_to_pump(executor, msg)
+
+        assert fut.done()
+        with pytest.raises(RuntimeError, match="Background D2H/SHM packing failed"):
+            fut.result(timeout=1.0)
+
+    def test_output_ready_caches_when_no_future_waiting(self):
+        """When OUTPUT_READY arrives but no future is waiting, result is cached."""
+        executor = _make_executor()
+        async_output_id = "abc123"
+        output = DiffusionOutput(output="orphan")
+
+        msg = AsyncDiffusionOutput(
+            kind=AsyncOutputKind.OUTPUT_READY,
+            async_output_id=async_output_id,
+            output=output,
+        )
+        _feed_one_msg_to_pump(executor, msg)
+
+        # Later call to wait_output_ready should find it cached
+        fut = executor.wait_output_ready(async_output_id)
+        assert fut.done()
+        assert fut.result(timeout=1.0) is output
+
+
+class TestShutdownCleansUpFutures:
+    """Test that shutdown cancels pending futures."""
+
+    def test_shutdown_sets_exception_on_pending_futures(self):
+        executor = _make_executor()
+
+        rpc_fut = concurrent.futures.Future()
+        output_fut = concurrent.futures.Future()
+        with executor._futures_lock:
+            executor._rpc_futures["1"] = rpc_fut
+            executor._output_futures["abc"] = output_fut
+
+        executor.shutdown()
+
+        assert rpc_fut.done()
+        with pytest.raises(RuntimeError, match="Executor shut down"):
+            rpc_fut.result(timeout=1.0)
+
+        assert output_fut.done()
+        with pytest.raises(RuntimeError, match="Executor shut down"):
+            output_fut.result(timeout=1.0)
+
+        assert len(executor._rpc_futures) == 0
+        assert len(executor._output_futures) == 0
diff --git a/tests/diffusion/test_stage_diffusion_proc.py b/tests/diffusion/test_stage_diffusion_proc.py
index c96aa8ba1..697465097 100644
--- a/tests/diffusion/test_stage_diffusion_proc.py
+++ b/tests/diffusion/test_stage_diffusion_proc.py
@@ -27,7 +27,7 @@ DELAY_BASE = 0.01
 
 
 class MockDiffusionEngine:
-    async def step(self, request):
+    async def step_streaming(self, request):
         def simulate_step_delay(height, width, num_inference_steps) -> float:
             return (height / BASE_HEIGHT) * (width / BASE_WIDTH) * (num_inference_steps / BASE_INFER_STEPS)
 
@@ -37,7 +37,7 @@ class MockDiffusionEngine:
         )
         delay = DELAY_BASE + delay_scale * DELAY_BASE
         await asyncio.sleep(delay)
-        return [MockOmniRequestOutput(request_id=request.request_id)]
+        yield [MockOmniRequestOutput(request_id=request.request_id)]
 
 
 @pytest.mark.asyncio
diff --git a/tests/diffusion/test_worker_wrapper_base.py b/tests/diffusion/test_worker_wrapper_base.py
index ba22743fc..170faec80 100644
--- a/tests/diffusion/test_worker_wrapper_base.py
+++ b/tests/diffusion/test_worker_wrapper_base.py
@@ -161,19 +161,6 @@ class TestWorkerWrapperBaseExtension:
 class TestWorkerWrapperBaseDelegation:
     """Test WorkerWrapperBase delegation to wrapped worker."""
 
-    def test_generate_delegation(self, mocker: MockerFixture, mock_od_config):
-        """Test that generate() delegates to worker.generate()."""
-        mocker.patch.object(DiffusionWorker, "__init__", return_value=None)
-        wrapper = WorkerWrapperBase(gpu_id=0, od_config=mock_od_config, base_worker_class=DiffusionWorker)
-        mock_output = mocker.Mock()
-        wrapper.worker.generate = mocker.Mock(return_value=mock_output)
-
-        mock_requests = [mocker.Mock()]
-        result = wrapper.generate(mock_requests)
-
-        wrapper.worker.generate.assert_called_once_with(mock_requests)
-        assert result == mock_output
-
     def test_execute_model_delegation(self, mocker: MockerFixture, mock_od_config):
         """Test that execute_model() delegates to worker.execute_model()."""
         mocker.patch.object(DiffusionWorker, "__init__", return_value=None)
@@ -181,25 +168,12 @@ class TestWorkerWrapperBaseDelegation:
         mock_output = mocker.Mock()
         wrapper.worker.execute_model = mocker.Mock(return_value=mock_output)
 
-        mock_reqs = [mocker.Mock()]
-        result = wrapper.execute_model(mock_reqs, mock_od_config)
+        mock_req = mocker.Mock()
+        result = wrapper.execute_model(mock_req, mock_od_config)
 
-        wrapper.worker.execute_model.assert_called_once_with(mock_reqs, mock_od_config, kv_prefetch_jobs=None)
+        wrapper.worker.execute_model.assert_called_once_with(mock_req, mock_od_config, kv_prefetch_job=None)
         assert result == mock_output
 
-    def test_load_weights_delegation(self, mocker: MockerFixture, mock_od_config):
-        """Test that load_weights() delegates to worker.load_weights()."""
-        mocker.patch.object(DiffusionWorker, "__init__", return_value=None)
-        wrapper = WorkerWrapperBase(gpu_id=0, od_config=mock_od_config, base_worker_class=DiffusionWorker)
-        expected_result = {"weight1", "weight2"}
-        wrapper.worker.load_weights = mocker.Mock(return_value=expected_result)
-
-        mock_weights = [("weight1", mocker.Mock()), ("weight2", mocker.Mock())]
-        result = wrapper.load_weights(mock_weights)
-
-        wrapper.worker.load_weights.assert_called_once_with(mock_weights)
-        assert result == expected_result
-
     def test_sleep_delegation(self, mocker: MockerFixture, mock_od_config):
         """Test that sleep() delegates to worker.sleep()."""
         mocker.patch.object(DiffusionWorker, "__init__", return_value=None)
diff --git a/tests/diffusion/utils/test_flow_matching.py b/tests/diffusion/utils/test_flow_matching.py
new file mode 100644
index 000000000..7f08bb624
--- /dev/null
+++ b/tests/diffusion/utils/test_flow_matching.py
@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.diffusion.utils import flow_matching
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def test_safe_linalg_solve_uses_torch_native_path(monkeypatch: pytest.MonkeyPatch):
+    matrix = torch.tensor([[3.0, 1.0], [1.0, 2.0]], dtype=torch.float32)
+    rhs = torch.tensor([9.0, 8.0], dtype=torch.float32)
+    expected = torch.tensor([2.0, 3.0], dtype=torch.float32)
+
+    def fake_torch_solve(solve_matrix: torch.Tensor, solve_rhs: torch.Tensor) -> torch.Tensor:
+        assert torch.equal(solve_matrix, matrix)
+        assert torch.equal(solve_rhs, rhs)
+        return expected
+
+    def fail_numpy(*_args, **_kwargs):
+        raise AssertionError("NumPy fallback should not run")
+
+    monkeypatch.setattr(flow_matching.torch.linalg, "solve", fake_torch_solve)
+    monkeypatch.setattr(flow_matching.np.linalg, "solve", fail_numpy)
+
+    result = flow_matching.safe_linalg_solve(matrix, rhs)
+
+    assert result is expected
+
+
+def test_safe_linalg_solve_falls_back_on_missing_cpu_lapack(monkeypatch: pytest.MonkeyPatch):
+    matrix = torch.tensor([[3.0, 1.0], [1.0, 2.0]], dtype=torch.float32)
+    rhs = torch.tensor([9.0, 8.0], dtype=torch.float32)
+    expected = np.array([2.0, 3.0], dtype=np.float32)
+
+    def fail_with_missing_lapack(*_args, **_kwargs):
+        raise RuntimeError(
+            "Calling torch.linalg.lu_factor on a CPU tensor requires compiling PyTorch with LAPACK. "
+            "Please use PyTorch built with LAPACK support."
+        )
+
+    monkeypatch.setattr(flow_matching.torch.linalg, "solve", fail_with_missing_lapack)
+    monkeypatch.setattr(flow_matching.np.linalg, "solve", lambda *_args, **_kwargs: expected)
+
+    result = flow_matching.safe_linalg_solve(matrix, rhs)
+
+    assert torch.equal(result, torch.from_numpy(expected))
+    assert result.dtype == matrix.dtype
+    assert result.device == matrix.device
+
+
+def test_safe_linalg_solve_reraises_unrelated_runtime_error(monkeypatch: pytest.MonkeyPatch):
+    matrix = torch.tensor([[3.0, 1.0], [1.0, 2.0]], dtype=torch.float32)
+    rhs = torch.tensor([9.0, 8.0], dtype=torch.float32)
+
+    def fail_with_unrelated_error(*_args, **_kwargs):
+        raise RuntimeError("solver exploded for another reason")
+
+    def fail_numpy(*_args, **_kwargs):
+        raise AssertionError("NumPy fallback should not run")
+
+    monkeypatch.setattr(flow_matching.torch.linalg, "solve", fail_with_unrelated_error)
+    monkeypatch.setattr(flow_matching.np.linalg, "solve", fail_numpy)
+
+    with pytest.raises(RuntimeError, match="solver exploded for another reason"):
+        flow_matching.safe_linalg_solve(matrix, rhs)
diff --git a/tests/distributed/omni_connectors/test_adapter_and_flow.py b/tests/distributed/omni_connectors/test_adapter_and_flow.py
index 548d16eb6..1cabaf3b3 100644
--- a/tests/distributed/omni_connectors/test_adapter_and_flow.py
+++ b/tests/distributed/omni_connectors/test_adapter_and_flow.py
@@ -8,6 +8,7 @@ from vllm_omni.distributed.omni_connectors.adapter import try_recv_via_connector
 from vllm_omni.distributed.omni_connectors.connectors.shm_connector import SharedMemoryConnector
 from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec, OmniTransferConfig
 from vllm_omni.distributed.omni_connectors.utils.initialization import get_connectors_config_for_stage
+from vllm_omni.engine.stage_init_utils import get_stage_connector_spec
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -142,11 +143,10 @@ def test_recv_no_connector():
 def test_shm_connector_flow(mocker: MockerFixture):
     """
     Verify the full flow: Send -> Adapter -> Connector -> Adapter -> Recv.
-    Using real SharedMemoryConnector (inline mode for simplicity).
+    Using real SharedMemoryConnector and key-addressed SHM metadata.
     """
     # 1. Setup Connector
-    config = {"shm_threshold_bytes": 1024, "inline_small_payloads": True}
-    connector = SharedMemoryConnector(config)
+    connector = SharedMemoryConnector({})
     connectors_map = {("0", "1"): connector}
 
     # 2. Setup Data
@@ -218,6 +218,39 @@ def test_get_connectors_for_stage():
     assert stage_2_config["from_stage_1"]["spec"]["name"] == "C2"
 
 
+@pytest.mark.parametrize("async_chunk", [False, True])
+def test_outgoing_stage_uses_sender_connector_spec(async_chunk: bool):
+    config = OmniTransferConfig(
+        connectors={
+            ("1", "2"): ConnectorSpec(
+                name="SharedMemoryConnector",
+                extra={"codec_chunk_frames": 25},
+            )
+        }
+    )
+
+    spec = get_stage_connector_spec(config, stage_id=1, async_chunk=async_chunk)
+
+    assert spec["name"] == "SharedMemoryConnector"
+    assert spec["extra"] == {"codec_chunk_frames": 25, "role": "sender"}
+
+
+def test_full_payload_consumer_uses_receiver_connector_spec():
+    config = OmniTransferConfig(
+        connectors={
+            ("1", "2"): ConnectorSpec(
+                name="SharedMemoryConnector",
+                extra={"codec_chunk_frames": 25},
+            )
+        }
+    )
+
+    spec = get_stage_connector_spec(config, stage_id=2, async_chunk=False)
+
+    assert spec["name"] == "SharedMemoryConnector"
+    assert spec["extra"] == {"codec_chunk_frames": 25, "role": "receiver"}
+
+
 def test_recv_with_missing_metadata(mocker: MockerFixture):
     """Test recv when queue payload is malformed (missing metadata)."""
     # Connector expects metadata but task doesn't have it
diff --git a/tests/distributed/omni_connectors/test_bagel_shared_memory_connector.py b/tests/distributed/omni_connectors/test_bagel_shared_memory_connector.py
index c21af394a..995835024 100644
--- a/tests/distributed/omni_connectors/test_bagel_shared_memory_connector.py
+++ b/tests/distributed/omni_connectors/test_bagel_shared_memory_connector.py
@@ -228,6 +228,7 @@ def _resolve_deploy_config(config_path: str, run_level: str) -> str:
 
 
 @pytest.mark.advanced_model
+@pytest.mark.skip(reason="#issue 5475")
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "H100", "rocm": "MI325"})
 def test_bagel_img2img_shared_memory_connector(run_level):
diff --git a/tests/distributed/omni_connectors/test_basic_connectors.py b/tests/distributed/omni_connectors/test_basic_connectors.py
index 1518e98b1..787d5594b 100644
--- a/tests/distributed/omni_connectors/test_basic_connectors.py
+++ b/tests/distributed/omni_connectors/test_basic_connectors.py
@@ -60,10 +60,9 @@ def test_ndarray_serialization():
 
 def test_create_shm_connector():
     """Test creating SharedMemoryConnector via Factory."""
-    spec = ConnectorSpec(name="SharedMemoryConnector", extra={"shm_threshold_bytes": 1024})
+    spec = ConnectorSpec(name="SharedMemoryConnector")
     connector = OmniConnectorFactory.create_connector(spec)
     assert isinstance(connector, SharedMemoryConnector)
-    assert connector.threshold == 1024
 
 
 def test_create_unknown_connector():
@@ -75,21 +74,20 @@ def test_create_unknown_connector():
 
 @pytest.fixture
 def shm_connector():
-    config = {"shm_threshold_bytes": 100, "inline_small_payloads": True}
-    return SharedMemoryConnector(config)
+    connector = SharedMemoryConnector({})
+    yield connector
+    connector.close()
 
 
-def test_put_get_inline(shm_connector):
-    """Test inline transfer for small data."""
+def test_put_get_small_payload_uses_shm(shm_connector):
+    """Small payloads use key-addressed SHM; inline metadata is retired."""
     data = {"small": "data"}
 
     success, size, metadata = shm_connector.put("stage_0", "stage_1", "req_1", data)
     assert success is True
-    assert "inline_bytes" in metadata
-    assert "shm" not in metadata
+    assert "shm" in metadata
+    assert "inline_bytes" not in metadata
     assert "size" in metadata
-    assert shm_connector._metrics["inline_writes"] == 1
-    assert shm_connector._metrics["shm_writes"] == 0
 
     # Retrieve
     retrieved_data, ret_size = shm_connector.get("stage_0", "stage_1", "req_1", metadata)
@@ -195,3 +193,42 @@ def test_mooncake_connector_defaults_missing_host_to_detected_ip(monkeypatch: py
         assert connector.get_connection_info()["host"] == "10.20.30.40"
     finally:
         connector.close()
+
+
+def test_mooncake_get_counts_zmq_timeout_separately(mocker: MockerFixture):
+    import vllm_omni.distributed.omni_connectors.connectors.mooncake_transfer_engine_connector as mooncake_module
+
+    connector = object.__new__(mooncake_module.MooncakeTransferEngineConnector)
+    connector._closed = False
+    connector._metrics = {"errors": 0, "timeouts": 0}
+    connector._resolve_metadata = mocker.Mock(
+        return_value={"source_host": "127.0.0.1", "source_port": 1234, "data_size": 8}
+    )
+    recv_buffer = mocker.Mock()
+    connector._alloc_recv_buffer = mocker.Mock(return_value=(recv_buffer, 1000))
+    connector._request_transfer = mocker.Mock(side_effect=mooncake_module.zmq.Again())
+
+    assert connector.get("s0", "s1", "req") is None
+    assert connector._metrics == {"errors": 0, "timeouts": 1}
+    recv_buffer.release.assert_called_once()
+    connector._closed = True
+
+
+def test_mooncake_get_counts_cuda_sync_failure_as_error(mocker: MockerFixture):
+    import vllm_omni.distributed.omni_connectors.connectors.mooncake_transfer_engine_connector as mooncake_module
+
+    connector = object.__new__(mooncake_module.MooncakeTransferEngineConnector)
+    connector._closed = False
+    connector._metrics = {"errors": 0, "timeouts": 0}
+    connector._resolve_metadata = mocker.Mock(
+        return_value={"source_host": "127.0.0.1", "source_port": 1234, "data_size": 8}
+    )
+    recv_buffer = mocker.Mock()
+    connector._alloc_recv_buffer = mocker.Mock(return_value=(recv_buffer, 1000))
+    connector._request_transfer = mocker.Mock(return_value=mooncake_module.TRANS_DONE)
+    connector._sync_receive_buffer_if_needed = mocker.Mock(side_effect=RuntimeError("CUDA sync failed"))
+
+    assert connector.get("s0", "s1", "req") is None
+    assert connector._metrics == {"errors": 1, "timeouts": 0}
+    recv_buffer.release.assert_called_once()
+    connector._closed = True
diff --git a/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py b/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
index 9c6a86ed3..b1ff5db94 100644
--- a/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
+++ b/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
@@ -10,9 +10,12 @@ import pytest
 import torch
 from pytest_mock import MockerFixture
 from vllm.v1.core.sched.scheduler import Scheduler as VLLMScheduler
+from vllm.v1.metrics.stats import PrefillStats, PromptTokenStats
 from vllm.v1.request import RequestStatus
 
+from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
 from vllm_omni.data_entry_keys import CodesStruct, MetaStruct, OmniPayload, OmniPayloadStruct
+from vllm_omni.distributed.omni_connectors.adapter import construct_next_stage_streaming_input_prompt
 from vllm_omni.distributed.omni_connectors.transfer_adapter.base import OmniTransferAdapterBase
 from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter import (
     OmniChunkTransferAdapter,
@@ -36,13 +39,66 @@ def _req(req_id: str, status: RequestStatus, external_req_id: str | None = None)
         external_req_id=external_req_id or req_id,
         status=status,
         prompt_token_ids=[],
+        num_prompt_tokens=0,
         num_computed_tokens=0,
         num_output_placeholders=0,
+        prefill_stats=None,
         additional_information=None,
         is_finished=lambda: status == RequestStatus.FINISHED_STOPPED,
     )
 
 
+def test_streaming_payload_can_replace_placeholder_prompt(mocker: MockerFixture) -> None:
+    request = SimpleNamespace(
+        _all_token_ids=[0, 0, 7, 8],
+        _output_token_ids=[7, 8],
+        prompt_token_ids=[0, 0],
+        num_computed_tokens=4,
+        num_prompt_tokens=2,
+        update_block_hashes=mocker.Mock(),
+    )
+    payload = {
+        "ids": {"prompt": [1, 2, 3]},
+        "meta": {
+            "replace_streaming_prompt": True,
+            "next_stage_prompt_len": 7,
+        },
+    }
+
+    construct_next_stage_streaming_input_prompt(payload, request)
+
+    assert request.prompt_token_ids == [0] * 7
+    assert request._all_token_ids == [0] * 7
+    assert request._output_token_ids == []
+    assert request.num_computed_tokens == 0
+    assert request.num_prompt_tokens == 7
+    request.update_block_hashes.assert_called_once_with()
+
+
+def test_streaming_payload_can_append_exact_prompt_length(mocker: MockerFixture) -> None:
+    request = SimpleNamespace(
+        _all_token_ids=[0, 0, 7, 8],
+        _output_token_ids=[7, 8],
+        prompt_token_ids=[0, 0],
+        num_computed_tokens=4,
+        num_prompt_tokens=2,
+        update_block_hashes=mocker.Mock(),
+    )
+    payload = {
+        "ids": {"prompt": [1, 2, 3]},
+        "meta": {"next_stage_prompt_len": 3},
+    }
+
+    construct_next_stage_streaming_input_prompt(payload, request)
+
+    assert request.prompt_token_ids == [0, 0, 7, 8, 0, 0, 0]
+    assert request._all_token_ids == [0, 0, 7, 8, 0, 0, 0]
+    assert request._output_token_ids == []
+    assert request.num_computed_tokens == 4
+    assert request.num_prompt_tokens == 7
+    request.update_block_hashes.assert_called_once_with()
+
+
 @pytest.fixture
 def build_adapter(monkeypatch, mocker: MockerFixture):
     def _build(
@@ -81,6 +137,10 @@ def build_adapter(monkeypatch, mocker: MockerFixture):
             worker_type=model_mode,
             max_num_seqs=max_num_seqs,
             active_stream_window=active_stream_window,
+            stage_connector_config={
+                "name": "SharedMemoryConnector",
+                "extra": connector_extra or {},
+            },
         )
         scheduler_config = SimpleNamespace(max_num_seqs=max_num_seqs)
         adapter = OmniChunkTransferAdapter(
@@ -136,7 +196,7 @@ def test_load_poll(build_adapter):
     assert request.additional_information == payload
     assert adapter.get_req_chunk["req-1"] == 1
     assert "req-1" in adapter._finished_load_reqs
-    assert "req-1" in adapter.finished_requests
+    assert "req-1" in adapter.upstream_exhausted_requests
     assert "req-1" not in adapter._pending_load_reqs
 
 
@@ -220,6 +280,37 @@ def test_save_async_uses_confirmed_tokens_for_async_scheduler_watermark(build_ad
     assert len(adapter._pending_save_reqs) == 1
 
 
+def test_send_single_request_terminal_chunk_still_flushes_processor(build_adapter, monkeypatch):
+    """A terminal stop is not a segment boundary (#5383), but the producer-side
+    processor must still receive the flush signal on the terminal chunk.
+    Passing only ``is_segment_finished`` starved processors of their final
+    accumulated payload once terminal stops stopped setting it (#5413: the
+    downstream stage got ``meta.finished`` with the tail data missing).
+    """
+    adapter, connector = build_adapter(stage_id=0)
+    request = _req("req-terminal", RequestStatus.FINISHED_STOPPED, external_req_id="ext-terminal")
+
+    seen_flush_flags = []
+
+    def recording_processor(**kwargs):
+        seen_flush_flags.append(kwargs["is_finished"])
+        return OmniPayloadStruct(
+            codes=CodesStruct(audio=torch.tensor([1, 2, 3], dtype=torch.long)),
+        )
+
+    adapter.custom_process_next_stage_input_func = recording_processor
+    monkeypatch.setattr(adapter, "cleanup", lambda *a, **kw: None)
+
+    adapter._send_single_request(
+        {"multimodal_output": None, "request": request, "is_finished": True, "is_segment_finished": False}
+    )
+
+    assert seen_flush_flags == [True]
+    sent_payload = connector.put.call_args.kwargs["data"]
+    assert bool(sent_payload.meta.finished.item()) is True
+    assert bool(sent_payload.meta.is_segment_finished.item()) is False
+
+
 def test_send_single_request_struct_without_meta_does_not_crash(build_adapter, monkeypatch):
     """Producer may return a struct with ``meta=None`` (e.g. payload that
     carries only ``embed`` or ``codes``). The sender's ``meta is not None``
@@ -282,6 +373,122 @@ def test_send_single_request_struct_preserves_segment_finished(build_adapter, mo
     assert sent_payload.meta.is_segment_finished.item() is True
 
 
+def test_send_single_request_respects_processor_receiver_boundary(build_adapter, monkeypatch):
+    adapter, connector = build_adapter(stage_id=1)
+    request = _req("req-stream", RequestStatus.WAITING, external_req_id="ext-stream")
+
+    adapter.custom_process_next_stage_input_func = lambda **kwargs: OmniPayloadStruct(
+        meta=MetaStruct(is_segment_finished=torch.tensor(False, dtype=torch.bool))
+    )
+    monkeypatch.setattr(adapter, "cleanup", lambda *a, **kw: None)
+
+    adapter._send_single_request(
+        {"multimodal_output": None, "request": request, "is_finished": False, "is_segment_finished": True}
+    )
+
+    sent_payload = connector.put.call_args.kwargs["data"]
+    assert sent_payload.meta.is_segment_finished.item() is False
+
+
+def test_send_single_request_personaplex_pending_frame_is_not_segment_boundary(
+    build_adapter,
+):
+    from vllm_omni.model_executor.stage_input_processors.personaplex import (
+        talker2code2wav_async_chunk,
+    )
+
+    adapter, connector = build_adapter(
+        stage_id=0,
+        connector_extra={
+            "initial_codec_chunk_frames": 1,
+            "codec_chunk_frames": 5,
+        },
+    )
+    request = _req(
+        "req-personaplex",
+        RequestStatus.WAITING,
+        external_req_id="ext-personaplex",
+    )
+    request.resumable = True
+    request.additional_information = {
+        "codes": {
+            "audio": torch.arange(8, dtype=torch.long).reshape(1, 8),
+        }
+    }
+    adapter.custom_process_next_stage_input_func = talker2code2wav_async_chunk
+
+    adapter._send_single_request(
+        {
+            "multimodal_output": None,
+            "request": request,
+            "is_finished": False,
+            "is_segment_finished": True,
+        }
+    )
+
+    sent_payload = connector.put.call_args.kwargs["data"]
+    assert sent_payload.codes is None
+    assert sent_payload.meta.finished.item() is False
+    assert sent_payload.meta.is_segment_finished.item() is False
+
+
+def test_personaplex_sender_cleanup_drops_delayed_frame_state(build_adapter):
+    from vllm_omni.model_executor.stage_input_processors.personaplex import (
+        talker2code2wav_async_chunk,
+    )
+
+    adapter, _ = build_adapter(
+        stage_id=0,
+        connector_extra={
+            "initial_codec_chunk_frames": 1,
+            "codec_chunk_frames": 5,
+        },
+    )
+    request = _req(
+        "req-personaplex-first",
+        RequestStatus.WAITING,
+        external_req_id="ext-personaplex-reused",
+    )
+    request.resumable = True
+    request.additional_information = {
+        "codes": {
+            "audio": torch.arange(8, dtype=torch.long).reshape(1, 8),
+        }
+    }
+
+    first = talker2code2wav_async_chunk(
+        adapter,
+        multimodal_output=None,
+        request=request,
+        is_finished=True,
+    )
+    assert first is not None
+    assert first.codes is None
+
+    adapter.cleanup_sender(request.external_req_id)
+
+    replacement = _req(
+        "req-personaplex-replacement",
+        RequestStatus.WAITING,
+        external_req_id=request.external_req_id,
+    )
+    replacement.resumable = True
+    replacement.additional_information = {
+        "codes": {
+            "audio": torch.arange(8, 16, dtype=torch.long).reshape(1, 8),
+        }
+    }
+    second = talker2code2wav_async_chunk(
+        adapter,
+        multimodal_output=None,
+        request=replacement,
+        is_finished=True,
+    )
+
+    assert second is not None
+    assert second.codes is None
+
+
 def test_save_async_skips_stale_resumable_chunk_until_dedup_is_reset(build_adapter):
     adapter, _ = build_adapter(stage_id=1)
     request = _req("req-stream", RequestStatus.WAITING, external_req_id="ext-stream")
@@ -355,7 +562,7 @@ def test_load_poll_non_ar_merges_into_existing_additional_information(build_adap
     assert request.additional_information["meta"]["phase"] == "decode"
     assert request.additional_information["kv_metadata"] == {"foo": "bar"}
     assert "req-non-ar" in adapter._finished_load_reqs
-    assert "req-non-ar" in adapter.finished_requests
+    assert "req-non-ar" in adapter.upstream_exhausted_requests
 
 
 def test_load_poll_ar_request_additional_information_concats_tensors(build_adapter):
@@ -381,6 +588,68 @@ def test_load_poll_ar_request_additional_information_concats_tensors(build_adapt
     assert request.additional_information["meta"]["finished"].item() is True
 
 
+def test_non_ar_poll_reinitializes_prefill_stats_for_later_chunks(build_adapter):
+    adapter, connector = build_adapter(stage_id=2, model_mode="generation")
+    request = _req("req-later-chunk", RequestStatus.WAITING, external_req_id="ext-later-chunk")
+    request.prefill_stats = PrefillStats()
+    adapter.request_ids_mapping[request.request_id] = request.external_req_id
+
+    connector.get.return_value = (
+        {
+            "codes": {"audio": torch.tensor([7, 8], dtype=torch.long)},
+            "meta": {"finished": torch.tensor(False, dtype=torch.bool)},
+        },
+        8,
+    )
+    assert adapter._poll_single_request(request) is True
+    OmniGenerationScheduler._record_prefill_stats(request)
+    first_chunk_stats = request.prefill_stats
+    request.prefill_stats = None
+
+    connector.get.return_value = (
+        {
+            "codes": {"audio": torch.tensor([9, 10, 11], dtype=torch.long)},
+            "meta": {"finished": torch.tensor(True, dtype=torch.bool)},
+        },
+        8,
+    )
+    assert adapter._poll_single_request(request) is True
+    assert isinstance(request.prefill_stats, PrefillStats)
+    OmniGenerationScheduler._record_prefill_stats(request)
+    second_chunk_stats = request.prefill_stats
+
+    assert first_chunk_stats is not None
+    assert first_chunk_stats.num_prompt_tokens == 2
+    assert second_chunk_stats is not None
+    assert second_chunk_stats.num_prompt_tokens == 3
+
+    prompt_token_stats = PromptTokenStats()
+    prompt_token_stats.update_from_output(first_chunk_stats)
+    prompt_token_stats.update_from_output(second_chunk_stats)
+    assert prompt_token_stats.total == 5
+    assert prompt_token_stats.computed == 5
+
+
+def test_sender_only_adapter_does_not_park_or_clear_requests(build_adapter):
+    adapter, _ = build_adapter(stage_id=1, connector_extra={"role": "sender"})
+    request = _req("req-1", RequestStatus.WAITING)
+    request.additional_information = {"tts_token_ids": torch.tensor([1])}
+    waiting_queue = DummyWaitingQueue([request])
+    running_queue = []
+
+    adapter.load_async(request)
+    adapter.process_pending_chunks(
+        waiting_queue,
+        running_queue,
+        scheduler_requests={request.request_id: request},
+    )
+
+    assert waiting_queue == [request]
+    assert request.status == RequestStatus.WAITING
+    assert request.additional_information["tts_token_ids"].item() == 1
+    assert adapter._pending_load_reqs == deque()
+
+
 def test_process_and_restore_queues(build_adapter):
     adapter, _ = build_adapter(stage_id=1, max_num_seqs=8)
     waiting_req = _req("w1", RequestStatus.WAITING)
@@ -403,7 +672,7 @@ def test_process_and_restore_queues(build_adapter):
 
 
 def test_fifo_promotion(build_adapter):
-    adapter, _ = build_adapter(stage_id=1, max_num_seqs=2, active_stream_window=2)
+    adapter, _ = build_adapter(stage_id=1, model_mode="generation", max_num_seqs=2, active_stream_window=2)
     reqs = [_req(f"req-{idx}", RequestStatus.WAITING) for idx in range(1, 5)]
     waiting_queue = DummyWaitingQueue(reqs)
     running_queue = []
@@ -411,16 +680,18 @@ def test_fifo_promotion(build_adapter):
     adapter.process_pending_chunks(waiting_queue, running_queue)
 
     assert list(adapter._active_streams) == ["req-1", "req-2"]
-    assert waiting_queue == reqs[2:]
+    assert waiting_queue == []
     assert reqs[0].status == RequestStatus.WAITING_FOR_CHUNK
     assert reqs[1].status == RequestStatus.WAITING_FOR_CHUNK
     assert reqs[2].status == RequestStatus.WAITING
 
-    adapter.finished_requests.add("req-1")
+    # Ordinary completion calls cleanup_receiver(), not finish_requests()
+    # (the abort path) -- see test_omni_ar_scheduler_free_request_cleanup.py.
     # Eviction is deferred to postprocess_scheduler_output in the runtime path
-    # (commit c4d95fd9 — otherwise the terminal chunk deadlocks at c=8 K=2).
-    # Simulate it here so promotion can pick up the freed slot.
-    adapter._evict_finished_active_streams({"req-1"})
+    # (commit c4d95fd9 -- otherwise the terminal chunk deadlocks at c=8 K=2).
+    # Simulate the restore step here so promotion can pick up the freed slot.
+    adapter.cleanup_receiver("req-1")
+    adapter.restore_queues(waiting_queue, running_queue)
     adapter.process_pending_chunks(waiting_queue, running_queue)
 
     assert list(adapter._active_streams) == ["req-2", "req-3"]
@@ -429,6 +700,22 @@ def test_fifo_promotion(build_adapter):
     assert reqs[2].status == RequestStatus.WAITING_FOR_CHUNK
 
 
+def test_non_active_waiting_request_is_held_off_scheduler(build_adapter):
+    adapter, _ = build_adapter(stage_id=2, max_num_seqs=2, active_stream_window=1)
+    active = _req("req-active", RequestStatus.WAITING)
+    non_active = _req("req-non-active", RequestStatus.WAITING)
+    waiting_queue = DummyWaitingQueue([active, non_active])
+    running_queue = []
+
+    adapter.process_pending_chunks(waiting_queue, running_queue)
+
+    assert waiting_queue == []
+    assert active.status == RequestStatus.WAITING_FOR_CHUNK
+    assert non_active.status == RequestStatus.WAITING
+    assert list(adapter._pending_load_reqs) == [active]
+    assert list(adapter.waiting_for_chunk_waiting_requests) == [active, non_active]
+
+
 def test_legacy_k0(build_adapter):
     adapter, _ = build_adapter(stage_id=1, max_num_seqs=1, active_stream_window=0)
     waiting_req = _req("waiting", RequestStatus.WAITING)
@@ -449,7 +736,7 @@ def test_legacy_k0(build_adapter):
 
 
 def test_finished_releases_slot(build_adapter):
-    adapter, _ = build_adapter(stage_id=1, max_num_seqs=1, active_stream_window=1)
+    adapter, _ = build_adapter(stage_id=1, model_mode="generation", max_num_seqs=1, active_stream_window=1)
     req_1 = _req("req-1", RequestStatus.WAITING)
     req_2 = _req("req-2", RequestStatus.WAITING)
     waiting_queue = DummyWaitingQueue([req_1, req_2])
@@ -457,12 +744,14 @@ def test_finished_releases_slot(build_adapter):
 
     adapter.process_pending_chunks(waiting_queue, running_queue)
     assert list(adapter._active_streams) == ["req-1"]
-    assert waiting_queue == [req_2]
+    assert waiting_queue == []
 
-    adapter.finished_requests.add("req-1")
-    # Eviction is deferred to postprocess_scheduler_output in the runtime path
-    # (commit c4d95fd9). Simulate it so promotion can pick up the freed slot.
-    adapter._evict_finished_active_streams({"req-1"})
+    # req-1 finishes ordinarily (see test_fifo_promotion for why this is
+    # cleanup_receiver(), not finish_requests()). Eviction is deferred to
+    # postprocess_scheduler_output in the runtime path (commit c4d95fd9);
+    # simulate the restore step so promotion can pick up the freed slot.
+    adapter.cleanup_receiver("req-1")
+    adapter.restore_queues(waiting_queue, running_queue)
     adapter.process_pending_chunks(waiting_queue, running_queue)
 
     assert list(adapter._active_streams) == ["req-2"]
@@ -489,6 +778,79 @@ def test_postprocess_scheduler_output(build_adapter):
     assert adapter.requests_with_ready_chunks == {"leftover"}
 
 
+@pytest.mark.parametrize("model_mode", ["ar", "generation"])
+def test_active_stream_window_stalls_lone_running_request_after_upstream_finishes(build_adapter, model_mode):
+    """Regression test for vllm-project/vllm-omni#5349.
+
+    upstream_exhausted_requests means the upstream sent its terminal chunk,
+    not that this stage's own generation is done. A downstream stage can
+    still have a long decode ahead after its upstream finishes. Evicting on
+    that signal and then permanently denying re-admission wedges the
+    request out of running_queue forever, with no error.
+
+    requests_with_ready_chunks is set up front so the request stays in
+    running_queue this tick instead of legitimately parking in
+    waiting_for_chunk_running_requests (a separate mechanism this test must
+    not conflate with the bug).
+
+    Parametrized over both worker types: the real issue hit an "ar" stage
+    (Qwen3-Omni's talker); must not regress "generation" (Qwen3-TTS's
+    Code2Wav), which this feature was designed for.
+    """
+    adapter, _ = build_adapter(stage_id=1, model_mode=model_mode, max_num_seqs=2, active_stream_window=2)
+    running_req = _req("req-1", RequestStatus.RUNNING)
+    running_queue = [running_req]
+    waiting_queue = DummyWaitingQueue([])
+
+    adapter._active_streams["req-1"] = running_req
+    adapter.requests_with_ready_chunks.add("req-1")
+
+    # Upstream terminal chunk arrives; this stage hasn't finished.
+    adapter.upstream_exhausted_requests.add("req-1")
+    scheduler_output = SimpleNamespace(
+        scheduled_new_reqs=[],
+        scheduled_cached_reqs=SimpleNamespace(req_ids=["req-1"]),
+    )
+    adapter.postprocess_scheduler_output(scheduler_output)
+    assert not running_req.is_finished()  # sanity: not done
+
+    # No competition for the slot; req-1 must stay schedulable.
+    adapter.process_pending_chunks(waiting_queue, running_queue)
+
+    assert running_queue == [running_req], "req-1 must still be schedulable -- losing it here is #5349"
+    assert not adapter.waiting_for_chunk_running_requests
+    assert running_req not in adapter._held_non_active
+    assert list(adapter._active_streams) == ["req-1"]
+
+
+def test_cleanup_receiver_releases_multiple_slots_in_sequence(build_adapter):
+    """Companion to test_fifo_promotion: after EACH of the K active streams
+    finishes (not just one), promotion of a new K-sized batch must still
+    work -- the window must not stay exhausted by stale entries. See
+    test_omni_ar_scheduler_free_request_cleanup.py for the scheduler-level
+    proof that ordinary completion calls cleanup_receiver().
+    """
+    adapter, _ = build_adapter(stage_id=1, model_mode="generation", max_num_seqs=2, active_stream_window=2)
+    reqs = [_req(f"req-{idx}", RequestStatus.WAITING) for idx in range(1, 5)]
+    waiting_queue = DummyWaitingQueue(reqs)
+    running_queue = []
+
+    adapter.process_pending_chunks(waiting_queue, running_queue)
+    assert list(adapter._active_streams) == ["req-1", "req-2"]
+
+    adapter.cleanup_receiver("req-1")
+    adapter.cleanup_receiver("req-2")
+    # Eviction is deferred to postprocess_scheduler_output in the runtime
+    # path; simulate the restore step so promotion can pick up the freed
+    # slots (see test_fifo_promotion).
+    adapter.restore_queues(waiting_queue, running_queue)
+    adapter.process_pending_chunks(waiting_queue, running_queue)
+
+    assert list(adapter._active_streams) == ["req-3", "req-4"], (
+        "both freed slots must be reusable after ordinary completion"
+    )
+
+
 # ---------------------------------------------------------------
 # Cleanup tests
 # ---------------------------------------------------------------
@@ -496,7 +858,7 @@ def test_postprocess_scheduler_output(build_adapter):
 
 def _populate_adapter_state(adapter, req_id="req-1", ext_id="ext-1"):
     """Fill every per-request structure so cleanup can be verified."""
-    adapter.finished_requests.add(req_id)
+    adapter.upstream_exhausted_requests.add(req_id)
     adapter._active_streams[req_id] = SimpleNamespace(request_id=req_id)
     adapter.get_req_chunk[req_id] = 3
     adapter.requests_with_ready_chunks.add(req_id)
@@ -517,7 +879,7 @@ def test_cleanup_clears_all_state(build_adapter):
 
     adapter.cleanup(req_id, ext_id)
 
-    assert req_id not in adapter.finished_requests
+    assert req_id not in adapter.upstream_exhausted_requests
     assert req_id not in adapter._active_streams
     assert req_id not in adapter.get_req_chunk
     assert req_id not in adapter.requests_with_ready_chunks
@@ -570,7 +932,7 @@ def test_cleanup_request_id_reuse_not_polluted(build_adapter):
 
     adapter.cleanup(req_id, ext_id)
 
-    assert req_id not in adapter.finished_requests
+    assert req_id not in adapter.upstream_exhausted_requests
     assert req_id not in adapter.get_req_chunk
 
 
@@ -596,7 +958,7 @@ def test_cleanup_only_affects_target_request(build_adapter):
 
     adapter.cleanup("req-a", "ext-a")
 
-    assert "req-b" in adapter.finished_requests
+    assert "req-b" in adapter.upstream_exhausted_requests
     assert "req-b" in adapter.get_req_chunk
     assert "ext-b" in adapter.put_req_chunk
     assert "ext-b" in adapter.request_payload
@@ -619,13 +981,13 @@ def test_cleanup_after_poll_flow(build_adapter):
     connector.get.return_value = (payload, 8)
     adapter._poll_single_request(request)
 
-    assert "req-flow" in adapter.finished_requests
+    assert "req-flow" in adapter.upstream_exhausted_requests
     assert adapter.get_req_chunk["req-flow"] == 1
     assert "req-flow" in adapter.request_ids_mapping
 
     adapter.cleanup("req-flow", "ext-flow")
 
-    assert "req-flow" not in adapter.finished_requests
+    assert "req-flow" not in adapter.upstream_exhausted_requests
     assert "req-flow" not in adapter.get_req_chunk
     assert "req-flow" not in adapter.request_ids_mapping
     assert "ext-flow" not in adapter.request_payload
@@ -659,7 +1021,7 @@ def test_finish_requests_removes_zombies_from_chunk_waiting_deques(build_adapter
     adapter.waiting_for_chunk_waiting_requests = deque([zombie, other])
     adapter.waiting_for_chunk_running_requests = deque([other, zombie])
     adapter.requests_with_ready_chunks.add("req-zombie")
-    adapter.finished_requests.add("req-zombie")
+    adapter.upstream_exhausted_requests.add("req-zombie")
     requests_map = {
         "req-zombie": zombie,
         "req-live": other,
@@ -674,7 +1036,29 @@ def test_finish_requests_removes_zombies_from_chunk_waiting_deques(build_adapter
     assert [req.request_id for req in adapter.waiting_for_chunk_waiting_requests] == ["req-live"]
     assert [req.request_id for req in adapter.waiting_for_chunk_running_requests] == ["req-live"]
     assert "req-zombie" not in adapter.requests_with_ready_chunks
-    assert "req-zombie" not in adapter.finished_requests
+    assert "req-zombie" not in adapter.upstream_exhausted_requests
+
+
+def test_finish_requests_releases_active_stream_slot(build_adapter):
+    adapter, _ = build_adapter(stage_id=1, max_num_seqs=1, active_stream_window=1)
+    aborted = _req("req-aborted", RequestStatus.RUNNING)
+    waiting = _req("req-waiting", RequestStatus.WAITING)
+    waiting_queue = DummyWaitingQueue([waiting])
+    running_queue = []
+    adapter._active_streams[aborted.request_id] = aborted
+    adapter._held_non_active.append(aborted)
+
+    adapter.finish_requests(
+        [aborted.request_id],
+        RequestStatus.FINISHED_ABORTED,
+        {aborted.request_id: aborted},
+    )
+    adapter.process_pending_chunks(waiting_queue, running_queue)
+
+    assert aborted.request_id not in adapter._active_streams
+    assert [request.request_id for request in adapter._held_non_active] == []
+    assert list(adapter._active_streams) == [waiting.request_id]
+    assert waiting.status == RequestStatus.WAITING_FOR_CHUNK
 
 
 def test_restore_queues_skips_requests_missing_from_scheduler_requests(build_adapter):
@@ -706,6 +1090,10 @@ def test_restore_queues_skips_requests_missing_from_scheduler_requests(build_ada
 class _HashableRequest(SimpleNamespace):
     """SimpleNamespace that can be added to a set (needed by scheduler internals)."""
 
+    # vLLM 0.26: update_from_output settles this counter for every scheduled
+    # request; real Requests initialise it to 0 (vllm/v1/request.py).
+    num_in_flight_tokens = 0
+
     def __hash__(self):
         return hash(self.request_id)
 
@@ -718,7 +1106,7 @@ def test_generation_scheduler_calls_cleanup_on_finished(monkeypatch, mocker: Moc
     cleanup_calls = []
 
     adapter_mock = mocker.MagicMock()
-    adapter_mock.finished_requests = {"req-s1"}
+    adapter_mock.upstream_exhausted_requests = {"req-s1"}
     adapter_mock.cleanup = lambda *a, **kw: cleanup_calls.append((a, kw))
 
     from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
@@ -759,7 +1147,7 @@ def test_generation_scheduler_calls_cleanup_on_finished(monkeypatch, mocker: Moc
     scheduler.requests = {"req-s1": request}
 
     scheduler._handle_stopped_request = mocker.MagicMock(return_value=True)
-    scheduler._free_request = mocker.MagicMock(return_value=None)
+    scheduler._free_request = mocker.MagicMock(return_value=(None, None))
     scheduler._get_routed_experts = mocker.MagicMock(return_value=None)
     scheduler.running = [request]
     scheduler.waiting = mocker.MagicMock()
@@ -844,7 +1232,7 @@ def test_ar_scheduler_defers_cleanup_and_queues_save_on_finished(mocker: MockerF
     scheduler._update_request_with_output = mocker.MagicMock(return_value=([], True))
     scheduler._process_kv_transfer_trigger = mocker.MagicMock(return_value=False)
     scheduler._handle_stopped_request = mocker.MagicMock(return_value=True)
-    scheduler._free_request = mocker.MagicMock(return_value=None)
+    scheduler._free_request = mocker.MagicMock(return_value=(None, None))
     scheduler._get_routed_experts = mocker.MagicMock(return_value=None)
     scheduler.running = [request]
     scheduler.waiting = mocker.MagicMock()
@@ -954,7 +1342,7 @@ def test_wire_round_trip_struct_to_dict_contract():
 def _build_deferred_finish_scheduler(mocker, *, running, pending_finish_reqs):
     """Build a mock scheduler with requests queued for deferred finish."""
     adapter_mock = mocker.MagicMock()
-    adapter_mock.finished_requests = {r.request_id for r in pending_finish_reqs}
+    adapter_mock.upstream_exhausted_requests = {r.request_id for r in pending_finish_reqs}
     cleanup_calls = []
     adapter_mock.cleanup = lambda *a, **kw: cleanup_calls.append((a, kw))
 
@@ -973,7 +1361,7 @@ def _build_deferred_finish_scheduler(mocker, *, running, pending_finish_reqs):
     scheduler._pending_finish_reqs = list(pending_finish_reqs)
 
     scheduler._handle_stopped_request = mocker.MagicMock(return_value=True)
-    scheduler._free_request = mocker.MagicMock(return_value=None)
+    scheduler._free_request = mocker.MagicMock(return_value=(None, None))
     scheduler._get_routed_experts = mocker.MagicMock(return_value=None)
     scheduler.running = list(running)
     scheduler.waiting = mocker.MagicMock()
@@ -1029,7 +1417,7 @@ def test_deferred_finish_emits_finished_output(mocker: MockerFixture):
         running=[request],
         pending_finish_reqs=[request],
     )
-    scheduler._free_request.return_value = {"mock": "kv_params"}
+    scheduler._free_request.return_value = ({"mock": "kv_params"}, None)
 
     result = OmniGenerationScheduler.update_from_output(scheduler, sched_out, model_out)
 
diff --git a/tests/distributed/omni_connectors/test_kv_flow.py b/tests/distributed/omni_connectors/test_kv_flow.py
index 83206fefb..b738c095e 100644
--- a/tests/distributed/omni_connectors/test_kv_flow.py
+++ b/tests/distributed/omni_connectors/test_kv_flow.py
@@ -330,6 +330,31 @@ def test_normalize_layer_kv_rejects_invalid_inputs(kv_config, common_constants,
     assert normalized is None
 
 
+def test_normalize_layer_kv_unpacks_packed_layout(common_constants):
+    """The vLLM >= 0.23 packed layout (num_blocks, n_heads, block_size,
+    2*head_dim) is unpacked into (num_blocks, block_size, n_heads, head_dim)
+    key/value blocks when block_size is provided."""
+    block_size = common_constants["block_size"]
+    num_heads = common_constants["num_heads"]
+    head_dim = common_constants["head_dim"]
+    req_id = common_constants["req_id"]
+    num_blocks = 10
+
+    layer_kv = torch.randn(num_blocks, num_heads, block_size, 2 * head_dim)
+
+    # Without block_size the 4-D packed layout is not recognized.
+    assert normalize_layer_kv(layer_kv, req_id=req_id, layer_idx=0) is None
+
+    normalized = normalize_layer_kv(layer_kv, req_id=req_id, layer_idx=0, block_size=block_size)
+    assert normalized is not None
+    key_blocks, value_blocks = normalized
+    assert key_blocks.shape == (num_blocks, block_size, num_heads, head_dim)
+    assert value_blocks.shape == (num_blocks, block_size, num_heads, head_dim)
+    reference = layer_kv.transpose(1, 2)
+    assert torch.equal(key_blocks, reference[..., :head_dim])
+    assert torch.equal(value_blocks, reference[..., head_dim:])
+
+
 def test_manager_reception(kv_config, mock_connector, common_constants):
     """Test reception and injection logic in OmniKVTransferManager."""
     num_layers = common_constants["num_layers"]
diff --git a/tests/distributed/omni_connectors/test_kv_recv_tp_consensus.py b/tests/distributed/omni_connectors/test_kv_recv_tp_consensus.py
new file mode 100644
index 000000000..a7e4b8562
--- /dev/null
+++ b/tests/distributed/omni_connectors/test_kv_recv_tp_consensus.py
@@ -0,0 +1,257 @@
+"""Pure-TP KV receive consensus (#5627) — CPU-testable mechanism.
+
+In pure TP (LOCAL role) each rank fetches its own KV shard independently and
+``distribute_kv_cache`` is a no-op, so one rank's silent receive timeout used
+to send only that rank into the pipeline's no-KV prefill — desyncing TP
+collectives until the NCCL watchdog killed the worker. These tests cover the
+identical-state verdict exchange: skip guards, both rank roles, KV dropping
+on any cross-rank divergence (primary or CFG companion roles), that the
+exchange runs on the TP group and never on ``world`` (which also holds DP/PP
+ranks working on other requests), and the wiring from both distributed-receive
+entry points.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.diffusion.request import DUMMY_DIFFUSION_REQUEST_ID
+from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+    OmniKVCacheConfig,
+    OmniKVTransferManager,
+    ReceiveRole,
+    _TransferTopoConfig,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeGroup:
+    """Scripted stand-in for one rank's view of a GroupCoordinator."""
+
+    def __init__(self, rank_in_group, world_size, peer_signatures=None, verdict=None):
+        self.rank_in_group = rank_in_group
+        self.world_size = world_size
+        self._peer_signatures = list(peer_signatures or [])
+        self._verdict = verdict
+        self.sent = []
+        self.broadcasts = []
+
+    def recv_object(self, src):
+        return self._peer_signatures.pop(0)
+
+    def send_object(self, obj, dst):
+        self.sent.append((obj, dst))
+
+    def broadcast_object(self, obj=None, src=0):
+        self.broadcasts.append(obj)
+        return obj if obj is not None else self._verdict
+
+    @property
+    def touched(self):
+        return bool(self.sent or self.broadcasts)
+
+
+def _topo(role=ReceiveRole.LOCAL, tp_active=True, tp_group=None, world=None):
+    tp_size = tp_group.world_size if tp_group is not None else 1
+    return _TransferTopoConfig(
+        role=role,
+        tp_active=tp_active,
+        cfg_size=1,
+        cfg_rank=0,
+        cfg_group=None,
+        sp_size=1,
+        sp_rank=0,
+        sp_group=None,
+        world=world,
+        tp_group=tp_group,
+        tp_size=tp_size,
+    )
+
+
+def _manager(topo, need_recv_cache=True):
+    mgr = OmniKVTransferManager(OmniKVCacheConfig(need_recv_cache=need_recv_cache))
+    mgr._topo_config = topo
+    return mgr
+
+
+def _req_with_kv(rid="r1", cfg_text=False):
+    kv = SimpleNamespace(key_cache=[], value_cache=[])
+    sp = SimpleNamespace(past_key_values=kv, kv_metadata={"ropes": [3]})
+    if cfg_text:
+        sp.cfg_text_past_key_values = SimpleNamespace(key_cache=[], value_cache=[])
+    return SimpleNamespace(
+        request_id=rid,
+        past_key_values=kv,
+        kv_metadata={"ropes": [3]},
+        sampling_params=sp,
+    )
+
+
+def _signature_of(req, received=True):
+    return (received, tuple(sorted(OmniKVTransferManager._collect_request_kv_payload(req))))
+
+
+# --------------------------------------------------------------------------- #
+#  Skip guards — no exchange may happen (a one-sided exchange would deadlock)
+# --------------------------------------------------------------------------- #
+
+
+def test_pass_through_outside_pure_tp():
+    group = _FakeGroup(0, 2, peer_signatures=[(False, ())])
+    for topo in (
+        _topo(role=ReceiveRole.LEADER, tp_active=True, tp_group=group),
+        _topo(role=ReceiveRole.LOCAL, tp_active=False, tp_group=group),
+        _topo(role=ReceiveRole.LOCAL, tp_active=True, tp_group=None),
+    ):
+        mgr = _manager(topo)
+        assert mgr._tp_local_receive_consensus(_req_with_kv(), True) is True
+        assert not group.touched
+
+
+def test_pass_through_single_rank_group_no_recv_config_and_dummy():
+    group = _FakeGroup(0, 1)
+    assert _manager(_topo(tp_group=group))._tp_local_receive_consensus(_req_with_kv(), True) is True
+
+    group2 = _FakeGroup(0, 2, peer_signatures=[(False, ())])
+    mgr = _manager(_topo(tp_group=group2), need_recv_cache=False)
+    assert mgr._tp_local_receive_consensus(_req_with_kv(), True) is True
+
+    mgr3 = _manager(_topo(tp_group=group2))
+    dummy = _req_with_kv(rid=DUMMY_DIFFUSION_REQUEST_ID)
+    assert mgr3._tp_local_receive_consensus(dummy, False) is False
+    assert not group2.touched
+
+
+def test_world_group_is_never_used_for_the_exchange():
+    """DP replicas / PP stages live in ``world`` and work on other requests —
+    the exchange must be scoped to the TP group (review #5636, P1)."""
+    tp_group = _FakeGroup(0, 2, peer_signatures=[(True, ())])
+    world = _FakeGroup(0, 4, peer_signatures=[(False, ()), (False, ()), (False, ())])
+    mgr = _manager(_topo(tp_group=tp_group, world=world))
+    req = SimpleNamespace(request_id="r1", sampling_params=SimpleNamespace())
+
+    assert mgr._tp_local_receive_consensus(req, True) is True
+    assert tp_group.touched
+    assert not world.touched
+
+
+# --------------------------------------------------------------------------- #
+#  Rank 0: collects signatures, decides, broadcasts
+# --------------------------------------------------------------------------- #
+
+
+def test_rank0_drops_kv_when_peer_missed_primary():
+    req = _req_with_kv()
+    peer_sig = (False, ())
+    group = _FakeGroup(0, 2, peer_signatures=[peer_sig])
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is False
+    assert group.broadcasts == [False]  # peers were told to fall back too
+    assert req.past_key_values is None
+    assert req.kv_metadata is None
+    assert req.sampling_params.past_key_values is None
+    assert req.sampling_params.kv_metadata is None
+
+
+def test_rank0_keeps_kv_when_all_ranks_match():
+    req = _req_with_kv()
+    group = _FakeGroup(0, 2, peer_signatures=[_signature_of(req)])
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is True
+    assert group.broadcasts == [True]
+    assert req.past_key_values is not None
+    assert req.sampling_params.past_key_values is not None
+
+
+def test_rank0_drops_kv_on_companion_role_divergence():
+    """Primary received everywhere but cfg_text only landed on this rank —
+    divergent branch caches would desync TP collectives (review #5636, P1)."""
+    req = _req_with_kv(cfg_text=True)
+    peer_sig = _signature_of(_req_with_kv(cfg_text=False))  # peer lacks cfg_text
+    group = _FakeGroup(0, 2, peer_signatures=[peer_sig])
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is False
+    assert group.broadcasts == [False]
+    assert req.past_key_values is None
+    assert req.sampling_params.cfg_text_past_key_values is None
+
+
+def test_rank0_keeps_symmetric_partial_state():
+    """cfg_text absent on every rank is consistent — Bagel's empty
+    unconditional branch — and must NOT be cleared or failed."""
+    req = _req_with_kv(cfg_text=False)
+    group = _FakeGroup(0, 2, peer_signatures=[_signature_of(req)])
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is True
+    assert req.past_key_values is not None
+
+
+def test_rank0_own_miss_fails_verdict_even_if_peers_received():
+    req = SimpleNamespace(request_id="r1", sampling_params=SimpleNamespace())
+    group = _FakeGroup(0, 3, peer_signatures=[(True, ("past_key_values",)), (True, ("past_key_values",))])
+    mgr = _manager(_topo(tp_group=group))
+    assert mgr._tp_local_receive_consensus(req, False) is False
+    assert group.broadcasts == [False]
+
+
+# --------------------------------------------------------------------------- #
+#  Rank > 0: reports signature, honors verdict
+# --------------------------------------------------------------------------- #
+
+
+def test_follower_rank_drops_kv_on_negative_verdict():
+    req = _req_with_kv()
+    sig_before_clear = _signature_of(req)
+    group = _FakeGroup(1, 2, verdict=False)
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is False
+    assert group.sent == [(sig_before_clear, 0)]
+    assert req.past_key_values is None
+    assert req.sampling_params.past_key_values is None
+
+
+def test_follower_rank_keeps_kv_on_positive_verdict():
+    req = _req_with_kv()
+    group = _FakeGroup(1, 2, verdict=True)
+    mgr = _manager(_topo(tp_group=group))
+
+    assert mgr._tp_local_receive_consensus(req, True) is True
+    assert group.sent == [(_signature_of(req), 0)]
+    assert req.past_key_values is not None
+
+
+# --------------------------------------------------------------------------- #
+#  Wiring — both distributed-receive entry points run the consensus
+# --------------------------------------------------------------------------- #
+
+
+def _wired_manager(monkeypatch, consensus_calls):
+    mgr = _manager(_topo(tp_group=_FakeGroup(0, 2)))
+
+    def fake_consensus(req, received):
+        consensus_calls.append(received)
+        return False
+
+    monkeypatch.setattr(mgr, "_tp_local_receive_consensus", fake_consensus)
+    monkeypatch.setattr(mgr, "receive_multi_kv_cache", lambda *a, **k: True)
+    return mgr
+
+
+def test_receive_multi_kv_cache_distributed_runs_consensus(monkeypatch):
+    calls = []
+    mgr = _wired_manager(monkeypatch, calls)
+    assert mgr.receive_multi_kv_cache_distributed(_req_with_kv()) is False
+    assert calls == [True]
+
+
+def test_consume_and_distribute_kv_cache_runs_consensus(monkeypatch):
+    calls = []
+    mgr = _wired_manager(monkeypatch, calls)
+    assert mgr.consume_and_distribute_kv_cache(_req_with_kv()) is False
+    assert calls == [True]
diff --git a/tests/distributed/omni_connectors/test_omni_connector_configs.py b/tests/distributed/omni_connectors/test_omni_connector_configs.py
index 3dc80b57b..6048de40a 100644
--- a/tests/distributed/omni_connectors/test_omni_connector_configs.py
+++ b/tests/distributed/omni_connectors/test_omni_connector_configs.py
@@ -2,10 +2,15 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
 from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 
 # Use the new import path for initialization utilities
+from vllm_omni.distributed.omni_connectors.utils.config import (
+    stage_receives_chunks,
+    stage_sends_async_output,
+)
 from vllm_omni.distributed.omni_connectors.utils.initialization import load_omni_transfer_config
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -38,6 +43,26 @@ def get_config_files():
 config_files = get_config_files()
 
 
+@pytest.mark.parametrize(
+    ("role", "stage_id", "receives", "sends"),
+    [
+        ("sender", 0, False, True),
+        ("receiver", 1, True, False),
+        (None, 0, True, False),
+        (None, None, True, True),
+    ],
+)
+def test_stage_chunk_direction_helpers(role, stage_id, receives, sends):
+    extra = {} if role is None else {"role": role}
+    model_config = SimpleNamespace(
+        stage_id=stage_id,
+        stage_connector_config={"extra": extra},
+    )
+
+    assert stage_receives_chunks(model_config) is receives
+    assert stage_sends_async_output(model_config) is sends
+
+
 @pytest.mark.skipif(len(config_files) == 0, reason="No config files found or directory missing")
 @pytest.mark.parametrize("yaml_file", config_files, ids=lambda p: p.name)
 def test_load_qwen_yaml_configs(yaml_file):
@@ -48,7 +73,6 @@ def test_load_qwen_yaml_configs(yaml_file):
     print(f"Testing config load: {yaml_file.name}")
     try:
         # Attempt to load the config
-        # default_shm_threshold doesn't matter much for loading correctness, using default
         config = load_omni_transfer_config(yaml_file)
 
         assert config is not None, "Config should not be None"
diff --git a/tests/distributed/omni_connectors/test_shm_connector.py b/tests/distributed/omni_connectors/test_shm_connector.py
index 572376aef..bba6002a0 100644
--- a/tests/distributed/omni_connectors/test_shm_connector.py
+++ b/tests/distributed/omni_connectors/test_shm_connector.py
@@ -2,7 +2,10 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Unit tests for SharedMemoryConnector focusing on TP / CFG / metadata fallback."""
 
+import os
+
 import pytest
+import torch
 
 from vllm_omni.distributed.omni_connectors.connectors.shm_connector import (
     SharedMemoryConnector,
@@ -13,7 +16,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 @pytest.fixture()
 def connector():
-    c = SharedMemoryConnector({"shm_threshold_bytes": 0})
+    c = SharedMemoryConnector({})
     yield c
     c.close()
 
@@ -36,6 +39,30 @@ class TestKeyBasedReadWrite:
         assert obj == data
         assert rsize == size
         assert "test_key_1" not in connector._pending_keys
+        assert connector._metrics["gets"] == 1
+
+    def test_tensor_payload_removes_lock_file(self, connector):
+        key = "tensor_payload"
+        payload = torch.ones(2, 2)
+        ok, _, metadata = connector.put("s0", "s1", key, payload)
+        assert ok
+
+        result = connector.get("s0", "s1", key, metadata=metadata)
+
+        assert result is not None
+        assert torch.equal(result[0], payload)
+        assert not os.path.exists(f"/dev/shm/shm_{key}_lockfile.lock")
+
+    def test_falsey_payload_removes_lock_file(self, connector):
+        key = "falsey_payload"
+        ok, _, metadata = connector.put("s0", "s1", key, 0)
+        assert ok
+
+        result = connector.get("s0", "s1", key, metadata=metadata)
+
+        assert result is not None
+        assert result[0] == 0
+        assert not os.path.exists(f"/dev/shm/shm_{key}_lockfile.lock")
 
     def test_get_nonexistent_key_returns_none(self, connector):
         result = connector.get("s0", "s1", "no_such_key_xyz", metadata=None)
diff --git a/tests/distributed/omni_connectors/test_tp_rank_aware.py b/tests/distributed/omni_connectors/test_tp_rank_aware.py
index 261de0b32..3fdc4820a 100644
--- a/tests/distributed/omni_connectors/test_tp_rank_aware.py
+++ b/tests/distributed/omni_connectors/test_tp_rank_aware.py
@@ -682,6 +682,10 @@ class TestDistributedReceive:
         mgr = _make_manager(from_tp=2, to_tp=2, local_rank=1)
         req = SimpleNamespace(request_id="req-1", sampling_params=SimpleNamespace())
         world_group = _MockBroadcastGroup(world_size=2, rank_in_group=1)
+        # broadcast_value=True: rank 0's verdict says every TP rank has the
+        # same KV state, so the per-rank receive result stands (see #5627
+        # consensus). The exchange runs on the TP group, not world.
+        tp_group = _MockBroadcastGroup(world_size=2, rank_in_group=1, broadcast_value=True)
         mgr.receive_multi_kv_cache = MagicMock(return_value=True)
 
         with (
@@ -704,10 +708,19 @@ class TestDistributedReceive:
                 return_value=0,
             ),
             patch("vllm_omni.diffusion.distributed.parallel_state.get_sp_group", return_value=None),
+            patch("vllm.distributed.parallel_state.get_tp_group", return_value=tp_group),
         ):
             assert mgr.receive_multi_kv_cache_distributed(req, target_device=torch.device("cpu")) is True
 
         mgr.receive_multi_kv_cache.assert_called_once_with(req, None, torch.device("cpu"))
+        # Pure TP still fetches per-rank (no leader→follower distribution),
+        # but each rank now reports its KV-state signature on the TP group
+        # for the identical-state verdict instead of silently diverging on a
+        # miss (#5627). World must stay untouched — it holds DP/PP ranks.
+        assert len(tp_group.send_calls) == 1
+        dst, sig = tp_group.send_calls[0]
+        assert dst == 0 and sig[0] is True
+        assert world_group.send_calls == []
 
     # ── SP-only scenarios ────────────────────────────────────────────
 
diff --git a/tests/docs/test_generate_examples.py b/tests/docs/test_generate_examples.py
index 0b29837a9..57d7d4832 100644
--- a/tests/docs/test_generate_examples.py
+++ b/tests/docs/test_generate_examples.py
@@ -6,6 +6,9 @@ from pathlib import Path
 
 import pytest
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 ROOT_DIR = Path(__file__).parents[2]
 HOOK_PATH = ROOT_DIR / "docs/mkdocs/hooks/generate_examples.py"
 SPEC = importlib.util.spec_from_file_location("generate_examples", HOOK_PATH)
diff --git a/tests/dreamzero/openpi_client_helper.py b/tests/dreamzero/openpi_client_helper.py
deleted file mode 100644
index 8918e5c36..000000000
--- a/tests/dreamzero/openpi_client_helper.py
+++ /dev/null
@@ -1,307 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from __future__ import annotations
-
-import uuid
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-
-try:
-    import cv2
-except ImportError:  # pragma: no cover - optional e2e dependency
-    cv2 = None
-
-try:
-    import websockets.sync.client as websockets_client
-except ImportError:  # pragma: no cover - optional e2e dependency
-    websockets_client = None
-
-try:
-    from openpi_client import msgpack_numpy
-except ImportError:  # pragma: no cover - optional e2e dependency
-    msgpack_numpy = None
-
-PING_INTERVAL_SECS = 300
-PING_TIMEOUT_SECS = 3600
-DEFAULT_HOST = "127.0.0.1"
-DEFAULT_PORT = 8000
-DEFAULT_PATH = "/v1/realtime/robot/openpi"
-DEFAULT_PROMPT = "Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan"
-ACTION_HORIZON = 24
-DEFAULT_ACTION_DIM = 8
-RELATIVE_OFFSETS = [-23, -16, -8, 0]
-CAMERA_FILES = {
-    "observation/exterior_image_0_left": "exterior_image_1_left.mp4",
-    "observation/exterior_image_1_left": "exterior_image_2_left.mp4",
-    "observation/wrist_image_left": "wrist_image_left.mp4",
-}
-
-
-def _decode_action_response(response: bytes | str) -> np.ndarray:
-    if isinstance(response, str):
-        raise RuntimeError(f"Inference failed: {response}")
-    decoded = msgpack_numpy.unpackb(response)
-    if isinstance(decoded, dict) and decoded.get("type") == "error":
-        message = decoded.get("message", decoded)
-        raise RuntimeError(f"Inference failed: {message}")
-    return np.asarray(decoded, dtype=np.float32)
-
-
-def require_dependencies() -> None:
-    missing = []
-    if cv2 is None:
-        missing.append("opencv-python")
-    if websockets_client is None:
-        missing.append("websockets")
-    if msgpack_numpy is None:
-        missing.append("openpi-client")
-    if missing:
-        raise ModuleNotFoundError(f"DreamZero OpenPI test dependencies are missing: {', '.join(missing)}")
-
-
-@dataclass(frozen=True)
-class DreamZeroServerMetadata:
-    image_resolution: tuple[int, int]
-    n_external_cameras: int
-    needs_wrist_camera: bool
-    needs_stereo_camera: bool
-    needs_session_id: bool
-    action_space: str
-
-    @classmethod
-    def from_dict(cls, payload: dict[str, Any]) -> DreamZeroServerMetadata:
-        required_keys = (
-            "image_resolution",
-            "n_external_cameras",
-            "needs_wrist_camera",
-            "needs_stereo_camera",
-            "needs_session_id",
-            "action_space",
-        )
-        missing_keys = [key for key in required_keys if key not in payload]
-        if missing_keys:
-            raise ValueError(f"Missing DreamZero metadata keys: {missing_keys}")
-
-        image_resolution = payload["image_resolution"]
-        if not isinstance(image_resolution, (list, tuple)) or len(image_resolution) != 2:
-            raise ValueError(f"Invalid image_resolution: {image_resolution!r}")
-
-        return cls(
-            image_resolution=(int(image_resolution[0]), int(image_resolution[1])),
-            n_external_cameras=int(payload["n_external_cameras"]),
-            needs_wrist_camera=bool(payload["needs_wrist_camera"]),
-            needs_stereo_camera=bool(payload["needs_stereo_camera"]),
-            needs_session_id=bool(payload["needs_session_id"]),
-            action_space=str(payload["action_space"]),
-        )
-
-
-class OpenPIWebsocketClient:
-    def __init__(
-        self,
-        *,
-        host: str = DEFAULT_HOST,
-        port: int = DEFAULT_PORT,
-        path: str = DEFAULT_PATH,
-    ) -> None:
-        require_dependencies()
-        self._uri = f"ws://{host}:{port}{path}"
-        self._packer = msgpack_numpy.Packer()
-        self._ws, self._server_metadata = self._connect()
-
-    def _connect(self):
-        conn = websockets_client.connect(
-            self._uri,
-            compression=None,
-            max_size=None,
-            ping_interval=PING_INTERVAL_SECS,
-            ping_timeout=PING_TIMEOUT_SECS,
-        )
-        metadata = msgpack_numpy.unpackb(conn.recv())
-        if not isinstance(metadata, dict):
-            raise TypeError(f"Expected dict metadata from server, got {type(metadata)!r}")
-        return conn, metadata
-
-    def get_server_metadata(self) -> dict[str, Any]:
-        return dict(self._server_metadata)
-
-    def infer(self, obs: dict[str, Any]) -> np.ndarray:
-        payload = dict(obs)
-        payload["endpoint"] = "infer"
-        self._ws.send(self._packer.pack(payload))
-        response = self._ws.recv()
-        return _decode_action_response(response)
-
-    def reset(self, reset_info: dict[str, Any] | None = None) -> str:
-        payload = dict(reset_info or {})
-        payload["endpoint"] = "reset"
-        self._ws.send(self._packer.pack(payload))
-        response = self._ws.recv()
-        if isinstance(response, str):
-            return response
-        decoded = msgpack_numpy.unpackb(response)
-        if not isinstance(decoded, dict) or decoded.get("status") != "reset successful":
-            raise RuntimeError(f"Unexpected reset response: {decoded!r}")
-        return str(decoded["status"])
-
-    def close(self) -> None:
-        self._ws.close()
-
-
-def load_all_frames(video_path: Path) -> np.ndarray:
-    require_dependencies()
-    cap = cv2.VideoCapture(str(video_path))
-    frames = []
-    while True:
-        ok, frame = cap.read()
-        if not ok:
-            break
-        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-    cap.release()
-    if not frames:
-        raise RuntimeError(f"No frames loaded from {video_path}")
-    return np.stack(frames, axis=0)
-
-
-def load_camera_frames(video_dir: Path) -> dict[str, np.ndarray]:
-    camera_frames: dict[str, np.ndarray] = {}
-    for camera_key, file_name in CAMERA_FILES.items():
-        video_path = video_dir / file_name
-        if not video_path.exists():
-            raise FileNotFoundError(f"Missing DreamZero test asset: {video_path}")
-        camera_frames[camera_key] = load_all_frames(video_path)
-    return camera_frames
-
-
-def build_frame_schedule(total_frames: int, num_chunks: int) -> list[list[int]]:
-    chunks: list[list[int]] = []
-    current_frame = 23
-    for _ in range(num_chunks):
-        indices = [max(current_frame + offset, 0) for offset in RELATIVE_OFFSETS]
-        if indices[-1] >= total_frames:
-            break
-        chunks.append(indices)
-        current_frame += ACTION_HORIZON
-    return chunks
-
-
-def make_obs_from_video(
-    camera_frames: dict[str, np.ndarray],
-    frame_indices: list[int],
-    *,
-    prompt: str,
-    session_id: str,
-) -> dict[str, Any]:
-    obs: dict[str, Any] = {}
-    for camera_key, all_frames in camera_frames.items():
-        selected = all_frames[frame_indices]
-        obs[camera_key] = selected[0] if len(frame_indices) == 1 else selected
-
-    obs["observation/joint_position"] = np.zeros(7, dtype=np.float32)
-    obs["observation/cartesian_position"] = np.zeros(6, dtype=np.float32)
-    obs["observation/gripper_position"] = np.zeros(1, dtype=np.float32)
-    obs["prompt"] = prompt
-    obs["session_id"] = session_id
-    return obs
-
-
-def build_demo_observations(
-    camera_frames: dict[str, np.ndarray],
-    *,
-    prompt: str,
-    session_id: str,
-    num_chunks: int = 2,
-) -> list[dict[str, Any]]:
-    if num_chunks < 1:
-        raise ValueError("num_chunks must be at least 1")
-
-    total_frames = min(frames.shape[0] for frames in camera_frames.values())
-    observations = [
-        make_obs_from_video(
-            camera_frames,
-            [0],
-            prompt=prompt,
-            session_id=session_id,
-        )
-    ]
-    for indices in build_frame_schedule(total_frames, num_chunks - 1):
-        observations.append(
-            make_obs_from_video(
-                camera_frames,
-                indices,
-                prompt=prompt,
-                session_id=session_id,
-            )
-        )
-    return observations
-
-
-def validate_session_result(
-    result: dict[str, Any],
-    *,
-    expected_action_horizon: int = ACTION_HORIZON,
-    expected_action_dim: int = DEFAULT_ACTION_DIM,
-) -> None:
-    metadata = DreamZeroServerMetadata.from_dict(result["metadata"])
-    if metadata.image_resolution != (180, 320):
-        raise AssertionError(f"Unexpected image_resolution: {metadata.image_resolution}")
-    if metadata.n_external_cameras != 2:
-        raise AssertionError(f"Unexpected n_external_cameras: {metadata.n_external_cameras}")
-    if not metadata.needs_wrist_camera:
-        raise AssertionError("DreamZero test expects wrist camera metadata")
-    if metadata.action_space != "joint_position":
-        raise AssertionError(f"Unexpected action_space: {metadata.action_space}")
-
-    actions = result["actions"]
-    if len(actions) != 3:
-        raise AssertionError(f"Expected 3 action tensors, got {len(actions)}")
-    for index, action in enumerate(actions):
-        if action.shape != (expected_action_horizon, expected_action_dim):
-            raise AssertionError(
-                f"Action {index} shape mismatch: expected "
-                f"{(expected_action_horizon, expected_action_dim)}, got {action.shape}"
-            )
-        if not np.isfinite(action).all():
-            raise AssertionError(f"Action {index} contains non-finite values")
-
-    if result["reset_status"] != "reset successful":
-        raise AssertionError(f"Unexpected reset status: {result['reset_status']!r}")
-
-
-def run_policy_session(
-    *,
-    host: str = DEFAULT_HOST,
-    port: int = DEFAULT_PORT,
-    path: str = DEFAULT_PATH,
-    video_dir: Path,
-    prompt: str = DEFAULT_PROMPT,
-    session_id: str | None = None,
-    num_chunks: int = 2,
-) -> dict[str, Any]:
-    session_id = session_id or str(uuid.uuid4())
-    camera_frames = load_camera_frames(video_dir)
-    observations = build_demo_observations(
-        camera_frames,
-        prompt=prompt,
-        session_id=session_id,
-        num_chunks=num_chunks,
-    )
-
-    client = OpenPIWebsocketClient(host=host, port=port, path=path)
-    try:
-        metadata = client.get_server_metadata()
-        actions = [client.infer(obs) for obs in observations]
-        reset_status = client.reset({})
-        actions.append(client.infer(observations[0]))
-        return {
-            "metadata": metadata,
-            "actions": actions,
-            "reset_status": reset_status,
-            "session_id": session_id,
-        }
-    finally:
-        client.close()
diff --git a/tests/dreamzero/test_openpi_client_helper.py b/tests/dreamzero/test_openpi_client_helper.py
deleted file mode 100644
index 76950a9ed..000000000
--- a/tests/dreamzero/test_openpi_client_helper.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import numpy as np
-import pytest
-
-from tests.dreamzero import openpi_client_helper
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class FakeMsgpackNumpy:
-    payloads = {}
-
-    @staticmethod
-    def packb(obj):
-        key = str(len(FakeMsgpackNumpy.payloads)).encode()
-        FakeMsgpackNumpy.payloads[key] = obj
-        return key
-
-    @staticmethod
-    def unpackb(data):
-        return FakeMsgpackNumpy.payloads[data]
-
-
-def test_decode_action_response_surfaces_structured_error(monkeypatch):
-    monkeypatch.setattr(openpi_client_helper, "msgpack_numpy", FakeMsgpackNumpy)
-    payload = FakeMsgpackNumpy.packb(
-        {
-            "type": "error",
-            "message": "Internal inference error",
-        }
-    )
-
-    with pytest.raises(RuntimeError, match="Internal inference error"):
-        openpi_client_helper._decode_action_response(payload)
-
-
-def test_decode_action_response_converts_action_payload_to_float32(monkeypatch):
-    monkeypatch.setattr(openpi_client_helper, "msgpack_numpy", FakeMsgpackNumpy)
-    payload = FakeMsgpackNumpy.packb(np.asarray([[1.0, 2.0]], dtype=np.float64))
-
-    actions = openpi_client_helper._decode_action_response(payload)
-
-    assert actions.dtype == np.float32
-    np.testing.assert_array_equal(actions, np.asarray([[1.0, 2.0]], dtype=np.float32))
diff --git a/tests/dreamzero/test_pipeline_state.py b/tests/dreamzero/test_pipeline_state.py
deleted file mode 100644
index f00caf53c..000000000
--- a/tests/dreamzero/test_pipeline_state.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from collections import OrderedDict
-
-import pytest
-
-from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import DreamZeroPipeline
-from vllm_omni.diffusion.models.dreamzero.state_dreamzero import DreamZeroState
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _empty_pipeline() -> DreamZeroPipeline:
-    pipeline = DreamZeroPipeline.__new__(DreamZeroPipeline)
-    pipeline._states = OrderedDict()
-    pipeline._max_session_states = 2
-    return pipeline
-
-
-def test_dreamzero_pipeline_state_is_session_keyed() -> None:
-    pipeline = _empty_pipeline()
-
-    session_a = pipeline._get_or_create_state("session-a")
-    session_b = pipeline._get_or_create_state("session-b")
-    session_a.call_count = 7
-    session_b.call_count = 3
-
-    assert pipeline._get_or_create_state("session-a") is session_a
-    assert pipeline._get_or_create_state("session-b") is session_b
-    assert session_a.call_count == 7
-    assert session_b.call_count == 3
-
-
-def test_dreamzero_pipeline_state_lru_caps_retained_sessions() -> None:
-    pipeline = _empty_pipeline()
-
-    session_a = pipeline._get_or_create_state("session-a")
-    pipeline._get_or_create_state("session-b")
-    assert pipeline._get_or_create_state("session-a") is session_a
-
-    pipeline._get_or_create_state("session-c")
-
-    assert list(pipeline._states) == ["session-a", "session-c"]
-    assert "session-b" not in pipeline._states
-
-
-def test_dreamzero_state_owns_no_kv_caches() -> None:
-    """KV (self- and cross-attention) is engine-owned since the AR-Diffusion
-    paged backend: the model-local cache accessors must be gone so nothing can
-    silently bypass the engine pool."""
-    state = DreamZeroState()
-
-    for removed in ("get_kv_caches", "create_kv_caches", "update_kv_cache", "get_crossattn_caches"):
-        assert not hasattr(state, removed)
diff --git a/tests/dreamzero/upstream/openpi_test_client_ar.py b/tests/dreamzero/upstream/openpi_test_client_ar.py
deleted file mode 100644
index 7c5aea1d9..000000000
--- a/tests/dreamzero/upstream/openpi_test_client_ar.py
+++ /dev/null
@@ -1,381 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copied from the DreamZero repository's `test_client_AR.py`:
-https://github.com/dreamzero0/dreamzero/blob/main/test_client_AR.py
-
-Kept here for end-to-end compatibility / parity testing against the vLLM
-OpenPI server.
-
-Test client for AR_droid policy server using roboarena interface.
-
-Sends real video frames from debug_image/ directory instead of zero dummy images.
-
-Frame schedule (matching debug_inference.py):
-  - Step 0 (initial): send frame [0]             (1 frame, H W 3)
-  - Step 1: send frames [0, 7, 15, 23]           (4 frames, 4 H W 3)
-  - Step 2: send frames [24, 31, 39, 47]         (4 frames)
-  - Step 3: send frames [48, 55, 63, 71]         (4 frames)
-  - ...
-
-Expected server configuration:
-    - image_resolution: (180, 320)
-    - n_external_cameras: 2
-    - needs_wrist_camera: True
-    - action_space: "joint_position"
-
-Usage:
-    # Start server with roboarena interface:
-    torchrun --nproc_per_node=8 socket_test_optimized_AR.py --port 8000
-
-    # Run against the original DreamZero websocket server (default path):
-    python test_client_AR.py --host <server_host> --port 8000
-
-    # Run against the vLLM OpenPI server:
-    python test_client_AR.py --host <server_host> --port 8000 --path /v1/realtime/robot/openpi
-
-    # Use zero images instead of real video (old behavior):
-    python test_client_AR.py --host <server_host> --port 8000 --use-zero-images
-"""
-
-import argparse
-import logging
-import os
-import sys
-import time
-import uuid
-from pathlib import Path
-
-import cv2
-import numpy as np
-from openpi_client import msgpack_numpy
-
-_DREAMZERO_REPO_ENV = os.environ.get("DREAMZERO_REPO")
-DREAMZERO_REPO = Path(_DREAMZERO_REPO_ENV).expanduser() if _DREAMZERO_REPO_ENV else None
-
-
-def _import_upstream_policy_modules():
-    if DREAMZERO_REPO is None:
-        raise ImportError("Set DREAMZERO_REPO to an upstream DreamZero checkout before using this helper.")
-    if DREAMZERO_REPO.exists() and str(DREAMZERO_REPO) not in sys.path:
-        sys.path.insert(0, str(DREAMZERO_REPO))
-
-    import eval_utils.policy_server as policy_server
-    from eval_utils.policy_client import WebsocketClientPolicy
-
-    return policy_server, WebsocketClientPolicy
-
-
-policy_server, WebsocketClientPolicy = _import_upstream_policy_modules()
-
-VIDEO_DIR = os.environ.get(
-    "DREAMZERO_VIDEO_DIR",
-    str(DREAMZERO_REPO / "debug_image") if DREAMZERO_REPO is not None else "debug_image",
-)
-
-# roboarena key -> video filename
-CAMERA_FILES = {
-    "observation/exterior_image_0_left": "exterior_image_1_left.mp4",
-    "observation/exterior_image_1_left": "exterior_image_2_left.mp4",
-    "observation/wrist_image_left": "wrist_image_left.mp4",
-}
-
-# Frame schedule constants (matching debug_inference.py)
-RELATIVE_OFFSETS = [-23, -16, -8, 0]
-ACTION_HORIZON = 24
-DEFAULT_WEBSOCKET_PATH = ""
-
-
-class OpenPIWebsocketClientPolicy(WebsocketClientPolicy):
-    """DreamZero websocket client with a configurable path suffix.
-
-    The original DreamZero client connects to ``ws://host:port``.
-    vLLM serves the compatible robot policy endpoint at
-    ``/v1/realtime/robot/openpi`` when ``path`` is set accordingly.
-    """
-
-    def __init__(
-        self,
-        host: str = "0.0.0.0",
-        port: int = 8000,
-        path: str = DEFAULT_WEBSOCKET_PATH,
-    ) -> None:
-        self._uri = f"ws://{host}:{port}{path}"
-        self._packer = msgpack_numpy.Packer()
-        self._ws, self._server_metadata = self._wait_for_server()
-
-
-def load_all_frames(video_path: str) -> np.ndarray:
-    """Load all frames from a video file. Returns (N, H, W, 3) uint8 array (RGB)."""
-    cap = cv2.VideoCapture(video_path)
-    frames = []
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-    cap.release()
-    if not frames:
-        raise RuntimeError(f"No frames loaded from {video_path}")
-    return np.stack(frames, axis=0)
-
-
-def load_camera_frames() -> dict[str, np.ndarray]:
-    """Load all video frames for each camera from the debug_image/ directory.
-
-    Returns:
-        Dict mapping roboarena camera keys to (N, H, W, 3) uint8 arrays.
-    """
-    camera_frames: dict[str, np.ndarray] = {}
-    for cam_key, fname in CAMERA_FILES.items():
-        path = os.path.join(VIDEO_DIR, fname)
-        camera_frames[cam_key] = load_all_frames(path)
-        logging.info(f"Loaded {cam_key}: {camera_frames[cam_key].shape}")
-    return camera_frames
-
-
-def build_frame_schedule(total_frames: int, num_chunks: int) -> list[list[int]]:
-    """Build the frame index schedule for multi-frame chunks.
-
-    Returns a list of frame-index lists. Each inner list has 4 indices.
-    """
-    chunks: list[list[int]] = []
-    current_frame = 23  # first anchor frame
-    for _ in range(num_chunks):
-        indices = [max(current_frame + off, 0) for off in RELATIVE_OFFSETS]
-        if indices[-1] >= total_frames:
-            logging.info(f"Frame {indices[-1]} >= {total_frames}, stopping at {len(chunks)} chunks")
-            break
-        chunks.append(indices)
-        current_frame += ACTION_HORIZON
-    return chunks
-
-
-def _make_obs_from_video(
-    camera_frames: dict[str, np.ndarray],
-    frame_indices: list[int],
-    prompt: str,
-    session_id: str,
-) -> dict:
-    """Build an observation dict from real video frames.
-
-    For 1 frame: each image key is (H, W, 3).
-    For 4 frames: each image key is (4, H, W, 3).
-    """
-    obs: dict = {}
-    for cam_key, all_frames in camera_frames.items():
-        selected = all_frames[frame_indices]  # (T, H, W, 3)
-        if len(frame_indices) == 1:
-            selected = selected[0]  # (H, W, 3)
-        obs[cam_key] = selected
-
-    obs["observation/joint_position"] = np.zeros(7, dtype=np.float32)
-    obs["observation/cartesian_position"] = np.zeros(6, dtype=np.float32)
-    obs["observation/gripper_position"] = np.zeros(1, dtype=np.float32)
-    obs["prompt"] = prompt
-    obs["session_id"] = session_id
-    return obs
-
-
-def _make_zero_observation(
-    server_config: policy_server.PolicyServerConfig,
-    prompt: str = "pick up the object",
-    session_id: str | None = None,
-) -> dict:
-    """Create a dummy observation matching AR_droid expectations.
-
-    AR_droid expects:
-        - 2 external cameras (exterior_image_0_left, exterior_image_1_left)
-        - 1 wrist camera (wrist_image_left)
-        - Image resolution: 180x320 (H x W)
-        - joint_position: 7 DoF
-        - gripper_position: 1 DoF
-    """
-    obs = {}
-
-    # Determine image resolution
-    if server_config.image_resolution is not None:
-        h, w = server_config.image_resolution
-    else:
-        # Default for AR_droid
-        h, w = 180, 320
-
-    # External cameras (0-indexed in roboarena)
-    for i in range(server_config.n_external_cameras):
-        obs[f"observation/exterior_image_{i}_left"] = np.zeros((h, w, 3), dtype=np.uint8)
-        if server_config.needs_stereo_camera:
-            obs[f"observation/exterior_image_{i}_right"] = np.zeros((h, w, 3), dtype=np.uint8)
-
-    # Wrist camera
-    if server_config.needs_wrist_camera:
-        obs["observation/wrist_image_left"] = np.zeros((h, w, 3), dtype=np.uint8)
-        if server_config.needs_stereo_camera:
-            obs["observation/wrist_image_right"] = np.zeros((h, w, 3), dtype=np.uint8)
-
-    # Session ID - should be passed in to ensure consistency within a session
-    if server_config.needs_session_id:
-        import uuid
-
-        # Generate unique session ID if not provided
-        obs["session_id"] = session_id if session_id else str(uuid.uuid4())
-
-    # State observations (AR_droid: 7 DoF arm + 1 gripper)
-    obs["observation/joint_position"] = np.zeros(7, dtype=np.float32)
-    obs["observation/cartesian_position"] = np.zeros(6, dtype=np.float32)
-    obs["observation/gripper_position"] = np.zeros(1, dtype=np.float32)
-
-    # Language prompt
-    obs["prompt"] = prompt
-
-    return obs
-
-
-def test_ar_droid_policy_server(
-    host: str = "localhost",
-    port: int = 8000,
-    path: str = DEFAULT_WEBSOCKET_PATH,
-    num_chunks: int = 15,
-    prompt: str = "Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan",
-    use_zero_images: bool = False,
-):
-    """Test the AR_droid policy server with roboarena interface.
-
-    When use_zero_images is False (default), loads real video frames from
-    debug_image/ and follows the frame schedule from debug_inference.py.
-    """
-    logging.info(f"Connecting to AR_droid server at ws://{host}:{port}{path} ...")
-
-    client = OpenPIWebsocketClientPolicy(host=host, port=port, path=path)
-
-    # Validate server metadata
-    metadata = client.get_server_metadata()
-    logging.info(f"Server metadata: {metadata}")
-    assert isinstance(metadata, dict), "Metadata should be a dict"
-
-    try:
-        server_config = policy_server.PolicyServerConfig(**metadata)
-    except Exception as e:
-        logging.error(f"Error parsing metadata: {e}")
-        raise e
-
-    # Validate expected AR_droid configuration
-    logging.info(f"Server config: {server_config}")
-    assert server_config.n_external_cameras == 2, f"Expected 2 external cameras, got {server_config.n_external_cameras}"
-    assert server_config.needs_wrist_camera, "Expected wrist camera to be enabled"
-    assert server_config.action_space == "joint_position", (
-        f"Expected joint_position action space, got {server_config.action_space}"
-    )
-
-    logging.info("Server configuration validated for AR_droid")
-
-    # Generate unique session ID for this test run
-    session_id = str(uuid.uuid4())
-    logging.info(f"Session ID: {session_id}")
-
-    # ── Zero-image fallback mode ──────────────────────────────────────
-    if use_zero_images:
-        logging.info("Using ZERO dummy images (legacy mode)")
-        for i in range(num_chunks):
-            obs = _make_zero_observation(server_config, prompt=prompt, session_id=session_id)
-            logging.info(f"Inference {i + 1}/{num_chunks}: prompt='{prompt}'")
-            t0 = time.time()
-            actions = client.infer(obs)
-            dt = time.time() - t0
-            _log_action(actions, dt)
-
-        logging.info("Sending reset...")
-        client.reset({})
-        logging.info("Done (zero-image mode).")
-        return
-
-    # ── Real video frame mode ─────────────────────────────────────────
-    logging.info("Loading real video frames from debug_image/ directory")
-    camera_frames = load_camera_frames()
-
-    total_frames = min(v.shape[0] for v in camera_frames.values())
-    logging.info(f"Total frames available: {total_frames}")
-
-    # Build frame schedule
-    chunks = build_frame_schedule(total_frames, num_chunks)
-
-    logging.info("Frame schedule:")
-    logging.info("  Initial: [0]")
-    for i, indices in enumerate(chunks):
-        logging.info(f"  Chunk {i}: {indices}")
-
-    # Step 0: initial single frame
-    logging.info("=== Initial: frame [0] ===")
-    obs = _make_obs_from_video(camera_frames, [0], prompt, session_id)
-    t0 = time.time()
-    actions = client.infer(obs)
-    dt = time.time() - t0
-    _log_action(actions, dt)
-
-    # Subsequent chunks: send 4 frames at a time
-    for chunk_idx, frame_indices in enumerate(chunks):
-        logging.info(f"=== Chunk {chunk_idx}: frames {frame_indices} ===")
-        obs = _make_obs_from_video(camera_frames, frame_indices, prompt, session_id)
-        t0 = time.time()
-        actions = client.infer(obs)
-        dt = time.time() - t0
-        _log_action(actions, dt)
-
-    # Reset triggers video save on the server
-    logging.info("Sending reset to save video...")
-    client.reset({})
-
-    logging.info("Done.")
-
-
-def _log_action(actions: np.ndarray, dt: float) -> None:
-    """Pretty-print action shape, range, and timing."""
-    assert isinstance(actions, np.ndarray), f"Expected numpy array, got {type(actions)}"
-    assert actions.ndim == 2, f"Expected 2D array, got shape {actions.shape}"
-    assert actions.shape[-1] == 8, f"Expected 8 action dims (7 joints + 1 gripper), got {actions.shape[-1]}"
-    logging.info(f"  Action shape: {actions.shape}, range: [{actions.min():.4f}, {actions.max():.4f}], time: {dt:.2f}s")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Test AR_droid policy server with real video frames from debug_image/")
-    parser.add_argument("--host", default="localhost", help="Server hostname")
-    parser.add_argument("--port", type=int, default=8000, help="Server port")
-    parser.add_argument(
-        "--path",
-        default=DEFAULT_WEBSOCKET_PATH,
-        help="WebSocket path suffix (default: empty string for the original DreamZero server)",
-    )
-    parser.add_argument(
-        "--num-chunks",
-        type=int,
-        default=15,
-        help="Number of 4-frame chunks to send after the initial frame (default: 15)",
-    )
-    parser.add_argument(
-        "--prompt",
-        default="Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan",
-        help="Language prompt for the policy",
-    )
-    parser.add_argument(
-        "--use-zero-images",
-        action="store_true",
-        help="Use zero dummy images instead of real video frames (legacy mode)",
-    )
-
-    args = parser.parse_args()
-
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s [%(levelname)s] %(message)s",
-    )
-
-    test_ar_droid_policy_server(
-        host=args.host,
-        port=args.port,
-        path=args.path,
-        num_chunks=args.num_chunks,
-        prompt=args.prompt,
-        use_zero_images=args.use_zero_images,
-    )
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tests/dreamzero/upstream/test_openpi_e2e_source_parity.py b/tests/dreamzero/upstream/test_openpi_e2e_source_parity.py
deleted file mode 100644
index e41cff903..000000000
--- a/tests/dreamzero/upstream/test_openpi_e2e_source_parity.py
+++ /dev/null
@@ -1,358 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""Formal OpenPI end-to-end parity: upstream DreamZero server vs `vllm serve`.
-
-This test uses DreamZero's own client-side observation builders from
-`${DREAMZERO_REPO}/test_client_AR.py`, and client-side websocket protocol from
-`${DREAMZERO_REPO}/eval_utils/policy_client.py`.
-
-The only client-side adaptation for vLLM is the websocket path:
-DreamZero's upstream server serves at `/`, while vLLM serves OpenPI at
-`/v1/realtime/robot/openpi`.
-
-Current scope for this test:
-- default two-GPU run (`nproc_per_node=2` on upstream, `--cfg-parallel-size 2` on `vllm serve`)
-- non-`torch.compile` (upstream launched through
-  `upstream_socket_server_no_compile.py`, vLLM with `--enforce-eager`)
-- non-DiT-cache / non-skip-schedule (`NUM_DIT_STEPS=16`)
-
-Serving contract locked by this test:
-- upstream DreamZero still boots from the local checkpoint directory
-- vLLM boots from the official DreamZero HF repo name (`GEAR-Dreams/DreamZero-DROID`)
-  rather than a prepared local bundle path
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import subprocess
-import sys
-import time
-from pathlib import Path
-
-import numpy as np
-import pytest
-import torch
-
-from tests.helpers.runtime import get_open_port
-
-msgpack_numpy = pytest.importorskip("openpi_client.msgpack_numpy")
-
-_DREAMZERO_REPO_ENV = os.environ.get("DREAMZERO_REPO")
-DREAMZERO_REPO = Path(_DREAMZERO_REPO_ENV).expanduser() if _DREAMZERO_REPO_ENV else None
-if DREAMZERO_REPO is not None and str(DREAMZERO_REPO) not in sys.path:
-    sys.path.insert(0, str(DREAMZERO_REPO))
-
-try:
-    import test_client_AR as dreamzero_client
-    from eval_utils.policy_client import WebsocketClientPolicy
-except Exception:  # pragma: no cover - guarded by pytest skip below
-    dreamzero_client = None
-    WebsocketClientPolicy = None
-_BaseWebsocketClientPolicy = WebsocketClientPolicy if WebsocketClientPolicy is not None else object
-
-CHECKPOINT_DIR = DREAMZERO_REPO / "checkpoints" / "dreamzero" if DREAMZERO_REPO is not None else None
-VLLM_MODEL = os.environ.get("VLLM_DREAMZERO_MODEL", "GEAR-Dreams/DreamZero-DROID")
-SERVICE_READY_TIMEOUT_S = int(os.environ.get("OPENPI_SERVICE_READY_TIMEOUT_S", "900"))
-PROMPT = "Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan"
-SESSION_ID = "openpi-e2e-parity-session"
-
-pytestmark = [
-    pytest.mark.skipif(not torch.cuda.is_available(), reason="GPU required"),
-    pytest.mark.skipif(
-        dreamzero_client is None or WebsocketClientPolicy is None,
-        reason="DreamZero client modules are required on PYTHONPATH",
-    ),
-    pytest.mark.skipif(
-        DREAMZERO_REPO is None or not DREAMZERO_REPO.exists(),
-        reason="DreamZero source repo is required at DREAMZERO_REPO",
-    ),
-    pytest.mark.skipif(
-        CHECKPOINT_DIR is None or not CHECKPOINT_DIR.exists(), reason="DreamZero local checkpoint is required"
-    ),
-]
-
-
-class OpenPIWebsocketClientPolicy(_BaseWebsocketClientPolicy):
-    """DreamZero client protocol with an OpenPI websocket path suffix."""
-
-    def __init__(
-        self,
-        host: str = "127.0.0.1",
-        port: int = 8000,
-        path: str = "/v1/realtime/robot/openpi",
-    ) -> None:
-        self._uri = f"ws://{host}:{port}{path}"
-        self._packer = msgpack_numpy.Packer()
-        self._ws, self._server_metadata = self._wait_for_server()
-
-
-def _vllm_executable() -> str:
-    fallback = Path(sys.executable).with_name("vllm")
-    if fallback.exists():
-        return str(fallback)
-    exe = shutil.which("vllm")
-    if exe:
-        return exe
-    raise FileNotFoundError("Unable to locate `vllm` executable in current environment.")
-
-
-def _cfg_parallel_size() -> int:
-    return int(os.environ.get("OPENPI_E2E_CFG_PARALLEL_SIZE", "2"))
-
-
-def _pick_test_gpus() -> list[str]:
-    cfg_parallel_size = _cfg_parallel_size()
-    override = os.environ.get("OPENPI_E2E_GPUS") or os.environ.get("OPENPI_E2E_GPU")
-    if override is not None:
-        gpus = [part.strip() for part in override.split(",") if part.strip()]
-        if not gpus:
-            raise ValueError("OPENPI_E2E_GPUS is set but empty.")
-        if len(gpus) < cfg_parallel_size:
-            raise RuntimeError(f"Need {cfg_parallel_size} GPUs, but OPENPI_E2E_GPUS only provided {gpus}.")
-        return gpus
-
-    query = subprocess.check_output(
-        [
-            "nvidia-smi",
-            "--query-gpu=index,memory.used",
-            "--format=csv,noheader,nounits",
-        ],
-        text=True,
-    )
-    gpu_rows = []
-    for line in query.strip().splitlines():
-        gpu_index, used_mb = [part.strip() for part in line.split(",", maxsplit=1)]
-        gpu_rows.append((int(used_mb), gpu_index))
-    gpu_rows.sort()
-    gpus = [gpu_index for _, gpu_index in gpu_rows[: max(cfg_parallel_size, 1)]]
-    if len(gpus) < cfg_parallel_size:
-        raise RuntimeError(
-            f"Need {cfg_parallel_size} GPUs for cfg_parallel_size={cfg_parallel_size}, "
-            f"but found only {len(gpus)} candidates."
-        )
-    return gpus
-
-
-def _torchrun_argv(script: str, port: int) -> list[str]:
-    return [
-        sys.executable,
-        "-m",
-        "torch.distributed.run",
-        "--standalone",
-        "--nproc_per_node",
-        str(_cfg_parallel_size()),
-        script,
-        "--port",
-        str(port),
-        "--model_path",
-        str(CHECKPOINT_DIR),
-    ]
-
-
-def _run_upstream_service(port: int, log_path: Path) -> subprocess.Popen[str]:
-    env = os.environ.copy()
-    env.setdefault("PYTHONPATH", "")
-    env["PYTHONPATH"] = f"{Path.cwd()}:{DREAMZERO_REPO}:{env['PYTHONPATH']}".rstrip(":")
-    env["CUDA_VISIBLE_DEVICES"] = ",".join(_pick_test_gpus())
-    env.setdefault("NO_ALBUMENTATIONS_UPDATE", "1")
-    env["ATTENTION_BACKEND"] = "torch"
-    env.setdefault("ENABLE_TENSORRT", "false")
-    env["ENABLE_DIT_CACHE"] = "false"
-    env["NUM_DIT_STEPS"] = "16"
-    env["DYNAMIC_CACHE_SCHEDULE"] = "false"
-    argv = _torchrun_argv(
-        str(Path("tests/dreamzero/upstream/upstream_socket_server_no_compile.py")),
-        port,
-    )
-    log_file = log_path.open("w")
-    proc = subprocess.Popen(
-        argv,
-        stdout=log_file,
-        stderr=subprocess.STDOUT,
-        text=True,
-        cwd=str(Path.cwd()),
-        env=env,
-    )
-    proc._codex_log_file = log_file  # type: ignore[attr-defined]
-    return proc
-
-
-def _run_vllm_service(port: int, log_path: Path) -> subprocess.Popen[str]:
-    env = os.environ.copy()
-    gpus = _pick_test_gpus()
-    cfg_parallel_size = _cfg_parallel_size()
-    if cfg_parallel_size > len(gpus):
-        raise RuntimeError(
-            f"cfg_parallel_size={cfg_parallel_size} requires at least {cfg_parallel_size} GPUs, but only got {gpus}."
-        )
-    env["CUDA_VISIBLE_DEVICES"] = ",".join(gpus[:cfg_parallel_size])
-    env.setdefault("ATTENTION_BACKEND", "torch")
-    env.setdefault("DIFFUSION_ATTENTION_BACKEND", "TORCH_SDPA")
-    env.setdefault("MASTER_PORT", str(get_open_port()))
-    argv = [
-        _vllm_executable(),
-        "serve",
-        VLLM_MODEL,
-        "--omni",
-        "--host",
-        "127.0.0.1",
-        "--port",
-        str(port),
-        "--served-model-name",
-        "dreamzero-droid",
-        "--enforce-eager",
-    ]
-    if cfg_parallel_size > 1:
-        argv.extend(["--cfg-parallel-size", str(cfg_parallel_size)])
-    log_file = log_path.open("w")
-    proc = subprocess.Popen(
-        argv,
-        stdout=log_file,
-        stderr=subprocess.STDOUT,
-        text=True,
-        env=env,
-        cwd=str(Path.cwd()),
-    )
-    proc._codex_log_file = log_file  # type: ignore[attr-defined]
-    return proc
-
-
-def _stop_process(proc: subprocess.Popen[str]) -> None:
-    log_file = getattr(proc, "_codex_log_file", None)
-    if proc.poll() is None:
-        proc.terminate()
-        try:
-            proc.wait(timeout=30)
-        except subprocess.TimeoutExpired:  # pragma: no cover - cleanup path
-            proc.kill()
-            proc.wait(timeout=10)
-    if log_file is not None:
-        log_file.close()
-
-
-def _build_obs_sequence() -> tuple[dict, dict]:
-    camera_frames = dreamzero_client.load_camera_frames()
-    chunks = dreamzero_client.build_frame_schedule(
-        min(v.shape[0] for v in camera_frames.values()),
-        1,
-    )
-    obs0 = dreamzero_client._make_obs_from_video(camera_frames, [0], PROMPT, SESSION_ID)
-    obs1 = dreamzero_client._make_obs_from_video(camera_frames, chunks[0], PROMPT, SESSION_ID)
-    return obs0, obs1
-
-
-def _wait_for_client_ready(client_factory, timeout_s: float, proc=None, log_path: Path | None = None):
-    deadline = time.time() + timeout_s
-    last_err: Exception | None = None
-    while time.time() < deadline:
-        if proc is not None and proc.poll() is not None:
-            details = ""
-            if log_path is not None and log_path.exists():
-                details = log_path.read_text(errors="replace")[-8000:]
-            raise RuntimeError(f"Service exited before becoming ready with code {proc.returncode}.\n{details}")
-        try:
-            return client_factory()
-        except Exception as exc:  # pragma: no cover - retry path
-            last_err = exc
-            time.sleep(1)
-    raise TimeoutError(f"Timed out waiting for websocket service: {last_err}")
-
-
-def _collect_outputs_with_client(client) -> tuple[dict, list[np.ndarray]]:
-    metadata = client.get_server_metadata()
-    obs0, obs1 = _build_obs_sequence()
-    outputs = [
-        client.infer(dict(obs0)),
-        client.infer(dict(obs1)),
-    ]
-    assert _normalize_reset_response(client.reset({})) == "reset successful"
-    outputs.append(client.infer(dict(obs0)))
-    client._ws.close()
-    return metadata, outputs
-
-
-def _normalize_reset_response(response) -> str:
-    if isinstance(response, str):
-        return response
-    decoded = msgpack_numpy.unpackb(response)
-    if isinstance(decoded, dict):
-        return str(decoded.get("status"))
-    return str(decoded)
-
-
-def _normalize_metadata(metadata: dict) -> dict:
-    normalized = dict(metadata)
-    if isinstance(normalized.get("image_resolution"), tuple):
-        normalized["image_resolution"] = list(normalized["image_resolution"])
-    return normalized
-
-
-def _assert_logs_clean(log_path: Path) -> None:
-    text = log_path.read_text(errors="replace")
-    if "SignalException: Process" in text and "got signal: 15" in text:
-        text = text.split("Traceback (most recent call last):", 1)[0]
-    assert "Traceback" not in text, text
-    assert "RuntimeError:" not in text, text
-
-
-def _assert_upstream_log_matches_vllm_baseline(log_path: Path) -> None:
-    text = log_path.read_text(errors="replace")
-    assert "DIT Compute Steps 8 steps" not in text, text
-    assert "DIT Compute Steps 16 steps" in text, text
-
-
-def test_openpi_service_matches_upstream_server_noncompile(tmp_path: Path) -> None:
-    expected_metadata = {
-        "image_resolution": [180, 320],
-        "n_external_cameras": 2,
-        "needs_wrist_camera": True,
-        "needs_stereo_camera": False,
-        "needs_session_id": True,
-        "action_space": "joint_position",
-    }
-
-    upstream_port = get_open_port()
-    upstream_log = tmp_path / "dreamzero_upstream.log"
-    upstream_proc = _run_upstream_service(upstream_port, upstream_log)
-    try:
-        upstream_client = _wait_for_client_ready(
-            lambda: WebsocketClientPolicy(host="127.0.0.1", port=upstream_port),
-            timeout_s=SERVICE_READY_TIMEOUT_S,
-            proc=upstream_proc,
-            log_path=upstream_log,
-        )
-        upstream_metadata, upstream_outputs = _collect_outputs_with_client(upstream_client)
-    finally:
-        _stop_process(upstream_proc)
-    _assert_logs_clean(upstream_log)
-    _assert_upstream_log_matches_vllm_baseline(upstream_log)
-
-    vllm_port = get_open_port()
-    vllm_log = tmp_path / "vllm_openpi.log"
-    vllm_proc = _run_vllm_service(vllm_port, vllm_log)
-    try:
-        vllm_client = _wait_for_client_ready(
-            lambda: OpenPIWebsocketClientPolicy(host="127.0.0.1", port=vllm_port),
-            timeout_s=SERVICE_READY_TIMEOUT_S,
-            proc=vllm_proc,
-            log_path=vllm_log,
-        )
-        vllm_metadata, vllm_outputs = _collect_outputs_with_client(vllm_client)
-    finally:
-        _stop_process(vllm_proc)
-    _assert_logs_clean(vllm_log)
-
-    assert _normalize_metadata(upstream_metadata) == expected_metadata
-    assert _normalize_metadata(vllm_metadata) == expected_metadata
-
-    for idx, (actual, expected) in enumerate(zip(vllm_outputs, upstream_outputs, strict=True)):
-        np.testing.assert_allclose(
-            actual,
-            expected,
-            rtol=1e-2,
-            atol=1e-3,
-            err_msg=f"OpenPI step {idx} output mismatch",
-        )
diff --git a/tests/e2e/accuracy/__init__.py b/tests/e2e/accuracy/__init__.py
new file mode 100644
index 000000000..d0b74930d
--- /dev/null
+++ b/tests/e2e/accuracy/__init__.py
@@ -0,0 +1 @@
+"""End-to-end accuracy tests."""
diff --git a/tests/e2e/accuracy/conftest.py b/tests/e2e/accuracy/conftest.py
index 6c0258aa2..750a81095 100644
--- a/tests/e2e/accuracy/conftest.py
+++ b/tests/e2e/accuracy/conftest.py
@@ -1,54 +1,15 @@
 from __future__ import annotations
 
-import os
-import subprocess
-from contextlib import contextmanager
-from dataclasses import dataclass
 from io import BytesIO
 from pathlib import Path
 
 import pytest
 import requests
-import torch
 from PIL import Image
 
-from tests.helpers.runtime import OmniServer, OmniServerParams
-
 
 def pytest_addoption(parser):
     group = parser.getgroup("accuracy-e2e")
-    group.addoption("--gebench-root", action="store", default=None, help="Local GEBench dataset root")
-    group.addoption("--gedit-root", action="store", default=None, help="Local GEdit-Bench dataset root")
-    group.addoption(
-        "--gebench-model", action="store", default="Qwen/Qwen-Image-2512", help="Generate model for GEBench smoke"
-    )
-    group.addoption(
-        "--gedit-model", action="store", default="Qwen/Qwen-Image-Edit", help="Generate model for GEdit-Bench smoke"
-    )
-    group.addoption(
-        "--accuracy-judge-model",
-        action="store",
-        default="QuantTrio/Qwen3-VL-30B-A3B-Instruct-AWQ",
-        help="Judge model path",
-    )
-    group.addoption("--accuracy-gpu", action="store", default="0", help="Single GPU id used sequentially")
-    group.addoption("--gebench-port", action="store", type=int, default=8093, help="Generate port for GEBench")
-    group.addoption("--gedit-port", action="store", type=int, default=8093, help="Generate port for GEdit-Bench")
-    group.addoption(
-        "--gebench-samples-per-type",
-        action="store",
-        type=int,
-        default=10,
-        help="Balanced sample count per GEBench type",
-    )
-    group.addoption(
-        "--gedit-samples-per-group",
-        action="store",
-        type=int,
-        default=20,
-        help="Balanced sample count per GEdit task group",
-    )
-    group.addoption("--accuracy-workers", action="store", type=int, default=1, help="Worker count for accuracy benches")
     group.addoption(
         "--wan22-i2v-image-source",
         action="store",
@@ -77,99 +38,6 @@ def pytest_addoption(parser):
     )
 
 
-def _hf_cache_root() -> Path:
-    return Path(os.environ.get("HF_HOME", "/root/.cache/huggingface"))
-
-
-def _dataset_cache_dirs(dataset_id: str) -> list[Path]:
-    cache_root = _hf_cache_root() / "hub" / f"datasets--{dataset_id.replace('/', '--')}" / "snapshots"
-    if not cache_root.exists():
-        return []
-    return sorted(
-        (path for path in cache_root.iterdir() if path.is_dir()), key=lambda path: path.stat().st_mtime, reverse=True
-    )
-
-
-def _ensure_dataset_snapshot(dataset_id: str) -> Path:
-    candidates = _dataset_cache_dirs(dataset_id)
-    if candidates:
-        return candidates[0]
-
-    subprocess.run(
-        ["hf", "download", "--repo-type", "dataset", dataset_id],
-        check=True,
-    )
-    candidates = _dataset_cache_dirs(dataset_id)
-    if not candidates:
-        raise FileNotFoundError(
-            f"Dataset {dataset_id} was downloaded but no snapshot was found under {_hf_cache_root()}"
-        )
-    return candidates[0]
-
-
-def _resolve_dataset_root(request: pytest.FixtureRequest, option_name: str, dataset_id: str) -> Path:
-    value = request.config.getoption(option_name)
-    if value:
-        path = Path(value)
-        if not path.exists():
-            pytest.skip(f"Dataset path does not exist: {path}")
-        return path
-    return _ensure_dataset_snapshot(dataset_id)
-
-
-@dataclass
-class AccuracyServerConfig:
-    generate_params: OmniServerParams
-    judge_params: OmniServerParams
-    run_level: str
-    model_prefix: str
-
-    @contextmanager
-    def generate_server(self):
-        params = self.generate_params
-        model = self.model_prefix + params.model
-        server_args = params.server_args or []
-        if params.use_omni and params.stage_init_timeout is not None:
-            server_args = ["--stage-init-timeout", str(params.stage_init_timeout), *server_args]
-        with OmniServer(
-            model,
-            server_args,
-            port=params.port,
-            env_dict=params.env_dict,
-            use_omni=params.use_omni,
-        ) as server:
-            yield server
-
-    @contextmanager
-    def judge_server(self):
-        params = self.judge_params
-        model = self.model_prefix + params.model
-        server_args = params.server_args or []
-        with OmniServer(
-            model,
-            server_args,
-            port=params.port,
-            env_dict=params.env_dict,
-            use_omni=params.use_omni,
-        ) as server:
-            yield server
-
-
-@pytest.fixture(scope="session")
-def gebench_dataset_root(request: pytest.FixtureRequest) -> Path:
-    return _resolve_dataset_root(request, "gebench_root", "stepfun-ai/GEBench")
-
-
-@pytest.fixture(scope="session")
-def gedit_dataset_root(request: pytest.FixtureRequest) -> Path:
-    return _resolve_dataset_root(request, "gedit_root", "stepfun-ai/GEdit-Bench")
-
-
-@pytest.fixture(scope="session")
-def accuracy_workers(request: pytest.FixtureRequest) -> int:
-    return int(request.config.getoption("accuracy_workers"))
-
-
 @pytest.fixture(scope="session")
 def wan22_i2v_image_source(request: pytest.FixtureRequest) -> str | None:
     value = request.config.getoption("wan22_i2v_image_source")
@@ -192,16 +60,6 @@ def hunyuanvideo15_online_timeout_seconds(request: pytest.FixtureRequest) -> int
     return int(request.config.getoption("hunyuanvideo15_online_timeout_seconds"))
 
 
-@pytest.fixture(scope="session")
-def gebench_samples_per_type(request: pytest.FixtureRequest) -> int:
-    return int(request.config.getoption("gebench_samples_per_type"))
-
-
-@pytest.fixture(scope="session")
-def gedit_samples_per_group(request: pytest.FixtureRequest) -> int:
-    return int(request.config.getoption("gedit_samples_per_group"))
-
-
 @pytest.fixture(scope="session")
 def accuracy_artifact_root() -> Path:
     root = Path(__file__).resolve().parent / "artifacts"
@@ -209,12 +67,6 @@ def accuracy_artifact_root() -> Path:
     return root
 
 
-@pytest.fixture(scope="session")
-def accuracy_assets_root() -> Path:
-    root = Path(__file__).resolve().parent / "assets"
-    return root
-
-
 @pytest.fixture(scope="session")
 def qwen_bear_image(accuracy_artifact_root: Path):
     """Download the Qwen bear image from the URL and save it to the accuracy artifact root."""
@@ -249,80 +101,3 @@ def rabbit_image(accuracy_artifact_root: Path):
     image.save(image_path)
     yield image
     image.close()
-
-
-def _build_accuracy_server_config(
-    *,
-    generate_model: str,
-    judge_model: str,
-    shared_gpu: str,
-    port: int,
-    run_level: str,
-    model_prefix: str,
-) -> AccuracyServerConfig:
-    if torch.accelerator.device_count() < 1:
-        pytest.skip("Need at least 1 CUDA GPU for accuracy benchmark smoke tests.")
-
-    if not generate_model:
-        pytest.skip("No generate model configured for accuracy benchmark test.")
-    generate_server_args = ["--num-gpus", "1"]
-    judge_server_args = [
-        "--max-model-len",
-        "32768",
-        "--gpu-memory-utilization",
-        "0.8",
-    ]
-
-    judge_env = {"CUDA_VISIBLE_DEVICES": shared_gpu}
-
-    return AccuracyServerConfig(
-        generate_params=OmniServerParams(
-            model=generate_model,
-            port=port,
-            server_args=generate_server_args,
-            env_dict={"CUDA_VISIBLE_DEVICES": shared_gpu},
-            use_omni=True,
-            stage_init_timeout=300,
-        ),
-        judge_params=OmniServerParams(
-            model=judge_model,
-            port=port,
-            server_args=judge_server_args,
-            env_dict=judge_env,
-            use_omni=False,
-        ),
-        run_level=run_level,
-        model_prefix=model_prefix,
-    )
-
-
-@pytest.fixture
-def gebench_accuracy_servers(
-    request: pytest.FixtureRequest,
-    run_level: str,
-    model_prefix: str,
-) -> AccuracyServerConfig:
-    return _build_accuracy_server_config(
-        generate_model=request.config.getoption("gebench_model"),
-        judge_model=request.config.getoption("accuracy_judge_model"),
-        shared_gpu=str(request.config.getoption("accuracy_gpu")),
-        port=int(request.config.getoption("gebench_port")),
-        run_level=run_level,
-        model_prefix=model_prefix,
-    )
-
-
-@pytest.fixture
-def gedit_accuracy_servers(
-    request: pytest.FixtureRequest,
-    run_level: str,
-    model_prefix: str,
-) -> AccuracyServerConfig:
-    return _build_accuracy_server_config(
-        generate_model=request.config.getoption("gedit_model"),
-        judge_model=request.config.getoption("accuracy_judge_model"),
-        shared_gpu=str(request.config.getoption("accuracy_gpu")),
-        port=int(request.config.getoption("gedit_port")),
-        run_level=run_level,
-        model_prefix=model_prefix,
-    )
diff --git a/tests/e2e/accuracy/helpers.py b/tests/e2e/accuracy/helpers.py
index ebe635ea8..99880fc73 100644
--- a/tests/e2e/accuracy/helpers.py
+++ b/tests/e2e/accuracy/helpers.py
@@ -3,8 +3,12 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import time
+from abc import ABC, abstractmethod
 from base64 import b64decode, b64encode
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
 from fractions import Fraction
 from hashlib import sha1
 from io import BytesIO
@@ -53,8 +57,6 @@ def env_to_apply_ftfy_mock_in_subproc(env: dict[str, str] | None = None) -> dict
 
 
 def reset_artifact_dir(path: Path) -> Path:
-    import shutil
-
     if path.exists():
         shutil.rmtree(path)
     path.mkdir(parents=True, exist_ok=True)
@@ -609,3 +611,344 @@ def download_images(urls: list[str]) -> list[Image.Image]:
         images.append(image)
 
     return images
+
+
+_DREAMZERO_UPSTREAM_SERVER_SCRIPT = (
+    Path(__file__).resolve().parent / "upstream_mock" / "upstream_socket_server_no_compile.py"
+)
+_DREAMZERO_DEFAULT_MODEL = "GEAR-Dreams/DreamZero-DROID"
+_DREAMZERO_DEFAULT_READY_TIMEOUT_S = int(os.environ.get("OPENPI_SERVICE_READY_TIMEOUT_S", "900"))
+_DREAMZERO_DEFAULT_PROMPT = (
+    "Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan"
+)
+_DREAMZERO_DEFAULT_SESSION_ID = "openpi-e2e-parity-session"
+_DREAMZERO_OPENPI_VLLM_PATH = "/v1/realtime/robot/openpi"
+
+
+def require_dreamzero_parity_env() -> tuple[Path, Path]:
+    repo_env = os.environ.get("DREAMZERO_REPO")
+    if repo_env is None:
+        raise ValueError("DREAMZERO_REPO environment variable is required.")
+    repo = Path(repo_env).expanduser()
+    if not repo.is_dir():
+        raise FileNotFoundError(f"DREAMZERO_REPO does not exist: {repo}")
+    checkpoint_dir = repo / "checkpoints" / "dreamzero"
+    if not checkpoint_dir.is_dir():
+        raise FileNotFoundError(f"DreamZero checkpoint not found: {checkpoint_dir}")
+    if str(repo) not in sys.path:
+        sys.path.insert(0, str(repo))
+    return repo, checkpoint_dir
+
+
+def load_dreamzero_upstream_modules():
+    require_dreamzero_parity_env()
+    import test_client_AR as dreamzero_upstream_client
+    from eval_utils.policy_client import WebsocketClientPolicy
+
+    return dreamzero_upstream_client, WebsocketClientPolicy
+
+
+def dreamzero_cfg_parallel_size() -> int:
+    return int(os.environ.get("OPENPI_E2E_CFG_PARALLEL_SIZE", "2"))
+
+
+def _dreamzero_parity_vllm_env() -> dict[str, str]:
+    from tests.helpers.env import pick_least_used_device_indices
+    from tests.helpers.runtime import get_open_port
+
+    parallel_size = dreamzero_cfg_parallel_size()
+    gpus = [str(index) for index in pick_least_used_device_indices(parallel_size)]
+    if parallel_size > len(gpus):
+        raise RuntimeError(
+            f"cfg_parallel_size={parallel_size} requires at least {parallel_size} GPUs, but only got {gpus}."
+        )
+    return {
+        "CUDA_VISIBLE_DEVICES": ",".join(gpus[:parallel_size]),
+        "ATTENTION_BACKEND": "torch",
+        "DIFFUSION_ATTENTION_BACKEND": "TORCH_SDPA",
+        "VLLM_DISABLE_COMPILE_CACHE": "1",
+        "MASTER_PORT": str(get_open_port()),
+    }
+
+
+def dreamzero_parity_vllm_params(model: str | None = None):
+    from tests.helpers.runtime import OmniServerParams
+    from tests.helpers.stage_config import get_deploy_config_path
+
+    parallel_size = dreamzero_cfg_parallel_size()
+    server_args = [
+        "--served-model-name",
+        "dreamzero-droid",
+        "--enforce-eager",
+    ]
+    if parallel_size > 1:
+        server_args.extend(["--cfg-parallel-size", str(parallel_size)])
+    return OmniServerParams(
+        model=model or os.environ.get("VLLM_DREAMZERO_MODEL", _DREAMZERO_DEFAULT_MODEL),
+        stage_config_path=get_deploy_config_path("dreamzero_tp1_cfg2.yaml"),
+        server_args=server_args,
+        env_dict=_dreamzero_parity_vllm_env(),
+    )
+
+
+def _dreamzero_omni_server_from_params(params):
+    from tests.helpers.runtime import OmniServer
+
+    server_args = list(params.server_args or [])
+    if params.stage_config_path is not None:
+        server_args += ["--deploy-config", params.stage_config_path]
+    return OmniServer(
+        params.model,
+        server_args,
+        port=params.port,
+        env_dict=params.env_dict,
+        use_omni=params.use_omni,
+    )
+
+
+@contextmanager
+def dreamzero_parity_vllm_client(
+    params=None,
+    *,
+    ready_timeout_s: float = _DREAMZERO_DEFAULT_READY_TIMEOUT_S,
+) -> Iterator["DreamZeroParityClient"]:
+    """Start vLLM via ``OmniServer`` and return a ready OpenPI parity client."""
+    with _dreamzero_omni_server_from_params(params or dreamzero_parity_vllm_params()) as server:
+        client = _dreamzero_wait_for_client_ready(
+            lambda: _dreamzero_create_openpi_vllm_client(server.host, server.port),
+            timeout_s=ready_timeout_s,
+            proc=server.proc,
+        )
+        yield DreamZeroParityClient(client)
+
+
+def _dreamzero_create_openpi_vllm_client(host: str, port: int) -> Any:
+    from openpi_client import msgpack_numpy
+
+    _, WebsocketClientPolicy = load_dreamzero_upstream_modules()
+
+    class _OpenPIWebsocketClientPolicy(WebsocketClientPolicy):
+        def __init__(
+            self,
+            host: str = "127.0.0.1",
+            port: int = 8000,
+            path: str = _DREAMZERO_OPENPI_VLLM_PATH,
+        ) -> None:
+            self._uri = f"ws://{host}:{port}{path}"
+            self._packer = msgpack_numpy.Packer()
+            self._ws, self._server_metadata = self._wait_for_server()
+
+    return _OpenPIWebsocketClientPolicy(host=host, port=port)
+
+
+def _dreamzero_stop_process(proc: subprocess.Popen[str]) -> None:
+    log_file = getattr(proc, "_codex_log_file", None)
+    if proc.poll() is None:
+        proc.terminate()
+        try:
+            proc.wait(timeout=30)
+        except subprocess.TimeoutExpired:  # pragma: no cover - cleanup path
+            proc.kill()
+            proc.wait(timeout=10)
+    if log_file is not None:
+        log_file.close()
+
+
+def _dreamzero_wait_for_client_ready(
+    client_factory: Callable[[], Any],
+    *,
+    timeout_s: float,
+    proc: subprocess.Popen[str] | None = None,
+    log_path: Path | None = None,
+) -> Any:
+    deadline = time.time() + timeout_s
+    last_err: Exception | None = None
+    while time.time() < deadline:
+        if proc is not None and proc.poll() is not None:
+            details = ""
+            if log_path is not None and log_path.exists():
+                details = log_path.read_text(errors="replace")[-8000:]
+            raise RuntimeError(f"Service exited before becoming ready with code {proc.returncode}.\n{details}")
+        try:
+            return client_factory()
+        except Exception as exc:  # pragma: no cover - retry path
+            last_err = exc
+            time.sleep(1)
+    raise TimeoutError(f"Timed out waiting for websocket service: {last_err}")
+
+
+def _dreamzero_normalize_reset_response(response: Any) -> str:
+    from openpi_client import msgpack_numpy
+
+    if isinstance(response, str):
+        return response
+    decoded = msgpack_numpy.unpackb(response)
+    if isinstance(decoded, dict):
+        return str(decoded.get("status"))
+    return str(decoded)
+
+
+def normalize_dreamzero_metadata(metadata: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(metadata)
+    if isinstance(normalized.get("image_resolution"), tuple):
+        normalized["image_resolution"] = list(normalized["image_resolution"])
+    return normalized
+
+
+def assert_dreamzero_logs_clean(log_path: Path) -> None:
+    text = log_path.read_text(errors="replace")
+    if "SignalException: Process" in text and "got signal: 15" in text:
+        text = text.split("Traceback (most recent call last):", 1)[0]
+    assert "Traceback" not in text, text
+    assert "RuntimeError:" not in text, text
+
+
+def assert_dreamzero_upstream_log_matches_vllm_baseline(log_path: Path) -> None:
+    text = log_path.read_text(errors="replace")
+    assert "DIT Compute Steps 8 steps" not in text, text
+    assert "DIT Compute Steps 16 steps" in text, text
+
+
+class DreamZeroParityClient:
+    """Connected OpenPI websocket client for DreamZero parity inference."""
+
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    @property
+    def raw_client(self) -> Any:
+        return self._client
+
+    def build_obs_sequence(self) -> tuple[dict[str, Any], dict[str, Any]]:
+        dreamzero_upstream_client, _ = load_dreamzero_upstream_modules()
+        camera_frames = dreamzero_upstream_client.load_camera_frames()
+        chunks = dreamzero_upstream_client.build_frame_schedule(
+            min(v.shape[0] for v in camera_frames.values()),
+            1,
+        )
+        obs0 = dreamzero_upstream_client._make_obs_from_video(
+            camera_frames,
+            [0],
+            _DREAMZERO_DEFAULT_PROMPT,
+            _DREAMZERO_DEFAULT_SESSION_ID,
+        )
+        obs1 = dreamzero_upstream_client._make_obs_from_video(
+            camera_frames,
+            chunks[0],
+            _DREAMZERO_DEFAULT_PROMPT,
+            _DREAMZERO_DEFAULT_SESSION_ID,
+        )
+        return obs0, obs1
+
+    def collect_parity_outputs(self) -> tuple[dict[str, Any], list[np.ndarray]]:
+        metadata = self._client.get_server_metadata()
+        obs0, obs1 = self.build_obs_sequence()
+        outputs = [
+            self._client.infer(dict(obs0)),
+            self._client.infer(dict(obs1)),
+        ]
+        assert _dreamzero_normalize_reset_response(self._client.reset({})) == "reset successful"
+        outputs.append(self._client.infer(dict(obs0)))
+        self._client._ws.close()
+        return metadata, outputs
+
+
+class _DreamZeroParityServer(ABC):
+    host = "127.0.0.1"
+
+    def __init__(
+        self,
+        *,
+        log_path: Path,
+        port: int | None = None,
+        ready_timeout_s: float = _DREAMZERO_DEFAULT_READY_TIMEOUT_S,
+    ) -> None:
+        from tests.helpers.runtime import get_open_port
+
+        self.log_path = log_path
+        self.port = get_open_port() if port is None else port
+        self.ready_timeout_s = ready_timeout_s
+        self.proc: subprocess.Popen[str] | None = None
+        self._log_file = None
+
+    @abstractmethod
+    def _build_argv(self) -> list[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _build_env(self) -> dict[str, str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _create_client(self) -> Any:
+        raise NotImplementedError
+
+    def _start(self) -> None:
+        self.log_path.parent.mkdir(parents=True, exist_ok=True)
+        self._log_file = self.log_path.open("w")
+        self.proc = subprocess.Popen(
+            self._build_argv(),
+            stdout=self._log_file,
+            stderr=subprocess.STDOUT,
+            text=True,
+            cwd=str(Path.cwd()),
+            env=self._build_env(),
+        )
+        self.proc._codex_log_file = self._log_file  # type: ignore[attr-defined]
+
+    def __enter__(self) -> DreamZeroParityClient:
+        self._start()
+        client = _dreamzero_wait_for_client_ready(
+            self._create_client,
+            timeout_s=self.ready_timeout_s,
+            proc=self.proc,
+            log_path=self.log_path,
+        )
+        return DreamZeroParityClient(client)
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        if self.proc is not None:
+            _dreamzero_stop_process(self.proc)
+            self.proc = None
+
+
+class DreamZeroUpstreamServer(_DreamZeroParityServer):
+    """Official DreamZero upstream reference server launched via torchrun."""
+
+    def _build_argv(self) -> list[str]:
+        _, checkpoint_dir = require_dreamzero_parity_env()
+        return [
+            sys.executable,
+            "-m",
+            "torch.distributed.run",
+            "--standalone",
+            "--nproc_per_node",
+            str(dreamzero_cfg_parallel_size()),
+            str(_DREAMZERO_UPSTREAM_SERVER_SCRIPT),
+            "--port",
+            str(self.port),
+            "--model_path",
+            str(checkpoint_dir),
+        ]
+
+    def _build_env(self) -> dict[str, str]:
+        from tests.helpers.env import pick_least_used_device_indices
+
+        dreamzero_repo, _ = require_dreamzero_parity_env()
+        env = os.environ.copy()
+        env.setdefault("PYTHONPATH", "")
+        env["PYTHONPATH"] = f"{Path.cwd()}:{dreamzero_repo}:{env['PYTHONPATH']}".rstrip(":")
+        env["CUDA_VISIBLE_DEVICES"] = ",".join(
+            str(index) for index in pick_least_used_device_indices(max(dreamzero_cfg_parallel_size(), 1))
+        )
+        env.setdefault("NO_ALBUMENTATIONS_UPDATE", "1")
+        env["ATTENTION_BACKEND"] = "torch"
+        env.setdefault("ENABLE_TENSORRT", "false")
+        env["ENABLE_DIT_CACHE"] = "false"
+        env["NUM_DIT_STEPS"] = "16"
+        env["DYNAMIC_CACHE_SCHEDULE"] = "false"
+        return env
+
+    def _create_client(self) -> Any:
+        _, WebsocketClientPolicy = load_dreamzero_upstream_modules()
+        return WebsocketClientPolicy(host=self.host, port=self.port)
diff --git a/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py b/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
index 84e032770..b830cdc6c 100644
--- a/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
+++ b/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
@@ -236,7 +236,8 @@ def test_hunyuanvideo15_i2v_serving_matches_offline_video_similarity(
     probe_binary("ffmpeg")
     probe_binary("ffprobe")
     image_source = _resolve_image_source(hunyuanvideo15_i2v_image_source)
-    validate_image_source(image_source)
+    # The input image was already consumed by the prerequisite generation
+    # tests. Avoid re-fetching a remote source when only comparing artifacts.
     online_path, offline_path = _artifact_paths(image_source)
     if not online_path.exists():
         pytest.skip(f"Missing online artifact from prerequisite test: {online_path}")
diff --git a/tests/e2e/accuracy/ltx/__init__.py b/tests/e2e/accuracy/ltx/__init__.py
new file mode 100644
index 000000000..08143263b
--- /dev/null
+++ b/tests/e2e/accuracy/ltx/__init__.py
@@ -0,0 +1 @@
+"""LTX family official-reference accuracy tests."""
diff --git a/tests/e2e/accuracy/ltx/run_ltx_reference.py b/tests/e2e/accuracy/ltx/run_ltx_reference.py
new file mode 100644
index 000000000..a4a180047
--- /dev/null
+++ b/tests/e2e/accuracy/ltx/run_ltx_reference.py
@@ -0,0 +1,331 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Generate raw LTX video and audio outputs with the official or Omni runtime."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from PIL import Image
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--backend", choices=("official", "omni"), required=True)
+    parser.add_argument("--request", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--model")
+    parser.add_argument("--model-class-name")
+    parser.add_argument("--official-root", type=Path)
+    parser.add_argument("--checkpoint", type=Path)
+    parser.add_argument("--gemma-root", type=Path)
+    parser.add_argument("--enable-layerwise-offload", action="store_true")
+    return parser.parse_args()
+
+
+def _save_outputs(
+    output_dir: Path,
+    *,
+    video: torch.Tensor,
+    audio: torch.Tensor,
+    audio_sample_rate: int,
+    metadata: dict[str, Any],
+) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    video = video.detach().float().cpu().clamp(0.0, 1.0)
+    audio = audio.detach().float().cpu()
+    np.save(output_dir / "video.npy", video.numpy())
+    np.save(output_dir / "audio.npy", audio.numpy())
+
+    frame_indices = sorted({0, video.shape[0] // 2, video.shape[0] - 1})
+    for index in frame_indices:
+        frame = video[index].mul(255.0).round().to(torch.uint8).numpy()
+        Image.fromarray(frame).save(output_dir / f"frame_{index:04d}.png")
+
+    metadata.update(
+        {
+            "video_shape": list(video.shape),
+            "audio_shape": list(audio.shape),
+            "audio_sample_rate": int(audio_sample_rate),
+            "frame_indices": frame_indices,
+        }
+    )
+    (output_dir / "metadata.json").write_text(json.dumps(metadata, indent=2) + "\n")
+
+
+def _insert_official_paths(official_root: Path) -> None:
+    for relative_path in ("packages/ltx-core/src", "packages/ltx-pipelines/src"):
+        path = str((official_root / relative_path).resolve())
+        if path not in sys.path:
+            sys.path.insert(0, path)
+
+
+def _configure_official_sdpa(pipeline: Any) -> None:
+    """Use PyTorch SDPA for official connector and denoiser attention."""
+    from ltx_core.loader.attention_ops import set_attention_module_op
+    from ltx_core.model.transformer.attention import PytorchAttention
+
+    class AllValidSDPA(PytorchAttention):
+        def __call__(
+            self,
+            query: torch.Tensor,
+            key: torch.Tensor,
+            value: torch.Tensor,
+            heads: int,
+            mask: torch.Tensor | None = None,
+        ) -> torch.Tensor:
+            if mask is not None and torch.count_nonzero(mask).item():
+                raise ValueError("The LTX accuracy guard cannot discard a non-empty attention mask")
+            return super().__call__(query, key, value, heads, mask=None)
+
+    attention = AllValidSDPA()
+    module_op = set_attention_module_op(
+        attention=attention,
+        masked_attention=attention,
+    )
+    owners_and_attributes = (
+        (pipeline.stage, "_transformer_builder"),
+        (pipeline.prompt_encoder, "_embeddings_processor_builder"),
+    )
+    for owner, attribute in owners_and_attributes:
+        builder = getattr(owner, attribute)
+        setattr(
+            owner,
+            attribute,
+            builder.with_module_ops((*builder.module_ops, module_op)),
+        )
+
+
+@torch.inference_mode()
+def _run_official(args: argparse.Namespace, request: dict[str, Any]) -> None:
+    if args.official_root is None or args.checkpoint is None or args.gemma_root is None:
+        raise ValueError("Official backend requires --official-root, --checkpoint, and --gemma-root")
+    _insert_official_paths(args.official_root)
+    # vLLM disables cuDNN SDPA during import; mirror the worker's Gemma dispatch.
+    torch.backends.cuda.enable_cudnn_sdp(False)
+
+    from ltx_core.components.guiders import MultiModalGuiderParams
+    from ltx_pipelines.ti2vid_one_stage import TI2VidOneStagePipeline
+    from ltx_pipelines.utils.args import ImageConditioningInput
+    from ltx_pipelines.utils.types import OffloadMode
+
+    pipeline = TI2VidOneStagePipeline(
+        checkpoint_path=str(args.checkpoint),
+        gemma_root=str(args.gemma_root),
+        loras=(),
+        offload_mode=OffloadMode.CPU if args.enable_layerwise_offload else OffloadMode.NONE,
+    )
+    _configure_official_sdpa(pipeline)
+    image_path = request.get("image")
+    images = (
+        []
+        if image_path is None
+        else [
+            ImageConditioningInput(
+                path=str(image_path),
+                frame_idx=0,
+                strength=1.0,
+                # Both runtimes must receive the same source pixels. The
+                # official CLI's optional H.264 preprocessing is not part of
+                # the seeded model trajectory under test.
+                crf=0,
+            )
+        ]
+    )
+    video, audio = pipeline(
+        prompt=request["prompt"],
+        negative_prompt=request["negative_prompt"],
+        seed=request["seed"],
+        height=request["height"],
+        width=request["width"],
+        num_frames=request["num_frames"],
+        frame_rate=request["fps"],
+        num_inference_steps=request["num_inference_steps"],
+        video_guider_params=MultiModalGuiderParams(
+            cfg_scale=request["video_cfg_scale"],
+            stg_scale=request["video_stg_scale"],
+            rescale_scale=request["video_rescale_scale"],
+            modality_scale=request["video_modality_scale"],
+            skip_step=0,
+            stg_blocks=request["video_stg_blocks"],
+        ),
+        audio_guider_params=MultiModalGuiderParams(
+            cfg_scale=request["audio_cfg_scale"],
+            stg_scale=request["audio_stg_scale"],
+            rescale_scale=request["audio_rescale_scale"],
+            modality_scale=request["audio_modality_scale"],
+            skip_step=0,
+            stg_blocks=request["audio_stg_blocks"],
+        ),
+        images=images,
+        max_batch_size=4,
+    )
+    video_tensor = torch.cat([chunk.detach().cpu() for chunk in video], dim=0)
+    _save_outputs(
+        args.output_dir,
+        video=_canonical_video(video_tensor),
+        audio=audio.waveform,
+        audio_sample_rate=audio.sampling_rate,
+        metadata={
+            "backend": "official",
+            "attention_backend": "torch_sdpa",
+            "official_revision": os.environ.get("VLLM_TEST_LTX_OFFICIAL_REVISION"),
+            "checkpoint": str(args.checkpoint),
+        },
+    )
+
+
+def _unwrap_omni_output(output: Any) -> tuple[Any, Any, int]:
+    from vllm_omni.outputs import OmniRequestOutput
+
+    audio = None
+    audio_sample_rate = None
+    frames = output[0] if isinstance(output, list) and output else output
+    if isinstance(frames, OmniRequestOutput):
+        multimodal_output = frames.multimodal_output or {}
+        audio = multimodal_output.get("audio")
+        audio_sample_rate = multimodal_output.get("audio_sample_rate")
+        if frames.is_pipeline_output and isinstance(frames.request_output, OmniRequestOutput):
+            frames = frames.request_output
+            multimodal_output = frames.multimodal_output or {}
+            audio = multimodal_output.get("audio", audio)
+            audio_sample_rate = multimodal_output.get("audio_sample_rate", audio_sample_rate)
+        if isinstance(frames, OmniRequestOutput):
+            if not frames.images:
+                raise ValueError("No video frames found in OmniRequestOutput")
+            frames = frames.images
+
+    if isinstance(frames, list) and len(frames) == 1:
+        frames = frames[0]
+    if isinstance(frames, tuple) and len(frames) == 2:
+        frames, audio = frames
+    elif isinstance(frames, dict):
+        audio = frames.get("audio", audio)
+        audio_sample_rate = frames.get("audio_sample_rate", audio_sample_rate)
+        frames = frames.get("frames", frames.get("video"))
+
+    if frames is None or audio is None or audio_sample_rate is None:
+        raise ValueError("Omni output did not contain video, audio, and audio_sample_rate")
+    return frames, audio, int(audio_sample_rate)
+
+
+def _canonical_video(video: Any) -> torch.Tensor:
+    if isinstance(video, list):
+        if len(video) == 1:
+            return _canonical_video(video[0])
+        tensors = [torch.as_tensor(np.asarray(item) if not isinstance(item, torch.Tensor) else item) for item in video]
+        if all(item.ndim == 3 for item in tensors):
+            video = torch.stack(tensors)
+        elif all(item.ndim == 4 for item in tensors):
+            video = torch.cat(tensors)
+        else:
+            raise ValueError(f"Cannot combine video items with dimensions {[item.ndim for item in tensors]}")
+    tensor = torch.as_tensor(np.asarray(video) if not isinstance(video, torch.Tensor) else video).detach().cpu()
+    if tensor.ndim == 5:
+        tensor = tensor[0]
+    if tensor.ndim != 4:
+        raise ValueError(f"Expected a 4D video tensor, got {tuple(tensor.shape)}")
+    if tensor.shape[-1] in (3, 4):
+        tensor = tensor[..., :3]
+    elif tensor.shape[1] in (3, 4):
+        tensor = tensor[:, :3].permute(0, 2, 3, 1)
+    elif tensor.shape[0] in (3, 4):
+        tensor = tensor[:3].permute(1, 2, 3, 0)
+    else:
+        raise ValueError(f"Cannot infer video channel dimension from {tuple(tensor.shape)}")
+    tensor = tensor.float()
+    if tensor.numel() and tensor.max() > 1:
+        tensor = tensor / 255.0
+    elif tensor.numel() and tensor.min() < 0:
+        tensor = tensor.clamp(-1.0, 1.0).add(1.0).mul(0.5)
+    return tensor.clamp(0.0, 1.0)
+
+
+@torch.inference_mode()
+def _run_omni(args: argparse.Namespace, request: dict[str, Any]) -> None:
+    if args.model is None or args.model_class_name is None:
+        raise ValueError("Omni backend requires --model and --model-class-name")
+
+    attention_config = {"default": {"backend": "TORCH_SDPA"}}
+
+    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.model_extras import get_extra_body_params, get_model_class_name
+    from vllm_omni.platforms import current_omni_platform
+
+    generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(request["seed"])
+    omni = Omni(
+        model=args.model,
+        model_class_name=args.model_class_name,
+        enforce_eager=True,
+        enable_layerwise_offload=args.enable_layerwise_offload,
+        diffusion_attention_config=attention_config,
+        parallel_config=DiffusionParallelConfig(),
+    )
+    try:
+        model_class_name = get_model_class_name(omni)
+        sampling_params = OmniDiffusionSamplingParams(
+            height=request["height"],
+            width=request["width"],
+            generator=generator,
+            guidance_scale=None,
+            num_inference_steps=request["num_inference_steps"],
+            num_frames=request["num_frames"],
+            fps=request["fps"],
+            frame_rate=float(request["fps"]),
+            output_type="np",
+        )
+        guidance = {
+            key: value for key, value in request.items() if key.startswith("video_") or key.startswith("audio_")
+        }
+        apply_declared_extra_args(sampling_params, get_extra_body_params(model_class_name), guidance)
+        prompt: dict[str, Any] = {
+            "prompt": request["prompt"],
+            "negative_prompt": request["negative_prompt"],
+        }
+        image_path = request.get("image")
+        if image_path is not None:
+            with Image.open(str(image_path)) as source_image:
+                image = source_image.convert("RGB")
+                image.load()
+            prompt["multi_modal_data"] = {"image": image}
+        output = omni.generate(prompt, sampling_params)
+        video, audio, audio_sample_rate = _unwrap_omni_output(output)
+        audio_tensor = torch.as_tensor(np.asarray(audio) if not isinstance(audio, torch.Tensor) else audio)
+        _save_outputs(
+            args.output_dir,
+            video=_canonical_video(video),
+            audio=audio_tensor,
+            audio_sample_rate=audio_sample_rate,
+            metadata={
+                "backend": "omni",
+                "attention_backend": "torch_sdpa",
+                "model": args.model,
+                "model_class_name": model_class_name,
+            },
+        )
+    finally:
+        omni.shutdown()
+
+
+def main() -> None:
+    args = _parse_args()
+    request = json.loads(args.request.read_text())
+    if args.backend == "official":
+        _run_official(args, request)
+    else:
+        _run_omni(args, request)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/accuracy/ltx/test_ltx_official_similarity.py b/tests/e2e/accuracy/ltx/test_ltx_official_similarity.py
new file mode 100644
index 000000000..647ece7a7
--- /dev/null
+++ b/tests/e2e/accuracy/ltx/test_ltx_official_similarity.py
@@ -0,0 +1,440 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""E2E accuracy guard against a pinned Lightricks LTX pipeline revision.
+
+The comparison runs both runtimes through PyTorch SDPA and uses
+``max_batch_size=4`` in the official reference to match Omni's fused guidance
+batch. Video and audio guidance use the official non-HQ one-stage defaults;
+only the generation shape and step count are reduced for CI runtime.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+from huggingface_hub import hf_hub_download, snapshot_download
+from torchmetrics.image import PeakSignalNoiseRatio, StructuralSimilarityIndexMeasure
+
+from tests.e2e.accuracy.helpers import reset_artifact_dir
+from tests.helpers.mark import hardware_test
+
+OFFICIAL_REPOSITORY = "https://github.com/Lightricks/LTX-2.git"
+OFFICIAL_REVISION = "9377758131b1ffde4b7f766804590a6617bf2ab9"
+# Version selected by this revision's uv.lock. Keep it out of Omni's runtime and dev dependencies.
+OFFICIAL_OPENIMAGEIO_VERSION = "3.1.11.0"
+PROMPT = (
+    "A space shuttle launches vertically above a desert launch pad. Bright exhaust flames and a dense white "
+    "plume billow beneath it while the camera remains fixed."
+)
+NEGATIVE_PROMPT = (
+    "blurry, out of focus, overexposed, underexposed, low contrast, washed out colors, excessive noise, "
+    "grainy texture, poor lighting, flickering, motion blur, distorted proportions, unnatural skin tones, "
+    "deformed facial features, asymmetrical face, missing facial features, extra limbs, disfigured hands, "
+    "wrong hand count, artifacts around text, inconsistent perspective, camera shake, incorrect depth of field, "
+    "background too sharp, background clutter, distracting reflections, harsh shadows, inconsistent lighting "
+    "direction, color banding, cartoonish rendering, 3D CGI look, unrealistic materials, uncanny valley effect, "
+    "incorrect ethnicity, wrong gender, exaggerated expressions, wrong gaze direction, mismatched lip sync, "
+    "silent or muted audio, distorted voice, robotic voice, echo, background noise, off-sync audio, incorrect "
+    "dialogue, added dialogue, repetitive speech, jittery movement, awkward pauses, incorrect timing, unnatural "
+    "transitions, inconsistent framing, tilted camera, flat lighting, inconsistent tone, cinematic oversaturation, "
+    "stylized filters, or AI artifacts."
+)
+
+# Both runtimes use PyTorch SDPA with the current Torch dispatch defaults.
+ATTENTION_BACKEND = "torch_sdpa"
+VIDEO_SSIM_MEAN_THRESHOLD = 0.95
+VIDEO_SSIM_MIN_THRESHOLD = 0.90
+VIDEO_PSNR_MEAN_THRESHOLD = 30.0
+AUDIO_RELATIVE_L2_THRESHOLD = 0.2
+AUDIO_COSINE_THRESHOLD = 0.95
+
+
+@dataclass(frozen=True)
+class LTXAccuracyCase:
+    name: str
+    model_id: str
+    model_revision: str
+    model_env: str
+    model_class_name: str
+    checkpoint_repo: str
+    checkpoint_filename: str
+    checkpoint_revision: str
+    checkpoint_env: str
+    stg_block: int
+    prompt: str = PROMPT
+    image_repo: str | None = None
+    image_filename: str | None = None
+    image_revision: str | None = None
+
+
+CASES = (
+    LTXAccuracyCase(
+        name="ltx2",
+        model_id="Lightricks/LTX-2",
+        model_revision="47da56e2ad66ce4125a9922b4a8826bf407f9d0a",
+        model_env="VLLM_TEST_LTX2_MODEL",
+        model_class_name="LTX2Pipeline",
+        checkpoint_repo="Lightricks/LTX-2",
+        checkpoint_filename="ltx-2-19b-dev.safetensors",
+        checkpoint_revision="47da56e2ad66ce4125a9922b4a8826bf407f9d0a",
+        checkpoint_env="VLLM_TEST_LTX2_OFFICIAL_CHECKPOINT",
+        stg_block=29,
+    ),
+    LTXAccuracyCase(
+        name="ltx2_3",
+        model_id="diffusers/LTX-2.3-Diffusers",
+        model_revision="8eee8edcf067e838b843f926ec4d4cc9b2be1aaf",
+        model_env="VLLM_TEST_LTX23_MODEL",
+        model_class_name="LTX2Pipeline",
+        checkpoint_repo="Lightricks/LTX-2.3",
+        checkpoint_filename="ltx-2.3-22b-dev.safetensors",
+        checkpoint_revision="4229404625088d21c4f112eb640fb04a0900ee25",
+        checkpoint_env="VLLM_TEST_LTX23_OFFICIAL_CHECKPOINT",
+        stg_block=28,
+    ),
+    LTXAccuracyCase(
+        name="ltx2_3_i2v",
+        model_id="diffusers/LTX-2.3-Diffusers",
+        model_revision="8eee8edcf067e838b843f926ec4d4cc9b2be1aaf",
+        model_env="VLLM_TEST_LTX23_MODEL",
+        model_class_name="LTX2Pipeline",
+        checkpoint_repo="Lightricks/LTX-2.3",
+        checkpoint_filename="ltx-2.3-22b-dev.safetensors",
+        checkpoint_revision="4229404625088d21c4f112eb640fb04a0900ee25",
+        checkpoint_env="VLLM_TEST_LTX23_OFFICIAL_CHECKPOINT",
+        stg_block=28,
+        image_repo="huggingface/documentation-images",
+        image_filename="diffusers/svd/rocket.png",
+        image_revision="645d8364f0c7a101180b364811b5a11a362e4010",
+    ),
+)
+
+
+def _run(command: list[str], *, env: dict[str, str], timeout: int = 1800) -> None:
+    start = time.perf_counter()
+    subprocess.run(command, env=env, timeout=timeout, check=True)
+    print(f"{' '.join(command[:3])} finished in {time.perf_counter() - start:.1f}s")
+
+
+def _clone_official_source(root: Path, revision: str) -> None:
+    root.mkdir(parents=True)
+    repository = os.environ.get("VLLM_TEST_LTX_OFFICIAL_REPOSITORY", OFFICIAL_REPOSITORY)
+    subprocess.run(["git", "init", "-q", str(root)], check=True)
+    subprocess.run(["git", "-C", str(root), "remote", "add", "origin", repository], check=True)
+    last_error: subprocess.CalledProcessError | None = None
+    for attempt in range(3):
+        try:
+            subprocess.run(
+                ["git", "-C", str(root), "fetch", "--depth", "1", "origin", revision],
+                check=True,
+            )
+            last_error = None
+            break
+        except subprocess.CalledProcessError as error:
+            last_error = error
+            if attempt < 2:
+                time.sleep(5 * (attempt + 1))
+    if last_error is not None:
+        raise last_error
+    subprocess.run(["git", "-C", str(root), "checkout", "-q", "--detach", "FETCH_HEAD"], check=True)
+
+
+def _git_revision(root: Path) -> str | None:
+    try:
+        return subprocess.check_output(
+            ["git", "-C", str(root), "rev-parse", "HEAD"],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip()
+    except subprocess.CalledProcessError:
+        return None
+
+
+def _official_source(artifact_root: Path) -> tuple[Path, str]:
+    revision = os.environ.get("VLLM_TEST_LTX_OFFICIAL_REVISION", OFFICIAL_REVISION)
+    configured_root = os.environ.get("VLLM_TEST_LTX_OFFICIAL_ROOT")
+    root = Path(configured_root) if configured_root else artifact_root / f"official-source-{revision[:12]}"
+    actual_revision = _git_revision(root) if root.exists() else None
+    if actual_revision != revision and configured_root:
+        raise AssertionError(f"Official source revision mismatch: {actual_revision} != {revision}")
+    if actual_revision != revision:
+        if root.exists():
+            shutil.rmtree(root)
+        _clone_official_source(root, revision)
+        actual_revision = _git_revision(root)
+    assert actual_revision == revision, f"Official source revision mismatch: {actual_revision} != {revision}"
+    return root, revision
+
+
+def _official_runner_prefix() -> list[str]:
+    """Run the reference with its missing binary dependency isolated from CI."""
+    uv = shutil.which("uv")
+    assert uv is not None, "uv is required to run the pinned official LTX reference"
+    return [
+        uv,
+        "run",
+        "--no-project",
+        "--with",
+        f"openimageio=={OFFICIAL_OPENIMAGEIO_VERSION}",
+        "--python",
+        sys.executable,
+        "python",
+    ]
+
+
+def _resolve_model(case: LTXAccuracyCase) -> Path:
+    configured_model = os.environ.get(case.model_env)
+    if configured_model and Path(configured_model).exists():
+        return Path(configured_model)
+    model_id = configured_model or case.model_id
+    revision = os.environ.get(f"{case.model_env}_REVISION")
+    if revision is None and model_id == case.model_id:
+        revision = case.model_revision
+    return Path(
+        snapshot_download(
+            repo_id=model_id,
+            revision=revision,
+            allow_patterns=[
+                "model_index.json",
+                "audio_vae/*",
+                "connectors/*",
+                "processor/*",
+                "scheduler/*",
+                "text_encoder/config.json",
+                "text_encoder/generation_config.json",
+                "text_encoder/model*",
+                "tokenizer/*",
+                "transformer/*",
+                "vae/*",
+                "vocoder/*",
+            ],
+        )
+    )
+
+
+def _resolve_gemma_root(model: Path) -> Path:
+    configured_root = os.environ.get("VLLM_TEST_LTX_GEMMA_ROOT")
+    if configured_root:
+        root = Path(configured_root)
+        assert root.is_dir(), f"Gemma root not found: {root}"
+        return root
+    return model
+
+
+def _resolve_checkpoint(case: LTXAccuracyCase, model: Path) -> Path:
+    configured_checkpoint = os.environ.get(case.checkpoint_env)
+    if configured_checkpoint:
+        checkpoint = Path(configured_checkpoint)
+        assert checkpoint.is_file(), f"Official checkpoint not found: {checkpoint}"
+        return checkpoint
+    model_checkpoint = model / case.checkpoint_filename
+    if model_checkpoint.is_file():
+        return model_checkpoint
+    return Path(
+        hf_hub_download(
+            repo_id=case.checkpoint_repo,
+            filename=case.checkpoint_filename,
+            revision=case.checkpoint_revision,
+        )
+    )
+
+
+def _resolve_image(case: LTXAccuracyCase) -> Path | None:
+    if case.image_filename is None:
+        return None
+    if case.image_repo is None or case.image_revision is None:
+        raise ValueError(f"Incomplete image source for LTX accuracy case {case.name!r}.")
+    configured_image = os.environ.get("VLLM_TEST_LTX_I2V_IMAGE")
+    if configured_image:
+        image = Path(configured_image)
+        assert image.is_file(), f"LTX I2V conditioning image not found: {image}"
+        return image
+    return Path(
+        hf_hub_download(
+            repo_id=case.image_repo,
+            repo_type="dataset",
+            filename=case.image_filename,
+            revision=case.image_revision,
+        )
+    )
+
+
+def _request(case: LTXAccuracyCase, image: Path | None) -> dict[str, object]:
+    request: dict[str, object] = {
+        "prompt": case.prompt,
+        "negative_prompt": NEGATIVE_PROMPT,
+        "width": 512,
+        "height": 384,
+        "num_frames": 25,
+        "fps": 24,
+        "num_inference_steps": 20,
+        "seed": 42,
+        "video_cfg_scale": 3.0,
+        "audio_cfg_scale": 7.0,
+        "video_stg_scale": 1.0,
+        "audio_stg_scale": 1.0,
+        "video_modality_scale": 3.0,
+        "audio_modality_scale": 3.0,
+        "video_rescale_scale": 0.7,
+        "audio_rescale_scale": 0.7,
+        "video_stg_blocks": [case.stg_block],
+        "audio_stg_blocks": [case.stg_block],
+    }
+    if image is not None:
+        request["image"] = str(image.resolve())
+    return request
+
+
+def _video_metrics(reference: np.ndarray, prediction: np.ndarray) -> dict[str, float]:
+    assert reference.shape == prediction.shape
+    assert reference.ndim == 4 and reference.shape[-1] == 3
+    ssim_scores: list[float] = []
+    psnr_scores: list[float] = []
+    for reference_frame, prediction_frame in zip(reference, prediction, strict=True):
+        reference_tensor = torch.from_numpy(reference_frame).permute(2, 0, 1).unsqueeze(0)
+        prediction_tensor = torch.from_numpy(prediction_frame).permute(2, 0, 1).unsqueeze(0)
+        ssim_scores.append(float(StructuralSimilarityIndexMeasure(data_range=1.0)(prediction_tensor, reference_tensor)))
+        psnr_scores.append(float(PeakSignalNoiseRatio(data_range=1.0)(prediction_tensor, reference_tensor)))
+    difference = np.abs(reference.astype(np.float64) - prediction.astype(np.float64))
+    return {
+        "ssim_mean": float(np.mean(ssim_scores)),
+        "ssim_min": float(np.min(ssim_scores)),
+        "psnr_mean_db": float(np.mean(psnr_scores)),
+        "max_abs": float(difference.max()),
+        "mean_abs": float(difference.mean()),
+    }
+
+
+def _canonical_audio(audio: np.ndarray) -> np.ndarray:
+    while audio.ndim > 2 and audio.shape[0] == 1:
+        audio = audio[0]
+    return audio.astype(np.float64)
+
+
+def _audio_metrics(reference: np.ndarray, prediction: np.ndarray) -> dict[str, float | bool]:
+    reference = _canonical_audio(reference)
+    prediction = _canonical_audio(prediction)
+    assert reference.shape == prediction.shape
+    difference = reference - prediction
+    reference_norm = max(float(np.linalg.norm(reference)), 1e-12)
+    prediction_norm = max(float(np.linalg.norm(prediction)), 1e-12)
+    return {
+        "bitwise_equal": bool(np.array_equal(reference, prediction)),
+        "max_abs": float(np.abs(difference).max()),
+        "mean_abs": float(np.abs(difference).mean()),
+        "relative_l2": float(np.linalg.norm(difference) / reference_norm),
+        "cosine_similarity": float(np.vdot(reference.ravel(), prediction.ravel()) / (reference_norm * prediction_norm)),
+    }
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda case: case.name)
+@pytest.mark.full_model
+@pytest.mark.benchmark
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+def test_ltx_one_stage_matches_official(case: LTXAccuracyCase, accuracy_artifact_root: Path) -> None:
+    """Compare official and Omni raw AV outputs from the same E2E request."""
+    output_root = reset_artifact_dir(accuracy_artifact_root / "ltx_official" / case.name)
+    official_root, official_revision = _official_source(accuracy_artifact_root / "ltx_official")
+    model = _resolve_model(case)
+    gemma_root = _resolve_gemma_root(model)
+    checkpoint = _resolve_checkpoint(case, model)
+    image = _resolve_image(case)
+    request_path = output_root / "request.json"
+    request_path.write_text(json.dumps(_request(case, image), indent=2) + "\n")
+
+    runner = Path(__file__).with_name("run_ltx_reference.py")
+    runner_args = [
+        str(runner),
+        "--request",
+        str(request_path),
+    ]
+    if os.environ.get("VLLM_TEST_LTX_ENABLE_LAYERWISE_OFFLOAD", "").lower() in {"1", "true", "yes", "on"}:
+        runner_args.append("--enable-layerwise-offload")
+    env = os.environ.copy()
+    env["VLLM_TEST_LTX_OFFICIAL_REVISION"] = official_revision
+    env["PYTHONUNBUFFERED"] = "1"
+    repository_root = Path(__file__).resolve().parents[4]
+    existing_pythonpath = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = (
+        str(repository_root) if not existing_pythonpath else f"{repository_root}{os.pathsep}{existing_pythonpath}"
+    )
+
+    official_output = output_root / "official"
+    _run(
+        _official_runner_prefix()
+        + runner_args
+        + [
+            "--backend",
+            "official",
+            "--output-dir",
+            str(official_output),
+            "--official-root",
+            str(official_root),
+            "--checkpoint",
+            str(checkpoint),
+            "--gemma-root",
+            str(gemma_root),
+        ],
+        env=env,
+    )
+
+    omni_output = output_root / "omni"
+    _run(
+        [sys.executable]
+        + runner_args
+        + [
+            "--backend",
+            "omni",
+            "--output-dir",
+            str(omni_output),
+            "--model",
+            str(model),
+            "--model-class-name",
+            case.model_class_name,
+        ],
+        env=env,
+    )
+
+    official_metadata = json.loads((official_output / "metadata.json").read_text())
+    omni_metadata = json.loads((omni_output / "metadata.json").read_text())
+    assert official_metadata["attention_backend"] == ATTENTION_BACKEND
+    assert omni_metadata["attention_backend"] == ATTENTION_BACKEND
+    assert official_metadata["audio_sample_rate"] == omni_metadata["audio_sample_rate"]
+    video_metrics = _video_metrics(
+        np.load(official_output / "video.npy"),
+        np.load(omni_output / "video.npy"),
+    )
+    audio_metrics = _audio_metrics(
+        np.load(official_output / "audio.npy"),
+        np.load(omni_output / "audio.npy"),
+    )
+    result = {
+        "case": case.name,
+        "task": "i2v" if image is not None else "t2v",
+        "attention_backend": ATTENTION_BACKEND,
+        "official_revision": official_revision,
+        "model_revision": case.model_revision,
+        "checkpoint_revision": case.checkpoint_revision,
+        "video": video_metrics,
+        "audio": audio_metrics,
+    }
+    (output_root / "metrics.json").write_text(json.dumps(result, indent=2) + "\n")
+    print(json.dumps(result, indent=2))
+
+    assert video_metrics["ssim_mean"] >= VIDEO_SSIM_MEAN_THRESHOLD
+    assert video_metrics["ssim_min"] >= VIDEO_SSIM_MIN_THRESHOLD
+    assert video_metrics["psnr_mean_db"] >= VIDEO_PSNR_MEAN_THRESHOLD
+    assert audio_metrics["relative_l2"] <= AUDIO_RELATIVE_L2_THRESHOLD
+    assert audio_metrics["cosine_similarity"] >= AUDIO_COSINE_THRESHOLD
diff --git a/tests/e2e/accuracy/minimax_h3/__init__.py b/tests/e2e/accuracy/minimax_h3/__init__.py
new file mode 100644
index 000000000..0dbed1df5
--- /dev/null
+++ b/tests/e2e/accuracy/minimax_h3/__init__.py
@@ -0,0 +1 @@
+"""MiniMax H3 accuracy tests."""
diff --git a/tests/e2e/accuracy/minimax_h3/test_minimax_h3_t2va_similarity.py b/tests/e2e/accuracy/minimax_h3/test_minimax_h3_t2va_similarity.py
new file mode 100644
index 000000000..33c8ae065
--- /dev/null
+++ b/tests/e2e/accuracy/minimax_h3/test_minimax_h3_t2va_similarity.py
@@ -0,0 +1,216 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+import requests
+import torch
+from huggingface_hub import snapshot_download
+
+from tests.e2e.accuracy.helpers import (
+    assert_video_metadata,
+    assert_video_similarity_metrics,
+    probe_binary,
+    probe_video,
+    reset_artifact_dir,
+)
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServer
+
+pytestmark = [pytest.mark.benchmark, pytest.mark.diffusion, pytest.mark.full_model]
+
+MODEL_REPO_ID = "MiniMaxAI/MiniMax-H3"
+# The previously pinned revision was removed from the Hugging Face repository.
+MODEL_REVISION = "main"
+MODEL_ENV_VAR = "VLLM_TEST_MINIMAX_H3_FL2VA_MODEL"
+# Keep the official asset link visible in the test report. Hugging Face's
+# ``blob`` URL is an HTML page, so resolve it to the raw asset for download.
+REFERENCE_VIDEO_URL = "https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/assets/t2va.mp4"
+REFERENCE_VIDEO_SHA256 = "d66903241362e224085cc93f7a5e70fba6ab378d0ac6ff6af83acf2559849a42"
+
+# This is the official reproducible 768p T2VA prompt associated with
+# ``assets/t2va.mp4`` in the MiniMax H3 repository.
+PROMPT = """integrated_multimodal_description: [Shot 1] Cinematic, medium wide shot, pushing in slowly. In the cavernous, dimly lit bridge of a starship, sleek metallic consoles with glowing amber displays flank a massive, curved observation window. A female captain, in her late 40s with an athletic build and short silver-streaked black hair, stands in the center midground. She wears a structured, high-collared dark navy military tunic with silver chest insignias. Her back is to the camera, silhouetted against the cool, ambient starlight pouring through the thick glass. She stands perfectly still with her hands clasped tightly behind her back. Outside the window, a massive armada of jagged, dark grey dreadnoughts hovers in tight formation against a deep purple space nebula. The fleet's massive rear thrusters begin to glow with an intense, escalating bright blue light. [Shot 2] At 00:04.500, the camera cuts to a close-up of the captain's face and shakes strongly. The brilliant blue-white light from the fleet's gathering energy reflects vividly in her dark eyes. Suddenly, a blinding white flash floods through the window, completely washing out the background as the fleet jumps to hyperspace. The sheer spatial force violently jolts the bridge, causing the captain from Shot 1 to stagger slightly forward, her shoulders tensing as she visibly braces herself against the physical tremors. As the intense white light fades abruptly, leaving only the dim, empty expanse of the purple nebula reflected on her starkly lit skin, her jaw clenches, and she slowly closes her eyes in the newly emptied space.
+overall_soundscape: A low, resonant hum of the ship's ambient life support systems serves as the baseline, soon drowned out by an audible, escalating, high-pitched electronic whine as the fleet outside charges its hyperdrives. A massive, deafening, bass-heavy boom and sharp crackle erupts during the blinding flash, accompanied by the loud metallic creaking, rattling, and deep thuds of the bridge's bulkheads vibrating under immense physical stress. The intense roaring impact then cuts abruptly back to a hollow, echoing room tone, leaving only the faint, steady hum of the isolated bridge.
+non_diegetic_music: Cinematic space-opera orchestral score, slow tempo, featuring a solitary, mournful French horn melody over deep, sustained string dissonances that build rapidly in volume and intensity, swelling to a massive orchestral peak before snapping immediately into silence right after the jump."""
+
+WIDTH = 1344
+HEIGHT = 768
+FPS = 24
+NUM_FRAMES = 243
+NUM_INFERENCE_STEPS = 50
+FLOW_SHIFT = 12.0
+AUDIO_FLOW_SHIFT = 3.0
+DURATION_SECONDS = 10.0
+SEED = 0
+SSIM_THRESHOLD = 0.82
+PSNR_THRESHOLD = 20.0
+REQUEST_TIMEOUT_SECONDS = 60 * 60
+
+
+def _model_name() -> str:
+    configured = os.environ.get(MODEL_ENV_VAR)
+    if configured:
+        return configured
+
+    snapshot_root = snapshot_download(
+        repo_id=MODEL_REPO_ID,
+        revision=MODEL_REVISION,
+        allow_patterns=["FL2VA/**"],
+    )
+    return str(Path(snapshot_root) / "FL2VA")
+
+
+def _server_args() -> list[str]:
+    return [
+        "--trust-remote-code",
+        "--num-gpus",
+        "4",
+        "--usp",
+        "4",
+        "--ring",
+        "1",
+        "--use-hsdp",
+        "--hsdp-shard-size",
+        "4",
+        "--text-encoder-tp-size",
+        "4",
+        "--vae-patch-parallel-size",
+        "4",
+        "--vae-parallel-mode",
+        "tile",
+        "--vae-use-tiling",
+        "--diffusion-attention-backend",
+        "FLASH_ATTN",
+        "--stage-init-timeout",
+        "1800",
+        "--init-timeout",
+        "1800",
+    ]
+
+
+def _download_reference_video(output_dir: Path) -> Path:
+    reference_path = output_dir / "reference.mp4"
+    download_url = REFERENCE_VIDEO_URL.replace("/blob/", "/resolve/", 1)
+    response = requests.get(download_url, timeout=120)
+    response.raise_for_status()
+    content = response.content
+    digest = hashlib.sha256(content).hexdigest()
+    assert digest == REFERENCE_VIDEO_SHA256, (
+        f"Official MiniMax H3 T2VA reference changed: got {digest}, expected {REFERENCE_VIDEO_SHA256}"
+    )
+    reference_path.write_bytes(content)
+    return reference_path
+
+
+def _probe_audio(path: Path) -> dict[str, str | int]:
+    probe_binary("ffprobe")
+    result = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-select_streams",
+            "a:0",
+            "-show_entries",
+            "stream=codec_name,sample_rate,channels",
+            "-of",
+            "json",
+            str(path),
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    streams = json.loads(result.stdout).get("streams", [])
+    assert len(streams) == 1, f"Expected one audio stream in {path}, got {streams}"
+    stream = streams[0]
+    return {
+        "codec_name": str(stream["codec_name"]),
+        "sample_rate": int(stream["sample_rate"]),
+        "channels": int(stream["channels"]),
+    }
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=4)
+def test_minimax_h3_t2va_matches_official_reference(
+    accuracy_artifact_root: Path,
+) -> None:
+    if not torch.cuda.is_available():
+        pytest.skip("MiniMax H3 T2VA accuracy test requires CUDA.")
+
+    probe_binary("ffmpeg")
+    probe_binary("ffprobe")
+    output_dir = reset_artifact_dir(accuracy_artifact_root / "minimax_h3_t2va")
+    reference_path = _download_reference_video(output_dir)
+    generated_path = output_dir / "vllm_omni.mp4"
+
+    server_env = {
+        "FLASHINFER_DISABLE_VERSION_CHECK": "1",
+        "VLLM_WORKER_MULTIPROC_METHOD": "spawn",
+        "VLLM_OMNI_VIDEO_SYNC_TIMEOUT": str(REQUEST_TIMEOUT_SECONDS),
+        "VLLM_OMNI_STORAGE_PATH": str(output_dir / "storage"),
+    }
+    request_data = {
+        "prompt": PROMPT,
+        "width": str(WIDTH),
+        "height": str(HEIGHT),
+        "fps": str(FPS),
+        "num_inference_steps": str(NUM_INFERENCE_STEPS),
+        "flow_shift": str(FLOW_SHIFT),
+        "seed": str(SEED),
+        "extra_params": json.dumps(
+            {
+                "task": "t2va",
+                "duration": DURATION_SECONDS,
+                "aspect_ratio": "16:9",
+                "audio_flow_shift": AUDIO_FLOW_SHIFT,
+            }
+        ),
+    }
+
+    with OmniServer(
+        _model_name(),
+        _server_args(),
+        env_dict=server_env,
+        use_omni=True,
+    ) as server:
+        response = requests.post(
+            f"http://{server.host}:{server.port}/v1/videos/sync",
+            data=request_data,
+            timeout=REQUEST_TIMEOUT_SECONDS,
+        )
+
+    response.raise_for_status()
+    assert response.headers["content-type"].startswith("video/mp4")
+    generated_path.write_bytes(response.content)
+
+    reference_metadata = probe_video(reference_path)
+    generated_metadata = probe_video(generated_path)
+    assert reference_metadata == generated_metadata
+    assert_video_metadata(
+        generated_metadata,
+        width=WIDTH,
+        height=HEIGHT,
+        fps=FPS,
+        frame_count=NUM_FRAMES,
+    )
+
+    expected_audio = {"codec_name": "aac", "sample_rate": 32000, "channels": 2}
+    assert _probe_audio(reference_path) == expected_audio
+    assert _probe_audio(generated_path) == expected_audio
+
+    assert_video_similarity_metrics(
+        label="minimax_h3_t2va_official_reference",
+        online_path=generated_path,
+        offline_path=reference_path,
+        ssim_threshold=SSIM_THRESHOLD,
+        psnr_threshold=PSNR_THRESHOLD,
+    )
diff --git a/tests/e2e/accuracy/test_cosmos3_similarity.py b/tests/e2e/accuracy/test_cosmos3_similarity.py
index ff2350096..efa095fb1 100644
--- a/tests/e2e/accuracy/test_cosmos3_similarity.py
+++ b/tests/e2e/accuracy/test_cosmos3_similarity.py
@@ -42,8 +42,6 @@ def _server_args() -> list[str]:
     return [
         "--num-gpus",
         "1",
-        "--model-class-name",
-        "Cosmos3OmniDiffusersPipeline",
         "--stage-init-timeout",
         "900",
         "--init-timeout",
diff --git a/tests/e2e/accuracy/test_diffusers_backend_similarity.py b/tests/e2e/accuracy/test_diffusers_backend_similarity.py
index 529152290..9e5485361 100644
--- a/tests/e2e/accuracy/test_diffusers_backend_similarity.py
+++ b/tests/e2e/accuracy/test_diffusers_backend_similarity.py
@@ -56,6 +56,10 @@ SEED = 42
 SSIM_THRESHOLD = 0.97
 PSNR_THRESHOLD = 30.0
 
+# A single-shot latency measurement on this benchmark is dominated by CI variance
+# (see issue #5108). Warm up once, then report the median of several timed runs.
+NUM_TIMED_RUNS = 2
+
 VIDEO_PROMPT = "The bear in the image dances happily"
 VIDEO_WIDTH = 832
 VIDEO_HEIGHT = 480
@@ -181,25 +185,38 @@ def _run_vllm_omni_qwen_image(*, model: str, output_path: Path) -> tuple[Image.I
         # "--enable-diffusion-pipeline-profiler",
     ]
     with OmniServer(model, server_args, use_omni=True) as omni_server:
-        start_time = time.perf_counter()
-        response = requests.post(
-            f"http://{omni_server.host}:{omni_server.port}/v1/images/generations",
-            json={
-                "model": omni_server.model,
-                "prompt": PROMPT,
-                "size": f"{WIDTH}x{HEIGHT}",
-                "n": 1,
-                "response_format": "b64_json",
-                "negative_prompt": NEGATIVE_PROMPT,
-                "num_inference_steps": NUM_INFERENCE_STEPS,
-                "true_cfg_scale": TRUE_CFG_SCALE,
-                "seed": SEED,
-            },
-            timeout=600,
-        )
-        end_time = time.perf_counter()
-        e2e_latency = end_time - start_time
-        response.raise_for_status()
+        url = f"http://{omni_server.host}:{omni_server.port}/v1/images/generations"
+        request_json = {
+            "model": omni_server.model,
+            "prompt": PROMPT,
+            "size": f"{WIDTH}x{HEIGHT}",
+            "n": 1,
+            "response_format": "b64_json",
+            "negative_prompt": NEGATIVE_PROMPT,
+            "num_inference_steps": NUM_INFERENCE_STEPS,
+            "true_cfg_scale": TRUE_CFG_SCALE,
+            "seed": SEED,
+        }
+
+        def _timed_request() -> tuple[requests.Response, float]:
+            start_time = time.perf_counter()
+            response = requests.post(url, json=request_json, timeout=600)
+            end_time = time.perf_counter()
+            response.raise_for_status()
+            return response, end_time - start_time
+
+        # Warm up the client request path so first-request lazy init is not charged
+        # to the measurement, mirroring _diffusers_dummy_run on the diffusers side.
+        _timed_request()
+
+        latencies: list[float] = []
+        response: requests.Response | None = None
+        for _ in range(NUM_TIMED_RUNS):
+            response, latency = _timed_request()
+            latencies.append(latency)
+        e2e_latency = float(np.median(latencies))
+
+        assert response is not None
         payload = response.json()
         assert len(payload["data"]) == 1
         image_bytes = base64.b64decode(payload["data"][0]["b64_json"])
@@ -221,20 +238,25 @@ def _run_diffusers_qwen_image(*, model: str, output_path: Path) -> tuple[Image.I
         pipe.transformer.set_attention_backend("_flash_3_hub")
         _diffusers_dummy_run(pipe)
 
-        generator = torch.Generator(device="cuda").manual_seed(SEED)
+        latencies: list[float] = []
+        result = None
         with torch.inference_mode():
-            start_time = time.perf_counter()
-            result = pipe(  # pyright: ignore[reportCallIssue]
-                prompt=PROMPT,
-                negative_prompt=NEGATIVE_PROMPT,
-                width=WIDTH,
-                height=HEIGHT,
-                num_inference_steps=NUM_INFERENCE_STEPS,
-                true_cfg_scale=TRUE_CFG_SCALE,
-                generator=generator,
-            )
-            end_time = time.perf_counter()
-        e2e_latency = end_time - start_time
+            for _ in range(NUM_TIMED_RUNS):
+                generator = torch.Generator(device="cuda").manual_seed(SEED)
+                start_time = time.perf_counter()
+                result = pipe(  # pyright: ignore[reportCallIssue]
+                    prompt=PROMPT,
+                    negative_prompt=NEGATIVE_PROMPT,
+                    width=WIDTH,
+                    height=HEIGHT,
+                    num_inference_steps=NUM_INFERENCE_STEPS,
+                    true_cfg_scale=TRUE_CFG_SCALE,
+                    generator=generator,
+                )
+                end_time = time.perf_counter()
+                latencies.append(end_time - start_time)
+        e2e_latency = float(np.median(latencies))
+        assert result is not None
         output_image = result.images[0].convert("RGB")
         output_image.save(output_path)
         return output_image, e2e_latency
@@ -276,8 +298,14 @@ def test_diffusers_backend_t2i_matches_diffusers(model_id: str, accuracy_artifac
         ssim_threshold=SSIM_THRESHOLD,
         psnr_threshold=PSNR_THRESHOLD,
     )
+    # Latency is checked against a warmed median of NUM_TIMED_RUNS runs (see the
+    # _run_* helpers), so the assertion reflects steady-state rather than a single
+    # cold shot -- which is what previously made this check flaky (issue #5108).
+    # Correctness is additionally gated by the SSIM/PSNR assertions above.
     assert vllm_latency <= latency_threshold, (
-        f"VLLM latency ({vllm_latency:.2f}ms) is greater than {latency_threshold_factor * 100}% more than Diffusers latency ({diffusers_latency:.2f}ms)."
+        f"VLLM latency ({vllm_latency:.2f}ms) is greater than "
+        f"{latency_threshold_factor * 100}% more than Diffusers latency "
+        f"({diffusers_latency:.2f}ms)."
     )
 
 
diff --git a/tests/e2e/accuracy/test_dreamzero.py b/tests/e2e/accuracy/test_dreamzero.py
new file mode 100644
index 000000000..2507530b3
--- /dev/null
+++ b/tests/e2e/accuracy/test_dreamzero.py
@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""DreamZero OpenPI upstream parity accuracy test."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from tests.e2e.accuracy.helpers import (
+    DreamZeroUpstreamServer,
+    assert_dreamzero_logs_clean,
+    assert_dreamzero_upstream_log_matches_vllm_baseline,
+    dreamzero_parity_vllm_client,
+    load_dreamzero_upstream_modules,
+    normalize_dreamzero_metadata,
+)
+from tests.helpers.mark import hardware_test
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+os.environ["VLLM_TEST_CLEAN_GPU_MEMORY"] = "0"
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.slow]
+
+EXPECTED_METADATA = {
+    "image_resolution": [180, 320],
+    "n_external_cameras": 2,
+    "needs_wrist_camera": True,
+    "needs_stereo_camera": False,
+    "needs_session_id": True,
+    "action_space": "joint_position",
+}
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+def test_dreamzero_openpi_upstream_parity(tmp_path: Path) -> None:
+    """Assert vLLM OpenPI actions match the upstream DreamZero reference server."""
+    load_dreamzero_upstream_modules()
+
+    upstream_log = tmp_path / "dreamzero_upstream.log"
+    with DreamZeroUpstreamServer(log_path=upstream_log) as upstream_client:
+        upstream_metadata, upstream_outputs = upstream_client.collect_parity_outputs()
+    assert_dreamzero_logs_clean(upstream_log)
+    assert_dreamzero_upstream_log_matches_vllm_baseline(upstream_log)
+
+    with dreamzero_parity_vllm_client() as vllm_client:
+        vllm_metadata, vllm_outputs = vllm_client.collect_parity_outputs()
+
+    assert normalize_dreamzero_metadata(upstream_metadata) == EXPECTED_METADATA
+    assert normalize_dreamzero_metadata(vllm_metadata) == EXPECTED_METADATA
+
+    for idx, (vllm_action, upstream_action) in enumerate(zip(vllm_outputs, upstream_outputs, strict=True)):
+        np.testing.assert_allclose(
+            vllm_action,
+            upstream_action,
+            rtol=1e-2,
+            atol=1e-3,
+            err_msg=f"OpenPI step {idx} output mismatch",
+        )
diff --git a/tests/e2e/accuracy/test_gebench_h100_smoke.py b/tests/e2e/accuracy/test_gebench_h100_smoke.py
deleted file mode 100644
index b17c951e5..000000000
--- a/tests/e2e/accuracy/test_gebench_h100_smoke.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from benchmarks.accuracy.text_to_image.gbench import main as gbench_main
-from tests.e2e.accuracy.helpers import infer_model_label, reset_artifact_dir
-from tests.helpers.mark import hardware_test
-
-pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
-
-
-@pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
-@pytest.mark.skip(reason="#3256")
-def test_gebench_h100_smoke(
-    gebench_accuracy_servers,
-    accuracy_artifact_root: Path,
-    gebench_dataset_root: Path,
-    accuracy_workers: int,
-) -> None:
-    model_label = infer_model_label(gebench_accuracy_servers.generate_params.model).lower()
-    output_root = reset_artifact_dir(accuracy_artifact_root / f"gebench_{model_label}")
-
-    with gebench_accuracy_servers.generate_server() as generate_server:
-        for data_type in ("type3", "type4"):
-            assert (
-                gbench_main(
-                    [
-                        "generate",
-                        "--dataset-root",
-                        str(gebench_dataset_root),
-                        "--output-root",
-                        str(output_root),
-                        "--base-url",
-                        f"http://{generate_server.host}:{generate_server.port}",
-                        "--model",
-                        generate_server.model,
-                        "--data-type",
-                        data_type,
-                        "--width",
-                        "768",
-                        "--height",
-                        "576",
-                        "--output-compression",
-                        "98",
-                        "--num-inference-steps",
-                        "8",
-                        "--workers",
-                        str(accuracy_workers),
-                    ]
-                )
-                == 0
-            )
-
-    with gebench_accuracy_servers.judge_server() as judge_server:
-        for data_type in ("type3", "type4"):
-            assert (
-                gbench_main(
-                    [
-                        "evaluate",
-                        "--dataset-root",
-                        str(gebench_dataset_root),
-                        "--output-root",
-                        str(output_root),
-                        "--data-type",
-                        data_type,
-                        "--judge-base-url",
-                        f"http://{judge_server.host}:{judge_server.port}",
-                        "--judge-model",
-                        judge_server.model,
-                        "--judge-api-key",
-                        "EMPTY",
-                        "--workers",
-                        str(accuracy_workers),
-                    ]
-                )
-                == 0
-            )
-
-    assert gbench_main(["summarize", "--output-root", str(output_root)]) == 0
-
-    summary = json.loads((output_root / "summary.json").read_text(encoding="utf-8"))
-    assert "generation" in summary
-    assert "evaluation" in summary
-
-    for data_type in ("type3", "type4"):
-        assert data_type in summary["generation"]["by_type"]
-        assert summary["generation"]["by_type"][data_type]["count"] > 0
-        assert data_type in summary["evaluation"]["by_type"]
-        assert summary["evaluation"]["by_type"][data_type]["count"] > 0
-
-    assert summary["evaluation"]["overall_mean"] >= 0.45
-    assert summary["evaluation"]["by_type"]["type3"]["overall_mean"] >= 0.45
-    assert summary["evaluation"]["by_type"]["type4"]["overall_mean"] >= 0.45
diff --git a/tests/e2e/accuracy/test_gedit_bench_h100_smoke.py b/tests/e2e/accuracy/test_gedit_bench_h100_smoke.py
deleted file mode 100644
index a7831fac8..000000000
--- a/tests/e2e/accuracy/test_gedit_bench_h100_smoke.py
+++ /dev/null
@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from benchmarks.accuracy.image_to_image.gedit_bench import GROUPS
-from benchmarks.accuracy.image_to_image.gedit_bench import main as gedit_main
-from tests.e2e.accuracy.helpers import infer_model_label, reset_artifact_dir
-from tests.helpers.mark import hardware_test
-
-pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
-
-
-@pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
-@pytest.mark.skip(reason="#3257")
-def test_gedit_bench_h100_smoke(
-    gedit_accuracy_servers,
-    accuracy_artifact_root: Path,
-    gedit_dataset_root: Path,
-    gedit_samples_per_group: int,
-    accuracy_workers: int,
-) -> None:
-    model_label = infer_model_label(gedit_accuracy_servers.generate_params.model).lower()
-    output_root = reset_artifact_dir(accuracy_artifact_root / f"gedit_results_{model_label}")
-    score_root = reset_artifact_dir(accuracy_artifact_root / f"gedit_scores_{model_label}")
-    model_name = model_label
-
-    with gedit_accuracy_servers.generate_server() as generate_server:
-        assert (
-            gedit_main(
-                [
-                    "generate",
-                    "--dataset-ref",
-                    str(gedit_dataset_root),
-                    "--output-root",
-                    str(output_root),
-                    "--base-url",
-                    f"http://{generate_server.host}:{generate_server.port}",
-                    "--model",
-                    generate_server.model,
-                    "--model-name",
-                    model_name,
-                    "--task-type",
-                    "all",
-                    "--instruction-language",
-                    "all",
-                    "--samples-per-group",
-                    str(gedit_samples_per_group),
-                    "--workers",
-                    str(accuracy_workers),
-                ]
-            )
-            == 0
-        )
-
-    with gedit_accuracy_servers.judge_server() as judge_server:
-        assert (
-            gedit_main(
-                [
-                    "evaluate",
-                    "--dataset-ref",
-                    str(gedit_dataset_root),
-                    "--output-root",
-                    str(output_root),
-                    "--model-name",
-                    model_name,
-                    "--save-dir",
-                    str(score_root),
-                    "--task-type",
-                    "all",
-                    "--instruction-language",
-                    "all",
-                    "--judge-base-url",
-                    f"http://{judge_server.host}:{judge_server.port}",
-                    "--judge-model",
-                    judge_server.model,
-                    "--judge-api-key",
-                    "EMPTY",
-                    "--samples-per-group",
-                    str(gedit_samples_per_group),
-                    "--workers",
-                    str(accuracy_workers),
-                ]
-            )
-            == 0
-        )
-
-    csv_path = score_root / f"{model_name}_all_all_vie_score.csv"
-    assert gedit_main(["summarize", "--csv-path", str(csv_path), "--language", "all"]) == 0
-
-    summary_path = score_root / f"{model_name}_all_all_summary.json"
-    summary = json.loads(summary_path.read_text(encoding="utf-8"))
-    assert set(summary["languages"]) == {"en", "cn"}
-
-    for language in ["en", "cn"]:
-        language_summary = summary["languages"][language]
-        assert language_summary["overall"]["count"] is not None
-        assert language_summary["intersection"]["count"] is not None
-        assert language_summary["overall"]["Q_SC"] is not None
-        assert language_summary["overall"]["Q_PQ"] is not None
-        assert language_summary["overall"]["Q_O"] is not None
-
-        for group in GROUPS:
-            group_summary = language_summary["by_group"][group]
-            assert set(group_summary) == {"count", "Q_SC", "Q_PQ", "Q_O"}
-
-    assert summary["languages"]["en"]["overall"]["Q_SC"] >= 6.95
-    assert summary["languages"]["en"]["overall"]["Q_PQ"] >= 5.8
-    assert summary["languages"]["en"]["overall"]["Q_O"] >= 6.15
-    assert summary["languages"]["cn"]["overall"]["Q_SC"] >= 6.9
-    assert summary["languages"]["cn"]["overall"]["Q_PQ"] >= 5.7
-    assert summary["languages"]["cn"]["overall"]["Q_O"] >= 6.1
diff --git a/tests/e2e/accuracy/test_hunyuan_image3.py b/tests/e2e/accuracy/test_hunyuan_image3.py
index 00e77fc8f..f28ac16b9 100644
--- a/tests/e2e/accuracy/test_hunyuan_image3.py
+++ b/tests/e2e/accuracy/test_hunyuan_image3.py
@@ -28,6 +28,7 @@ from tests.e2e.accuracy.helpers import (
     model_output_dir,
 )
 from tests.helpers.mark import hardware_test
+from tests.helpers.media import get_asset_path
 from tests.helpers.runtime import OmniRunner, OmniServer
 from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
     build_prompt_tokens,
@@ -94,6 +95,7 @@ def _default_ar_dit_devices() -> tuple[str, str]:
 
 AR_DEVICES, DIT_DEVICES = _default_ar_dit_devices()
 MODEL_NAME = "tencent/HunyuanImage-3.0-Instruct"
+HUNYUAN_IMAGE_REF_PATH = get_asset_path("hunyuan/hunyuan_image_ref.png")
 NUM_INFERENCE_STEPS = 50
 GUIDANCE_SCALE = 2.5
 
@@ -141,7 +143,6 @@ _DEPLOY_CONFIG = {
     "connectors": {
         "shared_memory_connector": {
             "name": "SharedMemoryConnector",
-            "extra": {"shm_threshold_bytes": 65536},
         },
     },
     "stages": [
@@ -298,7 +299,7 @@ def _run_offline(deploy_config_path: str, output_path: Path) -> tuple[Image.Imag
     system_prompt_type = result.system_prompt_type
 
     ar_stop_token_ids = resolve_stop_token_ids(task="it2i", bot_task="think_recaption", tokenizer=tokenizer)
-    with OmniRunner(MODEL_PATH, deploy_config=deploy_config_path) as runner:
+    with OmniRunner(MODEL_PATH, deploy_config=deploy_config_path, trust_remote_code=True) as runner:
         params_list = list(runner.omni.default_sampling_params_list)
         for sp in params_list:
             if isinstance(sp, OmniDiffusionSamplingParams):
@@ -358,16 +359,17 @@ def _run_offline(deploy_config_path: str, output_path: Path) -> tuple[Image.Imag
     return image, cot_text, elapsed
 
 
-def _run_online(stage_configs_path: str, output_path: Path) -> tuple[Image.Image, str, float]:
+def _run_online(deploy_config_path: str, output_path: Path) -> tuple[Image.Image, str, float]:
     from benchmarks.accuracy.common import decode_base64_image, pil_to_png_bytes
 
     server_args = [
-        "--stage-configs-path",
-        stage_configs_path,
+        "--deploy-config",
+        deploy_config_path,
         "--stage-init-timeout",
         "300",
         "--init-timeout",
         "900",
+        "--trust-remote-code",
     ]
     try:
         with OmniServer(MODEL_PATH, server_args, use_omni=True) as omni_server:
@@ -414,7 +416,7 @@ def _run_online(stage_configs_path: str, output_path: Path) -> tuple[Image.Image
     torch.accelerator.device_count() < AR_TP_SIZE + DIT_TP_SIZE,
     reason=f"Needs {AR_TP_SIZE + DIT_TP_SIZE}+ GPUs ({AR_TP_SIZE} AR + {DIT_TP_SIZE} DiT)",
 )
-def test_image_to_image_alignment_online(accuracy_artifact_root: Path, accuracy_assets_root: Path) -> None:
+def test_image_to_image_alignment_online(accuracy_artifact_root: Path) -> None:
     """Online API test: same pipeline, same seed as offline → PSNR >= 10 dB."""
     if importlib.util.find_spec("FlagEmbedding") is None:
         raise ImportError("Missing dependency: FlagEmbedding\nInstall with: pip install FlagEmbedding")
@@ -431,7 +433,7 @@ def test_image_to_image_alignment_online(accuracy_artifact_root: Path, accuracy_
     scorer = SemanticSimilarityScorer()
     clip_scorer = CLIPScorer()
     cot_results = scorer.text_similarity(online_cot, COT_REF)
-    image_ref = Image.open(str(accuracy_assets_root / "hunyuan_image_ref.png")).convert("RGB")
+    image_ref = Image.open(HUNYUAN_IMAGE_REF_PATH).convert("RGB")
     image_clip_score = clip_scorer.image_image_score(online_image, image_ref)
     ssim_value, psnr_value = compute_image_ssim_psnr(prediction=online_image, reference=image_ref, compare_mode="RGB")
 
@@ -491,7 +493,12 @@ def _run_dit_model(
         os.environ["VLLM_NVFP4_GEMM_BACKEND"] = nvfp4_backend
 
     try:
-        with OmniRunner(model, deploy_config=deploy_config_path, mode="text-to-image") as runner:
+        with OmniRunner(
+            model,
+            deploy_config=deploy_config_path,
+            mode="text-to-image",
+            trust_remote_code=True,
+        ) as runner:
             generator = torch.Generator(device=current_omni_platform.device_type or "cuda").manual_seed(SEED)
             params = OmniDiffusionSamplingParams(
                 height=QUANT_HEIGHT,
@@ -524,7 +531,7 @@ def _run_dit_model(
     torch.accelerator.device_count() < AR_TP_SIZE + DIT_TP_SIZE,
     reason=f"Needs {AR_TP_SIZE + DIT_TP_SIZE}+ GPUs ({AR_TP_SIZE} AR + {DIT_TP_SIZE} DiT)",
 )
-def test_image_to_image_alignment(accuracy_artifact_root: Path, accuracy_assets_root: Path) -> None:
+def test_image_to_image_alignment(accuracy_artifact_root: Path) -> None:
     if importlib.util.find_spec("FlagEmbedding") is None:
         raise ImportError("Missing dependency: FlagEmbedding\nInstall with: pip install FlagEmbedding")
     from tabulate import tabulate  # lazy import
@@ -540,7 +547,7 @@ def test_image_to_image_alignment(accuracy_artifact_root: Path, accuracy_assets_
     scorer = SemanticSimilarityScorer()
     clip_scorer = CLIPScorer()
     cot_results = scorer.text_similarity(omni_cot, COT_REF)
-    image_ref = Image.open(str(accuracy_assets_root / "hunyuan_image_ref.png")).convert("RGB")
+    image_ref = Image.open(HUNYUAN_IMAGE_REF_PATH).convert("RGB")
     image_clip_score = clip_scorer.image_image_score(omni_image, image_ref)
     ssim_value, psnr_value = compute_image_ssim_psnr(prediction=omni_image, reference=image_ref, compare_mode="RGB")
 
diff --git a/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py b/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
index 6ac930f46..16cd9c13c 100644
--- a/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
+++ b/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
@@ -3,6 +3,7 @@ from __future__ import annotations
 import base64
 import copy
 import io
+import logging
 import os
 import tempfile
 from pathlib import Path
@@ -14,10 +15,13 @@ from PIL import Image
 
 from tests.e2e.accuracy.helpers import assert_images_pixel_close, assert_similarity, model_output_dir
 from tests.helpers.mark import hardware_test
+from tests.helpers.media import get_asset_path
 from tests.helpers.runtime import OmniServer
 
 pytestmark = [pytest.mark.full_model, pytest.mark.diffusion]
 
+logger = logging.getLogger(__name__)
+
 MODEL_NAME = "tencent/HunyuanImage-3.0-Instruct"
 SEED = 42
 NUM_INFERENCE_STEPS = 50
@@ -28,10 +32,28 @@ PROMPT = "A brown and white dog is running on the grass."
 MEAN_THRESHOLD = 3e-2
 P99_THRESHOLD = 3e-1
 SSIM_THRESHOLD = 0.97
-PSNR_THRESHOLD = 30.0
+PSNR_THRESHOLD_CUDA = 30.0
+PSNR_THRESHOLD_NPU = 26.0
+
+
+def _psnr_threshold() -> float:
+    from vllm_omni.platforms import current_omni_platform
+
+    return PSNR_THRESHOLD_NPU if current_omni_platform.is_npu() else PSNR_THRESHOLD_CUDA
+
 
 _REPO_ROOT = Path(__file__).resolve().parent.parent.parent.parent
-BASELINE_PATH = _REPO_ROOT / "tests" / "assets" / "hunyuan" / "hunyuan_baseline.png"
+
+
+def _baseline_path() -> Path:
+    from vllm_omni.platforms import current_omni_platform
+
+    suffix = "_npu" if current_omni_platform.is_npu() else ""
+    path = get_asset_path(f"hunyuan/hunyuan_baseline{suffix}.png")
+    assert path.exists(), f"Baseline image not found at {path}"
+    return path
+
+
 _OFFLINE_SCRIPT = _REPO_ROOT / "examples" / "offline_inference" / "hunyuan_image3" / "end2end.py"
 
 # DiT-only deploy config with trust_remote_code (based on hunyuan_image3_dit.yaml).
@@ -48,15 +70,17 @@ _DEPLOY_CONFIG = {
             "trust_remote_code": True,
             "devices": "0,1,2,3",  # set dynamically by _write_deploy_config
             "vae_use_slicing": False,
+            "moe_backend": "flashinfer_cutlass",
             "vae_use_tiling": False,
             "parallel_config": {
                 "pipeline_parallel_size": 1,
                 "data_parallel_size": 1,
-                "tensor_parallel_size": 4,
+                "tensor_parallel_size": 1,
                 "enable_expert_parallel": True,
                 "sequence_parallel_size": 1,
                 "ulysses_degree": 1,
                 "ring_degree": 1,
+                "allgather_degree": 4,
                 "cfg_parallel_size": 1,
                 "vae_patch_parallel_size": 1,
                 "use_hsdp": False,
@@ -68,6 +92,23 @@ _DEPLOY_CONFIG = {
             },
         },
     ],
+    "platforms": {
+        "npu": {
+            "stages": [
+                {
+                    "stage_id": 0,
+                    "gpu_memory_utilization": 0.65,
+                    "devices": "0,1,2,3",
+                    "moe_backend": "auto",
+                    "max_num_batched_tokens": 32768,
+                    "parallel_config": {
+                        "tensor_parallel_size": 4,
+                        "enable_expert_parallel": True,
+                    },
+                },
+            ],
+        },
+    },
 }
 
 
@@ -82,9 +123,48 @@ def _devices() -> str:
 def _write_deploy_config(path: Path) -> None:
     config = copy.deepcopy(_DEPLOY_CONFIG)
     devices = _devices()
+    num_devices = len(devices.split(","))
     config["stages"][0]["devices"] = devices
-    config["stages"][0]["parallel_config"]["tensor_parallel_size"] = len(devices.split(","))
-    path.write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
+    parallel_config = config["stages"][0]["parallel_config"]
+    if parallel_config.get("allgather_degree", 1) > 1:
+        parallel_config["allgather_degree"] = num_devices
+    elif parallel_config.get("tensor_parallel_size", 1) > 1:
+        parallel_config["tensor_parallel_size"] = num_devices
+
+    sequence_parallel_size = (
+        parallel_config.get("allgather_degree", 1)
+        if parallel_config.get("allgather_degree", 1) > 1
+        else parallel_config.get("ulysses_degree", 1) * parallel_config.get("ring_degree", 1)
+    )
+    configured_world_size = (
+        parallel_config.get("pipeline_parallel_size", 1)
+        * parallel_config.get("data_parallel_size", 1)
+        * parallel_config.get("tensor_parallel_size", 1)
+        * sequence_parallel_size
+        * parallel_config.get("cfg_parallel_size", 1)
+    )
+    assert configured_world_size == num_devices, (
+        f"Configured parallel world size ({configured_world_size}) does not match "
+        f"the number of devices ({num_devices}): {parallel_config}"
+    )
+
+    parallel_config["sequence_parallel_size"] = sequence_parallel_size
+    config_text = yaml.dump(config, default_flow_style=False, sort_keys=False)
+    path.write_text(config_text)
+    logger.info(
+        "HunyuanImage3 pixel accuracy deploy config:\n"
+        "  path=%s\n"
+        "  CUDA_VISIBLE_DEVICES=%s\n"
+        "  devices=%s\n"
+        "  tensor_parallel_size=%s\n"
+        "  allgather_degree=%s\n%s",
+        path,
+        os.environ.get("CUDA_VISIBLE_DEVICES", "<unset>"),
+        devices,
+        parallel_config.get("tensor_parallel_size", 1),
+        parallel_config.get("allgather_degree", 1),
+        config_text,
+    )
 
 
 def _run_vllm_omni_hunyuan_image3_online(*, model: str, deploy_config: str, output_path: Path) -> Image.Image:
@@ -171,8 +251,8 @@ def _run_vllm_omni_hunyuan_image3_offline(*, model: str, deploy_config: str, out
 
 
 def _assert_against_baseline(image: Image.Image, label: str) -> None:
-    assert BASELINE_PATH.exists(), f"Baseline image not found at {BASELINE_PATH}"
-    baseline_image = Image.open(BASELINE_PATH).convert("RGB")
+    baseline_path = _baseline_path()
+    baseline_image = Image.open(baseline_path).convert("RGB")
 
     assert_images_pixel_close(
         model_name=f"{MODEL_NAME} ({label} vs baseline)",
@@ -186,11 +266,11 @@ def _assert_against_baseline(image: Image.Image, label: str) -> None:
         vllm_image=image,
         diffusers_image=baseline_image,
         ssim_threshold=SSIM_THRESHOLD,
-        psnr_threshold=PSNR_THRESHOLD,
+        psnr_threshold=_psnr_threshold(),
     )
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=4)
 def test_hunyuan_image3_pixel_accuracy_online(accuracy_artifact_root: Path) -> None:
     model = _model_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME)
@@ -204,7 +284,7 @@ def test_hunyuan_image3_pixel_accuracy_online(accuracy_artifact_root: Path) -> N
     _assert_against_baseline(image, "online")
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=4)
 def test_hunyuan_image3_pixel_accuracy_offline(accuracy_artifact_root: Path) -> None:
     model = _model_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME)
diff --git a/tests/e2e/accuracy/test_ltx2_3_video_similarity.py b/tests/e2e/accuracy/test_ltx2_3_video_similarity.py
deleted file mode 100644
index 7fb2297a2..000000000
--- a/tests/e2e/accuracy/test_ltx2_3_video_similarity.py
+++ /dev/null
@@ -1,410 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""
-SSIM/PSNR accuracy tests for LTX-2.3.
-
-1. **Transformer parity** (``test_ltx2_3_transformer_matches_diffusers``):
-   Swaps our custom transformer into diffusers' ``LTX2Pipeline`` to measure
-   numerical parity in isolation.  Thresholds: SSIM >= 0.95, PSNR >= 28 dB.
-   Result: SSIM 0.999987 (bit-identical).
-
-2. **Full pipeline** (``test_ltx2_3_pipeline_matches_diffusers``):
-   Runs the full vLLM-Omni serving stack (``OmniServer`` -> HTTP API) and
-   compares per-frame against stock diffusers.  Currently skipped because
-   the OmniServer subprocess creates a different RNG state than in-process
-   diffusers, producing different initial latents from the same seed.
-   This is a test infrastructure limitation, not a model accuracy issue.
-"""
-
-from __future__ import annotations
-
-import gc
-import os
-import tempfile
-from pathlib import Path
-
-import diffusers
-import numpy as np
-import pytest
-import requests
-import torch
-from PIL import Image
-
-from tests.e2e.accuracy.helpers import compute_image_ssim_psnr, model_output_dir
-from tests.helpers.env import run_post_test_cleanup, run_pre_test_cleanup
-from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniServer
-
-# Parse diffusers version for compatibility check
-_DIFFUSERS_VERSION = tuple(int(x) for x in diffusers.__version__.split(".")[:2] if x.isdigit())
-_DIFFUSERS_038 = _DIFFUSERS_VERSION >= (0, 38)
-
-MODEL_ID = "dg845/LTX-2.3-Diffusers"
-MODEL_ENV_VAR = "VLLM_TEST_LTX23_MODEL"
-PROMPT = "A lighthouse on a rocky cliff at sunset, waves crashing below, golden hour lighting"
-NEGATIVE_PROMPT = "blurry, low quality, distorted, watermark"
-WIDTH = 512
-HEIGHT = 384
-NUM_FRAMES = 25  # ~1 second at 24fps
-NUM_INFERENCE_STEPS = 20
-GUIDANCE_SCALE = 4.0
-SEED = 42
-
-# Transformer-swap test: near-identical output expected
-TRANSFORMER_SSIM_THRESHOLD = 0.95
-TRANSFORMER_PSNR_THRESHOLD = 28.0
-
-# Full-pipeline test: allows minor divergence from RNG / pipeline differences
-PIPELINE_SSIM_THRESHOLD = 0.94
-PIPELINE_PSNR_THRESHOLD = 28.0
-
-
-def _model_name() -> str:
-    return os.environ.get(MODEL_ENV_VAR, MODEL_ID)
-
-
-def _local_files_only(model: str) -> bool:
-    return Path(model).exists()
-
-
-# ---------------------------------------------------------------------------
-# Frame extraction helpers
-# ---------------------------------------------------------------------------
-
-
-def _video_to_frames(video_np: np.ndarray) -> list[Image.Image]:
-    """Convert numpy video to list of PIL Images."""
-    while video_np.ndim > 4:
-        video_np = video_np[0]
-    if video_np.dtype in (np.float32, np.float64, np.float16):
-        video_np = np.clip(video_np * 255, 0, 255).astype(np.uint8)
-    return [Image.fromarray(video_np[t]) for t in range(video_np.shape[0])]
-
-
-def _extract_diffusers_frames(result) -> list[Image.Image]:
-    """Extract frames from diffusers pipeline output."""
-    video = result.frames
-    if isinstance(video, np.ndarray):
-        return _video_to_frames(video)
-    if isinstance(video, list):
-        if isinstance(video[0], list):
-            return [img.convert("RGB") for img in video[0]]
-        if isinstance(video[0], Image.Image):
-            return [img.convert("RGB") for img in video]
-    raise ValueError(f"Unexpected output type: {type(video)}")
-
-
-def _extract_mp4_frames(mp4_bytes: bytes) -> list[Image.Image]:
-    """Extract frames from an MP4 video using ffmpeg."""
-    import subprocess
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        mp4_path = os.path.join(tmpdir, "video.mp4")
-        with open(mp4_path, "wb") as f:
-            f.write(mp4_bytes)
-
-        # Extract video frames as PNG files using ffmpeg
-        frame_pattern = os.path.join(tmpdir, "frame_%04d.png")
-        subprocess.run(
-            ["ffmpeg", "-i", mp4_path, "-vsync", "0", frame_pattern],
-            capture_output=True,
-            check=True,
-        )
-
-        # Load frames in order
-        frames = []
-        i = 1
-        while True:
-            fpath = os.path.join(tmpdir, f"frame_{i:04d}.png")
-            if not os.path.exists(fpath):
-                break
-            frames.append(Image.open(fpath).convert("RGB").copy())
-            i += 1
-        return frames
-
-
-# ---------------------------------------------------------------------------
-# Comparison helper
-# ---------------------------------------------------------------------------
-
-
-def _assert_video_similarity(
-    *,
-    model_name: str,
-    vllm_frames: list[Image.Image],
-    diffusers_frames: list[Image.Image],
-    ssim_threshold: float,
-    psnr_threshold: float,
-) -> tuple[float, float]:
-    """Compare video frames and assert SSIM/PSNR meet thresholds."""
-    min_frames = min(len(vllm_frames), len(diffusers_frames))
-    assert min_frames > 0, "No frames to compare"
-
-    ssim_scores = []
-    psnr_scores = []
-    for i in range(min_frames):
-        ssim_val, psnr_val = compute_image_ssim_psnr(
-            prediction=vllm_frames[i],
-            reference=diffusers_frames[i],
-        )
-        ssim_scores.append(ssim_val)
-        psnr_scores.append(psnr_val)
-
-    avg_ssim = sum(ssim_scores) / len(ssim_scores)
-    avg_psnr = sum(psnr_scores) / len(psnr_scores)
-
-    print(f"\n{model_name} video similarity ({min_frames} frames):")
-    print(f"  SSIM: avg={avg_ssim:.6f}, min={min(ssim_scores):.6f}, threshold>={ssim_threshold:.6f}")
-    print(f"  PSNR: avg={avg_psnr:.6f} dB, min={min(psnr_scores):.6f} dB, threshold>={psnr_threshold:.6f} dB")
-
-    assert avg_ssim >= ssim_threshold, f"SSIM below threshold: got {avg_ssim:.6f}, expected >= {ssim_threshold:.6f}."
-    assert avg_psnr >= psnr_threshold, f"PSNR below threshold: got {avg_psnr:.6f}, expected >= {psnr_threshold:.6f}."
-    return avg_ssim, avg_psnr
-
-
-# ---------------------------------------------------------------------------
-# Diffusers baseline (shared by both tests)
-# ---------------------------------------------------------------------------
-
-
-def _run_diffusers_baseline(model: str, output_dir: Path) -> list[Image.Image]:
-    """Generate video using stock diffusers LTX2Pipeline."""
-    from diffusers import LTX2Pipeline
-
-    run_pre_test_cleanup()
-    pipe = None
-    try:
-        pipe = LTX2Pipeline.from_pretrained(
-            model, torch_dtype=torch.bfloat16, local_files_only=_local_files_only(model)
-        ).to("cuda")
-
-        generator = torch.Generator(device="cuda").manual_seed(SEED)
-        result = pipe(
-            prompt=PROMPT,
-            negative_prompt=NEGATIVE_PROMPT,
-            width=WIDTH,
-            height=HEIGHT,
-            num_frames=NUM_FRAMES,
-            num_inference_steps=NUM_INFERENCE_STEPS,
-            guidance_scale=GUIDANCE_SCALE,
-            generator=generator,
-            output_type="np",
-        )
-        frames = _extract_diffusers_frames(result)
-        for i, f in enumerate(frames):
-            f.save(output_dir / f"diffusers_frame_{i:04d}.png")
-        return frames
-    finally:
-        del pipe
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.accelerator.empty_cache()
-        run_post_test_cleanup()
-
-
-# ---------------------------------------------------------------------------
-# Test 1: Transformer-swap parity
-# ---------------------------------------------------------------------------
-
-
-def _run_with_custom_transformer(model: str, output_dir: Path) -> list[Image.Image]:
-    """Run diffusers pipeline with our custom transformer swapped in."""
-    from contextlib import nullcontext
-
-    from diffusers import LTX2Pipeline
-    from vllm.config import VllmConfig, set_current_vllm_config
-    from vllm.distributed.parallel_state import init_distributed_environment, initialize_model_parallel
-
-    from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import create_transformer_from_config, load_transformer_config
-
-    vllm_config = VllmConfig()
-    ctx = set_current_vllm_config(vllm_config)
-    ctx.__enter__()
-
-    if not torch.distributed.is_initialized():
-        os.environ.setdefault("MASTER_ADDR", "localhost")
-        os.environ.setdefault("MASTER_PORT", "29503")
-        os.environ.setdefault("RANK", "0")
-        os.environ.setdefault("WORLD_SIZE", "1")
-        init_distributed_environment(world_size=1, rank=0, local_rank=0)
-        initialize_model_parallel(tensor_model_parallel_size=1)
-
-    local = _local_files_only(model)
-    pipe = LTX2Pipeline.from_pretrained(model, torch_dtype=torch.bfloat16, local_files_only=local)
-
-    transformer_config = load_transformer_config(model, "transformer", local)
-    our_transformer = create_transformer_from_config(transformer_config)
-
-    diffusers_state = dict(pipe.transformer.named_parameters())
-
-    def _weight_iter():
-        for name, param in diffusers_state.items():
-            yield name, param.data
-
-    our_transformer.load_weights(_weight_iter())
-    our_transformer = our_transformer.to(dtype=torch.bfloat16, device="cuda").eval()
-
-    # Compatibility shims for diffusers pipeline
-    our_transformer.dtype = torch.bfloat16
-    if not hasattr(our_transformer, "cache_context"):
-        our_transformer.cache_context = lambda name: nullcontext()
-
-    del pipe.transformer
-    pipe.transformer = our_transformer
-    for name, component in pipe.components.items():
-        if name != "transformer" and hasattr(component, "to"):
-            try:
-                component.to("cuda")
-            except Exception:
-                pass
-
-    generator = torch.Generator(device="cuda").manual_seed(SEED)
-    result = pipe(
-        prompt=PROMPT,
-        negative_prompt=NEGATIVE_PROMPT,
-        width=WIDTH,
-        height=HEIGHT,
-        num_frames=NUM_FRAMES,
-        num_inference_steps=NUM_INFERENCE_STEPS,
-        guidance_scale=GUIDANCE_SCALE,
-        generator=generator,
-        output_type="np",
-    )
-    frames = _extract_diffusers_frames(result)
-    for i, f in enumerate(frames):
-        f.save(output_dir / f"vllm_transformer_frame_{i:04d}.png")
-
-    del pipe, result, our_transformer
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.accelerator.empty_cache()
-    return frames
-
-
-@pytest.mark.full_model
-@pytest.mark.benchmark
-@pytest.mark.diffusion
-@pytest.mark.skipif(
-    not _DIFFUSERS_038, reason="LTX-2.3 requires diffusers >= 0.38.0 for cross_attn_mod and BWE vocoder"
-)
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
-def test_ltx2_3_transformer_matches_diffusers(accuracy_artifact_root: Path) -> None:
-    """Transformer-level parity: swap our transformer into diffusers pipeline.
-
-    Isolates transformer numerical accuracy from pipeline-level differences.
-    Both runs use diffusers' denoising loop, CFG, scheduler, and RNG.
-    """
-    model = _model_name()
-    output_dir = model_output_dir(accuracy_artifact_root, MODEL_ID)
-
-    diffusers_frames = _run_diffusers_baseline(model=model, output_dir=output_dir)
-    vllm_frames = _run_with_custom_transformer(model=model, output_dir=output_dir)
-
-    _assert_video_similarity(
-        model_name=f"{MODEL_ID} (transformer-swap)",
-        vllm_frames=vllm_frames,
-        diffusers_frames=diffusers_frames,
-        ssim_threshold=TRANSFORMER_SSIM_THRESHOLD,
-        psnr_threshold=TRANSFORMER_PSNR_THRESHOLD,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 2: Full pipeline (OmniServer → HTTP API vs diffusers)
-# ---------------------------------------------------------------------------
-
-
-def _run_vllm_omni_serving(model: str, output_dir: Path) -> list[Image.Image]:
-    """Generate video via the full vLLM-Omni serving stack."""
-    server_args = [
-        "--model-class-name",
-        "LTX23Pipeline",
-        "--stage-init-timeout",
-        "600",
-    ]
-    with OmniServer(model, server_args, use_omni=True) as server:
-        # Submit generation request
-        response = requests.post(
-            f"http://{server.host}:{server.port}/v1/videos",
-            files={
-                "prompt": (None, PROMPT),
-                "negative_prompt": (None, NEGATIVE_PROMPT),
-                "model": (None, server.model),
-                "num_frames": (None, str(NUM_FRAMES)),
-                "fps": (None, "24"),
-                "size": (None, f"{WIDTH}x{HEIGHT}"),
-                "num_inference_steps": (None, str(NUM_INFERENCE_STEPS)),
-                "guidance_scale": (None, str(GUIDANCE_SCALE)),
-                "seed": (None, str(SEED)),
-            },
-            timeout=120,
-        )
-        response.raise_for_status()
-        video_id = response.json()["id"]
-
-        # Poll for completion
-        import time
-
-        for _ in range(120):
-            status_resp = requests.get(
-                f"http://{server.host}:{server.port}/v1/videos/{video_id}",
-                timeout=30,
-            )
-            status_resp.raise_for_status()
-            status = status_resp.json()["status"]
-            if status == "completed":
-                break
-            if status in ("error", "failed"):
-                raise RuntimeError(f"Video generation failed: {status_resp.json()}")
-            time.sleep(5)
-        else:
-            raise TimeoutError(f"Video generation timed out after 600s (id={video_id})")
-
-        # Download video content
-        content_resp = requests.get(
-            f"http://{server.host}:{server.port}/v1/videos/{video_id}/content",
-            timeout=120,
-        )
-        content_resp.raise_for_status()
-        mp4_bytes = content_resp.content
-
-    # Save MP4
-    mp4_path = output_dir / "vllm_omni_pipeline.mp4"
-    with open(mp4_path, "wb") as f:
-        f.write(mp4_bytes)
-
-    # Extract frames
-    frames = _extract_mp4_frames(mp4_bytes)
-    for i, frame in enumerate(frames):
-        frame.save(output_dir / f"vllm_pipeline_frame_{i:04d}.png")
-    return frames
-
-
-@pytest.mark.full_model
-@pytest.mark.benchmark
-@pytest.mark.diffusion
-@pytest.mark.skipif(
-    not _DIFFUSERS_038, reason="LTX-2.3 requires diffusers >= 0.38.0 for cross_attn_mod and BWE vocoder"
-)
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
-def test_ltx2_3_pipeline_matches_diffusers(accuracy_artifact_root: Path) -> None:
-    """Full-pipeline parity: vLLM-Omni serving stack vs diffusers.
-
-    Runs the complete vLLM-Omni OmniServer (subprocess, HTTP API, video
-    encoding) and compares per-frame against stock diffusers output.
-    Follows the Wan2.2 / Qwen Image pattern with seed-based determinism.
-    """
-    model = _model_name()
-    output_dir = model_output_dir(accuracy_artifact_root, MODEL_ID)
-
-    diffusers_frames = _run_diffusers_baseline(model=model, output_dir=output_dir)
-    vllm_frames = _run_vllm_omni_serving(model=model, output_dir=output_dir)
-
-    _assert_video_similarity(
-        model_name=f"{MODEL_ID} (full-pipeline)",
-        vllm_frames=vllm_frames,
-        diffusers_frames=diffusers_frames,
-        ssim_threshold=PIPELINE_SSIM_THRESHOLD,
-        psnr_threshold=PIPELINE_PSNR_THRESHOLD,
-    )
diff --git a/tests/e2e/accuracy/test_qwen_image_edit.py b/tests/e2e/accuracy/test_qwen_image_edit.py
index 338758cc0..9ee9c2c87 100644
--- a/tests/e2e/accuracy/test_qwen_image_edit.py
+++ b/tests/e2e/accuracy/test_qwen_image_edit.py
@@ -14,6 +14,7 @@ from benchmarks.accuracy.common import decode_base64_image, pil_to_png_bytes
 from tests.e2e.accuracy.helpers import assert_images_pixel_close, assert_similarity, model_output_dir
 from tests.helpers.env import run_post_test_cleanup, run_pre_test_cleanup
 from tests.helpers.mark import hardware_test
+from tests.helpers.media import get_asset_path
 from tests.helpers.runtime import OmniServer
 
 pytestmark = [pytest.mark.full_model, pytest.mark.diffusion]
@@ -46,10 +47,9 @@ EDIT_2511_PROMPT = (
     "（帽子紧贴头顶，未贴合部分可调整帽子摆放角度达到完全贴合）， 头部与身体过渡必须自然，无拼接痕迹，"
     "无额外元素出现在头部四周，纯白背景，不要出现绿色圆圈"
 )
-EDIT_2511_ASSET_DIR = Path(__file__).resolve().parent / "assets"
 EDIT_2511_IMAGE_PATHS = [
-    EDIT_2511_ASSET_DIR / "qwen_image_edit_2511_test1.png",
-    EDIT_2511_ASSET_DIR / "qwen_image_edit_2511_test2.png",
+    get_asset_path("qwen_image_edit/qwen_image_edit_2511_test1.png"),
+    get_asset_path("qwen_image_edit/qwen_image_edit_2511_test2.png"),
 ]
 
 PROMPT_SINGLE_IMAGE = "The input is a 2D cartoon bear mascot. Restyle it into a painterly oil artwork with warm colors while preserving the main structure."
diff --git a/tests/dreamzero/upstream/upstream_socket_server_no_compile.py b/tests/e2e/accuracy/upstream_mock/upstream_socket_server_no_compile.py
similarity index 98%
rename from tests/dreamzero/upstream/upstream_socket_server_no_compile.py
rename to tests/e2e/accuracy/upstream_mock/upstream_socket_server_no_compile.py
index a9ef7a3d0..e6fccdd23 100644
--- a/tests/dreamzero/upstream/upstream_socket_server_no_compile.py
+++ b/tests/e2e/accuracy/upstream_mock/upstream_socket_server_no_compile.py
@@ -24,7 +24,7 @@ PyTorch SDPA (`ATTENTION_BACKEND=torch`) for this subprocess only.
 Usage:
     PYTHONPATH="${DREAMZERO_REPO}" \\
       .venv/bin/python -m torch.distributed.run --standalone --nproc_per_node=2 \\
-      tests/dreamzero/upstream/upstream_socket_server_no_compile.py --port 18081 \\
+      tests/e2e/accuracy/upstream_mock/upstream_socket_server_no_compile.py --port 18081 \\
       --model_path "${DREAMZERO_REPO}/checkpoints/dreamzero"
 """
 
diff --git a/tests/comfyui/conftest.py b/tests/e2e/features/comfyui/conftest.py
similarity index 97%
rename from tests/comfyui/conftest.py
rename to tests/e2e/features/comfyui/conftest.py
index 4280d3506..c3ac99bf2 100644
--- a/tests/comfyui/conftest.py
+++ b/tests/e2e/features/comfyui/conftest.py
@@ -25,7 +25,7 @@ def _setup_comfyui_test_environment():
     """Set up the test environment for ComfyUI plugin testing."""
     # === Add ComfyUI plugin path to allow importing comfyui_vllm_omni ===
     _COMFYUI_PLUGIN_PATH = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "..", "..", "apps", "ComfyUI-vLLM-Omni")
+        os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "apps", "ComfyUI-vLLM-Omni")
     )
     if not os.path.isdir(_COMFYUI_PLUGIN_PATH):
         raise FileNotFoundError(
diff --git a/tests/comfyui/test_comfyui_integration.py b/tests/e2e/features/comfyui/test_comfyui_integration.py
similarity index 81%
rename from tests/comfyui/test_comfyui_integration.py
rename to tests/e2e/features/comfyui/test_comfyui_integration.py
index f532c350f..e8d68b159 100644
--- a/tests/comfyui/test_comfyui_integration.py
+++ b/tests/e2e/features/comfyui/test_comfyui_integration.py
@@ -6,11 +6,13 @@ It ensures that
 2. The sampling parameters are correctly passed from the node to AsyncOmni through the API layer.
 """
 
+from __future__ import annotations
+
 import multiprocessing
 import time
 import traceback
 from collections.abc import Iterable, Sequence
-from enum import StrEnum, auto
+from enum import Enum
 from types import SimpleNamespace
 from typing import Any, NamedTuple
 
@@ -23,9 +25,15 @@ from comfyui_vllm_omni.nodes import (
     VLLMOmniGenerateVideo,
     VLLMOmniTTS,
     VLLMOmniUnderstanding,
+    VLLMOmniVideoReferences,
     VLLMOmniVoiceClone,
 )
-from comfyui_vllm_omni.utils.types import AutoregressionSamplingParams, DiffusionSamplingParams, WanModelSpecificParams
+from comfyui_vllm_omni.utils.types import (
+    AutoregressionSamplingParams,
+    DiffusionSamplingParams,
+    MiniMaxH3ModelSpecificParams,
+    WanModelSpecificParams,
+)
 from PIL import Image
 from pytest_mock import MockerFixture
 from vllm import SamplingParams
@@ -33,7 +41,7 @@ from vllm.outputs import CompletionOutput, RequestOutput
 
 from vllm_omni.entrypoints.async_omni import AsyncOmni as RealAsyncOmni
 from vllm_omni.entrypoints.cli.serve import OmniServeCommand
-from vllm_omni.inputs.data import OmniSamplingParams
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.utils.tracking_parser import TrackingArgumentParser
 
@@ -52,20 +60,22 @@ class ServerCase(NamedTuple):
 class SamplingCase(NamedTuple):
     """Parametrizing the input sampling parameters."""
 
-    kind: "SamplingKind"
+    kind: SamplingKind
     sampling_params: dict | list[dict] | None
     lora: dict | None = None
 
 
-class SamplingKind(StrEnum):
-    IMAGE_NONE = auto()
-    IMAGE_DIFFUSION_SINGLE = auto()
-    UNDERSTANDING_NONE = auto()
-    UNDERSTANDING_AR_LIST = auto()
-    TTS_NONE = auto()
-    TTS_DIFFUSION_SINGLE = auto()
-    VIDEO_NONE = auto()
-    VIDEO_DIFFUSION_SINGLE = auto()
+class SamplingKind(str, Enum):
+    IMAGE_NONE = "image_none"
+    IMAGE_DIFFUSION_SINGLE = "image_diffusion_single"
+    UNDERSTANDING_NONE = "understanding_none"
+    UNDERSTANDING_AR_LIST = "understanding_ar_list"
+    TTS_NONE = "tts_none"
+    TTS_DIFFUSION_SINGLE = "tts_diffusion_single"
+    VIDEO_NONE = "video_none"
+    VIDEO_DIFFUSION_SINGLE = "video_diffusion_single"
+    VIDEO_REF2VA_IMAGE_AUDIO = "video_ref2va_image_audio"
+    VIDEO_REF2VA_MULTI_VIDEO = "video_ref2va_multi_video"
 
 
 # Pre-defined arguments to be used in function calls during the tests
@@ -125,6 +135,15 @@ AR_LIST_SAMPLING_PARAMS = [
 
 VIDEO_MODEL_PARAMS = WanModelSpecificParams({"guidance_scale_2": 5.0, "boundary_ratio": 0.98, "flow_shift": 12.0})
 
+# Matches MiniMax-H3 recipe Ref2VA defaults (task is auto-routed by the client).
+H3_MODEL_PARAMS = MiniMaxH3ModelSpecificParams(
+    {
+        "type": "minimax_h3",
+        "audio_flow_shift": 3.0,
+        "flow_shift": 12.0,
+    }
+)
+
 LORA_PARAMS = {"local_path": "test_lora_path", "name": "test_name", "scale": 0.7, "int_id": 10}
 
 
@@ -304,6 +323,7 @@ def _build_mock_outputs(outputs: Iterable[OmniRequestOutput], sampling_case: Sam
         received_sampling_params_list: Sequence[OmniSamplingParams] | None = (
             args[2] if len(args) > 2 else kwargs.get("sampling_params_list")
         )
+        prompt = args[0] if len(args) > 0 else kwargs.get("prompt")
 
         assert received_sampling_params_list is not None, (
             "In the current codebase, the API layer always provides not-None sampling parameter list when calling `AsyncOmni.generate`"
@@ -370,6 +390,59 @@ def _build_mock_outputs(outputs: Iterable[OmniRequestOutput], sampling_case: Sam
                 LORA_PARAMS,
             )
             _assert_model_param_values(received_sampling_params_list[0], VIDEO_MODEL_PARAMS)
+        elif sampling_case.kind is SamplingKind.VIDEO_REF2VA_IMAGE_AUDIO:
+            assert len(received_sampling_params_list) == 1
+            assert isinstance(prompt, dict)
+            multi_modal_data = prompt.get("multi_modal_data")
+            assert isinstance(multi_modal_data, dict)
+            assert isinstance(multi_modal_data.get("image"), Image.Image)
+            assert isinstance(multi_modal_data.get("audio"), str)
+            assert "video" not in multi_modal_data
+            _assert_sampling_param_values(
+                received_sampling_params_list[0],
+                {
+                    "width": VIDEO_WIDTH,
+                    "height": VIDEO_HEIGHT,
+                    "num_frames": VIDEO_NUM_FRAMES,
+                    "fps": VIDEO_FPS,
+                },
+            )
+            _assert_model_param_values(
+                received_sampling_params_list[0],
+                {
+                    "flow_shift": 12.0,
+                    "task": "ref2va",
+                    "audio_flow_shift": 3.0,
+                },
+            )
+        elif sampling_case.kind is SamplingKind.VIDEO_REF2VA_MULTI_VIDEO:
+            assert len(received_sampling_params_list) == 1
+            assert isinstance(prompt, dict)
+            multi_modal_data = prompt.get("multi_modal_data")
+            assert isinstance(multi_modal_data, dict)
+            input_videos = multi_modal_data.get("video")
+            assert isinstance(input_videos, list)
+            assert len(input_videos) == 2
+            assert all(isinstance(path, str) for path in input_videos)
+            assert "image" not in multi_modal_data
+            assert "audio" not in multi_modal_data
+            _assert_sampling_param_values(
+                received_sampling_params_list[0],
+                {
+                    "width": VIDEO_WIDTH,
+                    "height": VIDEO_HEIGHT,
+                    "num_frames": VIDEO_NUM_FRAMES,
+                    "fps": VIDEO_FPS,
+                },
+            )
+            _assert_model_param_values(
+                received_sampling_params_list[0],
+                {
+                    "flow_shift": 12.0,
+                    "task": "ref2va",
+                    "audio_flow_shift": 3.0,
+                },
+            )
         else:
             raise AssertionError(f"Unknown sampling case: {sampling_case.kind}")
 
@@ -415,7 +488,7 @@ def mock_async_omni(
     mock_instance.stage_configs = server_case.stage_configs
     mock_instance.output_modalities = _build_output_modalities(server_case.stage_configs)
     mock_instance.default_sampling_params_list = [
-        SamplingParams() if _stage_type(stage) != "diffusion" else mocker.MagicMock()
+        OmniDiffusionSamplingParams() if _stage_type(stage) == "diffusion" else SamplingParams()
         for stage in server_case.stage_configs
     ]
     mock_instance.errored = False
@@ -773,7 +846,7 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
         "model_params": VIDEO_MODEL_PARAMS,
     }
     if image_input:
-        kwargs["image"] = torch.zeros((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), dtype=torch.float32)
+        kwargs["frame"] = torch.zeros((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), dtype=torch.float32)
     if sampling_case.sampling_params is not None:
         kwargs["sampling_params"] = sampling_case.sampling_params
     if sampling_case.lora:
@@ -784,3 +857,79 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
     assert isinstance(result, tuple)
     assert len(result) == 1
     assert isinstance(result[0], VideoInput)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "server_case,sampling_case,ref_mode",
+    [
+        pytest.param(
+            ServerCase(
+                served_model="MiniMaxAI/MiniMax-H3",
+                stage_list=["diffusion"],
+                stage_configs=[{"stage_type": "diffusion"}],
+                outputs=[_build_diffusion_video_output()],
+            ),
+            SamplingCase(kind=SamplingKind.VIDEO_REF2VA_IMAGE_AUDIO, sampling_params=None),
+            "image_audio",
+            id="ref2va-image-audio",
+        ),
+        pytest.param(
+            ServerCase(
+                served_model="MiniMaxAI/MiniMax-H3",
+                stage_list=["diffusion"],
+                stage_configs=[{"stage_type": "diffusion"}],
+                outputs=[_build_diffusion_video_output()],
+            ),
+            SamplingCase(kind=SamplingKind.VIDEO_REF2VA_MULTI_VIDEO, sampling_params=None),
+            "multi_video",
+            id="ref2va-multi-video",
+        ),
+    ],
+    indirect=["server_case", "sampling_case"],
+)
+async def test_video_generation_node_minimax_h3_ref2va(
+    api_server: str,
+    sampling_case: SamplingCase,
+    ref_mode: str,
+):
+    """MiniMax-H3 Ref2VA paths matching recipes/MiniMaxAI/MiniMax-H3.md."""
+    node = VLLMOmniGenerateVideo()
+    refs_node = VLLMOmniVideoReferences()
+
+    if ref_mode == "image_audio":
+        (references,) = refs_node.get_references(
+            image_1=torch.zeros((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), dtype=torch.float32),
+            audio_1={"waveform": torch.zeros((1, 1, 24000), dtype=torch.float32), "sample_rate": 24000},
+        )
+        prompt = (
+            "A white cat with black mustache and eyebrow markings sits on a beige couch, "
+            "lip-syncing precisely to the complete reference audio."
+        )
+    elif ref_mode == "multi_video":
+        (references,) = refs_node.get_references(
+            video_1=VideoInput(b"subject-video"),  # type: ignore[reportAbstractUsage]
+            video_2=VideoInput(b"background-video"),  # type: ignore[reportAbstractUsage]
+        )
+        prompt = (
+            "Remove the green screen background of Video 1 and replace it with the fairytale environment from Video 2."
+        )
+    else:
+        raise AssertionError(f"Unknown ref_mode: {ref_mode}")
+
+    result = await node.generate(
+        url=api_server,
+        model="MiniMaxAI/MiniMax-H3",
+        prompt=prompt,
+        negative_prompt="",
+        width=VIDEO_WIDTH,
+        height=VIDEO_HEIGHT,
+        fps=VIDEO_FPS,
+        num_frames=VIDEO_NUM_FRAMES,
+        references=references,
+        model_params=H3_MODEL_PARAMS,
+    )
+
+    assert isinstance(result, tuple)
+    assert len(result) == 1
+    assert isinstance(result[0], VideoInput)
diff --git a/tests/e2e/offline_inference/custom_pipeline/test_async_omni_collective_rpc.py b/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py
similarity index 96%
rename from tests/e2e/offline_inference/custom_pipeline/test_async_omni_collective_rpc.py
rename to tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py
index dc701af7a..04e83caeb 100644
--- a/tests/e2e/offline_inference/custom_pipeline/test_async_omni_collective_rpc.py
+++ b/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py
@@ -16,7 +16,7 @@ exercises when it calls ``await self.engine.list_loras()`` before
 dispatching a generation request.
 
 Usage:
-    pytest tests/e2e/offline_inference/custom_pipeline/test_async_omni_collective_rpc.py -v -s
+    pytest tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py -v -s
 """
 
 from __future__ import annotations
@@ -34,12 +34,8 @@ from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
 
 MODEL = "tiny-random/Qwen-Image"
-CUSTOM_PIPELINE_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.qwen_image_pipeline_with_logprob.QwenImagePipelineWithLogProbForTest"
-)
-WORKER_EXTENSION_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.worker_extension.vLLMOmniColocateWorkerExtensionForTest"
-)
+CUSTOM_PIPELINE_CLASS = "tests.e2e.features.helpers.custom_pipeline.QwenImagePipelineWithLogProbForTest"
+WORKER_EXTENSION_CLASS = "tests.e2e.features.helpers.custom_pipeline.vLLMOmniColocateWorkerExtensionForTest"
 
 
 def _create_inline_engine() -> AsyncOmni:
diff --git a/tests/e2e/offline_inference/custom_pipeline/test_async_omni_qwen_image_generate.py b/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
similarity index 96%
rename from tests/e2e/offline_inference/custom_pipeline/test_async_omni_qwen_image_generate.py
rename to tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
index 0681687fe..b24f364e4 100644
--- a/tests/e2e/offline_inference/custom_pipeline/test_async_omni_qwen_image_generate.py
+++ b/tests/e2e/features/custom_pipeline/test_async_omni_qwen_image_generate.py
@@ -24,12 +24,8 @@ from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
 
-CUSTOM_PIPELINE_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.qwen_image_pipeline_with_logprob.QwenImagePipelineWithLogProbForTest"
-)
-WORKER_EXTENSION_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.worker_extension.vLLMOmniColocateWorkerExtensionForTest"
-)
+CUSTOM_PIPELINE_CLASS = "tests.e2e.features.helpers.custom_pipeline.QwenImagePipelineWithLogProbForTest"
+WORKER_EXTENSION_CLASS = "tests.e2e.features.helpers.custom_pipeline.vLLMOmniColocateWorkerExtensionForTest"
 
 # Use your specified HF repo name/path directly here
 MODEL = "tiny-random/Qwen-Image"
@@ -158,6 +154,7 @@ async def test_async_omni_generate():
             custom_pipeline_args={"pipeline_class": CUSTOM_PIPELINE_CLASS},
             worker_extension_cls=WORKER_EXTENSION_CLASS,
             enforce_eager=True,
+            max_num_seqs=1,
         )
         after.callback(engine.shutdown)
 
@@ -183,6 +180,7 @@ async def test_async_omni_generate_with_logprobs():
             custom_pipeline_args={"pipeline_class": CUSTOM_PIPELINE_CLASS},
             worker_extension_cls=WORKER_EXTENSION_CLASS,
             enforce_eager=True,
+            max_num_seqs=1,
         )
         after.callback(engine.shutdown)
 
@@ -220,6 +218,7 @@ async def test_async_omni_generate_concurrent():
             custom_pipeline_args={"pipeline_class": CUSTOM_PIPELINE_CLASS},
             worker_extension_cls=WORKER_EXTENSION_CLASS,
             enforce_eager=True,
+            max_num_seqs=1,
         )
         after.callback(engine.shutdown)
 
diff --git a/tests/e2e/offline_inference/custom_pipeline/test_worker_extension.py b/tests/e2e/features/custom_pipeline/test_worker_extension.py
similarity index 59%
rename from tests/e2e/offline_inference/custom_pipeline/test_worker_extension.py
rename to tests/e2e/features/custom_pipeline/test_worker_extension.py
index 16dddde40..da7b0ac17 100644
--- a/tests/e2e/offline_inference/custom_pipeline/test_worker_extension.py
+++ b/tests/e2e/features/custom_pipeline/test_worker_extension.py
@@ -7,37 +7,19 @@ from contextlib import ExitStack
 
 import pytest
 
-from tests.e2e.offline_inference.custom_pipeline.qwen_image_pipeline_with_logprob import (
+from tests.e2e.features.helpers.custom_pipeline import (
     QwenImagePipelineWithLogProbForTest,
 )
-from tests.e2e.offline_inference.custom_pipeline.worker_extension import (
-    vLLMOmniColocateWorkerExtensionForTest,
-)
 from tests.helpers.mark import hardware_test
-from vllm_omni.diffusion.worker.diffusion_worker import CustomPipelineWorkerExtension
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 
 CUSTOM_PIPELINE_CLASS = QwenImagePipelineWithLogProbForTest
-WORKER_EXTENSION_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.worker_extension.vLLMOmniColocateWorkerExtensionForTest"
-)
+WORKER_EXTENSION_CLASS = "tests.e2e.features.helpers.custom_pipeline.vLLMOmniColocateWorkerExtensionForTest"
 MODEL = "tiny-random/Qwen-Image"
 
 pytestmark = [pytest.mark.core_model]
 
 
-@pytest.mark.cpu
-def test_worker_extension_inheritance():
-    assert issubclass(vLLMOmniColocateWorkerExtensionForTest, CustomPipelineWorkerExtension)
-
-
-@pytest.mark.cpu
-def test_worker_extension_test_function():
-    assert (
-        vLLMOmniColocateWorkerExtensionForTest.test_extension_name() == "vllm-omni-colocate-worker-extension-for-test"
-    )
-
-
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.asyncio
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_control_client.py b/tests/e2e/features/fullduplex/engine/test_duplex_control_client.py
new file mode 100644
index 000000000..c1fa9a592
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_control_client.py
@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_control_client import (
+    DuplexControlClient,
+    DuplexControlRequestError,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    DuplexControlError,
+    DuplexControlResultMessage,
+    DuplexFence,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Transport:
+    def __init__(self) -> None:
+        self.calls = []
+
+    def execute(self, key, message, **kwargs):
+        self.calls.append((key, message, kwargs))
+        return DuplexControlResultMessage(
+            control_id=message.control_id,
+            fence=message.fence,
+            operation="touch" if isinstance(message, TouchDuplexSessionMessage) else "resume",
+            session_id=message.session_id,
+            ok=True,
+            stage_results=[],
+        )
+
+
+class _UnsupportedTransport:
+    def execute(self, key, message, **kwargs):
+        del key, kwargs
+        return DuplexControlResultMessage(
+            control_id=message.control_id,
+            fence=message.fence,
+            operation="touch",
+            session_id=message.session_id,
+            ok=False,
+            stage_results=[{"result": {"supported": False}}],
+            unsupported_count=1,
+            error=DuplexControlError(code="invalid_capability", message="unsupported", retryable=False),
+            accepted_fence=DuplexFence(message.session_id, epoch=2),
+            lease_generation=7,
+        )
+
+
+def test_control_client_routes_touch_and_resume_by_control_id() -> None:
+    transport = _Transport()
+    control_ids = iter(("touch-id", "resume-id"))
+    client = DuplexControlClient(transport, control_id_factory=lambda: next(control_ids))
+    fence = DuplexFence("sid-client")
+
+    assert (
+        client.touch(
+            fence.session_id,
+            fence=fence,
+            activity=DuplexLeaseActivity.PLAYBACK_ACK,
+            timeout=2.0,
+        )["ok"]
+        is True
+    )
+    assert (
+        client.resume(
+            fence.session_id,
+            fence=fence,
+            expected_lease_generation=7,
+            timeout=3.0,
+        )["ok"]
+        is True
+    )
+
+    touch_key, touch_message, touch_kwargs = transport.calls[0]
+    assert touch_key == ("duplex", "touch-id")
+    assert isinstance(touch_message, TouchDuplexSessionMessage)
+    assert touch_message.activity == DuplexLeaseActivity.PLAYBACK_ACK.value
+    assert touch_kwargs["timeout"] == 2.0
+
+    resume_key, resume_message, resume_kwargs = transport.calls[1]
+    assert resume_key == ("duplex", "resume-id")
+    assert isinstance(resume_message, ResumeDuplexSessionMessage)
+    assert resume_message.expected_lease_generation == 7
+    assert resume_kwargs["timeout"] == 3.0
+
+
+def test_control_client_treats_ok_false_as_authoritative_failure() -> None:
+    client = DuplexControlClient(_UnsupportedTransport(), control_id_factory=lambda: "unsupported")
+    fence = DuplexFence("sid-unsupported")
+
+    with pytest.raises(DuplexControlRequestError, match="duplex touch failed") as exc_info:
+        client.touch(
+            fence.session_id,
+            fence=fence,
+            activity=DuplexLeaseActivity.HEARTBEAT,
+            timeout=1.0,
+        )
+
+    assert exc_info.value.code == "invalid_capability"
+    assert exc_info.value.retryable is False
+    assert exc_info.value.accepted_fence == DuplexFence(fence.session_id, epoch=2)
+    assert exc_info.value.lease_generation == 7
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_control_plane.py b/tests/e2e/features/fullduplex/engine/test_duplex_control_plane.py
new file mode 100644
index 000000000..46df33ffa
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_control_plane.py
@@ -0,0 +1,1270 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import FrozenInstanceError
+
+import msgspec
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_control_plane import (
+    DuplexControlPlane,
+    DuplexOutputContext,
+    DuplexRequestIdentity,
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+    DuplexStageSubmissionResult,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexAppendPlan,
+    DuplexInputMode,
+    DuplexRuntimeCapabilities,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity, DuplexLeaseConfig
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    AppendDuplexInputMessage,
+    CloseDuplexSessionMessage,
+    DuplexFence,
+    DuplexSessionLifecycleMessage,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    SignalDuplexTurnMessage,
+    TouchDuplexSessionMessage,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Extension:
+    def configure_sampling_params(self, *, runtime_config, defaults):
+        del runtime_config
+        return tuple(f"configured-{stage_id}" for stage_id, _ in enumerate(defaults))
+
+    def plan_append(
+        self,
+        *,
+        request_id,
+        fence,
+        session_config,
+        runtime_config,
+        seq,
+        turn_seq,
+        mode,
+        payload,
+        final,
+        sampling_params,
+    ):
+        del request_id, fence, session_config, runtime_config, seq, turn_seq, mode, payload, final
+        assert sampling_params == "configured-0"
+        return DuplexAppendPlan(prompt={"prompt_token_ids": [1, 2, 3]})
+
+    def decide_output(self, **kwargs):
+        del kwargs
+        return None
+
+
+class _TypedStagePort:
+    stage_count = 2
+
+    def __init__(self) -> None:
+        self.ensure_calls: list[DuplexStageRequestContext] = []
+        self.submit_calls: list[DuplexStageSubmission] = []
+        self.cleanup_calls: list[tuple[list[str], bool]] = []
+
+    def sampling_defaults(self) -> tuple[object, ...]:
+        return ("default-0", "default-1")
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None:
+        self.ensure_calls.append(context)
+
+    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
+        self.submit_calls.append(submission)
+        return DuplexStageSubmissionResult(
+            request_id=submission.context.request_id,
+            stage_id=submission.context.stage_id,
+            replica_id=3,
+        )
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+        self.cleanup_calls.append((request_ids, abort))
+
+
+class _Clock:
+    def __init__(self) -> None:
+        self.value = 0.0
+
+    def __call__(self) -> float:
+        return self.value
+
+    def advance(self, seconds: float) -> None:
+        self.value += seconds
+
+
+@pytest.mark.asyncio
+async def test_control_plane_uses_frozen_typed_stage_context_without_request_state() -> None:
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=_Extension(),
+        stage_port=stage_port,
+        result_sink=result_sink,
+    )
+    fence = DuplexFence("typed-port")
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={
+                "input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value],
+            },
+            session_config={"voice": "test"},
+            runtime_config={"runtime": "test"},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+
+    context = stage_port.ensure_calls[-1]
+    assert context.session_id == fence.session_id
+    assert context.fence == fence
+    assert context.stage_id == 0
+    assert context.final_stage_id == 1
+    assert context.sampling_params == ("configured-0", "configured-1")
+    assert context.session_config == {"voice": "test"}
+    assert context.runtime_config == {"runtime": "test"}
+    with pytest.raises(FrozenInstanceError):
+        context.stage_id = 1  # type: ignore[misc]
+
+    await plane.handle(
+        AppendDuplexInputMessage(
+            control_id="append",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+            final=True,
+        )
+    )
+    append_result = await result_sink.get()
+    assert append_result.ok is True
+    assert append_result.stage_results[0]["replica_id"] == 3
+    assert append_result.stage_results[0]["result"]["response_stage_id"] == 1
+
+    submission = stage_port.submit_calls[-1]
+    assert submission.context == stage_port.ensure_calls[-1]
+    assert submission.prompt == {"prompt_token_ids": [1, 2, 3]}
+    assert submission.already_submitted is False
+    assert not hasattr(submission, "request_state")
+
+
+def test_control_plane_accepts_only_typed_duplex_messages() -> None:
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=_TypedStagePort(),
+        result_sink=asyncio.Queue(),
+    )
+
+    assert plane.accepts(
+        OpenDuplexSessionMessage(
+            control_id="open",
+            fence=DuplexFence("typed-message"),
+            session_id="typed-message",
+            capabilities=DuplexRuntimeCapabilities().__dict__,
+        )
+    )
+    assert plane.accepts(type("Lookalike", (), {"type": "open_duplex_session"})()) is False
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        TouchDuplexSessionMessage(
+            control_id="touch-1",
+            fence=DuplexFence("sid-message"),
+            session_id="sid-message",
+            activity=DuplexLeaseActivity.HEARTBEAT.value,
+        ),
+        ResumeDuplexSessionMessage(
+            control_id="resume-1",
+            fence=DuplexFence("sid-message"),
+            session_id="sid-message",
+            expected_lease_generation=3,
+        ),
+        DuplexSessionLifecycleMessage(
+            fence=DuplexFence("sid-message"),
+            session_id="sid-message",
+            event="expired",
+            reason="idle_ttl_expired",
+            lease_generation=4,
+            submitted_request_ids=["req-submitted"],
+            reserved_request_ids=["req-reserved"],
+        ),
+    ],
+)
+def test_duplex_lease_messages_round_trip(message) -> None:
+    encoded = msgspec.json.encode(message)
+    decoded = msgspec.json.decode(encoded, type=type(message))
+
+    assert decoded == message
+
+
+@pytest.mark.asyncio
+async def test_control_plane_touches_append_signal_and_explicit_activity() -> None:
+    clock = _Clock()
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    lifecycle_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=_Extension(),
+        stage_port=stage_port,
+        result_sink=result_sink,
+        lifecycle_sink=lifecycle_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=30.0, disconnect_grace_s=5.0),
+        clock=clock,
+    )
+    fence = DuplexFence("sid-touch")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={"input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value]},
+        )
+    )
+    await result_sink.get()
+    session = plane.sessions.require(fence.session_id)
+
+    clock.advance(1.0)
+    await plane.handle(
+        AppendDuplexInputMessage(
+            control_id="append",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    assert session.lease.last_activity == 1.0
+
+    clock.advance(1.0)
+    await plane.handle(
+        SignalDuplexTurnMessage(
+            control_id="signal",
+            fence=fence,
+            session_id=fence.session_id,
+            event="session.update",
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    assert session.lease.last_activity == 2.0
+
+    submit_count = len(stage_port.submit_calls)
+    clock.advance(1.0)
+    await plane.handle(
+        TouchDuplexSessionMessage(
+            control_id="heartbeat",
+            fence=fence,
+            session_id=fence.session_id,
+            activity=DuplexLeaseActivity.HEARTBEAT.value,
+        )
+    )
+    touch_result = await result_sink.get()
+    assert touch_result.ok is True
+    assert session.lease.last_activity == 3.0
+    assert len(stage_port.submit_calls) == submit_count
+    assert lifecycle_sink.empty()
+
+
+@pytest.mark.asyncio
+async def test_control_plane_resume_requires_expected_lease_generation() -> None:
+    clock = _Clock()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=_TypedStagePort(),
+        result_sink=result_sink,
+        lifecycle_sink=asyncio.Queue(),
+        lease_config=DuplexLeaseConfig(),
+        clock=clock,
+    )
+    fence = DuplexFence("sid-resume-control")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={},
+        )
+    )
+    await result_sink.get()
+    await plane.handle(
+        TouchDuplexSessionMessage(
+            control_id="detach",
+            fence=fence,
+            session_id=fence.session_id,
+            activity=DuplexLeaseActivity.DETACH.value,
+        )
+    )
+    await result_sink.get()
+
+    await plane.handle(
+        ResumeDuplexSessionMessage(
+            control_id="resume",
+            fence=fence,
+            session_id=fence.session_id,
+            expected_lease_generation=0,
+        )
+    )
+    result = await result_sink.get()
+
+    assert result.ok is True
+    assert result.stage_results[0]["result"]["lease_generation"] == 1
+
+    await plane.handle(
+        ResumeDuplexSessionMessage(
+            control_id="stale-resume",
+            fence=fence,
+            session_id=fence.session_id,
+            expected_lease_generation=0,
+        )
+    )
+    stale_result = await result_sink.get()
+    assert stale_result.ok is False
+    assert stale_result.accepted_fence == fence
+    assert stale_result.lease_generation == 1
+
+
+@pytest.mark.asyncio
+async def test_control_plane_reaps_one_session_through_cleanup_and_lifecycle_sink() -> None:
+    clock = _Clock()
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    lifecycle_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        lifecycle_sink=lifecycle_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=2.0, disconnect_grace_s=1.0),
+        clock=clock,
+    )
+    for session_id in ("sid-a", "sid-b"):
+        fence = DuplexFence(session_id)
+        await plane.handle(
+            OpenDuplexSessionMessage(
+                control_id=f"open-{session_id}",
+                fence=fence,
+                session_id=session_id,
+                capabilities={},
+            )
+        )
+        await result_sink.get()
+    clock.advance(1.0)
+    plane.sessions.require("sid-b").touch(DuplexFence("sid-b"), DuplexLeaseActivity.HEARTBEAT)
+    clock.advance(1.1)
+
+    expired_count = await plane.reap_expired()
+
+    assert expired_count == 1
+    assert plane.sessions.get("sid-a") is None
+    assert plane.sessions.get("sid-b") is not None
+    assert stage_port.cleanup_calls == []
+    lifecycle = await lifecycle_sink.get()
+    assert isinstance(lifecycle, DuplexSessionLifecycleMessage)
+    assert lifecycle.session_id == "sid-a"
+    assert lifecycle.reason == "idle_ttl_expired"
+    assert result_sink.empty()
+
+
+@pytest.mark.asyncio
+async def test_control_plane_retries_expired_cleanup_before_publishing_lifecycle() -> None:
+    class _FailOnceStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.failures_remaining = 1
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            if self.failures_remaining:
+                self.failures_remaining -= 1
+                raise RuntimeError("transient cleanup failure")
+            await super().cleanup(request_ids, abort=abort)
+
+    clock = _Clock()
+    stage_port = _FailOnceStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    lifecycle_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        lifecycle_sink=lifecycle_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
+        clock=clock,
+    )
+    fence = DuplexFence("sid-retry-expiry")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-retry",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={},
+        )
+    )
+    await result_sink.get()
+    request_id = plane.stage_request_id(fence, stage_id=0)
+    plane.sessions.require(fence.session_id).reserve_stage_request(0, request_id, fence=fence)
+    clock.advance(2.0)
+
+    assert await plane.reap_expired() == 0
+    assert lifecycle_sink.empty()
+
+    assert await plane.reap_expired() == 1
+    assert (await lifecycle_sink.get()).session_id == fence.session_id
+
+
+@pytest.mark.asyncio
+async def test_expired_session_holds_admission_slot_while_cleanup_is_blocked() -> None:
+    class _BlockedCleanupStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.cleanup_started = asyncio.Event()
+            self.release_cleanup = asyncio.Event()
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            self.cleanup_started.set()
+            await self.release_cleanup.wait()
+            await super().cleanup(request_ids, abort=abort)
+
+    clock = _Clock()
+    stage_port = _BlockedCleanupStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
+        clock=clock,
+        max_sessions=1,
+    )
+    old_fence = DuplexFence("sid-expired-blocked")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-expired-blocked",
+            fence=old_fence,
+            session_id=old_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    old_session = plane.sessions.require(old_fence.session_id)
+    old_session.bind_stage_request(0, "req-expired-blocked", fence=old_fence)
+    clock.advance(2.0)
+
+    reap_task = asyncio.create_task(plane.reap_expired())
+    await asyncio.wait_for(stage_port.cleanup_started.wait(), timeout=1.0)
+    replacement_fence = DuplexFence("sid-replacement-blocked")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-replacement-blocked",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={},
+        )
+    )
+
+    blocked_result = await result_sink.get()
+    assert blocked_result.ok is False
+    assert blocked_result.error is not None
+    assert blocked_result.error.code == "resource_exhausted"
+    assert plane.sessions.get(old_fence.session_id) is old_session
+
+    stage_port.release_cleanup.set()
+    assert await reap_task == 1
+    assert plane.sessions.get(old_fence.session_id) is None
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-replacement-after-cleanup",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+
+
+@pytest.mark.asyncio
+async def test_failed_expiry_cleanup_retains_admission_slot_for_retry() -> None:
+    class _FailingCleanupStagePort(_TypedStagePort):
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            del request_ids, abort
+            raise RuntimeError("cleanup failed")
+
+    clock = _Clock()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=_FailingCleanupStagePort(),
+        result_sink=result_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
+        clock=clock,
+        max_sessions=1,
+    )
+    old_fence = DuplexFence("sid-expired-failed")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-expired-failed",
+            fence=old_fence,
+            session_id=old_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    old_session = plane.sessions.require(old_fence.session_id)
+    old_session.bind_stage_request(0, "req-expired-failed", fence=old_fence)
+    clock.advance(2.0)
+
+    assert await plane.reap_expired() == 0
+    replacement_fence = DuplexFence("sid-replacement-failed")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-replacement-failed",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={},
+        )
+    )
+
+    blocked_result = await result_sink.get()
+    assert blocked_result.ok is False
+    assert blocked_result.error is not None
+    assert blocked_result.error.code == "resource_exhausted"
+    assert plane.sessions.get(old_fence.session_id) is old_session
+
+
+@pytest.mark.asyncio
+async def test_capacity_rejection_is_an_info_event(caplog: pytest.LogCaptureFixture) -> None:
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=_TypedStagePort(),
+        result_sink=result_sink,
+        max_sessions=1,
+    )
+    first_fence = DuplexFence("sid-capacity-first")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-capacity-first",
+            fence=first_fence,
+            session_id=first_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    caplog.clear()
+
+    rejected_fence = DuplexFence("sid-capacity-rejected")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-capacity-rejected",
+            fence=rejected_fence,
+            session_id=rejected_fence.session_id,
+            capabilities={},
+        )
+    )
+
+    result = await result_sink.get()
+    assert result.error.code == "resource_exhausted"
+    assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
+
+
+@pytest.mark.asyncio
+async def test_failed_request_cleanup_retries_before_releasing_admission() -> None:
+    class _FailOnceCleanupStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.attempts = 0
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            self.cleanup_calls.append((list(request_ids), abort))
+            self.attempts += 1
+            if self.attempts == 1:
+                raise RuntimeError("transient request cleanup failure")
+
+    stage_port = _FailOnceCleanupStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        max_sessions=1,
+    )
+    old_fence = DuplexFence("sid-request-cleanup")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-request-cleanup",
+            fence=old_fence,
+            session_id=old_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    old_session = plane.sessions.require(old_fence.session_id)
+    old_session.bind_stage_request(0, "req-request-cleanup", fence=old_fence)
+
+    closed = plane.close_sessions_for_request_ids(
+        ["req-request-cleanup"],
+        abort=True,
+    )
+    assert closed == {old_fence.session_id: ["req-request-cleanup"]}
+    assert plane.sessions.get(old_fence.session_id) is old_session
+    with pytest.raises(RuntimeError, match="transient request cleanup failure"):
+        await stage_port.cleanup(closed[old_fence.session_id], abort=True)
+
+    replacement_fence = DuplexFence("sid-request-cleanup-replacement")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-request-cleanup-replacement-blocked",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).error.code == "resource_exhausted"
+
+    assert await plane.reap_expired() == 1
+    assert plane.sessions.get(old_fence.session_id) is None
+    assert stage_port.cleanup_calls == [
+        (["req-request-cleanup"], True),
+        (["req-request-cleanup"], True),
+    ]
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-request-cleanup-replacement",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+
+
+@pytest.mark.asyncio
+async def test_stale_request_cleanup_does_not_finalize_reopened_incarnation() -> None:
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        max_sessions=1,
+    )
+    old_fence = DuplexFence("sid-request-cleanup-reopen")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-request-cleanup-old",
+            fence=old_fence,
+            session_id=old_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    old_session = plane.sessions.require(old_fence.session_id)
+    old_session.bind_stage_request(0, "req-request-cleanup-old", fence=old_fence)
+    closed = plane.close_sessions_for_request_ids(
+        ["req-request-cleanup-old"],
+        abort=True,
+        cleanup_in_progress=True,
+    )
+    assert closed == {old_fence.session_id: ["req-request-cleanup-old"]}
+    plane.defer_request_cleanups([old_fence.session_id])
+
+    await plane.handle(
+        CloseDuplexSessionMessage(
+            control_id="close-request-cleanup-old",
+            fence=old_fence,
+            session_id=old_fence.session_id,
+            reason="client_close",
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    assert plane.sessions.get(old_fence.session_id) is None
+
+    new_fence = DuplexFence(old_fence.session_id, incarnation=1)
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-request-cleanup-new",
+            fence=new_fence,
+            session_id=new_fence.session_id,
+            capabilities={},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+    new_session = plane.sessions.require(new_fence.session_id)
+    assert new_session.resume(new_fence, expected_lease_generation=0) == 1
+
+    assert await plane.reap_expired() == 1
+    assert plane.sessions.get(new_fence.session_id) is new_session
+
+
+@pytest.mark.asyncio
+async def test_failed_open_cleanup_is_retried_before_releasing_admission() -> None:
+    class _FailOpenAndFirstCleanupStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.ensure_attempts = 0
+            self.cleanup_attempts = 0
+
+        def ensure_request(self, context: DuplexStageRequestContext) -> None:
+            self.ensure_attempts += 1
+            if self.ensure_attempts == 1:
+                raise RuntimeError("initial stage setup failed")
+            super().ensure_request(context)
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            self.cleanup_calls.append((list(request_ids), abort))
+            self.cleanup_attempts += 1
+            if self.cleanup_attempts == 1:
+                raise RuntimeError("transient open rollback failure")
+
+    stage_port = _FailOpenAndFirstCleanupStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=_Extension(),
+        stage_port=stage_port,
+        result_sink=result_sink,
+        max_sessions=1,
+    )
+    failed_fence = DuplexFence("sid-open-rollback")
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-fails-during-stage-setup",
+            fence=failed_fence,
+            session_id=failed_fence.session_id,
+            capabilities={"input_modes": ["append_audio_chunk"]},
+        )
+    )
+
+    failed_result = await result_sink.get()
+    assert failed_result.ok is False
+    assert plane.sessions.get(failed_fence.session_id) is not None
+
+    replacement_fence = DuplexFence("sid-open-rollback-replacement")
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-replacement-before-rollback",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={"input_modes": ["append_audio_chunk"]},
+        )
+    )
+    assert (await result_sink.get()).error.code == "resource_exhausted"
+
+    assert await plane.reap_expired() == 0
+    assert plane.sessions.get(failed_fence.session_id) is None
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-replacement-after-rollback",
+            fence=replacement_fence,
+            session_id=replacement_fence.session_id,
+            capabilities={"input_modes": ["append_audio_chunk"]},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+
+
+@pytest.mark.asyncio
+async def test_expired_cleanup_failure_does_not_block_other_sessions() -> None:
+    class _OneStuckExpiryStagePort(_TypedStagePort):
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            if request_ids == [stuck_request_id]:
+                raise RuntimeError("stuck expiry cleanup")
+            await super().cleanup(request_ids, abort=abort)
+
+    clock = _Clock()
+    stage_port = _OneStuckExpiryStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    lifecycle_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(
+        extension=None,
+        stage_port=stage_port,
+        result_sink=result_sink,
+        lifecycle_sink=lifecycle_sink,
+        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
+        clock=clock,
+    )
+    stuck_fence = DuplexFence("sid-expiry-stuck")
+    ready_fence = DuplexFence("sid-expiry-ready")
+    stuck_request_id = plane.stage_request_id(stuck_fence, stage_id=0)
+    ready_request_id = plane.stage_request_id(ready_fence, stage_id=0)
+    for fence in (stuck_fence, ready_fence):
+        await plane.handle(
+            OpenDuplexSessionMessage(
+                control_id=f"open-{fence.session_id}",
+                fence=fence,
+                session_id=fence.session_id,
+                capabilities={},
+            )
+        )
+        assert (await result_sink.get()).ok is True
+        plane.sessions.require(fence.session_id).reserve_stage_request(
+            0,
+            plane.stage_request_id(fence, stage_id=0),
+            fence=fence,
+        )
+    clock.advance(2.0)
+
+    assert await plane.reap_expired() == 1
+
+    assert (await lifecycle_sink.get()).session_id == ready_fence.session_id
+    assert stage_port.cleanup_calls == [([ready_request_id], False)]
+
+
+@pytest.mark.asyncio
+async def test_cancel_retains_request_resources_until_abort_succeeds() -> None:
+    class _FailOnceStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.failures_remaining = 1
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            if self.failures_remaining:
+                self.failures_remaining -= 1
+                raise RuntimeError("transient abort failure")
+            await super().cleanup(request_ids, abort=abort)
+
+    stage_port = _FailOnceStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
+    cancelled_fence = DuplexFence("sid-cancel-retry")
+    next_fence = DuplexFence("sid-cancel-retry", epoch=1)
+    session = plane.sessions.open_session(cancelled_fence)
+    session.bind_stage_request(0, "req-cancel-retry", fence=cancelled_fence)
+
+    def signal(control_id: str) -> SignalDuplexTurnMessage:
+        return SignalDuplexTurnMessage(
+            control_id=control_id,
+            fence=cancelled_fence,
+            next_fence=next_fence,
+            session_id=cancelled_fence.session_id,
+            event="input.cancel",
+        )
+
+    await plane.handle(signal("cancel-first"))
+    assert (await result_sink.get()).ok is False
+    assert session.fence == next_fence
+    assert session.resource_request_ids(cancelled_fence) == ["req-cancel-retry"]
+
+    await plane.handle(signal("cancel-retry"))
+    assert (await result_sink.get()).ok is True
+    assert session.resource_request_ids(cancelled_fence) == []
+    assert stage_port.cleanup_calls == [(["req-cancel-retry"], True)]
+
+
+@pytest.mark.asyncio
+async def test_close_retains_session_resources_until_cleanup_succeeds() -> None:
+    class _FailOnceStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.failures_remaining = 1
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            if self.failures_remaining:
+                self.failures_remaining -= 1
+                raise RuntimeError("transient close cleanup failure")
+            await super().cleanup(request_ids, abort=abort)
+
+    stage_port = _FailOnceStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
+    fence = DuplexFence("sid-close-retry")
+    session = plane.sessions.open_session(fence)
+    session.bind_stage_request(0, "req-close-retry", fence=fence)
+
+    def close(control_id: str) -> CloseDuplexSessionMessage:
+        return CloseDuplexSessionMessage(
+            control_id=control_id,
+            fence=fence,
+            session_id=fence.session_id,
+            reason="client_close",
+        )
+
+    await plane.handle(close("close-first"))
+    assert (await result_sink.get()).ok is False
+    assert plane.sessions.get(fence.session_id) is session
+    assert session.resource_request_ids() == ["req-close-retry"]
+
+    await plane.handle(close("close-retry"))
+    assert (await result_sink.get()).ok is True
+    assert plane.sessions.get(fence.session_id) is None
+    assert stage_port.cleanup_calls == [(["req-close-retry"], True)]
+
+
+@pytest.mark.asyncio
+async def test_control_cleanup_failure_does_not_block_other_sessions() -> None:
+    class _IndependentFailureStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.attempts: dict[str, int] = {}
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            request_id = request_ids[0]
+            self.attempts[request_id] = self.attempts.get(request_id, 0) + 1
+            if request_id == "req-stuck" or self.attempts[request_id] == 1:
+                raise RuntimeError(f"cleanup failed for {request_id}")
+            await super().cleanup(request_ids, abort=abort)
+
+    stage_port = _IndependentFailureStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
+
+    for session_id, request_id in (("sid-stuck", "req-stuck"), ("sid-ready", "req-ready")):
+        fence = DuplexFence(session_id)
+        session = plane.sessions.open_session(fence)
+        session.bind_stage_request(0, request_id, fence=fence)
+        await plane.handle(
+            CloseDuplexSessionMessage(
+                control_id=f"close-{session_id}",
+                fence=fence,
+                session_id=session_id,
+                reason="client_close",
+            )
+        )
+        assert (await result_sink.get()).ok is False
+
+    await plane.reap_expired()
+
+    assert plane.sessions.get("sid-stuck") is not None
+    assert plane.sessions.get("sid-ready") is None
+    assert stage_port.cleanup_calls == [(["req-ready"], True)]
+
+
+@pytest.mark.asyncio
+async def test_control_cleanup_is_single_flight_with_concurrent_reaper() -> None:
+    class _SlowCleanupStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.cleanup_started = asyncio.Event()
+            self.release_cleanup = asyncio.Event()
+            self.cleanup_attempts = 0
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            self.cleanup_attempts += 1
+            self.cleanup_started.set()
+            await self.release_cleanup.wait()
+            await super().cleanup(request_ids, abort=abort)
+
+    stage_port = _SlowCleanupStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
+    fence = DuplexFence("sid-concurrent-cleanup")
+    session = plane.sessions.open_session(fence)
+    session.bind_stage_request(0, "req-concurrent-cleanup", fence=fence)
+
+    close_task = asyncio.create_task(
+        plane.handle(
+            CloseDuplexSessionMessage(
+                control_id="close-concurrent-cleanup",
+                fence=fence,
+                session_id=fence.session_id,
+                reason="client_close",
+            )
+        )
+    )
+    await asyncio.wait_for(stage_port.cleanup_started.wait(), timeout=1)
+
+    reaper_task = asyncio.create_task(plane.reap_expired())
+    await asyncio.sleep(0)
+    await asyncio.sleep(0)
+    assert stage_port.cleanup_attempts == 1
+
+    stage_port.release_cleanup.set()
+    await asyncio.gather(close_task, reaper_task)
+
+    assert (await result_sink.get()).ok is True
+    assert plane.sessions.get(fence.session_id) is None
+    assert stage_port.cleanup_calls == [(["req-concurrent-cleanup"], True)]
+
+
+@pytest.mark.asyncio
+async def test_unknown_input_mode_rejects_open_without_registering_session() -> None:
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=_TypedStagePort(), result_sink=result_sink)
+    fence = DuplexFence("sid-unknown-mode")
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-unknown-mode",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={"input_modes": ["future_mode"]},
+        )
+    )
+
+    result = await result_sink.get()
+    assert result.ok is False
+    assert result.error is not None
+    assert result.error.code == "invalid_capability"
+    assert plane.sessions.get(fence.session_id) is None
+
+
+@pytest.mark.asyncio
+async def test_extension_free_turn_commit_does_not_allocate_or_submit_stage_request() -> None:
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
+    fence = DuplexFence("sid-turn-commit")
+
+    await plane.handle(
+        OpenDuplexSessionMessage(
+            control_id="open-turn-commit",
+            fence=fence,
+            session_id=fence.session_id,
+            capabilities={"input_modes": [DuplexInputMode.TURN_COMMIT_ONLY.value]},
+        )
+    )
+    assert (await result_sink.get()).ok is True
+
+    await plane.handle(
+        AppendDuplexInputMessage(
+            control_id="append-turn-commit",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.TURN_COMMIT_ONLY.value,
+            payload=None,
+            final=True,
+        )
+    )
+    result = await result_sink.get()
+
+    assert result.ok is True
+    assert result.stage_results[0]["result"]["data_plane_append"] is False
+    assert stage_port.ensure_calls == []
+    assert stage_port.submit_calls == []
+
+
+@pytest.mark.asyncio
+async def test_session_update_replaces_both_configs_with_one_generation() -> None:
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=_Extension(), stage_port=_TypedStagePort(), result_sink=result_sink)
+    fence = DuplexFence("sid-atomic-config")
+    session = plane.sessions.open_session(fence)
+
+    await plane.handle(
+        SignalDuplexTurnMessage(
+            control_id="update-config",
+            fence=fence,
+            session_id=fence.session_id,
+            event="session.update",
+            session_config={"voice": "new"},
+            runtime_config={"temperature": 0.5},
+        )
+    )
+
+    assert (await result_sink.get()).ok is True
+    assert session.config_generation == 1
+    assert session.session_config == {"voice": "new"}
+    assert session.runtime_config == {"temperature": 0.5}
+
+
+@pytest.mark.asyncio
+async def test_stage_submission_is_compensated_when_local_commit_fails() -> None:
+    stage_port = _TypedStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
+    fence = DuplexFence("sid-submit-compensation")
+    session = plane.sessions.open_session(
+        fence,
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
+    )
+    request_id = plane.stage_request_id(fence, stage_id=0)
+
+    def fail_commit(_reservation):
+        raise RuntimeError("local commit failed")
+
+    session.commit_append = fail_commit  # type: ignore[method-assign]
+    await plane.handle(
+        AppendDuplexInputMessage(
+            control_id="append-compensation",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+        )
+    )
+
+    assert (await result_sink.get()).ok is False
+    assert stage_port.cleanup_calls == [([request_id], True)]
+
+
+@pytest.mark.asyncio
+async def test_failed_submission_compensation_blocks_append_until_reaper_cleans_it() -> None:
+    class _FailingCleanupStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.cleanup_failures = 2
+
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            await super().cleanup(request_ids, abort=abort)
+            if self.cleanup_failures > 0:
+                self.cleanup_failures -= 1
+                raise RuntimeError("stage abort failed")
+
+    stage_port = _FailingCleanupStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
+    fence = DuplexFence("sid-durable-submit-compensation")
+    session = plane.sessions.open_session(
+        fence,
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
+    )
+    original_commit = session.commit_append
+
+    def fail_commit(_reservation):
+        raise RuntimeError("local commit failed")
+
+    session.commit_append = fail_commit  # type: ignore[method-assign]
+    first = AppendDuplexInputMessage(
+        control_id="append-compensation-1",
+        fence=fence,
+        session_id=fence.session_id,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+        payload={"audio": b"pcm"},
+    )
+    await plane.handle(first)
+    assert (await result_sink.get()).ok is False
+    assert plane.pending_submission_cleanup_count == 1
+    assert len(stage_port.submit_calls) == 1
+
+    await plane.handle(
+        AppendDuplexInputMessage(
+            control_id="append-compensation-2",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+        )
+    )
+    assert (await result_sink.get()).ok is False
+    assert plane.pending_submission_cleanup_count == 1
+    assert len(stage_port.submit_calls) == 1
+
+    session.commit_append = original_commit  # type: ignore[method-assign]
+    stage_port.cleanup_failures = 0
+    await plane.reap_expired()
+
+    assert plane.pending_submission_cleanup_count == 0
+    assert session.resource_request_ids() == []
+
+
+def test_stale_output_is_rejected_before_extension_decision() -> None:
+    class _CountingExtension(_Extension):
+        def __init__(self) -> None:
+            self.decision_calls = 0
+
+        def decide_output(self, **kwargs):
+            del kwargs
+            self.decision_calls += 1
+            return None
+
+    extension = _CountingExtension()
+    plane = DuplexControlPlane(extension=extension, stage_port=_TypedStagePort(), result_sink=asyncio.Queue())
+    current = DuplexFence("sid-stale-output", epoch=1)
+    plane.sessions.open_session(current)
+    context = DuplexOutputContext(
+        identity=DuplexRequestIdentity(
+            session_id=current.session_id,
+            fence=DuplexFence(current.session_id, epoch=0),
+        ),
+        final_stage_id=1,
+        segment_finished=True,
+    )
+
+    assert plane.decide_output(0, object(), context) is None
+    assert extension.decision_calls == 0
+
+
+@pytest.mark.asyncio
+async def test_control_dispatch_is_ordered_per_session_without_blocking_other_sessions() -> None:
+    class _BlockingStagePort(_TypedStagePort):
+        def __init__(self) -> None:
+            super().__init__()
+            self.started = asyncio.Event()
+            self.release = asyncio.Event()
+
+        async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
+            if submission.context.session_id == "sid-blocked":
+                self.started.set()
+                await self.release.wait()
+            return await super().submit(submission)
+
+    stage_port = _BlockingStagePort()
+    result_sink: asyncio.Queue = asyncio.Queue()
+    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
+    blocked = DuplexFence("sid-blocked")
+    independent = DuplexFence("sid-independent")
+    capabilities = DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK})
+    plane.sessions.open_session(blocked, capabilities=capabilities)
+    plane.sessions.open_session(independent, capabilities=capabilities)
+
+    plane.dispatch(
+        AppendDuplexInputMessage(
+            control_id="blocked-append",
+            fence=blocked,
+            session_id=blocked.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+            operation_id="blocked-operation",
+        )
+    )
+    await asyncio.wait_for(stage_port.started.wait(), timeout=1)
+    plane.dispatch(
+        AppendDuplexInputMessage(
+            control_id="blocked-append-retry",
+            fence=blocked,
+            session_id=blocked.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"audio": b"pcm"},
+            operation_id="blocked-operation",
+        )
+    )
+    plane.dispatch(
+        TouchDuplexSessionMessage(
+            control_id="blocked-touch",
+            fence=blocked,
+            session_id=blocked.session_id,
+            activity=DuplexLeaseActivity.HEARTBEAT.value,
+        )
+    )
+    plane.dispatch(
+        TouchDuplexSessionMessage(
+            control_id="independent-touch",
+            fence=independent,
+            session_id=independent.session_id,
+            activity=DuplexLeaseActivity.HEARTBEAT.value,
+        )
+    )
+
+    independent_result = await asyncio.wait_for(result_sink.get(), timeout=1)
+    assert independent_result.control_id == "independent-touch"
+
+    stage_port.release.set()
+    await plane.drain()
+    assert [result_sink.get_nowait().control_id for _ in range(3)] == [
+        "blocked-append",
+        "blocked-append-retry",
+        "blocked-touch",
+    ]
+    assert [
+        submission.context.session_id
+        for submission in stage_port.submit_calls
+        if submission.context.session_id == blocked.session_id
+    ] == [blocked.session_id]
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_deploy_config.py b/tests/e2e/features/fullduplex/engine/test_duplex_deploy_config.py
new file mode 100644
index 000000000..abb387573
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_deploy_config.py
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Focused tests for typed deployment-only runtime configuration."""
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from vllm_omni.config.stage_config import (
+    DuplexSessionRuntimeConfig,
+    load_deploy_config,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_duplex_session_runtime_defaults_are_typed_and_immutable(tmp_path) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text("duplex_session: {}\nstages: []\n", encoding="utf-8")
+
+    deploy = load_deploy_config(deploy_path)
+
+    assert isinstance(deploy.duplex_session, DuplexSessionRuntimeConfig)
+    assert deploy.duplex_session.idle_ttl_s == 300.0
+    assert deploy.duplex_session.disconnect_grace_s == 30.0
+    assert deploy.duplex_session.reaper_interval_s == 5.0
+    assert deploy.duplex_session.resume_replay_ttl_s == 60.0
+    assert deploy.duplex_session.resume_replay_max_bytes_per_session == 8 * 1024 * 1024
+    assert deploy.duplex_session.max_pending_input_bytes_per_session == 16 * 1024 * 1024
+    assert deploy.duplex_session.max_pending_turns_per_session == 4
+    assert deploy.duplex_session.max_sessions == 1
+    assert deploy.duplex_session.completed_append_cache_size == 256
+    with pytest.raises(FrozenInstanceError):
+        deploy.duplex_session.idle_ttl_s = 1.0  # type: ignore[misc]
+
+
+def test_duplex_session_runtime_accepts_disabled_idle_expiry(tmp_path) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text("duplex_session:\n  idle_ttl_s: null\nstages: []\n", encoding="utf-8")
+
+    deploy = load_deploy_config(deploy_path)
+
+    assert deploy.duplex_session.idle_ttl_s is None
+
+
+@pytest.mark.parametrize(
+    ("name", "value"),
+    [
+        ("idle_ttl_s", 0),
+        ("idle_ttl_s", -1),
+        ("disconnect_grace_s", 0),
+        ("reaper_interval_s", -1),
+        ("resume_replay_ttl_s", 0),
+        ("resume_replay_max_bytes_per_session", -1),
+        ("max_pending_input_bytes_per_session", 0),
+        ("max_pending_turns_per_session", -1),
+        ("max_sessions", 0),
+        ("completed_append_cache_size", 0),
+    ],
+)
+def test_duplex_session_runtime_rejects_non_positive_values(tmp_path, name: str, value: int) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text(f"duplex_session:\n  {name}: {value}\nstages: []\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match=rf"duplex_session\.{name} must be positive"):
+        load_deploy_config(deploy_path)
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_intermediate.py b/tests/e2e/features/fullduplex/engine/test_duplex_intermediate.py
new file mode 100644
index 000000000..37602e62e
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_intermediate.py
@@ -0,0 +1,14 @@
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.intermediate import get_stream_request_key
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_get_stream_request_key_requires_stable_identifier():
+    with pytest.raises(ValueError, match="stable request id"):
+        get_stream_request_key({"ids": {"tts": [1, 2, 3]}})
+
+
+def test_get_stream_request_key_accepts_global_request_id():
+    assert get_stream_request_key({"global_request_id": ["duplex-sid-stage0"]}) == "duplex-sid-stage0"
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_lease.py b/tests/e2e/features/fullduplex/engine/test_duplex_lease.py
new file mode 100644
index 000000000..80e7a73eb
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_lease.py
@@ -0,0 +1,224 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import DuplexInputMode
+from vllm_omni.experimental.fullduplex.engine.duplex_session import DuplexSessionRuntimeManager
+from vllm_omni.experimental.fullduplex.engine.lease import (
+    DuplexLeaseActivity,
+    DuplexLeaseConfig,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FakeMonotonicClock:
+    def __init__(self, value: float) -> None:
+        self.value = value
+
+    def __call__(self) -> float:
+        return self.value
+
+    def advance(self, seconds: float) -> None:
+        self.value += seconds
+
+
+def _lease_config(*, idle_ttl_s: float | None = 300.0) -> DuplexLeaseConfig:
+    return DuplexLeaseConfig(
+        idle_ttl_s=idle_ttl_s,
+        disconnect_grace_s=30.0,
+    )
+
+
+def test_open_touch_detach_and_idle_expiry_use_monotonic_time() -> None:
+    clock = FakeMonotonicClock(100.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-expiry")
+    session = manager.open_session(fence, lease_config=_lease_config())
+
+    assert session.lease.last_activity == 100.0
+    clock.advance(10.0)
+    session.touch(fence, DuplexLeaseActivity.HEARTBEAT)
+    session.detach(fence)
+    clock.advance(29.0)
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    assert manager.collect_expired() == []
+
+    clock.advance(272.0)
+    expired = manager.collect_expired()
+
+    assert [item.session_id for item in expired] == ["sid-expiry"]
+    assert expired[0].reason == "disconnect_grace_expired"
+    assert manager.get("sid-expiry") is session
+    manager.finalize_close_session(session)
+    assert manager.get("sid-expiry") is None
+
+
+def test_detach_grace_and_resume_advance_token_independent_lease_generation() -> None:
+    clock = FakeMonotonicClock(10.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-resume")
+    session = manager.open_session(fence, lease_config=_lease_config())
+
+    session.detach(fence)
+    clock.advance(29.0)
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    clock.advance(2.0)
+    assert session.lease.disconnect_grace_expired(clock()) is True
+
+    generation = session.resume(fence, expected_lease_generation=0)
+
+    assert generation == 1
+    assert session.lease.detached_at is None
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    with pytest.raises(ValueError, match="lease generation mismatch"):
+        session.resume(fence, expected_lease_generation=0)
+
+
+def test_active_operation_prevents_mid_transaction_expiry() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-operation")
+    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=5.0))
+
+    session.begin_operation(fence, "append-1")
+    clock.advance(10.0)
+    assert manager.collect_expired() == []
+
+    session.end_operation(fence, "append-1")
+    assert manager.collect_expired() == []
+    clock.advance(6.0)
+    assert [item.session_id for item in manager.collect_expired()] == ["sid-operation"]
+
+
+def test_sessions_have_independent_activity_deadlines_and_resources() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence_a = DuplexFence("sid-a")
+    fence_b = DuplexFence("sid-b")
+    session_a = manager.open_session(fence_a, lease_config=_lease_config(idle_ttl_s=10.0))
+    session_b = manager.open_session(fence_b, lease_config=_lease_config(idle_ttl_s=10.0))
+    session_a.reserve_stage_request(0, "req-a-reserved", fence=fence_a)
+    session_a.bind_stage_request(1, "req-a-submitted", fence=fence_a)
+    session_b.bind_stage_request(0, "req-b", fence=fence_b)
+
+    clock.advance(6.0)
+    session_b.touch(fence_b, DuplexLeaseActivity.MODEL_OUTPUT)
+    clock.advance(5.0)
+    expired = manager.collect_expired()
+
+    assert len(expired) == 1
+    assert expired[0].session_id == "sid-a"
+    assert expired[0].reserved_request_ids == ("req-a-reserved",)
+    assert expired[0].submitted_request_ids == ("req-a-submitted",)
+    assert manager.get("sid-b") is session_b
+    assert session_b.resource_request_ids() == ["req-b"]
+
+
+def test_close_and_reaper_select_exactly_one_terminal_transition() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-race")
+    manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=1.0))
+    clock.advance(2.0)
+
+    assert len(manager.collect_expired()) == 1
+    assert manager.close_session(fence, reason="explicit_close") is None
+    assert manager.collect_expired() == []
+
+    fence_2 = DuplexFence("sid-race-2")
+    manager.open_session(fence_2, lease_config=_lease_config(idle_ttl_s=1.0))
+    assert manager.close_session(fence_2, reason="explicit_close") is not None
+    clock.advance(2.0)
+    assert manager.collect_expired() == []
+
+
+def test_stale_fence_cannot_touch_detach_or_resume_lease() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    current = DuplexFence("sid-fence", epoch=1)
+    stale = DuplexFence("sid-fence", epoch=0)
+    session = manager.open_session(current, lease_config=_lease_config())
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.touch(stale, DuplexLeaseActivity.APPEND)
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.detach(stale)
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.resume(stale, expected_lease_generation=0)
+
+
+def test_disabled_idle_expiry_never_collects_session() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    manager.open_session(DuplexFence("sid-no-expiry"), lease_config=_lease_config(idle_ttl_s=None))
+
+    clock.advance(1_000_000.0)
+
+    assert manager.collect_expired() == []
+
+
+def test_detached_session_expires_at_disconnect_grace_when_idle_ttl_is_disabled() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-disconnect-grace")
+    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=None))
+
+    session.detach(fence)
+    clock.advance(29.0)
+    assert manager.collect_expired() == []
+
+    clock.advance(1.0)
+    expired = manager.collect_expired()
+
+    assert [item.session_id for item in expired] == [fence.session_id]
+    assert expired[0].reason == "disconnect_grace_expired"
+
+
+def test_runtime_manager_enforces_server_owned_session_admission() -> None:
+    manager = DuplexSessionRuntimeManager(max_sessions=2)
+    manager.open_session(DuplexFence("sid-admission-a"))
+    manager.open_session(DuplexFence("sid-admission-b"))
+
+    with pytest.raises(RuntimeError, match="duplex_session_capacity_exhausted"):
+        manager.open_session(DuplexFence("sid-admission-c"))
+
+
+def test_completed_append_cache_is_bounded() -> None:
+    manager = DuplexSessionRuntimeManager(completed_append_limit=2)
+    fence = DuplexFence("sid-completed-cache")
+    session = manager.open_session(fence)
+
+    for index in range(3):
+        session.record_completed_append(
+            f"operation-{index}",
+            fence=fence,
+            mode=DuplexInputMode.TURN_COMMIT_ONLY,
+            final=True,
+            stage_results=[{"index": index}],
+        )
+
+    assert list(session.completed_appends) == ["operation-1", "operation-2"]
+
+    session.accept_fence(DuplexFence(fence.session_id, epoch=1))
+    assert session.completed_appends == {}
+
+
+def test_lease_config_and_expiry_record_are_immutable() -> None:
+    config = _lease_config()
+    with pytest.raises(FrozenInstanceError):
+        config.idle_ttl_s = 1.0  # type: ignore[misc]
+
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    manager.open_session(DuplexFence("sid-record"), lease_config=_lease_config(idle_ttl_s=1.0))
+    clock.advance(2.0)
+    record = manager.collect_expired()[0]
+    with pytest.raises(FrozenInstanceError):
+        record.reason = "changed"  # type: ignore[misc]
diff --git a/tests/e2e/features/fullduplex/engine/test_duplex_runtime.py b/tests/e2e/features/fullduplex/engine/test_duplex_runtime.py
new file mode 100644
index 000000000..7cce93161
--- /dev/null
+++ b/tests/e2e/features/fullduplex/engine/test_duplex_runtime.py
@@ -0,0 +1,480 @@
+from dataclasses import FrozenInstanceError
+from types import SimpleNamespace
+
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.experimental.fullduplex.engine import duplex_runtime
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    duplex_data_plane_request_info,
+    duplex_resource_request_belongs_to_session,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexInputMode,
+    DuplexOutputAction,
+    DuplexOutputDecision,
+    DuplexRuntimeCapabilities,
+    DuplexSessionRuntimeManager,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.minicpmo45.runtime import (
+    MiniCPMO45DuplexRuntimeExtension,
+    build_duplex_data_plane_prompt,
+    duplex_scheduler_token_budget,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_duplex_fence_is_immutable():
+    fence = DuplexFence("session")
+
+    with pytest.raises(FrozenInstanceError):
+        fence.epoch = 1  # type: ignore[misc]
+
+    assert not hasattr(fence, "__dict__")
+
+
+def test_duplex_runtime_tracks_stage_bindings_and_barge_in_epoch():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-1"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_TOKENS},
+        ),
+    )
+    session.bind_stage_request(stage_id=0, request_id="req-stage0", fence=session.fence)
+    session.bind_stage_request(stage_id=1, request_id="req-stage1", fence=session.fence)
+
+    update = session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
+    next_fence = DuplexFence("sid-1", epoch=1)
+    stale_request_ids = session.release_fence(session.fence)
+    session.accept_fence(next_fence)
+
+    assert update.seq == 1
+    assert session.fence == next_fence
+    assert stale_request_ids == ["req-stage0", "req-stage1"]
+    assert session.stage_bindings == {}
+
+
+def test_duplex_runtime_tracks_same_request_id_for_each_pipeline_stage():
+    manager = DuplexSessionRuntimeManager()
+    fence = DuplexFence("sid-shared-pipeline-request")
+    session = manager.open_session(fence)
+
+    session.reserve_stage_request(0, "req-shared", fence=fence)
+    session.bind_stage_request(0, "req-shared", fence=fence)
+    session.bind_stage_request(1, "req-shared", fence=fence)
+
+    assert session.stage_bindings[0].request_id == "req-shared"
+    assert session.stage_bindings[1].request_id == "req-shared"
+    assert session.resource_request_ids() == ["req-shared"]
+    assert session.input_seq == 0
+
+
+def test_duplex_runtime_extension_validation_rejects_missing_methods():
+    class IncompleteExtension:
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults
+
+    with pytest.raises(TypeError, match="plan_append"):
+        duplex_runtime.validate_duplex_runtime_extension(IncompleteExtension())
+
+
+def test_duplex_runtime_extension_validation_rejects_stage_count_mismatch():
+    class WrongStageCountExtension(MiniCPMO45DuplexRuntimeExtension):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults[:1]
+
+    with pytest.raises(ValueError, match="one sampling parameter per stage"):
+        duplex_runtime.validate_duplex_runtime_extension(
+            WrongStageCountExtension(),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_duplex_runtime_extension_validation_rejects_sampling_type_mismatch():
+    class WrongSamplingTypeExtension(MiniCPMO45DuplexRuntimeExtension):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return tuple(object() for _ in defaults)
+
+    with pytest.raises(TypeError, match="sampling parameter type"):
+        duplex_runtime.validate_duplex_runtime_extension(
+            WrongSamplingTypeExtension(),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_duplex_output_decision_metadata_is_immutable():
+    decision = DuplexOutputDecision(
+        action=DuplexOutputAction.DIRECT_RESPONSE,
+        metadata={"model_listen": True},
+    )
+
+    with pytest.raises(TypeError):
+        decision.metadata["model_listen"] = False
+
+
+def _decide_minicpmo_output(
+    output: object,
+    *,
+    segment_token_ids: tuple[int, ...] = (),
+    segment_output_metadata: dict | None = None,
+):
+    return MiniCPMO45DuplexRuntimeExtension().decide_output(
+        stage_id=0,
+        final_stage_id=1,
+        segment_finished=True,
+        segment_token_ids=segment_token_ids,
+        segment_output_metadata=segment_output_metadata or {},
+        output=output,
+    )
+
+
+def test_minicpmo_extension_owns_stage_sampling_overrides():
+    defaults = (
+        SamplingParams(max_tokens=4),
+        SamplingParams(max_tokens=8),
+    )
+
+    configured = MiniCPMO45DuplexRuntimeExtension().configure_sampling_params(
+        runtime_config={
+            "duplex_stage_max_tokens": {"0": 20},
+            "duplex_stage_sampling_params": {"1": {"stop_token_ids": [151645]}},
+        },
+        defaults=defaults,
+    )
+
+    assert configured[0].max_tokens == 20
+    assert configured[1].stop_token_ids == [151645]
+    assert defaults[0].max_tokens == 4
+    assert 151645 not in (defaults[1].stop_token_ids or [])
+
+
+def test_minicpmo_output_decision_uses_raw_streaming_token_snapshot():
+    decision = _decide_minicpmo_output(
+        SimpleNamespace(outputs=[SimpleNamespace()]),
+        segment_token_ids=(151705,),
+        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
+    )
+
+    assert decision is not None
+    assert decision.action is DuplexOutputAction.DIRECT_RESPONSE
+    assert decision.metadata["duplex_native_decision"] == "listen"
+    assert decision.metadata["model_listen"] is True
+
+
+@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
+def test_minicpmo_output_decision_ignores_output_level_token_history(attr):
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace()],
+        **{attr: [42, 151705]},
+    )
+
+    assert _decide_minicpmo_output(output) is None
+
+
+@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
+def test_minicpmo_output_decision_uses_completion_token_ids(attr):
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace(**{attr: [42, 151705]})],
+    )
+
+    assert _decide_minicpmo_output(output) is not None
+
+
+def test_minicpmo_output_decision_uses_completion_stop_reason():
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace(stop_reason=151705)],
+    )
+
+    assert _decide_minicpmo_output(output) is not None
+
+
+def test_duplex_runtime_cancel_fence_rejects_late_append_and_accepts_next_epoch():
+    manager = DuplexSessionRuntimeManager()
+    cancelled_fence = DuplexFence("sid-cancel-race")
+    next_fence = DuplexFence("sid-cancel-race", epoch=1)
+    session = manager.open_session(
+        cancelled_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(
+        stage_id=0,
+        request_id="req-cancelled",
+        fence=cancelled_fence,
+    )
+
+    stale_request_ids = session.cancel_fence(cancelled_fence, next_fence)
+
+    assert stale_request_ids == ["req-cancelled"]
+    assert session.fence == next_fence
+    assert session.stage_bindings == {}
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=cancelled_fence,
+        )
+    update = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_fence,
+    )
+    assert update.seq == 1
+
+
+def test_duplex_runtime_stale_close_preserves_live_session_and_bindings():
+    manager = DuplexSessionRuntimeManager()
+    current_fence = DuplexFence("sid-stale-close", epoch=1)
+    session = manager.open_session(
+        current_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(0, "req-live", fence=current_fence)
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        manager.close_session(DuplexFence("sid-stale-close"))
+
+    assert manager.get("sid-stale-close") is session
+    assert session.stage_request_ids() == ["req-live"]
+
+
+def test_duplex_runtime_reopen_rejects_late_append_from_old_incarnation():
+    manager = DuplexSessionRuntimeManager()
+    old_fence = DuplexFence("sid-reopen", incarnation=0)
+    old_session = manager.open_session(
+        old_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    manager.close_session(old_fence)
+
+    new_fence = DuplexFence("sid-reopen", incarnation=1)
+    new_session = manager.open_session(
+        new_fence,
+        capabilities=old_session.capabilities,
+    )
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        new_session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=old_fence,
+        )
+    assert (
+        new_session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=new_fence,
+        ).seq
+        == 1
+    )
+
+
+def test_duplex_prompt_expands_incarnation_metadata():
+    fence = DuplexFence("sid-incarnation", incarnation=3)
+
+    prompt = build_duplex_data_plane_prompt(
+        request_id=duplex_resource_request_id(fence, "stage0"),
+        fence=fence,
+        session_config={},
+        runtime_config={},
+        seq=1,
+        turn_seq=1,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload={"is_speech": True},
+        final=False,
+    )
+
+    assert prompt["model_intermediate_buffer"]["duplex"]["incarnation"] == 3
+
+
+def test_duplex_runtime_tracks_turn_local_append_sequence():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-turn-seq"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+
+    first = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
+    second = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
+    next_turn = DuplexFence("sid-turn-seq", turn_id=1, response_seq=1)
+    third = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_turn,
+    )
+    fourth = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_turn,
+    )
+
+    assert [first.seq, second.seq, third.seq, fourth.seq] == [1, 2, 3, 4]
+    assert [first.turn_seq, second.turn_seq, third.turn_seq, fourth.turn_seq] == [1, 2, 1, 2]
+    assert [first.turn_id, second.turn_id, third.turn_id, fourth.turn_id] == [0, 0, 1, 1]
+
+
+def test_duplex_runtime_rejects_unsupported_append_mode():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-2"),
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.TURN_COMMIT_ONLY}),
+    )
+
+    with pytest.raises(ValueError, match="not supported"):
+        session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
+
+
+def test_duplex_data_plane_request_info_extracts_structured_stage_result():
+    request_id, response_stage_id = duplex_data_plane_request_info(
+        {
+            "stage_results": [
+                {"result": {"supported": True}},
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": "duplex-sid-e0-stage0-s1",
+                        "response_stage_id": 1,
+                    }
+                },
+            ]
+        }
+    )
+
+    assert request_id == "duplex-sid-e0-stage0-s1"
+    assert response_stage_id == 1
+
+
+def test_duplex_data_plane_request_info_rejects_missing_request_id():
+    assert duplex_data_plane_request_info(
+        {
+            "stage_results": [
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": "",
+                        "response_stage_id": 1,
+                    }
+                }
+            ]
+        }
+    ) == (None, None)
+
+
+def test_duplex_scheduler_token_budget_estimates_pcm_slots():
+    assert (
+        duplex_scheduler_token_budget(
+            {
+                "audio": "AAAAAA==",
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+        == 16
+    )
+
+
+def test_duplex_scheduler_token_budget_ignores_client_budget_fields():
+    assert (
+        duplex_scheduler_token_budget(
+            {
+                "audio": "AAAAAA==",
+                "format": "pcm_f32le",
+                "duplex_num_input_tokens": 999,
+                "num_input_tokens": 999,
+            }
+        )
+        == 16
+    )
+
+
+def test_resource_state_rejects_fence_regression_and_requires_explicit_fence():
+    current = DuplexFence("sid", epoch=2, turn_id=3, response_seq=4)
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        current,
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
+    )
+
+    for stale in (
+        DuplexFence("sid", epoch=1, turn_id=99, response_seq=99),
+        DuplexFence("sid", epoch=2, turn_id=2, response_seq=4),
+        DuplexFence("sid", epoch=2, turn_id=3, response_seq=3),
+    ):
+        with pytest.raises(RuntimeError, match="fence mismatch"):
+            session.accept_fence(stale)
+        assert session.fence == current
+
+    with pytest.raises(TypeError, match="fence"):
+        session.bind_stage_request(0, "request")
+    with pytest.raises(TypeError, match="fence"):
+        session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK)
+    with pytest.raises(TypeError, match="DuplexFence"):
+        manager.open_session("legacy-session")
+    with pytest.raises(TypeError, match="DuplexFence"):
+        manager.close_session("legacy-session")
+
+
+def test_resource_request_id_is_derived_from_fence_and_role():
+    fence = DuplexFence("sid-with-dashes", epoch=7, turn_id=11, response_seq=13)
+
+    assert duplex_resource_request_id(fence, "stage0") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage0"
+    assert duplex_resource_request_id(fence, "stage1") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage1"
+
+
+def test_resource_request_id_codec_separates_session_id_from_incarnation():
+    embedded_incarnation = duplex_resource_request_id(
+        DuplexFence("foo-i1", incarnation=0),
+        "stage0",
+    )
+    actual_incarnation = duplex_resource_request_id(
+        DuplexFence("foo", incarnation=1),
+        "stage0",
+    )
+
+    assert embedded_incarnation != actual_incarnation
+
+
+def test_resource_request_id_session_membership_uses_encoded_identity():
+    request_id = duplex_resource_request_id(
+        DuplexFence("sid-with-dashes", incarnation=2, epoch=7),
+        "stage0",
+    )
+
+    assert duplex_resource_request_belongs_to_session(request_id, "sid-with-dashes") is True
+    assert duplex_resource_request_belongs_to_session(request_id, "sid") is False
+    assert duplex_resource_request_belongs_to_session("duplex-s.invalid.i.x.e.7.r.stage0", "sid") is False
+
+
+def test_placeholder_budget_is_planned_inside_omni_engine_boundary():
+    fence = DuplexFence("sid", turn_id=1, response_seq=1)
+    prompt = build_duplex_data_plane_prompt(
+        request_id=duplex_resource_request_id(fence, "stage0"),
+        fence=fence,
+        session_config={},
+        runtime_config={},
+        seq=2,
+        turn_seq=1,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload={
+            "audio": "AAAAAA==",
+            "format": "pcm_f32le",
+            "duplex_num_input_tokens": 999,
+            "num_input_tokens": 999,
+        },
+        final=False,
+    )
+
+    assert len(prompt["prompt_token_ids"]) == 16
+    assert prompt["model_intermediate_buffer"]["duplex"]["fence"] == fence
+    assert prompt["model_intermediate_buffer"]["duplex"]["scheduler_token_budget"] == 16
diff --git a/vllm_omni/model_executor/stage_configs/__init__.py b/tests/e2e/features/fullduplex/minicpmo45/__init__.py
similarity index 100%
rename from vllm_omni/model_executor/stage_configs/__init__.py
rename to tests/e2e/features/fullduplex/minicpmo45/__init__.py
diff --git a/tests/e2e/features/fullduplex/minicpmo45/test_commit_policy.py b/tests/e2e/features/fullduplex/minicpmo45/test_commit_policy.py
new file mode 100644
index 000000000..5ee66b41a
--- /dev/null
+++ b/tests/e2e/features/fullduplex/minicpmo45/test_commit_policy.py
@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.commit_policy import (
+    CommitAction,
+    CommitSnapshot,
+    decide_commit_action,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    ("case", "snapshot", "expected"),
+    [
+        (
+            "first idle commit",
+            CommitSnapshot(
+                auto_responds=True,
+                speech_since_commit=True,
+                active_response_id=None,
+                overlap_speech_ms=0,
+                native_response_in_progress=False,
+                playback_active=False,
+            ),
+            CommitAction.START_AUTO_RESPONSE,
+        ),
+        (
+            "native auto-response remains model-owned during playback",
+            CommitSnapshot(
+                auto_responds=True,
+                speech_since_commit=True,
+                active_response_id=None,
+                overlap_speech_ms=800,
+                native_response_in_progress=True,
+                playback_active=True,
+            ),
+            CommitAction.START_AUTO_RESPONSE,
+        ),
+        (
+            "native auto-response commit without speech",
+            CommitSnapshot(
+                auto_responds=True,
+                speech_since_commit=False,
+                active_response_id=None,
+                overlap_speech_ms=0,
+                native_response_in_progress=True,
+                playback_active=False,
+            ),
+            CommitAction.COMMIT_ONLY,
+        ),
+        (
+            "non-auto response overlap",
+            CommitSnapshot(
+                auto_responds=False,
+                speech_since_commit=True,
+                active_response_id=None,
+                overlap_speech_ms=800,
+                native_response_in_progress=True,
+                playback_active=False,
+            ),
+            CommitAction.DEFER_ACTIVE_RESPONSE,
+        ),
+        (
+            "non-auto playback overlap",
+            CommitSnapshot(
+                auto_responds=False,
+                speech_since_commit=True,
+                active_response_id=None,
+                overlap_speech_ms=800,
+                native_response_in_progress=False,
+                playback_active=True,
+            ),
+            CommitAction.DEFER_ACTIVE_RESPONSE,
+        ),
+        (
+            "non-auto commit without overlap",
+            CommitSnapshot(
+                auto_responds=False,
+                speech_since_commit=True,
+                active_response_id=None,
+                overlap_speech_ms=0,
+                native_response_in_progress=False,
+                playback_active=False,
+            ),
+            CommitAction.COMMIT_ONLY,
+        ),
+    ],
+    ids=lambda value: value if isinstance(value, str) else None,
+)
+def test_decide_commit_action_covers_realtime_lifecycle_sequences(
+    case: str,
+    snapshot: CommitSnapshot,
+    expected: CommitAction,
+) -> None:
+    del case
+
+    assert decide_commit_action(snapshot) is expected
diff --git a/tests/e2e/features/fullduplex/minicpmo45/test_input.py b/tests/e2e/features/fullduplex/minicpmo45/test_input.py
new file mode 100644
index 000000000..5562fb237
--- /dev/null
+++ b/tests/e2e/features/fullduplex/minicpmo45/test_input.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.minicpmo45.input import MiniCPMO45PcmAppendBuffer
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def pcm_payload(samples: int, *, speech: bool = True) -> dict[str, object]:
+    audio = np.ones(samples, dtype=np.float32).tobytes()
+    return {
+        "type": "audio",
+        "audio": base64.b64encode(audio).decode("ascii"),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16_000,
+        "is_speech": speech,
+    }
+
+
+def test_commit_does_not_add_silence_after_incremental_audio_was_drained():
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    emitted = buffer.append(pcm_payload(16_000), chunk_period_ms=1_000)
+    committed = buffer.commit(chunk_period_ms=1_000)
+
+    assert emitted is not None
+    assert not buffer.has_pending()
+    assert committed is None
+
+
+def test_append_emits_one_model_unit_when_multiple_units_are_buffered():
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    emitted = buffer.append(pcm_payload(32_000), chunk_period_ms=1_000)
+
+    assert emitted is not None
+    assert len(base64.b64decode(emitted["audio"])) == 16_000 * 4
+    assert buffer.pending_byte_count == 16_000 * 4
+
+
+def test_speech_marker_does_not_leak_across_irregular_chunk_boundaries():
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    assert buffer.append(pcm_payload(15_000), chunk_period_ms=1_000) is None
+    speech_unit = buffer.append(pcm_payload(2_000, speech=False), chunk_period_ms=1_000)
+    silence_unit = buffer.append(pcm_payload(15_000, speech=False), chunk_period_ms=1_000)
+
+    assert speech_unit is not None
+    assert speech_unit["is_speech"] is True
+    assert silence_unit is not None
+    assert silence_unit["is_speech"] is False
+
+
+def test_force_listen_marker_does_not_leak_across_irregular_chunk_boundaries():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    forced = pcm_payload(15_000, speech=False)
+    forced["force_listen"] = True
+
+    assert buffer.append(forced, chunk_period_ms=1_000) is None
+    forced_unit = buffer.append(pcm_payload(2_000, speech=False), chunk_period_ms=1_000)
+    unforced_unit = buffer.append(pcm_payload(15_000, speech=False), chunk_period_ms=1_000)
+
+    assert forced_unit is not None
+    assert forced_unit["force_listen"] is True
+    assert unforced_unit is not None
+    assert unforced_unit["force_listen"] is False
+
+
+def test_pcm_append_rollback_restores_per_span_speech_markers():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    assert buffer.append(pcm_payload(15_000), chunk_period_ms=1_000) is None
+    reservation = buffer.prepare_append(
+        pcm_payload(2_000, speech=False),
+        operation_id="mixed-unit",
+        chunk_period_ms=1_000,
+    )
+
+    assert reservation is not None
+    reservation.rollback()
+    first = buffer.append(pcm_payload(15_000, speech=False), chunk_period_ms=1_000)
+    second = buffer.flush(chunk_period_ms=1_000)
+
+    assert first is not None
+    assert first["is_speech"] is True
+    assert second is not None
+    assert second["is_speech"] is False
+
+
+def test_commit_without_speech_does_not_synthesize_terminal_audio():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    buffer.append(pcm_payload(8_000, speech=False), chunk_period_ms=1_000)
+
+    committed = buffer.commit(chunk_period_ms=1_000)
+
+    assert committed is None
+
+
+def test_commit_resets_cumulative_turn_accounting():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    buffer.append(pcm_payload(16_000), chunk_period_ms=1_000)
+    buffer.commit(chunk_period_ms=1_000)
+
+    empty = buffer.commit(chunk_period_ms=1_000)
+
+    assert empty is None
+
+
+def test_pcm_append_reservation_rollback_restores_emitted_audio():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    original = pcm_payload(16_000)
+
+    reservation = buffer.prepare_append(
+        original,
+        operation_id="append-1",
+        chunk_period_ms=1_000,
+    )
+
+    assert reservation is not None
+    assert not buffer.has_pending()
+    reservation.rollback()
+    assert buffer.has_pending()
+
+    retried = buffer.flush(chunk_period_ms=1_000)
+    assert retried is not None
+    assert base64.b64decode(retried["audio"]) == base64.b64decode(original["audio"])
+
+
+def test_pcm_commit_keeps_prior_append_reservation_active():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    append_reservation = buffer.prepare_append(
+        pcm_payload(16_000),
+        operation_id="append-before-commit",
+        chunk_period_ms=1_000,
+    )
+
+    commit_reservation = buffer.prepare_commit(
+        operation_id="commit-after-append",
+        chunk_period_ms=1_000,
+    )
+
+    assert append_reservation is not None
+    assert append_reservation.active
+    assert commit_reservation.payload is None
+    append_reservation.commit()
+    commit_reservation.commit()
+
+
+def test_pcm_commit_reservation_rollback_restores_residual_audio():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    original = pcm_payload(8_000)
+    assert (
+        buffer.prepare_append(
+            original,
+            operation_id="buffer-half-chunk",
+            chunk_period_ms=1_000,
+        )
+        is None
+    )
+
+    reservation = buffer.prepare_commit(
+        operation_id="final-half-chunk",
+        chunk_period_ms=1_000,
+    )
+
+    assert reservation.payload is not None
+    assert reservation.payload["final"] is True
+    reservation.rollback()
+
+    retried = buffer.prepare_commit(
+        operation_id="retry-final-half-chunk",
+        chunk_period_ms=1_000,
+    )
+    assert retried.payload is not None
+    assert base64.b64decode(retried.payload["audio"]) == (base64.b64decode(original["audio"]) + b"\x00" * (8_000 * 4))
diff --git a/tests/e2e/features/fullduplex/openai/test_duplex_audio.py b/tests/e2e/features/fullduplex/openai/test_duplex_audio.py
new file mode 100644
index 000000000..535856976
--- /dev/null
+++ b/tests/e2e/features/fullduplex/openai/test_duplex_audio.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.audio import convert_input_audio_with_rate
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_pcm16_input_conversion_is_pure_and_reports_target_rate():
+    pcm16 = np.array([-32768, 0, 32767], dtype="<i2").tobytes()
+    encoded = base64.b64encode(pcm16).decode("ascii")
+
+    converted, fmt, sample_rate = convert_input_audio_with_rate(
+        encoded,
+        "pcm16",
+        sample_rate_hz=16_000,
+    )
+
+    assert encoded == base64.b64encode(pcm16).decode("ascii")
+    assert fmt == "pcm_f32le"
+    assert sample_rate == 16_000
+    samples = np.frombuffer(base64.b64decode(converted), dtype="<f4")
+    assert np.allclose(samples, [-1.0, 0.0, 32767 / 32768])
+
+
+@pytest.mark.parametrize("sample_rate_hz", [8_000, 192_000])
+def test_pcm16_input_conversion_accepts_supported_sample_rate_boundaries(sample_rate_hz: int):
+    encoded = base64.b64encode(np.zeros(8, dtype="<i2").tobytes()).decode("ascii")
+
+    _, fmt, converted_rate = convert_input_audio_with_rate(
+        encoded,
+        "pcm16",
+        sample_rate_hz=sample_rate_hz,
+    )
+
+    assert fmt == "pcm_f32le"
+    assert converted_rate == 16_000
+
+
+@pytest.mark.parametrize("sample_rate_hz", [7_999, 192_001, 10**1000])
+def test_pcm16_input_conversion_rejects_sample_rates_outside_supported_range(sample_rate_hz: int):
+    encoded = base64.b64encode(np.zeros(8, dtype="<i2").tobytes()).decode("ascii")
+
+    with pytest.raises(ValueError, match="sample_rate_hz"):
+        convert_input_audio_with_rate(
+            encoded,
+            "pcm16",
+            sample_rate_hz=sample_rate_hz,
+        )
diff --git a/tests/e2e/features/fullduplex/openai/test_runtime_adapter_boundary.py b/tests/e2e/features/fullduplex/openai/test_runtime_adapter_boundary.py
new file mode 100644
index 000000000..d7cecc13d
--- /dev/null
+++ b/tests/e2e/features/fullduplex/openai/test_runtime_adapter_boundary.py
@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    validate_serving_runtime_adapter,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    "module_name",
+    [
+        "vllm_omni.experimental.fullduplex.openai.session_runner",
+        "vllm_omni.experimental.fullduplex.openai.runtime_bridge",
+        "vllm_omni.experimental.fullduplex.openai.serving",
+    ],
+)
+def test_generic_openai_runtime_import_does_not_load_minicpmo45(module_name: str) -> None:
+    repo_root = Path(__file__).resolve().parents[3]
+    script = f"""
+import sys
+
+import {module_name}
+
+loaded = sorted(
+    name
+    for name in sys.modules
+    if name == "vllm_omni.experimental.fullduplex.minicpmo45"
+    or name.startswith("vllm_omni.experimental.fullduplex.minicpmo45.")
+)
+if loaded:
+    raise SystemExit("generic OpenAI runtime loaded MiniCPM-o: " + ", ".join(loaded))
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def test_generic_handler_requires_explicit_serving_runtime_adapter() -> None:
+    repo_root = Path(__file__).resolve().parents[3]
+    script = """
+from types import SimpleNamespace
+
+from vllm_omni.experimental.fullduplex.openai.serving import OmniDuplexSessionHandler
+
+chat_service = SimpleNamespace(engine_client=SimpleNamespace())
+try:
+    OmniDuplexSessionHandler(chat_service=chat_service)
+except ValueError as exc:
+    if "serving runtime adapter" not in str(exc).lower():
+        raise
+else:
+    raise SystemExit("generic handler silently selected a model serving adapter")
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def _valid_runtime_adapter() -> SimpleNamespace:
+    data_plane = SimpleNamespace(
+        begin_request=lambda request_id: None,
+        is_terminal=lambda request_id: False,
+        mark_terminal=lambda request_id: None,
+        close_stream=lambda request_id: None,
+        close_session=lambda session_id, **kwargs: None,
+        project=lambda result, **kwargs: (),
+    )
+    return SimpleNamespace(
+        adapter_id="test-adapter",
+        session_states={},
+        data_plane=data_plane,
+        clean_response_done_prefix="clean",
+        interrupted_tts_prefix="interrupted",
+        private_runtime_config_keys=frozenset({"private_key"}),
+        create_session_state=lambda: object(),
+        session_state=lambda session_id: object(),
+        remove_session_state=lambda session_id: None,
+        is_enabled=lambda config: True,
+        capabilities=lambda **kwargs: object(),
+        validate_client_extra_body=lambda extra_body: None,
+        prepare_runtime_config=lambda config, **kwargs: {},
+        runtime_config_for_update=lambda config, current: {},
+        data_plane_context=lambda **kwargs: object(),
+    )
+
+
+@pytest.mark.parametrize(
+    ("attribute", "invalid_value"),
+    [
+        ("session_states", None),
+        ("clean_response_done_prefix", None),
+        ("interrupted_tts_prefix", None),
+        ("private_runtime_config_keys", {"private_key"}),
+    ],
+)
+def test_runtime_adapter_validator_rejects_invalid_protocol_attributes(
+    attribute: str,
+    invalid_value: object,
+) -> None:
+    adapter = _valid_runtime_adapter()
+    setattr(adapter, attribute, invalid_value)
+
+    with pytest.raises(TypeError, match=attribute):
+        validate_serving_runtime_adapter(adapter)
+
+
+def test_runtime_adapter_validator_rejects_incomplete_data_plane() -> None:
+    adapter = _valid_runtime_adapter()
+    adapter.data_plane.close_session = None
+
+    with pytest.raises(TypeError, match="data_plane.*close_session"):
+        validate_serving_runtime_adapter(adapter)
diff --git a/tests/e2e/features/fullduplex/openai/test_runtime_control_redaction.py b/tests/e2e/features/fullduplex/openai/test_runtime_control_redaction.py
new file mode 100644
index 000000000..16bea686d
--- /dev/null
+++ b/tests/e2e/features/fullduplex/openai/test_runtime_control_redaction.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Regression tests for duplex ``runtime_control`` payload redaction.
+
+The redacted result is emitted on the WebSocket (for example
+``session.created.runtime_control``), so it must always survive
+``json.dumps``. Control results carry typed values straight from the engine --
+``fence`` and ``accepted_fence`` are ``DuplexFence`` instances added by
+``DuplexControlClient.execute`` -- which previously reached
+``WebSocket.send_json`` unconverted and killed the session at handshake.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from enum import Enum
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.openai.runtime_bridge import NativeRuntimeBridgeMixin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_redact = NativeRuntimeBridgeMixin._redact_runtime_control_result
+
+
+def _control_result() -> dict[str, object]:
+    """The shape ``DuplexControlClient.execute`` returns for an open."""
+    return {
+        "ok": True,
+        "operation": "open",
+        "session_id": "sess-1",
+        "fence": DuplexFence("sess-1", epoch=0, turn_id=0, response_seq=0, incarnation=0),
+        "accepted_fence": DuplexFence("sess-1", epoch=1, turn_id=2, response_seq=3, incarnation=4),
+        "stage_results": [{"stage_id": -1, "replica_id": -1, "result": {"supported": True}}],
+    }
+
+
+def test_redacted_control_result_is_json_serializable() -> None:
+    """The whole payload must serialize the way send_json does."""
+    redacted = _redact(_control_result())
+    # Must not raise.
+    json.dumps({"type": "session.created", "runtime_control": redacted})
+
+
+def test_fences_are_converted_to_plain_dicts() -> None:
+    redacted = _redact(_control_result())
+    assert redacted["fence"] == {
+        "session_id": "sess-1",
+        "epoch": 0,
+        "turn_id": 0,
+        "response_seq": 0,
+        "incarnation": 0,
+    }
+    # Field values are preserved, not just the type.
+    assert redacted["accepted_fence"]["epoch"] == 1
+    assert redacted["accepted_fence"]["turn_id"] == 2
+    assert redacted["accepted_fence"]["response_seq"] == 3
+    assert redacted["accepted_fence"]["incarnation"] == 4
+
+
+def test_nested_dataclasses_are_converted() -> None:
+    """Fences can appear inside stage results, not only at the top level."""
+    redacted = _redact(
+        {
+            "stage_results": [
+                {"stage_id": 0, "result": {"fence": DuplexFence("sess-2", epoch=7)}},
+            ]
+        }
+    )
+    json.dumps(redacted)
+    assert redacted["stage_results"][0]["result"]["fence"]["epoch"] == 7
+
+
+def test_enums_are_reduced_to_values() -> None:
+    class _Mode(str, Enum):
+        APPEND = "append_audio_chunk"
+
+    redacted = _redact({"mode": _Mode.APPEND})
+    json.dumps(redacted)
+    assert redacted["mode"] == "append_audio_chunk"
+
+
+def test_redaction_still_drops_heavy_payload_keys() -> None:
+    """The pre-existing contract must be preserved."""
+    redacted = _redact(
+        {
+            "ok": True,
+            "stage_handoff": object(),
+            "tts_handoff": object(),
+            "omni_payload": object(),
+            "tts_hidden_states": object(),
+            "tts_token_ids": object(),
+            "traceback": "long trace",
+        }
+    )
+    assert redacted == {"ok": True}
+
+
+def test_plain_values_pass_through_unchanged() -> None:
+    payload = {"ok": True, "count": 3, "name": "x", "missing": None, "items": [1, "two"]}
+    assert _redact(payload) == payload
+
+
+def test_dataclass_types_are_not_treated_as_instances() -> None:
+    """A class object is not a dataclass instance and must not be asdict'd."""
+
+    @dataclass
+    class _Shape:
+        x: int = 1
+
+    assert _redact(_Shape) is _Shape
diff --git a/tests/e2e/features/fullduplex/openai/test_websocket_actor.py b/tests/e2e/features/fullduplex/openai/test_websocket_actor.py
new file mode 100644
index 000000000..37924af52
--- /dev/null
+++ b/tests/e2e/features/fullduplex/openai/test_websocket_actor.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import asyncio
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.websocket import (
+    DuplexWebSocketActor,
+    normalize_duplex_input_event,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FakeWebSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict[str, object]] = []
+
+    async def send_json(self, payload: dict[str, object]) -> None:
+        self.sent.append(dict(payload))
+
+
+@pytest.mark.parametrize(
+    ("event", "expected"),
+    [
+        ({"type": "signal_turn", "event": "barge_in"}, {"type": "turn.signal", "event": "barge_in"}),
+        ({"type": "close_session"}, {"type": "session.close"}),
+        ({"type": "audio.playback_ack", "played_ms": 1}, {"type": "playback.ack", "played_ms": 1}),
+        ({"type": "input_text.append", "text": "a"}, {"type": "input.text.append", "text": "a"}),
+        ({"type": "push_text", "text": "b"}, {"type": "input.text.append", "text": "b"}),
+        (
+            {"type": "input.audio.append", "audio": "wav"},
+            {"type": "input_audio_buffer.append", "audio": "wav", "format": "wav"},
+        ),
+        (
+            {"type": "push_chunk", "audio": "wav", "format": "pcm_f32le"},
+            {"type": "input_audio_buffer.append", "audio": "wav", "format": "pcm_f32le"},
+        ),
+    ],
+)
+def test_input_aliases_normalize_once_at_mailbox_boundary(event, expected):
+    assert normalize_duplex_input_event(event) == expected
+
+
+def test_actor_uses_one_fifo_mailbox_for_inbound_events():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+
+    assert isinstance(actor.mailbox, asyncio.Queue)
+    assert not isinstance(actor.mailbox, asyncio.PriorityQueue)
+    assert not hasattr(actor, "control_queue")
+    assert not hasattr(actor, "input_queue")
+    assert not hasattr(actor, "event_queue")
+    assert not hasattr(actor, "lifecycle_state")
+    assert not hasattr(actor, "last_response_id")
+    assert not hasattr(actor, "overlap_speech_ms")
+    assert not hasattr(actor, "transition")
+    assert not hasattr(actor, "output_generation_in_flight")
+    assert not hasattr(actor, "session")
+    assert not hasattr(actor, "runtime_opened")
+    assert not hasattr(actor, "runtime_closed")
+    assert not hasattr(actor, "drain_input_queue")
+    assert not hasattr(actor, "control_events_seen")
+    assert not hasattr(actor, "input_events_seen")
+    assert not hasattr(actor, "cancel_count")
+
+
+@pytest.mark.asyncio
+async def test_control_event_does_not_overtake_earlier_audio_input():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
+    await actor.enqueue_event({"type": "response.cancel"})
+
+    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
+    assert await actor.next_event() == {"type": "response.cancel"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("event_type", ["input.cancel", "session.close", "close_session"])
+async def test_terminal_control_preserves_wire_order(event_type: str):
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
+    await actor.enqueue_event({"type": event_type})
+
+    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
+    assert await actor.next_event() == {"type": event_type}
+
+
+@pytest.mark.asyncio
+async def test_mailbox_delivers_every_enqueued_event_exactly_once():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    events = [
+        {"type": "input_audio_buffer.append", "audio": str(index)}
+        if index % 2
+        else {"type": "response.created", "response_id": f"resp-{index}"}
+        for index in range(20)
+    ]
+
+    await asyncio.gather(*(actor.enqueue_event(dict(event)) for event in events))
+    received = [await actor.next_event() for _ in events]
+
+    assert sorted(received, key=repr) == sorted(events, key=repr)
+
+
+@pytest.mark.asyncio
+async def test_writer_is_single_owner_of_websocket_send():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket)
+    writer = asyncio.create_task(actor.writer_loop())
+
+    await actor.send_json({"type": "one"})
+    await actor.send_json({"type": "two"})
+    await actor.close_writer()
+    await writer
+
+    assert websocket.sent == [{"type": "one"}, {"type": "two"}]
+
+
+@pytest.mark.asyncio
+async def test_stale_fence_payload_is_dropped_before_websocket_send():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 2)
+    writer = asyncio.create_task(actor.writer_loop())
+
+    await actor.send_json({"type": "response.audio.delta", "epoch": 1})
+    await actor.send_json({"type": "response.audio.delta", "epoch": 2})
+    await actor.close_writer()
+    await writer
+
+    assert websocket.sent == [{"type": "response.audio.delta", "epoch": 2}]
+    assert actor.stale_output_dropped == 1
+
+
+@pytest.mark.asyncio
+async def test_writer_does_not_revoke_accepted_terminal_after_close_starts():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 1)
+    await actor.send_json({"type": "response.done", "epoch": 1, "response_id": "resp-1"})
+    actor.closing = True
+    await actor.close_writer()
+
+    await actor.writer_loop()
+
+    assert websocket.sent == [{"type": "response.done", "epoch": 1, "response_id": "resp-1"}]
+    assert actor.stale_output_dropped == 0
diff --git a/tests/e2e/features/fullduplex/personaplex/test_import_boundary.py b/tests/e2e/features/fullduplex/personaplex/test_import_boundary.py
new file mode 100644
index 000000000..463c0c98e
--- /dev/null
+++ b/tests/e2e/features/fullduplex/personaplex/test_import_boundary.py
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import subprocess
+import sys
+
+
+def test_batched_runtime_import_does_not_require_optional_opus_dependency() -> None:
+    script = """
+import builtins
+
+real_import = builtins.__import__
+
+def guarded_import(name, *args, **kwargs):
+    if name == "sphn":
+        raise ModuleNotFoundError("blocked optional dependency: sphn")
+    return real_import(name, *args, **kwargs)
+
+builtins.__import__ = guarded_import
+from vllm_omni.experimental.fullduplex.personaplex.serving.batched import BatchedSessionManager
+assert BatchedSessionManager is not None
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stderr
diff --git a/tests/e2e/features/fullduplex/personaplex/test_stage0_runtime.py b/tests/e2e/features/fullduplex/personaplex/test_stage0_runtime.py
new file mode 100644
index 000000000..3bdc4456b
--- /dev/null
+++ b/tests/e2e/features/fullduplex/personaplex/test_stage0_runtime.py
@@ -0,0 +1,303 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import base64
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.experimental.fullduplex.personaplex.policy import (
+    SILENCE_TOKENS,
+    SINE_TOKENS,
+)
+from vllm_omni.experimental.fullduplex.personaplex.stage0 import (
+    PersonaPlexStage0DuplexRuntime,
+)
+from vllm_omni.model_executor.models.personaplex.personaplex_talker import (
+    PersonaPlexTalkerForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeCodec:
+    def __init__(self) -> None:
+        self.encode_calls = 0
+        self.reset_calls = 0
+
+    def streaming_init(self, batch_size: int) -> None:
+        assert batch_size == 1
+
+    def encode_frame(self, pcm: torch.Tensor) -> torch.Tensor:
+        assert pcm.shape == (1, 1920)
+        self.encode_calls += 1
+        return torch.full((1, 8), self.encode_calls, dtype=torch.long)
+
+    def reset_streaming(self) -> None:
+        self.reset_calls += 1
+
+
+class _FakeTalker:
+    def __init__(self) -> None:
+        self.device = torch.device("cpu")
+        self.dtype = torch.float32
+        self.frame_calls: list[dict[str, torch.Tensor | None]] = []
+
+    def _build_prefill_embed(
+        self,
+        tokens,
+        offset,
+        span,
+        device,
+        silence=None,
+        user_sine=None,
+    ):
+        del offset, silence, user_sine
+        values = tokens[:span].to(device=device, dtype=torch.float32)
+        return values[:, None].expand(-1, 4).contiguous()
+
+    def _build_frame_embed(
+        self,
+        text_token,
+        last_agent,
+        prev_agent,
+        device,
+        user_d0=None,
+        user_d1=None,
+    ):
+        self.frame_calls.append(
+            {
+                "text_token": text_token.clone(),
+                "last_agent": None if last_agent is None else last_agent.clone(),
+                "prev_agent": None if prev_agent is None else prev_agent.clone(),
+                "user_d0": None if user_d0 is None else user_d0.clone(),
+                "user_d1": None if user_d1 is None else user_d1.clone(),
+            }
+        )
+        value = float(user_d0[0].item()) if user_d0 is not None else -1.0
+        return torch.full((1, 4), value, device=device)
+
+
+def _duplex_info(*, seq: int, session_id: str = "session", incarnation: int = 1):
+    pcm = np.zeros(1920, dtype="<f4")
+    return {
+        "data_plane": True,
+        "session_id": session_id,
+        "incarnation": incarnation,
+        "epoch": 0,
+        "seq": seq,
+        "payload": {
+            "format": "pcm_f32le",
+            "sample_rate_hz": 24000,
+            "audio": base64.b64encode(pcm.tobytes()).decode("ascii"),
+        },
+        "runtime_config": {
+            "personaplex_model_path": "/unused",
+            "personaplex_voice_prompt": "NATF2.pt",
+            "personaplex_persona": "Be concise.",
+        },
+    }
+
+
+def _runtime(*codecs: _FakeCodec) -> PersonaPlexStage0DuplexRuntime:
+    voice_embeddings = torch.arange(8, dtype=torch.float32).reshape(2, 1, 1, 4)
+    codec_args = {"codec": codecs[0]}
+    if len(codecs) > 1:
+        available = iter(codecs)
+        codec_args = {
+            "codec_factory": lambda: next(available),
+            "max_sessions": len(codecs),
+        }
+    return PersonaPlexStage0DuplexRuntime(
+        _FakeTalker(),
+        model_path="/unused",
+        device="cpu",
+        **codec_args,
+        tokenizer=lambda _text: [7, 8, 9],
+        voice_loader=lambda _voice: {
+            "embeddings": voice_embeddings,
+            "cache": torch.zeros((1, 17, 4), dtype=torch.long),
+        },
+    )
+
+
+def test_first_append_prepends_voice_and_persona_once() -> None:
+    codec = _FakeCodec()
+    runtime = _runtime(codec)
+
+    first = runtime.prepare_append(_duplex_info(seq=1), prompt_len=18)
+    second = runtime.prepare_append(_duplex_info(seq=2), prompt_len=18)
+
+    assert first.prefill_applied is True
+    assert first.prompt_offset == 0
+    assert first.user_codes.shape == (1, 8)
+    assert first.inputs_embeds.shape == (18, 4)
+    assert second.prefill_applied is False
+    assert second.prompt_offset == 17
+    assert second.user_codes.shape == (2, 8)
+    assert second.inputs_embeds.shape == (1, 4)
+    assert codec.encode_calls == 2
+
+
+@pytest.mark.parametrize(
+    ("append_count", "expected_tokens", "expected_provided"),
+    [
+        (
+            1,
+            [*SILENCE_TOKENS, 1, *SINE_TOKENS[1:]],
+            [False, *([True] * 15)],
+        ),
+        (
+            2,
+            [*SILENCE_TOKENS, 2, *([1] * 7)],
+            [*([False] * 8), *([True] * 8)],
+        ),
+    ],
+)
+def test_prepare_append_preserves_native_depformer_teacher_forcing(
+    append_count: int,
+    expected_tokens: list[int],
+    expected_provided: list[bool],
+) -> None:
+    runtime = _runtime(_FakeCodec())
+
+    result = None
+    for seq in range(1, append_count + 1):
+        result = runtime.prepare_append(_duplex_info(seq=seq), prompt_len=18)
+
+    assert result is not None
+    assert result.info_update["pplex_depformer_audio_tokens"].tolist() == expected_tokens
+    assert result.info_update["pplex_depformer_audio_provided"].tolist() == expected_provided
+
+
+def test_frame_embed_uses_previous_effective_agent_frame() -> None:
+    fake_talker = SimpleNamespace(
+        config=SimpleNamespace(
+            num_audio_codebooks=16,
+            audio_vocab_size=2048,
+        ),
+        input_embeddings=lambda stack: stack,
+    )
+    last_agent = torch.arange(10, 18)
+
+    embeds = PersonaPlexTalkerForConditionalGeneration._build_frame_embed(
+        fake_talker,
+        torch.tensor([3]),
+        last_agent,
+        torch.arange(8),
+        torch.device("cpu"),
+    )
+
+    assert embeds.shape == (1, 17)
+    assert torch.equal(embeds[0, 1:9], last_agent)
+
+
+def test_repeated_append_identity_does_not_advance_codec() -> None:
+    codec = _FakeCodec()
+    runtime = _runtime(codec)
+
+    info = _duplex_info(seq=1)
+    first = runtime.prepare_append(info, prompt_len=18, request_id="req")
+    retry = runtime.prepare_append(info, prompt_len=18, request_id="req")
+
+    assert codec.encode_calls == 1
+    assert torch.equal(first.inputs_embeds, retry.inputs_embeds)
+    assert torch.equal(first.user_codes, retry.user_codes)
+
+
+def test_next_append_uses_prior_sample_and_causally_delayed_user_frame() -> None:
+    runtime = _runtime(_FakeCodec())
+
+    runtime.prepare_append(_duplex_info(seq=1), prompt_len=18, request_id="req")
+    first_agent = torch.arange(8, dtype=torch.long)
+    runtime.record_sample(request_id="req", text_token=torch.tensor(101), agent_codes=first_agent)
+    runtime.prepare_append(_duplex_info(seq=2), prompt_len=19, request_id="req")
+    second_agent = torch.arange(10, 18, dtype=torch.long)
+    runtime.record_sample(request_id="req", text_token=torch.tensor(102), agent_codes=second_agent)
+    runtime.prepare_append(_duplex_info(seq=3), prompt_len=20, request_id="req")
+
+    silence = torch.tensor(SILENCE_TOKENS, dtype=torch.long)
+    sine = torch.tensor(SINE_TOKENS, dtype=torch.long)
+    first_call = runtime.stage_model.frame_calls[0]
+    assert all(torch.equal(first_call[key], silence) for key in ("last_agent", "prev_agent"))
+    assert all(torch.equal(first_call[key], sine) for key in ("user_d0", "user_d1"))
+
+    second_call = runtime.stage_model.frame_calls[1]
+    assert second_call["text_token"].tolist() == [101]
+    expected_first_effective = torch.cat([first_agent[:1], silence[1:]])
+    assert torch.equal(second_call["last_agent"], expected_first_effective)
+    assert torch.equal(second_call["prev_agent"], expected_first_effective)
+    assert torch.equal(second_call["user_d0"], torch.full((8,), 1, dtype=torch.long))
+    assert torch.equal(second_call["user_d1"], sine)
+
+    third_call = runtime.stage_model.frame_calls[2]
+    assert third_call["text_token"].tolist() == [102]
+    assert torch.equal(third_call["last_agent"], second_agent)
+    assert torch.equal(third_call["prev_agent"], second_agent)
+    assert torch.equal(third_call["user_d0"], torch.full((8,), 2, dtype=torch.long))
+    assert torch.equal(third_call["user_d1"], torch.full((8,), 1, dtype=torch.long))
+
+
+def test_decoded_pcm_is_writable_for_torch_zero_copy() -> None:
+    pcm = PersonaPlexStage0DuplexRuntime._decode_pcm(_duplex_info(seq=1)["payload"])
+
+    assert pcm.flags.writeable
+
+
+def _prepare_two_sessions(
+    runtime: PersonaPlexStage0DuplexRuntime,
+) -> tuple[object, object, object, object]:
+    first_1 = runtime.prepare_append(_duplex_info(seq=1), prompt_len=18)
+    second_1 = runtime.prepare_append(
+        _duplex_info(seq=1, session_id="other", incarnation=2),
+        prompt_len=18,
+    )
+    first_2 = runtime.prepare_append(_duplex_info(seq=2), prompt_len=19)
+    second_2 = runtime.prepare_append(
+        _duplex_info(seq=2, session_id="other", incarnation=2),
+        prompt_len=19,
+    )
+    return first_1, second_1, first_2, second_2
+
+
+def test_live_sessions_keep_independent_streaming_encoders() -> None:
+    first_codec = _FakeCodec()
+    second_codec = _FakeCodec()
+    runtime = _runtime(first_codec, second_codec)
+
+    first_1, second_1, first_2, second_2 = _prepare_two_sessions(runtime)
+
+    assert first_1.user_codes[:, 0].tolist() == [1]
+    assert second_1.user_codes[:, 0].tolist() == [1]
+    assert first_2.user_codes[:, 0].tolist() == [1, 2]
+    assert second_2.user_codes[:, 0].tolist() == [1, 2]
+
+
+def test_stage0_session_capacity_fails_before_codec_state_is_shared() -> None:
+    runtime = _runtime(_FakeCodec(), _FakeCodec())
+    _prepare_two_sessions(runtime)
+
+    with pytest.raises(RuntimeError, match="capacity 2"):
+        runtime.prepare_append(
+            _duplex_info(seq=1, session_id="third", incarnation=3),
+            prompt_len=18,
+        )
+
+
+def test_close_session_resets_and_reuses_released_codec() -> None:
+    first_codec = _FakeCodec()
+    second_codec = _FakeCodec()
+    runtime = _runtime(first_codec, second_codec)
+    _prepare_two_sessions(runtime)
+
+    runtime.close_session("session", 1)
+
+    assert first_codec.reset_calls == 1
+    assert second_codec.reset_calls == 0
+    replacement = runtime.prepare_append(
+        _duplex_info(seq=1, session_id="replacement", incarnation=4),
+        prompt_len=18,
+    )
+    assert replacement.user_codes[:, 0].tolist() == [3]
diff --git a/tests/e2e/features/fullduplex/personaplex/test_streaming_code2wav.py b/tests/e2e/features/fullduplex/personaplex/test_streaming_code2wav.py
new file mode 100644
index 000000000..abe2146b6
--- /dev/null
+++ b/tests/e2e/features/fullduplex/personaplex/test_streaming_code2wav.py
@@ -0,0 +1,316 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.model_executor.models.personaplex import (
+    personaplex_code2wav,
+    personaplex_mimi,
+)
+from vllm_omni.model_executor.models.personaplex.personaplex_code2wav import (
+    PersonaPlexCode2Wav,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeStreamingMimi(nn.Module):
+    def __init__(self, stream_value: int = 0) -> None:
+        super().__init__()
+        self.stream_value = stream_value
+        self.decode_frame_calls = 0
+        self.reset_calls = 0
+
+    def decode(self, codes: torch.Tensor, return_dict: bool = True):
+        assert return_dict
+        frames = int(codes.shape[-1])
+        return SimpleNamespace(audio_values=torch.arange(frames * 4, dtype=torch.float32).reshape(1, 1, -1))
+
+    def streaming_init(self, batch_size: int) -> None:
+        assert batch_size == 1
+
+    def decode_frame(self, codes: torch.Tensor) -> torch.Tensor:
+        assert codes.shape == (1, 2)
+        self.decode_frame_calls += 1
+        value = self.stream_value + self.decode_frame_calls
+        return torch.full((1, 4), float(value), dtype=torch.float32)
+
+    def reset_streaming(self) -> None:
+        self.reset_calls += 1
+
+
+class _FakeChunkedMimi(_FakeStreamingMimi):
+    def __init__(self) -> None:
+        super().__init__()
+        self.decode_frames_calls = 0
+        self.decode_frames_shapes: list[tuple[int, ...]] = []
+
+    def decode_frames(self, codes: torch.Tensor) -> torch.Tensor:
+        self.decode_frames_calls += 1
+        self.decode_frames_shapes.append(tuple(codes.shape))
+        return torch.arange(codes.shape[-1] * 4, dtype=torch.float32).reshape(1, -1)
+
+
+class _FakeMimiModel(nn.Module):
+    def __init__(self, _config) -> None:
+        super().__init__()
+        self.encoder_transformer = nn.Linear(1, 1, bias=False)
+        self.decoder_transformer = nn.Linear(1, 1, bias=False)
+        self.quantizer = nn.Linear(1, 1, bias=False)
+        self.encoder = SimpleNamespace(layers=[])
+        self.downsample = SimpleNamespace(conv=nn.Conv1d(1, 1, 1))
+        self.upsample = SimpleNamespace(conv=nn.ConvTranspose1d(1, 1, 1))
+        self.decoder = SimpleNamespace(layers=[])
+
+    def load_state_dict(self, _state_dict, strict: bool = True):
+        assert not strict
+        return SimpleNamespace(
+            missing_keys=[
+                "encoder_transformer.weight",
+                "decoder_transformer.weight",
+            ],
+            unexpected_keys=[],
+        )
+
+
+class _FakeMimiTransformer(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.zeros(1))
+
+    def load_weights(self, _state_dict, _prefix: str) -> int:
+        return 80
+
+
+def test_moshi_checkpoint_mapping_drops_replaced_transformer_weights(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    mapper = getattr(personaplex_mimi, "_map_moshi_codec_weights", None)
+    assert callable(mapper), "PersonaPlex Mimi must load its bundled codec weights without Hugging Face"
+
+    source = {
+        "encoder.model.3.conv.conv.weight": torch.ones(1),
+        "downsample.conv.conv.conv.weight": torch.ones(1),
+        "quantizer.rvq_first.vq.layers.0._codebook.embedding_sum": torch.ones(1),
+        "quantizer.rvq_rest.vq.layers.3._codebook._initialized": torch.ones(1),
+        "encoder_transformer.transformer.layers.0.norm1.weight": torch.ones(1),
+    }
+
+    mapped = mapper(source)
+
+    assert set(mapped) == {
+        "encoder.layers.3.conv.weight",
+        "downsample.conv.weight",
+        "quantizer.semantic_residual_vector_quantizer.layers.0.codebook.embed_sum",
+        "quantizer.acoustic_residual_vector_quantizer.layers.3.codebook.initialized",
+    }
+    assert mapped["encoder.layers.3.conv.weight"] is source["encoder.model.3.conv.conv.weight"]
+    monkeypatch.setattr("transformers.MimiConfig", lambda: object())
+    monkeypatch.setattr("transformers.MimiModel", _FakeMimiModel)
+    monkeypatch.setattr("safetensors.torch.load_file", lambda *_args, **_kwargs: {})
+    monkeypatch.setattr(personaplex_mimi, "_MimiStreamingTransformer", _FakeMimiTransformer)
+
+    codec = personaplex_mimi.PersonaPlexMimiCodec(
+        checkpoint="/unused",
+        device="cpu",
+    )
+
+    assert not hasattr(codec.model, "encoder_transformer")
+    assert not hasattr(codec.model, "decoder_transformer")
+    assert not any(
+        name.startswith(("model.encoder_transformer.", "model.decoder_transformer."))
+        for name, _ in codec.named_parameters()
+    )
+
+
+def test_mimi_full_stream_reset_reuses_all_state_storage_and_clears_offsets() -> None:
+    codec = personaplex_mimi.PersonaPlexMimiCodec.__new__(personaplex_mimi.PersonaPlexMimiCodec)
+    nn.Module.__init__(codec)
+    codec.device = torch.device("cpu")
+    codec.dtype = torch.float32
+    codec._enc_stages = [("conv", personaplex_mimi._StreamConv1d(nn.Conv1d(1, 1, 3)))]
+    codec._dec_stages = []
+    codec._downsample = personaplex_mimi._StreamConv1d(nn.Conv1d(1, 1, 3))
+    codec._upsample = personaplex_mimi._StreamConvTr1d(nn.ConvTranspose1d(1, 1, 3))
+    codec.encoder_transformer = personaplex_mimi._MimiStreamingTransformer(
+        num_layers=1,
+        dim=4,
+        num_heads=1,
+        context=3,
+    )
+    codec.decoder_transformer = personaplex_mimi._MimiStreamingTransformer(
+        num_layers=1,
+        dim=4,
+        num_heads=1,
+        context=3,
+    )
+    codec.streaming_init(batch_size=2)
+
+    conv_states = list(codec._conv_states())
+    conv_buffers = [
+        state.prev if isinstance(state, personaplex_mimi._StreamConv1d) else state.partial for state in conv_states
+    ]
+    transformers = [codec.encoder_transformer, codec.decoder_transformer]
+    kv_states = [kv for transformer in transformers for kv in transformer._kv]
+    state_tensors = [
+        *conv_buffers,
+        *(kv.cache for kv in kv_states),
+        *(kv.end_offset for kv in kv_states),
+        *(kv.start_offset for kv in kv_states),
+        *(transformer._offset for transformer in transformers),
+    ]
+    for tensor in state_tensors:
+        tensor.fill_(1)
+    for state in conv_states:
+        state._fresh.zero_()
+    storage = [tensor.data_ptr() for tensor in state_tensors]
+
+    codec.reset_streaming()
+
+    assert storage == [tensor.data_ptr() for tensor in state_tensors]
+    cleared = [
+        *conv_buffers,
+        *(kv.end_offset for kv in kv_states),
+        *(kv.start_offset for kv in kv_states),
+        *(transformer._offset for transformer in transformers),
+    ]
+    assert all(not tensor.any() for tensor in cleared)
+    assert all(state._fresh.all() for state in conv_states)
+
+
+def _model(*, max_sessions: int = 1) -> tuple[PersonaPlexCode2Wav, _FakeStreamingMimi]:
+    mimi_config = SimpleNamespace(num_codebooks=2, sample_rate=24000, samples_per_frame=4, mimi_name=None)
+    config = SimpleNamespace(mimi_config=mimi_config, mimi_name=None)
+    vllm_config = SimpleNamespace(
+        model_config=SimpleNamespace(
+            model="/unused",
+            hf_config=config,
+            duplex_max_sessions=max_sessions,
+        ),
+        device_config=SimpleNamespace(device="cpu"),
+    )
+    model = PersonaPlexCode2Wav(vllm_config=vllm_config)
+    mimi = _FakeStreamingMimi()
+    model.mimi = mimi
+    model._mimi_device = torch.device("cpu")
+    return model, mimi
+
+
+def _codes(frames: int, *, start: int = 0) -> torch.Tensor:
+    return torch.stack([torch.arange(start + offset, start + offset + frames) for offset in (0, 100)]).reshape(-1)
+
+
+def _audio(output) -> torch.Tensor:
+    return output.multimodal_outputs["model_outputs"][0]
+
+
+@pytest.mark.parametrize("second_codes", [_codes(3), _codes(1, start=100)])
+def test_resumable_codes_emit_only_new_pcm(second_codes: torch.Tensor) -> None:
+    model, mimi = _model()
+
+    first = model(input_ids=_codes(2), request_ids=["req"])
+    second = model(input_ids=second_codes, request_ids=["req"])
+
+    assert _audio(first).numel() == 8
+    assert _audio(second).numel() == 4
+    assert mimi.decode_frame_calls == 3
+
+
+@pytest.mark.parametrize(
+    ("frames", "expected_shapes"),
+    [
+        (5, [(1, 2, 5)]),
+        (12, [(1, 2, 5), (1, 2, 5), (1, 2, 2)]),
+    ],
+)
+def test_streaming_decode_uses_bounded_multi_frame_calls(
+    frames: int,
+    expected_shapes: list[tuple[int, ...]],
+) -> None:
+    model, _ = _model()
+    mimi = _FakeChunkedMimi()
+    model.mimi = mimi
+
+    output = model(input_ids=_codes(frames), request_ids=["req"])
+
+    assert _audio(output).numel() == frames * 4
+    assert mimi.decode_frames_shapes == expected_shapes
+    assert mimi.decode_frame_calls == 0
+
+
+def test_profile_inputs_skip_decode_while_malformed_online_input_warns(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    model, mimi = _model()
+    runtime_info = [{"meta": {"personaplex_dummy_profile": True}}]
+    warnings: list[tuple] = []
+    monkeypatch.setattr(personaplex_code2wav.logger, "warning", lambda *args: warnings.append(args))
+
+    output = model(
+        input_ids=torch.arange(3),
+        runtime_additional_information=runtime_info,
+    )
+
+    assert _audio(output).numel() == 0
+    assert mimi.decode_frame_calls == 0
+    assert warnings == []
+
+    output = model(input_ids=torch.arange(3))
+
+    assert _audio(output).numel() == 0
+    assert mimi.decode_frame_calls == 0
+    assert len(warnings) == 1
+    assert "not divisible by" in warnings[0][0]
+    assert model.get_dummy_runtime_additional_information(2) == [
+        {"meta": {"personaplex_dummy_profile": True}},
+        {"meta": {"personaplex_dummy_profile": True}},
+    ]
+
+
+def test_request_id_falls_back_to_runtime_information() -> None:
+    model, _ = _model()
+    info = [{"request_id": "runtime-req"}]
+
+    model(input_ids=_codes(2), runtime_additional_information=info)
+    second = model(input_ids=_codes(3), runtime_additional_information=info)
+
+    assert _audio(second).numel() == 4
+
+
+def test_decoder_slot_lifecycle_isolated_capacity_and_reuse() -> None:
+    model, _ = _model(max_sessions=2)
+    first = _FakeStreamingMimi(stream_value=10)
+    second = _FakeStreamingMimi(stream_value=20)
+    model._set_mimi_codecs([first, second])
+    assert model._max_codec_sessions == 2
+
+    initial = model(
+        input_ids=torch.cat([_codes(1), _codes(1)]),
+        request_ids=["first", "second"],
+        seq_token_counts=[2, 2],
+    )
+    continued = model(
+        input_ids=torch.cat([_codes(1, start=10), _codes(1, start=20)]),
+        request_ids=["first", "second"],
+        seq_token_counts=[2, 2],
+    )
+
+    initial_audio = initial.multimodal_outputs["model_outputs"]
+    continued_audio = continued.multimodal_outputs["model_outputs"]
+    assert initial_audio[0].tolist() == [11.0] * 4
+    assert initial_audio[1].tolist() == [21.0] * 4
+    assert continued_audio[0].tolist() == [12.0] * 4
+    assert continued_audio[1].tolist() == [22.0] * 4
+    assert model._request_codec_slots == {"first": 0, "second": 1}
+    with pytest.raises(RuntimeError, match="decoder capacity 2 is exhausted"):
+        model._codec_for_request("overflow")
+
+    model.on_requests_finished(["first"])
+    assert first.reset_calls == 1
+    assert second.reset_calls == 0
+    replacement = model(input_ids=_codes(1), request_ids=["replacement"])
+    assert _audio(replacement).tolist() == [13.0] * 4
diff --git a/tests/e2e/features/fullduplex/personaplex/test_unified_runtime.py b/tests/e2e/features/fullduplex/personaplex/test_unified_runtime.py
new file mode 100644
index 000000000..f4a3c994e
--- /dev/null
+++ b/tests/e2e/features/fullduplex/personaplex/test_unified_runtime.py
@@ -0,0 +1,364 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import base64
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from tests.e2e.online_serving import personaplex_realtime_duplex as e2e_driver
+from vllm_omni.config.stage_config import (
+    load_deploy_config,
+    merge_pipeline_deploy,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexInputMode,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.personaplex.data_plane import (
+    PersonaPlexDataPlaneContext,
+    PersonaPlexDataPlaneSession,
+)
+from vllm_omni.experimental.fullduplex.personaplex.input import (
+    PersonaPlexPcmAppendBuffer,
+)
+from vllm_omni.experimental.fullduplex.personaplex.runtime_extension import (
+    PersonaPlexDuplexRuntimeExtension,
+)
+from vllm_omni.experimental.fullduplex.personaplex.serving_adapter import (
+    PersonaPlexServingRuntimeAdapter,
+)
+from vllm_omni.model_executor.models.personaplex.pipeline import (
+    PERSONAPLEX_PIPELINE,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _pcm_payload(samples: np.ndarray, *, sample_rate_hz: int = 24000) -> dict[str, object]:
+    samples = np.ascontiguousarray(samples, dtype="<f4")
+    return {
+        "type": "audio",
+        "format": "pcm_f32le",
+        "sample_rate_hz": sample_rate_hz,
+        "audio": base64.b64encode(samples.tobytes()).decode("ascii"),
+    }
+
+
+def _audio_client(
+    frame_count: int = 10,
+    *,
+    voiced_frames: int = 0,
+) -> SimpleNamespace:
+    frames = np.full((frame_count, e2e_driver.FRAME_SAMPLES), 7, dtype="<i2")
+    frames[:voiced_frames] = 1000
+    raw = frames.tobytes()
+    event = {
+        "type": "response.audio.delta",
+        "response_id": "response-1",
+        "sample_rate_hz": e2e_driver.SAMPLE_RATE_HZ,
+        "metadata": {
+            "vllm_omni": {
+                "runtime_impl": "scheduler_data_plane",
+                "uses_model_runner_scheduler": True,
+                "runner_kv_backed": True,
+            }
+        },
+    }
+    events = SimpleNamespace(
+        events=[event],
+        response_audio={"response-1": [raw]},
+        audio_bytes=lambda: raw,
+    )
+    return SimpleNamespace(events=events)
+
+
+def test_realtime_audio_frame_stats_separate_voiced_and_silent_frames() -> None:
+    silent = np.zeros(e2e_driver.FRAME_SAMPLES, dtype="<i2")
+    voiced = np.full(e2e_driver.FRAME_SAMPLES, 1000, dtype="<i2")
+
+    stats = e2e_driver._audio_frame_stats(
+        silent.tobytes() + voiced.tobytes(),
+        input_frames=3,
+        voiced_frame_rms_threshold=1e-4,
+    )
+
+    assert stats == {
+        "output_frames": 2,
+        "voiced_frames": 1,
+        "silent_frames": 1,
+        "frame_deficit": 1,
+        "frame_coverage_ratio": pytest.approx(2 / 3),
+    }
+
+
+def test_realtime_audio_frame_stats_reject_partial_codec_frame() -> None:
+    partial_frame = np.zeros(e2e_driver.FRAME_SAMPLES - 1, dtype="<i2")
+
+    with pytest.raises(AssertionError, match="whole 80 ms codec frames"):
+        e2e_driver._audio_frame_stats(
+            partial_frame.tobytes(),
+            input_frames=1,
+            voiced_frame_rms_threshold=1e-4,
+        )
+
+
+@pytest.mark.parametrize("frame_count", [10, 40])
+def test_e2e_driver_rejects_inaudible_sessions(frame_count: int) -> None:
+    args = SimpleNamespace(
+        max_frame_deficit=4,
+        voiced_frame_rms_threshold=1e-3,
+        min_voiced_frames=5,
+    )
+
+    with pytest.raises(AssertionError, match="audible speech"):
+        e2e_driver._session_result(
+            _audio_client(frame_count),
+            input_frames=frame_count,
+            args=args,
+            minimum_chunks=1,
+        )
+
+
+def test_e2e_driver_uses_absolute_audible_floor() -> None:
+    args = SimpleNamespace(
+        max_frame_deficit=4,
+        voiced_frame_rms_threshold=1e-3,
+        min_voiced_frames=5,
+    )
+
+    e2e_driver._session_result(
+        _audio_client(200, voiced_frames=5),
+        input_frames=200,
+        args=args,
+        minimum_chunks=1,
+    )
+
+
+def test_e2e_driver_defaults_replacement_to_full_input() -> None:
+    args = e2e_driver.parse_args(
+        [
+            "--model",
+            "/model",
+            "--input-wav",
+            "/input.wav",
+        ]
+    )
+
+    assert args.replacement_frames == 0
+    assert args.min_voiced_frames == 5
+
+
+def test_e2e_driver_records_and_validates_input_sha256(tmp_path: Path) -> None:
+    input_wav = tmp_path / "input.wav"
+    input_wav.write_bytes(b"fixture-wav")
+
+    identity = e2e_driver._input_identity(
+        input_wav,
+        expected_sha256="bade4b3c163edde390ff391207d34a887257d8a9cc3b621cc8c618b6e6761304",
+    )
+
+    assert identity == {
+        "path": str(input_wav.resolve()),
+        "sha256": "bade4b3c163edde390ff391207d34a887257d8a9cc3b621cc8c618b6e6761304",
+    }
+
+
+def test_e2e_driver_rejects_unexpected_input_sha256(tmp_path: Path) -> None:
+    input_wav = tmp_path / "input.wav"
+    input_wav.write_bytes(b"fixture-wav")
+
+    with pytest.raises(ValueError, match="input WAV SHA-256 mismatch"):
+        e2e_driver._input_identity(input_wav, expected_sha256="0" * 64)
+
+
+@pytest.mark.parametrize(
+    ("attribute", "expected"),
+    [
+        (
+            "duplex_runtime_extension",
+            "vllm_omni.experimental.fullduplex.personaplex.runtime_extension.PersonaPlexDuplexRuntimeExtension",
+        ),
+        (
+            "duplex_serving_adapter",
+            "vllm_omni.experimental.fullduplex.personaplex.serving_adapter.PersonaPlexServingRuntimeAdapter",
+        ),
+    ],
+)
+def test_personaplex_pipeline_registers_unified_duplex_components(
+    attribute: str,
+    expected: str,
+) -> None:
+    assert PERSONAPLEX_PIPELINE.duplex_control_enabled is True
+    assert getattr(PERSONAPLEX_PIPELINE, attribute) == expected
+
+
+@pytest.mark.parametrize(
+    ("engine_arg", "expected"),
+    [
+        ("skip_tokenizer_init", True),
+        ("enable_prefix_caching", False),
+    ],
+)
+def test_personaplex_stage_engine_args(
+    engine_arg: str,
+    expected: bool,
+) -> None:
+    deploy_path = Path(__file__).parents[5] / "vllm_omni" / "deploy" / "personaplex.yaml"
+    stages = merge_pipeline_deploy(
+        PERSONAPLEX_PIPELINE,
+        load_deploy_config(deploy_path),
+    )
+
+    assert [stage.yaml_engine_args.get(engine_arg) for stage in stages] == [
+        expected,
+        expected,
+    ]
+
+
+def test_personaplex_duplex_capacity_is_propagated_to_all_model_stages() -> None:
+    deploy_path = Path(__file__).parents[5] / "vllm_omni" / "deploy" / "personaplex.yaml"
+    deploy = load_deploy_config(deploy_path)
+    stages = merge_pipeline_deploy(PERSONAPLEX_PIPELINE, deploy)
+
+    assert deploy.duplex_session.max_sessions == 2
+    assert [stage.yaml_engine_args.get("duplex_max_sessions") for stage in stages] == [2, 2]
+    assert "personaplex_codec_max_sessions" not in deploy.connectors["connector_of_shared_memory"]["extra"]
+
+
+def test_personaplex_capabilities_are_honest() -> None:
+    single = PersonaPlexServingRuntimeAdapter(lambda *_: None).capabilities(max_sessions=1)
+    multi = PersonaPlexServingRuntimeAdapter(lambda *_: None).capabilities(max_sessions=2)
+
+    assert multi.implementation_level == "model_native_duplex"
+    assert multi.input_modes == ["append_audio_chunk"]
+    assert multi.chunk_period_ms == 80
+    assert single.supports_multi_session is False
+    assert multi.supports_multi_session is True
+    assert multi.supports_multi_session_same_replica is True
+    assert multi.supports_barge_in is False
+
+
+def test_pcm_buffer_emits_one_80ms_frame_transactionally() -> None:
+    buffer = PersonaPlexPcmAppendBuffer()
+    reservation = buffer.prepare_append(
+        _pcm_payload(np.arange(1920, dtype=np.float32)),
+        operation_id="op-1",
+        chunk_period_ms=80,
+        allow_emit=True,
+    )
+
+    assert reservation is not None
+    assert reservation.byte_count == 1920 * 4
+    assert buffer.pending_byte_count == 0
+    reservation.rollback()
+    assert buffer.pending_byte_count == 1920 * 4
+
+
+def test_pcm_buffer_rejects_changed_sample_rate() -> None:
+    buffer = PersonaPlexPcmAppendBuffer()
+    assert (
+        buffer.prepare_append(
+            _pcm_payload(np.zeros(100, np.float32)),
+            operation_id="op-1",
+            chunk_period_ms=80,
+            allow_emit=False,
+        )
+        is None
+    )
+
+    with pytest.raises(ValueError, match="sample_rate"):
+        buffer.prepare_append(
+            _pcm_payload(np.zeros(100, np.float32), sample_rate_hz=16000),
+            operation_id="op-2",
+            chunk_period_ms=80,
+            allow_emit=False,
+        )
+
+
+def test_pcm_buffer_rejects_non_finite_samples() -> None:
+    buffer = PersonaPlexPcmAppendBuffer()
+
+    with pytest.raises(ValueError, match="finite"):
+        buffer.prepare_append(
+            _pcm_payload(np.array([0.0, np.nan], np.float32)),
+            operation_id="op-1",
+            chunk_period_ms=80,
+            allow_emit=False,
+        )
+
+
+def test_runtime_extension_builds_one_frame_scheduler_append() -> None:
+    extension = PersonaPlexDuplexRuntimeExtension()
+    defaults = (
+        SamplingParams(temperature=0.8, top_k=10, max_tokens=10),
+        SamplingParams(max_tokens=1024),
+    )
+
+    configured = extension.configure_sampling_params(runtime_config={}, defaults=defaults)
+    assert configured[0].temperature == 0.0
+    assert configured[0].top_k == 1
+    assert configured[0].max_tokens == 1
+    assert configured[1] is defaults[1]
+
+    plan = extension.plan_append(
+        request_id="req",
+        fence=DuplexFence("session", incarnation=2, epoch=3),
+        session_config={"instructions": "Be concise."},
+        runtime_config={"personaplex_prefill_slots": 4},
+        seq=1,
+        turn_seq=1,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload=_pcm_payload(np.zeros(1920, np.float32)),
+        final=False,
+        sampling_params=configured[0],
+    )
+    assert len(plan.prompt["prompt_token_ids"]) == 5
+    duplex = plan.prompt["model_intermediate_buffer"]["duplex"]
+    assert duplex["session_id"] == "session"
+    assert duplex["incarnation"] == 2
+    assert duplex["epoch"] == 3
+    assert duplex["seq"] == 1
+    assert duplex["data_plane"] is True
+
+
+def test_projector_emits_only_cumulative_audio_and_text_suffixes() -> None:
+    encoded_sizes: list[int] = []
+
+    def encode_audio(audio, _sample_rate, _response_format, _speed):
+        size = int(np.asarray(audio, dtype=np.float32).size)
+        encoded_sizes.append(size)
+        return f"audio-{size}"
+
+    projector = PersonaPlexDataPlaneSession(encode_audio)
+    projector.begin_request("req")
+    context = PersonaPlexDataPlaneContext(response_format="wav")
+
+    first = SimpleNamespace(
+        request_id="req",
+        outputs=[SimpleNamespace(text="he", multimodal_output={})],
+        multimodal_output={"model_outputs": np.arange(4, dtype=np.float32), "sr": 24000},
+        finished=False,
+    )
+    second = SimpleNamespace(
+        request_id="req",
+        outputs=[SimpleNamespace(text="hello", multimodal_output={})],
+        multimodal_output={"model_outputs": np.arange(6, dtype=np.float32), "sr": 24000},
+        finished=False,
+    )
+
+    projected = list(
+        projector.project(
+            {"data_plane_outputs": [first, second]},
+            context=context,
+        )
+    )
+
+    assert encoded_sizes == [4, 2]
+    assert [item["text"] for item in projected] == ["he", "llo"]
+    assert [item["audio_data"] for item in projected] == ["audio-4", "audio-2"]
+    assert all(item["sample_rate_hz"] == 24000 for item in projected)
+    assert all(item["end_of_turn"] is False for item in projected)
diff --git a/tests/e2e/features/fullduplex/test_client.py b/tests/e2e/features/fullduplex/test_client.py
new file mode 100644
index 000000000..218050eb1
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_client.py
@@ -0,0 +1,240 @@
+import base64
+import wave
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.client import (
+    RealtimeDuplexClient,
+    RealtimeEventCollector,
+    build_realtime_url,
+    read_pcm16_wav,
+    write_pcm16_wav,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_realtime_client_builds_explicit_native_duplex_url():
+    url = build_realtime_url(
+        "ws://localhost:8099/v1/realtime?custom=1",
+        "openbmb/MiniCPM-o-4_5",
+        session_id="session-a",
+    )
+
+    query = parse_qs(urlsplit(url).query)
+    assert query == {
+        "custom": ["1"],
+        "duplex": ["1"],
+        "model": ["openbmb/MiniCPM-o-4_5"],
+        "minicpmo45_native_duplex": ["1"],
+        "session_id": ["session-a"],
+    }
+
+
+def test_realtime_client_builds_resume_only_url_when_autostart_disabled():
+    url = build_realtime_url(
+        "ws://localhost:8099/v1/realtime?duplex=1",
+        "openbmb/MiniCPM-o-4_5",
+        autostart=False,
+    )
+
+    query = parse_qs(urlsplit(url).query)
+    assert query["autostart"] == ["0"]
+    assert query["minicpmo45_native_duplex"] == ["1"]
+
+
+@pytest.mark.asyncio
+async def test_realtime_client_configure_omits_ref_audio_by_default():
+    class Client(RealtimeDuplexClient):
+        def __init__(self):
+            super().__init__("ws://unused")
+            self.sent = []
+
+        async def send(self, event):
+            self.sent.append(event)
+            self.events.add({"type": "session.created"})
+
+    client = Client()
+
+    await client.configure("openbmb/MiniCPM-o-4_5", timeout_s=1)
+
+    session = client.sent[0]["session"]
+    assert "ref_audio" not in session
+
+
+@pytest.mark.asyncio
+async def test_realtime_client_configure_sends_explicit_ref_audio():
+    class Client(RealtimeDuplexClient):
+        def __init__(self):
+            super().__init__("ws://unused")
+            self.sent = []
+
+        async def send(self, event):
+            self.sent.append(event)
+            self.events.add({"type": "session.created"})
+
+    client = Client()
+
+    await client.configure(
+        "openbmb/MiniCPM-o-4_5",
+        ref_audio="data:audio/wav;base64,AAAA",
+        timeout_s=1,
+    )
+
+    session = client.sent[0]["session"]
+    assert session["ref_audio"] == "data:audio/wav;base64,AAAA"
+
+
+def test_realtime_event_collector_partitions_audio_by_response():
+    collector = RealtimeEventCollector()
+    collector.add({"type": "response.created", "response": {"id": "resp-a"}})
+    collector.add(
+        {
+            "type": "response.audio.delta",
+            "response_id": "resp-a",
+            "delta": base64.b64encode(b"audio-a").decode("ascii"),
+            "sample_rate_hz": 16_000,
+        }
+    )
+
+    assert collector.response_ids == ["resp-a"]
+    assert collector.audio_bytes("resp-a") == b"audio-a"
+    assert collector.output_sample_rate_hz == 16_000
+    assert collector.first_received_at("response.created") is not None
+    assert collector.last_received_at("response.audio.delta") is not None
+
+
+def test_realtime_event_collector_reports_engine_token_and_audio_intervals():
+    collector = RealtimeEventCollector()
+    collector.add(
+        {"type": "response.created", "response": {"id": "resp-a"}},
+        received_at_s=10.0,
+    )
+    stage_metrics = {
+        "0": {
+            "num_tokens_out": 4,
+            "vllm_ttft_ms": 120.0,
+            "vllm_tpot_ms": 15.0,
+            "vllm_itl_ms": 14.0,
+            "vllm_itls_ms": [10.0, 14.0, 18.0],
+        }
+    }
+    for received_at_s, cumulative_audio_ms in ((10.2, 80), (10.25, 160), (10.36, 240)):
+        collector.add(
+            {
+                "type": "response.audio.delta",
+                "response_id": "resp-a",
+                "delta": base64.b64encode(b"audio").decode("ascii"),
+                "sample_rate_hz": 16_000,
+                "metadata": {
+                    "audio_duration_ms": cumulative_audio_ms,
+                    "vllm_omni": {"stage_metrics": stage_metrics},
+                },
+            },
+            received_at_s=received_at_s,
+        )
+
+    timing = collector.timing_summary(
+        after_s=10.0,
+        input_committed_at_s=9.9,
+        response_id="resp-a",
+    )
+
+    assert timing["stage0_tokens"] == {
+        "source": "engine_stage_metrics",
+        "output_token_count": 4,
+        "ttft_ms": 120.0,
+        "tpot_ms": 15.0,
+        "inter_token_interval_ms": {
+            "count": 3,
+            "mean": 14.0,
+            "p50": 14.0,
+            "p95": 18.0,
+            "max": 18.0,
+        },
+    }
+    assert timing["audio_output"] == {
+        "source": "client_monotonic_receive",
+        "chunk_count": 3,
+        "response_created_to_first_audio_ms": 200.0,
+        "commit_to_first_audio_ms": 300.0,
+        "inter_chunk_interval_ms": {
+            "count": 2,
+            "mean": 80.0,
+            "p50": 50.0,
+            "p95": 110.0,
+            "max": 110.0,
+        },
+        "chunk_duration_ms": {
+            "count": 3,
+            "mean": 80.0,
+            "p50": 80.0,
+            "p95": 80.0,
+            "max": 80.0,
+        },
+        "max_chunk_gap_ms": 110.0,
+    }
+
+
+def test_response_timing_ignores_unowned_session_level_metrics():
+    collector = RealtimeEventCollector()
+    collector.add(
+        {"type": "response.created", "response": {"id": "resp-a"}},
+        received_at_s=10.0,
+    )
+    collector.add(
+        {
+            "type": "response.audio.delta",
+            "response_id": "resp-a",
+            "delta": base64.b64encode(b"audio").decode("ascii"),
+            "metadata": {
+                "vllm_omni": {
+                    "stage_metrics": {
+                        "0": {
+                            "num_tokens_out": 20,
+                            "vllm_ttft_ms": 157.0,
+                            "vllm_tpot_ms": 16.0,
+                            "vllm_itls_ms": [15.0, 17.0],
+                        }
+                    }
+                }
+            },
+        },
+        received_at_s=10.2,
+    )
+    collector.add(
+        {
+            "type": "response.listen",
+            "metadata": {
+                "vllm_omni": {
+                    "stage_metrics": {
+                        "0": {
+                            "num_tokens_out": 2,
+                            "vllm_ttft_ms": 106.0,
+                            "vllm_tpot_ms": 0.0,
+                            "vllm_itls_ms": [],
+                        }
+                    }
+                }
+            },
+        },
+        received_at_s=10.3,
+    )
+
+    timing = collector.timing_summary(after_s=10.0, response_id="resp-a")
+
+    assert timing["stage0_tokens"]["output_token_count"] == 20
+    assert timing["stage0_tokens"]["ttft_ms"] == 157.0
+
+
+def test_realtime_client_pcm16_wav_round_trip(tmp_path):
+    path = tmp_path / "audio.wav"
+    pcm16 = b"\x01\x00\x02\x00"
+
+    write_pcm16_wav(path, pcm16, sample_rate_hz=16_000)
+
+    with wave.open(str(path), "rb") as wav_file:
+        assert wav_file.getnchannels() == 1
+        assert wav_file.getframerate() == 16_000
+    assert read_pcm16_wav(path) == pcm16
diff --git a/tests/e2e/features/fullduplex/test_core_contracts.py b/tests/e2e/features/fullduplex/test_core_contracts.py
new file mode 100644
index 000000000..2a514b9f2
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_core_contracts.py
@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Contract tests for the fullduplex core (PR #3907 alignment).
+
+Covers the DuplexFence identity value, the session identity rules (epoch only
+advances on barge-in, response_index once per begin_response), stale-output
+dropping in the turn lifecycle. The lockstep (single-eternal-response)
+lifecycle is model-owned (see
+tests/e2e/features/fullduplex/test_personaplex_adapter.py).
+"""
+
+import asyncio
+import dataclasses
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.core import protocol as ev
+from vllm_omni.experimental.fullduplex.core.adapter import (
+    DuplexAdapter,
+    DuplexCapability,
+    OutputChunk,
+)
+from vllm_omni.experimental.fullduplex.core.runtime import DuplexRuntime
+from vllm_omni.experimental.fullduplex.core.session import (
+    DuplexSession,
+    DuplexSessionConfig,
+    DuplexState,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_fence_is_frozen_value_identity():
+    f = DuplexFence(session_id="s1")
+    assert (f.epoch, f.turn_id, f.response_seq) == (0, 0, 0)
+    with pytest.raises(dataclasses.FrozenInstanceError):
+        f.epoch = 1  # type: ignore[misc]
+    assert DuplexFence("s1", 1, 2, 3) == DuplexFence("s1", 1, 2, 3)
+    assert DuplexFence("s1", 1, 2, 3) != DuplexFence("s1", 2, 2, 3)
+
+
+def test_session_identity_rules():
+    s = DuplexSession(session_id="test", config=DuplexSessionConfig())
+    r1, e1 = s.begin_response()
+    r2, e2 = s.begin_response()
+    assert r2 == r1 + 1, "response index advances exactly once per begin"
+    assert e1 == e2 == 0, "epoch does not move on response begin"
+    s.end_response()
+    assert s.epoch == 0, "epoch does not move on response end"
+    new_epoch = s.barge_in()
+    assert new_epoch == 1, "epoch advances only on barge-in"
+    assert s.is_stale(e1) and not s.is_stale(new_epoch)
+
+
+class _TurnAdapter(DuplexAdapter):
+    """Emits chunks until cancelled; counts respond() lifecycles."""
+
+    def __init__(self):
+        self.responses = 0
+        self.barge_ins = 0
+
+    def capabilities(self) -> DuplexCapability:
+        return DuplexCapability(
+            input_modalities=frozenset({"audio"}),
+            output_modalities=frozenset({"audio"}),
+            proactive=True,
+        )
+
+    async def on_input(self, session, modality, data) -> None:
+        pass
+
+    def should_respond(self, session) -> bool:
+        return True
+
+    async def on_barge_in(self, session) -> None:
+        self.barge_ins += 1
+
+    async def respond(self, session):
+        self.responses += 1
+        for i in range(100):
+            await asyncio.sleep(0.001)
+            yield OutputChunk("audio", i)
+
+
+async def _drive(runtime, events):
+    async def gen():
+        for e in events:
+            await asyncio.sleep(0.005)
+            yield e
+
+    out = []
+
+    async def emit(e):
+        out.append(e)
+
+    await runtime.run(gen(), emit)
+    return out
+
+
+def test_turn_mode_supersede_and_stale_drop():
+    adapter = _TurnAdapter()
+    session = DuplexSession(session_id="test", config=DuplexSessionConfig(proactive=True))
+    runtime = DuplexRuntime(session, adapter)
+    out = asyncio.run(
+        _drive(
+            runtime,
+            [
+                {"type": ev.RESPONSE_CREATE},
+                {"type": ev.RESPONSE_CREATE},  # supersedes the first
+                {"type": ev.CLOSE},
+            ],
+        )
+    )
+    assert adapter.responses == 2
+    assert adapter.barge_ins == 1, "superseding an in-flight response barges in"
+    created = [e for e in out if e["type"] == ev.RESPONSE_CREATED]
+    done = [e for e in out if e["type"] == ev.RESPONSE_DONE]
+    assert len(created) == 2
+    assert len(done) == 1, "stale first response must not emit done"
+    assert done[0]["response_index"] == created[1]["response_index"]
+    assert session.state is DuplexState.CLOSED
diff --git a/tests/fullduplex/test_joyvl_brain.py b/tests/e2e/features/fullduplex/test_joyvl_brain.py
similarity index 100%
rename from tests/fullduplex/test_joyvl_brain.py
rename to tests/e2e/features/fullduplex/test_joyvl_brain.py
diff --git a/tests/fullduplex/test_joyvl_policy.py b/tests/e2e/features/fullduplex/test_joyvl_policy.py
similarity index 100%
rename from tests/fullduplex/test_joyvl_policy.py
rename to tests/e2e/features/fullduplex/test_joyvl_policy.py
diff --git a/tests/e2e/features/fullduplex/test_personaplex_adapter.py b/tests/e2e/features/fullduplex/test_personaplex_adapter.py
new file mode 100644
index 000000000..458333627
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_personaplex_adapter.py
@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex adapter driven through the model-owned lockstep runtime.
+
+PersonaPlexDuplexRuntime starts ONE response for the whole session, streams one
+agent frame per user frame, and drains on close (core stays verbatim upstream;
+the lockstep lifecycle is model policy) — all with a GPU-free stub stepper.
+"""
+
+import asyncio
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.core import protocol as ev
+from vllm_omni.experimental.fullduplex.core.session import (
+    DuplexSession,
+    DuplexSessionConfig,
+    DuplexState,
+)
+from vllm_omni.experimental.fullduplex.personaplex.adapter import (
+    PersonaPlexDuplexAdapter,
+    PersonaPlexDuplexRuntime,
+)
+from vllm_omni.experimental.fullduplex.personaplex.config import FRAME_SIZE
+from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class StubStepper:
+    """Deterministic FrameStepper: frame i -> audio filled with i, text 't{i}' on odds."""
+
+    sample_rate = 24000
+    frame_size = FRAME_SIZE
+
+    def __init__(self) -> None:
+        self.opened: tuple[str | None, str | None] | None = None
+        self.steps = 0
+
+    def open_session(self, voice_prompt=None, persona=None) -> None:
+        self.opened = (voice_prompt, persona)
+        self.steps = 0
+
+    def step(self, user_pcm):
+        assert user_pcm.shape[0] == self.frame_size
+        self.steps += 1
+        i = self.steps
+        return FrameOutput(
+            audio=np.full(self.frame_size, float(i), dtype=np.float32),
+            text=(f"t{i}" if i % 2 else None),
+        )
+
+
+class RecordingAdapter(PersonaPlexDuplexAdapter):
+    def __init__(self, stepper: StubStepper) -> None:
+        super().__init__(stepper)
+        self.closed = False
+
+    async def on_close(self, session: DuplexSession) -> None:
+        self.closed = True
+        await super().on_close(session)
+
+
+def _collector():
+    out: list[dict] = []
+
+    async def emit(event: dict) -> None:
+        out.append(event)
+
+    return out, emit
+
+
+async def _feed(events):
+    for e in events:
+        yield e
+
+
+async def _raising_feed(frame):
+    yield {"type": ev.INPUT_APPEND, "modality": "audio", "data": frame}
+    await asyncio.sleep(0)
+    raise RuntimeError("input failed")
+
+
+def _respond_tasks() -> list[asyncio.Task]:
+    current = asyncio.current_task()
+    return [
+        task
+        for task in asyncio.all_tasks()
+        if task is not current and "_respond_once" in getattr(task.get_coro(), "__qualname__", "")
+    ]
+
+
+def _session():
+    cfg = DuplexSessionConfig(
+        input_modalities=("audio",),
+        output_modalities=("audio", "text"),
+    )
+    return DuplexSession("s", cfg)
+
+
+@pytest.mark.asyncio
+async def test_lockstep_one_agent_frame_per_user_frame():
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub, voice_prompt="NATF2.pt", persona="be terse")
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+
+    frame = np.zeros(FRAME_SIZE, dtype=np.float32)
+    events = [{"type": ev.INPUT_APPEND, "modality": "audio", "data": frame} for _ in range(3)]
+    events.append({"type": ev.CLOSE})
+    await rt.run(_feed(events), emit)
+
+    types = [e["type"] for e in out]
+    # exactly one response for the whole session, drained cleanly on close
+    assert types.count(ev.RESPONSE_CREATED) == 1
+    assert types.count(ev.RESPONSE_DONE) == 1
+    audio = [e for e in out if e["type"] == ev.RESPONSE_DELTA and e["modality"] == "audio"]
+    text = [e["data"] for e in out if e["type"] == ev.RESPONSE_DELTA and e["modality"] == "text"]
+    assert len(audio) == 3  # one agent frame per user frame
+    assert [int(e["data"][0]) for e in audio] == [1, 2, 3]  # lockstep order
+    assert text == ["t1", "t3"]
+    assert stub.steps == 3
+    assert stub.opened == ("NATF2.pt", "be terse")
+
+
+@pytest.mark.asyncio
+async def test_unaligned_chunks_are_reframed_to_80ms():
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub)
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+
+    # 2.5 frames in one chunk + 0.5 frame in another => 3 whole frames
+    events = [
+        {"type": ev.INPUT_APPEND, "modality": "audio", "data": np.zeros(FRAME_SIZE * 5 // 2, dtype=np.float32)},
+        {"type": ev.INPUT_APPEND, "modality": "audio", "data": np.zeros(FRAME_SIZE // 2, dtype=np.float32)},
+        {"type": ev.CLOSE},
+    ]
+    await rt.run(_feed(events), emit)
+    audio = [e for e in out if e["type"] == ev.RESPONSE_DELTA and e["modality"] == "audio"]
+    assert len(audio) == 3
+    assert stub.steps == 3
+
+
+@pytest.mark.asyncio
+async def test_close_without_input_is_clean():
+    adapter = PersonaPlexDuplexAdapter(StubStepper())
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+    await rt.run(_feed([{"type": ev.CLOSE}]), emit)
+    # no input -> response never started -> no created/done, no error
+    assert not any(e["type"] == ev.ERROR for e in out)
+    assert not any(e["type"] == ev.RESPONSE_CREATED for e in out)
+
+
+@pytest.mark.asyncio
+async def test_iterator_eof_without_close_drains_and_stops():
+    # Transport drop: the input iterator ends WITHOUT an explicit CLOSE event.
+    # The runtime must still signal on_close so the eternal response drains
+    # instead of blocking on its inbox forever.
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub)
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+    frame = np.zeros(FRAME_SIZE, dtype=np.float32)
+    events = [{"type": ev.INPUT_APPEND, "modality": "audio", "data": frame}]
+    await asyncio.wait_for(rt.run(_feed(events), emit), timeout=5.0)
+    types = [e["type"] for e in out]
+    assert types.count(ev.RESPONSE_DONE) == 1
+    assert stub.steps == 1
+
+
+@pytest.mark.asyncio
+async def test_input_exception_closes_response_and_runtime() -> None:
+    stub = StubStepper()
+    adapter = RecordingAdapter(stub)
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+    frame = np.zeros(FRAME_SIZE, dtype=np.float32)
+
+    with pytest.raises(RuntimeError, match="input failed"):
+        await rt.run(_raising_feed(frame), emit)
+
+    leaked = _respond_tasks()
+    for task in leaked:
+        task.cancel()
+    if leaked:
+        await asyncio.gather(*leaked, return_exceptions=True)
+
+    assert adapter.closed is True
+    assert rt.session.state is DuplexState.CLOSED
+    assert not leaked
+
+
+@pytest.mark.asyncio
+async def test_default_session_config_gets_lockstep_lifecycle():
+    # The lifecycle comes from the model-owned runtime class, not a session
+    # flag: a plain default-constructed session config runs lockstep.
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub)
+    session = DuplexSession(
+        "s",
+        DuplexSessionConfig(input_modalities=("audio",), output_modalities=("audio", "text")),
+    )
+    rt = PersonaPlexDuplexRuntime(session, adapter)
+    out, emit = _collector()
+    frame = np.zeros(FRAME_SIZE, dtype=np.float32)
+    events = [{"type": ev.INPUT_APPEND, "modality": "audio", "data": frame}, {"type": ev.CLOSE}]
+    await rt.run(_feed(events), emit)
+    types = [e["type"] for e in out]
+    assert types.count(ev.RESPONSE_CREATED) == 1
+    assert types.count(ev.RESPONSE_DONE) == 1
+    assert stub.steps == 1
+
+
+@pytest.mark.asyncio
+async def test_partial_tail_is_padded_and_stepped_on_close():
+    # A trailing sub-frame chunk is zero-padded and stepped at close (same
+    # contract as PersonaPlexSession.flush) rather than silently dropped.
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub)
+    rt = PersonaPlexDuplexRuntime(_session(), adapter)
+    out, emit = _collector()
+    events = [
+        {"type": ev.INPUT_APPEND, "modality": "audio", "data": np.ones(FRAME_SIZE // 2, dtype=np.float32)},
+        {"type": ev.CLOSE},
+    ]
+    await rt.run(_feed(events), emit)
+    audio = [e for e in out if e["type"] == ev.RESPONSE_DELTA and e["modality"] == "audio"]
+    assert len(audio) == 1
+    assert stub.steps == 1
+
+
+@pytest.mark.asyncio
+async def test_single_eternal_response_across_barge_in():
+    # Moved from the core contract tests when the lockstep lifecycle became
+    # model-owned: ONE response for the whole session, RESPONSE_CANCEL bumps the
+    # epoch fence (playback cursor) but the stream keeps flowing, and close
+    # drains via on_close.
+    stub = StubStepper()
+    adapter = PersonaPlexDuplexAdapter(stub)
+    session = _session()
+    rt = PersonaPlexDuplexRuntime(session, adapter)
+    out, emit = _collector()
+
+    frame = np.zeros(FRAME_SIZE, dtype=np.float32)
+    events = [
+        {"type": ev.INPUT_APPEND, "modality": "audio", "data": frame},
+        {"type": ev.RESPONSE_CANCEL},  # barge-in: epoch bumps, stream continues
+        {"type": ev.INPUT_APPEND, "modality": "audio", "data": frame},
+        {"type": ev.CLOSE},
+    ]
+    await rt.run(_feed(events), emit)
+
+    types = [e["type"] for e in out]
+    assert types.count(ev.RESPONSE_CREATED) == 1, "exactly one eternal response"
+    assert types.count(ev.RESPONSE_DONE) == 1
+    audio = [e for e in out if e["type"] == ev.RESPONSE_DELTA and e["modality"] == "audio"]
+    assert len(audio) == 2, "stream keeps flowing across barge-in"
+    assert session.epoch == 1, "cancel still advanced the epoch fence"
+    assert stub.steps == 2
diff --git a/tests/e2e/features/fullduplex/test_personaplex_batched.py b/tests/e2e/features/fullduplex/test_personaplex_batched.py
new file mode 100644
index 000000000..f2ee73729
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_personaplex_batched.py
@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""GPU-free tests for the batched PersonaPlex slot manager (stub engine)."""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput, PrefillStep
+from vllm_omni.experimental.fullduplex.personaplex.serving.batched import (
+    BatchedSessionManager,
+    SlotPhase,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+FRAME = 4
+
+
+class StubEngine:
+    """Records the slot-API call sequence; echoes each row's pcm as its output."""
+
+    frame_size = FRAME
+
+    def __init__(self, batch_size: int = 4, prefill_len: int = 2) -> None:
+        self.config = SimpleNamespace(batch_size=batch_size)
+        self.prefill_len = prefill_len
+        self.recycled: list[int] = []
+        self.voice_ended: list[int] = []
+        self.prefill_done: list[int] = []
+        self.steps: list[tuple[np.ndarray, dict | None]] = []
+
+    def prefill_steps(self, persona=None):
+        steps = [PrefillStep("sacrifice"), PrefillStep("voice", embedding=None), PrefillStep("voice_end")]
+        steps += [PrefillStep("tokens", moshi_tokens=None, text_token=3, user_sine=True)] * self.prefill_len
+        return steps
+
+    def recycle_slot(self, b):
+        self.recycled.append(b)
+
+    def voice_end(self, b):
+        self.voice_ended.append(b)
+
+    def end_prefill(self, b):
+        self.prefill_done.append(b)
+
+    def step_batch(self, pcm, prefill=None):
+        self.steps.append((pcm.copy(), dict(prefill) if prefill else None))
+        return [FrameOutput(audio=pcm[b].copy(), text=None) for b in range(self.config.batch_size)]
+
+
+def test_all_idle_does_not_step():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    assert mgr.tick() is False
+    assert eng.steps == []
+
+
+def test_pristine_slot_is_live_immediately():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    slot, ready_now = mgr.acquire()
+    assert ready_now is True
+    assert slot.phase is SlotPhase.LIVE
+    assert eng.recycled == []
+
+
+def test_custom_persona_prefills_and_recycles_on_tick_thread():
+    eng = StubEngine(prefill_len=2)
+    mgr = BatchedSessionManager(eng)
+    slot, ready_now = mgr.acquire(persona="custom")
+    assert ready_now is False
+    assert slot.phase is SlotPhase.PREFILL
+    assert eng.recycled == []  # deferred: reset must run between engine steps
+
+    ready = []
+    slot.on_ready = lambda: ready.append(True)
+
+    mgr.tick()  # recycle + sacrifice
+    assert eng.recycled == [slot.index]
+    assert eng.steps[-1][1][slot.index].kind == "sacrifice"
+
+    mgr.tick()  # voice frame
+    assert eng.steps[-1][1][slot.index].kind == "voice"
+    assert eng.voice_ended == []
+
+    mgr.tick()  # voice_end executed BETWEEN ticks, then first tokens frame
+    assert eng.voice_ended == [slot.index]
+    assert eng.steps[-1][1][slot.index].kind == "tokens"
+
+    mgr.tick()  # second tokens frame
+    assert not ready
+    mgr.tick()  # prefill exhausted -> live
+    assert eng.prefill_done == [slot.index]
+    assert slot.phase is SlotPhase.LIVE
+    assert ready == [True]
+
+
+def test_pristine_slot_after_ticking_requires_recycle():
+    # step_batch advances EVERY row each tick, so a pristine idle row that has
+    # lived through ticks has drifted from its boot prefill and must be
+    # recycled before a client may join it.
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    first, ready_now = mgr.acquire()
+    assert ready_now is True  # claimed before any tick: truly pristine
+    mgr.tick()
+    second, ready_now2 = mgr.acquire()
+    assert second.index != first.index
+    assert ready_now2 is False
+    assert second.phase is SlotPhase.PREFILL
+
+
+def test_used_slot_requires_recycle_even_with_default_persona():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    slot, ready_now = mgr.acquire()
+    assert ready_now
+    mgr.release(slot)
+    slot2, ready_now2 = mgr.acquire()
+    assert slot2.index == slot.index
+    assert ready_now2 is False
+    assert slot2.phase is SlotPhase.PREFILL
+
+
+def test_acquire_returns_none_when_full():
+    eng = StubEngine(batch_size=2)
+    mgr = BatchedSessionManager(eng)
+    assert mgr.acquire() is not None
+    assert mgr.acquire() is not None
+    assert mgr.acquire() is None
+
+
+def test_feed_frames_epoch_guard_and_backlog_cap():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng, max_buffered_frames=3)
+    slot, _ = mgr.acquire()
+    mgr.feed(slot, np.arange(FRAME * 2, dtype=np.float32), slot.epoch)
+    assert len(slot.inq) == 2
+    mgr.feed(slot, np.zeros(3, dtype=np.float32), slot.epoch)  # partial tail buffered
+    assert len(slot.inq) == 2 and slot.pending.shape[0] == 3
+    mgr.feed(slot, np.zeros(FRAME * 5, dtype=np.float32), slot.epoch)
+    assert len(slot.inq) == 3  # oldest dropped beyond the cap
+    mgr.feed(slot, np.zeros(FRAME, dtype=np.float32), slot.epoch - 1)  # stale epoch ignored
+    assert len(slot.inq) == 3
+
+
+def test_live_slot_consumes_input_and_emits_output():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    slot, _ = mgr.acquire()
+    got = []
+    slot.on_output = got.append
+    frame = np.full(FRAME, 0.5, dtype=np.float32)
+    mgr.feed(slot, frame, slot.epoch)
+    mgr.tick()
+    assert len(got) == 1
+    np.testing.assert_array_equal(got[0].audio, frame)
+    # queue drained: next tick feeds zeros
+    mgr.tick()
+    np.testing.assert_array_equal(got[1].audio, np.zeros(FRAME, dtype=np.float32))
+
+
+def test_release_mid_flight_stops_emission():
+    eng = StubEngine()
+    mgr = BatchedSessionManager(eng)
+    slot, _ = mgr.acquire()
+    got = []
+    slot.on_output = got.append
+    mgr.tick()
+    assert len(got) == 1
+    mgr.release(slot)
+    # another slot keeps the batch non-idle
+    other, _ = mgr.acquire()  # same slot index, now PREFILL (used)
+    assert other.phase is SlotPhase.PREFILL
+    mgr.tick()
+    assert len(got) == 1  # no further output for the released epoch
diff --git a/tests/e2e/features/fullduplex/test_personaplex_elastic.py b/tests/e2e/features/fullduplex/test_personaplex_elastic.py
new file mode 100644
index 000000000..453d90153
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_personaplex_elastic.py
@@ -0,0 +1,240 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""GPU e2e for PersonaPlex elastic batching (bit-exact isolation + recycle).
+
+Greedy decoding makes every cross-slot leak observable as a bit difference:
+
+1. Isolation (bit-exact): recycling one slot mid-flight leaves every other
+   slot's output bit-identical to a run that never recycled.
+2. Replay exactness: a recycled slot's opening live ticks match a pristine boot
+   at numerical-noise level (a broken KV mask / staging roll garbles frame 0).
+3. Coherence (behavioral): a recycled slot fed a real spoken question produces
+   a real reply in its inner-monologue text stream.
+
+Run (moshi-free native stack; ~30 GB GPU + HF access to the gated repo; set
+PPLEX_QUESTION_WAV to a spoken-question wav to enable the coherence test):
+    pytest tests/e2e/features/fullduplex/test_personaplex_elastic.py -v -s
+
+Bench (B sweep, ms/tick vs the 80 ms budget):
+    python tests/e2e/features/fullduplex/test_personaplex_elastic.py --bench 2 4 8 16
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+torch = pytest.importorskip("torch")
+
+# slow + H100 + omni routes this module into the weekly Buildkite E2E group
+# ("Omni · H100" in .buildkite/cuda/test-weekly.yml: -m "slow and H100 and
+# omni" --run-level full_model); the ready/merge CPU sweeps exclude it by mark.
+pytestmark = [pytest.mark.full_model, pytest.mark.omni, pytest.mark.slow, pytest.mark.H100]
+
+if not torch.cuda.is_available():  # noqa: E402
+    pytest.skip("needs CUDA", allow_module_level=True)
+
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig  # noqa: E402
+from vllm_omni.experimental.fullduplex.personaplex.runtime import (  # noqa: E402
+    PersonaPlexEngine,
+)
+
+B = 4
+LIVE_TICKS = 40  # live frames compared per claim
+RECYCLE_AT = 10
+
+
+def _make_engine() -> PersonaPlexEngine:
+    cfg = PersonaPlexConfig(batch_size=B)  # native stepper is greedy-only
+    try:
+        return PersonaPlexEngine(cfg).load()
+    except Exception as exc:  # gated-repo access is environment-dependent
+        name = type(exc).__name__
+        if "Gated" in name or "401" in str(exc) or "403" in str(exc):
+            pytest.skip(f"no access to the gated nvidia/personaplex-7b-v1 repo: {name}")
+        raise
+
+
+@pytest.fixture(scope="module")
+def engine() -> PersonaPlexEngine:
+    return _make_engine()
+
+
+def _slot_stream(slot: int, tick: int, frame: int) -> np.ndarray:
+    """Deterministic per-slot input: distinct low-amplitude tones."""
+    sr = 24000
+    freq = 180.0 + 90.0 * slot
+    t0 = tick * frame
+    t = (np.arange(frame) + t0) / sr
+    return (0.12 * np.sin(2 * np.pi * freq * t)).astype(np.float32)
+
+
+def _run(engine, total_ticks: int, recycle: bool):
+    """Run the lockstep loop; optionally recycle slot 1 at RECYCLE_AT.
+
+    Returns per-slot lists of (audio | None) per live tick index, where the
+    recycled slot's list restarts its input stream at its post-prefill tick.
+    """
+    frame = engine.frame_size
+    outs: list[list[np.ndarray | None]] = [[] for _ in range(B)]
+    stream_tick = [0] * B  # per-slot conversation clock driving its input
+    prefill = None
+    tick = 0
+    while tick < total_ticks:
+        if recycle and tick == RECYCLE_AT and prefill is None:
+            engine.recycle_slot(1)
+            prefill = list(engine.prefill_steps(None))
+        pcm = np.zeros((B, frame), dtype=np.float32)
+        step_for_1 = None
+        if prefill:
+            while prefill and prefill[0].kind == "voice_end":
+                engine.voice_end(1)
+                prefill.pop(0)
+            if prefill:
+                step_for_1 = prefill.pop(0)
+            else:
+                engine.end_prefill(1)
+                prefill = None
+                stream_tick[1] = 0  # restart slot 1's input stream from its own t=0
+        for b in range(B):
+            if b == 1 and step_for_1 is not None:
+                continue  # engine overrides the user channel for prefill rows
+            pcm[b] = _slot_stream(b, stream_tick[b], frame)
+            stream_tick[b] += 1
+        frame_outs = engine.step_batch(pcm, {1: step_for_1} if step_for_1 is not None else None)
+        for b in range(B):
+            if b == 1 and step_for_1 is not None:
+                continue  # prefill tick: nothing conversational to record
+            frame_out = frame_outs[b]
+            outs[b].append(None if frame_out is None else frame_out.audio)
+        tick += 1
+    return outs
+
+
+def test_recycle_isolation_and_fresh_equivalence(engine):
+    engine.open_batch()
+    prefill_len = sum(1 for s in engine.prefill_steps(None) if s.kind != "voice_end")
+    total = RECYCLE_AT + prefill_len + LIVE_TICKS
+
+    base = _run(engine, total, recycle=False)
+
+    engine.open_batch()  # deterministic re-boot (greedy, fixed voice/persona)
+    rec = _run(engine, total, recycle=True)
+
+    # Claim 1 -- isolation: untouched slots bit-identical to the no-recycle run.
+    for b in (0, 2, 3):
+        assert len(base[b]) == total and len(rec[b]) == total
+        for i, (x, y) in enumerate(zip(base[b], rec[b])):
+            assert (x is None) == (y is None), f"slot {b} tick {i} validity diverged"
+            if x is not None:
+                assert np.array_equal(x, y), f"slot {b} tick {i} audio diverged (recycle leaked)"
+
+    # Claim 2 -- replay exactness: the recycled slot's opening live ticks match a
+    # pristine boot at numerical-noise level. A broken KV mask / staging-ring
+    # roll / Mimi reset garbles the audio from the very first frame (diffs of
+    # 0.1-1.0); a correct replay differs only by decoder-state rounding (~1e-4).
+    #
+    # Full-length bitwise identity is NOT expected, for two structural reasons:
+    # the replayed system prompt sits at a different ABSOLUTE RoPE offset (bf16
+    # rounds differently there), and the recycled Mimi ENCODER cannot restore a
+    # fresh stream's start padding (a batch-shared scalar), so from the first
+    # non-silent user frame it emits different-but-equally-valid codes for the
+    # same audio. Once any near-tie flips a token, the two equally valid
+    # trajectories legitimately diverge; coherence of the recycled slot is
+    # asserted behaviorally in test_recycled_slot_converses.
+    fresh = [a for a in base[1] if a is not None][:LIVE_TICKS]
+    reborn = [a for a in rec[1][RECYCLE_AT:] if a is not None][:LIVE_TICKS]
+    assert len(reborn) >= LIVE_TICKS // 2, "recycled slot produced too few live frames"
+    diffs = [float(np.max(np.abs(x - y))) for x, y in zip(fresh, reborn)]
+    first_flip = next((i for i, d in enumerate(diffs) if d > 5e-2), len(diffs))
+    print(
+        f"[elastic] replay exactness: {first_flip}/{len(diffs)} opening ticks at noise level "
+        f"(head diffs: {[f'{d:.1e}' for d in diffs[:6]]})"
+    )
+    assert first_flip >= 4, (
+        f"recycled slot diverged from fresh behavior at tick {first_flip} "
+        f"(diffs {diffs[: first_flip + 2]}); the system-prompt replay is broken"
+    )
+    assert max(diffs[:4]) < 2e-2, f"reborn audio not at noise level: {max(diffs[:4])}"
+
+
+def test_recycled_slot_converses(engine):
+    """Behavioral guarantee: a recycled slot holds a coherent conversation.
+
+    Feed a real spoken question into a slot that was recycled mid-flight (while
+    other slots keep running); the model's own inner-monologue text stream must
+    produce a real reply. This is the end-user property the encoder-state
+    caveats above cannot break.
+    """
+    import os
+
+    import sphn
+
+    wav_path = os.environ.get("PPLEX_QUESTION_WAV")
+    if not wav_path:
+        pytest.skip("set PPLEX_QUESTION_WAV to a spoken-question wav to run")
+    wav, _ = sphn.read(wav_path, sample_rate=24000)
+    wav = wav[0].astype(np.float32)
+    frame = engine.frame_size
+    pad = (-len(wav)) % frame
+    wav = np.concatenate([wav, np.zeros(pad, dtype=np.float32)])
+    q_frames = [wav[i : i + frame] for i in range(0, len(wav), frame)]
+
+    engine.open_batch()
+    pcm = np.zeros((B, frame), dtype=np.float32)
+    for _ in range(5):  # everyone live briefly
+        engine.step_batch(pcm)
+    engine.recycle_slot(1)
+    prefill = list(engine.prefill_steps(None))
+    while prefill:
+        while prefill and prefill[0].kind == "voice_end":
+            engine.voice_end(1)
+            prefill.pop(0)
+        if not prefill:
+            break
+        engine.step_batch(pcm, {1: prefill.pop(0)})
+    engine.end_prefill(1)
+
+    text = ""
+    total = len(q_frames) + 120  # question + ~10 s to answer
+    for i in range(total):
+        pcm = np.zeros((B, frame), dtype=np.float32)
+        if i < len(q_frames):
+            pcm[1] = q_frames[i]
+        outs = engine.step_batch(pcm)
+        if outs[1] is not None and outs[1].text:
+            text += outs[1].text
+    alpha = sum(c.isalpha() for c in text)
+    print(f"[elastic] recycled slot inner monologue: {text!r}")
+    assert alpha >= 15, f"recycled slot produced no coherent reply: {text!r}"
+
+
+def _bench(batch_sizes: list[int]) -> None:
+    import time
+
+    for bs in batch_sizes:
+        cfg = PersonaPlexConfig(batch_size=max(bs, 2))
+        eng = PersonaPlexEngine(cfg).load()
+        eng.open_batch()
+        frame = eng.frame_size
+        pcm = np.zeros((cfg.batch_size, frame), dtype=np.float32)
+        for _ in range(10):  # warm
+            eng.step_batch(pcm)
+        torch.cuda.synchronize()
+        t0 = time.monotonic()
+        n = 100
+        for _ in range(n):
+            eng.step_batch(pcm)
+        torch.cuda.synchronize()
+        ms = (time.monotonic() - t0) / n * 1000
+        mem = torch.cuda.max_memory_allocated() / 2**30
+        print(f"B={cfg.batch_size:3d}  {ms:6.1f} ms/tick  RTF/stream {ms / 80:.3f}  {mem:.1f} GiB")
+        del eng
+        torch.cuda.empty_cache()
+
+
+if __name__ == "__main__":
+    import sys
+
+    sizes = [int(x) for x in sys.argv[2:]] if len(sys.argv) > 2 and sys.argv[1] == "--bench" else [2, 4, 8]
+    _bench(sizes)
diff --git a/tests/e2e/features/fullduplex/test_personaplex_server_lease.py b/tests/e2e/features/fullduplex/test_personaplex_server_lease.py
new file mode 100644
index 000000000..451ffb714
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_personaplex_server_lease.py
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Single-session lease teardown: a cancelled engine call must be drained.
+
+Cancelling an asyncio task blocked on a worker-thread engine call returns
+immediately while the thread keeps running (executor futures cannot be
+interrupted). The server therefore tracks the in-flight future on the session
+state and waits it out before releasing the capacity-one lease; otherwise a
+fast reconnect could call ``open()`` on the shared engine while the previous
+connection's final ``step()`` is still mutating it.
+"""
+
+import asyncio
+import contextlib
+import sys
+import threading
+import types
+
+import pytest
+
+try:
+    import sphn  # noqa: F401
+except ImportError:
+    # These lease tests never encode/decode Opus. Keep the optional serving
+    # dependency from hiding dependency-free teardown regressions.
+    sys.modules["sphn"] = types.ModuleType("sphn")
+
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.serving.server import DuplexServer
+from vllm_omni.experimental.fullduplex.personaplex.session import PersonaPlexServingSessionState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.asyncio
+async def test_cancelled_engine_call_is_drained_before_lease_release():
+    server = DuplexServer(PersonaPlexConfig())  # engine never loaded: stub calls only
+    state = PersonaPlexServingSessionState()
+
+    started = threading.Event()
+    release = threading.Event()
+    finished = threading.Event()
+
+    def slow_engine_op():
+        started.set()
+        release.wait(timeout=5.0)
+        finished.set()
+        return []
+
+    task = asyncio.create_task(server._engine_call(state, slow_engine_op))
+    await asyncio.to_thread(started.wait, 5.0)
+
+    # Cancel while the worker thread is mid-call: the await returns at once,
+    # the thread keeps running, and its completion event stays tracked on the
+    # state (the asyncio future itself reads as cancelled/done here, which is
+    # exactly why the drain must not rely on it).
+    task.cancel()
+    with contextlib.suppress(asyncio.CancelledError):
+        await task
+    assert state.inflight is not None
+    assert not state.inflight.is_set()
+
+    # The drain must genuinely wait for the worker, not just return.
+    drain = asyncio.create_task(server._drain_inflight(state))
+    await asyncio.sleep(0.05)
+    assert not drain.done()
+
+    release.set()
+    await asyncio.wait_for(drain, timeout=5.0)
+    assert finished.is_set()
+    assert state.inflight.is_set()
+
+
+@pytest.mark.asyncio
+async def test_completed_engine_call_clears_inflight():
+    server = DuplexServer(PersonaPlexConfig())
+    state = PersonaPlexServingSessionState()
+    result = await server._engine_call(state, lambda: "ok")
+    assert result == "ok"
+    assert state.inflight is None
+    await server._drain_inflight(state)  # no-op on a clean state
+
+
+@pytest.mark.asyncio
+async def test_drain_timeout_keeps_lease_until_worker_finishes():
+    server = DuplexServer(PersonaPlexConfig())
+    server._active = True
+    state = PersonaPlexServingSessionState()
+    state.inflight = threading.Event()
+
+    drained = await server._release_lease_after_drain(state, timeout=0.01)
+
+    assert drained is False
+    assert server._active is True
+
+    state.inflight.set()
+    for _ in range(100):
+        if not server._active:
+            break
+        await asyncio.sleep(0.01)
+    assert server._active is False
diff --git a/tests/e2e/features/fullduplex/test_personaplex_session.py b/tests/e2e/features/fullduplex/test_personaplex_session.py
new file mode 100644
index 000000000..f838de4ff
--- /dev/null
+++ b/tests/e2e/features/fullduplex/test_personaplex_session.py
@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Lockstep-contract tests for the PersonaPlex session driver (no GPU / no moshi).
+
+A stub :class:`FrameStepper` stands in for the real Moshi backend so we can assert
+the framing + 1-frame-in / 1-frame-out invariants without weights.
+"""
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.personaplex.config import FRAME_SIZE, PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput, FrameStepper
+from vllm_omni.experimental.fullduplex.personaplex.session import PersonaPlexSession
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class StubStepper:
+    """Deterministic FrameStepper: frame i -> audio filled with i, text 't{i}' on odds."""
+
+    sample_rate = 24000
+    frame_size = FRAME_SIZE
+
+    def __init__(self) -> None:
+        self.opened: tuple[str | None, str | None] | None = None
+        self.steps = 0
+
+    def open_session(self, voice_prompt=None, persona=None) -> None:
+        self.opened = (voice_prompt, persona)
+        self.steps = 0
+
+    def step(self, user_pcm):
+        assert user_pcm.shape[0] == self.frame_size
+        self.steps += 1
+        i = self.steps
+        return FrameOutput(
+            audio=np.full(self.frame_size, float(i), dtype=np.float32),
+            text=(f"t{i}" if i % 2 else None),
+        )
+
+
+def test_stub_satisfies_protocol():
+    assert isinstance(StubStepper(), FrameStepper)
+
+
+def test_feed_emits_one_output_per_complete_frame():
+    s = PersonaPlexSession(StubStepper(), PersonaPlexConfig())
+    s.open(voice_prompt="NATF2.pt", persona="be terse")
+    out = s.feed(np.zeros(FRAME_SIZE * 3, dtype=np.float32))
+    assert len(out) == 3
+    # lockstep order preserved: frame i -> audio filled with i
+    assert [int(o.audio[0]) for o in out] == [1, 2, 3]
+    assert [o.text for o in out] == ["t1", None, "t3"]
+
+
+def test_partial_frames_are_buffered_until_complete():
+    stub = StubStepper()
+    s = PersonaPlexSession(stub, PersonaPlexConfig())
+    s.open()
+    assert s.feed(np.zeros(FRAME_SIZE // 2, dtype=np.float32)) == []  # nothing yet
+    assert stub.steps == 0
+    out = s.feed(np.zeros(FRAME_SIZE, dtype=np.float32))  # 1.5 frames total -> 1 frame
+    assert len(out) == 1
+    assert stub.steps == 1
+
+
+def test_flush_pads_the_tail():
+    stub = StubStepper()
+    s = PersonaPlexSession(stub, PersonaPlexConfig())
+    s.open()
+    s.feed(np.ones(FRAME_SIZE + 10, dtype=np.float32))  # 1 frame + 10-sample tail
+    assert stub.steps == 1
+    tail = s.flush()
+    assert len(tail) == 1 and stub.steps == 2
+    assert s.flush() == []  # nothing left
+
+
+def test_run_concatenates_audio_and_joins_text():
+    s = PersonaPlexSession(StubStepper(), PersonaPlexConfig())
+    s.open()
+    audio, text = s.run(np.zeros(FRAME_SIZE * 4, dtype=np.float32))
+    assert audio.shape[0] == FRAME_SIZE * 4
+    assert text == "t1t3"  # frames 1..4, text on odds
+
+
+def test_open_forwards_voice_and_persona():
+    stub = StubStepper()
+    s = PersonaPlexSession(stub, PersonaPlexConfig())
+    s.open(voice_prompt="NATM1.pt", persona="pirate")
+    assert stub.opened == ("NATM1.pt", "pirate")
+
+
+def test_feed_before_open_raises():
+    s = PersonaPlexSession(StubStepper(), PersonaPlexConfig())
+    with pytest.raises(RuntimeError):
+        s.feed(np.zeros(FRAME_SIZE, dtype=np.float32))
diff --git a/tests/fullduplex/test_runtime.py b/tests/e2e/features/fullduplex/test_runtime.py
similarity index 100%
rename from tests/fullduplex/test_runtime.py
rename to tests/e2e/features/fullduplex/test_runtime.py
diff --git a/tests/e2e/offline_inference/custom_pipeline/qwen_image_pipeline_with_logprob.py b/tests/e2e/features/helpers/custom_pipeline.py
similarity index 59%
rename from tests/e2e/offline_inference/custom_pipeline/qwen_image_pipeline_with_logprob.py
rename to tests/e2e/features/helpers/custom_pipeline.py
index 193d1b1e2..63cb21056 100644
--- a/tests/e2e/offline_inference/custom_pipeline/qwen_image_pipeline_with_logprob.py
+++ b/tests/e2e/features/helpers/custom_pipeline.py
@@ -1,27 +1,299 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""Detailed custom Qwen-Image pipeline for E2E tests.
+"""Test doubles for custom-pipeline E2E and RLHF integration.
 
-This pipeline follows the structure of the user's reference implementation:
-- supports pre-tokenized prompt IDs via OmniCustomPrompt-style dict input
-- uses an SDE scheduler that can return step logprobs
-- returns structured trajectory_* fields (latents, timesteps, log_probs)
-  consistent with the BAGEL trajectory recording design
+Three layers:
+
+* ``FlowMatchSDEDiscreteSchedulerForTest`` — SDE scheduler with per-step logprobs.
+* ``vLLMOmniColocateWorkerExtensionForTest`` — verl-omni colocate worker extension mirror.
+* ``QwenImagePipelineWithLogProbForTest`` — Qwen-Image pipeline returning trajectory_* fields.
 """
 
 from __future__ import annotations
 
+import ctypes
+import logging
+import math
 import os
+import platform
+import signal
+from dataclasses import dataclass
 from typing import Any, Literal
 
 import torch
+from diffusers import FlowMatchEulerDiscreteScheduler
+from diffusers.utils import BaseOutput
+from diffusers.utils.torch_utils import randn_tensor
+from msgspec import field
 
-from tests.e2e.offline_inference.custom_pipeline.flow_match_sde_scheduler import FlowMatchSDEDiscreteSchedulerForTest
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.models.qwen_image import QwenImagePipeline
+from vllm_omni.diffusion.worker.diffusion_worker import CustomPipelineWorkerExtension
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.lora.request import LoRARequest as OmniLoRARequest
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Scheduler layer
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FlowMatchSDEDiscreteSchedulerOutputForTest(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_channels)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+        log_prob (`torch.FloatTensor` of shape `(batch_size,)`, *optional*):
+            The log probability of the previous sample.
+        prev_sample_mean (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_channels)` for images):
+            The mean of the computed sample of previous timestep.
+        std_dev_t (`torch.FloatTensor` of shape `(batch_size, 1, 1)`):
+            The standard deviation used to compute `prev_sample`.
+    """
+
+    prev_sample: torch.FloatTensor
+    log_prob: torch.FloatTensor | None
+    prev_sample_mean: torch.FloatTensor
+    std_dev_t: torch.FloatTensor
+
+
+class FlowMatchSDEDiscreteSchedulerForTest(FlowMatchEulerDiscreteScheduler):
+    """SDE version of the FlowMatchEulerDiscreteScheduler.
+    The implementation is based on FlowGRPO paper (https://arxiv.org/abs/2505.05470)
+    and diffusers v0.37 branch.
+    """
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        sample: torch.FloatTensor,
+        s_churn: float = 0.0,
+        s_tmin: float = 0.0,
+        s_tmax: float = float("inf"),
+        s_noise: float = 1.0,
+        generator: torch.Generator | None = None,
+        per_token_timesteps: torch.Tensor | None = None,
+        return_dict: bool = True,
+        noise_level: float = 0.7,
+        prev_sample: torch.FloatTensor | None = None,
+        sde_type: Literal["sde", "cps"] = "sde",
+        return_logprobs: bool = True,
+    ) -> FlowMatchSDEDiscreteSchedulerOutputForTest | tuple:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Modified from https://github.com/yifan123/flow_grpo/blob/main/flow_grpo/diffusers_patch/sd3_sde_with_logprob.py
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            s_churn (`float`):
+            s_tmin  (`float`):
+            s_tmax  (`float`):
+            s_noise (`float`, defaults to 1.0):
+                Scaling factor for noise added to the sample.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            per_token_timesteps (`torch.Tensor`, *optional*):
+                The timesteps for each token in the sample.
+            return_dict (`bool`):
+                Whether or not to return a
+                [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchSDEDiscreteSchedulerOutput`] or tuple.
+            noise_level (`float`, *optional*, defaults to 0.7):
+                The noise level used in the SDE.
+            prev_sample (`torch.FloatTensor`, *optional*):
+                The sample from the previous timestep. If not provided, it will be sampled inside the function.
+            sde_type (`str`, *optional*, defaults to "sde"):
+                The type of SDE to use. Choose between "sde" and "cps".
+            return_logprobs (`bool`, *optional*, defaults to True):
+                Whether to return log probabilities of the previous sample.
+        """
+
+        if isinstance(timestep, (int, torch.IntTensor, torch.LongTensor)):
+            raise ValueError(
+                (
+                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                    " `FlowMatchEulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                    " one of the `scheduler.timesteps` as a timestep."
+                ),
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+        if prev_sample is not None:
+            prev_sample = prev_sample.to(torch.float32)
+
+        prev_sample, log_prob, prev_sample_mean, std_dev_t = self.sample_previous_step(
+            sample=sample,
+            model_output=model_output,
+            generator=generator,
+            per_token_timesteps=per_token_timesteps,
+            noise_level=noise_level,
+            prev_sample=prev_sample,
+            sde_type=sde_type,
+            return_logprobs=return_logprobs,
+        )
+
+        # upon completion increase step index by one
+        self._step_index += 1
+        if per_token_timesteps is None:
+            # Cast sample back to model compatible dtype
+            prev_sample = prev_sample.to(model_output.dtype)
+
+        if not return_dict:
+            return (prev_sample, log_prob, prev_sample_mean, std_dev_t)
+
+        return FlowMatchSDEDiscreteSchedulerOutputForTest(
+            prev_sample=prev_sample, log_prob=log_prob, prev_sample_mean=prev_sample_mean, std_dev_t=std_dev_t
+        )
+
+    def sample_previous_step(
+        self,
+        sample: torch.Tensor,
+        model_output: torch.Tensor,
+        timestep: torch.FloatTensor | None = None,
+        generator: torch.Generator | None = None,
+        per_token_timesteps: torch.Tensor | None = None,
+        noise_level: float = 0.7,
+        prev_sample: torch.Tensor | None = None,
+        sde_type: Literal["cps", "sde"] = "sde",
+        return_logprobs: bool = True,
+    ):
+        assert sde_type in ["sde", "cps"]
+        assert sample.dtype == torch.float32
+        if prev_sample is not None:
+            assert prev_sample.dtype == torch.float32
+
+        if per_token_timesteps is not None:
+            raise NotImplementedError("per_token_timesteps is not supported yet for FlowMatchSDEDiscreteScheduler.")
+        else:
+            if timestep is None:
+                sigma_idx = self.step_index
+                sigma = self.sigmas[sigma_idx]
+                sigma_prev = self.sigmas[sigma_idx + 1]
+            else:
+                sigma_idx = torch.tensor([self.index_for_timestep(t) for t in timestep])
+                sigma = self.sigmas[sigma_idx].view(-1, *([1] * (len(sample.shape) - 1)))
+                sigma_prev = self.sigmas[sigma_idx + 1].view(-1, *([1] * (len(sample.shape) - 1)))
+
+            sigma_max = self.sigmas[1]
+            dt = sigma_prev - sigma
+
+        if sde_type == "sde":
+            std_dev_t = torch.sqrt(sigma / (1 - torch.where(sigma == 1, sigma_max, sigma))) * noise_level
+
+            prev_sample_mean = (
+                sample * (1 + std_dev_t**2 / (2 * sigma) * dt)
+                + model_output * (1 + std_dev_t**2 * (1 - sigma) / (2 * sigma)) * dt
+            )
+
+            if prev_sample is None:
+                variance_noise = randn_tensor(
+                    model_output.shape,
+                    generator=generator,
+                    device=model_output.device,
+                    dtype=model_output.dtype,
+                )
+                prev_sample = prev_sample_mean + std_dev_t * torch.sqrt(-1 * dt) * variance_noise
+
+            if return_logprobs:
+                log_prob = (
+                    -((prev_sample.detach() - prev_sample_mean) ** 2) / (2 * ((std_dev_t * torch.sqrt(-1 * dt)) ** 2))
+                    - torch.log(std_dev_t * torch.sqrt(-1 * dt))
+                    - torch.log(torch.sqrt(2 * torch.as_tensor(math.pi)))
+                )
+            else:
+                log_prob = None
+
+        elif sde_type == "cps":
+            std_dev_t = sigma_prev * math.sin(noise_level * math.pi / 2)
+            pred_original_sample = sample - sigma * model_output
+            noise_estimate = sample + model_output * (1 - sigma)
+            prev_sample_mean = pred_original_sample * (1 - sigma_prev) + noise_estimate * torch.sqrt(
+                sigma_prev**2 - std_dev_t**2
+            )
+
+            if prev_sample is None:
+                variance_noise = randn_tensor(
+                    model_output.shape,
+                    generator=generator,
+                    device=model_output.device,
+                    dtype=model_output.dtype,
+                )
+                prev_sample = prev_sample_mean + std_dev_t * variance_noise
+
+            if return_logprobs:
+                log_prob = -((prev_sample.detach() - prev_sample_mean) ** 2)
+            else:
+                log_prob = None
+
+        # mean along all but batch dimension
+        log_prob = log_prob.mean(dim=tuple(range(1, log_prob.ndim))) if log_prob is not None else None
+        return prev_sample, log_prob, prev_sample_mean, std_dev_t
+
+
+# ---------------------------------------------------------------------------
+# Worker extension layer
+# ---------------------------------------------------------------------------
+
+
+class OmniTensorLoRARequestForTest(OmniLoRARequest):
+    peft_config: dict = field(default=None)
+    lora_tensors: dict = field(default=None)
+
+
+def set_death_signal() -> None:
+    """Verbatim port of ``verl.workers.rollout.vllm_rollout.utils.set_death_signal``."""
+    if platform.system() != "Linux":
+        return
+    try:
+        libc = ctypes.CDLL("libc.so.6")
+        libc.prctl(1, signal.SIGKILL)
+        if os.getppid() == 1:
+            os.kill(os.getpid(), signal.SIGKILL)
+    except Exception:  # noqa: BLE001
+        # libc.so.6 may not be present (musl, alpine) — best-effort only.
+        pass
+
+
+class vLLMOmniColocateWorkerExtensionForTest(CustomPipelineWorkerExtension):
+    """Mirror of ``vLLMOmniColocateWorkerExtension`` (verl-omni).
+
+    The production ``__new__`` runs ``set_death_signal`` + ``VLLMOmniHijack.hijack``
+    on every vLLM worker process. Replicating both ensures this test
+    reproduces the same monkey-patched environment.
+    """
+
+    def __new__(cls, **kwargs):
+        set_death_signal()
+        return super().__new__(cls)
+
+    @staticmethod
+    def test_extension_name() -> str:
+        """Return a stable identifier for assertions in unit tests."""
+        return "vllm-omni-colocate-worker-extension-for-test"
+
+
+# ---------------------------------------------------------------------------
+# Pipeline layer
+# ---------------------------------------------------------------------------
 
 
 def _maybe_to_cpu(v):
@@ -30,8 +302,6 @@ def _maybe_to_cpu(v):
     return v
 
 
-# Custom pipeline class for QwenImage that returns log probabilities during the diffusion process.
-# This is for test
 class QwenImagePipelineWithLogProbForTest(QwenImagePipeline):
     supports_request_batch = False
 
diff --git a/tests/e2e/offline_inference/rlhf_test/test_verl_omni_e2e.py b/tests/e2e/features/helpers/verl_omni_server.py
similarity index 53%
rename from tests/e2e/offline_inference/rlhf_test/test_verl_omni_e2e.py
rename to tests/e2e/features/helpers/verl_omni_server.py
index 69952435e..d53e0936f 100644
--- a/tests/e2e/offline_inference/rlhf_test/test_verl_omni_e2e.py
+++ b/tests/e2e/features/helpers/verl_omni_server.py
@@ -1,30 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""E2E test that follows the EXACT same flow as
-``verl-omni/tests/workers/rollout/rollout_vllm/test_vllm_omni_generate.py``
-but inlines all the ``verl`` / ``verl_omni`` symbols the flow depends on
-(stripped down to only what the diffusion-mode test actually exercises).
+"""Ray-serializable verl-omni HTTP server test double for RLHF E2E tests.
 
-Flow (identical to the verl-omni test):
-
-1. Build two ``OmegaConf`` configs (``DiffusionRolloutConfig`` /
-   ``DiffusionModelConfig`` shape).
-2. ``ServerCls = ray.remote(vLLMOmniHttpServerLocal)`` then
-   ``ServerCls.options(...).remote(config=..., model_config=...,
-   rollout_mode=RolloutMode.STANDALONE, workers=[], replica_rank=0,
-   node_rank=0, gpus_per_node=1, nnodes=1, cuda_visible_devices="0")``.
-3. ``ray.get(server.launch_server.remote())``.
-4. ``server.generate.remote(prompt_ids=..., sampling_params=..., request_id=...)``
-   and assert the returned ``DiffusionOutput``.
-
-The inlined classes / helpers mirror their ``verl`` / ``verl_omni``
-counterparts; bits not reached by this test (AR mode, LoRA,
-quantization, run_uvicorn, headless, profiler, port wiring) are removed.
-
-Usage:
-    pytest tests/e2e/offline_inference/rlhf_test/\
-test_ray_async_omni_qwen_image_generate.py -v -s
+The actor class must live in an importable module (not a pytest test file) so
+Ray workers can unpickle ``vLLMOmniHttpServerLocal`` via
+``tests.e2e.features.helpers.verl_omni_server``.
 """
 
 from __future__ import annotations
@@ -35,23 +16,15 @@ import logging
 import os
 from dataclasses import asdict
 from enum import Enum
-from functools import lru_cache
 from typing import Any
-from uuid import uuid4
 
-import pytest
-import ray
-import torch
 import torchvision.transforms as T
-from huggingface_hub import snapshot_download
 from omegaconf import DictConfig, OmegaConf
 from pydantic import BaseModel, ConfigDict
-from transformers import AutoTokenizer
 from vllm.entrypoints.openai.api_server import build_app
 from vllm.utils.argparse_utils import FlexibleArgumentParser
 
 import vllm_omni.entrypoints.cli.serve
-from tests.helpers.mark import hardware_test
 from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.entrypoints.openai.api_server import omni_init_app_state
@@ -60,33 +33,8 @@ from vllm_omni.outputs import OmniRequestOutput
 
 logger = logging.getLogger(__name__)
 
-CUSTOM_PIPELINE_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.qwen_image_pipeline_with_logprob.QwenImagePipelineWithLogProbForTest"
-)
-WORKER_EXTENSION_CLASS = (
-    "tests.e2e.offline_inference.custom_pipeline.worker_extension.vLLMOmniColocateWorkerExtensionForTest"
-)
-
-# Use your specified HF repo name/path directly here
-MODEL = "tiny-random/Qwen-Image"
-
-TOKENIZER_MODEL = "Qwen/Qwen2-1.5B-Instruct"
-
-
-def _resolve_model_path(repo_id: str) -> str:
-    """Resolve an HF repo ID to a local snapshot path, downloading if needed."""
-    # Allow overriding with a pre-existing local path (skips download).
-    if os.path.isdir(repo_id):
-        return repo_id
-    return snapshot_download(repo_id=repo_id)
-
-
-_MIN_PROMPT_TOKENS = 35
-
-
-# ---------------------------------------------------------------------
-#       Inlined: verl.workers.rollout.replica.RolloutMode
-# ---------------------------------------------------------------------
+CUSTOM_PIPELINE_CLASS = "tests.e2e.features.helpers.custom_pipeline.QwenImagePipelineWithLogProbForTest"
+WORKER_EXTENSION_CLASS = "tests.e2e.features.helpers.custom_pipeline.vLLMOmniColocateWorkerExtensionForTest"
 
 
 class RolloutMode(Enum):
@@ -95,11 +43,6 @@ class RolloutMode(Enum):
     STANDALONE = "standalone"
 
 
-# ---------------------------------------------------------------------
-#       Inlined: verl_omni.workers.rollout.replica.DiffusionOutput
-# ---------------------------------------------------------------------
-
-
 class DiffusionOutput(BaseModel):
     """Pydantic mirror of ``verl_omni.workers.rollout.replica.DiffusionOutput``."""
 
@@ -112,11 +55,6 @@ class DiffusionOutput(BaseModel):
     extra_fields: dict[str, Any] = {}
 
 
-# ---------------------------------------------------------------------
-#       Inlined: verl.utils.tokenizer.normalize_token_ids
-# ---------------------------------------------------------------------
-
-
 def normalize_token_ids(tokenized_output) -> list[int]:
     token_ids = tokenized_output
     if isinstance(tokenized_output, dict):
@@ -142,11 +80,6 @@ def normalize_token_ids(tokenized_output) -> list[int]:
     return out
 
 
-# ---------------------------------------------------------------------
-#  Inlined: verl.workers.rollout.vllm_rollout.utils.build_cli_args_from_config
-# ---------------------------------------------------------------------
-
-
 def build_cli_args_from_config(config: dict[str, Any]) -> list[str]:
     cli_args: list[str] = []
     for k, v in config.items():
@@ -166,34 +99,6 @@ def build_cli_args_from_config(config: dict[str, Any]) -> list[str]:
     return cli_args
 
 
-# ---------------------------------------------------------------------
-#                  Tokenizer helper (test-side)
-# ---------------------------------------------------------------------
-
-
-@lru_cache(maxsize=1)
-def _get_tokenizer():
-    return AutoTokenizer.from_pretrained(TOKENIZER_MODEL, trust_remote_code=True)
-
-
-def _tokenize_prompt(text: str) -> list[int]:
-    tokenizer = _get_tokenizer()
-    messages = [{"role": "user", "content": text}]
-    token_ids = normalize_token_ids(tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=False))
-    assert len(token_ids) > _MIN_PROMPT_TOKENS, (
-        f"Prompt too short ({len(token_ids)} tokens, need >{_MIN_PROMPT_TOKENS}). "
-        "The pipeline drops the first 34 chat-template prefix tokens; "
-        "use a longer prompt so content tokens remain after the drop."
-    )
-    return token_ids
-
-
-# ---------------------------------------------------------------------
-#  Inlined: vLLMOmniHttpServer (verl-omni) + relevant vLLMHttpServer (verl)
-#  bits, stripped to the diffusion-mode path the test exercises.
-# ---------------------------------------------------------------------
-
-
 def _cfg_get(cfg: Any, key: str, default: Any = None) -> Any:
     """Uniform getter that works for both DictConfig and dataclass-like objects."""
     if isinstance(cfg, DictConfig):
@@ -202,13 +107,8 @@ def _cfg_get(cfg: Any, key: str, default: Any = None) -> Any:
 
 
 class vLLMOmniHttpServerLocal:
-    """Self-contained simulation of ``vLLMOmniHttpServer`` for diffusion mode.
+    """Self-contained simulation of ``vLLMOmniHttpServer`` for diffusion mode."""
 
-    Constructor signature matches ``vLLMHttpServer.__init__`` exactly so the
-    Ray-actor call site in the test is identical to the verl-omni one.
-    """
-
-    # ------------------------------------------------------------------ init
     def __init__(
         self,
         config,
@@ -224,8 +124,6 @@ class vLLMOmniHttpServerLocal:
         os.environ.setdefault("CUDA_VISIBLE_DEVICES", cuda_visible_devices)
         os.environ["VERL_REPLICA_RANK"] = str(replica_rank)
 
-        # Resolve configs. verl uses omega_conf_to_dataclass; here we keep
-        # them as DictConfig — every read site below uses ``_cfg_get``.
         self.config = OmegaConf.create(config) if not isinstance(config, DictConfig) else config
         self.model_config = OmegaConf.create(model_config) if not isinstance(model_config, DictConfig) else model_config
 
@@ -237,8 +135,6 @@ class vLLMOmniHttpServerLocal:
         self.nnodes = nnodes
         self.global_steps = 0
         self.engine: AsyncOmni | None = None
-
-        # Diffusion-mode parity with ``vLLMOmniHttpServer._post_init``.
         self._to_tensor = T.PILToTensor()
 
         logger.info(
@@ -249,11 +145,7 @@ class vLLMOmniHttpServerLocal:
             cuda_visible_devices,
         )
 
-    # ---------------------------------------------------------- launch_server
     async def launch_server(self) -> None:
-        """Diffusion-only mirror of ``vLLMHttpServer.launch_server``."""
-
-        # vLLMOmniHttpServer._get_engine_kwargs_key() returns "vllm_omni".
         engine_kwargs_root = _cfg_get(self.config, "engine_kwargs", {}) or {}
         if isinstance(engine_kwargs_root, (dict, DictConfig)):
             engine_kwargs = engine_kwargs_root.get("vllm_omni", {}) or {}
@@ -261,10 +153,8 @@ class vLLMOmniHttpServerLocal:
             engine_kwargs = {}
         engine_kwargs = {k: v for k, v in dict(engine_kwargs).items() if v is not None}
 
-        # vLLMOmniHttpServer._preprocess_engine_kwargs (diffusion path).
         engine_kwargs.pop("output_mode", None)
 
-        # ``compilation_config`` handling — verbatim from parent launch_server.
         compilation_config = engine_kwargs.pop("compilation_config", None) or {}
         if isinstance(compilation_config, str):
             compilation_config = json.loads(compilation_config)
@@ -273,8 +163,6 @@ class vLLMOmniHttpServerLocal:
         compilation_config.setdefault("cudagraph_mode", "FULL_AND_PIECEWISE")
         compilation_config = json.dumps(compilation_config)
 
-        # Args dict (subset of parent's; the diffusion override drops AR-only
-        # entries via ``_get_override_generation_config`` returning ``{}``).
         args = {
             "dtype": _cfg_get(self.config, "dtype", "bfloat16"),
             "load_format": _cfg_get(self.config, "load_format", "auto"),
@@ -283,7 +171,7 @@ class vLLMOmniHttpServerLocal:
             "worker_extension_cls": WORKER_EXTENSION_CLASS,
             "trust_remote_code": _cfg_get(self.model_config, "trust_remote_code", True),
             "max_model_len": _cfg_get(self.config, "max_model_len", 1058),
-            "max_num_seqs": _cfg_get(self.config, "max_num_seqs", 256),
+            "max_num_seqs": _cfg_get(self.config, "max_num_seqs", 1),
             "enable_chunked_prefill": _cfg_get(self.config, "enable_chunked_prefill", False),
             "max_num_batched_tokens": _cfg_get(self.config, "max_num_batched_tokens", 8192),
             "enable_prefix_caching": _cfg_get(self.config, "enable_prefix_caching", False),
@@ -303,8 +191,6 @@ class vLLMOmniHttpServerLocal:
         model_path = str(_cfg_get(self.model_config, "local_path", None) or _cfg_get(self.model_config, "path"))
         server_args_list = ["serve", model_path] + build_cli_args_from_config(args)
 
-        # Same parser pipeline as parent launch_server (with vllm-omni's
-        # cmd_init injected, matching ``_get_cli_modules`` + ``_get_cli_description``).
         parser = FlexibleArgumentParser(description="vLLM-Omni CLI")
         subparsers = parser.add_subparsers(required=False, dest="subparser")
         cmds: dict[str, Any] = {}
@@ -316,19 +202,12 @@ class vLLMOmniHttpServerLocal:
         if parsed.subparser in cmds:
             cmds[parsed.subparser].validate(parsed)
 
-        # node_rank == 0 → run_server (the test never sets node_rank != 0).
         await self.run_server(parsed)
 
-    # ------------------------------------------------------------- run_server
     async def run_server(self, args: argparse.Namespace) -> None:
-        """Diffusion branch of ``vLLMOmniHttpServer.run_server``."""
-
         engine_args = OmniEngineArgs.from_cli_args(args)
         engine_args = asdict(engine_args)
 
-        # Diffusion path: pin the in-repo test pipeline. The production code
-        # calls ``VllmOmniPipelineBase.get_pipeline_path(architecture)``; we
-        # bypass the registry and bind the test pipeline directly.
         engine_args["enable_dummy_pipeline"] = True
         engine_args["custom_pipeline_args"] = {"pipeline_class": CUSTOM_PIPELINE_CLASS}
 
@@ -337,10 +216,7 @@ class vLLMOmniHttpServerLocal:
         await omni_init_app_state(engine_client, app.state, args)
 
         self.engine = engine_client
-        # ``run_uvicorn`` intentionally skipped — the test drives the engine
-        # via Ray RPC, not HTTP.
 
-    # ---------------------------------------------------------------- generate
     async def generate(
         self,
         prompt_ids: list[int],
@@ -351,8 +227,6 @@ class vLLMOmniHttpServerLocal:
         negative_prompt_ids: list[int] | None = None,
         priority: int = 0,  # noqa: ARG002 (signature parity)
     ) -> DiffusionOutput:
-        # Verbatim copy of ``vLLMOmniHttpServer._generate_diffusion`` minus
-        # the LoRA branch (the test does not enable ``lora_as_adapter``).
         prompt_ids = normalize_token_ids(prompt_ids)
 
         multi_modal_data: dict[str, Any] = {}
@@ -444,148 +318,3 @@ class vLLMOmniHttpServerLocal:
             num_preempted=num_preempted,
             extra_fields=extra_fields,
         )
-
-
-# ---------------------------------------------------------------------
-#                          Fixtures & tests
-# ---------------------------------------------------------------------
-
-
-@pytest.fixture
-def init_server():
-    """Create and launch a vLLMOmniHttpServerLocal Ray actor with Qwen-Image."""
-    model_path = _resolve_model_path(MODEL)
-
-    ray.init(
-        runtime_env={
-            "env_vars": {
-                "TOKENIZERS_PARALLELISM": "true",
-                "NCCL_DEBUG": "WARN",
-                "VLLM_LOGGING_LEVEL": "INFO",
-            }
-        },
-        ignore_reinit_error=True,
-    )
-
-    rollout_cfg = OmegaConf.create(
-        {
-            "name": "vllm_omni",
-            "mode": "async",
-            "tensor_model_parallel_size": 1,
-            "data_parallel_size": 1,
-            "pipeline_model_parallel_size": 1,
-            "gpu_memory_utilization": 0.8,
-            "max_num_batched_tokens": 8192,
-            "max_num_seqs": 256,
-            "max_model_len": 1058,
-            "dtype": "bfloat16",
-            "load_format": "auto",
-            "enforce_eager": True,
-            "enable_chunked_prefill": False,
-            "enable_prefix_caching": False,
-            "enable_sleep_mode": False,
-            "free_cache_engine": True,
-            "disable_log_stats": True,
-            "logprobs_mode": "processed_logprobs",
-            "scheduling_policy": "fcfs",
-            "seed": 0,
-            "n": 4,
-            "pipeline": {
-                "height": 512,
-                "width": 512,
-                "num_inference_steps": 10,
-            },
-        }
-    )
-
-    model_cfg = OmegaConf.create(
-        {
-            "path": str(model_path),
-            "local_path": str(model_path),
-            "tokenizer_path": TOKENIZER_MODEL,
-            "trust_remote_code": True,
-            "load_tokenizer": True,
-        }
-    )
-
-    ServerCls = ray.remote(vLLMOmniHttpServerLocal)
-    server = ServerCls.options(
-        runtime_env={
-            "env_vars": {
-                "RAY_EXPERIMENTAL_NOSET_CUDA_VISIBLE_DEVICES": "1",
-                "RAY_EXPERIMENTAL_NOSET_ASCEND_RT_VISIBLE_DEVICES": "1",
-                "NCCL_CUMEM_ENABLE": "0",
-            }
-        },
-        max_concurrency=10,
-        num_gpus=1,
-    ).remote(
-        config=rollout_cfg,
-        model_config=model_cfg,
-        rollout_mode=RolloutMode.STANDALONE,
-        workers=[],
-        replica_rank=0,
-        node_rank=0,
-        gpus_per_node=1,
-        nnodes=1,
-        cuda_visible_devices="0",
-    )
-
-    ray.get(server.launch_server.remote())
-
-    yield server
-
-    ray.shutdown()
-
-
-@pytest.mark.core_model
-@pytest.mark.diffusion
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_generate(init_server):
-    """Concurrent generate() calls covering basic output, logprobs, and multi-request correctness."""
-    server = init_server
-
-    prompts = [
-        "a beautiful sunset over the ocean with vibrant orange and purple clouds "
-        "reflecting on the calm water surface near a rocky coastline",
-        "a fluffy orange cat sitting on a wooden windowsill looking outside at "
-        "a garden full of colorful flowers on a bright sunny afternoon",
-        "a majestic mountain landscape covered with fresh white snow under a "
-        "clear blue sky with pine trees in the foreground and a frozen lake",
-        "a futuristic city at night with neon lights glowing on tall glass "
-        "skyscrapers and flying vehicles soaring between the buildings",
-    ]
-
-    refs = []
-    for i, prompt in enumerate(prompts):
-        rid = f"test_{i}_{uuid4().hex[:8]}"
-        ref = server.generate.remote(
-            prompt_ids=_tokenize_prompt(prompt),
-            sampling_params={
-                "num_inference_steps": 10,
-                "true_cfg_scale": 4.0,
-                "height": 512,
-                "width": 512,
-                "logprobs": i == 0,  # first request includes logprobs
-            },
-            request_id=rid,
-        )
-        refs.append(ref)
-
-    results = ray.get(refs, timeout=600)
-
-    for i, output in enumerate(results):
-        assert isinstance(output, DiffusionOutput), f"Request {i}: expected DiffusionOutput"
-        img = output.diffusion_output
-        assert isinstance(img, torch.Tensor) and img.ndim == 3, (
-            f"Request {i}: expected CHW torch.Tensor, got {type(img).__name__} ndim={getattr(img, 'ndim', None)}"
-        )
-        c, h, w = img.shape
-        assert c == 3, f"Request {i}: expected 3 channels (CHW), got {c}"
-        assert h > 0 and w > 0, f"Request {i}: image dimensions must be positive"
-        assert output.stop_reason in ("completed", "aborted", None), (
-            f"Request {i}: unexpected stop_reason {output.stop_reason!r}"
-        )
-        assert 0.0 <= float(img[0, 0, 0]) <= 1.0, f"Request {i}: pixel values must be in [0, 1]"
-
-    print(f"All {len(prompts)} concurrent requests returned valid DiffusionOutput")
diff --git a/tests/e2e/features/rlhf_test/test_verl_omni_e2e.py b/tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
new file mode 100644
index 000000000..dab5feef1
--- /dev/null
+++ b/tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
@@ -0,0 +1,217 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""E2E test that follows the EXACT same flow as
+``verl-omni/tests/workers/rollout/rollout_vllm/test_vllm_omni_generate.py``
+but inlines all the ``verl`` / ``verl_omni`` symbols the flow depends on
+(stripped down to only what the diffusion-mode test actually exercises).
+
+Flow (identical to the verl-omni test):
+
+1. Build two ``OmegaConf`` configs (``DiffusionRolloutConfig`` /
+   ``DiffusionModelConfig`` shape).
+2. ``ServerCls = ray.remote(vLLMOmniHttpServerLocal)`` then
+   ``ServerCls.options(...).remote(config=..., model_config=...,
+   rollout_mode=RolloutMode.STANDALONE, workers=[], replica_rank=0,
+   node_rank=0, gpus_per_node=1, nnodes=1, cuda_visible_devices="0")``.
+3. ``ray.get(server.launch_server.remote())``.
+4. ``server.generate.remote(prompt_ids=..., sampling_params=..., request_id=...)``
+   and assert the returned ``DiffusionOutput``.
+
+The Ray actor lives in ``tests.e2e.features.helpers.verl_omni_server`` so
+workers can import it after directory migration (pytest test modules are not
+importable as ``test_verl_omni_e2e`` in Ray child processes).
+
+Usage:
+    pytest tests/e2e/features/rlhf_test/test_verl_omni_e2e.py -v -s
+"""
+
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from uuid import uuid4
+
+import pytest
+import ray
+import torch
+from huggingface_hub import snapshot_download
+from omegaconf import OmegaConf
+from transformers import AutoTokenizer
+
+from tests.e2e.features.helpers.verl_omni_server import (
+    DiffusionOutput,
+    RolloutMode,
+    normalize_token_ids,
+    vLLMOmniHttpServerLocal,
+)
+from tests.helpers.mark import hardware_test
+
+MODEL = "tiny-random/Qwen-Image"
+TOKENIZER_MODEL = "Qwen/Qwen2-1.5B-Instruct"
+_MIN_PROMPT_TOKENS = 35
+
+
+def _resolve_model_path(repo_id: str) -> str:
+    if os.path.isdir(repo_id):
+        return repo_id
+    return snapshot_download(repo_id=repo_id)
+
+
+@lru_cache(maxsize=1)
+def _get_tokenizer():
+    return AutoTokenizer.from_pretrained(TOKENIZER_MODEL, trust_remote_code=True)
+
+
+def _tokenize_prompt(text: str) -> list[int]:
+    tokenizer = _get_tokenizer()
+    messages = [{"role": "user", "content": text}]
+    token_ids = normalize_token_ids(tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=False))
+    assert len(token_ids) > _MIN_PROMPT_TOKENS, (
+        f"Prompt too short ({len(token_ids)} tokens, need >{_MIN_PROMPT_TOKENS}). "
+        "The pipeline drops the first 34 chat-template prefix tokens; "
+        "use a longer prompt so content tokens remain after the drop."
+    )
+    return token_ids
+
+
+@pytest.fixture
+def init_server():
+    """Create and launch a vLLMOmniHttpServerLocal Ray actor with Qwen-Image."""
+    model_path = _resolve_model_path(MODEL)
+
+    ray.init(
+        runtime_env={
+            "env_vars": {
+                "TOKENIZERS_PARALLELISM": "true",
+                "NCCL_DEBUG": "WARN",
+                "VLLM_LOGGING_LEVEL": "INFO",
+            }
+        },
+        ignore_reinit_error=True,
+    )
+
+    rollout_cfg = OmegaConf.create(
+        {
+            "name": "vllm_omni",
+            "mode": "async",
+            "tensor_model_parallel_size": 1,
+            "data_parallel_size": 1,
+            "pipeline_model_parallel_size": 1,
+            "gpu_memory_utilization": 0.8,
+            "max_num_batched_tokens": 8192,
+            # QwenImagePipeline (and the logprob custom subclass) only supports
+            # serial request execution; max_num_seqs>1 enables request-level batching.
+            "max_num_seqs": 1,
+            "max_model_len": 1058,
+            "dtype": "bfloat16",
+            "load_format": "auto",
+            "enforce_eager": True,
+            "enable_chunked_prefill": False,
+            "enable_prefix_caching": False,
+            "enable_sleep_mode": False,
+            "free_cache_engine": True,
+            "disable_log_stats": True,
+            "logprobs_mode": "processed_logprobs",
+            "scheduling_policy": "fcfs",
+            "seed": 0,
+            "n": 4,
+            "pipeline": {
+                "height": 512,
+                "width": 512,
+                "num_inference_steps": 10,
+            },
+        }
+    )
+
+    model_cfg = OmegaConf.create(
+        {
+            "path": str(model_path),
+            "local_path": str(model_path),
+            "tokenizer_path": TOKENIZER_MODEL,
+            "trust_remote_code": True,
+            "load_tokenizer": True,
+        }
+    )
+
+    ServerCls = ray.remote(vLLMOmniHttpServerLocal)
+    server = ServerCls.options(
+        runtime_env={
+            "env_vars": {
+                "RAY_EXPERIMENTAL_NOSET_CUDA_VISIBLE_DEVICES": "1",
+                "RAY_EXPERIMENTAL_NOSET_ASCEND_RT_VISIBLE_DEVICES": "1",
+                "NCCL_CUMEM_ENABLE": "0",
+            }
+        },
+        max_concurrency=10,
+        num_gpus=1,
+    ).remote(
+        config=rollout_cfg,
+        model_config=model_cfg,
+        rollout_mode=RolloutMode.STANDALONE,
+        workers=[],
+        replica_rank=0,
+        node_rank=0,
+        gpus_per_node=1,
+        nnodes=1,
+        cuda_visible_devices="0",
+    )
+
+    ray.get(server.launch_server.remote())
+
+    yield server
+
+    ray.shutdown()
+
+
+@pytest.mark.core_model
+@pytest.mark.diffusion
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_generate(init_server):
+    """Concurrent generate() calls covering basic output, logprobs, and multi-request correctness."""
+    server = init_server
+
+    prompts = [
+        "a beautiful sunset over the ocean with vibrant orange and purple clouds "
+        "reflecting on the calm water surface near a rocky coastline",
+        "a fluffy orange cat sitting on a wooden windowsill looking outside at "
+        "a garden full of colorful flowers on a bright sunny afternoon",
+        "a majestic mountain landscape covered with fresh white snow under a "
+        "clear blue sky with pine trees in the foreground and a frozen lake",
+        "a futuristic city at night with neon lights glowing on tall glass "
+        "skyscrapers and flying vehicles soaring between the buildings",
+    ]
+
+    refs = []
+    for i, prompt in enumerate(prompts):
+        rid = f"test_{i}_{uuid4().hex[:8]}"
+        ref = server.generate.remote(
+            prompt_ids=_tokenize_prompt(prompt),
+            sampling_params={
+                "num_inference_steps": 10,
+                "true_cfg_scale": 4.0,
+                "height": 512,
+                "width": 512,
+                "logprobs": i == 0,
+            },
+            request_id=rid,
+        )
+        refs.append(ref)
+
+    results = ray.get(refs, timeout=600)
+
+    for i, output in enumerate(results):
+        assert isinstance(output, DiffusionOutput), f"Request {i}: expected DiffusionOutput"
+        img = output.diffusion_output
+        assert isinstance(img, torch.Tensor) and img.ndim == 3, (
+            f"Request {i}: expected CHW torch.Tensor, got {type(img).__name__} ndim={getattr(img, 'ndim', None)}"
+        )
+        c, h, w = img.shape
+        assert c == 3, f"Request {i}: expected 3 channels (CHW), got {c}"
+        assert h > 0 and w > 0, f"Request {i}: image dimensions must be positive"
+        assert output.stop_reason in ("completed", "aborted", None), (
+            f"Request {i}: unexpected stop_reason {output.stop_reason!r}"
+        )
+        assert 0.0 <= float(img[0, 0, 0]) <= 1.0, f"Request {i}: pixel values must be in [0, 1]"
+
+    print(f"All {len(prompts)} concurrent requests returned valid DiffusionOutput")
diff --git a/tests/e2e/offline_inference/custom_pipeline/__init__.py b/tests/e2e/offline_inference/custom_pipeline/__init__.py
deleted file mode 100644
index 99663a46a..000000000
--- a/tests/e2e/offline_inference/custom_pipeline/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from tests.e2e.offline_inference.custom_pipeline.qwen_image_pipeline_with_logprob import (
-    QwenImagePipelineWithLogProbForTest,
-)
-from tests.e2e.offline_inference.custom_pipeline.worker_extension import (
-    vLLMOmniColocateWorkerExtensionForTest,
-)
-
-__all__ = [
-    "QwenImagePipelineWithLogProbForTest",
-    "vLLMOmniColocateWorkerExtensionForTest",
-]
diff --git a/tests/e2e/offline_inference/custom_pipeline/flow_match_sde_scheduler.py b/tests/e2e/offline_inference/custom_pipeline/flow_match_sde_scheduler.py
deleted file mode 100644
index f85eb6602..000000000
--- a/tests/e2e/offline_inference/custom_pipeline/flow_match_sde_scheduler.py
+++ /dev/null
@@ -1,220 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from __future__ import annotations
-
-import math
-from dataclasses import dataclass
-from typing import Literal
-
-import torch
-from diffusers import FlowMatchEulerDiscreteScheduler
-from diffusers.utils import BaseOutput
-from diffusers.utils.torch_utils import randn_tensor
-
-
-@dataclass
-class FlowMatchSDEDiscreteSchedulerOutputForTest(BaseOutput):
-    """
-    Output class for the scheduler's `step` function output.
-
-    Args:
-        prev_sample (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_channels)` for images):
-            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
-            denoising loop.
-        log_prob (`torch.FloatTensor` of shape `(batch_size,)`, *optional*):
-            The log probability of the previous sample.
-        prev_sample_mean (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_channels)` for images):
-            The mean of the computed sample of previous timestep.
-        std_dev_t (`torch.FloatTensor` of shape `(batch_size, 1, 1)`):
-            The standard deviation used to compute `prev_sample`.
-    """
-
-    prev_sample: torch.FloatTensor
-    log_prob: torch.FloatTensor | None
-    prev_sample_mean: torch.FloatTensor
-    std_dev_t: torch.FloatTensor
-
-
-class FlowMatchSDEDiscreteSchedulerForTest(FlowMatchEulerDiscreteScheduler):
-    """SDE version of the FlowMatchEulerDiscreteScheduler.
-    The implementation is based on FlowGRPO paper (https://arxiv.org/abs/2505.05470)
-    and diffusers v0.37 branch.
-    """
-
-    def step(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: float | torch.FloatTensor,
-        sample: torch.FloatTensor,
-        s_churn: float = 0.0,
-        s_tmin: float = 0.0,
-        s_tmax: float = float("inf"),
-        s_noise: float = 1.0,
-        generator: torch.Generator | None = None,
-        per_token_timesteps: torch.Tensor | None = None,
-        return_dict: bool = True,
-        noise_level: float = 0.7,
-        prev_sample: torch.FloatTensor | None = None,
-        sde_type: Literal["sde", "cps"] = "sde",
-        return_logprobs: bool = True,
-    ) -> FlowMatchSDEDiscreteSchedulerOutputForTest | tuple:
-        """
-        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
-        process from the learned model outputs (most often the predicted noise).
-
-        Modified from https://github.com/yifan123/flow_grpo/blob/main/flow_grpo/diffusers_patch/sd3_sde_with_logprob.py
-
-        Args:
-            model_output (`torch.FloatTensor`):
-                The direct output from learned diffusion model.
-            timestep (`float`):
-                The current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                A current instance of a sample created by the diffusion process.
-            s_churn (`float`):
-            s_tmin  (`float`):
-            s_tmax  (`float`):
-            s_noise (`float`, defaults to 1.0):
-                Scaling factor for noise added to the sample.
-            generator (`torch.Generator`, *optional*):
-                A random number generator.
-            per_token_timesteps (`torch.Tensor`, *optional*):
-                The timesteps for each token in the sample.
-            return_dict (`bool`):
-                Whether or not to return a
-                [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchSDEDiscreteSchedulerOutput`] or tuple.
-            noise_level (`float`, *optional*, defaults to 0.7):
-                The noise level used in the SDE.
-            prev_sample (`torch.FloatTensor`, *optional*):
-                The sample from the previous timestep. If not provided, it will be sampled inside the function.
-            sde_type (`str`, *optional*, defaults to "sde"):
-                The type of SDE to use. Choose between "sde" and "cps".
-            return_logprobs (`bool`, *optional*, defaults to True):
-                Whether to return log probabilities of the previous sample.
-        """
-
-        if isinstance(timestep, (int, torch.IntTensor, torch.LongTensor)):
-            raise ValueError(
-                (
-                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
-                    " `FlowMatchEulerDiscreteScheduler.step()` is not supported. Make sure to pass"
-                    " one of the `scheduler.timesteps` as a timestep."
-                ),
-            )
-
-        if self.step_index is None:
-            self._init_step_index(timestep)
-
-        # Upcast to avoid precision issues when computing prev_sample
-        sample = sample.to(torch.float32)
-        if prev_sample is not None:
-            prev_sample = prev_sample.to(torch.float32)
-
-        prev_sample, log_prob, prev_sample_mean, std_dev_t = self.sample_previous_step(
-            sample=sample,
-            model_output=model_output,
-            generator=generator,
-            per_token_timesteps=per_token_timesteps,
-            noise_level=noise_level,
-            prev_sample=prev_sample,
-            sde_type=sde_type,
-            return_logprobs=return_logprobs,
-        )
-
-        # upon completion increase step index by one
-        self._step_index += 1
-        if per_token_timesteps is None:
-            # Cast sample back to model compatible dtype
-            prev_sample = prev_sample.to(model_output.dtype)
-
-        if not return_dict:
-            return (prev_sample, log_prob, prev_sample_mean, std_dev_t)
-
-        return FlowMatchSDEDiscreteSchedulerOutputForTest(
-            prev_sample=prev_sample, log_prob=log_prob, prev_sample_mean=prev_sample_mean, std_dev_t=std_dev_t
-        )
-
-    def sample_previous_step(
-        self,
-        sample: torch.Tensor,
-        model_output: torch.Tensor,
-        timestep: torch.FloatTensor | None = None,
-        generator: torch.Generator | None = None,
-        per_token_timesteps: torch.Tensor | None = None,
-        noise_level: float = 0.7,
-        prev_sample: torch.Tensor | None = None,
-        sde_type: Literal["cps", "sde"] = "sde",
-        return_logprobs: bool = True,
-    ):
-        assert sde_type in ["sde", "cps"]
-        assert sample.dtype == torch.float32
-        if prev_sample is not None:
-            assert prev_sample.dtype == torch.float32
-
-        if per_token_timesteps is not None:
-            raise NotImplementedError("per_token_timesteps is not supported yet for FlowMatchSDEDiscreteScheduler.")
-        else:
-            if timestep is None:
-                sigma_idx = self.step_index
-                sigma = self.sigmas[sigma_idx]
-                sigma_prev = self.sigmas[sigma_idx + 1]
-            else:
-                sigma_idx = torch.tensor([self.index_for_timestep(t) for t in timestep])
-                sigma = self.sigmas[sigma_idx].view(-1, *([1] * (len(sample.shape) - 1)))
-                sigma_prev = self.sigmas[sigma_idx + 1].view(-1, *([1] * (len(sample.shape) - 1)))
-
-            sigma_max = self.sigmas[1]
-            dt = sigma_prev - sigma
-
-        if sde_type == "sde":
-            std_dev_t = torch.sqrt(sigma / (1 - torch.where(sigma == 1, sigma_max, sigma))) * noise_level
-
-            prev_sample_mean = (
-                sample * (1 + std_dev_t**2 / (2 * sigma) * dt)
-                + model_output * (1 + std_dev_t**2 * (1 - sigma) / (2 * sigma)) * dt
-            )
-
-            if prev_sample is None:
-                variance_noise = randn_tensor(
-                    model_output.shape,
-                    generator=generator,
-                    device=model_output.device,
-                    dtype=model_output.dtype,
-                )
-                prev_sample = prev_sample_mean + std_dev_t * torch.sqrt(-1 * dt) * variance_noise
-
-            if return_logprobs:
-                log_prob = (
-                    -((prev_sample.detach() - prev_sample_mean) ** 2) / (2 * ((std_dev_t * torch.sqrt(-1 * dt)) ** 2))
-                    - torch.log(std_dev_t * torch.sqrt(-1 * dt))
-                    - torch.log(torch.sqrt(2 * torch.as_tensor(math.pi)))
-                )
-            else:
-                log_prob = None
-
-        elif sde_type == "cps":
-            std_dev_t = sigma_prev * math.sin(noise_level * math.pi / 2)
-            pred_original_sample = sample - sigma * model_output
-            noise_estimate = sample + model_output * (1 - sigma)
-            prev_sample_mean = pred_original_sample * (1 - sigma_prev) + noise_estimate * torch.sqrt(
-                sigma_prev**2 - std_dev_t**2
-            )
-
-            if prev_sample is None:
-                variance_noise = randn_tensor(
-                    model_output.shape,
-                    generator=generator,
-                    device=model_output.device,
-                    dtype=model_output.dtype,
-                )
-                prev_sample = prev_sample_mean + std_dev_t * variance_noise
-
-            if return_logprobs:
-                log_prob = -((prev_sample.detach() - prev_sample_mean) ** 2)
-            else:
-                log_prob = None
-
-        # mean along all but batch dimension
-        log_prob = log_prob.mean(dim=tuple(range(1, log_prob.ndim))) if log_prob is not None else None
-        return prev_sample, log_prob, prev_sample_mean, std_dev_t
diff --git a/tests/e2e/offline_inference/custom_pipeline/worker_extension.py b/tests/e2e/offline_inference/custom_pipeline/worker_extension.py
deleted file mode 100644
index 6ed29d5a8..000000000
--- a/tests/e2e/offline_inference/custom_pipeline/worker_extension.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""Test worker extension that mirrors
-``verl_omni.workers.rollout.vllm_rollout.utils.vLLMOmniColocateWorkerExtension``
-
-Fidelity goals:
-
-* ``__new__`` calls ``set_death_signal()`` (Linux ``PR_SET_PDEATHSIG``) so
-  spawned vLLM workers die with the parent.
-* ``__new__`` calls ``VLLMOmniHijackForTest.hijack()`` which monkey-patches
-  ``vllm_omni.diffusion.lora.manager.DiffusionLoRAManager._load_adapter``
-  to accept in-memory LoRA tensors (verbatim port of
-  ``verl_omni.utils.vllm_omni.utils.VLLMOmniHijack.hijack``).
-
-The ``verl.utils.vllm.VLLMHijack.hijack()`` call (which patches vLLM's
-``LRUCacheWorkerLoRAManager._load_adapter`` for AR/text mode) is
-intentionally skipped because (a) ``verl`` is not importable from this
-repo and (b) the diffusion test path never reaches that manager.
-"""
-
-from __future__ import annotations
-
-import ctypes
-import logging
-import os
-import platform
-import signal
-
-from msgspec import field
-
-from vllm_omni.diffusion.worker.diffusion_worker import CustomPipelineWorkerExtension
-from vllm_omni.lora.request import LoRARequest as OmniLoRARequest
-
-logger = logging.getLogger(__name__)
-
-
-class OmniTensorLoRARequestForTest(OmniLoRARequest):
-    peft_config: dict = field(default=None)
-    lora_tensors: dict = field(default=None)
-
-
-def set_death_signal() -> None:
-    """Verbatim port of ``verl.workers.rollout.vllm_rollout.utils.set_death_signal``."""
-    if platform.system() != "Linux":
-        return
-    try:
-        libc = ctypes.CDLL("libc.so.6")
-        libc.prctl(1, signal.SIGKILL)
-        if os.getppid() == 1:
-            os.kill(os.getpid(), signal.SIGKILL)
-    except Exception:  # noqa: BLE001
-        # libc.so.6 may not be present (musl, alpine) — best-effort only.
-        pass
-
-
-# ---------------------------------------------------------------------
-#  The worker extension itself
-# ---------------------------------------------------------------------
-
-
-class vLLMOmniColocateWorkerExtensionForTest(CustomPipelineWorkerExtension):
-    """Mirror of ``vLLMOmniColocateWorkerExtension`` (verl-omni).
-
-    The production ``__new__`` runs ``set_death_signal`` + ``VLLMOmniHijack.hijack``
-    on every vLLM worker process. Replicating both ensures this test
-    reproduces the same monkey-patched environment.
-    """
-
-    def __new__(cls, **kwargs):
-        set_death_signal()
-        return super().__new__(cls)
-
-    @staticmethod
-    def test_extension_name() -> str:
-        """Return a stable identifier for assertions in unit tests."""
-        return "vllm-omni-colocate-worker-extension-for-test"
diff --git a/tests/e2e/offline_inference/stage_configs/step_audio2_ci.yaml b/tests/e2e/offline_inference/stage_configs/step_audio2_ci.yaml
deleted file mode 100644
index f9dd4f9af..000000000
--- a/tests/e2e/offline_inference/stage_configs/step_audio2_ci.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-# Stage config for Step-Audio2 CI tests
-# Single Thinker stage (audio/text understanding → text). ASR/text-output
-# tests don't need Token2Wav; a two-stage config would deadlock on stage-1 skip.
-
-# The following config has been verified on 2x 24GB GPU (L4/RTX3090/RTX4090).
-stage_args:
-  - stage_id: 0
-    runtime:
-      process: true
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      model_stage: thinker
-      model_arch: StepAudio2ThinkerForConditionalGeneration
-      tensor_parallel_size: 1
-      worker_cls: vllm_omni.worker.gpu_ar_worker.GPUARWorker
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      max_model_len: 4096
-      max_num_batched_tokens: 4096
-      max_num_seqs: 1
-      gpu_memory_utilization: 0.8
-      skip_mm_profiling: true
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      engine_output_type: text  # Output text + audio tokens
-    is_comprehension: true
-    final_output: true
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.7
-      top_p: 0.9
-      top_k: -1
-      max_tokens: 256
-      seed: 42
-      detokenize: true
-      repetition_penalty: 1.05
diff --git a/tests/e2e/offline_inference/test_audex_s2s.py b/tests/e2e/offline_inference/test_audex_s2s.py
new file mode 100644
index 000000000..d24412f79
--- /dev/null
+++ b/tests/e2e/offline_inference/test_audex_s2s.py
@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline E2E test for the Audex cascaded speech-to-speech pipeline.
+
+One ``audex_s2s`` deployment serves all three official
+passes. The routing contract is the hard gate here: text-modality passes
+(ASR, chat) finish at stage 0 and must never produce stage-1 audio; the
+audio-modality TTS pass streams through the causal speech decoder.
+"""
+
+from __future__ import annotations
+
+import copy
+import os
+import re
+import time
+
+import numpy as np
+import pytest
+from vllm.assets.audio import AudioAsset
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import concat_audio
+from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+MODEL_DIR_ENV = "VLLM_OMNI_AUDEX_MODEL_DIR"
+SAMPLE_RATE = 16_000
+
+ASR_PROMPT = (
+    "<|im_start|>user\n<so_embedding>\nTranscribe the input speech.<|im_end|>\n<|im_start|>assistant\n<think></think>"
+)
+
+# Official chat-pass recipe (examples/offline_inference/audex/speech_to_speech.py,
+# mirroring the official cascaded web demo) — 30B-A3B ONLY. The
+# formatting-instruction prefix is load-bearing on the 30B-A3B: without it a bare
+# transcript turn is treated as a TTS request and the model emits literal
+# <speechcodec_N> tokens instead of text, and under the yaml's near-greedy
+# defaults its reasoning block never closes. The 2B must NOT use this recipe:
+# it is long-verified stable on a bare prompt + engine-default sampling, while
+# the official temp-1.0 seed-0 draw hallucinates off-language text (yet closes
+# </think> cleanly, so the seed retry never fires) and fails the round-trip
+# WER gate — measured, reproduced byte-identically.
+SYSTEM_PROMPT = "You are a helpful and harmless assistant.\n\nYou are not allowed to use any tools."
+TEXT_INSTRUCTION = (
+    "SYSTEM & FORMATTING INSTRUCTION: You are Audex, created by NVIDIA based on the Nemotron-Cascade-2 architecture. "
+    "You may output your reasoning, followed by your final response. "
+    "You may format your reasoning block however you like. "
+    "However, your final response must strictly follow these rules: "
+    "* Write in plain, unformatted prose like a book or newspaper article. "
+    "* Do not use markdown, bullet points, lists, or headers. "
+    "* Standard numbers, abbreviations, and symbols are acceptable. "
+    "* [CRITICAL] You must press enter after every single sentence, placing each sentence on its own separate line."
+)
+CHAT_MAX_TOKENS = 2048  # official --text-max-tokens default
+# The official demo samples this pass unseeded; some trajectories deliberate
+# past the token budget without ever closing the think block, so retry a few
+# deterministic seeds until one closes.
+CHAT_SEEDS = (0, 1, 2)
+
+_audex_deployment = get_deploy_config_path("audex_s2s.yaml")
+_audex_model = os.environ.get(MODEL_DIR_ENV) or MODEL
+_OMNI_RUNNER_PARAMS = [
+    pytest.param(
+        (_audex_model, _audex_deployment, {"async_chunk": True}),
+        id="s2s_full",
+    ),
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    _OMNI_RUNNER_PARAMS.append(
+        pytest.param(
+            (_AUDEX_30B_MODEL, get_deploy_config_path("audex_s2s_30b.yaml"), {"async_chunk": True}),
+            id="s2s_30b",
+        )
+    )
+pytestmark = [
+    pytest.mark.slow,
+    pytest.mark.tts,
+    pytest.mark.parametrize("omni_runner", _OMNI_RUNNER_PARAMS, indirect=True),
+]
+
+
+def _normalize(text: str) -> list[str]:
+    return "".join(c.lower() if c.isalnum() or c.isspace() else " " for c in text).split()
+
+
+def _wer(hyp: str, ref: str) -> float:
+    hyp_words, ref_words = _normalize(hyp), _normalize(ref)
+    if not ref_words:
+        return 0.0
+    rows = list(range(len(hyp_words) + 1))
+    for i, ref_word in enumerate(ref_words, 1):
+        prev, rows[0] = rows[0], i
+        for j, hyp_word in enumerate(hyp_words, 1):
+            cur = min(rows[j] + 1, rows[j - 1] + 1, prev + (ref_word != hyp_word))
+            prev, rows[j] = rows[j], cur
+    return rows[-1] / len(ref_words)
+
+
+def _chat_prompt(user_text: str) -> str:
+    # Official chat-pass recipe: system prompt + formatting instruction
+    # prefixed to the user text, thinking ENABLED via an open <think> block
+    # (chat_template.jinja with enable_thinking=True renders
+    # "<|im_start|>assistant\n<think>\n"). Priming the block open keeps the
+    # reasoning inside <think>...</think> so _extract_final_response can drop
+    # it; with a closed block the 30B leaks the reasoning as plain text.
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n{TEXT_INSTRUCTION}\n\n{user_text}<|im_end|>\n"
+        "<|im_start|>assistant\n<think>\n"
+    )
+
+
+def _extract_final_response(text: str) -> str:
+    # Mirror the official demo's extract_spoken_answer: keep only what
+    # follows the LAST closing think tag, falling back to the full text when
+    # the model skipped reasoning or never closed the block. Benign no-op for
+    # the 2B, whose answers carry no think block.
+    if "</think>" in text:
+        answer = text.rsplit("</think>", 1)[-1].strip()
+        if answer:
+            return answer
+    return text.strip()
+
+
+def _chat_params(runner: OmniRunner, seed: int):
+    # Official demo text-pass sampling (--text-temperature 1.0, --text-top-p
+    # 0.95, --text-max-tokens 2048). The yaml stage-0 defaults (temperature
+    # 0.1, top_k 80) are TTS-thinker settings; under near-greedy decoding the
+    # 30B loops inside its reasoning block until the token budget runs out
+    # and never emits </think>.
+    params = copy.deepcopy(runner.omni.resolve_sampling_params_list(None))
+    stage0 = params[0]
+    stage0.temperature = 1.0
+    stage0.top_p = 0.95
+    stage0.top_k = -1
+    stage0.max_tokens = CHAT_MAX_TOKENS
+    stage0.seed = seed
+    return params
+
+
+def _chat_once(runner: OmniRunner, prompt: str, seed: int) -> tuple[str, bool]:
+    (req_output,) = runner.omni.generate([{"prompt": prompt, "modalities": ["text"]}], _chat_params(runner, seed))
+    out = req_output.outputs[0]
+    text = (out.text or "").strip()
+    truncated = getattr(out, "finish_reason", None) == "length" or len(out.token_ids or []) >= CHAT_MAX_TOKENS
+    return text, truncated
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+def test_audex_s2s_cascade_round_trip(omni_runner: OmniRunner, run_level: str) -> None:
+    """ASR → chat → TTS over one deployment; text passes never emit audio."""
+    real_weights = run_level in {"advanced_model", "full_model"}
+    # Spoken question: vLLM's public audio asset (downloaded on first use).
+    audio, sr = AudioAsset("mary_had_lamb").audio_and_sample_rate
+
+    # Pass 1 — ASR (text-final).
+    asr_outputs = omni_runner.omni.generate(
+        [
+            {
+                "prompt": ASR_PROMPT,
+                "multi_modal_data": {"audio": (audio, sr)},
+                "modalities": ["text"],
+            }
+        ]
+    )
+    assert len(asr_outputs) == 1
+    asr_out = asr_outputs[0]
+    transcript = (asr_out.outputs[0].text or "").strip()
+    mm = getattr(asr_out, "multimodal_output", None) or {}
+    stage1_audio = concat_audio(mm.get("audio")) if "audio" in mm else np.zeros((0,), dtype=np.float32)
+    assert stage1_audio.size == 0, "Text-modality ASR pass produced stage-1 audio (routing regression)"
+
+    # Pass 2 — chat (text-final). The recipe is size-conditional (see the
+    # SYSTEM_PROMPT comment above): the 30B requires the official recipe,
+    # the 2B regresses under it.
+    if omni_runner.model_name == _AUDEX_30B_MODEL:
+        # Official recipe. The raw completion is
+        # <reasoning...></think><answer>; speak only the final response.
+        # Retry with the next seed only when the budget ran out before the
+        # reasoning block closed (a natural stop without </think> is a
+        # complete answer); if every seed spins, keep the full text
+        # (official demo behavior).
+        chat_prompt = _chat_prompt(transcript or "Hello.")
+        raw = ""
+        for seed in CHAT_SEEDS:
+            raw, truncated = _chat_once(omni_runner, chat_prompt, seed)
+            if "</think>" in raw or not truncated:
+                break
+        answer = _extract_final_response(raw)
+    else:
+        # 2B: bare prompt with a closed think block, engine-default sampling
+        # (yaml near-greedy), no retry; the answer is used as-is.
+        chat_prompt = f"<|im_start|>user\n{transcript or 'Hello.'}<|im_end|>\n<|im_start|>assistant\n<think></think>"
+        (chat_output,) = omni_runner.omni.generate([{"prompt": chat_prompt, "modalities": ["text"]}])
+        answer = (chat_output.outputs[0].text or "").strip()
+
+    if real_weights:
+        assert transcript, "ASR pass produced an empty transcript"
+        assert answer, "Chat pass produced an empty answer"
+
+    # Pass 3 — TTS (audio-final; streams through code2wav). Both final
+    # stages may emit an output record; collect the audio-bearing one.
+    # The formatting instruction puts every sentence on its own line;
+    # flatten to plain prose for the TTS thinker.
+    tts_text = re.sub(r"\s+", " ", answer).strip() if answer else "The weather is nice today."
+    tts_text = tts_text[:200]
+    tts_prompt = {"prompt": build_cond_prompt(tts_text), "modalities": ["audio"]}
+    tts_outputs = omni_runner.omni.generate([tts_prompt])
+    assert tts_outputs, "TTS pass returned no outputs"
+    speech = np.zeros((0,), dtype=np.float32)
+    for req_output in tts_outputs:
+        mm = getattr(req_output, "multimodal_output", None) or {}
+        if "audio" in mm:
+            speech = concat_audio(mm["audio"])
+            break
+    assert speech.size > 0, "TTS pass produced empty audio"
+
+    if real_weights:
+        rms = float(np.sqrt(np.mean(np.square(speech))))
+        assert rms > 1e-3, f"TTS-pass audio near-silent (rms={rms})"
+
+        # Pass 4 — output verification: transcribe the synthesized answer
+        # with the SAME deployment's ASR pass and compare to the answer
+        # text (self-contained; no external ASR dependency).
+        verify_outputs = omni_runner.omni.generate(
+            [
+                {
+                    "prompt": ASR_PROMPT,
+                    "multi_modal_data": {"audio": (speech, SAMPLE_RATE)},
+                    "modalities": ["text"],
+                }
+            ]
+        )
+        verify_text = (verify_outputs[0].outputs[0].text or "").strip()
+        assert verify_text, "Output-verification ASR pass returned empty text"
+        # The full checkpoint prefixes transcripts with a language-tag
+        # sentence and quotes the content; extract the quoted payload.
+        if "'" in verify_text and len(verify_text.split("'")) >= 3:
+            verify_text = verify_text.split("'")[1].strip()
+        wer = _wer(verify_text, tts_text)
+        # Hard gate: the synthesized WAV must transcribe back to the answer
+        # (lenient threshold absorbs ASR quoting/prefix differences).
+        assert wer <= 0.5, f"Output WAV does not match the answer (WER={wer:.2f}): {verify_text!r} vs {tts_text!r}"
+        print(f"[trend] Audex S2S output-ASR WER vs answer: {wer:.3f} ({verify_text!r})")
+
+    # Final pass — time-to-first-audio for the streaming TTS path. This
+    # MUST be the last engine call: the py_generator API closes the engine
+    # when the generator is exhausted.
+    t_start = time.perf_counter()
+    first_audio_s: float | None = None
+    for req_output in omni_runner.omni.generate([tts_prompt], py_generator=True):
+        mm = getattr(req_output, "multimodal_output", None) or {}
+        if "audio" in mm and concat_audio(mm["audio"]).size > 0:
+            if first_audio_s is None:
+                first_audio_s = time.perf_counter() - t_start
+    assert first_audio_s is not None, "streaming TTS never produced an audio-bearing chunk"
+    print(f"[trend] Audex S2S TTS-pass first-audio latency: {first_audio_s * 1000.0:.0f} ms")
diff --git a/tests/e2e/offline_inference/test_audex_s2t.py b/tests/e2e/offline_inference/test_audex_s2t.py
new file mode 100644
index 000000000..230ab6e02
--- /dev/null
+++ b/tests/e2e/offline_inference/test_audex_s2t.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline E2E smoke test for Audex audio understanding (thinker-only).
+
+Single-stage ``audex_thinker_only`` pipeline on
+``checkpoint_folder_full``: WAV (+ instruction) in, text out. The input clip
+is vLLM's public ``mary_had_lamb`` audio asset (downloaded on first use), so
+its transcript is known.
+
+WER is a trend metric (recorded in the assertion message, no numeric hard
+gate); the hard gates are structural: non-empty, non-degenerate text.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+from vllm.assets.audio import AudioAsset
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+MODEL_DIR_ENV = "VLLM_OMNI_AUDEX_MODEL_DIR"
+
+# Full transcript of the mary_had_lamb asset (Edison's phonograph recording);
+# a shortened reference would count the extra spoken words as insertions and
+# inflate WER past the trend threshold.
+_REFERENCE = (
+    "the first words i spoke in the original phonograph a little piece of practical poetry "
+    "mary had a little lamb its fleece was white as snow and everywhere that mary went the "
+    "lamb was sure to go"
+)
+
+ASR_PROMPT = (
+    "<|im_start|>user\n<so_embedding>\nTranscribe the input speech.<|im_end|>\n<|im_start|>assistant\n<think></think>"
+)
+
+_audex_deployment = get_deploy_config_path("audex_thinker_only.yaml")
+_audex_model = os.environ.get(MODEL_DIR_ENV) or MODEL
+_OMNI_RUNNER_PARAMS = [
+    pytest.param(
+        (_audex_model, _audex_deployment, {"async_chunk": False}),
+        id="thinker_only",
+    ),
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    _OMNI_RUNNER_PARAMS.append(
+        pytest.param(
+            (_AUDEX_30B_MODEL, get_deploy_config_path("audex_thinker_only_30b.yaml"), {"async_chunk": False}),
+            id="thinker_only_30b",
+        )
+    )
+pytestmark = [
+    pytest.mark.slow,
+    pytest.mark.tts,
+    pytest.mark.parametrize("omni_runner", _OMNI_RUNNER_PARAMS, indirect=True),
+]
+
+
+def _normalize(text: str) -> list[str]:
+    return "".join(c.lower() if c.isalnum() or c.isspace() else " " for c in text).split()
+
+
+def _wer(hyp: str, ref: str) -> float:
+    hyp_words, ref_words = _normalize(hyp), _normalize(ref)
+    if not ref_words:
+        return 0.0
+    rows = list(range(len(hyp_words) + 1))
+    for i, ref_word in enumerate(ref_words, 1):
+        prev, rows[0] = rows[0], i
+        for j, hyp_word in enumerate(hyp_words, 1):
+            cur = min(
+                rows[j] + 1,
+                rows[j - 1] + 1,
+                prev + (ref_word != hyp_word),
+            )
+            prev, rows[j] = rows[j], cur
+    return rows[-1] / len(ref_words)
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_audex_offline_asr_smoke(omni_runner: OmniRunner, run_level: str) -> None:
+    """Transcribing the public audio asset yields coherent, non-degenerate text."""
+    audio, sr = AudioAsset("mary_had_lamb").audio_and_sample_rate
+    outputs = omni_runner.omni.generate([{"prompt": ASR_PROMPT, "multi_modal_data": {"audio": (audio, sr)}}])
+
+    assert len(outputs) == 1
+    text = outputs[0].outputs[0].text if outputs[0].outputs else ""
+    assert isinstance(text, str)
+
+    if run_level in {"advanced_model", "full_model"}:
+        words = _normalize(text)
+        assert words, f"Empty transcription: {text!r}"
+        # Degenerate repetition guard: no word may dominate the output.
+        most_common = max(words.count(w) for w in set(words))
+        assert most_common <= max(3, len(words) // 2), f"Degenerate transcript: {text!r}"
+        wer = _wer(text, _REFERENCE)
+        # Trend metric (recorded, not gated): substantially-correct check only.
+        assert wer <= 0.9, f"Transcript unrelated to reference (WER={wer:.2f}): {text!r}"
+        print(f"[trend] Audex S2T WER vs reference: {wer:.3f} ({text!r})")
diff --git a/tests/e2e/offline_inference/test_audex_tta.py b/tests/e2e/offline_inference/test_audex_tta.py
new file mode 100644
index 000000000..d23c9c36b
--- /dev/null
+++ b/tests/e2e/offline_inference/test_audex_tta.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline E2E smoke test for Audex text-to-audio (TTA).
+
+Caption → RVQ-phase-masked <audiocodec_*> tokens → XCodec1 waveform through
+the ``audex_tta`` pipeline. RVQ phase validity is enforced by
+the mask logits processor (unit-tested against the official validator); the
+hard gates here are decode-side: non-silent, finite audio at the documented
+sample rate. CFG runs at the official TTA default (3.0).
+"""
+
+from __future__ import annotations
+
+import copy
+import os
+
+import numpy as np
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import concat_audio
+from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.model_executor.models.audex.prompt import build_tta_cond_prompt
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+MODEL_DIR_ENV = "VLLM_OMNI_AUDEX_MODEL_DIR"
+SAMPLE_RATE = 16_000
+
+# The acceptance gate requires eight captions decoding to non-silent,
+# finite audio through XCodec1.
+CAPTIONS = (
+    "Heavy rain falling on a tin roof.",
+    "A dog barking in the distance while birds chirp.",
+    "Ocean waves crashing on a rocky shore.",
+    "A crackling campfire at night with crickets.",
+    "Thunder rumbling during a storm.",
+    "A steam train whistle blowing as it departs.",
+    "Wind chimes ringing in a gentle breeze.",
+    "Footsteps crunching through fresh snow.",
+)
+
+_audex_deployment = get_deploy_config_path("audex_tta.yaml")
+_audex_model = os.environ.get(MODEL_DIR_ENV) or MODEL
+_OMNI_RUNNER_PARAMS = [
+    pytest.param(
+        (_audex_model, _audex_deployment, {"async_chunk": False}),
+        id="tta_full_payload",
+    ),
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    _OMNI_RUNNER_PARAMS.append(
+        pytest.param(
+            (_AUDEX_30B_MODEL, get_deploy_config_path("audex_tta_30b.yaml"), {"async_chunk": False}),
+            id="tta_30b",
+        )
+    )
+pytestmark = [
+    pytest.mark.slow,
+    pytest.mark.tts,
+    pytest.mark.parametrize("omni_runner", _OMNI_RUNNER_PARAMS, indirect=True),
+]
+
+
+@pytest.fixture(scope="module")
+def tta_tokenizer_bits():
+    from transformers import AutoTokenizer
+
+    from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
+    from vllm_omni.model_executor.models.audex.tta import build_tta_phase_token_ids
+
+    root = ensure_audex_snapshot(_audex_model, profile="tta")
+    tokenizer = AutoTokenizer.from_pretrained(os.path.join(root, "checkpoint_folder_audiogen"), trust_remote_code=True)
+    phase_token_ids, start_tid, end_tid = build_tta_phase_token_ids(tokenizer)
+    return tokenizer, phase_token_ids, start_tid, end_tid
+
+
+def _tta_sampling_params(runner: OmniRunner, cond_prompt: str, tokenizer_bits, cfg_scale: float = 3.0):
+    from vllm_omni.model_executor.models.audex.prompt import build_tta_null_prompt
+
+    tokenizer, phase_token_ids, start_tid, end_tid = tokenizer_bits
+    params = copy.deepcopy(runner.omni.resolve_sampling_params_list(None))
+    stage0 = params[0]
+    if stage0.extra_args is None:
+        stage0.extra_args = {}
+    stage0.extra_args["tta_rvq"] = {
+        "phase_token_ids": phase_token_ids,
+        "start_tid": start_tid,
+        "end_tid": end_tid,
+        "codec_cap": 4000,
+        "start_in_prompt": True,
+    }
+    if cfg_scale > 1.0:
+        stage0.extra_args.update(
+            {
+                "cfg_scale": float(cfg_scale),
+                "cfg_role": "cond",
+                "cfg_pair_id": f"e2e-tta-{abs(hash(cond_prompt)) % 10_000_000}",
+                "cfg_null_prompt": build_tta_null_prompt(cond_prompt, tokenizer),
+            }
+        )
+    return params
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_audex_offline_tta_eight_captions(omni_runner: OmniRunner, run_level: str, tta_tokenizer_bits) -> None:
+    """All eight captions decode through XCodec1 to non-silent, finite audio.
+
+    RVQ phase validity is enforced by the mask logits processor by
+    construction; the final user output carries only decoded audio (the
+    audio-final pipeline emits no stage-0 token record), and disabling the
+    mask in-engine as an e2e control would require a second engine boot
+    with a different logits-processor config. The mask's sensitivity is
+    therefore proven at unit level (see test_audex_tta.py's mask tests and
+    the unmasked-sampling control) against the official validator.
+    """
+    real_weights = run_level in {"advanced_model", "full_model"}
+    for caption in CAPTIONS:
+        prompt = build_tta_cond_prompt(caption)
+        params = _tta_sampling_params(omni_runner, prompt, tta_tokenizer_bits)
+        outputs = omni_runner.omni.generate([prompt], params)
+
+        assert len(outputs) == 1, f"{caption!r}: expected one output, got {len(outputs)}"
+        audio_mm = outputs[0].multimodal_output
+        assert "audio" in audio_mm, f"{caption!r}: no audio output: {list(audio_mm.keys())}"
+        audio = concat_audio(audio_mm["audio"])
+        assert audio.size > 0, f"{caption!r}: generated audio is empty"
+        assert np.isfinite(audio).all(), f"{caption!r}: audio contains NaN/Inf"
+
+        sr_val = audio_mm.get("sr", SAMPLE_RATE)
+        if isinstance(sr_val, list) and sr_val:
+            sr_val = sr_val[-1]
+        if hasattr(sr_val, "item"):
+            sr_val = sr_val.item()
+        assert int(sr_val) == SAMPLE_RATE, f"{caption!r}: unexpected sample_rate={sr_val}"
+
+        if real_weights:
+            duration_s = audio.size / SAMPLE_RATE
+            # The decode cap is 500 frames = 10 s at 50 fps.
+            assert 0.1 <= duration_s <= 10.5, f"{caption!r}: unexpected duration={duration_s:.3f}s"
+            rms = float(np.sqrt(np.mean(np.square(audio))))
+            assert rms > 1e-4, f"{caption!r}: audio is near-silent (rms={rms})"
diff --git a/tests/e2e/offline_inference/test_audex_tts.py b/tests/e2e/offline_inference/test_audex_tts.py
new file mode 100644
index 000000000..e186c22d1
--- /dev/null
+++ b/tests/e2e/offline_inference/test_audex_tts.py
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline E2E smoke test for Audex (Nemotron-Labs-Audex-2B) TTS.
+
+Passes the HF repo ROOT and verifies the 2-stage pipeline (thinker →
+streaming causal speech decoder): root-path/subfolder resolution, codec-token
+extraction, per-request streaming sessions, and the lookahead flush at EOS.
+"""
+
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import concat_audio
+from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+MODEL_DIR_ENV = "VLLM_OMNI_AUDEX_MODEL_DIR"
+SAMPLE_RATE = 16_000
+
+SYNTH_TEXTS = (
+    "The weather is so good, and I want to enjoy the beautiful morning in the park.",
+    "The quick brown fox jumps over the lazy dog.",
+)
+
+
+_audex_deployment = get_deploy_config_path("audex_tts.yaml")
+# Collection must not download anything: pass the repo id (or a local
+# override) and let the engine's stage-init path resolve/download the
+# required snapshot subset at execution time (ensure_audex_snapshot).
+_audex_model = os.environ.get(MODEL_DIR_ENV) or MODEL
+_OMNI_RUNNER_PARAMS = [
+    pytest.param(
+        (_audex_model, _audex_deployment, {"async_chunk": True}),
+        id="async_chunk",
+    ),
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    _OMNI_RUNNER_PARAMS.append(
+        pytest.param(
+            (_AUDEX_30B_MODEL, get_deploy_config_path("audex_tts_30b.yaml"), {"async_chunk": True}),
+            id="tts_30b",
+        )
+    )
+pytestmark = [
+    pytest.mark.slow,
+    pytest.mark.tts,
+    pytest.mark.parametrize("omni_runner", _OMNI_RUNNER_PARAMS, indirect=True),
+]
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_audex_offline_tts_smoke(omni_runner: OmniRunner, run_level: str) -> None:
+    """Audex TTS from the repo root should produce sane 16 kHz audio per prompt.
+
+    At ``core_model`` level the runner loads DUMMY weights (structural smoke
+    only); real-speech assertions apply from ``advanced_model`` up.
+    """
+    prompts = [build_cond_prompt(text) for text in SYNTH_TEXTS]
+    outputs = omni_runner.omni.generate(prompts)
+
+    real_weights = run_level in {"advanced_model", "full_model"}
+    assert len(outputs) == len(SYNTH_TEXTS), f"expected {len(SYNTH_TEXTS)} outputs, got {len(outputs)}"
+    for output in outputs:
+        audio_mm = output.multimodal_output
+        assert "audio" in audio_mm, f"No audio output found: {list(audio_mm.keys())}"
+        audio = concat_audio(audio_mm["audio"])
+        assert audio.size > 0, "Generated audio is empty"
+
+        sr_val = audio_mm.get("sr", SAMPLE_RATE)
+        if isinstance(sr_val, list) and sr_val:
+            sr_val = sr_val[-1]
+        if hasattr(sr_val, "item"):
+            sr_val = sr_val.item()
+        assert int(sr_val) == SAMPLE_RATE, f"Unexpected sample_rate={sr_val}"
+
+        if real_weights:
+            duration_s = audio.size / SAMPLE_RATE
+            assert 0.5 <= duration_s <= 20.0, f"Unexpected duration={duration_s:.3f}s"
+            # Real speech, not silence.
+            rms = float(np.sqrt(np.mean(np.square(audio))))
+            assert rms > 1e-3, f"Audio is near-silent (rms={rms})"
+
+
+def _cfg_sampling_params(runner: OmniRunner, cfg_scale: float, pair_id: str, cond_prompt: str):
+    """Stage sampling params carrying the CFG pair contract for one request."""
+    import copy
+
+    from transformers import AutoTokenizer
+
+    from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
+    from vllm_omni.model_executor.models.audex.prompt import build_null_prompt
+
+    # Resolve the ACTIVE param's model (2B or 30B), not the module default:
+    # the null prompt must be built with the same tokenizer the engine uses.
+    root = ensure_audex_snapshot(runner.model_name)
+    tokenizer = AutoTokenizer.from_pretrained(os.path.join(root, "checkpoint_folder_audiogen"), trust_remote_code=True)
+    params = copy.deepcopy(runner.omni.resolve_sampling_params_list(None))
+    stage0 = params[0]
+    if stage0.extra_args is None:
+        stage0.extra_args = {}
+    stage0.extra_args.update(
+        {
+            "cfg_scale": float(cfg_scale),
+            "cfg_role": "cond",
+            "cfg_pair_id": pair_id,
+            "cfg_null_prompt": build_null_prompt(cond_prompt, tokenizer),
+        }
+    )
+    return params
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_audex_offline_cfg_guided_single_stream(omni_runner: OmniRunner, run_level: str) -> None:
+    """A guided request must yield exactly ONE audio stream (companion suppressed)."""
+    prompt = build_cond_prompt(SYNTH_TEXTS[0])
+    params = _cfg_sampling_params(omni_runner, 1.5, "e2e-cfg-pair", prompt)
+    outputs = omni_runner.omni.generate([prompt], params)
+
+    assert len(outputs) == 1, f"expected exactly one output (no companion leak), got {len(outputs)}"
+    audio = concat_audio(outputs[0].multimodal_output["audio"])
+    assert audio.size > 0, "Guided generation produced empty audio"
+    if run_level in {"advanced_model", "full_model"}:
+        rms = float(np.sqrt(np.mean(np.square(audio))))
+        assert rms > 1e-3, f"Guided audio is near-silent (rms={rms})"
+        duration_s = audio.size / SAMPLE_RATE
+        assert 0.5 <= duration_s <= 20.0, f"Unexpected duration={duration_s:.3f}s"
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_audex_offline_cfg_disabled_is_byte_identical(omni_runner: OmniRunner, run_level: str) -> None:
+    """cfg_scale=1.0 must be indistinguishable from not passing cfg at all."""
+    prompt = build_cond_prompt(SYNTH_TEXTS[1])
+
+    baseline = omni_runner.omni.generate([prompt])
+    base_audio = concat_audio(baseline[0].multimodal_output["audio"])
+
+    import copy
+
+    params = copy.deepcopy(omni_runner.omni.resolve_sampling_params_list(None))
+    if params[0].extra_args is None:
+        params[0].extra_args = {}
+    params[0].extra_args["cfg_scale"] = 1.0
+    disabled = omni_runner.omni.generate([prompt], params)
+    disabled_audio = concat_audio(disabled[0].multimodal_output["audio"])
+
+    assert base_audio.shape == disabled_audio.shape, (
+        f"cfg_scale=1.0 changed output length: {base_audio.shape} vs {disabled_audio.shape}"
+    )
+    np.testing.assert_array_equal(base_audio, disabled_audio)
diff --git a/tests/e2e/offline_inference/test_covo_audio_expansion.py b/tests/e2e/offline_inference/test_covo_audio_expansion.py
index ca05932ef..11672686e 100644
--- a/tests/e2e/offline_inference/test_covo_audio_expansion.py
+++ b/tests/e2e/offline_inference/test_covo_audio_expansion.py
@@ -14,7 +14,7 @@ from vllm_omni.model_executor.models.covo_audio.prompt_utils import (
 
 models = ["tencent/Covo-Audio-Chat"]
 stage_config = get_deploy_config_path("covo_audio.yaml")
-test_params = [(model, stage_config) for model in models]
+test_params = [(model, stage_config, {"trust_remote_code": True}) for model in models]
 
 
 def get_question():
diff --git a/tests/e2e/offline_inference/test_dynin_omni_expansion.py b/tests/e2e/offline_inference/test_dynin_omni_expansion.py
index 13b9e5cb3..19a847332 100644
--- a/tests/e2e/offline_inference/test_dynin_omni_expansion.py
+++ b/tests/e2e/offline_inference/test_dynin_omni_expansion.py
@@ -29,7 +29,7 @@ _DEFAULT_STAGE_CONFIG_PATH = Path(get_deploy_config_path("dynin_omni_ci.yaml"))
 
 models = ["snu-aidas/Dynin-Omni"]
 stage_configs = [str(_DEFAULT_STAGE_CONFIG_PATH)]
-test_params = [(model, stage_config) for model in models for stage_config in stage_configs]
+test_params = [(model, stage_config, {"trust_remote_code": True}) for model in models for stage_config in stage_configs]
 
 DYNIN_CONFIG_PATH = str(_DEFAULT_DYNIN_CONFIG_PATH) if _DEFAULT_DYNIN_CONFIG_PATH is not None else None
 
diff --git a/tests/e2e/offline_inference/test_glm_tts_expansion.py b/tests/e2e/offline_inference/test_glm_tts_expansion.py
index d6a8729f0..e54dd5480 100644
--- a/tests/e2e/offline_inference/test_glm_tts_expansion.py
+++ b/tests/e2e/offline_inference/test_glm_tts_expansion.py
@@ -98,6 +98,7 @@ def test_offline_voice_clone_zh(async_chunk: bool) -> None:
         MODEL,
         stage_configs_path=_get_deploy_config(async_chunk=async_chunk),
         stage_init_timeout=600,
+        trust_remote_code=True,
     ) as omni_runner:
         outputs = omni_runner.omni.generate(
             [
diff --git a/tests/e2e/offline_inference/test_hunyuanimage3.py b/tests/e2e/offline_inference/test_hunyuanimage3.py
index ac1cb13cb..ebd338fe8 100644
--- a/tests/e2e/offline_inference/test_hunyuanimage3.py
+++ b/tests/e2e/offline_inference/test_hunyuanimage3.py
@@ -275,6 +275,7 @@ def omni() -> Generator[Omni, None, None]:
         MODEL_NAME,
         deploy_config=str(DEPLOY_CONFIG_PATH),
         mode="text-to-image",
+        trust_remote_code=True,
     ) as runner:
         yield runner.omni
 
diff --git a/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py b/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
index 5178a40a6..008f0d2a9 100644
--- a/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
+++ b/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
@@ -53,6 +53,7 @@ def omni() -> Generator[Omni, None, None]:
     with OmniRunner(
         MODEL_NAME,
         stage_configs_path=str(STAGE_CONFIG_PATH),
+        trust_remote_code=True,
     ) as runner:
         yield runner.omni
 
diff --git a/tests/e2e/offline_inference/test_indextts2.py b/tests/e2e/offline_inference/test_indextts2_expansion.py
similarity index 98%
rename from tests/e2e/offline_inference/test_indextts2.py
rename to tests/e2e/offline_inference/test_indextts2_expansion.py
index 6c2786efa..ba5b984f9 100644
--- a/tests/e2e/offline_inference/test_indextts2.py
+++ b/tests/e2e/offline_inference/test_indextts2_expansion.py
@@ -33,7 +33,7 @@ ASSETS_DIR = Path(__file__).resolve().parents[2] / "assets" / "indextts2"
 REF_AUDIO = str(ASSETS_DIR / "ref_audio.wav")
 
 pytestmark = [
-    pytest.mark.advanced_model,
+    pytest.mark.slow,
     pytest.mark.tts,
     pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True),
 ]
diff --git a/tests/e2e/offline_inference/test_krea2_expansion.py b/tests/e2e/offline_inference/test_krea2_expansion.py
index f00b4bb0b..a8f63032b 100644
--- a/tests/e2e/offline_inference/test_krea2_expansion.py
+++ b/tests/e2e/offline_inference/test_krea2_expansion.py
@@ -31,7 +31,7 @@ LORA_PROMPT = f"a fox in the snow, {LORA_TRIGGER}"
 
 pytestmark = [
     pytest.mark.diffusion,
-    pytest.mark.full_model,
+    pytest.mark.slow,
 ]
 
 
diff --git a/tests/e2e/offline_inference/test_minicpmo_4_5.py b/tests/e2e/offline_inference/test_minicpmo_4_5.py
new file mode 100644
index 000000000..12f24e3dc
--- /dev/null
+++ b/tests/e2e/offline_inference/test_minicpmo_4_5.py
@@ -0,0 +1,118 @@
+"""
+E2E offline tests for MiniCPM-o 4.5 model with multimodal input and audio / text output.
+"""
+
+import os
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import generate_synthetic_audio, generate_synthetic_image, generate_synthetic_video
+from tests.helpers.stage_config import get_deploy_config_path
+
+models = ["openbmb/MiniCPM-o-4_5"]
+
+_CI_DEPLOY = get_deploy_config_path("minicpmo_4_5.yaml")
+
+
+test_params = [(model, None, {"deploy_config": _CI_DEPLOY, "trust_remote_code": True}) for model in models]
+
+
+def get_question(prompt_type: str = "text") -> str:
+    prompts = {
+        "text": "What is the capital of China? Answer in 20 words.",
+        "audio": "Describe the audio briefly.",
+        "image": "What color are the squares in this image?",
+        "video": "Describe the video briefly.",
+        "mix": "Describe what is in the image and audio.",
+    }
+    return prompts.get(prompt_type, prompts["text"])
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_text_to_text(omni_runner, omni_runner_handler) -> None:
+    """Test processing text, generating text output."""
+    request_config = {"prompts": get_question("text"), "modalities": ["text"]}
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_audio_to_text(omni_runner, omni_runner_handler) -> None:
+    """Test processing audio, generating text output."""
+    audio = generate_synthetic_audio(1, 1, 16000)["np_array"]
+    if len(audio.shape) == 2:
+        audio = audio.squeeze()
+    request_config = {"prompts": get_question("audio"), "audios": (audio, 16000), "modalities": ["text"]}
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_image_to_text(omni_runner, omni_runner_handler) -> None:
+    """Test processing image, generating text output."""
+    image = generate_synthetic_image(16, 16)["np_array"]
+    request_config = {"prompts": get_question("image"), "images": image, "modalities": ["text"]}
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_video_to_text(omni_runner, omni_runner_handler) -> None:
+    """Test processing video, generating text output."""
+    video = generate_synthetic_video(24, 24, 20)["np_array"]
+    request_config = {"prompts": get_question("video"), "videos": video, "modalities": ["text"]}
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_text_to_audio(omni_runner, omni_runner_handler) -> None:
+    """Test processing text and generating audio through Talker and Code2Wav."""
+    request_config = {"prompts": get_question("text"), "modalities": ["audio"]}
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_mix_to_audio(omni_runner, omni_runner_handler) -> None:
+    """Test processing mixed modalities (image + audio), generating audio output."""
+    audio = generate_synthetic_audio(1, 1, 16000)["np_array"]
+    if len(audio.shape) == 2:
+        audio = audio.squeeze()
+    image = generate_synthetic_image(16, 16)["np_array"]
+    request_config = {
+        "prompts": get_question("mix"),
+        "audios": (audio, 16000),
+        "images": image,
+        "modalities": ["audio"],
+    }
+    omni_runner_handler.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_runner", test_params, indirect=True)
+def test_video_to_audio(omni_runner, omni_runner_handler) -> None:
+    """Test processing video, generating audio output."""
+    video = generate_synthetic_video(24, 24, 20)["np_array"]
+    request_config = {"prompts": get_question("video"), "videos": video, "modalities": ["audio"]}
+    omni_runner_handler.send_omni_request(request_config)
diff --git a/tests/e2e/offline_inference/test_moss_tts_expansion.py b/tests/e2e/offline_inference/test_moss_tts_expansion.py
index 73e919d1c..81a64fcd9 100644
--- a/tests/e2e/offline_inference/test_moss_tts_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_expansion.py
@@ -76,7 +76,11 @@ pytestmark = [
     pytest.mark.slow,
     pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4700"),
     pytest.mark.tts,
-    pytest.mark.parametrize("omni_runner", [(MODEL, _get_test_config())], indirect=True),
+    pytest.mark.parametrize(
+        "omni_runner",
+        [(MODEL, _get_test_config(), {"trust_remote_code": True})],
+        indirect=True,
+    ),
 ]
 
 
diff --git a/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py b/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
index 2d247f691..d3e7fcb0f 100644
--- a/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
@@ -29,6 +29,7 @@ STAGE_CONFIG = get_deploy_config_path("moss_tts_nano.yaml")
 _OMNI_RUNNER_PARAM = (
     MODEL_NAME,
     STAGE_CONFIG,
+    {"trust_remote_code": True},
 )
 
 pytestmark = [
diff --git a/tests/e2e/offline_inference/test_moss_tts_realtime.py b/tests/e2e/offline_inference/test_moss_tts_realtime.py
index 5034f0f1d..892a395ba 100644
--- a/tests/e2e/offline_inference/test_moss_tts_realtime.py
+++ b/tests/e2e/offline_inference/test_moss_tts_realtime.py
@@ -98,7 +98,11 @@ pytestmark = [
     pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4700"),
     pytest.mark.full_model,
     pytest.mark.tts,
-    pytest.mark.parametrize("omni_runner", [(MODEL, _get_test_config())], indirect=True),
+    pytest.mark.parametrize(
+        "omni_runner",
+        [(MODEL, _get_test_config(), {"trust_remote_code": True})],
+        indirect=True,
+    ),
 ]
 
 # ---------------------------------------------------------------------------
diff --git a/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py b/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
index 80b12e2e4..b84e5a0ff 100644
--- a/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_realtime_expansion.py
@@ -24,7 +24,11 @@ from tests.helpers.stage_config import get_deploy_config_path
 
 MODEL = "OpenMOSS-Team/MOSS-TTS-Realtime"
 DEPLOY_CONFIG = get_deploy_config_path("moss_tts_realtime.yaml")
-_OMNI_RUNNER_PARAM = (MODEL, DEPLOY_CONFIG, {"stage_init_timeout": 300})
+_OMNI_RUNNER_PARAM = (
+    MODEL,
+    DEPLOY_CONFIG,
+    {"stage_init_timeout": 300, "trust_remote_code": True},
+)
 
 pytestmark = [
     pytest.mark.slow,
diff --git a/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py b/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
index 43bf80415..25c671e05 100644
--- a/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_v1_5_expansion.py
@@ -22,7 +22,11 @@ from tests.helpers.stage_config import get_deploy_config_path
 
 MODEL = "OpenMOSS-Team/MOSS-TTS-v1.5"
 DEPLOY_CONFIG = get_deploy_config_path("moss_tts.yaml")
-_OMNI_RUNNER_PARAM = (MODEL, DEPLOY_CONFIG, {"stage_init_timeout": 600})
+_OMNI_RUNNER_PARAM = (
+    MODEL,
+    DEPLOY_CONFIG,
+    {"stage_init_timeout": 600, "trust_remote_code": True},
+)
 
 pytestmark = [
     pytest.mark.skip(reason="https://github.com/vllm-project/vllm-omni/issues/4643"),
diff --git a/tests/e2e/offline_inference/test_qwen3_tts_base.py b/tests/e2e/offline_inference/test_qwen3_tts_base.py
index ecd769166..a076526a4 100644
--- a/tests/e2e/offline_inference/test_qwen3_tts_base.py
+++ b/tests/e2e/offline_inference/test_qwen3_tts_base.py
@@ -68,7 +68,7 @@ def get_prompt():
 
 @pytest.mark.advanced_model
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "xpu": "B60"}, num_cards=1)
 @pytest.mark.parametrize("omni_runner", tts_server_params, indirect=True)
 def test_text_to_audio_001(omni_runner, omni_runner_handler) -> None:
     """
diff --git a/tests/e2e/offline_inference/test_sensenova_u1_img2img_expansion.py b/tests/e2e/offline_inference/test_sensenova_u1_img2img_expansion.py
index 242d6a12e..1ac76da28 100644
--- a/tests/e2e/offline_inference/test_sensenova_u1_img2img_expansion.py
+++ b/tests/e2e/offline_inference/test_sensenova_u1_img2img_expansion.py
@@ -9,13 +9,14 @@ an input image and text prompt that match expected reference pixel values
 within a ±10 tolerance.
 
 Equivalent to running:
-    python examples/offline_inference/sensenova_u1/end2end.py \
+    python examples/offline_inference/image_to_image/image_edit.py \
+        --model SenseNova/SenseNova-U1-8B-MoT \
         --prompt "Turn this into an oil painting" \
         --image 2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg \
-        --width 2560 --height 1669 \
-        --seed 42 --num-steps 50 \
-        --cfg-scale 4.0 --img-cfg-scale 1.0 --cfg-norm none \
-        --think --print-think
+        --resolution 2048 \
+        --seed 42 --num-inference-steps 50 \
+        --cfg-scale 4.0 \
+        --extra-args '{"think": true, "img_cfg_scale": 1.0, "cfg_norm": "none", "timestep_shift": 3.0}'
 """
 
 import os
@@ -33,11 +34,14 @@ from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 # Reference pixel data extracted from the known-good output image generated by:
-#   python examples/offline_inference/sensenova_u1/end2end.py \
+#   python examples/offline_inference/image_to_image/image_edit.py \
+#       --model SenseNova/SenseNova-U1-8B-MoT \
 #       --prompt "Turn this into an oil painting" \
 #       --image 2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg \
-#       --width 2560 --height 1669 --seed 42 --num-steps 50 \
-#       --cfg-scale 4.0 --img-cfg-scale 1.0 --cfg-norm none --think
+#       --width 2560 --height 1669 \
+#       --seed 42 --num-inference-steps 50 \
+#       --cfg-scale 4.0 \
+#       --extra-args '{"think": true, "img_cfg_scale": 1.0, "cfg_norm": "none", "timestep_shift": 3.0}'
 REFERENCE_PIXELS = [
     {"position": (100, 100), "rgb": (95, 131, 174)},
     {"position": (400, 50), "rgb": (142, 153, 174)},
diff --git a/tests/e2e/offline_inference/test_sensenova_u1_text2img_expansion.py b/tests/e2e/offline_inference/test_sensenova_u1_text2img_expansion.py
index 65b11d3ee..092da16b9 100644
--- a/tests/e2e/offline_inference/test_sensenova_u1_text2img_expansion.py
+++ b/tests/e2e/offline_inference/test_sensenova_u1_text2img_expansion.py
@@ -30,10 +30,12 @@ from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 # Reference pixel data extracted from the known-good output image generated by:
-#   python examples/offline_inference/sensenova_u1/end2end.py \
+#   python examples/offline_inference/text_to_image/text_to_image.py \
+#       --model SenseNova/SenseNova-U1-8B-MoT \
 #       --prompt "Close portrait of an elderly woman ..." \
-#       --width 1536 --height 2720 --seed 42 --num-steps 50 \
-#       --cfg-scale 4.0 --timestep-shift 3.0 --cfg-norm none --think
+#       --width 1536 --height 2720 --seed 42 --num-inference-steps 50 \
+#       --cfg-scale 4.0 \
+#       --extra-body '{"think": true, "cfg_norm": "none", "timestep_shift": 3.0, "t_eps": 0.02}'
 REFERENCE_PIXELS = [
     {"position": (100, 100), "rgb": (247, 249, 250)},
     {"position": (768, 200), "rgb": (176, 135, 97)},
diff --git a/tests/e2e/offline_inference/test_soulxsinger.py b/tests/e2e/offline_inference/test_soulxsinger_expansion.py
similarity index 99%
rename from tests/e2e/offline_inference/test_soulxsinger.py
rename to tests/e2e/offline_inference/test_soulxsinger_expansion.py
index 465f5547b..c3a6091d6 100644
--- a/tests/e2e/offline_inference/test_soulxsinger.py
+++ b/tests/e2e/offline_inference/test_soulxsinger_expansion.py
@@ -38,7 +38,7 @@ if not PROMPT_AUDIO.is_file() or not TARGET_AUDIO.is_file():
         allow_module_level=True,
     )
 
-pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.tts]
+pytestmark = [pytest.mark.slow, pytest.mark.diffusion, pytest.mark.tts]
 
 _CASES = (
     pytest.param(
diff --git a/tests/e2e/offline_inference/test_step_audio2_expansion.py b/tests/e2e/offline_inference/test_step_audio2_expansion.py
index 362f2f33f..cac4fbe52 100644
--- a/tests/e2e/offline_inference/test_step_audio2_expansion.py
+++ b/tests/e2e/offline_inference/test_step_audio2_expansion.py
@@ -6,7 +6,6 @@ E2E expansion tests for Step-Audio2 offline inference (nightly CI).
 Full-model inference with audio input and audio output.
 """
 
-from pathlib import Path
 from typing import Any
 
 import numpy as np
@@ -15,11 +14,12 @@ import pytest
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import generate_synthetic_audio
 from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.outputs import OmniRequestOutput
 
 MODEL = "stepfun-ai/Step-Audio-2-mini"
-STAGE_CONFIG = str(Path(__file__).parent / "stage_configs" / "step_audio2_ci.yaml")
-TEST_PARAMS = [(MODEL, STAGE_CONFIG)]
+DEPLOY_CONFIG = get_deploy_config_path("step_audio2_ci.yaml")
+TEST_PARAMS = [(MODEL, None, {"deploy_config": DEPLOY_CONFIG, "trust_remote_code": True})]
 
 pytestmark = [pytest.mark.slow, pytest.mark.tts]
 
diff --git a/tests/e2e/offline_inference/test_voxcpm2_tts.py b/tests/e2e/offline_inference/test_voxcpm2_tts.py
index 5c91db45a..c10694a40 100644
--- a/tests/e2e/offline_inference/test_voxcpm2_tts.py
+++ b/tests/e2e/offline_inference/test_voxcpm2_tts.py
@@ -14,8 +14,8 @@ VOXCPM2_MODEL = "openbmb/VoxCPM2"
 DEPLOY_CONFIG = get_deploy_config_path("voxcpm2.yaml")
 SAMPLE_RATE = 48000
 
-# (model, stage_config_path) — see ``omni_runner`` in tests.helpers.fixtures.runtime
-_OMNI_RUNNER_PARAM = (VOXCPM2_MODEL, DEPLOY_CONFIG)
+# VoxCPM2 ships a custom tokenizer, so remote code must be explicitly enabled.
+_OMNI_RUNNER_PARAM = (VOXCPM2_MODEL, DEPLOY_CONFIG, {"trust_remote_code": True})
 
 pytestmark = pytest.mark.parametrize("omni_runner", [_OMNI_RUNNER_PARAM], indirect=True)
 
diff --git a/tests/e2e/offline_inference/test_voxtral_tts_expansion.py b/tests/e2e/offline_inference/test_voxtral_tts_expansion.py
index 56529dbbe..2441c46dc 100644
--- a/tests/e2e/offline_inference/test_voxtral_tts_expansion.py
+++ b/tests/e2e/offline_inference/test_voxtral_tts_expansion.py
@@ -58,7 +58,7 @@ def _compose_request(model_name: str, text: str, voice: str) -> dict:
 
 
 @pytest.mark.parametrize("omni_runner_function", [_OMNI_RUNNER_PARAM], indirect=True)
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "xpu": "B60"}, num_cards=1)
 def test_voxtral_tts_offline_basic(omni_runner_function: OmniRunner) -> None:
     """Offline sync path; function-scoped runner so AsyncOmni test does not overlap a live Omni."""
     omni = omni_runner_function.omni
diff --git a/tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py b/tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py
new file mode 100644
index 000000000..6a2809040
--- /dev/null
+++ b/tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py
@@ -0,0 +1,1701 @@
+"""Strict MiniCPM-o 4.5 Realtime duplex E2E scenario harness.
+
+This script is intentionally scenario-based instead of a generic chat client.
+It has two explicit validation contracts:
+
+1. ``model-policy`` accepts either a model-owned listen decision or a complete
+   spoken response for each streamed user turn;
+2. ``response-required`` uses a known fixture and requires a complete audio
+   response with an independent transcript for every requested turn.
+
+Explicit serving-side barge-in is intentionally not part of this smoke test.
+MiniCPM-o native duplex currently exposes model-owned listen/speak switching,
+not a separate model-level barge-in contract.
+
+Run only after a MiniCPM-o 4.5 vLLM-Omni server is up:
+
+  python tests/e2e/online_serving/minicpmo_realtime_duplex_scenarios.py \
+      --url ws://localhost:8099/v1/realtime?duplex=1 \
+      --model openbmb/MiniCPM-o-4_5 \
+      --input-wav input_16k_mono_pcm16.wav \
+      --validation-mode model-policy \
+      --output-dir /tmp/minicpmo_duplex_demo
+"""
+
+from __future__ import annotations
+
+import argparse
+import array
+import asyncio
+import base64
+import hashlib
+import inspect
+import json
+import sys
+import time
+import wave
+from dataclasses import dataclass, field
+from pathlib import Path
+
+_REPO_ROOT = Path(__file__).resolve().parents[3]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+try:
+    import websockets
+    from websockets.exceptions import ConnectionClosed
+except ImportError as exc:  # pragma: no cover - demo dependency.
+    raise SystemExit("Install websockets first: pip install websockets") from exc
+
+from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
+    PCM16_BYTES_PER_SAMPLE,
+    PCM16_SAMPLE_RATE,
+    RealtimeEventCollector,
+    build_realtime_url,
+    read_pcm16_wav,
+)
+
+_url_with_model = build_realtime_url
+_read_wav_pcm16 = read_pcm16_wav
+
+
+def _ref_audio_data_url(path: str | None) -> str | None:
+    if path is None:
+        return None
+    ref_path = Path(path).expanduser()
+    return "data:audio/wav;base64," + base64.b64encode(ref_path.read_bytes()).decode("ascii")
+
+
+@dataclass
+class DemoState:
+    events: list[dict[str, object]] = field(default_factory=list)
+    timing_events: RealtimeEventCollector = field(default_factory=RealtimeEventCollector)
+    audio_deltas: list[bytes] = field(default_factory=list)
+    response_audio_deltas: dict[str, list[bytes]] = field(default_factory=dict)
+    response_ids: list[str] = field(default_factory=list)
+    assistant_item_ids: list[str] = field(default_factory=list)
+    done_count: int = 0
+    cancelled_count: int = 0
+    listen_count: int = 0
+    model_listen_count: int = 0
+    buffering_listen_count: int = 0
+    model_speak_event_count: int = 0
+    model_speak_delta_count: int = 0
+    playback_ack_count: int = 0
+    playback_history_committed_count: int = 0
+    truncate_count: int = 0
+    input_transcription_count: int = 0
+    audio_marks_seen: bool = False
+    overlap_decisions: list[dict[str, object]] = field(default_factory=list)
+    output_sample_rate_hz: int = 24000
+    input_commit_sent_at_s: list[float] = field(default_factory=list)
+
+    def add(self, event: dict[str, object], *, received_at_s: float | None = None) -> None:
+        self.events.append(event)
+        self.timing_events.add(event, received_at_s=received_at_s)
+        event_type = event.get("type")
+        if event_type == "response.created":
+            response = event.get("response")
+            response_id = response.get("id") if isinstance(response, dict) else event.get("response_id")
+            if isinstance(response_id, str) and response_id not in self.response_ids:
+                self.response_ids.append(response_id)
+        elif event_type == "conversation.item.added":
+            item = event.get("item")
+            if isinstance(item, dict) and item.get("role") == "assistant":
+                item_id = item.get("id")
+                if isinstance(item_id, str) and item_id not in self.assistant_item_ids:
+                    self.assistant_item_ids.append(item_id)
+        elif event_type == "response.audio.delta":
+            delta = event.get("delta") or event.get("audio")
+            if isinstance(delta, str) and delta:
+                try:
+                    decoded = base64.b64decode(delta)
+                    self.audio_deltas.append(decoded)
+                    response_id = self._event_response_id(event)
+                    if isinstance(response_id, str):
+                        self.response_audio_deltas.setdefault(response_id, []).append(decoded)
+                except Exception:
+                    pass
+            metadata = event.get("metadata")
+            if isinstance(metadata, dict):
+                if metadata.get("model_speak") is True:
+                    self.model_speak_delta_count += 1
+                if isinstance(metadata.get("audio_text_marks"), list):
+                    self.audio_marks_seen = True
+            sample_rate_hz = event.get("sample_rate_hz")
+            if isinstance(sample_rate_hz, int) and sample_rate_hz > 0:
+                self.output_sample_rate_hz = sample_rate_hz
+        elif event_type == "response.done":
+            self.done_count += 1
+            response = event.get("response")
+            if isinstance(response, dict) and response.get("status") == "cancelled":
+                self.cancelled_count += 1
+        elif event_type in {"audio.cancelled", "input.cancelled"}:
+            self.cancelled_count += 1
+        elif event_type == "response.listen":
+            self.listen_count += 1
+            response = event.get("response")
+            metadata = response.get("metadata") if isinstance(response, dict) else None
+            if isinstance(metadata, dict) and metadata.get("model_listen") is True:
+                self.model_listen_count += 1
+            if isinstance(metadata, dict) and metadata.get("buffering") is True:
+                self.buffering_listen_count += 1
+        elif event_type == "response.speak":
+            self.model_speak_event_count += 1
+        elif event_type == "overlap.decision":
+            self.overlap_decisions.append(event)
+        elif event_type == "playback.acknowledged":
+            self.playback_ack_count += 1
+            payload = event.get("event")
+            if isinstance(payload, dict) and payload.get("history_committed") is True:
+                self.playback_history_committed_count += 1
+        elif event_type == "conversation.item.truncated":
+            self.truncate_count += 1
+        elif event_type == "conversation.item.input_audio_transcription.completed":
+            self.input_transcription_count += 1
+
+    def count(self, event_type: str) -> int:
+        return sum(1 for event in self.events if event.get("type") == event_type)
+
+    def response_timing_summaries(self) -> dict[str, dict[str, object]]:
+        summaries: dict[str, dict[str, object]] = {}
+        for response_id in self.response_ids:
+            created_at_s = next(
+                (
+                    received_at_s
+                    for event, received_at_s in zip(
+                        self.timing_events.events,
+                        self.timing_events.event_received_at_s,
+                        strict=True,
+                    )
+                    if event.get("type") == "response.created" and self._event_response_id(event) == response_id
+                ),
+                None,
+            )
+            if created_at_s is None:
+                continue
+            input_committed_at_s = next(
+                (
+                    committed_at_s
+                    for committed_at_s in reversed(self.input_commit_sent_at_s)
+                    if committed_at_s <= created_at_s
+                ),
+                None,
+            )
+            timing = self.timing_events.timing_summary(
+                after_s=created_at_s,
+                input_committed_at_s=input_committed_at_s,
+                response_id=response_id,
+            )
+            timing["measurement_origin"] = {
+                "response": "response.created client receive",
+                "input": "input_audio_buffer.commit client send" if input_committed_at_s is not None else None,
+            }
+            summaries[response_id] = timing
+        return summaries
+
+    def first_index(self, event_type: str, predicate=None) -> int | None:
+        for index, event in enumerate(self.events):
+            if event.get("type") != event_type:
+                continue
+            if predicate is not None and not predicate(event):
+                continue
+            return index
+        return None
+
+    @staticmethod
+    def _event_response_id(event: dict[str, object]) -> str | None:
+        response_id = event.get("response_id")
+        if isinstance(response_id, str) and response_id:
+            return response_id
+        response = event.get("response")
+        if isinstance(response, dict):
+            response_id = response.get("id")
+            if isinstance(response_id, str) and response_id:
+                return response_id
+        return None
+
+    @staticmethod
+    def _event_item_id(event: dict[str, object]) -> str | None:
+        item_id = event.get("item_id")
+        if isinstance(item_id, str) and item_id:
+            return item_id
+        item = event.get("item")
+        if isinstance(item, dict):
+            item_id = item.get("id")
+            if isinstance(item_id, str) and item_id:
+                return item_id
+        return None
+
+    def first_response_lifecycle_indices(self) -> dict[str, int]:
+        response_created_index = self.first_index("response.created")
+        if response_created_index is None:
+            return {}
+        response_id = self._event_response_id(self.events[response_created_index])
+        if not response_id:
+            return {}
+        item_id = f"item_{response_id}"
+        indices: dict[str, int] = {"response.created": response_created_index}
+        for event_type in (
+            "conversation.item.added",
+            "response.output_item.added",
+            "response.content_part.added",
+            "response.speak",
+            "response.audio.delta",
+            "response.audio.done",
+            "response.content_part.done",
+            "response.output_item.done",
+            "response.done",
+        ):
+            index = self.first_index(
+                event_type,
+                lambda event, event_type=event_type: (
+                    self._event_item_id(event) == item_id
+                    if event_type == "conversation.item.added"
+                    else self._event_response_id(event) == response_id
+                ),
+            )
+            if index is None and event_type not in {
+                "response.speak",
+                "response.audio.delta",
+                "response.audio.done",
+            }:
+                return {}
+            if index is not None:
+                indices[event_type] = index
+        return indices
+
+    def event_order_ok(
+        self,
+        *,
+        require_input_commit: bool = True,
+        require_commit_before_response: bool = True,
+    ) -> bool:
+        if not self.events or self.events[0].get("type") != "session.created":
+            return False
+        first_commit_index = self.first_index("input_audio_buffer.committed")
+        first_response_index = self.first_index("response.created")
+        if first_response_index is None:
+            return False
+        if require_input_commit and first_commit_index is None:
+            return False
+        if (
+            require_input_commit
+            and require_commit_before_response
+            and first_commit_index is not None
+            and first_commit_index > first_response_index
+        ):
+            return False
+        indices_by_type = self.first_response_lifecycle_indices()
+        if not indices_by_type:
+            return False
+        required_types = [
+            "response.created",
+            "conversation.item.added",
+            "response.output_item.added",
+            "response.content_part.added",
+            "response.content_part.done",
+            "response.output_item.done",
+            "response.done",
+        ]
+        if any(event_type not in indices_by_type for event_type in required_types):
+            return False
+        ordered_types = [
+            "response.created",
+            "conversation.item.added",
+            "response.output_item.added",
+            "response.content_part.added",
+            "response.speak",
+            "response.audio.delta",
+            "response.audio.done",
+            "response.content_part.done",
+            "response.output_item.done",
+            "response.done",
+        ]
+        if "response.audio.delta" not in indices_by_type:
+            listen_index = self.first_index(
+                "response.listen",
+                lambda event: (
+                    isinstance(event.get("response"), dict)
+                    and isinstance(event["response"].get("metadata"), dict)
+                    and event["response"]["metadata"].get("model_listen") is True
+                ),
+            )
+            return (
+                listen_index is not None
+                and indices_by_type["response.created"] < listen_index < indices_by_type["response.done"]
+            )
+        if any(event_type not in indices_by_type for event_type in ordered_types):
+            return False
+        indices = [indices_by_type[event_type] for event_type in ordered_types]
+        return indices == sorted(indices)
+
+    def model_policy_event_order_ok(
+        self,
+        *,
+        expected_turns: int,
+        require_input_commit: bool = True,
+    ) -> bool:
+        if not self.events or self.events[0].get("type") != "session.created":
+            return False
+        commit_indices = [
+            index for index, event in enumerate(self.events) if event.get("type") == "input_audio_buffer.committed"
+        ]
+        decision_indices = [
+            index
+            for index, event in enumerate(self.events)
+            if event.get("type") == "response.created"
+            or (
+                event.get("type") == "response.listen"
+                and isinstance(event.get("response"), dict)
+                and isinstance(event["response"].get("metadata"), dict)
+                and event["response"]["metadata"].get("model_listen") is True
+            )
+        ]
+        first_input_index = self.first_index("input_audio_buffer.speech_started")
+        if first_input_index is None:
+            first_input_index = commit_indices[0] if commit_indices else None
+        if first_input_index is None and not require_input_commit:
+            first_input_index = 0
+        if (
+            first_input_index is None
+            or (require_input_commit and len(commit_indices) < expected_turns)
+            or len(decision_indices) < expected_turns
+        ):
+            return False
+        return decision_indices[0] > first_input_index
+
+    def model_speak_before_audio_ok(self) -> bool:
+        speak_index = self.first_index("response.speak")
+        audio_index = self.first_index("response.audio.delta")
+        return speak_index is not None and audio_index is not None and speak_index < audio_index
+
+    def response_done(self, response_id: str | None) -> bool:
+        if not response_id:
+            return False
+        return any(
+            event.get("type") == "response.done" and self._event_response_id(event) == response_id
+            for event in self.events
+        )
+
+    def response_audio_delta_count(self, response_id: str | None) -> int:
+        if not response_id:
+            return 0
+        return sum(
+            1
+            for event in self.events
+            if event.get("type") == "response.audio.delta" and self._event_response_id(event) == response_id
+        )
+
+    def response_playback_sent_ms(self, response_id: str | None) -> int:
+        if not response_id:
+            return 0
+        for event in reversed(self.events):
+            if event.get("type") != "response.done" or self._event_response_id(event) != response_id:
+                continue
+            response = event.get("response")
+            metadata = response.get("metadata") if isinstance(response, dict) else None
+            playback = metadata.get("playback") if isinstance(metadata, dict) else event.get("playback")
+            sent_ms = playback.get("sent_ms") if isinstance(playback, dict) else None
+            if isinstance(sent_ms, int | float):
+                return max(0, int(sent_ms))
+        return 0
+
+    def response_playback_history_committed(self, response_id: str) -> bool:
+        item_id = f"item_{response_id}"
+        for event in self.events:
+            if event.get("type") != "playback.acknowledged":
+                continue
+            payload = event.get("event")
+            if not isinstance(payload, dict):
+                continue
+            if payload.get("item_id") == item_id and payload.get("history_committed") is True:
+                return True
+        return False
+
+    def response_transcript_delta(self, response_id: str) -> str:
+        return "".join(
+            str(event.get("delta", ""))
+            for event in self.events
+            if event.get("type") == "response.audio_transcript.delta" and self._event_response_id(event) == response_id
+        )
+
+    def response_transcript_done(self, response_id: str) -> list[str]:
+        return [
+            str(event.get("transcript", ""))
+            for event in self.events
+            if event.get("type") == "response.audio_transcript.done" and self._event_response_id(event) == response_id
+        ]
+
+    def completed_response_ids(self) -> list[str]:
+        response_ids: list[str] = []
+        for event in self.events:
+            if event.get("type") != "response.done":
+                continue
+            response_id = self._event_response_id(event)
+            if isinstance(response_id, str):
+                response_ids.append(response_id)
+        return response_ids
+
+    def stale_audio_delta_count(self) -> int:
+        cancelled_epochs_by_index: list[tuple[int, int]] = []
+        for index, event in enumerate(self.events):
+            if event.get("type") != "response.done":
+                continue
+            response = event.get("response")
+            if not isinstance(response, dict) or response.get("status") != "cancelled":
+                continue
+            metadata = response.get("metadata")
+            if not isinstance(metadata, dict):
+                continue
+            cancelled_epoch = metadata.get("cancelled_epoch")
+            if isinstance(cancelled_epoch, int):
+                cancelled_epochs_by_index.append((index, cancelled_epoch))
+        if not cancelled_epochs_by_index:
+            return 0
+        stale = 0
+        for index, event in enumerate(self.events):
+            if event.get("type") != "response.audio.delta":
+                continue
+            metadata = event.get("metadata")
+            if not isinstance(metadata, dict):
+                continue
+            event_epoch = metadata.get("epoch")
+            for cancel_index, cancelled_epoch in cancelled_epochs_by_index:
+                if index > cancel_index and event_epoch == cancelled_epoch:
+                    stale += 1
+                    break
+        return stale
+
+
+def _session_update_event(args: argparse.Namespace) -> dict[str, object]:
+    session_payload: dict[str, object] = {
+        "model": args.model,
+        "modalities": ["audio", "text"],
+        "input_audio_format": "pcm16",
+        "output_audio_format": args.output_audio_format,
+        "turn_detection": None,
+        "overlap_policy": "listen_only",
+        "overlap_short_ack_ms": args.short_ack_ms,
+        "playback_commit_policy": "ack_only",
+        "extra_body": {
+            "auto_response": True,
+            "minicpmo45_native_duplex": True,
+            "force_listen_count": 0,
+        },
+    }
+    temperature = getattr(args, "temperature", None)
+    if temperature is None and getattr(args, "validation_mode", None) == "response-required":
+        temperature = 0.0
+    if temperature is not None:
+        session_payload["temperature"] = temperature
+    ref_audio = _ref_audio_data_url(getattr(args, "ref_audio", None))
+    if ref_audio is not None:
+        session_payload["ref_audio"] = ref_audio
+    event: dict[str, object] = {
+        "type": "session.update",
+        "session": session_payload,
+    }
+    session_id = getattr(args, "session_id", None)
+    if session_id:
+        session_payload["session_id"] = session_id
+    return event
+
+
+def _turn_input_paths(primary: Path, additional: list[str], *, turns: int) -> list[Path]:
+    turn_count = max(1, turns)
+    if not additional:
+        return [primary] * turn_count
+    if len(additional) != turn_count - 1:
+        raise ValueError(
+            f"provide exactly one --turn-input-wav for each turn after the first "
+            f"(expected {turn_count - 1}, got {len(additional)})"
+        )
+    return [primary, *(Path(path) for path in additional)]
+
+
+def _turn_inputs_are_distinct(paths: list[Path], pcm16_inputs: list[bytes]) -> bool:
+    if len(paths) != len(pcm16_inputs):
+        return False
+    distinct_paths = len({str(path.resolve()) for path in paths}) == len(paths)
+    distinct_audio = len({hashlib.sha256(pcm16).digest() for pcm16 in pcm16_inputs}) == len(pcm16_inputs)
+    return distinct_paths and distinct_audio
+
+
+def _turn_durations(
+    explicit: list[int],
+    *,
+    turns: int,
+    first_turn_ms: int,
+) -> list[int | None]:
+    turn_count = max(1, turns)
+    if not explicit:
+        return [first_turn_ms, *([min(first_turn_ms, 1200)] * (turn_count - 1))]
+    if len(explicit) != turn_count:
+        raise ValueError(
+            f"provide exactly one --turn-duration-ms for each turn (expected {turn_count}, got {len(explicit)})"
+        )
+    if any(duration_ms < 0 for duration_ms in explicit):
+        raise ValueError("--turn-duration-ms values must be non-negative")
+    return [None if duration_ms == 0 else duration_ms for duration_ms in explicit]
+
+
+def _turn_transcripts(first: str, *, turns: int) -> list[str]:
+    turn_count = max(1, turns)
+    transcripts = [first, "继续", "再说一次"][:turn_count]
+    transcripts.extend(f"turn-{turn_index + 1}" for turn_index in range(len(transcripts), turn_count))
+    return transcripts
+
+
+def _write_wav(path: Path, pcm_bytes: bytes, *, sample_rate_hz: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(path), "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(PCM16_BYTES_PER_SAMPLE)
+        wf.setframerate(sample_rate_hz)
+        wf.writeframes(pcm_bytes)
+
+
+def _write_demo_artifacts(state: DemoState, output_dir: Path, *, output_audio_format: str) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    if state.audio_deltas and output_audio_format == "pcm16":
+        _write_wav(
+            output_dir / "joined_audio_deltas.wav",
+            b"".join(state.audio_deltas),
+            sample_rate_hz=state.output_sample_rate_hz,
+        )
+    elif state.audio_deltas:
+        (output_dir / "joined_audio_deltas.bin").write_bytes(b"".join(state.audio_deltas))
+    for index, response_id in enumerate(state.response_ids, start=1):
+        response_audio = state.response_audio_deltas.get(response_id, [])
+        if not response_audio:
+            continue
+        payload = b"".join(response_audio)
+        if output_audio_format == "pcm16":
+            _write_wav(
+                output_dir / f"response_{index:02d}.wav",
+                payload,
+                sample_rate_hz=state.output_sample_rate_hz,
+            )
+        else:
+            (output_dir / f"response_{index:02d}.bin").write_bytes(payload)
+    (output_dir / "events.jsonl").write_text(
+        "\n".join(json.dumps(event, ensure_ascii=False) for event in state.events) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _pcm16_silence(duration_ms: int) -> bytes:
+    samples = PCM16_SAMPLE_RATE * max(0, duration_ms) // 1000
+    return b"\x00\x00" * samples
+
+
+def _pcm16_slice(pcm16: bytes, duration_ms: int) -> bytes:
+    byte_count = PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * max(1, duration_ms) // 1000
+    return pcm16[: min(len(pcm16), byte_count)]
+
+
+def _pcm16_active_slice(pcm16: bytes, duration_ms: int) -> bytes:
+    byte_count = PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * max(1, duration_ms) // 1000
+    byte_count = min(len(pcm16), max(PCM16_BYTES_PER_SAMPLE, byte_count))
+    byte_count -= byte_count % PCM16_BYTES_PER_SAMPLE
+    if byte_count <= 0:
+        return _pcm16_slice(pcm16, duration_ms)
+    step = max(PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * 20 // 1000, PCM16_BYTES_PER_SAMPLE)
+    step -= step % PCM16_BYTES_PER_SAMPLE
+    best_offset = 0
+    best_energy = -1.0
+    for offset in range(0, max(1, len(pcm16) - byte_count + 1), max(PCM16_BYTES_PER_SAMPLE, step)):
+        chunk = pcm16[offset : offset + byte_count]
+        samples = array.array("h")
+        samples.frombytes(chunk)
+        if not samples:
+            continue
+        energy = sum(abs(sample) for sample in samples) / len(samples)
+        if energy > best_energy:
+            best_energy = energy
+            best_offset = offset
+    return pcm16[best_offset : best_offset + byte_count]
+
+
+def _select_turn_audio(pcm16: bytes, duration_ms: int | None) -> bytes:
+    if duration_ms is None:
+        return pcm16
+    return _pcm16_active_slice(pcm16, duration_ms)
+
+
+def _canonical_transcript(text: str) -> str:
+    return "".join(text.split())
+
+
+def _reuses_previous_turn_tail(previous: str, current: str) -> bool:
+    if not previous or not current:
+        return False
+    if len(previous) >= 4 and previous in current:
+        return True
+    max_overlap = min(len(previous), len(current))
+    return any(previous.endswith(current[:overlap]) for overlap in range(max_overlap, 2, -1))
+
+
+def _has_terminal_punctuation(text: str) -> bool:
+    stripped = text.rstrip("\"'”’）)]} ")
+    return bool(stripped) and (len(stripped) <= 4 or stripped[-1] in "。！？!?…")
+
+
+def _all_audio_responses_have_transcript(state: DemoState, response_ids: list[str]) -> bool:
+    return all(
+        state.response_audio_delta_count(response_id) == 0
+        or bool(_canonical_transcript(state.response_transcript_delta(response_id)))
+        for response_id in response_ids
+    )
+
+
+def _all_response_playback_history_committed(state: DemoState, response_ids: list[str]) -> bool:
+    return all(
+        state.response_playback_history_committed(response_id)
+        for response_id in response_ids
+        if state.response_playback_sent_ms(response_id) > 0
+    )
+
+
+def _response_cardinality_ok(
+    completed_response_ids: list[str],
+    *,
+    expected_turns: int,
+    validation_mode: str,
+) -> bool:
+    if validation_mode == "response-required":
+        return len(completed_response_ids) == expected_turns
+    return True
+
+
+def _requires_cross_turn_independence(
+    *,
+    validation_mode: str,
+    distinct_inputs_required: bool,
+) -> bool:
+    return distinct_inputs_required and validation_mode == "response-required"
+
+
+def _input_transcription_ok(count: int, *, transcript_hints_enabled: bool) -> bool:
+    return count > 0 if transcript_hints_enabled else True
+
+
+def _unexpected_error_events(state: DemoState) -> list[dict[str, object]]:
+    return [event for event in state.events if event.get("type") == "error"]
+
+
+def _evaluate_response_speak_contract(state: DemoState) -> dict[str, object]:
+    speak_counts: dict[str, int] = {}
+    invalid_response_speak_count = 0
+    text_bearing_response_speak_count = 0
+
+    for event in state.events:
+        if event.get("type") != "response.speak":
+            continue
+        response_id = state._event_response_id(event)
+        if not response_id or response_id not in state.response_ids:
+            invalid_response_speak_count += 1
+        else:
+            speak_counts[response_id] = speak_counts.get(response_id, 0) + 1
+        if "text" in event:
+            text_bearing_response_speak_count += 1
+
+    duplicate_response_speak_ids = sorted(response_id for response_id, count in speak_counts.items() if count > 1)
+    return {
+        "response_speak_contract_ok": not duplicate_response_speak_ids
+        and invalid_response_speak_count == 0
+        and text_bearing_response_speak_count == 0,
+        "duplicate_response_speak_ids": duplicate_response_speak_ids,
+        "invalid_response_speak_count": invalid_response_speak_count,
+        "text_bearing_response_speak_count": text_bearing_response_speak_count,
+    }
+
+
+def _evaluate_transcript_integrity(
+    state: DemoState,
+    response_ids: list[str],
+    *,
+    expected_empty_response_ids: set[str],
+    require_cross_turn_independence: bool,
+    require_terminal_punctuation: bool = False,
+) -> dict[str, object]:
+    details: list[dict[str, object]] = []
+    transcripts: list[str] = []
+    transcript_delta_done_ok = True
+    empty_turns_ok = True
+    nonempty_audio_has_transcript_ok = True
+    terminal_punctuation_ok = True
+
+    for response_id in response_ids:
+        transcript = state.response_transcript_delta(response_id)
+        done_transcripts = state.response_transcript_done(response_id)
+        canonical_transcript = _canonical_transcript(transcript)
+        response_delta_done = (
+            len(done_transcripts) == 1 and _canonical_transcript(done_transcripts[0]) == canonical_transcript
+        ) or (not done_transcripts and not canonical_transcript)
+        expected_empty = response_id in expected_empty_response_ids
+        audio_delta_count = state.response_audio_delta_count(response_id)
+        response_empty_ok = not expected_empty or (not canonical_transcript and audio_delta_count == 0)
+        response_audio_has_transcript = expected_empty or audio_delta_count == 0 or bool(canonical_transcript)
+        response_terminal_punctuation_ok = (
+            expected_empty
+            or not canonical_transcript
+            or not require_terminal_punctuation
+            or _has_terminal_punctuation(canonical_transcript)
+        )
+        transcript_delta_done_ok = transcript_delta_done_ok and response_delta_done
+        empty_turns_ok = empty_turns_ok and response_empty_ok
+        nonempty_audio_has_transcript_ok = nonempty_audio_has_transcript_ok and response_audio_has_transcript
+        terminal_punctuation_ok = terminal_punctuation_ok and response_terminal_punctuation_ok
+        transcripts.append(canonical_transcript)
+        details.append(
+            {
+                "response_id": response_id,
+                "transcript": transcript,
+                "delta_done_ok": response_delta_done,
+                "expected_empty": expected_empty,
+                "empty_ok": response_empty_ok,
+                "audio_delta_count": audio_delta_count,
+                "audio_has_transcript": response_audio_has_transcript,
+                "terminal_punctuation_ok": response_terminal_punctuation_ok,
+            }
+        )
+
+    cross_turn_independent_ok = True
+    if require_cross_turn_independence:
+        for index, current in enumerate(transcripts):
+            for previous in transcripts[:index]:
+                if _reuses_previous_turn_tail(previous, current):
+                    cross_turn_independent_ok = False
+                    break
+            if not cross_turn_independent_ok:
+                break
+
+    return {
+        "transcript_delta_done_ok": transcript_delta_done_ok,
+        "cross_turn_independent_ok": cross_turn_independent_ok,
+        "empty_turns_ok": empty_turns_ok,
+        "nonempty_audio_has_transcript_ok": nonempty_audio_has_transcript_ok,
+        "terminal_punctuation_ok": terminal_punctuation_ok,
+        "transcript_integrity": details,
+    }
+
+
+async def _reader(ws, state: DemoState, stop: asyncio.Event) -> None:
+    try:
+        while not stop.is_set():
+            raw = await ws.recv()
+            if not isinstance(raw, str):
+                continue
+            event = json.loads(raw)
+            if isinstance(event, dict):
+                state.add(event)
+    except ConnectionClosed:
+        return
+
+
+async def _send_pcm16(
+    ws,
+    pcm16: bytes,
+    *,
+    chunk_ms: int,
+    realtime_delay: bool,
+    hints: dict[str, object] | None = None,
+    first_chunk_hints: dict[str, object] | None = None,
+    on_model_unit_ready=None,
+    frame_b64: str | None = None,
+) -> None:
+    hints = hints or {}
+    first_chunk_hints = first_chunk_hints or {}
+    chunk_bytes = max(PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * chunk_ms // 1000, PCM16_BYTES_PER_SAMPLE)
+    model_unit_bytes = PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE
+    audio_ms = 0
+    next_model_unit_bytes = model_unit_bytes
+    frames_sent = 0
+    for offset in range(0, len(pcm16), chunk_bytes):
+        chunk = pcm16[offset : offset + chunk_bytes]
+        duration_ms = int(len(chunk) / (PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE) * 1000)
+        audio_ms += duration_ms
+        chunk_hints = dict(hints)
+        if offset == 0:
+            chunk_hints.update(first_chunk_hints)
+        if frame_b64 is not None and audio_ms > frames_sent * 1000:
+            # Omni duplex cadence: one camera frame per 1 s of audio.
+            chunk_hints["video_frames"] = [frame_b64]
+            frames_sent += 1
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "input_audio_buffer.append",
+                    "audio": base64.b64encode(chunk).decode("ascii"),
+                    "input_audio_format": "pcm16",
+                    "sample_rate_hz": PCM16_SAMPLE_RATE,
+                    "duration_ms": duration_ms,
+                    "audio_end_ms": audio_ms,
+                    **chunk_hints,
+                }
+            )
+        )
+        while offset + len(chunk) >= next_model_unit_bytes:
+            next_model_unit_bytes += model_unit_bytes
+            if on_model_unit_ready is None:
+                continue
+            should_continue = on_model_unit_ready()
+            if inspect.isawaitable(should_continue):
+                should_continue = await should_continue
+            if should_continue is False:
+                return
+        if realtime_delay:
+            await asyncio.sleep(duration_ms / 1000)
+
+
+async def _wait_for(
+    state: DemoState,
+    predicate,
+    *,
+    timeout_s: float,
+    label: str,
+) -> None:
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if predicate():
+            return
+        await asyncio.sleep(0.02)
+    raise TimeoutError(f"Timed out waiting for {label}")
+
+
+async def _wait_for_model_policy_outcome(
+    state: DemoState,
+    *,
+    before_created: int,
+    before_model_listen: int,
+    timeout_s: float,
+    listen_settle_s: float,
+    label: str,
+) -> str:
+    deadline = time.monotonic() + timeout_s
+    listen_deadline: float | None = None
+    while time.monotonic() < deadline:
+        if state.count("response.created") > before_created:
+            return "speak"
+        if state.model_listen_count > before_model_listen:
+            if listen_deadline is None:
+                listen_deadline = time.monotonic() + max(0.0, listen_settle_s)
+            if time.monotonic() >= listen_deadline:
+                return "listen"
+        await asyncio.sleep(0.02)
+    raise TimeoutError(f"Timed out waiting for {label}")
+
+
+async def _send_clean_turn(
+    ws,
+    state: DemoState,
+    pcm16: bytes,
+    *,
+    transcript: str,
+    duration_ms: int | None,
+    chunk_ms: int,
+    timeout_s: float,
+    require_audio: bool,
+    validation_mode: str,
+    send_transcript_hint: bool = True,
+    realtime_input: bool = False,
+    model_policy_settle_s: float = 2.0,
+    commit_input: bool = True,
+    frame_b64: str | None = None,
+) -> tuple[str | None, str]:
+    before_created = state.count("response.created")
+    before_model_listen = state.model_listen_count
+
+    def eligible_response_id() -> str | None:
+        for response_id in state.response_ids[before_created:]:
+            if not state.response_done(response_id):
+                continue
+            if require_audio and state.response_audio_delta_count(response_id) == 0:
+                continue
+            if require_audio and not _canonical_transcript(state.response_transcript_delta(response_id)):
+                continue
+            return response_id
+        return None
+
+    await _send_pcm16(
+        ws,
+        _select_turn_audio(pcm16, duration_ms),
+        chunk_ms=chunk_ms,
+        realtime_delay=realtime_input,
+        hints={"transcript": transcript} if send_transcript_hint else {},
+        frame_b64=frame_b64,
+    )
+    if commit_input:
+        state.input_commit_sent_at_s.append(time.monotonic())
+        await ws.send(json.dumps({"type": "input_audio_buffer.commit", "final": True}))
+    if validation_mode == "model-policy":
+        outcome = await _wait_for_model_policy_outcome(
+            state,
+            before_created=before_created,
+            before_model_listen=before_model_listen,
+            timeout_s=timeout_s,
+            listen_settle_s=model_policy_settle_s,
+            label=f"{transcript} model speak/listen decision",
+        )
+        if outcome == "listen":
+            return None, "listen"
+    else:
+        await _wait_for(
+            state,
+            lambda: state.count("response.created") > before_created,
+            timeout_s=timeout_s,
+            label=f"{transcript} response.created",
+        )
+        await _wait_for(
+            state,
+            lambda: eligible_response_id() is not None,
+            timeout_s=timeout_s,
+            label=f"{transcript} completed response",
+        )
+    response_id = (
+        eligible_response_id()
+        if validation_mode == "response-required"
+        else (state.response_ids[before_created] if len(state.response_ids) > before_created else None)
+    )
+    if require_audio:
+        await _wait_for(
+            state,
+            lambda: state.response_audio_delta_count(response_id) > 0,
+            timeout_s=timeout_s,
+            label=f"{transcript} response.audio.delta",
+        )
+    await _wait_for(
+        state,
+        lambda: state.response_done(response_id),
+        timeout_s=timeout_s,
+        label=f"{transcript} response.done",
+    )
+    if not isinstance(response_id, str):
+        raise TimeoutError(f"Missing response id for {transcript}")
+    await _ack_response_playback(
+        ws,
+        state,
+        response_id,
+        timeout_s=timeout_s,
+        label=transcript,
+    )
+    return response_id, "speak"
+
+
+async def _ack_response_playback(
+    ws,
+    state: DemoState,
+    response_id: str,
+    *,
+    timeout_s: float,
+    label: str,
+) -> None:
+    played_ms = state.response_playback_sent_ms(response_id)
+    if played_ms <= 0:
+        return
+    before_ack = state.playback_ack_count
+    await ws.send(
+        json.dumps(
+            {
+                "type": "playback.ack",
+                "response_id": response_id,
+                "item_id": f"item_{response_id}",
+                "played_ms": played_ms,
+                "committed_ms": played_ms,
+            }
+        )
+    )
+    await _wait_for(
+        state,
+        lambda: state.playback_ack_count > before_ack and state.response_playback_history_committed(response_id),
+        timeout_s=timeout_s,
+        label=f"{label} playback history committed",
+    )
+
+
+async def _ack_all_completed_response_playback(
+    ws,
+    state: DemoState,
+    *,
+    timeout_s: float,
+) -> None:
+    for response_id in state.completed_response_ids():
+        if state.response_playback_sent_ms(response_id) <= 0:
+            continue
+        if state.response_playback_history_committed(response_id):
+            continue
+        await _ack_response_playback(
+            ws,
+            state,
+            response_id,
+            timeout_s=timeout_s,
+            label=response_id,
+        )
+
+
+async def _drain_model_policy_responses(
+    ws,
+    state: DemoState,
+    *,
+    timeout_s: float,
+    settle_s: float,
+) -> None:
+    deadline = time.monotonic() + timeout_s
+    settle_s = max(0.0, settle_s)
+    observed_created_count = state.count("response.created")
+    quiet_since: float | None = None
+
+    while True:
+        remaining_s = deadline - time.monotonic()
+        active_response_ids = [
+            response_id for response_id in state.response_ids if not state.response_done(response_id)
+        ]
+        if remaining_s <= 0:
+            raise TimeoutError(f"Timed out draining model-policy responses; active response ids: {active_response_ids}")
+
+        await _ack_all_completed_response_playback(
+            ws,
+            state,
+            timeout_s=remaining_s,
+        )
+
+        now = time.monotonic()
+        created_count = state.count("response.created")
+        if created_count != observed_created_count:
+            observed_created_count = created_count
+            quiet_since = None
+
+        active_response_ids = [
+            response_id for response_id in state.response_ids if not state.response_done(response_id)
+        ]
+        if active_response_ids:
+            quiet_since = None
+        else:
+            if quiet_since is None:
+                quiet_since = now
+            if now - quiet_since >= settle_s:
+                return
+
+        await asyncio.sleep(min(0.02, max(0.0, deadline - time.monotonic())))
+
+
+def _event_index_for_response(state: DemoState, event_type: str, response_id: str) -> int | None:
+    return state.first_index(
+        event_type,
+        lambda event: state._event_response_id(event) == response_id,
+    )
+
+
+def _nth_event_index(state: DemoState, event_type: str, occurrence: int) -> int | None:
+    seen = 0
+    for index, event in enumerate(state.events):
+        if event.get("type") != event_type:
+            continue
+        seen += 1
+        if seen == occurrence:
+            return index
+    return None
+
+
+def _continuous_overlap_terminal_is_outcome(
+    state: DemoState,
+    *,
+    validation_mode: str,
+    model_unit_ready_while_active: bool,
+    before_created: int,
+    before_model_listen: int,
+) -> bool:
+    """Accept current-response termination as a model-policy overlap outcome."""
+    return (
+        validation_mode == "model-policy"
+        and model_unit_ready_while_active
+        and state.count("response.created") == before_created
+        and state.model_listen_count == before_model_listen
+    )
+
+
+async def _send_listen_only_overlap_pair(
+    ws,
+    state: DemoState,
+    first_pcm16: bytes,
+    second_pcm16: bytes,
+    *,
+    transcripts: tuple[str, str],
+    durations_ms: tuple[int | None, int | None],
+    chunk_ms: int,
+    timeout_s: float,
+    send_transcript_hint: bool,
+    realtime_input: bool,
+    model_policy_settle_s: float,
+    validation_mode: str,
+    silence_ms: int,
+    frame_b64: str | None = None,
+) -> tuple[list[str | None], list[str], bool]:
+    if not realtime_input:
+        raise ValueError("listen-only-overlap requires --realtime-input")
+
+    before_first_created = state.count("response.created")
+    observed_first_created = before_first_created
+    observed_first_listen = state.model_listen_count
+
+    async def continue_until_first_speak() -> bool:
+        nonlocal observed_first_created, observed_first_listen
+        outcome = await _wait_for_model_policy_outcome(
+            state,
+            before_created=observed_first_created,
+            before_model_listen=observed_first_listen,
+            timeout_s=timeout_s,
+            listen_settle_s=model_policy_settle_s,
+            label=f"{transcripts[0]} model-unit speak/listen decision",
+        )
+        observed_first_created = state.count("response.created")
+        observed_first_listen = state.model_listen_count
+        return outcome != "speak"
+
+    first_input = _select_turn_audio(first_pcm16, durations_ms[0]) + _pcm16_silence(silence_ms)
+    await _send_pcm16(
+        ws,
+        first_input,
+        chunk_ms=chunk_ms,
+        realtime_delay=True,
+        hints={"transcript": transcripts[0]} if send_transcript_hint else {},
+        on_model_unit_ready=continue_until_first_speak,
+        frame_b64=frame_b64,
+    )
+    state.input_commit_sent_at_s.append(time.monotonic())
+    await ws.send(json.dumps({"type": "input_audio_buffer.commit", "final": True}))
+    await _wait_for(
+        state,
+        lambda: state.count("response.created") > before_first_created,
+        timeout_s=timeout_s,
+        label=f"{transcripts[0]} response.created",
+    )
+    first_response_id = state.response_ids[before_first_created]
+    await _wait_for(
+        state,
+        lambda: state.response_audio_delta_count(first_response_id) > 0,
+        timeout_s=timeout_s,
+        label=f"{transcripts[0]} response.audio.delta",
+    )
+    if state.response_done(first_response_id):
+        raise RuntimeError("first response completed before overlap input could start")
+
+    before_second_created = state.count("response.created")
+    before_second_listen = state.model_listen_count
+    overlap_started_while_active = not state.response_done(first_response_id)
+    model_unit_ready_while_active = False
+    second_unit_event_index: int | None = None
+
+    def record_model_unit_ready() -> None:
+        nonlocal model_unit_ready_while_active, second_unit_event_index
+        model_unit_ready_while_active = not state.response_done(first_response_id)
+        if model_unit_ready_while_active:
+            second_unit_event_index = len(state.events)
+
+    await _send_pcm16(
+        ws,
+        _select_turn_audio(second_pcm16, durations_ms[1]),
+        chunk_ms=chunk_ms,
+        realtime_delay=True,
+        hints={"transcript": transcripts[1]} if send_transcript_hint else {},
+        on_model_unit_ready=record_model_unit_ready,
+        frame_b64=frame_b64,
+    )
+    state.input_commit_sent_at_s.append(time.monotonic())
+    await ws.send(json.dumps({"type": "input_audio_buffer.commit", "final": True}))
+
+    await _wait_for(
+        state,
+        lambda: state.response_done(first_response_id),
+        timeout_s=timeout_s,
+        label=f"{transcripts[0]} response.done",
+    )
+    await _ack_response_playback(
+        ws,
+        state,
+        first_response_id,
+        timeout_s=timeout_s,
+        label=transcripts[0],
+    )
+
+    if _continuous_overlap_terminal_is_outcome(
+        state,
+        validation_mode=validation_mode,
+        model_unit_ready_while_active=model_unit_ready_while_active,
+        before_created=before_second_created,
+        before_model_listen=before_second_listen,
+    ):
+        second_outcome = "continuous_terminal"
+    else:
+        second_outcome = await _wait_for_model_policy_outcome(
+            state,
+            before_created=before_second_created,
+            before_model_listen=before_second_listen,
+            timeout_s=timeout_s,
+            listen_settle_s=model_policy_settle_s,
+            label=f"{transcripts[1]} model speak/listen decision",
+        )
+    second_response_id: str | None = None
+    if second_outcome == "speak":
+        second_response_id = state.response_ids[before_second_created]
+        await _wait_for(
+            state,
+            lambda: state.response_done(second_response_id),
+            timeout_s=timeout_s,
+            label=f"{transcripts[1]} response.done",
+        )
+        await _ack_response_playback(
+            ws,
+            state,
+            second_response_id,
+            timeout_s=timeout_s,
+            label=transcripts[1],
+        )
+
+    first_done_index = _event_index_for_response(state, "response.done", first_response_id)
+    overlap_ok = (
+        overlap_started_while_active
+        and model_unit_ready_while_active
+        and second_unit_event_index is not None
+        and first_done_index is not None
+        and second_unit_event_index < first_done_index
+    )
+    return [first_response_id, second_response_id], ["speak", second_outcome], overlap_ok
+
+
+async def run_demo(args: argparse.Namespace) -> dict[str, object]:
+    demo_frame_b64: str | None = None
+    if getattr(args, "frame_image", None):
+        demo_frame_b64 = base64.b64encode(Path(args.frame_image).read_bytes()).decode("ascii")
+    turn_input_paths = _turn_input_paths(
+        Path(args.input_wav),
+        list(getattr(args, "turn_input_wav", []) or []),
+        turns=args.turns,
+    )
+    turn_pcm16 = [_read_wav_pcm16(path) for path in turn_input_paths]
+    if any(not pcm16 for pcm16 in turn_pcm16):
+        raise ValueError("input WAV has no audio")
+    turn_durations = _turn_durations(
+        list(getattr(args, "turn_duration_ms", []) or []),
+        turns=args.turns,
+        first_turn_ms=args.first_turn_ms,
+    )
+    expected_empty_turns = set(getattr(args, "expect_empty_turn", []) or [])
+    invalid_empty_turns = sorted(
+        turn_number for turn_number in expected_empty_turns if turn_number < 1 or turn_number > max(1, args.turns)
+    )
+    if invalid_empty_turns:
+        raise ValueError(
+            f"--expect-empty-turn values are 1-based and must refer to an existing turn: {invalid_empty_turns}"
+        )
+    distinct_turn_inputs = _turn_inputs_are_distinct(turn_input_paths, turn_pcm16)
+    if getattr(args, "require_distinct_inputs", False) and not distinct_turn_inputs:
+        raise ValueError("--require-distinct-inputs requires a different WAV path and audio payload for every turn")
+    url = _url_with_model(
+        args.url,
+        args.model,
+        autostart=False if getattr(args, "ref_audio", None) else None,
+        session_id=getattr(args, "session_id", None),
+    )
+    state = DemoState()
+    stop = asyncio.Event()
+    output_dir = Path(args.output_dir)
+    turn_response_ids: list[str | None] = []
+    turn_outcomes: list[str] = []
+    validation_mode = getattr(args, "validation_mode", "response-required")
+    scenario = getattr(args, "scenario", "sequential")
+    transcript_hints_enabled = not getattr(args, "omit_transcript_hints", False)
+    realtime_input = getattr(args, "realtime_input", False)
+    continuous_input = getattr(args, "continuous_input", False)
+    listen_only_overlap_ok = scenario != "listen-only-overlap"
+    if scenario == "listen-only-overlap" and args.turns < 2:
+        raise ValueError("listen-only-overlap requires at least two turns")
+
+    async with websockets.connect(url, max_size=64 * 1024 * 1024) as ws:
+        reader = asyncio.create_task(_reader(ws, state, stop))
+        try:
+            await ws.send(json.dumps(_session_update_event(args)))
+            await _wait_for(state, lambda: state.count("session.created") > 0, timeout_s=20, label="session.created")
+
+            turn_transcripts = _turn_transcripts(args.first_turn_transcript, turns=args.turns)
+            turn_specs = list(zip(turn_transcripts, turn_durations, strict=True))
+            if scenario == "listen-only-overlap":
+                turn_response_ids, turn_outcomes, listen_only_overlap_ok = await _send_listen_only_overlap_pair(
+                    ws,
+                    state,
+                    turn_pcm16[0],
+                    turn_pcm16[1],
+                    transcripts=(turn_specs[0][0], turn_specs[1][0]),
+                    durations_ms=(turn_specs[0][1], turn_specs[1][1]),
+                    chunk_ms=args.chunk_ms,
+                    timeout_s=args.timeout_s,
+                    send_transcript_hint=transcript_hints_enabled,
+                    realtime_input=realtime_input,
+                    model_policy_settle_s=max(0.0, args.model_policy_settle_ms / 1000),
+                    validation_mode=validation_mode,
+                    silence_ms=max(0, args.silence_ms),
+                    frame_b64=demo_frame_b64,
+                )
+                for turn_index in range(2, len(turn_specs)):
+                    transcript, duration_ms = turn_specs[turn_index]
+                    response_id, outcome = await _send_clean_turn(
+                        ws,
+                        state,
+                        turn_pcm16[turn_index],
+                        transcript=transcript,
+                        duration_ms=duration_ms,
+                        chunk_ms=args.chunk_ms,
+                        timeout_s=args.timeout_s,
+                        require_audio=args.require_audio and (turn_index + 1) not in expected_empty_turns,
+                        validation_mode=validation_mode,
+                        send_transcript_hint=transcript_hints_enabled,
+                        realtime_input=realtime_input,
+                        model_policy_settle_s=max(0.0, args.model_policy_settle_ms / 1000),
+                        commit_input=not continuous_input,
+                        frame_b64=demo_frame_b64,
+                    )
+                    turn_response_ids.append(response_id)
+                    turn_outcomes.append(outcome)
+            else:
+                for turn_index, (transcript, duration_ms) in enumerate(turn_specs):
+                    response_id, outcome = await _send_clean_turn(
+                        ws,
+                        state,
+                        turn_pcm16[turn_index],
+                        transcript=transcript,
+                        duration_ms=duration_ms,
+                        chunk_ms=args.chunk_ms,
+                        timeout_s=args.timeout_s,
+                        require_audio=args.require_audio and (turn_index + 1) not in expected_empty_turns,
+                        validation_mode=validation_mode,
+                        send_transcript_hint=transcript_hints_enabled,
+                        realtime_input=realtime_input,
+                        model_policy_settle_s=max(0.0, args.model_policy_settle_ms / 1000),
+                        commit_input=not continuous_input,
+                        frame_b64=demo_frame_b64,
+                    )
+                    turn_response_ids.append(response_id)
+                    turn_outcomes.append(outcome)
+
+            if validation_mode == "model-policy":
+                await _drain_model_policy_responses(
+                    ws,
+                    state,
+                    timeout_s=args.timeout_s,
+                    settle_s=max(0.0, args.model_policy_settle_ms / 1000),
+                )
+            await _ack_all_completed_response_playback(
+                ws,
+                state,
+                timeout_s=args.timeout_s,
+            )
+            await ws.send(json.dumps({"type": "session.close"}))
+            await _wait_for(state, lambda: state.count("session.closed") > 0, timeout_s=20, label="session.closed")
+        finally:
+            if state.count("session.created") > 0 and state.count("session.closed") == 0:
+                try:
+                    await ws.send(json.dumps({"type": "session.close"}))
+                    await _wait_for(
+                        state,
+                        lambda: state.count("session.closed") > 0,
+                        timeout_s=min(args.timeout_s, 5),
+                        label="session.closed during cleanup",
+                    )
+                except (ConnectionClosed, TimeoutError):
+                    pass
+            stop.set()
+            reader.cancel()
+            try:
+                await reader
+            except asyncio.CancelledError:
+                pass
+            _write_demo_artifacts(state, output_dir, output_audio_format=args.output_audio_format)
+
+    overlap_barge_in = any(decision.get("action") == "barge_in" for decision in state.overlap_decisions)
+    expected_turns = max(1, args.turns)
+    event_order_ok = (
+        state.model_policy_event_order_ok(
+            expected_turns=expected_turns,
+            require_input_commit=not continuous_input,
+        )
+        if validation_mode == "model-policy"
+        else state.event_order_ok(
+            require_input_commit=not continuous_input,
+            require_commit_before_response=False,
+        )
+    )
+    input_transcription_ok = _input_transcription_ok(
+        state.input_transcription_count,
+        transcript_hints_enabled=transcript_hints_enabled and not continuous_input,
+    )
+    model_speak_event_ok = state.model_speak_before_audio_ok()
+    realtime_audio_lifecycle_ok = state.count("response.audio.delta") > 0 and state.count("response.audio.done") > 0
+    completed_response_ids = state.completed_response_ids()
+    observed_turn_response_ids = [response_id for response_id in turn_response_ids if isinstance(response_id, str)]
+    expected_empty_response_ids = {
+        response_id
+        for turn_number in expected_empty_turns
+        if turn_number <= len(turn_response_ids)
+        and isinstance((response_id := turn_response_ids[turn_number - 1]), str)
+    }
+    transcript_integrity = _evaluate_transcript_integrity(
+        state,
+        observed_turn_response_ids,
+        expected_empty_response_ids=expected_empty_response_ids,
+        require_cross_turn_independence=_requires_cross_turn_independence(
+            validation_mode=validation_mode,
+            distinct_inputs_required=getattr(args, "require_distinct_inputs", False),
+        ),
+        require_terminal_punctuation=getattr(args, "require_distinct_inputs", False),
+    )
+    response_speak_contract = _evaluate_response_speak_contract(state)
+    expected_audio_turns = expected_turns - len(expected_empty_turns)
+    lifecycle_counts_ok = (
+        state.count("response.created") == state.count("response.done")
+        and len(state.response_ids) == len(completed_response_ids)
+        and len(completed_response_ids) == len(set(completed_response_ids))
+        and state.count("response.audio.done") <= state.count("response.done")
+        and _response_cardinality_ok(
+            completed_response_ids,
+            expected_turns=expected_turns,
+            validation_mode=validation_mode,
+        )
+    )
+    turn_outcomes_ok = len(turn_outcomes) == expected_turns and (
+        validation_mode == "model-policy" or all(outcome == "speak" for outcome in turn_outcomes)
+    )
+    clean_turn_audio_ok = all(
+        state.response_audio_delta_count(response_id) > 0
+        for response_id in observed_turn_response_ids
+        if response_id not in expected_empty_response_ids
+    )
+    playback_history_committed_ok = _all_response_playback_history_committed(
+        state,
+        completed_response_ids,
+    )
+    if validation_mode == "response-required":
+        full_audio_response_ok = (
+            len(observed_turn_response_ids) == expected_audio_turns + len(expected_empty_turns)
+            and clean_turn_audio_ok
+            and model_speak_event_ok
+            and state.model_speak_delta_count > 0
+            and realtime_audio_lifecycle_ok
+            and state.audio_marks_seen
+        )
+    else:
+        full_audio_response_ok = not observed_turn_response_ids or (
+            realtime_audio_lifecycle_ok and state.model_speak_delta_count > 0
+        )
+    stale_audio_delta_count = state.stale_audio_delta_count()
+    terminal_activity_ok = state.count("response.done") > 0 or (
+        validation_mode == "model-policy" and state.model_listen_count > 0
+    )
+    all_audio_responses_have_transcript = (
+        validation_mode != "response-required"
+        or _all_audio_responses_have_transcript(
+            state,
+            completed_response_ids,
+        )
+    )
+    unexpected_error_events = _unexpected_error_events(state)
+    continuous_input_ok = not continuous_input or state.count("input_audio_buffer.committed") == 0
+    result = {
+        "ok": terminal_activity_ok
+        and state.count("session.closed") > 0
+        and state.cancelled_count == 0
+        and not overlap_barge_in
+        and state.truncate_count == 0
+        and event_order_ok
+        and input_transcription_ok
+        and stale_audio_delta_count == 0
+        and lifecycle_counts_ok
+        and turn_outcomes_ok
+        and full_audio_response_ok,
+        "event_counts": {
+            event_type: state.count(event_type)
+            for event_type in sorted({str(event.get("type")) for event in state.events})
+        },
+        "audio_delta_count": len(state.audio_deltas),
+        "done_count": state.done_count,
+        "cancelled_count": state.cancelled_count,
+        "listen_count": state.listen_count,
+        "model_listen_count": state.model_listen_count,
+        "buffering_listen_count": state.buffering_listen_count,
+        "model_speak_event_count": state.model_speak_event_count,
+        "model_speak_delta_count": state.model_speak_delta_count,
+        "playback_ack_count": state.playback_ack_count,
+        "playback_history_committed_count": state.playback_history_committed_count,
+        "playback_history_committed_ok": playback_history_committed_ok,
+        "truncate_count": state.truncate_count,
+        "input_transcription_count": state.input_transcription_count,
+        "audio_marks_seen": state.audio_marks_seen,
+        "overlap_decisions": state.overlap_decisions,
+        "overlap_barge_in": overlap_barge_in,
+        "event_order_ok": event_order_ok,
+        "terminal_activity_ok": terminal_activity_ok,
+        "input_transcription_ok": input_transcription_ok,
+        "completed_response_ids": completed_response_ids,
+        "response_timings": state.response_timing_summaries(),
+        "lifecycle_counts_ok": lifecycle_counts_ok,
+        "validation_mode": validation_mode,
+        "scenario": scenario,
+        "listen_only_overlap_ok": listen_only_overlap_ok,
+        "transcript_hints_enabled": transcript_hints_enabled,
+        "realtime_input": realtime_input,
+        "continuous_input": continuous_input,
+        "continuous_input_ok": continuous_input_ok,
+        "input_chunk_ms": args.chunk_ms,
+        "model_policy_settle_ms": args.model_policy_settle_ms,
+        "turn_outcomes": turn_outcomes,
+        "turn_outcomes_ok": turn_outcomes_ok,
+        "clean_turn_audio_ok": clean_turn_audio_ok,
+        "full_audio_response_ok": full_audio_response_ok,
+        "model_speak_event_ok": model_speak_event_ok,
+        "realtime_audio_lifecycle_ok": realtime_audio_lifecycle_ok,
+        "stale_audio_delta_count": stale_audio_delta_count,
+        "all_audio_responses_have_transcript": all_audio_responses_have_transcript,
+        "distinct_turn_inputs": distinct_turn_inputs,
+        "error_count": len(unexpected_error_events),
+        "errors": unexpected_error_events,
+        **response_speak_contract,
+        **transcript_integrity,
+        "turn_inputs": [
+            {
+                "path": str(path),
+                "source_duration_ms": len(pcm16) * 1000 // (PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE),
+                "requested_duration_ms": duration_ms,
+                "sent_duration_ms": len(_select_turn_audio(pcm16, duration_ms))
+                * 1000
+                // (PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE),
+            }
+            for path, pcm16, duration_ms in zip(turn_input_paths, turn_pcm16, turn_durations, strict=True)
+        ],
+        "output_dir": str(output_dir),
+    }
+    result["ok"] = bool(
+        result["ok"]
+        and transcript_integrity["transcript_delta_done_ok"]
+        and transcript_integrity["cross_turn_independent_ok"]
+        and transcript_integrity["empty_turns_ok"]
+        and transcript_integrity["nonempty_audio_has_transcript_ok"]
+        and transcript_integrity["terminal_punctuation_ok"]
+        and all_audio_responses_have_transcript
+        and playback_history_committed_ok
+        and listen_only_overlap_ok
+        and not unexpected_error_events
+        and response_speak_contract["response_speak_contract_ok"]
+        and continuous_input_ok
+        and (distinct_turn_inputs or not getattr(args, "require_distinct_inputs", False))
+    )
+    return result
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://localhost:8099/v1/realtime?duplex=1")
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument("--session-id", help="Use an explicit public session ID, including for close/reopen tests.")
+    parser.add_argument("--input-wav", required=True)
+    parser.add_argument("--ref-audio", help="Optional WAV used as the MiniCPM-o voice prompt.")
+    parser.add_argument(
+        "--frame-image",
+        default=None,
+        help="Optional image file sent as an omni-duplex camera frame (one per 1 s of audio)",
+    )
+    parser.add_argument(
+        "--turn-input-wav",
+        action="append",
+        default=[],
+        help="WAV for each turn after the first; repeat exactly turns-1 times.",
+    )
+    parser.add_argument("--output-dir", default="/tmp/minicpmo_realtime_duplex_demo")
+    parser.add_argument(
+        "--output-audio-format",
+        default="pcm16",
+        choices=["pcm16", "wav", "g711_ulaw", "g711_alaw"],
+    )
+    parser.add_argument("--chunk-ms", type=int, default=200)
+    parser.add_argument(
+        "--model-policy-settle-ms",
+        type=int,
+        default=2000,
+        help="Wait for a delayed response.created after model-listen and before closing the session.",
+    )
+    parser.add_argument("--first-turn-ms", type=int, default=1400)
+    parser.add_argument(
+        "--turn-duration-ms",
+        action="append",
+        type=int,
+        default=[],
+        help="Audio duration for each turn; repeat turns times. Use 0 to send the complete WAV.",
+    )
+    parser.add_argument("--first-turn-transcript", default="demo input speech")
+    parser.add_argument(
+        "--omit-transcript-hints",
+        action="store_true",
+        help="Keep local turn labels but do not send transcript hints to the server.",
+    )
+    parser.add_argument(
+        "--realtime-input",
+        action="store_true",
+        help="Pace each input chunk according to its audio duration.",
+    )
+    parser.add_argument(
+        "--continuous-input",
+        action="store_true",
+        help="Model-owned browser mode: stream PCM continuously without input_audio_buffer.commit.",
+    )
+    parser.add_argument(
+        "--scenario",
+        choices=["sequential", "listen-only-overlap"],
+        default="sequential",
+        help="Run sequential turns or stream turn 2 while turn 1 audio is active without interruption.",
+    )
+    parser.add_argument(
+        "--validation-mode",
+        choices=["model-policy", "response-required"],
+        default="response-required",
+        help="Allow model listen decisions, or require at least one response for every input turn.",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=None,
+        help="Stage0 sampling temperature; response-required defaults to deterministic sampling.",
+    )
+    parser.add_argument(
+        "--require-distinct-inputs",
+        action="store_true",
+        help="Require distinct WAV paths and audio payloads, and reject cross-turn transcript reuse.",
+    )
+    parser.add_argument(
+        "--expect-empty-turn",
+        action="append",
+        type=int,
+        default=[],
+        help="1-based turn expected to end without text or audio; repeat for multiple turns.",
+    )
+    parser.add_argument("--short-ack-ms", type=int, default=350)
+    parser.add_argument("--silence-ms", type=int, default=500)
+    parser.add_argument("--playback-ack-ms", type=int, default=500)
+    parser.add_argument("--turns", type=int, default=3)
+    parser.add_argument("--timeout-s", type=float, default=60.0)
+    parser.add_argument(
+        "--require-audio",
+        action="store_true",
+        help="Fail if the first native response listens instead of producing audio.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    result = asyncio.run(run_demo(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    if not result["ok"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/online_serving/personaplex_realtime_duplex.py b/tests/e2e/online_serving/personaplex_realtime_duplex.py
new file mode 100644
index 000000000..62ad9e972
--- /dev/null
+++ b/tests/e2e/online_serving/personaplex_realtime_duplex.py
@@ -0,0 +1,492 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Strict PersonaPlex validation for the unified OpenAI Realtime duplex path."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import json
+import math
+import uuid
+import wave
+from collections.abc import Sequence
+from pathlib import Path
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.client import (
+    RealtimeDuplexClient,
+    wait_for,
+    write_pcm16_wav,
+)
+
+SAMPLE_RATE_HZ = 24_000
+FRAME_SAMPLES = 1_920
+FRAME_PERIOD_S = FRAME_SAMPLES / SAMPLE_RATE_HZ
+
+
+def _input_identity(
+    path: Path,
+    *,
+    expected_sha256: str | None,
+) -> dict[str, str]:
+    resolved = path.resolve()
+    digest = hashlib.sha256()
+    with resolved.open("rb") as input_file:
+        for chunk in iter(lambda: input_file.read(1024 * 1024), b""):
+            digest.update(chunk)
+    actual = digest.hexdigest()
+    if expected_sha256 is not None and actual != expected_sha256.lower():
+        raise ValueError(
+            f"input WAV SHA-256 mismatch: expected={expected_sha256.lower()}, actual={actual}, path={resolved}"
+        )
+    return {"path": str(resolved), "sha256": actual}
+
+
+def _realtime_url(base_url: str, model: str, session_id: str) -> str:
+    parts = urlsplit(base_url)
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query.update(duplex="1", model=model, autostart="0", session_id=session_id)
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+
+
+def _read_wav_as_float32(path: Path) -> np.ndarray:
+    with wave.open(str(path), "rb") as wav_file:
+        channels = wav_file.getnchannels()
+        sample_width = wav_file.getsampwidth()
+        source_rate = wav_file.getframerate()
+        frames = wav_file.readframes(wav_file.getnframes())
+    dtypes = {1: np.uint8, 2: np.dtype("<i2"), 4: np.dtype("<i4")}
+    if sample_width not in dtypes:
+        raise ValueError(f"unsupported WAV sample width: {sample_width}")
+    pcm = np.frombuffer(frames, dtype=dtypes[sample_width]).astype(np.float32)
+    if sample_width == 1:
+        pcm = (pcm - 128.0) / 128.0
+    else:
+        pcm /= float(1 << (sample_width * 8 - 1))
+    if channels > 1:
+        pcm = pcm.reshape(-1, channels).mean(axis=1)
+    if source_rate != SAMPLE_RATE_HZ and pcm.size:
+        output_samples = max(1, round(pcm.size * SAMPLE_RATE_HZ / source_rate))
+        pcm = np.interp(
+            np.linspace(0, pcm.size - 1, output_samples),
+            np.arange(pcm.size),
+            pcm,
+        ).astype(np.float32)
+    pcm = np.ascontiguousarray(pcm, dtype="<f4")
+    if not pcm.size or not np.isfinite(pcm).all():
+        raise ValueError("input WAV must contain finite audio")
+    return pcm
+
+
+def _events(client: RealtimeDuplexClient, event_type: str) -> list[dict[str, object]]:
+    return [event for event in client.events.events if event.get("type") == event_type]
+
+
+async def _open_session(
+    args: argparse.Namespace,
+    *,
+    session_id: str,
+    persona: str,
+    expect_error: bool = False,
+) -> tuple[RealtimeDuplexClient, dict[str, object]]:
+    client = RealtimeDuplexClient(_realtime_url(args.url, args.model, session_id))
+    await client.__aenter__()
+    await client.send(
+        {
+            "type": "session.update",
+            "session": {
+                "session_id": session_id,
+                "model": args.model,
+                "modalities": ["audio", "text"],
+                "input_audio_format": "pcm_f32le",
+                "output_audio_format": "pcm16",
+                "voice": args.voice,
+                "instructions": persona,
+                "turn_detection": None,
+                "extra_body": {"auto_response": True},
+            },
+        }
+    )
+    event_type = "error" if expect_error else "session.created"
+    await wait_for(
+        lambda: client.events.count(event_type) > 0,
+        timeout_s=args.timeout_s,
+        label=event_type,
+    )
+    return client, _events(client, event_type)[-1]
+
+
+async def _close_session(client: RealtimeDuplexClient, *, timeout_s: float) -> None:
+    await client.send({"type": "session.close"})
+    await wait_for(
+        lambda: client.events.count("session.closed") > 0,
+        timeout_s=timeout_s,
+        label="session.closed",
+    )
+    await client.__aexit__(None, None, None)
+
+
+async def _stream_frames(
+    client: RealtimeDuplexClient,
+    pcm: np.ndarray,
+    *,
+    max_frames: int | None = None,
+) -> int:
+    frame_count = math.ceil(pcm.size / FRAME_SAMPLES)
+    if max_frames is not None:
+        if max_frames < 0:
+            raise ValueError(f"max_frames must be non-negative, got {max_frames}")
+        if max_frames > 0:
+            frame_count = min(frame_count, max_frames)
+    for seq in range(frame_count):
+        frame = pcm[seq * FRAME_SAMPLES : (seq + 1) * FRAME_SAMPLES]
+        frame = np.pad(frame, (0, FRAME_SAMPLES - frame.size))
+        frame = np.ascontiguousarray(frame, dtype="<f4")
+        await client.send(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": base64.b64encode(frame).decode("ascii"),
+                "format": "pcm_f32le",
+                "sample_rate_hz": SAMPLE_RATE_HZ,
+                "duration_ms": 80,
+                "audio_end_ms": (seq + 1) * 80,
+                "is_speech": bool(np.sqrt(np.mean(np.square(frame))) >= 1e-4),
+            }
+        )
+        await asyncio.sleep(FRAME_PERIOD_S)
+    return frame_count
+
+
+def _audio_frame_stats(
+    raw: bytes,
+    *,
+    input_frames: int,
+    voiced_frame_rms_threshold: float,
+) -> dict[str, int | float]:
+    pcm = np.frombuffer(raw, dtype="<i2")
+    if pcm.size % FRAME_SAMPLES:
+        raise AssertionError(
+            "PersonaPlex output must contain whole 80 ms codec frames: "
+            f"samples={pcm.size}, samples_per_frame={FRAME_SAMPLES}"
+        )
+    output_frames = pcm.size // FRAME_SAMPLES
+    frames = pcm.astype(np.float32).reshape(output_frames, FRAME_SAMPLES) / 32768.0
+    voiced_frames = int(np.count_nonzero(np.sqrt(np.mean(np.square(frames), axis=1)) >= voiced_frame_rms_threshold))
+    return {
+        "output_frames": int(output_frames),
+        "voiced_frames": voiced_frames,
+        "silent_frames": int(output_frames - voiced_frames),
+        "frame_deficit": int(input_frames - output_frames),
+        "frame_coverage_ratio": float(output_frames / input_frames),
+    }
+
+
+def _response_ids(client: RealtimeDuplexClient) -> set[str]:
+    return {
+        str(event["response_id"])
+        for event in _events(client, "response.audio.delta")
+        if isinstance(event.get("response_id"), str)
+    }
+
+
+def _session_result(
+    client: RealtimeDuplexClient,
+    *,
+    input_frames: int,
+    args: argparse.Namespace,
+    minimum_chunks: int,
+) -> tuple[bytes, set[str], dict[str, object]]:
+    chunks = sum(len(items) for items in client.events.response_audio.values())
+    raw = client.events.audio_bytes()
+    if chunks < minimum_chunks or not raw or len(raw) % 2:
+        raise AssertionError(f"invalid PCM16 output: chunks={chunks}, bytes={len(raw)}")
+    pcm = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    rms = float(np.sqrt(np.mean(np.square(pcm))))
+    # This low floor only catches corrupt, non-finite, or effectively zero PCM.
+    # Audible speech is checked per frame below with the higher 1e-3 default.
+    if not np.isfinite(pcm).all() or rms <= 1e-5:
+        raise AssertionError(f"output audio is non-finite or silent: samples={pcm.size}, rms={rms}")
+    rates = {
+        int(event["sample_rate_hz"])
+        for event in _events(client, "response.audio.delta")
+        if isinstance(event.get("sample_rate_hz"), int)
+    }
+    if rates != {SAMPLE_RATE_HZ}:
+        raise AssertionError(f"unexpected output sample rates: {sorted(rates)}")
+    stats = _audio_frame_stats(
+        raw,
+        input_frames=input_frames,
+        voiced_frame_rms_threshold=args.voiced_frame_rms_threshold,
+    )
+    if not 0 <= int(stats["frame_deficit"]) <= args.max_frame_deficit:
+        raise AssertionError(f"invalid synchronous frame accounting: input={input_frames}, stats={stats}")
+    min_voiced_frames = int(args.min_voiced_frames)
+    if min_voiced_frames < 1:
+        raise ValueError(f"min_voiced_frames must be positive, got {min_voiced_frames}")
+    if int(stats["voiced_frames"]) < min_voiced_frames:
+        raise AssertionError(
+            f"output contained insufficient audible speech: minimum_voiced_frames={min_voiced_frames}, stats={stats}"
+        )
+    runtime_metadata = [
+        metadata["vllm_omni"]
+        for event in _events(client, "response.audio.delta")
+        if isinstance((metadata := event.get("metadata")), dict) and isinstance(metadata.get("vllm_omni"), dict)
+    ]
+    if not any(
+        item.get("runtime_impl") == "scheduler_data_plane"
+        and item.get("uses_model_runner_scheduler") is True
+        and item.get("runner_kv_backed") is True
+        for item in runtime_metadata
+    ):
+        raise AssertionError(f"audio events did not prove the scheduler data plane: {runtime_metadata}")
+    response_ids = _response_ids(client)
+    if len(response_ids) != 1:
+        raise AssertionError(f"continuous stream used multiple responses: {sorted(response_ids)}")
+    return (
+        raw,
+        response_ids,
+        {
+            **stats,
+            "audio_chunks": chunks,
+            "audio_samples": len(raw) // 2,
+            "audio_rms": rms,
+            "response_ids": sorted(response_ids),
+        },
+    )
+
+
+def _capabilities(created: dict[str, object]) -> dict[str, object]:
+    session = created.get("session")
+    capabilities = session.get("capabilities") if isinstance(session, dict) else None
+    if not isinstance(capabilities, dict):
+        raise AssertionError(f"session.created omitted capabilities: {created}")
+    return capabilities
+
+
+def _save(output_dir: Path, name: str, client: RealtimeDuplexClient, raw: bytes) -> None:
+    (output_dir / f"{name}-events.jsonl").write_text(
+        "".join(json.dumps(event, ensure_ascii=False) + "\n" for event in client.events.events),
+        encoding="utf-8",
+    )
+    write_pcm16_wav(output_dir / f"{name}-output.wav", raw, sample_rate_hz=SAMPLE_RATE_HZ)
+
+
+async def run(args: argparse.Namespace) -> dict[str, object]:
+    input_path = Path(args.input_wav)
+    input_identity = _input_identity(
+        input_path,
+        expected_sha256=args.expected_input_sha256,
+    )
+    pcm = _read_wav_as_float32(input_path)
+    if args.tail_s > 0:
+        pcm = np.concatenate([pcm, np.zeros(round(args.tail_s * SAMPLE_RATE_HZ), dtype=np.float32)])
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    ids = {name: f"personaplex-{name}-{uuid.uuid4().hex}" for name in ("primary", "secondary", "replacement")}
+    primary, created = await _open_session(args, session_id=ids["primary"], persona=args.persona)
+    secondary, secondary_created = await _open_session(
+        args,
+        session_id=ids["secondary"],
+        persona=args.secondary_persona,
+    )
+    capabilities = _capabilities(created)
+    if _capabilities(secondary_created) != capabilities:
+        raise AssertionError("concurrent sessions returned different capabilities")
+    expected_capabilities = {
+        "implementation_level": "model_native_duplex",
+        "chunk_period_ms": 80,
+        "supports_multi_session": True,
+        "supports_multi_session_same_replica": True,
+        "supports_barge_in": False,
+    }
+    if any(capabilities.get(key) != value for key, value in expected_capabilities.items()):
+        raise AssertionError(f"unexpected PersonaPlex capabilities: {capabilities}")
+
+    overflow, error = await _open_session(
+        args,
+        session_id=f"personaplex-overflow-{uuid.uuid4().hex}",
+        persona=args.persona,
+        expect_error=True,
+    )
+    error_body = error.get("error")
+    overflow_code = error_body.get("code") if isinstance(error_body, dict) else error.get("code")
+    await overflow.__aexit__(None, None, None)
+    if overflow_code != "resource_exhausted":
+        raise AssertionError(f"overflow session was not rejected: {error}")
+
+    primary_frames, secondary_frames = await asyncio.gather(
+        _stream_frames(primary, pcm),
+        _stream_frames(secondary, pcm),
+    )
+    await asyncio.gather(
+        wait_for(
+            lambda: len(primary.events.audio_bytes()) // (2 * FRAME_SAMPLES) >= primary_frames - args.max_frame_deficit,
+            timeout_s=args.timeout_s,
+            label="primary frame coverage",
+        ),
+        wait_for(
+            lambda: (
+                len(secondary.events.audio_bytes()) // (2 * FRAME_SAMPLES) >= secondary_frames - args.max_frame_deficit
+            ),
+            timeout_s=args.timeout_s,
+            label="secondary frame coverage",
+        ),
+    )
+    await asyncio.sleep(args.drain_s)
+    primary_audio, primary_response_ids, primary_stats = _session_result(
+        primary,
+        input_frames=primary_frames,
+        args=args,
+        minimum_chunks=args.minimum_audio_chunks,
+    )
+    secondary_audio, secondary_response_ids, _ = _session_result(
+        secondary,
+        input_frames=secondary_frames,
+        args=args,
+        minimum_chunks=args.minimum_audio_chunks,
+    )
+    if primary_response_ids & secondary_response_ids:
+        raise AssertionError("concurrent sessions shared a response id")
+    _save(output_dir, "primary", primary, primary_audio)
+    await _close_session(primary, timeout_s=args.timeout_s)
+
+    replacement, replacement_created = await _open_session(
+        args,
+        session_id=ids["replacement"],
+        persona=args.replacement_persona,
+    )
+    if _capabilities(replacement_created) != capabilities:
+        raise AssertionError("replacement session returned different capabilities")
+    continuation_frames, replacement_frames = await asyncio.gather(
+        _stream_frames(secondary, pcm, max_frames=args.replacement_frames),
+        _stream_frames(replacement, pcm, max_frames=args.replacement_frames),
+    )
+    secondary_total_frames = secondary_frames + continuation_frames
+    await asyncio.gather(
+        wait_for(
+            lambda: (
+                len(secondary.events.audio_bytes()) // (2 * FRAME_SAMPLES)
+                >= secondary_total_frames - args.max_frame_deficit
+            ),
+            timeout_s=args.timeout_s,
+            label="survivor frame coverage after slot recycle",
+        ),
+        wait_for(
+            lambda: (
+                len(replacement.events.audio_bytes()) // (2 * FRAME_SAMPLES)
+                >= replacement_frames - args.max_frame_deficit
+            ),
+            timeout_s=args.timeout_s,
+            label="replacement frame coverage",
+        ),
+    )
+    await asyncio.sleep(args.drain_s)
+    secondary_audio, secondary_after_ids, secondary_stats = _session_result(
+        secondary,
+        input_frames=secondary_total_frames,
+        args=args,
+        minimum_chunks=args.minimum_audio_chunks + 1,
+    )
+    replacement_audio, replacement_response_ids, replacement_stats = _session_result(
+        replacement,
+        input_frames=replacement_frames,
+        args=args,
+        minimum_chunks=1,
+    )
+    if secondary_after_ids != secondary_response_ids:
+        raise AssertionError("survivor response changed while another session slot was recycled")
+    if replacement_response_ids & (primary_response_ids | secondary_response_ids):
+        raise AssertionError("replacement session reused another session's response id")
+    _save(output_dir, "secondary", secondary, secondary_audio)
+    _save(output_dir, "replacement", replacement, replacement_audio)
+    await asyncio.gather(
+        _close_session(secondary, timeout_s=args.timeout_s),
+        _close_session(replacement, timeout_s=args.timeout_s),
+    )
+
+    errors = primary.events.errors() + secondary.events.errors() + replacement.events.errors()
+    result = {
+        "ok": not errors,
+        "model": args.model,
+        "input": {**input_identity, "tail_s": args.tail_s},
+        "capabilities": capabilities,
+        "overflow_error_code": overflow_code,
+        "primary": {"session_id": ids["primary"], "input_frames": primary_frames, **primary_stats},
+        "secondary": {
+            "session_id": ids["secondary"],
+            "input_frames": secondary_total_frames,
+            "continuation_frames_after_recycle": continuation_frames,
+            **secondary_stats,
+        },
+        "replacement": {
+            "session_id": ids["replacement"],
+            "input_frames": replacement_frames,
+            **replacement_stats,
+        },
+        "errors": errors,
+        "output_dir": str(output_dir),
+    }
+    (output_dir / "result.json").write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+    if errors:
+        raise AssertionError(f"Realtime sessions emitted errors: {errors}")
+    return result
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://127.0.0.1:8099/v1/realtime?duplex=1")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--input-wav", required=True)
+    parser.add_argument(
+        "--expected-input-sha256",
+        help="Fail before opening sessions when the input WAV does not match this SHA-256.",
+    )
+    parser.add_argument("--output-dir", default="/tmp/personaplex-realtime-duplex")
+    parser.add_argument("--voice", default="NATF2.pt")
+    parser.add_argument("--persona", default="You are a concise and helpful assistant.")
+    parser.add_argument("--secondary-persona", default="You are a calm and precise assistant.")
+    parser.add_argument("--replacement-persona", default="You are a cheerful travel assistant.")
+    parser.add_argument("--tail-s", type=float, default=2.0)
+    parser.add_argument("--drain-s", type=float, default=2.0)
+    parser.add_argument("--timeout-s", type=float, default=180.0)
+    parser.add_argument(
+        "--max-frame-deficit",
+        type=int,
+        default=4,
+        help=(
+            "Maximum unflushed tail frames. PersonaPlex Code2Wav emits five-frame "
+            "chunks, so a session cutoff can leave at most four pending frames."
+        ),
+    )
+    parser.add_argument("--voiced-frame-rms-threshold", type=float, default=1e-3)
+    parser.add_argument(
+        "--min-voiced-frames",
+        type=int,
+        default=5,
+        help=(
+            "Require at least one normal five-frame Code2Wav chunk (400 ms) above "
+            "the per-frame RMS threshold; this detects inaudible output, not speech quality."
+        ),
+    )
+    parser.add_argument("--minimum-audio-chunks", type=int, default=2)
+    parser.add_argument(
+        "--replacement-frames",
+        type=int,
+        default=0,
+        help="Frames sent after slot reuse; 0 replays the full input so the replacement must produce audible output.",
+    )
+    return parser.parse_args(argv)
+
+
+def main() -> None:
+    print(json.dumps(asyncio.run(run(parse_args())), ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py
new file mode 100644
index 000000000..f5539968b
--- /dev/null
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py
@@ -0,0 +1,388 @@
+"""Run two MiniCPM-o Realtime duplex demo processes concurrently.
+
+This E2E driver covers the same process boundary users exercise manually:
+two independent ``realtime_duplex_demo.py`` invocations, two distinct input
+WAVs, and two distinct output directories.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import io
+import json
+import sys
+import uuid
+import wave
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+DEMO_PATH = REPO_ROOT / "examples/online_serving/minicpmo/realtime_duplex_demo.py"
+AUDIO_DELTA_EVENTS = {"response.audio.delta", "response.output_audio.delta"}
+
+
+def _canonical_path(path: str) -> Path:
+    return Path(path).expanduser().resolve(strict=False)
+
+
+def _sha256_file(path: Path) -> str:
+    hasher = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
+def _validate_pair_args(args: argparse.Namespace) -> dict[str, object]:
+    input_a = _canonical_path(args.input_wav_a)
+    input_b = _canonical_path(args.input_wav_b)
+    output_a = _canonical_path(args.output_dir_a)
+    output_b = _canonical_path(args.output_dir_b)
+    if output_a == output_b:
+        raise ValueError("output directories must be different")
+    if not input_a.is_file():
+        raise ValueError(f"input WAV does not exist: {input_a}")
+    if not input_b.is_file():
+        raise ValueError(f"input WAV does not exist: {input_b}")
+    sha_a = _sha256_file(input_a)
+    sha_b = _sha256_file(input_b)
+    if sha_a == sha_b:
+        raise ValueError("input WAV files must have different content")
+    return {
+        "input_wav_a": str(input_a),
+        "input_wav_b": str(input_b),
+        "input_sha256_a": sha_a,
+        "input_sha256_b": sha_b,
+        "output_dir_a": str(output_a),
+        "output_dir_b": str(output_b),
+    }
+
+
+def _event_response_id(event: dict[str, object]) -> str | None:
+    response_id = event.get("response_id")
+    if isinstance(response_id, str):
+        return response_id
+    response = event.get("response")
+    if isinstance(response, dict) and isinstance(response.get("id"), str):
+        return response["id"]
+    return None
+
+
+def _read_json(path: Path) -> dict[str, object]:
+    if not path.is_file():
+        return {}
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return data if isinstance(data, dict) else {}
+
+
+def _read_events(path: Path) -> list[dict[str, object]]:
+    if not path.is_file():
+        return []
+    events: list[dict[str, object]] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        event = json.loads(line)
+        if isinstance(event, dict):
+            events.append(event)
+    return events
+
+
+def _response_ids_from_artifacts(result: dict[str, object], events: list[dict[str, object]]) -> list[str]:
+    response_ids = result.get("response_ids")
+    if isinstance(response_ids, list):
+        ids = [item for item in response_ids if isinstance(item, str)]
+        if ids:
+            return ids
+    seen: list[str] = []
+    for event in events:
+        response_id = _event_response_id(event)
+        if response_id is not None and response_id not in seen:
+            seen.append(response_id)
+    return seen
+
+
+def _audio_delta_duration_ms(event: dict[str, object]) -> float | None:
+    encoded = event.get("delta") or event.get("audio")
+    if not isinstance(encoded, str) or not encoded:
+        return None
+    try:
+        raw = base64.b64decode(encoded)
+    except ValueError:
+        return None
+    fmt = str(event.get("format") or event.get("audio_format") or "pcm16").lower()
+    sample_rate = event.get("sample_rate_hz") or event.get("sample_rate") or 24_000
+    if not isinstance(sample_rate, int | float) or sample_rate <= 0:
+        return None
+    if "wav" in fmt:
+        try:
+            with wave.open(io.BytesIO(raw), "rb") as wav:
+                return round((wav.getnframes() * 1000.0) / wav.getframerate(), 3)
+        except (EOFError, wave.Error):
+            return None
+    bytes_per_sample = 4 if "f32" in fmt else 2
+    return round((len(raw) * 1000.0) / (bytes_per_sample * float(sample_rate)), 3)
+
+
+def _audio_delta_received_at_s(event: dict[str, object]) -> float | None:
+    raw = event.get("_client_received_at_s")
+    if isinstance(raw, int | float):
+        return float(raw)
+    return None
+
+
+def _session_audio_contract_ok(
+    *,
+    audio_delta_count: int,
+    delta_response_ids: list[str],
+    response_ids: list[str],
+    first_audio_delta_before_done: bool,
+) -> bool:
+    if audio_delta_count <= 0 or not response_ids:
+        return False
+    if len(delta_response_ids) != audio_delta_count:
+        return False
+    delta_id_set = set(delta_response_ids)
+    if len(delta_id_set) != 1:
+        return False
+    return first_audio_delta_before_done and next(iter(delta_id_set)) in set(response_ids)
+
+
+def _summarize_session(
+    *,
+    label: str,
+    input_wav: str,
+    output_dir: str,
+    returncode: int,
+    stdout: str,
+    stderr: str,
+) -> dict[str, object]:
+    output_path = Path(output_dir)
+    result = _read_json(output_path / "result.json")
+    events = _read_events(output_path / "events.jsonl")
+    audio_delta_indices = [index for index, event in enumerate(events) if event.get("type") in AUDIO_DELTA_EVENTS]
+    done_indices = [index for index, event in enumerate(events) if event.get("type") == "response.done"]
+    response_ids = _response_ids_from_artifacts(result, events)
+    delta_response_ids = [
+        response_id
+        for response_id in (_event_response_id(events[index]) for index in audio_delta_indices)
+        if response_id is not None
+    ]
+    first_audio_delta_before_done = bool(audio_delta_indices and done_indices) and min(audio_delta_indices) < min(
+        done_indices
+    )
+    audio_delta_events = [events[index] for index in audio_delta_indices]
+    first_received_at_s = next(
+        (
+            received_at
+            for received_at in (_audio_delta_received_at_s(event) for event in audio_delta_events)
+            if received_at is not None
+        ),
+        None,
+    )
+    audio_delta_timings = []
+    for event in audio_delta_events:
+        received_at_s = _audio_delta_received_at_s(event)
+        audio_delta_timings.append(
+            {
+                "response_id": _event_response_id(event),
+                "received_at_s": received_at_s,
+                "arrival_offset_ms": (
+                    round((received_at_s - first_received_at_s) * 1000.0, 3)
+                    if received_at_s is not None and first_received_at_s is not None
+                    else None
+                ),
+                "audio_duration_ms": _audio_delta_duration_ms(event),
+            }
+        )
+    all_audio_deltas_same_response = (
+        len(delta_response_ids) == len(audio_delta_indices) and len(set(delta_response_ids)) == 1
+    )
+    response_id_nonempty = bool(response_ids)
+    response_audio_contract_ok = _session_audio_contract_ok(
+        audio_delta_count=len(audio_delta_indices),
+        delta_response_ids=delta_response_ids,
+        response_ids=response_ids,
+        first_audio_delta_before_done=first_audio_delta_before_done,
+    )
+    return {
+        "label": label,
+        "input_wav": input_wav,
+        "output_dir": output_dir,
+        "returncode": returncode,
+        "ok": returncode == 0 and result.get("ok") is True and response_audio_contract_ok,
+        "result_ok": result.get("ok"),
+        "response_ids": response_ids,
+        "response_id_nonempty": response_id_nonempty,
+        "audio_bytes": result.get("audio_bytes", 0),
+        "audio_delta_count": len(audio_delta_indices),
+        "audio_delta_response_ids": delta_response_ids,
+        "audio_delta_timings": audio_delta_timings,
+        "all_audio_deltas_same_response": all_audio_deltas_same_response,
+        "first_audio_delta_before_done": first_audio_delta_before_done,
+        "response_audio_contract_ok": response_audio_contract_ok,
+        "event_count": len(events),
+        "stdout_tail": stdout[-4000:],
+        "stderr_tail": stderr[-4000:],
+    }
+
+
+def _identity_isolation_ok(sessions: list[dict[str, object]]) -> bool:
+    seen: set[str] = set()
+    for session in sessions:
+        ids = {response_id for response_id in session.get("response_ids", []) if isinstance(response_id, str)}
+        if not ids:
+            return False
+        if ids & seen:
+            return False
+        seen.update(ids)
+    return True
+
+
+async def _run_demo_process(
+    *,
+    label: str,
+    args: argparse.Namespace,
+    input_wav: str,
+    output_dir: str,
+) -> dict[str, object]:
+    command = [
+        sys.executable,
+        str(DEMO_PATH),
+        "--url",
+        args.url,
+        "--model",
+        args.model,
+        "--input-wav",
+        input_wav,
+        "--output-dir",
+        output_dir,
+        "--chunk-ms",
+        str(args.chunk_ms),
+        "--timeout-s",
+        str(args.timeout_s),
+        "--session-id",
+        f"duplex-pair-{label}-{uuid.uuid4().hex}",
+    ]
+    if args.no_realtime_pacing:
+        command.append("--no-realtime-pacing")
+    if args.require_audio:
+        command.append("--require-audio")
+    command.extend(["--ref-audio", str(args.ref_audio)])
+
+    process = await asyncio.create_subprocess_exec(
+        *command,
+        cwd=str(REPO_ROOT),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            process.communicate(),
+            timeout=args.timeout_s + 15.0,
+        )
+    except TimeoutError:
+        process.kill()
+        stdout_bytes, stderr_bytes = await process.communicate()
+        return _summarize_session(
+            label=label,
+            input_wav=input_wav,
+            output_dir=output_dir,
+            returncode=-1,
+            stdout=stdout_bytes.decode(errors="replace"),
+            stderr=(stderr_bytes.decode(errors="replace") + "\nclient timeout"),
+        )
+    return _summarize_session(
+        label=label,
+        input_wav=input_wav,
+        output_dir=output_dir,
+        returncode=process.returncode if process.returncode is not None else -1,
+        stdout=stdout_bytes.decode(errors="replace"),
+        stderr=stderr_bytes.decode(errors="replace"),
+    )
+
+
+async def run_pair(args: argparse.Namespace) -> dict[str, object]:
+    validated = _validate_pair_args(args)
+    Path(validated["output_dir_a"]).mkdir(parents=True, exist_ok=True)
+    Path(validated["output_dir_b"]).mkdir(parents=True, exist_ok=True)
+
+    sessions = await asyncio.gather(
+        _run_demo_process(
+            label="a",
+            args=args,
+            input_wav=str(validated["input_wav_a"]),
+            output_dir=str(validated["output_dir_a"]),
+        ),
+        _run_demo_process(
+            label="b",
+            args=args,
+            input_wav=str(validated["input_wav_b"]),
+            output_dir=str(validated["output_dir_b"]),
+        ),
+    )
+    identity_isolation_ok = _identity_isolation_ok(sessions)
+    min_audio_delta_ok = all(
+        int(session.get("audio_delta_count", 0)) >= args.min_audio_deltas_per_session for session in sessions
+    )
+    response_audio_contract_ok = all(session.get("response_audio_contract_ok") is True for session in sessions)
+    result = {
+        "ok": (
+            all(session.get("ok") is True for session in sessions)
+            and identity_isolation_ok
+            and min_audio_delta_ok
+            and response_audio_contract_ok
+        ),
+        "input_wavs_distinct": True,
+        "output_dirs_distinct": True,
+        "identity_isolation_ok": identity_isolation_ok,
+        "min_audio_deltas_per_session": args.min_audio_deltas_per_session,
+        "min_audio_delta_ok": min_audio_delta_ok,
+        "response_audio_contract_ok": response_audio_contract_ok,
+        "inputs": {
+            "a": validated["input_wav_a"],
+            "b": validated["input_wav_b"],
+            "sha256_a": validated["input_sha256_a"],
+            "sha256_b": validated["input_sha256_b"],
+        },
+        "sessions": sessions,
+    }
+    summary_output = (
+        Path(args.summary_output) if args.summary_output else Path(validated["output_dir_a"]).parent / "summary.json"
+    )
+    summary_output.parent.mkdir(parents=True, exist_ok=True)
+    summary_output.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+    return result
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://127.0.0.1:8099/v1/realtime?duplex=1")
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument("--input-wav-a", required=True)
+    parser.add_argument("--input-wav-b", required=True)
+    parser.add_argument("--ref-audio", required=True)
+    parser.add_argument("--output-dir-a", required=True)
+    parser.add_argument("--output-dir-b", required=True)
+    parser.add_argument("--summary-output")
+    parser.add_argument("--chunk-ms", type=int, default=200)
+    parser.add_argument("--timeout-s", type=float, default=120.0)
+    parser.add_argument("--no-realtime-pacing", action="store_true")
+    parser.add_argument("--require-audio", action="store_true")
+    parser.add_argument("--min-audio-deltas-per-session", type=int, default=2)
+    args = parser.parse_args()
+    if args.min_audio_deltas_per_session < 0:
+        parser.error("--min-audio-deltas-per-session must be non-negative")
+    return args
+
+
+def main() -> None:
+    result = asyncio.run(run_pair(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
new file mode 100644
index 000000000..e317c412c
--- /dev/null
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
@@ -0,0 +1,612 @@
+"""Concurrent MiniCPM-o Realtime duplex and resumable-session E2E driver."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import hashlib
+import json
+import sys
+import uuid
+from pathlib import Path
+from types import SimpleNamespace
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import websockets
+from websockets.exceptions import ConnectionClosed
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+if str(SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_DIR))
+
+from minicpmo_realtime_duplex_scenarios import (  # noqa: E402
+    _ref_audio_data_url,
+    _url_with_model,
+    run_demo,
+)
+
+
+def _with_resume_mode(url: str) -> str:
+    parts = urlsplit(url)
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query["resume"] = "1"
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+
+
+def _response_ids(result: dict[str, object]) -> set[str]:
+    values = result.get("completed_response_ids")
+    return {value for value in values if isinstance(value, str)} if isinstance(values, list) else set()
+
+
+def _event_session_id(event: dict[str, object]) -> str | None:
+    session_id = event.get("session_id")
+    if isinstance(session_id, str):
+        return session_id
+    inner = event.get("event")
+    if isinstance(inner, dict):
+        nested_session_id = inner.get("session_id")
+        if isinstance(nested_session_id, str):
+            return nested_session_id
+    return None
+
+
+def _error_code(event: dict[str, object]) -> str | None:
+    error = event.get("error")
+    if isinstance(error, dict) and isinstance(error.get("code"), str):
+        return error["code"]
+    code = event.get("code")
+    return code if isinstance(code, str) else None
+
+
+def _validate_identity_isolation(results: list[dict[str, object]]) -> bool:
+    seen: set[str] = set()
+    for result in results:
+        current = _response_ids(result)
+        if current & seen:
+            return False
+        seen.update(current)
+    return True
+
+
+def _validate_semantic_isolation(
+    results: list[dict[str, object]],
+    *,
+    input_wavs: list[str],
+    expected_tokens: list[str],
+) -> bool:
+    if not input_wavs:
+        return True
+    if len(results) != len(input_wavs):
+        return False
+    input_hashes = [hashlib.sha256(Path(path).read_bytes()).digest() for path in input_wavs]
+    if len(set(input_hashes)) != len(input_hashes):
+        return False
+    if not expected_tokens:
+        return True
+    if len(expected_tokens) != len(results):
+        return False
+    for result, expected_token in zip(results, expected_tokens, strict=True):
+        details = result.get("transcript_integrity")
+        transcripts = (
+            [str(item.get("transcript", "")) for item in details if isinstance(item, dict)]
+            if isinstance(details, list)
+            else []
+        )
+        if expected_token not in "".join(transcripts):
+            return False
+    return True
+
+
+async def _receive_until(ws, event_type: str, *, timeout_s: float) -> tuple[dict[str, object], list[dict[str, object]]]:
+    async def receive() -> tuple[dict[str, object], list[dict[str, object]]]:
+        events: list[dict[str, object]] = []
+        while True:
+            raw = await ws.recv()
+            if not isinstance(raw, str):
+                continue
+            event = json.loads(raw)
+            if not isinstance(event, dict):
+                continue
+            events.append(event)
+            if event.get("type") == event_type:
+                return event, events
+
+    return await asyncio.wait_for(receive(), timeout=timeout_s)
+
+
+async def _open_admission_session(
+    args: argparse.Namespace,
+    session_id: str,
+) -> tuple[object, dict[str, object]]:
+    url = _url_with_model(
+        args.url,
+        args.model,
+        autostart=False if getattr(args, "ref_audio", None) else None,
+        session_id=session_id,
+    )
+    ws = await websockets.connect(url, max_size=64 * 1024 * 1024)
+    await ws.send(
+        json.dumps(
+            {
+                "type": "session.update",
+                "session": {
+                    "session_id": session_id,
+                    "model": args.model,
+                    "modalities": ["audio", "text"],
+                    "extra_body": {"minicpmo45_native_duplex": True},
+                    **({"ref_audio": _ref_audio_data_url(args.ref_audio)} if getattr(args, "ref_audio", None) else {}),
+                },
+            }
+        )
+    )
+    created, _ = await _receive_until(ws, "session.created", timeout_s=args.timeout_s)
+    return ws, created
+
+
+async def _close_admission_session(ws, *, timeout_s: float) -> None:
+    await ws.send(json.dumps({"type": "session.close"}))
+    await _receive_until(ws, "session.closed", timeout_s=timeout_s)
+    await ws.close()
+
+
+async def _admission_probe(args: argparse.Namespace, *, limit: int) -> dict[str, object]:
+    if limit < 1:
+        raise ValueError("admission limit must be positive")
+    prefix = f"admission-{uuid.uuid4().hex}"
+    accepted: list[tuple[object, dict[str, object]]] = []
+    replacement: tuple[object, dict[str, object]] | None = None
+    overflow_code = None
+    try:
+        for index in range(limit):
+            accepted.append(await _open_admission_session(args, f"{prefix}-accepted-{index}"))
+
+        overflow_id = f"{prefix}-overflow"
+        overflow_url = _url_with_model(
+            args.url,
+            args.model,
+            autostart=False if getattr(args, "ref_audio", None) else None,
+            session_id=overflow_id,
+        )
+        async with websockets.connect(overflow_url, max_size=64 * 1024 * 1024) as overflow:
+            await overflow.send(
+                json.dumps(
+                    {
+                        "type": "session.update",
+                        "session": {
+                            "session_id": overflow_id,
+                            "model": args.model,
+                            "modalities": ["audio", "text"],
+                            "extra_body": {"minicpmo45_native_duplex": True},
+                            **(
+                                {"ref_audio": _ref_audio_data_url(args.ref_audio)}
+                                if getattr(args, "ref_audio", None)
+                                else {}
+                            ),
+                        },
+                    }
+                )
+            )
+            error, _ = await _receive_until(overflow, "error", timeout_s=args.timeout_s)
+            overflow_code = _error_code(error)
+
+        first_ws, _ = accepted.pop(0)
+        await _close_admission_session(first_ws, timeout_s=args.timeout_s)
+        replacement = await _open_admission_session(args, f"{prefix}-replacement")
+
+        first_capabilities = accepted[0][1].get("session") if accepted else replacement[1].get("session")
+        capabilities = first_capabilities.get("capabilities") if isinstance(first_capabilities, dict) else None
+        advertised_multi = capabilities.get("supports_multi_session") if isinstance(capabilities, dict) else None
+        admission_mode = capabilities.get("session_admission_mode") if isinstance(capabilities, dict) else None
+        return {
+            "ok": (
+                overflow_code == "resource_exhausted"
+                and replacement[1].get("type") == "session.created"
+                and admission_mode == "engine_managed"
+            ),
+            "configured_limit": limit,
+            "accepted_before_rejection": limit,
+            "overflow_error_code": overflow_code,
+            "replacement_accepted": True,
+            "advertised_multi_session": advertised_multi,
+            "session_admission_mode": admission_mode,
+        }
+    finally:
+        cleanup = list(accepted)
+        if replacement is not None:
+            cleanup.append(replacement)
+        for ws, _ in cleanup:
+            try:
+                await _close_admission_session(ws, timeout_s=args.timeout_s)
+            except Exception:
+                await ws.close()
+
+
+async def _resume_probe(
+    args: argparse.Namespace,
+    *,
+    session_id: str,
+    expect_expired: bool = False,
+) -> dict[str, object]:
+    url = _url_with_model(
+        args.url,
+        args.model,
+        autostart=False if getattr(args, "ref_audio", None) else None,
+        session_id=session_id,
+    )
+    async with websockets.connect(url, max_size=64 * 1024 * 1024) as first:
+        await first.send(
+            json.dumps(
+                {
+                    "type": "session.update",
+                    "session": {
+                        "session_id": session_id,
+                        "model": args.model,
+                        "modalities": ["audio", "text"],
+                        "extra_body": {"minicpmo45_native_duplex": True},
+                        **(
+                            {"ref_audio": _ref_audio_data_url(args.ref_audio)}
+                            if getattr(args, "ref_audio", None)
+                            else {}
+                        ),
+                    },
+                }
+            )
+        )
+        created, first_events = await _receive_until(first, "session.created", timeout_s=args.timeout_s)
+        token = created.get("resume_token")
+        incarnation = created.get("incarnation")
+        generation = created.get("attachment_generation")
+        if not isinstance(token, str) or not isinstance(incarnation, int):
+            raise RuntimeError("session.created omitted resumable credentials")
+        last_seq = max(
+            (
+                event.get("server_event_seq", 0)
+                for event in first_events
+                if isinstance(event.get("server_event_seq"), int)
+            ),
+            default=0,
+        )
+
+    delay_s = args.expire_after_s if expect_expired else args.resume_after_ms / 1000
+    if delay_s > 0:
+        await asyncio.sleep(delay_s)
+
+    resume_url = _with_resume_mode(url)
+    async with websockets.connect(resume_url, max_size=64 * 1024 * 1024) as second:
+        await second.send(
+            json.dumps(
+                {
+                    "type": "session.resume",
+                    "session_id": session_id,
+                    "incarnation": incarnation,
+                    "resume_token": token,
+                    "last_received_server_event_seq": last_seq,
+                }
+            )
+        )
+        if expect_expired:
+            error, error_events = await _receive_until(second, "error", timeout_s=args.timeout_s)
+            error_payload = error.get("error")
+            code = error_payload.get("code") if isinstance(error_payload, dict) else error.get("code")
+            return {
+                "ok": code == "session_resume_expired",
+                "session_id": session_id,
+                "expired": True,
+                "error_code": code,
+                "event_count": len(error_events),
+            }
+        resumed, replay = await _receive_until(second, "session.resumed", timeout_s=args.timeout_s)
+        rotated = resumed.get("resume_token")
+        if not isinstance(rotated, str) or rotated == token:
+            raise RuntimeError("session.resume did not rotate the resume token")
+        await second.send(json.dumps({"type": "session.heartbeat"}))
+        heartbeat, heartbeat_events = await _receive_until(
+            second,
+            "session.heartbeat_ack",
+            timeout_s=args.timeout_s,
+        )
+        await second.send(json.dumps({"type": "session.close"}))
+        closed, close_events = await _receive_until(second, "session.closed", timeout_s=args.timeout_s)
+
+    replay_sequences = [event["server_event_seq"] for event in replay if isinstance(event.get("server_event_seq"), int)]
+    return {
+        "ok": (
+            resumed.get("session_id") == session_id
+            and isinstance(generation, int)
+            and resumed.get("attachment_generation") == generation + 1
+            and _event_session_id(heartbeat) == session_id
+            and _event_session_id(closed) == session_id
+            and replay_sequences == sorted(replay_sequences)
+        ),
+        "session_id": session_id,
+        "resumed_session_id": resumed.get("session_id"),
+        "heartbeat_session_id": _event_session_id(heartbeat),
+        "closed_session_id": _event_session_id(closed),
+        "initial_attachment_generation": generation,
+        "resumed_attachment_generation": resumed.get("attachment_generation"),
+        "replayed_event_count": len(replay_sequences),
+        "replayed_event_sequences": replay_sequences,
+        "heartbeat_event_count": len(heartbeat_events),
+        "close_event_count": len(close_events),
+        "token_rotated": True,
+    }
+
+
+async def _takeover_probe(
+    args: argparse.Namespace,
+    *,
+    session_id: str,
+) -> dict[str, object]:
+    url = _url_with_model(
+        args.url,
+        args.model,
+        autostart=False if getattr(args, "ref_audio", None) else None,
+        session_id=session_id,
+    )
+    first = await websockets.connect(url, max_size=64 * 1024 * 1024)
+    second = None
+    try:
+        await first.send(
+            json.dumps(
+                {
+                    "type": "session.update",
+                    "session": {
+                        "session_id": session_id,
+                        "model": args.model,
+                        "modalities": ["audio", "text"],
+                        "extra_body": {"minicpmo45_native_duplex": True},
+                        **(
+                            {"ref_audio": _ref_audio_data_url(args.ref_audio)}
+                            if getattr(args, "ref_audio", None)
+                            else {}
+                        ),
+                    },
+                }
+            )
+        )
+        created, first_events = await _receive_until(first, "session.created", timeout_s=args.timeout_s)
+        token = created.get("resume_token")
+        incarnation = created.get("incarnation")
+        generation = created.get("attachment_generation")
+        if not isinstance(token, str) or not isinstance(incarnation, int) or not isinstance(generation, int):
+            raise RuntimeError("session.created omitted takeover credentials")
+        last_seq = max(
+            (
+                event.get("server_event_seq", 0)
+                for event in first_events
+                if isinstance(event.get("server_event_seq"), int)
+            ),
+            default=0,
+        )
+
+        second = await websockets.connect(_with_resume_mode(url), max_size=64 * 1024 * 1024)
+        await second.send(
+            json.dumps(
+                {
+                    "type": "session.resume",
+                    "session_id": session_id,
+                    "incarnation": incarnation,
+                    "resume_token": token,
+                    "last_received_server_event_seq": last_seq,
+                }
+            )
+        )
+        resumed, replay_events = await _receive_until(second, "session.resumed", timeout_s=args.timeout_s)
+        replaced, replaced_events = await _receive_until(first, "session.replaced", timeout_s=args.timeout_s)
+        await asyncio.wait_for(first.wait_closed(), timeout=args.timeout_s)
+
+        rejected_old_writes = 0
+        for _ in range(4):
+            try:
+                await first.send(json.dumps({"type": "session.heartbeat"}))
+            except ConnectionClosed:
+                rejected_old_writes += 1
+
+        await second.send(json.dumps({"type": "session.heartbeat"}))
+        heartbeat, heartbeat_events = await _receive_until(
+            second,
+            "session.heartbeat_ack",
+            timeout_s=args.timeout_s,
+        )
+        await second.send(json.dumps({"type": "session.close"}))
+        closed, close_events = await _receive_until(second, "session.closed", timeout_s=args.timeout_s)
+        rotated_token = resumed.get("resume_token")
+        return {
+            "ok": (
+                resumed.get("session_id") == session_id
+                and resumed.get("attachment_generation") == generation + 1
+                and isinstance(rotated_token, str)
+                and rotated_token != token
+                and _event_session_id(replaced) == session_id
+                and replaced.get("attachment_generation") == generation
+                and rejected_old_writes == 4
+                and _event_session_id(heartbeat) == session_id
+                and _event_session_id(closed) == session_id
+            ),
+            "session_id": session_id,
+            "initial_attachment_generation": generation,
+            "resumed_attachment_generation": resumed.get("attachment_generation"),
+            "replaced_attachment_generation": replaced.get("attachment_generation"),
+            "token_rotated": isinstance(rotated_token, str) and rotated_token != token,
+            "old_attachment_closed": True,
+            "rejected_old_writes": rejected_old_writes,
+            "replay_event_count": len(replay_events),
+            "replaced_event_count": len(replaced_events),
+            "heartbeat_event_count": len(heartbeat_events),
+            "close_event_count": len(close_events),
+        }
+    finally:
+        if second is not None:
+            await second.close()
+        await first.close()
+
+
+def _demo_args(args: argparse.Namespace, index: int) -> SimpleNamespace:
+    validation_mode = "response-required" if args.response_required else "model-policy"
+    input_wav = args.session_input_wav[index] if args.session_input_wav else args.input_wav
+    return SimpleNamespace(
+        url=args.url,
+        model=args.model,
+        session_id=f"multi-{index}-{uuid.uuid4().hex}",
+        input_wav=input_wav,
+        ref_audio=args.ref_audio,
+        turn_input_wav=list(args.turn_input_wav),
+        output_dir=str(Path(args.output_dir) / f"session_{index:02d}"),
+        output_audio_format="pcm16",
+        chunk_ms=args.chunk_ms,
+        realtime_input=args.realtime_input,
+        first_turn_ms=args.first_turn_ms,
+        turn_duration_ms=list(args.turn_duration_ms),
+        first_turn_transcript=f"session {index} input",
+        omit_transcript_hints=True,
+        validation_mode=validation_mode,
+        temperature=args.temperature,
+        scenario="sequential",
+        require_audio=args.response_required,
+        require_distinct_inputs=False,
+        expect_empty_turn=[],
+        short_ack_ms=350,
+        turns=args.turns,
+        timeout_s=args.timeout_s,
+        model_policy_settle_ms=args.model_policy_settle_ms,
+    )
+
+
+async def run_multi_session(args: argparse.Namespace) -> dict[str, object]:
+    if args.sessions < 1:
+        raise ValueError("--sessions must be positive")
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    resume_result = None
+    if args.disconnect_session_index is not None:
+        if not 0 <= args.disconnect_session_index < args.sessions:
+            raise ValueError("--disconnect-session-index is outside the session range")
+        resume_result = await _resume_probe(
+            args,
+            session_id=f"resume-{args.disconnect_session_index}-{uuid.uuid4().hex}",
+        )
+    takeover_result = None
+    if args.takeover_session_index is not None:
+        if not 0 <= args.takeover_session_index < args.sessions:
+            raise ValueError("--takeover-session-index is outside the session range")
+        takeover_result = await _takeover_probe(
+            args,
+            session_id=f"takeover-{args.takeover_session_index}-{uuid.uuid4().hex}",
+        )
+    lifecycle_result = await run_lifecycle_probes(args)
+
+    session_results = await asyncio.gather(
+        *(run_demo(_demo_args(args, index)) for index in range(args.sessions)),
+        return_exceptions=True,
+    )
+    failures = [repr(result) for result in session_results if isinstance(result, BaseException)]
+    completed = [result for result in session_results if isinstance(result, dict)]
+    identity_isolation_ok = _validate_identity_isolation(completed)
+    semantic_isolation_ok = _validate_semantic_isolation(
+        completed,
+        input_wavs=list(args.session_input_wav),
+        expected_tokens=list(args.session_expected_token),
+    )
+    result = {
+        "ok": (
+            not failures
+            and len(completed) == args.sessions
+            and all(item.get("ok") is True for item in completed)
+            and identity_isolation_ok
+            and semantic_isolation_ok
+            and (resume_result is None or resume_result.get("ok") is True)
+            and (takeover_result is None or takeover_result.get("ok") is True)
+            and lifecycle_result["ok"] is True
+        ),
+        "session_count": args.sessions,
+        "identity_isolation_ok": identity_isolation_ok,
+        "semantic_isolation_ok": semantic_isolation_ok,
+        "resume": resume_result,
+        "takeover": takeover_result,
+        "expiry": lifecycle_result["expiry"],
+        "admission": lifecycle_result["admission"],
+        "failures": failures,
+        "sessions": completed,
+    }
+    (output_dir / "summary.json").write_text(
+        json.dumps(result, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    return result
+
+
+async def run_lifecycle_probes(args: argparse.Namespace) -> dict[str, object]:
+    """Run expiry and admission probes without requiring model output."""
+    if args.sessions < 1:
+        raise ValueError("--sessions must be positive")
+    expiry_result = None
+    if args.expire_session_index is not None:
+        if not 0 <= args.expire_session_index < args.sessions:
+            raise ValueError("--expire-session-index is outside the session range")
+        expiry_result = await _resume_probe(
+            args,
+            session_id=f"expire-{args.expire_session_index}-{uuid.uuid4().hex}",
+            expect_expired=True,
+        )
+    admission_result = (
+        await _admission_probe(args, limit=args.verify_admission_limit)
+        if args.verify_admission_limit is not None
+        else None
+    )
+    return {
+        "ok": (
+            (expiry_result is None or expiry_result.get("ok") is True)
+            and (admission_result is None or admission_result.get("ok") is True)
+        ),
+        "expiry": expiry_result,
+        "admission": admission_result,
+    }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://127.0.0.1:8113/v1/realtime?duplex=1")
+    parser.add_argument("--base-url", help="Deprecated alias; /v1/realtime is appended when supplied.")
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument("--sessions", type=int, default=2)
+    parser.add_argument("--input-wav", required=True)
+    parser.add_argument("--ref-audio", help="Optional WAV used as the MiniCPM-o voice prompt for every session.")
+    parser.add_argument("--session-input-wav", action="append", default=[])
+    parser.add_argument("--session-expected-token", action="append", default=[])
+    parser.add_argument("--turn-input-wav", action="append", default=[])
+    parser.add_argument("--output-dir", default="/tmp/minicpmo_pr3907_multi_session_e2e")
+    parser.add_argument("--realtime-input", action="store_true")
+    parser.add_argument("--chunk-ms", type=int, default=200)
+    parser.add_argument("--turns", type=int, default=1)
+    parser.add_argument("--first-turn-ms", type=int, default=1400)
+    parser.add_argument("--turn-duration-ms", type=int, action="append", default=[])
+    parser.add_argument("--response-required", action="store_true")
+    parser.add_argument("--temperature", type=float, default=None)
+    parser.add_argument("--disconnect-session-index", type=int)
+    parser.add_argument("--takeover-session-index", type=int)
+    parser.add_argument("--resume-after-ms", type=int, default=1000)
+    parser.add_argument("--expire-session-index", type=int)
+    parser.add_argument("--expire-after-s", type=float, default=6.0)
+    parser.add_argument("--verify-admission-limit", type=int)
+    parser.add_argument("--model-policy-settle-ms", type=int, default=600)
+    parser.add_argument("--timeout-s", type=float, default=120.0)
+    args = parser.parse_args()
+    if args.base_url:
+        args.url = args.base_url.rstrip("/") + "/v1/realtime?duplex=1"
+    if args.session_input_wav and len(args.session_input_wav) != args.sessions:
+        parser.error("provide exactly one --session-input-wav per session")
+    if args.session_expected_token and len(args.session_expected_token) != args.sessions:
+        parser.error("provide exactly one --session-expected-token per session")
+    if args.session_expected_token and not args.session_input_wav:
+        parser.error("--session-expected-token requires --session-input-wav")
+    return args
+
+
+def main() -> None:
+    result = asyncio.run(run_multi_session(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
new file mode 100644
index 000000000..57d9e433f
--- /dev/null
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
@@ -0,0 +1,484 @@
+"""Validate MiniCPM-o Realtime duplex soft-interrupt delta streaming.
+
+This E2E driver runs the public ``realtime_duplex_demo.py`` against a live
+duplex backend. Arbitrary audio defaults to the model-policy lifecycle contract.
+The stronger response-required mode binds the multi-response contract to a
+known input checksum and expected follow-up response.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import io
+import json
+import sys
+import uuid
+import wave
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+DEMO_PATH = REPO_ROOT / "examples/online_serving/minicpmo/realtime_duplex_demo.py"
+AUDIO_DELTA_EVENTS = {"response.audio.delta", "response.output_audio.delta"}
+TRANSCRIPT_DELTA_EVENTS = {
+    "response.audio_transcript.delta",
+    "response.output_text.delta",
+}
+
+
+def _canonical_path(path: str) -> Path:
+    return Path(path).expanduser().resolve(strict=False)
+
+
+def _validate_input_sha256(path: Path, expected: str) -> str:
+    actual = hashlib.sha256(path.read_bytes()).hexdigest()
+    if actual != expected.lower():
+        raise ValueError(f"input WAV SHA256 mismatch: expected {expected.lower()}, got {actual}")
+    return actual
+
+
+def _input_duration_s(path: Path) -> float:
+    with wave.open(str(path), "rb") as wav_file:
+        return wav_file.getnframes() / wav_file.getframerate()
+
+
+def _client_process_timeout_s(input_wav: Path, protocol_timeout_s: float) -> float:
+    # The child first streams the WAV in real time, then can independently
+    # exhaust its post-commit and session-close protocol waits.
+    return _input_duration_s(input_wav) + 2 * protocol_timeout_s + 30.0
+
+
+def _read_json(path: Path) -> dict[str, object]:
+    if not path.is_file():
+        return {}
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return data if isinstance(data, dict) else {}
+
+
+def _read_events(path: Path) -> list[dict[str, object]]:
+    if not path.is_file():
+        return []
+    events: list[dict[str, object]] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        event = json.loads(line)
+        if isinstance(event, dict):
+            events.append(event)
+    return events
+
+
+def _event_response_id(event: dict[str, object]) -> str | None:
+    response_id = event.get("response_id")
+    if isinstance(response_id, str):
+        return response_id
+    response = event.get("response")
+    if isinstance(response, dict) and isinstance(response.get("id"), str):
+        return response["id"]
+    return None
+
+
+def _event_received_at_s(event: dict[str, object]) -> float | None:
+    received_at = event.get("_client_received_at_s")
+    if isinstance(received_at, int | float):
+        return float(received_at)
+    return None
+
+
+def _first_event_index(events: list[dict[str, object]], event_type: str) -> int | None:
+    for index, event in enumerate(events):
+        if event.get("type") == event_type:
+            return index
+    return None
+
+
+def _event_counts(events: list[dict[str, object]]) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for event in events:
+        event_type = str(event.get("type"))
+        counts[event_type] = counts.get(event_type, 0) + 1
+    return counts
+
+
+def _response_created_ids(events: list[dict[str, object]]) -> list[str]:
+    response_ids: list[str] = []
+    for event in events:
+        if event.get("type") != "response.created":
+            continue
+        response_id = _event_response_id(event)
+        if response_id and response_id not in response_ids:
+            response_ids.append(response_id)
+    return response_ids
+
+
+def _audio_delta_duration_ms(event: dict[str, object]) -> float | None:
+    encoded = event.get("delta") or event.get("audio")
+    if not isinstance(encoded, str) or not encoded:
+        return None
+    try:
+        raw = base64.b64decode(encoded)
+    except ValueError:
+        return None
+    fmt = str(event.get("format") or event.get("audio_format") or "pcm16").lower()
+    sample_rate = event.get("sample_rate_hz") or event.get("sample_rate") or 24_000
+    if not isinstance(sample_rate, int | float) or sample_rate <= 0:
+        return None
+    if "wav" in fmt:
+        try:
+            with wave.open(io.BytesIO(raw), "rb") as wav_file:
+                return round((wav_file.getnframes() * 1000.0) / wav_file.getframerate(), 3)
+        except (EOFError, wave.Error):
+            return None
+    bytes_per_sample = 4 if "f32" in fmt else 2
+    return round((len(raw) * 1000.0) / (bytes_per_sample * float(sample_rate)), 3)
+
+
+def _normalize_text(text: str) -> str:
+    return "".join(text.split())
+
+
+def _compact_sequence(events: list[dict[str, object]]) -> list[str]:
+    sequence: list[str] = []
+    for event in events:
+        event_type = event.get("type")
+        response_id = _event_response_id(event)
+        suffix = f" {response_id[-8:]}" if response_id else ""
+        if event_type == "response.listen":
+            sequence.append("listen")
+        elif event_type == "response.created":
+            sequence.append(f"response.created{suffix}")
+        elif event_type == "response.speak":
+            sequence.append(f"speak{suffix}")
+        elif event_type in AUDIO_DELTA_EVENTS:
+            sequence.append(f"audio.delta{suffix}")
+        elif event_type in TRANSCRIPT_DELTA_EVENTS:
+            delta = str(event.get("delta") or "")
+            sequence.append(f"text.delta{suffix}> {delta}")
+        elif event_type == "response.done":
+            sequence.append(f"response.done{suffix}")
+        elif event_type == "input_audio_buffer.committed":
+            sequence.append("input.committed")
+    return sequence
+
+
+def _response_summary(
+    events: list[dict[str, object]],
+    response_id: str,
+    *,
+    t0: float | None,
+) -> dict[str, object]:
+    created_indices = [
+        index
+        for index, event in enumerate(events)
+        if event.get("type") == "response.created" and _event_response_id(event) == response_id
+    ]
+    done_indices = [
+        index
+        for index, event in enumerate(events)
+        if event.get("type") == "response.done" and _event_response_id(event) == response_id
+    ]
+    audio_indices = [
+        index
+        for index, event in enumerate(events)
+        if event.get("type") in AUDIO_DELTA_EVENTS and _event_response_id(event) == response_id
+    ]
+    transcript_indices = [
+        index
+        for index, event in enumerate(events)
+        if event.get("type") in TRANSCRIPT_DELTA_EVENTS and _event_response_id(event) == response_id
+    ]
+    done_index = done_indices[0] if done_indices else None
+    audio_before_done_ok = done_index is not None and all(index < done_index for index in audio_indices)
+    stale_audio_count = sum(index > done_index for index in audio_indices) if done_index is not None else 0
+
+    def offset_ms(index: int) -> float | None:
+        if t0 is None:
+            return None
+        received_at = _event_received_at_s(events[index])
+        return round((received_at - t0) * 1000.0, 3) if received_at is not None else None
+
+    return {
+        "response_id": response_id,
+        "created_index": created_indices[0] if created_indices else None,
+        "done_indices": done_indices,
+        "created_offset_ms": offset_ms(created_indices[0]) if created_indices else None,
+        "done_offset_ms": offset_ms(done_indices[0]) if done_indices else None,
+        "audio_delta_count": len(audio_indices),
+        "transcript_delta_count": len(transcript_indices),
+        "audio_delta_offsets_ms": [offset_ms(index) for index in audio_indices],
+        "audio_duration_ms": [_audio_delta_duration_ms(events[index]) for index in audio_indices],
+        "transcript": "".join(str(events[index].get("delta") or "") for index in transcript_indices),
+        "one_done": len(done_indices) == 1,
+        "audio_before_done_ok": audio_before_done_ok,
+        "stale_audio_count": stale_audio_count,
+    }
+
+
+def summarize_artifacts(
+    *,
+    output_dir: Path,
+    validation_mode: str,
+    min_responses: int,
+    min_audio_deltas_per_response: int,
+    expect_followup_response_substring: str | None,
+) -> dict[str, object]:
+    if validation_mode not in {"model-policy", "response-required"}:
+        raise ValueError(f"unsupported validation mode: {validation_mode}")
+    result = _read_json(output_dir / "result.json")
+    events = _read_events(output_dir / "events.jsonl")
+    response_ids = _response_created_ids(events)
+    times = [_event_received_at_s(event) for event in events]
+    clean_times = [received_at for received_at in times if received_at is not None]
+    t0 = min(clean_times) if clean_times else None
+    response_summaries = [_response_summary(events, response_id, t0=t0) for response_id in response_ids]
+    commit_index = _first_event_index(events, "input_audio_buffer.committed")
+    first_created_index = next(
+        (summary["created_index"] for summary in response_summaries if isinstance(summary.get("created_index"), int)),
+        None,
+    )
+    first_done_index = (
+        response_summaries[0]["done_indices"][0]
+        if response_summaries and response_summaries[0]["done_indices"]
+        else None
+    )
+    second_created_index = (
+        response_summaries[1]["created_index"]
+        if len(response_summaries) >= 2 and isinstance(response_summaries[1].get("created_index"), int)
+        else None
+    )
+    last_done_index = next(
+        (summary["done_indices"][0] for summary in reversed(response_summaries) if summary.get("done_indices")),
+        None,
+    )
+    listen_indices = [index for index, event in enumerate(events) if event.get("type") == "response.listen"]
+    effective_min_responses = min_responses if validation_mode == "response-required" else 1
+    enough_responses = len(response_summaries) >= effective_min_responses
+    response_lifecycle_ok = enough_responses and all(bool(summary.get("one_done")) for summary in response_summaries)
+    multi_delta_ok = enough_responses and all(
+        int(summary.get("audio_delta_count", 0)) >= min_audio_deltas_per_response for summary in response_summaries
+    )
+    response_audio_contract_ok = enough_responses and all(
+        summary.get("audio_before_done_ok") is True and int(summary.get("stale_audio_count", 0)) == 0
+        for summary in response_summaries
+    )
+    response_before_final_commit = (
+        first_created_index is not None and commit_index is not None and first_created_index < commit_index
+    )
+    second_response_before_final_commit = (
+        second_created_index is not None and commit_index is not None and second_created_index < commit_index
+    )
+    listen_before_first_response = first_created_index is not None and any(
+        index < first_created_index for index in listen_indices
+    )
+    listen_between_responses = (
+        first_done_index is not None
+        and second_created_index is not None
+        and any(first_done_index < index < second_created_index for index in listen_indices)
+    )
+    listen_after_last_done = last_done_index is not None and any(index > last_done_index for index in listen_indices)
+    listen_after_response_before_commit = (
+        last_done_index is not None
+        and commit_index is not None
+        and any(last_done_index < index < commit_index for index in listen_indices)
+    )
+    final_listen_after_commit = commit_index is not None and any(index > commit_index for index in listen_indices)
+    transcript = "".join(str(summary.get("transcript") or "") for summary in response_summaries)
+    followup_response_transcripts = [
+        str(summary.get("transcript") or "")
+        for summary in response_summaries[1:]
+        if commit_index is not None
+        and isinstance(summary.get("created_index"), int)
+        and summary["created_index"] < commit_index
+    ]
+    followup_response_transcript_ok = any(
+        bool(_normalize_text(transcript)) for transcript in followup_response_transcripts
+    )
+    followup_response_transcript_expectation_ok = not expect_followup_response_substring or any(
+        _normalize_text(expect_followup_response_substring) in _normalize_text(transcript)
+        for transcript in followup_response_transcripts
+    )
+    error_events = [
+        event
+        for event in events
+        if event.get("type") == "error"
+        or str(event.get("type") or "").endswith(".cancelled")
+        or str(event.get("type") or "").endswith(".truncated")
+    ]
+    cancelled_count = sum(
+        1
+        for event in events
+        if event.get("type") == "response.done"
+        and isinstance(event.get("response"), dict)
+        and event["response"].get("status") == "cancelled"
+    )
+    result_ok = result.get("ok") is True
+    common_contract_ok = bool(
+        result_ok
+        and not error_events
+        and cancelled_count == 0
+        and enough_responses
+        and response_lifecycle_ok
+        and multi_delta_ok
+        and response_audio_contract_ok
+        and response_before_final_commit
+        and listen_after_response_before_commit
+        and final_listen_after_commit
+    )
+    mode_contract_ok = validation_mode == "model-policy" or (
+        second_response_before_final_commit
+        and listen_before_first_response
+        and listen_after_last_done
+        and followup_response_transcript_ok
+    )
+    ok = common_contract_ok and mode_contract_ok
+    return {
+        "ok": ok,
+        "result_ok": result_ok,
+        "validation_mode": validation_mode,
+        "event_counts": _event_counts(events),
+        "response_ids": response_ids,
+        "response_summaries": response_summaries,
+        "min_responses": min_responses,
+        "effective_min_responses": effective_min_responses,
+        "min_audio_deltas_per_response": min_audio_deltas_per_response,
+        "enough_responses": enough_responses,
+        "response_lifecycle_ok": response_lifecycle_ok,
+        "multi_delta_ok": multi_delta_ok,
+        "response_audio_contract_ok": response_audio_contract_ok,
+        "response_before_final_commit": response_before_final_commit,
+        "second_response_before_final_commit": second_response_before_final_commit,
+        "listen_before_first_response": listen_before_first_response,
+        "listen_between_responses": listen_between_responses,
+        "listen_after_last_done": listen_after_last_done,
+        "listen_after_response_before_commit": listen_after_response_before_commit,
+        "final_listen_after_commit": final_listen_after_commit,
+        "transcript": transcript,
+        "followup_response_transcripts": followup_response_transcripts,
+        "followup_response_transcript_ok": followup_response_transcript_ok,
+        "expect_followup_response_substring": expect_followup_response_substring,
+        "followup_response_transcript_expectation_ok": followup_response_transcript_expectation_ok,
+        "error_count": len(error_events),
+        "cancelled_count": cancelled_count,
+        "compact_sequence": _compact_sequence(events),
+        "output_dir": str(output_dir),
+    }
+
+
+async def run_soft_interrupt(args: argparse.Namespace) -> dict[str, object]:
+    input_wav = _canonical_path(args.input_wav)
+    output_dir = _canonical_path(args.output_dir)
+    if not input_wav.is_file():
+        raise ValueError(f"input WAV does not exist: {input_wav}")
+    input_sha256 = hashlib.sha256(input_wav.read_bytes()).hexdigest()
+    if args.input_sha256:
+        input_sha256 = _validate_input_sha256(input_wav, args.input_sha256)
+    command = [
+        sys.executable,
+        str(DEMO_PATH),
+        "--url",
+        args.url,
+        "--model",
+        args.model,
+        "--input-wav",
+        str(input_wav),
+        "--output-dir",
+        str(output_dir),
+        "--chunk-ms",
+        str(args.chunk_ms),
+        "--timeout-s",
+        str(args.timeout_s),
+        "--session-id",
+        f"duplex-soft-interrupt-{uuid.uuid4().hex}",
+    ]
+    command.extend(["--ref-audio", str(_canonical_path(args.ref_audio))])
+    if args.require_audio:
+        command.append("--require-audio")
+    if args.no_realtime_pacing:
+        command.append("--no-realtime-pacing")
+
+    process = await asyncio.create_subprocess_exec(
+        *command,
+        cwd=str(REPO_ROOT),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            process.communicate(),
+            timeout=_client_process_timeout_s(input_wav, args.timeout_s),
+        )
+    except TimeoutError:
+        process.kill()
+        stdout_bytes, stderr_bytes = await process.communicate()
+        return {
+            "ok": False,
+            "returncode": -1,
+            "stdout_tail": stdout_bytes.decode(errors="replace")[-4000:],
+            "stderr_tail": (stderr_bytes.decode(errors="replace") + "\nclient timeout")[-4000:],
+            "output_dir": str(output_dir),
+        }
+
+    summary = summarize_artifacts(
+        output_dir=output_dir,
+        validation_mode=args.validation_mode,
+        min_responses=args.min_responses,
+        min_audio_deltas_per_response=args.min_audio_deltas_per_response,
+        expect_followup_response_substring=args.expect_followup_response_substring,
+    )
+    summary.update(
+        {
+            "returncode": process.returncode if process.returncode is not None else -1,
+            "input_wav": str(input_wav),
+            "input_sha256": input_sha256,
+            "stdout_tail": stdout_bytes.decode(errors="replace")[-4000:],
+            "stderr_tail": stderr_bytes.decode(errors="replace")[-4000:],
+        }
+    )
+    summary["ok"] = bool(summary["ok"] and summary["returncode"] == 0)
+    summary_output = Path(args.summary_output) if args.summary_output else output_dir / "summary.json"
+    summary_output.parent.mkdir(parents=True, exist_ok=True)
+    summary_output.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    return summary
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="ws://127.0.0.1:8099/v1/realtime?duplex=1")
+    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument("--input-wav", required=True)
+    parser.add_argument("--ref-audio", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--summary-output")
+    parser.add_argument("--chunk-ms", type=int, default=200)
+    parser.add_argument("--timeout-s", type=float, default=120.0)
+    parser.add_argument("--require-audio", action="store_true")
+    parser.add_argument("--no-realtime-pacing", action="store_true")
+    parser.add_argument(
+        "--validation-mode",
+        choices=("model-policy", "response-required"),
+        default="model-policy",
+    )
+    parser.add_argument("--min-responses", type=int, default=2)
+    parser.add_argument("--min-audio-deltas-per-response", type=int, default=2)
+    parser.add_argument("--input-sha256")
+    parser.add_argument("--expect-followup-response-substring")
+    args = parser.parse_args()
+    if args.validation_mode == "response-required" and args.min_responses < 2:
+        parser.error("--min-responses must be at least 2")
+    if args.validation_mode == "response-required" and not args.input_sha256:
+        parser.error("--input-sha256 is required in response-required mode")
+    if args.min_audio_deltas_per_response < 1:
+        parser.error("--min-audio-deltas-per-response must be positive")
+    return args
+
+
+def main() -> None:
+    result = asyncio.run(run_soft_interrupt(parse_args()))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/online_serving/stage_configs/step_audio2_ci.yaml b/tests/e2e/online_serving/stage_configs/step_audio2_ci.yaml
deleted file mode 100644
index 703a7cdcc..000000000
--- a/tests/e2e/online_serving/stage_configs/step_audio2_ci.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-# Stage config for Step-Audio2 CI tests
-# Stage 0: Thinker (audio understanding → text + audio tokens)
-# Stage 1: Token2Wav (audio tokens → waveform)
-
-# The following config has been verified on 2x 24GB GPU (L4/RTX3090/RTX4090).
-stage_args:
-  - stage_id: 0
-    runtime:
-      process: true
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      model_stage: thinker
-      model_arch: StepAudio2ThinkerForConditionalGeneration
-      tensor_parallel_size: 1
-      hf_overrides:
-          architectures: ["StepAudio2ThinkerForConditionalGeneration"]
-
-      worker_cls: vllm_omni.worker.gpu_ar_worker.GPUARWorker
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      max_model_len: 1024
-      max_num_batched_tokens: 1024
-      max_num_seqs: 1
-      gpu_memory_utilization: 0.7
-      skip_mm_profiling: true
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      engine_output_type: text  # Output text + audio tokens
-    is_comprehension: true
-    final_output: true
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.7
-      top_p: 0.9
-      top_k: -1
-      max_tokens: 256
-      seed: 42
-      detokenize: true
-      repetition_penalty: 1.05
-
-  - stage_id: 1
-    runtime:
-      process: true
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-
-      model_stage: token2wav
-      model_arch: StepAudio2Token2WavModel
-      worker_cls: vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
-      hf_overrides:
-          architectures: ["StepAudio2Token2WavModel"]
-      gpu_memory_utilization: 0.2
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      max_num_batched_tokens: 1024
-      engine_output_type: audio  # Output waveform
-    engine_input_source: [0]
-    custom_process_input_func: vllm_omni.model_executor.stage_input_processors.step_audio2.thinker2token2wav
-    final_output: true
-    final_output_type: audio
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 1
-      seed: 42
-      detokenize: false
-
-runtime:
-  enabled: true
-  defaults:
-    window_size: -1
-    max_inflight: 1
-  edges:
-    - from: 0
-      to: 1
-      window_size: -1
diff --git a/tests/e2e/online_serving/test_audex_tta.py b/tests/e2e/online_serving/test_audex_tta.py
new file mode 100644
index 000000000..cfcb722d0
--- /dev/null
+++ b/tests/e2e/online_serving/test_audex_tta.py
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""E2E online tests for Audex (Nemotron-Labs-Audex-2B) text-to-audio.
+
+Covers /v1/audio/speech through the ``audex_tta`` deployment:
+the ``audex_tta`` adapter builds the caption prompt and the serving layer
+injects the RVQ phase contract plus the official default guidance
+(cfg_scale 3.0) server-side.
+"""
+
+import os
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+CAPTION = "Heavy rain falling on a tin roof."
+SAMPLE_RATE = 16_000
+
+audex_tta_server_params = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=get_deploy_config_path("audex_tta.yaml"),
+            server_args=["--trust-remote-code"],
+        ),
+        id="audex_tta",
+    )
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    audex_tta_server_params.append(
+        pytest.param(
+            OmniServerParams(
+                model=_AUDEX_30B_MODEL,
+                stage_config_path=get_deploy_config_path("audex_tta_30b.yaml"),
+                server_args=["--trust-remote-code"],
+            ),
+            id="online_tta_30b",
+        )
+    )
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_tta_server_params, indirect=True)
+def test_audex_tta_online_smoke(omni_server, openai_client, run_level) -> None:
+    """A caption returns a valid finite non-silent WAV at the default cfg 3.0."""
+    import io
+    import wave
+
+    import numpy as np
+    import requests
+
+    url = f"{openai_client.base_url.rstrip('/')}/v1/audio/speech"
+    resp = requests.post(
+        url,
+        json={"model": omni_server.model, "input": CAPTION, "response_format": "wav"},
+        timeout=600,
+    )
+    assert resp.status_code == 200, resp.text[:200]
+    assert resp.content[:4] == b"RIFF", "not a WAV response"
+
+    with wave.open(io.BytesIO(resp.content)) as wav:
+        assert wav.getframerate() == SAMPLE_RATE, f"unexpected sample rate {wav.getframerate()}"
+        frames = wav.readframes(wav.getnframes())
+        duration_s = wav.getnframes() / wav.getframerate()
+
+    audio = np.frombuffer(frames, dtype=np.int16).astype(np.float32) / 32768.0
+    assert audio.size > 0, "empty audio body"
+    assert np.isfinite(audio).all(), "audio contains NaN/Inf"
+
+    if run_level in {"advanced_model", "full_model"}:
+        # The decode cap is 500 frames = 10 s at 50 fps.
+        assert 0.1 <= duration_s <= 10.5, f"unexpected duration={duration_s:.3f}s"
+        rms = float(np.sqrt(np.mean(np.square(audio))))
+        assert rms > 1e-4, f"audio is near-silent (rms={rms})"
diff --git a/tests/e2e/online_serving/test_audex_tts.py b/tests/e2e/online_serving/test_audex_tts.py
new file mode 100644
index 000000000..94f39c7b8
--- /dev/null
+++ b/tests/e2e/online_serving/test_audex_tts.py
@@ -0,0 +1,230 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""E2E online tests for Audex (Nemotron-Labs-Audex-2B) TTS.
+
+Covers /v1/audio/speech non-streaming and audio-byte streaming, plus the
+Audex request policies: single built-in voice (missing/empty/"default" only),
+no reference audio, and cfg_scale reserved at 1.0.
+"""
+
+import os
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
+
+MODEL = "nvidia/Nemotron-Labs-Audex-2B"
+PROMPT = "The weather is so good, and I want to enjoy the beautiful morning in the park."
+
+audex_server_params = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=get_deploy_config_path("audex_tts.yaml"),
+            server_args=["--trust-remote-code"],
+        ),
+        id="audex",
+    )
+]
+# 30B-A3B variant: opt-in (pulls ~60 GB); enable with AUDEX_E2E_30B=1.
+_AUDEX_30B_MODEL = os.environ.get("VLLM_OMNI_AUDEX_30B_MODEL_DIR") or "nvidia/Nemotron-Labs-Audex-30B-A3B"
+if os.environ.get("AUDEX_E2E_30B") == "1":
+    audex_server_params.append(
+        pytest.param(
+            OmniServerParams(
+                model=_AUDEX_30B_MODEL,
+                stage_config_path=get_deploy_config_path("audex_tts_30b.yaml"),
+                server_args=["--trust-remote-code"],
+            ),
+            id="online_tts_30b",
+        )
+    )
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_nonstream(omni_server, openai_client) -> None:
+    """Plain English TTS, non-streaming WAV response."""
+    request_config = {
+        "model": omni_server.model,
+        "input": PROMPT,
+        "stream": False,
+        "response_format": "wav",
+    }
+    openai_client.send_audio_speech_request(request_config)
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_stream_audio(omni_server, openai_client) -> None:
+    """Plain English TTS, raw audio-byte streaming."""
+    request_config = {
+        "model": omni_server.model,
+        "input": PROMPT,
+        "stream": True,
+        "stream_format": "audio",
+        "response_format": "wav",
+    }
+    openai_client.send_audio_speech_request(request_config)
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_max_new_tokens_caps_duration(omni_server, openai_client, run_level) -> None:
+    """max_new_tokens must cap stage-0 generation (review P2 regression)."""
+    import io
+    import wave
+
+    import requests
+
+    if run_level not in {"advanced_model", "full_model"}:
+        pytest.skip("duration cap needs real weights")
+
+    url = f"{openai_client.base_url.rstrip('/')}/v1/audio/speech"
+    resp = requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": PROMPT,
+            "response_format": "wav",
+            "max_new_tokens": 25,
+        },
+    )
+    assert resp.status_code == 200, resp.text
+    with wave.open(io.BytesIO(resp.content)) as wav:
+        duration_s = wav.getnframes() / wav.getframerate()
+    # 25 codec frames at 50 fps = 0.5 s (+ small lookahead tail); the full
+    # sentence would be ~3 s, so a capped result proves the override applied.
+    assert duration_s <= 1.0, f"max_new_tokens ignored: duration={duration_s:.2f}s"
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_request_policies(omni_server, openai_client) -> None:
+    """Unsupported voice / CFG / empty input must be rejected with 400."""
+    import requests
+
+    url = f"{openai_client.base_url.rstrip('/')}/v1/audio/speech"
+
+    ok = requests.post(url, json={"model": omni_server.model, "input": PROMPT, "voice": "default"})
+    assert ok.status_code == 200, ok.text
+
+    for bad_payload, needle in (
+        ({"input": PROMPT, "voice": "alloy"}, "voice"),
+        ({"input": "   "}, "non-empty"),
+        ({"input": PROMPT, "extra_params": {"cfg_scale": 0.5}}, "cfg_scale"),
+        ({"input": PROMPT, "extra_params": {"cfg_scale": 10.5}}, "cfg_scale"),
+        ({"input": PROMPT, "extra_params": {"cfg_scale": "big"}}, "cfg_scale"),
+        ({"input": PROMPT, "extra_params": {"cfg_role": "cond"}}, "cfg_role"),
+        ({"input": PROMPT, "extra_params": {"cfg_pair_id": "x"}}, "cfg_pair_id"),
+        ({"input": PROMPT, "ref_audio": "https://example.com/ref.wav"}, "reference audio"),
+    ):
+        resp = requests.post(url, json={"model": omni_server.model, **bad_payload})
+        assert resp.status_code == 400, f"{bad_payload} -> {resp.status_code}: {resp.text[:200]}"
+        assert needle in resp.text, f"{bad_payload} error missing {needle!r}: {resp.text[:200]}"
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_cfg_nonstream(omni_server, openai_client) -> None:
+    """Guided (cfg_scale=1.5) non-streaming request returns one WAV."""
+    request_config = {
+        "model": omni_server.model,
+        "input": PROMPT,
+        "stream": False,
+        "response_format": "wav",
+        "extra_params": {"cfg_scale": 1.5},
+    }
+    openai_client.send_audio_speech_request(request_config)
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_cfg_stream_audio(omni_server, openai_client) -> None:
+    """Guided (cfg_scale=1.5) streaming request yields a single audio stream."""
+    request_config = {
+        "model": omni_server.model,
+        "input": PROMPT,
+        "stream": True,
+        "stream_format": "audio",
+        "response_format": "wav",
+        "extra_params": {"cfg_scale": 1.5},
+    }
+    openai_client.send_audio_speech_request(request_config)
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_mixed_cfg_concurrency(omni_server, openai_client) -> None:
+    """Mixed guided/unguided requests at concurrency 4 all complete with audio."""
+    import concurrent.futures
+
+    import requests
+
+    url = f"{openai_client.base_url.rstrip('/')}/v1/audio/speech"
+    payloads = [
+        {"model": omni_server.model, "input": f"{PROMPT} Take {i}.", "response_format": "wav"}
+        | ({"extra_params": {"cfg_scale": 1.5}} if i % 2 == 0 else {})
+        for i in range(4)
+    ]
+
+    def _post(payload):
+        return requests.post(url, json=payload, timeout=300)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
+        responses = list(pool.map(_post, payloads))
+
+    for payload, resp in zip(payloads, responses):
+        assert resp.status_code == 200, f"{payload} -> {resp.status_code}: {resp.text[:200]}"
+        assert resp.content[:4] == b"RIFF", f"{payload}: not a WAV response"
+        assert len(resp.content) > 44, f"{payload}: empty audio body"
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", audex_server_params, indirect=True)
+def test_audex_tts_stream_abort_leaves_server_healthy(omni_server, openai_client) -> None:
+    """Aborting a guided streaming request mid-flight must not wedge the server.
+
+    The abort cascades to the CFG companion (cfg_companion_tracker); a
+    follow-up guided request on the same server must still succeed.
+    """
+    import requests
+
+    url = f"{openai_client.base_url.rstrip('/')}/v1/audio/speech"
+    long_input = " ".join([PROMPT] * 4)
+
+    with requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": long_input,
+            "stream": True,
+            "stream_format": "audio",
+            "response_format": "wav",
+            "extra_params": {"cfg_scale": 1.5},
+        },
+        stream=True,
+        timeout=300,
+    ) as resp:
+        assert resp.status_code == 200, resp.text
+        # Read one chunk, then abort the connection mid-stream.
+        next(resp.iter_content(chunk_size=4096))
+
+    follow_up = requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": PROMPT,
+            "response_format": "wav",
+            "extra_params": {"cfg_scale": 1.5},
+        },
+        timeout=300,
+    )
+    assert follow_up.status_code == 200, follow_up.text[:200]
+    assert follow_up.content[:4] == b"RIFF" and len(follow_up.content) > 44
diff --git a/tests/e2e/online_serving/test_boogu_image.py b/tests/e2e/online_serving/test_boogu_image.py
new file mode 100644
index 000000000..5a5494d7d
--- /dev/null
+++ b/tests/e2e/online_serving/test_boogu_image.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+Online serving tests for ``Boogu/Boogu-Image-0.1-Base`` (text-to-image).
+
+- ``test_text_to_image_001``: single chat request, default server (``_get_default_case``).
+- ``test_batch_001``: concurrent prompts via ``send_diffusion_request([cfg0, cfg1, ...])`` — one
+  dict per prompt; each entry carries its own ``messages`` / ``negative_prompt`` (see
+  ``TEST_PROMPTS``).
+
+Boogu-Image's pipeline reads ``sp.guidance_scale`` (not ``true_cfg_scale``), so the
+``extra_body`` uses ``guidance_scale``. These are smoke tests (minimal steps); numeric
+parity vs. the Diffusers baseline is covered separately (see the support plan, step 14).
+
+From ``tests/``::
+
+    pytest -s -v e2e/online_serving/test_boogu_image.py \
+        -m "full_model and diffusion and H100" --run-level=full_model
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+
+MODEL = "Boogu/Boogu-Image-0.1-Base"
+T2I_PROMPT = "A mountain lake at sunset, photorealistic, cinematic lighting"
+NEGATIVE_PROMPT = ""
+
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+TEST_PROMPTS: list[dict[str, str]] = [
+    {"prompt": "a cup of coffee on a table", "negative_prompt": ""},
+    {"prompt": "a toy dinosaur on a sandy beach", "negative_prompt": ""},
+    {"prompt": "a futuristic city skyline at sunset", "negative_prompt": ""},
+]
+
+
+def _get_default_case(model: str):
+    """Return a single default ``OmniServerParams`` row (no extra ``server_args``)."""
+    return [
+        pytest.param(
+            OmniServerParams(model=model),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.parametrize("omni_server", _get_default_case(MODEL), indirect=True)
+def test_text_to_image_001(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """Default Boogu-Image T2I smoke (single ``default`` server config)."""
+    messages = dummy_messages_from_mix_data(content_text=T2I_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "height": 512,
+            "width": 512,
+            "num_inference_steps": 2,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "guidance_scale": 4.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize("omni_server", _get_default_case(MODEL), indirect=True)
+def test_batch_001(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """Concurrent T2I: one ``request_config`` dict per prompt (``send_diffusion_request`` list mode)."""
+    request_config = [
+        {
+            "model": omni_server.model,
+            "messages": dummy_messages_from_mix_data(content_text=prompt["prompt"]),
+            "extra_body": {
+                "height": 512,
+                "width": 512,
+                "num_inference_steps": 2,
+                "negative_prompt": prompt["negative_prompt"],
+                "guidance_scale": 4.0,
+                "seed": 42,
+            },
+        }
+        for prompt in TEST_PROMPTS
+    ]
+    openai_client.send_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_boogu_image_edit.py b/tests/e2e/online_serving/test_boogu_image_edit.py
new file mode 100644
index 000000000..45f999d26
--- /dev/null
+++ b/tests/e2e/online_serving/test_boogu_image_edit.py
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+Online serving tests for Boogu-Image-0.1-Edit (image-to-image via chat completions).
+
+The Edit checkpoint shares the ``BooguImagePipeline`` class with the Base
+text-to-image checkpoint; the editing (TI2I) path activates when the request
+carries a reference image. Text guidance rides on ``guidance_scale`` (upstream
+default 4.0), and image guidance rides on ``guidance_scale_2`` (upstream default
+1.0 = off; a value > 1 enables the double-guidance path). Only a single
+reference image is supported.
+
+- ``test_single_image_to_image_001``: one reference image, text guidance only.
+- ``test_double_guidance_001``: one reference image, text + image guidance.
+- ``test_images_edits_endpoint_001``: same text-guided edit via ``/v1/images/edits``.
+- ``test_images_edits_endpoint_double_guidance_001``: double guidance via ``/v1/images/edits``.
+
+From ``tests/``::
+
+    pytest -s -v e2e/online_serving/test_boogu_image_edit.py \
+        -m "full_model and diffusion and H100" --run-level=full_model
+"""
+
+import base64
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.media import generate_synthetic_image
+from tests.helpers.runtime import (
+    OmniServer,
+    OmniServerParams,
+    OpenAIClientHandler,
+    dummy_messages_from_mix_data,
+)
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+
+EDIT_PROMPT = "Change the style to a colored pencil drawing."
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_diffusion_feature_cases(model: str):
+    """Return one ``default`` ``OmniServerParams`` row for ``model`` (no extra ``server_args``)."""
+    return [
+        pytest.param(
+            OmniServerParams(
+                model=model,
+            ),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.parametrize(
+    "omni_server",
+    _get_diffusion_feature_cases("Boogu/Boogu-Image-0.1-Edit"),
+    indirect=True,
+)
+def test_single_image_to_image_001(omni_server: OmniServer, openai_client: OpenAIClientHandler):
+    """Single-reference text-guided edit smoke for ``Boogu/Boogu-Image-0.1-Edit``."""
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(512, 512)['base64']}"
+
+    messages = dummy_messages_from_mix_data(image_data_url=image_data_url, content_text=EDIT_PROMPT)
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "num_inference_steps": 2,
+            # Boogu text guidance (upstream default 4.0); > 1 enables CFG.
+            "guidance_scale": 5.0,
+            "seed": 42,
+        },
+    }
+
+    openai_client.send_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize(
+    "omni_server",
+    _get_diffusion_feature_cases("Boogu/Boogu-Image-0.1-Edit"),
+    indirect=True,
+)
+def test_double_guidance_001(omni_server: OmniServer, openai_client: OpenAIClientHandler):
+    """Single-reference double-guidance edit (text + image guidance) smoke."""
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(512, 512)['base64']}"
+
+    messages = dummy_messages_from_mix_data(image_data_url=image_data_url, content_text=EDIT_PROMPT)
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "num_inference_steps": 2,
+            "guidance_scale": 5.0,
+            # Image guidance > 1 activates the 3-prediction double-guidance path.
+            "guidance_scale_2": 2.0,
+            "seed": 42,
+        },
+    }
+
+    openai_client.send_diffusion_request(request_config)
+
+
+def _edits_request_config(model: str, *, guidance_scale_2: float | None = None) -> dict:
+    """Multipart ``/v1/images/edits`` config: one synthetic reference + smoke-depth params."""
+    image_bytes = base64.b64decode(generate_synthetic_image(512, 512)["base64"])
+    data = {
+        "model": model,
+        "prompt": EDIT_PROMPT,
+        "num_inference_steps": 2,
+        # Boogu text guidance (upstream default 4.0); > 1 enables CFG.
+        "guidance_scale": 5.0,
+        "seed": 42,
+    }
+    if guidance_scale_2 is not None:
+        data["guidance_scale_2"] = guidance_scale_2
+    return {
+        "data": data,
+        "files": {"image": ("ref.jpg", image_bytes, "image/jpeg")},
+        "timeout": 300,
+    }
+
+
+def _assert_edits_response_has_image(responses) -> None:
+    assert responses and responses[0].success, "Expected a successful /v1/images/edits response"
+    body = responses[0].json_body
+    assert body and body.get("data"), "No image data returned by /v1/images/edits"
+    assert body["data"][0].get("b64_json"), "Missing b64_json in /v1/images/edits response"
+
+
+@pytest.mark.parametrize(
+    "omni_server",
+    _get_diffusion_feature_cases("Boogu/Boogu-Image-0.1-Edit"),
+    indirect=True,
+)
+def test_images_edits_endpoint_001(omni_server: OmniServer, openai_client: OpenAIClientHandler):
+    """Single-reference text-guided edit via the OpenAI-compatible ``/v1/images/edits`` endpoint."""
+    responses = openai_client.send_images_edits_http_request(_edits_request_config(omni_server.model))
+    _assert_edits_response_has_image(responses)
+
+
+@pytest.mark.parametrize(
+    "omni_server",
+    _get_diffusion_feature_cases("Boogu/Boogu-Image-0.1-Edit"),
+    indirect=True,
+)
+def test_images_edits_endpoint_double_guidance_001(omni_server: OmniServer, openai_client: OpenAIClientHandler):
+    """Double-guidance edit (text + image guidance) via ``/v1/images/edits``."""
+    responses = openai_client.send_images_edits_http_request(
+        _edits_request_config(omni_server.model, guidance_scale_2=2.0)
+    )
+    _assert_edits_response_has_image(responses)
diff --git a/tests/e2e/online_serving/test_boogu_image_edit_expansion.py b/tests/e2e/online_serving/test_boogu_image_edit_expansion.py
new file mode 100644
index 000000000..efc968eb6
--- /dev/null
+++ b/tests/e2e/online_serving/test_boogu_image_edit_expansion.py
@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+L4 expansion coverage for ``Boogu/Boogu-Image-0.1-Edit`` (image editing / TI2I).
+
+The nightly smoke module (``test_boogu_image_edit.py``) already covers single-image
+text-guided editing and the text+image double-guidance path. This expansion
+module adds the two edit paths smoke does not exercise:
+
+- ``test_image_only_guidance`` — ``guidance_scale=1.0`` (text CFG off) with
+  ``guidance_scale_2=2.0`` (image CFG on): the image-only branch of upstream's
+  CFG-branch priority (double > text-only > image-only > t2i), which no existing
+  e2e test reaches.
+- ``test_align_res_output_size`` — a non-square reference with no requested
+  ``height`` / ``width``: asserts the output resolution follows the reference
+  (upstream ``align_res``, on by default for a single reference).
+
+The Edit checkpoint shares ``BooguImagePipeline`` with the Base checkpoint; the
+TI2I path activates when the request carries a reference image. Only a single
+reference image is supported. Cases stay smoke-depth (``num_inference_steps=2``).
+CPU offload, Cache-DiT, and multi-GPU parallelism are not yet supported for this
+model and are intentionally omitted.
+
+From ``tests/``::
+
+    pytest -s -v e2e/online_serving/test_boogu_image_edit_expansion.py \
+        -m "full_model and diffusion and H100" --run-level=full_model
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.media import generate_synthetic_image
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+
+MODEL = "Boogu/Boogu-Image-0.1-Edit"
+EDIT_PROMPT = "Change the style to a colored pencil drawing."
+
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_diffusion_feature_cases(model: str):
+    """Return the single-card server configuration supported for Boogu-Image-Edit today."""
+    return [
+        pytest.param(
+            OmniServerParams(model=model),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_image_only_guidance(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """Image-only guidance: text CFG off (1.0), image CFG on (2.0) -> image-only CFG branch."""
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(512, 512)['base64']}"
+    messages = dummy_messages_from_mix_data(image_data_url=image_data_url, content_text=EDIT_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "num_inference_steps": 2,
+            # Text guidance off, image guidance on -> upstream's image-only branch.
+            "guidance_scale": 1.0,
+            "guidance_scale_2": 2.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_align_res_output_size(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """Output resolution follows the reference image (upstream ``align_res``).
+
+    No ``height`` / ``width`` is requested. The reference is 512x384 — both
+    already multiples of 32 (>= the ``vae_scale_factor * 2`` alignment) and well
+    under the VAE ``max_pixels`` / ``max_side`` limits — so the align-res target
+    equals the reference dims regardless of the exact VAE scale factor.
+    """
+    ref_width, ref_height = 512, 384
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(ref_width, ref_height)['base64']}"
+    messages = dummy_messages_from_mix_data(image_data_url=image_data_url, content_text=EDIT_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "num_inference_steps": 2,
+            "guidance_scale": 5.0,
+            "seed": 42,
+        },
+    }
+    responses = openai_client.send_diffusion_request(request_config)
+
+    assert responses and responses[0].images, "No image returned for the edit request"
+    out_image = responses[0].images[0]
+    assert (out_image.width, out_image.height) == (ref_width, ref_height), (
+        f"align_res should size the output to the reference dims {(ref_width, ref_height)}; "
+        f"got {(out_image.width, out_image.height)}"
+    )
diff --git a/tests/e2e/online_serving/test_boogu_image_expansion.py b/tests/e2e/online_serving/test_boogu_image_expansion.py
new file mode 100644
index 000000000..ef6d3a62e
--- /dev/null
+++ b/tests/e2e/online_serving/test_boogu_image_expansion.py
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+L4 expansion coverage for ``Boogu/Boogu-Image-0.1-Base`` (text-to-image).
+
+The nightly smoke module (``test_boogu_image.py``) already covers the default
+512x512 single request and a concurrent batch. This expansion module adds the
+request-level paths that smoke does not exercise, run against every currently
+supported single-GPU server configuration:
+
+Server rows (single card):
+- ``default`` — no extra ``server_args``.
+- ``vae_slicing_tiling`` — ``--vae-use-slicing --vae-use-tiling`` (the recipe's
+  OOM mitigation; applied generically in ``registry.initialize_model``).
+
+Cases (one per test, each parametrized over both server rows):
+- ``test_non_square_resolution`` — 768x1024, exercises the patchify / RoPE path
+  at a non-square aspect ratio.
+- ``test_cfg_off`` — ``guidance_scale=1.0``, exercises the no-CFG denoise branch
+  (single prediction per step).
+- ``test_high_resolution`` — 1024x1024, the recipe-recommended resolution.
+
+Boogu-Image reads ``sp.guidance_scale`` (not ``true_cfg_scale``). These stay
+smoke-depth (``num_inference_steps=2``); numeric parity vs. Diffusers is covered
+by the local parity harness (support plan, step 14). CPU offload, Cache-DiT, and
+multi-GPU parallelism are not yet supported for this model and are intentionally
+omitted (add rows here when those features land).
+
+From ``tests/``::
+
+    pytest -s -v e2e/online_serving/test_boogu_image_expansion.py \
+        -m "full_model and diffusion and H100" --run-level=full_model
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+
+MODEL = "Boogu/Boogu-Image-0.1-Base"
+T2I_PROMPT = "A mountain lake at sunset, photorealistic, cinematic lighting"
+NEGATIVE_PROMPT = ""
+
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_diffusion_feature_cases(model: str):
+    """Return the single-card server configurations supported for Boogu-Image today."""
+    return [
+        pytest.param(
+            OmniServerParams(model=model),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=["--vae-use-slicing", "--vae-use-tiling"],
+            ),
+            id="vae_slicing_tiling",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_non_square_resolution(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """Non-square (768x1024) T2I exercises the patchify / RoPE path off the square grid."""
+    messages = dummy_messages_from_mix_data(content_text=T2I_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "height": 1024,
+            "width": 768,
+            "num_inference_steps": 2,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "guidance_scale": 4.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_cfg_off(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """``guidance_scale=1.0`` exercises the no-CFG denoise branch (one prediction per step)."""
+    messages = dummy_messages_from_mix_data(content_text=T2I_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "height": 512,
+            "width": 512,
+            "num_inference_steps": 2,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "guidance_scale": 1.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_high_resolution(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    """1024x1024 T2I at the recipe-recommended resolution."""
+    messages = dummy_messages_from_mix_data(content_text=T2I_PROMPT)
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "extra_body": {
+            "height": 1024,
+            "width": 1024,
+            "num_inference_steps": 2,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "guidance_scale": 4.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_dreamzero_expansion.py b/tests/e2e/online_serving/test_dreamzero_expansion.py
index 38e7d4b16..66d558120 100644
--- a/tests/e2e/online_serving/test_dreamzero_expansion.py
+++ b/tests/e2e/online_serving/test_dreamzero_expansion.py
@@ -1,34 +1,37 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""E2E online serving test for DreamZero OpenPI websocket serving."""
+"""E2E online serving tests for DreamZero OpenPI websocket serving."""
 
 from __future__ import annotations
 
 import os
 from pathlib import Path
 
+import cv2
 import numpy as np
 import pytest
 
-from tests.dreamzero import openpi_client_helper as openpi_client
 from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniServerParams, get_open_port
+from tests.helpers.runtime import (
+    DREAMZERO_ACTION_DIM,
+    DREAMZERO_ACTION_HORIZON,
+    DREAMZERO_CAMERA_FILES,
+    OmniServerParams,
+    OpenPIWebSocketResponse,
+    get_open_port,
+)
+from tests.helpers.stage_config import get_deploy_config_path
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 os.environ["VLLM_TEST_CLEAN_GPU_MEMORY"] = "0"
 
 MODEL = "GEAR-Dreams/DreamZero-DROID"
 
-
 test_params = [
     OmniServerParams(
         model=MODEL,
-        port=8091,
-        server_args=[
-            "--deploy-config",
-            "vllm_omni/deploy/dreamzero_tp1_cfg2.yaml",
-        ],
+        stage_config_path=get_deploy_config_path("dreamzero_tp1_cfg2.yaml"),
         env_dict={
             "ATTENTION_BACKEND": "torch",
             "DIFFUSION_ATTENTION_BACKEND": "TORCH_SDPA",
@@ -39,10 +42,10 @@ test_params = [
 ]
 
 
-def _write_synthetic_video(path: Path, cv2_module, *, channel: int) -> None:
+def _write_synthetic_video(path: Path, *, channel: int) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     height, width, num_frames = 180, 320, 24
-    writer = cv2_module.VideoWriter(str(path), cv2_module.VideoWriter_fourcc(*"mp4v"), 15.0, (width, height))
+    writer = cv2.VideoWriter(str(path), cv2.VideoWriter_fourcc(*"mp4v"), 15.0, (width, height))
     if not writer.isOpened():
         raise RuntimeError(f"Failed to open video writer for {path}")
     try:
@@ -50,39 +53,47 @@ def _write_synthetic_video(path: Path, cv2_module, *, channel: int) -> None:
             frame = np.zeros((height, width, 3), dtype=np.uint8)
             frame[..., channel] = (frame_idx * 7) % 255
             frame[..., (channel + 1) % 3] = 64
-            writer.write(cv2_module.cvtColor(frame, cv2_module.COLOR_RGB2BGR))
+            writer.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
     finally:
         writer.release()
 
 
-def _write_synthetic_dreamzero_videos(client_mod, video_dir: Path) -> None:
-    for channel, file_name in enumerate(client_mod.CAMERA_FILES.values()):
-        _write_synthetic_video(video_dir / file_name, client_mod.cv2, channel=channel)
+def _write_synthetic_dreamzero_videos(video_dir: Path) -> None:
+    for channel, file_name in enumerate(DREAMZERO_CAMERA_FILES.values()):
+        _write_synthetic_video(video_dir / file_name, channel=channel)
+
+
+def _validate_dreamzero_openpi_session(response: OpenPIWebSocketResponse) -> None:
+    metadata = response.server_metadata
+    assert tuple(metadata["image_resolution"]) == (180, 320)
+    assert metadata["n_external_cameras"] == 2
+    assert metadata["needs_wrist_camera"] is True
+    assert metadata["needs_stereo_camera"] is False
+    assert metadata["needs_session_id"] is True
+    assert metadata["action_space"] == "joint_position"
+    assert response.operation_responses[-1]["status"] == "reset successful"
+
+    action_tensors = response.action_tensors
+    assert action_tensors is not None
+    assert len(action_tensors) == 3
+    for index, action in enumerate(action_tensors):
+        assert action.shape == (DREAMZERO_ACTION_HORIZON, DREAMZERO_ACTION_DIM)
+        assert action.dtype == np.float32
+        assert np.isfinite(action).all()
 
 
 @pytest.mark.slow
 @pytest.mark.diffusion
-@pytest.mark.distributed_cuda
 @hardware_test(res={"cuda": "H100"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_dreamzero_openpi_online(omni_server, tmp_path: Path) -> None:
-    try:
-        openpi_client.require_dependencies()
-    except ModuleNotFoundError as exc:
-        pytest.skip(str(exc))
-
+def test_dreamzero_openpi_online(omni_server, openai_client, tmp_path: Path) -> None:
     video_dir = tmp_path / "dreamzero_videos"
-    _write_synthetic_dreamzero_videos(openpi_client, video_dir)
-    result = openpi_client.run_policy_session(
-        host=omni_server.host,
-        port=omni_server.port,
-        video_dir=video_dir,
-        session_id="dreamzero-online-e2e",
-    )
-
-    openpi_client.validate_session_result(result)
-
-    metadata = result["metadata"]
-    assert metadata["needs_session_id"] is True
-    assert metadata["needs_stereo_camera"] is False
-    assert tuple(metadata["image_resolution"]) == (180, 320)
+    _write_synthetic_dreamzero_videos(video_dir)
+    response = openai_client.send_robot_openpi_ws_request(
+        {
+            "run_dreamzero_policy_session": True,
+            "video_dir": video_dir,
+            "session_id": "dreamzero-online-e2e",
+        }
+    )[0]
+    _validate_dreamzero_openpi_session(response)
diff --git a/tests/e2e/online_serving/test_dynin_omni_expansion.py b/tests/e2e/online_serving/test_dynin_omni_expansion.py
index 348191b6e..1f16a584b 100644
--- a/tests/e2e/online_serving/test_dynin_omni_expansion.py
+++ b/tests/e2e/online_serving/test_dynin_omni_expansion.py
@@ -26,7 +26,14 @@ T2I_PROMPT = "A high quality detailed living room interior photo."
 T2S_PROMPT = "Please read this sentence naturally: Hello from online serving."
 I2I_PROMPT = "Transform this outdoor nature boardwalk scene into a painting style with vivid colors."
 
-TEST_PARAMS = [OmniServerParams(model=MODEL, stage_config_path=STAGE_CONFIG, stage_init_timeout=600)]
+TEST_PARAMS = [
+    OmniServerParams(
+        model=MODEL,
+        stage_config_path=STAGE_CONFIG,
+        stage_init_timeout=600,
+        server_args=["--trust-remote-code"],
+    )
+]
 _STAGE_COUNT = 3
 _I2I_STAGE_SAMPLING = {"max_tokens": 1, "temperature": 0.0, "top_p": 1.0, "detokenize": False}
 
diff --git a/tests/e2e/online_serving/test_flux_2_dev_expansion.py b/tests/e2e/online_serving/test_flux_2_dev_expansion.py
index 77a7a9271..9bc3308b8 100644
--- a/tests/e2e/online_serving/test_flux_2_dev_expansion.py
+++ b/tests/e2e/online_serving/test_flux_2_dev_expansion.py
@@ -2,9 +2,11 @@
 End-to-end diffusion coverage for FLUX.2-dev in online serving mode.
 
 Coverage:
-- CPU offload
+- CPU offload (model-level)
+- Layerwise CPU offload
 - Ulysses sequence parallelism
 - Ring sequence parallelism
+- VAE patch parallel encode/decode
 
 This test verifies that FLUX.2-dev can be launched with CPU offload enabled,
 accepts text-to-image requests through the OpenAI-compatible API, and returns
@@ -43,6 +45,16 @@ def _get_flux_2_dev_feature_cases(model: str):
             id="cpu_offload",
             marks=SINGLE_CARD_FEATURE_MARKS,
         ),
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--enable-layerwise-offload",
+                ],
+            ),
+            id="layerwise_offload",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
         pytest.param(
             OmniServerParams(
                 model=model,
@@ -79,6 +91,21 @@ def _get_flux_2_dev_feature_cases(model: str):
             id="ring_2",
             marks=PARALLEL_FEATURE_MARKS,
         ),
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--enable-cpu-offload",
+                    "--tensor-parallel-size",
+                    "2",
+                    "--vae-patch-parallel-size",
+                    "2",
+                    "--vae-use-tiling",
+                ],
+            ),
+            id="vae_patch_parallel_2",
+            marks=PARALLEL_FEATURE_MARKS,
+        ),
     ]
 
 
diff --git a/tests/e2e/online_serving/test_flux_kontext_expansion.py b/tests/e2e/online_serving/test_flux_kontext_expansion.py
index 5fa4eb2a1..5714ef711 100644
--- a/tests/e2e/online_serving/test_flux_kontext_expansion.py
+++ b/tests/e2e/online_serving/test_flux_kontext_expansion.py
@@ -5,6 +5,7 @@ and are supported by the FluxKontext model.
 
 import pytest
 
+from tests.helpers.mark import hardware_marks
 from tests.helpers.media import generate_synthetic_image
 from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
 
@@ -13,6 +14,7 @@ pytestmark = [pytest.mark.diffusion, pytest.mark.slow]
 EDIT_PROMPT = "Transform this modern, geometrist image into a Vincent van Gogh style impressionist painting."
 NEGATIVE_PROMPT = "blurry, low quality, modern, geometrist"
 MODEL = "black-forest-labs/FLUX.1-Kontext-dev"
+PARALLEL_FEATURE_MARKS = hardware_marks(res={"cuda": "L4"}, num_cards=2)
 
 
 def _get_diffusion_feature_cases(model: str):
@@ -26,7 +28,33 @@ def _get_diffusion_feature_cases(model: str):
                     "--enable-cpu-offload",
                 ],
             ),
-            id="parallel_001",
+            id="parallel_tp_2",
+            marks=PARALLEL_FEATURE_MARKS,
+        ),
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--enable-cpu-offload",
+                    "--cfg-parallel-size",
+                    "2",
+                ],
+            ),
+            id="parallel_cfg_2",
+            marks=PARALLEL_FEATURE_MARKS,
+        ),
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--tensor-parallel-size",
+                    "2",
+                    "--enable-cpu-offload",
+                    "--cache-backend",
+                    "cache_dit",
+                ],
+            ),
+            id="parallel_002",
         ),
     ]
 
diff --git a/tests/e2e/online_serving/test_gr00t_openpi.py b/tests/e2e/online_serving/test_gr00t_openpi_expansion.py
similarity index 66%
rename from tests/e2e/online_serving/test_gr00t_openpi.py
rename to tests/e2e/online_serving/test_gr00t_openpi_expansion.py
index 40b8293d6..70e11088d 100644
--- a/tests/e2e/online_serving/test_gr00t_openpi.py
+++ b/tests/e2e/online_serving/test_gr00t_openpi_expansion.py
@@ -7,14 +7,19 @@ import os
 import numpy as np
 import pytest
 
-from tests.gr00t import openpi_client_helper as openpi_client
 from tests.helpers.mark import hardware_test
-from tests.helpers.runtime import OmniServerParams
+from tests.helpers.runtime import (
+    OmniServerParams,
+    OpenPIWebSocketResponse,
+    build_openpi_droid_observation,
+)
 from tests.helpers.stage_config import get_deploy_config_path
 
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 
 MODEL = "nvidia/GR00T-N1.7-3B"
+ACTION_KEYS = frozenset({"eef_9d", "gripper_position", "joint_position"})
+EXPECTED_EMBODIMENT_TAG = "OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT"
 
 pytest.importorskip("websockets")
 pytest.importorskip("openpi_client.msgpack_numpy")
@@ -34,7 +39,7 @@ test_params = [
 ]
 
 # Reference values captured from the Isaac-GR00T ZMQ server (nvidia/GR00T-N1.7-3B,
-# OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT embodiment) using build_droid_observation()
+# OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT embodiment) using build_openpi_droid_observation()
 # inputs: zero images (256×256), identity eef_9d, zero gripper/joint, "pick up the object".
 # Outputs are bit-reproducible across resets and across runs (max_diff=0.0).
 _REF_EEF_9D = np.array(
@@ -112,32 +117,65 @@ _REF_JOINT = np.array(
 )  # rows = step 0, step 4, step 39
 
 
-@pytest.mark.full_model
+def _validate_gr00t_openpi_session(response: OpenPIWebSocketResponse) -> None:
+    metadata = response.server_metadata
+    for key in ("action_horizon", "action_keys", "embodiment_tag", "needs_session_id"):
+        assert key in metadata, f"Missing GR00T metadata key: {key}"
+
+    assert metadata["embodiment_tag"] == EXPECTED_EMBODIMENT_TAG
+    assert metadata["needs_session_id"] is True
+    assert frozenset(metadata["action_keys"]) == ACTION_KEYS
+    assert response.operation_responses[-1]["status"] == "reset successful"
+
+    actions = response.actions
+    assert actions is not None
+    assert frozenset(actions) == ACTION_KEYS
+
+    action_horizon = int(metadata["action_horizon"])
+    expected_shapes = {
+        "eef_9d": (1, action_horizon, 9),
+        "gripper_position": (1, action_horizon, 1),
+        "joint_position": (1, action_horizon, 7),
+    }
+    for key, expected_shape in expected_shapes.items():
+        assert actions[key].shape == expected_shape
+        assert actions[key].dtype == np.float32
+        assert np.isfinite(actions[key]).all()
+
+
+@pytest.mark.slow
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_gr00t_n1d7_openpi_online(omni_server) -> None:
-    result = openpi_client.run_policy_session(
-        host=omni_server.host,
-        port=omni_server.port,
-        session_id="gr00t-online-e2e",
-    )
-    openpi_client.validate_session_result(result)
+def test_gr00t_n1d7_openpi_online(omni_server, openai_client) -> None:
+    response = openai_client.send_robot_openpi_ws_request(
+        {
+            "run_default_policy_session": True,
+            "session_id": "gr00t-online-e2e",
+        }
+    )[0]
+    _validate_gr00t_openpi_session(response)
 
 
-@pytest.mark.full_model
+@pytest.mark.slow
 @pytest.mark.diffusion
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_gr00t_n1d7_openpi_precision(omni_server) -> None:
+def test_gr00t_n1d7_openpi_precision(omni_server, openai_client) -> None:
     """Assert actions match Isaac-GR00T reference (GR00T_NOISE_SEED=42, zero inputs)."""
-    client = openpi_client.OpenPIWebsocketClient(host=omni_server.host, port=omni_server.port)
-    try:
-        obs = openpi_client.build_droid_observation(session_id="gr00t-precision-e2e")
-        client.reset({})
-        actions = client.infer(obs)
-    finally:
-        client.close()
+    response = openai_client.send_robot_openpi_ws_request(
+        {
+            "operations": [
+                {"endpoint": "reset", "payload": {}},
+                {
+                    "endpoint": "infer",
+                    "payload": build_openpi_droid_observation(session_id="gr00t-precision-e2e"),
+                },
+            ],
+        }
+    )[0]
+    actions = response.actions
+    assert actions is not None
 
     steps = [0, 4, 39]
     np.testing.assert_allclose(
diff --git a/tests/e2e/online_serving/test_higgs_audio_v2_expansion.py b/tests/e2e/online_serving/test_higgs_audio_v2_expansion.py
index e7371fe17..8927eb039 100644
--- a/tests/e2e/online_serving/test_higgs_audio_v2_expansion.py
+++ b/tests/e2e/online_serving/test_higgs_audio_v2_expansion.py
@@ -6,7 +6,7 @@ E2E Online expansion tests for higgs-audio v2 against /v1/audio/speech.
 v1 scope is plain text -> 24 kHz speech plus shallow voice clone via
 ref_audio + ref_text (inline) or voice=<name> (after POST /v1/audio/voices).
 The model-aware request validator
-(vllm_omni/entrypoints/openai/serving_speech.py::_validate_higgs_audio_v2_request)
+(vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2::validate)
 rejects multi-speaker tags, language overrides, task_type, and bare
 voice=<name> for names that do not match an uploaded speaker — this suite
 exercises both the happy path (plain text in, audio bytes out) and the
@@ -92,6 +92,15 @@ class TestHiggsAudioV2OnlineHappyPath:
         higgs_audio_v2.yaml pins ``codec_streaming: true`` + ``async_chunk: false``,
         so the only streaming surface exposed to clients is the WAV/PCM bytes
         served chunk-by-chunk from Stage 1 — exercise it directly.
+
+        NOTE: ``min_hnr_db=-3.0`` keeps the check as a catastrophic-codec-failure
+        guard (white noise / sample scramble measure around -10 dB) while
+        tolerating Higgs sampling variance: legitimate speech for this prompt
+        measured -1.03 dB on L4 (weekly CI, issue #5045) and 1.34 dB on H100, so
+        the default 1.0 dB threshold flakes on hardware-dependent tail samples.
+        Same rationale as the higgs_audio_v3 streaming thresholds (issue #4411);
+        content correctness is separately guarded by the full_model transcript
+        check.
         """
         openai_client.send_audio_speech_request(
             {
@@ -102,6 +111,7 @@ class TestHiggsAudioV2OnlineHappyPath:
                 "response_format": "pcm",
                 "timeout": DEFAULT_SPEECH_TIMEOUT_S,
                 "min_audio_bytes": _MIN_AUDIO_BYTES,
+                "min_hnr_db": -3.0,
             }
         )
 
diff --git a/tests/e2e/online_serving/test_indextts2.py b/tests/e2e/online_serving/test_indextts2_expansion.py
similarity index 97%
rename from tests/e2e/online_serving/test_indextts2.py
rename to tests/e2e/online_serving/test_indextts2_expansion.py
index 5ab0d1f8d..d971ef166 100644
--- a/tests/e2e/online_serving/test_indextts2.py
+++ b/tests/e2e/online_serving/test_indextts2_expansion.py
@@ -19,7 +19,7 @@ from tests.helpers.media import load_test_audio_data_url
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import get_deploy_config_path
 
-pytestmark = [pytest.mark.advanced_model, pytest.mark.tts]
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
 
 MODEL = "IndexTeam/IndexTTS-2"
 
diff --git a/tests/e2e/online_serving/test_krea2_expansion.py b/tests/e2e/online_serving/test_krea2_expansion.py
index 10aa520fb..f76a567f4 100644
--- a/tests/e2e/online_serving/test_krea2_expansion.py
+++ b/tests/e2e/online_serving/test_krea2_expansion.py
@@ -31,7 +31,7 @@ from PIL import Image
 from tests.helpers.mark import hardware_marks
 from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler, dummy_messages_from_mix_data
 
-pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+pytestmark = [pytest.mark.diffusion, pytest.mark.slow]
 
 MODEL = os.environ.get("KREA2_MODEL", "krea/Krea-2-Turbo")
 # vLLM-Omni-compatible PEFT repackaging of krea/Krea-2-LoRA-darkbrush (264 modules, r=alpha=32).
diff --git a/tests/e2e/online_serving/test_lingbot_video.py b/tests/e2e/online_serving/test_lingbot_video.py
new file mode 100644
index 000000000..e7af994cb
--- /dev/null
+++ b/tests/e2e/online_serving/test_lingbot_video.py
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+Online serving smoke for ``robbyant/lingbot-video-dense-1.3b``.
+
+The LingBot dense PR supports text-to-video only, so this module exercises the
+native ``/v1/videos`` path with a small 9-frame request.
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+MODEL = "robbyant/lingbot-video-dense-1.3b"
+PROMPT = "a robotic arm picks up a red block"
+NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
+DEFAULT_SAMPLING_PARAMS = '{"0":{"num_frames":81,"num_inference_steps":40,"guidance_scale":6.0}}'
+
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_diffusion_feature_cases(model: str):
+    return [
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--model-class-name",
+                    "LingBotVideoPipeline",
+                    "--default-sampling-params",
+                    DEFAULT_SAMPLING_PARAMS,
+                ],
+            ),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.diffusion
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_text_to_video_001(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    request_config = {
+        "model": omni_server.model,
+        "form_data": {
+            "model": omni_server.model,
+            "prompt": PROMPT,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "height": 192,
+            "width": 320,
+            "num_frames": 9,
+            "fps": 24,
+            "num_inference_steps": 2,
+            "guidance_scale": 3.0,
+            "flow_shift": 3.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_video_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_lingbot_video_expansion.py b/tests/e2e/online_serving/test_lingbot_video_expansion.py
new file mode 100644
index 000000000..cb5a314ff
--- /dev/null
+++ b/tests/e2e/online_serving/test_lingbot_video_expansion.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""
+L4 expansion coverage for ``robbyant/lingbot-video-dense-1.3b``.
+
+This file remains dense-only. Basic single-GPU MoE serving is covered by
+``test_lingbot_video_moe.py``; T2I, I2V, TI2V, and multi-GPU feature rows
+belong in follow-up PRs.
+"""
+
+import json
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+
+MODEL = "robbyant/lingbot-video-dense-1.3b"
+PROMPT = "a robotic arm picks up a red block"
+NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
+
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_diffusion_feature_cases(model: str):
+    return [
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=["--model-class-name", "LingBotVideoPipeline"],
+            ),
+            id="default",
+            marks=SINGLE_CARD_FEATURE_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_cfg_off(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    request_config = {
+        "model": omni_server.model,
+        "form_data": {
+            "model": omni_server.model,
+            "prompt": PROMPT,
+            "height": 192,
+            "width": 192,
+            "num_frames": 9,
+            "fps": 24,
+            "num_inference_steps": 2,
+            "guidance_scale": 1.0,
+            "flow_shift": 3.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_video_diffusion_request(request_config)
+
+
+@pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
+def test_batch_cfg_extra_params(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    request_config = {
+        "model": omni_server.model,
+        "form_data": {
+            "model": omni_server.model,
+            "prompt": PROMPT,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "height": 192,
+            "width": 320,
+            "num_frames": 9,
+            "fps": 24,
+            "num_inference_steps": 2,
+            "guidance_scale": 3.0,
+            "flow_shift": 3.0,
+            "seed": 42,
+            "extra_params": json.dumps({"batch_cfg": True}, separators=(",", ":")),
+        },
+    }
+    openai_client.send_video_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_lingbot_video_moe.py b/tests/e2e/online_serving/test_lingbot_video_moe.py
new file mode 100644
index 000000000..32a6cbf2f
--- /dev/null
+++ b/tests/e2e/online_serving/test_lingbot_video_moe.py
@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Single-GPU serving smoke for ``robbyant/lingbot-video-moe-30b-a3b``."""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_marks
+from tests.helpers.runtime import OmniServer, OmniServerParams, OpenAIClientHandler
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+MODEL = "robbyant/lingbot-video-moe-30b-a3b"
+PROMPT = "a robotic arm picks up a red block"
+NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
+SMOKE_DEFAULT_SAMPLING_PARAMS = '{"0":{"num_frames":81,"num_inference_steps":2,"guidance_scale":3.0}}'
+
+SINGLE_CARD_MARKS = hardware_marks(res={"cuda": "H100"})
+
+
+def _get_server_cases(model: str):
+    return [
+        pytest.param(
+            OmniServerParams(
+                model=model,
+                server_args=[
+                    "--model-class-name",
+                    "LingBotVideoPipeline",
+                    "--default-sampling-params",
+                    SMOKE_DEFAULT_SAMPLING_PARAMS,
+                ],
+            ),
+            id="default",
+            marks=SINGLE_CARD_MARKS,
+        ),
+    ]
+
+
+@pytest.mark.full_model
+@pytest.mark.diffusion
+@pytest.mark.parametrize("omni_server", _get_server_cases(MODEL), indirect=True)
+def test_text_to_video_moe(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
+    request_config = {
+        "model": omni_server.model,
+        "form_data": {
+            "model": omni_server.model,
+            "prompt": PROMPT,
+            "negative_prompt": NEGATIVE_PROMPT,
+            "height": 192,
+            "width": 320,
+            "num_frames": 9,
+            "fps": 24,
+            "flow_shift": 3.0,
+            "seed": 42,
+        },
+    }
+    openai_client.send_video_diffusion_request(request_config)
diff --git a/tests/e2e/online_serving/test_ltx2_expansion.py b/tests/e2e/online_serving/test_ltx2_expansion.py
index 82855f62f..4d0eb6c90 100644
--- a/tests/e2e/online_serving/test_ltx2_expansion.py
+++ b/tests/e2e/online_serving/test_ltx2_expansion.py
@@ -4,8 +4,7 @@
 Expansion tests for LTX-2 two-stage pipelines.
 
 Coverage:
-- HSDP with LTX2TwoStagesPipeline (text-to-video)
-- HSDP with LTX2ImageToVideoTwoStagesPipeline (image-to-video)
+- HSDP with LTX2DistilledPipeline (text-to-video and image-to-video)
 """
 
 import os
@@ -27,7 +26,6 @@ HSDP_ARGS = ["--use-hsdp", "--hsdp-shard-size", "2"]
 def _cases():
     cases = []
 
-    # T2V: LTX2TwoStagesPipeline
     cases.append(
         pytest.param(
             OmniServerParams(
@@ -35,15 +33,15 @@ def _cases():
                 server_args=[
                     *HSDP_ARGS,
                     "--model-class-name",
-                    "LTX2TwoStagesPipeline",
+                    "LTX2DistilledPipeline",
                 ],
             ),
+            False,
             id="t2v_hsdp",
             marks=PARALLEL_MARKS,
         )
     )
 
-    # I2V: LTX2ImageToVideoTwoStagesPipeline
     cases.append(
         pytest.param(
             OmniServerParams(
@@ -51,9 +49,10 @@ def _cases():
                 server_args=[
                     *HSDP_ARGS,
                     "--model-class-name",
-                    "LTX2ImageToVideoTwoStagesPipeline",
+                    "LTX2DistilledPipeline",
                 ],
             ),
+            True,
             id="i2v_hsdp",
             marks=PARALLEL_MARKS,
         )
@@ -62,25 +61,22 @@ def _cases():
     return cases
 
 
-@pytest.mark.parametrize("omni_server", _cases(), indirect=True)
+@pytest.mark.parametrize(("omni_server", "is_i2v"), _cases(), indirect=["omni_server"])
 def test_ltx2_two_stage_hsdp(
     omni_server: OmniServer,
+    is_i2v: bool,
     openai_client: OpenAIClientHandler,
 ):
-    is_i2v = any("ImageToVideo" in arg for arg in omni_server.serve_args)
-
-    # The two-stage pipeline generates at the requested resolution then 2x
-    # upsamples via LTX2LatentUpsamplerModel, so output dimensions differ
-    # from the request.  Omit height/width from form_data so the assertion
-    # helper skips the dimension check (it only asserts when the key is
-    # present).  The pipeline falls back to its own defaults.
+    # Keep CI small while exercising the fixed 8+3-step distilled recipe.
+    # Height and width describe the final output; Stage 1 runs at half size.
     form_data = {
         "prompt": PROMPT,
         "model": omni_server.model,
+        "height": 128,
+        "width": 128,
         "num_frames": 9,
         "fps": 8,
-        "num_inference_steps": 2,
-        "guidance_scale": 1.0,
+        "num_inference_steps": 8,
         "seed": 42,
     }
 
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5.py b/tests/e2e/online_serving/test_minicpmo_4_5.py
new file mode 100644
index 000000000..7e77de2e1
--- /dev/null
+++ b/tests/e2e/online_serving/test_minicpmo_4_5.py
@@ -0,0 +1,233 @@
+"""
+E2E Online tests for MiniCPM-o 4.5 model with multimodal input and audio / text output.
+
+MiniCPM-o 4.5 is a three-stage pipeline: Stage 0 Thinker (text), Stage 1 Talker
+(TTS codec), Stage 2 Code2Wav (vocoder). The talker -> Code2Wav bridge supports
+both async_chunk (streaming) and full-payload (``--no-async-chunk``) modes, so the
+tests below exercise the sync path as well.
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import generate_synthetic_audio, generate_synthetic_image, generate_synthetic_video
+from tests.helpers.runtime import OmniServerParams, dummy_messages_from_mix_data
+from tests.helpers.stage_config import get_deploy_config_path
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+_MODEL = "openbmb/MiniCPM-o-4_5"
+_CI_DEPLOY = get_deploy_config_path("minicpmo_4_5.yaml")
+
+test_params = [
+    pytest.param(
+        OmniServerParams(
+            model=_MODEL,
+            stage_config_path=_CI_DEPLOY,
+            use_stage_cli=False,
+            server_args=[
+                "--trust-remote-code",
+            ],
+        ),
+        id="default",
+    )
+]
+
+
+def get_system_prompt():
+    return {
+        "role": "system",
+        "content": [
+            {
+                "type": "text",
+                "text": (
+                    "You are MiniCPM-o 4.5, a virtual human capable of perceiving "
+                    "auditory and visual inputs, as well as generating text and speech."
+                ),
+            }
+        ],
+    }
+
+
+def get_prompt(prompt_type: str = "text_only") -> str:
+    prompts = {
+        "text_only": "What is the capital of China? Answer in 20 words.",
+        "mix": "What is recited in the audio? What is in this image? Describe the video briefly.",
+        "text_image": "What color are the squares in this image?",
+    }
+    return prompts.get(prompt_type, prompts["text_only"])
+
+
+def get_max_batch_size(size_type="few"):
+    batch_sizes = {"few": 5, "medium": 100, "large": 256}
+    return batch_sizes.get(size_type, 5)
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_text_to_text_001(omni_server, openai_client) -> None:
+    """
+    Test text-only input generating text output via OpenAI API.
+    Deploy Setting: default 2GPU
+    Input Modal: text
+    Output Modal: text
+    Input Setting: stream=False
+    """
+    messages = dummy_messages_from_mix_data(system_prompt=get_system_prompt(), content_text=get_prompt())
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": False,
+        "modalities": ["text"],
+        "key_words": {"text": ["Beijing"]},
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_text_to_audio_001(omni_server, openai_client) -> None:
+    """
+    Test text-only input generating text + audio output via OpenAI API.
+    This exercises the talker TTS region detection and in-process token2wav vocoder.
+    Deploy Setting: default 2GPU
+    Input Modal: text
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    messages = dummy_messages_from_mix_data(system_prompt=get_system_prompt(), content_text=get_prompt())
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+        "key_words": {"audio": ["Beijing"]},
+    }
+
+    openai_client.send_omni_request(request_config)
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_audio_to_text_audio_001(omni_server, openai_client) -> None:
+    """
+    Test audio input generating text + audio output via OpenAI API.
+    Deploy Setting: default 2GPU
+    Input Modal: text + audio
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    audio_data_url = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        audio_data_url=audio_data_url,
+        content_text=get_prompt("mix"),
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_image_to_text_audio_001(omni_server, openai_client) -> None:
+    """
+    Test image input generating text + audio output via OpenAI API.
+    Deploy Setting: default 2GPU
+    Input Modal: text + image
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(24, 24)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        image_data_url=image_data_url,
+        content_text=get_prompt("text_image"),
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@pytest.mark.full_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_video_to_text_audio_001(omni_server, openai_client) -> None:
+    """
+    Test video input generating text + audio output via OpenAI API.
+    Deploy Setting: default 2GPU
+    Input Modal: text + video
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(24, 24, 20)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        video_data_url=video_data_url,
+        content_text=get_prompt("mix"),
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.omni
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_mix_to_text_audio_001(omni_server, openai_client) -> None:
+    """
+    Test multi-modal input (text + audio + video + image) generating text + audio output.
+    Deploy Setting: default 2GPU
+    Input Modal: text + audio + video + image
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(24, 24, 20)['base64']}"
+    image_data_url = f"data:image/jpeg;base64,{generate_synthetic_image(24, 24)['base64']}"
+    audio_data_url = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        video_data_url=video_data_url,
+        image_data_url=image_data_url,
+        audio_data_url=audio_data_url,
+        content_text=get_prompt("mix"),
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py b/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
new file mode 100644
index 000000000..895846147
--- /dev/null
+++ b/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
@@ -0,0 +1,147 @@
+"""CI coverage for the MiniCPM-o 4.5 native-duplex Realtime API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+from pathlib import Path
+
+import pytest
+import websockets
+
+from tests.e2e.online_serving.minicpmo_realtime_duplex_scenarios import (
+    _ref_audio_data_url,
+    run_demo,
+)
+from tests.e2e.online_serving.run_minicpmo_realtime_duplex_multi_session import (
+    run_multi_session,
+)
+from tests.helpers.mark import hardware_test
+from tests.helpers.minicpmo_4_5_duplex import (
+    CORE_SERVER_PARAMS,
+    SERVER_PARAMS,
+    demo_args,
+    multi_session_args,
+    realtime_url,
+    resolve_ref_audio,
+    validated_input_wav,
+)
+from vllm_omni.experimental.fullduplex.client import build_realtime_url
+
+pytestmark = pytest.mark.omni
+
+
+async def _receive_protocol_events(ws, required_types: set[str], *, timeout_s: float) -> list[dict[str, object]]:
+    async def receive() -> list[dict[str, object]]:
+        events: list[dict[str, object]] = []
+        seen: set[str] = set()
+        while not required_types.issubset(seen):
+            raw = await ws.recv()
+            if not isinstance(raw, str):
+                continue
+            event = json.loads(raw)
+            if not isinstance(event, dict):
+                continue
+            events.append(event)
+            event_type = event.get("type")
+            if event_type == "error":
+                raise AssertionError(f"WebSocket protocol smoke received an error: {event}")
+            if isinstance(event_type, str):
+                seen.add(event_type)
+        return events
+
+    return await asyncio.wait_for(receive(), timeout=timeout_s)
+
+
+async def _run_protocol_smoke(*, url: str, model: str, ref_audio: Path) -> list[dict[str, object]]:
+    session_id = f"duplex-ci-protocol-{uuid.uuid4().hex}"
+    websocket_url = build_realtime_url(url, model, autostart=False, session_id=session_id)
+    async with websockets.connect(websocket_url, max_size=64 * 1024 * 1024) as ws:
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "session.update",
+                    "session": {
+                        "session_id": session_id,
+                        "model": model,
+                        "modalities": ["audio", "text"],
+                        "ref_audio": _ref_audio_data_url(str(ref_audio)),
+                        "extra_body": {"minicpmo45_native_duplex": True},
+                    },
+                }
+            )
+        )
+        events = await _receive_protocol_events(
+            ws,
+            {"session.created", "session.updated"},
+            timeout_s=60,
+        )
+        await ws.send(json.dumps({"type": "session.close"}))
+        events.extend(await _receive_protocol_events(ws, {"session.closed"}, timeout_s=60))
+    return events
+
+
+@pytest.mark.core_model
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", CORE_SERVER_PARAMS, indirect=True)
+def test_duplex_websocket_protocol_smoke(omni_server, model_prefix: str) -> None:
+    ref_audio = resolve_ref_audio(model_prefix)
+    events = asyncio.run(
+        _run_protocol_smoke(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=ref_audio,
+        )
+    )
+    event_types = [event.get("type") for event in events]
+    assert "session.created" in event_types
+    assert "session.updated" in event_types
+    assert event_types[-1] == "session.closed"
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_single_session_response_required(omni_server, model_prefix: str, tmp_path: Path) -> None:
+    result = asyncio.run(
+        run_demo(
+            demo_args(
+                omni_server=omni_server,
+                input_wav=validated_input_wav(),
+                ref_audio=resolve_ref_audio(model_prefix),
+                output_dir=tmp_path / "single_session",
+            )
+        )
+    )
+    assert result["ok"] is True, json.dumps(result, ensure_ascii=False, indent=2)
+    assert result["audio_delta_count"] > 0
+    assert result["done_count"] == 1
+    assert result["error_count"] == 0
+    assert result["all_audio_responses_have_transcript"] is True
+    assert result["transcript_delta_done_ok"] is True
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_two_sessions_resume_and_takeover(omni_server, model_prefix: str, tmp_path: Path) -> None:
+    result = asyncio.run(
+        run_multi_session(
+            multi_session_args(
+                omni_server=omni_server,
+                input_wav=validated_input_wav(),
+                ref_audio=resolve_ref_audio(model_prefix),
+                output_dir=tmp_path / "multi_session",
+                response_required=True,
+            )
+        )
+    )
+    assert result["ok"] is True, json.dumps(result, ensure_ascii=False, indent=2)
+    assert result["session_count"] == 2
+    assert result["resume"]["ok"] is True
+    assert result["takeover"]["ok"] is True
+    assert not result["failures"]
+    assert all(session["audio_delta_count"] > 0 for session in result["sessions"])
+    assert all(session["done_count"] == 1 for session in result["sessions"])
+    assert all(session["error_count"] == 0 for session in result["sessions"])
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py b/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
new file mode 100644
index 000000000..69c266456
--- /dev/null
+++ b/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
@@ -0,0 +1,86 @@
+"""Nightly lifecycle coverage for the MiniCPM-o 4.5 native-duplex API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from tests.e2e.online_serving.run_minicpmo_realtime_duplex_multi_session import (
+    run_lifecycle_probes,
+)
+from tests.e2e.online_serving.run_minicpmo_realtime_duplex_soft_interrupt import (
+    run_soft_interrupt,
+)
+from tests.helpers.mark import hardware_test
+from tests.helpers.minicpmo_4_5_duplex import (
+    SERVER_PARAMS,
+    SOFT_INTERRUPT_SHA256,
+    multi_session_args,
+    realtime_url,
+    resolve_ref_audio,
+    validated_input_wav,
+    validated_soft_interrupt_wav,
+)
+
+pytestmark = [pytest.mark.full_model, pytest.mark.omni]
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_admission_and_expiry_reaper(omni_server, model_prefix: str, tmp_path: Path) -> None:
+    args = multi_session_args(
+        omni_server=omni_server,
+        input_wav=validated_input_wav(),
+        ref_audio=resolve_ref_audio(model_prefix),
+        output_dir=tmp_path / "admission_expiry",
+        response_required=False,
+    )
+    args.sessions = 1
+    args.disconnect_session_index = None
+    args.takeover_session_index = None
+    args.expire_session_index = 0
+    args.verify_admission_limit = 2
+    result = asyncio.run(run_lifecycle_probes(args))
+
+    assert result["ok"] is True, json.dumps(result, ensure_ascii=False, indent=2)
+    assert result["expiry"]["ok"] is True
+    assert result["expiry"]["error_code"] == "session_resume_expired"
+    assert result["admission"]["ok"] is True
+    assert result["admission"]["overflow_error_code"] == "resource_exhausted"
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_soft_interrupt(omni_server, model_prefix: str, tmp_path: Path) -> None:
+    input_wav = validated_soft_interrupt_wav()
+    result = asyncio.run(
+        run_soft_interrupt(
+            SimpleNamespace(
+                url=realtime_url(omni_server),
+                model=omni_server.model,
+                input_wav=str(input_wav),
+                ref_audio=str(resolve_ref_audio(model_prefix)),
+                output_dir=str(tmp_path / "soft_interrupt"),
+                summary_output=None,
+                chunk_ms=200,
+                timeout_s=180.0,
+                require_audio=True,
+                no_realtime_pacing=False,
+                validation_mode="response-required",
+                min_responses=2,
+                min_audio_deltas_per_response=2,
+                input_sha256=SOFT_INTERRUPT_SHA256,
+                expect_followup_response_substring=None,
+            )
+        )
+    )
+
+    assert result["ok"] is True, json.dumps(result, ensure_ascii=False, indent=2)
+    assert result["error_count"] == 0
+    assert result["response_lifecycle_ok"] is True
+    assert result["response_audio_contract_ok"] is True
+    assert result["followup_response_transcript_ok"] is True
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5_expansion.py b/tests/e2e/online_serving/test_minicpmo_4_5_expansion.py
new file mode 100644
index 000000000..6e76904b6
--- /dev/null
+++ b/tests/e2e/online_serving/test_minicpmo_4_5_expansion.py
@@ -0,0 +1,185 @@
+"""E2E online expansion tests for MiniCPM-o 4.5.
+
+These cover modality combinations, separate Code2Wav behavior, sequential
+request isolation, longer audio output, and Chinese speech.
+"""
+
+import os
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import generate_synthetic_video
+from tests.helpers.runtime import OmniServerParams, dummy_messages_from_mix_data
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.full_model, pytest.mark.omni]
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+_MODEL = "openbmb/MiniCPM-o-4_5"
+_CI_DEPLOY = get_deploy_config_path("minicpmo_4_5.yaml")
+
+test_params = [
+    pytest.param(
+        OmniServerParams(
+            model=_MODEL,
+            stage_config_path=_CI_DEPLOY,
+            use_stage_cli=False,
+            server_args=[
+                "--trust-remote-code",
+            ],
+        ),
+        id="default",
+    )
+]
+
+
+def get_system_prompt():
+    return {
+        "role": "system",
+        "content": [
+            {
+                "type": "text",
+                "text": (
+                    "You are MiniCPM-o 4.5, a virtual human capable of perceiving "
+                    "auditory and visual inputs, as well as generating text and speech."
+                ),
+            }
+        ],
+    }
+
+
+def get_prompt(prompt_type: str = "text_only") -> str:
+    prompts = {
+        "text_only": "What is the capital of China? Answer in 20 words.",
+        "mix": "What is recited in the audio? What is in this image? Describe the video briefly.",
+    }
+    return prompts.get(prompt_type, prompts["text_only"])
+
+
+def get_max_batch_size(size_type="few"):
+    batch_sizes = {"few": 5, "medium": 100, "large": 256}
+    return batch_sizes.get(size_type, 5)
+
+
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_text_video_to_text_001(omni_server, openai_client) -> None:
+    """
+    Test text + video input generating text output.
+    Deploy Setting: default 2GPU
+    Input Modal: text + video
+    Output Modal: text
+    Input Setting: stream=False
+    """
+    video_data_url = f"data:video/mp4;base64,{generate_synthetic_video(24, 24, 20)['base64']}"
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        video_data_url=video_data_url,
+        content_text=get_prompt("mix"),
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": False,
+        "modalities": ["text"],
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_sequential_requests_independent(omni_server, openai_client) -> None:
+    """
+    Verify that sequential requests produce independent results and that the
+    second request does not receive the first request's audio or token state.
+    Deploy Setting: default 2GPU
+    Input Modal: text (two different prompts)
+    Output Modal: text + audio (both)
+    """
+    messages_1 = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text="What is the capital of France?",
+    )
+    messages_2 = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text="What is the capital of China?",
+    )
+
+    # Send first request and ensure it completes
+    openai_client.send_omni_request(
+        {
+            "model": omni_server.model,
+            "messages": messages_1,
+            "stream": True,
+        },
+        request_num=1,
+    )
+
+    # Send second request with different prompt; must produce its own output
+    openai_client.send_omni_request(
+        {
+            "model": omni_server.model,
+            "messages": messages_2,
+            "stream": True,
+            "key_words": {"text": ["Beijing"]},
+        },
+        request_num=1,
+    )
+
+
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_text_to_audio_long_output_001(omni_server, openai_client) -> None:
+    """
+    Test text input generating a longer audio output to exercise the
+    Code2Wav stage across multiple frames.
+    Deploy Setting: default 2GPU
+    Input Modal: text (longer prompt)
+    Output Modal: text + audio
+    Input Setting: stream=True
+    """
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text="What is the capital of China? Answer in 40 words.",
+    )
+
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "modalities": ["text", "audio"],
+        "stream": True,
+        # Delimit the assistant answer with the TTS template so the Talker
+        # does not spend its codec-token budget speaking hidden reasoning.
+        "extra_body": {
+            "chat_template_kwargs": {
+                "use_tts_template": True,
+                "enable_thinking": False,
+            }
+        },
+        "key_words": {"audio": ["Beijing"]},
+    }
+
+    openai_client.send_omni_request(request_config, request_num=get_max_batch_size())
+
+
+@hardware_test(res={"cuda": "H100", "npu": "A2"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", test_params, indirect=True)
+def test_chinese_text_to_audio(omni_server, openai_client) -> None:
+    """
+    Test Chinese text input generating audio output.
+    """
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text="北京，中国的首都，是一座融合了长城等历史地点与现代建筑的国际化大都市，充满了独特的文化与活力。请重复这句话。",
+    )
+    request_config = {
+        "model": omni_server.model,
+        "messages": messages,
+        "stream": True,
+        "key_words": {"text": ["北京"]},
+    }
+    openai_client.send_omni_request(request_config)
diff --git a/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py b/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
new file mode 100644
index 000000000..1dbfdbe2f
--- /dev/null
+++ b/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
@@ -0,0 +1,1705 @@
+import asyncio
+import base64
+import importlib.util
+import subprocess
+import sys
+import wave
+from pathlib import Path
+from types import SimpleNamespace
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+DRIVER_DIR = Path(__file__).resolve().parent
+DEMO_PATH = DRIVER_DIR / "minicpmo_realtime_duplex_scenarios.py"
+MULTI_DEMO_PATH = DRIVER_DIR / "run_minicpmo_realtime_duplex_multi_session.py"
+PAIR_DEMO_PATH = DRIVER_DIR / "run_minicpmo_realtime_duplex_demo_pair.py"
+SOFT_INTERRUPT_DEMO_PATH = DRIVER_DIR / "run_minicpmo_realtime_duplex_soft_interrupt.py"
+
+
+def _load_demo_module():
+    spec = importlib.util.spec_from_file_location("minicpmo_realtime_duplex_demo_test", DEMO_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _load_multi_demo_module():
+    spec = importlib.util.spec_from_file_location("minicpmo_realtime_duplex_multi_session_test", MULTI_DEMO_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _load_pair_demo_module():
+    spec = importlib.util.spec_from_file_location("minicpmo_realtime_duplex_demo_pair_test", PAIR_DEMO_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _load_soft_interrupt_demo_module():
+    spec = importlib.util.spec_from_file_location(
+        "minicpmo_realtime_duplex_soft_interrupt_test",
+        SOFT_INTERRUPT_DEMO_PATH,
+    )
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_realtime_duplex_multi_session_script_is_directly_executable():
+    result = subprocess.run(
+        [sys.executable, str(MULTI_DEMO_PATH), "--help"],
+        cwd=MULTI_DEMO_PATH.parents[3],
+        capture_output=True,
+        text=True,
+        timeout=20,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def test_realtime_duplex_demo_pair_script_is_directly_executable():
+    result = subprocess.run(
+        [sys.executable, str(PAIR_DEMO_PATH), "--help"],
+        cwd=PAIR_DEMO_PATH.parents[3],
+        capture_output=True,
+        text=True,
+        timeout=20,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def test_realtime_duplex_soft_interrupt_script_is_directly_executable():
+    result = subprocess.run(
+        [sys.executable, str(SOFT_INTERRUPT_DEMO_PATH), "--help"],
+        cwd=SOFT_INTERRUPT_DEMO_PATH.parents[3],
+        capture_output=True,
+        text=True,
+        timeout=20,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def test_realtime_duplex_demo_pair_requires_distinct_inputs_and_outputs(tmp_path):
+    demo = _load_pair_demo_module()
+    wav_a = tmp_path / "request_a.wav"
+    wav_b = tmp_path / "request_b.wav"
+    wav_a.write_bytes(b"same")
+    wav_b.write_bytes(b"same")
+
+    args = SimpleNamespace(
+        input_wav_a=str(wav_a),
+        input_wav_b=str(wav_b),
+        output_dir_a=str(tmp_path / "session_a"),
+        output_dir_b=str(tmp_path / "session_a"),
+    )
+
+    with pytest.raises(ValueError, match="output directories must be different"):
+        demo._validate_pair_args(args)
+
+    args.output_dir_b = str(tmp_path / "session_b")
+    with pytest.raises(ValueError, match="input WAV files must have different content"):
+        demo._validate_pair_args(args)
+
+
+def test_realtime_duplex_demo_pair_launches_demo_processes_concurrently(tmp_path, monkeypatch):
+    demo = _load_pair_demo_module()
+    fake_demo = tmp_path / "fake_realtime_duplex_demo.py"
+    start_log = tmp_path / "starts.log"
+    fake_demo.write_text(
+        "\n".join(
+            [
+                "import argparse, json, os, time",
+                "from pathlib import Path",
+                "parser = argparse.ArgumentParser()",
+                "parser.add_argument('--url')",
+                "parser.add_argument('--model')",
+                "parser.add_argument('--input-wav')",
+                "parser.add_argument('--output-dir')",
+                "parser.add_argument('--chunk-ms')",
+                "parser.add_argument('--timeout-s')",
+                "parser.add_argument('--session-id')",
+                "parser.add_argument('--ref-audio')",
+                "parser.add_argument('--require-audio', action='store_true')",
+                "parser.add_argument('--no-realtime-pacing', action='store_true')",
+                "args = parser.parse_args()",
+                "if args.ref_audio != os.environ.get('EXPECTED_REF_AUDIO'):",
+                "    raise SystemExit(f'unexpected ref audio: {args.ref_audio}')",
+                "output = Path(args.output_dir)",
+                "output.mkdir(parents=True, exist_ok=True)",
+                "response_id = 'resp-' + output.name",
+                "with open(os.environ['PAIR_START_LOG'], 'a', encoding='utf-8') as f:",
+                "    f.write(f'{output.name} {time.time()}\\n')",
+                "time.sleep(0.25)",
+                "events = [",
+                "    {'type': 'session.created'},",
+                "    {'type': 'response.created', 'response': {'id': response_id}},",
+                "    {'type': 'response.audio.delta', 'response_id': response_id, "
+                "'delta': 'AAAA', 'sample_rate_hz': 24000, '_client_received_at_s': 10.1},",
+                "    {'type': 'response.audio.delta', 'response_id': response_id, "
+                "'delta': 'AAAA', 'sample_rate_hz': 24000, '_client_received_at_s': 10.6},",
+                "    {'type': 'response.done', 'response_id': response_id},",
+                "    {'type': 'session.closed'},",
+                "]",
+                "Path(output / 'events.jsonl').write_text(",
+                "    ''.join(json.dumps(event) + '\\n' for event in events),",
+                "    encoding='utf-8',",
+                ")",
+                "result = {'ok': True, 'response_ids': [response_id], 'audio_bytes': 1, 'output_dir': str(output)}",
+                "Path(output / 'result.json').write_text(json.dumps(result), encoding='utf-8')",
+                "print(json.dumps(result))",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(demo, "DEMO_PATH", fake_demo)
+    monkeypatch.setenv("PAIR_START_LOG", str(start_log))
+    monkeypatch.setenv("EXPECTED_REF_AUDIO", str(tmp_path / "ref.wav"))
+    wav_a = tmp_path / "request_a.wav"
+    wav_b = tmp_path / "request_b.wav"
+    wav_a.write_bytes(b"request a")
+    wav_b.write_bytes(b"request b")
+
+    result = asyncio.run(
+        demo.run_pair(
+            SimpleNamespace(
+                url="ws://localhost:28889/v1/realtime?duplex=1",
+                model="/data/why/MiniCPM-o-4_5",
+                input_wav_a=str(wav_a),
+                input_wav_b=str(wav_b),
+                output_dir_a=str(tmp_path / "duplex_session_a"),
+                output_dir_b=str(tmp_path / "duplex_session_b"),
+                ref_audio=str(tmp_path / "ref.wav"),
+                summary_output=str(tmp_path / "summary.json"),
+                chunk_ms=200,
+                timeout_s=5.0,
+                no_realtime_pacing=False,
+                require_audio=True,
+                min_audio_deltas_per_session=2,
+            )
+        )
+    )
+
+    starts = [float(line.split()[1]) for line in start_log.read_text(encoding="utf-8").splitlines()]
+    assert len(starts) == 2
+    assert max(starts) - min(starts) < 0.2
+    assert result["ok"] is True
+    assert result["input_wavs_distinct"] is True
+    assert result["output_dirs_distinct"] is True
+    assert result["identity_isolation_ok"] is True
+    assert result["response_audio_contract_ok"] is True
+    assert {session["audio_delta_count"] for session in result["sessions"]} == {2}
+    for session in result["sessions"]:
+        assert session["all_audio_deltas_same_response"] is True
+        assert session["response_id_nonempty"] is True
+        assert session["first_audio_delta_before_done"] is True
+        assert len(session["audio_delta_timings"]) == 2
+
+
+def test_realtime_duplex_demo_pair_rejects_false_green_audio_contract(tmp_path):
+    demo = _load_pair_demo_module()
+    output = tmp_path / "session"
+    output.mkdir()
+    response_id = "resp-a"
+    events = [
+        {"type": "response.created", "response": {"id": response_id}},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "sample_rate_hz": 24000},
+        {"type": "response.audio.delta", "response_id": "resp-other", "delta": "AAAA", "sample_rate_hz": 24000},
+        {"type": "response.done", "response_id": response_id},
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    (output / "result.json").write_text(
+        demo.json.dumps({"ok": True, "response_ids": [response_id], "audio_bytes": 4}),
+        encoding="utf-8",
+    )
+
+    session = demo._summarize_session(
+        label="a",
+        input_wav="request.wav",
+        output_dir=str(output),
+        returncode=0,
+        stdout="",
+        stderr="",
+    )
+
+    assert session["ok"] is False
+    assert session["all_audio_deltas_same_response"] is False
+    assert session["response_audio_contract_ok"] is False
+
+
+def test_realtime_duplex_demo_pair_default_requires_multiple_audio_deltas(monkeypatch):
+    demo = _load_pair_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "pair.py",
+            "--input-wav-a",
+            "a.wav",
+            "--input-wav-b",
+            "b.wav",
+            "--output-dir-a",
+            "a",
+            "--output-dir-b",
+            "b",
+            "--ref-audio",
+            "ref.wav",
+        ],
+    )
+
+    args = demo.parse_args()
+
+    assert args.ref_audio == "ref.wav"
+    assert args.min_audio_deltas_per_session == 2
+
+
+def test_realtime_duplex_demo_pair_requires_ref_audio(monkeypatch):
+    demo = _load_pair_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "pair.py",
+            "--input-wav-a",
+            "a.wav",
+            "--input-wav-b",
+            "b.wav",
+            "--output-dir-a",
+            "a",
+            "--output-dir-b",
+            "b",
+        ],
+    )
+
+    with pytest.raises(SystemExit):
+        demo.parse_args()
+
+
+def test_realtime_duplex_soft_interrupt_requires_ref_audio(monkeypatch):
+    demo = _load_soft_interrupt_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "soft.py",
+            "--input-wav",
+            "input.wav",
+            "--output-dir",
+            "out",
+        ],
+    )
+
+    with pytest.raises(SystemExit):
+        demo.parse_args()
+
+
+def test_realtime_duplex_soft_interrupt_accepts_explicit_ref_audio(monkeypatch):
+    demo = _load_soft_interrupt_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "soft.py",
+            "--input-wav",
+            "input.wav",
+            "--output-dir",
+            "out",
+            "--ref-audio",
+            "ref.wav",
+        ],
+    )
+
+    args = demo.parse_args()
+
+    assert args.ref_audio == "ref.wav"
+    assert args.validation_mode == "model-policy"
+
+
+def test_realtime_duplex_soft_interrupt_response_required_needs_bound_fixture(monkeypatch):
+    demo = _load_soft_interrupt_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "soft.py",
+            "--input-wav",
+            "input.wav",
+            "--output-dir",
+            "out",
+            "--ref-audio",
+            "ref.wav",
+            "--validation-mode",
+            "response-required",
+        ],
+    )
+
+    with pytest.raises(SystemExit):
+        demo.parse_args()
+
+
+def test_realtime_duplex_soft_interrupt_rejects_input_checksum_mismatch(tmp_path):
+    demo = _load_soft_interrupt_demo_module()
+    input_wav = tmp_path / "input.wav"
+    input_wav.write_bytes(b"two-turn fixture")
+
+    with pytest.raises(ValueError, match="input WAV SHA256 mismatch"):
+        demo._validate_input_sha256(input_wav, "0" * 64)
+
+
+def test_realtime_duplex_soft_interrupt_accepts_multi_delta_handoff_sequence(tmp_path):
+    demo = _load_soft_interrupt_demo_module()
+    output = tmp_path / "soft_interrupt"
+    output.mkdir()
+    first_response_id = "resp-first"
+    second_response_id = "resp-second"
+    events = [
+        {"type": "response.listen", "_client_received_at_s": 1.0},
+        {"type": "response.created", "response": {"id": first_response_id}, "_client_received_at_s": 2.0},
+        {"type": "response.speak", "response_id": first_response_id, "_client_received_at_s": 2.0},
+        {
+            "type": "response.audio.delta",
+            "response_id": first_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": first_response_id,
+            "delta": "中国古代四大发明",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.audio.delta",
+            "response_id": first_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.6,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": first_response_id,
+            "delta": "是造纸术。",
+            "_client_received_at_s": 2.6,
+        },
+        {"type": "response.done", "response_id": first_response_id, "_client_received_at_s": 3.0},
+        {"type": "response.created", "response": {"id": second_response_id}, "_client_received_at_s": 4.0},
+        {"type": "response.speak", "response_id": second_response_id, "_client_received_at_s": 4.0},
+        {
+            "type": "response.audio.delta",
+            "response_id": second_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 4.1,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": second_response_id,
+            "delta": "一加一等于",
+            "_client_received_at_s": 4.1,
+        },
+        {
+            "type": "response.audio.delta",
+            "response_id": second_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 4.6,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": second_response_id,
+            "delta": "二。",
+            "_client_received_at_s": 4.6,
+        },
+        {"type": "response.done", "response_id": second_response_id, "_client_received_at_s": 5.0},
+        {"type": "response.listen", "_client_received_at_s": 5.2},
+        {"type": "input_audio_buffer.committed", "_client_received_at_s": 6.0},
+        {"type": "response.listen", "_client_received_at_s": 6.1},
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    (output / "result.json").write_text(
+        demo.json.dumps({"ok": True, "response_ids": [first_response_id, second_response_id]}),
+        encoding="utf-8",
+    )
+
+    summary = demo.summarize_artifacts(
+        output_dir=output,
+        validation_mode="response-required",
+        min_responses=2,
+        min_audio_deltas_per_response=2,
+        expect_followup_response_substring="一加一等于二",
+    )
+
+    assert summary["ok"] is True
+    assert summary["listen_between_responses"] is False
+    assert summary["second_response_before_final_commit"] is True
+    assert summary["final_listen_after_commit"] is True
+    assert summary["response_audio_contract_ok"] is True
+    assert summary["response_summaries"][0]["audio_delta_count"] == 2
+    assert summary["response_summaries"][1]["transcript"] == "一加一等于二。"
+
+
+def test_realtime_duplex_soft_interrupt_model_policy_accepts_single_response(tmp_path):
+    demo = _load_soft_interrupt_demo_module()
+    output = tmp_path / "model_policy"
+    output.mkdir()
+    response_id = "resp-only"
+    events = [
+        {"type": "response.listen", "_client_received_at_s": 1.0},
+        {"type": "response.created", "response": {"id": response_id}, "_client_received_at_s": 2.0},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.1},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.15},
+        {"type": "response.done", "response_id": response_id, "_client_received_at_s": 2.2},
+        {"type": "response.listen", "_client_received_at_s": 2.3},
+        {"type": "input_audio_buffer.committed", "_client_received_at_s": 3.0},
+        {"type": "response.listen", "_client_received_at_s": 3.1},
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    (output / "result.json").write_text(
+        demo.json.dumps({"ok": True, "response_ids": [response_id]}),
+        encoding="utf-8",
+    )
+
+    summary = demo.summarize_artifacts(
+        output_dir=output,
+        validation_mode="model-policy",
+        min_responses=2,
+        min_audio_deltas_per_response=2,
+        expect_followup_response_substring=None,
+    )
+
+    assert summary["ok"] is True
+    assert summary["validation_mode"] == "model-policy"
+    assert summary["enough_responses"] is True
+    assert summary["response_before_final_commit"] is True
+    assert summary["listen_after_response_before_commit"] is True
+
+
+def test_realtime_duplex_soft_interrupt_response_required_rejects_single_response(tmp_path):
+    demo = _load_soft_interrupt_demo_module()
+    output = tmp_path / "response_required"
+    output.mkdir()
+    response_id = "resp-only"
+    events = [
+        {"type": "response.listen", "_client_received_at_s": 1.0},
+        {"type": "response.created", "response": {"id": response_id}, "_client_received_at_s": 2.0},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.1},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.15},
+        {"type": "response.done", "response_id": response_id, "_client_received_at_s": 2.2},
+        {"type": "response.listen", "_client_received_at_s": 2.3},
+        {"type": "input_audio_buffer.committed", "_client_received_at_s": 3.0},
+        {"type": "response.listen", "_client_received_at_s": 3.1},
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    (output / "result.json").write_text(
+        demo.json.dumps({"ok": True, "response_ids": [response_id]}),
+        encoding="utf-8",
+    )
+
+    summary = demo.summarize_artifacts(
+        output_dir=output,
+        validation_mode="response-required",
+        min_responses=2,
+        min_audio_deltas_per_response=2,
+        expect_followup_response_substring="一加一等于二",
+    )
+
+    assert summary["ok"] is False
+    assert summary["enough_responses"] is False
+
+
+def test_realtime_duplex_soft_interrupt_reports_text_expectation_without_gating(tmp_path):
+    demo = _load_soft_interrupt_demo_module()
+    output = tmp_path / "second_response_text"
+    output.mkdir()
+    first_response_id = "resp-first"
+    second_response_id = "resp-second"
+    events = [
+        {"type": "response.listen", "_client_received_at_s": 1.0},
+        {"type": "response.created", "response": {"id": first_response_id}, "_client_received_at_s": 2.0},
+        {
+            "type": "response.audio.delta",
+            "response_id": first_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.audio.delta",
+            "response_id": first_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.2,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": first_response_id,
+            "delta": "一加一等于二",
+            "_client_received_at_s": 2.2,
+        },
+        {"type": "response.done", "response_id": first_response_id, "_client_received_at_s": 2.3},
+        {"type": "response.listen", "_client_received_at_s": 2.4},
+        {"type": "response.created", "response": {"id": second_response_id}, "_client_received_at_s": 3.0},
+        {
+            "type": "response.audio.delta",
+            "response_id": second_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 3.1,
+        },
+        {
+            "type": "response.audio.delta",
+            "response_id": second_response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 3.2,
+        },
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": second_response_id,
+            "delta": "不知道",
+            "_client_received_at_s": 3.2,
+        },
+        {"type": "response.done", "response_id": second_response_id, "_client_received_at_s": 3.3},
+        {"type": "response.listen", "_client_received_at_s": 3.4},
+        {"type": "input_audio_buffer.committed", "_client_received_at_s": 4.0},
+        {"type": "response.listen", "_client_received_at_s": 4.1},
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    (output / "result.json").write_text(
+        demo.json.dumps({"ok": True, "response_ids": [first_response_id, second_response_id]}),
+        encoding="utf-8",
+    )
+
+    summary = demo.summarize_artifacts(
+        output_dir=output,
+        validation_mode="response-required",
+        min_responses=2,
+        min_audio_deltas_per_response=2,
+        expect_followup_response_substring="一加一等于二",
+    )
+
+    assert summary["ok"] is True
+    assert summary["followup_response_transcript_ok"] is True
+    assert summary["followup_response_transcript_expectation_ok"] is False
+
+    events = [
+        event
+        for event in events
+        if event.get("response_id") != second_response_id or event["type"] != "response.audio_transcript.delta"
+    ]
+    (output / "events.jsonl").write_text(
+        "".join(demo.json.dumps(event) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    missing_transcript_summary = demo.summarize_artifacts(
+        output_dir=output,
+        validation_mode="response-required",
+        min_responses=2,
+        min_audio_deltas_per_response=2,
+        expect_followup_response_substring="一加一等于二",
+    )
+
+    assert missing_transcript_summary["ok"] is False
+    assert missing_transcript_summary["followup_response_transcript_ok"] is False
+
+
+def test_realtime_duplex_multi_session_resume_url_disables_autostart():
+    demo = _load_multi_demo_module()
+
+    url = demo._with_resume_mode("ws://localhost:8113/v1/realtime?duplex=1&model=openbmb%2FMiniCPM-o-4_5")
+
+    query = parse_qs(urlsplit(url).query)
+    assert query["model"] == ["openbmb/MiniCPM-o-4_5"]
+    assert query["resume"] == ["1"]
+
+
+def test_realtime_duplex_multi_session_rejects_cross_session_response_identity():
+    demo = _load_multi_demo_module()
+
+    assert demo._validate_identity_isolation(
+        [
+            {"completed_response_ids": ["resp-a"]},
+            {"completed_response_ids": ["resp-b"]},
+        ]
+    )
+    assert not demo._validate_identity_isolation(
+        [
+            {"completed_response_ids": ["resp-shared"]},
+            {"completed_response_ids": ["resp-shared"]},
+        ]
+    )
+
+
+def test_realtime_duplex_multi_session_reads_nested_terminal_identity():
+    demo = _load_multi_demo_module()
+
+    assert demo._event_session_id({"type": "session.heartbeat_ack", "session_id": "sid"}) == "sid"
+    assert (
+        demo._event_session_id({"type": "session.closed", "event": {"type": "session.closed", "session_id": "sid"}})
+        == "sid"
+    )
+
+
+def test_realtime_duplex_demo_resolves_distinct_turn_inputs():
+    demo = _load_demo_module()
+    primary = Path("first.wav")
+
+    assert demo._turn_input_paths(primary, [], turns=3) == [primary, primary, primary]
+    assert demo._turn_input_paths(primary, ["second.wav", "third.wav"], turns=3) == [
+        primary,
+        Path("second.wav"),
+        Path("third.wav"),
+    ]
+    with pytest.raises(ValueError, match="one --turn-input-wav"):
+        demo._turn_input_paths(primary, ["second.wav"], turns=3)
+
+
+def test_realtime_duplex_demo_explicitly_enables_native_runtime_before_connect():
+    demo = _load_demo_module()
+
+    url = demo._url_with_model(
+        "ws://localhost:8099/v1/realtime?duplex=1",
+        "openbmb/MiniCPM-o-4_5",
+    )
+
+    query = parse_qs(urlsplit(url).query)
+    assert query["minicpmo45_native_duplex"] == ["1"]
+
+
+def test_realtime_duplex_demo_explicit_session_id_reaches_autostart_query():
+    demo = _load_demo_module()
+
+    url = demo._url_with_model(
+        "ws://localhost:8099/v1/realtime?duplex=1",
+        "openbmb/MiniCPM-o-4_5",
+        session_id="reopen-e2e",
+    )
+
+    query = parse_qs(urlsplit(url).query)
+    assert query["session_id"] == ["reopen-e2e"]
+
+
+def test_realtime_duplex_demo_session_update_uses_explicit_session_id():
+    demo = _load_demo_module()
+
+    event = demo._session_update_event(
+        SimpleNamespace(
+            model="openbmb/MiniCPM-o-4_5",
+            output_audio_format="pcm16",
+            short_ack_ms=1200,
+            session_id="reopen-e2e",
+        )
+    )
+
+    assert event["type"] == "session.update"
+    assert "session_id" not in event
+    assert event["session"]["session_id"] == "reopen-e2e"
+    assert event["session"]["extra_body"]["minicpmo45_native_duplex"] is True
+
+
+def test_realtime_duplex_demo_response_required_uses_deterministic_sampling():
+    demo = _load_demo_module()
+
+    event = demo._session_update_event(
+        SimpleNamespace(
+            model="openbmb/MiniCPM-o-4_5",
+            output_audio_format="pcm16",
+            short_ack_ms=1200,
+            session_id=None,
+            validation_mode="response-required",
+            temperature=None,
+        )
+    )
+
+    assert event["session"]["temperature"] == 0.0
+
+
+def test_realtime_duplex_demo_model_policy_preserves_default_sampling():
+    demo = _load_demo_module()
+
+    event = demo._session_update_event(
+        SimpleNamespace(
+            model="openbmb/MiniCPM-o-4_5",
+            output_audio_format="pcm16",
+            short_ack_ms=1200,
+            session_id=None,
+            validation_mode="model-policy",
+            temperature=None,
+        )
+    )
+
+    assert "temperature" not in event["session"]
+
+
+def test_realtime_duplex_demo_resolves_explicit_turn_durations():
+    demo = _load_demo_module()
+
+    assert demo._turn_durations([], turns=3, first_turn_ms=3000) == [3000, 1200, 1200]
+    assert demo._turn_durations([0, 900, 1500], turns=3, first_turn_ms=3000) == [None, 900, 1500]
+    with pytest.raises(ValueError, match="one --turn-duration-ms"):
+        demo._turn_durations([0, 900], turns=3, first_turn_ms=3000)
+    with pytest.raises(ValueError, match="non-negative"):
+        demo._turn_durations([0, -1, 900], turns=3, first_turn_ms=3000)
+
+
+def test_realtime_duplex_demo_resolves_transcript_labels_for_requested_turns():
+    demo = _load_demo_module()
+
+    assert demo._turn_transcripts("first", turns=1) == ["first"]
+    assert demo._turn_transcripts("first", turns=4) == ["first", "继续", "再说一次", "turn-4"]
+
+
+def test_realtime_duplex_demo_reads_response_playback_cursor():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add(
+        {
+            "type": "response.done",
+            "response_id": "resp-1",
+            "response": {
+                "id": "resp-1",
+                "metadata": {
+                    "playback": {
+                        "sent_ms": 27920,
+                        "played_ms": 0,
+                    }
+                },
+            },
+        }
+    )
+
+    assert state.response_playback_sent_ms("resp-1") == 27920
+
+
+def test_realtime_duplex_demo_partitions_timing_by_response_identity():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    for response_id, created_at_s, audio_at_s, token_count in (
+        ("resp-1", 10.0, 10.1, 3),
+        ("resp-2", 20.0, 20.2, 5),
+    ):
+        state.add(
+            {"type": "response.created", "response": {"id": response_id}},
+            received_at_s=created_at_s,
+        )
+        state.add(
+            {
+                "type": "response.audio.delta",
+                "response_id": response_id,
+                "delta": base64.b64encode(b"audio").decode("ascii"),
+                "metadata": {
+                    "audio_duration_ms": 80,
+                    "vllm_omni": {
+                        "stage_metrics": {
+                            "0": {
+                                "num_tokens_out": token_count,
+                                "vllm_itls_ms": [10.0],
+                            }
+                        }
+                    },
+                },
+            },
+            received_at_s=audio_at_s,
+        )
+
+    timings = state.response_timing_summaries()
+
+    assert timings["resp-1"]["stage0_tokens"]["output_token_count"] == 3
+    assert timings["resp-1"]["audio_output"]["response_created_to_first_audio_ms"] == 100.0
+    assert timings["resp-1"]["audio_output"]["commit_to_first_audio_ms"] is None
+    assert timings["resp-2"]["stage0_tokens"]["output_token_count"] == 5
+    assert timings["resp-2"]["audio_output"]["response_created_to_first_audio_ms"] == 200.0
+    assert timings["resp-2"]["audio_output"]["commit_to_first_audio_ms"] is None
+
+
+def test_realtime_duplex_demo_model_policy_accepts_one_listen_per_streamed_turn():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "session.created"})
+    for turn in range(3):
+        state.add({"type": "input_audio_buffer.speech_started", "turn": turn})
+        state.add(
+            {
+                "type": "response.listen",
+                "response": {
+                    "status": "listening",
+                    "metadata": {"model_listen": True},
+                },
+            }
+        )
+        state.add({"type": "input_audio_buffer.committed", "turn": turn})
+
+    assert state.model_policy_event_order_ok(expected_turns=3)
+
+
+def test_realtime_duplex_demo_model_policy_accepts_continuous_input_without_commits():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "session.created"})
+    state.add({"type": "input_audio_buffer.speech_started"})
+    for _ in range(3):
+        state.add(
+            {
+                "type": "response.listen",
+                "response": {"metadata": {"model_listen": True}},
+            }
+        )
+
+    assert not state.model_policy_event_order_ok(expected_turns=3)
+    assert state.model_policy_event_order_ok(expected_turns=3, require_input_commit=False)
+
+
+def test_realtime_duplex_demo_distinguishes_late_and_missing_commit():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    response_id = "resp-1"
+    item_id = f"item_{response_id}"
+    for event in (
+        {"type": "session.created"},
+        {"type": "response.created", "response_id": response_id},
+        {"type": "conversation.item.added", "item": {"id": item_id}},
+        {"type": "response.output_item.added", "response_id": response_id},
+        {"type": "response.content_part.added", "response_id": response_id},
+        {"type": "response.speak", "response_id": response_id},
+        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA"},
+        {"type": "response.audio.done", "response_id": response_id},
+        {"type": "response.content_part.done", "response_id": response_id},
+        {"type": "response.output_item.done", "response_id": response_id},
+        {"type": "response.done", "response_id": response_id},
+        {"type": "input_audio_buffer.committed"},
+    ):
+        state.add(event)
+
+    assert not state.event_order_ok(require_input_commit=True)
+    assert state.event_order_ok(
+        require_input_commit=True,
+        require_commit_before_response=False,
+    )
+    state.events.pop()
+    assert not state.event_order_ok(
+        require_input_commit=True,
+        require_commit_before_response=False,
+    )
+
+
+def test_realtime_duplex_demo_accepts_overlap_unit_terminating_continuous_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response_id": "resp-1"})
+    state.add({"type": "response.done", "response_id": "resp-1"})
+
+    assert demo._continuous_overlap_terminal_is_outcome(
+        state,
+        validation_mode="model-policy",
+        model_unit_ready_while_active=True,
+        before_created=1,
+        before_model_listen=0,
+    )
+    assert not demo._continuous_overlap_terminal_is_outcome(
+        state,
+        validation_mode="response-required",
+        model_unit_ready_while_active=True,
+        before_created=1,
+        before_model_listen=0,
+    )
+
+
+def test_realtime_duplex_demo_full_turn_duration_does_not_slice_audio():
+    demo = _load_demo_module()
+    pcm16 = b"\x01\x00" * (demo.PCM16_SAMPLE_RATE * 2)
+
+    assert demo._select_turn_audio(pcm16, None) == pcm16
+    assert len(demo._select_turn_audio(pcm16, 1000)) == demo.PCM16_SAMPLE_RATE * demo.PCM16_BYTES_PER_SAMPLE
+
+
+def test_realtime_duplex_demo_distinct_inputs_compare_audio_content():
+    demo = _load_demo_module()
+    paths = [Path("first.wav"), Path("second.wav"), Path("third.wav")]
+
+    assert demo._turn_inputs_are_distinct(paths, [b"first", b"second", b"third"]) is True
+    assert demo._turn_inputs_are_distinct(paths, [b"same", b"same", b"third"]) is False
+    assert demo._turn_inputs_are_distinct([paths[0], paths[0]], [b"first", b"second"]) is False
+
+
+def _add_response_transcript(state, response_id, *, transcript, audio=True):
+    state.add(
+        {
+            "type": "response.audio.delta",
+            "response_id": response_id,
+            "delta": "YQ==" if audio else "",
+        }
+    )
+    if transcript:
+        state.add(
+            {
+                "type": "response.audio_transcript.delta",
+                "response_id": response_id,
+                "delta": transcript,
+            }
+        )
+        state.add(
+            {
+                "type": "response.audio_transcript.done",
+                "response_id": response_id,
+                "transcript": transcript,
+            }
+        )
+    state.add(
+        {
+            "type": "response.done",
+            "response_id": response_id,
+            "response": {"id": response_id, "status": "completed"},
+        }
+    )
+
+
+def test_realtime_duplex_demo_gate_checks_delta_done_and_turn_independence():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(
+        state,
+        "resp-1",
+        transcript="第一轮回答",
+    )
+    _add_response_transcript(
+        state,
+        "resp-2",
+        transcript="第二轮回答",
+    )
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1", "resp-2"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=True,
+    )
+
+    assert result["transcript_delta_done_ok"] is True
+    assert result["cross_turn_independent_ok"] is True
+
+
+def test_realtime_duplex_demo_speak_gate_accepts_one_decision_event_per_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response": {"id": "resp-1"}})
+    state.add(
+        {
+            "type": "response.speak",
+            "response_id": "resp-1",
+            "metadata": {"model_speak": True},
+        }
+    )
+
+    assert demo._evaluate_response_speak_contract(state)["response_speak_contract_ok"] is True
+
+
+def test_realtime_duplex_demo_speak_gate_rejects_duplicate_event():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response": {"id": "resp-1"}})
+    state.add({"type": "response.speak", "response_id": "resp-1"})
+    state.add({"type": "response.speak", "response_id": "resp-1"})
+
+    result = demo._evaluate_response_speak_contract(state)
+
+    assert result["response_speak_contract_ok"] is False
+    assert result["duplicate_response_speak_ids"] == ["resp-1"]
+
+
+def test_realtime_duplex_demo_speak_gate_rejects_text_channel():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response": {"id": "resp-1"}})
+    state.add(
+        {
+            "type": "response.speak",
+            "response_id": "resp-1",
+            "text": "must be emitted through response.audio_transcript.delta",
+        }
+    )
+
+    result = demo._evaluate_response_speak_contract(state)
+
+    assert result["response_speak_contract_ok"] is False
+    assert result["text_bearing_response_speak_count"] == 1
+
+
+def test_realtime_duplex_demo_gate_rejects_cross_turn_tail_reuse():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-1", transcript="第一轮回答")
+    _add_response_transcript(state, "resp-2", transcript="第二轮仍然带着第一轮回答")
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1", "resp-2"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=True,
+    )
+
+    assert result["cross_turn_independent_ok"] is False
+
+
+def test_realtime_duplex_demo_gate_rejects_terminal_only_previous_tail():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-1", transcript="上一轮回答结尾是的吗？")
+    _add_response_transcript(state, "resp-2", transcript="的吗？")
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1", "resp-2"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=True,
+    )
+
+    assert result["cross_turn_independent_ok"] is False
+
+
+def test_realtime_duplex_demo_gate_rejects_delta_done_mismatch():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-1", transcript="delta文本")
+    done = next(event for event in state.events if event.get("type") == "response.audio_transcript.done")
+    done["transcript"] = "另一个done文本"
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=False,
+    )
+
+    assert result["transcript_delta_done_ok"] is False
+
+
+def test_realtime_duplex_demo_gate_rejects_terminal_only_stale_tail():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(
+        state,
+        "resp-empty",
+        transcript="的吗？",
+        audio=False,
+    )
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-empty"],
+        expected_empty_response_ids={"resp-empty"},
+        require_cross_turn_independence=False,
+    )
+
+    assert result["empty_turns_ok"] is False
+
+
+def test_realtime_duplex_demo_gate_rejects_audio_without_transcript():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(
+        state,
+        "resp-audio-no-text",
+        transcript="",
+        audio=True,
+    )
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-audio-no-text"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=False,
+    )
+
+    assert result["nonempty_audio_has_transcript_ok"] is False
+
+
+def test_realtime_duplex_demo_response_required_rejects_unselected_audio_only_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-audio-only", transcript="", audio=True)
+    _add_response_transcript(state, "resp-with-text", transcript="你好", audio=True)
+
+    assert (
+        demo._all_audio_responses_have_transcript(
+            state,
+            ["resp-audio-only", "resp-with-text"],
+        )
+        is False
+    )
+
+
+def test_realtime_duplex_demo_gate_rejects_incomplete_model_turn_sentence():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-1", transcript="哎，不是说好不")
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=False,
+        require_terminal_punctuation=True,
+    )
+
+    assert result["terminal_punctuation_ok"] is False
+
+
+def test_realtime_duplex_demo_gate_accepts_short_interjection_without_punctuation():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    _add_response_transcript(state, "resp-1", transcript="哈哈")
+
+    result = demo._evaluate_transcript_integrity(
+        state,
+        ["resp-1"],
+        expected_empty_response_ids=set(),
+        require_cross_turn_independence=False,
+        require_terminal_punctuation=True,
+    )
+
+    assert result["terminal_punctuation_ok"] is True
+
+
+def test_realtime_duplex_demo_response_required_skips_audio_only_model_turn(monkeypatch):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+
+    async def fake_send_pcm16(*args, **kwargs):
+        state.add({"type": "response.created", "response": {"id": "resp-audio-only"}})
+        _add_response_transcript(state, "resp-audio-only", transcript="", audio=True)
+        state.add({"type": "response.created", "response": {"id": "resp-with-text"}})
+        _add_response_transcript(state, "resp-with-text", transcript="你好", audio=True)
+
+    class FakeWebSocket:
+        async def send(self, payload):
+            return None
+
+    monkeypatch.setattr(demo, "_send_pcm16", fake_send_pcm16)
+
+    response_id, outcome = asyncio.run(
+        demo._send_clean_turn(
+            FakeWebSocket(),
+            state,
+            b"\x00\x00",
+            transcript="fixture",
+            duration_ms=None,
+            chunk_ms=200,
+            timeout_s=0.1,
+            require_audio=True,
+            validation_mode="response-required",
+        )
+    )
+
+    assert response_id == "resp-with-text"
+    assert outcome == "speak"
+
+
+def test_realtime_duplex_demo_no_hint_realtime_turn_omits_transcript_hint(monkeypatch):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    captured = {}
+
+    async def fake_send_pcm16(*args, **kwargs):
+        del args
+        captured.update(kwargs)
+        state.add(
+            {
+                "type": "response.listen",
+                "response": {"metadata": {"model_listen": True}},
+            }
+        )
+
+    class FakeWebSocket:
+        async def send(self, payload):
+            del payload
+
+    monkeypatch.setattr(demo, "_send_pcm16", fake_send_pcm16)
+
+    response_id, outcome = asyncio.run(
+        demo._send_clean_turn(
+            FakeWebSocket(),
+            state,
+            b"\x00\x00",
+            transcript="turn label only",
+            duration_ms=None,
+            chunk_ms=200,
+            timeout_s=0.1,
+            require_audio=False,
+            validation_mode="model-policy",
+            send_transcript_hint=False,
+            realtime_input=True,
+            model_policy_settle_s=0.01,
+        )
+    )
+
+    assert response_id is None
+    assert outcome == "listen"
+    assert captured["hints"] == {}
+    assert captured["realtime_delay"] is True
+
+
+def test_realtime_duplex_demo_continuous_input_omits_browser_commit(monkeypatch):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+
+    async def fake_send_pcm16(*args, **kwargs):
+        del args, kwargs
+        state.add({"type": "response.created", "response": {"id": "resp-continuous"}})
+        _add_response_transcript(state, "resp-continuous", transcript="连续输入", audio=True)
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            self.messages.append(demo.json.loads(payload))
+
+    monkeypatch.setattr(demo, "_send_pcm16", fake_send_pcm16)
+    ws = FakeWebSocket()
+
+    response_id, outcome = asyncio.run(
+        demo._send_clean_turn(
+            ws,
+            state,
+            b"\x00\x00",
+            transcript="fixture",
+            duration_ms=None,
+            chunk_ms=200,
+            timeout_s=0.1,
+            require_audio=True,
+            validation_mode="response-required",
+            commit_input=False,
+        )
+    )
+
+    assert response_id == "resp-continuous"
+    assert outcome == "speak"
+    assert not any(message.get("type") == "input_audio_buffer.commit" for message in ws.messages)
+
+
+def test_realtime_duplex_demo_no_hint_gate_does_not_require_transcription_event():
+    demo = _load_demo_module()
+
+    assert demo._input_transcription_ok(0, transcript_hints_enabled=False)
+    assert not demo._input_transcription_ok(0, transcript_hints_enabled=True)
+    assert demo._input_transcription_ok(3, transcript_hints_enabled=True)
+
+
+def test_realtime_duplex_demo_gate_rejects_server_errors():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "error", "code": "runtime_signal_failed", "error": "signal failed"})
+
+    errors = demo._unexpected_error_events(state)
+
+    assert errors == [{"type": "error", "code": "runtime_signal_failed", "error": "signal failed"}]
+
+
+def test_realtime_duplex_demo_model_policy_waits_for_speak_after_intermediate_listen(monkeypatch):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+
+    async def fake_send_pcm16(*args, **kwargs):
+        del args, kwargs
+        state.add(
+            {
+                "type": "response.listen",
+                "response": {"metadata": {"model_listen": True}},
+            }
+        )
+
+        async def delayed_speak():
+            await asyncio.sleep(0.01)
+            state.add({"type": "response.created", "response": {"id": "resp-delayed"}})
+            _add_response_transcript(state, "resp-delayed", transcript="延迟回答", audio=False)
+
+        asyncio.create_task(delayed_speak())
+
+    class FakeWebSocket:
+        async def send(self, payload):
+            del payload
+
+    monkeypatch.setattr(demo, "_send_pcm16", fake_send_pcm16)
+
+    response_id, outcome = asyncio.run(
+        demo._send_clean_turn(
+            FakeWebSocket(),
+            state,
+            b"\x00\x00",
+            transcript="fixture",
+            duration_ms=None,
+            chunk_ms=200,
+            timeout_s=0.2,
+            require_audio=False,
+            validation_mode="model-policy",
+            model_policy_settle_s=0.05,
+        )
+    )
+
+    assert response_id == "resp-delayed"
+    assert outcome == "speak"
+
+
+def test_realtime_duplex_demo_playback_gate_covers_unassigned_completed_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    for response_id in ("resp-assigned", "resp-unassigned"):
+        state.add({"type": "response.created", "response": {"id": response_id}})
+        state.add(
+            {
+                "type": "response.done",
+                "response": {
+                    "id": response_id,
+                    "metadata": {"playback": {"sent_ms": 1200}},
+                },
+            }
+        )
+    state.add(
+        {
+            "type": "playback.acknowledged",
+            "event": {
+                "item_id": "item_resp-assigned",
+                "history_committed": True,
+            },
+        }
+    )
+
+    assert not demo._all_response_playback_history_committed(
+        state,
+        state.completed_response_ids(),
+    )
+
+
+def test_realtime_duplex_demo_acks_unassigned_completed_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    for response_id in ("resp-assigned", "resp-unassigned"):
+        state.add({"type": "response.created", "response": {"id": response_id}})
+        state.add(
+            {
+                "type": "response.done",
+                "response": {
+                    "id": response_id,
+                    "metadata": {"playback": {"sent_ms": 1200}},
+                },
+            }
+        )
+    state.add(
+        {
+            "type": "playback.acknowledged",
+            "event": {
+                "item_id": "item_resp-assigned",
+                "history_committed": True,
+            },
+        }
+    )
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            message = demo.json.loads(payload)
+            self.messages.append(message)
+            state.add(
+                {
+                    "type": "playback.acknowledged",
+                    "event": {
+                        "item_id": message["item_id"],
+                        "history_committed": True,
+                    },
+                }
+            )
+
+    ws = FakeWebSocket()
+    asyncio.run(demo._ack_all_completed_response_playback(ws, state, timeout_s=0.1))
+
+    assert [message["response_id"] for message in ws.messages] == ["resp-unassigned"]
+    assert demo._all_response_playback_history_committed(state, state.completed_response_ids())
+
+
+def test_realtime_duplex_demo_model_policy_does_not_assume_one_response_per_physical_input():
+    demo = _load_demo_module()
+
+    assert demo._response_cardinality_ok(
+        ["resp-1", "resp-2", "resp-3", "resp-4"],
+        expected_turns=3,
+        validation_mode="model-policy",
+    )
+    assert not demo._response_cardinality_ok(
+        ["resp-1", "resp-2", "resp-3", "resp-4"],
+        expected_turns=3,
+        validation_mode="response-required",
+    )
+
+
+def test_realtime_duplex_demo_only_requires_cross_turn_independence_for_response_required():
+    demo = _load_demo_module()
+
+    assert not demo._requires_cross_turn_independence(
+        validation_mode="model-policy",
+        distinct_inputs_required=True,
+    )
+    assert demo._requires_cross_turn_independence(
+        validation_mode="response-required",
+        distinct_inputs_required=True,
+    )
+    assert not demo._requires_cross_turn_independence(
+        validation_mode="response-required",
+        distinct_inputs_required=False,
+    )
+
+
+def test_realtime_duplex_demo_drains_late_model_response_before_close():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response": {"id": "resp-first"}})
+    state.add({"type": "response.done", "response": {"id": "resp-first"}})
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            self.messages.append(demo.json.loads(payload))
+
+    async def run_fixture():
+        async def finish_late_response():
+            await asyncio.sleep(0.01)
+            state.add({"type": "response.created", "response": {"id": "resp-late"}})
+            await asyncio.sleep(0.01)
+            state.add({"type": "response.done", "response": {"id": "resp-late"}})
+
+        late_response = asyncio.create_task(finish_late_response())
+        ws = FakeWebSocket()
+        await demo._drain_model_policy_responses(
+            ws,
+            state,
+            timeout_s=0.2,
+            settle_s=0.03,
+        )
+        await late_response
+        return ws
+
+    ws = asyncio.run(run_fixture())
+
+    assert state.completed_response_ids() == ["resp-first", "resp-late"]
+    assert not [message for message in ws.messages if message.get("type") == "session.close"]
+
+
+def test_realtime_duplex_demo_model_response_drain_times_out_with_active_ids():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    state.add({"type": "response.created", "response": {"id": "resp-active"}})
+
+    class FakeWebSocket:
+        async def send(self, payload):
+            del payload
+
+    with pytest.raises(TimeoutError, match="resp-active"):
+        asyncio.run(
+            demo._drain_model_policy_responses(
+                FakeWebSocket(),
+                state,
+                timeout_s=0.03,
+                settle_s=0.01,
+            )
+        )
+
+
+def test_realtime_duplex_demo_waits_at_each_model_unit_and_stops_after_speak():
+    demo = _load_demo_module()
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            self.messages.append(demo.json.loads(payload))
+
+    async def run_fixture():
+        ws = FakeWebSocket()
+        model_unit_message_counts = []
+
+        async def on_model_unit_ready():
+            model_unit_message_counts.append(len(ws.messages))
+            await asyncio.sleep(0)
+            return len(model_unit_message_counts) < 2
+
+        await demo._send_pcm16(
+            ws,
+            b"\x01\x00" * (demo.PCM16_SAMPLE_RATE * 3),
+            chunk_ms=200,
+            realtime_delay=False,
+            on_model_unit_ready=on_model_unit_ready,
+        )
+        return ws, model_unit_message_counts
+
+    ws, model_unit_message_counts = asyncio.run(run_fixture())
+
+    assert model_unit_message_counts == [5, 10]
+    assert len(ws.messages) == 10
+
+
+def test_realtime_duplex_demo_listen_only_overlap_accepts_silence_unit_before_first_done(monkeypatch):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    send_calls = 0
+
+    async def fake_send_pcm16(*args, **kwargs):
+        nonlocal send_calls
+        send_calls += 1
+        if send_calls == 1:
+            assert len(args[1]) == 2 + demo.PCM16_SAMPLE_RATE * demo.PCM16_BYTES_PER_SAMPLE
+            state.add({"type": "input_audio_buffer.speech_started", "turn": 1})
+            state.add({"type": "response.created", "response": {"id": "resp-first"}})
+            state.add(
+                {
+                    "type": "response.audio.delta",
+                    "response_id": "resp-first",
+                    "delta": "YQ==",
+                }
+            )
+            assert await kwargs["on_model_unit_ready"]() is False
+            return
+
+        del args
+        assert not state.response_done("resp-first")
+        kwargs["on_model_unit_ready"]()
+        _add_response_transcript(state, "resp-first", transcript="第一轮完成", audio=False)
+        state.add({"type": "response.created", "response": {"id": "resp-second"}})
+        _add_response_transcript(state, "resp-second", transcript="第二轮完成", audio=True)
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            self.messages.append(payload)
+
+    monkeypatch.setattr(demo, "_send_pcm16", fake_send_pcm16)
+    ws = FakeWebSocket()
+
+    response_ids, outcomes, overlap_ok = asyncio.run(
+        demo._send_listen_only_overlap_pair(
+            ws,
+            state,
+            b"\x00\x00",
+            b"\x00\x00",
+            transcripts=("first", "second"),
+            durations_ms=(None, None),
+            chunk_ms=200,
+            timeout_s=0.2,
+            send_transcript_hint=False,
+            realtime_input=True,
+            model_policy_settle_s=0.01,
+            validation_mode="response-required",
+            silence_ms=1000,
+        )
+    )
+
+    assert response_ids == ["resp-first", "resp-second"]
+    assert outcomes == ["speak", "speak"]
+    assert overlap_ok is True
+    assert sum(demo.json.loads(message)["type"] == "input_audio_buffer.commit" for message in ws.messages) == 2
+
+
+def test_realtime_duplex_demo_playback_ack_identifies_and_commits_response():
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    response_id = "resp-overlap-second"
+    state.add(
+        {
+            "type": "response.done",
+            "response": {
+                "id": response_id,
+                "metadata": {"playback": {"sent_ms": 1200}},
+            },
+        }
+    )
+
+    class FakeWebSocket:
+        def __init__(self):
+            self.messages = []
+
+        async def send(self, payload):
+            message = demo.json.loads(payload)
+            self.messages.append(message)
+            state.add(
+                {
+                    "type": "playback.acknowledged",
+                    "event": {
+                        "item_id": message.get("item_id"),
+                        "history_committed": message.get("item_id") == f"item_{response_id}",
+                    },
+                }
+            )
+
+    ws = FakeWebSocket()
+    asyncio.run(
+        demo._ack_response_playback(
+            ws,
+            state,
+            response_id,
+            timeout_s=0.1,
+            label="overlap second",
+        )
+    )
+
+    assert ws.messages == [
+        {
+            "type": "playback.ack",
+            "response_id": response_id,
+            "item_id": f"item_{response_id}",
+            "played_ms": 1200,
+            "committed_ms": 1200,
+        }
+    ]
+    assert state.playback_history_committed_count == 1
+
+
+def test_realtime_duplex_demo_writes_audio_per_response(tmp_path):
+    demo = _load_demo_module()
+    state = demo.DemoState()
+    for response_id, payload in (("resp-1", b"\x01\x00"), ("resp-2", b"\x02\x00")):
+        state.add({"type": "response.created", "response": {"id": response_id}})
+        state.add(
+            {
+                "type": "response.audio.delta",
+                "response_id": response_id,
+                "delta": demo.base64.b64encode(payload).decode(),
+                "sample_rate_hz": 24000,
+            }
+        )
+
+    demo._write_demo_artifacts(state, tmp_path, output_audio_format="pcm16")
+
+    for index, expected in enumerate((b"\x01\x00", b"\x02\x00"), start=1):
+        with wave.open(str(tmp_path / f"response_{index:02d}.wav"), "rb") as wf:
+            assert wf.getframerate() == 24000
+            assert wf.readframes(wf.getnframes()) == expected
diff --git a/tests/e2e/online_serving/test_omnivoice_expansion.py b/tests/e2e/online_serving/test_omnivoice_expansion.py
index ff41ee413..ab35b74ea 100644
--- a/tests/e2e/online_serving/test_omnivoice_expansion.py
+++ b/tests/e2e/online_serving/test_omnivoice_expansion.py
@@ -25,7 +25,7 @@ try:
 except ImportError:
     _HAS_VOICE_CLONE = False
 
-pytestmark = [pytest.mark.full_model, pytest.mark.tts]
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
 
 MODEL = "k2-fsa/OmniVoice"
 
diff --git a/tests/e2e/online_serving/test_qwen3_omni_expansion.py b/tests/e2e/online_serving/test_qwen3_omni_expansion.py
index 25ba4f284..1ba94c011 100644
--- a/tests/e2e/online_serving/test_qwen3_omni_expansion.py
+++ b/tests/e2e/online_serving/test_qwen3_omni_expansion.py
@@ -7,6 +7,7 @@ E2E Online tests for Qwen3-Omni model.
 import os
 
 import pytest
+from openai import BadRequestError
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import generate_synthetic_audio, generate_synthetic_image, generate_synthetic_video
@@ -467,6 +468,10 @@ def test_one_word_prompt_001(omni_server, openai_client) -> None:
         "messages": messages,
         "stream": True,
         "key_words": {"text": ["london"]},
+        # A one-word English clip is too short for whisper's language detection to
+        # be stable; unpinned it renders "London" as 런던 / ランデ / 梁敦 and the
+        # containment check then fails on correct audio.
+        "transcript_language": "en",
     }
 
     # Retry only when assert_omni_response fails on text/audio cosine similarity (see tests/helpers/assertions.py).
@@ -610,3 +615,21 @@ def test_text_to_audio_long_output_001(omni_server, openai_client) -> None:
     text = responses[0].text_content if responses else ""
     word_count = len(text.split())
     assert word_count >= 200, f"Expected at least 200 words in long output, got {word_count}"
+
+
+@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.parametrize("omni_server", test_params[:1], indirect=True)
+def test_invalid_audio_format_rejected(omni_server, openai_client) -> None:
+    """Ensure invalid audio format is rejected with 400 before streaming starts."""
+    messages = dummy_messages_from_mix_data(
+        system_prompt=get_system_prompt(),
+        content_text=get_prompt(),
+    )
+    with pytest.raises(BadRequestError, match="audio format"):
+        openai_client.client.chat.completions.create(
+            model=omni_server.model,
+            messages=messages,
+            modalities=["text", "audio"],
+            audio={"voice": "alloy", "format": "aac"},
+            stream=True,
+        )
diff --git a/tests/e2e/online_serving/test_qwen3_tts_customvoice.py b/tests/e2e/online_serving/test_qwen3_tts_customvoice.py
index 2aab84840..7ebe08e1a 100644
--- a/tests/e2e/online_serving/test_qwen3_tts_customvoice.py
+++ b/tests/e2e/online_serving/test_qwen3_tts_customvoice.py
@@ -15,12 +15,18 @@ import pytest
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniServerParams
-from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
+from tests.helpers.stage_config import (
+    get_deploy_config_path,
+    get_deploy_config_stage,
+    modify_stage_config,
+)
+from vllm_omni.platforms import current_omni_platform
 
 MODEL = "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice"
 
+_DEFAULT_STAGE_CONFIG = get_deploy_config_path("qwen3_tts.yaml")
 _STAGE_CONFIG = modify_stage_config(
-    get_deploy_config_path("qwen3_tts.yaml"),
+    _DEFAULT_STAGE_CONFIG,
     updates={"stages": {0: {"default_sampling_params.max_tokens": 500}}},
 )
 
@@ -50,11 +56,47 @@ tts_server_params = [
     )
 ]
 
+default_tts_server_params = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=_DEFAULT_STAGE_CONFIG,
+            server_args=["--trust-remote-code"],
+        ),
+        id="async_chunk",
+    )
+]
+
 
 @pytest.mark.core_model
 @pytest.mark.advanced_model
 @pytest.mark.tts
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", default_tts_server_params, indirect=True)
+def test_default_cuda_graph_startup(omni_server) -> None:
+    """Verify both stages start with the shipped CUDA Graph configuration.
+
+    The fixture reaching this test is the smoke assertion: it waits for the
+    server to become ready after both stages finish model initialization and
+    CUDA Graph capture. The regression covered here exited during stage 1
+    capture, before fixture setup could complete.
+    """
+    for stage_id in (0, 1):
+        stage = get_deploy_config_stage("qwen3_tts.yaml", stage_id=stage_id)
+        assert stage.get("enforce_eager", False) is False
+
+    assert omni_server.proc is not None
+    assert omni_server.proc.poll() is None
+
+
+@pytest.mark.core_model
+@pytest.mark.advanced_model
+@pytest.mark.tts
+@pytest.mark.skipif(
+    current_omni_platform.is_npu(),
+    reason="#issue 5479",
+)
+@hardware_test(res={"cuda": "L4", "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_001(omni_server, openai_client) -> None:
     """
@@ -80,7 +122,11 @@ def test_text_to_audio_001(omni_server, openai_client) -> None:
 @pytest.mark.core_model
 @pytest.mark.advanced_model
 @pytest.mark.tts
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.skipif(
+    current_omni_platform.is_npu(),
+    reason="#issue 5479",
+)
+@hardware_test(res={"cuda": "L4", "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_002(omni_server, openai_client) -> None:
     """
diff --git a/tests/e2e/online_serving/test_qwen3_tts_ref_audio_artifact_mode_e2e.py b/tests/e2e/online_serving/test_qwen3_tts_ref_audio_artifact_mode_e2e.py
new file mode 100644
index 000000000..e6c396932
--- /dev/null
+++ b/tests/e2e/online_serving/test_qwen3_tts_ref_audio_artifact_mode_e2e.py
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""E2E regression for Qwen3-TTS ref_audio artifact mode collision (#5049).
+
+Reproduces the issue's exact sequence on a live server: an
+``x_vector_only_mode=true`` request followed by an ICL
+(``x_vector_only_mode=false`` + ``ref_text``) request using the **same**
+``ref_audio``.
+
+Before the fix, the ref_audio artifact readiness was mode-agnostic: the
+x-vector-only request (which caches a speaker embedding but no ``ref_code``)
+marked the artifact "ready", so the ICL request took the artifact-only serving
+path (``ref_audio`` stripped before dispatch), found no ``ref_code`` and no
+audio to recompute from, and raised in ``build_prompt_embeds`` ->
+``EngineDeadError`` — taking the whole server down rather than failing the one
+request.
+
+After the fix (readiness keyed by ``(artifact_key, x_vector_only)``), the ICL
+request no longer matches the x-vector artifact, so it sends ``ref_audio`` and
+the worker computes ``ref_code``. Both requests succeed and the server stays up.
+"""
+
+import os
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+import pytest
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import load_test_audio_data_url
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
+
+MODEL = "Qwen/Qwen3-TTS-12Hz-0.6B-Base"
+DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 180.0
+
+# Vendored under tests/assets/qwen3_tts/clone_2.wav (see test_qwen3_tts_base.py).
+REF_AUDIO_URL = load_test_audio_data_url("qwen3_tts/clone_2.wav")
+REF_TEXT = "Okay. Yeah. I resent you. I love you. I respect you. But you know what? You blew it! And thanks to you."
+INPUT_TEXT = "The weather is nice today, perfect for a walk in the park."
+
+tts_server_params = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=get_deploy_config_path("qwen3_tts.yaml"),
+            server_args=["--trust-remote-code"],
+        ),
+        id="async_chunk",
+    )
+]
+
+
+@pytest.mark.advanced_model
+@pytest.mark.core_model
+@pytest.mark.tts
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_xvector_then_icl_same_ref_audio_keeps_engine_alive(omni_server, openai_client) -> None:
+    """Regression for #5049: x-vector-only then ICL on the same ref_audio.
+
+    Both requests must return audio and the engine must stay alive (pre-fix the
+    second request killed EngineCore).
+    """
+    base_request = {
+        "model": omni_server.model,
+        "input": INPUT_TEXT,
+        "stream": False,
+        "timeout": DEFAULT_AUDIO_SPEECH_TIMEOUT_S,
+        "response_format": "wav",
+        "task_type": "Base",
+        "ref_audio": REF_AUDIO_URL,
+        # Assert non-empty audio came back (not just HTTP 200).
+        "min_audio_bytes": 1,
+    }
+
+    # 1) x-vector-only request: caches a speaker embedding (no ref_code) and, on
+    #    completion, marks the ref_audio artifact "ready".
+    openai_client.send_audio_speech_request({**base_request, "x_vector_only_mode": True})
+
+    # 2) ICL request with the SAME ref_audio. Pre-fix this reused the x-vector
+    #    artifact via the artifact-only path, hit the missing ref_code, and
+    #    killed EngineCore (#5049). It must now succeed with audio.
+    openai_client.send_audio_speech_request({**base_request, "x_vector_only_mode": False, "ref_text": REF_TEXT})
+
+    # 3) The server must still be serving after the ICL request (pre-fix this
+    #    would fail with EngineDeadError / connection refused).
+    openai_client.send_audio_speech_request({**base_request, "x_vector_only_mode": True})
diff --git a/tests/e2e/online_serving/test_qwen_image.py b/tests/e2e/online_serving/test_qwen_image.py
index 454a87aa5..c40cfbda8 100644
--- a/tests/e2e/online_serving/test_qwen_image.py
+++ b/tests/e2e/online_serving/test_qwen_image.py
@@ -58,7 +58,6 @@ def _get_default_case(model: str):
     ]
 
 
-@pytest.mark.core_model
 @pytest.mark.advanced_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("omni_server", _get_default_case(MODEL), indirect=True)
diff --git a/tests/e2e/online_serving/test_step_audio2_expansion.py b/tests/e2e/online_serving/test_step_audio2_expansion.py
index 05beb1131..9c8280b59 100644
--- a/tests/e2e/online_serving/test_step_audio2_expansion.py
+++ b/tests/e2e/online_serving/test_step_audio2_expansion.py
@@ -3,34 +3,32 @@
 """
 E2E expansion tests for Step-Audio2 online serving (weekly CI).
 
-Tests speech-to-speech translation via /v1/chat/completions.
+Tests audio-to-text generation via /v1/chat/completions.
 Request shape follows examples/online_serving/step_audio2/openai_chat_completion_client.py.
 """
 
 import os
-from pathlib import Path
 
 import pytest
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import generate_synthetic_audio
 from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
 
 os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
 
 MODEL = "stepfun-ai/Step-Audio-2-mini"
-STAGE_CONFIG = str(Path(__file__).parent / "stage_configs" / "step_audio2_ci.yaml")
+DEPLOY_CONFIG = get_deploy_config_path("step_audio2_ci.yaml")
 SAMPLE_RATE = 16000
 SEED = 42
-# pyttsx3 synthetic input phrase; Step-Audio2 text output includes codec tokens
-# (<audio_NNNN>) so we validate audio only, not text↔audio similarity.
 SYNTH_PHRASE = "how are you"
 
 TEST_PARAMS = [
     pytest.param(
         OmniServerParams(
             model=MODEL,
-            stage_config_path=STAGE_CONFIG,
+            server_args=["--deploy-config", DEPLOY_CONFIG, "--trust-remote-code"],
             env_dict={"VLLM_IMAGE_FETCH_TIMEOUT": "60"},
         ),
         id="step_audio2",
@@ -64,19 +62,11 @@ def _default_sampling_params_list() -> list[dict]:
             "detokenize": True,
             "repetition_penalty": 1.05,
         },
-        {
-            "temperature": 0.0,
-            "top_p": 1.0,
-            "top_k": -1,
-            "max_tokens": 1,
-            "seed": SEED,
-            "detokenize": False,
-        },
     ]
 
 
-def _build_s2st_request_config(omni_server, audio_base64: str) -> dict:
-    """Build audio-to-audio (S2ST) chat completion request config."""
+def _build_audio_to_text_request_config(omni_server, audio_base64: str) -> dict:
+    """Build an audio-to-text chat completion request config."""
     audio_url = f"data:audio/wav;base64,{audio_base64}"
     return {
         "model": omni_server.model,
@@ -86,7 +76,7 @@ def _build_s2st_request_config(omni_server, audio_base64: str) -> dict:
                 "content": [
                     {
                         "type": "text",
-                        "text": "You are an audio processing assistant. Listen and repeat the audio content.",
+                        "text": "You are a speech recognition assistant. Transcribe the audio accurately.",
                     }
                 ],
             },
@@ -94,26 +84,19 @@ def _build_s2st_request_config(omni_server, audio_base64: str) -> dict:
                 "role": "user",
                 "content": [
                     {"type": "audio_url", "audio_url": {"url": audio_url}},
-                    {"type": "text", "text": "Please listen to this audio and repeat its content."},
+                    {"type": "text", "text": "Please transcribe the audio content."},
                 ],
             },
-            {"role": "assistant", "content": "<tts_start>"},
         ],
-        # Thinker text includes undetokenized audio codec placeholders; assert audio only.
-        "modalities": ["audio"],
-        "audio_ref_text": SYNTH_PHRASE,
+        "modalities": ["text"],
         "sampling_params_list": _default_sampling_params_list(),
-        "extra_body": {
-            "continue_final_message": True,
-            "add_generation_prompt": False,
-        },
     }
 
 
 @hardware_test(res={"cuda": "H100"}, num_cards=1)
-def test_single_s2st_request(omni_server, openai_client) -> None:
-    """Test single speech-to-speech request via chat completions API."""
-    request_config = _build_s2st_request_config(
+def test_single_audio_to_text_request(omni_server, openai_client) -> None:
+    """Test a single audio-to-text request via the chat completions API."""
+    request_config = _build_audio_to_text_request_config(
         omni_server,
         _synthetic_audio_base64(duration_sec=2),
     )
@@ -122,9 +105,9 @@ def test_single_s2st_request(omni_server, openai_client) -> None:
 
 @hardware_test(res={"cuda": "H100"}, num_cards=1)
 @pytest.mark.parametrize("request_num", [2, 4])
-def test_concurrent_s2st_requests(omni_server, openai_client, request_num: int) -> None:
-    """Test concurrent speech-to-speech requests."""
-    request_config = _build_s2st_request_config(
+def test_concurrent_audio_to_text_requests(omni_server, openai_client, request_num: int) -> None:
+    """Test concurrent audio-to-text requests."""
+    request_config = _build_audio_to_text_request_config(
         omni_server,
         _synthetic_audio_base64(duration_sec=2),
     )
diff --git a/tests/e2e/online_serving/test_voxtral_tts_expansion.py b/tests/e2e/online_serving/test_voxtral_tts_expansion.py
index 1448567d3..264778ab9 100644
--- a/tests/e2e/online_serving/test_voxtral_tts_expansion.py
+++ b/tests/e2e/online_serving/test_voxtral_tts_expansion.py
@@ -30,7 +30,7 @@ pytestmark = [
 ]
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "xpu": "B60"}, num_cards=1)
 def test_speech_english_basic(omni_server, openai_client) -> None:
     """Test basic English TTS generation."""
     openai_client.send_audio_speech_request(
@@ -46,7 +46,7 @@ def test_speech_english_basic(omni_server, openai_client) -> None:
     )
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": "L4", "xpu": "B60"}, num_cards=1)
 def test_speech_english_streaming(omni_server, openai_client) -> None:
     """Test basic streaming English TTS generation (PCM via streaming API)."""
     openai_client.send_audio_speech_request(
diff --git a/tests/engine/test_arg_utils.py b/tests/engine/test_arg_utils.py
index cf77e2256..ca491275e 100644
--- a/tests/engine/test_arg_utils.py
+++ b/tests/engine/test_arg_utils.py
@@ -128,6 +128,24 @@ def test_qwen3_tts_codec_frame_rate_patching():
     assert omni_config.codec_frame_rate_hz == 12.3
 
 
+def test_qwen3_tts_startup_task_type_is_validated():
+    vllm_config = EngineArgs().create_model_config()
+
+    config = OmniModelConfig.from_vllm_model_config(
+        vllm_config,
+        model_arch="Qwen3TTSTalkerForConditionalGenerationARVLLM",
+        task_type="Base",
+    )
+    assert config.task_type == "Base"
+
+    with pytest.raises(ValueError, match="Qwen3-TTS --task-type must be one of"):
+        OmniModelConfig.from_vllm_model_config(
+            vllm_config,
+            model_arch="Qwen3TTSTalkerForConditionalGenerationARVLLM",
+            task_type="fl2va",
+        )
+
+
 def test_from_cli_args_picks_up_stage_configs_path():
     """from_cli_args should pick up stage_configs_path from namespace."""
     ns = argparse.Namespace(
diff --git a/tests/test_arg_utils.py b/tests/engine/test_arg_utils_shared_fields.py
similarity index 100%
rename from tests/test_arg_utils.py
rename to tests/engine/test_arg_utils_shared_fields.py
diff --git a/tests/engine/test_async_omni_engine_abort.py b/tests/engine/test_async_omni_engine_abort.py
index 794475388..dfe00732f 100644
--- a/tests/engine/test_async_omni_engine_abort.py
+++ b/tests/engine/test_async_omni_engine_abort.py
@@ -1,6 +1,5 @@
 import asyncio
 import os
-import sys
 from contextlib import ExitStack
 
 import pytest
@@ -67,11 +66,9 @@ async def generate(
 @pytest.mark.asyncio
 async def test_abort():
     with ExitStack() as after:
-        # Avoid SHM IPC in tests to prevent /dev/shm exhaustion and SIGBUS.
         engine = AsyncOmni(
             model=model,
             stage_configs_path=stage_config,
-            shm_threshold_bytes=sys.maxsize,
         )
         after.callback(engine.shutdown)
 
diff --git a/tests/engine/test_async_omni_engine_input.py b/tests/engine/test_async_omni_engine_input.py
index a1ec472f6..740064173 100644
--- a/tests/engine/test_async_omni_engine_input.py
+++ b/tests/engine/test_async_omni_engine_input.py
@@ -1,4 +1,5 @@
 import pytest
+import torch
 from pytest_mock import MockerFixture
 from vllm.sampling_params import SamplingParams
 from vllm.v1.engine import EngineCoreRequest
@@ -6,7 +7,9 @@ from vllm.v1.engine import EngineCoreRequest
 from vllm_omni.distributed.omni_coordinator import ReplicaInfo, ReplicaStatus
 from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine, StageRuntimeInfo
+from vllm_omni.engine.serialization import deserialize_additional_information
 from vllm_omni.engine.stage_pool import StagePool
+from vllm_omni.model_executor.stage_input_processors.bagel import ExpandedPrompt
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -64,6 +67,76 @@ def test_build_add_request_message_preserves_additional_information(mocker: Mock
     output_processor.add_request.assert_not_called()
 
 
+def test_build_add_request_message_preserves_model_intermediate_buffer(mocker: MockerFixture):
+    engine = object.__new__(AsyncOmniEngine)
+    params = SamplingParams(max_tokens=8)
+    engine.default_sampling_params_list = [params]
+    engine.stage_metadata = [StageRuntimeInfo(final_output=False, final_output_type=None, stage_type="llm")]
+    engine.supported_tasks = ("speech",)
+
+    input_processor = mocker.Mock()
+    input_processor.process_inputs.return_value = _make_engine_core_request()
+    engine.input_processor = input_processor
+
+    output_processor = mocker.Mock()
+    engine.output_processors = [output_processor]
+
+    hidden = torch.arange(6, dtype=torch.float32).reshape(2, 3)
+    prompt = {
+        "prompt_token_ids": [1, 1, 1],
+        "model_intermediate_buffer": {
+            "ids": {"tts": [11, 12]},
+            "hidden_states": {"tts": hidden},
+        },
+    }
+
+    msg = engine._build_add_request_message(
+        request_id="req-1",
+        prompt=prompt,
+        sampling_params_list=[params],
+        final_stage_id=0,
+        arrival_time=0.0,
+    )
+
+    request = msg.prompt
+    assert isinstance(request, OmniEngineCoreRequest)
+    assert request.additional_information is not None
+    assert request.additional_information.entries["global_request_id"].list_data == ["req-1"]
+    assert request.additional_information.entries["omni_final_stage_id"].scalar_data == 0
+    assert isinstance(request.model_intermediate_buffer, dict)
+    info = request.model_intermediate_buffer
+    assert info["ids"]["tts"] == [11, 12]
+    assert torch.equal(info["hidden_states"]["tts"], hidden)
+
+
+def test_cfg_companion_suppresses_payload_but_forces_kv_transfer(mocker: MockerFixture):
+    engine = object.__new__(AsyncOmniEngine)
+    params = SamplingParams(max_tokens=8)
+    engine.prompt_expand_func = lambda *_args: [
+        ExpandedPrompt(
+            prompt={"prompt": "negative"},
+            role="cfg_text",
+            request_id_suffix="__cfg_text",
+        )
+    ]
+    engine.supported_tasks = ("generate",)
+    engine.input_processor = mocker.Mock()
+    engine.input_processor.process_inputs.return_value = _make_engine_core_request("req__cfg_text")
+    engine.request_queue = mocker.Mock()
+
+    engine._enqueue_cfg_companions(
+        parent_id="req",
+        original_prompt={"prompt": "positive"},
+        stage0_params=params,
+        sampling_params_list=[params],
+    )
+
+    message = engine.request_queue.sync_q.put.call_args.args[0]
+    metadata = deserialize_additional_information(message.prompt.additional_information)
+    assert metadata["omni_final_stage_id"] == 0
+    assert metadata["omni_force_kv_transfer"] is True
+
+
 def test_build_add_request_message_with_resumable_streaming(mocker: MockerFixture):
     engine = object.__new__(AsyncOmniEngine)
     params = SamplingParams(max_tokens=8)
diff --git a/tests/engine/test_async_omni_engine_outputs.py b/tests/engine/test_async_omni_engine_outputs.py
index ecf3ee9ee..a1b7a536e 100644
--- a/tests/engine/test_async_omni_engine_outputs.py
+++ b/tests/engine/test_async_omni_engine_outputs.py
@@ -4,13 +4,33 @@ Focuses on the critical behavior: when the orchestrator thread dies,
 subsequent attempts to collect output raise RuntimeError.
 """
 
+import asyncio
 import queue
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from types import SimpleNamespace
 
 import pytest
 from pytest_mock import MockerFixture
 
+from vllm_omni.engine.async_engine_utils import weak_shutdown_async_omni_engine
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
-from vllm_omni.engine.messages import ErrorMessage, OutputMessage
+from vllm_omni.engine.messages import (
+    CollectiveRPCResultMessage,
+    ErrorMessage,
+    OutputMessage,
+)
+from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
+from vllm_omni.experimental.fullduplex.engine.duplex_control_client import (
+    DuplexControlClient,
+    DuplexControlRequestError,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    AppendDuplexInputMessage,
+    DuplexControlResultMessage,
+    DuplexFence,
+    SignalDuplexTurnMessage,
+)
 from vllm_omni.outputs import OmniRequestOutput
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -26,6 +46,33 @@ def _make_engine(output_queue, mocker: MockerFixture, *, thread_alive: bool = Tr
     return engine
 
 
+def test_weak_shutdown_closes_rpc_router_before_joining_orchestrator(mocker: MockerFixture):
+    request_queue = mocker.MagicMock()
+    output_queue = mocker.MagicMock()
+    rpc_output_queue = mocker.MagicMock()
+    router = mocker.MagicMock()
+    orchestrator_thread = mocker.MagicMock()
+    orchestrator_thread.is_alive.return_value = True
+
+    def assert_router_closed_before_join(*args, **kwargs):
+        router.close.assert_called_once_with()
+
+    orchestrator_thread.join.side_effect = assert_router_closed_before_join
+
+    weak_shutdown_async_omni_engine(
+        orchestrator_thread,
+        request_queue,
+        output_queue,
+        rpc_output_queue,
+        router,
+    )
+
+    request_queue.sync_q.put.assert_called_once()
+    assert request_queue.sync_q.put.call_args.kwargs["timeout"] > 0
+    orchestrator_thread.join.assert_called_once()
+    assert orchestrator_thread.join.call_args.kwargs["timeout"] > 0
+
+
 def test_try_get_output_raises_after_orchestrator_dies(mocker: MockerFixture):
     """Draining remaining results then hitting an empty queue with a dead
     orchestrator must raise RuntimeError so callers know the pipeline is gone."""
@@ -56,18 +103,17 @@ def test_try_get_output_raises_after_orchestrator_dies(mocker: MockerFixture):
 @pytest.mark.asyncio
 async def test_try_get_output_async_raises_after_orchestrator_dies(mocker: MockerFixture):
     """Same scenario as above but for the async variant."""
-    mock_queue = mocker.MagicMock()
-    mock_queue.sync_q.get_nowait.side_effect = [
+    raw_queue = queue.Queue()
+    raw_queue.put_nowait(
         OutputMessage(
             request_id="r1",
             stage_id=0,
             engine_outputs=OmniRequestOutput(request_id="r1"),
             finished=False,
-        ),
-        queue.Empty,
-    ]
+        )
+    )
 
-    engine = _make_engine(mock_queue, mocker, thread_alive=True)
+    engine = _make_engine(SimpleNamespace(sync_q=raw_queue), mocker, thread_alive=True)
 
     assert (await engine.try_get_output_async()).request_id == "r1"
 
@@ -102,12 +148,495 @@ async def test_fatal_error_message_surfaces_through_try_get_output_async(mocker:
     """Async variant of the fatal error message test."""
     fatal_msg = ErrorMessage(error="Orchestrator thread crashed", fatal=True)
 
-    mock_queue = mocker.MagicMock()
-    mock_queue.sync_q.get_nowait.return_value = fatal_msg
+    raw_queue = queue.Queue()
+    raw_queue.put_nowait(fatal_msg)
 
-    engine = _make_engine(mock_queue, mocker, thread_alive=False)
+    engine = _make_engine(SimpleNamespace(sync_q=raw_queue), mocker, thread_alive=False)
 
     msg = await engine.try_get_output_async()
     assert msg is not None
     assert msg.type == "error"
     assert msg.fatal is True
+
+
+def test_output_remains_on_shared_output_path(mocker: MockerFixture):
+    raw_queue = queue.Queue()
+    raw_queue.put_nowait(
+        OutputMessage(
+            request_id="legacy-duplex-request",
+            stage_id=0,
+            engine_outputs=OmniRequestOutput(request_id="legacy-duplex-request"),
+            finished=False,
+        )
+    )
+    engine = _make_engine(SimpleNamespace(sync_q=raw_queue), mocker)
+
+    output = engine.try_get_output(timeout=0.01)
+
+    assert output.request_id == "legacy-duplex-request"
+
+
+def test_duplex_control_client_uses_engine_owned_correlated_transport():
+    engine = object.__new__(AsyncOmniEngine)
+    engine._duplex_control_client = None
+    engine._correlated_rpc_client = CorrelatedRpcClient(queue.Queue(), queue.Queue())
+
+    try:
+        client = engine._get_duplex_control_client()
+
+        assert isinstance(client, DuplexControlClient)
+        assert client._transport is engine._correlated_rpc_client
+        assert not hasattr(engine, "_submit_rpc_and_wait")
+    finally:
+        engine._correlated_rpc_client.close()
+
+
+def test_duplex_control_api_requires_explicit_fence():
+    engine = object.__new__(AsyncOmniEngine)
+
+    with pytest.raises(TypeError, match="fence"):
+        engine.open_duplex_session("sid")
+    with pytest.raises(TypeError, match="fence"):
+        engine.append_duplex_input("sid", mode="append_audio_chunk", payload={})
+    with pytest.raises(TypeError, match="fence"):
+        engine.signal_duplex_turn("sid", event="turn.end")
+    with pytest.raises(TypeError, match="fence"):
+        engine.close_duplex_session("sid")
+
+
+def test_open_duplex_session_waits_for_control_ack(mocker: MockerFixture):
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    control_result = DuplexControlResultMessage(
+        control_id="ctrl-1",
+        fence=DuplexFence("sid"),
+        operation="open",
+        session_id="sid",
+        ok=False,
+        stage_results=[{"stage_id": 0, "replica_id": 0, "result": {"supported": False}}],
+        unsupported_count=1,
+        error_count=0,
+    )
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-1"))
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        pending = executor.submit(engine.open_duplex_session, "sid", fence=DuplexFence("sid"), timeout=1)
+        msg = request_q.get(timeout=1)
+        assert msg.type == "open_duplex_session"
+        assert msg.control_id == "ctrl-1"
+        rpc_q.put(control_result)
+        with pytest.raises(DuplexControlRequestError) as exc_info:
+            pending.result(timeout=1)
+
+    assert exc_info.value.result["unsupported_count"] == 1
+    assert exc_info.value.result["stage_results"][0]["result"]["supported"] is False
+    engine._correlated_rpc_client.close()
+
+
+def test_signal_duplex_turn_message_carries_next_fence(mocker: MockerFixture):
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    cancelled_fence = DuplexFence("sid-cancel", epoch=4, turn_id=2)
+    next_fence = DuplexFence("sid-cancel", epoch=5, turn_id=2)
+    control_result = DuplexControlResultMessage(
+        control_id="ctrl-signal",
+        fence=cancelled_fence,
+        operation="signal",
+        session_id="sid-cancel",
+        ok=True,
+        stage_results=[],
+    )
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-signal"))
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        pending = executor.submit(
+            engine.signal_duplex_turn,
+            "sid-cancel",
+            event="input.cancel",
+            fence=cancelled_fence,
+            next_fence=next_fence,
+            session_config={"temperature": 0.0},
+            timeout=1,
+        )
+        msg = request_q.get(timeout=1)
+        assert isinstance(msg, SignalDuplexTurnMessage)
+        assert msg.fence == cancelled_fence
+        assert msg.next_fence == next_fence
+        assert msg.session_config == {"temperature": 0.0}
+        rpc_q.put(control_result)
+        assert pending.result(timeout=1)["ok"] is True
+
+    engine._correlated_rpc_client.close()
+
+
+@pytest.mark.asyncio
+async def test_cancelled_async_append_does_not_stop_executor_callable(mocker: MockerFixture):
+    entered = threading.Event()
+    release = threading.Event()
+    completed = threading.Event()
+    engine = object.__new__(AsyncOmniEngine)
+
+    def blocking_append(*args, **kwargs):
+        del args, kwargs
+        entered.set()
+        release.wait(timeout=1)
+        completed.set()
+        return {}
+
+    mocker.patch.object(engine, "append_duplex_input", side_effect=blocking_append)
+    task = asyncio.create_task(
+        engine.append_duplex_input_async(
+            "sid-executor-cancel",
+            mode="append_audio_chunk",
+            payload=b"audio",
+            fence=DuplexFence("sid-executor-cancel"),
+        )
+    )
+    assert await asyncio.to_thread(entered.wait, 1)
+
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    release.set()
+
+    assert await asyncio.to_thread(completed.wait, 1)
+
+
+def test_duplex_controls_route_out_of_order_without_global_lock():
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    first_fence = DuplexFence("sid", epoch=1)
+    second_fence = DuplexFence("sid", epoch=2)
+    first = AppendDuplexInputMessage(
+        control_id="first",
+        fence=first_fence,
+        session_id="sid",
+        expected_epoch=1,
+        mode="audio",
+        payload=b"first",
+    )
+    second = AppendDuplexInputMessage(
+        control_id="second",
+        fence=second_fence,
+        session_id="sid",
+        expected_epoch=2,
+        mode="audio",
+        payload=b"second",
+    )
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        client = engine._get_duplex_control_client()
+        first_result = executor.submit(client.execute, first, timeout=1)
+        second_result = executor.submit(client.execute, second, timeout=1)
+        submitted = {request_q.get(timeout=1).control_id, request_q.get(timeout=1).control_id}
+        assert submitted == {"first", "second"}
+        rpc_q.put(
+            DuplexControlResultMessage(
+                control_id="second",
+                fence=second_fence,
+                operation="append",
+                session_id="sid",
+                ok=True,
+                stage_results=[],
+            )
+        )
+        rpc_q.put(
+            DuplexControlResultMessage(
+                control_id="first",
+                fence=first_fence,
+                operation="append",
+                session_id="sid",
+                ok=True,
+                stage_results=[],
+            )
+        )
+
+        assert first_result.result(timeout=1)["fence"] == first_fence
+        assert second_result.result(timeout=1)["fence"] == second_fence
+
+    assert not hasattr(engine, "_rpc_lock")
+    engine._correlated_rpc_client.close()
+
+
+def test_terminal_rpc_router_rejects_without_enqueuing_new_control():
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    pending_message = AppendDuplexInputMessage(
+        control_id="pending",
+        fence=DuplexFence("sid"),
+        session_id="sid",
+        mode="audio",
+        payload=b"audio",
+    )
+    message = AppendDuplexInputMessage(
+        control_id="after-fatal",
+        fence=DuplexFence("sid"),
+        session_id="sid",
+        mode="audio",
+        payload=b"audio",
+    )
+
+    try:
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            pending = executor.submit(engine._get_duplex_control_client().execute, pending_message, timeout=1)
+            assert request_q.get(timeout=1).control_id == "pending"
+            rpc_q.put(ErrorMessage(error="orchestrator failed", fatal=True))
+            with pytest.raises(RuntimeError, match="orchestrator failed"):
+                pending.result(timeout=1)
+
+        with pytest.raises(RuntimeError, match="orchestrator failed"):
+            engine._get_duplex_control_client().execute(message, timeout=1)
+
+        assert request_q.empty()
+    finally:
+        engine._correlated_rpc_client.close()
+
+
+def test_collective_and_duplex_results_share_router_without_swapping(mocker: MockerFixture):
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    fence = DuplexFence("sid")
+    duplex = AppendDuplexInputMessage(
+        control_id="duplex-control",
+        fence=fence,
+        session_id="sid",
+        mode="audio",
+        payload=b"audio",
+    )
+    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="collective-rpc"))
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        duplex_result = executor.submit(engine._get_duplex_control_client().execute, duplex, timeout=1)
+        collective_result = executor.submit(engine.collective_rpc, "health", timeout=1)
+        submitted_types = {request_q.get(timeout=1).type, request_q.get(timeout=1).type}
+        assert submitted_types == {"append_duplex_input", "collective_rpc"}
+        rpc_q.put(
+            CollectiveRPCResultMessage(
+                rpc_id="collective-rpc",
+                method="health",
+                stage_ids=[0],
+                results=["healthy"],
+            )
+        )
+        rpc_q.put(
+            DuplexControlResultMessage(
+                control_id="duplex-control",
+                fence=fence,
+                operation="append",
+                session_id="sid",
+                ok=True,
+                stage_results=[],
+            )
+        )
+
+        assert collective_result.result(timeout=1) == ["healthy"]
+        assert duplex_result.result(timeout=1)["fence"] == fence
+
+    engine._correlated_rpc_client.close()
+
+
+def test_collective_rpc_preserves_request_queue_backpressure(mocker: MockerFixture):
+    class SignallingQueue(queue.Queue):
+        def __init__(self) -> None:
+            super().__init__(maxsize=1)
+            self.put_attempted = threading.Event()
+
+        def put(self, item, block=True, timeout=None):
+            self.put_attempted.set()
+            return super().put(item, block=block, timeout=timeout)
+
+    request_q = SignallingQueue()
+    request_q.put("queue-is-full")
+    request_q.put_attempted.clear()
+    rpc_q = queue.Queue()
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="blocked-rpc"))
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        pending = executor.submit(engine.collective_rpc, "health", timeout=1)
+        assert request_q.put_attempted.wait(timeout=1)
+        assert not pending.done()
+
+        assert request_q.get(timeout=1) == "queue-is-full"
+        assert request_q.get(timeout=1).rpc_id == "blocked-rpc"
+        rpc_q.put(
+            CollectiveRPCResultMessage(
+                rpc_id="blocked-rpc",
+                method="health",
+                stage_ids=[0],
+                results=["healthy"],
+            )
+        )
+        assert pending.result(timeout=1) == ["healthy"]
+
+    engine._correlated_rpc_client.close()
+
+
+def test_open_duplex_session_raises_on_stage_control_error(mocker: MockerFixture):
+    request_q = queue.Queue()
+    rpc_q = queue.Queue()
+    control_result = DuplexControlResultMessage(
+        control_id="ctrl-error",
+        fence=DuplexFence("sid"),
+        operation="open",
+        session_id="sid",
+        ok=False,
+        stage_results=[{"stage_id": 0, "replica_id": 0, "result": {"supported": False, "error": "boom"}}],
+        unsupported_count=1,
+        error_count=1,
+    )
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine.request_queue = SimpleNamespace(sync_q=request_q)
+    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
+    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
+    engine._duplex_control_client = None
+    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-error"))
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        pending = executor.submit(engine.open_duplex_session, "sid", fence=DuplexFence("sid"), timeout=1)
+        request_q.get(timeout=1)
+        rpc_q.put(control_result)
+        with pytest.raises(RuntimeError, match="duplex open failed"):
+            pending.result(timeout=1)
+    engine._correlated_rpc_client.close()
+
+
+def test_shutdown_does_not_race_runtime_cleanup_with_live_orchestrator(mocker: MockerFixture):
+    engine = object.__new__(AsyncOmniEngine)
+    engine._shutdown_called = False
+    engine._weak_finalizer = None
+    engine.request_queue = mocker.MagicMock()
+    engine.request_queue.sync_q.put.side_effect = queue.Full
+    engine.output_queue = mocker.MagicMock()
+    engine.rpc_output_queue = mocker.MagicMock()
+    engine._correlated_rpc_client = mocker.MagicMock()
+    engine.orchestrator_thread = mocker.MagicMock()
+    engine.orchestrator_thread.is_alive.return_value = True
+    engine._runtime = mocker.MagicMock()
+
+    engine.shutdown()
+
+    engine.request_queue.sync_q.put.assert_called_once()
+    assert engine.request_queue.sync_q.put.call_args.kwargs["timeout"] > 0
+    assert engine.orchestrator_thread.join.call_args_list[0].kwargs["timeout"] > 0
+    engine._correlated_rpc_client.close.assert_called_once_with()
+    engine.request_queue.close.assert_called_once_with()
+    engine.output_queue.close.assert_called_once_with()
+    engine.rpc_output_queue.close.assert_called_once_with()
+    engine._runtime.shutdown.assert_not_called()
+
+
+def test_shutdown_releases_runtime_after_orchestrator_stops(mocker: MockerFixture):
+    engine = object.__new__(AsyncOmniEngine)
+    engine._shutdown_called = False
+    engine._weak_finalizer = None
+    engine.request_queue = mocker.MagicMock()
+    engine.output_queue = mocker.MagicMock()
+    engine.rpc_output_queue = mocker.MagicMock()
+    engine._correlated_rpc_client = mocker.MagicMock()
+    engine.orchestrator_thread = mocker.MagicMock()
+    engine.orchestrator_thread.is_alive.side_effect = [True, False]
+    engine._runtime = mocker.MagicMock()
+
+    engine.shutdown()
+
+    engine.orchestrator_thread.join.assert_called_once()
+    engine._runtime.shutdown.assert_called_once_with()
+
+
+def test_shutdown_defers_runtime_release_until_live_orchestrator_stops(mocker: MockerFixture):
+    orchestrator_stopped = threading.Event()
+    runtime_released = threading.Event()
+
+    class ControllableOrchestratorThread:
+        def __init__(self) -> None:
+            self.join_timeouts: list[float | None] = []
+
+        def is_alive(self) -> bool:
+            return not orchestrator_stopped.is_set()
+
+        def join(self, timeout: float | None = None) -> None:
+            self.join_timeouts.append(timeout)
+            if timeout is None:
+                orchestrator_stopped.wait()
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine._shutdown_called = False
+    engine._weak_finalizer = None
+    engine.request_queue = mocker.MagicMock()
+    engine.output_queue = mocker.MagicMock()
+    engine.rpc_output_queue = mocker.MagicMock()
+    engine._correlated_rpc_client = mocker.MagicMock()
+    engine.orchestrator_thread = ControllableOrchestratorThread()
+    engine._runtime = mocker.MagicMock()
+    engine._runtime.shutdown.side_effect = runtime_released.set
+
+    try:
+        engine.shutdown()
+
+        engine._runtime.shutdown.assert_not_called()
+        orchestrator_stopped.set()
+        assert runtime_released.wait(timeout=1)
+        engine._runtime.shutdown.assert_called_once_with()
+        assert engine.orchestrator_thread.join_timeouts[0] is not None
+        assert engine.orchestrator_thread.join_timeouts[-1] is None
+    finally:
+        orchestrator_stopped.set()
+
+
+def test_weak_shutdown_is_bounded_when_request_queue_is_full(mocker: MockerFixture):
+    request_queue = mocker.MagicMock()
+    request_queue.sync_q.put.side_effect = queue.Full
+    output_queue = mocker.MagicMock()
+    rpc_output_queue = mocker.MagicMock()
+    router = mocker.MagicMock()
+    orchestrator_thread = mocker.MagicMock()
+    orchestrator_thread.is_alive.return_value = True
+
+    weak_shutdown_async_omni_engine(
+        orchestrator_thread,
+        request_queue,
+        output_queue,
+        rpc_output_queue,
+        router,
+    )
+
+    request_queue.sync_q.put.assert_called_once()
+    assert request_queue.sync_q.put.call_args.kwargs["timeout"] > 0
+    orchestrator_thread.join.assert_called_once()
+    assert orchestrator_thread.join.call_args.kwargs["timeout"] > 0
+    request_queue.close.assert_called_once_with()
+    output_queue.close.assert_called_once_with()
+    rpc_output_queue.close.assert_called_once_with()
diff --git a/tests/engine/test_async_omni_engine_stage_init.py b/tests/engine/test_async_omni_engine_stage_init.py
index d5a50cf29..67765aba6 100644
--- a/tests/engine/test_async_omni_engine_stage_init.py
+++ b/tests/engine/test_async_omni_engine_stage_init.py
@@ -1,3 +1,4 @@
+import concurrent.futures
 import contextlib
 import importlib
 import os
@@ -7,6 +8,7 @@ import types
 import pytest
 
 from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec
+from vllm_omni.engine import async_omni_engine as async_omni_engine_module
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
 from vllm_omni.engine.stage_init_utils import (
     LogicalStageInitPlan,
@@ -19,6 +21,30 @@ from vllm_omni.engine.stage_runtime import StageRuntime
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+def test_orchestrator_startup_timeout_warns_how_to_raise_limits(monkeypatch):
+    engine = object.__new__(AsyncOmniEngine)
+    engine.orchestrator_thread = types.SimpleNamespace(is_alive=lambda: True)
+    monkeypatch.setattr(engine, "_try_shutdown", lambda _message: None)
+
+    ticks = iter((0.0, 1.0))
+    monkeypatch.setattr(async_omni_engine_module.time, "monotonic", lambda: next(ticks))
+
+    warnings: list[tuple[object, ...]] = []
+    monkeypatch.setattr(
+        async_omni_engine_module.logger,
+        "warning",
+        lambda *args: warnings.append(args),
+    )
+
+    with pytest.raises(TimeoutError, match="did not become ready within 1s"):
+        engine._wait_for_orchestrator_init(concurrent.futures.Future(), startup_timeout=1)
+
+    assert len(warnings) == 1
+    message = str(warnings[0][0])
+    assert "--init-timeout" in message
+    assert "--stage-init-timeout" in message
+
+
 def _make_llm_metadata(
     stage_id: int,
     *,
@@ -146,6 +172,41 @@ def test_stage_engine_core_client_module_reload_keeps_forward_refs_deferred():
     )
 
 
+def test_async_omni_engine_initialize_stages_passes_log_stats_to_runtime(monkeypatch):
+    import vllm_omni.engine.async_omni_engine as engine_mod
+
+    engine = object.__new__(AsyncOmniEngine)
+    engine.stage_configs = [types.SimpleNamespace()]
+    engine.model = "dummy-model"
+    engine.config_path = "dummy-config"
+    engine.single_stage_mode = False
+    engine.diffusion_batch_size = 1
+    engine.async_chunk = False
+    engine.tokenizer = None
+    engine._single_stage_id_filter = None
+    engine._omni_master_address = None
+    engine._omni_master_port = None
+    engine._omni_dp_size_local = 1
+    engine._omni_heartbeat_timeout = 30.0
+    engine._omni_lb_policy = "random"
+    engine.request_queue = types.SimpleNamespace()
+    engine._log_stats = True
+
+    captured: dict[str, object] = {}
+    runtime = types.SimpleNamespace(stage_pools=[], initialize=lambda: None)
+
+    def _capture_create_stage_runtime(**kwargs):
+        captured.update(kwargs)
+        return runtime
+
+    monkeypatch.setattr(engine_mod, "create_stage_runtime", _capture_create_stage_runtime)
+
+    engine._initialize_stages(stage_init_timeout=7)
+
+    assert captured["stage_init_timeout"] == 7
+    assert captured["log_stats"] is True
+
+
 def test_compute_replica_layout_splits_diffusion_devices_by_world_size():
     stage_cfg = types.SimpleNamespace(
         stage_id=0,
@@ -316,6 +377,95 @@ def test_stage_runtime_initializes_stage_pools(monkeypatch):
     assert runtime.stage_pools[1].output_processor is stage1_output_processor
 
 
+def test_stage_runtime_passes_log_stats_to_llm_replica_launch(monkeypatch):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = StageRuntime(
+        stage_configs=[types.SimpleNamespace()],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        diffusion_batch_size=1,
+        async_chunk=False,
+        log_stats=True,
+    )
+    cfg = types.SimpleNamespace(model_config=types.SimpleNamespace(max_model_len=64))
+    plan = _make_llm_plan(0, stage_id=0, vllm_config=cfg).replicas[0]
+    plan.engine_args_dict = {}
+
+    captured: dict[str, object] = {}
+    addresses = types.SimpleNamespace(
+        inputs=["tcp://127.0.0.1:1"],
+        outputs=["tcp://127.0.0.1:2"],
+        frontend_stats_publish_address=None,
+    )
+    resources = types.SimpleNamespace(manager=object(), coordinator=None, addresses=addresses)
+    stage_client = types.SimpleNamespace()
+
+    @contextlib.contextmanager
+    def _capture_launch_stage_replica(**kwargs):
+        captured["log_stats"] = kwargs["log_stats"]
+        yield resources
+
+    monkeypatch.setattr(runtime_mod, "acquire_device_locks", lambda *_args, **_kwargs: [])
+    monkeypatch.setattr(runtime_mod, "launch_stage_replica", _capture_launch_stage_replica)
+    monkeypatch.setattr(
+        runtime_mod.StageEngineCoreClientBase,
+        "make_async_mp_client",
+        lambda **kwargs: (captured.__setitem__("client_log_stats", kwargs["log_stats"]) or stage_client),
+    )
+
+    assert runtime._initialize_local_llm_replica(plan, stage_init_timeout=1) is stage_client
+    assert captured["log_stats"] is True
+    assert captured["client_log_stats"] is True
+
+
+def test_stage_runtime_passes_log_stats_to_output_processor(monkeypatch):
+    import vllm_omni.engine.stage_runtime as runtime_mod
+
+    runtime = StageRuntime(
+        stage_configs=[types.SimpleNamespace()],
+        model="dummy-model",
+        config_path="dummy-config",
+        stage_init_timeout=1,
+        diffusion_batch_size=1,
+        async_chunk=False,
+        log_stats=True,
+    )
+    cfg = types.SimpleNamespace(model_config=types.SimpleNamespace(max_model_len=64))
+    stage_plan = _make_llm_plan(0, stage_id=0, vllm_config=cfg)
+    stage_client = types.SimpleNamespace(
+        stage_type="llm",
+        is_comprehension=False,
+        final_output=True,
+        final_output_type=None,
+        default_sampling_params=types.SimpleNamespace(),
+    )
+    captured: dict[str, object] = {}
+    output_processor = object()
+
+    def _capture_build_llm_stage_output_processor(plan, stage_vllm_config, *, log_stats=False):
+        captured["plan"] = plan
+        captured["stage_vllm_config"] = stage_vllm_config
+        captured["log_stats"] = log_stats
+        return output_processor
+
+    monkeypatch.setattr(
+        runtime_mod,
+        "build_llm_stage_output_processor",
+        _capture_build_llm_stage_output_processor,
+    )
+
+    pools = runtime._assemble_stage_pools([stage_plan], {0: [stage_client]})
+
+    assert pools[0].output_processor is output_processor
+    assert captured == {
+        "plan": stage_plan,
+        "stage_vllm_config": cfg,
+        "log_stats": True,
+    }
+
+
 def test_build_logical_stage_init_plans_applies_replica_device_splits(monkeypatch):
     import vllm_omni.engine.stage_runtime as runtime_mod
 
@@ -342,7 +492,7 @@ def test_build_logical_stage_init_plans_applies_replica_device_splits(monkeypatc
 
     monkeypatch.setattr(
         runtime_mod,
-        "extract_stage_metadata",
+        "extract_legacy_stage_metadata",
         lambda cfg: types.SimpleNamespace(**metadata_by_stage[cfg.stage_id].__dict__),
     )
     monkeypatch.setattr(runtime_mod, "get_stage_connector_spec", lambda **_: {})
@@ -511,10 +661,11 @@ def test_initialize_local_llm_replica_passes_stage_init_timeout_to_complete_stag
         stage_configs=[],
         model="dummy-model",
         config_path="dummy-config",
-        stage_init_timeout=302,
+        stage_init_timeout=1,
         diffusion_batch_size=1,
         async_chunk=False,
     )
+    stage_init_timeout = 302
 
     fake_vllm_config = types.SimpleNamespace()
     fake_addresses = types.SimpleNamespace(inputs=["in"], outputs=["out"], frontend_stats_publish_address=None)
@@ -561,14 +712,14 @@ def test_initialize_local_llm_replica_passes_stage_init_timeout_to_complete_stag
     )
 
     try:
-        runtime._initialize_local_llm_replica(plan, 302)
+        runtime._initialize_local_llm_replica(plan, stage_init_timeout)
     finally:
         if prev_device_env is None:
             os.environ.pop(device_env_var, None)
         else:
             os.environ[device_env_var] = prev_device_env
 
-    assert captured_timeout == 302
+    assert captured_timeout == stage_init_timeout
 
 
 def test_build_engine_args_cli_tokenizer_overrides_inferred_base_tokenizer(tmp_path):
@@ -609,6 +760,29 @@ def test_build_engine_args_stage_model_overrides_parent_model():
     assert engine_args["model"] == "/stage/model"
 
 
+def test_build_engine_args_keeps_full_payload_connector_spec():
+    from vllm_omni.engine.stage_init_utils import build_engine_args_dict
+
+    stage_cfg = types.SimpleNamespace(
+        stage_id=1,
+        stage_type="llm",
+        engine_args={"async_chunk": False},
+        default_sampling_params={},
+    )
+    connector_spec = {
+        "name": "SharedMemoryConnector",
+        "extra": {"role": "sender"},
+    }
+
+    engine_args = build_engine_args_dict(
+        stage_cfg,
+        "/parent/model",
+        stage_connector_spec=connector_spec,
+    )
+
+    assert engine_args["stage_connector_spec"] == connector_spec
+
+
 def test_build_engine_args_keeps_stage_owned_tokenizer_subdir(tmp_path):
     from vllm_omni.engine.stage_init_utils import build_engine_args_dict
 
@@ -745,6 +919,7 @@ def test_resolve_stage_configs_injects_global_diffusion_attention_when_missing(m
     _config_path, stage_configs = engine._resolve_stage_configs(
         model="dummy-model",
         kwargs={"diffusion_attention_backend": "FLASH_ATTN"},
+        trust_remote_code=False,
     )
 
     diffusion_attention_config = stage_configs[0].engine_args.diffusion_attention_config
@@ -778,6 +953,7 @@ def test_resolve_stage_configs_preserves_stage_diffusion_attention(monkeypatch):
     _config_path, stage_configs = engine._resolve_stage_configs(
         model="dummy-model",
         kwargs={"diffusion_attention_backend": "FLASH_ATTN"},
+        trust_remote_code=False,
     )
 
     assert stage_configs[0].engine_args.diffusion_attention_config is existing_attention
@@ -804,15 +980,16 @@ def test_resolve_stage_configs_does_not_inject_diffusion_attention_into_llm_stag
     _config_path, stage_configs = engine._resolve_stage_configs(
         model="dummy-model",
         kwargs={"diffusion_attention_backend": "TORCH_SDPA"},
+        trust_remote_code=False,
     )
 
     assert stage_configs[0].engine_args.attention_config == {"backend": "FLASH_ATTN"}
     assert not hasattr(stage_configs[0].engine_args, "diffusion_attention_config")
 
 
-def test_extract_stage_metadata_rocm_does_not_inject_diffusion_attention(monkeypatch):
+def test_extract_legacy_stage_metadata_rocm_does_not_inject_diffusion_attention(monkeypatch):
     """ROCm default attention logic only applies to LLM stages, not diffusion."""
-    from vllm_omni.engine.stage_init_utils import extract_stage_metadata
+    from vllm_omni.engine.stage_init_utils import extract_legacy_stage_metadata
 
     monkeypatch.setattr("vllm_omni.engine.stage_init_utils.current_omni_platform.is_rocm", lambda: True)
 
@@ -826,7 +1003,7 @@ def test_extract_stage_metadata_rocm_does_not_inject_diffusion_attention(monkeyp
         final_output_type=None,
     )
 
-    metadata = extract_stage_metadata(stage_cfg)
+    metadata = extract_legacy_stage_metadata(stage_cfg)
 
     assert metadata.stage_type == "diffusion"
     assert "diffusion_attention_config" not in stage_cfg.engine_args
diff --git a/tests/engine/test_cfg_companion_lifecycle.py b/tests/engine/test_cfg_companion_lifecycle.py
new file mode 100644
index 000000000..5cf2fd072
--- /dev/null
+++ b/tests/engine/test_cfg_companion_lifecycle.py
@@ -0,0 +1,334 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Deterministic tests for the CFG-companion output lifecycle.
+
+Regression suite for the companion-output race behind the nightly Bagel
+failures: ``kv_ready`` used to mark a companion done before its processed
+output was stashed, letting the parent dispatch to the diffusion stage with
+0/N companion outputs (degraded CFG conditioning, and after an abort a TP
+rank desync). The invariant under test: **dispatch to the diffusion stage
+never happens with an incomplete companion bundle** — the parent is
+re-deferred while outputs are pending and failed when the bundle can no
+longer complete.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
+from vllm_omni.engine.messages import AbortRequestMessage, ErrorMessage
+from vllm_omni.engine.orchestrator import Orchestrator
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+# ───────── tracker-level ordering semantics ─────────
+
+
+def test_companion_first_then_parent_is_not_deferred():
+    tracker = CfgCompanionTracker()
+    tracker.register_companion("p", "neg", "p__neg")
+    tracker.set_companion_output("p__neg", {"o": 1})
+    assert tracker.on_companion_completed("p__neg") is None  # parent not deferred yet
+    # Parent arrives afterwards: bundle already complete, no defer needed.
+    assert tracker.all_companions_done("p")
+    assert tracker.get_companion_outputs("p") == [{"o": 1}]
+
+
+def test_parent_first_deferred_then_companion_flushes():
+    tracker = CfgCompanionTracker()
+    tracker.register_companion("p", "neg", "p__neg")
+    tracker.defer_parent("p", {"parent": True}, stage_id=0)
+    tracker.set_companion_output("p__neg", {"o": 1})
+    assert tracker.on_companion_completed("p__neg") == "p"
+    deferred = tracker.pop_pending_parent("p")
+    assert deferred is not None and deferred["engine_outputs"] == {"parent": True}
+
+
+def test_duplicate_companion_completion_is_idempotent():
+    tracker = CfgCompanionTracker()
+    tracker.register_companion("p", "neg", "p__neg")
+    tracker.defer_parent("p", {}, stage_id=0)
+    tracker.set_companion_output("p__neg", {"o": 1})
+    assert tracker.on_companion_completed("p__neg") == "p"
+    assert tracker.on_companion_completed("p__neg") is None  # duplicate: no re-flush
+    assert tracker.get_companion_outputs("p") == [{"o": 1}]
+
+
+def test_bundle_survives_resubmission_until_cleanup():
+    """get_companion_outputs is non-destructive: a streaming re-submission of
+    the parent bundles the complete set again (never a partial/empty one).
+    Only cleanup_parent releases the outputs."""
+    tracker = CfgCompanionTracker()
+    tracker.register_companion("p", "neg", "p__neg")
+    tracker.set_companion_output("p__neg", {"o": 1})
+    assert tracker.get_companion_outputs("p") == [{"o": 1}]
+    assert tracker.get_companion_outputs("p") == [{"o": 1}]  # re-submit: full bundle again
+    tracker.cleanup_parent("p")
+    assert tracker.get_companion_outputs("p") == []
+
+
+# ───────── orchestrator-method-level lifecycle ─────────
+
+
+class _FakePool:
+    """Minimal stage pool satisfying _forward_to_next_stage's preamble and cleanup."""
+
+    def __init__(self, stage_type: str = "diffusion") -> None:
+        self.stage_type = stage_type
+        self.stage_client = SimpleNamespace(requires_multimodal_data=False, custom_process_input_func=None)
+        self.aborted: list[list[str]] = []
+
+    async def abort_requests(self, request_ids):
+        self.aborted.append(list(request_ids))
+
+    def release_bindings(self, request_ids):
+        pass
+
+
+def _make_orchestrator(num_stages: int = 2) -> Orchestrator:
+    orch = Orchestrator.__new__(Orchestrator)
+    orch._cfg_tracker = CfgCompanionTracker()
+    orch.request_states = {}
+    orch.stage_pools = [_FakePool("llm"), _FakePool("diffusion")][:num_stages]
+    orch.output_async_queue = asyncio.Queue()
+    orch.async_chunk = False
+    orch.duplex_control_plane = None
+    orch._pd_kv_params = {}
+    orch._pd_pair = None
+    orch._running_counter = None
+    orch._transfer_emitter = None
+    return orch
+
+
+def _req_state(final_stage_id: int = 1) -> SimpleNamespace:
+    return SimpleNamespace(
+        final_stage_id=final_stage_id,
+        stage_submit_ts={},
+        sampling_params_list=[SimpleNamespace(output_kind=None)] * (final_stage_id + 1),
+        streaming=SimpleNamespace(enabled=False, segment_finished=False),
+        running_counter_registered=False,
+        prompt={"prompt": "x"},
+        pipeline_timings={},
+    )
+
+
+@pytest.mark.asyncio
+async def test_kv_ready_does_not_mark_companion_done():
+    """kv_ready alone must not count a companion as done — only the processed
+    output (set_companion_output) may. Guards the original race."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch.request_states["p__neg"] = _req_state()
+
+    raw = SimpleNamespace(request_id="p__neg", kv_transfer_params={"kv_ready": True})
+    await orch._handle_kv_ready_raw_outputs(0, SimpleNamespace(outputs=[raw]))
+
+    assert not orch._cfg_tracker.all_companions_done("p")
+    assert orch._cfg_tracker.pop_pending_parent("p") is None
+
+
+@pytest.mark.asyncio
+async def test_parent_kv_ready_defers_until_companion_outputs_stashed():
+    """Parent kv_ready with an incomplete bundle defers; the companion's
+    processed output later flushes it (companion-first vs parent-first order
+    both funnel through the same defer/flush path)."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch.request_states["p"] = _req_state()
+
+    raw = SimpleNamespace(request_id="p", kv_transfer_params={"kv_ready": True})
+    await orch._handle_kv_ready_raw_outputs(0, SimpleNamespace(outputs=[raw]))
+
+    deferred = orch._cfg_tracker.pop_pending_parent("p")
+    assert deferred is not None and deferred["stage_id"] == 0
+
+
+@pytest.mark.asyncio
+async def test_forward_re_defers_when_bundle_incomplete():
+    """The forward gate re-defers (non-destructively) instead of dispatching
+    with 0/N companion outputs."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})  # stashed but NOT done-marked
+    state = _req_state()
+    orch.request_states["p"] = state
+
+    await orch._forward_to_next_stage("p", 0, {"parent": True}, state)
+
+    # Not dispatched: re-deferred with the stashed output left intact.
+    deferred = orch._cfg_tracker.pop_pending_parent("p")
+    assert deferred is not None
+    assert orch._cfg_tracker.get_companion_outputs("p") == [{"o": 1}]
+    assert orch.output_async_queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_forward_fails_request_when_bundle_lost():
+    """Companions done but outputs gone without a prior bundle: the request is
+    failed (terminal ErrorMessage + abort) instead of dispatching degraded CFG."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})
+    orch._cfg_tracker.on_companion_completed("p__neg")
+    orch._cfg_tracker._companion_outputs.pop("p__neg")  # simulate lost output (unreachable normally)
+    state = _req_state()
+    orch.request_states["p"] = state
+
+    await orch._forward_to_next_stage("p", 0, {"parent": True}, state)
+
+    msg = orch.output_async_queue.get_nowait()
+    assert isinstance(msg, ErrorMessage)
+    assert msg.request_id == "p"
+    assert "incomplete" in msg.error
+    assert "p" not in orch.request_states
+    assert any("p" in batch for pool in orch.stage_pools for batch in pool.aborted)
+
+
+@pytest.mark.asyncio
+async def test_companion_abort_fails_deferred_parent():
+    """A companion aborted directly (parent not in the batch) can never
+    complete the bundle — the deferred parent is failed immediately."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.defer_parent("p", {"parent": True}, stage_id=0)
+    orch.request_states["p"] = _req_state()
+
+    await orch._handle_abort(AbortRequestMessage(request_ids=["p__neg"]))
+
+    msg = orch.output_async_queue.get_nowait()
+    assert isinstance(msg, ErrorMessage)
+    assert msg.request_id == "p"
+    assert "p__neg" in msg.error
+    assert "p" not in orch.request_states
+    assert not orch._cfg_tracker.is_companion("p__neg")
+    # Idempotent: a repeated abort of the same companion is a no-op.
+    await orch._handle_abort(AbortRequestMessage(request_ids=["p__neg"]))
+    assert orch.output_async_queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_companion_abort_after_completion_does_not_fail_parent():
+    """A late/duplicate abort of a companion whose output is already stashed
+    must not cancel the (possibly already dispatched) parent."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})
+    orch._cfg_tracker.on_companion_completed("p__neg")
+    orch.request_states["p"] = _req_state()
+
+    await orch._handle_abort(AbortRequestMessage(request_ids=["p__neg"]))
+
+    assert orch.output_async_queue.empty()  # no parent failure emitted
+    assert "p" in orch.request_states  # parent untouched
+    assert orch._cfg_tracker.get_companion_outputs("p") == [{"o": 1}]  # bundle intact
+
+
+class _CapturedDispatchError(Exception):
+    """Sentinel raised by the capture hook to stop the forward after bundling."""
+
+
+@pytest.mark.asyncio
+async def test_repeated_forward_bundles_full_set_again():
+    """A second forward of the same parent (streaming terminal update) must
+    dispatch the complete [parent, *companions] bundle again — never [parent]
+    alone. Captured at the diffusion input hook, i.e. actual dispatch content."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})
+    orch._cfg_tracker.on_companion_completed("p__neg")
+    state = _req_state()
+    orch.request_states["p"] = state
+
+    captured: list[list] = []
+
+    def _capture(source_outputs, prompt, requires_multimodal_data):
+        captured.append(list(source_outputs))
+        raise _CapturedDispatchError
+
+    orch.stage_pools[1].stage_client.custom_process_input_func = _capture
+
+    for _ in range(2):
+        with pytest.raises(_CapturedDispatchError):
+            await orch._forward_to_next_stage("p", 0, {"parent": True}, state)
+
+    assert captured == [[{"parent": True}, {"o": 1}], [{"parent": True}, {"o": 1}]]
+
+
+@pytest.mark.asyncio
+async def test_replica_loss_cleanup_releases_parent_tracker_state():
+    """Replica-loss/membership teardown calls _cleanup_request_ids directly
+    (no cleanup_parent at the call site): the parent's tracker state must be
+    released and its companions folded into the same cleanup batch."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})
+    orch._cfg_tracker.defer_parent("p", {"parent": True}, stage_id=0)
+    orch.request_states["p"] = _req_state()
+
+    await orch._cleanup_request_ids(["p"], abort=True)
+
+    assert not orch._cfg_tracker.has_companions("p")
+    assert not orch._cfg_tracker.is_companion("p__neg")
+    assert orch._cfg_tracker.get_companion_outputs("p") == []
+    assert orch._cfg_tracker.pop_pending_parent("p") is None
+    aborted = {rid for pool in orch.stage_pools for b in pool.aborted for rid in b}
+    assert {"p", "p__neg"} <= aborted
+
+
+@pytest.mark.asyncio
+async def test_replica_loss_of_companion_fails_deferred_parent():
+    """A companion torn down by replica loss before its output arrived means
+    the parent can never complete its bundle — the cleanup fails the parent."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.defer_parent("p", {"parent": True}, stage_id=0)
+    orch.request_states["p"] = _req_state()
+
+    await orch._cleanup_request_ids(["p__neg"])
+
+    msg = orch.output_async_queue.get_nowait()
+    assert isinstance(msg, ErrorMessage)
+    assert msg.request_id == "p"
+    assert "p__neg" in msg.error
+    assert "p" not in orch.request_states
+    assert not orch._cfg_tracker.has_companions("p")
+
+
+@pytest.mark.asyncio
+async def test_finished_companion_cleanup_preserves_parent_bundle():
+    """The normal companion-finished cleanup (_route_output cleans just the
+    companion id) must not disturb the parent's stashed bundle."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.set_companion_output("p__neg", {"o": 1})
+    orch._cfg_tracker.on_companion_completed("p__neg")
+    orch.request_states["p"] = _req_state()
+
+    await orch._cleanup_request_ids(["p__neg"])
+
+    assert orch.output_async_queue.empty()
+    assert "p" in orch.request_states
+    assert orch._cfg_tracker.get_companion_outputs("p") == [{"o": 1}]
+
+
+@pytest.mark.asyncio
+async def test_parent_abort_still_expands_to_companions():
+    """Regression-guard the existing behavior: aborting the parent aborts its
+    companions and clears tracker state, without emitting an error."""
+    orch = _make_orchestrator()
+    orch._cfg_tracker.register_companion("p", "neg", "p__neg")
+    orch._cfg_tracker.defer_parent("p", {"parent": True}, stage_id=0)
+    orch.request_states["p"] = _req_state()
+
+    await orch._handle_abort(AbortRequestMessage(request_ids=["p"]))
+
+    assert orch.output_async_queue.empty()
+    assert "p" not in orch.request_states
+    assert not orch._cfg_tracker.is_companion("p__neg")
+    aborted = {rid for pool in orch.stage_pools for batch in pool.aborted for rid in batch}
+    assert {"p", "p__neg"} <= aborted
diff --git a/tests/engine/test_correlated_rpc_client.py b/tests/engine/test_correlated_rpc_client.py
new file mode 100644
index 000000000..2f470a996
--- /dev/null
+++ b/tests/engine/test_correlated_rpc_client.py
@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import queue
+from concurrent.futures import ThreadPoolExecutor
+
+import pytest
+
+from vllm_omni.engine.messages import (
+    CollectiveRPCRequestMessage,
+    CollectiveRPCResultMessage,
+    ErrorMessage,
+)
+from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _request(rpc_id: str) -> CollectiveRPCRequestMessage:
+    return CollectiveRPCRequestMessage(
+        rpc_id=rpc_id,
+        method="health",
+        timeout=1,
+        args=(),
+        kwargs={},
+        stage_ids=None,
+    )
+
+
+def test_correlated_rpc_client_unregisters_timeout_before_late_result() -> None:
+    request_queue: queue.Queue = queue.Queue()
+    result_queue: queue.Queue = queue.Queue()
+    client = CorrelatedRpcClient(request_queue, result_queue)
+
+    try:
+        with pytest.raises(TimeoutError, match="first timed out"):
+            client.execute(
+                ("collective", "first"),
+                _request("first"),
+                timeout=0.01,
+                timeout_message="first timed out",
+            )
+        assert request_queue.get_nowait().rpc_id == "first"
+
+        result_queue.put(
+            CollectiveRPCResultMessage(
+                rpc_id="first",
+                method="health",
+                stage_ids=[0],
+                results=["late"],
+            )
+        )
+        result_queue.put(
+            CollectiveRPCResultMessage(
+                rpc_id="second",
+                method="health",
+                stage_ids=[0],
+                results=["current"],
+            )
+        )
+        current = client.execute(
+            ("collective", "second"),
+            _request("second"),
+            timeout=1,
+            timeout_message="second timed out",
+        )
+
+        assert isinstance(current, CollectiveRPCResultMessage)
+        assert current.results == ["current"]
+    finally:
+        client.close()
+
+
+def test_correlated_rpc_client_rejects_after_fatal_without_enqueuing() -> None:
+    request_queue: queue.Queue = queue.Queue()
+    result_queue: queue.Queue = queue.Queue()
+    client = CorrelatedRpcClient(request_queue, result_queue)
+
+    try:
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            pending = executor.submit(
+                client.execute,
+                ("collective", "pending"),
+                _request("pending"),
+                timeout=1,
+                timeout_message="unexpected timeout",
+            )
+            assert request_queue.get(timeout=1).rpc_id == "pending"
+            result_queue.put(ErrorMessage(error="orchestrator failed", fatal=True))
+            with pytest.raises(RuntimeError, match="orchestrator failed"):
+                pending.result(timeout=1)
+
+        with pytest.raises(RuntimeError, match="orchestrator failed"):
+            client.execute(
+                ("collective", "after-fatal"),
+                _request("after-fatal"),
+                timeout=1,
+                timeout_message="unexpected timeout",
+            )
+        assert request_queue.empty()
+    finally:
+        client.close()
diff --git a/tests/test_data_entry_keys.py b/tests/engine/test_data_entry_keys.py
similarity index 92%
rename from tests/test_data_entry_keys.py
rename to tests/engine/test_data_entry_keys.py
index 73dcc82c2..4720cd8ea 100644
--- a/tests/test_data_entry_keys.py
+++ b/tests/engine/test_data_entry_keys.py
@@ -21,6 +21,8 @@ from vllm_omni.data_entry_keys import (
 )
 from vllm_omni.engine import AdditionalInformationPayload
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 class TestOmniPayloadStruct:
     """Runtime-validated mirror of OmniPayload (msgspec.Struct)."""
@@ -43,6 +45,16 @@ class TestOmniPayloadStruct:
         with pytest.raises(msgspec.ValidationError, match="unknown field"):
             to_struct({"meta": {"finisheed": True}})
 
+    def test_to_struct_rejects_minicpmo_duplex_runtime_handoff_fields(self):
+        with pytest.raises(msgspec.ValidationError, match="unknown field"):
+            to_struct({"hidden_states": {"tts": torch.zeros(1)}})
+        with pytest.raises(msgspec.ValidationError, match="unknown field"):
+            to_struct({"ids": {"tts": [1]}})
+        with pytest.raises(msgspec.ValidationError, match="unknown field"):
+            to_struct({"meta": {"ref_audio_sr": 16000}})
+        with pytest.raises(msgspec.ValidationError, match="unknown field"):
+            to_struct({"meta": {"listen_token_id": 151685}})
+
     def test_to_struct_rejects_wrong_type(self):
         with pytest.raises(msgspec.ValidationError, match="Expected"):
             to_struct({"meta": {"left_context_size": "not_an_int"}})
@@ -66,10 +78,10 @@ class TestOmniPayloadStruct:
 
     def test_struct_with_all_categories(self):
         d = {
-            "hidden_states": {"output": torch.zeros(1)},
+            "hidden_states": {"output": torch.zeros(1), "last": torch.ones(2, 4)},
             "embed": {"prefill": torch.zeros(1), "tts_bos": torch.zeros(1)},
-            "ids": {"all": [1, 2], "prompt": [1]},
-            "codes": {"audio": torch.zeros(1)},
+            "ids": {"all": [1, 2], "prompt": [1], "speech_token": [3, 4]},
+            "codes": {"audio": torch.zeros(1), "ref": torch.ones(4)},
             "meta": {"left_context_size": 3, "num_processed_tokens": 7},
         }
         s = to_struct(d)
@@ -79,7 +91,10 @@ class TestOmniPayloadStruct:
         assert isinstance(s.codes, CodesStruct)
         assert isinstance(s.meta, MetaStruct)
         assert s.ids.all == [1, 2]
+        assert s.ids.speech_token == [3, 4]
+        assert torch.equal(s.hidden_states.last, torch.ones(2, 4))
         assert s.meta.num_processed_tokens == 7
+        assert torch.equal(s.codes.ref, torch.ones(4))
 
 
 class TestValidatePayload:
@@ -332,7 +347,7 @@ class TestSerializeDeserializePayload:
             "hidden_states": {"output": torch.tensor([1.0, 2.0])},
             "ids": {"all": [1, 2, 3]},
             "meta": {"finished": torch.tensor(False, dtype=torch.bool), "ar_width": 4},
-            "codes": {"audio": torch.tensor([3.0])},
+            "codes": {"audio": torch.tensor([3.0]), "ref": torch.tensor([0.1, 0.2])},
         }
         wire = serialize_payload(original)
         restored = deserialize_payload(wire)
@@ -341,6 +356,7 @@ class TestSerializeDeserializePayload:
         assert restored["meta"]["finished"].item() is False
         assert restored["meta"]["ar_width"] == 4
         assert torch.equal(restored["codes"]["audio"], original["codes"]["audio"])
+        assert torch.equal(restored["codes"]["ref"], original["codes"]["ref"])
 
     def test_hidden_states_layers_round_trip(self):
         original = {
diff --git a/tests/engine/test_duplex_import_boundary.py b/tests/engine/test_duplex_import_boundary.py
new file mode 100644
index 000000000..6eae2e698
--- /dev/null
+++ b/tests/engine/test_duplex_import_boundary.py
@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+def _assert_isolated_import_succeeds(script: str) -> None:
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
+
+
+def test_stable_engine_imports_do_not_load_experimental_duplex() -> None:
+    _assert_isolated_import_succeeds("""
+import sys
+
+import vllm_omni.engine.async_omni_engine
+import vllm_omni.engine.orchestrator
+import vllm_omni.entrypoints.async_omni
+
+loaded = sorted(
+    name
+    for name in sys.modules
+    if name == "vllm_omni.experimental.fullduplex"
+    or name.startswith("vllm_omni.experimental.fullduplex.")
+)
+if loaded:
+    raise SystemExit("stable imports loaded experimental duplex: " + ", ".join(loaded))
+""")
+
+
+def test_stable_engine_does_not_expose_duplex_contract_modules() -> None:
+    _assert_isolated_import_succeeds("""
+import importlib.util
+
+from vllm_omni.engine import messages
+
+legacy_modules = (
+    "vllm_omni.engine.duplex_contracts",
+    "vllm_omni.engine.duplex_lease",
+    "vllm_omni.engine.resumable",
+)
+present = [name for name in legacy_modules if importlib.util.find_spec(name) is not None]
+if present:
+    raise SystemExit("stable duplex modules still exist: " + ", ".join(present))
+
+duplex_exports = sorted(name for name in vars(messages) if name.startswith("Duplex"))
+if duplex_exports:
+    raise SystemExit("stable messages still expose duplex contracts: " + ", ".join(duplex_exports))
+""")
+
+
+def test_stable_outputs_do_not_declare_duplex_decision_field() -> None:
+    _assert_isolated_import_succeeds("""
+import dataclasses
+
+from vllm_omni.outputs import OmniRequestOutput
+
+fields = {field.name for field in dataclasses.fields(OmniRequestOutput)}
+if "duplex_output_decision" in fields:
+    raise SystemExit("stable output declares duplex_output_decision")
+""")
+
+
+def test_stable_model_executor_does_not_expose_duplex_helper_module() -> None:
+    _assert_isolated_import_succeeds("""
+import importlib.util
+
+if importlib.util.find_spec("vllm_omni.model_executor.duplex") is not None:
+    raise SystemExit("stable model_executor still exposes duplex helper module")
+""")
+
+
+def test_runtime_package_does_not_bundle_the_browser_demo() -> None:
+    assert not (REPO_ROOT / "vllm_omni" / "experimental" / "fullduplex" / "web").exists()
+
+
+def test_experimental_engine_uses_canonical_contract_module_names() -> None:
+    engine_dir = REPO_ROOT / "vllm_omni" / "experimental" / "fullduplex" / "engine"
+    core_dir = REPO_ROOT / "vllm_omni" / "experimental" / "fullduplex" / "core"
+
+    assert (engine_dir / "contracts.py").is_file()
+    assert (engine_dir / "lease.py").is_file()
+    assert (engine_dir / "messages.py").is_file()
+    assert not (engine_dir / "duplex_lease.py").exists()
+    assert not (engine_dir / "duplex_types.py").exists()
+    assert not (core_dir / "identity.py").exists()
diff --git a/tests/engine/test_membership_controller.py b/tests/engine/test_membership_controller.py
index c00a7f646..1b8bf2adb 100644
--- a/tests/engine/test_membership_controller.py
+++ b/tests/engine/test_membership_controller.py
@@ -11,6 +11,7 @@ import pytest
 
 from vllm_omni.distributed.omni_coordinator.messages import ReplicaStatus
 from vllm_omni.engine.membership_controller import MembershipController
+from vllm_omni.engine.stage_pool import StagePool
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -45,10 +46,10 @@ class FakePool:
     def attach_load_balancer(self, lb):
         self.lb = lb
 
-    def add_client(self, input_addr, client):
-        self.added.append((input_addr, client))
+    def add_client(self, input_addr, client, *, replica_id=None):
+        self.added.append((input_addr, client, replica_id))
         self.clients.append(client)
-        return len(self.clients) - 1
+        return len(self.clients) - 1 if replica_id is None else replica_id
 
     def invalidate_addr(self, input_addr):
         self.invalidated.append(input_addr)
@@ -155,4 +156,35 @@ async def test_do_register_offloads_remote_factory(monkeypatch):
 
     assert factory_thread_ids
     assert factory_thread_ids[0] != threading.get_ident()
-    assert pool.added[0][0] == "tcp://stage-0-replica-1"
+    assert pool.added[0] == ("tcp://stage-0-replica-1", pool.clients[0], 1)
+
+
+@pytest.mark.asyncio
+async def test_unregister_then_register_restores_coordinator_replica_slot(monkeypatch):
+    class Client:
+        def __init__(self, input_addr: str) -> None:
+            self.client_addresses = {"input_address": input_addr}
+            self.shutdown_calls = 0
+
+        def shutdown(self) -> None:
+            self.shutdown_calls += 1
+
+    old_clients = [Client("tcp://old-0"), Client("tcp://old-1")]
+    replacement = Client("tcp://new-1")
+    pool = StagePool(0, old_clients)
+
+    def factory(stage_id: int, replica_id: int):
+        assert (stage_id, replica_id) == (0, 1)
+        return replacement
+
+    controller = _controller(monkeypatch, pool, FakeHub(), remote_replica_factory=factory)
+    await controller.handle_unregister(0, "tcp://old-0")
+    await controller.handle_unregister(0, "tcp://old-1")
+
+    await controller.handle_register(0, 1)
+    await controller.drain_tasks(timeout=1)
+
+    assert pool.clients == [None, replacement]
+    assert pool.get_replica_id_by_addr("tcp://new-1") == 1
+    assert pool.get_replica_id_by_addr("tcp://old-1") is None
+    assert pool.available_replica_ids() == [1]
diff --git a/tests/engine/test_multimodal_accumulation.py b/tests/engine/test_multimodal_accumulation.py
new file mode 100644
index 000000000..dbde83fef
--- /dev/null
+++ b/tests/engine/test_multimodal_accumulation.py
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+import torch
+
+from vllm_omni.outputs.mm_outputs import MultimodalPayload
+from vllm_omni.outputs.multimodal_accumulation import (
+    drain_delta_payload,
+    is_non_final_delta_audio_chunk,
+    replace_snapshot_keys,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_chunk_accumulation_policy_replaces_snapshots_and_drains_delta_state():
+    accumulated = MultimodalPayload.from_dict(
+        {
+            "audio": torch.tensor([1.0]),
+            "meta.segment_end": torch.tensor([0]),
+            "meta.tts_is_last_chunk": torch.tensor([0]),
+            "meta.turn_end": torch.tensor([0]),
+            "meta.stable_request_value": "keep",
+        }
+    )
+    incoming = MultimodalPayload.from_dict(
+        {
+            "audio": torch.tensor([2.0]),
+            "meta.segment_end": torch.tensor([1]),
+            "meta.tts_is_last_chunk": torch.tensor([1]),
+            "meta.turn_end": torch.tensor([1]),
+        }
+    )
+    assert accumulated is not None
+    assert incoming is not None
+
+    replace_snapshot_keys(accumulated, incoming)
+    merged = accumulated.merged_with(incoming)
+
+    assert not is_non_final_delta_audio_chunk(merged, "audio")
+
+    drain_delta_payload(merged)
+
+    assert "audio" not in merged
+    assert "meta.segment_end" not in merged
+    assert "meta.tts_is_last_chunk" not in merged
+    assert "meta.turn_end" not in merged
+    assert merged.metadata["meta.stable_request_value"] == "keep"
diff --git a/tests/test_omni_request.py b/tests/engine/test_omni_request.py
similarity index 82%
rename from tests/test_omni_request.py
rename to tests/engine/test_omni_request.py
index 09f893a03..4f4718f09 100644
--- a/tests/test_omni_request.py
+++ b/tests/engine/test_omni_request.py
@@ -20,7 +20,7 @@ from vllm.sampling_params import SamplingParams
 from vllm.v1.request import Request
 
 from vllm_omni.engine import PromptEmbedsPayload
-from vllm_omni.request import OmniRequest
+from vllm_omni.request import OmniRequest, OmniStreamingUpdate
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -32,7 +32,12 @@ def test_omni_params_are_keyword_only():
     came first positionally and broke positional ``Request(...)`` construction.
     """
     params = inspect.signature(OmniRequest.__init__).parameters
-    for name in ("prompt_embeds", "external_req_id", "additional_information"):
+    for name in (
+        "prompt_embeds",
+        "external_req_id",
+        "additional_information",
+        "model_intermediate_buffer",
+    ):
         assert params[name].kind is inspect.Parameter.KEYWORD_ONLY, name
 
 
@@ -87,3 +92,21 @@ def test_keyword_omni_params_round_trip():
     # The serialized payload is retained and decoded into a tensor on the base.
     assert req.prompt_embeds_payload is payload
     assert torch.equal(req.prompt_embeds, torch.from_numpy(arr))
+
+
+def test_model_intermediate_buffer_round_trips_to_streaming_update():
+    buffer = {"duplex": {"turn_id": 3}}
+    request = OmniRequest(
+        request_id="req-model-buffer",
+        prompt_token_ids=[1, 2],
+        sampling_params=SamplingParams(max_tokens=16),
+        pooling_params=None,
+        resumable=True,
+        model_intermediate_buffer=buffer,
+    )
+
+    update = OmniStreamingUpdate.from_request(request)
+
+    assert update is not None
+    assert request.model_intermediate_buffer is buffer
+    assert update.model_intermediate_buffer is buffer
diff --git a/tests/test_outputs.py b/tests/engine/test_omni_request_output.py
similarity index 100%
rename from tests/test_outputs.py
rename to tests/engine/test_omni_request_output.py
diff --git a/tests/engine/test_orchestrator.py b/tests/engine/test_orchestrator.py
index 23f8cfaa2..b6c4f8509 100644
--- a/tests/engine/test_orchestrator.py
+++ b/tests/engine/test_orchestrator.py
@@ -14,12 +14,15 @@ import janus
 import pytest
 from vllm.outputs import CompletionOutput, RequestOutput
 from vllm.sampling_params import SamplingParams
+from vllm.v1.engine.exceptions import EngineDeadError
+from vllm.v1.metrics.stats import IterationStats
 
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
     AddCompanionRequestMessage,
     CollectiveRPCRequestMessage,
     CollectiveRPCResultMessage,
+    ErrorMessage,
     OutputMessage,
     ShutdownRequestMessage,
     StageSubmissionMessage,
@@ -28,15 +31,70 @@ from vllm_omni.engine.orchestrator import (
     Orchestrator,
     OrchestratorRequestState,
     _build_terminal_empty_output,
-    _infer_stage_audio_sample_rate,
 )
 from vllm_omni.engine.stage_pool import StagePool
+from vllm_omni.experimental.fullduplex.engine.duplex_control_plane import DuplexControlPlane
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexInputMode,
+    DuplexRuntimeCapabilities,
+    DuplexSessionRuntimeState,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    AppendDuplexInputMessage,
+    CloseDuplexSessionMessage,
+    DuplexFence,
+    OpenDuplexSessionMessage,
+    SignalDuplexTurnMessage,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.runtime import MiniCPMO45DuplexRuntimeExtension
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+class FakeRunningCounter:
+    def __init__(self) -> None:
+        self.value = 0
+
+    def increment(self) -> None:
+        self.value += 1
+
+    def decrement(self) -> None:
+        self.value -= 1
+
+
+@pytest.mark.asyncio
+async def test_engine_dead_broadcasts_fatal_to_rpc_waiters(monkeypatch: pytest.MonkeyPatch) -> None:
+    rpc_queue: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_queue,
+        stage_pools=[],
+    )
+    orchestrator._fatal_error = "stage engine died"
+    orchestrator._fatal_error_stage_id = 2
+
+    async def wait_for_requests() -> None:
+        await asyncio.Event().wait()
+
+    async def fail_outputs() -> None:
+        raise EngineDeadError("stage engine died")
+
+    monkeypatch.setattr(orchestrator, "_request_handler", wait_for_requests)
+    monkeypatch.setattr(orchestrator, "_orchestration_output_handler", fail_outputs)
+
+    await orchestrator.run()
+
+    fatal = rpc_queue.get_nowait()
+    assert isinstance(fatal, ErrorMessage)
+    assert fatal.fatal is True
+    assert fatal.error == "stage engine died"
+    assert fatal.stage_id == 2
+
+
 @dataclass
 class OrchestratorFixture:
     orchestrator: Orchestrator
@@ -88,7 +146,7 @@ class FakeStageClient:
         try:
             return self._engine_core_outputs.get_nowait()
         except queue.Empty:
-            return SimpleNamespace(outputs=[])
+            return SimpleNamespace(outputs=[], scheduler_stats=None, finished_requests=None)
 
     def get_diffusion_output_nowait(self):
         try:
@@ -143,12 +201,12 @@ class FakeStageClient:
 def test_terminal_empty_audio_output_uses_stage_sample_rate() -> None:
     final_stage = FakeStageClient(final_output=True, final_output_type="audio")
     final_stage.sample_rate = 44100
-    final_pool = SimpleNamespace(stage_client=final_stage, _stage_vllm_config=None)
+    final_pool = StagePool(0, [final_stage])
 
     terminal_output = _build_terminal_empty_output(
         "req-1",
         final_output_type="audio",
-        audio_sample_rate=_infer_stage_audio_sample_rate(final_pool),
+        audio_sample_rate=final_pool._infer_audio_sample_rate(),
     )
 
     assert terminal_output.outputs[0].multimodal_output["sr"] == 44100
@@ -196,12 +254,40 @@ class FakeOutputProcessor:
         return None
 
 
+class IterationStatsOutputProcessor(FakeOutputProcessor):
+    def process_outputs(self, *_args, **kwargs):
+        iteration_stats = kwargs.get("iteration_stats")
+        if iteration_stats is None and len(_args) >= 3:
+            iteration_stats = _args[2]
+        assert iteration_stats is not None
+        iteration_stats.num_generation_tokens += 3
+        return super().process_outputs(*_args, **kwargs)
+
+
+class RecordingOutputProcessor(FakeOutputProcessor):
+    def __init__(self, *, request_outputs: list[object] | None = None) -> None:
+        super().__init__(request_outputs=request_outputs)
+        self.process_calls: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
+
+    def process_outputs(self, *args, **kwargs):
+        self.process_calls.append((args, kwargs))
+        return super().process_outputs(*args, **kwargs)
+
+
+class RecordingStatLogger:
+    def __init__(self) -> None:
+        self.records: list[tuple[Any, Any, int]] = []
+
+    def record(self, scheduler_stats, iteration_stats, *, engine_idx: int = 0) -> None:
+        self.records.append((scheduler_stats, iteration_stats, engine_idx))
+
+
 def _sampling_params(max_tokens: int = 4) -> SamplingParams:
     return SamplingParams(max_tokens=max_tokens)
 
 
 def _engine_core_outputs(tag: str, timestamp: float) -> SimpleNamespace:
-    return SimpleNamespace(outputs=[tag], timestamp=timestamp, scheduler_stats=None)
+    return SimpleNamespace(outputs=[tag], timestamp=timestamp, scheduler_stats=None, finished_requests=None)
 
 
 def _build_request_output(
@@ -272,6 +358,7 @@ def _build_harness(
     output_processors: list[object] | None = None,
     stage_vllm_configs: list[object] | None = None,
     async_chunk: bool = False,
+    log_stats: bool = False,
     stage_pools: list[StagePool] | None = None,
 ) -> OrchestratorFixture:
     """Build an Orchestrator test harness.
@@ -307,6 +394,7 @@ def _build_harness(
                 rpc_async_queue=rpc_queue.async_q,
                 stage_pools=stage_pools,
                 async_chunk=async_chunk,
+                log_stats=log_stats,
             )
             ready_future.set_result((orchestrator, request_queue, output_queue, rpc_queue))
             await orchestrator.run()
@@ -724,6 +812,778 @@ async def test_run_abort(orchestrator_factory) -> None:
         await _shutdown_orchestrator(orchestrator_fixture)
 
 
+def _duplex_open_message(
+    session_id: str,
+    *,
+    incarnation: int = 0,
+    session_config: dict[str, object] | None = None,
+    runtime_config: dict[str, object] | None = None,
+) -> OpenDuplexSessionMessage:
+    return OpenDuplexSessionMessage(
+        control_id=f"open-{session_id}",
+        fence=DuplexFence(session_id, incarnation=incarnation),
+        session_id=session_id,
+        capabilities={
+            "input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value],
+            "implementation_level": "model_native_duplex",
+        },
+        session_config=session_config or {},
+        runtime_config=runtime_config or {},
+    )
+
+
+async def _handle_duplex(orchestrator: Orchestrator, message: object) -> None:
+    await orchestrator._require_duplex_control_plane().handle(message)
+
+
+def _duplex_request_state(
+    orchestrator: Orchestrator,
+    session: DuplexSessionRuntimeState,
+    *,
+    stage_id: int,
+) -> OrchestratorRequestState | None:
+    context = orchestrator._require_duplex_control_plane().ensure_stage_request(
+        session,
+        stage_id=stage_id,
+    )
+    if context is None:
+        return None
+    return orchestrator.request_states.get(context.request_id)
+
+
+@pytest.mark.asyncio
+async def test_duplex_control_plane_keeps_public_and_runtime_config_separate() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    open_message = _duplex_open_message(
+        "sid-config-channels",
+        incarnation=3,
+        session_config={
+            "instructions": "public instructions",
+            "extra_body": {"duplex_stage_max_tokens": {"0": 99}},
+        },
+        runtime_config={
+            "duplex_stage_max_tokens": {"0": 3},
+            "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151705]}},
+        },
+    )
+
+    await _handle_duplex(orchestrator, open_message)
+
+    assert rpc_q.get_nowait().ok is True
+    session = orchestrator.duplex_sessions.require(open_message.session_id)
+    request_state = _duplex_request_state(orchestrator, session, stage_id=0)
+    assert request_state.sampling_params_list[0].max_tokens == 3
+    assert request_state.sampling_params_list[0].stop_token_ids == [151705]
+    bridge = request_state.streaming.bridge_states["duplex"]
+    assert bridge["incarnation"] == open_message.fence.incarnation
+    assert bridge["session_config"] == open_message.session_config
+    assert bridge["runtime_config"] == open_message.runtime_config
+
+
+@pytest.mark.asyncio
+async def test_duplex_control_plane_preserves_turn_commit_without_model_extension() -> None:
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=[],
+        duplex_runtime_extension=None,
+        enable_duplex_control=True,
+    )
+    assert isinstance(orchestrator.duplex_control_plane, DuplexControlPlane)
+
+    message = OpenDuplexSessionMessage(
+        control_id="open-turn-commit",
+        fence=DuplexFence("sid-turn-commit"),
+        session_id="sid-turn-commit",
+        capabilities={"input_modes": [DuplexInputMode.TURN_COMMIT_ONLY.value]},
+        session_config={},
+    )
+    await _handle_duplex(orchestrator, message)
+
+    result = rpc_q.get_nowait()
+    assert result.ok is True
+    assert result.stage_results[0]["result"]["scheduler_request_context"] is False
+
+
+def test_ordinary_orchestrator_bypasses_duplex_control_plane() -> None:
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=[],
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+    )
+
+    assert orchestrator.duplex_control_plane is None
+
+
+@pytest.mark.asyncio
+async def test_duplex_close_cleans_preregistered_request_without_append() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    running_counter = FakeRunningCounter()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+        running_counter=running_counter,
+    )
+    open_message = _duplex_open_message("sid-preregister-close")
+
+    await _handle_duplex(orchestrator, open_message)
+    open_result = rpc_q.get_nowait()
+    request_id = open_result.stage_results[0]["result"]["request_id"]
+    assert request_id in orchestrator.request_states
+
+    await _handle_duplex(
+        orchestrator,
+        CloseDuplexSessionMessage(
+            control_id="close-preregistered",
+            fence=open_message.fence,
+            session_id=open_message.session_id,
+        ),
+    )
+
+    assert rpc_q.get_nowait().ok is True
+    assert request_id not in orchestrator.request_states
+    assert orchestrator.duplex_sessions.get(open_message.session_id) is None
+    assert running_counter.value == 0
+
+
+@pytest.mark.asyncio
+async def test_duplex_open_failure_rolls_back_session_and_reserved_request() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    open_message = _duplex_open_message(
+        "sid-open-rollback",
+        runtime_config={
+            "duplex_stage_sampling_params": {
+                "0": {"stop_token_ids": 123},
+            }
+        },
+    )
+
+    await _handle_duplex(orchestrator, open_message)
+
+    assert rpc_q.get_nowait().ok is False
+    assert orchestrator.duplex_sessions.get(open_message.session_id) is None
+    assert orchestrator.request_states == {}
+
+
+@pytest.mark.asyncio
+async def test_duplex_running_counter_tracks_only_submitted_request() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    running_counter = FakeRunningCounter()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+        running_counter=running_counter,
+    )
+    open_message = _duplex_open_message("sid-duplex-counter")
+    await _handle_duplex(orchestrator, open_message)
+    assert rpc_q.get_nowait().ok is True
+    assert running_counter.value == 0
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="append-duplex-counter",
+            fence=open_message.fence,
+            session_id=open_message.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+    assert rpc_q.get_nowait().ok is True
+    assert running_counter.value == 1
+
+    await _handle_duplex(
+        orchestrator,
+        CloseDuplexSessionMessage(
+            control_id="close-duplex-counter",
+            fence=open_message.fence,
+            session_id=open_message.session_id,
+        ),
+    )
+    assert rpc_q.get_nowait().ok is True
+    assert running_counter.value == 0
+
+
+@pytest.mark.asyncio
+async def test_duplex_failed_append_does_not_advance_sequence_or_fence() -> None:
+    class FailingPlanExtension(MiniCPMO45DuplexRuntimeExtension):
+        def plan_append(self, **kwargs):
+            raise RuntimeError("planned append failure")
+
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=FailingPlanExtension(),
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-append-rollback", turn_id=1)
+    session = orchestrator.duplex_sessions.open_session(
+        DuplexFence("sid-append-rollback"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="append-rollback",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+
+    result = rpc_q.get_nowait()
+    assert result.ok is False
+    assert session.fence == DuplexFence("sid-append-rollback")
+    assert session.input_seq == 0
+    assert session.input_turn_seq == 0
+    assert stage0.add_request_calls == []
+
+
+@pytest.mark.asyncio
+async def test_duplex_duplicate_append_operation_is_submitted_once() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-idempotent-append")
+    session = orchestrator.duplex_sessions.open_session(
+        fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+
+    for control_id in ("append-first", "append-timeout-retry"):
+        await _handle_duplex(
+            orchestrator,
+            AppendDuplexInputMessage(
+                control_id=control_id,
+                operation_id="physical-input-1",
+                fence=fence,
+                session_id=fence.session_id,
+                mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+                payload={"is_speech": True},
+            ),
+        )
+
+    first = rpc_q.get_nowait()
+    retry = rpc_q.get_nowait()
+    assert first.ok is True
+    assert retry.ok is True
+    assert first.stage_results == retry.stage_results
+    assert len(stage0.add_request_calls) == 1
+    assert session.input_seq == 1
+
+
+@pytest.mark.asyncio
+async def test_duplex_barge_in_aborts_bound_stage_requests_before_releasing_fence() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=False)
+    stage1 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0], [stage1]],
+        output_processors=[FakeOutputProcessor(), FakeOutputProcessor()],
+        stage_vllm_configs=[
+            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+        ],
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=stage_pools,
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    session = orchestrator.duplex_sessions.open_session(
+        DuplexFence("sid-stage-signal"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(0, "req-stage0", fence=session.fence)
+    session.bind_stage_request(1, "req-stage1", fence=session.fence)
+    assert stage_pools[0].select_replica_id("req-stage0") == 0
+    assert stage_pools[1].select_replica_id("req-stage1") == 0
+    session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=session.fence,
+    )
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="ctrl-signal",
+            fence=session.fence,
+            next_fence=DuplexFence("sid-stage-signal", epoch=1),
+            session_id="sid-stage-signal",
+            event="barge_in",
+        ),
+    )
+
+    assert stage0.abort_calls == [["req-stage0"]]
+    assert stage1.abort_calls == [["req-stage1"]]
+    assert stage0.collective_rpc_calls == []
+    assert stage1.collective_rpc_calls == []
+    assert session.stage_bindings == {}
+    assert session.fence == DuplexFence("sid-stage-signal", epoch=1)
+    result = rpc_q.get_nowait()
+    assert result.ok is True
+
+
+@pytest.mark.asyncio
+async def test_duplex_late_barge_in_releases_only_cancelled_fence_bindings() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=False)
+    stage1 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0], [stage1]],
+        output_processors=[FakeOutputProcessor(), FakeOutputProcessor()],
+        stage_vllm_configs=[
+            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+        ],
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=stage_pools,
+        enable_duplex_control=True,
+    )
+    cancelled_fence = DuplexFence("sid-late-stage-signal")
+    session = orchestrator.duplex_sessions.open_session(
+        cancelled_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(0, "req-stage0", fence=cancelled_fence)
+    session.bind_stage_request(1, "req-stage1", fence=cancelled_fence)
+    assert stage_pools[0].select_replica_id("req-stage0") == 0
+    assert stage_pools[1].select_replica_id("req-stage1") == 0
+    current_fence = DuplexFence("sid-late-stage-signal", epoch=1)
+    session.accept_fence(current_fence)
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="ctrl-late-signal",
+            fence=cancelled_fence,
+            next_fence=current_fence,
+            session_id="sid-late-stage-signal",
+            event="barge_in",
+        ),
+    )
+
+    assert stage0.abort_calls == [["req-stage0"]]
+    assert stage1.abort_calls == [["req-stage1"]]
+    assert session.stage_bindings == {}
+    assert session.fence == current_fence
+    result = rpc_q.get_nowait()
+    assert result.ok is True
+
+
+@pytest.mark.asyncio
+async def test_duplex_cancel_without_next_fence_is_rejected_without_releasing_bindings() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0]],
+        output_processors=[FakeOutputProcessor()],
+        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=stage_pools,
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-cancel-contract")
+    session = orchestrator.duplex_sessions.open_session(fence)
+    session.bind_stage_request(0, "req-live", fence=fence)
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="cancel-without-next",
+            fence=fence,
+            session_id=fence.session_id,
+            event="input.cancel",
+        ),
+    )
+
+    result = rpc_q.get_nowait()
+    assert result.ok is False
+    assert result.error_count == 1
+    assert "next_fence" in result.stage_results[0]["result"]["error"]
+    assert session.fence == fence
+    assert session.stage_request_ids() == ["req-live"]
+    assert stage0.abort_calls == []
+
+
+@pytest.mark.asyncio
+async def test_duplex_session_update_replaces_runtime_config() -> None:
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=[],
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-update-config")
+    session = orchestrator.duplex_sessions.open_session(
+        fence,
+        session_config={"temperature": 0.7},
+    )
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="update-config",
+            fence=fence,
+            session_id=fence.session_id,
+            event="session.update",
+            session_config={"temperature": 0.0, "instructions": "updated"},
+        ),
+    )
+
+    result = rpc_q.get_nowait()
+    assert result.ok is True
+    assert session.session_config == {"temperature": 0.0, "instructions": "updated"}
+
+
+@pytest.mark.asyncio
+async def test_duplex_session_update_refreshes_next_append_sampling_params() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0]],
+        output_processors=[FakeOutputProcessor()],
+        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=stage_pools,
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-update-policy")
+    session = orchestrator.duplex_sessions.open_session(
+        fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+        runtime_config={
+            "duplex_stage_max_tokens": {"0": 2},
+            "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151645]}},
+        },
+    )
+    req_state = _duplex_request_state(orchestrator, session, stage_id=0)
+    assert req_state is not None
+    assert req_state.sampling_params_list[0].max_tokens == 2
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="update-policy",
+            fence=fence,
+            session_id=fence.session_id,
+            event="session.update",
+            runtime_config={
+                "duplex_stage_max_tokens": {"0": 7},
+                "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151705]}},
+            },
+        ),
+    )
+    assert rpc_q.get_nowait().ok is True
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="append-updated-policy",
+            fence=fence,
+            session_id=fence.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+
+    assert rpc_q.get_nowait().ok is True
+    assert req_state.sampling_params_list[0].max_tokens == 7
+    assert req_state.sampling_params_list[0].stop_token_ids == [151705]
+    submitted_request = stage0.add_request_calls[0][0]
+    assert submitted_request.sampling_params.stop_token_ids == [151705]
+    assert submitted_request.sampling_params.max_tokens == 7
+
+
+@pytest.mark.asyncio
+async def test_duplex_invalid_session_update_preserves_previous_config() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=_build_stage_pools([[stage0]]),
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-invalid-update")
+    original_runtime_config = {
+        "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151645]}},
+    }
+    session = orchestrator.duplex_sessions.open_session(
+        fence,
+        runtime_config=original_runtime_config,
+    )
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="invalid-update",
+            fence=fence,
+            session_id=fence.session_id,
+            event="session.update",
+            runtime_config={
+                "duplex_stage_sampling_params": {"0": {"stop_token_ids": 123}},
+            },
+        ),
+    )
+
+    result = rpc_q.get_nowait()
+    assert result.ok is False
+    assert session.runtime_config == original_runtime_config
+    assert session.config_generation == 0
+
+
+@pytest.mark.asyncio
+async def test_duplex_arbitrary_non_cancel_signal_is_rejected() -> None:
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=[],
+        enable_duplex_control=True,
+    )
+    fence = DuplexFence("sid-unsupported-signal")
+    orchestrator.duplex_sessions.open_session(fence)
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="unsupported-signal",
+            fence=fence,
+            session_id=fence.session_id,
+            event="turn.end",
+        ),
+    )
+
+    result = rpc_q.get_nowait()
+    assert result.ok is False
+    assert "unsupported duplex runtime signal" in result.stage_results[0]["result"]["error"]
+
+
+@pytest.mark.asyncio
+async def test_duplex_cancel_rejects_late_old_append_and_accepts_next_epoch() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0]],
+        output_processors=[FakeOutputProcessor()],
+        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=rpc_q,
+        stage_pools=stage_pools,
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    cancelled_fence = DuplexFence("sid-cancel-late-append")
+    next_fence = DuplexFence("sid-cancel-late-append", epoch=1)
+    session = orchestrator.duplex_sessions.open_session(
+        cancelled_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+
+    await _handle_duplex(
+        orchestrator,
+        SignalDuplexTurnMessage(
+            control_id="cancel-old-fence",
+            fence=cancelled_fence,
+            next_fence=next_fence,
+            session_id=session.session_id,
+            event="input.cancel",
+        ),
+    )
+
+    cancel_result = rpc_q.get_nowait()
+    assert cancel_result.ok is True
+    assert session.fence == next_fence
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="late-old-append",
+            fence=cancelled_fence,
+            session_id=session.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+
+    stale_result = rpc_q.get_nowait()
+    assert stale_result.ok is False
+    assert stage0.add_request_calls == []
+    assert session.stage_bindings == {}
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="next-epoch-append",
+            fence=next_fence,
+            session_id=session.session_id,
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+
+    next_result = rpc_q.get_nowait()
+    assert next_result.ok is True
+    assert len(stage0.add_request_calls) == 1
+    assert session.stage_bindings[0].fence == next_fence
+
+
+@pytest.mark.asyncio
+async def test_duplex_append_updates_bridge_turn_id_on_long_lived_stage0_request() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    stage_pools = _build_stage_pools(
+        [[stage0]],
+        output_processors=[FakeOutputProcessor()],
+        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
+    )
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=stage_pools,
+        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
+        enable_duplex_control=True,
+    )
+    session = orchestrator.duplex_sessions.open_session(
+        DuplexFence("sid-bridge-turn"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+        session_config={
+            "voice": "test",
+        },
+        runtime_config={
+            "duplex_stage_sampling_params": {
+                "0": {"stop_token_ids": [151645]},
+            },
+        },
+    )
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="append-1",
+            fence=DuplexFence("sid-bridge-turn"),
+            session_id="sid-bridge-turn",
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True},
+        ),
+    )
+    req_state1 = _duplex_request_state(orchestrator, session, stage_id=0)
+    assert req_state1 is not None
+    duplex_state1 = req_state1.streaming.bridge_states["duplex"]
+    assert duplex_state1["session_id"] == "sid-bridge-turn"
+    assert duplex_state1["epoch"] == 0
+    assert duplex_state1["turn_id"] == 0
+    assert duplex_state1["session_config"] == session.session_config
+    assert req_state1.sampling_params_list[0].stop_token_ids == [151645]
+    submitted_request = stage0.add_request_calls[0][0]
+    assert submitted_request.sampling_params.stop_token_ids == [151645]
+    assert submitted_request.sampling_params.max_tokens == 1
+
+    await _handle_duplex(
+        orchestrator,
+        AppendDuplexInputMessage(
+            control_id="append-2",
+            fence=DuplexFence("sid-bridge-turn", turn_id=1, response_seq=1),
+            session_id="sid-bridge-turn",
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
+            payload={"is_speech": True, "new_user_turn": True},
+        ),
+    )
+    req_state2 = _duplex_request_state(orchestrator, session, stage_id=0)
+    assert req_state2 is req_state1
+    duplex_state2 = req_state2.streaming.bridge_states["duplex"]
+    assert duplex_state2["turn_id"] == 1
+    assert duplex_state2["epoch"] == 0
+    expected_request_id = duplex_resource_request_id(DuplexFence("sid-bridge-turn"), "stage0")
+    assert [call[0].request_id for call in stage0.add_request_calls] == [
+        expected_request_id,
+        expected_request_id,
+    ]
+
+
 # ---------------------------------------------------------------------------
 # Multi-replica tests
 # ---------------------------------------------------------------------------
@@ -898,6 +1758,50 @@ async def test_stage_pool_submit_update_reuses_existing_binding() -> None:
     assert stage0_r1.add_request_calls[1][0].request_id == "req-1"
 
 
+@pytest.mark.asyncio
+async def test_stage_pool_failed_replica_releases_distributed_affinity_and_stops_polling() -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=False)
+    pool = StagePool(
+        0,
+        [stage0],
+        output_processor=FakeOutputProcessor(),
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+    )
+    pool._addr_to_replica_id["tcp://replica-0"] = 0
+    pool.bind("distributed-request", "tcp://replica-0")
+    pool._request_bindings["legacy-request"] = 0
+
+    affected = pool.mark_replica_unavailable(0)
+
+    assert set(affected) == {"distributed-request", "legacy-request"}
+    assert pool.get_bound_replica_id("distributed-request") is None
+    assert pool.get_bound_replica_id("legacy-request") is None
+    assert await pool.poll_llm_raw_output(0) is None
+
+
+def test_stage_pool_reattached_replica_becomes_available_again() -> None:
+    failed_client = FakeStageClient(stage_type="llm", final_output=False)
+    replacement_client = FakeStageClient(stage_type="llm", final_output=False)
+    pool = StagePool(
+        0,
+        [failed_client],
+        output_processor=FakeOutputProcessor(),
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+    )
+    input_addr = "tcp://replica-0"
+    pool._addr_to_replica_id[input_addr] = 0
+    pool.mark_replica_unavailable(0)
+    removed = pool.remove_client(input_addr)
+
+    replica_id = pool.add_client(input_addr, replacement_client)
+
+    assert removed is failed_client
+    assert replica_id == 0
+    assert len(pool.clients) == 1
+    assert pool.clients[0] is replacement_client
+    assert pool.available_replica_ids() == [0]
+
+
 @pytest.mark.asyncio
 async def test_stage_pool_submit_update_refreshes_output_processor_state() -> None:
     output_processor = FakeOutputProcessor()
@@ -940,6 +1844,56 @@ async def test_stage_pool_submit_update_refreshes_output_processor_state() -> No
 
 
 @pytest.mark.asyncio
+async def test_handle_streaming_update_unknown_request_is_dropped() -> None:
+    """A streaming update for an untracked request must not resurrect it.
+
+    Updates always follow the first-chunk add_request through the same
+    ordered submission queue, so an unknown id can only mean the request
+    already finished or was aborted (e.g. the client disconnected).
+    Falling back to add_request created headless sessions that kept
+    cycling through the stages (issue #4271).
+    """
+
+    class RecordingPool:
+        def __init__(self) -> None:
+            self.calls: list[tuple[str, Any]] = []
+
+        async def submit_update(self, request_id, req_state, request, *, prompt_text=None) -> int:
+            self.calls.append((request_id, prompt_text))
+            return 0
+
+    pool = RecordingPool()
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.async_chunk = False
+    orchestrator.request_states = {}
+    orchestrator.stage_pools = [pool]
+    add_request_calls: list[str] = []
+
+    async def record_add_request(msg) -> None:
+        add_request_calls.append(msg.request_id)
+
+    orchestrator._handle_add_request = record_add_request
+
+    await orchestrator._handle_streaming_update(
+        StageSubmissionMessage(
+            type="streaming_update",
+            request_id="req-unknown",
+            prompt=SimpleNamespace(request_id="req-unknown", prompt_token_ids=[1], resumable=True),
+            original_prompt={"prompt": "segment-2"},
+            output_prompt_text="segment-2",
+            sampling_params_list=[_sampling_params()],
+            final_stage_id=0,
+            preprocess_ms=0.0,
+            request_timestamp=time.time(),
+            enqueue_ts=time.perf_counter(),
+        )
+    )
+
+    assert pool.calls == []
+    assert add_request_calls == []
+    assert "req-unknown" not in orchestrator.request_states
+
+
 async def test_handle_streaming_update_passes_prompt_text_to_stage_pool() -> None:
     class RecordingPool:
         def __init__(self) -> None:
@@ -980,6 +1934,73 @@ async def test_handle_streaming_update_passes_prompt_text_to_stage_pool() -> Non
     assert orchestrator.request_states["req-stream"].streaming.enabled is True
 
 
+@pytest.mark.asyncio
+async def test_resumable_segment_boundary_builds_stage_metrics() -> None:
+    built_metrics = SimpleNamespace(pipeline_timings={})
+
+    class RecordingPool:
+        def __init__(self) -> None:
+            self.calls: list[list[Any]] = []
+
+        def build_stage_metrics(self, outputs, **_kwargs):
+            self.calls.append(outputs)
+            return built_metrics
+
+    pool = RecordingPool()
+    orchestrator = object.__new__(Orchestrator)
+    req_state = OrchestratorRequestState(
+        request_id="req-stream",
+        sampling_params_list=[_sampling_params()],
+        final_stage_id=0,
+    )
+    req_state.streaming.enabled = True
+    req_state.streaming.segment_finished = True
+    req_state.stage_submit_ts[0] = time.time()
+    orchestrator.request_states = {"req-stream": req_state}
+    orchestrator.stage_pools = [pool]
+    routed: list[Any] = []
+
+    async def record_route(_stage_id, _replica_id, _output, _req_state, stage_metrics):
+        routed.append(stage_metrics)
+
+    orchestrator._route_output = record_route
+    output = SimpleNamespace(request_id="req-stream", error=None, finished=False)
+
+    await orchestrator._handle_processed_outputs(0, 0, [output])
+
+    assert pool.calls == [[output]]
+    assert routed == [built_metrics]
+
+
+def test_stage_pool_metrics_use_resumable_segment_token_count() -> None:
+    class SegmentMetricsOutputProcessor(FakeOutputProcessor):
+        def pop_native_text_metrics(self, request_id: str) -> dict[str, Any]:
+            assert request_id == "req-stream"
+            return {"num_generation_tokens": 3}
+
+    stage0 = FakeStageClient(stage_type="llm", final_output=False)
+    pool = StagePool(
+        0,
+        [stage0],
+        output_processor=SegmentMetricsOutputProcessor(),
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+    )
+    output = SimpleNamespace(
+        request_id="req-stream",
+        outputs=[SimpleNamespace(cumulative_token_ids=list(range(11)))],
+    )
+
+    metrics = pool.build_stage_metrics(
+        [output],
+        submit_ts=time.time(),
+        request_timestamp=time.time(),
+        replica_id=0,
+    )
+
+    assert metrics.num_tokens_out == 3
+    assert metrics.output_unit_count == 3
+
+
 @pytest.mark.asyncio
 async def test_stage_pool_submit_initial_rolls_back_output_processor_when_client_submit_fails() -> None:
     class FailingStageClient(FakeStageClient):
@@ -1147,35 +2168,272 @@ async def test_multi_replica_cfg_companion_inherits_parent_affinity(orchestrator
         await _shutdown_orchestrator(orchestrator_fixture)
 
 
-def test_orchestrator_does_not_re_introduce_global_stats_throttle() -> None:
-    """Regression: each (stage, replica) must independently publish its wrapped
-    vllm:* stats when its scheduler emits non-None scheduler_stats.
-
-    A previous version of Orchestrator carried a global self._last_stats_ts /
-    _stats_interval_s gate around _stat_logger.record(). Because
-    OmniSchedulerMixin.make_stats() already throttles at 1 Hz per scheduler
-    (one per (stage, replica)), the extra global gate starved every replica
-    other than the first to emit within each second — their {stage, replica}
-    gauges/counters went stale.
-
-    The fix removed the global gate entirely; the only signal needed is
-    'this replica's scheduler emitted non-None scheduler_stats'. This test
-    fails loudly if someone reintroduces the global throttle.
-    """
-    import inspect
-
-    from vllm_omni.engine.orchestrator import Orchestrator
-
-    source = inspect.getsource(Orchestrator)
-    assert "_last_stats_ts" not in source, (
-        "Orchestrator must not gate stat recording on a global timestamp. "
-        "OmniSchedulerMixin.make_stats() already throttles per scheduler "
-        "(per (stage, replica)); an outer global gate starves all but the "
-        "first replica to emit within each 1s window."
+@pytest.mark.asyncio
+async def test_orchestrator_records_iteration_stats_without_scheduler_stats(orchestrator_factory) -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    processor = IterationStatsOutputProcessor(
+        request_outputs=[_build_request_output("req-stats", token_ids=[1], finished=True)]
     )
-    assert "_stats_interval_s" not in source
-    assert "raw_outputs.scheduler_stats is not None" in source, (
-        "Orchestrator must gate stat recording solely on "
-        "raw_outputs.scheduler_stats being non-None — the per-scheduler 1Hz "
-        "throttle in OmniSchedulerMixin.make_stats() is the only gate needed."
+    orchestrator_fixture = orchestrator_factory([stage0], output_processors=[processor], log_stats=True)
+    stat_logger = RecordingStatLogger()
+    orchestrator_fixture.orchestrator._stat_logger = stat_logger
+    request = SimpleNamespace(request_id="req-stats", prompt_token_ids=[1, 2])
+
+    try:
+        await _enqueue_add_request(
+            orchestrator_fixture,
+            request_id="req-stats",
+            prompt=request,
+            original_prompt={"prompt": "hello"},
+            sampling_params_list=[_sampling_params()],
+            final_stage_id=0,
+        )
+        await _wait_for(lambda: len(stage0.add_request_calls) == 1)
+
+        stage0.push_engine_core_outputs(_engine_core_outputs("raw-without-scheduler-stats", 1.0))
+
+        await _wait_for(lambda: len(stat_logger.records) == 1)
+        scheduler_stats, iteration_stats, engine_idx = stat_logger.records[0]
+        assert scheduler_stats is None
+        assert iteration_stats is not None
+        assert iteration_stats.num_generation_tokens == 3
+        assert engine_idx == 0
+    finally:
+        await _shutdown_orchestrator(orchestrator_fixture)
+
+
+@pytest.mark.asyncio
+async def test_orchestrator_records_scheduler_stats_without_outputs(orchestrator_factory) -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    processor = RecordingOutputProcessor()
+    orchestrator_fixture = orchestrator_factory([stage0], output_processors=[processor], log_stats=True)
+    stat_logger = RecordingStatLogger()
+    orchestrator_fixture.orchestrator._stat_logger = stat_logger
+    scheduler_stats = SimpleNamespace(num_running_reqs=0, kv_cache_usage=0.5)
+
+    try:
+        stage0.push_engine_core_outputs(
+            SimpleNamespace(
+                outputs=[],
+                timestamp=1.0,
+                scheduler_stats=scheduler_stats,
+                finished_requests=None,
+            )
+        )
+
+        await _wait_for(lambda: len(stat_logger.records) == 1)
+        recorded_scheduler_stats, iteration_stats, engine_idx = stat_logger.records[0]
+        assert recorded_scheduler_stats is scheduler_stats
+        assert iteration_stats is None
+        assert engine_idx == 0
+        assert processor.process_calls[0][0][2] is None
+    finally:
+        await _shutdown_orchestrator(orchestrator_fixture)
+
+
+@pytest.mark.asyncio
+async def test_orchestrator_does_not_build_iteration_stats_for_finished_only_batch(orchestrator_factory) -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    processor = RecordingOutputProcessor()
+    orchestrator_fixture = orchestrator_factory([stage0], output_processors=[processor], log_stats=True)
+    stat_logger = RecordingStatLogger()
+    orchestrator_fixture.orchestrator._stat_logger = stat_logger
+
+    try:
+        stage0.push_engine_core_outputs(
+            SimpleNamespace(
+                outputs=[],
+                timestamp=1.0,
+                scheduler_stats=None,
+                finished_requests={"req-finished"},
+            )
+        )
+
+        await _wait_for(lambda: bool(processor.process_calls))
+        assert processor.process_calls[0][0][2] is None
+        assert stat_logger.records == []
+    finally:
+        await _shutdown_orchestrator(orchestrator_fixture)
+
+
+@pytest.mark.asyncio
+async def test_orchestrator_does_not_build_iteration_stats_without_stat_logger(orchestrator_factory) -> None:
+    stage0 = FakeStageClient(stage_type="llm", final_output=True)
+    processor = RecordingOutputProcessor()
+    orchestrator_fixture = orchestrator_factory([stage0], output_processors=[processor], log_stats=True)
+    orchestrator_fixture.orchestrator._stat_logger = None
+
+    try:
+        stage0.push_engine_core_outputs(_engine_core_outputs("raw-output", 1.0))
+
+        await _wait_for(lambda: bool(processor.process_calls))
+        assert processor.process_calls[0][0][2] is None
+    finally:
+        await _shutdown_orchestrator(orchestrator_fixture)
+
+
+@pytest.mark.asyncio
+async def test_stage_pool_preserves_none_iteration_stats() -> None:
+    client = FakeStageClient(stage_type="llm", final_output=True)
+    processor = RecordingOutputProcessor()
+    pool = StagePool(
+        0,
+        [client],
+        output_processor=processor,
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
     )
+    raw_outputs = SimpleNamespace(outputs=["raw"], timestamp=1.0, scheduler_stats=None)
+
+    await pool.process_llm_raw_outputs(0, raw_outputs, iteration_stats=None)
+
+    assert processor.process_calls[0][0][2] is None
+
+
+@pytest.mark.asyncio
+async def test_stage_pool_process_llm_raw_outputs_mutates_iteration_stats() -> None:
+    client = FakeStageClient(stage_type="llm", final_output=True)
+    processor = IterationStatsOutputProcessor()
+    pool = StagePool(
+        0,
+        [client],
+        output_processor=processor,
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+    )
+    raw_outputs = SimpleNamespace(outputs=["raw"], timestamp=1.0, scheduler_stats=None)
+    iteration_stats = IterationStats()
+
+    await pool.process_llm_raw_outputs(0, raw_outputs, iteration_stats=iteration_stats)
+
+    assert iteration_stats.num_generation_tokens == 3
+
+
+@pytest.mark.asyncio
+async def test_duplex_reaper_loop_waits_between_ticks():
+    class _Plane:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        async def reap_expired(self) -> int:
+            self.calls += 1
+            return 0
+
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.duplex_control_plane = _Plane()
+    orchestrator._duplex_reaper_interval_s = 0.01
+    orchestrator._shutdown_event = asyncio.Event()
+
+    task = asyncio.create_task(orchestrator._duplex_reaper_loop())
+    await asyncio.sleep(0.035)
+    orchestrator._shutdown_event.set()
+    await task
+
+    assert 2 <= orchestrator.duplex_control_plane.calls <= 5
+
+
+@pytest.mark.asyncio
+async def test_duplex_reaper_loop_survives_one_cleanup_failure():
+    class _Plane:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        async def reap_expired(self) -> int:
+            self.calls += 1
+            if self.calls == 1:
+                raise RuntimeError("transient cleanup failure")
+            return 0
+
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.duplex_control_plane = _Plane()
+    orchestrator._duplex_reaper_interval_s = 0.01
+    orchestrator._shutdown_event = asyncio.Event()
+
+    task = asyncio.create_task(orchestrator._duplex_reaper_loop())
+    await asyncio.sleep(0.035)
+    orchestrator._shutdown_event.set()
+    await task
+
+    assert orchestrator.duplex_control_plane.calls >= 2
+
+
+@pytest.mark.asyncio
+async def test_abort_retry_does_not_repeat_successful_stage_abort():
+    class _Pool:
+        def __init__(self, *, fail_once: bool = False) -> None:
+            self.bound = {"req-a"}
+            self.fail_once = fail_once
+            self.physical_abort_calls = 0
+
+        async def abort_requests(self, request_ids: list[str]) -> None:
+            active = self.bound.intersection(request_ids)
+            if not active:
+                return
+            self.physical_abort_calls += 1
+            if self.fail_once:
+                self.fail_once = False
+                raise RuntimeError("stage abort failed")
+
+        def release_bindings(self, request_ids: list[str]) -> None:
+            self.bound.difference_update(request_ids)
+
+    first = _Pool()
+    second = _Pool(fail_once=True)
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.stage_pools = [first, second]
+
+    with pytest.raises(RuntimeError, match="stage abort failed"):
+        await orchestrator._abort_request_ids(["req-a"])
+
+    assert first.bound == set()
+    assert first.physical_abort_calls == 1
+    assert second.bound == {"req-a"}
+
+    await orchestrator._abort_request_ids(["req-a"])
+
+    assert first.physical_abort_calls == 1
+    assert second.physical_abort_calls == 2
+    assert second.bound == set()
+
+
+@pytest.mark.asyncio
+async def test_request_cleanup_failure_is_deferred_to_control_plane():
+    class _FailingPool:
+        async def abort_requests(self, request_ids: list[str]) -> None:
+            raise RuntimeError("stage abort failed")
+
+        def release_bindings(self, request_ids: list[str]) -> None:
+            pass
+
+    class _Plane:
+        def __init__(self) -> None:
+            self.deferred: list[str] = []
+            self.finalized: list[str] = []
+
+        def close_sessions_for_request_ids(self, request_ids: list[str], **kwargs):
+            assert kwargs == {"abort": True, "cleanup_in_progress": True}
+            return {"sid-cleanup": ["req-a"]}
+
+        def defer_request_cleanups(self, session_ids: list[str]) -> None:
+            self.deferred.extend(session_ids)
+
+        def finalize_closed_sessions(self, session_ids: list[str]) -> None:
+            self.finalized.extend(session_ids)
+
+    from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
+
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.stage_pools = [_FailingPool()]
+    orchestrator.duplex_control_plane = _Plane()
+    orchestrator._pd_kv_params = {}
+    orchestrator.request_states = {}
+    orchestrator._running_counter = None
+    orchestrator._cfg_tracker = CfgCompanionTracker()
+
+    with pytest.raises(RuntimeError, match="stage abort failed"):
+        await orchestrator._cleanup_request_ids(
+            ["req-a"],
+            abort=True,
+            close_duplex_sessions=True,
+        )
+
+    assert orchestrator.duplex_control_plane.deferred == ["sid-cleanup"]
+    assert orchestrator.duplex_control_plane.finalized == []
diff --git a/tests/engine/test_orchestrator_error_handling.py b/tests/engine/test_orchestrator_error_handling.py
index 0553c03ff..d30b1eee4 100644
--- a/tests/engine/test_orchestrator_error_handling.py
+++ b/tests/engine/test_orchestrator_error_handling.py
@@ -73,9 +73,21 @@ def orchestrator_factory():
 
 
 class FakeDeadLLMStageClient(FakeStageClient):
-    """LLM stage client that raises EngineDeadError on get_output_async."""
+    """LLM stage client that raises EngineDeadError once a request is in-flight.
+
+    Raising on the first poll races with ``add_request``: under suite load the
+    orchestrator can die and drain before the test enqueues anything, so no
+    fatal ErrorMessage is ever published. Keep returning empty outputs until
+    ``add_request_async`` has been called, then fail on the next poll.
+    """
 
     async def get_output_async(self):
+        if not self.add_request_calls:
+            return SimpleNamespace(
+                outputs=[],
+                scheduler_stats=None,
+                finished_requests=None,
+            )
         raise EngineDeadError("Stage-0 engine core is dead")
 
 
diff --git a/tests/engine/test_orchestrator_stage_input_bridge.py b/tests/engine/test_orchestrator_stage_input_bridge.py
index 27ee11df4..cf347e49f 100644
--- a/tests/engine/test_orchestrator_stage_input_bridge.py
+++ b/tests/engine/test_orchestrator_stage_input_bridge.py
@@ -3,17 +3,28 @@
 
 from __future__ import annotations
 
+import asyncio
 import queue
 from types import SimpleNamespace
 from typing import Any
+from unittest.mock import ANY, AsyncMock, MagicMock
 
 import janus
 import pytest
 from vllm.outputs import CompletionOutput, RequestOutput
 from vllm.sampling_params import SamplingParams
 
-from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorRequestState
+from vllm_omni.engine.orchestrator import (
+    Orchestrator,
+    OrchestratorRequestState,
+    _OrchestratorDuplexStagePort,
+)
 from vllm_omni.engine.stage_pool import StagePool
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -38,6 +49,7 @@ class FakeStageClient:
         self.custom_process_input_func = None
         self.next_inputs = list(next_inputs or [])
         self.add_request_calls: list[tuple[Any, ...]] = []
+        self.decoded_source_tokens: str | None = None
         self._engine_core_outputs = queue.Queue()
 
     async def add_request_async(self, *args, **_kwargs) -> None:
@@ -50,6 +62,9 @@ class FakeStageClient:
             return SimpleNamespace(outputs=[])
 
     def process_engine_inputs(self, _source_outputs, prompt=None, streaming_context=None):
+        decoder = getattr(streaming_context, "source_token_decoder", None)
+        if callable(decoder):
+            self.decoded_source_tokens = decoder([11, 12], skip_special_tokens=True)
         return list(self.next_inputs)
 
     async def abort_requests_async(self, _request_ids: list[str]) -> None:
@@ -66,6 +81,9 @@ class FakeStageClient:
 
 
 class FakeOutputProcessor:
+    def __init__(self, tokenizer=None) -> None:
+        self.tokenizer = tokenizer
+
     def add_request(self, *args, **kwargs) -> None:
         return None
 
@@ -84,6 +102,64 @@ class FakeInputProcessor:
         )
 
 
+class FakePrewarmPool:
+    stage_type = "llm"
+
+    def __init__(self, role: str) -> None:
+        self.stage_vllm_config = SimpleNamespace(
+            model_config=SimpleNamespace(
+                max_model_len=64,
+                stage_connector_config={"extra": {"role": role}},
+            )
+        )
+        self.submitted: list[Any] = []
+
+    async def submit_initial(self, _request_id, _req_state, request, prompt_text=None):
+        self.submitted.append(request)
+        return 0
+
+    def get_bound_replica_id(self, _request_id):
+        return 0
+
+
+def _duplex_stage_port_submission():
+    stage_pools = []
+    for stage_id in range(3):
+        pool = SimpleNamespace(
+            stage_client=SimpleNamespace(default_sampling_params=SamplingParams(max_tokens=1)),
+            stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
+            submit_initial=AsyncMock(return_value=stage_id + 10),
+            submit_update=AsyncMock(return_value=stage_id + 20),
+        )
+        stage_pools.append(pool)
+    request_states: dict[str, OrchestratorRequestState] = {}
+    prewarm = AsyncMock()
+    port = _OrchestratorDuplexStagePort(
+        stage_pools=stage_pools,
+        request_states=request_states,
+        running_counter=None,
+        cleanup_request_ids=AsyncMock(),
+        async_chunk=True,
+        prewarm_async_chunk_stages=prewarm,
+    )
+    context = DuplexStageRequestContext(
+        request_id="req-duplex",
+        session_id="session-duplex",
+        fence=DuplexFence("session-duplex"),
+        stage_id=0,
+        final_stage_id=2,
+        config_generation=0,
+        sampling_params=tuple(SamplingParams(max_tokens=1) for _ in range(3)),
+    )
+    port.ensure_request(context)
+    submission = DuplexStageSubmission(
+        context=context,
+        prompt={"prompt_token_ids": [1, 2]},
+        already_submitted=False,
+    )
+    return port, stage_pools, request_states, prewarm, submission
+
+
 def _request_output(request_id: str) -> RequestOutput:
     completion = CompletionOutput(
         index=0,
@@ -108,6 +184,11 @@ def _request_output(request_id: str) -> RequestOutput:
 
 @pytest.mark.asyncio
 async def test_forward_text_prompt_uses_target_stage_input_processor() -> None:
+    class SourceTokenizer:
+        def decode(self, token_ids, *, skip_special_tokens):
+            assert skip_special_tokens is True
+            return ":".join(str(token_id) for token_id in token_ids)
+
     stage0 = FakeStageClient(final_output=True)
     stage1 = FakeStageClient(
         final_output=True,
@@ -117,7 +198,7 @@ async def test_forward_text_prompt_uses_target_stage_input_processor() -> None:
         StagePool(
             0,
             [stage0],
-            output_processor=FakeOutputProcessor(),
+            output_processor=FakeOutputProcessor(tokenizer=SourceTokenizer()),
             stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
         ),
         StagePool(
@@ -150,7 +231,116 @@ async def test_forward_text_prompt_uses_target_stage_input_processor() -> None:
 
     assert input_processor.calls
     assert input_processor.calls[0]["prompt"] == {"prompt": "hello", "multi_modal_data": {"video": ["frame"]}}
+    assert stage1.decoded_source_tokens == "11:12"
+    assert req_state.streaming.source_token_decoder is None
     assert stage1.add_request_calls
     submitted_request = stage1.add_request_calls[0][0]
     assert submitted_request.prompt_token_ids == [101, 102]
     assert submitted_request.external_req_id == "req-text"
+
+
+@pytest.mark.asyncio
+async def test_async_prewarm_skips_outgoing_only_stage() -> None:
+    orchestrator = object.__new__(Orchestrator)
+    stage0 = FakePrewarmPool("sender")
+    stage1 = FakePrewarmPool("sender")
+    stage2 = FakePrewarmPool("receiver")
+    orchestrator.stage_pools = [stage0, stage1, stage2]
+    orchestrator._emit_tx_edge = lambda **_kwargs: None
+    orchestrator._record_duplex_stage_submission = MagicMock()
+    req_state = OrchestratorRequestState(
+        request_id="req-prewarm",
+        prompt={"prompt_token_ids": [1, 2]},
+        sampling_params_list=[SamplingParams(max_tokens=1) for _ in range(3)],
+        final_stage_id=2,
+        duplex_identity=SimpleNamespace(),
+    )
+
+    await orchestrator._prewarm_async_chunk_stages(
+        "req-prewarm",
+        SimpleNamespace(prompt_token_ids=[1, 2], resumable=True),
+        req_state,
+    )
+
+    assert stage1.submitted == []
+    assert len(stage2.submitted) == 1
+    assert 1 not in req_state.stage_submit_ts
+    assert 2 in req_state.stage_submit_ts
+    orchestrator._record_duplex_stage_submission.assert_called_once_with(
+        2,
+        "req-prewarm",
+        0,
+        req_state,
+    )
+
+
+@pytest.mark.asyncio
+async def test_duplex_prewarm_runs_after_first_stage0_submission() -> None:
+    port, stage_pools, request_states, prewarm, submission = _duplex_stage_port_submission()
+
+    result = await port.submit(submission)
+
+    assert result.stage_id == 0
+    stage_pools[0].submit_initial.assert_awaited_once()
+    prewarm.assert_awaited_once_with("req-duplex", ANY, request_states["req-duplex"])
+
+
+@pytest.mark.asyncio
+async def test_async_route_forwards_to_outgoing_only_stage() -> None:
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.async_chunk = True
+    orchestrator._pd_pair = None
+    orchestrator._cfg_tracker = SimpleNamespace(
+        is_companion=lambda _request_id: False,
+        has_companions=lambda _request_id: False,
+    )
+    stage0 = SimpleNamespace(final_output=False)
+    stage1 = FakePrewarmPool("sender")
+    orchestrator.stage_pools = [stage0, stage1]
+    orchestrator._forward_to_next_stage = AsyncMock()
+    req_state = OrchestratorRequestState(
+        request_id="req-route",
+        sampling_params_list=[SamplingParams(max_tokens=1) for _ in range(2)],
+        final_stage_id=1,
+    )
+    req_state.stage_submit_ts[0] = 1.0
+    output = SimpleNamespace(request_id="req-route", finished=True)
+
+    await orchestrator._route_output(0, 0, output, req_state, None)
+
+    orchestrator._forward_to_next_stage.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_streaming_segment_does_not_complete_final_output_stage() -> None:
+    orchestrator = object.__new__(Orchestrator)
+    orchestrator.async_chunk = True
+    orchestrator._pd_pair = None
+    orchestrator._cfg_tracker = SimpleNamespace(
+        is_companion=lambda _request_id: False,
+        has_companions=lambda _request_id: False,
+        cleanup_parent=lambda _request_id: [],
+    )
+    orchestrator.stage_pools = [SimpleNamespace(final_output=True)]
+    orchestrator.output_async_queue = asyncio.Queue()
+    orchestrator._cleanup_request_ids = AsyncMock()
+
+    req_state = OrchestratorRequestState(
+        request_id="req-segment-final-output",
+        sampling_params_list=[SamplingParams(max_tokens=1)],
+        final_stage_id=0,
+        final_output_stage_ids={0},
+    )
+    req_state.streaming.enabled = True
+    req_state.streaming.segment_finished = True
+    output = SimpleNamespace(
+        request_id=req_state.request_id,
+        finished=True,
+    )
+
+    await orchestrator._route_output(0, 0, output, req_state, None)
+
+    assert req_state.finished_final_output_stage_ids == set()
+    orchestrator._cleanup_request_ids.assert_not_awaited()
+    routed = orchestrator.output_async_queue.get_nowait()
+    assert routed.finished is False
diff --git a/tests/engine/test_output_processor.py b/tests/engine/test_output_processor.py
index 86e71fcbc..23ac601b3 100644
--- a/tests/engine/test_output_processor.py
+++ b/tests/engine/test_output_processor.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Regression tests for OmniRequestState multimodal DELTA drain and consolidation guard."""
 
+from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import numpy as np
@@ -9,10 +10,14 @@ import pytest
 import torch
 from vllm.outputs import PoolingRequestOutput
 from vllm.sampling_params import RequestOutputKind
-from vllm.v1.engine import FinishReason
+from vllm.v1.engine import EngineCoreEvent, EngineCoreEventType, FinishReason
+from vllm.v1.engine.output_processor import OutputProcessor as VLLMOutputProcessor
+from vllm.v1.metrics.stats import IterationStats, PrefillStats
 
-from vllm_omni.outputs.output_modality import OutputModalityNames
-from vllm_omni.outputs.output_processor import OmniRequestState
+from vllm_omni.engine import OmniEngineCoreOutput
+from vllm_omni.outputs import output_processor
+from vllm_omni.outputs.output_modality import OutputModality, OutputModalityNames
+from vllm_omni.outputs.output_processor import MultimodalOutputProcessor, OmniRequestState
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -56,12 +61,75 @@ def _make_state(output_kind: RequestOutputKind):
     return OmniRequestState(**_DEFAULT_STATE_KWARGS, output_kind=output_kind)
 
 
+def test_output_modality_name_uses_string_value():
+    assert str(OutputModalityNames.AUDIO) == "audio"
+
+
 def test_init_empty_dict():
     """Ensure mm_accumulated is initially empty."""
     assert _make_state(RequestOutputKind.CUMULATIVE).mm_accumulated == {}
     assert _make_state(RequestOutputKind.DELTA).mm_accumulated == {}
 
 
+def test_streaming_update_resets_native_text_metrics_for_next_segment():
+    state = _make_state(RequestOutputKind.DELTA)
+    state.native_text_stats.num_generation_tokens = 12
+    state.native_text_stats.first_token_ts = 10.0
+    state.native_text_stats.last_token_ts = 10.2
+
+    state.apply_streaming_update(
+        SimpleNamespace(
+            final=False,
+            prompt=None,
+            prompt_token_ids=[],
+            arrival_time=20.0,
+        )
+    )
+
+    assert state.native_text_stats.arrival_time == 20.0
+    assert state.native_text_stats.num_generation_tokens == 0
+    assert state.native_text_stats.first_token_ts == 0.0
+    assert state.native_text_stats.last_token_ts == 0.0
+
+
+def test_native_text_tpot_snapshot_matches_vllm_finished_metric_definition():
+    calculate = getattr(output_processor, "_mean_time_per_output_token_ms", None)
+    assert calculate is not None
+    stats = SimpleNamespace(
+        num_generation_tokens=4,
+        first_token_ts=10.0,
+        last_token_ts=10.045,
+    )
+
+    assert calculate(stats) == pytest.approx(15.0)
+
+
+def test_native_text_metrics_include_segment_generation_token_count(monkeypatch):
+    monkeypatch.setattr(VLLMOutputProcessor, "_update_stats_from_output", lambda *args, **kwargs: None)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor._native_text_metrics_by_request = {}
+    processor.lora_states = {}
+    state = _make_state(RequestOutputKind.DELTA)
+    state.is_prefilling = False
+    iteration_stats = MagicMock()
+
+    def update_native_stats(_output, _timestamp, _was_prefilling, native_stats, *_args):
+        native_stats.num_generation_tokens = 27
+        native_stats.first_token_ts = 10.0
+        native_stats.last_token_ts = 10.26
+
+    iteration_stats.update_from_output.side_effect = update_native_stats
+
+    processor._update_stats_from_output(
+        state,
+        SimpleNamespace(),
+        10.26,
+        iteration_stats,
+    )
+
+    assert processor.pop_native_text_metrics("r")["num_generation_tokens"] == 27
+
+
 def test_delta_drains_output_modality_per_step():
     """DELTA drains the mm_type key (output modality) but preserves hidden-state keys."""
     s = _make_state(RequestOutputKind.DELTA)
@@ -172,6 +240,145 @@ def test_finish_consolidation_drains_mm_delta():
     assert AUDIO not in s.mm_accumulated  # drained
 
 
+def test_delta_drains_audio_chunk_metadata_per_step():
+    s = _make_state(RequestOutputKind.DELTA)
+    segment_text = "你好"
+    segment_utf8 = torch.tensor(list(segment_text.encode("utf-8")), dtype=torch.uint8)
+
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(5),
+            "meta.duplex_epoch": torch.tensor([7], dtype=torch.int32),
+            "meta.duplex_turn_id": torch.tensor([1], dtype=torch.int32),
+            "meta.llm_output_text_utf8": segment_utf8,
+            "meta.audio_text_total_chars": torch.tensor([len(segment_text)], dtype=torch.int32),
+            "meta.tts_is_last_chunk": torch.tensor([0], dtype=torch.int32),
+        },
+        mm_type=AUDIO,
+    )
+    result1 = s.make_request_output([1], None, FinishReason.STOP, None)
+    assert result1 is not None and not isinstance(result1, PoolingRequestOutput)
+    meta1 = result1.outputs[0].multimodal_output["meta"]
+    assert bytes(meta1["llm_output_text_utf8"].tolist()).decode("utf-8") == segment_text
+
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(3),
+            "meta.duplex_epoch": torch.tensor([8], dtype=torch.int32),
+            "meta.duplex_turn_id": torch.tensor([2], dtype=torch.int32),
+            "meta.llm_output_text_utf8": segment_utf8,
+            "meta.audio_text_total_chars": torch.tensor([len(segment_text)], dtype=torch.int32),
+            "meta.tts_is_last_chunk": torch.tensor([1], dtype=torch.int32),
+        },
+        mm_type=AUDIO,
+    )
+    result2 = s.make_request_output([2], None, FinishReason.STOP, None)
+
+    assert result2 is not None and not isinstance(result2, PoolingRequestOutput)
+    meta2 = result2.outputs[0].multimodal_output["meta"]
+    assert bytes(meta2["llm_output_text_utf8"].tolist()).decode("utf-8") == segment_text
+    assert meta2["audio_text_total_chars"].tolist() == [len(segment_text)]
+    assert meta2["duplex_epoch"].tolist() == [8]
+    assert meta2["duplex_turn_id"].tolist() == [2]
+
+
+def test_cumulative_audio_replaces_chunk_metadata_per_step():
+    s = _make_state(RequestOutputKind.CUMULATIVE)
+    segment_text = "你好"
+    segment_utf8 = torch.tensor(list(segment_text.encode("utf-8")), dtype=torch.uint8)
+
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(5),
+            "meta.duplex_epoch": torch.tensor([7], dtype=torch.int32),
+            "meta.duplex_turn_id": torch.tensor([1], dtype=torch.int32),
+            "meta.llm_output_text_utf8": segment_utf8,
+            "meta.audio_text_total_chars": torch.tensor([len(segment_text)], dtype=torch.int32),
+            "meta.tts_is_last_chunk": torch.tensor([0], dtype=torch.int32),
+        },
+        mm_type=AUDIO,
+    )
+    result1 = s.make_request_output([1], None, None, None)
+    assert result1 is not None and not isinstance(result1, PoolingRequestOutput)
+    assert result1.outputs[0].multimodal_output["audio"].shape[0] == 5
+
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(3),
+            "meta.duplex_epoch": torch.tensor([8], dtype=torch.int32),
+            "meta.duplex_turn_id": torch.tensor([2], dtype=torch.int32),
+            "meta.llm_output_text_utf8": segment_utf8,
+            "meta.audio_text_total_chars": torch.tensor([len(segment_text)], dtype=torch.int32),
+            "meta.tts_is_last_chunk": torch.tensor([1], dtype=torch.int32),
+        },
+        mm_type=AUDIO,
+    )
+    result2 = s.make_request_output([2], None, None, None)
+
+    assert result2 is not None and not isinstance(result2, PoolingRequestOutput)
+    output = result2.outputs[0].multimodal_output
+    assert output["audio"].shape[0] == 8
+    meta = output["meta"]
+    assert bytes(meta["llm_output_text_utf8"].tolist()).decode("utf-8") == segment_text
+    assert meta["audio_text_total_chars"].tolist() == [len(segment_text)]
+    assert meta["duplex_epoch"].tolist() == [8]
+    assert meta["duplex_turn_id"].tolist() == [2]
+    assert meta["tts_is_last_chunk"].tolist() == [1]
+
+
+def test_delta_audio_non_final_tts_chunk_overrides_spurious_finish():
+    s = _make_state(RequestOutputKind.DELTA)
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(5),
+            "meta.tts_is_last_chunk": torch.tensor([0]),
+        },
+        mm_type=AUDIO,
+    )
+
+    result = s.make_request_output([1], None, FinishReason.STOP, None)
+
+    assert result is not None and not isinstance(result, PoolingRequestOutput)
+    assert result.finished is False
+    assert result.outputs[0].finish_reason is None
+    assert result.outputs[0].multimodal_output["meta"]["tts_is_last_chunk"].tolist() == [0]
+    assert torch.equal(result.outputs[0].multimodal_output[AUDIO], torch.ones(5))
+
+
+def test_delta_audio_final_tts_chunk_keeps_finish():
+    s = _make_state(RequestOutputKind.DELTA)
+    s.add_multimodal_tensor(
+        {
+            "model_outputs": torch.ones(5),
+            "meta.tts_is_last_chunk": torch.tensor([1]),
+        },
+        mm_type=AUDIO,
+    )
+
+    result = s.make_request_output([151645], None, FinishReason.STOP, None)
+
+    assert result is not None and not isinstance(result, PoolingRequestOutput)
+    assert result.finished is True
+    assert result.outputs[0].finish_reason == "stop"
+
+
+def test_delta_audio_non_final_tts_chunk_accepts_nested_meta():
+    s = _make_state(RequestOutputKind.DELTA)
+    s.add_multimodal_tensor(
+        {
+            AUDIO: torch.ones(5),
+            "meta": {"tts_is_last_chunk": torch.tensor([0])},
+        },
+        mm_type=AUDIO,
+    )
+
+    result = s.make_request_output([1], None, FinishReason.STOP, None)
+
+    assert result is not None and not isinstance(result, PoolingRequestOutput)
+    assert result.finished is False
+    assert result.outputs[0].multimodal_output["meta"]["tts_is_last_chunk"].tolist() == [0]
+
+
 @pytest.mark.parametrize("mm_type", [AUDIO, "hidden"])
 def test_final_only_consolidates_drainable_keys(mm_type):
     """FINAL_ONLY never drains per-step, so modality keys and hidden state
@@ -251,6 +458,127 @@ def test_no_detokenizer_make_request_output():
     assert AUDIO in result.outputs[0].multimodal_output
 
 
+def test_no_detokenizer_process_outputs_returns_nonterminal_audio_chunk(monkeypatch):
+    """Generation-stage MM-only chunks must reach the orchestrator.
+
+    StagePool registers generation requests without a per-request collector,
+    so the processor return value is the only path from Stage2 to
+    Orchestrator._handle_processed_outputs().
+    """
+    state = _make_no_detok_state(RequestOutputKind.DELTA)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor.output_modality = OutputModality.AUDIO
+    processor.request_states = {"r": state}
+    upstream_result = SimpleNamespace(request_outputs=[], reqs_to_abort=[])
+    monkeypatch.setattr(
+        VLLMOutputProcessor,
+        "process_outputs",
+        lambda *_args, **_kwargs: upstream_result,
+    )
+    engine_output = SimpleNamespace(
+        request_id="r",
+        multimodal_output={
+            "model_outputs": torch.arange(8, dtype=torch.float32),
+            "sr": torch.tensor(24000, dtype=torch.int32),
+        },
+        output_type="audio",
+        pooling_output=None,
+        new_token_ids=[],
+        finish_reason=None,
+        stop_reason=None,
+        kv_transfer_params=None,
+        routed_experts=None,
+        num_cached_tokens=0,
+    )
+
+    result = processor.process_outputs([engine_output])
+
+    assert len(result.request_outputs) == 1
+    assert result.request_outputs[0].request_id == "r"
+    assert AUDIO in result.request_outputs[0].outputs[0].multimodal_output
+
+
+def _make_mm_only_output_processor(monkeypatch):
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor.output_modality = OutputModality.AUDIO
+    processor.request_states = {"r": _make_no_detok_state(RequestOutputKind.DELTA)}
+    monkeypatch.setattr(
+        VLLMOutputProcessor,
+        "process_outputs",
+        lambda *_args, **_kwargs: SimpleNamespace(
+            request_outputs=[],
+            reqs_to_abort=[],
+        ),
+    )
+
+    def finish_request(req_state):
+        processor.request_states.pop(req_state.request_id, None)
+
+    processor._finish_request = finish_request
+    return processor
+
+
+def _audio_engine_output(*, is_segment_finished: bool, is_last_chunk: bool):
+    return SimpleNamespace(
+        request_id="r",
+        multimodal_output={
+            "model_outputs": torch.arange(8, dtype=torch.float32),
+            "meta.tts_is_last_chunk": torch.tensor([int(is_last_chunk)]),
+        },
+        output_type="audio",
+        pooling_output=None,
+        new_token_ids=[],
+        finish_reason=FinishReason.STOP,
+        stop_reason=None,
+        kv_transfer_params=None,
+        routed_experts=None,
+        num_cached_tokens=0,
+        is_segment_finished=is_segment_finished,
+    )
+
+
+def test_mm_only_segment_finish_retains_request_state_for_next_audio_chunk(monkeypatch):
+    processor = _make_mm_only_output_processor(monkeypatch)
+
+    first = processor.process_outputs([_audio_engine_output(is_segment_finished=True, is_last_chunk=False)])
+
+    assert "r" in processor.request_states
+    assert len(first.request_outputs) == 1
+    assert first.request_outputs[0].finished is False
+
+    second = processor.process_outputs([_audio_engine_output(is_segment_finished=False, is_last_chunk=True)])
+
+    assert len(second.request_outputs) == 1
+    assert second.request_outputs[0].finished is True
+    assert "r" not in processor.request_states
+
+
+def test_mm_only_nonfinal_audio_retains_state_without_segment_marker(monkeypatch):
+    processor = _make_mm_only_output_processor(monkeypatch)
+
+    first = processor.process_outputs([_audio_engine_output(is_segment_finished=False, is_last_chunk=False)])
+
+    assert "r" in processor.request_states
+    assert len(first.request_outputs) == 1
+    assert first.request_outputs[0].finished is False
+
+    second = processor.process_outputs([_audio_engine_output(is_segment_finished=False, is_last_chunk=True)])
+
+    assert len(second.request_outputs) == 1
+    assert second.request_outputs[0].finished is True
+    assert "r" not in processor.request_states
+
+
+def test_mm_only_terminal_finish_removes_request_state(monkeypatch):
+    processor = _make_mm_only_output_processor(monkeypatch)
+
+    result = processor.process_outputs([_audio_engine_output(is_segment_finished=False, is_last_chunk=True)])
+
+    assert len(result.request_outputs) == 1
+    assert result.request_outputs[0].finished is True
+    assert "r" not in processor.request_states
+
+
 def test_no_detokenizer_make_request_output_with_routed_experts():
     """make_request_output accepts the routed_experts arg that the multimodal
     output channel (_process_mm_only_outputs) passes positionally, and attaches
@@ -290,3 +618,48 @@ def test_no_detokenizer_final_only():
     result = s.make_request_output([], None, FinishReason.STOP, None)
     assert result is not None
     assert AUDIO in result.outputs[0].multimodal_output
+
+
+def test_mm_only_outputs_update_iteration_stats():
+    processor = MultimodalOutputProcessor(
+        tokenizer=None,
+        log_stats=True,
+        engine_core_output_type=AUDIO,
+    )
+    state = _make_no_detok_state(RequestOutputKind.CUMULATIVE)
+    processor.request_states[state.request_id] = state
+    processor.external_req_ids[state.external_req_id].append(state.request_id)
+
+    prefill_stats = PrefillStats()
+    prefill_stats.set(
+        num_prompt_tokens=4,
+        num_local_cached_tokens=0,
+        num_external_cached_tokens=0,
+    )
+    output = OmniEngineCoreOutput(
+        request_id=state.request_id,
+        new_token_ids=[10, 11],
+        finish_reason=FinishReason.STOP,
+        events=[
+            EngineCoreEvent(EngineCoreEventType.QUEUED, 1.0),
+            EngineCoreEvent(EngineCoreEventType.SCHEDULED, 2.0),
+        ],
+        prefill_stats=prefill_stats,
+        multimodal_output={AUDIO: torch.ones(1, 8)},
+    )
+    iteration_stats = IterationStats()
+
+    processor.process_outputs(
+        [output],
+        engine_core_timestamp=3.0,
+        iteration_stats=iteration_stats,
+    )
+
+    assert iteration_stats.num_prompt_tokens == 4
+    assert iteration_stats.num_generation_tokens == 2
+    assert len(iteration_stats.time_to_first_tokens_iter) == 1
+    assert len(iteration_stats.finished_requests) == 1
+    finished = iteration_stats.finished_requests[0]
+    assert finished.finish_reason == FinishReason.STOP
+    assert finished.num_prompt_tokens == state.prompt_len
+    assert finished.num_generation_tokens == 2
diff --git a/tests/engine/test_rpc_result_router.py b/tests/engine/test_rpc_result_router.py
new file mode 100644
index 000000000..ec983392b
--- /dev/null
+++ b/tests/engine/test_rpc_result_router.py
@@ -0,0 +1,109 @@
+import queue
+from typing import Literal
+
+import pytest
+
+from vllm_omni.engine.messages import (
+    CollectiveRPCResultMessage,
+    EngineQueueMessage,
+    ErrorMessage,
+)
+from vllm_omni.engine.rpc_result_router import RpcResultRouter
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class GenericCorrelatedResultMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["generic_correlated_result"] = "generic_correlated_result"
+    namespace: str
+    correlation_id: str
+
+    @property
+    def rpc_correlation_key(self) -> tuple[str, str]:
+        return (self.namespace, self.correlation_id)
+
+
+def _generic_result(correlation_id: str) -> GenericCorrelatedResultMessage:
+    return GenericCorrelatedResultMessage(
+        namespace="plugin",
+        correlation_id=correlation_id,
+    )
+
+
+def test_rpc_result_router_routes_out_of_order_results_by_correlation_id():
+    source: queue.Queue = queue.Queue()
+    router = RpcResultRouter(source)
+    first = router.register(("plugin", "first"))
+    second = router.register(("plugin", "second"))
+
+    source.put(_generic_result("second"))
+    source.put(_generic_result("first"))
+
+    assert first.get(timeout=1).correlation_id == "first"
+    assert second.get(timeout=1).correlation_id == "second"
+    router.close()
+
+
+def test_rpc_result_router_drops_only_the_late_result_after_unregister():
+    source: queue.Queue = queue.Queue()
+    router = RpcResultRouter(source)
+    expired = router.register(("plugin", "expired"))
+    active = router.register(("collective", "active"))
+    router.unregister(("plugin", "expired"), expired)
+
+    source.put(_generic_result("expired"))
+    source.put(
+        CollectiveRPCResultMessage(
+            rpc_id="active",
+            method="health",
+            stage_ids=[0],
+            results=["ok"],
+        )
+    )
+
+    assert active.get(timeout=1).rpc_id == "active"
+    assert expired.empty()
+    router.close()
+
+
+def test_rpc_result_router_broadcasts_fatal_errors_to_pending_waiters():
+    source: queue.Queue = queue.Queue()
+    router = RpcResultRouter(source)
+    plugin = router.register(("plugin", "one"))
+    collective = router.register(("collective", "two"))
+
+    source.put(ErrorMessage(error="orchestrator failed", fatal=True))
+
+    assert plugin.get(timeout=1).error == "orchestrator failed"
+    assert collective.get(timeout=1).error == "orchestrator failed"
+    with pytest.raises(RuntimeError, match="orchestrator failed"):
+        router.register(("plugin", "after-failure"))
+    router.close()
+
+
+def test_rpc_result_router_does_not_broadcast_uncorrelated_nonfatal_errors():
+    source: queue.Queue = queue.Queue()
+    router = RpcResultRouter(source)
+    waiter = router.register(("plugin", "active"))
+
+    source.put(ErrorMessage(error="request failed", fatal=False, request_id="other"))
+    source.put(_generic_result("active"))
+
+    assert waiter.get(timeout=1).correlation_id == "active"
+    router.close()
+
+
+def test_rpc_result_router_close_unblocks_waiters_and_stops_consumer():
+    source: queue.Queue = queue.Queue()
+    router = RpcResultRouter(source)
+    waiter = router.register(("plugin", "pending"))
+
+    router.close()
+
+    result = waiter.get(timeout=1)
+    assert isinstance(result, ErrorMessage)
+    assert result.fatal is True
+    assert result.error == "RPC result router closed"
+    assert not router._thread.is_alive()
+    with pytest.raises(RuntimeError, match="router is closed"):
+        router.register(("plugin", "after-close"))
diff --git a/tests/engine/test_single_stage_mode.py b/tests/engine/test_single_stage_mode.py
index dc06c0c8d..bde8ba490 100644
--- a/tests/engine/test_single_stage_mode.py
+++ b/tests/engine/test_single_stage_mode.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+import socket
 from contextlib import contextmanager
 from types import SimpleNamespace
 from typing import Any
@@ -11,6 +12,8 @@ import pytest
 from pytest_mock import MockerFixture
 from vllm.v1.engine.utils import EngineZmqAddresses
 
+from vllm_omni.config.config_factory import StageConfigFactory
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
 from vllm_omni.engine.stage_engine_core_client import StageEngineCoreClientBase
 from vllm_omni.engine.stage_engine_startup import (
@@ -189,6 +192,34 @@ class TestOmniMasterServerAllocation:
         output_port = int(alloc.output_bind_address.split(":")[-1])
         assert len({handshake_port, input_port, output_port}) == 3
 
+    def test_route_ports_remain_os_reserved_until_master_releases_them(self):
+        server = OmniMasterServer(master_address="127.0.0.1", master_port=15005, stage_ids=[0])
+        alloc = server.get_allocation(0)
+        ports = [
+            int(alloc.handshake_bind_address.rsplit(":", 1)[-1]),
+            int(alloc.input_bind_address.rsplit(":", 1)[-1]),
+            int(alloc.output_bind_address.rsplit(":", 1)[-1]),
+        ]
+
+        for port in ports:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                with pytest.raises(OSError):
+                    probe.bind(("127.0.0.1", port))
+
+        server.release_route_port_reservations(0, handshake=True, data=False)
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+            probe.bind(("127.0.0.1", ports[0]))
+        for port in ports[1:]:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                with pytest.raises(OSError):
+                    probe.bind(("127.0.0.1", port))
+
+        server.stop()
+
+        for port in ports[1:]:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                probe.bind(("127.0.0.1", port))
+
     def test_get_zmq_addresses_returns_bind_addresses(self):
         server = OmniMasterServer(master_address="127.0.0.1", master_port=15002, stage_ids=[0])
         alloc = server.get_allocation(0)
@@ -397,6 +428,30 @@ class TestSingleStageModeDetection:
         assert engine.single_stage_mode is False
         assert engine._single_stage_id_filter is None
 
+    def test_stage_configs_path_loads_duplex_runtime_config(self, mocker: MockerFixture):
+        duplex_session = DuplexSessionRuntimeConfig(max_sessions=2)
+        get_pipeline_config = mocker.patch(
+            "vllm_omni.engine.async_omni_engine.StageConfigFactory.get_pipeline_config",
+            return_value=None,
+        )
+        load_deploy_config = mocker.patch(
+            "vllm_omni.engine.async_omni_engine.load_deploy_config",
+            return_value=SimpleNamespace(duplex_session=duplex_session),
+        )
+
+        engine = self._make_engine_no_thread(
+            mocker,
+            stage_configs_path="/fake/duplex.yaml",
+        )
+
+        get_pipeline_config.assert_called_once_with(
+            model="fake-model",
+            trust_remote_code=False,
+            deploy_config_path="/fake/duplex.yaml",
+        )
+        load_deploy_config.assert_called_once_with("/fake/duplex.yaml")
+        assert engine.duplex_session_config is duplex_session
+
     def test_single_stage_mode_without_stage_id_has_no_filter(self, mocker: MockerFixture):
         engine = self._make_engine_no_thread(
             mocker,
@@ -422,6 +477,89 @@ class TestSingleStageModeDetection:
         assert not hasattr(engine, "_omni_master_server")
 
 
+# ---------------------------------------------------------------------------
+# Endpoint-restriction resolution vs. tri-state trust_remote_code (#5495)
+# ---------------------------------------------------------------------------
+
+
+class TestEndpointRestrictionsTrustRemoteCode:
+    """Regression tests for issue #5495.
+
+    ``AsyncOmniEngine.__init__`` takes ``trust_remote_code: bool | None`` where
+    ``None`` means "not specified" (the CLI default, since ``--trust-remote-code``
+    is ``store_true`` and its absence is mapped to ``None``). Endpoint-restriction
+    resolution eagerly loads the HF config via vLLM's ``get_config``, which does
+    ``trust_remote_code |= ...`` internally and raises ``TypeError`` on ``None``.
+    That used to be swallowed, leaving ``endpoint_restrictions`` empty so
+    ``/v1/completions`` was never shut down and the request crashed stage-1.
+
+    ``__init__`` must collapse the ``None`` "not specified" case to ``False`` at
+    the ``get_pipeline_config`` call site so the restriction is still computed.
+    """
+
+    @pytest.fixture(autouse=True)
+    def clear_config_factory_caches(self):
+        """Isolate the process-wide ``functools.cache`` on StageConfigFactory.
+
+        ``get_hf_config`` / ``try_infer_model_type`` cache per-model results for
+        the whole process. These tests patch ``get_config`` with a synthetic
+        Qwen3-Omni config for ``"fake-model"``; without clearing on teardown the
+        synthetic entry would leak to later tests in the same worker (after the
+        mock is restored), making the suite order-dependent. Clear both before
+        and after.
+        """
+        StageConfigFactory.get_hf_config.cache_clear()
+        StageConfigFactory.try_infer_model_type.cache_clear()
+        yield
+        StageConfigFactory.get_hf_config.cache_clear()
+        StageConfigFactory.try_infer_model_type.cache_clear()
+
+    def _make_engine_no_thread(self, mocker: MockerFixture, **kwargs: Any) -> AsyncOmniEngine:
+        mocker.patch.object(
+            AsyncOmniEngine,
+            "_resolve_stage_configs",
+            return_value=("/fake/path", [_make_stage_cfg(0)]),
+        )
+        mocker.patch.object(AsyncOmniEngine, "_bootstrap_orchestrator")
+        mocker.patch("threading.Thread")
+        mocker.patch("concurrent.futures.Future")
+        return AsyncOmniEngine(model="fake-model", **kwargs)
+
+    @staticmethod
+    def _install_qwen3_omni_config(mocker: MockerFixture) -> None:
+        """Patch get_config to a thinker+talker config, mirroring vLLM's
+        ``trust_remote_code |= ...`` (raises TypeError on None)."""
+        from transformers import Qwen3OmniMoeConfig
+
+        def fake_get_config(model, trust_remote_code, **_):
+            trust_remote_code |= False  # TypeError if None reaches here
+            return Qwen3OmniMoeConfig(enable_audio_output=True)
+
+        mocker.patch("vllm_omni.config.config_factory.get_config", side_effect=fake_get_config)
+
+    @pytest.mark.parametrize("trc_kwargs", [{}, {"trust_remote_code": False}, {"trust_remote_code": True}])
+    def test_completions_restriction_survives(self, mocker: MockerFixture, trc_kwargs: dict):
+        """COMPLETIONS restriction is computed regardless of how (or whether)
+        trust_remote_code is passed — including the unset case that resolves to
+        the engine's ``None`` default."""
+        from vllm_omni.config.endpoint_policy import OmniServingCapability
+
+        self._install_qwen3_omni_config(mocker)
+        engine = self._make_engine_no_thread(mocker, **trc_kwargs)
+        assert any(r.capability is OmniServingCapability.COMPLETIONS for r in engine.endpoint_restrictions), (
+            f"COMPLETIONS restriction dropped for {trc_kwargs or 'unset (None default)'}"
+        )
+
+    def test_unset_trust_remote_code_defaults_to_none(self, mocker: MockerFixture):
+        """Guard the tri-state premise: the engine keeps ``None`` (not ``False``)
+        when trust_remote_code is not passed, so the call-site coercion is what
+        prevents the crash."""
+        import inspect
+
+        default = inspect.signature(AsyncOmniEngine.__init__).parameters["trust_remote_code"].default
+        assert default is None
+
+
 # ---------------------------------------------------------------------------
 # AsyncOmniEngine single-stage initialization paths
 # ---------------------------------------------------------------------------
@@ -450,7 +588,7 @@ class TestSingleStageInitialization:
         monkeypatch = pytest.MonkeyPatch()
         monkeypatch.setattr(
             runtime_mod,
-            "extract_stage_metadata",
+            "extract_legacy_stage_metadata",
             lambda cfg: SimpleNamespace(
                 stage_id=cfg.stage_id,
                 stage_type=getattr(cfg, "stage_type", "llm"),
@@ -477,7 +615,7 @@ class TestSingleStageInitialization:
         monkeypatch = pytest.MonkeyPatch()
         monkeypatch.setattr(
             runtime_mod,
-            "extract_stage_metadata",
+            "extract_legacy_stage_metadata",
             lambda cfg: SimpleNamespace(
                 stage_id=cfg.stage_id,
                 stage_type=getattr(cfg, "stage_type", "llm"),
@@ -550,7 +688,7 @@ class TestSingleStageInitialization:
         monkeypatch = pytest.MonkeyPatch()
         monkeypatch.setattr(
             runtime_mod,
-            "extract_stage_metadata",
+            "extract_legacy_stage_metadata",
             lambda cfg: SimpleNamespace(
                 stage_id=cfg.stage_id,
                 stage_type="llm",
@@ -609,7 +747,7 @@ class TestSingleStageInitialization:
         monkeypatch = pytest.MonkeyPatch()
         monkeypatch.setattr(
             runtime_mod,
-            "extract_stage_metadata",
+            "extract_legacy_stage_metadata",
             lambda cfg: SimpleNamespace(
                 stage_id=cfg.stage_id,
                 stage_type="diffusion",
@@ -724,6 +862,7 @@ class TestSingleStageReplicaInitialization:
             single_stage_id_filter=None,
             omni_master_address="127.0.0.1",
             omni_master_port=26000,
+            log_stats=True,
         )
         runtime._omni_master_server = mocker.Mock(spec=OmniMasterServer)
         runtime._omni_master_server.get_stage_config.return_value = {"stage_id": 1, "stage_type": "llm"}
@@ -757,10 +896,17 @@ class TestSingleStageReplicaInitialization:
         sentinel_client = SimpleNamespace()
 
         mock_connect = mocker.patch.object(runtime_mod, "connect_remote_engine_cores", side_effect=_fake_connect)
+        client_kwargs: dict[str, Any] = {}
+
+        def _capture_make_async_mp_client(**kwargs):
+            client_kwargs.update(kwargs)
+            events.append("attach")
+            return sentinel_client
+
         mocker.patch.object(
             StageEngineCoreClientBase,
             "make_async_mp_client",
-            side_effect=lambda **_: (events.append("attach"), sentinel_client)[1],
+            side_effect=_capture_make_async_mp_client,
         )
 
         result = runtime._initialize_remote_replica(plan, stage_init_timeout=60)
@@ -770,6 +916,7 @@ class TestSingleStageReplicaInitialization:
         assert mock_connect.call_args.kwargs["vllm_config"].parallel_config.data_parallel_size_local == 0
         assert mock_connect.call_args.kwargs["stage_id"] == 1
         assert mock_connect.call_args.kwargs["replica_id"] == 0
+        assert client_kwargs["log_stats"] is True
         assert events == ["enter", "exit", "attach"]
 
     def test_initialize_llm_replica_remote_missing_registered_stage_config_raises(self, mocker: MockerFixture):
@@ -943,7 +1090,7 @@ class TestSingleStageReplicaInitialization:
         plan = _make_diffusion_plan(1, stage_id=1, launch_mode="remote").replicas[0]
         sentinel_client = SimpleNamespace()
 
-        mocker.patch.object(runtime_mod, "extract_stage_metadata", return_value=remote_metadata)
+        mocker.patch.object(runtime_mod, "extract_legacy_stage_metadata", return_value=remote_metadata)
         mock_connect = mocker.patch.object(runtime_mod, "connect_remote_diffusion_proc", side_effect=_fake_connect)
         mock_from_addresses = mocker.patch(
             "vllm_omni.diffusion.stage_diffusion_client.StageDiffusionClient.from_addresses",
diff --git a/tests/engine/test_stage_engine_args.py b/tests/engine/test_stage_engine_args.py
new file mode 100644
index 000000000..75660cbc7
--- /dev/null
+++ b/tests/engine/test_stage_engine_args.py
@@ -0,0 +1,510 @@
+from __future__ import annotations
+
+import copy
+import sys
+import types
+from dataclasses import fields, replace
+from pathlib import Path
+
+import pytest
+from pydantic.fields import FieldInfo
+
+from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
+from vllm_omni.config.stage_config import (
+    DeployConfig,
+    PipelineConfig,
+    StageDeployConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+    StageType,
+    build_stage_runtime_overrides,
+    load_deploy_config,
+    merge_pipeline_deploy,
+)
+from vllm_omni.diffusion.data import AttentionConfig, OmniDiffusionConfig
+from vllm_omni.engine import stage_init_utils
+from vllm_omni.engine.arg_utils import OmniEngineArgs
+from vllm_omni.engine.stage_init_utils import (
+    build_engine_args_dict,
+    build_engine_args_dict_from_omni_stage_config,
+    build_legacy_engine_args_dict,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_DEPLOY_DIR = Path(__file__).parents[2] / "vllm_omni" / "deploy"
+
+
+def _effective_backend_values(config_cls: type, engine_args: dict) -> dict[str, object]:
+    backend_fields = fields(config_cls)
+    backend_field_names = {backend_field.name for backend_field in backend_fields}
+    backend_config = config_cls(
+        **{name: copy.deepcopy(value) for name, value in engine_args.items() if name in backend_field_names}
+    )
+    effective_values: dict[str, object] = {}
+    for backend_field in backend_fields:
+        value = getattr(backend_config, backend_field.name)
+        if isinstance(value, FieldInfo):
+            value = value.get_default(call_default_factory=True)
+        effective_values[backend_field.name] = value
+    return effective_values
+
+
+_LLM_BACKEND_FIELDS = frozenset(field.name for field in fields(OmniEngineArgs))
+_DIFFUSION_BACKEND_FIELDS = frozenset(field.name for field in fields(OmniDiffusionConfig))
+
+
+@pytest.fixture(autouse=True)
+def _stable_engine_arg_environment(monkeypatch, tmp_path):
+    from vllm_omni import platforms
+
+    monkeypatch.delenv("VLLM_USE_FLASHINFER_MOE_FP16", raising=False)
+    xcodec_model = tmp_path / "xcodec-model"
+    xcodec_model.mkdir()
+    monkeypatch.setenv("XCODEC1_PATH", str(xcodec_model))
+    platform = platforms.current_omni_platform
+    monkeypatch.setattr(platform, "device_name", "cpu", raising=False)
+    monkeypatch.setattr(platform, "device_type", "cpu", raising=False)
+    monkeypatch.setattr(platform, "is_rocm", lambda: False)
+    monkeypatch.setattr(
+        OmniDiffusionConfig,
+        "_resolve_master_port",
+        lambda config: config.master_port or 29500,
+    )
+
+    def _resolve_test_worker(engine_args):
+        worker_type = engine_args.get("worker_type")
+        if worker_type is not None and engine_args.get("worker_cls") in (None, "auto"):
+            engine_args["worker_cls"] = f"test.{worker_type}.Worker"
+
+    monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", _resolve_test_worker)
+
+
+def _engine_arg_inputs(tmp_path: Path) -> tuple[PipelineConfig, DeployConfig, str]:
+    parent_model = tmp_path / "parent-model"
+    stage_model = tmp_path / "stage-model"
+    diffusion_model = tmp_path / "diffusion-model"
+    for root in (parent_model, stage_model, diffusion_model):
+        root.mkdir()
+    (stage_model / "ar-model").mkdir()
+    (stage_model / "ar-tokenizer").mkdir()
+
+    pipeline = PipelineConfig(
+        model_type="typed-engine-args",
+        model_arch="PipelineModel",
+        stages=(
+            StagePipelineConfig(
+                stage_id=0,
+                model_stage="thinker",
+                execution_type=StageExecutionType.LLM_AR,
+                requires_multimodal_data=True,
+                hf_config_name="thinker_config",
+                engine_output_type="hidden_states",
+                model_arch="Qwen3OmniMoeForConditionalGeneration",
+                model_subdir="ar-model",
+                tokenizer_subdir="ar-tokenizer",
+                retains_state_across_chunks=True,
+                async_chunk_process_next_stage_input_func="operator.add",
+            ),
+            StagePipelineConfig(
+                stage_id=1,
+                model_stage="talker",
+                execution_type=StageExecutionType.LLM_GENERATION,
+                input_sources=(0,),
+                engine_output_type="audio_tokens",
+            ),
+            StagePipelineConfig(
+                stage_id=2,
+                model_stage="dit",
+                execution_type=StageExecutionType.DIFFUSION,
+                input_sources=(1,),
+                final_output=True,
+                final_output_type="image",
+                model_arch="TypedDiffusionPipeline",
+            ),
+        ),
+    )
+    deploy = DeployConfig(
+        async_chunk=True,
+        trust_remote_code=True,
+        dtype="float16",
+        distributed_executor_backend="mp",
+        stages=[
+            StageDeployConfig(
+                stage_id=0,
+                tensor_parallel_size=2,
+                max_num_seqs=8,
+                default_sampling_params={"extra_args": {"voice": "test"}},
+                engine_extras={
+                    "model": str(stage_model),
+                    "attention_backend": "FLASHINFER",
+                    "hf_overrides": {"rope_scaling": {"factor": 2}},
+                    "limit_mm_per_prompt": {"audio": 1},
+                    "logits_processors": ["test.custom.LogitsProcessor"],
+                    "kv_cache_memory_bytes": 1024,
+                    "omni_kv_config": {"need_send_cache": True},
+                    "max_cudagraph_capture_size": 0,
+                    "worker_cls": "test.custom.Worker",
+                },
+            ),
+            StageDeployConfig(
+                stage_id=1,
+                max_num_seqs=4,
+            ),
+            StageDeployConfig(
+                stage_id=2,
+                tensor_parallel_size=2,
+                vae_parallel_mode="spatial_shard_height",
+                diffusion_attention_config={
+                    "default": {"backend": "FLASH_ATTN"},
+                    "per_role": {"cross": {"backend": "TORCH_SDPA"}},
+                },
+                engine_extras={
+                    "model": str(diffusion_model),
+                    "engine_backend": "test.diffusion.Engine",
+                    "enable_session_state_manager": True,
+                },
+            ),
+        ],
+    )
+    return pipeline, deploy, str(parent_model)
+
+
+def _legacy_and_typed_stages(
+    pipeline: PipelineConfig,
+    deploy: DeployConfig,
+    model: str,
+    cli_overrides: dict[str, object] | None = None,
+):
+    resolved_cli_overrides = {"model": model, **(cli_overrides or {})}
+    legacy_stage_configs = merge_pipeline_deploy(
+        pipeline,
+        copy.deepcopy(deploy),
+    )
+    for stage in legacy_stage_configs:
+        stage.runtime_overrides = build_stage_runtime_overrides(
+            stage.stage_id,
+            resolved_cli_overrides,
+        )
+    legacy_stages = [stage.to_omegaconf() for stage in legacy_stage_configs]
+    omni_config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=copy.deepcopy(deploy),
+        cli_overrides=resolved_cli_overrides,
+    )
+    return legacy_stages, omni_config
+
+
+def test_typed_llm_engine_args_preserve_legacy_adapter_behavior(tmp_path):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
+    connector_spec = {"name": "SharedMemoryConnector", "extra": {"mode": "test"}}
+    cli_tokenizer = "/external/tokenizer"
+
+    typed_args_by_stage = {}
+    for stage_id in (0, 1):
+        legacy_args = build_legacy_engine_args_dict(
+            legacy_stages[stage_id],
+            model,
+            stage_connector_spec=connector_spec,
+            cli_tokenizer=cli_tokenizer,
+        )
+        typed_args = build_engine_args_dict_from_omni_stage_config(
+            omni_config.stage_by_id(stage_id),
+            model,
+            stage_connector_spec=connector_spec,
+            cli_tokenizer=cli_tokenizer,
+        )
+        typed_args_by_stage[stage_id] = typed_args
+
+        assert {name: typed_args[name] for name in legacy_args} == legacy_args
+
+    thinker_args = typed_args_by_stage[0]
+    assert thinker_args["model"] == str(tmp_path / "stage-model" / "ar-model")
+    assert thinker_args["tokenizer"] == str(tmp_path / "stage-model" / "ar-tokenizer")
+    assert thinker_args["stage_id"] == 0
+    assert thinker_args["stage_connector_spec"] == connector_spec
+    assert thinker_args["has_sampling_extra_args"] is True
+    assert thinker_args["omni_kv_config"] == {"need_send_cache": True}
+    assert thinker_args["worker_cls"] == "test.custom.Worker"
+    assert thinker_args["attention_backend"] == "FLASHINFER"
+    assert thinker_args["trust_remote_code"] is True
+    assert thinker_args["dtype"] == "float16"
+    assert thinker_args["distributed_executor_backend"] == "mp"
+    assert thinker_args["tensor_parallel_size"] == 2
+    assert thinker_args["hf_overrides"] == {"rope_scaling": {"factor": 2}}
+    assert thinker_args["limit_mm_per_prompt"] == {"audio": 1}
+    assert thinker_args["logits_processors"] == ["test.custom.LogitsProcessor"]
+    assert thinker_args["retains_state_across_chunks"] is True
+    assert thinker_args["kv_cache_memory_bytes"] == 1024
+    assert thinker_args["max_cudagraph_capture_size"] == 0
+
+    talker_args = typed_args_by_stage[1]
+    assert talker_args["model"] == model
+    assert talker_args["tokenizer"] == cli_tokenizer
+    assert talker_args["worker_cls"] == "test.generation.Worker"
+    assert talker_args["disable_hybrid_kv_cache_manager"] is True
+    assert talker_args["enable_prefix_caching"] is False
+
+
+def test_typed_diffusion_engine_args_use_structured_diffusion_config(tmp_path):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[2], model)
+    typed_args = build_engine_args_dict_from_omni_stage_config(
+        omni_config.stage_by_id(2),
+        model,
+    )
+
+    assert typed_args["stage_id"] == legacy_args["stage_id"] == 2
+    assert typed_args["model"] == legacy_args["model"] == str(tmp_path / "diffusion-model")
+    assert omni_config.stage_by_id(2).diffusion_config.model == str(tmp_path / "diffusion-model")
+    assert typed_args["model_stage"] == legacy_args["model_stage"] == "dit"
+    assert typed_args["model_arch"] == legacy_args["model_arch"] == "TypedDiffusionPipeline"
+    assert typed_args["model_class_name"] == legacy_args["model_class_name"] == "TypedDiffusionPipeline"
+    assert typed_args["engine_backend"] == legacy_args["engine_backend"] == "test.diffusion.Engine"
+    assert typed_args["enable_session_state_manager"] is legacy_args["enable_session_state_manager"] is True
+    assert typed_args["parallel_config"]["tensor_parallel_size"] == 2
+    assert typed_args["parallel_config"]["vae_parallel_mode"] == "spatial_shard_height"
+    assert isinstance(typed_args["diffusion_attention_config"], AttentionConfig)
+    assert typed_args["diffusion_attention_config"].default.backend == "FLASH_ATTN"
+    assert typed_args["diffusion_attention_config"].per_role["cross"].backend == "TORCH_SDPA"
+
+
+def test_typed_engine_args_preserve_explicit_backend_default_overrides(tmp_path):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    deploy.enable_prefix_caching = False
+    deploy.enable_chunked_prefill = False
+    thinker_deploy = deploy.stages[0]
+    thinker_deploy.gpu_memory_utilization = 0.75
+    thinker_deploy.disable_hybrid_kv_cache_manager = False
+    thinker_deploy.async_scheduling = False
+    legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
+    typed_args = build_engine_args_dict_from_omni_stage_config(
+        omni_config.stage_by_id(0),
+        model,
+    )
+    expected = {
+        "gpu_memory_utilization": 0.75,
+        "enable_prefix_caching": False,
+        "disable_hybrid_kv_cache_manager": False,
+        "max_num_seqs": 8,
+        "enable_chunked_prefill": False,
+        "async_scheduling": False,
+    }
+
+    assert {name: legacy_args[name] for name in expected} == expected
+    assert {name: typed_args[name] for name in expected} == expected
+
+
+@pytest.mark.parametrize("stage_scoped", [False, True], ids=["global", "stage-scoped"])
+def test_typed_engine_args_preserve_inherited_model_and_load_cli_fields(tmp_path, stage_scoped):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    expected = {
+        "revision": "model-rev",
+        "tokenizer_revision": "tokenizer-rev",
+        "code_revision": "code-rev",
+        "seed": 123,
+        "download_dir": str(tmp_path / "downloads"),
+    }
+    cli_overrides = {f"stage_0_{name}" if stage_scoped else name: value for name, value in expected.items()}
+    legacy_stages, omni_config = _legacy_and_typed_stages(
+        pipeline,
+        deploy,
+        model,
+        cli_overrides,
+    )
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
+    typed_args = build_engine_args_dict_from_omni_stage_config(
+        omni_config.stage_by_id(0),
+        model,
+    )
+
+    assert {name: legacy_args[name] for name in expected} == expected
+    assert {name: typed_args[name] for name in expected} == expected
+
+
+def test_typed_engine_args_preserve_deploy_subdirectory_precedence(tmp_path):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    stage_model = tmp_path / "stage-model"
+    (stage_model / "override-model").mkdir()
+    (stage_model / "override-tokenizer").mkdir()
+    deploy.stages[0].engine_extras.update(
+        {
+            "model_subdir": "override-model",
+            "tokenizer_subdir": "override-tokenizer",
+        }
+    )
+    legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
+
+    typed_stage = omni_config.stage_by_id(0)
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
+    typed_args = build_engine_args_dict_from_omni_stage_config(typed_stage, model)
+
+    assert typed_stage.model_config.model_subdir == "override-model"
+    assert typed_stage.model_config.tokenizer_subdir == "override-tokenizer"
+    assert typed_args["model"] == legacy_args["model"] == str(stage_model / "override-model")
+    assert typed_args["tokenizer"] == legacy_args["tokenizer"] == str(stage_model / "override-tokenizer")
+
+
+@pytest.mark.parametrize(
+    ("cli_overrides", "expected"),
+    [
+        ({}, {"need_recv_cache": True}),
+        (
+            {"stage_0_omni_kv_config": {"need_send_cache": False}},
+            {"need_send_cache": False},
+        ),
+    ],
+    ids=["topology-over-deploy", "cli-over-topology"],
+)
+def test_typed_engine_args_preserve_legacy_omni_kv_precedence(tmp_path, cli_overrides, expected):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    thinker = replace(
+        pipeline.stages[0],
+        omni_kv_config={"need_recv_cache": True},
+    )
+    pipeline = replace(pipeline, stages=(thinker, *pipeline.stages[1:]))
+    legacy_stages, omni_config = _legacy_and_typed_stages(
+        pipeline,
+        deploy,
+        model,
+        cli_overrides,
+    )
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
+    typed_stage = omni_config.stage_by_id(0)
+    typed_args = build_engine_args_dict_from_omni_stage_config(typed_stage, model)
+
+    assert typed_stage.connector_config.omni_kv_config == expected
+    assert typed_args["omni_kv_config"] == legacy_args["omni_kv_config"] == expected
+
+
+def test_build_engine_args_dict_preserves_legacy_api(tmp_path):
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    legacy_stages, _ = _legacy_and_typed_stages(pipeline, deploy, model)
+    connector_spec = {"name": "SharedMemoryConnector", "extra": {}}
+
+    compatibility_args = build_engine_args_dict(
+        copy.deepcopy(legacy_stages[0]),
+        model,
+        stage_connector_spec=connector_spec,
+        cli_tokenizer="/external/tokenizer",
+    )
+    explicitly_legacy_args = build_legacy_engine_args_dict(
+        copy.deepcopy(legacy_stages[0]),
+        model,
+        stage_connector_spec=connector_spec,
+        cli_tokenizer="/external/tokenizer",
+    )
+
+    assert compatibility_args == explicitly_legacy_args
+
+
+def test_legacy_engine_args_drop_none_tp_without_mutating_stage_config():
+    stage_config = types.SimpleNamespace(
+        stage_id=0,
+        stage_type="llm",
+        engine_args={"tensor_parallel_size": None},
+        default_sampling_params={},
+    )
+
+    engine_args = build_legacy_engine_args_dict(
+        stage_config,
+        model="test-model",
+    )
+
+    assert "tensor_parallel_size" not in engine_args
+    assert stage_config.engine_args == {"tensor_parallel_size": None}
+
+
+def test_typed_engine_args_own_rocm_attention_default(monkeypatch, tmp_path):
+    from vllm_omni import platforms
+
+    pipeline, deploy, model = _engine_arg_inputs(tmp_path)
+    legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
+    monkeypatch.setattr(platforms.current_omni_platform, "is_rocm", lambda: True)
+    aiter_module = types.ModuleType("vllm._aiter_ops")
+    setattr(
+        aiter_module,
+        "rocm_aiter_ops",
+        types.SimpleNamespace(is_enabled=lambda: False),
+    )
+    monkeypatch.setitem(sys.modules, "vllm._aiter_ops", aiter_module)
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[1], model)
+    typed_args = build_engine_args_dict_from_omni_stage_config(
+        omni_config.stage_by_id(1),
+        model,
+    )
+
+    assert "attention_backend" not in legacy_args
+    assert typed_args["attention_backend"] == "TRITON_ATTN"
+
+
+def test_typed_ming_image_engine_args_defer_diffusion_batch_default():
+    pipeline = resolve_pipeline_config("ming_flash_omni_image")
+    assert pipeline is not None
+    deploy = load_deploy_config(_DEPLOY_DIR / "ming_flash_omni_image.yaml")
+    legacy_stages, omni_config = _legacy_and_typed_stages(
+        pipeline,
+        deploy,
+        model="/tmp",
+    )
+
+    legacy_args = build_legacy_engine_args_dict(legacy_stages[1], model="/tmp")
+    typed_args = build_engine_args_dict_from_omni_stage_config(
+        omni_config.stage_by_id(1),
+        model="/tmp",
+    )
+    typed_backend_args = {name: value for name, value in typed_args.items() if name in _DIFFUSION_BACKEND_FIELDS}
+
+    assert "max_num_seqs" not in legacy_args
+    assert "max_num_seqs" not in typed_args
+    assert OmniDiffusionConfig(**typed_backend_args).max_num_seqs == 1
+
+
+@pytest.mark.parametrize("model_type", sorted(OMNI_PIPELINES))
+def test_typed_engine_args_match_current_registry_backend_semantics(model_type):
+    pipeline = resolve_pipeline_config(model_type)
+    if pipeline is None:
+        pytest.skip(f"Pipeline {model_type!r} requires an HF config to resolve")
+
+    deploy = (
+        load_deploy_config(_DEPLOY_DIR / pipeline.default_deploy_config_name)
+        if pipeline.default_deploy_config_name is not None
+        else DeployConfig()
+    )
+    legacy_stages, omni_config = _legacy_and_typed_stages(
+        pipeline,
+        deploy,
+        model="/tmp",
+    )
+
+    for legacy_stage in legacy_stages:
+        stage_id = legacy_stage.stage_id
+        legacy_args = build_legacy_engine_args_dict(legacy_stage, model="/tmp")
+        typed_args = build_engine_args_dict_from_omni_stage_config(
+            omni_config.stage_by_id(stage_id),
+            model="/tmp",
+        )
+        if legacy_stage.stage_type == StageType.DIFFUSION:
+            backend_fields = _DIFFUSION_BACKEND_FIELDS
+            backend_config_cls = OmniDiffusionConfig
+        else:
+            backend_fields = _LLM_BACKEND_FIELDS
+            backend_config_cls = OmniEngineArgs
+
+        missing_fields = (legacy_args.keys() & backend_fields) - typed_args.keys()
+        assert not missing_fields, f"{model_type} stage {stage_id} lost backend fields: {sorted(missing_fields)}"
+
+        legacy_effective_args = _effective_backend_values(backend_config_cls, legacy_args)
+        typed_effective_args = _effective_backend_values(backend_config_cls, typed_args)
+        assert typed_effective_args == legacy_effective_args, (
+            f"{model_type} stage {stage_id} changed effective backend arguments"
+        )
diff --git a/tests/engine/test_stage_engine_core_proc.py b/tests/engine/test_stage_engine_core_proc.py
new file mode 100644
index 000000000..a7104b14d
--- /dev/null
+++ b/tests/engine/test_stage_engine_core_proc.py
@@ -0,0 +1,28 @@
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from vllm.v1.engine.core import EngineCoreProc
+
+from vllm_omni.engine.stage_engine_core_proc import StageEngineCoreProc
+
+
+def test_preprocess_add_request_preserves_omni_fields():
+    engine = StageEngineCoreProc.__new__(StageEngineCoreProc)
+    request = SimpleNamespace(
+        request_id="internal",
+        external_req_id="external",
+        additional_information={"conditioning": "payload"},
+    )
+    scheduler_request = SimpleNamespace()
+
+    with patch.object(
+        EngineCoreProc,
+        "preprocess_add_request",
+        return_value=(scheduler_request, 3),
+    ):
+        result, current_wave = engine.preprocess_add_request(request)
+
+    assert result is scheduler_request
+    assert current_wave == 3
+    assert result.external_req_id == "external"
+    assert result.additional_information == {"conditioning": "payload"}
diff --git a/tests/engine/test_stage_metadata.py b/tests/engine/test_stage_metadata.py
new file mode 100644
index 000000000..0b21f7573
--- /dev/null
+++ b/tests/engine/test_stage_metadata.py
@@ -0,0 +1,173 @@
+import copy
+import operator
+
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.stage_config import (
+    DeployConfig,
+    PipelineConfig,
+    StageDeployConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+    merge_pipeline_deploy,
+)
+from vllm_omni.engine.stage_init_utils import (
+    extract_legacy_stage_metadata,
+    extract_stage_metadata,
+    extract_stage_metadata_from_omni_stage_config,
+)
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _metadata_inputs() -> tuple[PipelineConfig, DeployConfig]:
+    pipeline = PipelineConfig(
+        model_type="metadata-test",
+        stages=(
+            StagePipelineConfig(
+                stage_id=0,
+                model_stage="thinker",
+                execution_type=StageExecutionType.LLM_AR,
+                owns_tokenizer=True,
+                requires_multimodal_data=True,
+                engine_output_type="token_ids",
+                custom_process_input_func="operator.add",
+                prompt_expand_func="operator.mul",
+            ),
+            StagePipelineConfig(
+                stage_id=1,
+                model_stage="talker",
+                execution_type=StageExecutionType.LLM_GENERATION,
+                input_sources=(0,),
+                engine_output_type="audio_tokens",
+                custom_process_input_func="operator.sub",
+                sync_process_input_func="operator.floordiv",
+            ),
+            StagePipelineConfig(
+                stage_id=2,
+                model_stage="dit",
+                execution_type=StageExecutionType.DIFFUSION,
+                input_sources=(1,),
+                final_output=True,
+                final_output_type="image",
+                custom_process_input_func="operator.neg",
+                cfg_kv_collect_func="operator.concat",
+            ),
+        ),
+    )
+    deploy = DeployConfig(
+        async_chunk=False,
+        stages=[
+            StageDeployConfig(
+                stage_id=0,
+                devices="0",
+                env={"STAGE": "thinker"},
+                default_sampling_params={"temperature": 0.25},
+            ),
+            StageDeployConfig(
+                stage_id=1,
+                devices="1,2",
+                num_replicas=2,
+                env={"STAGE": "talker"},
+                default_sampling_params={"temperature": 0.75},
+            ),
+            StageDeployConfig(
+                stage_id=2,
+                devices="3",
+                env={"STAGE": "dit"},
+                default_sampling_params={"seed": 7},
+            ),
+        ],
+    )
+    return pipeline, deploy
+
+
+def test_extract_stage_metadata_matches_legacy_projection():
+    pipeline, deploy = _metadata_inputs()
+    omni_config = VllmOmniConfig.from_pipeline_config(
+        pipeline,
+        user_deploy_config=copy.deepcopy(deploy),
+    )
+    legacy_configs = [
+        stage.to_omegaconf()
+        for stage in merge_pipeline_deploy(
+            pipeline,
+            copy.deepcopy(deploy),
+        )
+    ]
+
+    parity_fields = (
+        "stage_id",
+        "stage_type",
+        "engine_output_type",
+        "is_comprehension",
+        "requires_multimodal_data",
+        "engine_input_source",
+        "final_output",
+        "final_output_type",
+        "custom_process_input_func",
+        "model_stage",
+        "prompt_expand_func",
+        "cfg_kv_collect_func",
+    )
+    for legacy_config in legacy_configs:
+        stage_id = legacy_config.stage_id
+        omni_stage_config = omni_config.stage_by_id(stage_id)
+        structured = extract_stage_metadata_from_omni_stage_config(omni_stage_config)
+        legacy = extract_legacy_stage_metadata(legacy_config)
+
+        assert {field: getattr(structured, field) for field in parity_fields} == {
+            field: getattr(legacy, field) for field in parity_fields
+        }
+        assert type(structured.default_sampling_params) is type(legacy.default_sampling_params)
+        assert structured.runtime_cfg is omni_stage_config.runtime_config
+        for runtime_field in ("devices", "num_replicas", "env"):
+            assert getattr(structured.runtime_cfg, runtime_field) == getattr(legacy.runtime_cfg, runtime_field)
+
+    thinker = extract_stage_metadata_from_omni_stage_config(omni_config.stage_by_id(0))
+    talker = extract_stage_metadata_from_omni_stage_config(omni_config.stage_by_id(1))
+    diffusion = extract_stage_metadata_from_omni_stage_config(omni_config.stage_by_id(2))
+
+    assert isinstance(thinker.default_sampling_params, SamplingParams)
+    assert thinker.default_sampling_params.temperature == 0.25
+    assert thinker.custom_process_input_func is operator.add
+    assert thinker.prompt_expand_func is operator.mul
+
+    assert isinstance(talker.default_sampling_params, SamplingParams)
+    assert talker.default_sampling_params.temperature == 0.75
+    assert talker.custom_process_input_func is operator.floordiv
+
+    assert isinstance(diffusion.default_sampling_params, OmniDiffusionSamplingParams)
+    assert diffusion.default_sampling_params.seed == 7
+    assert diffusion.custom_process_input_func is operator.neg
+    assert diffusion.cfg_kv_collect_func is operator.concat
+
+
+def test_extract_stage_metadata_preserves_legacy_one_argument_api():
+    pipeline, deploy = _metadata_inputs()
+    legacy_config = merge_pipeline_deploy(
+        pipeline,
+        deploy,
+    )[0].to_omegaconf()
+
+    metadata = extract_stage_metadata(legacy_config)
+
+    assert metadata.stage_id == 0
+    assert metadata.model_stage == "thinker"
+    assert metadata.custom_process_input_func is operator.add
+
+
+def test_extract_stage_metadata_defaults_missing_engine_input_source():
+    pipeline, deploy = _metadata_inputs()
+    legacy_config = merge_pipeline_deploy(
+        pipeline,
+        deploy,
+    )[0].to_omegaconf()
+    del legacy_config["engine_input_source"]
+
+    metadata = extract_stage_metadata(legacy_config)
+
+    assert metadata.engine_input_source == []
diff --git a/tests/entrypoints/openai/test_duplex_protocol.py b/tests/entrypoints/openai/test_duplex_protocol.py
new file mode 100644
index 000000000..3c3666026
--- /dev/null
+++ b/tests/entrypoints/openai/test_duplex_protocol.py
@@ -0,0 +1,474 @@
+import asyncio
+import json
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexCapabilities,
+    DuplexOverlapPolicy,
+    DuplexSession,
+    DuplexSessionConfig,
+    DuplexSessionRegistry,
+    DuplexTurnController,
+    DuplexTurnEventType,
+    DuplexTurnState,
+    ResponseCreateOptions,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_session import (
+    NativeRealtimeSessionProtocol,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_state import RealtimeStateOwner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_realtime_state_owner_uses_explicit_bindings_not_dynamic_attribute_proxy():
+    assert "__getattr__" not in RealtimeStateOwner.__dict__
+    assert "__setattr__" not in RealtimeStateOwner.__dict__
+
+
+class _ProtocolWebSocket:
+    def __init__(self, *events: dict[str, object]) -> None:
+        self._events = asyncio.Queue()
+        for event in events:
+            self._events.put_nowait(json.dumps(event))
+
+    async def receive_text(self) -> str:
+        return await self._events.get()
+
+
+def test_duplex_session_commits_text_and_audio_as_one_turn():
+    registry = DuplexSessionRegistry()
+    session = registry.create(DuplexSessionConfig(model="test-model"))
+
+    session.append_text("hello")
+    session.append_audio("YWJj", fmt="wav", sample_rate_hz=16000)
+    committed = session.commit_user_input()
+
+    assert committed is not None
+    assert committed.turn_id == 0
+    assert committed.input_commit_seq == 1
+    assert committed.epoch == 0
+    assert len(session.history) == 1
+    content = session.history[0]["content"]
+    assert isinstance(content, list)
+    assert content[0] == {"type": "text", "text": "hello"}
+    assert content[1]["type"] == "audio_url"
+    assert content[1]["audio_url"]["url"] == "data:audio/wav;base64,YWJj"
+    assert session.turn_state == DuplexTurnState.USER_COMMITTED
+
+
+def test_response_options_apply_to_one_response_without_mutating_session_defaults():
+    session = DuplexSession(
+        session_id="sid-response-options",
+        config=DuplexSessionConfig(instructions="base", voice="base-voice", max_tokens=64),
+    )
+    session.reserve_response_options(
+        ResponseCreateOptions(
+            instructions="one response",
+            voice="override-voice",
+            max_tokens=8,
+        )
+    )
+
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    session.begin_response()
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    assert session.response_config.instructions == "one response"
+    assert session.response_config.voice == "override-voice"
+    assert session.response_config.max_tokens == 8
+
+    session.end_response()
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    assert session.config.max_tokens == 64
+
+
+def test_response_options_cannot_overwrite_an_unconsumed_reservation():
+    session = DuplexSession(
+        session_id="sid-response-options-pending",
+        config=DuplexSessionConfig(instructions="base"),
+    )
+    session.reserve_response_options(ResponseCreateOptions(instructions="first"))
+
+    with pytest.raises(RuntimeError, match="already reserved"):
+        session.reserve_response_options(ResponseCreateOptions(instructions="second"))
+
+    session.begin_response()
+    assert session.response_config.instructions == "first"
+
+
+def test_response_options_cannot_be_reserved_while_response_is_active():
+    session = DuplexSession(
+        session_id="sid-response-options-active",
+        config=DuplexSessionConfig(instructions="base"),
+    )
+    session.begin_response()
+
+    with pytest.raises(RuntimeError, match="active"):
+        session.reserve_response_options(ResponseCreateOptions(instructions="too late"))
+
+
+def test_realtime_model_name_does_not_implicitly_enable_native_duplex():
+    protocol = NativeRealtimeSessionProtocol({})
+
+    event = protocol._session_create_from_realtime({"model": "openbmb/MiniCPM-o-4_5"})
+
+    assert "minicpmo45_native_duplex" not in event["session"]["extra_body"]
+
+
+def test_realtime_explicit_native_duplex_flag_is_preserved():
+    protocol = NativeRealtimeSessionProtocol({})
+
+    event = protocol._session_create_from_realtime(
+        {
+            "model": "openbmb/MiniCPM-o-4_5",
+            "extra_body": {"minicpmo45_native_duplex": True},
+        }
+    )
+
+    assert event["session"]["extra_body"]["minicpmo45_native_duplex"] is True
+
+
+def test_realtime_explicit_query_native_duplex_flag_is_available_before_autostart():
+    protocol = NativeRealtimeSessionProtocol(
+        {
+            "model": "openbmb/MiniCPM-o-4_5",
+            "minicpmo45_native_duplex": "1",
+        }
+    )
+
+    event = json.loads(asyncio.run(protocol.receive_internal_event_text(None)))
+
+    assert event["type"] == "session.create"
+    assert event["session"]["extra_body"]["minicpmo45_native_duplex"] is True
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_heartbeat_and_event_ack_translate_without_session_autostart():
+    protocol = NativeRealtimeSessionProtocol(
+        {
+            "model": "openbmb/MiniCPM-o-4_5",
+            "minicpmo45_native_duplex": "1",
+        }
+    )
+
+    resume = await protocol._to_duplex_event(
+        {
+            "type": "session.resume",
+            "session_id": "sid-resume",
+            "incarnation": 3,
+            "resume_token": "opaque-token",
+            "last_received_server_event_seq": 17,
+        }
+    )
+    heartbeat = await protocol._to_duplex_event(
+        {
+            "type": "session.heartbeat",
+            "event_id": "event-heartbeat",
+        }
+    )
+    event_ack = await protocol._to_duplex_event(
+        {
+            "type": "session.event_ack",
+            "server_event_seq": 19,
+        }
+    )
+
+    assert resume == {
+        "type": "session.resume",
+        "session_id": "sid-resume",
+        "incarnation": 3,
+        "resume_token": "opaque-token",
+        "last_received_server_event_seq": 17,
+    }
+    assert heartbeat == {
+        "type": "session.heartbeat",
+        "event_id": "event-heartbeat",
+    }
+    assert event_ack == {
+        "type": "session.event_ack",
+        "server_event_seq": 19,
+    }
+    assert protocol._opened is False
+
+    wire_protocol = NativeRealtimeSessionProtocol({})
+    first_wire_event = json.loads(
+        await wire_protocol.receive_internal_event_text(
+            _ProtocolWebSocket(
+                {
+                    "type": "session.resume",
+                    "session_id": "sid-resume",
+                    "incarnation": 3,
+                    "resume_token": "opaque-token",
+                    "last_received_server_event_seq": 17,
+                }
+            )
+        )
+    )
+
+    assert first_wire_event["type"] == "session.resume"
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_query_suppresses_model_autostart_on_same_url():
+    protocol = NativeRealtimeSessionProtocol(
+        {
+            "model": "openbmb/MiniCPM-o-4_5",
+            "minicpmo45_native_duplex": "1",
+            "resume": "1",
+        }
+    )
+    resume = {
+        "type": "session.resume",
+        "session_id": "sid-resume",
+        "incarnation": 3,
+        "resume_token": "opaque-token",
+        "last_received_server_event_seq": 17,
+    }
+
+    first_wire_event = json.loads(await protocol.receive_internal_event_text(_ProtocolWebSocket(resume)))
+
+    assert first_wire_event == resume
+    assert protocol._autostarted_default_session is False
+
+
+def test_realtime_projects_resume_lifecycle_events_without_duplex_prefix():
+    protocol = NativeRealtimeSessionProtocol({})
+
+    created = protocol.encode_outbound_event(
+        {
+            "type": "session.created",
+            "session": {"id": "sid-resume"},
+            "incarnation": 3,
+            "attachment_generation": 1,
+            "resume_token": "first-token",
+        }
+    )[0]
+    resumed = protocol.encode_outbound_event(
+        {
+            "type": "session.resumed",
+            "session_id": "sid-resume",
+            "incarnation": 3,
+            "attachment_generation": 2,
+            "resume_token": "second-token",
+        }
+    )[0]
+    heartbeat = protocol.encode_outbound_event(
+        {
+            "type": "session.heartbeat_ack",
+            "session_id": "sid-resume",
+        }
+    )[0]
+    replaced = protocol.encode_outbound_event(
+        {
+            "type": "session.replaced",
+            "session_id": "sid-resume",
+            "attachment_generation": 1,
+        }
+    )[0]
+    resync = protocol.encode_outbound_event(
+        {
+            "type": "session.resync_required",
+            "session_id": "sid-resume",
+            "reason": "journal_gap",
+        }
+    )[0]
+
+    assert created["type"] == "session.created"
+    assert created["incarnation"] == 3
+    assert created["attachment_generation"] == 1
+    assert created["resume_token"] == "first-token"
+    assert resumed["type"] == "session.resumed"
+    assert resumed["resume_token"] == "second-token"
+    assert heartbeat["type"] == "session.heartbeat_ack"
+    assert replaced["type"] == "session.replaced"
+    assert resync == {
+        "type": "session.resync_required",
+        "session_id": "sid-resume",
+        "reason": "journal_gap",
+        "event_id": resync["event_id"],
+    }
+
+
+def test_duplex_session_registry_advances_incarnation_when_id_is_reused():
+    registry = DuplexSessionRegistry()
+
+    first = registry.create(session_id="reused-session")
+    registry.close(first.session_id)
+    second = registry.create(session_id="reused-session")
+
+    assert first.incarnation == 0
+    assert second.incarnation == 1
+
+
+def test_native_input_commit_does_not_advance_model_turn_identity():
+    session = DuplexSession(
+        session_id="sid-model-owned-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+
+    first = session.commit_native_audio_input(transcript="first chunk")
+    second = session.commit_native_audio_input(transcript="second chunk")
+
+    assert session.input_commit_seq == 2
+    assert first.input_commit_seq == 1
+    assert second.input_commit_seq == 2
+    assert first.turn_id == second.turn_id == session.turn_id == 0
+
+
+def test_duplex_session_owns_response_and_overlap_identity():
+    session = DuplexSession(session_id="sid-state-owner", config=DuplexSessionConfig())
+
+    response_id = session.begin_response()
+    session.accumulate_overlap_speech(320)
+    session.accumulate_overlap_speech(180)
+    session.end_response()
+
+    assert session.active_response_id is None
+    assert session.last_response_id == response_id
+    assert session.overlap_speech_ms == 500
+    assert session.reset_overlap_speech() == 500
+    assert session.overlap_speech_ms == 0
+
+
+def test_duplex_session_composes_single_owner_ledgers():
+    session = DuplexSession(session_id="sid-ledgers", config=DuplexSessionConfig())
+
+    session.append_text("hello")
+    session.bind_request("req-1")
+    response_id = session.begin_response(turn_id=3)
+    session.mark_audio_sent(duration_ms=240)
+
+    assert not hasattr(session, "input")
+    assert not hasattr(session, "response")
+    assert not hasattr(session, "playback_ledger")
+    assert not hasattr(session, "conversation")
+    assert session.pending_text == ("hello",)
+    assert session.active_request_id == "req-1"
+    assert session.active_response_id == response_id
+    assert session.active_response_turn_id == 3
+    assert session.playback.sent_ms == 240
+
+    try:
+        session.playback.sent_ms = 480
+    except (AttributeError, TypeError):
+        pass
+    else:
+        raise AssertionError("playback view must be immutable")
+
+
+def test_duplex_barge_in_advances_epoch_and_drops_uncommitted_assistant_text():
+    registry = DuplexSessionRegistry()
+    session = registry.create()
+    response_id = session.begin_response()
+    session.bind_request("chatcmpl-duplex-test")
+    session.append_assistant_text("unplayed answer")
+
+    new_epoch = session.barge_in()
+
+    assert response_id is not None
+    assert new_epoch == 1
+    assert session.epoch == 1
+    assert session.active_request_id is None
+    assert session.active_response_id is None
+    assert session.assistant_text_buffer == ()
+    assert session.history == ()
+    assert session.turn_state == DuplexTurnState.BARGE_IN
+
+
+def test_duplex_playback_ack_tracks_committed_cursor_separately():
+    registry = DuplexSessionRegistry()
+    session = registry.create()
+    session.mark_audio_sent(duration_ms=10_000)
+
+    session.acknowledge_playback(played_ms=2_000)
+
+    assert session.playback.generated_ms == 10_000
+    assert session.playback.sent_ms == 10_000
+    assert session.playback.played_ms == 2_000
+    assert session.playback.committed_ms == 2_000
+
+
+def test_duplex_history_commit_uses_audio_text_alignment_marks():
+    registry = DuplexSessionRegistry()
+    session = registry.create()
+    session.begin_response()
+
+    session.append_assistant_text("hello ")
+    session.mark_audio_sent(duration_ms=1_000, text_chars=6)
+    session.append_assistant_text("world")
+    session.mark_audio_sent(duration_ms=2_000, text_chars=11)
+    session.acknowledge_playback(played_ms=1_200, committed_ms=1_200)
+
+    committed = session.end_response(commit_text=True)
+
+    assert committed == {"role": "assistant", "content": "hello w"}
+
+
+def test_turn_controller_accepts_external_signal_source():
+    registry = DuplexSessionRegistry()
+    session = registry.create()
+    controller = DuplexTurnController()
+
+    event = controller.signal(session, DuplexTurnEventType.USER_STARTED.value)
+
+    assert event["type"] == "turn.event"
+    assert event["event"] == "user_started"
+    assert event["turn_state"] == "user_speaking"
+    assert session.turn_state == DuplexTurnState.USER_SPEAKING
+
+
+def test_duplex_capabilities_do_not_claim_core_kv_or_input_append():
+    registry = DuplexSessionRegistry()
+    session = registry.create()
+    caps = session.capabilities.as_dict()
+
+    assert caps["implementation_level"] == "serving_session_adapter"
+    assert caps["supports_kv_lease"] is False
+    assert caps["supports_input_append"] is False
+    assert caps["supports_reencode_context"] is True
+    assert caps["adapter_patterns"] == ["chunk_group_append"]
+    assert "turn_commit_only" in caps["input_modes"]
+    assert "client_event" in caps["signal_sources"]
+
+
+def test_minicpmo_native_capabilities_separate_model_state_from_core_kv_lease():
+    caps = DuplexCapabilities.minicpmo45_native(max_sessions=2).as_dict()
+
+    assert caps["implementation_level"] == "model_native_duplex"
+    assert caps["supports_input_append"] is True
+    assert caps["input_modes"] == ["append_audio_chunk"]
+    assert caps["adapter_patterns"] == ["scheduler_data_plane"]
+    assert caps["supports_model_internal_state"] is True
+    assert caps["requires_model_runner_kv"] is True
+    assert caps["requires_native_stage_role"] is True
+    assert caps["supports_kv_lease"] is False
+    assert caps["supports_core_kv_lease"] is False
+    assert caps["supports_stage_resumption"] is True
+    assert caps["supports_scheduler_native_append"] is False
+    assert caps["supports_core_resumable_request"] is True
+    assert caps["supports_stage_connector_handoff"] is True
+    assert caps["supports_audio_truncate"] is True
+    assert caps["supports_barge_in"] is False
+    assert caps["target_barge_in_latency_ms"] is None
+    assert caps["supports_multi_session"] is True
+    assert caps["supports_multi_session_same_replica"] is True
+    assert caps["supports_session_lease"] is True
+    assert caps["supports_session_resume"] is True
+    assert caps["session_admission_mode"] == "engine_managed"
+    assert caps["stage_handoff_transport"] == "scheduler_data_plane"
+
+
+def test_minicpmo_native_capabilities_do_not_overclaim_single_session_deployment():
+    caps = DuplexCapabilities.minicpmo45_native(max_sessions=1).as_dict()
+
+    assert caps["supports_multi_session"] is False
+    assert caps["supports_multi_session_same_replica"] is False
+
+
+def test_duplex_overlap_policy_defaults_and_invalid_values_to_listen_only():
+    assert DuplexSessionConfig().overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert DuplexSessionConfig._normalize_overlap_policy("not-a-policy") == DuplexOverlapPolicy.LISTEN_ONLY.value
diff --git a/tests/entrypoints/openai/test_duplex_session_attachment.py b/tests/entrypoints/openai/test_duplex_session_attachment.py
new file mode 100644
index 000000000..24a6f5365
--- /dev/null
+++ b/tests/entrypoints/openai/test_duplex_session_attachment.py
@@ -0,0 +1,387 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.openai.session_attachment import (
+    DuplexEventJournal,
+    DuplexJournalGapError,
+    DuplexJournalOverflowError,
+    DuplexResumeCredential,
+    DuplexSessionAttachmentRegistry,
+    InvalidResumeTokenError,
+    ResumeToken,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Clock:
+    def __init__(self) -> None:
+        self.value = 0.0
+
+    def __call__(self) -> float:
+        return self.value
+
+    def advance(self, seconds: float) -> None:
+        self.value += seconds
+
+
+def _decoded_token_bytes(token: ResumeToken) -> bytes:
+    padding = "=" * (-len(token.plaintext) % 4)
+    return base64.urlsafe_b64decode(token.plaintext + padding)
+
+
+def test_resume_credential_uses_256_bit_token_digest_and_redacted_repr(monkeypatch) -> None:
+    token = ResumeToken.generate()
+    credential = DuplexResumeCredential.from_token(token)
+    calls = []
+
+    import vllm_omni.experimental.fullduplex.openai.session_attachment as attachment_module
+
+    original_compare = attachment_module.hmac.compare_digest
+
+    def recording_compare(left, right):
+        calls.append((left, right))
+        return original_compare(left, right)
+
+    monkeypatch.setattr(attachment_module.hmac, "compare_digest", recording_compare)
+
+    assert len(_decoded_token_bytes(token)) == 32
+    assert credential.verify(token.plaintext) is True
+    assert credential.verify("invalid-token") is False
+    assert len(calls) == 2
+    assert token.plaintext not in repr(token)
+    assert token.plaintext not in repr(credential)
+    assert not hasattr(credential, "plaintext")
+    assert len(credential.token_digest) == 32
+
+
+def test_resume_credential_rotation_revokes_old_token() -> None:
+    first = ResumeToken.generate()
+    credential = DuplexResumeCredential.from_token(first)
+
+    second = credential.rotate()
+
+    assert credential.verify(first.plaintext) is False
+    assert credential.verify(second.plaintext) is True
+    assert second.plaintext != first.plaintext
+
+
+def test_event_journal_sequences_acknowledges_and_replays_exact_payloads() -> None:
+    clock = _Clock()
+    journal = DuplexEventJournal(max_bytes=4096, ttl_s=60.0, clock=clock)
+
+    first = journal.record({"type": "response.audio.delta", "delta": "AAAA"})
+    second = journal.record({"type": "response.done", "response_id": "resp-1"})
+
+    assert first.sequence == 1
+    assert second.sequence == 2
+    assert first.payload["server_event_seq"] == 1
+    assert second.payload["server_event_seq"] == 2
+    assert first.encoded_bytes == len(
+        json.dumps(dict(first.payload), separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    )
+    assert [entry.sequence for entry in journal.replay_after(0)] == [1, 2]
+    assert journal.acknowledge(1) == 1
+    assert [entry.sequence for entry in journal.replay_after(1)] == [2]
+    assert journal.acknowledge(1) == 0
+
+
+def test_event_journal_ttl_pruning_reports_replay_gap() -> None:
+    clock = _Clock()
+    journal = DuplexEventJournal(max_bytes=4096, ttl_s=5.0, clock=clock)
+    journal.record({"type": "one"})
+    clock.advance(3.0)
+    journal.record({"type": "two"})
+    clock.advance(3.0)
+
+    assert journal.prune() == 1
+    with pytest.raises(DuplexJournalGapError, match="older than retained"):
+        journal.replay_after(0)
+    assert [entry.payload["type"] for entry in journal.replay_after(1)] == ["two"]
+
+
+def test_event_journal_overflow_is_explicit_and_does_not_evict_silently() -> None:
+    clock = _Clock()
+    journal = DuplexEventJournal(max_bytes=100, ttl_s=60.0, clock=clock)
+    first = journal.record({"type": "small", "value": "x"})
+
+    with pytest.raises(DuplexJournalOverflowError, match="byte limit"):
+        journal.record({"type": "large", "value": "x" * 200})
+
+    assert journal.overflowed is True
+    assert journal.retained_bytes == first.encoded_bytes
+    with pytest.raises(DuplexJournalGapError, match="overflowed"):
+        journal.replay_after(0)
+
+
+@pytest.mark.asyncio
+async def test_registry_resume_rotates_token_replays_and_atomically_replaces_attachment() -> None:
+    clock = _Clock()
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+        clock=clock,
+    )
+    sends_a = []
+    closes_a = []
+    sends_b = []
+    closes_b = []
+
+    async def send_a(payload):
+        sends_a.append(payload)
+
+    async def close_a(reason):
+        closes_a.append(reason)
+
+    async def send_b(payload):
+        sends_b.append(payload)
+
+    async def close_b(reason):
+        closes_b.append(reason)
+
+    created = await registry.create("sid", incarnation=2, send=send_a, close=close_a)
+    await registry.send_event("sid", {"type": "event-1"})
+    await registry.send_event("sid", {"type": "event-2"})
+
+    resumed = await registry.resume(
+        "sid",
+        incarnation=2,
+        resume_token=created.resume_token.plaintext,
+        last_received_server_event_seq=1,
+        send=send_b,
+        close=close_b,
+    )
+
+    assert resumed.attachment_generation == 2
+    assert resumed.resume_token.plaintext != created.resume_token.plaintext
+    assert [entry.sequence for entry in resumed.replay_entries] == [2]
+    assert resumed.replaced_attachment is not None
+    assert resumed.replaced_attachment.generation == 1
+    assert await registry.is_current_attachment("sid", created.attachment_generation) is False
+    assert await registry.is_current_attachment("sid", resumed.attachment_generation) is True
+    assert await registry.detach("sid", attachment_generation=1) is False
+    assert await registry.detach("sid", attachment_generation=2) is True
+    assert [(payload["type"], payload["server_event_seq"]) for payload in sends_a] == [
+        ("event-1", 1),
+        ("event-2", 2),
+    ]
+    assert closes_a == [] and sends_b == [] and closes_b == []
+
+
+@pytest.mark.asyncio
+async def test_registry_resume_sends_activation_then_replay_before_new_live_events() -> None:
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+    )
+    wire = []
+    activation_started = asyncio.Event()
+    release_activation = asyncio.Event()
+
+    async def old_send(payload):
+        del payload
+
+    async def close(reason):
+        del reason
+
+    async def new_send(payload):
+        wire.append(payload["type"])
+        if payload["type"] == "session.resumed":
+            activation_started.set()
+            await release_activation.wait()
+
+    created = await registry.create("sid-order", incarnation=0, send=old_send, close=close)
+    await registry.detach("sid-order", attachment_generation=1)
+    await registry.send_event("sid-order", {"type": "replayed"})
+    resume_task = asyncio.create_task(
+        registry.resume(
+            "sid-order",
+            incarnation=0,
+            resume_token=created.resume_token.plaintext,
+            last_received_server_event_seq=0,
+            send=new_send,
+            close=close,
+            activation_payload_factory=lambda _token, _generation: {"type": "session.resumed"},
+        )
+    )
+    await activation_started.wait()
+    live_task = asyncio.create_task(registry.send_event("sid-order", {"type": "live"}))
+
+    release_activation.set()
+    await asyncio.gather(resume_task, live_task)
+
+    assert wire == ["session.resumed", "replayed", "live"]
+
+
+@pytest.mark.asyncio
+async def test_registry_resume_delivery_failure_keeps_one_shot_old_token_recovery() -> None:
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+    )
+
+    async def send(payload):
+        del payload
+
+    async def failing_send(payload):
+        del payload
+        raise RuntimeError("transport lost before rotated token arrived")
+
+    async def close(reason):
+        del reason
+
+    created = await registry.create("sid-recovery", incarnation=0, send=send, close=close)
+    await registry.detach("sid-recovery", attachment_generation=1)
+
+    with pytest.raises(RuntimeError, match="transport lost"):
+        await registry.resume(
+            "sid-recovery",
+            incarnation=0,
+            resume_token=created.resume_token.plaintext,
+            last_received_server_event_seq=0,
+            send=failing_send,
+            close=close,
+            activation_payload_factory=lambda token, generation: {
+                "type": "session.resumed",
+                "resume_token": token.plaintext,
+                "attachment_generation": generation,
+            },
+        )
+
+    recovered = await registry.resume(
+        "sid-recovery",
+        incarnation=0,
+        resume_token=created.resume_token.plaintext,
+        last_received_server_event_seq=0,
+        send=send,
+        close=close,
+    )
+
+    assert recovered.attachment_generation == 3
+    with pytest.raises(InvalidResumeTokenError):
+        await registry.resume(
+            "sid-recovery",
+            incarnation=0,
+            resume_token=created.resume_token.plaintext,
+            last_received_server_event_seq=0,
+            send=send,
+            close=close,
+        )
+
+
+@pytest.mark.asyncio
+async def test_registry_concurrent_resume_allows_exactly_one_rotated_token_winner() -> None:
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+    )
+
+    async def send(payload):
+        del payload
+
+    async def close(reason):
+        del reason
+
+    created = await registry.create("sid-race", incarnation=0, send=send, close=close)
+
+    async def attempt():
+        try:
+            return await registry.resume(
+                "sid-race",
+                incarnation=0,
+                resume_token=created.resume_token.plaintext,
+                last_received_server_event_seq=0,
+                send=send,
+                close=close,
+            )
+        except InvalidResumeTokenError as exc:
+            return exc
+
+    results = await asyncio.gather(attempt(), attempt())
+
+    assert sum(not isinstance(result, Exception) for result in results) == 1
+    assert sum(isinstance(result, InvalidResumeTokenError) for result in results) == 1
+
+
+@pytest.mark.asyncio
+async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> None:
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+    )
+
+    async def send(payload):
+        del payload
+
+    async def close(reason):
+        del reason
+
+    created_a = await registry.create("sid-a", incarnation=1, send=send, close=close)
+    created_b = await registry.create("sid-b", incarnation=4, send=send, close=close)
+    await registry.detach("sid-a", attachment_generation=1)
+    await registry.detach("sid-b", attachment_generation=1)
+    await registry.send_event("sid-a", {"type": "a-only"})
+    await registry.send_event("sid-b", {"type": "b-only"})
+
+    resumed_a = await registry.resume(
+        "sid-a",
+        incarnation=1,
+        resume_token=created_a.resume_token.plaintext,
+        last_received_server_event_seq=0,
+        send=send,
+        close=close,
+    )
+    resumed_b = await registry.resume(
+        "sid-b",
+        incarnation=4,
+        resume_token=created_b.resume_token.plaintext,
+        last_received_server_event_seq=0,
+        send=send,
+        close=close,
+    )
+
+    assert [entry.payload["type"] for entry in resumed_a.replay_entries] == ["a-only"]
+    assert [entry.payload["type"] for entry in resumed_b.replay_entries] == ["b-only"]
+    with pytest.raises(ValueError, match="incarnation mismatch"):
+        await registry.resume(
+            "sid-a",
+            incarnation=2,
+            resume_token=resumed_a.resume_token.plaintext,
+            last_received_server_event_seq=1,
+            send=send,
+            close=close,
+        )
+
+
+@pytest.mark.asyncio
+async def test_registry_repr_never_contains_plaintext_tokens() -> None:
+    registry = DuplexSessionAttachmentRegistry(
+        replay_ttl_s=60.0,
+        replay_max_bytes_per_session=4096,
+    )
+
+    async def send(payload):
+        del payload
+
+    async def close(reason):
+        del reason
+
+    created = await registry.create("sid-repr", incarnation=0, send=send, close=close)
+    await registry.detach("sid-repr", attachment_generation=1)
+    entry = await registry.send_event(
+        "sid-repr",
+        {"type": "session.resumed", "resume_token": created.resume_token.plaintext},
+    )
+
+    assert entry is not None
+    assert created.resume_token.plaintext not in repr(created)
+    assert created.resume_token.plaintext not in repr(entry)
+    assert created.resume_token.plaintext not in repr(registry)
diff --git a/tests/entrypoints/openai_api/test_audex_serving_guards.py b/tests/entrypoints/openai_api/test_audex_serving_guards.py
new file mode 100644
index 000000000..343eb9816
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_audex_serving_guards.py
@@ -0,0 +1,376 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Serving-layer regressions for the Audex zero-codec-token contract.
+
+A zero-codec-token (or phase-invalid TTA) request reaches the serving layer
+as a stream whose only audio payloads are zero-size tensors. The streaming
+generator must not turn that into a header-only/empty successful stream: the
+raw-bytes generator raises (before any WAV header), and the SSE wrapper
+surfaces ``speech.audio.error`` instead of ``speech.audio.done``. The
+contract covers both audex pipelines (``audex`` TTS and ``audex_tta``).
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.entrypoints.openai.serving_speech import (
+    _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES,
+    OmniOpenAIServingSpeech,
+)
+
+
+def _serving(model_type: str = "audex") -> OmniOpenAIServingSpeech:
+    serving = OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+    serving._tts_model_type = model_type
+    serving._mark_ref_audio_artifact_ready_for_request = lambda request_id: None
+    serving._discard_ref_audio_artifact_warmup = lambda request_id: None
+    return serving
+
+
+def _result(audio: torch.Tensor) -> SimpleNamespace:
+    return SimpleNamespace(multimodal_output={"model_outputs": audio, "sr": torch.tensor(16000, dtype=torch.int32)})
+
+
+async def _gen(*results):
+    for res in results:
+        yield res
+
+
+async def _collect(chunks):
+    out = []
+    async for chunk in chunks:
+        out.append(chunk)
+    return out
+
+
+def test_no_audio_guard_covers_both_audex_pipelines():
+    # The non-streaming CreateAudio guard keys off the same constant; pin
+    # its membership so neither pipeline regresses to empty-200 responses.
+    assert _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES == {"audex", "audex_tta"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("model_type", ["audex", "audex_tta"])
+async def test_raw_stream_raises_on_empty_audio_before_any_header(model_type):
+    serving = _serving(model_type)
+    chunks = serving._generate_audio_chunks(
+        _gen(_result(torch.empty(0)), _result(torch.empty(0))),
+        request_id="req-empty",
+        response_format="wav",
+    )
+    with pytest.raises(ValueError, match="no audio"):
+        await _collect(chunks)
+
+
+@pytest.mark.asyncio
+async def test_raw_stream_yields_audio_normally_when_non_empty():
+    serving = _serving()
+    chunks = serving._generate_audio_chunks(
+        _gen(_result(torch.zeros(320)), _result(torch.empty(0))),
+        request_id="req-ok",
+        response_format="wav",
+    )
+    collected = await _collect(chunks)
+    # WAV header + one PCM chunk; the trailing empty chunk is skipped silently.
+    assert len(collected) == 2
+    assert collected[0][:4] == b"RIFF"
+    assert len(collected[1]) == 320 * 2  # int16 PCM
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("model_type", ["audex", "audex_tta"])
+async def test_sse_stream_emits_error_not_done_on_empty_audio(model_type):
+    serving = _serving(model_type)
+    events = serving._generate_audio_sse_events(
+        _gen(_result(torch.empty(0))),
+        request_id="req-empty",
+        response_format="pcm",
+    )
+    collected = await _collect(events)
+    assert any("speech.audio.error" in event for event in collected)
+    assert not any("speech.audio.done" in event for event in collected)
+
+
+@pytest.mark.asyncio
+async def test_non_audex_empty_chunks_keep_legacy_behavior():
+    """Other models keep their existing semantics (no new rejection)."""
+    serving = _serving(model_type="qwen3_tts")
+    chunks = serving._generate_audio_chunks(
+        _gen(_result(torch.empty(0))),
+        request_id="req-other",
+        response_format="pcm",
+    )
+    await _collect(chunks)  # must not raise
+
+
+# ---------------------------------------------------------------- CFG serving surface
+
+import re  # noqa: E402
+
+from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest  # noqa: E402
+from vllm_omni.entrypoints.openai.tts_adapters.audex import AudexAdapter  # noqa: E402
+
+
+def _adapter() -> AudexAdapter:
+    return AudexAdapter.__new__(AudexAdapter)
+
+
+def _speech_request(**extra_params) -> OpenAICreateSpeechRequest:
+    payload = {"model": "audex", "input": "Hello world."}
+    if extra_params:
+        payload["extra_params"] = extra_params
+    return OpenAICreateSpeechRequest(**payload)
+
+
+class _MarkerTokenizer:
+    """Special markers count one token; words and punctuation split."""
+
+    _TOKEN_RE = re.compile(r"<unk>|<\|[^|]*\|>|<[a-z_]+>|\w+|[^\w\s]")
+
+    def encode(self, text: str) -> list[int]:
+        return [0] * len(self._TOKEN_RE.findall(text))
+
+
+class TestAudexCfgValidation:
+    def test_no_cfg_scale_accepted(self):
+        assert _adapter().validate(_speech_request()) is None
+
+    @pytest.mark.parametrize("scale", [1.0, 1.5, 3.0, 10.0])
+    def test_in_range_scale_accepted(self, scale):
+        assert _adapter().validate(_speech_request(cfg_scale=scale)) is None
+
+    @pytest.mark.parametrize("scale", [0.5, 0.0, -1.0, 10.5, "big"])
+    def test_out_of_range_or_malformed_scale_rejected(self, scale):
+        error = _adapter().validate(_speech_request(cfg_scale=scale))
+        assert error is not None and "cfg_scale" in error
+
+    def test_explicit_null_scale_treated_as_absent(self):
+        assert _adapter().validate(_speech_request(cfg_scale=None)) is None
+        serving = TestAudexCfgInjection()._serving_with_fake_tokenizer()
+        params = SimpleNamespace(extra_args={"cfg_scale": None})
+        out = serving._inject_audex_cfg_pair_args("req-1", {"prompt": "p"}, params)
+        assert out.extra_args == {}
+
+    @pytest.mark.parametrize("key", ["cfg_role", "cfg_pair_id", "cfg_null_prompt"])
+    def test_internal_cfg_keys_rejected(self, key):
+        error = _adapter().validate(_speech_request(**{key: "x"}))
+        assert error is not None and key in error
+
+
+class TestAudexCfgInjection:
+    def _serving_with_fake_tokenizer(self):
+        serving = _serving()
+        serving._get_audex_tokenizer = lambda: _MarkerTokenizer()
+        return serving
+
+    def _cond_prompt(self, text: str = "Hello world.") -> str:
+        from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+        return build_cond_prompt(text)
+
+    def test_no_extra_args_is_untouched(self):
+        serving = self._serving_with_fake_tokenizer()
+        params = SimpleNamespace(extra_args=None)
+        out = serving._inject_audex_cfg_pair_args("req-1", {"prompt": self._cond_prompt()}, params)
+        assert out.extra_args is None
+        assert params.extra_args is None
+
+    def test_scale_one_leaves_params_byte_identical(self):
+        serving = self._serving_with_fake_tokenizer()
+        params = SimpleNamespace(extra_args={"cfg_scale": 1.0})
+        out = serving._inject_audex_cfg_pair_args("req-1", {"prompt": self._cond_prompt()}, params)
+        assert out.extra_args == {}
+
+    def test_guided_request_gains_pair_contract(self):
+        serving = self._serving_with_fake_tokenizer()
+        params = SimpleNamespace(extra_args={"cfg_scale": 1.5})
+        cond = self._cond_prompt("Some transcription text here.")
+        out = serving._inject_audex_cfg_pair_args("req-42", {"prompt": cond}, params)
+
+        extra = out.extra_args
+        assert extra["cfg_scale"] == 1.5
+        assert extra["cfg_role"] == "cond"
+        assert extra["cfg_pair_id"] == "req-42"
+        null_prompt = extra["cfg_null_prompt"]
+        assert "<unk>" in null_prompt
+        assert "Some transcription" not in null_prompt
+        tok = _MarkerTokenizer()
+        assert len(tok.encode(null_prompt)) == len(tok.encode(cond))
+
+    def test_missing_text_prompt_raises(self):
+        serving = self._serving_with_fake_tokenizer()
+        params = SimpleNamespace(extra_args={"cfg_scale": 1.5})
+        with pytest.raises(ValueError, match="adapter-built text prompt"):
+            serving._inject_audex_cfg_pair_args("req-1", {"prompt_token_ids": [1]}, params)
+
+    def test_injection_never_mutates_input_params(self):
+        """The input may be the engine's SHARED default params (review P2):
+        pair state must land only on the returned clone."""
+        serving = self._serving_with_fake_tokenizer()
+        shared = SimpleNamespace(extra_args={"cfg_scale": 1.5}, temperature=0.1)
+        out = serving._inject_audex_cfg_pair_args("req-7", {"prompt": self._cond_prompt()}, shared)
+        assert out is not shared
+        assert shared.extra_args == {"cfg_scale": 1.5}
+        assert shared.temperature == 0.1
+        assert out.extra_args["cfg_pair_id"] == "req-7"
+        assert out.temperature == 0.05
+
+
+class TestAudexStageDetection:
+    """audex_omni is speech-capable only alongside the speech decoder."""
+
+    def _serving_with_stages(self, stages: list[str]) -> OmniOpenAIServingSpeech:
+        serving = OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+        serving.engine_client = SimpleNamespace(
+            stage_configs=[SimpleNamespace(engine_args=SimpleNamespace(model_stage=s)) for s in stages]
+        )
+        return serving
+
+    def test_full_pipeline_detected_as_tts(self):
+        serving = self._serving_with_stages(["audex_omni", "audex_code2wav"])
+        stage = serving._find_tts_stage()
+        assert stage is not None and stage.engine_args.model_stage == "audex_omni"
+
+    def test_thinker_only_not_detected_as_tts(self):
+        serving = self._serving_with_stages(["audex_omni"])
+        assert serving._find_tts_stage() is None
+
+    def test_tts_pipeline_still_detected(self):
+        serving = self._serving_with_stages(["audex_thinker", "audex_code2wav"])
+        stage = serving._find_tts_stage()
+        assert stage is not None and stage.engine_args.model_stage == "audex_thinker"
+
+
+def test_guided_injection_sets_guided_temperature():
+    """Guided requests decode at the measured CFG temperature (0.05)."""
+    serving = TestAudexCfgInjection()._serving_with_fake_tokenizer()
+    cond = TestAudexCfgInjection()._cond_prompt()
+    params = SimpleNamespace(extra_args={"cfg_scale": 1.5}, temperature=0.1)
+    out = serving._inject_audex_cfg_pair_args("req-1", {"prompt": cond}, params)
+    assert out.temperature == 0.05
+
+    unguided = SimpleNamespace(extra_args={"cfg_scale": 1.0}, temperature=0.1)
+    out = serving._inject_audex_cfg_pair_args("req-2", {"prompt": cond}, unguided)
+    assert out.temperature == 0.1
+
+
+# ---------------------------------------------------------------- TTA serving surface
+
+from vllm_omni.entrypoints.openai.tts_adapters import resolve_adapter  # noqa: E402
+from vllm_omni.entrypoints.openai.tts_adapters.audex_tta import AudexTTAAdapter  # noqa: E402
+
+
+def _tta_adapter() -> AudexTTAAdapter:
+    return AudexTTAAdapter.__new__(AudexTTAAdapter)
+
+
+class _TTAVocabTokenizer(_MarkerTokenizer):
+    """Marker tokenizer + a full audiocodec vocab for phase-id building."""
+
+    def get_vocab(self):
+        vocab = {"<audiogen_start>": 7, "<audiogen_end>": 8}
+        for n in range(8192):
+            vocab[f"<audiocodec_{n}>"] = 1000 + n
+        return vocab
+
+
+class TestAudexTTAAdapterValidation:
+    def test_default_caption_accepted(self):
+        assert _tta_adapter().validate(_speech_request()) is None
+
+    def test_empty_caption_rejected(self):
+        req = _speech_request()
+        req.input = "  "
+        assert _tta_adapter().validate(req) is not None
+
+    @pytest.mark.parametrize("scale", [1.0, 3.0, 10.0])
+    def test_in_range_scale_accepted(self, scale):
+        assert _tta_adapter().validate(_speech_request(cfg_scale=scale)) is None
+
+    @pytest.mark.parametrize("scale", [0.5, 10.5, "big"])
+    def test_out_of_range_scale_rejected(self, scale):
+        error = _tta_adapter().validate(_speech_request(cfg_scale=scale))
+        assert error is not None and "cfg_scale" in error
+
+    @pytest.mark.parametrize("key", ["cfg_role", "cfg_pair_id", "cfg_null_prompt", "tta_rvq"])
+    def test_internal_keys_rejected(self, key):
+        error = _tta_adapter().validate(_speech_request(**{key: "x"}))
+        assert error is not None and key in error
+
+
+class TestAdapterRouting:
+    def test_tta_adapter_resolves_by_model_type(self):
+        adapter_cls = resolve_adapter("audex_tta")
+        assert adapter_cls is AudexTTAAdapter
+        assert adapter_cls.stage_keys == frozenset({"audex_tta_thinker"})
+
+    def test_tts_adapter_never_selects_tta_stage(self):
+        assert "audex_tta_thinker" not in AudexAdapter.stage_keys
+        assert not (AudexAdapter.stage_keys & AudexTTAAdapter.stage_keys)
+
+    def test_detection_separates_tts_and_tta(self):
+        tta_serving = TestAudexStageDetection()._serving_with_stages(["audex_tta_thinker", "audex_xcodec"])
+        tta_serving._tts_stage = tta_serving._find_tts_stage()
+        assert tta_serving._tts_stage.engine_args.model_stage == "audex_tta_thinker"
+        assert tta_serving._detect_tts_model_type() == "audex_tta"
+
+        tts_serving = TestAudexStageDetection()._serving_with_stages(["audex_thinker", "audex_code2wav"])
+        tts_serving._tts_stage = tts_serving._find_tts_stage()
+        assert tts_serving._detect_tts_model_type() == "audex"
+
+
+class TestAudexTTAInjection:
+    def _serving(self):
+        serving = _serving(model_type="audex_tta")
+        serving._get_audex_tokenizer = lambda: _TTAVocabTokenizer()
+        serving._audex_tta_rvq = None
+        return serving
+
+    def _prompt(self):
+        from vllm_omni.model_executor.models.audex.prompt import build_tta_cond_prompt
+
+        return {"prompt": build_tta_cond_prompt("Rain on a tin roof.")}
+
+    def test_default_injection_applies_rvq_and_cfg3(self):
+        serving = self._serving()
+        params = SimpleNamespace(extra_args=None)
+        out = serving._inject_audex_tta_args("req-9", self._prompt(), params)
+
+        extra = out.extra_args
+        rvq = extra["tta_rvq"]
+        assert len(rvq["phase_token_ids"]) == 4
+        assert all(len(ids) == 1024 for ids in rvq["phase_token_ids"])
+        assert (rvq["start_tid"], rvq["end_tid"]) == (7, 8)
+        assert rvq["codec_cap"] == 4000 and rvq["start_in_prompt"] is True
+        assert extra["cfg_scale"] == 3.0
+        assert extra["cfg_role"] == "cond" and extra["cfg_pair_id"] == "req-9"
+        assert "<unk>" in extra["cfg_null_prompt"]
+
+    def test_explicit_scale_one_disables_cfg_but_keeps_rvq(self):
+        serving = self._serving()
+        params = SimpleNamespace(extra_args={"cfg_scale": 1.0})
+        out = serving._inject_audex_tta_args("req-1", self._prompt(), params)
+        assert "tta_rvq" in out.extra_args
+        assert "cfg_scale" not in out.extra_args
+        assert "cfg_role" not in out.extra_args
+
+    def test_rvq_contract_cached_per_process(self):
+        serving = self._serving()
+        out_a = serving._inject_audex_tta_args("a", self._prompt(), SimpleNamespace(extra_args=None))
+        out_b = serving._inject_audex_tta_args("b", self._prompt(), SimpleNamespace(extra_args=None))
+        assert out_a.extra_args["tta_rvq"] is out_b.extra_args["tta_rvq"]
+
+    def test_injection_never_mutates_input_params(self):
+        """The default online path hands the injector an element of the
+        engine's SHARED default_sampling_params_list (review P2): the
+        per-request pair state must land only on the returned clone."""
+        serving = self._serving()
+        shared = SimpleNamespace(extra_args=None)
+        out_1 = serving._inject_audex_tta_args("req-1", self._prompt(), shared)
+        out_2 = serving._inject_audex_tta_args("req-2", self._prompt(), shared)
+        assert shared.extra_args is None
+        assert out_1 is not shared and out_2 is not shared
+        assert out_1.extra_args["cfg_pair_id"] == "req-1"
+        assert out_2.extra_args["cfg_pair_id"] == "req-2"
diff --git a/tests/entrypoints/openai_api/test_audio_format.py b/tests/entrypoints/openai_api/test_audio_format.py
new file mode 100644
index 000000000..2f1f487d9
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_audio_format.py
@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for audio output format handling in chat completions.
+
+Covers:
+- #4716: audio.format parameter must be respected, not hardcoded to WAV
+- Format validation rejects unsupported formats
+- pcm16 is mapped to pcm for soundfile compatibility
+- Default format is WAV when not specified
+- create_audio encodes correctly for each supported format
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin
+from vllm_omni.entrypoints.openai.protocol.audio import (
+    DEFAULT_AUDIO_FORMAT,
+    SUPPORTED_AUDIO_FORMATS,
+    SUPPORTED_CHAT_AUDIO_FORMATS,
+    CreateAudio,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class TestAudioFormatConstants:
+    def test_default_format_is_wav(self):
+        assert DEFAULT_AUDIO_FORMAT == "wav"
+
+    def test_supported_formats_no_aac(self):
+        assert "aac" not in SUPPORTED_AUDIO_FORMATS
+
+    def test_chat_formats_include_pcm16(self):
+        assert "pcm16" in SUPPORTED_CHAT_AUDIO_FORMATS
+
+    def test_chat_formats_superset_of_audio_formats(self):
+        assert SUPPORTED_AUDIO_FORMATS <= SUPPORTED_CHAT_AUDIO_FORMATS
+
+
+class TestCreateAudio:
+    @pytest.fixture
+    def mixin(self):
+        return AudioMixin()
+
+    @pytest.fixture
+    def audio_tensor(self):
+        return np.sin(np.linspace(0, 2 * np.pi, 24000)).astype(np.float32)
+
+    @pytest.mark.parametrize("fmt", ["wav", "mp3", "flac", "opus", "pcm"])
+    def test_create_audio_supported_formats(self, mixin, audio_tensor, fmt):
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format=fmt,
+            speed=1.0,
+            base64_encode=False,
+        )
+        response = mixin.create_audio(audio_obj)
+        assert len(response.audio_data) > 0
+
+    def test_wav_magic_bytes(self, mixin, audio_tensor):
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format="wav",
+            speed=1.0,
+            base64_encode=False,
+        )
+        response = mixin.create_audio(audio_obj)
+        assert response.audio_data[:4] == b"RIFF"
+        assert response.media_type == "audio/wav"
+
+    def test_mp3_encoding(self, mixin, audio_tensor):
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format="mp3",
+            speed=1.0,
+            base64_encode=False,
+        )
+        response = mixin.create_audio(audio_obj)
+        assert response.media_type == "audio/mpeg"
+        assert response.audio_data[:4] != b"RIFF"
+
+    def test_flac_magic_bytes(self, mixin, audio_tensor):
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format="flac",
+            speed=1.0,
+            base64_encode=False,
+        )
+        response = mixin.create_audio(audio_obj)
+        assert response.audio_data[:4] == b"fLaC"
+        assert response.media_type == "audio/flac"
+
+    def test_unsupported_format_falls_back_to_default(self, mixin, audio_tensor):
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format="aac",
+            speed=1.0,
+            base64_encode=False,
+        )
+        response = mixin.create_audio(audio_obj)
+        assert response.audio_data[:4] == b"RIFF"
+        assert response.media_type == "audio/wav"
+
+    def test_base64_encoding(self, mixin, audio_tensor):
+        import base64
+
+        audio_obj = CreateAudio(
+            audio_tensor=audio_tensor,
+            sample_rate=24000,
+            response_format="wav",
+            speed=1.0,
+            base64_encode=True,
+        )
+        response = mixin.create_audio(audio_obj)
+        decoded = base64.b64decode(response.audio_data)
+        assert decoded[:4] == b"RIFF"
+
+
+class TestResolveAudioFormat:
+    """Test _resolve_audio_format via the serving chat class."""
+
+    @pytest.fixture
+    def serving_chat(self):
+        from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+        return object.__new__(OmniOpenAIServingChat)
+
+    def _make_request(self, audio_params=None):
+        from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
+
+        req = ChatCompletionRequest(
+            model="test-model",
+            messages=[{"role": "user", "content": "hello"}],
+        )
+        if audio_params is not None:
+            req.audio = audio_params
+        return req
+
+    def test_default_format_when_no_audio_params(self, serving_chat):
+        request = self._make_request()
+        result = serving_chat._resolve_audio_format(request)
+        assert result == "wav"
+
+    def test_extracts_mp3_format(self, serving_chat):
+        request = self._make_request({"format": "mp3", "voice": "alloy"})
+        result = serving_chat._resolve_audio_format(request)
+        assert result == "mp3"
+
+    def test_pcm16_mapped_to_pcm(self, serving_chat):
+        request = self._make_request({"format": "pcm16", "voice": "alloy"})
+        result = serving_chat._resolve_audio_format(request)
+        assert result == "pcm"
+
+    def test_invalid_format_returns_error(self, serving_chat):
+        from vllm.entrypoints.openai.engine.protocol import ErrorResponse
+
+        request = self._make_request({"format": "aac", "voice": "alloy"})
+        result = serving_chat._resolve_audio_format(request)
+        assert isinstance(result, ErrorResponse)
+        assert "aac" in result.error.message
+
+    def test_all_supported_formats_accepted(self, serving_chat):
+        from vllm.entrypoints.openai.engine.protocol import ErrorResponse
+
+        for fmt in SUPPORTED_CHAT_AUDIO_FORMATS:
+            request = self._make_request({"format": fmt, "voice": "alloy"})
+            result = serving_chat._resolve_audio_format(request)
+            assert not isinstance(result, ErrorResponse), f"Format {fmt} should be accepted"
diff --git a/tests/entrypoints/openai_api/test_diffusion_request_utils.py b/tests/entrypoints/openai_api/test_diffusion_request_utils.py
new file mode 100644
index 000000000..0b3091f24
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_diffusion_request_utils.py
@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.entrypoints.openai.diffusion_request_utils import (
+    apply_normalized_diffusion_request_extra_args,
+    normalize_diffusion_request_args,
+)
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+REQUEST_SOURCES = (
+    "root.declared",
+    "root.extra_args",
+    "root.extra_params",
+    "nested.declared",
+    "nested.extra_args",
+    "nested.extra_params",
+)
+
+
+def _source_args(source: str, value: object) -> dict[str, object]:
+    scope, container = source.split(".")
+    payload = {"solver": value} if container == "declared" else {container: {"solver": value}}
+    kwargs: dict[str, object] = {scope: payload}
+    if container == "declared":
+        kwargs["registered_extra_fields"] = {"solver"}
+    return kwargs
+
+
+@pytest.mark.parametrize("source", REQUEST_SOURCES)
+@pytest.mark.parametrize(("value", "expected"), [("ddim", "ddim"), (None, "euler")])
+def test_normalizer_routes_values_without_erasing_defaults(
+    source: str,
+    value: object,
+    expected: str,
+) -> None:
+    normalized, _ = normalize_diffusion_request_args(**_source_args(source, value))
+    sampling_params = OmniDiffusionSamplingParams(
+        extra_args={"solver": "euler", "stage_default": True},
+    )
+    apply_normalized_diffusion_request_extra_args(sampling_params, normalized)
+
+    assert sampling_params.extra_args == {"solver": expected, "stage_default": True}
+
+
+def test_non_overlapping_legacy_and_canonical_values_are_merged(mocker) -> None:
+    warning_once = mocker.patch("vllm_omni.entrypoints.openai.diffusion_request_utils.logger.warning_once")
+
+    normalized, _ = normalize_diffusion_request_args(
+        root={"extra_args": {"cfg_text_scale": 7.0}},
+        nested={"extra_params": {"sample_solver": "euler"}},
+    )
+
+    assert normalized == {"cfg_text_scale": 7.0, "sample_solver": "euler"}
+    warning_once.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "kwargs, expected_sources",
+    [
+        (
+            {
+                "root": {"seed": 1, "extra_args": {"seed": 2}},
+                "serving_root_fields": {"seed"},
+            },
+            "request.seed, request.extra_args.seed",
+        ),
+        (
+            {
+                "root": {"cfg_scale": 7.0},
+                "nested": {"true_cfg_scale": 2.0},
+                "serving_root_fields": {"true_cfg_scale"},
+                "root_field_aliases": {"cfg_scale": "true_cfg_scale"},
+            },
+            "request.cfg_scale, request.extra_body.true_cfg_scale",
+        ),
+        (
+            {
+                "root": {
+                    "extra_args": {"solver": "euler"},
+                    "extra_params": {"solver": "ddim"},
+                }
+            },
+            "request.extra_args.solver, request.extra_params.solver",
+        ),
+        (
+            {
+                "root": {"cfg_text_scale": 7.0},
+                "nested": {"extra_args": {"cfg_text_scale": 8.0}},
+                "registered_extra_fields": {"cfg_text_scale"},
+            },
+            "request.cfg_text_scale, request.extra_body.extra_args.cfg_text_scale",
+        ),
+    ],
+)
+def test_duplicate_sources_are_rejected(
+    kwargs: dict[str, object],
+    expected_sources: str,
+    mocker,
+) -> None:
+    warning_once = mocker.patch("vllm_omni.entrypoints.openai.diffusion_request_utils.logger.warning_once")
+
+    with pytest.raises(ValueError, match=expected_sources):
+        normalize_diffusion_request_args(**kwargs)
+
+    warning_once.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ("scope", "name"),
+    (
+        ("root", "extra_args"),
+        ("root", "extra_params"),
+        ("nested", "extra_args"),
+        ("nested", "extra_params"),
+    ),
+)
+def test_public_containers_must_be_objects(scope: str, name: str) -> None:
+    with pytest.raises(ValueError, match="must be a JSON object"):
+        normalize_diffusion_request_args(**{scope: {name: ["not", "an", "object"]}})
+
+
+def test_container_keys_must_be_strings() -> None:
+    with pytest.raises(ValueError, match="must be a JSON object with string keys"):
+        normalize_diffusion_request_args(root={"extra_args": {1: "invalid"}})
diff --git a/tests/entrypoints/openai_api/test_duplex_capability.py b/tests/entrypoints/openai_api/test_duplex_capability.py
new file mode 100644
index 000000000..153563cbb
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_duplex_capability.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_api_server_does_not_import_experimental_duplex_at_module_load() -> None:
+    api_server = Path(__file__).parents[3] / "vllm_omni/entrypoints/openai/api_server.py"
+    module = ast.parse(api_server.read_text())
+
+    top_level_imports = {
+        node.module for node in module.body if isinstance(node, ast.ImportFrom) and isinstance(node.module, str)
+    }
+
+    assert not any(module.startswith("vllm_omni.experimental.fullduplex") for module in top_level_imports)
diff --git a/tests/entrypoints/openai_api/test_duplex_handler.py b/tests/entrypoints/openai_api/test_duplex_handler.py
new file mode 100644
index 000000000..9f8768bf4
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_duplex_handler.py
@@ -0,0 +1,7187 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import struct
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+from starlette.websockets import WebSocketDisconnect
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.experimental.fullduplex.engine.duplex_control_client import DuplexControlRequestError
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import duplex_resource_request_id
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence, DuplexSessionLifecycleMessage
+from vllm_omni.experimental.fullduplex.minicpmo45 import (
+    MiniCPMO45NativeDuplexServingAdapter,
+    MiniCPMO45PcmAppendBuffer,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.data_plane import (
+    MiniCPMO45DataPlaneContext,
+    MiniCPMO45DataPlaneSession,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.runtime import (
+    MiniCPMO45DuplexRuntimeExtension,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.session import (
+    MiniCPMO45ServingSessionState,
+)
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexCapabilities,
+    DuplexOverlapPolicy,
+    DuplexPlaybackCommitPolicy,
+    DuplexSession,
+    DuplexSessionConfig,
+    ResponseCreateOptions,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_session import NativeRealtimeSessionProtocol
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import ServingRuntimeConfigError
+from vllm_omni.experimental.fullduplex.openai.serving import (
+    OmniDuplexSessionHandler,
+    should_enable_duplex_endpoint,
+)
+from vllm_omni.experimental.fullduplex.openai.websocket import DuplexWebSocketActor
+from vllm_omni.experimental.fullduplex.output import attach_duplex_output_decision
+from vllm_omni.outputs import OmniRequestOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _ModelConfig:
+    model = "test-model"
+
+
+class FakeEngineClient:
+    output_modalities = ["text", "audio"]
+
+    def __init__(
+        self,
+        *,
+        fail_open: bool = False,
+        fail_signal: bool = False,
+        fail_touch: bool = False,
+        fail_signal_events: set[str] | None = None,
+        fail_close: bool = False,
+        fail_abort: bool = False,
+        control_result: dict[str, object] | None = None,
+        open_result: dict[str, object] | None = None,
+        append_result: dict[str, object] | None = None,
+        append_results: list[dict[str, object]] | None = None,
+        collect_outputs: list[list[object]] | None = None,
+        collect_delay_s: float = 0.0,
+        signal_result: dict[str, object] | None = None,
+        close_result: dict[str, object] | None = None,
+    ) -> None:
+        self.fail_open = fail_open
+        self.fail_signal = fail_signal
+        self.fail_touch = fail_touch
+        self.fail_signal_events = set(fail_signal_events or ())
+        self.fail_close = fail_close
+        self.fail_abort = fail_abort
+        self.control_result = control_result
+        self.open_result = open_result
+        self.append_result = append_result
+        self.append_results = list(append_results or [])
+        self.collect_outputs = list(collect_outputs or [])
+        self.collect_delay_s = collect_delay_s
+        self.signal_result = signal_result
+        self.close_result = close_result
+        self.opened: list[str] = []
+        self.opened_fences: list[DuplexFence | None] = []
+        self.appended: list[tuple[str, str, object, bool]] = []
+        self.append_operation_ids: list[str | None] = []
+        self.appended_fences: list[DuplexFence | None] = []
+        self.opened_configs: list[dict[str, object]] = []
+        self.opened_runtime_configs: list[dict[str, object]] = []
+        self.signals: list[tuple[str, str]] = []
+        self.signal_fences: list[DuplexFence | None] = []
+        self.signal_next_fences: list[DuplexFence | None] = []
+        self.signal_session_configs: list[dict[str, object] | None] = []
+        self.signal_runtime_configs: list[dict[str, object] | None] = []
+        self.closed: list[tuple[str, str]] = []
+        self.touched: list[tuple[str, DuplexLeaseActivity]] = []
+        self.touch_fences: list[DuplexFence] = []
+        self.resumed: list[tuple[str, int]] = []
+        self.resume_fences: list[DuplexFence] = []
+        self.aborted: list[str] = []
+        self.abort_batches: list[list[str]] = []
+        self.internal_abort_batches: list[list[str]] = []
+        self.collected: list[tuple[str, int | None]] = []
+        self.duplex_lifecycle_events: asyncio.Queue[DuplexSessionLifecycleMessage] = asyncio.Queue()
+
+    async def open_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        session_mode: str = "duplex",
+        capabilities: dict[str, object] | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        timeout: float | None = None,
+        fence: DuplexFence | None = None,
+    ) -> None:
+        del timeout
+        if self.fail_open:
+            raise RuntimeError("open failed")
+        self.opened.append(session_id)
+        self.opened_fences.append(fence)
+        self.opened_configs.append(dict(session_config or {}))
+        self.opened_runtime_configs.append(dict(runtime_config or {}))
+        return self.open_result if self.open_result is not None else self.control_result
+
+    async def append_duplex_input_async(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None = None,
+        final: bool = False,
+        timeout: float | None = None,
+        collect_outputs: bool = True,
+        fence: DuplexFence | None = None,
+    ) -> None:
+        del timeout, collect_outputs
+        self.appended.append((session_id, mode, payload, final))
+        self.append_operation_ids.append(operation_id)
+        self.appended_fences.append(fence)
+        if self.append_results:
+            return self.append_results.pop(0)
+        return self.append_result if self.append_result is not None else self.control_result
+
+    async def collect_duplex_data_plane_outputs_async(
+        self,
+        request_id: str,
+        *,
+        response_stage_id: int | None = None,
+        timeout: float | None = None,
+    ) -> list[object]:
+        del timeout
+        self.collected.append((request_id, response_stage_id))
+        if self.collect_delay_s > 0:
+            await asyncio.sleep(self.collect_delay_s)
+        if not self.collect_outputs:
+            return []
+        return self.collect_outputs.pop(0)
+
+    async def signal_duplex_turn_async(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        timeout: float | None = None,
+        fence: DuplexFence | None = None,
+        next_fence: DuplexFence | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+    ) -> None:
+        del timeout
+        if self.fail_signal or event in self.fail_signal_events:
+            raise RuntimeError("signal failed")
+        self.signals.append((session_id, event))
+        self.signal_fences.append(fence)
+        self.signal_next_fences.append(next_fence)
+        self.signal_session_configs.append(session_config)
+        self.signal_runtime_configs.append(runtime_config)
+        return self.signal_result if self.signal_result is not None else self.control_result
+
+    async def close_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        timeout: float | None = None,
+        fence: DuplexFence | None = None,
+    ) -> None:
+        del timeout
+        if self.fail_close:
+            raise RuntimeError("close failed")
+        self.closed.append((session_id, reason))
+        return self.close_result if self.close_result is not None else self.control_result
+
+    async def touch_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None = None,
+    ) -> dict[str, object]:
+        del timeout
+        if self.fail_touch:
+            raise RuntimeError("touch failed")
+        self.touched.append((session_id, activity))
+        self.touch_fences.append(fence)
+        return {
+            "operation": "touch",
+            "session_id": session_id,
+            "ok": True,
+            "stage_results": [
+                {
+                    "stage_id": -1,
+                    "replica_id": -1,
+                    "result": {"supported": True, "lease_generation": 0},
+                }
+            ],
+        }
+
+    async def resume_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None = None,
+    ) -> dict[str, object]:
+        del timeout
+        self.resumed.append((session_id, expected_lease_generation))
+        self.resume_fences.append(fence)
+        return {
+            "operation": "resume",
+            "session_id": session_id,
+            "ok": True,
+            "stage_results": [
+                {
+                    "stage_id": -1,
+                    "replica_id": -1,
+                    "result": {
+                        "supported": True,
+                        "lease_generation": expected_lease_generation + 1,
+                    },
+                }
+            ],
+        }
+
+    async def abort(self, request_ids: list[str]) -> None:
+        if self.fail_abort:
+            raise RuntimeError("abort failed")
+        assert isinstance(request_ids, list)
+        self.abort_batches.append(list(request_ids))
+        self.aborted.extend(request_ids)
+
+    async def _abort_internal_requests(self, request_ids: list[str]) -> None:
+        if self.fail_abort:
+            raise RuntimeError("abort failed")
+        assert isinstance(request_ids, list)
+        self.internal_abort_batches.append(list(request_ids))
+        self.aborted.extend(request_ids)
+
+
+class FakeChatService:
+    duplex_serving_adapter_path = (
+        "vllm_omni.experimental.fullduplex.minicpmo45.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
+    )
+
+    def __init__(self, engine_client: FakeEngineClient) -> None:
+        self.engine_client = engine_client
+        self.model_config = _ModelConfig()
+        self.seen_request_ids: list[str] = []
+
+    async def create_chat_completion(self, request, raw_request=None):
+        self.seen_request_ids.append(request.request_id)
+
+        async def _gen():
+            await asyncio.sleep(999)
+            yield "data: [DONE]\n\n"
+
+        return _gen()
+
+    def create_audio(self, audio_obj):
+        return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
+
+
+def _test_data_plane() -> MiniCPMO45DataPlaneSession:
+    def encode_audio(
+        audio: object,
+        sample_rate_hz: int,
+        response_format: str,
+        speed: float | None,
+    ) -> str | None:
+        del sample_rate_hz, response_format, speed
+        if audio is None:
+            return None
+        if hasattr(audio, "numel"):
+            return f"wav-{int(audio.numel())}"
+        return f"wav-{int(np.asarray(audio).size)}"
+
+    return MiniCPMO45DataPlaneSession(encode_audio)
+
+
+def _data_plane_context(session: DuplexSession | None = None) -> MiniCPMO45DataPlaneContext:
+    if session is None:
+        return MiniCPMO45DataPlaneContext()
+    return MiniCPMO45DataPlaneContext(
+        epoch=session.epoch,
+        turn_id=session.turn_id,
+        active_response_turn_id=session.active_response_turn_id,
+        active_response_id=session.active_response_id,
+        auto_responds=bool(session.config.extra_body.get("auto_response", False)),
+        response_format=session.config.response_format,
+        speed=session.config.speed,
+        modalities=tuple(session.config.modalities),
+    )
+
+
+def _project_data_plane(
+    data_plane: MiniCPMO45DataPlaneSession,
+    result: object,
+    *,
+    session: DuplexSession | None = None,
+) -> list[dict[str, object]]:
+    return list(data_plane.project(result, context=_data_plane_context(session)))
+
+
+class TimedWebSocket:
+    def __init__(self, *, on_send=None, receive_timeout_s: float = 1.0):
+        self._q: asyncio.Queue[str | BaseException] = asyncio.Queue()
+        self.sent: list[dict[str, Any]] = []
+        self.accepted = False
+        self._on_send = on_send
+        self._receive_timeout_s = receive_timeout_s
+        self.query_params: dict[str, str] = {}
+
+    async def accept(self):
+        self.accepted = True
+
+    async def receive_text(self) -> str:
+        try:
+            item = await asyncio.wait_for(self._q.get(), timeout=self._receive_timeout_s)
+        except asyncio.TimeoutError as exc:
+            raise WebSocketDisconnect(code=1000) from exc
+        if isinstance(item, BaseException):
+            raise item
+        return item
+
+    async def send_json(self, data: dict[str, Any]):
+        self.sent.append(data)
+        if self._on_send is not None:
+            self._on_send(self, data)
+
+    def put(self, payload: dict[str, Any]) -> None:
+        self._q.put_nowait(json.dumps(payload))
+
+    async def close(self, code: int = 1000, reason: str | None = None) -> None:
+        del reason
+        self._q.put_nowait(WebSocketDisconnect(code=code))
+
+    def sent_types(self) -> list[str]:
+        return [m.get("type", "") for m in self.sent]
+
+
+def test_native_realtime_protocol_emits_speak_once_per_response():
+    protocol = NativeRealtimeSessionProtocol({})
+    response_id = "resp-speak-once"
+
+    projected = protocol.encode_outbound_event(
+        {
+            "type": "response.created",
+            "response_id": response_id,
+            "modalities": ["audio", "text"],
+        }
+    )
+    projected.extend(
+        protocol.encode_outbound_event(
+            {
+                "type": "response.speak",
+                "response_id": response_id,
+                "text": "hello",
+                "model_speak": True,
+            }
+        )
+    )
+    projected.extend(
+        protocol.encode_outbound_event(
+            {
+                "type": "response.output_audio.delta",
+                "response_id": response_id,
+                "audio": base64.b64encode(b"\x00\x00").decode("ascii"),
+                "format": "pcm16",
+                "sample_rate_hz": 24000,
+                "model_speak": True,
+            }
+        )
+    )
+
+    assert [event["type"] for event in projected].count("response.speak") == 1
+    speak = next(event for event in projected if event["type"] == "response.speak")
+    assert "text" not in speak
+    assert speak["metadata"] == {"model_speak": True}
+
+
+def test_native_realtime_protocol_speak_does_not_expose_internal_event():
+    protocol = NativeRealtimeSessionProtocol({})
+
+    projected = protocol.encode_outbound_event(
+        {
+            "type": "response.speak",
+            "response_id": "resp-curated-speak",
+            "session_id": "sid-curated-speak",
+            "epoch": 3,
+            "text": "transcript belongs on the delta channel",
+            "model_speak": True,
+            "data_plane_request_id": "internal-request-id",
+            "uses_model_runner_scheduler": True,
+        }
+    )
+
+    assert len(projected) == 1
+    projected[0].pop("event_id")
+    assert projected == [
+        {
+            "type": "response.speak",
+            "response_id": "resp-curated-speak",
+            "item_id": "item_resp-curated-speak",
+            "output_index": 0,
+            "content_index": 0,
+            "metadata": {
+                "session_id": "sid-curated-speak",
+                "epoch": 3,
+                "model_speak": True,
+            },
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_drains_internal_conversation_item_control_event():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-delete"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    ws.put(
+        {
+            "type": "conversation.item.create",
+            "item": {
+                "id": "item-a",
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "hello"}],
+            },
+        }
+    )
+    assert json.loads(await protocol.receive_internal_event_text(ws)) == {
+        "type": "turn.signal",
+        "event": "conversation.item.create",
+        "payload": {
+            "item": {
+                "id": "item-a",
+                "object": "realtime.item",
+                "type": "message",
+                "status": "completed",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "hello"}],
+            }
+        },
+    }
+
+    ws.put({"type": "conversation.item.delete", "item_id": "item-a"})
+    translated = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert translated == {
+        "type": "turn.signal",
+        "event": "conversation.item.delete",
+        "payload": {"item_id": "item-a"},
+    }
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_conversation_item_create_commits_user_text():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-item-create"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    ws.put(
+        {
+            "type": "conversation.item.create",
+            "item": {
+                "id": "item-user-text",
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "hello"}],
+            },
+        }
+    )
+
+    translated = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert translated == {
+        "type": "turn.signal",
+        "event": "conversation.item.create",
+        "payload": {
+            "item": {
+                "id": "item-user-text",
+                "object": "realtime.item",
+                "type": "message",
+                "status": "completed",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "hello"}],
+            }
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_audio_commit_requires_non_empty_buffer():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-commit"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+    with pytest.raises(WebSocketDisconnect):
+        await protocol.receive_internal_event_text(ws)
+
+    assert ws.sent[-1]["type"] == "error"
+    assert ws.sent[-1]["error"]["code"] == "input_audio_buffer_empty"
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_audio_commit_does_not_auto_create_response():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-commit-full"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    pcm = struct.pack("<2h", 1024, -1024)
+    ws.put({"type": "input_audio_buffer.append", "audio": base64.b64encode(pcm).decode("ascii"), "format": "pcm16"})
+    append_event = json.loads(await protocol.receive_internal_event_text(ws))
+    assert append_event["type"] == "input_audio_buffer.append"
+
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+    commit_event = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert commit_event["type"] == "input_audio_buffer.commit"
+    assert commit_event["response_create"] is False
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_rejects_invalid_sample_rate_without_closing():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-invalid-rate"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(1),
+            "format": "pcm16",
+            "sample_rate_hz": 192_001,
+        }
+    )
+    ws.put({"type": "input_audio_buffer.clear"})
+    translated = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert translated == {"type": "input_audio_buffer.clear", "reason": "input_audio_buffer.clear"}
+    error = next(event for event in ws.sent if event.get("type") == "error")
+    assert error["error"]["code"] == "bad_event"
+    assert error["error"]["param"] == "sample_rate_hz"
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_audio_clear_is_not_barge_in_cancel():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-clear"})
+    session_create = json.loads(await protocol.receive_internal_event_text(ws))
+    assert session_create["type"] == "session.create"
+
+    ws.put({"type": "input_audio_buffer.clear"})
+    clear_event = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert clear_event == {"type": "input_audio_buffer.clear", "reason": "input_audio_buffer.clear"}
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_preserves_input_turn_policy_hints():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    translated = await protocol._to_duplex_event(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": "AAAA",
+            "format": "pcm_f32le",
+            "duration_ms": 240,
+            "vad": {"is_speech": True, "speech_probability": 0.9},
+            "overlap_action": "listen",
+        }
+    )
+
+    assert translated is not None
+    assert translated["duration_ms"] == 240
+    assert translated["vad"] == {"is_speech": True, "speech_probability": 0.9}
+    assert translated["overlap_action"] == "listen"
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_rejects_unimplemented_server_vad():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    translated = await protocol._to_duplex_event(
+        {
+            "type": "session.update",
+            "model": "test-model",
+            "session_id": "rt-turn-detection",
+            "turn_detection": {
+                "type": "server_vad",
+                "interrupt_response": False,
+                "silence_duration_ms": 900,
+                "threshold": 0.4,
+            },
+        }
+    )
+
+    assert translated is None
+    error = ws.sent[-1]
+    assert error["type"] == "error"
+    assert error["error"]["code"] == "unsupported_turn_detection"
+    assert "server_vad" in error["error"]["message"]
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_accepts_disabled_turn_detection():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    ws.put(
+        {
+            "type": "session.update",
+            "model": "test-model",
+            "session_id": "rt-no-turn-detection",
+            "turn_detection": None,
+        }
+    )
+    translated = json.loads(await protocol.receive_internal_event_text(ws))
+
+    assert translated["type"] == "session.create"
+    assert translated["session"]["extra_body"]["realtime_session_payload"]["turn_detection"] is None
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_rejects_nested_vad_even_when_top_level_is_disabled():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    translated = await protocol._to_duplex_event(
+        {
+            "type": "session.update",
+            "model": "test-model",
+            "turn_detection": None,
+            "audio": {
+                "input": {
+                    "turn_detection": {
+                        "type": "server_vad",
+                    }
+                }
+            },
+        }
+    )
+
+    assert translated is None
+    assert ws.sent[-1]["error"]["code"] == "unsupported_turn_detection"
+
+
+def test_native_duplex_handler_has_no_fixed_session_admission_cap():
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    client_config = DuplexSessionConfig(
+        extra_body={"max_duplex_sessions": 99, "duplex_max_sessions": 99},
+    )
+
+    assert not hasattr(handler, "_max_native_duplex_sessions")
+    assert not hasattr(handler, "_max_duplex_sessions")
+    assert client_config.extra_body["max_duplex_sessions"] == 99
+
+
+def test_native_response_options_ignore_private_runtime_config():
+    session = DuplexSession(
+        session_id="sid-response-private-config",
+        config=DuplexSessionConfig(),
+        capabilities=DuplexCapabilities.minicpmo45_native(),
+    )
+
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    handler._apply_response_create_options(
+        session,
+        {
+            "extra_body": {
+                "duplex_stage_max_tokens": {"0": 999},
+                "client_trace_id": "trace-1",
+            }
+        },
+    )
+    session.begin_response()
+
+    assert "duplex_stage_max_tokens" not in session.config.extra_body
+    assert "client_trace_id" not in session.config.extra_body
+    assert session.response_config.extra_body["client_trace_id"] == "trace-1"
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {"instructions": "not wired"},
+        {"voice": "not-wired"},
+        {"temperature": 0.2},
+        {"max_output_tokens": 8},
+        {"tools": [{"type": "function", "name": "lookup"}]},
+    ],
+)
+def test_native_response_create_rejects_unwired_generation_options(payload):
+    session = DuplexSession(
+        session_id="sid-response-unwired-options",
+        config=DuplexSessionConfig(),
+        capabilities=DuplexCapabilities.minicpmo45_native(),
+    )
+
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    error = handler._apply_response_create_options(session, payload)
+
+    assert error == "unsupported_native_response_options"
+    session.begin_response()
+    assert session.response_config == session.config
+
+
+def test_chat_fallback_excludes_realtime_response_metadata_from_model_request():
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-response-protocol-metadata",
+        config=DuplexSessionConfig(),
+    )
+    session.reserve_response_options(
+        ResponseCreateOptions(
+            extra_body={
+                "user": "trace-1",
+                "realtime_response_conversation": "none",
+                "realtime_response_metadata": {"source": "test"},
+                "realtime_response_prompt": {"id": "prompt-1"},
+                "realtime_response_tools": [
+                    {
+                        "type": "function",
+                        "function": {"name": "lookup", "parameters": {}},
+                    }
+                ],
+                "realtime_response_tool_choice": "auto",
+            }
+        )
+    )
+    session.begin_response()
+
+    request = handler._build_chat_request(session, "request-1")
+    created = handler._response_created_payload(session, session.active_response_id or "response-1", epoch=0)
+    dumped = request.model_dump()
+
+    assert dumped["user"] == "trace-1"
+    assert dumped["tools"][0]["function"]["name"] == "lookup"
+    assert dumped["tool_choice"] == "auto"
+    assert not any(key.startswith("realtime_response_") for key in dumped)
+    assert created["conversation"] == "none"
+    assert created["metadata"] == {"source": "test"}
+    assert created["prompt"] == {"id": "prompt-1"}
+    assert session.response_config.extra_body["realtime_response_conversation"] == "none"
+
+
+@pytest.mark.asyncio
+async def test_native_response_create_surfaces_unwired_generation_options_error():
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-response-unwired-options-event"))
+    ws.put(
+        {
+            "type": "response.create",
+            "response": {"instructions": "not wired"},
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    error = next(message for message in ws.sent if message.get("type") == "error")
+    assert error["code"] == "unsupported_native_response_options"
+    assert "response_create_without_input" not in {message.get("code") for message in ws.sent}
+
+
+@pytest.mark.asyncio
+async def test_realtime_session_update_preserves_tools_and_metadata():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-rt-update-fields"))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {
+                "tools": [{"type": "function", "name": "lookup"}],
+                "tool_choice": "auto",
+                "metadata": {"demo": "yes"},
+            },
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    updated = next(m for m in ws.sent if m.get("type") == "session.updated")
+    session = updated["session"]
+    assert session["tools"] == [{"type": "function", "name": "lookup"}]
+    assert session["tool_choice"] == "auto"
+    assert session["metadata"] == {"demo": "yes"}
+    assert "turn_detection" not in session
+    runtime_config = engine.signal_session_configs[-1]
+    assert runtime_config is not None
+    assert runtime_config["extra_body"]["realtime_tools"] == [{"type": "function", "name": "lookup"}]
+    assert runtime_config["extra_body"]["realtime_metadata"] == {"demo": "yes"}
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_non_speech_append_does_not_emit_speech_started():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+
+    translated = await protocol._to_duplex_event(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": "AAAA",
+            "format": "pcm_f32le",
+            "vad": {"is_speech": False},
+        }
+    )
+
+    assert translated is not None
+    assert translated["vad"] == {"is_speech": False}
+    assert not any(event.get("type") == "input_audio_buffer.speech_started" for event in ws.sent)
+
+
+@pytest.mark.asyncio
+async def test_native_session_update_rebuilds_server_runtime_policy():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-runtime-update"))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {"temperature": 0.2, "max_output_tokens": 7},
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert "session.updated" in ws.sent_types()
+    public_config = engine.signal_session_configs[-1]
+    runtime_config = engine.signal_runtime_configs[-1]
+    assert public_config is not None
+    assert runtime_config is not None
+    assert "duplex_stage_sampling_params" not in public_config["extra_body"]
+    assert runtime_config["duplex_stage_max_tokens"]["0"] == 7
+    assert runtime_config["duplex_stage_sampling_params"]["0"]["temperature"] == 0.2
+    assert runtime_config["duplex_stage_sampling_params"]["0"]["top_k"] == 20
+    assert runtime_config["duplex_stage_sampling_params"]["0"]["top_p"] == 0.8
+
+
+@pytest.mark.asyncio
+async def test_native_session_update_rejects_client_runtime_config():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-runtime-update-reject"))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {
+                "extra_body": {"duplex_stage_max_tokens": {"0": 999}},
+            },
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    error = next(message for message in ws.sent if message.get("type") == "error")
+    assert error["code"] == "invalid_duplex_runtime_config"
+    assert ("sid-runtime-update-reject", "session.update") not in engine.signals
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_session_update_requires_ref_audio_before_enabling_audio():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-runtime-update-ref-required", modalities=["text"]))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {"modalities": ["text", "audio"]},
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    error = next(message for message in ws.sent if message.get("type") == "error")
+    assert error["code"] == "ref_audio_required"
+    assert "session.updated" not in ws.sent_types()
+    assert ("sid-runtime-update-ref-required", "session.update") not in engine.signals
+
+
+def test_native_realtime_protocol_audio_delta_preserves_sample_rate_hz():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+
+    payloads = protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-a",
+            "audio": "AAAA",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+        }
+    )
+
+    audio_events = [
+        payload for payload in payloads if payload["type"] in {"response.output_audio.delta", "response.audio.delta"}
+    ]
+    assert {payload["type"] for payload in audio_events} == {"response.audio.delta"}
+    assert {payload["format"] for payload in audio_events} == {"pcm16"}
+    assert {payload["sample_rate_hz"] for payload in audio_events} == {24000}
+
+
+def test_native_realtime_protocol_ignores_removed_legacy_event_switches():
+    ws = TimedWebSocket()
+    ws.query_params = {
+        "legacy_audio_events": "true",
+        "vllm_omni_legacy_events": "true",
+        "output_audio_events": "true",
+        "vllm_omni_output_audio_events": "true",
+    }
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+
+    payloads = protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-canonical",
+            "audio": "AAAA",
+            "text": "hello",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+            "end_of_turn": True,
+        }
+    )
+
+    event_types = {payload["type"] for payload in payloads}
+    assert "response.audio.delta" in event_types
+    assert "response.audio.done" in event_types
+    assert "response.audio_transcript.delta" in event_types
+    assert "response.audio_transcript.done" in event_types
+    assert "response.output_audio.delta" not in event_types
+    assert "response.output_audio.done" not in event_types
+    assert "response.output_audio_transcript.delta" not in event_types
+    assert "response.output_audio_transcript.done" not in event_types
+    assert "response.output_item.created" not in event_types
+    assert "response.text.delta" not in event_types
+
+
+def test_native_realtime_protocol_emits_terminal_audio_transcript_events():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+
+    payloads = protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-a",
+            "audio": "AAAA",
+            "text": "hello",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+            "end_of_turn": True,
+        }
+    )
+
+    by_type = {payload["type"]: payload for payload in payloads}
+    assert "response.audio.done" in by_type
+    assert "response.audio_transcript.delta" in by_type
+    assert "response.audio_transcript.done" in by_type
+    assert by_type["response.content_part.done"]["part"]["transcript"] == "hello"
+    assert by_type["response.output_item.done"]["item"]["object"] == "realtime.item"
+    assert by_type["response.done"]["response"]["output"][0]["object"] == "realtime.item"
+
+
+def test_native_realtime_protocol_terminal_transcript_equals_joined_deltas():
+    protocol = NativeRealtimeSessionProtocol(TimedWebSocket())  # type: ignore[arg-type]
+    response_id = "resp-transcript-contract"
+    events: list[dict[str, object]] = []
+
+    for text, end_of_turn in (("It's Canberra.", False), (" Next question.", True)):
+        events.extend(
+            protocol._from_duplex_event(
+                {
+                    "type": "response.output_audio.delta",
+                    "response_id": response_id,
+                    "audio": "AAAA",
+                    "text": text,
+                    "format": "pcm",
+                    "sample_rate_hz": 24000,
+                    "end_of_turn": end_of_turn,
+                }
+            )
+        )
+
+    transcript = "".join(str(event["delta"]) for event in events if event["type"] == "response.audio_transcript.delta")
+    done = [str(event["transcript"]) for event in events if event["type"] == "response.audio_transcript.done"]
+
+    assert transcript == "It's Canberra. Next question."
+    assert done == [transcript]
+
+
+def test_native_realtime_protocol_updates_in_progress_item_for_audio_truncate():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+
+    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-truncate"})
+    protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-truncate",
+            "audio": "AAAA",
+            "text": "hello",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+            "audio_duration_ms": 100,
+            "audio_text_marks": [{"text_chars": 5, "audio_end_ms": 100}],
+        }
+    )
+
+    item = protocol._conversation_items["item_resp-truncate"]
+    assert item["content"][0]["type"] == "output_audio"
+    assert item["content"][0]["transcript"] == "hello"
+    assert item["content"][0]["audio_duration_ms"] == 100
+
+    translated = asyncio.run(
+        protocol._to_duplex_event(
+            {
+                "type": "conversation.item.truncate",
+                "item_id": "item_resp-truncate",
+                "content_index": 0,
+                "audio_end_ms": 50,
+            }
+        )
+    )
+
+    assert translated is None
+    assert protocol._conversation_items["item_resp-truncate"]["content"][0]["transcript"] == "he"
+
+
+@pytest.mark.asyncio
+async def test_native_realtime_protocol_rejects_truncate_for_user_item():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol.bind_sender(ws.send_json)
+    protocol._conversation_items["item-user"] = {
+        "id": "item-user",
+        "object": "realtime.item",
+        "type": "message",
+        "role": "user",
+        "status": "completed",
+        "content": [{"type": "input_audio", "transcript": "hello"}],
+    }
+
+    translated = await protocol._to_duplex_event(
+        {
+            "type": "conversation.item.truncate",
+            "item_id": "item-user",
+            "content_index": 0,
+            "audio_end_ms": 10,
+        }
+    )
+
+    assert translated is None
+    error = next(event for event in ws.sent if event.get("type") == "error")
+    assert error["error"]["code"] == "bad_event"
+
+
+def test_native_realtime_protocol_response_done_emits_audio_done_before_terminal_events():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-done"})
+    protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-done",
+            "audio": "AAAA",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+        }
+    )
+
+    payloads = protocol._from_duplex_event({"type": "response.done", "response_id": "resp-done"})
+    event_types = [payload["type"] for payload in payloads]
+
+    assert event_types.index("response.audio.done") < event_types.index("response.content_part.done")
+    assert event_types.index("response.content_part.done") < event_types.index("response.output_item.done")
+    assert event_types.index("conversation.item.done") < event_types.index("response.done")
+    assert event_types.index("response.output_item.done") < event_types.index("response.done")
+
+
+def test_native_realtime_protocol_audio_cancelled_uses_active_response_id():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-cancel"})
+
+    payloads = protocol._from_duplex_event(
+        {
+            "type": "audio.cancelled",
+            "reason": "barge_in",
+            "committed_ms": 0,
+        }
+    )
+
+    done = [payload for payload in payloads if payload.get("type") == "response.done"]
+    assert len(done) == 1
+    assert done[0]["response_id"] == "resp-cancel"
+    assert done[0]["response"]["id"] == "resp-cancel"
+
+
+def test_native_realtime_protocol_audio_cancelled_does_not_reopen_completed_response():
+    ws = TimedWebSocket()
+    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
+    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-complete"})
+    protocol._from_duplex_event(
+        {
+            "type": "response.output_audio.delta",
+            "response_id": "resp-complete",
+            "audio": "AAAA",
+            "format": "pcm",
+            "sample_rate_hz": 24000,
+        }
+    )
+    protocol._from_duplex_event({"type": "response.done", "response_id": "resp-complete"})
+
+    payloads = protocol._from_duplex_event(
+        {
+            "type": "audio.cancelled",
+            "reason": "session_close",
+            "committed_ms": 999999,
+        }
+    )
+
+    assert [payload.get("type") for payload in payloads] == []
+
+
+def test_native_audio_text_marks_are_normalized_to_session_cumulative_offsets():
+    marks = OmniDuplexSessionHandler._normalize_native_audio_text_marks(
+        [{"text_chars": 3, "audio_end_ms": 200}],
+        audio_offset_ms=800,
+        text_offset_chars=5,
+    )
+
+    assert marks == [{"text_chars": 8, "audio_end_ms": 1000}]
+
+
+def test_duplex_session_playback_commit_uses_multi_delta_audio_text_marks():
+    session = DuplexSession(
+        session_id="sid-marks",
+        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.ACK_ONLY.value),
+    )
+    session.begin_response()
+    session.append_assistant_text("hello ")
+    session.mark_audio_sent(1000, text_chars=6)
+    session.append_assistant_text("world")
+    session.mark_audio_sent(2000, text_chars=11)
+    session.acknowledge_playback(played_ms=1500, committed_ms=1500)
+
+    committed = session.end_response(commit_text=True)
+
+    assert committed == {"role": "assistant", "content": "hello wo"}
+    assert session.history == (committed,)
+
+
+@pytest.mark.asyncio
+async def test_duplex_session_actor_preserves_wire_order_before_control():
+    ws = TimedWebSocket()
+    actor = DuplexWebSocketActor(ws)
+
+    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "AAAA"})
+    await actor.enqueue_event({"type": "response.cancel"})
+
+    first = await actor.next_event()
+    second = await actor.next_event()
+
+    assert first["type"] == "input_audio_buffer.append"
+    assert second["type"] == "response.cancel"
+
+
+def _pcm_f32_b64(samples: int, *, value: float = 0.05) -> str:
+    return base64.b64encode(struct.pack(f"<{samples}f", *([value] * samples))).decode("ascii")
+
+
+def _pcm16_b64(samples: int = 1, *, value: int = 1000) -> str:
+    return base64.b64encode(struct.pack(f"<{samples}h", *([value] * samples))).decode("ascii")
+
+
+def _session_create(session_id: str = "duplex-test") -> dict[str, Any]:
+    return {
+        "type": "session.create",
+        "session_id": session_id,
+        "session": {
+            "model": "test-model",
+            "modalities": ["text", "audio"],
+            "idle_timeout_s": 1,
+        },
+    }
+
+
+def _native_session_create(
+    session_id: str = "duplex-native",
+    *,
+    modalities: list[str] | None = None,
+) -> dict[str, Any]:
+    event = _session_create(session_id)
+    event["session"]["model"] = "openbmb/MiniCPM-o-4_5"
+    event["session"]["modalities"] = list(modalities or ["text"])
+    event["session"]["instructions"] = "You are a concise assistant."
+    event["session"]["extra_body"] = {"minicpmo45_native_duplex": True}
+    return event
+
+
+def _native_realtime_session_update(
+    session_id: str,
+    *,
+    modalities: list[str] | None = None,
+) -> dict[str, Any]:
+    return {
+        "type": "session.update",
+        "session": {
+            "session_id": session_id,
+            "model": "openbmb/MiniCPM-o-4_5",
+            "modalities": list(modalities or ["text"]),
+            "instructions": "You are a concise assistant.",
+            "idle_timeout_s": 1,
+            "extra_body": {"minicpmo45_native_duplex": True},
+        },
+    }
+
+
+def test_native_stage0_request_id_matches_engine_after_same_session_id_reopen():
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    first = handler._registry.create(session_id="sid-reused")
+    handler._registry.close(first.session_id)
+    reopened = handler._registry.create(session_id="sid-reused")
+    expected = duplex_resource_request_id(
+        DuplexFence(
+            reopened.session_id,
+            epoch=reopened.epoch,
+            incarnation=reopened.incarnation,
+        ),
+        "stage0",
+    )
+
+    assert reopened.incarnation == 1
+    assert handler._native_stage0_request_id(reopened, reopened.epoch) == expected
+
+
+def _native_audio_payload(
+    *,
+    samples: int = 16000,
+    value: float = 0.05,
+    is_speech: bool | None = True,
+    force_listen: bool | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "type": "audio",
+        "audio": _pcm_f32_b64(samples, value=value),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16000,
+    }
+    if is_speech is not None:
+        payload["is_speech"] = is_speech
+    if force_listen is not None:
+        payload["force_listen"] = force_listen
+    return payload
+
+
+def _auto_response_context(
+    session_id: str,
+    *,
+    playback_active: bool = False,
+) -> tuple[OmniDuplexSessionHandler, DuplexSession]:
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id=session_id,
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    if playback_active:
+        session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
+        session.begin_response()
+        session.mark_audio_sent(duration_ms=1000)
+    return handler, session
+
+
+def _install_direct_silence_scheduler(
+    handler: OmniDuplexSessionHandler,
+    session: DuplexSession,
+) -> None:
+    native = handler._minicpmo_session_state(session)
+
+    async def _schedule(payload: object, **kwargs: Any) -> bool:
+        if handler._native_silence_continuation_is_stale(
+            session,
+            request_id=kwargs["request_id"],
+            response_id=kwargs["response_id"],
+            response_owned=kwargs["response_owned"],
+            expected_epoch=kwargs["expected_epoch"],
+            expected_incarnation=kwargs["expected_incarnation"],
+            expected_model_turn_id=kwargs["expected_model_turn_id"],
+        ):
+            return False
+        append_ok, _ = await handler._append_runtime_input(
+            session,
+            payload,
+            final=False,
+            send_json=kwargs["send_json"],
+            mode="append_audio_chunk",
+            expected_epoch=kwargs["expected_epoch"],
+        )
+        return append_ok
+
+    native.silence_continuation_scheduler = _schedule
+
+
+def test_minicpmo_pcm_append_buffer_flush_preserves_accumulated_speech_marker():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    payload = _native_audio_payload(samples=8000)
+
+    assert buffer.append(payload, chunk_period_ms=1000) is None
+    flushed = buffer.flush(chunk_period_ms=1000)
+
+    assert flushed is not None
+    assert flushed["is_speech"] is True
+
+
+def test_minicpmo_pcm_append_buffer_drops_serving_new_user_turn_marker():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    first = _native_audio_payload(samples=8000)
+    first.update(
+        new_user_turn=True,
+        new_user_turn_prefix_variant="clean_response_done",
+        force_speak=True,
+    )
+    second = _native_audio_payload(samples=8000)
+
+    assert buffer.append(first, chunk_period_ms=1000) is None
+    emitted = buffer.append(second, chunk_period_ms=1000)
+
+    assert emitted is not None
+    assert emitted["is_speech"] is True
+    assert "new_user_turn" not in emitted
+    assert "new_user_turn_prefix_variant" not in emitted
+    assert "force_speak" not in emitted
+
+
+def test_minicpmo_merge_native_audio_payloads_preserves_speech_marker():
+    first = _native_audio_payload(samples=8000)
+    second = _native_audio_payload(samples=8000, value=0.0, is_speech=False)
+
+    merged = OmniDuplexSessionHandler._merge_native_audio_payloads(first, second)
+
+    assert merged["is_speech"] is True
+
+
+def test_minicpmo_merge_drops_serving_new_user_turn_marker():
+    first = _native_audio_payload(samples=8000)
+    first.update(
+        new_user_turn=True,
+        new_user_turn_prefix_variant="clean_response_done",
+        force_speak=True,
+    )
+    second = _native_audio_payload(samples=8000, is_speech=False)
+
+    merged = OmniDuplexSessionHandler._merge_native_audio_payloads(first, second)
+
+    assert merged["is_speech"] is True
+    assert "new_user_turn" not in merged
+    assert "new_user_turn_prefix_variant" not in merged
+    assert "force_speak" not in merged
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_clear_continuation_does_not_cancel_pending_silence_task():
+    async def _pending() -> bool:
+        await asyncio.sleep(3600)
+        return True
+
+    native = MiniCPMO45ServingSessionState()
+    task = asyncio.create_task(_pending())
+    native.continuation_owner_id = "owner"
+    native.continuation_units = 1
+    native.pending_silence_task = task
+    native.pending_silence_owner_id = "owner"
+
+    native.clear_continuation()
+
+    assert native.continuation_owner_id is None
+    assert native.continuation_units == 0
+    assert native.pending_silence_task is None
+    assert native.pending_silence_owner_id is None
+    assert not task.cancelled()
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+
+
+def test_auto_response_playback_overlap_keeps_model_owned_listen_speak_decision():
+    handler, session = _auto_response_context("sid-auto-silent-overlap", playback_active=True)
+    session.mark_audio_sent(duration_ms=1000)
+    silent_payload = _native_audio_payload(value=0.0, is_speech=None, force_listen=False)
+    speech_payload = _native_audio_payload(is_speech=None, force_listen=False)
+
+    assert handler._should_force_listen_for_auto_response_overlap(session, {}, silent_payload) is False
+    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
+    assert (
+        handler._should_force_listen_for_auto_response_overlap(
+            session,
+            {"force_listen": True},
+            speech_payload,
+        )
+        is True
+    )
+    assert (
+        handler._should_force_listen_for_auto_response_overlap(
+            session,
+            {"force_barge_in": True},
+            speech_payload,
+        )
+        is False
+    )
+
+    session.acknowledge_playback(played_ms=1000, committed_ms=1000)
+    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
+
+
+def test_auto_response_overlap_silence_advances_model_unit_and_preserves_realtime_input():
+    handler, session = _auto_response_context(
+        "sid-auto-silent-wire-buffer",
+        playback_active=True,
+    )
+    decision = handler._overlap_decision(
+        session,
+        {"is_speech": False},
+        _native_audio_payload(samples=3200, is_speech=False),
+    )
+
+    assert decision["action"] == "listen"
+    assert decision["buffer_audio"] is True
+    assert decision["defer_runtime_append"] is False
+    assert decision["force_listen"] is False
+    assert decision["preserve_realtime_input"] is True
+
+
+def test_auto_response_playback_overlap_admits_model_units_and_tracks_speech():
+    handler, session = _auto_response_context("sid-auto-deferred-overlap", playback_active=True)
+    payload = _native_audio_payload(samples=8640)
+
+    decision = handler._overlap_decision(
+        session,
+        {"duration_ms": 540, "is_speech": True},
+        payload,
+    )
+
+    assert decision["action"] == "listen"
+    assert decision["defer_runtime_append"] is False
+    assert decision["force_listen"] is False
+    assert decision["buffer_audio"] is True
+    assert session.overlap_speech_ms == 540
+
+
+@pytest.mark.asyncio
+async def test_auto_response_overlap_exact_unit_commit_does_not_block_or_replay_next_unit():
+    class ModelUnitEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            super().__init__()
+            self.append_started = asyncio.Event()
+            self.active_response_ids_at_append: list[str | None] = []
+            self.response_done_seen_at_append = False
+            self.session: DuplexSession | None = None
+            self.websocket: TimedWebSocket | None = None
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            assert self.session is not None
+            assert self.websocket is not None
+            self.active_response_ids_at_append.append(self.session.active_response_id)
+            self.response_done_seen_at_append = "response.done" in self.websocket.sent_types()
+            kwargs.pop("expected_epoch", None)
+            result = await super().append_duplex_input_async(session_id, **kwargs)
+            self.append_started.set()
+            return result
+
+    engine = ModelUnitEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    engine.websocket = ws
+    create = _native_session_create("sid-auto-overlap-model-unit")
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+
+    try:
+        for _ in range(100):
+            session = handler._registry.get("sid-auto-overlap-model-unit")
+            if session is not None and "session.created" in ws.sent_types():
+                break
+            await asyncio.sleep(0.01)
+        else:
+            pytest.fail("native duplex session did not open")
+
+        engine.session = session
+        session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
+        response_id = session.begin_response()
+        session.mark_audio_sent(duration_ms=2000)
+        request_id = handler._native_stage0_request_id(session, session.epoch)
+        session.bind_request(request_id)
+        expected_fence = DuplexFence(
+            session.session_id,
+            epoch=session.epoch,
+            turn_id=session.turn_id,
+            incarnation=session.incarnation,
+        )
+
+        chunk = {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(3200, value=0.05),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+            "duration_ms": 200,
+            "is_speech": True,
+        }
+        for _ in range(4):
+            ws.put(chunk)
+        await asyncio.sleep(0.05)
+        assert engine.appended == []
+
+        ws.put(chunk)
+        await asyncio.wait_for(engine.append_started.wait(), timeout=0.5)
+
+        ws.put({"type": "input_audio_buffer.commit", "final": True})
+        for _ in range(100):
+            if "input.committed" in ws.sent_types():
+                break
+            await asyncio.sleep(0.01)
+        else:
+            pytest.fail("exact model unit input did not commit")
+
+        engine.append_started.clear()
+        for _ in range(5):
+            ws.put(chunk)
+        await asyncio.wait_for(engine.append_started.wait(), timeout=0.5)
+        await asyncio.sleep(0.05)
+        assert "error" not in ws.sent_types()
+    finally:
+        ws.put({"type": "session.close"})
+        await asyncio.wait_for(handler_task, timeout=2)
+
+    assert len(engine.appended) == 2
+    for appended_session_id, mode, payload, final in engine.appended:
+        assert appended_session_id == session.session_id
+        assert mode == "append_audio_chunk"
+        assert final is False
+        assert isinstance(payload, dict)
+        assert np.frombuffer(base64.b64decode(payload["audio"]), dtype="<f4").shape == (16000,)
+        assert payload.get("force_listen") is not True
+    assert engine.appended_fences == [expected_fence, expected_fence]
+    assert engine.active_response_ids_at_append == [response_id, response_id]
+    assert engine.response_done_seen_at_append is False
+    assert not any(event in {"barge_in", "input.cancel"} for _, event in engine.signals)
+    assert ws.sent_types().count("response.speak") <= 1
+
+
+@pytest.mark.asyncio
+async def test_stale_terminal_event_does_not_reset_current_session_overlap():
+    handler, session = _auto_response_context("sid-stale-terminal")
+    session.epoch = 2
+    session.accumulate_overlap_speech(540)
+    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
+    native = MiniCPMO45ServingSessionState()
+
+    accepted, deferred = await handler._apply_outbound_session_event(
+        {"type": "response.done", "epoch": 1},
+        session=session,
+        actor=actor,
+        native=native,
+        realtime_protocol=None,
+    )
+
+    assert accepted is False
+    assert deferred is None
+    assert session.overlap_speech_ms == 540
+
+
+@pytest.mark.asyncio
+async def test_current_terminal_event_resets_session_owned_overlap():
+    handler, session = _auto_response_context("sid-current-terminal")
+    session.accumulate_overlap_speech(320)
+    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
+    native = MiniCPMO45ServingSessionState()
+
+    accepted, deferred = await handler._apply_outbound_session_event(
+        {"type": "response.done", "epoch": session.epoch},
+        session=session,
+        actor=actor,
+        native=native,
+        realtime_protocol=None,
+    )
+
+    assert accepted is True
+    assert deferred is None
+    assert session.overlap_speech_ms == 0
+
+
+@pytest.mark.asyncio
+async def test_response_listen_terminal_does_not_drive_serving_generation_state():
+    handler, session = _auto_response_context("sid-listen-terminal")
+    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
+    native = MiniCPMO45ServingSessionState()
+
+    accepted, deferred = await handler._apply_outbound_session_event(
+        {"type": "response.listen", "epoch": session.epoch},
+        session=session,
+        actor=actor,
+        native=native,
+        realtime_protocol=None,
+    )
+
+    assert accepted is True
+    assert deferred is None
+    assert session.turn_id == 0
+
+
+@pytest.mark.asyncio
+async def test_stale_audio_cancelled_does_not_reset_current_session_overlap():
+    handler, session = _auto_response_context("sid-stale-audio-cancelled")
+    session.epoch = 3
+    session.accumulate_overlap_speech(640)
+    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
+    native = MiniCPMO45ServingSessionState()
+
+    accepted, deferred = await handler._apply_outbound_session_event(
+        {"type": "audio.cancelled", "epoch": 2},
+        session=session,
+        actor=actor,
+        native=native,
+        realtime_protocol=None,
+    )
+
+    assert accepted is False
+    assert deferred is None
+    assert session.overlap_speech_ms == 640
+
+
+def test_auto_response_post_response_silence_remains_model_owned_input():
+    handler, session = _auto_response_context("sid-auto-waiting-silence", playback_active=True)
+    silent_payload = _native_audio_payload(value=0.0, is_speech=False, force_listen=False)
+    speech_payload = _native_audio_payload(force_listen=False)
+
+    assert handler._assistant_playback_active(session) is True
+    assert handler._should_force_listen_for_auto_response_overlap(session, {}, silent_payload) is False
+    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
+
+
+@pytest.mark.asyncio
+async def test_auto_response_terminal_advances_open_realtime_input_without_commit():
+    handler, session = _auto_response_context("sid-auto-realtime-open-input", playback_active=True)
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.active_response_id
+    assert response_id is not None
+
+    native = handler._minicpmo_session_state(session)
+    native.input_since_commit = True
+    native.speech_since_commit = True
+    session.accumulate_overlap_speech(800)
+    assert (
+        native.audio_buffer.append(
+            _native_audio_payload(samples=8000),
+            chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+        )
+        is None
+    )
+    session.end_response(commit_text=False, preserve_request=True)
+
+    allowed, promoted = await handler._apply_outbound_session_event(
+        {
+            "type": "response.done",
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "status": "completed",
+        },
+        session=session,
+        actor=DuplexWebSocketActor(TimedWebSocket()),
+        native=native,
+        realtime_protocol=NativeRealtimeSessionProtocol({}),
+    )
+
+    assert allowed is True
+    assert promoted is None
+    assert native.audio_buffer.has_pending()
+    assert native.committed_audio_payload is None
+    assert native.deferred_response_create is False
+    assert native.input_since_commit is True
+    assert native.speech_since_commit is True
+    next_speech = _native_audio_payload(samples=8000)
+    assert "new_user_turn" not in next_speech
+
+
+@pytest.mark.asyncio
+async def test_auto_response_terminal_allows_next_model_unit_while_playback_drains():
+    handler, session = _auto_response_context(
+        "sid-auto-realtime-open-before-overlap",
+        playback_active=True,
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.active_response_id
+    assert response_id is not None
+
+    native = handler._minicpmo_session_state(session)
+    native.input_since_commit = True
+    native.speech_since_commit = True
+    session.end_response(commit_text=False, preserve_request=True)
+
+    allowed, promoted = await handler._apply_outbound_session_event(
+        {
+            "type": "response.done",
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "status": "completed",
+        },
+        session=session,
+        actor=DuplexWebSocketActor(TimedWebSocket()),
+        native=native,
+        realtime_protocol=NativeRealtimeSessionProtocol({}),
+    )
+
+    assert allowed is True
+    assert promoted is None
+    assert native.input_since_commit is True
+    assert handler._assistant_playback_active(session) is True
+
+    next_speech = _native_audio_payload(samples=16_000)
+    assert "new_user_turn" not in next_speech
+
+
+@pytest.mark.asyncio
+async def test_realtime_committed_overlap_promotes_after_response_done():
+    handler, session = _auto_response_context("sid-auto-realtime-committed-input", playback_active=True)
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.active_response_id
+    assert response_id is not None
+
+    native = handler._minicpmo_session_state(session)
+    native.committed_audio_payload = _native_audio_payload()
+    native.deferred_response_create = True
+    session.accumulate_overlap_speech(1000)
+    session.end_response(commit_text=False, preserve_request=True)
+
+    allowed, promoted = await handler._apply_outbound_session_event(
+        {
+            "type": "response.done",
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "status": "completed",
+        },
+        session=session,
+        actor=DuplexWebSocketActor(TimedWebSocket()),
+        native=native,
+        realtime_protocol=NativeRealtimeSessionProtocol({}),
+    )
+
+    assert allowed is True
+    assert promoted is not None
+    assert promoted["force_listen"] is False
+    assert native.committed_audio_payload is promoted
+    assert native.deferred_response_create is False
+    assert "new_user_turn" not in promoted
+
+
+@pytest.mark.asyncio
+async def test_auto_response_committed_overlap_does_not_precreate_empty_response():
+    session_id = "sid-auto-overlap-no-empty-response"
+    request_id = f"duplex-{session_id}-e0-stage0"
+
+    def _stage_output(samples: int, *, turn_end: bool = False):
+        return SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[
+                SimpleNamespace(
+                    text="hello",
+                    multimodal_output={
+                        "audio": np.zeros(samples, dtype=np.float32),
+                        "sr": 24000,
+                        "meta": {
+                            "turn_end": turn_end,
+                            "duplex_turn_id": 0,
+                            "duplex_epoch": 0,
+                        },
+                    },
+                )
+            ],
+        )
+
+    first_append = {
+        "operation": "append",
+        "session_id": session_id,
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+        "data_plane_outputs": [_stage_output(2400)],
+    }
+    promoted_append = {
+        "operation": "append",
+        "session_id": session_id,
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [],
+        "data_plane_outputs": [],
+    }
+    engine = FakeEngineClient(
+        append_results=[first_append, promoted_append],
+        collect_outputs=[[_stage_output(4800, turn_end=True)]],
+        collect_delay_s=0.1,
+    )
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=2,
+    )
+
+    overlap_sent = False
+
+    def commit_overlap_after_first_response(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        nonlocal overlap_sent
+        if data.get("type") != "response.audio.delta" or overlap_sent:
+            return
+        overlap_sent = True
+        chunk = {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(3200, value=0.05),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+            "duration_ms": 200,
+            "is_speech": True,
+        }
+        for _ in range(4):
+            ws.put(chunk)
+        ws.put({"type": "input_audio_buffer.commit", "final": True})
+
+    ws = TimedWebSocket(on_send=commit_overlap_after_first_response, receive_timeout_s=3)
+    create = _native_realtime_session_update(session_id)
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000, value=0.05),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+            "duration_ms": 1000,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+
+    handler_task = asyncio.create_task(handler.handle_realtime_session(ws))
+    try:
+        for _ in range(300):
+            if len(engine.appended) >= 2:
+                break
+            await asyncio.sleep(0.01)
+        else:
+            pytest.fail(
+                f"committed overlap was not promoted after response.done: "
+                f"appends={len(engine.appended)}, events={ws.sent_types()}"
+            )
+
+        assert overlap_sent is True
+        assert len(engine.appended) == 2
+        assert engine.appended[1][3] is True
+        assert ws.sent_types().count("response.created") == 1
+    finally:
+        ws.put({"type": "session.close"})
+        await asyncio.wait_for(handler_task, timeout=3)
+
+    assert ws.sent_types().count("response.done") >= 1
+
+
+def test_auto_response_barge_in_does_not_mark_serving_new_user_turn_payload():
+    handler, session = _auto_response_context("sid-auto-barge-new-turn", playback_active=True)
+    payload = _native_audio_payload()
+
+    assert handler._should_force_listen_for_auto_response_overlap(session, {"force_barge_in": True}, payload) is False
+    assert "new_user_turn" not in payload
+    assert "new_user_turn_prefix_variant" not in payload
+    assert session.turn_id == 0
+    assert payload.get("force_speak") is not True
+
+
+def test_native_realtime_barge_in_payload_does_not_create_serving_turn_boundary():
+    payload: dict[str, object] = {
+        "type": "audio",
+        "audio": _pcm_f32_b64(16000, value=0.05),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16000,
+        "is_speech": True,
+    }
+    session = DuplexSession(session_id="sid-realtime-barge", config=DuplexSessionConfig())
+    session.turn_id = 2
+
+    assert "new_user_turn" not in payload
+    assert "new_user_turn_prefix_variant" not in payload
+    assert session.turn_id == 2
+
+
+def test_auto_response_force_barge_in_has_no_waiting_turn_variant():
+    handler, session = _auto_response_context("sid-auto-barge-keeps-variant")
+    payload = _native_audio_payload()
+
+    assert (
+        handler._should_force_listen_for_auto_response_overlap(
+            session,
+            {"force_barge_in": True},
+            payload,
+        )
+        is False
+    )
+
+
+def test_duplex_endpoint_requires_explicit_session_mode_duplex():
+    assert should_enable_duplex_endpoint(None) is False
+    assert should_enable_duplex_endpoint([]) is False
+    assert should_enable_duplex_endpoint([SimpleNamespace(session_mode="turn")]) is False
+    assert should_enable_duplex_endpoint([{"session_mode": "turn"}]) is False
+    assert (
+        should_enable_duplex_endpoint(
+            [
+                SimpleNamespace(session_mode="turn"),
+                SimpleNamespace(session_mode="duplex"),
+            ]
+        )
+        is True
+    )
+    assert should_enable_duplex_endpoint([{"session_mode": "duplex"}]) is True
+
+
+def test_duplex_endpoint_supports_top_level_session_mode(tmp_path):
+    config_path = tmp_path / "stage_config.yaml"
+    config_path.write_text(
+        """
+session_mode: duplex
+stage_args:
+  - stage_id: 0
+    engine_args: {}
+""",
+        encoding="utf-8",
+    )
+
+    assert should_enable_duplex_endpoint([], config_path=str(config_path)) is True
+
+
+def test_duplex_handler_splits_data_plane_audio_list_into_deltas():
+    import torch
+
+    data_plane = _test_data_plane()
+    output = SimpleNamespace(
+        finished=True,
+        outputs=[
+            SimpleNamespace(
+                text="hello",
+                multimodal_output={
+                    "audio": [
+                        torch.zeros(10, dtype=torch.float32),
+                        torch.zeros(20, dtype=torch.float32),
+                    ],
+                    "sr": 24000,
+                },
+            )
+        ],
+    )
+
+    native_results = list(data_plane.project_output(output))
+
+    assert [result["audio_data"] for result in native_results] == ["wav-10", "wav-20"]
+    assert [result["text"] for result in native_results] == ["hello", ""]
+    assert [result["end_of_turn"] for result in native_results] == [False, True]
+
+
+def test_duplex_listen_latent_does_not_poison_cumulative_audio_offset():
+    import torch
+
+    data_plane = _test_data_plane()
+    request_id = "duplex-duplex-sess-stage0"
+
+    # A model-listen decision wraps the segment with a latent tensor that is
+    # NOT reply audio; it must not advance the cumulative audio offset.
+    listen_output = SimpleNamespace(
+        request_id=request_id,
+        finished=True,
+        outputs=[],
+        multimodal_output={
+            "duplex_native_decision": "listen",
+            "model_listen": True,
+            "latent": torch.zeros(331776, dtype=torch.float32),
+            "meta": {"sr": 24000},
+        },
+    )
+    listen_results = list(data_plane.project_output(listen_output))
+    assert [result.get("is_listen") for result in listen_results] == [True]
+
+    # The first speak unit carries cumulative stage-1 audio far smaller than
+    # the listen latent; it must still be delivered from sample 0.
+    speak_output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[
+            SimpleNamespace(
+                text=" It was a very",
+                multimodal_output={},
+            )
+        ],
+        multimodal_output={
+            "audio": torch.zeros(32768, dtype=torch.float32),
+            "sr": 24000,
+        },
+    )
+    speak_results = list(data_plane.project_output(speak_output))
+    assert [result.get("audio_data") for result in speak_results] == ["wav-32768"]
+    assert speak_results[0]["text"] == " It was a very"
+
+
+def test_direct_listen_decision_survives_inner_completion_metadata():
+    inner_output = SimpleNamespace(
+        outputs=[
+            SimpleNamespace(
+                multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+            )
+        ]
+    )
+    decision = MiniCPMO45DuplexRuntimeExtension().decide_output(
+        stage_id=0,
+        final_stage_id=1,
+        segment_finished=True,
+        segment_token_ids=(151705,),
+        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
+        output=inner_output,
+    )
+    assert decision is not None
+    output = attach_duplex_output_decision(
+        OmniRequestOutput(
+            request_id="duplex-direct-listen",
+            finished=True,
+            stage_id=0,
+            final_output_type=decision.final_output_type,
+            request_output=inner_output,
+            metrics={
+                "stage_metrics": {
+                    "0": {
+                        "vllm_ttft_ms": 125.0,
+                        "vllm_tpot_ms": 18.0,
+                        "vllm_itl_ms": 17.5,
+                        "vllm_itls_ms": [17.0, 18.0],
+                    }
+                }
+            },
+        ),
+        decision,
+    )
+
+    results = list(_test_data_plane().project_output(output))
+
+    assert len(results) == 1
+    assert results[0]["is_listen"] is True
+    assert results[0]["model_listen"] is True
+    assert results[0]["listen_source"] == "model_listen"
+    assert results[0]["stage_metrics"] == output.metrics["stage_metrics"]
+
+
+def test_duplex_segment_text_is_attached_once_across_streaming_batches():
+    import torch
+
+    class _ChatService:
+        model_config = _ModelConfig()
+
+        def create_audio(self, audio_obj):
+            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
+
+    data_plane = _test_data_plane()
+    request_id = "duplex-duplex-sess-stage0"
+    session = DuplexSession(
+        session_id="sid-auto-respond",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+
+    def _speak(total_samples: int, text: str, *, finished: bool):
+        output = SimpleNamespace(
+            request_id=request_id,
+            finished=finished,
+            outputs=[SimpleNamespace(text=text, multimodal_output={})],
+            multimodal_output={
+                "audio": torch.zeros(total_samples, dtype=torch.float32),
+                "sr": 24000,
+            },
+        )
+        return _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    def _audio(results):
+        return [r for r in results if r.get("is_listen") is False]
+
+    def _listen(results):
+        return [r for r in results if r.get("is_listen") is True]
+
+    # One talker segment streams several cumulative-audio batches, each
+    # carrying the SAME segment text; only the first may attach it.
+    assert [r["text"] for r in _audio(_speak(100, " movie called", finished=False))] == [" movie called"]
+    assert [r["text"] for r in _audio(_speak(220, " movie called", finished=False))] == [""]
+    finished_results = _speak(300, " movie called", finished=True)
+    assert [r["text"] for r in _audio(finished_results)] == [""]
+    assert _listen(finished_results) == []
+
+    # Continuation units re-run the talker with the SAME handed text past a
+    # finished boundary (every engine segment ends finished=True); the text
+    # must stay suppressed or each continuation duplicates the transcript.
+    assert [r["text"] for r in _audio(_speak(400, " movie called", finished=False))] == [""]
+    assert [r["text"] for r in _audio(_speak(450, " movie called", finished=True))] == [""]
+
+    # A genuinely new segment text is attached in full.
+    assert [r["text"] for r in _audio(_speak(500, " Titanic", finished=True))] == [" Titanic"]
+
+    # Text growing within a segment is delivered as suffix deltas.
+    assert [r["text"] for r in _audio(_speak(600, " by", finished=False))] == [" by"]
+    assert [r["text"] for r in _audio(_speak(700, " by James", finished=True))] == [" James"]
+
+    # A segment whose finished batch slices to an EMPTY audio delta (all
+    # samples already delivered) must not block the next segment's text.
+    assert [r["text"] for r in _audio(_speak(800, " James Cameron. The", finished=False))] == [" James Cameron. The"]
+    assert _speak(800, " James Cameron. The", finished=True) == []
+    assert [r["text"] for r in _audio(_speak(900, " 997.", finished=False))] == [" 997."]
+
+
+def test_duplex_data_plane_output_prefers_audio_segment_text_metadata():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-native-segment-text-e0-stage0"
+    segment_text = "你好，有什么想聊的吗？"
+    cumulative_text = segment_text * 2
+    output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text=cumulative_text, multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(24000, dtype=np.float32),
+            "sr": 24000,
+            "meta.llm_output_text_utf8": np.frombuffer(segment_text.encode("utf-8"), dtype=np.uint8),
+        },
+    )
+
+    results = list(data_plane.project_output(output))
+
+    assert len(results) == 1
+    assert results[0]["audio_data"] == "wav-24000"
+    assert results[0]["text"] == segment_text
+
+    next_output_without_segment_metadata = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text=segment_text * 3, multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(30720, dtype=np.float32),
+            "sr": 24000,
+        },
+    )
+    next_results = list(data_plane.project_output(next_output_without_segment_metadata))
+
+    assert len(next_results) == 1
+    assert next_results[0]["audio_data"] == "wav-6720"
+    assert next_results[0]["text"] == ""
+
+
+@pytest.mark.parametrize(
+    ("request_id", "second_samples", "expected_second_audio"),
+    [
+        ("duplex-sid-model-turn-audio-e0-stage0", 36000, "wav-12000"),
+        ("duplex-sid-model-turn-audio-restart-e0-stage0", 12000, "wav-12000"),
+    ],
+    ids=["cumulative-across-model-turns", "upstream-cumulative-audio-restarts"],
+)
+def test_duplex_audio_cursor_across_model_turns(
+    request_id: str,
+    second_samples: int,
+    expected_second_audio: str,
+):
+    data_plane = _test_data_plane()
+
+    def output(turn_id: int, samples: int):
+        return SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[SimpleNamespace(text="", multimodal_output={})],
+            multimodal_output={
+                "audio": np.zeros(samples, dtype=np.float32),
+                "sr": 24000,
+                "meta.duplex_turn_id": np.array([turn_id], dtype=np.int32),
+            },
+        )
+
+    first = list(data_plane.project_output(output(0, 24000)))
+    second = list(data_plane.project_output(output(1, second_samples)))
+
+    assert first[0]["audio_data"] == "wav-24000"
+    assert second[0]["audio_data"] == expected_second_audio
+
+
+def test_duplex_data_plane_accepts_model_turn_output_across_client_commits():
+    data_plane = _test_data_plane()
+    session = DuplexSession(
+        session_id="sid-auto-stale-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.commit_native_audio_input()
+    session.commit_native_audio_input()
+    session.turn_id = 1
+    session.epoch = 0
+    request_id = "duplex-sid-auto-stale-turn-stage0"
+    output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text="old tail", multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(24000, dtype=np.float32),
+            "sr": 24000,
+            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
+            "meta.llm_output_text_utf8": np.frombuffer("旧尾巴".encode(), dtype=np.uint8),
+        },
+    )
+
+    results = list(data_plane.project_output(output, context=_data_plane_context(session)))
+
+    assert len(results) == 1
+    assert results[0]["audio_data"] == "wav-24000"
+    assert results[0]["model_turn_id"] == 1
+
+
+def test_duplex_data_plane_accepts_active_response_turn_identity():
+    data_plane = _test_data_plane()
+    session = DuplexSession(
+        session_id="sid-active-response-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.turn_id = 1
+    session.epoch = 0
+    session.begin_response(turn_id=0)
+    output = SimpleNamespace(
+        request_id="duplex-sid-active-response-turn-stage0",
+        finished=True,
+        outputs=[SimpleNamespace(text="", multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(10, dtype=np.float32),
+            "sr": 24000,
+            "meta.duplex_turn_id": np.array([0], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+
+
+def test_duplex_data_plane_listen_preserves_model_turn_identity():
+    data_plane = _test_data_plane()
+    session = DuplexSession(
+        session_id="sid-listen-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    output = SimpleNamespace(
+        request_id="duplex-sid-listen-turn-stage0",
+        finished=True,
+        outputs=[SimpleNamespace(text="", token_ids=[], multimodal_output={})],
+        multimodal_output={
+            "duplex_native_decision": "listen",
+            "meta.duplex_turn_id": np.array([2], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["is_listen"] is True
+    assert results[0]["model_turn_id"] == 2
+
+
+def test_duplex_data_plane_does_not_drop_future_model_turn_while_response_active():
+    data_plane = _test_data_plane()
+    session = DuplexSession(
+        session_id="sid-future-response-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.turn_id = 0
+    session.epoch = 0
+    session.begin_response(turn_id=0)
+    output = SimpleNamespace(
+        request_id="duplex-sid-future-response-turn-stage0",
+        finished=False,
+        outputs=[SimpleNamespace(text="", multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(10, dtype=np.float32),
+            "sr": 24000,
+            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["model_turn_id"] == 1
+    assert results[0]["audio_data"] == "wav-10"
+
+
+def _duplex_tts_output(
+    *,
+    request_id: str,
+    samples: int,
+    finished: bool,
+    text: str = "hello",
+    tts_is_last_chunk: bool = False,
+    turn_end: bool = False,
+    turn_id: int = 0,
+    token_ids: list[int] | None = None,
+):
+    return SimpleNamespace(
+        request_id=request_id,
+        finished=finished,
+        outputs=[SimpleNamespace(text=text, token_ids=list(token_ids or []), multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(samples, dtype=np.float32),
+            "sr": 24000,
+            "meta.tts_is_last_chunk": np.array([int(tts_is_last_chunk)], dtype=np.int32),
+            "meta.turn_end": np.array([int(turn_end)], dtype=np.int32),
+            "meta.duplex_turn_id": np.array([turn_id], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+
+
+@pytest.mark.parametrize(
+    (
+        "finished",
+        "tts_is_last_chunk",
+        "turn_end",
+        "consume_audio_first",
+        "expected_end_of_turn",
+        "expected_audio",
+    ),
+    [
+        (False, True, False, False, False, "wav-24000"),
+        (True, True, False, True, False, ""),
+        (True, True, True, True, True, ""),
+    ],
+    ids=[
+        "last-audio-batch-does-not-end-response",
+        "scheduler-eos-only-ends-tts-segment",
+        "explicit-turn-end-metadata-ends-response",
+    ],
+)
+def test_duplex_auto_response_tts_boundary(
+    finished: bool,
+    tts_is_last_chunk: bool,
+    turn_end: bool,
+    consume_audio_first: bool,
+    expected_end_of_turn: bool,
+    expected_audio: str,
+):
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-tts-boundary-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-tts-boundary",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.bind_response_turn(0)
+    if consume_audio_first:
+        data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
+    output = _duplex_tts_output(
+        request_id=request_id,
+        samples=24000,
+        finished=finished,
+        tts_is_last_chunk=tts_is_last_chunk,
+        turn_end=turn_end,
+        token_ids=[151645] if finished else None,
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+    boundary = results[0]
+    assert boundary["stage_role"] == "tts"
+    assert boundary["end_of_turn"] is expected_end_of_turn
+    assert boundary["abort_data_plane_request"] is True
+    assert boundary["audio_data"] == expected_audio
+
+
+def test_duplex_auto_response_tts_scheduler_eos_fallback():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-tts-eos-no-profile-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-tts-eos-no-profile",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.bind_response_turn(0)
+    data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
+    output = _duplex_tts_output(
+        request_id=request_id,
+        samples=24000,
+        finished=True,
+        tts_is_last_chunk=False,
+        token_ids=[151645],
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["stage_role"] == "tts"
+    assert results[0]["abort_data_plane_request"] is True
+
+
+def test_duplex_auto_response_rearms_tts_boundary_for_next_segment_in_same_turn():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-next-segment-same-turn-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-next-segment-same-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.bind_response_turn(0)
+    data_plane.begin_request(request_id)
+
+    first_segment = _duplex_tts_output(
+        request_id=request_id,
+        samples=24000,
+        finished=False,
+        tts_is_last_chunk=True,
+        turn_id=0,
+    )
+    first_results = _project_data_plane(
+        data_plane,
+        {"data_plane_outputs": [first_segment]},
+        session=session,
+    )
+
+    assert len(first_results) == 1
+    assert first_results[0]["abort_data_plane_request"] is True
+
+    data_plane.begin_request(request_id)
+    second_segment = _duplex_tts_output(
+        request_id=request_id,
+        samples=48000,
+        finished=False,
+        text="hello again",
+        tts_is_last_chunk=True,
+        turn_id=0,
+    )
+    second_results = _project_data_plane(
+        data_plane,
+        {"data_plane_outputs": [second_segment]},
+        session=session,
+    )
+
+    assert len(second_results) == 1
+    assert second_results[0]["audio_data"] == "wav-24000"
+    assert second_results[0]["abort_data_plane_request"] is True
+
+
+def test_duplex_turn_end_is_not_swallowed_by_finished_segment_fallback():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-turn-end-after-segment-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-turn-end-after-segment",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.begin_response(turn_id=0)
+    session.bind_request(request_id)
+    _project_data_plane(
+        data_plane,
+        {
+            "data_plane_outputs": [
+                _duplex_tts_output(
+                    request_id=request_id,
+                    samples=24000,
+                    finished=False,
+                    tts_is_last_chunk=True,
+                )
+            ]
+        },
+        session=session,
+    )
+    output = _duplex_tts_output(
+        request_id=request_id,
+        samples=24000,
+        finished=True,
+        text="",
+        tts_is_last_chunk=False,
+        turn_end=True,
+        token_ids=[151645],
+    )
+
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["stage_role"] == "tts"
+    assert results[0]["end_of_turn"] is True
+
+    duplicate = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert not any(result.get("end_of_turn") is True for result in duplicate)
+
+
+def test_duplex_auto_response_discards_terminal_only_audio_before_response_creation():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-terminal-only-audio-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-terminal-only-audio",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.bind_request(request_id)
+    first_audio = _duplex_tts_output(
+        request_id=request_id,
+        samples=3840,
+        finished=False,
+        text="",
+    )
+
+    assert _project_data_plane(data_plane, {"data_plane_outputs": [first_audio]}, session=session) == []
+
+    terminal = _duplex_tts_output(
+        request_id=request_id,
+        samples=3840,
+        finished=True,
+        text="",
+        tts_is_last_chunk=True,
+        turn_end=True,
+        token_ids=[151645],
+    )
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [terminal]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["audio_data"] == ""
+    assert results[0]["end_of_turn"] is True
+    assert session.active_request_id == request_id
+    assert not data_plane.is_terminal(request_id)
+
+
+def test_duplex_auto_response_releases_buffered_audio_when_transcript_arrives():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-delayed-transcript-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-delayed-transcript",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    audio_before_text = _duplex_tts_output(
+        request_id=request_id,
+        samples=100,
+        finished=False,
+        text="",
+    )
+
+    assert _project_data_plane(data_plane, {"data_plane_outputs": [audio_before_text]}, session=session) == []
+
+    audio_with_text = _duplex_tts_output(
+        request_id=request_id,
+        samples=200,
+        finished=False,
+        text="hello",
+    )
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [audio_with_text]}, session=session)
+
+    assert [result["audio_data"] for result in results] == ["wav-100", "wav-100"]
+    assert [result["text"] for result in results] == ["", "hello"]
+
+
+def test_duplex_auto_response_releases_buffered_audio_on_text_only_terminal():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-delayed-terminal-text-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-delayed-terminal-text",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    audio_before_text = _duplex_tts_output(
+        request_id=request_id,
+        samples=100,
+        finished=False,
+        text="",
+        turn_id=1,
+    )
+
+    assert _project_data_plane(data_plane, {"data_plane_outputs": [audio_before_text]}, session=session) == []
+
+    textless_turn_terminal = _duplex_tts_output(
+        request_id=request_id,
+        samples=100,
+        finished=True,
+        text="",
+        tts_is_last_chunk=True,
+        turn_end=True,
+        turn_id=1,
+        token_ids=[151645],
+    )
+    terminal_results = list(
+        data_plane.project(
+            {"data_plane_outputs": [textless_turn_terminal]},
+            context=_data_plane_context(session),
+        )
+    )
+
+    assert len(terminal_results) == 1
+    assert terminal_results[0]["audio_data"] == ""
+    assert terminal_results[0]["end_of_turn"] is True
+
+    text_only_terminal = SimpleNamespace(
+        request_id=request_id,
+        finished=True,
+        outputs=[SimpleNamespace(text="hello", token_ids=[151645], multimodal_output={})],
+        multimodal_output={
+            "sr": 24000,
+            "meta.tts_is_last_chunk": np.array([1], dtype=np.int32),
+            "meta.turn_end": np.array([1], dtype=np.int32),
+            "meta.duplex_turn_id": np.array([2], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+    results = _project_data_plane(data_plane, {"data_plane_outputs": [text_only_terminal]}, session=session)
+
+    assert len(results) == 1
+    assert results[0]["audio_data"] == "wav-100"
+    assert results[0]["text"] == "hello"
+    assert results[0]["end_of_turn"] is True
+    assert results[0]["abort_data_plane_request"] is True
+    assert not data_plane.has_pending_audio(request_id)
+
+
+@pytest.mark.asyncio
+async def test_native_append_propagates_current_turn_fence_to_engine():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-fenced-append",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.turn_id = 2
+    session.begin_response(turn_id=2)
+    ws = TimedWebSocket()
+
+    await handler._append_runtime_input(
+        session,
+        {"duplex_turn_id": 2, "audio": "", "format": "pcm_f32le"},
+        final=True,
+        send_json=ws.send_json,
+        mode="append_audio_chunk",
+        expected_epoch=0,
+    )
+
+    assert engine.appended_fences == [DuplexFence("sid-fenced-append", epoch=0, turn_id=2)]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_tts_segment_boundary_appends_silence_unit():
+    request_id = "duplex-sid-segment-boundary-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-segment-boundary",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.begin_response(turn_id=0)
+    session.turn_id = 1
+    session.bind_request(request_id)
+    session.mark_audio_sent(100)
+    _install_direct_silence_scheduler(handler, session)
+    ws = TimedWebSocket()
+
+    await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "",
+            "audio_data": "",
+            "audio_format": "pcm16",
+            "end_of_turn": False,
+            "abort_data_plane_request": True,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+    await asyncio.sleep(0.01)
+
+    assert len(engine.appended) == 1
+    _, mode, payload, final = engine.appended[0]
+    assert mode == "append_audio_chunk"
+    assert payload["format"] == "pcm_f32le"
+    assert payload["duplex_turn_id"] == 0
+    assert "force_speak" not in payload
+    assert final is False
+    assert session.active_response_id is not None
+    assert "response.done" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_pre_response_tts_boundary_continues_model_turn():
+    request_id = "duplex-sid-pre-response-boundary-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-pre-response-boundary",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    _install_direct_silence_scheduler(handler, session)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "model_turn_id": session.turn_id,
+            "text": "",
+            "audio_data": "",
+            "audio_format": "pcm16",
+            "end_of_turn": False,
+            "abort_data_plane_request": True,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+    await asyncio.sleep(0.01)
+
+    assert close_reason is None
+    assert emitted is False
+    assert session.active_response_id is None
+    assert ws.sent == []
+    assert len(engine.appended) == 1
+    _, mode, payload, final = engine.appended[0]
+    assert mode == "append_audio_chunk"
+    assert payload["duplex_turn_id"] == session.turn_id
+    assert final is False
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_pre_response_continuation_drops_after_model_turn_ends():
+    request_id = "duplex-sid-stale-pre-response-boundary-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-stale-pre-response-boundary",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    model_turn_id = session.turn_id
+
+    native = handler._minicpmo_session_state(session)
+
+    async def _stale_before_append(payload: object, **kwargs: Any) -> bool:
+        session.complete_model_turn(model_turn_id)
+        if handler._native_silence_continuation_is_stale(
+            session,
+            request_id=kwargs["request_id"],
+            response_id=kwargs["response_id"],
+            response_owned=kwargs["response_owned"],
+            expected_epoch=kwargs["expected_epoch"],
+            expected_incarnation=kwargs["expected_incarnation"],
+            expected_model_turn_id=kwargs["expected_model_turn_id"],
+        ):
+            return False
+        append_ok, _ = await handler._append_runtime_input(
+            session,
+            payload,
+            final=False,
+            send_json=kwargs["send_json"],
+            mode="append_audio_chunk",
+            expected_epoch=kwargs["expected_epoch"],
+        )
+        return append_ok
+
+    native.silence_continuation_scheduler = _stale_before_append
+
+    await handler._maybe_continue_native_response(
+        TimedWebSocket().send_json,
+        session=session,
+        expected_epoch=session.epoch,
+        expected_model_turn_id=model_turn_id,
+    )
+    await asyncio.sleep(0.01)
+
+    assert engine.appended == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_continuation_has_no_semantic_unit_cap():
+    request_id = "duplex-sid-long-response-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-long-response",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.begin_response(turn_id=0)
+    session.turn_id = 1
+    session.bind_request(request_id)
+    session.mark_audio_sent(100)
+    _install_direct_silence_scheduler(handler, session)
+    ws = TimedWebSocket()
+
+    for _ in range(9):
+        await handler._maybe_continue_native_response(
+            ws.send_json,
+            session=session,
+            expected_epoch=session.epoch,
+        )
+    await asyncio.sleep(0.02)
+
+    assert len(engine.appended) == 9
+    assert all(payload["duplex_turn_id"] == 0 for _, _, payload, _ in engine.appended)
+    assert all("force_speak" not in payload for _, _, payload, _ in engine.appended)
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_pre_speak_listen_continues_same_response():
+    request_id = "duplex-sid-pre-speak-listen-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-pre-speak-listen",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.begin_response(turn_id=0)
+    session.turn_id = 1
+    session.bind_request(request_id)
+    _install_direct_silence_scheduler(handler, session)
+    ws = TimedWebSocket()
+
+    await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "llm",
+            "is_listen": True,
+            "model_listen": True,
+            "data_plane_request_id": request_id,
+            "end_of_turn": False,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+    await asyncio.sleep(0.01)
+
+    assert len(engine.appended) == 1
+    assert session.active_response_id == response_id
+    assert session.active_request_id == request_id
+    assert "response.listen" not in ws.sent_types()
+    assert "response.done" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_listen_before_response_keeps_resumable_request():
+    request_id = "duplex-sid-listen-before-response-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-listen-before-response",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "llm",
+            "is_listen": True,
+            "model_listen": True,
+            "data_plane_request_id": request_id,
+            "end_of_turn": False,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is True
+    assert session.active_request_id == request_id
+    assert not handler._minicpmo_data_plane.is_terminal(request_id)
+    assert ws.sent_types().count("response.listen") == 1
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_listen_without_response_does_not_defer_commit():
+    session_id = "sid-listen-before-response-commit"
+    request_id = duplex_resource_request_id(DuplexFence(session_id), "stage0")
+    inner_output = SimpleNamespace(
+        outputs=[
+            SimpleNamespace(
+                multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+            )
+        ]
+    )
+    decision = MiniCPMO45DuplexRuntimeExtension().decide_output(
+        stage_id=0,
+        final_stage_id=1,
+        segment_finished=True,
+        segment_token_ids=(151705,),
+        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
+        output=inner_output,
+    )
+    assert decision is not None
+    listen_output = attach_duplex_output_decision(
+        OmniRequestOutput(
+            request_id=request_id,
+            finished=True,
+            stage_id=0,
+            final_output_type=decision.final_output_type,
+            request_output=inner_output,
+        ),
+        decision,
+    )
+    append_result = {
+        "operation": "append",
+        "session_id": session_id,
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+        "data_plane_outputs": [listen_output],
+    }
+    engine = FakeEngineClient(append_result=append_result)
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    listen_count = 0
+
+    def append_residual_after_listen(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        nonlocal listen_count
+        if data.get("type") == "response.listen":
+            listen_count += 1
+            if listen_count == 1:
+                ws.put(
+                    {
+                        "type": "input_audio_buffer.append",
+                        "audio": _pcm_f32_b64(3_200),
+                        "format": "pcm_f32le",
+                        "sample_rate_hz": 16_000,
+                        "duration_ms": 200,
+                        "is_speech": True,
+                    }
+                )
+                ws.put({"type": "input_audio_buffer.commit", "final": True})
+        elif data.get("type") == "input_audio_buffer.committed":
+            asyncio.get_running_loop().call_later(0.05, ws.put, {"type": "session.close"})
+
+    ws = TimedWebSocket(on_send=append_residual_after_listen, receive_timeout_s=2)
+    create = _native_realtime_session_update(session_id)
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16_000),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16_000,
+            "duration_ms": 1_000,
+            "is_speech": True,
+        }
+    )
+
+    await handler.handle_realtime_session(ws)
+
+    committed = [event for event in ws.sent if event.get("type") == "input_audio_buffer.committed"]
+    assert len(engine.appended) == 2
+    assert engine.appended[1][3] is True
+    assert len(committed) == 1
+    assert committed[0].get("event", {}).get("overlap_deferred") is not True
+    assert committed[0].get("event", {}).get("response_create_deferred") is not True
+    assert "response.created" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_pcm_f32_residual_commit_releases_pending_input_bytes():
+    session_id = "sid-pcm-residual-byte-accounting"
+    control_result = {
+        "operation": "append",
+        "session_id": session_id,
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [],
+    }
+    engine = FakeEngineClient(control_result=control_result)
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket(receive_timeout_s=2)
+    create = _native_realtime_session_update(session_id)
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+    handler_task = asyncio.create_task(handler.handle_realtime_session(ws))
+
+    try:
+        for _ in range(100):
+            session = handler._registry.get(session_id)
+            if session is not None and "session.created" in ws.sent_types():
+                break
+            await asyncio.sleep(0.01)
+        else:
+            pytest.fail("native duplex session did not open")
+
+        pending_bytes_after_turn: list[int] = []
+        for turn_index in range(3):
+            ws.put(
+                {
+                    "type": "input_audio_buffer.append",
+                    "audio": _pcm_f32_b64(19_200),
+                    "format": "pcm_f32le",
+                    "sample_rate_hz": 16_000,
+                    "duration_ms": 1_200,
+                    "is_speech": True,
+                }
+            )
+            ws.put({"type": "input_audio_buffer.commit", "final": True})
+            expected_appends = (turn_index + 1) * 2
+            for _ in range(100):
+                if len(engine.appended) >= expected_appends:
+                    await asyncio.sleep(0)
+                    break
+                await asyncio.sleep(0.01)
+            else:
+                pytest.fail(f"turn {turn_index} residual append did not complete")
+            pending_bytes_after_turn.append(session.pending_input_bytes)
+    finally:
+        ws.put({"type": "session.close"})
+        await asyncio.wait_for(handler_task, timeout=2)
+
+    assert pending_bytes_after_turn == [0, 0, 0]
+    assert not any(
+        event.get("type") == "error"
+        and isinstance(event.get("error"), dict)
+        and event["error"].get("code") == "input_backpressure"
+        for event in ws.sent
+    )
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_post_speak_listen_continues_same_response():
+    request_id = "duplex-sid-post-speak-listen-e0-stage0"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid-post-speak-listen",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.begin_response(turn_id=0)
+    session.turn_id = 1
+    session.bind_request(request_id)
+    session.mark_audio_sent(100)
+    _install_direct_silence_scheduler(handler, session)
+    ws = TimedWebSocket()
+
+    await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "llm",
+            "is_listen": True,
+            "model_listen": True,
+            "data_plane_request_id": request_id,
+            "end_of_turn": False,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+    await asyncio.sleep(0.01)
+
+    assert len(engine.appended) == 1
+    assert session.active_response_id == response_id
+    assert session.active_request_id == request_id
+    assert "response.listen" not in ws.sent_types()
+    assert "response.done" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_turn_end_preserves_resumable_request():
+    request_id = "duplex-sid-turn-end-preserve-request-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-turn-end-preserve-request",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.begin_response(turn_id=0)
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "done",
+            "audio_data": "audio",
+            "audio_format": "pcm16",
+            "audio_duration_ms": 100,
+            "end_of_turn": True,
+            "model_turn_id": 0,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert session.active_response_id is None
+    assert session.active_request_id == request_id
+    assert "response.done" in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_empty_turn_end_emits_model_listen():
+    request_id = "duplex-sid-empty-turn-end-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-empty-turn-end",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "",
+            "audio_data": "",
+            "audio_format": "pcm16",
+            "end_of_turn": True,
+            "abort_data_plane_request": True,
+            "model_turn_id": 0,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is True
+    assert session.turn_id == 1
+    assert session.active_request_id == request_id
+    assert session.active_response_id is None
+    assert ws.sent_types() == ["response.listen"]
+    assert ws.sent[0]["model_listen"] is True
+    assert ws.sent[0]["reason"] == "model_turn_completed_without_output"
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_drops_late_audio_from_completed_model_turn():
+    request_id = "duplex-sid-late-completed-turn-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-late-completed-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    session.complete_model_turn(0)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "late duplicate",
+            "audio_data": "late-audio",
+            "audio_format": "pcm16",
+            "audio_duration_ms": 100,
+            "end_of_turn": True,
+            "model_turn_id": 0,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is False
+    assert session.turn_id == 1
+    assert session.active_response_id is None
+    assert "response.created" not in ws.sent_types()
+    assert "response.done" not in ws.sent_types()
+
+
+def test_duplex_data_plane_drops_stale_epoch_audio_after_barge_in():
+    class _ChatService:
+        model_config = _ModelConfig()
+
+        def create_audio(self, audio_obj):
+            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
+
+    data_plane = _test_data_plane()
+    session = DuplexSession(
+        session_id="sid-auto-stale-epoch",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.turn_id = 1
+    session.epoch = 2
+    output = SimpleNamespace(
+        request_id="duplex-sid-auto-stale-epoch-stage0",
+        finished=False,
+        outputs=[SimpleNamespace(text="old epoch", multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(24000, dtype=np.float32),
+            "sr": 24000,
+            "meta.duplex_epoch": np.array([1], dtype=np.int32),
+            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
+            "meta.llm_output_text_utf8": np.frombuffer("旧轮".encode(), dtype=np.uint8),
+        },
+    )
+
+    assert list(data_plane.project_output(output, context=_data_plane_context(session))) == []
+
+
+def test_duplex_data_plane_text_delta_preserves_repeated_suffix_growth():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-native-repeated-word-e0-stage0"
+
+    assert data_plane.segment_text_delta(request_id, "好的") == "好的"
+    assert data_plane.segment_text_delta(request_id, "好的好的") == "好的"
+
+
+def test_duplex_data_plane_text_delta_appends_distinct_non_prefix_segments():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-native-rewrite-e0-stage0"
+
+    deltas = [
+        data_plane.segment_text_delta(request_id, "It's Canberra."),
+        data_plane.segment_text_delta(request_id, " Next question."),
+    ]
+
+    assert deltas == ["It's Canberra.", " Next question."]
+    assert "".join(deltas) == "It's Canberra. Next question."
+
+
+def test_duplex_data_plane_close_session_removes_encoded_request_state():
+    data_plane = _test_data_plane()
+    target_request_id = duplex_resource_request_id(
+        DuplexFence("sid-to-close", incarnation=1, epoch=2),
+        "stage0",
+    )
+    other_request_id = duplex_resource_request_id(
+        DuplexFence("sid-to-keep", incarnation=1, epoch=2),
+        "stage0",
+    )
+    data_plane.begin_request(target_request_id)
+    data_plane.begin_request(other_request_id)
+
+    data_plane.close_session("sid-to-close")
+
+    assert data_plane.has_request(target_request_id) is False
+    assert data_plane.has_request(other_request_id) is True
+
+
+def test_duplex_auto_response_segment_complete_keeps_data_plane_request_open():
+    import numpy as np
+
+    class _ChatService:
+        model_config = _ModelConfig()
+
+        def create_audio(self, audio_obj):
+            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
+
+    data_plane = _test_data_plane()
+    request_id = "duplex-duplex-sess-stage0"
+    session = DuplexSession(
+        session_id="sid-auto-respond",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.begin_response()
+    session.mark_audio_sent(1280)
+    data_plane.slice_cumulative_audio(request_id, np.zeros(30720, dtype=np.float32))
+
+    output = SimpleNamespace(
+        request_id=request_id,
+        finished=True,
+        outputs=[SimpleNamespace(text="hello", multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(30720, dtype=np.float32),
+            "sr": 24000,
+        },
+    )
+
+    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert len(native_results) == 1
+    assert native_results[0]["is_listen"] is True
+    assert native_results[0]["reason"] == "auto_response_segment_complete"
+    assert native_results[0]["data_plane_request_id"] == request_id
+    assert "abort_data_plane_request" not in native_results[0]
+
+
+def test_duplex_auto_response_prior_playback_does_not_abort_before_current_response():
+    data_plane = _test_data_plane()
+    request_id = "duplex-duplex-sess-stage0"
+    session = DuplexSession(
+        session_id="sid-auto-respond-next-turn",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.mark_audio_sent(1280)
+    session.acknowledge_playback(played_ms=1280, committed_ms=1280)
+
+    output = SimpleNamespace(
+        request_id=request_id,
+        finished=True,
+        outputs=[SimpleNamespace(text="", multimodal_output={})],
+        multimodal_output={},
+    )
+
+    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
+
+    assert native_results == []
+
+
+def test_duplex_auto_response_text_only_flush_does_not_consume_audio_transcript():
+    import numpy as np
+
+    data_plane = _test_data_plane()
+    request_id = "duplex-duplex-sess-stage0"
+    session = DuplexSession(
+        session_id="sid-auto-respond-delayed-audio",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    text = "你好呀，有什莫问的吗？"
+
+    text_only_output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text=text, multimodal_output={})],
+        multimodal_output={"sr": 24000},
+    )
+
+    assert _project_data_plane(data_plane, {"data_plane_outputs": [text_only_output]}, session=session) == []
+
+    audio_output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text=text, multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(24000, dtype=np.float32),
+            "sr": 24000,
+        },
+    )
+
+    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [audio_output]}, session=session)
+
+    assert len(native_results) == 1
+    assert native_results[0]["audio_data"].startswith("wav-")
+    assert native_results[0]["text"] == text
+
+
+@pytest.mark.asyncio
+async def test_duplex_auto_response_empty_terminal_does_not_create_empty_response():
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    request_id = "duplex-sid-native-empty-terminal-e0-stage0"
+    session = DuplexSession(
+        session_id="sid-native-empty-terminal",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.mark_audio_sent(1280)
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(payload: dict[str, Any]) -> None:
+        sent.append(payload)
+
+    output = SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text="hello", multimodal_output={})],
+        multimodal_output={
+            "sr": 24000,
+            "meta": {"turn_end": True, "duplex_turn_id": 0},
+        },
+    )
+
+    native_results = list(
+        handler._minicpmo_data_plane.project(
+            {"data_plane_outputs": [output]},
+            context=_data_plane_context(session),
+        )
+    )
+    assert len(native_results) == 1
+    assert native_results[0]["end_of_turn"] is True
+    assert native_results[0]["model_turn_id"] == 0
+
+    for native_result in native_results:
+        await handler._send_one_native_duplex_event(send_json, native_result, session=session)
+
+    assert "response.created" not in [m.get("type") for m in sent]
+    assert "response.done" not in [m.get("type") for m in sent]
+    assert session.turn_id == 1
+    assert not handler._minicpmo_data_plane.is_terminal(request_id)
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_session_close_cleans_auto_response_data_plane_state():
+    session_id = "sid-native-cleanup"
+    request_id = f"duplex-{session_id}-e0-stage0"
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    handler._minicpmo_data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
+    handler._minicpmo_data_plane.segment_text_delta(request_id, "hello")
+    handler._minicpmo_data_plane.mark_terminal(request_id)
+    native = MiniCPMO45ServingSessionState()
+    handler._minicpmo_sessions[session_id] = native
+
+    event = _native_session_create(session_id)
+    event["session"]["extra_body"]["auto_response"] = True
+    ws = TimedWebSocket()
+    ws.put(event)
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert not handler._minicpmo_data_plane.has_request(request_id)
+    assert session_id not in handler._minicpmo_sessions
+
+
+@pytest.mark.asyncio
+async def test_duplex_chat_audio_stream_uses_output_audio_delta_event():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    session = DuplexSession(session_id="sid-chat-audio", config=DuplexSessionConfig())
+    response_id = session.begin_response()
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(data: dict[str, Any]) -> None:
+        sent.append(data)
+
+    await handler._emit_chat_payload(
+        session,
+        {
+            "modality": "audio",
+            "choices": [
+                {
+                    "delta": {
+                        "content": "AAAA",
+                    }
+                }
+            ],
+        },
+        session.epoch,
+        response_id,
+        send_json,
+    )
+
+    assert sent == [
+        {
+            "type": "response.output_audio.delta",
+            "session_id": "sid-chat-audio",
+            "response_id": response_id,
+            "epoch": 0,
+            "audio": "AAAA",
+            "format": "wav",
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_duplex_chat_rejects_unknown_output_modality():
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(session_id="sid-chat-unknown", config=DuplexSessionConfig())
+    response_id = session.begin_response()
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(data: dict[str, Any]) -> None:
+        sent.append(data)
+
+    await handler._emit_chat_payload(
+        session,
+        {
+            "modality": "video",
+            "choices": [{"delta": {"content": "not-text"}}],
+        },
+        session.epoch,
+        response_id,
+        send_json,
+    )
+
+    assert sent == [
+        {
+            "type": "error",
+            "session_id": session.session_id,
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "code": "unsupported_response_modality",
+            "error": "Unsupported chat response modality: video",
+        }
+    ]
+    assert session.assistant_text_buffer == ()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_model_name_does_not_auto_enable_experimental_native_duplex():
+    event = _session_create("sid-minicpmo-default-protocol")
+    event["session"]["model"] = "openbmb/MiniCPM-o-4_5"
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(event)
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    created = next(m for m in ws.sent if m.get("type") == "session.created")
+    capabilities = created["session"]["capabilities"]
+    assert capabilities["implementation_level"] == "serving_session_adapter"
+    assert capabilities["supports_input_append"] is False
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_aborts_current_chat_request_id_on_barge_in():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "response.created":
+            ws.put({"type": "input.cancel", "reason": "test_barge_in"})
+
+    ws = TimedWebSocket(on_send=on_send)
+    ws.put(_session_create("sid-a"))
+    ws.put({"type": "input.text.append", "text": "hello"})
+    ws.put({"type": "input.commit"})
+
+    await handler.handle_session(ws)
+
+    assert ws.accepted
+    assert "response.created" in ws.sent_types()
+    assert "audio.cancelled" in ws.sent_types()
+    assert chat_service.seen_request_ids == ["duplex-sid-a-0-1"]
+    assert engine.aborted == ["chatcmpl-duplex-sid-a-0-1"]
+    assert engine.internal_abort_batches == [["chatcmpl-duplex-sid-a-0-1"]]
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_runtime_open_failure_is_reported_to_client():
+    engine = FakeEngineClient(fail_open=True)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-open-fail"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "runtime_open_failed"
+    assert engine.opened == []
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_preserves_typed_admission_error():
+    class AdmissionRejectingEngine(FakeEngineClient):
+        async def open_duplex_session_async(self, session_id: str, **kwargs):
+            del kwargs
+            raise DuplexControlRequestError(
+                {
+                    "operation": "open",
+                    "session_id": session_id,
+                    "error": {
+                        "code": "resource_exhausted",
+                        "message": "duplex session capacity exhausted",
+                        "retryable": True,
+                    },
+                    "accepted_fence": None,
+                    "lease_generation": None,
+                }
+            )
+
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(AdmissionRejectingEngine()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-admission-rejected"))
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "resource_exhausted"
+    assert ws.sent[0]["retryable"] is True
+
+
+@pytest.mark.asyncio
+async def test_duplex_cancel_reports_playback_committed_cursor():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "response.created":
+            ws.put({"type": "playback.ack", "played_ms": 1200, "committed_ms": 1000})
+            ws.put({"type": "input.cancel", "reason": "test_barge_in"})
+
+    ws = TimedWebSocket(on_send=on_send)
+    ws.put(_session_create("sid-playback"))
+    ws.put({"type": "input.text.append", "text": "hello"})
+    ws.put({"type": "input.commit"})
+
+    await handler.handle_session(ws)
+
+    ack = next(m for m in ws.sent if m.get("type") == "playback.acknowledged")
+    cancelled = next(m for m in ws.sent if m.get("type") == "audio.cancelled")
+    assert ack["playback"]["played_ms"] == 1200
+    assert ack["playback"]["committed_ms"] == 1000
+    assert cancelled["committed_ms"] == 1000
+    assert cancelled["epoch"] == 1
+
+
+@pytest.mark.asyncio
+async def test_playback_ack_response_id_selects_matching_pending_history_item():
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-playback-response-id",
+        config=DuplexSessionConfig(),
+    )
+    first_item_id = "item_resp-first"
+    second_item_id = "item_resp-second"
+    session.stage_pending_history_item(
+        first_item_id,
+        {"role": "assistant", "content": "first response"},
+    )
+    session.stage_pending_history_item(
+        second_item_id,
+        {"role": "assistant", "content": "second response"},
+    )
+    ws = TimedWebSocket()
+
+    await handler._handle_playback_ack(
+        session,
+        {
+            "type": "playback.ack",
+            "response_id": "resp-second",
+            "played_ms": 1000,
+            "committed_ms": 1000,
+        },
+        ws.send_json,
+    )
+
+    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
+    assert ack["item_id"] == second_item_id
+    assert ack["history_committed"] is True
+    assert first_item_id in session.pending_history_item_ids
+    assert second_item_id not in session.pending_history_item_ids
+
+
+@pytest.mark.asyncio
+async def test_late_playback_ack_does_not_advance_new_response_cursor():
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-late-playback-ack",
+        config=DuplexSessionConfig(),
+    )
+    first_response_id = session.begin_response()
+    session.append_assistant_text("first response")
+    session.mark_audio_sent(11480, text_chars=len("first response"))
+    session.end_response(commit_text=False, preserve_request=True)
+    session.register_history_item(f"item_{first_response_id}", None)
+
+    second_response_id = session.begin_response()
+    session.mark_audio_sent(2200, text_chars=len("second response"))
+    ws = TimedWebSocket()
+
+    await handler._handle_playback_ack(
+        session,
+        {
+            "type": "playback.ack",
+            "response_id": first_response_id,
+            "item_id": f"item_{first_response_id}",
+            "played_ms": 11480,
+            "committed_ms": 11480,
+        },
+        ws.send_json,
+    )
+
+    assert session.active_response_id == second_response_id
+    assert session.playback.as_dict() == {
+        "generated_ms": 2200,
+        "sent_ms": 2200,
+        "played_ms": 0,
+        "committed_ms": 0,
+    }
+    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
+    assert ack["playback"] == {
+        "generated_ms": 11480,
+        "sent_ms": 11480,
+        "played_ms": 11480,
+        "committed_ms": 11480,
+    }
+    assert first_response_id not in session.response_playbacks
+    assert session.response_playbacks[second_response_id] == session.playback
+
+
+@pytest.mark.asyncio
+async def test_late_playback_ack_truncates_history_with_matching_response_cursor():
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(FakeEngineClient()),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-late-playback-history",
+        config=DuplexSessionConfig(),
+    )
+    first_response_id = session.begin_response()
+    session.append_assistant_text("abcdefghij")
+    session.mark_audio_sent(1000)
+    session.end_response(commit_text=False, preserve_request=True)
+    session.register_history_item(f"item_{first_response_id}", None)
+
+    session.begin_response()
+    session.mark_audio_sent(10000)
+    ws = TimedWebSocket()
+
+    await handler._handle_playback_ack(
+        session,
+        {
+            "type": "playback.ack",
+            "response_id": first_response_id,
+            "item_id": f"item_{first_response_id}",
+            "played_ms": 500,
+            "committed_ms": 500,
+        },
+        ws.send_json,
+    )
+
+    assert session.history[-1] == {"role": "assistant", "content": "abcde"}
+    assert first_response_id in session.response_playbacks
+
+
+@pytest.mark.asyncio
+async def test_cancel_active_response_commits_only_played_assistant_history():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    session = DuplexSession(
+        session_id="sid-playback-partial",
+        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value),
+    )
+    response_id = session.begin_response()
+    session.append_assistant_text("hello world")
+    session.mark_audio_sent(1000, text_chars=len("hello world"))
+    session.acknowledge_playback(played_ms=500, committed_ms=500)
+
+    cancelled = await handler._cancel_active_response(session, None, ws.send_json, reason="barge_in")
+
+    assert cancelled is True
+    assert session.epoch == 1
+    assert session.history == ({"role": "assistant", "content": "hello"},)
+    assert session.history_item_ids[f"item_{response_id}"] == session.history[0]
+    event = next(m for m in ws.sent if m.get("type") == "audio.cancelled")
+    assert event["committed_ms"] == 500
+
+
+@pytest.mark.asyncio
+async def test_cancel_active_response_keeps_truncated_history_in_serving():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    session = DuplexSession(
+        session_id="sid-playback-runtime-rebuild",
+        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value),
+    )
+    response_id = session.begin_response()
+    session.append_assistant_text("hello world")
+    session.mark_audio_sent(1000, text_chars=len("hello world"))
+    session.acknowledge_playback(played_ms=500, committed_ms=500)
+
+    cancelled = await handler._cancel_active_response(
+        session,
+        None,
+        ws.send_json,
+        reason="barge_in",
+    )
+
+    assert cancelled is True
+    assert session.history == ({"role": "assistant", "content": "hello"},)
+    assert session.history_item_ids[f"item_{response_id}"] == session.history[0]
+    assert engine.signals == []
+    assert "error" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_cancel_active_native_data_plane_request_aborts_stage_request_id():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    session = DuplexSession(session_id="sid-native-abort", config=DuplexSessionConfig())
+    session.bind_request("duplex-sid-native-abort-e0-stage0-s1")
+
+    cancelled = await handler._cancel_active_response(session, None, ws.send_json, reason="barge_in")
+
+    assert cancelled is True
+    assert engine.aborted == ["duplex-sid-native-abort-e0-stage0-s1"]
+    assert engine.internal_abort_batches == [["duplex-sid-native-abort-e0-stage0-s1"]]
+    assert "audio.cancelled" in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_explicit_close_closes_runtime_once_with_client_reason():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-close"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["session.created", "session.closed"]
+    assert engine.closed == [("sid-close", "session_close")]
+
+
+@pytest.mark.asyncio
+async def test_realtime_disconnect_detaches_resumable_session_without_runtime_close():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket(receive_timeout_s=0.01)
+    ws.put(_native_realtime_session_update("sid-resumable-disconnect"))
+
+    await handler.handle_realtime_session(ws)
+
+    created = next(message for message in ws.sent if message.get("type") == "session.created")
+    assert created["session"]["id"] == "sid-resumable-disconnect"
+    assert isinstance(created["resume_token"], str)
+    assert created["resume_token"]
+    assert created["attachment_generation"] == 1
+    assert engine.closed == []
+    assert engine.touched == [
+        ("sid-resumable-disconnect", DuplexLeaseActivity.DETACH),
+    ]
+    assert handler._registry.get("sid-resumable-disconnect") is not None
+    assert "sid-resumable-disconnect" in handler._minicpmo_sessions
+
+
+@pytest.mark.asyncio
+async def test_realtime_initial_resume_token_delivery_failure_closes_unrecoverable_session():
+    class FailingCreatedWebSocket(TimedWebSocket):
+        async def send_json(self, data: dict[str, Any]):
+            if data.get("type") == "session.created":
+                raise WebSocketDisconnect(code=1006)
+            await super().send_json(data)
+
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = FailingCreatedWebSocket(receive_timeout_s=0.01)
+    ws.put(_native_realtime_session_update("sid-created-delivery-failure"))
+
+    await handler.handle_realtime_session(ws)
+
+    assert engine.closed == [("sid-created-delivery-failure", "disconnect")]
+    assert handler._registry.get("sid-created-delivery-failure") is None
+    assert "sid-created-delivery-failure" not in handler._minicpmo_sessions
+
+
+@pytest.mark.asyncio
+async def test_realtime_send_after_created_disconnect_preserves_resumable_session():
+    class ClosedAfterCreatedWebSocket(TimedWebSocket):
+        def __init__(self) -> None:
+            super().__init__(receive_timeout_s=0.01)
+            self.transport_closed = False
+
+        async def send_json(self, data: dict[str, Any]):
+            if self.transport_closed:
+                raise RuntimeError(
+                    "Unexpected ASGI message 'websocket.send', "
+                    "after sending 'websocket.close' or response already completed."
+                )
+            await super().send_json(data)
+            if data.get("type") == "session.created":
+                self.transport_closed = True
+
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = ClosedAfterCreatedWebSocket()
+    ws.put(_native_realtime_session_update("sid-created-then-disconnected"))
+
+    await handler.handle_realtime_session(ws)
+
+    assert engine.closed == []
+    assert engine.touched == [
+        ("sid-created-then-disconnected", DuplexLeaseActivity.DETACH),
+    ]
+    assert handler._registry.get("sid-created-then-disconnected") is not None
+    assert "sid-created-then-disconnected" in handler._minicpmo_sessions
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_rotates_token_replays_and_preserves_runtime_identity():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = TimedWebSocket(receive_timeout_s=0.01)
+    first.put(_native_realtime_session_update("sid-realtime-resume"))
+    first.put({"type": "session.heartbeat"})
+
+    await handler.handle_realtime_session(first)
+
+    created = next(message for message in first.sent if message.get("type") == "session.created")
+    heartbeat = next(message for message in first.sent if message.get("type") == "session.heartbeat_ack")
+    token = created["resume_token"]
+    incarnation = created["incarnation"]
+    second = TimedWebSocket(receive_timeout_s=0.1)
+    second.query_params = {
+        "model": "openbmb/MiniCPM-o-4_5",
+        "minicpmo45_native_duplex": "1",
+        "resume": "1",
+    }
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-realtime-resume",
+            "incarnation": incarnation,
+            "resume_token": token,
+            "last_received_server_event_seq": heartbeat["server_event_seq"] - 1,
+        }
+    )
+    second.put({"type": "session.close"})
+
+    await handler.handle_realtime_session(second)
+
+    resumed = next(message for message in second.sent if message.get("type") == "session.resumed")
+    replayed = [
+        message
+        for message in second.sent
+        if message.get("type") == "session.heartbeat_ack"
+        and message.get("server_event_seq") == heartbeat["server_event_seq"]
+    ]
+    assert resumed["session_id"] == "sid-realtime-resume"
+    assert resumed["incarnation"] == incarnation
+    assert resumed["attachment_generation"] == 2
+    assert resumed["resume_token"] != token
+    assert replayed == [heartbeat]
+    assert engine.opened == ["sid-realtime-resume"]
+    assert engine.resumed == [("sid-realtime-resume", 0)]
+    assert engine.resume_fences[0] == engine.opened_fences[0]
+    assert engine.closed == [("sid-realtime-resume", "session_close")]
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_preserves_append_tail_order_across_connections():
+    class SlowFirstAppendEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            super().__init__()
+            self.first_append_started = asyncio.Event()
+            self.second_append_started = asyncio.Event()
+            self.release_first_append = asyncio.Event()
+            self.append_start_order: list[int] = []
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            call_index = len(self.append_start_order) + 1
+            self.append_start_order.append(call_index)
+            if call_index == 1:
+                self.first_append_started.set()
+                await self.release_first_append.wait()
+            else:
+                self.second_append_started.set()
+            kwargs.pop("expected_epoch", None)
+            return await super().append_duplex_input_async(session_id, **kwargs)
+
+    engine = SlowFirstAppendEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = TimedWebSocket(receive_timeout_s=1.0)
+    session_update = _native_realtime_session_update("sid-resume-append-order")
+    session_update["session"]["extra_body"]["auto_response"] = True
+    first.put(session_update)
+    first_task = asyncio.create_task(handler.handle_realtime_session(first))
+    for _ in range(100):
+        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
+        if created is not None:
+            break
+        await asyncio.sleep(0.01)
+    else:
+        pytest.fail("resumable session did not open")
+    session = handler._registry.get("sid-resume-append-order")
+    assert session is not None
+    native_state = handler._minicpmo_session_state(session)
+    first_scheduler = native_state.silence_continuation_scheduler
+    assert first_scheduler is not None
+    first.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    await asyncio.wait_for(engine.first_append_started.wait(), timeout=1)
+    await first.close(code=1006)
+    await asyncio.wait_for(first_task, timeout=1)
+
+    second = TimedWebSocket(receive_timeout_s=0.5)
+    second.query_params = {
+        "model": "openbmb/MiniCPM-o-4_5",
+        "minicpmo45_native_duplex": "1",
+        "resume": "1",
+    }
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-resume-append-order",
+            "incarnation": created["incarnation"],
+            "resume_token": created["resume_token"],
+            "last_received_server_event_seq": created.get("server_event_seq", 0),
+        }
+    )
+    second_task = asyncio.create_task(handler.handle_realtime_session(second))
+    for _ in range(100):
+        if "session.resumed" in second.sent_types():
+            break
+        await asyncio.sleep(0.01)
+    else:
+        pytest.fail("session did not resume")
+    assert native_state.silence_continuation_scheduler is not first_scheduler
+    second.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    try:
+        await asyncio.sleep(0.05)
+        assert not engine.second_append_started.is_set()
+    finally:
+        engine.release_first_append.set()
+
+    await asyncio.wait_for(engine.second_append_started.wait(), timeout=1)
+    second.put({"type": "session.close"})
+    await asyncio.wait_for(second_task, timeout=2)
+    assert engine.append_start_order == [1, 2]
+
+
+@pytest.mark.asyncio
+async def test_realtime_takeover_ignores_late_detach_from_replaced_attachment():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = TimedWebSocket(receive_timeout_s=1.0)
+    first.put(_native_realtime_session_update("sid-takeover"))
+    first_task = asyncio.create_task(handler.handle_realtime_session(first))
+    for _ in range(100):
+        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
+        if created is not None:
+            break
+        await asyncio.sleep(0.001)
+    else:
+        raise AssertionError("first attachment did not create the session")
+
+    second = TimedWebSocket(receive_timeout_s=0.03)
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-takeover",
+            "incarnation": created["incarnation"],
+            "resume_token": created["resume_token"],
+            "last_received_server_event_seq": 0,
+        }
+    )
+    await handler.handle_realtime_session(second)
+    await first_task
+
+    detach_touches = [item for item in engine.touched if item[1] is DuplexLeaseActivity.DETACH]
+    assert detach_touches == [("sid-takeover", DuplexLeaseActivity.DETACH)]
+    assert "session.replaced" in first.sent_types()
+    assert engine.resumed == [("sid-takeover", 0)]
+    assert engine.closed == []
+
+
+@pytest.mark.asyncio
+async def test_realtime_takeover_does_not_clear_new_attachment_pending_turns():
+    class DelayedReplacementCloseWebSocket(TimedWebSocket):
+        def __init__(self) -> None:
+            super().__init__(receive_timeout_s=1.0)
+            self.replacement_close_started = asyncio.Event()
+            self.release_replacement_close = asyncio.Event()
+
+        async def close(self, code: int = 1000, reason: str | None = None) -> None:
+            if not self.replacement_close_started.is_set():
+                self.replacement_close_started.set()
+                await self.release_replacement_close.wait()
+            await super().close(code=code, reason=reason)
+
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = DelayedReplacementCloseWebSocket()
+    first.put(_native_realtime_session_update("sid-takeover-pending-turn"))
+    first_task = asyncio.create_task(handler.handle_realtime_session(first))
+    for _ in range(100):
+        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
+        if created is not None:
+            break
+        await asyncio.sleep(0.001)
+    else:
+        pytest.fail("first attachment did not create the session")
+
+    second = TimedWebSocket(receive_timeout_s=1.0)
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-takeover-pending-turn",
+            "incarnation": created["incarnation"],
+            "resume_token": created["resume_token"],
+            "last_received_server_event_seq": 0,
+        }
+    )
+    second_task = asyncio.create_task(handler.handle_realtime_session(second))
+    await asyncio.wait_for(first.replacement_close_started.wait(), timeout=1)
+
+    session = handler._registry.get("sid-takeover-pending-turn")
+    assert session is not None
+    assert session.reserve_pending_turn(limit=2)
+    first.release_replacement_close.set()
+    await asyncio.wait_for(first_task, timeout=1)
+
+    assert session.pending_input_turns == 1
+    session.release_pending_turn()
+    second.put({"type": "session.close"})
+    await asyncio.wait_for(second_task, timeout=2)
+
+
+@pytest.mark.asyncio
+async def test_realtime_takeover_drops_input_queued_by_replaced_attachment():
+    class DelayedReplacementCloseWebSocket(TimedWebSocket):
+        def __init__(self) -> None:
+            super().__init__(receive_timeout_s=1.0)
+            self.replacement_close_started = asyncio.Event()
+            self.release_replacement_close = asyncio.Event()
+            self.stale_heartbeat_read = asyncio.Event()
+
+        async def receive_text(self) -> str:
+            payload = await super().receive_text()
+            if json.loads(payload).get("type") == "session.heartbeat":
+                self.stale_heartbeat_read.set()
+            return payload
+
+        async def close(self, code: int = 1000, reason: str | None = None) -> None:
+            if not self.replacement_close_started.is_set():
+                self.replacement_close_started.set()
+                await self.release_replacement_close.wait()
+            await super().close(code=code, reason=reason)
+
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = DelayedReplacementCloseWebSocket()
+    first.put(_native_realtime_session_update("sid-takeover-stale-input"))
+    first_task = asyncio.create_task(handler.handle_realtime_session(first))
+    for _ in range(100):
+        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
+        if created is not None:
+            break
+        await asyncio.sleep(0.001)
+    else:
+        pytest.fail("first attachment did not create the session")
+
+    second = TimedWebSocket(receive_timeout_s=1.0)
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-takeover-stale-input",
+            "incarnation": created["incarnation"],
+            "resume_token": created["resume_token"],
+            "last_received_server_event_seq": 0,
+        }
+    )
+    second_task = asyncio.create_task(handler.handle_realtime_session(second))
+    await asyncio.wait_for(first.replacement_close_started.wait(), timeout=1)
+
+    first.put({"type": "session.heartbeat"})
+    await asyncio.wait_for(first.stale_heartbeat_read.wait(), timeout=1)
+    first.release_replacement_close.set()
+    await asyncio.wait_for(first_task, timeout=1)
+
+    second.put({"type": "session.close"})
+    await asyncio.wait_for(second_task, timeout=2)
+    assert all(activity is not DuplexLeaseActivity.HEARTBEAT for _, activity in engine.touched)
+    assert "session.heartbeat_ack" not in second.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_rejects_invalid_token_before_engine_control():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = TimedWebSocket(receive_timeout_s=0.01)
+    first.put(_native_realtime_session_update("sid-invalid-resume"))
+    await handler.handle_realtime_session(first)
+
+    created = next(message for message in first.sent if message.get("type") == "session.created")
+    second = TimedWebSocket(receive_timeout_s=0.01)
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-invalid-resume",
+            "incarnation": created["incarnation"],
+            "resume_token": "invalid-token",
+            "last_received_server_event_seq": 0,
+        }
+    )
+
+    await handler.handle_realtime_session(second)
+
+    error = next(message for message in second.sent if message.get("type") == "error")
+    assert error["error"]["code"] == "invalid_resume_token"
+    assert engine.resumed == []
+    assert engine.closed == []
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_recovers_when_rotated_token_delivery_is_lost():
+    class FailingResumeWebSocket(TimedWebSocket):
+        async def send_json(self, data: dict[str, Any]):
+            if data.get("type") == "session.resumed":
+                raise RuntimeError("resume transport disappeared")
+            await super().send_json(data)
+
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    first = TimedWebSocket(receive_timeout_s=0.01)
+    first.put(_native_realtime_session_update("sid-token-delivery"))
+    await handler.handle_realtime_session(first)
+    created = next(message for message in first.sent if message.get("type") == "session.created")
+    resume_event = {
+        "type": "session.resume",
+        "session_id": "sid-token-delivery",
+        "incarnation": created["incarnation"],
+        "resume_token": created["resume_token"],
+        "last_received_server_event_seq": 0,
+    }
+
+    failed_transport = FailingResumeWebSocket(receive_timeout_s=0.01)
+    failed_transport.put(resume_event)
+    await handler.handle_realtime_session(failed_transport)
+
+    recovered_transport = TimedWebSocket(receive_timeout_s=0.1)
+    recovered_transport.put(resume_event)
+    recovered_transport.put({"type": "session.close"})
+    await handler.handle_realtime_session(recovered_transport)
+
+    assert "session.resumed" in recovered_transport.sent_types()
+    assert engine.resumed == [
+        ("sid-token-delivery", 0),
+        ("sid-token-delivery", 1),
+    ]
+    assert engine.closed == [("sid-token-delivery", "session_close")]
+
+
+@pytest.mark.asyncio
+async def test_realtime_disconnect_grace_cancels_only_orphan_response():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+        duplex_session_config=DuplexSessionRuntimeConfig(disconnect_grace_s=0.02),
+    )
+    ws = TimedWebSocket(receive_timeout_s=0.01)
+    ws.put(_native_realtime_session_update("sid-grace-response"))
+
+    await handler.handle_realtime_session(ws)
+    session = handler._registry.get("sid-grace-response")
+    assert session is not None
+    session.begin_response()
+    session.bind_request("orphan-request")
+    orphan_task = asyncio.create_task(asyncio.sleep(10))
+    handler._session_tasks[session.session_id].active_response_task = orphan_task
+    assert engine.closed == []
+
+    await asyncio.sleep(0.05)
+
+    assert engine.closed == []
+    assert engine.aborted == ["orphan-request"]
+    assert orphan_task.cancelled()
+    assert session.active_response_id is None
+    assert "sid-grace-response" in handler._minicpmo_sessions
+
+
+@pytest.mark.asyncio
+async def test_realtime_heartbeat_control_failure_is_non_terminal():
+    engine = FakeEngineClient(fail_touch=True)
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket(receive_timeout_s=0.1)
+    ws.put(_native_realtime_session_update("sid-heartbeat-failure"))
+    ws.put({"type": "session.heartbeat"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_realtime_session(ws)
+
+    error = next(message for message in ws.sent if message.get("type") == "error")
+    assert error["error"]["code"] == "runtime_touch_failed"
+    assert engine.closed == [("sid-heartbeat-failure", "session_close")]
+
+
+@pytest.mark.asyncio
+async def test_realtime_idle_ttl_lifecycle_removes_detached_serving_projection():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket(receive_timeout_s=0.01)
+    ws.put(_native_realtime_session_update("sid-idle-expired"))
+
+    await handler.handle_realtime_session(ws)
+    fence = engine.opened_fences[0]
+    assert fence is not None
+    await engine.duplex_lifecycle_events.put(
+        DuplexSessionLifecycleMessage(
+            fence=fence,
+            session_id="sid-idle-expired",
+            event="expired",
+            reason="idle_ttl_expired",
+            lease_generation=1,
+            submitted_request_ids=[],
+            reserved_request_ids=[],
+        )
+    )
+    await asyncio.sleep(0.05)
+
+    assert handler._registry.get("sid-idle-expired") is None
+    assert "sid-idle-expired" not in handler._minicpmo_sessions
+    assert "sid-idle-expired" not in handler._session_tasks
+    assert engine.closed == []
+
+
+@pytest.mark.asyncio
+async def test_realtime_resume_reports_resync_required_after_journal_ttl_gap():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+        duplex_session_config=DuplexSessionRuntimeConfig(resume_replay_ttl_s=0.01),
+    )
+    first = TimedWebSocket(receive_timeout_s=0.01)
+    first.put(_native_realtime_session_update("sid-journal-gap"))
+    first.put({"type": "session.heartbeat"})
+    await handler.handle_realtime_session(first)
+    created = next(message for message in first.sent if message.get("type") == "session.created")
+    await asyncio.sleep(0.02)
+
+    second = TimedWebSocket(receive_timeout_s=0.01)
+    second.put(
+        {
+            "type": "session.resume",
+            "session_id": "sid-journal-gap",
+            "incarnation": created["incarnation"],
+            "resume_token": created["resume_token"],
+            "last_received_server_event_seq": 0,
+        }
+    )
+    await handler.handle_realtime_session(second)
+
+    assert "session.resync_required" in second.sent_types()
+    assert engine.resumed == []
+    assert engine.closed == []
+
+
+@pytest.mark.asyncio
+async def test_realtime_journal_overflow_degrades_to_live_resync_without_closing_runtime():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+        duplex_session_config=DuplexSessionRuntimeConfig(resume_replay_max_bytes_per_session=128),
+    )
+    ws = TimedWebSocket(receive_timeout_s=0.01)
+    ws.put(_native_realtime_session_update("sid-journal-overflow"))
+
+    await handler.handle_realtime_session(ws)
+
+    assert "session.created" in ws.sent_types()
+    assert "session.resync_required" in ws.sent_types()
+    assert engine.closed == []
+    assert handler._registry.get("sid-journal-overflow") is not None
+
+
+@pytest.mark.asyncio
+async def test_realtime_input_backpressure_is_per_session_and_rejects_before_mutation():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+        duplex_session_config=DuplexSessionRuntimeConfig(
+            max_pending_input_bytes_per_session=100,
+        ),
+    )
+    first = TimedWebSocket(receive_timeout_s=0.1)
+    first.put(_native_realtime_session_update("sid-backpressure-a"))
+    for _ in range(2):
+        first.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm16_b64(20),
+                "format": "pcm16",
+                "sample_rate_hz": 16000,
+            }
+        )
+    first.put({"type": "session.close"})
+
+    await handler.handle_realtime_session(first)
+
+    backpressure = [
+        event
+        for event in first.sent
+        if event.get("type") == "error"
+        and isinstance(event.get("error"), dict)
+        and event["error"].get("code") == "input_backpressure"
+    ]
+    assert len(backpressure) == 1
+
+    second = TimedWebSocket(receive_timeout_s=0.1)
+    second.put(_native_realtime_session_update("sid-backpressure-b"))
+    second.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(20),
+            "format": "pcm16",
+            "sample_rate_hz": 16000,
+        }
+    )
+    second.put({"type": "session.close"})
+
+    await handler.handle_realtime_session(second)
+
+    assert not any(
+        event.get("type") == "error"
+        and isinstance(event.get("error"), dict)
+        and event["error"].get("code") == "input_backpressure"
+        for event in second.sent
+    )
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_idle_timeout_close_does_not_emit_runtime_control():
+    control_result = {
+        "operation": "close",
+        "session_id": "sid-disconnect",
+        "ok": True,
+        "unsupported_count": 1,
+        "error_count": 0,
+        "stage_results": [{"stage_id": 0, "replica_id": 0, "result": {"supported": False}}],
+    }
+    engine = FakeEngineClient(append_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=0.1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-disconnect"))
+
+    await handler.handle_session(ws)
+
+    assert engine.closed == [("sid-disconnect", "timeout")]
+
+
+@pytest.mark.asyncio
+async def test_idle_output_audio_clear_does_not_advance_runtime_fence():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-idle-output-clear"))
+    ws.put({"type": "output_audio_buffer.clear"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    cancelled = next(event for event in ws.sent if event.get("type") == "audio.cancelled")
+    assert cancelled["cancelled_epoch"] == cancelled["epoch"] == 0
+    assert engine.signals == []
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_runtime_close_failure_is_reported_without_closed_ack():
+    engine = FakeEngineClient(fail_close=True)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-close-fail"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["session.created", "error"]
+    assert ws.sent[-1]["code"] == "runtime_close_failed"
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_control_close_failure_is_reported_without_closed_ack():
+    control_result = {
+        "operation": "close",
+        "session_id": "sid-control-close-fail",
+        "ok": False,
+        "unsupported_count": 0,
+        "error_count": 1,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "error": "stage close failed"},
+            }
+        ],
+    }
+    engine = FakeEngineClient(close_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-control-close-fail"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["session.created", "error"]
+    assert ws.sent[-1]["code"] == "runtime_close_failed"
+    assert ws.sent[-1]["runtime_control"]["error_count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_duplex_cancel_without_active_response_clears_pending_input_and_acks():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-pending-cancel"))
+    ws.put({"type": "input.text.append", "text": "hello"})
+    ws.put({"type": "input.cancel", "reason": "user_cancel"})
+    ws.put({"type": "input.commit"})
+
+    await handler.handle_session(ws)
+
+    cancelled = next(m for m in ws.sent if m.get("type") == "input.cancelled")
+    assert cancelled["cancelled"] == {"text_chunks": 1, "audio_chunks": 0}
+    assert cancelled["epoch"] == 1
+    assert chat_service.seen_request_ids == []
+    assert "response.created" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_turn_signal_input_cancel_uses_epoch_fence_transition():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-turn-signal-cancel"))
+    ws.put({"type": "input.text.append", "text": "discard me"})
+    ws.put({"type": "turn.signal", "event": "input.cancel"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert engine.signal_fences[-1] == DuplexFence("sid-turn-signal-cancel")
+    assert engine.signal_next_fences[-1] == DuplexFence("sid-turn-signal-cancel", epoch=1)
+    assert any(message.get("type") == "input.cancelled" for message in ws.sent)
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_local_turn_signal_does_not_round_trip_runtime():
+    engine = FakeEngineClient(fail_signal=True)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-signal-fail"))
+    ws.put({"type": "turn.signal", "event": "user_started"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    turn_event = next(m for m in ws.sent if m.get("type") == "turn.event")
+    assert turn_event["event"] == "user_started"
+    assert not engine.signals
+    assert "runtime_signal_failed" not in {m.get("code") for m in ws.sent}
+
+
+@pytest.mark.asyncio
+async def test_duplex_barge_in_aborts_active_response_when_runtime_signal_fails():
+    engine = FakeEngineClient(fail_signal_events={"barge_in"})
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "response.created":
+            ws.put({"type": "input.cancel", "reason": "test_barge_in"})
+
+    ws = TimedWebSocket(on_send=on_send)
+    ws.put(_session_create("sid-barge-signal-fail"))
+    ws.put({"type": "input.text.append", "text": "hello"})
+    ws.put({"type": "input.commit"})
+
+    await handler.handle_session(ws)
+
+    assert "audio.cancelled" in ws.sent_types()
+    assert engine.aborted == ["chatcmpl-duplex-sid-barge-signal-fail-0-1"]
+    assert engine.internal_abort_batches == [["chatcmpl-duplex-sid-barge-signal-fail-0-1"]]
+    error = next(m for m in ws.sent if m.get("type") == "error")
+    assert error["code"] == "runtime_signal_failed"
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_surfaces_stage_unsupported_result_to_client():
+    control_result = {
+        "operation": "open",
+        "session_id": "sid-unsupported",
+        "ok": True,
+        "unsupported_count": 1,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "reason": "not implemented"},
+            }
+        ],
+    }
+    engine = FakeEngineClient(open_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-unsupported"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    created = next(m for m in ws.sent if m.get("type") == "session.created")
+    assert created["runtime_control"]["unsupported_count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_append_without_format_defaults_to_pcm16():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-default-pcm16"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+    _, mode, payload, final = engine.appended[0]
+    assert mode == "append_audio_chunk"
+    assert final is False
+    assert isinstance(payload, dict)
+    assert payload["format"] == "pcm_f32le"
+    assert payload["sample_rate_hz"] == 16000
+    samples = np.frombuffer(base64.b64decode(payload["audio"]), dtype="<f4")
+    assert samples.shape == (16000,)
+    assert samples[:4].tolist() == pytest.approx([1000 / 32768.0] * 4)
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_rejects_invalid_sample_rate_without_append():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-invalid-rate"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(1),
+            "sample_rate_hz": 16_000.5,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert engine.appended == []
+    error = next(event for event in ws.sent if event.get("type") == "error")
+    assert error["code"] == "bad_event"
+
+
+@pytest.mark.asyncio
+async def test_native_input_commit_does_not_send_noop_runtime_signal():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-commit-without-signal"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "input_audio_buffer.commit"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ("sid-commit-without-signal", "input.commit") not in engine.signals
+
+
+@pytest.mark.asyncio
+async def test_audio_clear_preserves_later_wire_order_append():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-clear-then-append"))
+    ws.put({"type": "input_audio_buffer.clear"})
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+
+
+@pytest.mark.asyncio
+async def test_native_append_is_cancelled_by_later_wire_order_input_cancel():
+    class SlowAppendEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            super().__init__()
+            self.append_started = asyncio.Event()
+            self.append_cancelled = asyncio.Event()
+            self.release_append = asyncio.Event()
+
+        async def append_duplex_input_async(
+            self,
+            session_id: str,
+            *,
+            mode: str,
+            payload: object,
+            final: bool = False,
+            timeout: float | None = None,
+            collect_outputs: bool = True,
+            fence: DuplexFence | None = None,
+        ):
+            self.append_started.set()
+            try:
+                await self.release_append.wait()
+            except asyncio.CancelledError:
+                self.append_cancelled.set()
+                raise
+            return await super().append_duplex_input_async(
+                session_id,
+                mode=mode,
+                payload=payload,
+                final=final,
+                timeout=timeout,
+                collect_outputs=collect_outputs,
+                fence=fence,
+            )
+
+    engine = SlowAppendEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-cancel-slow-append"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm16_b64(16000),
+            "sample_rate_hz": 16000,
+            "is_speech": True,
+        }
+    )
+    ws.put({"type": "input.cancel"})
+    ws.put({"type": "session.close"})
+
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+    await asyncio.wait_for(engine.append_started.wait(), timeout=1)
+    try:
+        await asyncio.wait_for(engine.append_cancelled.wait(), timeout=0.2)
+    except TimeoutError:
+        pass
+    finally:
+        engine.release_append.set()
+    await asyncio.wait_for(handler_task, timeout=1)
+
+    assert engine.append_cancelled.is_set()
+    assert engine.signal_fences[-1] == DuplexFence("sid-cancel-slow-append")
+    assert engine.signal_next_fences[-1] == DuplexFence("sid-cancel-slow-append", epoch=1)
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_append_control_error_does_not_emit_model_delta():
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-append-error",
+        "ok": False,
+        "unsupported_count": 0,
+        "error_count": 1,
+        "stage_results": [
+            {
+                "stage_id": -1,
+                "replica_id": -1,
+                "result": {
+                    "supported": False,
+                    "error": "duplex_stage_handoff_target_missing:tts",
+                },
+            },
+        ],
+    }
+    engine = FakeEngineClient(append_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-append-error"))
+    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert "response.output_audio.delta" not in ws.sent_types()
+    error = next(m for m in ws.sent if m.get("type") == "error")
+    assert error["code"] == "runtime_append_failed"
+    assert error["runtime_control"]["error_count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_session_update_control_failure_rolls_back_config():
+    control_result = {
+        "operation": "signal",
+        "session_id": "sid-control-signal-fail",
+        "ok": False,
+        "unsupported_count": 0,
+        "error_count": 1,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "error": "stage signal failed"},
+            }
+        ],
+    }
+    engine = FakeEngineClient(signal_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-control-signal-fail"))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {"instructions": "must roll back"},
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert "session.updated" not in ws.sent_types()
+    error = next(m for m in ws.sent if m.get("type") == "error")
+    assert error["code"] == "runtime_signal_failed"
+    assert error["runtime_control"]["error_count"] == 1
+    assert engine.signal_session_configs[-1]["instructions"] == "must roll back"
+
+
+@pytest.mark.asyncio
+async def test_native_session_update_commits_config_only_after_runtime_ack():
+    class BlockingUpdateEngine(FakeEngineClient):
+        def __init__(self):
+            super().__init__()
+            self.update_started = asyncio.Event()
+            self.release_update = asyncio.Event()
+
+        async def signal_duplex_turn_async(self, session_id: str, **kwargs):
+            if kwargs.get("event") == "session.update":
+                self.update_started.set()
+                await self.release_update.wait()
+            return await super().signal_duplex_turn_async(session_id, **kwargs)
+
+    engine = BlockingUpdateEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-update-two-phase"))
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {"instructions": "candidate instructions"},
+        }
+    )
+
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+    await asyncio.wait_for(engine.update_started.wait(), timeout=1)
+    live_session = handler._registry.get("sid-update-two-phase")
+    assert live_session is not None
+    assert live_session.config.instructions != "candidate instructions"
+
+    engine.release_update.set()
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    updated = next(message for message in ws.sent if message.get("type") == "session.updated")
+    assert updated["session"]["instructions"] == "candidate instructions"
+
+
+@pytest.mark.asyncio
+async def test_native_session_update_waits_for_prior_append_effect():
+    class OrderedUpdateEngine(FakeEngineClient):
+        def __init__(self):
+            super().__init__()
+            self.append_started = asyncio.Event()
+            self.release_append = asyncio.Event()
+            self.update_started = asyncio.Event()
+            self.effects: list[str] = []
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            self.effects.append("append.started")
+            self.append_started.set()
+            await self.release_append.wait()
+            kwargs.pop("expected_epoch", None)
+            result = await super().append_duplex_input_async(session_id, **kwargs)
+            self.effects.append("append.done")
+            return result
+
+        async def signal_duplex_turn_async(self, session_id: str, **kwargs):
+            if kwargs.get("event") == "session.update":
+                self.effects.append("session.update")
+                self.update_started.set()
+            return await super().signal_duplex_turn_async(session_id, **kwargs)
+
+    engine = OrderedUpdateEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-ordered-update"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000, value=0.05),
+            "format": "pcm_f32le",
+        }
+    )
+    ws.put(
+        {
+            "type": "turn.signal",
+            "event": "session.update",
+            "payload": {"temperature": 0.2},
+        }
+    )
+
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+    await asyncio.wait_for(engine.append_started.wait(), timeout=1)
+    try:
+        await asyncio.sleep(0.05)
+        assert not engine.update_started.is_set()
+    finally:
+        engine.release_append.set()
+        ws.put({"type": "session.close"})
+        await asyncio.wait_for(handler_task, timeout=2)
+
+    assert engine.effects.index("append.done") < engine.effects.index("session.update")
+
+
+@pytest.mark.asyncio
+async def test_failed_native_append_prevents_queued_append_from_running():
+    failed_result = {
+        "operation": "append",
+        "session_id": "sid-append-chain-failure",
+        "ok": False,
+        "unsupported_count": 0,
+        "error_count": 1,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "error": "append failed"},
+            }
+        ],
+    }
+
+    class BlockingFailureEngine(FakeEngineClient):
+        def __init__(self):
+            super().__init__(append_result=failed_result)
+            self.first_started = asyncio.Event()
+            self.release_first = asyncio.Event()
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            if not self.appended:
+                self.first_started.set()
+                await self.release_first.wait()
+            kwargs.pop("expected_epoch", None)
+            return await super().append_duplex_input_async(session_id, **kwargs)
+
+    engine = BlockingFailureEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    create = _native_session_create("sid-append-chain-failure")
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+    for _ in range(2):
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm_f32_b64(16_000, value=0.05),
+                "format": "pcm_f32le",
+            }
+        )
+
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+    await asyncio.wait_for(engine.first_started.wait(), timeout=1)
+    engine.release_first.set()
+    await asyncio.sleep(0.1)
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    assert len(engine.appended) == 1
+
+
+@pytest.mark.asyncio
+async def test_failed_final_append_keeps_committed_audio_for_response_retry():
+    failed_result = {
+        "operation": "append",
+        "session_id": "sid-final-append-retry",
+        "ok": False,
+        "unsupported_count": 0,
+        "error_count": 1,
+        "stage_results": [],
+    }
+    successful_result = {
+        "operation": "append",
+        "session_id": "sid-final-append-retry",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [],
+    }
+    engine = FakeEngineClient(append_results=[failed_result, successful_result])
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+
+    def retry_after_runtime_error(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "error" and data.get("code") == "runtime_append_failed":
+            ws.put({"type": "response.create"})
+
+    ws = TimedWebSocket(on_send=retry_after_runtime_error)
+    ws.put(_native_session_create("sid-final-append-retry"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(8_000, value=0.05),
+            "format": "pcm_f32le",
+        }
+    )
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+    ws.put({"type": "response.create"})
+
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+    for _ in range(100):
+        if len(engine.appended) >= 2:
+            break
+        await asyncio.sleep(0.01)
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    assert len(engine.appended) == 2
+    assert engine.appended[0][2]["audio"] == engine.appended[1][2]["audio"]
+    assert engine.append_operation_ids[0] == engine.append_operation_ids[1]
+
+
+@pytest.mark.asyncio
+async def test_duplex_handler_signal_unsupported_workers_with_data_plane_ack_is_not_fatal():
+    control_result = {
+        "operation": "signal",
+        "session_id": "sid-control-signal-data-plane",
+        "ok": False,
+        "unsupported_count": 2,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "reason": "worker_duplex_signal_not_implemented"},
+            },
+            {
+                "stage_id": 1,
+                "replica_id": 0,
+                "result": {"supported": False, "reason": "worker_duplex_signal_not_implemented"},
+            },
+            {
+                "stage_id": -1,
+                "replica_id": -1,
+                "result": {
+                    "supported": True,
+                    "data_plane_signal": True,
+                    "event": "barge_in",
+                    "epoch": 1,
+                },
+            },
+        ],
+    }
+    engine = FakeEngineClient(signal_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_session_create("sid-control-signal-data-plane"))
+    ws.put({"type": "turn.signal", "event": "barge_in"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert "runtime_signal_failed" not in {m.get("code") for m in ws.sent}
+    assert "input.cancelled" in ws.sent_types()
+    runtime_control = next(m for m in ws.sent if m.get("type") == "runtime.control")
+    assert runtime_control["result"]["unsupported_count"] == 2
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_open_unsupported_fails_session_create():
+    control_result = {
+        "operation": "open",
+        "session_id": "sid-native-busy",
+        "ok": True,
+        "unsupported_count": 1,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {"supported": False, "reason": "native_duplex_session_busy"},
+            }
+        ],
+    }
+    engine = FakeEngineClient(control_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-busy"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "runtime_open_unsupported"
+    assert ws.sent[0]["runtime_control"]["unsupported_count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_rejects_engine_without_fence_contract():
+    class LegacyEngineClient(FakeEngineClient):
+        async def open_duplex_session_async(
+            self,
+            session_id: str,
+            *,
+            session_mode: str = "duplex",
+            capabilities: dict[str, object] | None = None,
+            session_config: dict[str, object] | None = None,
+            timeout: float | None = None,
+        ) -> None:
+            return await super().open_duplex_session_async(
+                session_id,
+                session_mode=session_mode,
+                capabilities=capabilities,
+                session_config=session_config,
+                timeout=timeout,
+            )
+
+    engine = LegacyEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-no-fence-contract"))
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "runtime_contract_invalid"
+    assert "open_duplex_session_async" in ws.sent[0]["error"]
+    assert "fence" in ws.sent[0]["error"]
+    assert engine.opened == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_audio_append_does_not_retain_pending_audio():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-no-pending"))
+    short_chunk = base64.b64encode(b"\x00" * (800 * 4)).decode("ascii")
+    ws.put({"type": "input_audio_buffer.append", "audio": short_chunk, "format": "pcm_f32le"})
+    ws.put({"type": "input.cancel", "reason": "barge_in"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    cancelled = next(m for m in ws.sent if m.get("type") == "input.cancelled")
+    assert cancelled["cancelled"] == {"text_chunks": 0, "audio_chunks": 0}
+    assert cancelled["epoch"] == 1
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_rejects_text_append_before_runtime_call():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-text"))
+    ws.put({"type": "input.text.append", "text": "hello"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    error = next(m for m in ws.sent if m.get("type") == "error")
+    assert error["code"] == "native_text_append_unsupported"
+    assert engine.appended == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_separates_public_and_runtime_config(monkeypatch):
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    async def fake_resolve_ref_audio(_, *, model_config):
+        del model_config
+        return [0.25] * 1600, 16000
+
+    monkeypatch.setattr(
+        "vllm_omni.experimental.fullduplex.minicpmo45.MiniCPMO45NativeDuplexServingAdapter.resolve_ref_audio",
+        fake_resolve_ref_audio,
+    )
+    event = _native_session_create("sid-native-ref-audio", modalities=["text", "audio"])
+    event["session"]["ref_audio"] = "data:audio/wav;base64,AAAA"
+    ws = TimedWebSocket()
+    ws.put(event)
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types()[0] == "session.created"
+    opened_config = engine.opened_configs[0]
+    opened_runtime_config = engine.opened_runtime_configs[0]
+    extra_body = opened_config["extra_body"]
+    assert "ref_audio_data" not in extra_body
+    assert "duplex_stage_max_tokens" not in extra_body
+    assert opened_runtime_config["ref_audio_format"] == "pcm_f32le"
+    assert opened_runtime_config["ref_audio_sample_rate_hz"] == 16000
+    assert opened_runtime_config["duplex_stage_max_tokens"] == {"0": 20, "1": 8192}
+    assert opened_runtime_config["duplex_stage_sampling_params"]["0"]["top_k"] == 20
+    assert opened_runtime_config["duplex_stage_sampling_params"]["0"]["top_p"] == 0.8
+    assert base64.b64decode(opened_runtime_config["ref_audio_data"]) == struct.pack("<1600f", *([0.25] * 1600))
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_rejects_client_runtime_config():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    event = _native_session_create("sid-native-private-config")
+    event["session"]["extra_body"]["duplex_stage_sampling_params"] = {"0": {"temperature": 0.0}}
+    ws = TimedWebSocket()
+    ws.put(event)
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "invalid_duplex_runtime_config"
+    assert engine.opened == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_audio_output_requires_ref_audio(monkeypatch):
+    monkeypatch.setattr(
+        MiniCPMO45NativeDuplexServingAdapter,
+        "_load_native_tokenizer",
+        staticmethod(lambda model_config: None),
+    )
+
+    event = _native_session_create(
+        "sid-native-ref-required",
+        modalities=["text", "audio"],
+    )
+    config = DuplexSessionConfig.from_event(event)
+
+    with pytest.raises(ServingRuntimeConfigError) as exc_info:
+        await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
+            config,
+            model_config=SimpleNamespace(model="openbmb/MiniCPM-o-4_5"),
+        )
+
+    assert exc_info.value.code == "ref_audio_required"
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_open_session_maps_missing_ref_audio_to_typed_error():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(
+        _native_session_create(
+            "sid-native-ref-required-open",
+            modalities=["text", "audio"],
+        )
+    )
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "ref_audio_required"
+    assert engine.opened == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_text_only_omits_ref_audio_when_client_does_not_provide_it(monkeypatch):
+    monkeypatch.setattr(
+        MiniCPMO45NativeDuplexServingAdapter,
+        "_load_native_tokenizer",
+        staticmethod(lambda model_config: None),
+    )
+
+    event = _native_session_create("sid-native-default-ref", modalities=["text"])
+    config = DuplexSessionConfig.from_event(event)
+
+    runtime_config = await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
+        config,
+        model_config=SimpleNamespace(model="openbmb/MiniCPM-o-4_5"),
+    )
+
+    assert "ref_audio_data" not in runtime_config
+    assert "ref_audio_format" not in runtime_config
+    assert "ref_audio_sample_rate_hz" not in runtime_config
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_preserves_ref_audio_channels_until_normalize(monkeypatch):
+    class FakeMediaConnector:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        async def fetch_audio_async(self, ref_audio):
+            assert ref_audio == "data:audio/wav;base64,AAAA"
+            return np.tile(np.array([[0.25, -0.25], [0.5, -0.5]], dtype=np.float32), (800, 1)), 16000
+
+    monkeypatch.setattr(
+        "vllm_omni.experimental.fullduplex.minicpmo45.adapter.MediaConnector",
+        FakeMediaConnector,
+    )
+
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    event = _native_session_create("sid-native-ref-audio-stereo", modalities=["text", "audio"])
+    event["session"]["ref_audio"] = "data:audio/wav;base64,AAAA"
+    ws = TimedWebSocket()
+    ws.put(event)
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    runtime_config = engine.opened_runtime_configs[0]
+    assert base64.b64decode(runtime_config["ref_audio_data"]) == struct.pack("<1600f", *([0.0] * 1600))
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_rejects_ref_audio_path():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    event = _native_session_create("sid-native-ref-path")
+    event["session"]["extra_body"] = {
+        "minicpmo45_native_duplex": True,
+        "ref_audio_path": "/tmp/ref.wav",
+    }
+    ws = TimedWebSocket()
+    ws.put(event)
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["error"]
+    assert ws.sent[0]["code"] == "unsupported_ref_audio_path"
+    assert engine.opened == []
+
+
+def test_minicpmo_native_duplex_explicit_barge_in_request_is_deferred_as_listen():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-native-explicit-barge-disabled",
+        config=DuplexSessionConfig(overlap_policy=DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value),
+        capabilities=DuplexCapabilities.minicpmo45_native(),
+    )
+    payload = {
+        "type": "audio",
+        "audio": _pcm_f32_b64(16000, value=0.05),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16000,
+        "is_speech": True,
+    }
+
+    decision = handler._overlap_decision(
+        session,
+        {"force_barge_in": True},
+        payload,
+    )
+
+    assert decision == {
+        "action": "listen",
+        "reason": "barge_in_unsupported",
+        "duration_ms": 1000,
+        "overlap_speech_ms": 1000,
+        "buffer_audio": True,
+        "defer_runtime_append": True,
+    }
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "barge_in_event",
+    [
+        {"type": "barge_in"},
+        {"type": "turn.signal", "event": "barge_in"},
+    ],
+)
+async def test_minicpmo_native_duplex_rejects_unadvertised_barge_in_control(
+    barge_in_event: dict[str, object],
+):
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-barge-control-disabled"))
+    ws.put(barge_in_event)
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    error = next(message for message in ws.sent if message.get("code") == "barge_in_unsupported")
+    assert error["session_id"] == "sid-native-barge-control-disabled"
+    assert ("sid-native-barge-control-disabled", "barge_in") not in engine.signals
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_explicit_non_speech_stays_listening_without_append():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-silence"))
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": "AAAA",
+            "format": "pcm_f32le",
+            "is_speech": False,
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert engine.appended == []
+    assert "response.listen" in ws.sent_types()
+    assert "response.created" not in ws.sent_types()
+    assert "response.output_audio.delta" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_drains_data_plane_stream_until_done():
+    def _stage_output(samples: int, *, finished: bool):
+        return SimpleNamespace(
+            request_id="duplex-sid-native-stream-e0-stage0-s1",
+            finished=finished,
+            outputs=[
+                SimpleNamespace(
+                    text="",
+                    multimodal_output={
+                        "audio": np.zeros(samples, dtype=np.float32),
+                        "sr": 24000,
+                    },
+                )
+            ],
+        )
+
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-stream",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": "duplex-sid-native-stream-e0-stage0-s1",
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+        "data_plane_outputs": [_stage_output(10, finished=False)],
+    }
+    engine = FakeEngineClient(
+        append_result=control_result,
+        collect_outputs=[
+            [_stage_output(20, finished=False)],
+            [_stage_output(30, finished=True)],
+        ],
+    )
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    def close_on_second_created(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if ws.sent_types().count("response.created") >= 2:
+            ws.put({"type": "session.close"})
+
+    ws = TimedWebSocket(on_send=close_on_second_created)
+    ws.put(_native_session_create("sid-native-stream"))
+    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
+
+    await handler.handle_session(ws)
+
+    deltas = [m for m in ws.sent if m.get("type") == "response.output_audio.delta"]
+    assert [m["audio"] for m in deltas] == ["wav-10", "wav-10", "wav-10"]
+    assert [m["end_of_turn"] for m in deltas] == [False, False, True]
+    assert len([m for m in ws.sent if m.get("type") == "response.done"]) == 1
+    assert engine.collected == [
+        ("duplex-sid-native-stream-e0-stage0-s1", 1),
+        ("duplex-sid-native-stream-e0-stage0-s1", 1),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_restarts_drain_when_append_races_idle_exit(
+    monkeypatch: pytest.MonkeyPatch,
+):
+    request_id = "duplex-sid-native-late-output-e0-stage0"
+    late_output = object()
+    engine = FakeEngineClient(
+        collect_outputs=[[], [], [], [late_output]],
+        collect_delay_s=0.05,
+    )
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    session = DuplexSession(
+        session_id="sid-native-late-output",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    session.bind_request(request_id)
+    native = handler._minicpmo_session_state(session)
+    projected_batches: list[object] = []
+    projected = asyncio.Event()
+
+    async def project_late_output(_send_json, result, **_kwargs):
+        projected_batches.append(result)
+        projected.set()
+        session.close()
+        return None, True
+
+    monkeypatch.setattr(handler, "_send_native_duplex_events", project_late_output)
+    result = {
+        "stage_results": [
+            {
+                "result": {
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                }
+            }
+        ]
+    }
+
+    assert (
+        await handler._start_native_data_plane_stream_task(
+            None,
+            result,
+            session=session,
+            expected_epoch=session.epoch,
+        )
+        is True
+    )
+    first_drain = native.data_plane_task
+    assert first_drain is not None
+    await asyncio.sleep(0.01)
+
+    assert (
+        await handler._start_native_data_plane_stream_task(
+            None,
+            result,
+            session=session,
+            expected_epoch=session.epoch,
+        )
+        is False
+    )
+    await asyncio.wait_for(projected.wait(), timeout=1)
+    await asyncio.wait_for(first_drain, timeout=1)
+
+    assert len(engine.collected) == 4
+    assert projected_batches == [{"data_plane_outputs": [late_output]}]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_ignores_outputs_after_data_plane_turn_done():
+    request_id = "duplex-sid-native-post-done-e0-stage0-s1"
+
+    def _stage_output(samples: int, *, turn_end: bool = False):
+        return SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[
+                SimpleNamespace(
+                    text="hello",
+                    multimodal_output={
+                        "audio": np.zeros(samples, dtype=np.float32),
+                        "sr": 24000,
+                        "meta": {
+                            "turn_end": turn_end,
+                            "duplex_turn_id": 0,
+                            "duplex_epoch": 0,
+                        },
+                    },
+                )
+            ],
+        )
+
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-post-done",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+        "data_plane_outputs": [_stage_output(10)],
+    }
+    engine = FakeEngineClient(
+        append_result=control_result,
+        collect_outputs=[
+            [_stage_output(20, turn_end=True)],
+            [_stage_output(30)],
+        ],
+    )
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+
+    def close_on_done(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "response.done":
+            ws.put({"type": "session.close"})
+
+    event = _native_session_create("sid-native-post-done")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws = TimedWebSocket(on_send=close_on_done)
+    ws.put(event)
+    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types().count("response.created") == 1
+    assert ws.sent_types().count("response.done") == 1
+    deltas = [m for m in ws.sent if m.get("type") == "response.output_audio.delta"]
+    assert [m["audio"] for m in deltas] == ["wav-10", "wav-10"]
+    assert engine.collected
+    assert all(collected == (request_id, 1) for collected in engine.collected)
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_accepts_next_append_after_response_done():
+    def _stage_output(*, finished: bool):
+        return SimpleNamespace(
+            request_id="duplex-sid-native-next-turn-e0-stage0-s1",
+            finished=finished,
+            outputs=[
+                SimpleNamespace(
+                    text="",
+                    multimodal_output={
+                        "audio": np.zeros(10, dtype=np.float32),
+                        "sr": 24000,
+                    },
+                )
+            ],
+        )
+
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-next-turn",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": "duplex-sid-native-next-turn-e0-stage0-s1",
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+        "data_plane_outputs": [_stage_output(finished=True)],
+    }
+    engine = FakeEngineClient(append_result=control_result)
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    done_count = 0
+
+    def send_next_turn_or_close(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        nonlocal done_count
+        if data.get("type") != "response.done":
+            return
+        done_count += 1
+        if done_count == 1:
+            ws.put({"type": "input_audio_buffer.append", "audio": "BBBB", "format": "pcm_f32le"})
+            ws.put({"type": "input_audio_buffer.commit", "final": True})
+            ws.put({"type": "response.create"})
+        else:
+            ws.put({"type": "session.close"})
+
+    ws = TimedWebSocket(on_send=send_next_turn_or_close, receive_timeout_s=5)
+    create = _native_session_create("sid-native-next-turn")
+    create["session"]["idle_timeout_s"] = 5
+    ws.put(create)
+    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) >= 2, [
+        (message.get("type"), message.get("code"), message.get("reason")) for message in ws.sent
+    ]
+    assert len([m for m in ws.sent if m.get("type") == "response.done"]) == 2
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_commit_finalizes_after_streamed_full_chunk():
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-auto-finalize",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [],
+    }
+    engine = FakeEngineClient(control_result=control_result)
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    event = _native_session_create("sid-native-auto-finalize")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+    assert engine.appended[0][3] is False
+    assert "response.created" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_commit_finalizes_with_active_data_plane_stream():
+    request_id = "duplex-sid-native-auto-active-stream-stage0"
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-auto-active-stream",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "result": {
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                }
+            }
+        ],
+    }
+    engine = FakeEngineClient(
+        control_result=control_result,
+        collect_outputs=[[], [], []],
+        collect_delay_s=0.05,
+    )
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    event = _native_session_create("sid-native-auto-active-stream")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    ws.put({"type": "input_audio_buffer.commit", "final": True})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+    assert engine.appended[0][3] is False
+    assert "response.created" not in ws.sent_types()
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_accepts_realtime_commit_after_stream_consumed():
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket()
+    event = _native_session_create("sid-native-auto-consumed-stream")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    ws.put(
+        {
+            "type": "input_audio_buffer.commit",
+            "final": True,
+            "realtime_item_id": "item-consumed-stream",
+        }
+    )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert not any(message.get("code") == "input_audio_buffer_empty" for message in ws.sent)
+    committed = next(message for message in ws.sent if message.get("type") == "input.committed")
+    assert committed["realtime_item_id"] == "item-consumed-stream"
+    assert committed["native_audio"] is True
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_post_response_commit_ignores_stale_progress_state():
+    session_id = "sid-native-auto-post-response"
+    engine = FakeEngineClient()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") != "session.created":
+            return
+        session = handler._registry.get(session_id)
+        assert session is not None
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm_f32_b64(8000),
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+        ws.put({"type": "input_audio_buffer.commit", "final": True})
+        ws.put({"type": "session.close"})
+
+    ws = TimedWebSocket(on_send=on_send)
+    create = _native_session_create(session_id)
+    create["session"]["extra_body"]["auto_response"] = True
+    ws.put(create)
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+    assert engine.appended[0][3] is True
+    assert "input.committed" in ws.sent_types()
+    assert not any(message.get("code") == "response_already_active" for message in ws.sent)
+
+
+def test_realtime_overlap_commit_uses_current_generation_identity():
+    handler, session = _auto_response_context("sid-realtime-reserved-input-turn")
+    session.turn_id = 1
+    session.bind_response_turn(1)
+    session.turn_id = 3
+    committed = handler._commit_native_audio_input(session)
+
+    assert committed.turn_id == 3
+    assert session.turn_id == 3
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_keeps_request_bound_for_segment_continuation():
+    request_id = "duplex-sid-native-auto-continuation-e0-stage0"
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-auto-continuation",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "result": {
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": 1,
+                }
+            }
+        ],
+    }
+    terminal_segment = _duplex_tts_output(
+        request_id=request_id,
+        samples=0,
+        finished=True,
+        tts_is_last_chunk=True,
+        token_ids=[151645],
+    )
+    engine = FakeEngineClient(
+        control_result=control_result,
+        collect_outputs=[[terminal_segment], [], []],
+        collect_delay_s=0.05,
+    )
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") != "session.created":
+            return
+        session = handler._registry.get("sid-native-auto-continuation")
+        assert session is not None
+        session.capabilities.chunk_period_ms = 50
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm_f32_b64(800),
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+        ws.put({"type": "input_audio_buffer.commit", "final": True})
+
+    ws = TimedWebSocket(on_send=on_send)
+    event = _native_session_create("sid-native-auto-continuation")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) >= 3
+    _, mode, payload, final = engine.appended[2]
+    assert mode == "append_audio_chunk"
+    assert payload["duplex_turn_id"] == 0
+    assert final is False
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_real_input_preempts_unsent_silence():
+    request_id = "duplex-sid-native-real-before-silence-e0-stage0"
+
+    class SequencedAppendEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            control_result = {
+                "operation": "append",
+                "session_id": "sid-native-real-before-silence",
+                "ok": True,
+                "unsupported_count": 0,
+                "error_count": 0,
+                "stage_results": [
+                    {
+                        "result": {
+                            "data_plane_append": True,
+                            "request_id": request_id,
+                            "response_stage_id": 1,
+                        }
+                    }
+                ],
+            }
+            terminal_segment = _duplex_tts_output(
+                request_id=request_id,
+                samples=0,
+                finished=True,
+                tts_is_last_chunk=True,
+                token_ids=[151645],
+            )
+            super().__init__(
+                control_result=control_result,
+                collect_outputs=[[terminal_segment], [], []],
+                collect_delay_s=0.01,
+            )
+            self.append_sequence: list[str] = []
+            self.first_real_started = asyncio.Event()
+            self.second_real_started = asyncio.Event()
+            self.real_count = 0
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            kwargs.pop("expected_epoch", None)
+            result = await super().append_duplex_input_async(session_id, **kwargs)
+            payload = kwargs.get("payload")
+            is_silence = (
+                isinstance(payload, dict)
+                and payload.get("audio") == OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
+            )
+            if is_silence:
+                self.append_sequence.append("silence")
+            else:
+                self.real_count += 1
+                self.append_sequence.append(f"real-{self.real_count}")
+                if self.real_count == 1:
+                    self.first_real_started.set()
+                elif self.real_count == 2:
+                    self.second_real_started.set()
+            return result
+
+    session_created = asyncio.Event()
+    engine = SequencedAppendEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") != "session.created":
+            return
+        session = handler._registry.get("sid-native-real-before-silence")
+        assert session is not None
+        session.capabilities.chunk_period_ms = 50
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm_f32_b64(800),
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+        session_created.set()
+
+    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
+    event = _native_session_create("sid-native-real-before-silence")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+
+    await asyncio.wait_for(session_created.wait(), timeout=1)
+    await asyncio.wait_for(engine.first_real_started.wait(), timeout=1)
+    await asyncio.sleep(0.02)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(800, value=0.07),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    await asyncio.wait_for(engine.second_real_started.wait(), timeout=1)
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    assert engine.append_sequence[:2] == ["real-1", "real-2"]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_real_input_waits_for_submitted_silence_tail():
+    request_id = "duplex-sid-native-silence-tail-e0-stage0"
+
+    class SubmittedSilenceEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            control_result = {
+                "operation": "append",
+                "session_id": "sid-native-silence-tail",
+                "ok": True,
+                "unsupported_count": 0,
+                "error_count": 0,
+                "stage_results": [
+                    {
+                        "result": {
+                            "data_plane_append": True,
+                            "request_id": request_id,
+                            "response_stage_id": 1,
+                        }
+                    }
+                ],
+            }
+            terminal_segment = _duplex_tts_output(
+                request_id=request_id,
+                samples=0,
+                finished=True,
+                tts_is_last_chunk=True,
+                token_ids=[151645],
+            )
+            super().__init__(
+                control_result=control_result,
+                collect_outputs=[[terminal_segment], [], []],
+                collect_delay_s=0.01,
+            )
+            self.silence_append_started = asyncio.Event()
+            self.release_silence_append = asyncio.Event()
+            self.append_sequence: list[str] = []
+            self.real_append_count = 0
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            kwargs.pop("expected_epoch", None)
+            payload = kwargs.get("payload")
+            is_silence_continuation = (
+                isinstance(payload, dict)
+                and payload.get("format") == "pcm_f32le"
+                and payload.get("audio") == OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
+            )
+            if is_silence_continuation:
+                result = await super().append_duplex_input_async(session_id, **kwargs)
+                self.append_sequence.append("silence-started")
+                self.silence_append_started.set()
+                await self.release_silence_append.wait()
+                self.append_sequence.append("silence-returned")
+                return result
+            result = await super().append_duplex_input_async(session_id, **kwargs)
+            if (
+                isinstance(payload, dict)
+                and payload.get("audio") != OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
+            ):
+                self.real_append_count += 1
+                self.append_sequence.append(f"real-{self.real_append_count}")
+            return result
+
+    engine = SubmittedSilenceEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+
+    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") != "session.created":
+            return
+        session = handler._registry.get("sid-native-silence-tail")
+        assert session is not None
+        session.capabilities.chunk_period_ms = 50
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": _pcm_f32_b64(800, value=0.05),
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+
+    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
+    event = _native_session_create("sid-native-silence-tail")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+
+    await asyncio.wait_for(engine.silence_append_started.wait(), timeout=1)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000, value=0.07),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    await asyncio.sleep(0.05)
+
+    assert engine.real_append_count == 1
+    assert engine.append_sequence == ["real-1", "silence-started"]
+
+    engine.release_silence_append.set()
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    assert engine.real_append_count == 2
+    assert engine.append_sequence == ["real-1", "silence-started", "silence-returned", "real-2"]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_auto_response_preserves_silence_continuations_across_append_tails():
+    request_id = "duplex-sid-native-continuation-tails-e0-stage0"
+
+    class SequencedAppendEngine(FakeEngineClient):
+        def __init__(self) -> None:
+            control_result = {
+                "operation": "append",
+                "session_id": "sid-native-continuation-tails",
+                "ok": True,
+                "unsupported_count": 0,
+                "error_count": 0,
+                "stage_results": [
+                    {
+                        "result": {
+                            "data_plane_append": True,
+                            "request_id": request_id,
+                            "response_stage_id": 1,
+                        }
+                    }
+                ],
+            }
+            super().__init__(control_result=control_result)
+            self.real_append_started = asyncio.Event()
+            self.release_real_append = asyncio.Event()
+            self.first_silence_started = asyncio.Event()
+            self.release_first_silence = asyncio.Event()
+            self.second_silence_started = asyncio.Event()
+            self.release_collect = asyncio.Event()
+            self.silence_count = 0
+
+        async def append_duplex_input_async(self, session_id: str, **kwargs):
+            kwargs.pop("expected_epoch", None)
+            payload = kwargs.get("payload")
+            assert isinstance(payload, dict)
+            result = await super().append_duplex_input_async(session_id, **kwargs)
+            if payload.get("audio") != OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO:
+                self.real_append_started.set()
+                await self.release_real_append.wait()
+                return result
+
+            self.silence_count += 1
+            if self.silence_count == 1:
+                self.first_silence_started.set()
+                await self.release_first_silence.wait()
+            else:
+                self.second_silence_started.set()
+            return result
+
+        async def collect_duplex_data_plane_outputs_async(
+            self,
+            request_id: str,
+            *,
+            response_stage_id: int | None = None,
+            timeout: float | None = None,
+        ) -> list[object]:
+            del timeout
+            self.collected.append((request_id, response_stage_id))
+            await self.release_collect.wait()
+            return []
+
+    session_created = asyncio.Event()
+
+    def on_send(_ws: TimedWebSocket, data: dict[str, Any]) -> None:
+        if data.get("type") == "session.created":
+            session_created.set()
+
+    engine = SequencedAppendEngine()
+    handler = OmniDuplexSessionHandler(
+        chat_service=FakeChatService(engine),
+        config_timeout_s=0.1,
+        idle_timeout_s=1,
+    )
+    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
+    event = _native_session_create("sid-native-continuation-tails")
+    event["session"]["extra_body"]["auto_response"] = True
+    ws.put(event)
+    ws.put(
+        {
+            "type": "input_audio_buffer.append",
+            "audio": _pcm_f32_b64(16000, value=0.05),
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+    )
+    handler_task = asyncio.create_task(handler.handle_session(ws))
+
+    await asyncio.wait_for(session_created.wait(), timeout=1)
+    await asyncio.wait_for(engine.real_append_started.wait(), timeout=1)
+    session = handler._registry.get("sid-native-continuation-tails")
+    assert session is not None
+    session.capabilities.chunk_period_ms = 50
+    session.bind_request(request_id)
+    response_id = session.begin_response(turn_id=session.turn_id)
+    native = handler._minicpmo_session_state(session)
+    scheduler = native.silence_continuation_scheduler
+    assert scheduler is not None
+
+    payload = handler._native_silence_unit_payload()
+    payload["duplex_turn_id"] = session.turn_id
+    kwargs = {
+        "request_id": request_id,
+        "owner_id": f"response:{response_id}",
+        "response_id": response_id,
+        "response_owned": True,
+        "expected_epoch": session.epoch,
+        "expected_incarnation": session.incarnation,
+        "expected_model_turn_id": None,
+        "send_json": ws.send_json,
+    }
+    assert await scheduler(payload, **kwargs) is True
+
+    next_schedule = asyncio.create_task(scheduler(payload, **kwargs))
+    await asyncio.sleep(0.05)
+    assert not next_schedule.done()
+
+    engine.release_real_append.set()
+    await asyncio.wait_for(engine.first_silence_started.wait(), timeout=1)
+    assert not next_schedule.done()
+
+    engine.release_first_silence.set()
+    assert await asyncio.wait_for(next_schedule, timeout=1) is True
+    await asyncio.wait_for(engine.second_silence_started.wait(), timeout=1)
+    ws.put({"type": "session.close"})
+    await asyncio.wait_for(handler_task, timeout=2)
+
+    assert engine.silence_count == 2
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_uses_segment_text_metadata_for_transcript_cursor():
+    request_id = "duplex-sid-native-repeat-text-e0-stage0"
+
+    def _stage_output(
+        text: str,
+        samples: int,
+        *,
+        segment_text: str,
+        turn_id: int = 0,
+        turn_end: bool = False,
+        token_ids: list[int] | None = None,
+    ):
+        return SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[
+                SimpleNamespace(
+                    text=text,
+                    token_ids=list(token_ids or []),
+                    multimodal_output={
+                        "audio": np.zeros(samples, dtype=np.float32),
+                        "sr": 24000,
+                        "meta.llm_output_text_utf8": np.frombuffer(segment_text.encode("utf-8"), dtype=np.uint8),
+                        "meta": {"duplex_turn_id": turn_id, "turn_end": turn_end},
+                    },
+                )
+            ],
+        )
+
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-native-repeat-text",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(payload: dict[str, Any]) -> None:
+        sent.append(payload)
+
+    async def emit(output: object) -> None:
+        result = {"data_plane_outputs": [output]}
+        for native_result in handler._minicpmo_data_plane.project(
+            result,
+            context=_data_plane_context(session),
+        ):
+            await handler._send_one_native_duplex_event(send_json, native_result, session=session)
+
+    await emit(_stage_output("same reply", 24000, segment_text="same reply"))
+    await emit(
+        _stage_output("same replysame reply", 24000, segment_text="same reply", turn_end=True, token_ids=[151645])
+    )
+
+    await emit(_stage_output("same replysame replysame reply", 48000, segment_text="same reply", turn_id=1))
+    await emit(
+        _stage_output(
+            "same replysame replysame replysame reply",
+            48000,
+            segment_text="same reply",
+            turn_id=1,
+            turn_end=True,
+            token_ids=[151645],
+        )
+    )
+
+    created = [m for m in sent if m.get("type") == "response.created"]
+    done = [m for m in sent if m.get("type") == "response.done"]
+    deltas = [m for m in sent if m.get("type") == "response.output_audio.delta" and m.get("audio")]
+    protocol = NativeRealtimeSessionProtocol(TimedWebSocket())  # type: ignore[arg-type]
+    realtime_events = [event for payload in sent for event in protocol._from_duplex_event(payload)]
+    transcript_deltas = [
+        m for m in realtime_events if m.get("type") == "response.audio_transcript.delta" and m.get("delta")
+    ]
+    assert len(created) == 2
+    assert len(done) == 2
+    assert len(deltas) == 2
+    assert [m["text"] for m in deltas] == ["same reply", "same reply"]
+    assert [m["audio"] for m in deltas] == ["wav-24000", "wav-24000"]
+    assert [m["delta"] for m in transcript_deltas] == ["same reply", "same reply"]
+    assert [m["response_id"] for m in deltas] == [m["response_id"] for m in created]
+    assert [m["response_id"] for m in done] == [m["response_id"] for m in created]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_continuous_speak_reuses_active_response_until_turn_end():
+    request_id = "duplex-sid-native-continuous-speak-e0-stage0"
+
+    def _stage_output(
+        text: str,
+        samples: int,
+        *,
+        turn_end: bool = False,
+        token_ids: list[int] | None = None,
+    ):
+        return SimpleNamespace(
+            request_id=request_id,
+            finished=turn_end,
+            outputs=[
+                SimpleNamespace(
+                    text=text,
+                    token_ids=list(token_ids or []),
+                    multimodal_output={},
+                )
+            ],
+            multimodal_output={
+                "audio": np.zeros(samples, dtype=np.float32),
+                "sr": 24000,
+                "meta.duplex_turn_id": np.array([0], dtype=np.int32),
+                "meta.duplex_epoch": np.array([0], dtype=np.int32),
+                "meta.turn_end": np.array([int(turn_end)], dtype=np.int32),
+                "meta.tts_is_last_chunk": np.array([int(turn_end)], dtype=np.int32),
+            },
+        )
+
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-native-continuous-speak",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(payload: dict[str, Any]) -> None:
+        sent.append(payload)
+
+    async def emit(output: object) -> None:
+        result = {"data_plane_outputs": [output]}
+        for native_result in handler._minicpmo_data_plane.project(
+            result,
+            context=_data_plane_context(session),
+        ):
+            await handler._send_one_native_duplex_event(send_json, native_result, session=session)
+
+    await emit(_stage_output("hello", 24000))
+    await emit(_stage_output("hello again", 48000))
+
+    created = [m for m in sent if m.get("type") == "response.created"]
+    deltas = [m for m in sent if m.get("type") == "response.output_audio.delta" and m.get("audio")]
+    assert len(created) == 1
+    assert len(deltas) == 2
+    assert {m["response_id"] for m in deltas} == {created[0]["response_id"]}
+    assert "response.done" not in [m.get("type") for m in sent]
+
+    await emit(_stage_output("hello again", 48000, turn_end=True, token_ids=[151645]))
+
+    done = [m for m in sent if m.get("type") == "response.done"]
+    assert len(done) == 1
+    assert done[0]["response_id"] == created[0]["response_id"]
+    assert session.active_response_id is None
+    assert session.turn_id == 1
+
+
+@pytest.mark.asyncio
+async def test_continuous_response_metrics_accumulate_only_owned_model_units():
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-response-metrics",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(payload: dict[str, Any]) -> None:
+        sent.append(payload)
+
+    async def emit(*, text: str, audio: str, tokens: int, ttft_ms: float, itls: list[float]) -> None:
+        await handler._send_one_native_duplex_event(
+            send_json,
+            {
+                "supported": True,
+                "stage_role": "tts",
+                "is_listen": False,
+                "data_plane_request_id": "duplex-sid-response-metrics-e0-stage0",
+                "text": text,
+                "audio_data": audio,
+                "audio_format": "pcm16",
+                "audio_duration_ms": 100,
+                "end_of_turn": False,
+                "model_turn_id": 0,
+                "stage_metrics": {
+                    "0": {
+                        "num_tokens_out": tokens,
+                        "stage_gen_time_ms": 80.0,
+                        "vllm_ttft_ms": ttft_ms,
+                        "vllm_tpot_ms": 9.0,
+                        "vllm_itls_ms": itls,
+                    }
+                },
+            },
+            session=session,
+        )
+
+    await emit(text="first", audio="audio-a", tokens=4, ttft_ms=50.0, itls=[10.0, 11.0])
+    await emit(text="second", audio="audio-b", tokens=6, ttft_ms=70.0, itls=[12.0, 13.0, 14.0])
+
+    deltas = [payload for payload in sent if payload.get("type") == "response.output_audio.delta"]
+    assert len(deltas) == 2
+    first_metrics = deltas[0]["vllm_omni"]["stage_metrics"]["0"]
+    second_metrics = deltas[1]["vllm_omni"]["stage_metrics"]["0"]
+    assert first_metrics["num_tokens_out"] == 4
+    assert second_metrics["num_tokens_out"] == 10
+    assert second_metrics["vllm_ttft_ms"] == 50.0
+    assert second_metrics["vllm_itls_ms"] == [10.0, 11.0, 12.0, 13.0, 14.0]
+
+    first_response_id = deltas[0]["response_id"]
+    session.end_response()
+    await emit(text="third", audio="audio-c", tokens=3, ttft_ms=90.0, itls=[15.0, 16.0])
+
+    third_delta = [payload for payload in sent if payload.get("type") == "response.output_audio.delta"][-1]
+    third_metrics = third_delta["vllm_omni"]["stage_metrics"]["0"]
+    assert third_delta["response_id"] != first_response_id
+    assert third_metrics["num_tokens_out"] == 3
+    assert third_metrics["vllm_ttft_ms"] == 90.0
+    assert third_metrics["vllm_itls_ms"] == [15.0, 16.0]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_drops_old_turn_audio_while_new_response_is_active():
+    request_id = "duplex-sid-native-old-turn-audio-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-native-old-turn-audio",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    response_id = session.begin_response(turn_id=1)
+    session.turn_id = 2
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "stale",
+            "audio_data": "old-audio",
+            "audio_format": "pcm16",
+            "audio_duration_ms": 100,
+            "end_of_turn": False,
+            "model_turn_id": 0,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is False
+    assert session.active_response_id == response_id
+    assert ws.sent == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_future_turn_audio_starts_next_response():
+    request_id = "duplex-sid-native-future-turn-audio-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-native-future-turn-audio",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    first_response_id = session.begin_response(turn_id=0)
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": "next",
+            "audio_data": "next-audio",
+            "audio_format": "pcm16",
+            "audio_duration_ms": 100,
+            "end_of_turn": False,
+            "model_turn_id": 1,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is True
+    sent_types = [event["type"] for event in ws.sent]
+    assert sent_types == [
+        "response.done",
+        "response.created",
+        "response.speak",
+        "response.output_audio.delta",
+    ]
+    assert ws.sent[0]["response_id"] == first_response_id
+    assert ws.sent[1]["response_id"] != first_response_id
+    assert ws.sent[3]["response_id"] == ws.sent[1]["response_id"]
+    assert ws.sent[3]["vllm_omni"]["model_turn_id"] == 1
+    assert session.active_response_turn_id == 1
+    assert session.turn_id == 1
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_drops_old_turn_listen_while_new_response_is_active():
+    request_id = "duplex-sid-native-old-turn-listen-e0-stage0"
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
+    session = DuplexSession(
+        session_id="sid-native-old-turn-listen",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    response_id = session.begin_response(turn_id=1)
+    session.turn_id = 2
+    session.bind_request(request_id)
+    ws = TimedWebSocket()
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        ws.send_json,
+        {
+            "supported": True,
+            "stage_role": "llm",
+            "is_listen": True,
+            "model_listen": True,
+            "data_plane_request_id": request_id,
+            "end_of_turn": False,
+            "model_turn_id": 0,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+
+    assert close_reason is None
+    assert emitted is False
+    assert session.active_response_id == response_id
+    assert ws.sent == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_silence_continuation_requires_active_request():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    session = DuplexSession(
+        session_id="sid-native-stale-continuation",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.begin_response()
+    session.bind_request("duplex-sid-native-stale-continuation-stage0")
+    session.mark_audio_sent(100)
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(data: dict[str, Any]) -> None:
+        sent.append(data)
+
+    _install_direct_silence_scheduler(handler, session)
+
+    await handler._maybe_continue_native_response(send_json, session=session, expected_epoch=session.epoch)
+    session.clear_request()
+    await asyncio.sleep(0.01)
+
+    assert engine.appended == []
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_auto_response_segment_complete_continues_until_model_listen():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    session = DuplexSession(
+        session_id="sid-native-segment-complete",
+        config=DuplexSessionConfig(extra_body={"auto_response": True}),
+    )
+    session.capabilities = DuplexCapabilities.minicpmo45_native()
+    response_id = session.begin_response()
+    request_id = "duplex-sid-native-segment-complete-stage0"
+    session.bind_request(request_id)
+    session.mark_audio_sent(1000)
+    _install_direct_silence_scheduler(handler, session)
+    sent: list[dict[str, Any]] = []
+
+    async def send_json(data: dict[str, Any]) -> None:
+        sent.append(data)
+
+    close_reason, emitted = await handler._send_one_native_duplex_event(
+        send_json,
+        {
+            "supported": True,
+            "stage_role": "llm",
+            "is_listen": True,
+            "model_listen": False,
+            "listen_source": "auto_response_segment_complete",
+            "reason": "auto_response_segment_complete",
+            "data_plane_request_id": request_id,
+            "end_of_turn": False,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+            "owned_runtime": False,
+        },
+        session=session,
+        expected_epoch=session.epoch,
+    )
+    await asyncio.sleep(0.01)
+
+    assert close_reason is None
+    assert emitted is False
+    assert session.active_response_id == response_id
+    assert session.active_request_id == request_id
+    assert not handler._minicpmo_data_plane.is_terminal(request_id)
+    assert sent == []
+    assert len(engine.appended) == 1
+    _, mode, payload, final = engine.appended[0]
+    assert mode == "append_audio_chunk"
+    assert payload["type"] == "audio"
+    assert payload.get("force_listen") is not True
+    assert final is False
+
+
+@pytest.mark.parametrize(
+    ("steps", "expected_deltas"),
+    [
+        (
+            [("你好呀", 1), ("你好呀", 1), ("你好呀", 2)],
+            ["你好呀", "", "你好呀"],
+        ),
+        (
+            [("你好呀", 1), ("你好呀", 2)],
+            ["你好呀", "你好呀"],
+        ),
+    ],
+    ids=["turn-scoped", "exact-repeated-turn-text"],
+)
+def test_minicpmo_data_plane_text_cursor(
+    steps: list[tuple[str, int]],
+    expected_deltas: list[str],
+):
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-native-e0-stage0"
+
+    deltas = [data_plane.segment_text_delta(request_id, text, turn_id=turn_id) for text, turn_id in steps]
+
+    assert deltas == expected_deltas
+
+
+def test_minicpmo_data_plane_text_cursor_does_not_clip_prior_turn_overlap():
+    data_plane = _test_data_plane()
+    request_id = "duplex-sid-native-e0-stage0"
+
+    assert data_plane.segment_text_delta(request_id, "你好呀。你有什么想聊的吗？", turn_id=1)
+    assert (
+        data_plane.segment_text_delta(request_id, "你有什么想聊的吗？你好呀。", turn_id=2)
+        == "你有什么想聊的吗？你好呀。"
+    )
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_cancel_interrupts_background_data_plane_stream():
+    control_result = {
+        "operation": "append",
+        "session_id": "sid-native-cancel-stream",
+        "ok": True,
+        "unsupported_count": 0,
+        "error_count": 0,
+        "stage_results": [
+            {
+                "stage_id": 0,
+                "replica_id": 0,
+                "result": {
+                    "supported": True,
+                    "implementation_level": "model_native_duplex",
+                    "data_plane_append": True,
+                    "request_id": "duplex-sid-native-cancel-stream-e0-stage0-s1",
+                    "response_stage_id": 1,
+                },
+            }
+        ],
+    }
+    engine = FakeEngineClient(
+        append_result=control_result,
+        collect_delay_s=0.2,
+        collect_outputs=[
+            [
+                SimpleNamespace(
+                    request_id="duplex-sid-native-cancel-stream-e0-stage0-s1",
+                    finished=True,
+                    outputs=[
+                        SimpleNamespace(
+                            text="",
+                            multimodal_output={"audio": np.zeros(10, dtype=np.float32), "sr": 24000},
+                        )
+                    ],
+                )
+            ]
+        ],
+    )
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-cancel-stream"))
+    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
+    ws.put({"type": "input.cancel"})
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert "audio.cancelled" in ws.sent_types()
+    assert "response.output_audio.delta" not in ws.sent_types()
+    assert engine.signals == [("sid-native-cancel-stream", "barge_in")]
+    assert engine.signal_fences == [DuplexFence("sid-native-cancel-stream")]
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_session_close_discards_partial_pcm_tail():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-short-chunks"))
+    chunk = _pcm_f32_b64(3200)
+    for _ in range(6):
+        ws.put(
+            {
+                "type": "input_audio_buffer.append",
+                "audio": chunk,
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+    ws.put({"type": "session.close"})
+
+    await handler.handle_session(ws)
+
+    assert len(engine.appended) == 1
+    _, mode, payload, final = engine.appended[0]
+    assert mode == "append_audio_chunk"
+    assert final is False
+    assert isinstance(payload, dict)
+    assert len(base64.b64decode(payload["audio"])) == 16000 * 4
+    assert "duplex_num_input_tokens" not in payload
+
+
+@pytest.mark.asyncio
+async def test_minicpmo_native_duplex_idle_timeout_closes_runtime_with_timeout_reason():
+    engine = FakeEngineClient()
+    chat_service = FakeChatService(engine)
+    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=0.1)
+    ws = TimedWebSocket()
+    ws.put(_native_session_create("sid-native-timeout"))
+
+    await handler.handle_session(ws)
+
+    assert ws.sent_types() == ["session.created", "session.closed"]
+    assert ws.sent[-1]["reason"] == "timeout"
+    assert engine.closed == [("sid-native-timeout", "timeout")]
diff --git a/tests/entrypoints/openai_api/test_image_server.py b/tests/entrypoints/openai_api/test_image_server.py
index 5a7ef7bf0..2d6c0299e 100644
--- a/tests/entrypoints/openai_api/test_image_server.py
+++ b/tests/entrypoints/openai_api/test_image_server.py
@@ -1301,7 +1301,11 @@ def test_generate_images_rejects_model_mismatch(test_client):
     assert "model mismatch" in response.json()["detail"].lower()
 
 
-def test_image_file_response_format_multiple(test_client):
+@pytest.mark.parametrize(
+    ("output_format", "expected_pil_format"),
+    [("png", "PNG"), ("jpeg", "JPEG"), ("webp", "WEBP")],
+)
+def test_image_file_response_format_multiple(test_client, output_format, expected_pil_format):
     """Test response_format=file with n>1 returns ZIP archive"""
     response = test_client.post(
         "/v1/images/generations",
@@ -1309,6 +1313,7 @@ def test_image_file_response_format_multiple(test_client):
             "prompt": "a dog",
             "n": 3,
             "response_format": "file",
+            "output_format": output_format,
         },
     )
 
@@ -1317,23 +1322,32 @@ def test_image_file_response_format_multiple(test_client):
     assert "attachment" in response.headers.get("content-disposition", "")
     assert ".zip" in response.headers.get("content-disposition", "")
 
-    # Verify it's a valid ZIP with 3 PNG files
+    # Verify it's a valid ZIP with 3 correctly labelled image files
     import zipfile
 
     zip_buffer = io.BytesIO(response.content)
     with zipfile.ZipFile(zip_buffer, "r") as zf:
         files = zf.namelist()
         assert len(files) == 3
-        assert all(f.endswith(".png") for f in files)
+        assert all(f.endswith(f".{output_format}") for f in files)
 
-        # Verify each file is a valid PNG
+        # Verify each file's bytes match its advertised format
         for filename in files:
             img_bytes = zf.read(filename)
             img = Image.open(io.BytesIO(img_bytes))
-            assert img.format == "PNG"
+            assert img.format == expected_pil_format
 
 
-def test_image_file_response_format_single(test_client):
+@pytest.mark.parametrize(
+    ("output_format", "expected_media_type", "expected_pil_format"),
+    [
+        ("png", "image/png", "PNG"),
+        ("jpg", "image/jpeg", "JPEG"),
+        ("jpeg", "image/jpeg", "JPEG"),
+        ("webp", "image/webp", "WEBP"),
+    ],
+)
+def test_image_file_response_format_single(test_client, output_format, expected_media_type, expected_pil_format):
     """Test response_format=file with n=1 returns a single image file."""
     response = test_client.post(
         "/v1/images/generations",
@@ -1341,16 +1355,61 @@ def test_image_file_response_format_single(test_client):
             "prompt": "a dog",
             "n": 1,
             "response_format": "file",
+            "output_format": output_format,
         },
     )
 
     assert response.status_code == 200
-    assert response.headers["content-type"] == "image/png"
+    assert response.headers["content-type"] == expected_media_type
     assert "attachment" in response.headers.get("content-disposition", "")
-    assert ".png" in response.headers.get("content-disposition", "")
+    assert f".{output_format}" in response.headers.get("content-disposition", "")
 
     img = Image.open(io.BytesIO(response.content))
-    assert img.format == "PNG"
+    assert img.format == expected_pil_format
+
+
+@pytest.mark.parametrize(
+    ("output_format", "image_count", "expected_media_type", "expected_pil_format"),
+    [
+        ("jpeg", 1, "image/jpeg", "JPEG"),
+        ("webp", 2, "application/zip", "WEBP"),
+    ],
+)
+def test_multistage_image_file_response_uses_requested_format(
+    async_omni_test_client,
+    output_format,
+    image_count,
+    expected_media_type,
+    expected_pil_format,
+):
+    engine = async_omni_test_client.app.state.engine_client
+    engine._images = [Image.new("RGB", (16, 16), color="green") for _ in range(image_count)]
+
+    response = async_omni_test_client.post(
+        "/v1/images/generations",
+        json={
+            "prompt": "a dog",
+            "n": image_count,
+            "response_format": "file",
+            "output_format": output_format,
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.headers["content-type"] == expected_media_type
+    if image_count == 1:
+        assert f".{output_format}" in response.headers["content-disposition"]
+        assert Image.open(io.BytesIO(response.content)).format == expected_pil_format
+        return
+
+    import zipfile
+
+    with zipfile.ZipFile(io.BytesIO(response.content), "r") as archive:
+        filenames = archive.namelist()
+        assert len(filenames) == image_count
+        assert all(filename.endswith(f".{output_format}") for filename in filenames)
+        for filename in filenames:
+            assert Image.open(io.BytesIO(archive.read(filename))).format == expected_pil_format
 
 
 def make_test_image_bytes(size=(64, 64)) -> bytes:
@@ -1562,6 +1621,7 @@ def test_image_edit_parameter_pass(async_omni_test_client):
             "output_format": "jpeg",
             "num_inference_steps": 20,
             "guidance_scale": 8.0,
+            "guidance_scale_2": 2.0,
             "seed": 1234,
             "negative_prompt": "negative",
             "n": 2,
@@ -1576,6 +1636,7 @@ def test_image_edit_parameter_pass(async_omni_test_client):
     assert captured_prompt["negative_prompt"] == "negative"
     assert captured_sampling_params.num_inference_steps == 20
     assert captured_sampling_params.guidance_scale == 8.0
+    assert captured_sampling_params.guidance_scale_2 == 2.0
     assert captured_sampling_params.seed == 1234
     assert captured_sampling_params.num_outputs_per_prompt == 2
     assert captured_sampling_params.width == 16
diff --git a/tests/entrypoints/openai_api/test_modality_validation.py b/tests/entrypoints/openai_api/test_modality_validation.py
new file mode 100644
index 000000000..fde0c0ca1
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_modality_validation.py
@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Regression tests for output modality validation in chat completions.
+
+Covers:
+- #4719: unsupported modality must return an error, not empty choices
+- Single-stage diffusion text-output path must remain accessible
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
+from vllm.entrypoints.openai.engine.protocol import ErrorResponse
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_serving_chat(output_modalities: list[str], stage_configs=None):
+    """Build a minimal OmniOpenAIServingChat with mocked internals."""
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    instance = object.__new__(OmniOpenAIServingChat)
+    instance.engine_client = SimpleNamespace(
+        output_modalities=output_modalities,
+        errored=False,
+        stage_configs=stage_configs or [],
+    )
+    instance._diffusion_mode = False
+    instance.models = MagicMock()
+    instance.models.model_name.return_value = "test-model"
+    instance.enable_prompt_tokens_details = False
+
+    renderer = MagicMock()
+    renderer.get_tokenizer.return_value = MagicMock()
+    instance.renderer = renderer
+    instance.online_renderer = MagicMock()
+    instance.online_renderer.validate_chat_template.return_value = None
+
+    instance.parser_cls = None
+    instance.use_harmony = False
+    instance.trust_request_chat_template = True
+    instance.chat_template = None
+    instance.chat_template_content_format = "auto"
+    instance.default_chat_template_kwargs = {}
+    instance.enable_auto_tools = False
+    instance.exclude_tools_when_tool_choice_none = False
+    instance._check_model = AsyncMock(return_value=None)
+    return instance
+
+
+def _make_request(modalities):
+    """Build a ChatCompletionRequest with the given modalities."""
+    req = ChatCompletionRequest(
+        model="test-model",
+        messages=[{"role": "user", "content": "hello"}],
+    )
+    req.modalities = modalities
+    return req
+
+
+@pytest.mark.asyncio
+async def test_unsupported_modality_returns_error():
+    """#4719: requesting 'video' on a text/audio model must return an error."""
+    serving = _make_serving_chat(["text", "audio"])
+    request = _make_request(["video"])
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        result = await serving._create_chat_completion(request)
+
+    assert isinstance(result, ErrorResponse)
+    assert "video" in result.error.message
+    assert "Unsupported" in result.error.message
+
+
+@pytest.mark.asyncio
+async def test_supported_modality_passes_validation():
+    """Requesting a supported modality must not trigger an error."""
+    serving = _make_serving_chat(["text", "audio"])
+    request = _make_request(["text"])
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        try:
+            result = await serving._create_chat_completion(request)
+        except (AttributeError, TypeError):
+            return
+
+    assert not isinstance(result, ErrorResponse)
+
+
+@pytest.mark.asyncio
+async def test_invalid_modalities_type_returns_error():
+    """Modalities must be a list of strings."""
+    serving = _make_serving_chat(["text", "audio"])
+    request = _make_request("audio")  # bare string, not a list
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        result = await serving._create_chat_completion(request)
+
+    assert isinstance(result, ErrorResponse)
+    assert "list of strings" in result.error.message
+
+
+@pytest.mark.asyncio
+async def test_modalities_with_non_string_element_returns_error():
+    """Modalities list with non-string elements must be rejected."""
+    serving = _make_serving_chat(["text", "audio"])
+    request = _make_request(["text", 123])
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        result = await serving._create_chat_completion(request)
+
+    assert isinstance(result, ErrorResponse)
+    assert "list of strings" in result.error.message
+
+
+@pytest.mark.asyncio
+async def test_single_stage_diffusion_allows_text_modality():
+    """Single-stage diffusion engines that advertise 'image' must also accept 'text'."""
+    stage_configs = [SimpleNamespace(stage_type="diffusion", is_comprehension=False)]
+    serving = _make_serving_chat(["image"], stage_configs=stage_configs)
+    request = _make_request(["text"])
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        try:
+            result = await serving._create_chat_completion(request)
+        except (AttributeError, TypeError):
+            return
+
+    assert not isinstance(result, ErrorResponse)
+
+
+@pytest.mark.asyncio
+async def test_single_stage_diffusion_rejects_unsupported_modality():
+    """Single-stage diffusion must still reject truly unsupported modalities."""
+    stage_configs = [SimpleNamespace(stage_type="diffusion", is_comprehension=False)]
+    serving = _make_serving_chat(["image"], stage_configs=stage_configs)
+    request = _make_request(["video"])
+
+    with patch.object(serving, "_preprocess_chat", new_callable=AsyncMock, return_value=([], [{}])):
+        result = await serving._create_chat_completion(request)
+
+    assert isinstance(result, ErrorResponse)
+    assert "video" in result.error.message
diff --git a/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py b/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
index cf7d6e234..c47eb8da6 100644
--- a/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
+++ b/tests/entrypoints/openai_api/test_omni_sleep_wakeup.py
@@ -175,6 +175,26 @@ def test_wakeup_engine_not_support(sleep_incapable_engine):
     assert "wake_up" in response.json()["detail"]
 
 
+def test_wakeup_route_propagates_not_implemented_error(sleep_capable_engine, mocker):
+    """``/v1/omni/wakeup`` must not swallow ``NotImplementedError`` from the engine.
+
+    Route exception-propagation only: the mock authors the exception on purpose.
+    The real level-2 discarded-weight path and live HTTP 501 mapping are covered by
+    ``test_wakeup_after_level2_sleep_fails``.
+    """
+    sleep_capable_engine.wake_up = mocker.AsyncMock(side_effect=NotImplementedError("engine wake_up refused"))
+    app = _make_app(sleep_capable_engine)
+    app.state.sleeping_stages = {0}
+    # Re-raise in-process; default TestClient would wrap this as a 500 response.
+    client = TestClient(app, raise_server_exceptions=True)
+
+    with pytest.raises(NotImplementedError, match="engine wake_up refused"):
+        client.post("/v1/omni/wakeup", json={"stage_ids": [0]})
+
+    # Failed wake must not clear the sleeping set.
+    assert app.state.sleeping_stages == {0}
+
+
 def test_wakeup_removes_only_requested_stages(sleep_capable_engine):
     app = _make_app(sleep_capable_engine)
     app.state.sleeping_stages = {0, 1, 2}
diff --git a/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py b/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
index 50f8eef91..325daabdd 100644
--- a/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
+++ b/tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py
@@ -201,6 +201,7 @@ def _assert_realtime_smoke(result: dict) -> None:
 def _assert_realtime_accuracy(
     result: dict,
     whisper_model_size: str = "large-v3",
+    threshold: float = 0.8,
 ) -> None:
     """Assert that whisper transcription of audio output matches model text.
 
@@ -214,6 +215,12 @@ def _assert_realtime_accuracy(
                    variability even though audio generation was correct. large-v3
                    transcribes these clips reliably, so a failure here now points
                    at the model, not the ASR grader.
+        threshold: Minimum cosine similarity (with length penalty) required to
+                   pass. Default 0.8. Do not lower per-callsite without data:
+                   at 0.35 the assertion no longer detects real audio
+                   regressions. If a variant genuinely needs a different gate
+                   (e.g. whisper partial transcripts under async_chunk), propose
+                   it in its own PR with measurements.
     """
     final_text = (result["transcription_text"] or "").strip()
     assert final_text, "Expected non-empty transcription (model text stream)"
@@ -223,8 +230,9 @@ def _assert_realtime_accuracy(
     assert whisper_text, "Whisper returned empty string for synthesized output audio"
 
     sim = cosine_similarity_text(whisper_text.lower(), final_text.lower())
-    assert sim > 0.8, (
-        f"Output audio transcript should match model text (sim={sim:.3f}): "
+    assert sim > threshold, (
+        f"Output audio transcript should match model text (sim={sim:.3f}, "
+        f"threshold={threshold}): "
         f"whisper={whisper_text!r}, model_text={final_text!r}"
     )
 
diff --git a/tests/entrypoints/openai_api/test_qwen3_tts_websocket.py b/tests/entrypoints/openai_api/test_qwen3_tts_websocket.py
index 058b20331..132d43858 100644
--- a/tests/entrypoints/openai_api/test_qwen3_tts_websocket.py
+++ b/tests/entrypoints/openai_api/test_qwen3_tts_websocket.py
@@ -33,26 +33,63 @@ tts_ws_server_params = [
 ]
 
 
-async def _run_ws_session(host: str, port: int, model: str) -> dict:
-    uri = f"ws://{host}:{port}/v1/audio/speech/stream"
+def _session_config(model: str) -> str:
+    return json.dumps(
+        {
+            "type": "session.config",
+            "model": model,
+            "voice": "vivian",
+            "language": "English",
+            "response_format": "pcm",
+            "stream_audio": True,
+        }
+    )
+
+
+async def _collect_utterance(ws) -> dict:
+    """Read frames until session.done closes out one flushed utterance."""
     starts: list[dict] = []
     dones: list[dict] = []
     chunk_lengths: dict[int, list[int]] = {}
     session_done: dict | None = None
 
+    while True:
+        message = await asyncio.wait_for(ws.recv(), timeout=180)
+        if isinstance(message, bytes):
+            if not starts:
+                raise AssertionError("Received audio bytes before audio.start")
+            sentence_index = starts[-1]["sentence_index"]
+            chunk_lengths.setdefault(sentence_index, []).append(len(message))
+            continue
+
+        payload = json.loads(message)
+        msg_type = payload.get("type")
+        if msg_type == "audio.start":
+            starts.append(payload)
+            chunk_lengths.setdefault(payload["sentence_index"], [])
+        elif msg_type == "audio.done":
+            dones.append(payload)
+        elif msg_type == "session.done":
+            session_done = payload
+            break
+        elif msg_type == "error":
+            raise AssertionError(f"WebSocket error: {payload['message']}")
+        else:
+            raise AssertionError(f"Unexpected WebSocket message: {payload}")
+
+    return {
+        "starts": starts,
+        "dones": dones,
+        "chunk_lengths": chunk_lengths,
+        "session_done": session_done,
+    }
+
+
+async def _run_ws_session(host: str, port: int, model: str) -> dict:
+    uri = f"ws://{host}:{port}/v1/audio/speech/stream"
+
     async with websockets.connect(uri, max_size=None) as ws:
-        await ws.send(
-            json.dumps(
-                {
-                    "type": "session.config",
-                    "model": model,
-                    "voice": "vivian",
-                    "language": "English",
-                    "response_format": "pcm",
-                    "stream_audio": True,
-                }
-            )
-        )
+        await ws.send(_session_config(model))
         await ws.send(
             json.dumps(
                 {
@@ -67,42 +104,29 @@ async def _run_ws_session(host: str, port: int, model: str) -> dict:
         )
         await ws.send(json.dumps({"type": "input.done"}))
 
-        while True:
-            message = await asyncio.wait_for(ws.recv(), timeout=180)
-            if isinstance(message, bytes):
-                if not starts:
-                    raise AssertionError("Received audio bytes before audio.start")
-                sentence_index = starts[-1]["sentence_index"]
-                chunk_lengths.setdefault(sentence_index, []).append(len(message))
-                continue
+        return await _collect_utterance(ws)
 
-            payload = json.loads(message)
-            msg_type = payload.get("type")
-            if msg_type == "audio.start":
-                starts.append(payload)
-                chunk_lengths.setdefault(payload["sentence_index"], [])
-            elif msg_type == "audio.done":
-                dones.append(payload)
-            elif msg_type == "session.done":
-                session_done = payload
-                break
-            elif msg_type == "error":
-                raise AssertionError(f"WebSocket error: {payload['message']}")
-            else:
-                raise AssertionError(f"Unexpected WebSocket message: {payload}")
 
-    return {
-        "starts": starts,
-        "dones": dones,
-        "chunk_lengths": chunk_lengths,
-        "session_done": session_done,
-    }
+async def _run_ws_reused_connection(host: str, port: int, model: str, texts: list[str]) -> list[dict]:
+    """Synthesize several utterances over a single connection."""
+    uri = f"ws://{host}:{port}/v1/audio/speech/stream"
+    results: list[dict] = []
+
+    async with websockets.connect(uri, max_size=None) as ws:
+        await ws.send(_session_config(model))
+        for text in texts:
+            await ws.send(json.dumps({"type": "input.text", "text": text}))
+            await ws.send(json.dumps({"type": "input.done"}))
+            results.append(await _collect_utterance(ws))
+        await ws.send(json.dumps({"type": "session.close"}))
+
+    return results
 
 
 class TestQwen3TTSWebSocket:
     @pytest.mark.advanced_model
     @pytest.mark.tts
-    @hardware_test(res={"cuda": "L4"}, num_cards=4)
+    @hardware_test(res={"cuda": "L4"}, num_cards=1)
     @pytest.mark.parametrize("omni_server", tts_ws_server_params, indirect=True)
     def test_streaming_pcm_output(self, omni_server) -> None:
         result = asyncio.run(_run_ws_session(omni_server.host, omni_server.port, omni_server.model))
@@ -113,6 +137,7 @@ class TestQwen3TTSWebSocket:
         session_done = result["session_done"]
 
         assert session_done is not None
+        assert session_done["utterance_index"] == 0
         assert session_done["total_sentences"] == 1
         assert len(starts) == 1
         assert len(dones) == 1
@@ -131,3 +156,32 @@ class TestQwen3TTSWebSocket:
             assert total_bytes > 0
             assert chunk_lengths[sentence_index], f"Expected binary PCM frames for sentence {sentence_index}"
             assert sum(chunk_lengths[sentence_index]) == total_bytes
+
+    @pytest.mark.advanced_model
+    @pytest.mark.tts
+    @hardware_test(res={"cuda": "L4"}, num_cards=1)
+    @pytest.mark.parametrize("omni_server", tts_ws_server_params, indirect=True)
+    def test_input_done_flushes_without_closing_connection(self, omni_server) -> None:
+        # input.done must flush the buffer and leave the connection usable:
+        # the second utterance is synthesized without a second handshake.
+        texts = [
+            "This is the first utterance sent over the websocket connection.",
+            "This is the second utterance, reusing the very same connection.",
+        ]
+        results = asyncio.run(_run_ws_reused_connection(omni_server.host, omni_server.port, omni_server.model, texts))
+
+        assert len(results) == len(texts)
+        for expected_index, result in enumerate(results):
+            assert result["session_done"] == {
+                "type": "session.done",
+                "utterance_index": expected_index,
+                "total_sentences": 1,
+            }
+            assert len(result["starts"]) == 1
+            assert len(result["dones"]) == 1
+            # utterance_index counts the flushes of the connection, while
+            # sentence_index stays within the flush it belongs to.
+            assert result["starts"][0]["utterance_index"] == expected_index
+            assert result["starts"][0]["sentence_index"] == 0
+            assert result["dones"][0]["error"] is False
+            assert result["dones"][0]["total_bytes"] > 0
diff --git a/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py
new file mode 100644
index 000000000..1a3a4f22e
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_serving_chat_minicpmo45_stream_output_kinds.py
@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Regression tests for MiniCPM-o 4.5 audio-streaming output-kind coercion.
+
+Chat ``stream=true`` coerces every AR stage to DELTA. For MiniCPM-o 4.5 that
+hands ``llm2tts`` one thinker token per step while the forwarded hidden states
+still span prompt + generated, so the talker is conditioned on a broadcast
+mismatch (issue #5298). The thinker must stay FINAL_ONLY; only the talker
+streams.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+from vllm.sampling_params import RequestOutputKind, SamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+MINICPMO45_ARCH = "MiniCPMO45OmniForConditionalGeneration"
+
+
+@pytest.fixture
+def serving_chat():
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    return object.__new__(OmniOpenAIServingChat)
+
+
+def _stage(model_arch: str, model_stage: str) -> SimpleNamespace:
+    # SimpleNamespace, not MagicMock: _stage_get prefers .get() when present,
+    # and a MagicMock satisfies hasattr(obj, "get") and returns a mock.
+    return SimpleNamespace(engine_args=SimpleNamespace(model_arch=model_arch, model_stage=model_stage))
+
+
+def _minicpmo45_stages():
+    return [_stage(MINICPMO45_ARCH, "llm"), _stage(MINICPMO45_ARCH, "tts")]
+
+
+def _delta_params(n: int = 2):
+    return [SamplingParams(output_kind=RequestOutputKind.DELTA) for _ in range(n)]
+
+
+def test_thinker_forced_final_only_talker_stays_delta(serving_chat):
+    serving_chat.engine_client = SimpleNamespace(stage_configs=_minicpmo45_stages())
+
+    out = serving_chat._fix_minicpmo45_audio_stream_output_kinds(_delta_params(), ["text", "audio"])
+
+    assert out[0].output_kind is RequestOutputKind.FINAL_ONLY
+    assert out[1].output_kind is RequestOutputKind.DELTA
+
+
+@pytest.mark.parametrize("modalities", [None, [], ["text"]])
+def test_non_audio_request_is_untouched(serving_chat, modalities):
+    serving_chat.engine_client = SimpleNamespace(stage_configs=_minicpmo45_stages())
+
+    out = serving_chat._fix_minicpmo45_audio_stream_output_kinds(_delta_params(), modalities)
+
+    assert [p.output_kind for p in out] == [RequestOutputKind.DELTA] * 2
+
+
+def test_other_architectures_are_untouched(serving_chat):
+    stages = [_stage("SomeOtherOmniForConditionalGeneration", "llm")]
+    serving_chat.engine_client = SimpleNamespace(stage_configs=stages)
+
+    out = serving_chat._fix_minicpmo45_audio_stream_output_kinds(_delta_params(1), ["text", "audio"])
+
+    assert out[0].output_kind is RequestOutputKind.DELTA
+
+
+def test_shorter_sampling_params_list_does_not_raise(serving_chat):
+    serving_chat.engine_client = SimpleNamespace(stage_configs=_minicpmo45_stages())
+
+    out = serving_chat._fix_minicpmo45_audio_stream_output_kinds(_delta_params(1), ["text", "audio"])
+
+    assert len(out) == 1
+    assert out[0].output_kind is RequestOutputKind.FINAL_ONLY
diff --git a/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py b/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
index a6c7baffe..de3158d43 100644
--- a/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
+++ b/tests/entrypoints/openai_api/test_serving_chat_sampling_params.py
@@ -6,10 +6,12 @@ Tests that standard OpenAI API parameters (max_tokens, temperature, etc.)
 are correctly applied to the comprehension stage while preserving YAML defaults.
 """
 
+import asyncio
 from types import SimpleNamespace
 
 import pytest
 from pytest_mock import MockerFixture
+from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
 from vllm.sampling_params import SamplingParams
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -86,6 +88,233 @@ def serving_chat(mock_engine_client):
     return instance
 
 
+def test_serving_boundary_normalizes_declared_root_and_nested_extras(serving_chat):
+    serving_chat._diffusion_extra_body_params = frozenset({"cfg_text_scale", "negative_prompt"})
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[],
+        modalities=["image"],
+        num_inference_steps=7,
+        size="768x512",
+        negative_prompt="avoid blur",
+        lora={"name": "adapter"},
+        cfg_text_scale=7.0,
+        extra_body={"extra_args": {"sample_solver": "euler"}},
+    )
+
+    normalized_extra_args, diffusion_request_args = serving_chat._normalize_diffusion_request_args(request)
+
+    assert normalized_extra_args == {
+        "cfg_text_scale": 7.0,
+        "sample_solver": "euler",
+    }
+    assert diffusion_request_args["cfg_text_scale"] == 7.0
+    assert diffusion_request_args["num_inference_steps"] == 7
+    assert diffusion_request_args["size"] == "768x512"
+    assert diffusion_request_args["negative_prompt"] == "avoid blur"
+    assert diffusion_request_args["lora"] == {"name": "adapter"}
+    assert diffusion_request_args["modalities"] == ["image"]
+
+
+def test_unknown_root_extra_does_not_claim_canonical_extra(serving_chat):
+    serving_chat._diffusion_extra_body_params = frozenset()
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[],
+        pipeline_option="ignored-root-value",
+        extra_args={"pipeline_option": "canonical-value"},
+    )
+
+    normalized_extra_args, diffusion_request_args = serving_chat._normalize_diffusion_request_args(request)
+
+    assert normalized_extra_args == {
+        "pipeline_option": "canonical-value",
+    }
+    assert "pipeline_option" not in diffusion_request_args
+
+
+def test_unregistered_cfg_scale_aliases_common_true_cfg_scale(serving_chat):
+    serving_chat._diffusion_extra_body_params = frozenset()
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[],
+        cfg_scale=7.0,
+    )
+
+    normalized_extra_args, diffusion_request_args = serving_chat._normalize_diffusion_request_args(request)
+
+    assert normalized_extra_args == {}
+    assert diffusion_request_args == {"true_cfg_scale": 7.0}
+
+
+@pytest.mark.parametrize(
+    ("registered", "request_kwargs"),
+    [
+        ({"cfg_scale"}, {"cfg_scale": 7.0, "extra_args": {"cfg_scale": 8.0}}),
+        (set(), {"cfg_scale": 7.0, "true_cfg_scale": 2.0}),
+    ],
+    ids=["registered-model-extra", "unregistered-common-alias"],
+)
+def test_cfg_scale_owner_conflicts_are_rejected(serving_chat, registered, request_kwargs):
+    serving_chat._diffusion_extra_body_params = frozenset(registered)
+    request = ChatCompletionRequest(model="test", messages=[], **request_kwargs)
+
+    with pytest.raises(ValueError, match="provided more than once"):
+        serving_chat._normalize_diffusion_request_args(request)
+
+
+@pytest.mark.parametrize("diffusion_mode", [True, False], ids=["pure", "mixed"])
+def test_duplicate_extras_return_the_same_bad_request_before_dispatch(
+    serving_chat,
+    mocker: MockerFixture,
+    diffusion_mode: bool,
+):
+    serving_chat._diffusion_mode = diffusion_mode
+    serving_chat._diffusion_extra_body_params = frozenset({"sample_solver"})
+    serving_chat.engine_client.stage_configs = [SimpleNamespace(stage_type="diffusion")]
+    check_model = mocker.patch.object(serving_chat, "_check_model", new=mocker.AsyncMock())
+    pure_dispatch = mocker.patch.object(
+        serving_chat,
+        "_create_diffusion_chat_completion",
+        new=mocker.AsyncMock(),
+    )
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[],
+        sample_solver="euler",
+        extra_args={"sample_solver": "ddim"},
+    )
+
+    response = asyncio.run(serving_chat._create_chat_completion(request))
+
+    assert response.error.code == 400
+    assert response.error.message == (
+        'Diffusion request parameters were provided more than once: "sample_solver": '
+        "request.sample_solver, request.extra_args.sample_solver."
+    )
+    check_model.assert_not_awaited()
+    pure_dispatch.assert_not_awaited()
+
+
+def test_pure_consumer_preserves_defaults_and_separate_cfg_owners(serving_chat, mocker: MockerFixture):
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    captured: dict[str, object] = {}
+
+    async def generate(**kwargs):
+        captured.update(kwargs)
+        if False:
+            yield None
+
+    serving_chat._diffusion_model_name = "test"
+    serving_chat._diffusion_engine = SimpleNamespace(
+        stage_configs=[SimpleNamespace(stage_type="diffusion")],
+        default_sampling_params_list=[
+            OmniDiffusionSamplingParams(extra_args={"solver": "euler", "stage_default": True}),
+        ],
+        generate=generate,
+    )
+    serving_chat._diffusion_mode = True
+    serving_chat._diffusion_extra_body_params = frozenset({"cfg_scale"})
+    serving_chat._extract_diffusion_prompt_and_media = mocker.Mock(return_value=("prompt", [], [], []))
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[],
+        modalities=["image"],
+        num_inference_steps=7,
+        size="768x512",
+        negative_prompt="avoid blur",
+        cfg_scale=7.0,
+        true_cfg_scale=2.0,
+        extra_body={"extra_args": {"solver": "ddim"}},
+    )
+
+    response = asyncio.run(serving_chat._create_chat_completion(request))
+
+    (sampling_params,) = captured["sampling_params_list"]
+    assert sampling_params.extra_args == {
+        "cfg_scale": 7.0,
+        "solver": "ddim",
+        "stage_default": True,
+    }
+    assert sampling_params.true_cfg_scale == 2.0
+    assert sampling_params.num_inference_steps == 7
+    assert (sampling_params.height, sampling_params.width) == (512, 768)
+    assert captured["prompt"]["negative_prompt"] == "avoid blur"
+    assert response.error.message == "No output generated from AsyncOmni"
+
+
+def test_mixed_consumer_keeps_root_common_args_with_nested_extras(serving_chat, mocker: MockerFixture):
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    serving_chat.engine_client.stage_configs = [
+        SimpleNamespace(stage_type="llm", is_comprehension=True),
+        SimpleNamespace(stage_type="diffusion", is_comprehension=False),
+    ]
+    serving_chat.engine_client.default_sampling_params_list = [
+        SamplingParams(),
+        OmniDiffusionSamplingParams(),
+    ]
+    serving_chat.engine_client.output_modalities = ["image"]
+    serving_chat.engine_client.errored = False
+
+    captured: dict[str, object] = {}
+
+    async def results():
+        if False:
+            yield None
+
+    def generate(**kwargs):
+        captured.update(kwargs)
+        return results()
+
+    serving_chat.engine_client.generate = generate
+    serving_chat.__dict__.update(
+        _diffusion_mode=False,
+        _diffusion_extra_body_params=frozenset(),
+        models=SimpleNamespace(model_name=lambda _: "test"),
+        renderer=SimpleNamespace(get_tokenizer=lambda: object()),
+        online_renderer=SimpleNamespace(validate_chat_template=lambda **_: None),
+        parser_cls=None,
+        use_harmony=False,
+        enable_auto_tools=False,
+        exclude_tools_when_tool_choice_none=False,
+        trust_request_chat_template=True,
+        chat_template=None,
+        chat_template_content_format="auto",
+    )
+    mocker.patch.multiple(
+        serving_chat,
+        _check_model=mocker.AsyncMock(return_value=None),
+        _maybe_get_adapters=mocker.Mock(return_value=None),
+        _effective_chat_template_kwargs=mocker.Mock(return_value={}),
+        _preprocess_chat=mocker.AsyncMock(return_value=([], [{"prompt": "raw"}])),
+        _base_request_id=mocker.Mock(return_value="test"),
+        _extract_diffusion_prompt_and_images_from_messages=mocker.Mock(return_value=("prompt", [])),
+        _log_inputs=mocker.Mock(),
+        chat_completion_full_generator=mocker.AsyncMock(return_value="done"),
+    )
+    request = ChatCompletionRequest(
+        model="test",
+        messages=[{"role": "user", "content": "prompt"}],
+        modalities=["image"],
+        num_inference_steps=7,
+        size="768x512",
+        negative_prompt="avoid blur",
+        extra_body={"extra_args": {"solver": "euler"}},
+    )
+
+    assert asyncio.run(serving_chat._create_chat_completion(request)) == "done"
+
+    sampling_params_list = captured["sampling_params_list"]
+    assert sampling_params_list[0].extra_args == {"target_h": 512, "target_w": 768}
+    diffusion_params = sampling_params_list[1]
+    assert diffusion_params.num_inference_steps == 7
+    assert (diffusion_params.height, diffusion_params.width) == (512, 768)
+    assert diffusion_params.extra_args == {"solver": "euler"}
+    assert captured["prompt"]["negative_prompt"] == "avoid blur"
+
+
 @pytest.fixture
 def mock_request(mocker: MockerFixture):
     """Create a mock request with all OpenAI sampling params set to None."""
@@ -616,124 +845,3 @@ class TestResolveHeightWidth:
         h, w = OmniOpenAIServingChat._resolve_height_width_from_extra_body({"size": "invalid"})
         assert h is None
         assert w is None
-
-
-# =============================================================================
-# Tests for _apply_request_overrides with GLM-Image (target_h/w injection)
-# =============================================================================
-
-
-class TestApplyRequestOverridesGLMImage:
-    """Test target_h/w injection for GLM-Image AR stage.
-
-    max_tokens is NOT computed dynamically — it comes from the deploy YAML
-    default (e.g. 4353). _apply_request_overrides only injects target_h/w
-    into extra_args so the model can build M-RoPE position grids.
-    """
-
-    @pytest.fixture
-    def glm_serving_chat(self, mock_engine_client, mocker: MockerFixture):
-        from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
-
-        instance = object.__new__(OmniOpenAIServingChat)
-        instance.engine_client = mock_engine_client
-        instance._extract_diffusion_prompt_and_images_from_messages = mocker.MagicMock(return_value=("a cat", []))
-        return instance
-
-    @pytest.fixture
-    def glm_request(self, mocker: MockerFixture):
-        req = mocker.MagicMock()
-        req.temperature = None
-        req.top_p = None
-        req.top_k = None
-        req.max_tokens = None
-        req.min_tokens = None
-        req.seed = None
-        req.ignore_eos = None
-        req.stop = None
-        req.stop_token_ids = None
-        req.frequency_penalty = None
-        req.presence_penalty = None
-        req.extra_body = {"height": 1024, "width": 1024}
-        req.model_fields_set = set()
-        return req
-
-    def test_t2i_injects_target_h_w(self, glm_serving_chat, glm_request, default_comprehension_params):
-        """t2i mode: target_h/w injected into extra_args, max_tokens unchanged."""
-        result = glm_serving_chat._apply_request_overrides(default_comprehension_params, glm_request)
-        assert result.extra_args["target_h"] == 1024
-        assert result.extra_args["target_w"] == 1024
-        # max_tokens stays at YAML default (not dynamically computed)
-        assert result.max_tokens == 4353
-
-    def test_i2i_injects_target_h_w(
-        self, glm_serving_chat, glm_request, default_comprehension_params, mocker: MockerFixture
-    ):
-        """i2i mode: target_h/w injected, max_tokens unchanged."""
-        glm_serving_chat._extract_diffusion_prompt_and_images_from_messages = mocker.MagicMock(
-            return_value=("edit this", ["fake_image"])
-        )
-        result = glm_serving_chat._apply_request_overrides(default_comprehension_params, glm_request)
-        assert result.extra_args["target_h"] == 1024
-        assert result.extra_args["target_w"] == 1024
-        # max_tokens stays at YAML default regardless of t2i/i2i
-        assert result.max_tokens == 4353
-
-    def test_user_max_tokens_preserved(self, glm_serving_chat, glm_request, default_comprehension_params):
-        """User-provided max_tokens is respected (not overridden by dynamic computation)."""
-        glm_request.max_tokens = 500
-        glm_request.model_fields_set = {"max_tokens"}
-
-        result = glm_serving_chat._apply_request_overrides(default_comprehension_params, glm_request)
-        assert result.max_tokens == 500
-        assert result.extra_args["target_h"] == 1024
-        assert result.extra_args["target_w"] == 1024
-
-    def test_no_height_width_preserves_default(
-        self, glm_serving_chat, mocker: MockerFixture, default_comprehension_params
-    ):
-        """When no height/width in extra_body, keep YAML default max_tokens, no target_h/w."""
-        req = mocker.MagicMock()
-        req.temperature = None
-        req.top_p = None
-        req.top_k = None
-        req.max_tokens = None
-        req.min_tokens = None
-        req.seed = None
-        req.ignore_eos = None
-        req.stop = None
-        req.stop_token_ids = None
-        req.frequency_penalty = None
-        req.presence_penalty = None
-        req.extra_body = {}
-        req.model_fields_set = set()
-
-        result = glm_serving_chat._apply_request_overrides(default_comprehension_params, req)
-        assert result.max_tokens == 4353  # YAML default
-        # No target_h/w injected when dimensions not provided
-        assert not result.extra_args or "target_h" not in (result.extra_args or {})
-
-    def test_size_string_parsed_for_glm_image(
-        self, glm_serving_chat, mocker: MockerFixture, default_comprehension_params
-    ):
-        """'size' in extra_body is parsed as fallback for height/width."""
-        req = mocker.MagicMock()
-        req.temperature = None
-        req.top_p = None
-        req.top_k = None
-        req.max_tokens = None
-        req.min_tokens = None
-        req.seed = None
-        req.ignore_eos = None
-        req.stop = None
-        req.stop_token_ids = None
-        req.frequency_penalty = None
-        req.presence_penalty = None
-        req.extra_body = {"size": "512x512"}
-        req.model_fields_set = set()
-
-        result = glm_serving_chat._apply_request_overrides(default_comprehension_params, req)
-        assert result.extra_args["target_h"] == 512
-        assert result.extra_args["target_w"] == 512
-        # max_tokens stays at YAML default (not dynamically computed)
-        assert result.max_tokens == 4353
diff --git a/tests/entrypoints/openai_api/test_serving_speech.py b/tests/entrypoints/openai_api/test_serving_speech.py
index 904e5735c..3739f8860 100644
--- a/tests/entrypoints/openai_api/test_serving_speech.py
+++ b/tests/entrypoints/openai_api/test_serving_speech.py
@@ -25,6 +25,7 @@ from vllm.entrypoints.openai.engine.protocol import ErrorInfo, ErrorResponse
 
 from vllm_omni.entrypoints.omni_base import OmniEngineDeadError
 from vllm_omni.entrypoints.openai import api_server as api_server_module
+from vllm_omni.entrypoints.openai import serving_speech as serving_speech_module
 from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin
 from vllm_omni.entrypoints.openai.protocol.audio import (
     BatchSpeechRequest,
@@ -45,6 +46,13 @@ from vllm_omni.model_executor.models.fish_speech.prompt_utils import (
     FISH_TEXT_ONLY_SYSTEM_PROMPT,
     build_fish_voice_clone_prompt_ids,
 )
+from vllm_omni.model_executor.models.ming_tts.constants import (
+    KEY_SPEAKER_EMBEDDING,
+    KEY_SPEAKER_SAMPLE_RATES,
+    KEY_SPEAKER_WAVEFORM,
+    KEY_SPEAKER_WAVEFORM_LENGTHS,
+    SPEAKER_EMBEDDING_DIM,
+)
 from vllm_omni.outputs import OmniRequestOutput
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -975,21 +983,25 @@ class TestTTSMethods:
             )
 
     def test_upload_ming_voice_embedding_wrong_dims_rejected_without_replacing_existing(self, speech_server):
-        """Ming embedding uploads must be 192-dim before replacing stored voices."""
+        """Ming embedding uploads must match the model dimension before replacement."""
         speech_server._tts_model_type = "ming_tts"
+        invalid_dim = SPEAKER_EMBEDDING_DIM - 1
         existing = {
             "name": "bad_emb_voice",
             "file_path": "/tmp/voice_samples/bad_emb_voice.safetensors",
             "mime_type": "application/x-safetensors",
             "embedding_source": "direct",
-            "embedding_dim": 192,
+            "embedding_dim": SPEAKER_EMBEDDING_DIM,
         }
         speech_server.uploaded_speakers = {"bad_emb_voice": existing.copy()}
 
-        with pytest.raises(ValueError, match="Ming speaker embedding must have 192 dims, got 191"):
+        with pytest.raises(
+            ValueError,
+            match=f"Ming speaker embedding must have {SPEAKER_EMBEDDING_DIM} dims, got {invalid_dim}",
+        ):
             asyncio.run(
                 speech_server.upload_voice_embedding(
-                    embedding_json=json.dumps([0.0] * 191),
+                    embedding_json=json.dumps([0.0] * invalid_dim),
                     consent="consent",
                     name="bad_emb_voice",
                 )
@@ -997,6 +1009,57 @@ class TestTTSMethods:
 
         assert speech_server.uploaded_speakers["bad_emb_voice"] == existing
 
+    def test_upload_ming_audio_voice_defers_speaker_extraction(self, speech_server, mocker: MockerFixture, tmp_path):
+        """Ming audio uploads stay model-agnostic and defer extraction to use."""
+        speech_server._tts_model_type = "ming_tts"
+        speech_server.uploaded_speakers_dir = tmp_path
+        speech_server.uploaded_speakers = {}
+        speech_server.supported_speakers = set()
+        speech_server._speaker_cache.clear()
+
+        left = np.full(32000, 0.5, dtype=np.float32)
+        right = np.full(32000, -0.25, dtype=np.float32)
+        samples = np.stack((left, right), axis=-1)
+        mocker.patch("soundfile.read", return_value=(samples, 16000))
+        saved: dict[str, object] = {}
+
+        def fake_save_file(tensors, path, metadata=None):
+            saved["tensors"] = tensors
+            saved["metadata"] = metadata
+            Path(path).touch()
+
+        mocker.patch("safetensors.torch.save_file", side_effect=fake_save_file)
+        audio_file = mocker.MagicMock()
+        audio_file.filename = "reference.wav"
+        audio_file.content_type = "audio/wav"
+        audio_file.file = io.BytesIO(b"fake audio")
+        audio_file.read = mocker.AsyncMock(return_value=b"fake audio")
+
+        asyncio.run(
+            speech_server.upload_voice(
+                audio_file,
+                consent="consent",
+                name="ming_audio_voice",
+                ref_text="Reference transcript.",
+            )
+        )
+
+        tensors = saved["tensors"]
+        metadata = saved["metadata"]
+        assert isinstance(tensors, dict)
+        assert isinstance(metadata, dict)
+        assert set(tensors) == {"audio"}
+        assert tensors["audio"].shape == (32000, 2)
+        assert metadata["embedding_source"] == "audio"
+        assert "embedding_dim" not in metadata
+        speaker_info = speech_server.uploaded_speakers["ming_audio_voice"]
+        cache_key = speech_server._speaker_cache.make_cache_key(
+            "ming_audio_voice",
+            model_type="ming_tts",
+            created_at=speaker_info["created_at"],
+        )
+        assert speech_server._speaker_cache.get(cache_key) is None
+
     def test_base_task_requires_ref_audio_or_speaker_embedding(self, speech_server):
         """Base task without ref_audio or speaker_embedding is rejected."""
         req = OpenAICreateSpeechRequest(input="Hello", task_type="Base")
@@ -1328,6 +1391,20 @@ class TestTTSMethods:
         # Verify speakers are normalized to lowercase
         assert server.supported_speakers == {"ryan", "vivian", "aiden"}
 
+    def test_load_supported_speakers_skips_non_tts_omni_model(
+        self,
+        speech_server,
+        mocker: MockerFixture,
+    ):
+        warning = mocker.patch.object(serving_speech_module.logger, "warning")
+        speech_server.engine_client.model_config = SimpleNamespace(
+            hf_config=SimpleNamespace(tts_config=SimpleNamespace())
+        )
+
+        assert speech_server._is_tts is False
+        assert speech_server._load_supported_speakers() == set()
+        warning.assert_not_called()
+
     def test_load_supported_languages_from_config(self, speech_server):
         """Languages/dialects from codec_language_id are loaded title-cased; 'Auto' is added."""
         speech_server._tts_model_type = "qwen3_tts"
@@ -1549,7 +1626,7 @@ class TestTTSMethods:
         req = OpenAICreateSpeechRequest.model_validate({"input": "Hello", "speaker": "UTESF", "task_type": "Base"})
         assert req.voice == "UTESF"
         mocker.patch("pathlib.Path.exists", return_value=True)
-        result = speech_server._validate_qwen_tts_request(req)
+        result = speech_server._validate_tts_request(req)
         assert result is None
 
     # ── uploaded voice with embedding ──
@@ -1591,10 +1668,10 @@ class TestTTSMethods:
                 "file_path": "/tmp/voice_samples/emb_voice.safetensors",
                 "mime_type": "application/x-safetensors",
                 "embedding_source": "direct",
-                "embedding_dim": 192,
+                "embedding_dim": SPEAKER_EMBEDDING_DIM,
             }
         }
-        fake_embedding = [0.1] * 192
+        fake_embedding = [0.1] * SPEAKER_EMBEDDING_DIM
         mock_get_emb = mocker.patch.object(
             speech_server, "_get_uploaded_speaker_embedding", return_value=fake_embedding
         )
@@ -1611,38 +1688,38 @@ class TestTTSMethods:
 
         mock_get_emb.assert_called_once_with("emb_voice")
         mock_get_audio.assert_not_called()
-        mock_prompt.assert_called_once_with(req, ref_audio_data=None)
+        mock_prompt.assert_called_once_with(
+            req,
+            ref_audio_data=None,
+            voice_name=None,
+            voice_created_at=0,
+        )
         prompt_request = mock_prompt.call_args.args[0]
         assert prompt_request.speaker_embedding == fake_embedding
-        assert len(prompt_request.speaker_embedding) == 192
+        assert len(prompt_request.speaker_embedding) == SPEAKER_EMBEDDING_DIM
         assert prepared.prompt["additional_information"]["speaker_count"] == 1
         assert prepared.model_type == "ming_tts"
 
-    def test_ming_adapter_uploaded_audio_path_preserves_ref_text(self, speech_server, mocker: MockerFixture):
-        """Ming uploaded audio voices still resolve audio and stored ref_text."""
+    def test_ming_adapter_uploaded_audio_forwards_worker_cache_metadata(self, speech_server, mocker: MockerFixture):
+        """Ming audio voices defer extraction and cache ownership to Stage-0."""
         speech_server.uploaded_speakers = {
             "audio_voice": {
                 "name": "audio_voice",
-                "file_path": "/tmp/voice_samples/audio_voice.wav",
+                "file_path": "/tmp/voice_samples/audio_voice.safetensors",
+                "created_at": 123,
                 "mime_type": "audio/wav",
+                "embedding_source": "audio",
                 "ref_text": "Reference transcript.",
             }
         }
         ref_audio_source = "data:audio/wav;base64,ZmFrZWF1ZGlv"
         ref_audio_data = ([0.0, 0.1], 16000)
-        fake_embedding = [0.2] * 192
-        mock_get_audio = mocker.patch.object(speech_server, "_get_uploaded_audio_data", return_value=ref_audio_source)
-        mock_get_emb = mocker.patch.object(speech_server, "_get_uploaded_speaker_embedding")
+        mocker.patch.object(speech_server, "_get_uploaded_audio_data", return_value=ref_audio_source)
         mocker.patch.object(
             speech_server,
             "_resolve_ref_audio",
             new=mocker.AsyncMock(return_value=ref_audio_data),
         )
-        mock_extract = mocker.patch.object(
-            speech_server,
-            "_extract_ming_speaker_embeddings_from_ref_audio",
-            return_value=[fake_embedding],
-        )
         mock_prompt = mocker.patch.object(
             speech_server,
             "_build_ming_dense_prompt",
@@ -1653,14 +1730,145 @@ class TestTTSMethods:
         req = OpenAICreateSpeechRequest(input="Hello", voice="audio_voice")
         prepared = asyncio.run(adapter.build(req, [], False))
 
-        mock_get_audio.assert_called_once_with("audio_voice")
-        mock_get_emb.assert_not_called()
-        mock_extract.assert_called_once_with([ref_audio_data])
-        mock_prompt.assert_called_once_with(req, ref_audio_data=ref_audio_data)
+        mock_prompt.assert_called_once_with(
+            req,
+            ref_audio_data=ref_audio_data,
+            voice_name="audio_voice",
+            voice_created_at=123,
+        )
         assert req.ref_text == "Reference transcript."
-        assert req.speaker_embedding == fake_embedding
+        assert req.speaker_embedding is None
         assert prepared.model_type == "ming_tts"
 
+    def test_build_ming_prompt_forwards_audio_segments_and_worker_cache_metadata(self, speech_server):
+        class FakeTokenizer:
+            unk_token_id = -1
+
+            def encode(self, text):
+                return [777] if text == "<|vision_pad|>" else [1]
+
+            def convert_tokens_to_ids(self, token):
+                return 888 if token == "<audioPatch>" else self.unk_token_id
+
+        speech_server._tts_tokenizer = FakeTokenizer()
+        request = OpenAICreateSpeechRequest(
+            input="Hello",
+            ref_text="Two reference speakers.",
+        )
+        ref_audio_data = [
+            ([0.1, 0.2, 0.3], 16000),
+            ([0.4, 0.5], 24000),
+        ]
+
+        prompt = speech_server._build_ming_dense_prompt(
+            request,
+            ref_audio_data=ref_audio_data,
+            voice_name="uploaded_voice",
+            voice_created_at=123,
+        )
+
+        info = prompt["additional_information"]
+        assert KEY_SPEAKER_EMBEDDING not in info
+        torch.testing.assert_close(
+            info[KEY_SPEAKER_WAVEFORM],
+            torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5]], dtype=torch.float32),
+        )
+        assert info[KEY_SPEAKER_WAVEFORM_LENGTHS].tolist() == [3, 2]
+        assert info[KEY_SPEAKER_SAMPLE_RATES].tolist() == [16000, 24000]
+        assert info["prompt_waveform"].shape[-1] > info[KEY_SPEAKER_WAVEFORM].shape[-1]
+        assert info["voice_name"] == "uploaded_voice"
+        assert info["voice_created_at"] == 123
+        assert prompt["prompt_token_ids"].count(777) == 2
+
+    def test_build_ming_prompt_forwards_speaker_waveform_without_ref_text(self, speech_server):
+        class FakeTokenizer:
+            unk_token_id = -1
+
+            def encode(self, text):
+                return [1]
+
+            def convert_tokens_to_ids(self, token):
+                return 888 if token == "<audioPatch>" else self.unk_token_id
+
+        speech_server._tts_tokenizer = FakeTokenizer()
+        request = OpenAICreateSpeechRequest(input="Hello")
+
+        prompt = speech_server._build_ming_dense_prompt(
+            request,
+            ref_audio_data=([0.1, 0.2, 0.3], 16000),
+        )
+
+        info = prompt["additional_information"]
+        assert info[KEY_SPEAKER_WAVEFORM].shape == (1, 3)
+        assert info[KEY_SPEAKER_WAVEFORM_LENGTHS].tolist() == [3]
+        assert info[KEY_SPEAKER_SAMPLE_RATES].tolist() == [16000]
+        assert "prompt_waveform" not in info
+        assert KEY_SPEAKER_EMBEDDING not in info
+
+    def test_ming_adapter_legacy_audio_only_voice_forwards_audio_to_worker(
+        self,
+        speech_server,
+        mocker: MockerFixture,
+        tmp_path,
+    ):
+        """Legacy audio-only profiles extract once instead of failing after upgrade."""
+        from safetensors.torch import save_file
+
+        speech_server._tts_model_type = "ming_tts"
+        speech_server.uploaded_speakers_dir = tmp_path
+        speech_server._speaker_cache.clear()
+        file_path = tmp_path / "legacy_audio_voice.safetensors"
+        save_file({"audio": torch.zeros(32000, dtype=torch.float32)}, str(file_path))
+        speech_server.uploaded_speakers = {
+            "legacy_audio_voice": {
+                "name": "legacy_audio_voice",
+                "file_path": str(file_path),
+                "created_at": 456,
+                "mime_type": "audio/wav",
+                "embedding_source": "audio",
+                "ref_text": "Reference transcript.",
+            }
+        }
+        ref_audio_source = "data:audio/wav;base64,ZmFrZWF1ZGlv"
+        ref_audio_data = ([0.0, 0.1], 16000)
+        mocker.patch.object(speech_server, "_get_uploaded_audio_data", return_value=ref_audio_source)
+        mocker.patch.object(
+            speech_server,
+            "_resolve_ref_audio",
+            new=mocker.AsyncMock(return_value=ref_audio_data),
+        )
+        mock_prompt = mocker.patch.object(
+            speech_server,
+            "_build_ming_dense_prompt",
+            return_value={"additional_information": {"speaker_count": 1}},
+        )
+
+        adapter = MingTTSAdapter(SpeechServingContext(server=speech_server))
+        first_req = OpenAICreateSpeechRequest(input="Hello", voice="legacy_audio_voice")
+        first_prepared = asyncio.run(adapter.build(first_req, [], False))
+        second_req = OpenAICreateSpeechRequest(input="Hello again", voice="legacy_audio_voice")
+        second_prepared = asyncio.run(adapter.build(second_req, [], False))
+
+        assert first_req.speaker_embedding is None
+        assert second_req.speaker_embedding is None
+        assert first_req.ref_text == "Reference transcript."
+        assert second_req.ref_text == "Reference transcript."
+        assert first_prepared.model_type == "ming_tts"
+        assert second_prepared.model_type == "ming_tts"
+        assert mock_prompt.call_count == 2
+        mock_prompt.assert_any_call(
+            first_req,
+            ref_audio_data=ref_audio_data,
+            voice_name="legacy_audio_voice",
+            voice_created_at=456,
+        )
+        mock_prompt.assert_any_call(
+            second_req,
+            ref_audio_data=ref_audio_data,
+            voice_name="legacy_audio_voice",
+            voice_created_at=456,
+        )
+
     # ── regression: full flow from issue #1603 ──
 
     def test_regression_1603_speaker_key_with_uploaded_audio_voice(self, speech_server, mocker: MockerFixture):
@@ -1684,7 +1892,7 @@ class TestTTSMethods:
 
         # Validation should pass (file exists)
         mocker.patch("pathlib.Path.exists", return_value=True)
-        err = speech_server._validate_qwen_tts_request(req)
+        err = speech_server._validate_tts_request(req)
         assert err is None, f"Validation failed: {err}"
 
         # Build params should auto-set ref_audio from stored file
@@ -1722,7 +1930,7 @@ class TestTTSMethods:
 
         # Validation should pass
         mocker.patch("pathlib.Path.exists", return_value=True)
-        err = speech_server._validate_qwen_tts_request(req)
+        err = speech_server._validate_tts_request(req)
         assert err is None, f"Validation failed: {err}"
 
         # Build params should use embedding, NOT audio
@@ -1866,6 +2074,35 @@ class TestTTSMethods:
         assert error is not None
         assert "max 10 characters" in error
 
+    def test_batch_voice_not_treated_as_inline_ref_audio(
+        self,
+        speech_server,
+        mocker: MockerFixture,
+    ):
+        speech_server._check_model = mocker.AsyncMock(return_value=None)
+        speech_server._batch_max_items = 32
+
+        def validate_and_resolve_uploaded_voice(request):
+            assert request.voice == "alice"
+            assert request.ref_audio is None
+
+            request.ref_audio = "data:audio/wav;base64,dGVzdA=="
+            request.ref_text = "reference text"
+            return None
+
+        speech_server._validate_tts_request = mocker.Mock(side_effect=validate_and_resolve_uploaded_voice)
+        speech_server._generate_audio_bytes = mocker.AsyncMock(return_value=("YWJj", "audio/wav"))
+
+        batch = BatchSpeechRequest(voice="alice", items=[SpeechBatchItem(input="hello")])
+
+        response = asyncio.run(speech_server.create_speech_batch(batch))
+        call = speech_server._generate_audio_bytes.await_args
+        request = call.args[0]
+
+        assert response.results[0].status == "success"
+        assert request.ref_audio is not None
+        assert call.kwargs["has_inline_ref_audio"] is False
+
 
 class TestFileValidationFunctions:
     """Unit tests for file validation helper functions."""
@@ -3221,25 +3458,25 @@ class TestCosyVoice3Serving:
 
     def test_validate_cosyvoice3_empty_input(self, cosyvoice3_server):
         request = OpenAICreateSpeechRequest(input="", ref_audio="data:audio/wav;base64,abc", ref_text="hello")
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is not None
         assert "empty" in error.lower()
 
     def test_validate_cosyvoice3_missing_ref_audio(self, cosyvoice3_server):
         request = OpenAICreateSpeechRequest(input="Hello", ref_text="hello")
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is not None
         assert "ref_audio" in error.lower()
 
     def test_validate_cosyvoice3_missing_ref_text(self, cosyvoice3_server):
         request = OpenAICreateSpeechRequest(input="Hello", ref_audio="data:audio/wav;base64,abc")
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is not None
         assert "ref_text" in error.lower()
 
     def test_validate_cosyvoice3_invalid_ref_audio_format(self, cosyvoice3_server):
         request = OpenAICreateSpeechRequest(input="Hello", ref_audio="/local/path.wav", ref_text="hello")
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is not None
         assert "url" in error.lower() or "format" in error.lower()
 
@@ -3249,7 +3486,7 @@ class TestCosyVoice3Serving:
             ref_audio="data:audio/wav;base64,abc123",
             ref_text="Reference transcript",
         )
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is None
 
     def test_validate_cosyvoice3_max_new_tokens_range(self, cosyvoice3_server):
@@ -3259,7 +3496,7 @@ class TestCosyVoice3Serving:
             ref_text="hello",
             max_new_tokens=0,
         )
-        error = cosyvoice3_server._validate_cosyvoice3_request(request)
+        error = cosyvoice3_server._validate_tts_request(request)
         assert error is not None
         assert "max_new_tokens" in error
 
@@ -3325,13 +3562,13 @@ def glm_tts_server(mocker: MockerFixture):
 class TestGLMTTSServing:
     def test_validate_glm_tts_requires_ref_audio(self, glm_tts_server):
         request = OpenAICreateSpeechRequest(input="Hello", ref_text="Reference transcript")
-        error = glm_tts_server._validate_glm_tts_request(request)
+        error = glm_tts_server._validate_tts_request(request)
         assert error is not None
         assert "ref_audio" in error
 
     def test_validate_glm_tts_requires_ref_text(self, glm_tts_server):
         request = OpenAICreateSpeechRequest(input="Hello", ref_audio="data:audio/wav;base64,abc")
-        error = glm_tts_server._validate_glm_tts_request(request)
+        error = glm_tts_server._validate_tts_request(request)
         assert error is not None
         assert "ref_text" in error
 
@@ -3438,7 +3675,7 @@ class TestTTSAsyncOffloading:
 
     def test_prepare_speech_generation_awaits_qwen3_tts_async(self, qwen3_tts_server, mocker: MockerFixture):
         """Qwen3 TTS path should call _estimate_prompt_len_async."""
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3455,7 +3692,7 @@ class TestTTSAsyncOffloading:
         qwen3_tts_server.engine_client.default_sampling_params_list = [
             SimpleNamespace(max_tokens=2048, seed=42, extra_args=None)
         ]
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3505,7 +3742,7 @@ class TestTTSAsyncOffloading:
 
     def test_prepare_speech_generation_treats_sse_as_streaming(self, qwen3_tts_server, mocker: MockerFixture):
         """stream_format=sse should request delta-style multimodal outputs."""
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3522,7 +3759,7 @@ class TestTTSAsyncOffloading:
 
     def test_prepare_speech_generation_treats_stream_true_as_streaming(self, qwen3_tts_server, mocker: MockerFixture):
         """stream=True should request delta-style multimodal outputs for SSE streaming."""
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3539,7 +3776,7 @@ class TestTTSAsyncOffloading:
 
     def test_prepare_speech_generation_treats_audio_as_streaming(self, qwen3_tts_server, mocker: MockerFixture):
         """stream_format=audio should request delta-style multimodal outputs."""
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3559,7 +3796,7 @@ class TestTTSAsyncOffloading:
     ):
         """Full-payload TTS streaming should not request delta multimodal outputs."""
         qwen3_tts_server.engine_client.model_config.async_chunk = False
-        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._adapter.validate = mocker.MagicMock(return_value=None)
         qwen3_tts_server._build_tts_params = mocker.MagicMock(
             return_value={"text": ["hello"], "task_type": ["CustomVoice"], "speaker": ["Vivian"]}
         )
@@ -3653,7 +3890,7 @@ class TestTTSAsyncOffloading:
             24000,
             artifact_key,
         )
-        qwen3_tts_server._ref_audio_model_artifact_ready.add(artifact_key)
+        qwen3_tts_server._ref_audio_model_artifact_ready.add((artifact_key, False))
         qwen3_tts_server._codec_frame_rate = 25.0
         qwen3_tts_server._tts_tokenizer = lambda _text, padding=False: {"input_ids": list(range(10))}
         qwen3_tts_server.engine_client.model_config.hf_config.talker_config = SimpleNamespace(
@@ -3683,10 +3920,10 @@ class TestTTSAsyncOffloading:
         qwen3_tts_server._ref_audio_resolve_cache_max_bytes = 1_000_000
 
         qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
-        qwen3_tts_server._ref_audio_model_artifact_ready.add("artifact-a")
+        qwen3_tts_server._ref_audio_model_artifact_ready.add(("artifact-a", False))
         qwen3_tts_server._put_resolved_ref_audio("ref-b", [0.0] * 8, 24000, "artifact-b")
 
-        assert "artifact-a" not in qwen3_tts_server._ref_audio_model_artifact_ready
+        assert ("artifact-a", False) not in qwen3_tts_server._ref_audio_model_artifact_ready
         assert "artifact-b" in {entry[3] for entry in qwen3_tts_server._ref_audio_resolve_cache.values()}
 
     @pytest.mark.asyncio
@@ -3695,13 +3932,13 @@ class TestTTSAsyncOffloading:
             raise ValueError("boom")
             yield  # pragma: no cover
 
-        qwen3_tts_server._request_ref_audio_artifact_keys["req-fail"] = "artifact-fail"
+        qwen3_tts_server._request_ref_audio_artifact_keys["req-fail"] = ("artifact-fail", False)
 
         with pytest.raises(ValueError, match="boom"):
             await anext(qwen3_tts_server._generate_audio_chunks(failing_generator(), "req-fail"))
 
         assert "req-fail" not in qwen3_tts_server._request_ref_audio_artifact_keys
-        assert "artifact-fail" not in qwen3_tts_server._ref_audio_model_artifact_ready
+        assert ("artifact-fail", False) not in qwen3_tts_server._ref_audio_model_artifact_ready
 
     @pytest.mark.asyncio
     async def test_generate_audio_chunks_discards_ref_audio_artifact_warmup_on_close(self, qwen3_tts_server):
@@ -3714,22 +3951,48 @@ class TestTTSAsyncOffloading:
             )
             await asyncio.sleep(0)
 
-        qwen3_tts_server._request_ref_audio_artifact_keys["req-close"] = "artifact-close"
+        qwen3_tts_server._request_ref_audio_artifact_keys["req-close"] = ("artifact-close", False)
 
         stream = qwen3_tts_server._generate_audio_chunks(pcm_generator(), "req-close")
         assert await anext(stream)
         await stream.aclose()
 
         assert "req-close" not in qwen3_tts_server._request_ref_audio_artifact_keys
-        assert "artifact-close" not in qwen3_tts_server._ref_audio_model_artifact_ready
+        assert ("artifact-close", False) not in qwen3_tts_server._ref_audio_model_artifact_ready
 
     def test_qwen3_ref_audio_artifact_ready_requires_live_resolve_cache_entry(self, qwen3_tts_server):
-        qwen3_tts_server._request_ref_audio_artifact_keys["req-evicted"] = "artifact-evicted"
+        qwen3_tts_server._request_ref_audio_artifact_keys["req-evicted"] = ("artifact-evicted", False)
 
         qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-evicted")
 
         assert "req-evicted" not in qwen3_tts_server._request_ref_audio_artifact_keys
-        assert "artifact-evicted" not in qwen3_tts_server._ref_audio_model_artifact_ready
+        assert ("artifact-evicted", False) not in qwen3_tts_server._ref_audio_model_artifact_ready
+
+    def test_qwen3_xvector_ready_artifact_does_not_enable_icl_artifact_only(self, qwen3_tts_server):
+        # An x-vector-only artifact (speaker embedding, no ref_code) must not enable
+        # the artifact-only path for a later ICL request with the same ref_audio (#5049).
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._track_ref_audio_artifact_warmup("req-xvec", "artifact-a", x_vector_only=True)
+        qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-xvec")
+
+        icl_params = {"task_type": ["Base"], "x_vector_only_mode": [False]}
+        assert qwen3_tts_server._qwen3_tts_can_use_ref_audio_artifact_only(icl_params, "artifact-a") is False
+
+    def test_qwen3_xvector_ready_artifact_still_reusable_by_xvector_request(self, qwen3_tts_server):
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._track_ref_audio_artifact_warmup("req-xvec", "artifact-a", x_vector_only=True)
+        qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-xvec")
+
+        xvec_params = {"task_type": ["Base"], "x_vector_only_mode": [True]}
+        assert qwen3_tts_server._qwen3_tts_can_use_ref_audio_artifact_only(xvec_params, "artifact-a") is True
+
+    def test_qwen3_icl_ready_artifact_enables_icl_artifact_only(self, qwen3_tts_server):
+        qwen3_tts_server._put_resolved_ref_audio("ref-a", [0.0] * 8, 24000, "artifact-a")
+        qwen3_tts_server._track_ref_audio_artifact_warmup("req-icl", "artifact-a", x_vector_only=False)
+        qwen3_tts_server._mark_ref_audio_artifact_ready_for_request("req-icl")
+
+        icl_params = {"task_type": ["Base"], "x_vector_only_mode": [False]}
+        assert qwen3_tts_server._qwen3_tts_can_use_ref_audio_artifact_only(icl_params, "artifact-a") is True
 
     def test_shutdown_is_idempotent(self, mocker: MockerFixture):
         """Calling shutdown() twice should not raise."""
diff --git a/tests/entrypoints/openai_api/test_serving_speech_batch.py b/tests/entrypoints/openai_api/test_serving_speech_batch.py
index ce0a5e21f..686dba7d0 100644
--- a/tests/entrypoints/openai_api/test_serving_speech_batch.py
+++ b/tests/entrypoints/openai_api/test_serving_speech_batch.py
@@ -88,7 +88,7 @@ class TestSpeechBatchE2E:
 
     @pytest.mark.advanced_model
     @pytest.mark.tts
-    @hardware_test(res={"cuda": "H100"}, num_cards=1)
+    @hardware_test(res={"cuda": "L4"}, num_cards=1)
     @pytest.mark.parametrize("omni_server", default_server_params, indirect=True)
     def test_batch_basic_two_items(self, omni_server) -> None:
         """Batch with two items returns two successful base64-encoded results."""
diff --git a/tests/entrypoints/openai_api/test_serving_speech_stream.py b/tests/entrypoints/openai_api/test_serving_speech_stream.py
index 881717363..44e84b346 100644
--- a/tests/entrypoints/openai_api/test_serving_speech_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_speech_stream.py
@@ -72,13 +72,162 @@ class TestStreamingSpeechWebSocket:
                 assert audio.startswith(b"RIFF")
 
                 done = ws.receive_json()
-                assert done == {"type": "audio.done", "sentence_index": 0, "total_bytes": len(audio), "error": False}
+                assert done == {
+                    "type": "audio.done",
+                    "utterance_index": 0,
+                    "sentence_index": 0,
+                    "total_bytes": len(audio),
+                    "error": False,
+                }
 
                 session_done = ws.receive_json()
-                assert session_done == {"type": "session.done", "total_sentences": 1}
+                assert session_done == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
         assert speech_service._generate_audio_bytes.await_count == 1
 
+    def test_input_done_flushes_and_keeps_connection_open(self, mocker: MockerFixture):
+        app, speech_service = _build_test_app(mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                ws.send_json({"type": "session.config", "voice": "Vivian"})
+
+                # The same connection serves several utterances; the config sent
+                # once at the top keeps applying and utterance_index rises.
+                for expected_index, text in enumerate(("First utterance. ", "Second utterance. ")):
+                    ws.send_json({"type": "input.text", "text": text})
+                    ws.send_json({"type": "input.done"})
+
+                    start = ws.receive_json()
+                    assert start["type"] == "audio.start"
+                    assert start["utterance_index"] == expected_index
+                    assert start["sentence_text"] == text.strip()
+                    assert ws.receive_bytes().startswith(b"RIFF")
+                    assert ws.receive_json()["type"] == "audio.done"
+                    assert ws.receive_json() == {
+                        "type": "session.done",
+                        "utterance_index": expected_index,
+                        "total_sentences": 1,
+                    }
+
+        assert speech_service._generate_audio_bytes.await_count == 2
+        assert [call.args[0].voice for call in speech_service._generate_audio_bytes.await_args_list] == [
+            "Vivian",
+            "Vivian",
+        ]
+
+    def test_sentence_index_stays_within_the_flushed_utterance(self, mocker: MockerFixture):
+        # sentence_index counts within one flush and utterance_index counts the
+        # flushes, so a late utterance never reports "sentence 2 of 1".
+        app, _ = _build_test_app(mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                ws.send_json({"type": "session.config", "voice": "Vivian"})
+
+                for expected_index in range(3):
+                    ws.send_json({"type": "input.text", "text": "Hello world. "})
+                    ws.send_json({"type": "input.done"})
+
+                    start = ws.receive_json()
+                    assert start["utterance_index"] == expected_index
+                    assert start["sentence_index"] == 0
+                    ws.receive_bytes()
+
+                    done = ws.receive_json()
+                    assert done["utterance_index"] == expected_index
+                    assert done["sentence_index"] == 0
+
+                    session_done = ws.receive_json()
+                    assert session_done["utterance_index"] == expected_index
+                    assert session_done["total_sentences"] == 1
+                    assert start["sentence_index"] < session_done["total_sentences"]
+
+    def test_session_config_between_utterances_replaces_config(self, mocker: MockerFixture):
+        app, speech_service = _build_test_app(mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                for expected_index, voice in enumerate(("Vivian", "Serena")):
+                    ws.send_json({"type": "session.config", "voice": voice})
+                    ws.send_json({"type": "input.text", "text": "Hello world. "})
+                    ws.send_json({"type": "input.done"})
+
+                    assert ws.receive_json()["type"] == "audio.start"
+                    ws.receive_bytes()
+                    assert ws.receive_json()["type"] == "audio.done"
+                    assert ws.receive_json() == {
+                        "type": "session.done",
+                        "utterance_index": expected_index,
+                        "total_sentences": 1,
+                    }
+
+        assert [call.args[0].voice for call in speech_service._generate_audio_bytes.await_args_list] == [
+            "Vivian",
+            "Serena",
+        ]
+
+    def test_session_config_rejected_while_input_is_buffered(self, mocker: MockerFixture):
+        app, speech_service = _build_test_app(mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                ws.send_json({"type": "session.config", "voice": "Vivian"})
+                ws.send_json({"type": "input.text", "text": "Hello world. "})
+                ws.send_json({"type": "session.config", "voice": "Serena"})
+
+                error = ws.receive_json()
+                assert error["type"] == "error"
+                assert "while input is buffered" in error["message"]
+
+                # The buffered text survives the rejected reconfiguration.
+                ws.send_json({"type": "input.done"})
+                assert ws.receive_json()["sentence_text"] == "Hello world."
+                ws.receive_bytes()
+                assert ws.receive_json()["type"] == "audio.done"
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
+
+        assert speech_service._generate_audio_bytes.await_args_list[0].args[0].voice == "Vivian"
+
+    def test_session_close_ends_connection(self, mocker: MockerFixture):
+        app, _ = _build_test_app(mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                ws.send_json({"type": "session.config", "voice": "Vivian"})
+                ws.send_json({"type": "input.text", "text": "Hello world. "})
+                ws.send_json({"type": "input.done"})
+
+                assert ws.receive_json()["type"] == "audio.start"
+                ws.receive_bytes()
+                assert ws.receive_json()["type"] == "audio.done"
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
+
+                ws.send_json({"type": "session.close"})
+                with pytest.raises(WebSocketDisconnect):
+                    ws.receive_json()
+
+    def test_idle_timeout_closes_reused_connection(self, mocker: MockerFixture):
+        app, _ = _build_test_app(idle_timeout=0.05, mocker=mocker)
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/audio/speech/stream") as ws:
+                ws.send_json({"type": "session.config", "voice": "Vivian"})
+                ws.send_json({"type": "input.text", "text": "Hello world. "})
+                ws.send_json({"type": "input.done"})
+
+                assert ws.receive_json()["type"] == "audio.start"
+                ws.receive_bytes()
+                assert ws.receive_json()["type"] == "audio.done"
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
+
+                # Holding a connection open is not free: an idle client still
+                # gets timed out after the flush.
+                assert ws.receive_json() == {
+                    "type": "error",
+                    "message": "Idle timeout: no message received",
+                }
+
     def test_streaming_multiple_binary_frames(self, mocker: MockerFixture):
         captured_requests = []
 
@@ -125,9 +274,15 @@ class TestStreamingSpeechWebSocket:
                 assert ws.receive_bytes() == b"\x06"
 
                 done = ws.receive_json()
-                assert done == {"type": "audio.done", "sentence_index": 0, "total_bytes": 6, "error": False}
+                assert done == {
+                    "type": "audio.done",
+                    "utterance_index": 0,
+                    "sentence_index": 0,
+                    "total_bytes": 6,
+                    "error": False,
+                }
 
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
         assert len(captured_requests) == 1
         assert captured_requests[0].stream is True
@@ -210,6 +365,8 @@ class TestStreamingSpeechWebSocket:
                 # is fully aligned.
                 chunk = ws.receive_json()
                 assert chunk["type"] == "audio.chunk"
+                assert chunk["utterance_index"] == 0
+                assert chunk["sentence_index"] == 0
                 assert chunk["chunk_id"] == 0
                 assert chunk["chunk_start_ms"] == 0
                 assert chunk["chunk_end_ms"] == 500
@@ -240,7 +397,13 @@ class TestStreamingSpeechWebSocket:
                 ]
 
                 done = ws.receive_json()
-                assert done == {"type": "audio.done", "sentence_index": 0, "total_bytes": 2000, "error": False}
+                assert done == {
+                    "type": "audio.done",
+                    "utterance_index": 0,
+                    "sentence_index": 0,
+                    "total_bytes": 2000,
+                    "error": False,
+                }
 
         assert captured_requests[0].word_timestamps is True
         assert mock_align.await_count == 1
@@ -309,11 +472,12 @@ class TestStreamingSpeechWebSocket:
                 assert ws.receive_bytes()
                 assert ws.receive_json() == {
                     "type": "audio.done",
+                    "utterance_index": 0,
                     "sentence_index": 0,
                     "total_bytes": 36,
                     "error": False,
                 }
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
     def test_invalid_streaming_config(self, mocker: MockerFixture):
         app, _ = _build_test_app(mocker=mocker)
@@ -341,7 +505,7 @@ class TestStreamingSpeechWebSocket:
                 ws.send_json({"type": "input.text", "text": ""})
                 ws.send_json({"type": "input.done"})
 
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 0}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 0}
 
         assert speech_service._generate_audio_bytes.await_count == 0
 
@@ -361,11 +525,12 @@ class TestStreamingSpeechWebSocket:
                 ws.receive_bytes()
                 assert ws.receive_json() == {
                     "type": "audio.done",
+                    "utterance_index": 0,
                     "sentence_index": 0,
                     "total_bytes": 36,
                     "error": False,
                 }
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
     def test_unknown_message_type_keeps_session_open(self, mocker: MockerFixture):
         app, _ = _build_test_app(mocker=mocker)
@@ -384,12 +549,13 @@ class TestStreamingSpeechWebSocket:
                 ws.receive_bytes()
                 assert ws.receive_json() == {
                     "type": "audio.done",
+                    "utterance_index": 0,
                     "sentence_index": 0,
                     "total_bytes": 36,
                     "error": False,
                 }
 
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
     def test_config_timeout_closes_session(self, mocker: MockerFixture):
         app, _ = _build_test_app(config_timeout=0.01, mocker=mocker)
@@ -416,10 +582,19 @@ class TestStreamingSpeechWebSocket:
                 ws.send_json({"type": "input.done"})
 
                 assert ws.receive_json()["type"] == "audio.start"
-                assert ws.receive_json() == {"type": "error", "message": "Generation failed for sentence 0: boom"}
-                assert ws.receive_json() == {"type": "audio.done", "sentence_index": 0, "total_bytes": 0, "error": True}
+                assert ws.receive_json() == {
+                    "type": "error",
+                    "message": "Generation failed for utterance 0, sentence 0: boom",
+                }
+                assert ws.receive_json() == {
+                    "type": "audio.done",
+                    "utterance_index": 0,
+                    "sentence_index": 0,
+                    "total_bytes": 0,
+                    "error": True,
+                }
 
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
     def test_streaming_generation_error_marks_audio_done(self, mocker: MockerFixture):
         speech_service = mocker.MagicMock(spec=OmniOpenAIServingSpeech)
@@ -453,16 +628,17 @@ class TestStreamingSpeechWebSocket:
                 assert ws.receive_bytes() == b"\x01\x02"
                 assert ws.receive_json() == {
                     "type": "error",
-                    "message": "Generation failed for sentence 0: stream boom",
+                    "message": "Generation failed for utterance 0, sentence 0: stream boom",
                 }
                 assert ws.receive_json() == {
                     "type": "audio.done",
+                    "utterance_index": 0,
                     "sentence_index": 0,
                     "total_bytes": 2,
                     "error": True,
                 }
 
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 1}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 1}
 
     def test_invalid_input_text_type_returns_validation_error(self, mocker: MockerFixture):
         app, speech_service = _build_test_app(mocker=mocker)
@@ -478,7 +654,7 @@ class TestStreamingSpeechWebSocket:
                 }
 
                 ws.send_json({"type": "input.done"})
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 0}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 0}
 
         assert speech_service._generate_audio_bytes.await_count == 0
 
@@ -497,7 +673,7 @@ class TestStreamingSpeechWebSocket:
                 }
 
                 ws.send_json({"type": "input.done"})
-                assert ws.receive_json() == {"type": "session.done", "total_sentences": 0}
+                assert ws.receive_json() == {"type": "session.done", "utterance_index": 0, "total_sentences": 0}
 
         assert speech_service._generate_audio_bytes.await_count == 0
 
@@ -550,7 +726,15 @@ class TestStreamingSpeechWebSocket:
         config.word_timestamps = False
 
         with pytest.raises(WebSocketDisconnect):
-            asyncio.run(handler._generate_and_send(websocket, config, "Hello world.", 0))
+            asyncio.run(
+                handler._generate_and_send(
+                    websocket,
+                    config,
+                    "Hello world.",
+                    utterance_index=0,
+                    sentence_index=0,
+                )
+            )
 
         speech_service.engine_client.abort.assert_awaited_once_with("req-abort")
         assert websocket.send_json.await_count == 2
diff --git a/tests/entrypoints/openai_api/test_serving_video_output_stream.py b/tests/entrypoints/openai_api/test_serving_video_output_stream.py
index 72d293853..ec1727fe8 100644
--- a/tests/entrypoints/openai_api/test_serving_video_output_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_video_output_stream.py
@@ -16,6 +16,7 @@ from fastapi import FastAPI, WebSocket
 from pytest_mock import MockerFixture
 from starlette.testclient import TestClient
 
+from tests.helpers.media import generate_synthetic_image
 from vllm_omni.entrypoints.openai.serving_video_output_stream import OmniStreamingVideoOutputHandler
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
@@ -27,6 +28,12 @@ def _fake_video_frames(num_frames: int = 2) -> list[np.ndarray]:
     return [np.full((4, 4, 3), fill_value=i, dtype=np.uint8) for i in range(num_frames)]
 
 
+def _receive_video_chunk(ws) -> tuple[dict, bytes]:
+    metadata = ws.receive_json()
+    assert metadata["type"] == "video.chunk_metadata"
+    return metadata, ws.receive_bytes()
+
+
 def _build_test_app(
     *,
     mocker: MockerFixture,
@@ -37,6 +44,7 @@ def _build_test_app(
 ) -> tuple[FastAPI, OmniStreamingVideoOutputHandler, MagicMock]:
     engine_client = mocker.MagicMock()
     engine_client.abort = mocker.AsyncMock()
+    engine_client.submit_interaction_async = mocker.AsyncMock()
     engine_client.default_sampling_params_list = [OmniDiffusionSamplingParams()]
     engine_client.stage_configs = [SimpleNamespace(stage_type="diffusion")]
     engine_client.generate = mock_generate
@@ -126,8 +134,13 @@ class TestStreamingVideoOutputWebSocket:
                 assert "format" not in start["config"]
                 assert "request_id" in start
 
-                assert ws.receive_bytes() == b"mp4-chunk-0"
-                assert ws.receive_bytes() == b"mp4-chunk-1"
+                metadata, chunk = _receive_video_chunk(ws)
+                assert metadata["transport_chunk_index"] == 0
+                assert metadata["kind"] == "media"
+                assert chunk == b"mp4-chunk-0"
+                metadata, chunk = _receive_video_chunk(ws)
+                assert metadata["transport_chunk_index"] == 1
+                assert chunk == b"mp4-chunk-1"
 
                 done = ws.receive_json()
                 assert done["type"] == "session.done"
@@ -138,6 +151,48 @@ class TestStreamingVideoOutputWebSocket:
         engine_client.streaming_encoder_factory.assert_called_once()
         assert engine_client.streaming_encoder_factory.call_args.kwargs["output_format"] == "m4s"
 
+    def test_streaming_session_accepts_initial_image_reference(self, mocker: MockerFixture):
+        """session.start forwards image_reference as prompt multi_modal_data.image."""
+        captured_prompts: list[dict[str, object]] = []
+
+        async def mock_generate(*_args, **kwargs):
+            captured_prompts.append(kwargs["prompt"])
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", True)],
+            mock_generate=mock_generate,
+        )
+
+        synth_image = generate_synthetic_image(4, 4)
+        image_url = f"data:image/jpeg;base64,{synth_image['base64']}"
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json(
+                    {
+                        "type": "session.start",
+                        "prompt": "animate this image",
+                        "width": 4,
+                        "height": 4,
+                        "image_reference": {"image_url": image_url},
+                    }
+                )
+                assert ws.receive_json()["type"] == "video.start"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+                assert ws.receive_json()["type"] == "session.done"
+
+        prompt = captured_prompts[0]
+        image = prompt["multi_modal_data"]["image"]  # type: ignore[index]
+        assert image.size == (4, 4)
+        engine_client.abort.assert_not_called()
+
     def test_streaming_session_rejects_unknown_format(self, mocker: MockerFixture):
         async def mock_generate(*_args, **_kwargs):
             if False:
@@ -158,6 +213,33 @@ class TestStreamingVideoOutputWebSocket:
 
         engine_client.abort.assert_not_called()
 
+    def test_first_message_must_be_session_start(self, mocker: MockerFixture):
+        """Control messages sent before session.start are rejected at the handshake.
+
+        This test can practically ensure ``session.interaction`` before ``session.start`` is rejected,
+        but the implementation is more generic to also guard against other control messages.
+        """
+
+        async def mock_generate(*_args, **_kwargs):
+            if False:
+                yield None
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[],
+            mock_generate=mock_generate,
+        )
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.interaction", "interaction": {"event": {"prompt": "too early"}}})
+                err = ws.receive_json()
+                assert err["type"] == "error"
+                assert err["message"] == "Expected session.start, got: session.interaction"
+
+        engine_client.abort.assert_not_called()
+        engine_client.submit_interaction_async.assert_not_called()
+
     def test_streaming_session_emits_final_encoder_delta_before_done(self, mocker: MockerFixture):
         """A non-empty encoder close delta is delivered as the final binary chunk."""
 
@@ -180,8 +262,13 @@ class TestStreamingVideoOutputWebSocket:
             with client.websocket_connect("/v1/realtime/video") as ws:
                 ws.send_json({"type": "session.start", "prompt": "A cat walking in the rain"})
                 assert ws.receive_json()["type"] == "video.start"
-                assert ws.receive_bytes() == b"mp4-chunk-0"
-                assert ws.receive_bytes() == b"mp4-trailer"
+                metadata, chunk = _receive_video_chunk(ws)
+                assert metadata["kind"] == "media"
+                assert chunk == b"mp4-chunk-0"
+                metadata, chunk = _receive_video_chunk(ws)
+                assert metadata["kind"] == "trailer"
+                assert metadata["generation_chunk_index"] is None
+                assert chunk == b"mp4-trailer"
 
                 done = ws.receive_json()
                 assert done["type"] == "session.done"
@@ -213,7 +300,7 @@ class TestStreamingVideoOutputWebSocket:
             with client.websocket_connect("/v1/realtime/video") as ws:
                 ws.send_json({"type": "session.start", "prompt": "hello"})
                 assert ws.receive_json()["type"] == "video.start"
-                assert ws.receive_bytes() == b"mp4-chunk-0"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
                 err = ws.receive_json()
                 assert err["type"] == "error"
                 assert error_message in err["message"]
@@ -259,6 +346,7 @@ def _build_handler_for_async_tests(
 ) -> tuple[OmniStreamingVideoOutputHandler, MagicMock, _MockVideoOutputWebSocket]:
     engine_client = mocker.MagicMock()
     engine_client.abort = mocker.AsyncMock()
+    engine_client.submit_interaction_async = mocker.AsyncMock()
     engine_client.default_sampling_params_list = [OmniDiffusionSamplingParams()]
     engine_client.stage_configs = [SimpleNamespace(stage_type="diffusion")]
     engine_client.generate = mock_generate
@@ -340,8 +428,8 @@ class TestStreamingVideoOutputStallTimeout:
             with client.websocket_connect("/v1/realtime/video") as ws:
                 ws.send_json({"type": "session.start", "prompt": "slow generation"})
                 assert ws.receive_json()["type"] == "video.start"
-                assert ws.receive_bytes() == b"mp4-chunk-0"
-                assert ws.receive_bytes() == b"mp4-chunk-1"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
                 done = ws.receive_json()
                 assert done["type"] == "session.done"
                 assert done["stopped"] is False
@@ -444,3 +532,374 @@ class TestStreamingVideoOutputStallTimeout:
         assert any(m.get("type") == "session.pong" for m in ws.sent_json)
         assert any(m.get("type") == "session.done" for m in ws.sent_json)
         engine_client.abort.assert_not_called()
+
+
+class TestStreamingVideoOutputPromptUpdate:
+    """session.interaction control messages during streaming."""
+
+    def test_prompt_update_accepted_during_streaming(self, mocker: MockerFixture):
+        """A valid interaction during generation is forwarded to the engine and acknowledged."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial scene"})
+                start = ws.receive_json()
+                assert start["type"] == "video.start"
+                request_id = start["request_id"]
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event_id": "ui-update-42",
+                            "event": {"prompt": "new scene"},
+                        },
+                    }
+                )
+                queued = ws.receive_json()
+                assert queued["type"] == "session.interaction.queued"
+                assert queued["request_id"] == request_id
+                assert queued["event_id"] == "ui-update-42"
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                done = ws.receive_json()
+                assert done["type"] == "session.done"
+                assert done["stopped"] is False
+
+        engine_client.submit_interaction_async.assert_awaited_once_with(
+            request_id,
+            interaction={"event_id": "ui-update-42", "event": {"prompt": "new scene"}},
+        )
+
+    def test_prompt_update_rejects_duplicate_event_id(self, mocker: MockerFixture):
+        """Any repeated event_id is rejected at the session API boundary."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        interaction = {
+            "type": "session.interaction",
+            "interaction": {
+                "event_id": "ui-update-42",
+                "event": {"prompt": "new scene"},
+            },
+        }
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial scene"})
+                request_id = ws.receive_json()["request_id"]
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(interaction)
+                queued = ws.receive_json()
+                assert queued["type"] == "session.interaction.queued"
+
+                ws.send_json(interaction)
+                err = ws.receive_json()
+                assert err["type"] == "error"
+                assert err["code"] == "event_id_conflict"
+                assert err["request_id"] == request_id
+                assert err["event_id"] == "ui-update-42"
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_awaited_once_with(
+            request_id,
+            interaction={"event_id": "ui-update-42", "event": {"prompt": "new scene"}},
+        )
+
+    def test_prompt_update_forwards_transition_chunks(self, mocker: MockerFixture):
+        """transition_chunks is passed through to the engine client."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial"})
+                request_id = ws.receive_json()["request_id"]
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event_id": "ui-update-42",
+                            "event": {"prompt": "fade to sunset"},
+                            "transition_chunks": 5,
+                        },
+                    }
+                )
+                assert ws.receive_json()["type"] == "session.interaction.queued"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_awaited_once_with(
+            request_id,
+            interaction={
+                "event_id": "ui-update-42",
+                "event": {"prompt": "fade to sunset"},
+                "transition_chunks": 5,
+            },
+        )
+
+    def test_prompt_update_rejects_empty_prompt(self, mocker: MockerFixture):
+        """An empty prompt is rejected before calling the engine."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial"})
+                assert ws.receive_json()["type"] == "video.start"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json({"type": "session.interaction", "interaction": {"event": {"prompt": "   "}}})
+                err = ws.receive_json()
+                assert err["type"] == "error"
+                assert "non-empty event.prompt" in err["message"]
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_not_called()
+
+    @pytest.mark.parametrize(
+        ("transition_chunks"),
+        ["not-an-int", 2.9, True, -1],
+    )
+    def test_prompt_update_rejects_invalid_transition_chunks(
+        self,
+        mocker: MockerFixture,
+        transition_chunks: object,
+    ):
+        """Non-integral or negative transition_chunks returns an error."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial"})
+                assert ws.receive_json()["type"] == "video.start"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event": {"prompt": "new scene"},
+                            "transition_chunks": transition_chunks,
+                        },
+                    }
+                )
+                err = ws.receive_json()
+                assert err["type"] == "error"
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_not_called()
+
+    def test_prompt_update_engine_failure_returns_error(self, mocker: MockerFixture):
+        """Engine failures during interaction are surfaced to the client."""
+
+        async def mock_generate(*_args, **_kwargs):
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=False,
+            )
+            await asyncio.sleep(0.3)
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        app, _handler, engine_client = _build_test_app(
+            mocker=mocker,
+            streaming_chunks=[(b"mp4-chunk-0", False), (b"mp4-chunk-1", True)],
+            mock_generate=mock_generate,
+        )
+        engine_client.submit_interaction_async.side_effect = RuntimeError("engine unavailable")
+
+        with TestClient(app) as client:
+            with client.websocket_connect("/v1/realtime/video") as ws:
+                ws.send_json({"type": "session.start", "prompt": "initial"})
+                assert ws.receive_json()["type"] == "video.start"
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-0"
+
+                ws.send_json(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event_id": "ui-update-42",
+                            "event": {"prompt": "new scene"},
+                        },
+                    }
+                )
+                err = ws.receive_json()
+                assert err["type"] == "error"
+                assert "Failed to apply interaction" in err["message"]
+                assert err["code"] == "interaction_failed"
+                assert err["event_id"] == "ui-update-42"
+
+                assert _receive_video_chunk(ws)[1] == b"mp4-chunk-1"
+                assert ws.receive_json()["type"] == "session.done"
+
+        engine_client.submit_interaction_async.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_prompt_update_accepted_via_async_handler(self, mocker: MockerFixture):
+        """interaction acknowledgement is sent while generation is in progress."""
+
+        release = asyncio.Event()
+
+        async def mock_generate(*_args, **_kwargs):
+            await release.wait()
+            yield OmniRequestOutput.from_diffusion(
+                request_id="req-ws",
+                images=[_fake_video_frames(2)],
+                final_output_type="image",
+                finished=True,
+            )
+
+        handler, engine_client, ws = _build_handler_for_async_tests(
+            mocker,
+            mock_generate=mock_generate,
+        )
+
+        async def _send_interaction_after_delay() -> None:
+            await asyncio.sleep(0.05)
+            ws.enqueue(
+                json.dumps(
+                    {
+                        "type": "session.interaction",
+                        "interaction": {
+                            "event_id": "ui-update-42",
+                            "event": {"prompt": "mid-stream update"},
+                            "transition_chunks": 2,
+                        },
+                    }
+                )
+            )
+
+        prompt_task = asyncio.create_task(_send_interaction_after_delay())
+        session_task = asyncio.create_task(handler.handle_session(ws))  # type: ignore[arg-type]
+        await asyncio.sleep(0.15)
+        release.set()
+        await session_task
+        await prompt_task
+
+        start = next(m for m in ws.sent_json if m.get("type") == "video.start")
+        request_id = start["request_id"]
+        assert any(m.get("type") == "session.interaction.queued" for m in ws.sent_json)
+        engine_client.submit_interaction_async.assert_awaited_once_with(
+            request_id,
+            interaction={
+                "event_id": "ui-update-42",
+                "event": {"prompt": "mid-stream update"},
+                "transition_chunks": 2,
+            },
+        )
diff --git a/tests/entrypoints/openai_api/test_serving_video_stream.py b/tests/entrypoints/openai_api/test_serving_video_stream.py
index de2fcc24d..fc8d83da6 100644
--- a/tests/entrypoints/openai_api/test_serving_video_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_video_stream.py
@@ -138,6 +138,112 @@ async def test_receive_config_accepts_client_legacy_aliases():
     assert config.frame_filter_threshold == 0.87
 
 
+@pytest.mark.asyncio
+async def test_video_frame_ack_reports_receiver_buffer_state():
+    ws = MockWebSocket(
+        [
+            json.dumps(
+                {
+                    "type": "session.config",
+                    "model": "test",
+                    "enable_frame_filter": False,
+                }
+            ),
+            json.dumps(
+                {
+                    "type": "video.frame",
+                    "data": _b64(_make_jpeg()),
+                    "frame_id": "frame-7",
+                    "pts_ms": 700,
+                    "capture_ts_ms": 1234.5,
+                }
+            ),
+            json.dumps({"type": "video.done"}),
+        ]
+    )
+    handler = QwenOmniStreamingVideoHandler(chat_service=object())
+
+    await handler.handle_session(ws)
+
+    ack = next(message for message in ws.sent if message.get("type") == "video.frame.ack")
+    assert ack["frame_id"] == "frame-7"
+    assert ack["pts_ms"] == 700
+    assert ack["capture_ts_ms"] == 1234.5
+    assert ack["accepted"] is True
+    assert ack["buffered_frames"] == 1
+    assert ack["server_receive_ts_ms"] > 0
+
+
+@pytest.mark.asyncio
+async def test_video_frames_consumed_is_emitted_after_engine_uses_frame_prompt():
+    class OneOutputEngine:
+        def generate(self, **_kwargs):
+            async def _gen():
+                await asyncio.sleep(0.05)
+                yield _text_result("visible")
+
+            return _gen()
+
+    class CapturingHandler(QwenOmniStreamingVideoHandler):
+        async def _preprocess_to_engine_prompt(self, request):
+            return {"prompt": "with-video"}
+
+    ws = MockWebSocket(
+        [
+            json.dumps(
+                {
+                    "type": "session.config",
+                    "model": "test",
+                    "modalities": ["text"],
+                    "num_frames": 1,
+                    "enable_frame_filter": False,
+                }
+            ),
+            json.dumps(
+                {
+                    "type": "video.frame",
+                    "data": _b64(_make_jpeg()),
+                    "frame_id": "frame-9",
+                    "pts_ms": 900,
+                    "source_pts_ms": 880,
+                    "quality_profile": "balanced",
+                }
+            ),
+            json.dumps({"type": "video.query", "text": "describe"}),
+            json.dumps({"type": "video.done"}),
+        ]
+    )
+    handler = CapturingHandler(
+        chat_service=object(),
+        engine_client=OneOutputEngine(),
+        idle_timeout=2.0,
+    )
+
+    await handler.handle_session(ws)
+
+    consumed = next(message for message in ws.sent if message.get("type") == "video.frames.consumed")
+    assert consumed["frame_ids"] == ["frame-9"]
+    assert consumed["latest_pts_ms"] == 900
+    assert consumed["request_id"].startswith("video-")
+    assert consumed["model_selected_ts_ms"] > 0
+    assert consumed["frames"] == [
+        {
+            "frame_id": "frame-9",
+            "pts_ms": 900,
+            "source_pts_ms": 880,
+            "quality_profile": "balanced",
+            "receiver_received_ts_ms": consumed["frames"][0]["receiver_received_ts_ms"],
+            "decoded_ready_ts_ms": consumed["frames"][0]["decoded_ready_ts_ms"],
+        }
+    ]
+    assert consumed["frames"][0]["receiver_received_ts_ms"] > 0
+    assert consumed["frames"][0]["decoded_ready_ts_ms"] >= consumed["frames"][0]["receiver_received_ts_ms"]
+    assert consumed["model_selected_ts_ms"] >= consumed["frames"][0]["decoded_ready_ts_ms"]
+    assert ws.sent.index(consumed) < next(
+        index for index, message in enumerate(ws.sent) if message.get("type") == "response.text.delta"
+    )
+
+
 @pytest.mark.asyncio
 async def test_audio_in_video_sets_mm_processor_kwargs():
     captured_requests = []
diff --git a/tests/test_speaker_metadata_persistence.py b/tests/entrypoints/openai_api/test_speaker_metadata_persistence.py
similarity index 100%
rename from tests/test_speaker_metadata_persistence.py
rename to tests/entrypoints/openai_api/test_speaker_metadata_persistence.py
diff --git a/tests/entrypoints/openai_api/test_speech_usage.py b/tests/entrypoints/openai_api/test_speech_usage.py
index 8211dab88..2fba10516 100644
--- a/tests/entrypoints/openai_api/test_speech_usage.py
+++ b/tests/entrypoints/openai_api/test_speech_usage.py
@@ -16,6 +16,8 @@ from vllm_omni.entrypoints.openai.speech_usage import (
     qwen3_tts_input_token_details,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 # A deterministic stand-in for a real tokenizer: 1 token per whitespace word.
 def word_count(text: str) -> int:
diff --git a/tests/entrypoints/openai_api/test_stage_params.py b/tests/entrypoints/openai_api/test_stage_params.py
index f9fd40349..5db768b30 100644
--- a/tests/entrypoints/openai_api/test_stage_params.py
+++ b/tests/entrypoints/openai_api/test_stage_params.py
@@ -3,6 +3,7 @@
 
 from types import SimpleNamespace
 
+import pytest
 from vllm import SamplingParams
 
 from vllm_omni.entrypoints.openai.stage_params import (
@@ -12,6 +13,8 @@ from vllm_omni.entrypoints.openai.stage_params import (
 )
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def test_resolve_stage_sampling_params_clones_stage_default():
     default = SamplingParams(temperature=0.2, seed=11)
diff --git a/tests/entrypoints/openai_api/test_tts_adapter.py b/tests/entrypoints/openai_api/test_tts_adapter.py
index 2930a204d..5f6d5930a 100644
--- a/tests/entrypoints/openai_api/test_tts_adapter.py
+++ b/tests/entrypoints/openai_api/test_tts_adapter.py
@@ -15,6 +15,9 @@ from vllm_omni.entrypoints.openai.tts_adapters import (
 )
 from vllm_omni.entrypoints.openai.tts_adapters.qwen3_tts import Qwen3TTSAdapter
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # Every dedicated TTS model-type must have an adapter so the orchestrator's
 # uniform ``self._adapter.build(...)`` dispatch covers it.
 EXPECTED_MODEL_TYPES = {
diff --git a/tests/entrypoints/openai_api/test_video_api_utils.py b/tests/entrypoints/openai_api/test_video_api_utils.py
index 722819682..08d223c68 100644
--- a/tests/entrypoints/openai_api/test_video_api_utils.py
+++ b/tests/entrypoints/openai_api/test_video_api_utils.py
@@ -48,6 +48,71 @@ def test_encode_video_bytes_exports_frames_without_interpolation(monkeypatch):
     assert mux_calls[0]["audio"] is None
 
 
+def test_float_frames_are_converted_without_stacking_full_video(monkeypatch):
+    frame = np.array(
+        [
+            [[0.0, 0.5, 1.0, 0.2], [1.5, -0.5, 0.5, 0.8]],
+        ],
+        dtype=np.float32,
+    )
+    original = frame.copy()
+
+    def fail_stack(*args, **kwargs):
+        raise AssertionError("float video conversion must not stack all frames")
+
+    monkeypatch.setattr(video_api_utils.np, "stack", fail_stack)
+
+    frames = video_api_utils._coerce_video_to_uint8_frames([frame, frame])
+
+    expected = np.array([[[128, 191, 255], [255, 64, 191]]], dtype=np.uint8)
+    assert frames.flags.c_contiguous
+    np.testing.assert_array_equal(frames, np.array([expected, expected]))
+    np.testing.assert_array_equal(frame, original)
+
+
+def test_two_dimensional_width_four_frames_are_not_treated_as_rgba():
+    frame = np.arange(8, dtype=np.float32).reshape(2, 4) / 8
+
+    frames = video_api_utils._coerce_video_to_uint8_frames([frame, frame])
+
+    expected = np.rint(frame * 255).astype(np.uint8)
+    assert frames.shape == (2, 2, 4)
+    np.testing.assert_array_equal(frames, np.stack([expected, expected]))
+
+
+def test_mixed_float_dtypes_preserve_stacked_rounding_semantics():
+    frames = [
+        np.full((1, 1, 3), 0.1, dtype=np.float16),
+        np.full((1, 1, 3), 0.2, dtype=np.float32),
+    ]
+    stacked = np.stack(frames)
+    expected = np.rint(np.clip(stacked, 0.0, 1.0) * 255.0).astype(np.uint8)
+
+    actual = video_api_utils._coerce_video_to_uint8_frames(frames)
+
+    assert expected[0, 0, 0, 0] == 25
+    np.testing.assert_array_equal(actual, expected)
+
+
+@pytest.mark.parametrize("frame_count", [3, 4])
+def test_channel_last_video_tensor_preserves_channel_sized_frame_count(frame_count):
+    video = torch.arange(frame_count * 2 * 5 * 3, dtype=torch.uint8).reshape(frame_count, 2, 5, 3)
+
+    frames = video_api_utils._coerce_video_to_uint8_frames(video)
+
+    assert frames.shape == (frame_count, 2, 5, 3)
+    np.testing.assert_array_equal(frames, video.numpy())
+
+
+def test_channel_first_video_tensor_is_converted_to_channel_last():
+    video = torch.arange(3 * 5 * 2 * 6, dtype=torch.uint8).reshape(3, 5, 2, 6)
+
+    frames = video_api_utils._coerce_video_to_uint8_frames(video)
+
+    assert frames.shape == (5, 2, 6, 3)
+    np.testing.assert_array_equal(frames, video.permute(1, 2, 3, 0).numpy())
+
+
 def test_fragmented_mp4_video_encoder_reuses_single_muxer(monkeypatch):
     muxers = []
 
diff --git a/tests/entrypoints/openai_api/test_video_frame_filter.py b/tests/entrypoints/openai_api/test_video_frame_filter.py
index a734aec75..ecada7a55 100644
--- a/tests/entrypoints/openai_api/test_video_frame_filter.py
+++ b/tests/entrypoints/openai_api/test_video_frame_filter.py
@@ -12,6 +12,8 @@ from tests.entrypoints.openai_api.conftest_video import (
 )
 from vllm_omni.entrypoints.openai.video_frame_filter import FrameSimilarityFilter
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 class TestFrameSimilarityFilter:
     def test_first_frame_always_retained(self):
@@ -29,8 +31,8 @@ class TestFrameSimilarityFilter:
         assert f.should_retain(make_jpeg(255, 255, 255)) is True
         assert f.should_retain(make_jpeg(0, 0, 0)) is True
 
-    def test_low_threshold_keeps_slightly_different(self):
-        f = FrameSimilarityFilter(threshold=0.50)
+    def test_high_threshold_keeps_slightly_different(self):
+        f = FrameSimilarityFilter(threshold=0.999)
         assert f.should_retain(make_jpeg(100, 100, 100)) is True
         assert f.should_retain(make_jpeg(110, 110, 110)) is True
 
diff --git a/tests/entrypoints/openai_api/test_video_server.py b/tests/entrypoints/openai_api/test_video_server.py
index ff69a2bf2..5af971755 100644
--- a/tests/entrypoints/openai_api/test_video_server.py
+++ b/tests/entrypoints/openai_api/test_video_server.py
@@ -12,11 +12,12 @@ import os
 import threading
 import time
 from contextlib import asynccontextmanager
+from pathlib import Path
 from types import SimpleNamespace
 
 import numpy as np
 import pytest
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.testclient import TestClient
 from PIL import Image
 from pytest_mock import MockerFixture
@@ -61,12 +62,24 @@ class FakeAsyncOmni:
     def __init__(self):
         self.stage_configs = [SimpleNamespace(stage_type="diffusion")]
         self.default_sampling_params_list = [OmniDiffusionSamplingParams()]
+        self.model_class_name = "WanPipeline"
         self.captured_prompt = None
+        self.captured_reference_video_bytes = None
         self.captured_sampling_params_list = None
 
+    def get_diffusion_od_config(self):
+        return SimpleNamespace(model_class_name=self.model_class_name)
+
     async def generate(self, prompt, request_id, sampling_params_list):
         self.captured_prompt = prompt
         self.captured_sampling_params_list = sampling_params_list
+        reference_videos = prompt.get("multi_modal_data", {}).get("video")
+        if (
+            isinstance(reference_videos, list)
+            and reference_videos
+            and all(isinstance(item, str) for item in reference_videos)
+        ):
+            self.captured_reference_video_bytes = [Path(item).read_bytes() for item in reference_videos]
         num_outputs = sampling_params_list[0].num_outputs_per_prompt
         videos = [object() for _ in range(num_outputs)]
         yield MockVideoResult(videos)
@@ -478,7 +491,7 @@ def test_v2v_video_generation_form(test_client, mocker: MockerFixture):
     assert input_video[0].size == (32, 24)
 
 
-def test_v2v_video_generation_with_video_reference_form(test_client, mocker: MockerFixture):
+def test_r9_typed_video_reference_form(test_client, mocker: MockerFixture):
     mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
         return_value=b"fake-video",
@@ -497,8 +510,113 @@ def test_v2v_video_generation_with_video_reference_form(test_client, mocker: Moc
 
     engine = test_client.app.state.openai_serving_video._engine_client
     input_video = engine.captured_prompt["multi_modal_data"]["video"]
-    assert len(input_video) == 2
-    assert input_video[0].size == (32, 24)
+    assert len(input_video) == 1
+    assert all(isinstance(item, str) for item in input_video)
+    assert engine.captured_reference_video_bytes is not None
+    assert len(engine.captured_reference_video_bytes) == 1
+    assert b"ftyp" in engine.captured_reference_video_bytes[0][:32]
+
+
+def test_r5_mixed_image_video_audio_references_and_fanout(test_client, mocker: MockerFixture):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
+        return_value=b"fake-video",
+    )
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "Use both references.",
+            "image_reference": json.dumps(
+                [
+                    {"image_url": _make_test_image_data_url((40, 24))},
+                    {"image_url": _make_test_image_data_url((40, 24))},
+                ]
+            ),
+            "video_reference": json.dumps(
+                {"video_url": _make_test_video_data_url((32, 24), 2)},
+            ),
+            "audio_reference": json.dumps(
+                [{"audio_url": "data:audio/mp3;base64,ZmFrZQ=="}],
+            ),
+            "extra_params": json.dumps({"task": "ref2va", "frame_indices": [0, -1], "start_time_seconds": 1.5}),
+            "num_outputs_per_prompt": "2",
+        },
+    )
+
+    assert response.status_code == 200
+    video_id = response.json()["id"]
+    _wait_for_status(test_client, video_id, VideoGenerationStatus.COMPLETED.value)
+    engine = test_client.app.state.openai_serving_video._engine_client
+    multi_modal_data = engine.captured_prompt["multi_modal_data"]
+    assert len(multi_modal_data["image"]) == 2
+    assert len(multi_modal_data["video"]) == 1
+    assert all(isinstance(item, str) for item in multi_modal_data["video"])
+    assert engine.captured_reference_video_bytes is not None
+    assert len(engine.captured_reference_video_bytes) == 1
+    assert b"ftyp" in engine.captured_reference_video_bytes[0][:32]
+    assert isinstance(multi_modal_data["audio"], str)
+    assert engine.captured_sampling_params_list[0].num_outputs_per_prompt == 2
+
+
+@pytest.mark.parametrize("endpoint", ["/v1/videos", "/v1/videos/sync"])
+def test_multi_video_generation_preserves_uploaded_files_until_generation(
+    endpoint,
+    test_client,
+    mocker: MockerFixture,
+):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
+        return_value=b"fake-video",
+    )
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    response = test_client.post(
+        endpoint,
+        data={
+            "prompt": "Composite the subject from the first video into the second.",
+            "extra_params": json.dumps({"task": "ref2va", "duration": 15.0}),
+        },
+        files=[
+            ("input_references", ("subject.png", _make_test_image_bytes((40, 24)), "image/png")),
+            ("input_references", ("subject.mp4", b"subject-video", "video/mp4")),
+            ("input_references", ("background.mov", b"background-video", "video/quicktime")),
+            ("input_references", ("voice.wav", b"reference-audio", "audio/wav")),
+        ],
+    )
+
+    assert response.status_code == 200
+    if endpoint.endswith("/sync"):
+        assert response.content == b"fake-video"
+    else:
+        video_id = response.json()["id"]
+        _wait_for_status(test_client, video_id, VideoGenerationStatus.COMPLETED.value)
+
+    engine = test_client.app.state.openai_serving_video._engine_client
+    input_videos = engine.captured_prompt["multi_modal_data"]["video"]
+    assert engine.captured_reference_video_bytes == [b"subject-video", b"background-video"]
+    assert len(input_videos) == 2
+    assert all(not Path(path).exists() for path in input_videos)
+    assert isinstance(engine.captured_prompt["multi_modal_data"]["image"], Image.Image)
+    assert isinstance(engine.captured_prompt["multi_modal_data"]["audio"], str)
+    assert engine.captured_sampling_params_list[0].extra_args["task"] == "ref2va"
+    assert engine.captured_sampling_params_list[0].extra_args["duration"] == 15.0
+
+
+def test_decode_video_bytes_can_keep_first_frames():
+    from vllm_omni.entrypoints.openai.video_api_utils import _decode_video_bytes
+
+    frames = _decode_video_bytes(
+        _make_test_video_bytes((32, 24), num_frames=6),
+        source="input_reference",
+        max_frames=2,
+        keep="first",
+    )
+
+    assert len(frames) == 2
+    assert frames.fps == pytest.approx(8.0)
+    red_means = [np.asarray(frame)[:, :, 0].mean() for frame in frames]
+    assert red_means[0] < red_means[1]
+    assert red_means[1] < 100
 
 
 def test_decode_video_bytes_can_keep_last_frames():
@@ -1136,17 +1254,67 @@ def test_rejects_input_reference_and_image_reference_together(test_client):
     assert "only one of input_reference, image_reference, or video_reference" in response.json()["detail"].lower()
 
 
-def test_rejects_image_reference_and_video_reference_together(test_client):
+def test_r10_typed_image_and_video_reference_form(test_client, mocker: MockerFixture):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.serving_video._encode_video_bytes",
+        return_value=b"fake-video",
+    )
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
     response = test_client.post(
         "/v1/videos",
         data={
-            "prompt": "bad refs",
-            "image_reference": '{"image_url": "https://example.com/cat.png"}',
-            "video_reference": '{"video_url": "https://example.com/cat.mp4"}',
+            "prompt": "use both references",
+            "image_reference": json.dumps({"image_url": _make_test_image_data_url((40, 24))}),
+            "video_reference": json.dumps({"video_url": _make_test_video_data_url((32, 24), 2)}),
         },
     )
+    assert response.status_code == 200
+    _wait_for_status(test_client, response.json()["id"], VideoGenerationStatus.COMPLETED.value)
+
+
+def test_generic_video_model_rejects_mixed_image_and_video_references(test_client):
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={
+            "prompt": "use both references",
+            "image_reference": json.dumps({"image_url": _make_test_image_data_url((40, 24))}),
+            "video_reference": json.dumps({"video_url": _make_test_video_data_url((32, 24), 2)}),
+        },
+    )
+
     assert response.status_code == 400
-    assert "only one of input_reference, image_reference, or video_reference" in response.json()["detail"].lower()
+    assert "does not support mixed image and video" in response.json()["detail"].lower()
+
+
+def test_h3_multipart_rejects_bmp_image_reference(test_client):
+    image = Image.new("RGB", (64, 64), color="blue")
+    image_buffer = io.BytesIO()
+    image.save(image_buffer, format="BMP")
+
+    test_client.app.state.openai_serving_video._engine_client.model_class_name = "MiniMaxH3Pipeline"
+    response = test_client.post(
+        "/v1/videos/sync",
+        data={"prompt": "reject unsupported image container", "extra_params": '{"task":"ref2va"}'},
+        files=[("input_references", ("reference.bmp", image_buffer.getvalue(), "image/bmp"))],
+    )
+
+    assert response.status_code == 400
+    assert "must use jpg" in response.json()["detail"].lower()
+
+
+@pytest.mark.asyncio
+async def test_h3_upload_limit_checks_declared_size_before_read():
+    class OversizedUpload:
+        size = api_server.MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES + 1
+
+        async def read(self, _size):
+            raise AssertionError("the oversized upload must be rejected before reading")
+
+    with pytest.raises(HTTPException, match="size limit"):
+        await api_server._read_upload_limited(
+            OversizedUpload(),
+            max_bytes=api_server.MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES,
+        )
 
 
 def test_invalid_seconds_returns_422(test_client):
diff --git a/tests/entrypoints/openai_api/test_video_stream_handler.py b/tests/entrypoints/openai_api/test_video_stream_handler.py
index a5ce3d616..e382b5e32 100644
--- a/tests/entrypoints/openai_api/test_video_stream_handler.py
+++ b/tests/entrypoints/openai_api/test_video_stream_handler.py
@@ -22,6 +22,9 @@ from vllm_omni.entrypoints.openai.video_stream_session import (
     VideoStreamHandler,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
diff --git a/tests/entrypoints/openai_api/test_video_stream_session.py b/tests/entrypoints/openai_api/test_video_stream_session.py
index b0a12b1e4..b91723c26 100644
--- a/tests/entrypoints/openai_api/test_video_stream_session.py
+++ b/tests/entrypoints/openai_api/test_video_stream_session.py
@@ -15,6 +15,9 @@ from vllm_omni.entrypoints.openai.video_stream_session import (
     VideoStreamSession,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # ---------------------------------------------------------------------------
 # VideoStreamConfig
 # ---------------------------------------------------------------------------
diff --git a/tests/entrypoints/test_async_omni_diffusion_config.py b/tests/entrypoints/test_async_omni_diffusion_config.py
index ba132dbd2..ecb0f20e8 100644
--- a/tests/entrypoints/test_async_omni_diffusion_config.py
+++ b/tests/entrypoints/test_async_omni_diffusion_config.py
@@ -85,6 +85,8 @@ def test_default_stage_config_defaults_nullified_parallel_size_kwargs():
             "tensor_parallel_size": None,
             "enable_expert_parallel": None,
             "enforce_eager": None,
+            "diffusion_compile_granularity": None,
+            "diffusion_compile_dynamic": None,
         }
     )[0]
 
@@ -94,6 +96,8 @@ def test_default_stage_config_defaults_nullified_parallel_size_kwargs():
     assert parallel_config.tensor_parallel_size == 1
     assert parallel_config.enable_expert_parallel is False
     assert stage_cfg["engine_args"]["enforce_eager"] is False
+    assert stage_cfg["engine_args"]["diffusion_compile_granularity"] == "regional"
+    assert stage_cfg["engine_args"]["diffusion_compile_dynamic"] is True
 
 
 def test_default_stage_config_propagates_ulysses_mode():
@@ -236,6 +240,28 @@ def test_serve_cli_accepts_ulysses_mode():
     assert parallel_config.ulysses_mode == "advanced_uaa"
 
 
+def test_serve_cli_forwards_model_defined_task_type_to_diffusion_stage():
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="command")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(
+        [
+            "serve",
+            "MiniMaxAI/MiniMax-H3",
+            "--omni",
+            "--task-type",
+            "fl2va",
+        ]
+    )
+
+    explicit_kwargs = args.get_explicit_kwargs_dict()
+    stage_cfg = AsyncOmniEngine._create_default_diffusion_stage_cfg(explicit_kwargs)[0]
+
+    assert args.task_type == "fl2va"
+    assert stage_cfg["engine_args"]["task_type"] == "fl2va"
+
+
 def test_serve_cli_accepts_diffusion_pipeline_profiler_flag():
     """Ensure diffusion serve CLI exposes the profiler switch."""
     parser = TrackingArgumentParser()
@@ -258,6 +284,62 @@ def test_serve_cli_accepts_diffusion_pipeline_profiler_flag():
     assert stage_cfg["engine_args"]["enable_diffusion_pipeline_profiler"] is True
 
 
+def test_serve_cli_forwards_distributed_offload_residency():
+    """Ensure the two-GPU DLO placement controls reach the diffusion stage."""
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="command")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(
+        [
+            "serve",
+            "MiniMaxAI/MiniMax-H3",
+            "--omni",
+            "--enable-distributed-layerwise-offload",
+            "--dlo-no-use-allgather",
+            "--dlo-resident-layers",
+            "20",
+        ]
+    )
+
+    explicit_kwargs = args.get_explicit_kwargs_dict()
+    stage_cfg = AsyncOmniEngine._create_default_diffusion_stage_cfg(explicit_kwargs)[0]
+    engine_args = stage_cfg["engine_args"]
+
+    assert args.enable_distributed_layerwise_offload is True
+    assert args.dlo_use_allgather is False
+    assert args.dlo_resident_layers == 20
+    assert engine_args["enable_distributed_layerwise_offload"] is True
+    assert engine_args["dlo_use_allgather"] is False
+    assert engine_args["dlo_resident_layers"] == 20
+
+
+def test_serve_cli_accepts_diffusion_compile_controls():
+    """Ensure both compile controls reach the diffusion stage."""
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="command")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(
+        [
+            "serve",
+            "Lightricks/LTX-Video-0.9.8-13B-distilled",
+            "--omni",
+            "--diffusion-compile-granularity",
+            "full",
+            "--no-diffusion-compile-dynamic",
+        ]
+    )
+
+    explicit_kwargs = args.get_explicit_kwargs_dict()
+    stage_cfg = AsyncOmniEngine._create_default_diffusion_stage_cfg(explicit_kwargs)[0]
+
+    assert args.diffusion_compile_granularity == "full"
+    assert args.diffusion_compile_dynamic is False
+    assert stage_cfg["engine_args"]["diffusion_compile_granularity"] == "full"
+    assert stage_cfg["engine_args"]["diffusion_compile_dynamic"] is False
+
+
 def test_serve_cli_accepts_diffusion_attention_backend():
     """Ensure diffusion serve CLI exposes the shorthand backend flag."""
     parser = TrackingArgumentParser()
@@ -355,6 +437,7 @@ def test_resolve_stage_configs_injects_additional_config_into_diffusion_stage(mo
             "stage_configs_path": "dummy.yaml",
             "additional_config": {"torchair_graph_config": {"enabled": True}},
         },
+        trust_remote_code=False,
     )
 
     assert not hasattr(stage_configs[0].engine_args, "additional_config")
@@ -392,6 +475,7 @@ def test_resolve_stage_configs_injects_quantization_config_into_diffusion_stage(
             "stage_configs_path": "dummy.yaml",
             "quantization_config": {"method": "bitsandbytes"},
         },
+        trust_remote_code=False,
     )
 
     assert stage_configs[0].engine_args.quantization_config == {"method": "bitsandbytes"}
diff --git a/tests/entrypoints/test_async_omni_duplex.py b/tests/entrypoints/test_async_omni_duplex.py
new file mode 100644
index 000000000..62f3f49ad
--- /dev/null
+++ b/tests/entrypoints/test_async_omni_duplex.py
@@ -0,0 +1,600 @@
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.engine.messages import OutputMessage
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.client_request_state import ClientRequestState
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexOutputAction,
+    DuplexOutputDecision,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.output import attach_duplex_output_decision
+from vllm_omni.experimental.fullduplex.request_client import DuplexRequestClient
+from vllm_omni.metrics.stats import OrchestratorAggregator, StageRequestStats, StageStats
+from vllm_omni.outputs import OmniRequestOutput
+
+
+def test_async_omni_uses_extracted_duplex_request_client():
+    app = object.__new__(AsyncOmni)
+    app.engine = SimpleNamespace(num_stages=2)
+    app.request_states = {}
+    app._duplex_request_client = None
+
+    client = app._get_duplex_request_client()
+
+    assert isinstance(client, DuplexRequestClient)
+    assert not hasattr(client, "_async_omni")
+
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.asyncio
+async def test_async_omni_open_duplex_forwards_session_config_and_timeout():
+    calls = []
+    output_handler_starts = 0
+
+    async def open_duplex_session_async(session_id, **kwargs):
+        calls.append((session_id, kwargs))
+        return {"ok": True}
+
+    app = object.__new__(AsyncOmni)
+    app.engine = SimpleNamespace(open_duplex_session_async=open_duplex_session_async)
+
+    def start_output_handler():
+        nonlocal output_handler_starts
+        output_handler_starts += 1
+
+    app._final_output_handler = start_output_handler
+
+    result = await app.open_duplex_session_async(
+        "sid",
+        fence=DuplexFence("sid"),
+        capabilities={"implementation_level": "model_native_duplex"},
+        session_config={"instructions": "Be brief.", "idle_timeout_s": 30},
+        timeout=7.5,
+    )
+
+    assert result == {"ok": True}
+    assert output_handler_starts == 1
+    assert calls == [
+        (
+            "sid",
+            {
+                "session_mode": "duplex",
+                "capabilities": {"implementation_level": "model_native_duplex"},
+                "session_config": {"instructions": "Be brief.", "idle_timeout_s": 30},
+                "fence": DuplexFence("sid"),
+                "timeout": 7.5,
+            },
+        )
+    ]
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_runtime_controls_forward_timeout():
+    calls = []
+    cancelled_fence = DuplexFence("sid", epoch=2, turn_id=3)
+    next_fence = DuplexFence("sid", epoch=3, turn_id=3)
+
+    async def append_duplex_input_async(session_id, **kwargs):
+        calls.append(("append", session_id, kwargs))
+        return {"ok": True}
+
+    async def signal_duplex_turn_async(session_id, **kwargs):
+        calls.append(("signal", session_id, kwargs))
+        return {"ok": True}
+
+    async def close_duplex_session_async(session_id, **kwargs):
+        calls.append(("close", session_id, kwargs))
+        return {"ok": True}
+
+    async def touch_duplex_session_async(session_id, **kwargs):
+        calls.append(("touch", session_id, kwargs))
+        return {"ok": True}
+
+    async def resume_duplex_session_async(session_id, **kwargs):
+        calls.append(("resume", session_id, kwargs))
+        return {"ok": True}
+
+    app = object.__new__(AsyncOmni)
+    app.request_states = {}
+    app._final_output_handler = lambda: None
+    app.engine = SimpleNamespace(
+        append_duplex_input_async=append_duplex_input_async,
+        signal_duplex_turn_async=signal_duplex_turn_async,
+        close_duplex_session_async=close_duplex_session_async,
+        touch_duplex_session_async=touch_duplex_session_async,
+        resume_duplex_session_async=resume_duplex_session_async,
+    )
+
+    await app.append_duplex_input_async(
+        "sid",
+        mode="append_audio_chunk",
+        payload={},
+        fence=cancelled_fence,
+        timeout=12.5,
+    )
+    await app.signal_duplex_turn_async(
+        "sid",
+        event="barge_in",
+        fence=cancelled_fence,
+        next_fence=next_fence,
+        timeout=13.5,
+    )
+    await app.close_duplex_session_async("sid", reason="done", fence=next_fence, timeout=14.5)
+    await app.touch_duplex_session_async(
+        "sid",
+        fence=next_fence,
+        activity=DuplexLeaseActivity.HEARTBEAT,
+        timeout=15.5,
+    )
+    await app.resume_duplex_session_async(
+        "sid",
+        fence=next_fence,
+        expected_lease_generation=3,
+        timeout=16.5,
+    )
+
+    assert calls == [
+        (
+            "append",
+            "sid",
+            {
+                "mode": "append_audio_chunk",
+                "payload": {},
+                "final": False,
+                "expected_epoch": None,
+                "fence": cancelled_fence,
+                "timeout": 12.5,
+            },
+        ),
+        (
+            "signal",
+            "sid",
+            {
+                "event": "barge_in",
+                "fence": cancelled_fence,
+                "next_fence": next_fence,
+                "timeout": 13.5,
+            },
+        ),
+        (
+            "close",
+            "sid",
+            {
+                "reason": "done",
+                "fence": next_fence,
+                "timeout": 14.5,
+            },
+        ),
+        (
+            "touch",
+            "sid",
+            {
+                "fence": next_fence,
+                "activity": DuplexLeaseActivity.HEARTBEAT,
+                "timeout": 15.5,
+            },
+        ),
+        (
+            "resume",
+            "sid",
+            {
+                "fence": next_fence,
+                "expected_lease_generation": 3,
+                "timeout": 16.5,
+            },
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_append_can_defer_data_plane_output_collection():
+    app = object.__new__(AsyncOmni)
+    request_id = duplex_resource_request_id(DuplexFence("sid"), "stage0")
+
+    async def append_duplex_input_async(session_id, **kwargs):
+        del session_id, kwargs
+        request_state = app.request_states.get(request_id)
+        assert request_state is not None
+        assert request_state.metrics is not None
+        return {
+            "stage_results": [
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": request_id,
+                        "response_stage_id": 1,
+                    }
+                }
+            ]
+        }
+
+    app.engine = SimpleNamespace(append_duplex_input_async=append_duplex_input_async)
+    app.request_states = {}
+    app._final_output_handler = lambda: None
+
+    result = await app.append_duplex_input_async(
+        "sid",
+        mode="append_audio_chunk",
+        payload={},
+        fence=DuplexFence("sid"),
+        collect_outputs=False,
+    )
+
+    assert "data_plane_outputs" not in result
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_append_forwards_fence():
+    calls = []
+
+    async def append_duplex_input_async(session_id, **kwargs):
+        calls.append((session_id, kwargs))
+        return {"ok": True}
+
+    app = object.__new__(AsyncOmni)
+    app.request_states = {}
+    app._final_output_handler = lambda: None
+    app.engine = SimpleNamespace(append_duplex_input_async=append_duplex_input_async)
+    fence = DuplexFence("sid", epoch=1, turn_id=2)
+
+    await app.append_duplex_input_async(
+        "sid",
+        mode="append_audio_chunk",
+        payload={},
+        fence=fence,
+        collect_outputs=False,
+    )
+
+    assert calls[0][1]["fence"] is fence
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_collect_waits_for_response_stage():
+    app = object.__new__(AsyncOmni)
+    req_state = ClientRequestState("duplex-sid-e0-stage0")
+    stage0_output = OmniRequestOutput(
+        request_id="duplex-sid-e0-stage0",
+        stage_id=0,
+        finished=False,
+    )
+    stage1_output = OmniRequestOutput(
+        request_id="duplex-sid-e0-stage0",
+        stage_id=1,
+        final_output_type="audio",
+        finished=False,
+    )
+    await req_state.queue.put(
+        OutputMessage(
+            request_id="duplex-sid-e0-stage0",
+            stage_id=0,
+            engine_outputs=stage0_output,
+            finished=False,
+        )
+    )
+    await req_state.queue.put(
+        OutputMessage(
+            request_id="duplex-sid-e0-stage0",
+            stage_id=1,
+            engine_outputs=stage1_output,
+            finished=False,
+        )
+    )
+
+    outputs = await app._collect_duplex_data_plane_outputs(
+        "duplex-sid-e0-stage0",
+        req_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+
+    assert outputs == [stage1_output]
+
+
+@pytest.mark.asyncio
+async def test_duplex_request_client_retains_output_route_at_segment_terminal():
+    request_id = "duplex-sid-e0-stage0"
+    request_state = ClientRequestState(request_id)
+    request_states = {request_id: request_state}
+    output = OmniRequestOutput(
+        request_id=request_id,
+        stage_id=1,
+        final_output_type="audio",
+        finished=True,
+    )
+    await request_state.queue.put(
+        OutputMessage(
+            request_id=request_id,
+            stage_id=1,
+            engine_outputs=output,
+            finished=True,
+        )
+    )
+    client = DuplexRequestClient(
+        SimpleNamespace(),
+        SimpleNamespace(
+            request_states=request_states,
+            num_stages=2,
+            log_stats=False,
+        ),
+    )
+
+    outputs = await client.collect_outputs(
+        request_id,
+        request_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+
+    assert outputs == [output]
+    assert request_states[request_id] is request_state
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_direct_output_keeps_stage_metrics():
+    app = object.__new__(AsyncOmni)
+    app._duplex_request_client = None
+    app._final_output_handler = lambda: None
+    request_id = "duplex-sid-e0-stage0"
+    req_state = ClientRequestState(request_id)
+    decision = DuplexOutputDecision(
+        action=DuplexOutputAction.DIRECT_RESPONSE,
+        metadata={
+            "duplex_direct_response": True,
+            "duplex_native_decision": "speak",
+        },
+    )
+    direct_output = attach_duplex_output_decision(
+        OmniRequestOutput(
+            request_id=request_id,
+            stage_id=0,
+            final_output_type="text",
+            finished=True,
+        ),
+        decision,
+    )
+    await req_state.queue.put(
+        OutputMessage(
+            request_id=request_id,
+            stage_id=0,
+            engine_outputs=direct_output,
+            metrics=StageRequestStats(
+                batch_id=1,
+                batch_size=1,
+                num_tokens_in=160,
+                num_tokens_out=8,
+                stage_gen_time_ms=80.0,
+                rx_transfer_bytes=0,
+                rx_decode_time_ms=0.0,
+                rx_in_flight_time_ms=0.0,
+                stage_stats=StageStats(total_token=8, total_gen_time_ms=80.0),
+                vllm_ttft_ms=12.5,
+                vllm_tpot_ms=9.0,
+                vllm_itl_ms=8.75,
+                vllm_itls_ms=[8.0, 9.5],
+            ),
+            finished=True,
+        )
+    )
+
+    outputs = await app._collect_duplex_data_plane_outputs(
+        request_id,
+        req_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+
+    assert outputs == [direct_output]
+    assert direct_output.metrics["stage_metrics"]["0"]["vllm_ttft_ms"] == 12.5
+    assert direct_output.metrics["stage_metrics"]["0"]["vllm_tpot_ms"] == 9.0
+    assert direct_output.metrics["stage_metrics"]["0"]["vllm_itls_ms"] == [8.0, 9.5]
+
+
+@pytest.mark.asyncio
+async def test_duplex_metrics_cursor_isolates_resumable_collect_windows():
+    app = object.__new__(AsyncOmni)
+    app._duplex_request_client = None
+    app._final_output_handler = lambda: None
+    request_id = "duplex-sid-e0-stage0"
+    req_state = ClientRequestState(request_id)
+    req_state.metrics = OrchestratorAggregator(
+        num_stages=2,
+        log_stats=False,
+        wall_start_ts=0.0,
+        final_stage_id_for_e2e=1,
+    )
+
+    def stage_message(*, batch_id: int, tokens: int, ttft_ms: float, itls: list[float]) -> OutputMessage:
+        decision = DuplexOutputDecision(
+            action=DuplexOutputAction.DIRECT_RESPONSE,
+            metadata={"duplex_direct_response": True, "duplex_native_decision": "speak"},
+        )
+        output = attach_duplex_output_decision(
+            OmniRequestOutput(
+                request_id=request_id,
+                stage_id=0,
+                final_output_type="text",
+                finished=True,
+            ),
+            decision,
+        )
+        return OutputMessage(
+            request_id=request_id,
+            stage_id=0,
+            engine_outputs=output,
+            metrics=StageRequestStats(
+                batch_id=batch_id,
+                batch_size=1,
+                num_tokens_in=160,
+                num_tokens_out=tokens,
+                stage_gen_time_ms=80.0,
+                rx_transfer_bytes=0,
+                rx_decode_time_ms=0.0,
+                rx_in_flight_time_ms=0.0,
+                stage_stats=StageStats(total_token=tokens, total_gen_time_ms=80.0),
+                vllm_ttft_ms=ttft_ms,
+                vllm_tpot_ms=9.0,
+                vllm_itl_ms=sum(itls) / len(itls),
+                vllm_itls_ms=itls,
+            ),
+            finished=True,
+        )
+
+    await req_state.queue.put(stage_message(batch_id=1, tokens=71, ttft_ms=62.5, itls=[10.0, 11.0]))
+    first = await app._collect_duplex_data_plane_outputs(
+        request_id,
+        req_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+    await req_state.queue.put(stage_message(batch_id=2, tokens=155, ttft_ms=81.0, itls=[12.0, 13.0, 14.0]))
+    second = await app._collect_duplex_data_plane_outputs(
+        request_id,
+        req_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+
+    assert first[0].metrics["stage_metrics"]["0"]["num_tokens_out"] == 71
+    second_stage0 = second[0].metrics["stage_metrics"]["0"]
+    assert second_stage0["num_tokens_out"] == 155
+    assert second_stage0["vllm_ttft_ms"] == 81.0
+    assert second_stage0["vllm_itls_ms"] == [12.0, 13.0, 14.0]
+
+
+def test_async_omni_duplex_direct_output_prefers_outer_control_metadata():
+    decision = DuplexOutputDecision(
+        action=DuplexOutputAction.DIRECT_RESPONSE,
+        metadata={
+            "duplex_direct_response": True,
+            "duplex_native_decision": "listen",
+        },
+    )
+    output = attach_duplex_output_decision(
+        OmniRequestOutput(
+            request_id="duplex-sid-e0-stage0",
+            stage_id=0,
+            request_output=SimpleNamespace(
+                outputs=[],
+                multimodal_output=SimpleNamespace(kind="processed-payload"),
+                _custom_output={"inner": "completion"},
+            ),
+        ),
+        decision,
+    )
+
+    assert AsyncOmni._is_direct_duplex_data_plane_response(output)
+
+
+def test_async_omni_drops_unregistered_duplex_prefixed_output():
+    app = object.__new__(AsyncOmni)
+    app.request_states = {}
+    output = OmniRequestOutput(request_id="duplex-unregistered-e0-stage0", stage_id=0)
+
+    keep_processing, request_id, stage_id, request_state = app._handle_output_message(
+        OutputMessage(
+            request_id=output.request_id,
+            stage_id=0,
+            engine_outputs=output,
+            finished=False,
+        )
+    )
+
+    assert keep_processing is True
+    assert request_id is stage_id is request_state is None
+    assert app.request_states == {}
+
+
+@pytest.mark.asyncio
+async def test_async_omni_duplex_collect_wraps_raw_response_stage_output():
+    app = object.__new__(AsyncOmni)
+    app.log_stats = False
+    app._enable_ar_profiler = False
+    app.request_states = {}
+    app.prom_metrics = SimpleNamespace(
+        set_running=lambda value: None,
+        set_waiting=lambda value: None,
+    )
+    app.engine = SimpleNamespace(
+        num_stages=2,
+        get_stage_metadata=lambda stage_id: SimpleNamespace(
+            final_output=stage_id == 1,
+            final_output_type="audio",
+        ),
+    )
+    req_state = ClientRequestState("duplex-sid-e0-stage0")
+    raw_stage1_output = SimpleNamespace(
+        finished=False,
+        outputs=[],
+        stage_durations={},
+        peak_memory_mb=0.0,
+        final_output_type="audio",
+    )
+    await req_state.queue.put(
+        OutputMessage(
+            request_id="duplex-sid-e0-stage0",
+            stage_id=1,
+            engine_outputs=raw_stage1_output,
+            finished=False,
+        )
+    )
+
+    outputs = await app._collect_duplex_data_plane_outputs(
+        "duplex-sid-e0-stage0",
+        req_state,
+        response_stage_id=1,
+        timeout=1.0,
+    )
+
+    assert len(outputs) == 1
+    assert outputs[0].request_id == "duplex-sid-e0-stage0"
+    assert outputs[0].finished is False
+    assert outputs[0].stage_id == 1
+    assert outputs[0].final_output_type == "audio"
+    assert outputs[0].request_output is raw_stage1_output
+
+
+def test_async_omni_duplex_request_info_includes_response_stage():
+    request_id, response_stage_id = AsyncOmni._duplex_data_plane_request_info(
+        {
+            "stage_results": [
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": "duplex-sid-e0-stage0",
+                        "response_stage_id": 1,
+                    }
+                }
+            ]
+        }
+    )
+
+    assert request_id == "duplex-sid-e0-stage0"
+    assert response_stage_id == 1
+
+
+@pytest.mark.asyncio
+async def test_duplex_request_client_retains_output_route_when_close_fails():
+    fence = DuplexFence("sid-close-route")
+    request_id = duplex_resource_request_id(fence, "stage0")
+    request_states = {request_id: ClientRequestState(request_id)}
+
+    async def close_duplex_session_async(session_id, **kwargs):
+        del session_id, kwargs
+        raise RuntimeError("close failed")
+
+    client = DuplexRequestClient(
+        SimpleNamespace(close_duplex_session_async=close_duplex_session_async),
+        SimpleNamespace(request_states=request_states),
+    )
+
+    with pytest.raises(RuntimeError, match="close failed"):
+        await client.close(fence.session_id, reason="test", fence=fence, timeout=1.0)
+
+    assert request_id in request_states
diff --git a/tests/entrypoints/test_async_omni_prompt_update.py b/tests/entrypoints/test_async_omni_prompt_update.py
new file mode 100644
index 000000000..f3edeeec7
--- /dev/null
+++ b/tests/entrypoints/test_async_omni_prompt_update.py
@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Entrypoint contract tests for ``AsyncOmni.submit_interaction_async``."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.client_request_state import ClientRequestState
+from vllm_omni.inputs.data import OmniInteractionPrompt
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_async_omni(*, num_stages: int = 1, stage_type: str = "diffusion") -> AsyncOmni:
+    omni = object.__new__(AsyncOmni)
+    omni.log_stats = False
+    omni.request_states = {
+        "external-abc-uuid-1": ClientRequestState(
+            request_id="external-abc-uuid-1",
+            external_request_id="external-abc",
+            queue=AsyncMock(),
+        ),
+        "external-abc-uuid-2": ClientRequestState(
+            request_id="external-abc-uuid-2",
+            external_request_id="external-abc",
+            queue=AsyncMock(),
+        ),
+        "other-req-uuid": ClientRequestState(
+            request_id="other-req-uuid",
+            external_request_id="other-req",
+            queue=AsyncMock(),
+        ),
+    }
+    omni.engine = SimpleNamespace(  # pyright: ignore[reportAttributeAccessIssue]
+        num_stages=num_stages,
+        get_stage_metadata=lambda stage_id: SimpleNamespace(stage_type=stage_type),
+        submit_interaction_async=AsyncMock(),
+    )
+    return omni
+
+
+def _prompt_interaction(prompt: str = "new prompt", transition_chunks: int | None = None) -> OmniInteractionPrompt:
+    interaction: OmniInteractionPrompt = {"event_id": "ui-update-1", "event": {"prompt": prompt}}
+    if transition_chunks is not None:
+        interaction["transition_chunks"] = transition_chunks
+    return interaction
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_maps_external_to_internal_id() -> None:
+    omni = _make_async_omni()
+    with pytest.raises(ValueError, match="exactly one active request"):
+        await omni.submit_interaction_async("external-abc", interaction=_prompt_interaction(transition_chunks=2))
+
+    omni.request_states.pop("external-abc-uuid-2")
+    await omni.submit_interaction_async(
+        "external-abc",
+        interaction=_prompt_interaction(transition_chunks=2),
+    )
+    omni.engine.submit_interaction_async.assert_awaited_once_with(  # pyright: ignore[reportAttributeAccessIssue]
+        "external-abc-uuid-1",
+        interaction=_prompt_interaction(transition_chunks=2),
+    )
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_passes_missing_transition_chunks() -> None:
+    omni = _make_async_omni()
+    omni.request_states.pop("external-abc-uuid-2")
+    await omni.submit_interaction_async("external-abc", interaction=_prompt_interaction())
+    omni.engine.submit_interaction_async.assert_awaited_once_with(  # pyright: ignore[reportAttributeAccessIssue]
+        "external-abc-uuid-1",
+        interaction=_prompt_interaction(),
+    )
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_rejects_empty_prompt() -> None:
+    omni = _make_async_omni()
+    omni.request_states.pop("external-abc-uuid-2")
+    with pytest.raises(ValueError, match="prompt must be non-empty"):
+        await omni.submit_interaction_async("external-abc", interaction=_prompt_interaction(""))
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_rejects_negative_transition_chunks() -> None:
+    omni = _make_async_omni()
+    omni.request_states.pop("external-abc-uuid-2")
+    with pytest.raises(ValueError, match="transition_chunks must be >= 0"):
+        await omni.submit_interaction_async(
+            "external-abc",
+            interaction=_prompt_interaction(transition_chunks=-1),
+        )
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_rejects_inactive_request() -> None:
+    omni = _make_async_omni()
+    omni.request_states.clear()
+    with pytest.raises(ValueError, match="No active request"):
+        await omni.submit_interaction_async("missing", interaction=_prompt_interaction(transition_chunks=2))
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_rejects_non_diffusion() -> None:
+    omni = _make_async_omni(stage_type="llm")
+    omni.request_states = {
+        "req-uuid": ClientRequestState(
+            request_id="req-uuid",
+            external_request_id="req",
+            queue=AsyncMock(),
+        ),
+    }
+    with pytest.raises(ValueError, match="requires a diffusion stage"):
+        await omni.submit_interaction_async("req", interaction=_prompt_interaction(transition_chunks=2))
+
+
+@pytest.mark.asyncio
+async def test_submit_interaction_async_forwards_unsupported_dict_shape_to_engine() -> None:
+    omni = _make_async_omni()
+    omni.request_states.pop("external-abc-uuid-2")
+    payload: OmniInteractionPrompt = {  # pyright: ignore[reportAssignmentType]  # deliberately wrong
+        "event": {"multi_modal_data": {"unsupported_modality": {"type": "pose"}}},
+        "transition_chunks": 2,
+    }
+
+    await omni.submit_interaction_async(
+        "external-abc",
+        interaction=payload,
+    )
+
+    omni.engine.submit_interaction_async.assert_awaited_once_with(  # pyright: ignore[reportAttributeAccessIssue]
+        "external-abc-uuid-1",
+        interaction=payload,
+    )
diff --git a/tests/entrypoints/test_duplex_fence_propagation.py b/tests/entrypoints/test_duplex_fence_propagation.py
new file mode 100644
index 000000000..f7b8cdcfc
--- /dev/null
+++ b/tests/entrypoints/test_duplex_fence_propagation.py
@@ -0,0 +1,123 @@
+import pytest
+
+from tests.entrypoints.openai_api.test_duplex_handler import FakeChatService, TimedWebSocket
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.openai.protocol import DuplexSession, DuplexSessionConfig
+from vllm_omni.experimental.fullduplex.openai.serving import OmniDuplexSessionHandler
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FenceRecordingEngine:
+    output_modalities = ["text", "audio"]
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, DuplexFence | None]] = []
+        self.signal_next_fences: list[DuplexFence | None] = []
+
+    async def open_duplex_session_async(self, session_id, *, fence=None, **kwargs):
+        del session_id, kwargs
+        self.calls.append(("open", fence))
+        return {"ok": True}
+
+    async def append_duplex_input_async(self, session_id, *, fence=None, **kwargs):
+        del session_id, kwargs
+        self.calls.append(("append", fence))
+        return {"ok": True}
+
+    async def signal_duplex_turn_async(
+        self,
+        session_id,
+        *,
+        event,
+        fence=None,
+        next_fence=None,
+        timeout=None,
+    ):
+        del session_id, event, timeout
+        self.calls.append(("signal", fence))
+        self.signal_next_fences.append(next_fence)
+        return {"ok": True}
+
+    async def close_duplex_session_async(self, session_id, *, fence=None, **kwargs):
+        del session_id, kwargs
+        self.calls.append(("close", fence))
+        return {"ok": True}
+
+
+@pytest.mark.asyncio
+async def test_async_omni_forwards_fence_for_all_runtime_operations():
+    engine = FenceRecordingEngine()
+    app = object.__new__(AsyncOmni)
+    app.engine = engine
+    app.request_states = {}
+    app._final_output_handler = lambda: None
+    fence = DuplexFence("sid", epoch=1, turn_id=2)
+
+    await app.open_duplex_session_async("sid", fence=fence)
+    await app.append_duplex_input_async(
+        "sid", mode="append_audio_chunk", payload={}, fence=fence, collect_outputs=False
+    )
+    await app.signal_duplex_turn_async("sid", event="turn.end", fence=fence)
+    await app.close_duplex_session_async("sid", reason="done", fence=fence)
+
+    assert engine.calls == [(operation, fence) for operation in ("open", "append", "signal", "close")]
+
+
+@pytest.mark.asyncio
+async def test_openai_handler_passes_current_session_fence_for_runtime_controls():
+    engine = FenceRecordingEngine()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(
+        session_id="sid",
+        config=DuplexSessionConfig(),
+        epoch=1,
+        turn_id=2,
+    )
+    ws = TimedWebSocket()
+    fence = DuplexFence("sid", epoch=1, turn_id=2)
+
+    await handler._open_runtime_session(session, ws.send_json)
+    await handler._signal_runtime_session(session, "turn.end", send_json=ws.send_json)
+    await handler._close_runtime_session(session, reason="done", send_json=ws.send_json)
+
+    assert engine.calls == [(operation, fence) for operation in ("open", "signal", "close")]
+
+
+@pytest.mark.asyncio
+async def test_runtime_signal_uses_fence_captured_before_session_turn_advances():
+    engine = FenceRecordingEngine()
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
+    session = DuplexSession(session_id="sid", config=DuplexSessionConfig())
+    captured_fence = DuplexFence("sid", epoch=0, turn_id=0)
+    session.turn_id = 1
+
+    await handler._signal_runtime_session(
+        session,
+        "input.commit",
+        fence=captured_fence,
+    )
+
+    assert engine.calls == [("signal", captured_fence)]
+
+
+@pytest.mark.asyncio
+async def test_openai_handler_forwards_cancel_fence_through_async_omni_facade():
+    engine = FenceRecordingEngine()
+    app = object.__new__(AsyncOmni)
+    app.engine = engine
+    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(app))
+    session = DuplexSession(session_id="sid-cancel", config=DuplexSessionConfig())
+    cancelled_fence = DuplexFence("sid-cancel", epoch=2, turn_id=3)
+    next_fence = DuplexFence("sid-cancel", epoch=3, turn_id=3)
+
+    assert await handler._signal_runtime_session(
+        session,
+        "input.cancel",
+        fence=cancelled_fence,
+        next_fence=next_fence,
+    )
+
+    assert engine.calls == [("signal", cancelled_fence)]
+    assert engine.signal_next_fences == [next_fence]
diff --git a/tests/entrypoints/test_omni_entrypoints.py b/tests/entrypoints/test_omni_entrypoints.py
index 4da82390b..5d9b85938 100644
--- a/tests/entrypoints/test_omni_entrypoints.py
+++ b/tests/entrypoints/test_omni_entrypoints.py
@@ -108,6 +108,8 @@ class FakeAsyncOmniEngine:
         self.output_processors = [SimpleNamespace(tokenizer=None) for _ in range(self.num_stages)]
         self.input_processor = None
         self.endpoint_restrictions = ()
+        self.duplex_session_config = None
+        self.duplex_serving_adapter_path = None
 
         self.output_q: queue.Queue[Any] = queue.Queue()
         self.submitted: list[dict[str, Any]] = []
diff --git a/tests/entrypoints/test_omni_new_request_data.py b/tests/entrypoints/test_omni_new_request_data.py
index b1ad56cdd..abbb04d8f 100644
--- a/tests/entrypoints/test_omni_new_request_data.py
+++ b/tests/entrypoints/test_omni_new_request_data.py
@@ -2,7 +2,9 @@ from types import SimpleNamespace
 
 import pytest
 import torch
+from vllm.v1.core.sched.output import NewRequestData
 
+from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
 from vllm_omni.core.sched.output import OmniNewRequestData
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -52,3 +54,80 @@ def test_omni_new_request_data_allows_missing_payloads():
 
     assert data.prompt_embeds is None
     assert data.additional_information is None
+
+
+def test_from_base_preserves_every_upstream_field_and_adds_omni_payloads():
+    prompt_embeds = torch.randn(2, 3)
+    base = NewRequestData(
+        req_id="req-base",
+        prompt_token_ids=[1, 2],
+        mm_features=[],
+        sampling_params=None,
+        pooling_params=None,
+        block_ids=([3, 4],),
+        num_computed_tokens=1,
+        lora_request=None,
+        prompt_embeds=prompt_embeds,
+        prompt_is_token_ids=False,
+        prefill_token_ids=[1],
+    )
+    request = SimpleNamespace(
+        external_req_id="external-base",
+        additional_information={"payload": "value"},
+        model_intermediate_buffer={"hidden": "state"},
+    )
+
+    data = OmniNewRequestData.from_base(base, request)
+
+    for field_name in NewRequestData.__dataclass_fields__:
+        assert getattr(data, field_name) is getattr(base, field_name)
+    assert data.external_req_id == "external-base"
+    assert data.additional_information == {"payload": "value"}
+    assert data.model_intermediate_buffer == {"hidden": "state"}
+
+
+def test_rewrap_converts_fallback_entries_and_keeps_fast_path_entries():
+    base = NewRequestData(
+        req_id="req-fallback",
+        prompt_token_ids=[1],
+        mm_features=[],
+        sampling_params=None,
+        pooling_params=None,
+        block_ids=([2],),
+        num_computed_tokens=0,
+        lora_request=None,
+        prompt_embeds=None,
+        prompt_is_token_ids=True,
+        prefill_token_ids=[1],
+    )
+    fast_path = OmniNewRequestData(
+        req_id="req-fast",
+        prompt_token_ids=[3],
+        mm_features=[],
+        sampling_params=None,
+        pooling_params=None,
+        block_ids=([4],),
+        num_computed_tokens=0,
+        lora_request=None,
+        prompt_embeds=None,
+        prompt_is_token_ids=True,
+        prefill_token_ids=[3],
+        additional_information={"fast": True},
+    )
+    scheduler = OmniSchedulerMixin()
+    scheduler.requests = {
+        "req-fallback": SimpleNamespace(
+            external_req_id="external-fallback",
+            additional_information={"fallback": True},
+            model_intermediate_buffer=None,
+        )
+    }
+    output = SimpleNamespace(scheduled_new_reqs=[base, fast_path])
+
+    scheduler._rewrap_scheduled_new_reqs(output)
+
+    fallback_data, fast_path_data = output.scheduled_new_reqs
+    assert isinstance(fallback_data, OmniNewRequestData)
+    assert fallback_data.prefill_token_ids == [1]
+    assert fallback_data.additional_information == {"fallback": True}
+    assert fast_path_data is fast_path
diff --git a/tests/entrypoints/test_omni_sleep_mode.py b/tests/entrypoints/test_omni_sleep_mode.py
index efbb19fff..0377e1a9a 100644
--- a/tests/entrypoints/test_omni_sleep_mode.py
+++ b/tests/entrypoints/test_omni_sleep_mode.py
@@ -1,13 +1,19 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-"""Omni sleep mode: entrypoint-level VRAM/ACK tests (L4) plus H100 multi-TP e2e."""
+"""Omni sleep mode: entrypoint-level VRAM/ACK tests plus multi-stage e2e.
+
+Class-scoped engines amortize BAGEL load across sleep/wake assertions within
+each suite (LLM vs diffusion). Suites are separate classes so only one heavy
+engine is alive at a time. Device cleanup runs once per module.
+"""
 
 import asyncio
 import logging
 import os
 
 import pytest
+import pytest_asyncio
 import torch
 from vllm import SamplingParams
 
@@ -20,12 +26,11 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("OmniTest")
 pytestmark = [
     pytest.mark.advanced_model,
-    pytest.mark.usefixtures("clean_gpu_memory_between_tests"),
 ]
 
 
-def clean_gpu_envs():
-    """clean up GPU environment variables to ensure tests run on all available devices."""
+def clean_device_envs():
+    """Clear device-visibility env vars so tests see all available devices."""
     device_visibility_vars = [
         "CUDA_VISIBLE_DEVICES",  # NVIDIA
         "HIP_VISIBLE_DEVICES",  # AMD ROCm
@@ -103,11 +108,15 @@ def get_dynamic_devices(stage_idx: int, num_stages: int, tp_size: int) -> str:
     return ",".join(device_ids)
 
 
-@pytest.fixture(scope="function")
-async def llm_engine():
-    if current_omni_platform.is_rocm():
-        clean_gpu_envs()
-    model_name = "ByteDance-Seed/BAGEL-7B-MoT"
+async def _ensure_awake(engine: AsyncOmni, stage_ids: list[int]) -> None:
+    """Best-effort full wake so the next shared-engine test starts active."""
+    try:
+        await engine.wake_up(stage_ids=stage_ids)
+    except Exception as e:
+        logger.warning("ensure_awake failed (stage_ids=%s): %s", stage_ids, e)
+
+
+def _build_llm_stages() -> tuple[list[dict], list[dict]]:
     common_args = {
         "worker_type": "ar",
         "enable_sleep_mode": True,
@@ -133,18 +142,38 @@ async def llm_engine():
         },
     ]
     connectors = [{"src_stage_id": 0, "dst_stage_id": 1, "connector_type": "queue"}]
-    engine = AsyncOmni(model=model_name, stages=stages, connectors=connectors, init_timeout=600, enable_sleep_mode=True)
+    return stages, connectors
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _module_device_cleanup():
+    """One device cleanup pass around the module (engines are class-scoped)."""
+    from tests.helpers.env import run_post_test_cleanup, run_pre_test_cleanup
+
+    print("\n=== PRE-MODULE DEVICE CLEANUP (sleep_mode) ===")
+    run_pre_test_cleanup()
+    yield
+    print("\n=== POST-MODULE DEVICE CLEANUP (sleep_mode) ===")
+    run_post_test_cleanup()
+
+
+@pytest_asyncio.fixture(scope="class", loop_scope="class")
+async def llm_engine():
+    """Shared 2-stage BAGEL LLM engine for sleep/wake protocol tests."""
+    if current_omni_platform.is_rocm():
+        clean_device_envs()
+    stages, connectors = _build_llm_stages()
+    engine = AsyncOmni(model=MODEL, stages=stages, connectors=connectors, init_timeout=600, enable_sleep_mode=True)
     yield engine
     engine.shutdown()
-    # Subprocess / driver can lag releasing VRAM; brief pause before the next test spins up new workers.
     await asyncio.sleep(1.5)
 
 
-@pytest.fixture(scope="function")
+@pytest_asyncio.fixture(scope="class", loop_scope="class")
 async def diffusion_engine():
+    """Shared BAGEL diffusion TP=2 engine for sleep/wake + generate checks."""
     if current_omni_platform.is_rocm():
-        clean_gpu_envs()
-    model_name = "ByteDance-Seed/BAGEL-7B-MoT"
+        clean_device_envs()
     stages = [
         {
             "stage_id": 0,
@@ -165,28 +194,27 @@ async def diffusion_engine():
             "final_output_type": "image",
         }
     ]
-    engine = AsyncOmni(model=model_name, stages=stages, init_timeout=600, enable_sleep_mode=True)
+    engine = AsyncOmni(model=MODEL, stages=stages, init_timeout=600, enable_sleep_mode=True)
     yield engine
     engine.shutdown()
     await asyncio.sleep(1.5)
 
 
-class TestOmniSleepMode:
-    @pytest.mark.asyncio
+class TestOmniLlmSleepMode:
+    """LLM sleep/wake protocol tests sharing one class-scoped engine."""
+
+    @pytest.mark.asyncio(loop_scope="class")
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=1)
     async def test_llm_sleep_ack(self, llm_engine: AsyncOmni):
         """LLM Thinker (GPU0) Signal and Physical Recycling Audit"""
+        device_id = 0
         try:
-            device_id = 0
             used_before = get_device_global_memory_used_gib(device_id)
             acks = await llm_engine.sleep(stage_ids=[0], level=1)
             await asyncio.sleep(1.5)
             used_after = get_device_global_memory_used_gib(device_id)
             drop_gib = used_before - used_after
-            # Verification signal successful
             assert all(get_ack_info(ack, "status") == "SUCCESS" for ack in acks)
-            # Worker-reported delta (can be 0 if get_current_memory_usage does not move) or
-            # GPU-global drop from mem_get_info (sees child worker processes).
             total_freed_bytes = sum(get_ack_info(ack, "freed_bytes", 0) for ack in acks)
             freed_gib = total_freed_bytes / 1024**3
             logger.info(
@@ -201,9 +229,42 @@ class TestOmniSleepMode:
                 f"ACK={freed_gib:.2f} GiB, global_drop={drop_gib:.2f} GiB"
             )
         finally:
-            llm_engine.shutdown()
+            await _ensure_awake(llm_engine, [0])
 
-    @pytest.mark.asyncio
+    @pytest.mark.asyncio(loop_scope="class")
+    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+    async def test_partial_wake_blocks_generate(self, llm_engine: AsyncOmni):
+        """Regression for #4473 Repro B: generate() must be rejected if kv_cache
+        is still asleep after wake_up(tags=["weights"]), instead of crashing with
+        CUDA illegal memory access."""
+        try:
+            await llm_engine.sleep(stage_ids=[0], level=1)
+            await llm_engine.wake_up(stage_ids=[0], tags=["weights"])
+            with pytest.raises(RuntimeError, match="partially or fully asleep"):
+                async for _ in llm_engine.generate("test", sampling_params=SamplingParams(max_tokens=4)):
+                    pass
+        finally:
+            await _ensure_awake(llm_engine, [0])
+
+    @pytest.mark.asyncio(loop_scope="class")
+    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+    async def test_duplicate_wake_is_idempotent(self, llm_engine: AsyncOmni):
+        """Regression for #4473 Repro C: duplicate wake_up(tags=None) must be a
+        safe no-op instead of raising a cumem CUDA invalid argument error."""
+        try:
+            await llm_engine.sleep(stage_ids=[0], level=1)
+            first_acks = await llm_engine.wake_up(stage_ids=[0])
+            assert len(first_acks) > 0, "First wake_up() should return ACKs"
+            second_acks = await llm_engine.wake_up(stage_ids=[0])
+            assert second_acks == [], f"Duplicate wake_up() should return [] but got {second_acks}"
+        finally:
+            await _ensure_awake(llm_engine, [0])
+
+
+class TestOmniDiffusionSleepMode:
+    """Diffusion sleep/wake tests sharing one class-scoped TP=2 engine."""
+
+    @pytest.mark.asyncio(loop_scope="class")
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
     async def test_diffusion_sleep_handshake(self, diffusion_engine: AsyncOmni):
         """Diffusion Worker stage signal loop"""
@@ -217,19 +278,15 @@ class TestOmniSleepMode:
             assert len(acks) >= 1, "Expected at least 1 ACK from Diffusion Workers"
             assert all(_get_status(ack) == "SUCCESS" for ack in acks)
             logger.info(f"Success: Received {len(acks)} Diffusion Worker ACKs")
-            logger.info("Testing auto-wakeup before test end...")
             await diffusion_engine.wake_up(stage_ids=[0])
-            logger.info("Test logic finished, triggering manual shutdown...")
         finally:
-            diffusion_engine.shutdown()
-            logger.info("Manual shutdown executed. Test should exit now.")
+            await _ensure_awake(diffusion_engine, [0])
 
-    @pytest.mark.asyncio
+    @pytest.mark.asyncio(loop_scope="class")
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
     async def test_cross_device_cleanup(self, diffusion_engine: AsyncOmni):
         """Physical recycling audit: leveraging deterministic data returned by Workers"""
         try:
-            # TP2 uses GPUs 0 and 1; measure whole-GPU usage (includes worker subprocesses).
             used_before = get_device_global_memory_used_gib(0) + get_device_global_memory_used_gib(1)
             acks = await diffusion_engine.sleep(stage_ids=[0], level=1)
             await asyncio.sleep(1.5)
@@ -246,52 +303,90 @@ class TestOmniSleepMode:
             )
             logger.info("SUCCESS: 100% weights offloaded.")
         finally:
-            diffusion_engine.shutdown()
+            await _ensure_awake(diffusion_engine, [0])
 
-    @pytest.mark.asyncio
+    @pytest.mark.asyncio(loop_scope="class")
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
-    async def test_diffusion_integrity_bit_level(self, diffusion_engine: AsyncOmni):
-        """Bit-level consistency after Diffusion wake-up (prevent image corruption)"""
+    async def test_diffusion_sleep_wake_generate(self, diffusion_engine: AsyncOmni):
+        """Merged diffusion lifecycle with test points from the former trio:
+
+        - ``test_diffusion_integrity_bit_level``: 4-step/512 baseline generate →
+          sleep → wake → post generate (images present, count unchanged).
+        - ``test_diffusion_vram_lifecycle_audit``: ACK/process VRAM reclaim on
+          sleep; after wake, process VRAM restores to within 3 GiB of initial;
+          post-wake generate smoke.
+        - ``test_diffusion_model_sleep_tp``: sleep ACK SUCCESS → wake → verify
+          generate (same Active→Sleep→Active→Generate path; runs on the shared
+          class TP=2 BagelPipeline engine rather than a second default-config load).
+        """
+        import gc
+
+        device_id = 1
         try:
+            # --- integrity: baseline generate at original resolution/steps ---
             prompt = "A huge swimming pool, with many people swimming."
             sp = OmniDiffusionSamplingParams(num_inference_steps=4, height=512, width=512, seed=42)
             llm_sp = SamplingParams()
 
-            # Baseline Generation
             logger.info("Running Baseline Generation...")
             base_output = None
             async for output in diffusion_engine.generate(prompt, request_id="base", sampling_params_list=[llm_sp, sp]):
                 base_output = output
             assert base_output is not None and len(base_output.images) > 0
             logger.info("Baseline Generation successful.")
-            # Sleep Level 1
+
+            # Snapshot Active VRAM after generate (lifecycle compared Sleep/Wake
+            # against the pre-sleep active watermark).
+            get_vram_info(device_id)
+            torch.accelerator.empty_cache()
+            vram_initial = get_vram_info(device_id)["reserved"]
+            logger.info(f"Diffusion Active VRAM before sleep: {vram_initial:.2f} GiB")
+
+            # --- lifecycle + model_sleep_tp: level-1 sleep reclaim ---
             logger.info("Entering Deep Sleep (VRAM Scavenging)...")
-            await diffusion_engine.sleep(stage_ids=[0], level=1)
-            # Wake-up
+            acks = await diffusion_engine.sleep(stage_ids=[0], level=1)
+            statuses = [get_ack_info(ack, "status") for ack in acks]
+            assert all(s == "SUCCESS" for s in statuses), f"Sleep failed. Statuses: {statuses}"
+
+            reported_freed_bytes = sum(get_ack_info(ack, "freed_bytes", 0) for ack in acks)
+            reported_freed_gib = reported_freed_bytes / 1024**3
+            logger.info(f"Worker internally reported freed: {reported_freed_gib:.2f} GiB")
+
+            await asyncio.sleep(2)
+            get_vram_info(device_id)
+            torch.accelerator.empty_cache()
+            vram_sleeping = get_vram_info(device_id)["reserved"]
+            logger.info(f"External VRAM measurement during Sleep: {vram_sleeping:.2f} GiB")
+            assert reported_freed_gib > 14.0 or vram_sleeping < 5.0, (
+                f"Reclamation failed. Reported: {reported_freed_gib:.2f}G, Measured: {vram_sleeping:.2f}G"
+            )
+
+            # --- wake + VRAM restore to initial (±3 GiB) ---
             logger.info("Waking up (Reloading Weights)...")
             await diffusion_engine.wake_up(stage_ids=[0])
-
             await asyncio.sleep(2.0)
-            import gc
-
             gc.collect()
+            get_vram_info(device_id)
+            torch.accelerator.empty_cache()
+            vram_restored = get_vram_info(device_id)["reserved"]
+            logger.info(f"VRAM after Wake-up: {vram_restored:.2f} GiB")
+            assert abs(vram_restored - vram_initial) < 3.0, "VRAM failed to restore to initial levels"
 
+            # --- integrity + lifecycle: post-wake generate ---
             logger.info("Running Post-Wakeup Generation...")
             post_output = None
             async for output in diffusion_engine.generate(prompt, request_id="post", sampling_params_list=[llm_sp, sp]):
                 post_output = output
-            # Assert result consistency
             assert post_output is not None
             assert len(base_output.images) == len(post_output.images)
             assert post_output.images[0] is not None
-            logger.info("SUCCESS: Diffusion integrity verified after Sleep/Wake cycle.")
-        except Exception as e:
-            logger.error(f"Integrity test failed: {e}")
-            raise e
+            logger.info("SUCCESS: Diffusion integrity + VRAM lifecycle + sleep/wake generate verified.")
         finally:
-            logger.info("Triggering mandatory cleanup...")
-            diffusion_engine.shutdown()
-            logger.info("Cleanup complete, test exiting.")
+            await _ensure_awake(diffusion_engine, [0])
+
+
+class TestOmniCoordinatedSleepMode:
+    """Dual-engine coordination (kept skipped; do not delete)."""
 
     @pytest.mark.skip(
         reason=(
@@ -301,7 +396,7 @@ class TestOmniSleepMode:
             "Note: this test is fixture-free so skip does not init llm/diffusion engines."
         )
     )
-    @pytest.mark.asyncio
+    @pytest.mark.asyncio(loop_scope="class")
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
     async def test_coordinated_cross_device(self, llm_engine: AsyncOmni, diffusion_engine: AsyncOmni):
         """Heterogeneous Coordinated Cleanup Test (Talker and Diffusion on GPU 1)"""
@@ -341,172 +436,22 @@ class TestOmniSleepMode:
             diffusion_engine.shutdown()
             logger.info("All engines scavenged. Ready for next test.")
 
-    @pytest.mark.asyncio
-    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
-    async def test_diffusion_vram_lifecycle_audit(self, diffusion_engine: AsyncOmni):
-        """Diffusion memory loop: Active -> Deep Sleep -> Active -> inference sanity check"""
-        device_id = 1
-        try:
-            get_vram_info(device_id)
-            torch.accelerator.empty_cache()
-            vram_initial = get_vram_info(device_id)["reserved"]
-            logger.info(f"Diffusion Initial VRAM: {vram_initial:.2f} GiB")
-
-            # Sleep
-            logger.info("Triggering Level 1 Deep Sleep (Partial Weight Offloading)...")
-            acks = await diffusion_engine.sleep(stage_ids=[0], level=1)
-
-            reported_freed_bytes = sum(getattr(ack, "freed_bytes", 0) for ack in acks)
-            reported_freed_gib = reported_freed_bytes / 1024**3
-            logger.info(f"Worker internally reported freed: {reported_freed_gib:.2f} GiB")
-
-            await asyncio.sleep(2)
-            get_vram_info(device_id)
-            torch.accelerator.empty_cache()
-
-            vram_sleeping = get_vram_info(device_id)["reserved"]
-            logger.info(f"External VRAM measurement during Sleep: {vram_sleeping:.2f} GiB")
-
-            assert reported_freed_gib > 14.0 or vram_sleeping < 5.0, (
-                f"Reclamation failed. Reported: {reported_freed_gib:.2f}G, Measured: {vram_sleeping:.2f}G"
-            )
-
-            # wake-up
-            logger.info("Triggering Wake-up (Reloading weights to GPU)...")
-            await diffusion_engine.wake_up(stage_ids=[0])
-
-            await asyncio.sleep(2)
-            get_vram_info(device_id)
-            torch.accelerator.empty_cache()
-            vram_restored = get_vram_info(device_id)["reserved"]
-            logger.info(f"VRAM after Wake-up: {vram_restored:.2f} GiB")
-
-            assert abs(vram_restored - vram_initial) < 3.0, "VRAM failed to restore to initial levels"
-
-            # inference sanity check
-            logger.info("Running post-lifecycle inference smoke test...")
-            prompt = "A futuristic lab with glowing lights, high quality."
-            sp = OmniDiffusionSamplingParams(num_inference_steps=2, height=512, width=512, seed=42)
-            llm_sp = SamplingParams()
-
-            base_img_found = False
-            async for output in diffusion_engine.generate(
-                prompt, request_id="lifecycle-check", sampling_params_list=[llm_sp, sp]
-            ):
-                if output.images and output.images[0] is not None:
-                    base_img_found = True
-
-            assert base_img_found, "Inference failed after Wake-up cycle!"
-            logger.info("SUCCESS: Full Diffusion Lifecycle (Active -> Sleep -> Active -> Generate) audited.")
-
-        except Exception as e:
-            logger.error(f"Lifecycle audit failed: {e}")
-            raise e
-        finally:
-            logger.info("Cleaning up engine and scavenging processes...")
-            diffusion_engine.shutdown()
-            await asyncio.sleep(1)
-
-    @pytest.mark.asyncio
-    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
-    async def test_level2_sleep_wake_raises(self, llm_engine: AsyncOmni):
-        """Regression for #4473 Repro A: wake_up() after sleep(level=2) must raise
-        NotImplementedError instead of silently producing corrupted output."""
-        try:
-            await llm_engine.sleep(stage_ids=[0], level=2)
-            with pytest.raises(NotImplementedError, match="sleep\\(level=2\\)"):
-                await llm_engine.wake_up(stage_ids=[0])
-        finally:
-            llm_engine.shutdown()
-
-    @pytest.mark.asyncio
-    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
-    async def test_partial_wake_blocks_generate(self, llm_engine: AsyncOmni):
-        """Regression for #4473 Repro B: generate() must be rejected if kv_cache
-        is still asleep after wake_up(tags=["weights"]), instead of crashing with
-        CUDA illegal memory access."""
-        try:
-            await llm_engine.sleep(stage_ids=[0], level=1)
-            await llm_engine.wake_up(stage_ids=[0], tags=["weights"])
-            with pytest.raises(RuntimeError, match="partially or fully asleep"):
-                async for _ in llm_engine.generate("test", sampling_params=SamplingParams(max_tokens=4)):
-                    pass
-        finally:
-            llm_engine.shutdown()
-
-    @pytest.mark.asyncio
-    @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
-    async def test_duplicate_wake_is_idempotent(self, llm_engine: AsyncOmni):
-        """Regression for #4473 Repro C: duplicate wake_up(tags=None) must be a
-        safe no-op instead of raising a cumem CUDA invalid argument error."""
-        try:
-            await llm_engine.sleep(stage_ids=[0], level=1)
-            first_acks = await llm_engine.wake_up(stage_ids=[0])
-            assert len(first_acks) > 0, "First wake_up() should return ACKs"
-            second_acks = await llm_engine.wake_up(stage_ids=[0])
-            assert second_acks == [], f"Duplicate wake_up() should return [] but got {second_acks}"
-        finally:
-            llm_engine.shutdown()
-
 
 # ---------------------------------------------------------------------------
-# H100 (or MI325) e2e: BAGEL / pure diffusion, multi-TP
+# Multi-stage (H100) / pure diffusion TP=1 (2×L4): sleep→wake→generate
+# (BAGEL TP=2 diffusion path covered by TestOmniDiffusionSleepMode)
 # ---------------------------------------------------------------------------
 
 
-@pytest.mark.omni
-@pytest.mark.advanced_model
-@pytest.mark.parametrize("tp_size", [1])
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=1)
-@pytest.mark.asyncio
-async def test_diffusion_model_sleep_tp(tp_size: int):
-    """Two-stage BAGEL default config: warmup, sleep all, wake, verify generate."""
-    if current_omni_platform.is_rocm():
-        clean_gpu_envs()
-    num_gpus = torch.accelerator.device_count()
-    if num_gpus < tp_size:
-        pytest.skip(f"Skipping TP={tp_size}")
-
-    engine_args = {
-        "model": MODEL,
-        "enable_sleep_mode": True,
-        "tensor_parallel_size": tp_size,
-        "enforce_eager": True,
-        "trust_remote_code": True,
-        "dtype": "bfloat16",
-        "gpu_memory_utilization": 0.5,
-    }
-
-    engine = AsyncOmni(**engine_args, stage_init_timeout=1200)
-    try:
-        diff_sp = OmniDiffusionSamplingParams(num_inference_steps=2, height=256, width=256)
-        llm_sp = SamplingParams()
-
-        async for _ in engine.generate("test", sampling_params_list=[llm_sp, diff_sp]):
-            pass
-
-        acks = await engine.sleep(level=1)
-        statuses = [get_ack_info(ack, "status") for ack in acks]
-        assert all(s == "SUCCESS" for s in statuses), f"Sleep failed. Statuses: {statuses}"
-
-        await engine.wake_up()
-        async for _ in engine.generate("verify", sampling_params_list=[llm_sp, diff_sp]):
-            pass
-
-        logger.info("Diffusion TP=%s lifecycle OK", tp_size)
-    finally:
-        engine.shutdown()
-
-
 @pytest.mark.omni
 @pytest.mark.advanced_model
 @pytest.mark.parametrize("tp_size", [1, 2])
 @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
 @pytest.mark.asyncio
-async def test_multistage_sleep_h100(tp_size: int):
+async def test_multistage_llm_diffusion_sleep_wake(tp_size: int):
     """Explicit 2-stage (llm + diffusion) + connectors; sleep/wake both stages."""
     if current_omni_platform.is_rocm():
-        clean_gpu_envs()
+        clean_device_envs()
     num_gpus = torch.accelerator.device_count()
     if num_gpus < tp_size * 2:
         pytest.skip("Not enough GPUs")
@@ -552,18 +497,22 @@ async def test_multistage_sleep_h100(tp_size: int):
 
 
 @pytest.mark.omni
-@pytest.mark.advanced_model
-@pytest.mark.parametrize("tp_size", [1, 2])
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@pytest.mark.core_model
+@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards=1)
 @pytest.mark.asyncio
-async def test_pure_diffusion_scenario(tp_size: int):
-    """Single-stage random diffusion: sleep, wake, generate."""
+async def test_pure_diffusion_sleep_wake():
+    """Single-stage random diffusion (TP=1): sleep → wake → generate.
+
+    Diffusion TP=2 sleep/wake is covered by TestOmniDiffusionSleepMode
+    (shared BAGEL TP=2 engine); this case keeps the default AsyncOmni +
+    qwen_image_random entrypoint path on L4.
+    """
     if current_omni_platform.is_rocm():
-        clean_gpu_envs()
+        clean_device_envs()
     engine_args = {
         "model": MODEL_DIFF,
         "enable_sleep_mode": True,
-        "tensor_parallel_size": tp_size,
+        "tensor_parallel_size": 1,
         "enforce_eager": True,
         "dtype": "bfloat16",
         "gpu_memory_utilization": 0.5,
@@ -578,6 +527,6 @@ async def test_pure_diffusion_scenario(tp_size: int):
             sampling_params=OmniDiffusionSamplingParams(num_inference_steps=2, height=256, width=256),
         ):
             pass
-        logger.info("Pure diffusion OK (TP=%s)", tp_size)
+        logger.info("Pure diffusion sleep/wake OK")
     finally:
         engine.shutdown()
diff --git a/tests/entrypoints/test_omni_snapshot_download.py b/tests/entrypoints/test_omni_snapshot_download.py
new file mode 100644
index 000000000..d2c76a249
--- /dev/null
+++ b/tests/entrypoints/test_omni_snapshot_download.py
@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""``omni_snapshot_download`` must honor vLLM's ``VLLM_USE_MODELSCOPE`` semantics.
+
+vLLM treats the flag as enabled only for the literal string ``"true"``
+(case-insensitive). Reading ``os.environ`` directly made every non-empty value
+truthy, so an explicit opt-out such as ``VLLM_USE_MODELSCOPE=0`` still took the
+ModelScope path.
+"""
+
+import sys
+import types
+
+import pytest
+from vllm import envs
+
+from vllm_omni.entrypoints import omni_base
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+MODEL_ID = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+
+
+@pytest.fixture
+def download_backend(monkeypatch: pytest.MonkeyPatch):
+    """Run ``omni_snapshot_download`` and report which backend it selected.
+
+    ModelScope is not a vLLM-Omni dependency, so the ModelScope branch is stubbed
+    into ``sys.modules``; without the stub it would raise ``ModuleNotFoundError``
+    instead of being observable.
+    """
+    # vLLM caches env lookups once a service is initialized; make sure this test
+    # reads the values monkeypatch sets rather than a cached snapshot.
+    envs.disable_envs_cache()
+
+    picked: list[str] = []
+
+    snapshot_module = types.ModuleType("modelscope.hub.snapshot_download")
+    snapshot_module.snapshot_download = lambda model_id: picked.append("modelscope") or model_id
+    hub_module = types.ModuleType("modelscope.hub")
+    hub_module.snapshot_download = snapshot_module
+    root_module = types.ModuleType("modelscope")
+    root_module.hub = hub_module
+    for name, module in (
+        ("modelscope", root_module),
+        ("modelscope.hub", hub_module),
+        ("modelscope.hub.snapshot_download", snapshot_module),
+    ):
+        monkeypatch.setitem(sys.modules, name, module)
+
+    monkeypatch.setattr(
+        omni_base,
+        "download_weights_from_hf_specific",
+        lambda **_kwargs: picked.append("huggingface"),
+    )
+    monkeypatch.setattr(
+        omni_base,
+        "file_or_path_exists",
+        lambda *_args, **_kwargs: False,
+    )
+
+    def run() -> str:
+        picked.clear()
+        omni_base.omni_snapshot_download(MODEL_ID)
+        return picked[0] if picked else "none"
+
+    return run
+
+
+@pytest.mark.parametrize("value", ["0", "1", "False", "false", "no", "off"])
+def test_non_true_values_do_not_enable_modelscope(monkeypatch, download_backend, value):
+    monkeypatch.setenv("VLLM_USE_MODELSCOPE", value)
+
+    assert envs.VLLM_USE_MODELSCOPE is False
+    assert download_backend() == "huggingface"
+
+
+@pytest.mark.parametrize("value", ["true", "True", "TRUE"])
+def test_true_values_enable_modelscope(monkeypatch, download_backend, value):
+    monkeypatch.setenv("VLLM_USE_MODELSCOPE", value)
+
+    assert envs.VLLM_USE_MODELSCOPE is True
+    assert download_backend() == "modelscope"
+
+
+def test_unset_defaults_to_huggingface(monkeypatch, download_backend):
+    monkeypatch.delenv("VLLM_USE_MODELSCOPE", raising=False)
+
+    assert download_backend() == "huggingface"
+
+
+def test_modular_diffusers_defers_component_download(monkeypatch, download_backend):
+    monkeypatch.delenv("VLLM_USE_MODELSCOPE", raising=False)
+    monkeypatch.setattr(
+        omni_base,
+        "file_or_path_exists",
+        lambda *_args, **_kwargs: True,
+    )
+
+    assert download_backend() == "none"
diff --git a/tests/entrypoints/test_pd_disaggregation.py b/tests/entrypoints/test_pd_disaggregation.py
index 5ffabfbf2..c896ccb88 100644
--- a/tests/entrypoints/test_pd_disaggregation.py
+++ b/tests/entrypoints/test_pd_disaggregation.py
@@ -22,6 +22,9 @@ from vllm import SamplingParams
 
 from vllm_omni.entrypoints.pd_utils import PDDisaggregationMixin
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 pytestmark = pytest.mark.skip(reason="Temporarily skip PD entrypoint tests while PD config is being removed.")
 
 # Suppress noisy DeprecationWarnings from optional Swig bindings imported by vLLM dependencies.
@@ -121,9 +124,7 @@ class _FakeStage:
         self._in_q = in_q
         self._out_q = out_q
 
-    def init_stage_worker(
-        self, model: str, *, is_async=False, shm_threshold_bytes=65536, ctx=None, batch_timeout=10, **kwargs
-    ):
+    def init_stage_worker(self, model: str, *, is_async=False, ctx=None, batch_timeout=10, **kwargs):
         self._proc = _ns(
             start=lambda: None,
             join=lambda timeout=None: None,
@@ -307,21 +308,11 @@ def mock_get_config(monkeypatch):
     """Auto-mock get_config and related model loading functions."""
     import sys
 
-    fake_tokenizer = _ns()
-    fake_tokenizer.encode = lambda *args, **kwargs: [1, 2, 3]
-    fake_tokenizer.decode = lambda *args, **kwargs: "test"
-
-    def _mock_init_tokenizer_from_configs(model_config=None, **kwargs):
-        return fake_tokenizer
-
-    monkeypatch.setattr(
-        "vllm.transformers_utils.tokenizer.init_tokenizer_from_configs",
-        _mock_init_tokenizer_from_configs,
-        raising=False,
-    )
-    tokenizer_module_path = "vllm.transformers_utils.tokenizer"
-    if tokenizer_module_path in sys.modules:
-        setattr(sys.modules[tokenizer_module_path], "init_tokenizer_from_configs", _mock_init_tokenizer_from_configs)
+    # TODO(pd-unskip): the tokenizer mock that lived here targeted
+    # vllm.transformers_utils.tokenizer.init_tokenizer_from_configs, which was
+    # deleted in vLLM 0.26 (the raising=False setattr made it a silent no-op).
+    # When the module-level skip is lifted, mock whatever tokenizer seam the
+    # revived PD entrypoint code actually uses.
 
     def _mock_length_from_prompt_token_ids_or_embeds(prompt_token_ids=None, prompt_embeds=None):
         if prompt_token_ids is not None:
@@ -346,13 +337,6 @@ def mock_get_config(monkeypatch):
             _mock_length_from_prompt_token_ids_or_embeds,
         )
 
-    monkeypatch.setattr(
-        "vllm_omni.entrypoints.async_omni.init_tokenizer_from_configs", _mock_init_tokenizer_from_configs, raising=False
-    )
-    async_omni_path = "vllm_omni.entrypoints.async_omni"
-    if async_omni_path in sys.modules:
-        setattr(sys.modules[async_omni_path], "init_tokenizer_from_configs", _mock_init_tokenizer_from_configs)
-
     fake_hf_config = _ns()
     fake_hf_config.model_type = "qwen2_5_omni"
 
diff --git a/tests/entrypoints/test_resolve_dreamzero_config.py b/tests/entrypoints/test_resolve_dreamzero_config.py
index 4dcaddd63..cc459c269 100644
--- a/tests/entrypoints/test_resolve_dreamzero_config.py
+++ b/tests/entrypoints/test_resolve_dreamzero_config.py
@@ -28,11 +28,18 @@ def test_dreamzero_config_sets_model_class_and_policy_config(monkeypatch):
         classmethod(lambda _cls, model, trust_remote_code=True: "vla"),
     )
     monkeypatch.setattr(
-        "vllm_omni.diffusion.utils.hf_utils._looks_like_dreamzero",
+        "vllm_omni.config.config_factory.StageConfigFactory.get_hf_config",
+        classmethod(lambda _cls, model, trust_remote_code=True: None),
+    )
+    monkeypatch.setattr(
+        "vllm_omni.config.config_factory._looks_like_dreamzero",
         lambda _model: True,
     )
 
-    stage_configs, _ = load_stage_configs_from_model("GEAR-Dreams/DreamZero-DROID")
+    stage_configs, _ = load_stage_configs_from_model(
+        "GEAR-Dreams/DreamZero-DROID",
+        trust_remote_code=False,
+    )
     engine_args = stage_configs[0].engine_args
 
     assert engine_args.model_class_name == "DreamZeroPipeline"
diff --git a/tests/entrypoints/test_serve.py b/tests/entrypoints/test_serve.py
index 61ffed3d5..04a29edd1 100644
--- a/tests/entrypoints/test_serve.py
+++ b/tests/entrypoints/test_serve.py
@@ -46,6 +46,36 @@ def test_serve_parser_accepts_strategy_config() -> None:
     assert args.get_explicit_kwargs_dict()["strategy_config"] == "/tmp/strategy.yaml"
 
 
+def test_serve_parser_accepts_deploy_config() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(["serve", "fake-model", "--omni", "--deploy-config", "/tmp/deploy.yaml"])
+
+    assert args.deploy_config == "/tmp/deploy.yaml"
+    assert args.get_explicit_kwargs_dict()["deploy_config"] == "/tmp/deploy.yaml"
+
+
+def test_serve_parser_rejects_stage_configs_path() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    with pytest.raises(SystemExit):
+        parser.parse_args(["serve", "fake-model", "--omni", "--stage-configs-path", "/tmp/stages.yaml"])
+
+
+def test_serve_parser_accepts_four_way_cfg_parallelism() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(["serve", "fake-model", "--omni", "--cfg-parallel-size", "4"])
+
+    assert args.cfg_parallel_size == 4
+
+
 def _make_headless_args(**kwargs) -> TrackingNamespace:
     defaults = {
         "model": "fake-model",
@@ -56,7 +86,6 @@ def _make_headless_args(**kwargs) -> TrackingNamespace:
         "omni_replica_address": None,
         "omni_dp_size_local": 1,
         "worker_backend": "multi_process",
-        "stage_configs_path": None,
         "deploy_config": None,
         "log_stats": False,
         "disable_log_stats": False,
@@ -144,6 +173,7 @@ def test_run_headless_parses_and_forwards_stage_overrides(mocker: MockerFixture)
     captured: dict = {}
 
     def _fake_resolve(*args, **kwargs):
+        captured["args"] = args
         captured.update(kwargs)
         # Return a stage that does NOT match stage_id=0 so run_headless stops
         # right after the resolver call (we only care about how it was called).
@@ -156,12 +186,15 @@ def test_run_headless_parses_and_forwards_stage_overrides(mocker: MockerFixture)
 
     args = _make_headless_args(
         stage_id=0,
+        deploy_config="/tmp/deploy.yaml",
         strategy_config="/tmp/strategy.yaml",
         stage_overrides='{"0": {"devices": "0,1"}, "1": {"devices": "2"}}',
     )
     with pytest.raises(ValueError, match="No stage config found for stage_id=0"):
         run_headless(args)
 
+    assert captured["args"][1] is None
+    assert captured["deploy_config_path"] == "/tmp/deploy.yaml"
     assert captured["stage_overrides"] == {"0": {"devices": "0,1"}, "1": {"devices": "2"}}
     assert captured["strategy_config_path"] == "/tmp/strategy.yaml"
 
@@ -222,6 +255,7 @@ def test_run_headless_llm_registers_with_auto_assigned_replica_id(mocker: Mocker
     from vllm_omni.engine.stage_engine_startup import StageRegistrationResponse
 
     stage_cfg = _make_stage_cfg(0, stage_type="llm")
+    stage_cfg.engine_args["async_chunk"] = True
     parallel_config = SimpleNamespace(
         data_parallel_size_local=1,
         data_parallel_rank=0,
@@ -241,7 +275,10 @@ def test_run_headless_llm_registers_with_auto_assigned_replica_id(mocker: Mocker
         "vllm_omni.distributed.omni_connectors.utils.initialization.resolve_omni_kv_config_for_stage",
         return_value=(None, None, None),
     )
-    mocker.patch("vllm_omni.engine.stage_init_utils.get_stage_connector_spec", return_value={})
+    mock_connector_spec = mocker.patch(
+        "vllm_omni.engine.stage_init_utils.get_stage_connector_spec",
+        return_value={},
+    )
     mocker.patch("vllm_omni.engine.stage_init_utils.build_engine_args_dict", return_value={})
     mocker.patch(
         "vllm_omni.engine.stage_init_utils.build_vllm_config",
@@ -277,6 +314,7 @@ def test_run_headless_llm_registers_with_auto_assigned_replica_id(mocker: Mocker
     assert kwargs["omni_stage_config"] is stage_cfg
     assert kwargs["replica_id"] is None
     assert "socket_ownership" not in kwargs
+    assert mock_connector_spec.call_args.kwargs["async_chunk"] is True
 
     assert mock_manager_cls.call_count == 1
     mgr_kwargs = mock_manager_cls.call_args.kwargs
@@ -377,7 +415,7 @@ def test_run_headless_diffusion_registers_and_spawns_proc(mocker: MockerFixture)
         return_value=(None, None, None),
     )
     mocker.patch(
-        "vllm_omni.engine.stage_init_utils.extract_stage_metadata",
+        "vllm_omni.engine.stage_init_utils.extract_legacy_stage_metadata",
         return_value=SimpleNamespace(stage_id=1, stage_type="diffusion"),
     )
     mock_inject = mocker.patch("vllm_omni.engine.stage_init_utils.inject_kv_stage_info")
@@ -457,7 +495,7 @@ def test_run_headless_diffusion_raises_on_nonzero_proc_exit(mocker: MockerFixtur
         return_value=(None, None, None),
     )
     mocker.patch(
-        "vllm_omni.engine.stage_init_utils.extract_stage_metadata",
+        "vllm_omni.engine.stage_init_utils.extract_legacy_stage_metadata",
         return_value=SimpleNamespace(stage_id=1, stage_type="diffusion"),
     )
     mocker.patch("vllm_omni.engine.stage_init_utils.inject_kv_stage_info")
diff --git a/tests/entrypoints/test_stage_utils.py b/tests/entrypoints/test_stage_utils.py
index c4c0667df..e2890797f 100644
--- a/tests/entrypoints/test_stage_utils.py
+++ b/tests/entrypoints/test_stage_utils.py
@@ -6,6 +6,8 @@ from pytest_mock import MockerFixture
 
 from vllm_omni.entrypoints.stage_utils import _map_device_list, resolve_stage_physical_devices, set_stage_devices
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _make_dummy_torch(call_log):
     class _Props:
diff --git a/tests/entrypoints/test_stream_finish_reason.py b/tests/entrypoints/test_stream_finish_reason.py
index ebbca1917..3d6052045 100644
--- a/tests/entrypoints/test_stream_finish_reason.py
+++ b/tests/entrypoints/test_stream_finish_reason.py
@@ -16,20 +16,11 @@ Key invariants tested:
   - voice/speaker parameter compatibility in chat completions
 """
 
-import enum
 import json
+import time
 from unittest.mock import MagicMock
 
 import pytest
-
-# Python 3.10 compat: StrEnum was added in 3.11
-if not hasattr(enum, "StrEnum"):
-
-    class _StrEnum(str, enum.Enum):
-        """Minimal StrEnum backport for Python 3.10."""
-
-    enum.StrEnum = _StrEnum  # type: ignore[attr-defined]
-
 from vllm.entrypoints.openai.chat_completion.protocol import (
     ChatCompletionRequest,
     ChatCompletionResponseStreamChoice,
@@ -90,28 +81,37 @@ def _make_audio_omni_output(
     request_id: str = "test-req",
     index: int = 0,
     num_prompt_tokens: int = 3,
+    stage_id: int | None = None,
+    replica_id: int | None = None,
+    audio_samples: int = 0,
 ) -> OmniRequestOutput:
     """Build an OmniRequestOutput for audio (no torch dependency)."""
+    completion = CompletionOutput(
+        index=index,
+        text="",
+        token_ids=[],
+        cumulative_logprob=0.0,
+        logprobs=None,
+        finish_reason="stop",
+        stop_reason=None,
+    )
+    if audio_samples > 0:
+        completion.multimodal_output = {
+            "audio": [MagicMock(numel=MagicMock(return_value=audio_samples))],
+            "sr": 24000,
+        }
     res = RequestOutput(
         request_id=request_id,
         prompt="test",
         prompt_token_ids=list(range(num_prompt_tokens)),
         prompt_logprobs=None,
-        outputs=[
-            CompletionOutput(
-                index=index,
-                text="",
-                token_ids=[],
-                cumulative_logprob=0.0,
-                logprobs=None,
-                finish_reason="stop",
-                stop_reason=None,
-            )
-        ],
+        outputs=[completion],
         finished=True,
     )
     return OmniRequestOutput(
         request_id=request_id,
+        stage_id=stage_id,
+        replica_id=replica_id,
         final_output_type="audio",
         request_output=res,
         finished=True,
@@ -331,6 +331,74 @@ async def test_single_modality_audio_only_one_stop():
     assert finish_reasons[-1] == "stop"
 
 
+@pytest.mark.parametrize(
+    ("output_replica_id", "pool_replica_id", "expected_replica_id", "pool_lookup"),
+    [
+        (7, None, 7, False),
+        (None, 5, 5, True),
+    ],
+)
+@pytest.mark.asyncio
+async def test_streaming_audio_metrics_resolve_replica_id(
+    monkeypatch,
+    output_replica_id,
+    pool_replica_id,
+    expected_replica_id,
+    pool_lookup,
+):
+    import vllm_omni.entrypoints.openai.serving_chat as serving_chat_mod
+    from vllm_omni.entrypoints.client_request_state import ClientRequestState
+
+    serving_chat = _build_serving_chat()
+    request = _make_request(modalities=["audio"])
+    req_state = ClientRequestState(
+        request_id="internal-req",
+        external_request_id="test-req",
+    )
+    req_state.request_arrival_ts = time.time() - 1.0
+    serving_chat.engine_client.request_states = {"internal-req": req_state}
+    serving_chat.engine_client.mod_metrics = object()
+    serving_chat.engine_client.engine = MagicMock()
+    serving_chat.engine_client.engine.stage_pools = [MagicMock(), MagicMock(), MagicMock()]
+    serving_chat.engine_client.engine.stage_pools[2].get_bound_replica_id.return_value = pool_replica_id
+
+    first_packet_calls = []
+    finalize_calls = []
+
+    def fake_observe_audio_first_packet(*args, **kwargs):
+        first_packet_calls.append(kwargs)
+
+    def fake_observe_audio_streaming_finalize(*args, **kwargs):
+        finalize_calls.append(kwargs)
+
+    monkeypatch.setattr(serving_chat_mod, "observe_audio_first_packet", fake_observe_audio_first_packet)
+    monkeypatch.setattr(serving_chat_mod, "observe_audio_streaming_finalize", fake_observe_audio_streaming_finalize)
+
+    async def result_generator():
+        yield _make_audio_omni_output(stage_id=2, replica_id=output_replica_id, audio_samples=2400)
+
+    await _collect_stream(
+        serving_chat.chat_completion_stream_generator(
+            request=request,
+            result_generator=result_generator(),
+            request_id="test-req",
+            model_name="test-model",
+            conversation=[],
+            tokenizer=MagicMock(),
+            request_metadata=MagicMock(),
+        )
+    )
+
+    if pool_lookup:
+        serving_chat.engine_client.engine.stage_pools[2].get_bound_replica_id.assert_called_once_with("internal-req")
+    else:
+        serving_chat.engine_client.engine.stage_pools[2].get_bound_replica_id.assert_not_called()
+    assert first_packet_calls[0]["stage_id"] == 2
+    assert first_packet_calls[0]["replica_id"] == expected_replica_id
+    assert finalize_calls[0]["stage_id"] == 2
+    assert finalize_calls[0]["replica_id"] == expected_replica_id
+
+
 # ---------------------------------------------------------------------------
 # Tests: fallback stop chunk when declared modality is not produced
 # ---------------------------------------------------------------------------
@@ -403,6 +471,90 @@ async def test_declared_modality_not_produced_text_finish_suppressed():
                 assert ch["finish_reason"] is None
 
 
+# ---------------------------------------------------------------------------
+# Tests: audio chunks that carry no waveform
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_audio_chunk_without_waveform_keeps_stream_alive():
+    """An audio message with no PCM must not break the stream.
+
+    ``_create_audio_choice`` used to return an ErrorResponse here, which the
+    stream generator then iterated as a list of choices; the pydantic model
+    yields (field, value) tuples, so the loop raised
+    ``AttributeError: 'tuple' object has no attribute 'finish_reason'``.
+    """
+    serving_chat = _build_serving_chat()
+    request = _make_request(modalities=["text", "audio"])
+
+    empty_audio = _make_audio_omni_output()
+    empty_audio.request_output.outputs[0].multimodal_output = {"audio": []}
+
+    def create_audio_choice(omni_res, role, request, stream=False):
+        return OmniOpenAIServingChat._create_audio_choice(serving_chat, omni_res, role, request, stream=stream)
+
+    serving_chat._create_audio_choice = create_audio_choice
+
+    async def result_generator():
+        yield _make_text_omni_output(text="hi", token_ids=[10], finish_reason=None)
+        yield _make_text_omni_output(text="!", token_ids=[11], finish_reason="stop")
+        yield empty_audio
+
+    raw_lines = await _collect_stream(
+        serving_chat.chat_completion_stream_generator(
+            request=request,
+            result_generator=result_generator(),
+            request_id="test-req",
+            model_name="test-model",
+            conversation=[],
+            tokenizer=MagicMock(),
+            request_metadata=MagicMock(),
+        )
+    )
+
+    assert not any("Error in chat completion stream generator" in line for line in raw_lines)
+    chunks = _parse_sse_chunks(raw_lines)
+    finish_reasons = [ch["finish_reason"] for c in chunks for ch in c.get("choices", [])]
+    assert finish_reasons.count("stop") == 1, f"Expected 1 stop, got {finish_reasons}"
+    assert finish_reasons[-1] == "stop"
+
+
+@pytest.mark.asyncio
+async def test_audio_choice_error_response_is_not_iterated_as_choices():
+    """Any ErrorResponse from the audio path is skipped, not iterated."""
+    from vllm.entrypoints.openai.engine.protocol import ErrorResponse
+
+    serving_chat = _build_serving_chat()
+    request = _make_request(modalities=["text", "audio"])
+
+    serving_chat._create_audio_choice = MagicMock(
+        side_effect=lambda omni_res, role, request, stream=False: serving_chat._create_error_response("boom")
+    )
+
+    async def result_generator():
+        yield _make_text_omni_output(text="hi", token_ids=[10], finish_reason="stop")
+        yield _make_audio_omni_output()
+
+    raw_lines = await _collect_stream(
+        serving_chat.chat_completion_stream_generator(
+            request=request,
+            result_generator=result_generator(),
+            request_id="test-req",
+            model_name="test-model",
+            conversation=[],
+            tokenizer=MagicMock(),
+            request_metadata=MagicMock(),
+        )
+    )
+
+    assert isinstance(serving_chat._create_error_response("boom"), ErrorResponse)
+    assert not any("AttributeError" in line for line in raw_lines)
+    chunks = _parse_sse_chunks(raw_lines)
+    finish_reasons = [ch["finish_reason"] for c in chunks for ch in c.get("choices", [])]
+    assert finish_reasons.count("stop") == 1, f"Expected 1 stop, got {finish_reasons}"
+
+
 # ---------------------------------------------------------------------------
 # Tests: voice/speaker parameter compatibility
 # ---------------------------------------------------------------------------
diff --git a/tests/entrypoints/test_utils.py b/tests/entrypoints/test_utils.py
index b48ed2d91..c6d8e0354 100644
--- a/tests/entrypoints/test_utils.py
+++ b/tests/entrypoints/test_utils.py
@@ -3,6 +3,8 @@
 import os
 from collections import Counter
 from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 import torch
@@ -13,6 +15,10 @@ from vllm_omni.config.yaml_util import create_config
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.engine.stage_init_utils import (
+    get_stage_connector_spec,
+    load_omni_transfer_config_for_model,
+)
 from vllm_omni.entrypoints.utils import (
     _convert_dataclasses_to_dict,
     _filter_dict_like_object,
@@ -313,15 +319,71 @@ class TestResolveModelConfigPath:
         assert result is not None
         assert "glm_image.yaml" in result
 
+    def test_uses_registry_default_deploy_when_hf_model_type_differs(
+        self,
+        mocker: MockerFixture,
+        tmp_path,
+    ):
+        from vllm_omni.config.stage_config import _DEPLOY_DIR as _REAL_DEPLOY_DIR
+        from vllm_omni.entrypoints import utils as utils_mod
+
+        hf_config = SimpleNamespace(
+            model_type="minicpmo",
+            architectures=["MiniCPMO"],
+            version="4.5",
+        )
+        model = "local/minicpmo-registry-default-test"
+        mocker.patch(
+            "vllm_omni.entrypoints.utils.get_config",
+            return_value=hf_config,
+        )
+        mocker.patch(
+            "vllm_omni.config.config_factory.get_config",
+            return_value=hf_config,
+        )
+        # A bare deploy/<hf_model_type>.yaml must not win over the registered
+        # pipeline default when HF model_type is not an OMNI_PIPELINES key.
+        (tmp_path / "minicpmo.yaml").write_text("stages: []\n", encoding="utf-8")
+        (tmp_path / "minicpmo_4_5.yaml").write_bytes((_REAL_DEPLOY_DIR / "minicpmo_4_5.yaml").read_bytes())
+        mocker.patch.object(utils_mod, "_DEPLOY_DIR", tmp_path)
+
+        result = resolve_model_config_path(model)
+
+        assert result is not None
+        assert Path(result).as_posix().endswith("minicpmo_4_5.yaml")
+        assert Path(result).name == "minicpmo_4_5.yaml"
+        transfer_config = load_omni_transfer_config_for_model(model, result)
+        assert transfer_config is not None
+
+        sender = get_stage_connector_spec(
+            omni_transfer_config=transfer_config,
+            stage_id=1,
+            async_chunk=True,
+        )
+        receiver = get_stage_connector_spec(
+            omni_transfer_config=transfer_config,
+            stage_id=2,
+            async_chunk=True,
+        )
+        assert sender["extra"]["role"] == "sender"
+        assert receiver["extra"]["role"] == "receiver"
+        assert sender["extra"]["connector_get_sleep_s"] == 0.01
+        assert sender["extra"]["connector_get_max_wait_first_chunk"] == 3000
+        assert sender["extra"]["connector_get_max_wait"] == 300
+
 
 class TestLoadAndResolveStageConfigs:
-    def test_load_and_resolve_with_kwargs(self):
+    def test_load_and_resolve_with_kwargs(self, mocker: MockerFixture):
         """Ensure that dtype survives default stage creation."""
         kwargs = {"dtype": torch.float32}
+        mocker.patch("vllm_omni.entrypoints.utils.resolve_model_config_path", return_value=None)
+        mocker.patch("vllm_omni.entrypoints.utils.load_stage_configs_from_model", return_value=([], None))
+
         config_path, stage_configs, _ = load_and_resolve_stage_configs(
             model="black-forest-labs/FLUX.2-klein-4B",
             stage_configs_path=None,
             kwargs=kwargs,
+            trust_remote_code=False,
             default_stage_cfg_factory=lambda: AsyncOmniEngine._create_default_diffusion_stage_cfg(kwargs),
         )
         assert config_path is None
@@ -356,10 +418,12 @@ class TestLoadAndResolveStageConfigs:
             model="dummy-model",
             stage_configs_path=str(deploy_path),
             kwargs={},
+            trust_remote_code=True,
         )
 
         load_stage_configs.assert_called_once_with(
             "dummy-model",
+            trust_remote_code=True,
             base_engine_args={},
             deploy_config_path=str(deploy_path),
             stage_overrides=None,
diff --git a/tests/examples/offline_inference/test_ltx2_cfg_parallel_parity.py b/tests/examples/offline_inference/test_ltx2_cfg_parallel_parity.py
deleted file mode 100644
index 757d906ec..000000000
--- a/tests/examples/offline_inference/test_ltx2_cfg_parallel_parity.py
+++ /dev/null
@@ -1,243 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import hashlib
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import numpy as np
-import pytest
-from PIL import Image
-
-from tests.helpers.mark import hardware_test
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-T2V_EXAMPLE = REPO_ROOT / "examples" / "offline_inference" / "text_to_video" / "text_to_video.py"
-I2V_EXAMPLE = REPO_ROOT / "examples" / "offline_inference" / "image_to_video" / "image_to_video.py"
-
-T2V_PROMPT = (
-    "At sunrise, a glowing paper lantern boat drifts through a narrow canal between mossy stone walls, "
-    "soft fog above the water, the camera slowly gliding forward as golden reflections shimmer across "
-    "the ripples, cinematic, realistic, highly detailed."
-)
-T2V_NEGATIVE_PROMPT = "worst quality, blurry, jittery motion, distorted, oversaturated, artifacts"
-I2V_PROMPT = "A cinematic dolly shot of a boat drifting on calm water at sunset"
-I2V_NEGATIVE_PROMPT = "worst quality, blurry, jittery motion"
-
-os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
-
-
-def _get_ltx2_model() -> str:
-    return "Lightricks/LTX-2"
-
-
-def _md5(path: Path) -> str:
-    digest = hashlib.md5(usedforsecurity=False)
-    with path.open("rb") as f:
-        for chunk in iter(lambda: f.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def _make_deterministic_test_image(path: Path) -> None:
-    """Create a deterministic 256x256 test image for I2V tests."""
-    rng = np.random.RandomState(42)
-    img = Image.fromarray(rng.randint(0, 255, (256, 256, 3), dtype=np.uint8))
-    img.save(path)
-
-
-def _run_and_check(cmd: list[str], env: dict, output_path: Path, expected_md5: str) -> None:
-    result = subprocess.run(cmd, cwd=REPO_ROOT, env=env, capture_output=True, text=True, check=False)
-    assert result.returncode == 0, (
-        f"Command failed (exit {result.returncode}).\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
-    )
-    generated_md5 = _md5(output_path)
-    assert generated_md5 == expected_md5, (
-        f"Unexpected output md5: {generated_md5} != {expected_md5}.\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
-    )
-
-
-# ── T2V tests ──
-
-
-@pytest.mark.full_model
-@pytest.mark.diffusion
-@pytest.mark.parallel
-@pytest.mark.slow
-@hardware_test(res={"cuda": "L4"}, num_cards=2)
-def test_ltx2_t2v_cfg_parallel(tmp_path: Path):
-    """T2V with CFG=4.0, cfg-parallel-size=2."""
-    output = tmp_path / "t2v_cfg4.mp4"
-    env = os.environ.copy()
-    env.setdefault("CUDA_VISIBLE_DEVICES", "0,1")
-    cmd = [
-        sys.executable,
-        str(T2V_EXAMPLE),
-        "--model",
-        _get_ltx2_model(),
-        "--prompt",
-        T2V_PROMPT,
-        "--negative-prompt",
-        T2V_NEGATIVE_PROMPT,
-        "--height",
-        "256",
-        "--width",
-        "256",
-        "--num-frames",
-        "145",
-        "--num-inference-steps",
-        "6",
-        "--guidance-scale",
-        "4.0",
-        "--frame-rate",
-        "24",
-        "--fps",
-        "24",
-        "--seed",
-        "42",
-        "--cfg-parallel-size",
-        "2",
-        "--enforce-eager",
-        "--output",
-        str(output),
-    ]
-    _run_and_check(cmd, env, output, expected_md5="08e606b9c522fee4b6f30cee8b77db40")
-
-
-@pytest.mark.full_model
-@pytest.mark.diffusion
-@pytest.mark.slow
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_ltx2_t2v_no_cfg(tmp_path: Path):
-    """T2V with CFG=1.0 (no classifier-free guidance)."""
-    output = tmp_path / "t2v_nocfg.mp4"
-    env = os.environ.copy()
-    env.setdefault("CUDA_VISIBLE_DEVICES", "0")
-    cmd = [
-        sys.executable,
-        str(T2V_EXAMPLE),
-        "--model",
-        _get_ltx2_model(),
-        "--prompt",
-        T2V_PROMPT,
-        "--height",
-        "256",
-        "--width",
-        "256",
-        "--num-frames",
-        "145",
-        "--num-inference-steps",
-        "6",
-        "--guidance-scale",
-        "1.0",
-        "--frame-rate",
-        "24",
-        "--fps",
-        "24",
-        "--seed",
-        "42",
-        "--enforce-eager",
-        "--output",
-        str(output),
-    ]
-    _run_and_check(cmd, env, output, expected_md5="a83994b94b6e67c54a524e0383c45ce8")
-
-
-# ── I2V tests ──
-
-
-@pytest.mark.full_model
-@pytest.mark.diffusion
-@pytest.mark.parallel
-@pytest.mark.slow
-@hardware_test(res={"cuda": "L4"}, num_cards=2)
-def test_ltx2_i2v_cfg_parallel(tmp_path: Path):
-    """I2V with CFG=4.0, cfg-parallel-size=2."""
-    test_image = tmp_path / "test_input.png"
-    _make_deterministic_test_image(test_image)
-    output = tmp_path / "i2v_cfg4.mp4"
-    env = os.environ.copy()
-    env.setdefault("CUDA_VISIBLE_DEVICES", "0,1")
-    cmd = [
-        sys.executable,
-        str(I2V_EXAMPLE),
-        "--model",
-        _get_ltx2_model(),
-        "--model-class-name",
-        "LTX2ImageToVideoPipeline",
-        "--image",
-        str(test_image),
-        "--prompt",
-        I2V_PROMPT,
-        "--negative-prompt",
-        I2V_NEGATIVE_PROMPT,
-        "--height",
-        "256",
-        "--width",
-        "256",
-        "--num-frames",
-        "73",
-        "--num-inference-steps",
-        "6",
-        "--guidance-scale",
-        "4.0",
-        "--frame-rate",
-        "24",
-        "--fps",
-        "24",
-        "--seed",
-        "42",
-        "--cfg-parallel-size",
-        "2",
-        "--enforce-eager",
-        "--output",
-        str(output),
-    ]
-    _run_and_check(cmd, env, output, expected_md5="aed7e56084b36373244d8f839b16d115")
-
-
-@pytest.mark.full_model
-@pytest.mark.diffusion
-@pytest.mark.slow
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_ltx2_i2v_no_cfg(tmp_path: Path):
-    """I2V with CFG=1.0 (no classifier-free guidance)."""
-    test_image = tmp_path / "test_input.png"
-    _make_deterministic_test_image(test_image)
-    output = tmp_path / "i2v_nocfg.mp4"
-    env = os.environ.copy()
-    env.setdefault("CUDA_VISIBLE_DEVICES", "0")
-    cmd = [
-        sys.executable,
-        str(I2V_EXAMPLE),
-        "--model",
-        _get_ltx2_model(),
-        "--model-class-name",
-        "LTX2ImageToVideoPipeline",
-        "--image",
-        str(test_image),
-        "--prompt",
-        I2V_PROMPT,
-        "--height",
-        "256",
-        "--width",
-        "256",
-        "--num-frames",
-        "73",
-        "--num-inference-steps",
-        "6",
-        "--guidance-scale",
-        "1.0",
-        "--frame-rate",
-        "24",
-        "--fps",
-        "24",
-        "--seed",
-        "42",
-        "--enforce-eager",
-        "--output",
-        str(output),
-    ]
-    _run_and_check(cmd, env, output, expected_md5="81b21ede12753e9e14a357a6c548b666")
diff --git a/tests/examples/offline_inference/test_text_to_image.py b/tests/examples/offline_inference/test_text_to_image.py
index 701f1a184..9b5597c3e 100644
--- a/tests/examples/offline_inference/test_text_to_image.py
+++ b/tests/examples/offline_inference/test_text_to_image.py
@@ -26,6 +26,9 @@ EXAMPLE_OUTPUT_SUBFOLDER = "example_offline_t2i"
 def _skip_readme_snippet(language: str, code: str, h2_title: str) -> tuple[bool, str]:
     if h2_title == "Web UI Demo":
         return True, f"README section '{h2_title}' is intentionally excluded for examples tests"
+    # Krea-2 Turbo/Raw README snippets currently fail in CI (more_cli_examples_006/007).
+    if "krea/Krea-2-Turbo" in code or "krea/Krea-2-Raw" in code:
+        return True, "Krea-2 README snippets are temporarily skipped (CI failures)"
     return False, ""
 
 
diff --git a/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py b/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
new file mode 100644
index 000000000..93fc4db38
--- /dev/null
+++ b/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
@@ -0,0 +1,211 @@
+import base64
+import importlib.util
+import sys
+import wave
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+DEMO_PATH = Path(__file__).resolve().parents[2] / "examples/online_serving/minicpmo/realtime_duplex_demo.py"
+
+
+def _load_demo_module():
+    spec = importlib.util.spec_from_file_location(
+        "minicpmo_realtime_duplex_simple_demo_test",
+        DEMO_PATH,
+    )
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_post_commit_decision_ignores_streaming_listens_before_commit_ack():
+    demo = _load_demo_module()
+    events = [
+        {"type": "session.created"},
+        {"type": "response.listen"},
+        {"type": "response.listen"},
+        {"type": "input_audio_buffer.committed"},
+    ]
+
+    commit_index = demo._input_committed_index(events, after_index=0)
+
+    assert commit_index == 3
+    assert demo._post_commit_model_decision(events, commit_index) is None
+
+
+def test_post_commit_decision_accepts_listen_after_commit_ack():
+    demo = _load_demo_module()
+    events = [
+        {"type": "response.listen"},
+        {"type": "input_audio_buffer.committed"},
+        {"type": "response.listen"},
+    ]
+
+    commit_index = demo._input_committed_index(events, after_index=0)
+
+    assert demo._post_commit_model_decision(events, commit_index) == "listen"
+
+
+def test_post_commit_decision_accepts_drained_speak_after_commit_ack():
+    demo = _load_demo_module()
+    events = [
+        {"type": "input_audio_buffer.committed"},
+        {"type": "response.created", "response": {"id": "resp-a"}},
+        {"type": "response.audio.delta", "response_id": "resp-a", "delta": "AAAA"},
+        {"type": "response.done", "response_id": "resp-a"},
+    ]
+
+    commit_index = demo._input_committed_index(events, after_index=0)
+
+    assert demo._post_commit_model_decision(events, commit_index) == "speak"
+
+
+def test_post_commit_decision_ignores_cancelled_response():
+    demo = _load_demo_module()
+    events = [
+        {"type": "input_audio_buffer.committed"},
+        {"type": "response.done", "response": {"status": "cancelled"}},
+    ]
+
+    commit_index = demo._input_committed_index(events, after_index=0)
+
+    assert demo._post_commit_model_decision(events, commit_index) is None
+
+
+def test_commit_ack_search_starts_after_stream_cursor():
+    demo = _load_demo_module()
+    events = [
+        {"type": "input_audio_buffer.committed"},
+        {"type": "response.listen"},
+        {"type": "input_audio_buffer.committed"},
+    ]
+
+    assert demo._input_committed_index(events, after_index=1) == 2
+
+
+def test_exact_model_unit_boundary_does_not_require_an_extra_decision():
+    demo = _load_demo_module()
+    unit_bytes = demo.PCM16_SAMPLE_RATE * demo.PCM16_BYTES_PER_SAMPLE
+
+    assert not demo._has_residual_model_unit(b"\0" * (unit_bytes * 6), chunk_period_ms=1000)
+
+
+def test_partial_model_unit_requires_a_post_commit_decision():
+    demo = _load_demo_module()
+    unit_bytes = demo.PCM16_SAMPLE_RATE * demo.PCM16_BYTES_PER_SAMPLE
+
+    assert demo._has_residual_model_unit(b"\0" * (unit_bytes * 6 + 512), chunk_period_ms=1000)
+
+
+def test_latest_streaming_decision_is_used_at_exact_boundary():
+    demo = _load_demo_module()
+    events = [
+        {"type": "response.listen"},
+        {"type": "response.listen"},
+        {"type": "input_audio_buffer.committed"},
+    ]
+
+    assert demo._latest_model_decision(events, after_index=0) == "listen"
+
+
+def test_ref_audio_data_url_encodes_explicit_wav(tmp_path):
+    demo = _load_demo_module()
+    ref = tmp_path / "ref.wav"
+    ref.write_bytes(b"RIFFfake")
+
+    assert demo._ref_audio_data_url(str(ref)) == "data:audio/wav;base64,UklGRmZha2U="
+    assert demo._ref_audio_data_url(None) is None
+
+
+def test_realtime_duplex_demo_requires_ref_audio(monkeypatch):
+    demo = _load_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "realtime_duplex_demo.py",
+            "--input-wav",
+            "input.wav",
+        ],
+    )
+
+    with pytest.raises(SystemExit):
+        demo.parse_args()
+
+
+def test_realtime_duplex_demo_accepts_explicit_ref_audio(monkeypatch):
+    demo = _load_demo_module()
+    monkeypatch.setattr(
+        demo.sys,
+        "argv",
+        [
+            "realtime_duplex_demo.py",
+            "--input-wav",
+            "input.wav",
+            "--ref-audio",
+            "ref.wav",
+        ],
+    )
+
+    args = demo.parse_args()
+
+    assert args.ref_audio == "ref.wav"
+
+
+def test_open_streaming_response_requires_post_commit_drain():
+    demo = _load_demo_module()
+
+    assert demo._response_in_progress([{"type": "response.created"}])
+    assert not demo._response_in_progress(
+        [
+            {"type": "response.created"},
+            {"type": "response.done"},
+        ]
+    )
+
+
+def test_streaming_output_writer_persists_audio_deltas_as_they_arrive(tmp_path, capsys):
+    demo = _load_demo_module()
+    writer = demo._StreamingOutputWriter(tmp_path)
+    first_pcm = b"\x01\x00\x02\x00"
+    second_pcm = b"\x03\x00"
+
+    writer.handle(
+        {
+            "type": "response.audio.delta",
+            "response_id": "resp-a",
+            "delta": base64.b64encode(first_pcm).decode("ascii"),
+            "sample_rate_hz": 24_000,
+        }
+    )
+    writer.handle(
+        {
+            "type": "response.audio_transcript.delta",
+            "response_id": "resp-a",
+            "delta": "你好",
+        }
+    )
+    writer.handle(
+        {
+            "type": "response.audio.delta",
+            "response_id": "resp-a",
+            "delta": base64.b64encode(second_pcm).decode("ascii"),
+            "sample_rate_hz": 24_000,
+        }
+    )
+
+    assert (tmp_path / "output.pcm").read_bytes() == first_pcm + second_pcm
+    chunk_paths = sorted((tmp_path / "audio_chunks").glob("*.wav"))
+    assert [path.name for path in chunk_paths] == ["chunk_0001.wav", "chunk_0002.wav"]
+    with wave.open(str(chunk_paths[0]), "rb") as chunk_wav:
+        assert chunk_wav.getframerate() == 24_000
+        assert chunk_wav.readframes(chunk_wav.getnframes()) == first_pcm
+    assert writer.audio_chunk_paths == chunk_paths
+    stderr = capsys.readouterr().err
+    assert "audio chunk 1" in stderr
+    assert "你好" in stderr
diff --git a/tests/examples/test_minicpmo_realtime_web_server.py b/tests/examples/test_minicpmo_realtime_web_server.py
new file mode 100644
index 000000000..6c35760a7
--- /dev/null
+++ b/tests/examples/test_minicpmo_realtime_web_server.py
@@ -0,0 +1,99 @@
+import hashlib
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+SERVER_PATH = Path(__file__).resolve().parents[2] / "examples/online_serving/minicpmo/realtime_web/server.py"
+spec = importlib.util.spec_from_file_location(
+    "minicpmo_realtime_web_server_test",
+    SERVER_PATH,
+)
+assert spec is not None and spec.loader is not None
+server = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = server
+spec.loader.exec_module(server)
+
+APP_DIR = server.APP_DIR
+STATIC_DIR = server.STATIC_DIR
+_join_ws_url = server._join_ws_url
+build_app = server.build_app
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_join_ws_url_preserves_realtime_query():
+    assert (
+        _join_ws_url(
+            "ws://127.0.0.1:8099/",
+            "/v1/realtime",
+            "duplex=1&model=openbmb%2FMiniCPM-o-4_5",
+        )
+        == "ws://127.0.0.1:8099/v1/realtime?duplex=1&model=openbmb%2FMiniCPM-o-4_5"
+    )
+
+
+def test_build_app_serves_health_and_injected_client_config():
+    app = build_app(
+        ws_backend="ws://127.0.0.1:9001",
+        model="local/MiniCPM-o-4_5",
+    )
+    client = TestClient(app)
+
+    health = client.get("/healthz")
+    assert health.status_code == 200
+    assert health.text == "ok"
+
+    index = client.get("/")
+    assert index.status_code == 200
+    assert '"model": "local/MiniCPM-o-4_5"' in index.text
+    assert '"realtimePath": "v1/realtime"' in index.text
+    assert "__FULL_DUPLEX_CONFIG__" not in index.text
+
+
+def test_build_app_injects_public_realtime_url():
+    public_realtime_url = "wss://proxy.example.test/backend/v1/realtime"
+    app = build_app(
+        ws_backend="ws://127.0.0.1:9001",
+        public_realtime_url=public_realtime_url,
+    )
+    client = TestClient(app)
+
+    index = client.get("/")
+
+    assert index.status_code == 200
+    assert f'"realtimePath": "{public_realtime_url}"' in index.text
+
+
+def test_build_app_versions_client_bundle_and_disables_index_cache():
+    client = TestClient(build_app())
+    expected_version_hash = hashlib.sha256()
+    for asset_name in ("app.js", "pcm_worklet.js", "playback_worklet.js"):
+        expected_version_hash.update((STATIC_DIR / asset_name).read_bytes())
+    expected_version = expected_version_hash.hexdigest()[:12]
+
+    assert (APP_DIR / "index.html").is_file()
+    assert (STATIC_DIR / "app.js").is_file()
+    assert not (APP_DIR.parent / "static").exists()
+    assert not (STATIC_DIR / "index.html").exists()
+
+    index = client.get("/")
+
+    assert index.status_code == 200
+    assert f'src="static/app.js?v={expected_version}"' in index.text
+    assert index.headers["cache-control"] == "no-store"
+
+
+def test_build_app_exposes_realtime_websocket_and_static_assets():
+    app = build_app()
+    paths = {route.path for route in app.routes}
+
+    assert "/v1/realtime" in paths
+    assert "/static" in paths
+
+    client = TestClient(app)
+    assert client.get("/static/app.js").status_code == 200
+    assert client.get("/static/pcm_worklet.js").status_code == 200
+    assert client.get("/static/playback_worklet.js").status_code == 200
diff --git a/tests/examples/test_minicpmo_realtime_web_static.py b/tests/examples/test_minicpmo_realtime_web_static.py
new file mode 100644
index 000000000..00859dabb
--- /dev/null
+++ b/tests/examples/test_minicpmo_realtime_web_static.py
@@ -0,0 +1,274 @@
+import re
+import shutil
+import subprocess
+import textwrap
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2] / "examples" / "online_serving" / "minicpmo" / "realtime_web"
+APP_ROOT = ROOT / "app"
+STATIC_ROOT = APP_ROOT / "static"
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_page_exposes_focused_call_conversation_and_log_surfaces():
+    html = (APP_ROOT / "index.html").read_text(encoding="utf-8")
+
+    assert 'id="callButton"' in html
+    assert 'id="muteButton"' in html
+    assert 'id="connectionState"' in html
+    assert 'id="modelState"' in html
+    assert 'id="conversation"' in html
+    assert 'id="eventLog"' in html
+    assert "<details" in html
+    assert "Automatic barge-in" not in html
+    assert "Server VAD" not in html
+
+
+def test_client_uses_proxy_relative_realtime_url_and_model_policy_session():
+    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+
+    assert "new URL(config.realtimePath, window.location.href)" in source
+    assert "url.protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'" in source
+    assert "url.searchParams.set('autostart', '0')" in source
+    assert "url.searchParams.set('minicpmo45_native_duplex', '1')" in source
+    assert "auto_response: true" in source
+    assert "input_audio_buffer.append" in source
+    assert "input_audio_buffer.commit" not in source
+    assert "playback.ack" in source
+    assert "event.event || event" in source
+    assert "response.audio.delta" in source
+    assert "response.audio_transcript.delta" in source
+    assert "conversation.item.input_audio_transcription" in source
+    assert "force_barge_in" not in source
+    assert "server_vad" not in source
+    assert "type: 'response.create'" not in source
+    assert 'type: "response.create"' not in source
+
+
+def test_web_server_requires_ref_audio_for_audio_output_session():
+    source = (ROOT / "server.py").read_text(encoding="utf-8")
+
+    ref_audio_arg = re.search(
+        r"parser\.add_argument\(\s*\"--ref-audio\",(?P<body>.*?)\n\s*\)",
+        source,
+        re.DOTALL,
+    )
+    assert ref_audio_arg is not None
+    assert "required=True" in ref_audio_arg.group("body")
+    assert "Optional reference voice" not in ref_audio_arg.group("body")
+
+
+def test_client_sends_ref_audio_in_realtime_session_contract():
+    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+
+    assert "if (config.refAudio) session.ref_audio = config.refAudio;" in source
+    assert "extraBody.ref_audio" not in source
+
+
+def test_client_has_transactional_cleanup_and_visible_event_logging():
+    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+
+    assert "async function stopSession" in source
+    assert "type: 'session.close'" in source
+    assert "waitForSessionClosed" in source
+    assert "SESSION_CLOSE_TIMEOUT_MS" in source
+    assert "case 'session.closed':" in source
+    assert "track.stop()" in source
+    assert "clearInterval(sendTimer)" in source
+    assert "appendEventLog(event)" in source
+    assert "stopSession({ terminal: false })" in source
+
+
+def test_client_keeps_microphone_upload_active_during_assistant_playback():
+    source = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+    upload_gate = re.search(r"function microphoneUploadEnabled\(\) \{(?P<body>.*?)\n  \}", source, re.DOTALL)
+    begin_assistant = re.search(r"function beginAssistant\(responseId\) \{(?P<body>.*?)\n  \}", source, re.DOTALL)
+
+    assert upload_gate is not None
+    assert "return running && !muted;" in upload_gate.group("body")
+    assert "assistantActive" not in upload_gate.group("body")
+    assert begin_assistant is not None
+    assert "pendingCapture = []" not in begin_assistant.group("body")
+
+
+def test_audio_worklets_define_capture_and_playback_processors():
+    capture = (STATIC_ROOT / "pcm_worklet.js").read_text(encoding="utf-8")
+    playback = (STATIC_ROOT / "playback_worklet.js").read_text(encoding="utf-8")
+
+    assert "registerProcessor('fullduplex-pcm-capture'" in capture
+    assert "Int16Array" in capture
+    assert "registerProcessor('fullduplex-pcm-playback'" in playback
+    assert "playback-drained" in playback
+    assert "clear" in playback
+
+
+def test_audio_worklet_urls_use_the_static_asset_version():
+    server = (ROOT / "server.py").read_text(encoding="utf-8")
+    app = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+
+    assert '"appVersion": app_version' in server
+    assert 'STATIC_DIR / "playback_worklet.js"' in server
+    assert 'STATIC_DIR / "pcm_worklet.js"' in server
+    assert "staticAssetUrl('static/playback_worklet.js')" in app
+    assert "staticAssetUrl('static/pcm_worklet.js')" in app
+
+
+def test_playback_worklet_buffers_first_400ms_and_reports_underruns():
+    app = (STATIC_ROOT / "app.js").read_text(encoding="utf-8")
+    playback = (STATIC_ROOT / "playback_worklet.js").read_text(encoding="utf-8")
+
+    assert "INITIAL_PLAYBACK_BUFFER_MS = 400" in app
+    assert "initialBufferMs" in app
+    assert "responseId" in app
+    assert "playback-underrun" in app
+    assert "underrunMs" in app
+    assert "initialBufferFrames" in playback
+    assert "playback-underrun" in playback
+    assert "underrunFrames" in playback
+    assert "underrunMs" in playback
+
+
+def test_playback_worklet_waits_before_playing_and_rebuffers_after_underrun():
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("node is required for the AudioWorklet regression test")
+
+    script = textwrap.dedent(
+        """
+        const fs = require('fs');
+        const vm = require('vm');
+
+        global.sampleRate = 1000;
+        global.AudioWorkletProcessor = class {
+          constructor() {
+            this.port = { onmessage: null, postMessage: () => {} };
+          }
+        };
+        let Processor = null;
+        global.registerProcessor = (_name, processor) => { Processor = processor; };
+        vm.runInThisContext(fs.readFileSync(process.argv[1], 'utf8'));
+
+        const processor = new Processor();
+        const render = () => {
+          const output = new Float32Array(100);
+          processor.process([], [[output]]);
+          return output;
+        };
+        const assert = (condition, message) => {
+          if (!condition) throw new Error(message);
+        };
+
+        const first = new Int16Array(150);
+        first.fill(16384);
+        processor.handleMessage({
+          type: 'audio',
+          pcm: first,
+          responseId: 'response-1',
+          initialBufferMs: 400,
+        });
+        assert(!processor.started, 'large first delta must not bypass wall-clock prebuffer');
+        assert(render().every((sample) => sample === 0), 'first prebuffer render must be silent');
+        assert(render().every((sample) => sample === 0), 'second prebuffer render must be silent');
+        assert(render().every((sample) => sample === 0), 'third prebuffer render must be silent');
+        assert(render().every((sample) => sample === 0), 'fourth prebuffer render must be silent');
+        const firstPlayback = render();
+        assert(firstPlayback.some((sample) => sample !== 0), 'playback must start after prebuffer');
+
+        const underrun = render();
+        assert(!processor.started, 'an empty queue must return to buffering');
+        assert(underrun[underrun.length - 1] === 0, 'underrun boundary must fade to zero');
+
+        const resumed = new Int16Array(300);
+        resumed.fill(8192);
+        processor.handleMessage({
+          type: 'audio',
+          pcm: resumed,
+          responseId: 'response-1',
+          initialBufferMs: 400,
+        });
+        assert(render().every((sample) => sample === 0), 'resume must rebuild jitter buffer');
+        assert(render().every((sample) => sample === 0), 'resume must keep rebuilding jitter buffer');
+        assert(render().every((sample) => sample === 0), 'resume must keep waiting');
+        assert(render().every((sample) => sample === 0), 'resume must wait the full buffer interval');
+        const resumedPlayback = render();
+        assert(resumedPlayback.some((sample) => sample !== 0), 'playback must resume after rebuffer');
+        assert(
+          Math.abs(resumedPlayback[0]) < Math.abs(resumedPlayback[50]),
+          'resumed playback must fade in instead of jumping from silence',
+        );
+        """
+    )
+    subprocess.run(
+        [node, "-e", script, str(STATIC_ROOT / "playback_worklet.js")],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def test_playback_worklet_fades_terminal_drain_to_zero():
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("node is required for the AudioWorklet regression test")
+
+    script = textwrap.dedent(
+        """
+        const fs = require('fs');
+        const vm = require('vm');
+
+        global.sampleRate = 1000;
+        const messages = [];
+        global.AudioWorkletProcessor = class {
+          constructor() {
+            this.port = {
+              onmessage: null,
+              postMessage: (message) => messages.push(message),
+            };
+          }
+        };
+        let Processor = null;
+        global.registerProcessor = (_name, processor) => { Processor = processor; };
+        vm.runInThisContext(fs.readFileSync(process.argv[1], 'utf8'));
+
+        const processor = new Processor();
+        const pcm = new Int16Array(100);
+        pcm.fill(16384);
+        processor.handleMessage({
+          type: 'audio',
+          pcm,
+          responseId: 'response-terminal',
+          initialBufferMs: 400,
+        });
+        processor.handleMessage({
+          type: 'drain',
+          responseId: 'response-terminal',
+        });
+
+        const output = new Float32Array(100);
+        processor.process([], [[output]]);
+        const assert = (condition, message) => {
+          if (!condition) throw new Error(message);
+        };
+
+        assert(output.some((sample) => sample !== 0), 'terminal audio must still play');
+        assert(output[output.length - 1] === 0, 'terminal drain must fade the final sample to zero');
+        const tail = Array.from(output.slice(-5), Math.abs);
+        assert(
+          tail.every((sample, index) => index === 0 || sample <= tail[index - 1]),
+          'terminal drain fade must decrease monotonically',
+        );
+        assert(
+          messages.filter((message) => message.type === 'playback-drained').length === 1,
+          'terminal drain must be reported exactly once after playback',
+        );
+        """
+    )
+    subprocess.run(
+        [node, "-e", script, str(STATIC_ROOT / "playback_worklet.js")],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
diff --git a/tests/gr00t/openpi_client_helper.py b/tests/gr00t/openpi_client_helper.py
deleted file mode 100644
index e5943ca33..000000000
--- a/tests/gr00t/openpi_client_helper.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from dataclasses import dataclass
-from typing import Any
-
-import numpy as np
-
-try:
-    import websockets.sync.client as websockets_client
-except ImportError:  # pragma: no cover - optional e2e dependency
-    websockets_client = None
-
-try:
-    from openpi_client import msgpack_numpy
-except ImportError:  # pragma: no cover - optional e2e dependency
-    msgpack_numpy = None
-
-PING_INTERVAL_SECS = 300
-PING_TIMEOUT_SECS = 3600
-DEFAULT_HOST = "127.0.0.1"
-DEFAULT_PORT = 8000
-DEFAULT_PATH = "/v1/realtime/robot/openpi"
-DEFAULT_SESSION_ID = "gr00t-smoke"
-ACTION_KEYS = {"eef_9d", "gripper_position", "joint_position"}
-LANGUAGE_KEY = "annotation.language.language_instruction"
-
-
-def _identity_eef_9d_state() -> np.ndarray:
-    state = np.zeros((1, 1, 9), dtype=np.float32)
-    state[..., 3:] = np.array([1, 0, 0, 0, 1, 0], dtype=np.float32)
-    return state
-
-
-def require_dependencies() -> None:
-    missing = []
-    if websockets_client is None:
-        missing.append("websockets")
-    if msgpack_numpy is None:
-        missing.append("openpi-client")
-    if missing:
-        raise ModuleNotFoundError(f"GR00T OpenPI test dependencies are missing: {', '.join(missing)}")
-
-
-@dataclass(frozen=True)
-class Gr00tServerMetadata:
-    action_horizon: int
-    action_keys: set[str]
-    embodiment_tag: str
-    needs_session_id: bool
-
-    @classmethod
-    def from_dict(cls, payload: dict[str, Any]):
-        required_keys = ("action_horizon", "action_keys", "embodiment_tag", "needs_session_id")
-        missing_keys = [key for key in required_keys if key not in payload]
-        if missing_keys:
-            raise ValueError(f"Missing GR00T metadata keys: {missing_keys}")
-
-        return cls(
-            action_horizon=int(payload["action_horizon"]),
-            action_keys={str(key) for key in payload["action_keys"]},
-            embodiment_tag=str(payload["embodiment_tag"]),
-            needs_session_id=bool(payload["needs_session_id"]),
-        )
-
-
-class OpenPIWebsocketClient:
-    def __init__(
-        self,
-        *,
-        host: str = DEFAULT_HOST,
-        port: int = DEFAULT_PORT,
-        path: str = DEFAULT_PATH,
-    ) -> None:
-        require_dependencies()
-        self._uri = f"ws://{host}:{port}{path}"
-        self._packer = msgpack_numpy.Packer()
-        self._ws, self._server_metadata = self._connect()
-
-    def _connect(self):
-        conn = websockets_client.connect(
-            self._uri,
-            compression=None,
-            max_size=None,
-            ping_interval=PING_INTERVAL_SECS,
-            ping_timeout=PING_TIMEOUT_SECS,
-        )
-        metadata = msgpack_numpy.unpackb(conn.recv())
-        if not isinstance(metadata, dict):
-            raise TypeError(f"Expected dict metadata from server, got {type(metadata)!r}")
-        return conn, metadata
-
-    def get_server_metadata(self) -> dict[str, Any]:
-        return dict(self._server_metadata)
-
-    def infer(self, obs: dict[str, Any]) -> dict[str, np.ndarray]:
-        payload = dict(obs)
-        payload["endpoint"] = "infer"
-        self._ws.send(self._packer.pack(payload))
-        response = msgpack_numpy.unpackb(self._ws.recv())
-        if isinstance(response, dict) and response.get("type") == "error":
-            raise RuntimeError(f"Inference failed: {response['message']}")
-        if not isinstance(response, dict):
-            raise RuntimeError(f"Expected dict actions from GR00T OpenPI endpoint, got {type(response)!r}")
-        return {str(key): np.asarray(value, dtype=np.float32) for key, value in response.items()}
-
-    def reset(self, reset_info: dict[str, Any] | None = None) -> str:
-        payload = dict(reset_info or {})
-        payload["endpoint"] = "reset"
-        self._ws.send(self._packer.pack(payload))
-        response = msgpack_numpy.unpackb(self._ws.recv())
-        if not isinstance(response, dict) or response.get("status") != "reset successful":
-            raise RuntimeError(f"Unexpected reset response: {response!r}")
-        return str(response["status"])
-
-    def close(self) -> None:
-        self._ws.close()
-
-
-def build_droid_observation(*, session_id: str = DEFAULT_SESSION_ID) -> dict[str, Any]:
-    return {
-        "session_id": session_id,
-        "video": {
-            "exterior_image_1_left": np.zeros((1, 2, 256, 256, 3), dtype=np.uint8),
-            "wrist_image_left": np.zeros((1, 2, 256, 256, 3), dtype=np.uint8),
-        },
-        "state": {
-            "eef_9d": _identity_eef_9d_state(),
-            "gripper_position": np.zeros((1, 1, 1), dtype=np.float32),
-            "joint_position": np.zeros((1, 1, 7), dtype=np.float32),
-        },
-        "language": {LANGUAGE_KEY: [["pick up the object"]]},
-    }
-
-
-def run_policy_session(
-    *,
-    host: str = DEFAULT_HOST,
-    port: int = DEFAULT_PORT,
-    path: str = DEFAULT_PATH,
-    session_id: str = DEFAULT_SESSION_ID,
-) -> dict[str, Any]:
-    client = OpenPIWebsocketClient(host=host, port=port, path=path)
-    try:
-        metadata = client.get_server_metadata()
-        actions = client.infer(build_droid_observation(session_id=session_id))
-        reset_status = client.reset({})
-        return {
-            "metadata": metadata,
-            "actions": actions,
-            "reset_status": reset_status,
-            "session_id": session_id,
-        }
-    finally:
-        client.close()
-
-
-def validate_session_result(result: dict[str, Any]) -> None:
-    metadata = Gr00tServerMetadata.from_dict(result["metadata"])
-    if metadata.embodiment_tag != "OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT":
-        raise AssertionError(f"Unexpected embodiment_tag: {metadata.embodiment_tag}")
-    if not metadata.needs_session_id:
-        raise AssertionError("GR00T test expects needs_session_id metadata")
-    if metadata.action_keys != ACTION_KEYS:
-        raise AssertionError(f"Unexpected action keys: {metadata.action_keys}")
-    if result["reset_status"] != "reset successful":
-        raise AssertionError(f"Unexpected reset status: {result['reset_status']!r}")
-
-    actions = result["actions"]
-    if set(actions) != ACTION_KEYS:
-        raise AssertionError(f"Unexpected action keys: {set(actions)}")
-    expected_shapes = {
-        "eef_9d": (1, metadata.action_horizon, 9),
-        "gripper_position": (1, metadata.action_horizon, 1),
-        "joint_position": (1, metadata.action_horizon, 7),
-    }
-    for key, expected_shape in expected_shapes.items():
-        if actions[key].shape != expected_shape:
-            raise AssertionError(f"Action {key} shape mismatch: expected {expected_shape}, got {actions[key].shape}")
-        if actions[key].dtype != np.float32:
-            raise AssertionError(f"Action {key} dtype mismatch: expected float32, got {actions[key].dtype}")
-        if not np.isfinite(actions[key]).all():
-            raise AssertionError(f"Action {key} contains non-finite values")
diff --git a/tests/helpers/__init__.py b/tests/helpers/__init__.py
index 04d51fb90..9929beab8 100644
--- a/tests/helpers/__init__.py
+++ b/tests/helpers/__init__.py
@@ -1,10 +1,11 @@
 """Shared, importable test helper utilities.
 
 Submodules (``assertions``, ``env``, ``media``, ``runtime``, …) are imported
-explicitly by callers. Avoid star-importing everything here: that ran before
-refactor only inside the old monolithic ``conftest``; a greedy ``__init__``
-changes import order and can affect in-process Omni (``OmniRunner`` / offline
-e2e) vs subprocess-based ``OmniServer`` tests.
+explicitly by callers. Unit tests for these helpers live under ``tests/``.
+Avoid star-importing everything here: that ran before refactor only inside the
+old monolithic ``conftest``; a greedy ``__init__`` changes import order and can
+affect in-process Omni (``OmniRunner`` / offline e2e) vs subprocess-based
+``OmniServer`` tests.
 """
 
 import pytest
diff --git a/tests/helpers/assertions.py b/tests/helpers/assertions.py
index 11e86ed8c..9fe34f9b5 100644
--- a/tests/helpers/assertions.py
+++ b/tests/helpers/assertions.py
@@ -527,7 +527,7 @@ def _resolve_audio_transcript(
     audio_bytes = getattr(response, "audio_bytes", None)
     if not audio_bytes:
         return None
-    return convert_audio_bytes_to_text(audio_bytes)
+    return convert_audio_bytes_to_text(audio_bytes, language=request_config.get("transcript_language"))
 
 
 def assert_omni_response(response: Any, request_config: dict[str, Any], run_level):
@@ -632,6 +632,7 @@ def _assert_transcript_matches(
     *,
     threshold: float,
     escalation_model: str | None = None,
+    language: str | None = None,
 ) -> None:
     """Assert spoken audio matches ``expected_text``.
 
@@ -647,7 +648,8 @@ def _assert_transcript_matches(
     clip is re-transcribed with that stronger ASR and the assertion is decided on
     its verdict -- so a weak whisper-``small`` mishear on a short clip does not
     flake the gate, while a genuine model artifact still fails (the strong ASR
-    mismatches too).
+    mismatches too). ``language`` applies to that escalated pass too, so a request
+    that pins a language does not silently fall back to auto-detection on retry.
     """
     expected = str(expected_text).strip().lower()
     similarity = cosine_similarity_text(transcript.strip().lower(), expected)
@@ -664,7 +666,7 @@ def _assert_transcript_matches(
             f"whisper-small below threshold ({similarity:.2f} <= {threshold}); "
             f"escalating to whisper-{escalation_model} to rule out an ASR mishear"
         )
-        strong_transcript = convert_audio_bytes_to_text(audio_bytes, model_size=escalation_model)
+        strong_transcript = convert_audio_bytes_to_text(audio_bytes, model_size=escalation_model, language=language)
         strong_similarity = cosine_similarity_text(strong_transcript.strip().lower(), expected)
         print(
             f"audio content (whisper-{escalation_model}): {strong_transcript}\n"
@@ -741,6 +743,7 @@ def assert_audio_speech_response(response: Any, request_config: dict[str, Any],
                     expected_text,
                     threshold=0.9,
                     escalation_model=request_config.get("transcript_escalation_model"),
+                    language=request_config.get("transcript_language"),
                 )
         _assert_preset_voice_gender_from_audio(
             response.audio_bytes,
diff --git a/tests/helpers/env.py b/tests/helpers/env.py
index dcf2484cd..39cec30e7 100644
--- a/tests/helpers/env.py
+++ b/tests/helpers/env.py
@@ -27,6 +27,32 @@ def get_physical_device_indices(devices):
     return [index_mapping[i] for i in devices if i in index_mapping]
 
 
+def pick_least_used_device_indices(num_devices: int) -> list[int]:
+    """Return physical device indices for the least-used accelerators.
+
+    Args:
+        num_devices: Number of device indices to return.
+
+    Returns:
+        Physical device indices sorted from least to most used memory.
+    """
+    if num_devices <= 0:
+        raise ValueError(f"num_devices must be positive, got {num_devices}.")
+
+    logical_count = current_omni_platform.get_device_count()
+    if logical_count < num_devices:
+        raise RuntimeError(f"Need {num_devices} devices, but only {logical_count} are available.")
+
+    device_usage: list[tuple[int, int]] = []
+    for device_index in range(logical_count):
+        with current_omni_platform.device(device_index):
+            free_bytes, total_bytes = current_omni_platform.get_device_memory()
+        device_usage.append((total_bytes - free_bytes, device_index))
+    device_usage.sort()
+    logical_indices = [device_index for _, device_index in device_usage[:num_devices]]
+    return get_physical_device_indices(logical_indices)
+
+
 def wait_for_gpu_memory_to_clear(
     *,
     devices: list[int],
@@ -264,6 +290,7 @@ class DeviceMemoryMonitor:
 __all__ = [
     "DeviceMemoryMonitor",
     "get_physical_device_indices",
+    "pick_least_used_device_indices",
     "run_post_test_cleanup",
     "run_pre_test_cleanup",
     "wait_for_gpu_memory_to_clear",
diff --git a/tests/helpers/mark.py b/tests/helpers/mark.py
index 3475a0012..676732a8e 100644
--- a/tests/helpers/mark.py
+++ b/tests/helpers/mark.py
@@ -2,10 +2,69 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Pytest marks and decorators for hardware / resource selection (CUDA, ROCm, …)."""
 
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
 import pytest
 from vllm.platforms import current_platform
 
-# Re-exported from tests.helpers.env (GPU wait + DeviceMemoryMonitor).
+# Marker description tag in ``pyproject.toml`` ``tool.pytest.ini_options.markers``.
+# Example: ``"H100: [hardware-resource] Tests that require H100 GPU"``.
+_HARDWARE_RESOURCE_MARKER_TAG = "[hardware-resource]"
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def _load_pyproject() -> dict:
+    path = _repo_root() / "pyproject.toml"
+    try:
+        try:
+            import tomllib
+        except ModuleNotFoundError:  # Python < 3.11
+            import tomli as tomllib  # type: ignore[no-redef]
+
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except Exception:
+        return {}
+
+
+@lru_cache(maxsize=1)
+def get_hardware_mark_list() -> frozenset[str]:
+    """Return hardware SKU marker names from ``pyproject.toml``.
+
+    A marker is treated as a hardware resource marker when its description
+    contains the ``[hardware-resource]`` tag, e.g.::
+
+        "H100: [hardware-resource] Tests that require H100 GPU"
+    """
+    data = _load_pyproject()
+    entries = data.get("tool", {}).get("pytest", {}).get("ini_options", {}).get("markers", [])
+    if not entries:
+        # Fallback when TOML parsing fails: scan tagged marker lines.
+        text = (_repo_root() / "pyproject.toml").read_text(encoding="utf-8")
+        return frozenset(
+            re.findall(
+                rf'^\s*"([A-Za-z0-9_]+)\s*:\s*{re.escape(_HARDWARE_RESOURCE_MARKER_TAG)}',
+                text,
+                flags=re.M,
+            )
+        )
+
+    names: set[str] = set()
+    for entry in entries:
+        text = str(entry)
+        if _HARDWARE_RESOURCE_MARKER_TAG not in text:
+            continue
+        name = text.split(":", 1)[0].strip()
+        if name:
+            names.add(name)
+    return frozenset(names)
 
 
 def cuda_marks(*, res: str, num_cards: int):
diff --git a/tests/helpers/media.py b/tests/helpers/media.py
index e50a9f001..93e136f57 100644
--- a/tests/helpers/media.py
+++ b/tests/helpers/media.py
@@ -529,6 +529,26 @@ def decode_b64_image(b64: str):
     return img
 
 
+def concat_audio(audio_val) -> np.ndarray:
+    """Flatten a multimodal audio payload to mono float32 samples.
+
+    Engines return ``multimodal_output["audio"]`` as a tensor, a list of
+    per-chunk tensors (streaming decoders), or an array-like; concatenate
+    in order and return a 1-D ``np.float32`` array (empty when a list has
+    no tensors).
+    """
+    import torch
+
+    if isinstance(audio_val, list):
+        tensors = [t.detach().cpu().float().reshape(-1) for t in audio_val if isinstance(t, torch.Tensor)]
+        if not tensors:
+            return np.zeros((0,), dtype=np.float32)
+        return torch.cat(tensors, dim=-1).numpy().astype(np.float32, copy=False)
+    if isinstance(audio_val, torch.Tensor):
+        return audio_val.detach().cpu().float().reshape(-1).numpy()
+    return np.asarray(audio_val, dtype=np.float32).reshape(-1)
+
+
 def preprocess_text(text):
     import opencc
 
@@ -632,7 +652,9 @@ def _serialize_whisper_model_download(model_size: str = "small"):
         f.close()
 
 
-def _whisper_transcribe_in_current_process(output_path: str, model_size: str = "small") -> str:
+def _whisper_transcribe_in_current_process(
+    output_path: str, model_size: str = "small", language: str | None = None
+) -> str:
     import whisper
 
     device_index = None
@@ -664,6 +686,9 @@ def _whisper_transcribe_in_current_process(output_path: str, model_size: str = "
             temperature=0.0,
             word_timestamps=True,
             condition_on_previous_text=False,
+            # None keeps whisper's auto-detection. Do not default this to a
+            # language: callers include non-English audio tests.
+            language=language,
         )["text"]
     finally:
         del model
@@ -674,15 +699,15 @@ def _whisper_transcribe_in_current_process(output_path: str, model_size: str = "
     return text or ""
 
 
-def convert_audio_file_to_text(output_path: str, model_size: str = "small") -> str:
+def convert_audio_file_to_text(output_path: str, model_size: str = "small", language: str | None = None) -> str:
     """Convert an audio file to text in an isolated subprocess."""
     ctx = multiprocessing.get_context("spawn")
     with concurrent.futures.ProcessPoolExecutor(max_workers=1, mp_context=ctx) as executor:
-        future = executor.submit(_whisper_transcribe_in_current_process, output_path, model_size)
+        future = executor.submit(_whisper_transcribe_in_current_process, output_path, model_size, language)
         return future.result()
 
 
-def convert_audio_bytes_to_text(raw_bytes: bytes, model_size: str = "small") -> str:
+def convert_audio_bytes_to_text(raw_bytes: bytes, model_size: str = "small", language: str | None = None) -> str:
     output_fd, output_path = tempfile.mkstemp(prefix="test_", suffix=".wav")
     os.close(output_fd)
     if os.environ.get("VLLM_OMNI_KEEP_REQUEST_MEDIA", "").lower() not in ("1", "true", "yes"):
@@ -690,11 +715,12 @@ def convert_audio_bytes_to_text(raw_bytes: bytes, model_size: str = "small") ->
     data, samplerate = sf.read(io.BytesIO(raw_bytes))
     sf.write(output_path, data, samplerate, format="WAV", subtype="PCM_16")
     print(f"audio data is saved: {output_path}")
-    return convert_audio_file_to_text(output_path, model_size)
+    return convert_audio_file_to_text(output_path, model_size, language)
 
 
 __all__ = [
     "_merge_base64_audio_to_segment",
+    "concat_audio",
     "convert_audio_bytes_to_text",
     "convert_audio_file_to_text",
     "cosine_similarity_text",
diff --git a/tests/helpers/minicpmo_4_5_duplex.py b/tests/helpers/minicpmo_4_5_duplex.py
new file mode 100644
index 000000000..e19903e84
--- /dev/null
+++ b/tests/helpers/minicpmo_4_5_duplex.py
@@ -0,0 +1,192 @@
+"""Shared fixtures and argument builders for MiniCPM-o 4.5 duplex E2E tests."""
+
+from __future__ import annotations
+
+import hashlib
+import uuid
+import wave
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+from huggingface_hub import snapshot_download
+
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
+
+MODEL = "openbmb/MiniCPM-o-4_5"
+DEPLOY_CONFIG = modify_stage_config(
+    get_deploy_config_path("minicpmo_4_5_duplex.yaml"),
+    updates={
+        "base_config": get_deploy_config_path("minicpmo_4_5.yaml"),
+        "stages": {
+            0: {"kv_cache_memory_bytes": 6 * 1024 * 1024 * 1024},
+            1: {"kv_cache_memory_bytes": 512 * 1024 * 1024},
+            2: {"kv_cache_memory_bytes": 256 * 1024 * 1024},
+        },
+        # Platform overrides are applied after ordinary stage settings. Keep
+        # the constrained duplex test's Talker budget ahead of the base CUDA
+        # profile's single-GPU default.
+        "platforms": {
+            "cuda": {
+                "stages": [
+                    {
+                        "stage_id": 1,
+                        "kv_cache_memory_bytes": 512 * 1024 * 1024,
+                    }
+                ]
+            }
+        },
+    },
+)
+CORE_DEPLOY_CONFIG = modify_stage_config(
+    DEPLOY_CONFIG,
+    updates={
+        "stages": {
+            0: {"enforce_eager": True},
+            1: {"enforce_eager": True},
+        }
+    },
+)
+ASSET_DIR = Path(__file__).resolve().parents[1] / "assets" / "minicpmo_4_5"
+RESPONSE_REQUIRED_WAV = ASSET_DIR / "response_required_16k.wav"
+RESPONSE_REQUIRED_SHA256 = "2e5fd4eb3ee434ce107ee3a0591fa624a33f7683c7462f45fe651c443c9af941"
+SOFT_INTERRUPT_WAV = ASSET_DIR / "soft_interrupt_16k.wav"
+SOFT_INTERRUPT_SHA256 = "cadae6d0ddc510310f16f8775d6379f30a5195369ccb54ff10a8e3f9a1f4a2ea"
+REF_AUDIO_RELATIVE_PATH = Path("assets") / "HT_ref_audio.wav"
+
+SERVER_PARAMS = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=DEPLOY_CONFIG,
+            use_stage_cli=True,
+            server_args=["--trust-remote-code"],
+        ),
+        id="three-stage-single-gpu",
+    )
+]
+CORE_SERVER_PARAMS = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=CORE_DEPLOY_CONFIG,
+            use_stage_cli=True,
+            server_args=["--trust-remote-code"],
+        ),
+        id="three-stage-single-gpu",
+    )
+]
+
+
+def validated_wav(path: Path, expected_sha256: str) -> Path:
+    actual_sha256 = hashlib.sha256(path.read_bytes()).hexdigest()
+    if actual_sha256 != expected_sha256:
+        raise AssertionError(
+            f"MiniCPM-o duplex fixture SHA256 mismatch: expected {expected_sha256}, got {actual_sha256}"
+        )
+    with wave.open(str(path), "rb") as wav_file:
+        actual_format = (
+            wav_file.getframerate(),
+            wav_file.getnchannels(),
+            wav_file.getsampwidth(),
+            wav_file.getcomptype(),
+        )
+    expected_format = (16_000, 1, 2, "NONE")
+    if actual_format != expected_format:
+        raise AssertionError(f"MiniCPM-o duplex fixture must be 16 kHz mono PCM16, got {actual_format}")
+    return path
+
+
+def validated_input_wav() -> Path:
+    return validated_wav(RESPONSE_REQUIRED_WAV, RESPONSE_REQUIRED_SHA256)
+
+
+def validated_soft_interrupt_wav() -> Path:
+    return validated_wav(SOFT_INTERRUPT_WAV, SOFT_INTERRUPT_SHA256)
+
+
+def resolve_ref_audio(model_prefix: str) -> Path:
+    if model_prefix:
+        model_root = Path(model_prefix) / MODEL
+    else:
+        model_root = Path(snapshot_download(MODEL, local_files_only=True))
+    ref_audio = model_root / REF_AUDIO_RELATIVE_PATH
+    if not ref_audio.is_file():
+        raise FileNotFoundError(f"MiniCPM-o checkpoint ref audio is missing: {ref_audio}")
+    return ref_audio
+
+
+def realtime_url(omni_server) -> str:
+    return f"ws://{omni_server.host}:{omni_server.port}/v1/realtime?duplex=1"
+
+
+def demo_args(
+    *,
+    omni_server,
+    input_wav: Path,
+    ref_audio: Path,
+    output_dir: Path,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        url=realtime_url(omni_server),
+        model=omni_server.model,
+        session_id=f"duplex-ci-single-{uuid.uuid4().hex}",
+        input_wav=str(input_wav),
+        ref_audio=str(ref_audio),
+        turn_input_wav=[],
+        output_dir=str(output_dir),
+        output_audio_format="pcm16",
+        chunk_ms=200,
+        realtime_input=True,
+        first_turn_ms=1400,
+        turn_duration_ms=[],
+        first_turn_transcript="duplex CI speech",
+        omit_transcript_hints=False,
+        validation_mode="response-required",
+        temperature=0.0,
+        scenario="sequential",
+        require_audio=True,
+        require_distinct_inputs=False,
+        expect_empty_turn=[],
+        short_ack_ms=350,
+        turns=1,
+        timeout_s=120.0,
+        model_policy_settle_ms=2000,
+    )
+
+
+def multi_session_args(
+    *,
+    omni_server,
+    input_wav: Path,
+    ref_audio: Path,
+    output_dir: Path,
+    response_required: bool,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        url=realtime_url(omni_server),
+        model=omni_server.model,
+        sessions=2,
+        input_wav=str(input_wav),
+        ref_audio=str(ref_audio),
+        session_input_wav=[],
+        session_expected_token=[],
+        turn_input_wav=[],
+        output_dir=str(output_dir),
+        realtime_input=True,
+        chunk_ms=200,
+        turns=1,
+        first_turn_ms=1400,
+        turn_duration_ms=[],
+        response_required=response_required,
+        temperature=0.0 if response_required else None,
+        disconnect_session_index=0,
+        takeover_session_index=1,
+        resume_after_ms=100,
+        expire_session_index=None,
+        expire_after_s=40.0,
+        verify_admission_limit=None,
+        model_policy_settle_ms=2000,
+        timeout_s=180.0,
+    )
diff --git a/tests/helpers/runtime.py b/tests/helpers/runtime.py
index 885a4654f..5c1601cd0 100644
--- a/tests/helpers/runtime.py
+++ b/tests/helpers/runtime.py
@@ -22,6 +22,7 @@ from pathlib import Path
 from typing import Any, NamedTuple, cast
 from urllib.parse import quote
 
+import numpy as np
 import psutil
 import requests
 import soundfile as sf
@@ -597,7 +598,7 @@ class OmniServerStageCli(OmniServer):
             "serve",
             self.model,
             "--omni",
-            "--stage-configs-path",
+            "--deploy-config",
             self.stage_config_path,
             "--stage-id",
             str(stage_id),
@@ -638,7 +639,10 @@ class OmniServerStageCli(OmniServer):
         proc = subprocess.Popen(
             cmd,
             env=env,
-            cwd=os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            # Must be repo root (not tests/): after Docker deps-cache installs an empty
+            # vllm_omni stub into site-packages, cwd on sys.path[0] is what makes
+            # ``python -m vllm_omni.entrypoints...`` resolve the real package.
+            cwd=_omni_subprocess_cwd(),
             stdout=log_fh,
             stderr=subprocess.STDOUT,
         )
@@ -799,6 +803,189 @@ class WebSocketJsonResponse:
     json_body: dict[str, Any]
 
 
+@dataclass
+class OpenPIWebSocketResponse:
+    """Msgpack WebSocket session against ``/v1/realtime/robot/openpi``."""
+
+    server_metadata: dict[str, Any]
+    operation_responses: list[Any]
+    actions: dict[str, np.ndarray] | None = None
+    action_tensors: list[np.ndarray] | None = None
+
+
+def build_openpi_droid_observation(*, session_id: str = "gr00t-smoke") -> dict[str, Any]:
+    """Build a minimal DROID-style observation payload for the OpenPI robot endpoint."""
+    identity_eef_9d = np.zeros((1, 1, 9), dtype=np.float32)
+    identity_eef_9d[..., 3:] = np.array([1, 0, 0, 0, 1, 0], dtype=np.float32)
+    return {
+        "session_id": session_id,
+        "video": {
+            "exterior_image_1_left": np.zeros((1, 2, 256, 256, 3), dtype=np.uint8),
+            "wrist_image_left": np.zeros((1, 2, 256, 256, 3), dtype=np.uint8),
+        },
+        "state": {
+            "eef_9d": identity_eef_9d,
+            "gripper_position": np.zeros((1, 1, 1), dtype=np.float32),
+            "joint_position": np.zeros((1, 1, 7), dtype=np.float32),
+        },
+        "language": {"annotation.language.language_instruction": [["pick up the object"]]},
+    }
+
+
+DREAMZERO_DEFAULT_PROMPT = (
+    "Move the pan forward and use the brush in the middle of the plates to brush the inside of the pan"
+)
+DREAMZERO_ACTION_HORIZON = 24
+DREAMZERO_ACTION_DIM = 8
+DREAMZERO_CAMERA_FILES = {
+    "observation/exterior_image_0_left": "exterior_image_1_left.mp4",
+    "observation/exterior_image_1_left": "exterior_image_2_left.mp4",
+    "observation/wrist_image_left": "wrist_image_left.mp4",
+}
+
+
+def _require_opencv() -> Any:
+    try:
+        import cv2
+    except ImportError as exc:  # pragma: no cover - optional e2e dependency
+        raise ModuleNotFoundError("DreamZero OpenPI test dependencies are missing: opencv-python") from exc
+    return cv2
+
+
+def load_dreamzero_camera_frames(video_dir: Path) -> dict[str, np.ndarray]:
+    cv2 = _require_opencv()
+    camera_frames: dict[str, np.ndarray] = {}
+    for camera_key, file_name in DREAMZERO_CAMERA_FILES.items():
+        video_path = video_dir / file_name
+        if not video_path.exists():
+            raise FileNotFoundError(f"Missing DreamZero test asset: {video_path}")
+        cap = cv2.VideoCapture(str(video_path))
+        frames = []
+        while True:
+            ok, frame = cap.read()
+            if not ok:
+                break
+            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        cap.release()
+        if not frames:
+            raise RuntimeError(f"No frames loaded from {video_path}")
+        camera_frames[camera_key] = np.stack(frames, axis=0)
+    return camera_frames
+
+
+def build_dreamzero_demo_observations(
+    camera_frames: dict[str, np.ndarray],
+    *,
+    prompt: str,
+    session_id: str,
+    num_chunks: int = 2,
+) -> list[dict[str, Any]]:
+    if num_chunks < 1:
+        raise ValueError("num_chunks must be at least 1")
+
+    relative_offsets = [-23, -16, -8, 0]
+    total_frames = min(frames.shape[0] for frames in camera_frames.values())
+    frame_schedules = [[0]]
+    current_frame = 23
+    for _ in range(num_chunks - 1):
+        indices = [max(current_frame + offset, 0) for offset in relative_offsets]
+        if indices[-1] >= total_frames:
+            break
+        frame_schedules.append(indices)
+        current_frame += DREAMZERO_ACTION_HORIZON
+
+    observations: list[dict[str, Any]] = []
+    for frame_indices in frame_schedules:
+        obs: dict[str, Any] = {}
+        for camera_key, all_frames in camera_frames.items():
+            selected = all_frames[frame_indices]
+            obs[camera_key] = selected[0] if len(frame_indices) == 1 else selected
+        obs["observation/joint_position"] = np.zeros(7, dtype=np.float32)
+        obs["observation/cartesian_position"] = np.zeros(6, dtype=np.float32)
+        obs["observation/gripper_position"] = np.zeros(1, dtype=np.float32)
+        obs["prompt"] = prompt
+        obs["session_id"] = session_id
+        observations.append(obs)
+    return observations
+
+
+class OpenPIWebSocketSession:
+    """Persistent msgpack session for ``/v1/realtime/robot/openpi``."""
+
+    DEFAULT_PING_INTERVAL_SECS = 300
+    DEFAULT_PING_TIMEOUT_SECS = 3600
+
+    @staticmethod
+    def _require_dependencies() -> tuple[Any, Any]:
+        try:
+            import websockets.sync.client as websockets_client
+        except ImportError as exc:  # pragma: no cover - optional e2e dependency
+            raise ModuleNotFoundError("GR00T OpenPI test dependencies are missing: websockets") from exc
+        try:
+            from openpi_client import msgpack_numpy
+        except ImportError as exc:  # pragma: no cover - optional e2e dependency
+            raise ModuleNotFoundError("GR00T OpenPI test dependencies are missing: openpi-client") from exc
+        return websockets_client, msgpack_numpy
+
+    def __init__(
+        self,
+        uri: str,
+        *,
+        ping_interval: float = DEFAULT_PING_INTERVAL_SECS,
+        ping_timeout: float = DEFAULT_PING_TIMEOUT_SECS,
+        open_timeout: float = 120.0,
+        close_timeout: float = 120.0,
+    ) -> None:
+        websockets_client, msgpack_numpy = self._require_dependencies()
+        self._msgpack_numpy = msgpack_numpy
+        self._packer = msgpack_numpy.Packer()
+        self._conn = websockets_client.connect(
+            uri,
+            compression=None,
+            max_size=None,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            open_timeout=open_timeout,
+            close_timeout=close_timeout,
+        )
+        server_metadata = msgpack_numpy.unpackb(self._conn.recv())
+        if not isinstance(server_metadata, dict):
+            raise TypeError(f"Expected dict metadata from {uri}, got {type(server_metadata)!r}")
+        self._server_metadata = server_metadata
+
+    def get_server_metadata(self) -> dict[str, Any]:
+        return dict(self._server_metadata)
+
+    def infer(self, obs: dict[str, Any]) -> dict[str, np.ndarray]:
+        response = self._send_operation("infer", obs)
+        if not isinstance(response, dict):
+            raise TypeError(f"Expected dict infer response, got {type(response)!r}")
+        return {str(key): np.asarray(value, dtype=np.float32) for key, value in response.items()}
+
+    def reset(self, reset_info: dict[str, Any] | None = None) -> str:
+        response = self._send_operation("reset", dict(reset_info or {}))
+        return str(response["status"])
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def _send_operation(self, endpoint: str, payload: dict[str, Any]) -> Any:
+        body = dict(payload)
+        body["endpoint"] = endpoint
+        self._conn.send(self._packer.pack(body))
+        raw = self._conn.recv()
+        if isinstance(raw, str):
+            raise RuntimeError(f"OpenPI {endpoint!r} failed: {raw}")
+        decoded = self._msgpack_numpy.unpackb(raw)
+        if isinstance(decoded, dict) and decoded.get("type") == "error":
+            raise RuntimeError(f"OpenPI {endpoint!r} failed: {decoded.get('message')}")
+        if endpoint == "reset":
+            if not isinstance(decoded, dict) or decoded.get("status") != "reset successful":
+                raise RuntimeError(f"Unexpected OpenPI reset response: {decoded!r}")
+            return decoded
+        return decoded
+
+
 def _merge_http_expectation_kwargs(
     base: dict[str, Any] | None,
     *,
@@ -1590,6 +1777,92 @@ class OpenAIClientHandler:
         )
         return self._send_websocket_first_json_request("/v1/realtime", cfg)
 
+    def send_robot_openpi_ws_request(
+        self,
+        request_config: dict[str, Any] | None = None,
+    ) -> list[OpenPIWebSocketResponse]:
+        """WebSocket ``/v1/realtime/robot/openpi`` — msgpack metadata plus optional infer/reset ops.
+
+        ``request_config`` keys:
+
+        - ``operations``: optional sequence of ``{"endpoint": "infer"|"reset", "payload": {...}}``.
+        - ``run_default_policy_session``: when true and ``operations`` is omitted, run infer then reset
+          using :func:`build_openpi_droid_observation`.
+        - ``run_dreamzero_policy_session``: when true and ``operations`` is omitted, run the DreamZero
+          infer/reset/infer sequence using :func:`build_dreamzero_demo_observations`.
+        - ``video_dir``: required for ``run_dreamzero_policy_session``.
+        - ``prompt``: language instruction for DreamZero observations (optional).
+        - ``session_id``: used by the default policy session observation builder.
+        - ``num_chunks``: DreamZero chunk count (default ``2``).
+        - ``timeout``: seconds to wait for each inbound msgpack frame (default ``120``).
+        - ``ping_interval`` / ``ping_timeout``: forwarded to :func:`websockets.sync.client.connect`.
+        """
+        cfg = dict(request_config or {})
+        operations_cfg = cfg.get("operations")
+        if operations_cfg is not None:
+            operations = [dict(op) for op in operations_cfg]
+        elif cfg.get("run_dreamzero_policy_session"):
+            video_dir = cfg.get("video_dir")
+            if video_dir is None:
+                raise ValueError("run_dreamzero_policy_session requires video_dir")
+            session_id = str(cfg.get("session_id", "dreamzero-smoke"))
+            prompt = str(cfg.get("prompt", DREAMZERO_DEFAULT_PROMPT))
+            num_chunks = int(cfg.get("num_chunks", 2))
+            observations = build_dreamzero_demo_observations(
+                load_dreamzero_camera_frames(Path(video_dir)),
+                prompt=prompt,
+                session_id=session_id,
+                num_chunks=num_chunks,
+            )
+            operations = [{"endpoint": "infer", "payload": obs} for obs in observations]
+            operations.append({"endpoint": "reset", "payload": {}})
+            operations.append({"endpoint": "infer", "payload": observations[0]})
+        elif cfg.get("run_default_policy_session"):
+            session_id = str(cfg.get("session_id", "gr00t-smoke"))
+            operations = [
+                {"endpoint": "infer", "payload": build_openpi_droid_observation(session_id=session_id)},
+                {"endpoint": "reset", "payload": {}},
+            ]
+        else:
+            operations = []
+        timeout = float(cfg.get("timeout", 120.0))
+        ping_interval = float(cfg.get("ping_interval", OpenPIWebSocketSession.DEFAULT_PING_INTERVAL_SECS))
+        ping_timeout = float(cfg.get("ping_timeout", OpenPIWebSocketSession.DEFAULT_PING_TIMEOUT_SECS))
+
+        uri = self._build_ws_url("/v1/realtime/robot/openpi")
+        session = OpenPIWebSocketSession(
+            uri,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            open_timeout=timeout,
+            close_timeout=timeout,
+        )
+        try:
+            operation_responses: list[Any] = []
+            actions: dict[str, np.ndarray] | None = None
+            action_tensors: list[np.ndarray] = []
+            for operation in operations:
+                endpoint = str(operation["endpoint"])
+                payload = dict(operation.get("payload") or {})
+                response = session._send_operation(endpoint, payload)
+                operation_responses.append(response)
+                if endpoint == "infer":
+                    if isinstance(response, dict):
+                        actions = {str(key): np.asarray(value, dtype=np.float32) for key, value in response.items()}
+                    else:
+                        action_tensors.append(np.asarray(response, dtype=np.float32))
+        finally:
+            session.close()
+
+        return [
+            OpenPIWebSocketResponse(
+                server_metadata=session.get_server_metadata(),
+                operation_responses=operation_responses,
+                actions=actions,
+                action_tensors=action_tensors or None,
+            )
+        ]
+
     def send_omni_request(self, request_config: dict[str, Any], request_num: int = 1) -> list[OmniResponse]:
         """Chat completions via the OpenAI Python SDK (not raw HTTP)."""
         responses: list[OmniResponse] = []
@@ -1795,6 +2068,7 @@ class OpenAIClientHandler:
             "instructions",
             "speed",
             "stream_format",
+            "x_vector_only_mode",
         ):
             if key in request_config:
                 extra_body[key] = request_config[key]
@@ -2332,7 +2606,6 @@ class OmniRunner:
         # production default in AsyncOmniEngine remains 600s; this only
         # affects the test runner wrapper.
         init_timeout: int = 1800,
-        shm_threshold_bytes: int = 65536,
         log_stats: bool = False,
         stage_configs_path: str | None = None,
         **kwargs,
@@ -2352,7 +2625,6 @@ class OmniRunner:
             stage_init_timeout=stage_init_timeout,
             batch_timeout=batch_timeout,
             init_timeout=init_timeout,
-            shm_threshold_bytes=shm_threshold_bytes,
             stage_configs_path=stage_configs_path,
             **kwargs,
         )
@@ -2422,6 +2694,10 @@ class OmniRunner:
         video_padding_token = "<|VIDEO|>"
         image_padding_token = "<|IMAGE|>"
         audio_padding_token = "<|AUDIO|>"
+        # Default wrapping for Qwen-style models (bos/eos around the placeholder).
+        audio_fmt = "<|audio_bos|>{p}<|audio_eos|>"
+        image_fmt = "<|vision_bos|>{p}<|vision_eos|>"
+        video_fmt = "<|vision_bos|>{p}<|vision_eos|>"
         if "Qwen3-Omni-30B-A3B-Instruct" in self.model_name:
             video_padding_token = "<|video_pad|>"
             image_padding_token = "<|image_pad|>"
@@ -2430,6 +2706,15 @@ class OmniRunner:
             video_padding_token = "<VIDEO>"
             image_padding_token = "<IMAGE>"
             audio_padding_token = "<AUDIO>"
+        elif "MiniCPM" in self.model_name:
+            # MiniCPM-o expects the bare placeholder literals (with parens and ./),
+            # not Qwen-style bos/eos wrapping.
+            video_padding_token = "(<video>./</video>)"
+            image_padding_token = "(<image>./</image>)"
+            audio_padding_token = "(<audio>./</audio>)"
+            audio_fmt = "{p}"
+            image_fmt = "{p}"
+            video_fmt = "{p}"
         if isinstance(prompts, str):
             prompts = [prompts]
 
@@ -2490,28 +2775,28 @@ class OmniRunner:
             if audio is not None:
                 if isinstance(audio, list):
                     for _ in audio:
-                        user_content += f"<|audio_bos|>{audio_padding_token}<|audio_eos|>"
+                        user_content += audio_fmt.format(p=audio_padding_token)
                     multi_modal_data["audio"] = audio
                 else:
-                    user_content += f"<|audio_bos|>{audio_padding_token}<|audio_eos|>"
+                    user_content += audio_fmt.format(p=audio_padding_token)
                     multi_modal_data["audio"] = audio
             image = images_list[i]
             if image is not None:
                 if isinstance(image, list):
                     for _ in image:
-                        user_content += f"<|vision_bos|>{image_padding_token}<|vision_eos|>"
+                        user_content += image_fmt.format(p=image_padding_token)
                     multi_modal_data["image"] = image
                 else:
-                    user_content += f"<|vision_bos|>{image_padding_token}<|vision_eos|>"
+                    user_content += image_fmt.format(p=image_padding_token)
                     multi_modal_data["image"] = image
             video = videos_list[i]
             if video is not None:
                 if isinstance(video, list):
                     for _ in video:
-                        user_content += f"<|vision_bos|>{video_padding_token}<|vision_eos|>"
+                        user_content += video_fmt.format(p=video_padding_token)
                     multi_modal_data["video"] = video
                 else:
-                    user_content += f"<|vision_bos|>{video_padding_token}<|vision_eos|>"
+                    user_content += video_fmt.format(p=video_padding_token)
                     multi_modal_data["video"] = video
             user_content += prompt_text
 
@@ -2850,7 +3135,7 @@ def iter_omni_server(
                 raise ValueError("omni_server with use_stage_cli=True requires use_omni=True")
             if stage_config_path is None:
                 raise ValueError("omni_server with use_stage_cli=True requires a stage_config_path")
-            server_args += ["--stage-configs-path", stage_config_path]
+            server_args += ["--deploy-config", stage_config_path]
 
             with OmniServerStageCli(
                 model,
@@ -2866,7 +3151,7 @@ def iter_omni_server(
                 print("OmniServer stopping...")
         else:
             if stage_config_path is not None:
-                server_args += ["--stage-configs-path", stage_config_path]
+                server_args += ["--deploy-config", stage_config_path]
 
             with (
                 OmniServer(
@@ -2931,6 +3216,14 @@ __all__ = [
     "DiffusionResponse",
     "HttpResponse",
     "WebSocketJsonResponse",
+    "OpenPIWebSocketResponse",
+    "build_openpi_droid_observation",
+    "build_dreamzero_demo_observations",
+    "DREAMZERO_ACTION_DIM",
+    "DREAMZERO_ACTION_HORIZON",
+    "DREAMZERO_CAMERA_FILES",
+    "load_dreamzero_camera_frames",
+    "OpenPIWebSocketSession",
     "OmniResponse",
     "OmniRunner",
     "OmniRunnerHandler",
diff --git a/tests/helpers/test_assertions.py b/tests/helpers/test_assertions.py
deleted file mode 100644
index 0bfa7f593..000000000
--- a/tests/helpers/test_assertions.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import pytest
-
-from tests.helpers.assertions import _assert_transcript_matches
-
-
-def test_short_transcript_repeat_passes_containment_fallback():
-    _assert_transcript_matches(
-        " How... how are you?",
-        audio_bytes=None,
-        expected_text="how are you",
-        threshold=0.9,
-    )
-
-
-def test_short_transcript_unrelated_text_still_fails():
-    with pytest.raises(AssertionError, match="Transcript doesn't match input"):
-        _assert_transcript_matches(
-            " I don't know, sorry.",
-            audio_bytes=None,
-            expected_text="how are you",
-            threshold=0.9,
-        )
diff --git a/tests/helpers/tests/test_assertions.py b/tests/helpers/tests/test_assertions.py
new file mode 100644
index 000000000..9cb1560b9
--- /dev/null
+++ b/tests/helpers/tests/test_assertions.py
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import pytest
+
+from tests.helpers import assertions
+from tests.helpers.assertions import _assert_transcript_matches, _resolve_audio_transcript
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_short_transcript_repeat_passes_containment_fallback():
+    _assert_transcript_matches(
+        " How... how are you?",
+        audio_bytes=None,
+        expected_text="how are you",
+        threshold=0.9,
+    )
+
+
+def test_short_transcript_unrelated_text_still_fails():
+    with pytest.raises(AssertionError, match="Transcript doesn't match input"):
+        _assert_transcript_matches(
+            " I don't know, sorry.",
+            audio_bytes=None,
+            expected_text="how are you",
+            threshold=0.9,
+        )
+
+
+def _capture_transcribe(monkeypatch) -> dict:
+    captured: dict = {}
+
+    def fake_convert(raw_bytes, model_size="small", language=None):
+        captured["model_size"] = model_size
+        captured["language"] = language
+        return "London"
+
+    monkeypatch.setattr(assertions, "convert_audio_bytes_to_text", fake_convert)
+    return captured
+
+
+def test_resolve_transcript_honors_declared_language(monkeypatch):
+    captured = _capture_transcribe(monkeypatch)
+    response = SimpleNamespace(audio_content=None, audio_bytes=b"fake-wav")
+
+    _resolve_audio_transcript(
+        response,
+        {"modalities": ["text", "audio"], "transcript_language": "en"},
+        "full_model",
+        speech_api=False,
+    )
+
+    assert captured["language"] == "en"
+
+
+def test_resolve_transcript_leaves_language_unset_by_default(monkeypatch):
+    captured = _capture_transcribe(monkeypatch)
+    response = SimpleNamespace(audio_content=None, audio_bytes=b"fake-wav")
+
+    _resolve_audio_transcript(
+        response,
+        {"modalities": ["text", "audio"]},
+        "full_model",
+        speech_api=False,
+    )
+
+    assert captured["language"] is None
+    assert captured["model_size"] == "small"
+
+
+def test_escalated_transcript_keeps_declared_language(monkeypatch):
+    # The escalated pass must honour the same language, otherwise a request that
+    # pins one silently falls back to auto-detection on retry.
+    captured = _capture_transcribe(monkeypatch)
+
+    with pytest.raises(AssertionError, match="after ASR escalation"):
+        _assert_transcript_matches(
+            "totally different words",
+            audio_bytes=b"fake-wav",
+            expected_text="how are you",
+            threshold=0.9,
+            escalation_model="large-v3",
+            language="en",
+        )
+
+    assert captured["model_size"] == "large-v3"
+    assert captured["language"] == "en"
diff --git a/tests/helpers/tests/test_media.py b/tests/helpers/tests/test_media.py
new file mode 100644
index 000000000..4a8e5393d
--- /dev/null
+++ b/tests/helpers/tests/test_media.py
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import sys
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import soundfile as sf
+
+from tests.helpers import media
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _stub_transcribe(monkeypatch) -> dict:
+    """Capture the kwargs the helper hands to whisper, with no model and no device."""
+    captured: dict = {}
+
+    class FakeModel:
+        def transcribe(self, path, **kwargs):
+            captured.update(kwargs)
+            return {"text": "London"}
+
+    monkeypatch.setitem(sys.modules, "whisper", SimpleNamespace(load_model=lambda size, device=None: FakeModel()))
+    # Keep the unit test off the accelerator probe so it stays hermetic.
+    monkeypatch.setitem(
+        sys.modules,
+        "vllm_omni.platforms",
+        SimpleNamespace(current_omni_platform=SimpleNamespace(is_available=lambda: False)),
+    )
+    return captured
+
+
+def test_transcribe_forwards_requested_language(monkeypatch):
+    captured = _stub_transcribe(monkeypatch)
+
+    media._whisper_transcribe_in_current_process("/tmp/does-not-matter.wav", "small", language="en")
+
+    assert captured["language"] == "en"
+
+
+def test_transcribe_defaults_to_auto_language(monkeypatch):
+    # Auto-detect must stay the default: forcing a language globally would break
+    # the non-English audio tests (e.g. the Chinese Qwen3-Omni prompts).
+    captured = _stub_transcribe(monkeypatch)
+
+    media._whisper_transcribe_in_current_process("/tmp/does-not-matter.wav", "small")
+
+    assert captured.get("language") is None
+
+
+def test_bytes_entrypoint_forwards_language_to_subprocess(monkeypatch, tmp_path):
+    """Cover the two hops the tests above skip: bytes -> file -> executor.submit.
+
+    The real call crosses a spawn ProcessPoolExecutor, so capture what gets
+    submitted rather than what the worker eventually does.
+    """
+    submitted: dict = {}
+
+    class FakeExecutor:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+        def submit(self, fn, *args):
+            submitted["fn"] = fn
+            submitted["args"] = args
+            return SimpleNamespace(result=lambda: "London")
+
+    monkeypatch.setattr(media.concurrent.futures, "ProcessPoolExecutor", lambda *a, **kw: FakeExecutor())
+
+    wav = tmp_path / "clip.wav"
+    sf.write(wav, np.zeros(2400, dtype=np.float32), 24000)
+
+    assert media.convert_audio_bytes_to_text(wav.read_bytes(), "small", "en") == "London"
+
+    assert submitted["fn"] is media._whisper_transcribe_in_current_process
+    assert submitted["args"][1:] == ("small", "en")
diff --git a/tests/test_pydub_removal.py b/tests/helpers/tests/test_media_pydub_removal.py
similarity index 85%
rename from tests/test_pydub_removal.py
rename to tests/helpers/tests/test_media_pydub_removal.py
index ae65bdab2..60e5cab65 100644
--- a/tests/test_pydub_removal.py
+++ b/tests/helpers/tests/test_media_pydub_removal.py
@@ -7,13 +7,19 @@ identical results to the old pydub-based code for all three paths:
   3. TTS WER PCM export: resample to 24000Hz mono s16
 """
 
+import base64
 import io
 import wave
 
 import av
 import numpy as np
+import pytest
 import soundfile as sf
 
+from tests.helpers.media import _merge_base64_audio_to_segment
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _make_wav_bytes(sample_rate=16000, channels=1, sample_width=2, duration_sec=1.0):
     """Generate a WAV file with a sine wave, return (wav_bytes, pcm_bytes, params)."""
@@ -69,8 +75,6 @@ def test_wav_path_duration_and_frames():
                     f"sr={sr} ch={ch} dur={dur}: frames {audio_frames} != {expected_frames}"
                 )
 
-    print("[PASS] test_wav_path_duration_and_frames")
-
 
 def test_non_wav_path_duration_av():
     """Path 2: non-WAV audio → duration & frames via av."""
@@ -86,8 +90,6 @@ def test_non_wav_path_duration_av():
         # OGG encoding may add padding, allow small tolerance
         assert abs(audio_duration_sec - dur) < 0.05, f"dur={dur}: got {audio_duration_sec}"
 
-    print("[PASS] test_non_wav_path_duration_av")
-
 
 def test_tts_pcm_export_wav_path():
     """Path 3a: WAV PCM → resample to 24000Hz mono s16."""
@@ -114,8 +116,6 @@ def test_tts_pcm_export_wav_path():
     assert abs(actual_samples - expected_samples) < 10, f"expected ~{expected_samples} samples, got {actual_samples}"
     assert len(pcm_array.shape) == 1, "should be mono (1D array)"
 
-    print("[PASS] test_tts_pcm_export_wav_path")
-
 
 def test_tts_pcm_export_non_wav_path():
     """Path 3b: non-WAV → resample to 24000Hz mono s16 via av.AudioResampler."""
@@ -135,22 +135,13 @@ def test_tts_pcm_export_non_wav_path():
     actual_samples = len(result_bytes) // 2
     assert abs(actual_samples - expected_samples) < 500, f"expected ~{expected_samples} samples, got {actual_samples}"
 
-    print("[PASS] test_tts_pcm_export_non_wav_path")
-
 
 def test_media_merge_and_export():
     """media.py: _merge_base64_audio_to_segment decode + concat + export WAV."""
-    import base64 as b64mod
-    import sys
-
-    sys.path.insert(0, ".")
-    from tests.helpers.media import _merge_base64_audio_to_segment
-
-    # Create two WAV chunks as base64
     chunks_b64 = []
     for dur in [0.5, 0.3]:
         wav_bytes, _, _ = _make_wav_bytes(sample_rate=16000, channels=1, sample_width=2, duration_sec=dur)
-        chunks_b64.append(b64mod.b64encode(wav_bytes).decode())
+        chunks_b64.append(base64.b64encode(wav_bytes).decode())
 
     merged = _merge_base64_audio_to_segment(chunks_b64)
 
@@ -164,19 +155,3 @@ def test_media_merge_and_export():
     out_data, out_sr = sf.read(io.BytesIO(wav_out))
     actual_dur = len(out_data) / out_sr
     assert abs(actual_dur - 0.8) < 0.05, f"expected ~0.8s merged duration, got {actual_dur}"
-
-    print(f"[PASS] test_media_merge_and_export (duration={actual_dur:.3f}s, wav_size={len(wav_out)} bytes)")
-
-
-if __name__ == "__main__":
-    test_wav_path_duration_and_frames()
-    test_non_wav_path_duration_av()
-    import importlib.util
-
-    if importlib.util.find_spec("torch") and importlib.util.find_spec("torchaudio"):
-        test_tts_pcm_export_wav_path()
-    else:
-        print("[SKIP] test_tts_pcm_export_wav_path (torch/torchaudio not available)")
-    test_tts_pcm_export_non_wav_path()
-    test_media_merge_and_export()
-    print("\nAll tests passed.")
diff --git a/tests/helpers/test_runtime_stage_cli.py b/tests/helpers/tests/test_runtime_stage_cli.py
similarity index 91%
rename from tests/helpers/test_runtime_stage_cli.py
rename to tests/helpers/tests/test_runtime_stage_cli.py
index d9b50c85f..5a2ab5d68 100644
--- a/tests/helpers/test_runtime_stage_cli.py
+++ b/tests/helpers/tests/test_runtime_stage_cli.py
@@ -4,8 +4,12 @@ from __future__ import annotations
 
 from pathlib import Path
 
+import pytest
+
 from tests.helpers.runtime import OmniServerStageCli
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _write_stage_config(tmp_path: Path) -> str:
     path = tmp_path / "stages.yaml"
@@ -31,7 +35,7 @@ def test_stage_cli_builds_headless_replica_cmd(tmp_path: Path) -> None:
     assert "--headless" in cmd
     assert cmd[cmd.index("--stage-id") + 1] == "1"
     assert cmd[cmd.index("--replica-id") + 1] == "2"
-    assert cmd[cmd.index("--stage-configs-path") + 1] == server.stage_config_path
+    assert cmd[cmd.index("--deploy-config") + 1] == server.stage_config_path
 
 
 def test_stage_cli_splits_devices_per_replica(tmp_path: Path) -> None:
diff --git a/tests/helpers/tiny_model.py b/tests/helpers/tiny_model.py
new file mode 100644
index 000000000..7ada9f987
--- /dev/null
+++ b/tests/helpers/tiny_model.py
@@ -0,0 +1,123 @@
+"""Reusable utility for building tiny diffusion models with random weights.
+
+Mirrors the component loading loop in DiffusionPipeline.from_pretrained,
+but monkeypatches from_pretrained on ModelMixin and PreTrainedModel to
+initialize with random weights instead of loading checkpoint files.
+Components with vendored configs use those; others load configs from
+the upstream HF model, optionally passed through a per-component transform
+function first.
+"""
+
+import os
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from unittest.mock import patch
+
+import torch
+from diffusers import ModelMixin
+from diffusers.pipelines.pipeline_loading_utils import _get_pipeline_class, simple_get_class_obj
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from transformers import PretrainedConfig, PreTrainedModel
+
+TINY_MODEL_DIR = os.path.join(tempfile.gettempdir(), "vllm-omni-tiny-models")
+
+
+def _get_tiny_model_path(name: str) -> str:
+    path = os.path.join(TINY_MODEL_DIR, name)
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+def build_tiny_from_configs(
+    pipeline_name: str,
+    model_id: str,
+    configs_dir: str | Path | None = None,
+    transform: dict[str, Callable[[dict], dict]] | None = None,
+) -> str:
+    """Build a tiny diffusion model with random weights.
+
+    Args:
+        pipeline_name: Name of the pipeline (used as output directory name).
+        model_id: HuggingFace model ID for loading upstream components
+            (tokenizer, scheduler, and any component without a vendored
+            config or transform) that don't have vendored configs.
+        configs_dir: Path to a directory containing vendored config files
+            (model_index.json and per-component config.json).
+        transform: Maps a component (subfolder) name to a function that
+            takes that component's raw config dict (fetched from model_id)
+            and returns a shrunk one, applied only when that component has
+            no vendored config in configs_dir. Lets each pipeline encode
+            exactly the shrink it needs (layer counts, and any component-
+            internal width that isn't read by another component), including
+            keeping sibling config fields in sync (e.g. layer_types matching
+            num_hidden_layers).
+
+    Returns:
+        Path to the saved tiny model directory with safetensors weights.
+    """
+    model_dir = _get_tiny_model_path(pipeline_name)
+    config_dir = Path(configs_dir) if configs_dir is not None else None
+    transform = transform or {}
+
+    if config_dir is None and not transform:
+        raise ValueError(
+            f"Neither configs_dir nor transform given for {pipeline_name!r}. Pass a "
+            "configs_dir with vendored configs, and/or transform={{name: fn}} to shrink "
+            f"specific components fetched from the upstream model {model_id!r}."
+        )
+
+    def _diffusers_from_config(cls, pretrained_model_name_or_path, **kwargs):
+        """Replacement for ModelMixin.from_pretrained that initializes random weights."""
+        subfolder = kwargs.get("subfolder")
+        load_kwargs = {"subfolder": subfolder} if subfolder else {}
+        config = cls.load_config(pretrained_model_name_or_path, **load_kwargs)
+        if subfolder in transform:
+            config = transform[subfolder](dict(config))
+        return cls.from_config(config)
+
+    def _transformers_from_config(cls, pretrained_model_name_or_path, **kwargs):
+        """Replacement for PreTrainedModel.from_pretrained that initializes random weights.
+
+        Uses the model's own config_class (every PreTrainedModel subclass
+        declares one) so the raw dict can be transformed before constructing
+        the config object.
+        """
+        subfolder = kwargs.get("subfolder")
+        load_kwargs = {"subfolder": subfolder} if subfolder else {}
+        config_dict, _ = PretrainedConfig.get_config_dict(pretrained_model_name_or_path, **load_kwargs)
+        if subfolder in transform:
+            config_dict = transform[subfolder](config_dict)
+        config = cls.config_class.from_dict(config_dict)
+        return cls(config)
+
+    # model_index.json comes from the vendored configs_dir when it's there, otherwise
+    # from model_id. Independent of the per-component checks below, so a configs_dir
+    # can vendor just one component without also needing its own model_index.json.
+    vendored_index = config_dir is not None and (config_dir / "model_index.json").exists()
+    config_dict = DiffusionPipeline.load_config(config_dir if vendored_index else model_id)
+    pipeline_cls = _get_pipeline_class(DiffusionPipeline, config=config_dict)
+
+    init_dict, _, _ = pipeline_cls.extract_init_dict(config_dict)
+
+    # Pop non-component entries (optional pipeline kwargs like is_distilled),
+    # same as DiffusionPipeline.from_pretrained lines 345-350
+    _, optional_kwargs = DiffusionPipeline._get_signature_keys(pipeline_cls)
+    init_kwargs = {k: init_dict.pop(k) for k in optional_kwargs if k in init_dict}
+
+    with (
+        patch.object(ModelMixin, "from_pretrained", classmethod(_diffusers_from_config)),
+        patch.object(PreTrainedModel, "from_pretrained", classmethod(_transformers_from_config)),
+    ):
+        for name, (library_name, class_name) in init_dict.items():
+            cls = simple_get_class_obj(library_name, class_name)
+
+            # Use vendored config dir if available, otherwise upstream model
+            if config_dir is not None and (config_dir / name).exists():
+                init_kwargs[name] = cls.from_pretrained(config_dir / name)
+            else:
+                init_kwargs[name] = cls.from_pretrained(model_id, subfolder=name)
+
+    pipe = pipeline_cls(**init_kwargs)
+    pipe.to(torch.bfloat16).save_pretrained(model_dir)
+    return model_dir
diff --git a/tests/inputs/test_diffusion_sampling_params.py b/tests/inputs/test_diffusion_sampling_params.py
new file mode 100644
index 000000000..5daa1fd49
--- /dev/null
+++ b/tests/inputs/test_diffusion_sampling_params.py
@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Regression tests for diffusion sampling params coercion."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _sampling_params(*, seed: int | None = None, extra_args: dict[str, Any] | None = None) -> SamplingParams:
+    return SamplingParams(max_tokens=1, seed=seed, extra_args=extra_args)
+
+
+def test_from_params_returns_existing_omni_params() -> None:
+    params = OmniDiffusionSamplingParams(num_inference_steps=20)
+
+    converted = OmniDiffusionSamplingParams.from_params(params)
+
+    assert converted is params
+
+
+def test_from_params_converts_sampling_params_seed_and_known_extra_args() -> None:
+    params = _sampling_params(
+        seed=1234,
+        extra_args={
+            "num_inference_steps": 50,
+            "height": 1024,
+            "width": 768,
+            "guidance_scale": 7.5,
+        },
+    )
+
+    converted = OmniDiffusionSamplingParams.from_params(params)
+
+    assert converted.seed == 1234
+    assert converted.num_inference_steps == 50
+    assert converted.height == 1024
+    assert converted.width == 768
+    assert converted.guidance_scale == 7.5
+    assert converted.extra_args == {}
+
+
+def test_from_params_preserves_unknown_extra_args() -> None:
+    params = _sampling_params(
+        extra_args={
+            "height": 512,
+            "pipeline_specific": "kept",
+        },
+    )
+
+    converted = OmniDiffusionSamplingParams.from_params(params)
+
+    assert converted.height == 512
+    assert converted.extra_args == {"pipeline_specific": "kept"}
+
+
+def test_from_params_rejects_unsupported_types() -> None:
+    with pytest.raises(TypeError, match="Diffusion stage requires OmniDiffusionSamplingParams"):
+        OmniDiffusionSamplingParams.from_params({"height": 512})
diff --git a/tests/metrics/test_metrics_utils.py b/tests/metrics/test_metrics_utils.py
new file mode 100644
index 000000000..544c7819a
--- /dev/null
+++ b/tests/metrics/test_metrics_utils.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.metrics.utils import (
+    count_audio_chunk_frames,
+    count_audio_frames,
+    count_image_pixels,
+    count_tokens_from_outputs,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    ("audio_chunk", "expected"),
+    [
+        (SimpleNamespace(shape=(2, 320)), 320),
+        ([0.0, 0.0, 0.0], 3),
+        (1.0, 1),
+    ],
+)
+def test_count_audio_chunk_frames(audio_chunk: object, expected: int) -> None:
+    assert count_audio_chunk_frames(audio_chunk) == expected
+
+
+def test_count_audio_frames_sums_audio_chunks() -> None:
+    mm_out = {
+        "audio": [
+            SimpleNamespace(shape=(1, 120)),
+            SimpleNamespace(shape=(2, 80)),
+        ]
+    }
+
+    assert count_audio_frames(mm_out) == 200
+
+
+def test_count_audio_frames_supports_model_outputs() -> None:
+    mm_out = {
+        "model_outputs": [
+            SimpleNamespace(shape=(1, 120)),
+            SimpleNamespace(shape=(2, 80)),
+        ]
+    }
+
+    assert count_audio_frames(mm_out) == 200
+
+
+@pytest.mark.parametrize("mm_out", [{}, {"audio": None}, {"model_outputs": None}])
+def test_count_audio_frames_returns_zero_without_audio(mm_out: dict[str, object]) -> None:
+    assert count_audio_frames(mm_out) == 0
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        (None, 0),
+        (object(), 0),
+        (SimpleNamespace(size=(10, 20)), 200),
+        (SimpleNamespace(shape=(2, 3, 4, 5)), 40),
+        (SimpleNamespace(shape=(3, 4, 5)), 20),
+        (SimpleNamespace(shape=(6, 7, 3)), 42),
+        (SimpleNamespace(shape=(6, 7)), 42),
+    ],
+)
+def test_count_image_pixels(value: object, expected: int) -> None:
+    assert count_image_pixels(value) == expected
+
+
+def test_count_image_pixels_sums_nested_values() -> None:
+    images = [
+        SimpleNamespace(size=(10, 20)),
+        (
+            SimpleNamespace(shape=(3, 4, 5)),
+            SimpleNamespace(shape=(6, 7, 3)),
+        ),
+    ]
+
+    assert count_image_pixels(images) == 262
+
+
+def test_count_tokens_from_outputs() -> None:
+    engine_outputs = [
+        SimpleNamespace(
+            outputs=[
+                SimpleNamespace(cumulative_token_ids=[1, 2, 3], token_ids=[3]),
+                SimpleNamespace(cumulative_token_ids=None, token_ids=[4, 5]),
+                SimpleNamespace(cumulative_token_ids=None, token_ids=None),
+            ]
+        ),
+        SimpleNamespace(outputs=None),
+        SimpleNamespace(
+            outputs=[
+                SimpleNamespace(cumulative_token_ids=[6], token_ids=[6]),
+            ]
+        ),
+    ]
+
+    assert count_tokens_from_outputs(engine_outputs) == 6
diff --git a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
index bf2261cb9..2a4cb2f1e 100644
--- a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
@@ -10,6 +10,8 @@ import torch.nn as nn
 
 from tests.helpers.mark import hardware_test
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 class TestPreLookaheadLayer:
     """Tests for PreLookaheadLayer."""
diff --git a/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py b/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py
index d77b28cd5..d2138541f 100644
--- a/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py
+++ b/tests/model_executor/models/dynin_omni/test_dynin_omni_token2audio.py
@@ -1,16 +1,34 @@
 from __future__ import annotations
 
+import pytest
 from transformers import PreTrainedModel
 
 from vllm_omni.model_executor.models.dynin_omni.dynin_omni_token2audio import (
     _ensure_transformers_tied_weights_compat,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def test_transformers_tied_weights_compat(monkeypatch):
+    """Compat shim must not permanently mutate ``PreTrainedModel``.
+
+    ``monkeypatch.delattr(..., raising=False)`` is a no-op undo when the attr
+    was absent. ``_ensure_transformers_tied_weights_compat`` then assigns a
+    read-only ``property`` on the class that later PreTrainedModel subclasses
+    (e.g. qwen3 TTS mask-cache) can trip over with
+    ``AttributeError: property ... has no setter``.
+    """
     monkeypatch.delattr(PreTrainedModel, "all_tied_weights_keys", raising=False)
 
     _ensure_transformers_tied_weights_compat()
+    installed = PreTrainedModel.__dict__.get("all_tied_weights_keys")
+    assert installed is not None
+
+    # Re-own the installed descriptor through monkeypatch so teardown always
+    # removes/restores it, even when the attr did not exist before this test.
+    delattr(PreTrainedModel, "all_tied_weights_keys")
+    monkeypatch.setattr(PreTrainedModel, "all_tied_weights_keys", installed, raising=False)
 
     model = PreTrainedModel.__new__(PreTrainedModel)
     model._tied_weights_keys = ["decoder.weight"]
diff --git a/tests/model_executor/models/fish_speech/test_fish_speech_fast_ar_runtime_buffers.py b/tests/model_executor/models/fish_speech/test_fish_speech_fast_ar_runtime_buffers.py
index 41a29ca63..9586ad053 100644
--- a/tests/model_executor/models/fish_speech/test_fish_speech_fast_ar_runtime_buffers.py
+++ b/tests/model_executor/models/fish_speech/test_fish_speech_fast_ar_runtime_buffers.py
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+import pytest
 import torch
 import torch.nn as nn
 
@@ -13,6 +14,8 @@ from vllm_omni.model_executor.models.fish_speech.fish_speech_slow_ar import (
     FishSpeechSlowARForConditionalGeneration,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def test_fast_ar_reuses_dense_position_id_buffer(monkeypatch):
     fast_config = FishSpeechFastARConfig(
diff --git a/tests/model_executor/models/glm_image/test_glm_image_ar.py b/tests/model_executor/models/glm_image/test_glm_image_ar.py
index 32a016b2a..5ccc9fc62 100644
--- a/tests/model_executor/models/glm_image/test_glm_image_ar.py
+++ b/tests/model_executor/models/glm_image/test_glm_image_ar.py
@@ -91,6 +91,10 @@ GlmImageRotaryEmbedding = _ar_mod.GlmImageRotaryEmbedding
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+def test_glm_image_ar_omits_hidden_pooler_payload():
+    assert GlmImageForConditionalGeneration.omni_pooler_payload_include_hidden is False
+
+
 # =============================================================================
 # Helper: Minimal config for testing
 # =============================================================================
diff --git a/tests/unit/higgs_audio_v3/test_higgs_audio_v3.py b/tests/model_executor/models/higgs_audio_v3/test_higgs_audio_v3.py
similarity index 91%
rename from tests/unit/higgs_audio_v3/test_higgs_audio_v3.py
rename to tests/model_executor/models/higgs_audio_v3/test_higgs_audio_v3.py
index b92b0095b..6d81f300a 100755
--- a/tests/unit/higgs_audio_v3/test_higgs_audio_v3.py
+++ b/tests/model_executor/models/higgs_audio_v3/test_higgs_audio_v3.py
@@ -8,6 +8,7 @@ without requiring the actual checkpoint or GPU.
 
 import asyncio
 import json
+import os
 import time
 from collections import OrderedDict, defaultdict
 from types import SimpleNamespace
@@ -15,6 +16,11 @@ from types import SimpleNamespace
 import pytest
 import torch
 
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # ---- AC-1: Configuration ----
 
 
@@ -240,6 +246,37 @@ class TestDelayPatternBehavior:
 class TestSamplerMethods:
     """Test the actual sampler and batched delay masking methods."""
 
+    @pytest.fixture(autouse=True)
+    def _stub_apply_top_k_top_p_on_cpu(self, monkeypatch):
+        # File is marked cpu; vLLM's apply_top_k_top_p uses Triton and rejects
+        # CPU tensors. Use a pure-PyTorch fallback that still honors top-k/top-p.
+        def _cpu_apply_top_k_top_p(logits, top_ks, top_ps):
+            out = logits.clone()
+            vocab = out.shape[-1]
+            top_ks = top_ks.reshape(-1)
+            top_ps = top_ps.reshape(-1)
+            for row in range(out.shape[0]):
+                k = int(top_ks[row].item())
+                p = float(top_ps[row].item())
+                if 0 < k < vocab:
+                    threshold = torch.topk(out[row], k).values[-1]
+                    out[row].masked_fill_(out[row] < threshold, float("-inf"))
+                if 0.0 < p < 1.0:
+                    sorted_logits, sorted_idx = torch.sort(out[row], descending=True)
+                    probs = torch.softmax(sorted_logits, dim=-1)
+                    cumprobs = torch.cumsum(probs, dim=-1)
+                    # Keep the first token that exceeds p; drop the rest.
+                    to_remove = cumprobs > p
+                    to_remove[1:] = to_remove[:-1].clone()
+                    to_remove[0] = False
+                    out[row, sorted_idx[to_remove]] = float("-inf")
+            return out
+
+        monkeypatch.setattr(
+            "vllm_omni.model_executor.models.higgs_audio_v3.higgs_audio_v3_talker.apply_top_k_top_p",
+            _cpu_apply_top_k_top_p,
+        )
+
     def _make_minimal_talker(self):
         """Create a minimal talker-like object with sampler/masking methods."""
         from vllm_omni.model_executor.models.higgs_audio_v3 import higgs_audio_v3_talker as mod
@@ -250,6 +287,7 @@ class TestSamplerMethods:
 
         t = FakeTalker()
         t._sample_audio_codes = mod.HiggsAudioV3TalkerForConditionalGeneration._sample_audio_codes.__get__(t)
+        t._expand_audio_sampling_params = mod.HiggsAudioV3TalkerForConditionalGeneration._expand_audio_sampling_params
         return t
 
     def _make_batched_sampler_talker(self, num_rows=4):
@@ -300,16 +338,30 @@ class TestSamplerMethods:
             "_audio_seed_mask_from_step_input",
         ):
             setattr(t, name, getattr(cls, name).__get__(t))
+        t._expand_audio_sampling_params = cls._expand_audio_sampling_params
         t._device_cache_key = cls._device_cache_key
         return t
 
+    @staticmethod
+    def _sampling_metadata(temperature=1.0, top_k=50, top_p=0.95):
+        return type(
+            "SamplingMetadata",
+            (),
+            {
+                "temperature": temperature,
+                "top_k": top_k,
+                "top_p": top_p,
+                "all_greedy": temperature is None,
+            },
+        )()
+
     def test_sample_respects_mask(self):
         """Tokens masked to -inf must never be sampled."""
         t = self._make_batched_sampler_talker(num_rows=1)
         logits = torch.full((10, 1026), float("-inf"))
         # Only token 500 is allowed for each row
         logits[:, 500] = 0.0
-        result = t._sample_audio_codes(logits)
+        result = t._sample_audio_codes(logits, self._sampling_metadata(), num_codebooks=1)
         assert result.shape == (10,)
         assert (result == 500).all(), f"Expected all 500, got {result.tolist()}"
 
@@ -320,10 +372,76 @@ class TestSamplerMethods:
         # Row 0: all masked
         # Row 1: only token 42 allowed
         logits[1, 42] = 0.0
-        result = t._sample_audio_codes(logits)
+        result = t._sample_audio_codes(logits, self._sampling_metadata(), num_codebooks=1)
         assert result.shape == (2,)
         assert result[1].item() == 42
 
+    def test_top_k_minus_one_disables_top_k_filtering(self, monkeypatch):
+        t = self._make_minimal_talker()
+        seen_probs = []
+
+        def fake_multinomial(probs, num_samples):
+            seen_probs.append(probs.clone())
+            return probs.argmax(dim=-1, keepdim=True)
+
+        monkeypatch.setattr(torch, "multinomial", fake_multinomial)
+
+        logits = torch.tensor([[4.0, 3.0, 2.0, 1.0]])
+        metadata = self._sampling_metadata(
+            temperature=1.0,
+            top_k=-1,
+            top_p=1.0,
+        )
+
+        t._sample_audio_codes(logits, metadata, num_codebooks=1)
+
+        assert len(seen_probs) == 1
+        assert torch.count_nonzero(seen_probs[0][0]).item() == 4
+
+    def test_sampling_metadata_invalid_temperature_is_sanitized(self, monkeypatch):
+        t = self._make_minimal_talker()
+        seen = []
+        monkeypatch.setattr(
+            torch, "multinomial", lambda probs, num_samples: seen.append(probs) or probs.argmax(-1, True)
+        )
+        logits = torch.tensor([[0.0, 2.0], [3.0, 0.0]])
+
+        result = t._sample_audio_codes(
+            logits,
+            self._sampling_metadata(torch.tensor([float("nan"), float("inf")])),
+            num_codebooks=1,
+        )
+
+        assert len(seen) == 1
+        assert torch.isfinite(seen[0]).all()
+        assert result.tolist() == [1, 0]
+
+    def test_sampling_metadata_is_expanded_per_request_and_vq(self, monkeypatch):
+        t = self._make_minimal_talker()
+        seen = []
+        monkeypatch.setattr(
+            torch, "multinomial", lambda probs, num_samples: seen.append(probs) or probs.argmax(-1, True)
+        )
+        cb_logits = torch.tensor([[[4.0, 3.0, 2.0, 1.0]] * 2] * 2)  # [2 requests, 2 VQs, 4 vocab]
+        logits = cb_logits.reshape(-1, cb_logits.shape[-1])
+        metadata = self._sampling_metadata(
+            temperature=torch.tensor([0.5, 1.0]),
+            top_k=torch.tensor([1, 4]),
+            top_p=torch.tensor([1.0, 0.8]),
+        )
+
+        temperatures, top_ks, top_ps = t._expand_audio_sampling_params(metadata, logits, num_codebooks=2)
+        t._sample_audio_codes(logits, metadata, num_codebooks=2)
+
+        torch.testing.assert_close(temperatures, torch.tensor([0.5, 0.5, 1.0, 1.0]))
+        assert top_ks.tolist() == [1, 1, 4, 4]
+        torch.testing.assert_close(top_ps, torch.tensor([1.0, 1.0, 0.8, 0.8]))
+        assert len(seen) == 1
+        torch.testing.assert_close(seen[0][0], seen[0][1])
+        torch.testing.assert_close(seen[0][2], seen[0][3])
+        assert torch.count_nonzero(seen[0][0]).item() == 1
+        assert torch.count_nonzero(seen[0][2]).item() > 1
+
     def test_delay_masking_forces_boc_during_delay(self):
         """During delay phase, codebooks beyond delay_count must have only BOC allowed."""
         from vllm_omni.model_executor.models.higgs_audio_v3.higgs_audio_v3_talker import BOC_ID
@@ -468,7 +586,9 @@ class TestSamplerMethods:
         t._fast_audio_sampler_gpu_fallback_reason = lambda **kwargs: None
         t._audio_codebook_logits_from_rows = lambda hidden, rows, all_rows=False: torch.zeros(2, 8, 1026)
         t._apply_delay_pattern_masking_batched = lambda cb_logits, audio_rows, all_rows=False: None
-        t._sample_audio_codes = lambda logits_2d: torch.zeros(int(logits_2d.shape[0]), dtype=torch.long)
+        t._sample_audio_codes = lambda logits_2d, *args, **kwargs: torch.zeros(
+            int(logits_2d.shape[0]), dtype=torch.long
+        )
         t._update_delay_state_batched = lambda *args, **kwargs: None
         t.sample = mod.HiggsAudioV3TalkerForConditionalGeneration.sample.__get__(t)
 
@@ -499,7 +619,9 @@ class TestSamplerMethods:
         t._fast_audio_sampler_gpu_fallback_reason = lambda **kwargs: None
         t._audio_codebook_logits_from_rows = lambda hidden, rows, all_rows=False: torch.zeros(2, 8, 1026)
         t._apply_delay_pattern_masking_batched = lambda cb_logits, audio_rows, all_rows=False: None
-        t._sample_audio_codes = lambda logits_2d: torch.zeros(int(logits_2d.shape[0]), dtype=torch.long)
+        t._sample_audio_codes = lambda logits_2d, *args, **kwargs: torch.zeros(
+            int(logits_2d.shape[0]), dtype=torch.long
+        )
         t._update_delay_state_batched = lambda *args, **kwargs: None
         t.sample = mod.HiggsAudioV3TalkerForConditionalGeneration.sample.__get__(t)
 
@@ -1205,17 +1327,12 @@ class TestRegistry:
         assert "higgs_multimodal_qwen3" in OMNI_PIPELINES
 
     def test_deploy_yaml_exists(self):
-        import os
-
-        # __file__ = tests/unit/higgs_audio_v3/test_*.py → 4 dirnames to repo root
-        repo_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
-        deploy_dir = os.path.join(repo_root, "vllm_omni", "deploy")
         for name in (
             "higgs_multimodal_qwen3.yaml",
             "higgs_multimodal_qwen3_high_throughput.yaml",
             "higgs_multimodal_qwen3_low_latency.yaml",
         ):
-            yaml_path = os.path.join(deploy_dir, name)
+            yaml_path = get_deploy_config_path(name)
             assert os.path.isfile(yaml_path), f"Deploy YAML not found at {yaml_path}"
 
 
diff --git a/tests/unit/mammoth_moda2/test_mammoth_moda2_config.py b/tests/model_executor/models/mammoth_moda2/test_mammoth_moda2_config.py
similarity index 72%
rename from tests/unit/mammoth_moda2/test_mammoth_moda2_config.py
rename to tests/model_executor/models/mammoth_moda2/test_mammoth_moda2_config.py
index 77b68ca3f..05d5dbdde 100644
--- a/tests/unit/mammoth_moda2/test_mammoth_moda2_config.py
+++ b/tests/model_executor/models/mammoth_moda2/test_mammoth_moda2_config.py
@@ -16,10 +16,13 @@ from vllm_omni.transformers_utils.configs.mammoth_moda2 import (
     Mammothmoda2Config,
     Mammothmoda2Qwen2_5_VLConfig,
     Mammothmoda2Qwen2_5_VLTextConfig,
+    Mammothmoda2Qwen3VLConfig,
+    Mammothmoda2Qwen3VLTextConfig,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
-@pytest.mark.cpu
 class TestMammothmoda2Config:
     """Tests for Mammothmoda2Config class."""
 
@@ -71,7 +74,6 @@ class TestMammothmoda2Config:
         assert config.llm_config is not None
 
 
-@pytest.mark.cpu
 class TestMammothmoda2Qwen2_5_VLConfig:
     """Tests for Mammothmoda2Qwen2_5_VLConfig class."""
 
@@ -89,3 +91,29 @@ class TestMammothmoda2Qwen2_5_VLConfig:
         assert hasattr(text_config, "vocab_size")
         assert hasattr(text_config, "image_token_id")
         assert hasattr(text_config, "video_token_id")
+
+
+class TestMammothmoda2Qwen3VLConfig:
+    def test_dev_config_uses_qwen3_vl_subconfigs(self):
+        config = Mammothmoda2Config(
+            llm_config={
+                "model_type": "mammothmoda2_qwen3_vl",
+                "text_config": {
+                    "model_type": "mammothmoda2_qwen3_vl_text",
+                    "vocab_size": 151936,
+                    "gen_vocab_size": 32800,
+                    "gen_vocab_start_index": 152064,
+                },
+                "vision_config": {
+                    "model_type": "mammothmoda2_qwen3_vl_vision",
+                    "deepstack_visual_indexes": [8, 16, 24],
+                },
+            }
+        )
+
+        assert isinstance(config.llm_config, Mammothmoda2Qwen3VLConfig)
+        assert isinstance(config.get_text_config(), Mammothmoda2Qwen3VLTextConfig)
+        # vLLM validates sampling against the complete base + visual vocabulary.
+        assert config.get_text_config().vocab_size == 152064 + 32800
+        assert config.get_text_config().gen_vocab_start_index == 152064
+        assert config.llm_config.vision_config.deepstack_visual_indexes == [8, 16, 24]
diff --git a/tests/model_executor/models/mimo_audio/test_mimo_audio_per_request_codes.py b/tests/model_executor/models/mimo_audio/test_mimo_audio_per_request_codes.py
new file mode 100644
index 000000000..4dc365ef0
--- /dev/null
+++ b/tests/model_executor/models/mimo_audio/test_mimo_audio_per_request_codes.py
@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression tests for MiMo-Audio per-request speech-code routing.
+
+Guards the cross-request audio-corruption class (same class as RFC #4316
+Issue 1 for MOSS-TTS): the fused thinker+talker emits one speech-code row per
+request, so ``codes["audio"]`` must be a batch-ordered **list** for the
+generic splitter (``to_payload_element``) to route ``element[idx]`` to
+request ``idx``. A batched ``(num_reqs, 1, 8, 4)`` tensor is only split
+correctly by the token-offset path when every request has exactly one
+scheduled token; in a mixed prefill+decode step the tensor's first dim
+matches neither token length, the splitter falls through to ``clone()``, and
+every request receives the whole batch — leaking codes across requests and
+crashing the async-chunk ragged-list conversion
+(``expected sequence of length 36 at dim 1 (got 144)``).
+
+CPU-only and weight-free: ``forward`` is driven on a bare model with
+``generate_codes`` stubbed to return row-indexed codes, so assertions on the
+payload prove which request got which row.
+"""
+
+from __future__ import annotations
+
+import functools
+
+import pytest
+
+torch = pytest.importorskip("torch")
+
+from vllm_omni.utils.mm_outputs import to_payload_element  # noqa: E402
+
+NUM_CODEBOOKS = 8
+GROUP_SIZE = 4
+
+
+@functools.lru_cache(maxsize=1)
+def _model_cls():
+    """Defer the import (pulls vLLM model_executor) until first use."""
+    from vllm_omni.model_executor.models.mimo_audio.mimo_audio import (
+        MiMoAudioForConditionalGeneration,
+    )
+
+    return MiMoAudioForConditionalGeneration
+
+
+def _row_indexed_codes(num_reqs: int) -> torch.Tensor:
+    """(num_reqs, 1, 8, 4) tensor where request r's codes all hold r."""
+    codes = torch.empty((num_reqs, 1, NUM_CODEBOOKS, GROUP_SIZE), dtype=torch.long)
+    for r in range(num_reqs):
+        codes[r] = r
+    return codes
+
+
+def _make_bare_model(next_speech_tokens, num_tokens: int):
+    """A model whose only behaviour is the emit logic under test."""
+    cls = _model_cls()
+    model = cls.__new__(cls)
+    model.model_stage = "fused_thinker_talker"
+    hidden = torch.zeros((num_tokens, 16), dtype=torch.float32)
+    model.generate_codes = lambda **kwargs: (next_speech_tokens, hidden)
+    return model
+
+
+def _emit(next_speech_tokens, num_tokens: int):
+    model = _make_bare_model(next_speech_tokens, num_tokens)
+    result = model.forward(
+        input_ids=torch.zeros((num_tokens,), dtype=torch.long),
+        positions=torch.zeros((num_tokens,), dtype=torch.long),
+    )
+    return result.multimodal_outputs["codes"]["audio"]
+
+
+class TestPerRequestCodeRouting:
+    def test_emit_is_batch_aligned_list(self):
+        audio = _emit(_row_indexed_codes(3), num_tokens=3)
+
+        assert isinstance(audio, list)
+        assert len(audio) == 3  # one entry per request, batch-aligned
+        for r, codes in enumerate(audio):
+            assert codes.shape == (1, 1, NUM_CODEBOOKS, GROUP_SIZE)
+            assert torch.all(codes == r)
+
+    def test_no_codes_step_emits_none(self):
+        audio = _emit(None, num_tokens=2)
+        assert audio is None
+
+    def test_mixed_prefill_decode_routes_by_request_index(self):
+        """req 1 prefills 7 tokens while reqs 0 and 2 decode: the splitter
+        must hand each request its own row, not the whole batch."""
+        audio = _emit(_row_indexed_codes(3), num_tokens=9)
+
+        seq_len = 9  # 1 (decode) + 7 (prefill) + 1 (decode) scheduled tokens
+        spans = [(0, 1), (1, 8), (8, 9)]
+        for idx, (start, end) in enumerate(spans):
+            routed = to_payload_element(
+                audio,
+                idx,
+                start,
+                end,
+                seq_len=seq_len,
+                scheduled_seq_len=seq_len,
+            )
+            assert routed.shape == (1, 1, NUM_CODEBOOKS, GROUP_SIZE)
+            assert torch.all(routed == idx), f"req {idx} received another request's codes"
+
+    def test_pure_decode_routes_by_request_index(self):
+        """One token per request (the only case the old tensor emit handled)."""
+        audio = _emit(_row_indexed_codes(4), num_tokens=4)
+
+        for idx in range(4):
+            routed = to_payload_element(audio, idx, idx, idx + 1, seq_len=4, scheduled_seq_len=4)
+            assert torch.all(routed == idx)
+
+    def test_routed_codes_do_not_alias_the_emit(self):
+        """The splitter clones list elements; mutating the routed payload must
+        not corrupt another request's view of the emit."""
+        audio = _emit(_row_indexed_codes(2), num_tokens=5)
+        routed = to_payload_element(audio, 0, 0, 4, seq_len=5, scheduled_seq_len=5)
+        routed.fill_(99)
+        assert torch.all(audio[0] == 0)
diff --git a/tests/model_executor/models/ming_tts/test_ming_shared_modules.py b/tests/model_executor/models/ming_tts/test_ming_shared_modules.py
index c5966dd60..7a0ad68de 100644
--- a/tests/model_executor/models/ming_tts/test_ming_shared_modules.py
+++ b/tests/model_executor/models/ming_tts/test_ming_shared_modules.py
@@ -12,17 +12,24 @@ from vllm_omni.model_executor.models.common.ming.fm import Solver
 from vllm_omni.model_executor.models.ming_tts.constants import (
     AGGREGATOR_HIDDEN_SIZE,
     HISTORY_PATCH_SIZE,
+    KEY_SPEAKER_EMBEDDING,
+    KEY_SPEAKER_SAMPLE_RATES,
+    KEY_SPEAKER_WAVEFORM,
+    KEY_SPEAKER_WAVEFORM_LENGTHS,
     LATENT_DIM,
     LLM_HIDDEN_SIZE,
     LLM_VOCAB_SIZE,
     PATCH_SIZE,
     SAMPLE_RATE,
+    SPEAKER_EMBEDDING_DIM,
     VAE_PATCH_SIZE,
 )
 from vllm_omni.model_executor.models.ming_tts.flowloss_head import FlowLoss
 from vllm_omni.model_executor.models.ming_tts.ming_tts_llm import MingLLMModel
+from vllm_omni.model_executor.models.ming_tts.speaker_extractor import _resolve_speaker_embeddings
 from vllm_omni.model_executor.models.ming_tts.validation import validate_ming_tts_config
 from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.utils.speaker_cache import SpeakerEmbeddingCache
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.tts]
 
@@ -99,6 +106,122 @@ def test_ming_instruction_parser_preserves_dense_and_flash_defaults():
     assert flash_fields == {"风格": "calm"}
 
 
+class _FakeMingSpeakerExtractor:
+    def __init__(self):
+        self.calls: list[tuple[torch.Tensor, int]] = []
+
+    def extract_from_waveform(self, waveform, sample_rate):
+        waveform = torch.as_tensor(waveform).detach().clone()
+        self.calls.append((waveform, int(sample_rate)))
+        return torch.full((SPEAKER_EMBEDDING_DIM,), float(len(self.calls)), dtype=torch.float32)
+
+
+def _make_ming_speaker_wrapper():
+    return SimpleNamespace(
+        _speaker_cache=SpeakerEmbeddingCache(max_bytes=1024 * 1024),
+        _speaker_extractor=_FakeMingSpeakerExtractor(),
+        ming_config=SimpleNamespace(sample_rate=SAMPLE_RATE),
+    )
+
+
+def test_ming_stage0_speaker_cache_extracts_once_and_honors_created_at():
+    wrapper = _make_ming_speaker_wrapper()
+    waveform = torch.arange(12, dtype=torch.float32).reshape(1, -1)
+    info = {
+        KEY_SPEAKER_WAVEFORM: waveform,
+        KEY_SPEAKER_WAVEFORM_LENGTHS: torch.tensor([12]),
+        "voice_name": "UploadedVoice",
+        "voice_created_at": 123,
+    }
+
+    first = _resolve_speaker_embeddings(wrapper, info)
+    cached = _resolve_speaker_embeddings(
+        wrapper,
+        {
+            "voice_name": "uploadedvoice",
+            "voice_created_at": 123,
+        },
+    )
+    refreshed = _resolve_speaker_embeddings(
+        wrapper,
+        {
+            **info,
+            "voice_created_at": 124,
+        },
+    )
+
+    assert first is not None and cached is not None and refreshed is not None
+    torch.testing.assert_close(first[0], cached[0])
+    assert torch.all(first[0] == 1)
+    assert torch.all(refreshed[0] == 2)
+    assert len(wrapper._speaker_extractor.calls) == 2
+
+
+def test_ming_stage0_speaker_extraction_splits_multiple_waveforms():
+    wrapper = _make_ming_speaker_wrapper()
+
+    embeddings = _resolve_speaker_embeddings(
+        wrapper,
+        {
+            KEY_SPEAKER_WAVEFORM: torch.arange(10, dtype=torch.float32).reshape(1, -1),
+            KEY_SPEAKER_WAVEFORM_LENGTHS: torch.tensor([4, 6]),
+            KEY_SPEAKER_SAMPLE_RATES: torch.tensor([16000, 24000]),
+        },
+    )
+
+    assert embeddings is not None and len(embeddings) == 2
+    assert [call[0].shape[-1] for call in wrapper._speaker_extractor.calls] == [4, 6]
+    assert [call[1] for call in wrapper._speaker_extractor.calls] == [16000, 24000]
+
+
+def test_ming_stage0_speaker_extraction_rejects_mismatched_sample_rates():
+    wrapper = _make_ming_speaker_wrapper()
+
+    with pytest.raises(ValueError, match="Invalid Ming speaker sample rates"):
+        _resolve_speaker_embeddings(
+            wrapper,
+            {
+                KEY_SPEAKER_WAVEFORM: torch.arange(10, dtype=torch.float32).reshape(1, -1),
+                KEY_SPEAKER_WAVEFORM_LENGTHS: torch.tensor([4, 6]),
+                KEY_SPEAKER_SAMPLE_RATES: torch.tensor([16000]),
+            },
+        )
+
+
+def test_ming_stage0_prompt_waveform_does_not_trigger_speaker_extraction():
+    wrapper = _make_ming_speaker_wrapper()
+
+    embeddings = _resolve_speaker_embeddings(
+        wrapper,
+        {
+            "prompt_waveform": torch.ones((1, 10)),
+            "prompt_text": "Reference transcript.",
+        },
+    )
+
+    assert embeddings is None
+    assert not wrapper._speaker_extractor.calls
+
+
+def test_ming_stage0_direct_speaker_embedding_bypasses_extractor():
+    wrapper = _make_ming_speaker_wrapper()
+    direct = torch.full((SPEAKER_EMBEDDING_DIM,), 0.25)
+
+    embeddings = _resolve_speaker_embeddings(
+        wrapper,
+        {
+            KEY_SPEAKER_EMBEDDING: direct,
+            KEY_SPEAKER_WAVEFORM: torch.ones((1, 10)),
+            "voice_name": "direct",
+            "voice_created_at": 1,
+        },
+    )
+
+    assert embeddings is not None
+    torch.testing.assert_close(embeddings[0], direct)
+    assert not wrapper._speaker_extractor.calls
+
+
 def _make_ming_logits_model(vocab_size=8):
     model = object.__new__(MingLLMModel)
     model.ming_config = SimpleNamespace(
diff --git a/tests/model_executor/models/minicpmo_4_5/test_audio_chunk_mask.py b/tests/model_executor/models/minicpmo_4_5/test_audio_chunk_mask.py
new file mode 100644
index 000000000..7769b38be
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_audio_chunk_mask.py
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression tests for MiniCPM-o 4.5 audio chunk attention masks."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _reference_chunk_mask(
+    size: int,
+    chunk_size: int,
+    num_left_chunks: int,
+    num_lookhead: int,
+) -> torch.Tensor:
+    """Preserve the original row-by-row implementation as a test oracle."""
+    mask = torch.zeros(size, size, dtype=torch.bool)
+    for row in range(size):
+        if num_left_chunks < 0:
+            start = 0
+        else:
+            start = max(
+                (row // chunk_size - num_left_chunks) * chunk_size,
+                0,
+            )
+        end = min(
+            (row // chunk_size + 1) * chunk_size + num_lookhead,
+            size,
+        )
+        mask[row, start:end] = True
+    return mask
+
+
+@pytest.mark.parametrize("size", [0, 1, 49, 50, 51, 1500])
+@pytest.mark.parametrize("chunk_size", [1, 17, 50])
+@pytest.mark.parametrize("num_left_chunks", [-1, 0, 1, 3])
+@pytest.mark.parametrize("num_lookhead", [0, 1, 7])
+def test_subsequent_chunk_mask_matches_row_by_row_reference(
+    size: int,
+    chunk_size: int,
+    num_left_chunks: int,
+    num_lookhead: int,
+) -> None:
+    actual = MiniCPMO45OmniLLMForConditionalGeneration.subsequent_chunk_mask(
+        None,
+        size=size,
+        chunk_size=chunk_size,
+        num_left_chunks=num_left_chunks,
+        num_lookhead=num_lookhead,
+    )
+    expected = _reference_chunk_mask(
+        size,
+        chunk_size,
+        num_left_chunks,
+        num_lookhead,
+    )
+
+    assert actual.dtype == torch.bool
+    assert actual.shape == (size, size)
+    assert torch.equal(actual, expected)
diff --git a/tests/model_executor/models/minicpmo_4_5/test_audio_pool_step.py b/tests/model_executor/models/minicpmo_4_5/test_audio_pool_step.py
new file mode 100644
index 000000000..9fe2f144a
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_audio_pool_step.py
@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression tests for MiniCPM-o 4.5 audio placeholder pooling."""
+
+from __future__ import annotations
+
+import math
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMProcessingInfo,
+    MiniCPMOConfig,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeProcessor:
+    """Minimal processor surface used by ``get_audio_placeholder``."""
+
+    def __init__(self) -> None:
+        # Reproduce the cached vLLM processor's legacy initial state.
+        self.pool_step = 2
+        self.audio_processor = SimpleNamespace(hop_length=160)
+        self.image_processor = SimpleNamespace(mean=[0.0], std=[1.0])
+
+    def get_audio_placeholder(
+        self,
+        audio_lens: int,
+        chunk_input: bool = True,
+        chunk_length: int = 1,
+    ) -> str:
+        del chunk_input, chunk_length
+        feature_lens = math.ceil(audio_lens / self.audio_processor.hop_length)
+        cnn_feature_lens = (feature_lens - 1) // 2 + 1
+        output_lens = (cnn_feature_lens - self.pool_step) // self.pool_step + 1
+        return "<unk>" * output_lens
+
+
+def _processing_info(pool_step: int, processor: _FakeProcessor) -> MiniCPMO45OmniLLMProcessingInfo:
+    info = object.__new__(MiniCPMO45OmniLLMProcessingInfo)
+    info.ctx = SimpleNamespace(
+        tokenizer=object(),
+        get_hf_config=lambda: SimpleNamespace(audio_pool_step=pool_step),
+        get_hf_processor=lambda **kwargs: processor,
+    )
+    return info
+
+
+@pytest.mark.parametrize(
+    ("configured_pool_step", "expected_placeholders"),
+    [(5, 50), (2, 125)],
+)
+def test_audio_placeholders_follow_checkpoint_pool_step(
+    configured_pool_step: int,
+    expected_placeholders: int,
+) -> None:
+    """The prompt path must use the same pool step as the audio encoder."""
+    processor = _FakeProcessor()
+    info = _processing_info(configured_pool_step, processor)
+
+    placeholder = info.get_audio_placeholder(5 * 16_000)
+
+    assert processor.pool_step == configured_pool_step
+    assert placeholder.count("<unk>") == expected_placeholders
+
+
+def test_minicpmo_4_5_pool_step_defaults_to_checkpoint_value() -> None:
+    assert MiniCPMOConfig().audio_pool_step == 5
diff --git a/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py b/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py
new file mode 100644
index 000000000..c47aa8bbf
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py
@@ -0,0 +1,695 @@
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.model_executor.models.minicpmo_4_5.batched_token2wav import (
+    BatchedToken2Wav,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav import (
+    MiniCPMO45Code2Wav,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.calls: list[int] = []
+        self.last_chunk_calls: list[bool] = []
+
+    def forward_chunk(self, xs, last_chunk=False, cnn_cache=None, att_cache=None):
+        batch, length, _ = xs.shape
+        self.calls.append(batch)
+        self.last_chunk_calls.append(last_chunk)
+        old_length = 0 if att_cache is None else att_cache.shape[3]
+        output = xs[:, : max(1, length - 1)]
+        cnn = xs[:, :1, :].transpose(1, 2).contiguous()
+        marker = xs[:, 0, 0].reshape(1, batch, 1, 1, 1)
+        att = marker.expand(1, batch, 1, old_length + output.shape[1], 1).clone()
+        return output, cnn, att
+
+
+class _FakeBlock:
+    def __init__(self):
+        conv1 = SimpleNamespace(causal_padding=(1, 0))
+        self.conv = SimpleNamespace(
+            in_channels=1,
+            out_channels=1,
+            block=[None, conv1],
+        )
+        self.attn = SimpleNamespace(num_heads=1, head_dim=1)
+
+
+class _FakeEstimator(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.blocks = [_FakeBlock()]
+        self.cfg_batches: list[int] = []
+        self.speaker_order: list[list[float]] = []
+
+    def t_embedder(self, time):
+        return time[:, None]
+
+    def blocks_forward_chunk(
+        self,
+        inputs,
+        time,
+        mask,
+        cnn_cache,
+        att_cache,
+        cnn_out,
+        att_out,
+    ):
+        del time, mask, cnn_cache, att_cache
+        self.cfg_batches.append(inputs.shape[0])
+        self.speaker_order.append(inputs[:, 2, 0].tolist())
+        marker = inputs[:, 1, 0]
+        cnn_out.copy_(marker.reshape(1, -1, 1, 1).expand_as(cnn_out))
+        att_out.copy_(marker.reshape(1, -1, 1, 1, 1).expand_as(att_out))
+        return inputs[:, 1:2]
+
+
+class _FakeDecoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.estimator = _FakeEstimator()
+        self.inference_cfg_rate = 0.7
+        self.register_buffer("rand_noise", torch.zeros(1, 1, 100), persistent=False)
+
+
+class _FakeFlow(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.encoder = _FakeEncoder()
+        self.encoder_proj = nn.Identity()
+        self.decoder = _FakeDecoder()
+        self.spk_embed_affine_layer = nn.Identity()
+
+    def input_embedding(self, tokens):
+        return tokens.to(torch.float32).unsqueeze(-1)
+
+
+class _FakeHiFT(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.calls: list[int] = []
+
+    def forward(self, mel, source):
+        del source
+        self.calls.append(mel.shape[0])
+        speech = mel[:, 0].repeat_interleave(3, dim=1)
+        generated_source = speech[:, None]
+        return speech, generated_source
+
+
+class _FakeToken2Wav:
+    def __init__(self):
+        self.flow = _FakeFlow()
+        self.hift = _FakeHiFT()
+        self.float16 = False
+        self.n_timesteps = 2
+        self.mel_cache_len = 1
+        self.source_cache_len = 2
+        self.speech_window = torch.hamming_window(4, periodic=False)
+        self.prompt_calls = 0
+
+    def _prepare_prompt(self, prompt_wav):
+        del prompt_wav
+        self.prompt_calls += 1
+        return (
+            torch.tensor([[5, 6]], dtype=torch.long),
+            torch.tensor([2], dtype=torch.int32),
+            torch.ones(1, 1),
+            torch.ones(1, 4, 1),
+            torch.tensor([4], dtype=torch.int32),
+        )
+
+    def stream(self, *args, **kwargs):
+        raise AssertionError("sequential stream fallback must never be called")
+
+    def __call__(self, *args, **kwargs):
+        raise AssertionError("sequential __call__ fallback must never be called")
+
+
+def _config(minimum: int = 1):
+    return SimpleNamespace(
+        model_config=SimpleNamespace(
+            model="/fake/model",
+            stage_connector_config={
+                "extra": {
+                    "code2wav_min_batch_size": minimum,
+                    "prompt_cache_id": "shared",
+                    "prompt_wav": "/fake/prompt.wav",
+                }
+            },
+        )
+    )
+
+
+def _model():
+    token2wav = _FakeToken2Wav()
+    backend = BatchedToken2Wav(token2wav)
+    model = MiniCPMO45Code2Wav(vllm_config=_config())
+    model.backend = backend
+    return model, token2wav
+
+
+def _info(
+    request_id: str,
+    chunk_seq: int,
+    codes: list[int],
+    *,
+    last_chunk: bool = False,
+    cache_epoch: int = 0,
+):
+    return {
+        "codes": {"audio": torch.tensor(codes, dtype=torch.long)},
+        "meta": {
+            "request_id": request_id,
+            "chunk_seq": chunk_seq,
+            "cache_epoch": cache_epoch,
+            "last_chunk": last_chunk,
+            "prompt_cache_id": "shared",
+        },
+    }
+
+
+def _forward(model, infos, placeholder_counts=None, request_ids=None):
+    placeholder_counts = placeholder_counts or [1] * len(infos)
+    input_ids = torch.zeros(sum(placeholder_counts), dtype=torch.long)
+    return model(
+        input_ids=input_ids,
+        seq_token_counts=placeholder_counts,
+        runtime_additional_information=infos,
+        request_ids=request_ids,
+    )
+
+
+def test_adapter_runs_true_batch_cfg_and_splits_request_caches():
+    token2wav = _FakeToken2Wav()
+    adapter = BatchedToken2Wav(token2wav)
+    prompt = adapter.prepare_prompt("shared", "/fake/prompt.wav")
+    states = adapter.setup_batch(prompt, 2)
+    audios, states = adapter.decode_batch(
+        torch.tensor([[10, 11], [20, 21]]),
+        prompt,
+        states,
+        last_chunk=False,
+    )
+
+    assert token2wav.prompt_calls == 1
+    assert token2wav.flow.encoder.calls == [2, 2]
+    assert token2wav.flow.decoder.estimator.cfg_batches == [4, 4, 4, 4]
+    assert all(order == [1.0, 1.0, 0.0, 0.0] for order in token2wav.flow.decoder.estimator.speaker_order)
+    assert token2wav.hift.calls == [2]
+    assert len(audios) == 2
+    cache0 = states[0].flow_cache["estimator_cnn_cache"]
+    cache1 = states[1].flow_cache["estimator_cnn_cache"]
+    assert cache0.data_ptr() != cache1.data_ptr()
+    assert cache0[0, 0, 0, 0, 0].item() == 10
+    assert cache1[0, 0, 0, 0, 0].item() == 20
+
+
+def test_fade_in_out_limits_overlap_to_available_previous_audio():
+    speech = torch.arange(6, dtype=torch.float32).reshape(1, -1)
+    previous = torch.full((1, 3), 2.0)
+    window = torch.hamming_window(8, periodic=False)
+
+    actual = BatchedToken2Wav._fade_in_out(speech, previous, window)
+
+    expected = speech.clone()
+    expected[..., :3] = speech[..., :3] * window[:3] + previous * window[-3:]
+    torch.testing.assert_close(actual, expected)
+
+
+def test_estimator_cache_stack_split_round_trip_preserves_cfg_rows():
+    token2wav = _FakeToken2Wav()
+    adapter = BatchedToken2Wav(token2wav)
+    prompt = adapter.prepare_prompt("shared", "/fake/prompt.wav")
+    states = adapter.setup_batch(prompt, 2)
+    _, states = adapter.decode_batch(
+        torch.tensor([[10, 11], [20, 21]]),
+        prompt,
+        states,
+        last_chunk=False,
+    )
+
+    stacked = adapter._stack_flow_cache(states)
+    assert stacked["estimator_cnn_cache"].shape[2] == 4
+    assert stacked["estimator_att_cache"].shape[2] == 4
+    restored = adapter._split_flow_cache(stacked, 2)
+    for original, round_tripped in zip(states, restored, strict=True):
+        torch.testing.assert_close(
+            round_tripped["estimator_cnn_cache"],
+            original.flow_cache["estimator_cnn_cache"],
+        )
+        torch.testing.assert_close(
+            round_tripped["estimator_att_cache"],
+            original.flow_cache["estimator_att_cache"],
+        )
+
+
+def test_model_preserves_output_slots_and_prefers_runtime_codes():
+    model, token2wav = _model()
+    output = _forward(
+        model,
+        [_info("a", 0, [10, 11]), _info("b", 0, [20, 21])],
+        placeholder_counts=[3, 1],
+    )
+
+    audios = output.multimodal_outputs["model_outputs"]
+    assert len(audios) == 2
+    assert len(output.multimodal_outputs["sr"]) == 2
+    assert all(sr.item() == 24000 for sr in output.multimodal_outputs["sr"])
+    assert all(audio.dtype == torch.float32 for audio in audios)
+    # Fake CFM uses two Euler steps whose deltas sum to one. Its conditional
+    # row is mu and its unconditional row is zero, so CFG produces 1.7 * mu.
+    torch.testing.assert_close(audios[0][0], torch.tensor(1.7 * 10))
+    torch.testing.assert_close(audios[1][0], torch.tensor(1.7 * 20))
+    assert token2wav.flow.encoder.calls[-1] == 2
+
+
+def test_code2wav_projects_duplex_metadata_to_final_audio_output():
+    model, token2wav = _model()
+    segment = _info("duplex", 0, [10, 11])
+    segment_text_utf8 = torch.tensor(list(b"hello"), dtype=torch.uint8)
+    segment["meta"].update(
+        {
+            "duplex_epoch": 3,
+            "duplex_turn_id": 7,
+            "llm_output_text_utf8": segment_text_utf8,
+            "tts_is_last_chunk": True,
+            "turn_end": False,
+        }
+    )
+
+    segment_output = _forward(model, [segment])
+
+    assert segment_output.multimodal_outputs["meta.turn_end"][0].item() is False
+    # A Talker unit boundary only drains pending codec tokens. The official
+    # streaming path keeps Token2wav open until the assistant turn ends.
+    assert token2wav.flow.encoder.last_chunk_calls[-1] is False
+    assert "duplex" in model._states
+
+    final = _info("duplex", 1, [12, 13], last_chunk=True)
+    final["meta"].update(segment["meta"])
+    final["meta"]["chunk_seq"] = 1
+    final["meta"]["last_chunk"] = True
+    final["meta"]["turn_end"] = True
+    output = _forward(model, [final])
+
+    payload = output.multimodal_outputs
+    assert "meta" not in payload
+    assert payload["meta.duplex_epoch"][0].item() == 3
+    assert payload["meta.duplex_turn_id"][0].item() == 7
+    torch.testing.assert_close(
+        payload["meta.llm_output_text_utf8"][0],
+        segment_text_utf8,
+    )
+    assert payload["meta.tts_is_last_chunk"][0].item() is True
+    assert payload["meta.turn_end"][0].item() is True
+    assert token2wav.flow.encoder.last_chunk_calls[-1] is True
+    assert "duplex" not in model._states
+
+
+def test_initial_empty_segment_marker_initializes_stream_without_audio():
+    model, token2wav = _model()
+    boundary = _info("duplex", 0, [])
+    boundary["meta"].update(
+        {
+            "code_flat_numel": 0,
+            "tts_is_last_chunk": True,
+            "turn_end": False,
+        }
+    )
+
+    output = _forward(model, [boundary])
+
+    assert output.multimodal_outputs["model_outputs"][0].numel() == 0
+    assert "duplex" in model._states
+    assert token2wav.hift.calls == []
+
+    resumed = _info(
+        "duplex",
+        1,
+        [4218, 4218, 4218, 10, 11, 12, 13, 14],
+    )
+    output = _forward(model, [resumed])
+
+    assert output.multimodal_outputs["model_outputs"][0].numel() > 0
+    assert "duplex" in model._states
+
+
+def test_shared_runtime_prompt_recreates_missing_file_before_second_owner(tmp_path, monkeypatch):
+    monkeypatch.setattr("tempfile.gettempdir", lambda: str(tmp_path))
+    model, _ = _model()
+    reference = torch.tensor([0.0, 0.25, -0.25, 0.0])
+
+    first = _info("voice-a", 0, [10, 11])
+    first["codes"]["ref"] = reference
+    first["meta"]["ref_audio_sr"] = 16000
+    first["meta"].pop("prompt_cache_id")
+    _forward(model, [first], request_ids=["internal-a"])
+
+    prompt_key = model._request_prompt_keys["internal-a"]
+    prompt_path = Path(model._runtime_prompts[prompt_key].path)
+    prompt_path.unlink()
+
+    second = _info("voice-b", 0, [12, 13])
+    second["codes"]["ref"] = reference
+    second["meta"]["ref_audio_sr"] = 16000
+    second["meta"].pop("prompt_cache_id")
+    _forward(model, [second], request_ids=["internal-b"])
+
+    assert prompt_path.is_file()
+    assert model._runtime_prompts[prompt_key].owners == {"internal-a", "internal-b"}
+
+    model.on_requests_finished(["internal-a"])
+    assert prompt_path.is_file()
+    assert model._runtime_prompts[prompt_key].owners == {"internal-b"}
+
+    model.on_requests_finished(["internal-b"])
+    assert not prompt_path.exists()
+    assert prompt_key not in model._runtime_prompts
+
+
+def test_runtime_prompt_write_failure_does_not_publish_partial_file(tmp_path, monkeypatch):
+    monkeypatch.setattr("tempfile.gettempdir", lambda: str(tmp_path))
+    model, _ = _model()
+    reference = torch.tensor([0.0, 0.25, -0.25, 0.0])
+
+    def fail_after_partial_write(path, *_args, **_kwargs):
+        Path(path).write_bytes(b"partial")
+        raise OSError("simulated write failure")
+
+    monkeypatch.setattr(
+        "vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav.sf.write",
+        fail_after_partial_write,
+    )
+
+    with pytest.raises(OSError, match="simulated write failure"):
+        model._materialize_runtime_prompt(reference, 16000)
+
+    assert len(model._runtime_prompts) == 1
+    entry = next(iter(model._runtime_prompts.values()))
+    assert not Path(entry.path).exists()
+    assert list(Path(entry.path).parent.iterdir()) == []
+
+
+def test_runtime_prompt_files_are_isolated_between_model_instances(tmp_path, monkeypatch):
+    monkeypatch.setattr("tempfile.gettempdir", lambda: str(tmp_path))
+    first_model, _ = _model()
+    second_model, _ = _model()
+    reference = torch.tensor([0.0, 0.25, -0.25, 0.0])
+
+    def runtime_ref_info(request_id: str):
+        info = _info(request_id, 0, [10, 11])
+        info["codes"]["ref"] = reference
+        info["meta"]["ref_audio_sr"] = 16000
+        info["meta"].pop("prompt_cache_id")
+        return info
+
+    _forward(first_model, [runtime_ref_info("voice-a")], request_ids=["internal-a"])
+    _forward(second_model, [runtime_ref_info("voice-b")], request_ids=["internal-b"])
+
+    first_key = first_model._request_prompt_keys["internal-a"]
+    second_key = second_model._request_prompt_keys["internal-b"]
+    first_path = Path(first_model._runtime_prompts[first_key].path)
+    second_path = Path(second_model._runtime_prompts[second_key].path)
+    assert first_key == second_key
+    assert first_path != second_path
+    assert first_path.is_file()
+    assert second_path.is_file()
+
+    first_model.on_requests_finished(["internal-a"])
+    assert not first_path.exists()
+    assert second_path.is_file()
+
+    second_model.on_requests_finished(["internal-b"])
+    assert not second_path.exists()
+
+
+def test_mixed_final_exact_buckets_keep_order_and_release_only_final_states():
+    model, _ = _model()
+    _forward(
+        model,
+        [_info(name, 0, [index + 1, index + 2]) for index, name in enumerate(("a", "b", "c", "d"))],
+    )
+    output = _forward(
+        model,
+        [
+            _info("a", 1, [11, 12]),
+            _info("c", 1, [31, 32, 33], last_chunk=True),
+            _info("b", 1, [21, 22]),
+            _info("d", 1, [41, 42, 43], last_chunk=True),
+        ],
+    )
+
+    audios = output.multimodal_outputs["model_outputs"]
+    window = torch.hamming_window(4, periodic=False)
+    overlap_scale = 1.7 * (window[0] + window[2])
+    expected = torch.tensor([1, 3, 2, 4], dtype=torch.float32) * overlap_scale
+    actual = torch.stack([audio[0] for audio in audios])
+    torch.testing.assert_close(actual, expected)
+    assert set(model._states) == {"a", "b"}
+
+
+def test_empty_final_sentinel_emits_empty_and_releases_state_without_compute():
+    model, token2wav = _model()
+    _forward(model, [_info("a", 0, [1, 2]), _info("b", 0, [3, 4])])
+    hift_calls = list(token2wav.hift.calls)
+    output = _forward(
+        model,
+        [
+            _info("a", 1, [], last_chunk=True),
+            _info("b", 1, [], last_chunk=True),
+        ],
+    )
+
+    assert [audio.numel() for audio in output.multimodal_outputs["model_outputs"]] == [0, 0]
+    assert model._states == {}
+    assert token2wav.hift.calls == hift_calls
+
+
+def test_empty_final_ignores_generation_scheduler_placeholder_token():
+    model, _ = _model()
+    _forward(model, [_info("a", 0, [1, 2]), _info("b", 0, [3, 4])])
+    infos = [_info("a", 1, [], last_chunk=True), _info("b", 1, [], last_chunk=True)]
+    for info in infos:
+        info.pop("codes")
+        info["meta"]["code_flat_numel"] = 0
+
+    output = _forward(model, infos, placeholder_counts=[1, 1])
+
+    assert [audio.numel() for audio in output.multimodal_outputs["model_outputs"]] == [0, 0]
+    assert model._states == {}
+
+
+@pytest.mark.parametrize(
+    "info",
+    [
+        # The runner injects the engine request id on every step (GPU
+        # _preprocess, NPU _gather_runtime_additional_information)...
+        {"request_id": "a", "meta": {"request_id": "a"}},
+        # ...but a pre-warm step can also reach the model with nothing at all.
+        {},
+    ],
+)
+def test_prewarm_placeholder_step_emits_silence_without_touching_state(info):
+    # async-chunk pre-warm submits Stage 2 with a reserved placeholder prompt.
+    # If it gets scheduled before the first codec window lands, those reserved
+    # tokens must neither be vocoded nor held to the codec payload contract.
+    model, token2wav = _model()
+
+    output = _forward(model, [info], request_ids=["a"])
+
+    assert output.multimodal_outputs["model_outputs"][0].numel() == 0
+    assert model._states == {}
+    assert token2wav.hift.calls == []
+
+
+def test_metadata_only_payload_still_decodes_codec_from_prompt_tokens():
+    # The connector strips 1-D codec tensors out of additional_information and
+    # leaves them in the prompt tokens, so a real chunk reaches the model as
+    # producer metadata plus input ids. It must still be vocoded.
+    model, _ = _model()
+    info = {
+        "request_id": "a",
+        "meta": {
+            "request_id": "a",
+            "chunk_seq": 0,
+            "code_flat_numel": 2,
+            "prompt_cache_id": "shared",
+        },
+    }
+
+    output = _forward(model, [info], placeholder_counts=[2])
+
+    assert output.multimodal_outputs["model_outputs"][0].numel() > 0
+    assert set(model._states) == {"a"}
+
+
+def test_non_final_chunk_shorter_than_lookahead_window_is_rejected():
+    token2wav = _FakeToken2Wav()
+    token2wav.flow.encoder.pre_lookahead_layer = SimpleNamespace(pre_lookahead_len=3)
+    adapter = BatchedToken2Wav(token2wav)
+    prompt = adapter.prepare_prompt("shared", "/fake/prompt.wav")
+    states = adapter.setup_batch(prompt, 1)
+
+    with pytest.raises(RuntimeError, match="chunk_below_lookahead_window"):
+        adapter.decode_batch(torch.tensor([[10]]), prompt, states, last_chunk=False)
+
+    # The final chunk is zero-padded by the encoder, so it stays decodable.
+    audios, _ = adapter.decode_batch(torch.tensor([[10]]), prompt, states, last_chunk=True)
+    assert len(audios) == 1
+
+
+def test_forward_builds_backend_when_weight_loading_was_skipped(monkeypatch):
+    # load_format=dummy never calls load_weights(), so Stage 2 would otherwise
+    # reach its first request with no Token2wav assets at all.
+    model = MiniCPMO45Code2Wav(vllm_config=_config())
+    token2wav = _FakeToken2Wav()
+    builds = 0
+
+    def build_backend():
+        nonlocal builds
+        builds += 1
+        model.backend = BatchedToken2Wav(token2wav)
+
+    monkeypatch.setattr(model, "_build_backend", build_backend)
+
+    output = _forward(model, [_info("a", 0, [10, 11])])
+    _forward(model, [_info("a", 1, [12, 13])])
+
+    assert builds == 1
+    assert output.multimodal_outputs["model_outputs"][0].numel() > 0
+
+
+@pytest.mark.parametrize(
+    ("info", "reason"),
+    [
+        (_info("a", 0, [1, 2], cache_epoch=-1), "negative_stream_position"),
+        (_info("a", 0, [1, 2]), "stale_or_reordered_chunk"),
+        (_info("a", 2, [1, 2]), "stale_or_reordered_chunk"),
+    ],
+)
+def test_stale_epoch_and_reordered_chunks_are_rejected(info, reason):
+    model, _ = _model()
+    _forward(model, [_info("a", 0, [1, 2]), _info("b", 0, [3, 4])])
+
+    with pytest.raises(RuntimeError, match=reason):
+        _forward(model, [info, _info("b", 1, [3, 4])])
+
+
+def test_singleton_and_mixed_shape_buckets_use_same_batched_backend_without_fallback():
+    model, token2wav = _model()
+    _forward(model, [_info("a", 0, [1, 2]), _info("b", 0, [3, 4])])
+    output = _forward(model, [_info("a", 1, [5, 6]), _info("b", 1, [7, 8, 9])])
+
+    assert len(output.multimodal_outputs["model_outputs"]) == 2
+    # Exact-shape buckets execute independently but both use the same vectorized
+    # adapter; there is no Token2wav.stream/__call__ fallback.
+    assert token2wav.hift.calls[-2:] == [1, 1]
+
+
+def test_backend_failure_does_not_commit_any_request_state(monkeypatch):
+    model, _ = _model()
+    _forward(
+        model,
+        [_info(name, 0, [index + 1, index + 2]) for index, name in enumerate(("a", "b", "c", "d"))],
+    )
+    before = dict(model._states)
+    original = model.backend.decode_batch
+    call_count = 0
+
+    def fail(*args, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        if call_count == 2:
+            raise RuntimeError("injected failure")
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(model.backend, "decode_batch", fail)
+    with pytest.raises(RuntimeError, match="injected failure"):
+        _forward(
+            model,
+            [
+                _info("a", 1, [5, 6]),
+                _info("b", 1, [7, 8]),
+                _info("c", 1, [9, 10, 11]),
+                _info("d", 1, [12, 13, 14]),
+            ],
+        )
+    assert call_count == 2
+    assert model._states == before
+
+
+def test_cleanup_and_profile_output_are_aligned():
+    model, _ = _model()
+    _forward(model, [_info("a", 0, [1, 2]), _info("b", 0, [3, 4])])
+    model.on_requests_finished(["a"])
+    assert set(model._states) == {"b"}
+
+    profile = model(
+        input_ids=torch.zeros(5, dtype=torch.long),
+        seq_token_counts=[2, 3],
+    )
+    assert [audio.numel() for audio in profile.multimodal_outputs["model_outputs"]] == [0, 0]
+    assert set(model._states) == {"b"}
+
+
+def test_cleanup_uses_generation_runner_internal_request_ids():
+    model, _ = _model()
+    _forward(
+        model,
+        [_info("external-a", 0, [1, 2]), _info("external-b", 0, [3, 4])],
+        request_ids=["internal-a", "internal-b"],
+    )
+
+    model.on_requests_finished(["internal-a"])
+
+    assert set(model._states) == {"internal-b"}
+
+
+def test_reference_voice_and_duplex_metadata_follow_request_lifecycle():
+    model, _ = _model()
+    first = _info("voice-a", 0, [1, 2])
+    first["codes"]["ref"] = torch.linspace(-0.1, 0.1, 160)
+    segment_text_utf8 = torch.tensor(list(b"hello"), dtype=torch.uint8)
+    first["meta"].update(
+        ref_audio_sr=16000,
+        llm_output_text_utf8=segment_text_utf8,
+        duplex_turn_id=7,
+        duplex_epoch=3,
+    )
+    first["meta"].pop("prompt_cache_id")
+
+    output = _forward(model, [first])
+    prompt_key = model._request_prompt_keys["voice-a"]
+    prompt = model._runtime_prompts[prompt_key]
+    prompt_cache_id, prompt_wav = prompt.cache_id, prompt.path
+    assert prompt_cache_id.startswith("runtime-ref-")
+    assert Path(prompt_wav).is_file()
+    torch.testing.assert_close(
+        output.multimodal_outputs["meta.llm_output_text_utf8"][0],
+        segment_text_utf8,
+    )
+    assert output.multimodal_outputs["meta.duplex_turn_id"][0].item() == 7
+    assert output.multimodal_outputs["meta.duplex_epoch"][0].item() == 3
+
+    final = _info("voice-a", 1, [3, 4], last_chunk=True)
+    final["meta"].pop("prompt_cache_id")
+    final["meta"]["tts_is_last_chunk"] = True
+    output = _forward(model, [final])
+
+    assert output.multimodal_outputs["meta.tts_is_last_chunk"][0].item() is True
+    assert model._request_prompt_keys["voice-a"] == prompt_key
+    model.on_requests_finished(["voice-a"])
+    assert "voice-a" not in model._request_prompt_keys
+    assert prompt_key not in model._runtime_prompts
+    assert not Path(prompt_wav).exists()
+    assert (prompt_cache_id, prompt_wav) not in model.backend._prompt_features
diff --git a/tests/model_executor/models/minicpmo_4_5/test_code2wav_model_dir.py b/tests/model_executor/models/minicpmo_4_5/test_code2wav_model_dir.py
new file mode 100644
index 000000000..5aa78262a
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_code2wav_model_dir.py
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for MiniCPM-o 4.5 code2wav model-dir resolution (#5442).
+
+In hub/CI deployments ``model_config.model`` is a repo id rather than a local
+directory, so asset lookups must resolve to the downloaded snapshot. The
+resolution must stay lazy: constructing the model with a fake path (as the
+CPU unit tests do) must not touch the hub.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import huggingface_hub
+import pytest
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav import (
+    MiniCPMO45Code2Wav,
+    _resolve_model_dir,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _no_hub(monkeypatch):
+    def _fail(*args, **kwargs):  # pragma: no cover - must not be reached
+        raise AssertionError("snapshot_download must not be called here")
+
+    monkeypatch.setattr(huggingface_hub, "snapshot_download", _fail)
+
+
+def test_local_directory_is_returned_unchanged(tmp_path, monkeypatch):
+    _no_hub(monkeypatch)
+    assert _resolve_model_dir(str(tmp_path)) == str(tmp_path)
+
+
+def test_repo_id_resolves_via_snapshot_download(tmp_path, monkeypatch):
+    calls = {}
+
+    def _fake_snapshot_download(model_ref, revision=None, allow_patterns=None):
+        calls["model_ref"] = model_ref
+        calls["revision"] = revision
+        calls["allow_patterns"] = allow_patterns
+        return str(tmp_path / "snapshot")
+
+    monkeypatch.setattr(huggingface_hub, "snapshot_download", _fake_snapshot_download)
+    resolved = _resolve_model_dir("openbmb/MiniCPM-o-4_5", revision="abc123")
+    assert resolved == str(tmp_path / "snapshot")
+    assert calls["model_ref"] == "openbmb/MiniCPM-o-4_5"
+    assert calls["revision"] == "abc123"
+    assert calls["allow_patterns"] == ["assets/*"]
+
+
+def test_snapshot_download_failure_propagates(monkeypatch):
+    def _raise(*args, **kwargs):
+        raise FileNotFoundError("offline and not cached")
+
+    monkeypatch.setattr(huggingface_hub, "snapshot_download", _raise)
+    with pytest.raises(FileNotFoundError):
+        _resolve_model_dir("openbmb/MiniCPM-o-4_5")
+
+
+def test_init_with_fake_path_does_not_resolve(monkeypatch):
+    """Mirrors the CPU-test construction: fake model path, no ``revision``."""
+    _no_hub(monkeypatch)
+    config = SimpleNamespace(
+        model_config=SimpleNamespace(
+            model="/fake/model",
+            stage_connector_config=None,
+        )
+    )
+    model = MiniCPMO45Code2Wav(vllm_config=config)
+    assert model.model_path == "/fake/model"
+    assert model._default_prompt_wav == "/fake/model/assets/HT_ref_audio.wav"
+
+
+def test_default_prompt_wav_follows_resolved_model_path(monkeypatch):
+    _no_hub(monkeypatch)
+    config = SimpleNamespace(
+        model_config=SimpleNamespace(
+            model="openbmb/MiniCPM-o-4_5",
+            stage_connector_config=None,
+        )
+    )
+    model = MiniCPMO45Code2Wav(vllm_config=config)
+    model.model_path = "/resolved/snapshot"
+    assert model._default_prompt_wav == "/resolved/snapshot/assets/HT_ref_audio.wav"
diff --git a/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py b/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
index d52bcafa1..9c4b50967 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
@@ -7,12 +7,10 @@ Covers ``vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.llm2t
   - empty ``source_outputs`` raises
   - latent fallback to ``hidden_states`` when ``multimodal_output`` is empty
   - both inputs missing -> raises
-  - additional_information payload carries the keys the talker expects
-    (prompt_embeds, prompt_token_ids, llm_output_token_ids, llm_output_text)
-  - dummy talker prompt ``[BOS, PAD, EOS] = [1, 0, 2]`` (single prefill step)
+  - structured model_intermediate_buffer carries the thinker ids and text
+  - scheduler prompt tokens follow the selected TTS region or output tokens
   - MiniCPM-o 4.5 TTS region detection on 151703 / 151704 tokens
-  - MiniCPM-o 2.6 fallback detection on 151691 / 151692 when no 4.5 markers
-  - No TTS markers present -> no ``tts_token_ids`` / ``tts_hidden_states`` keys
+  - plain chat without TTS markers conditions on the generated assistant span
   - prompt arg is normalized to a list and ``multi_modal_data`` is gated by
     ``requires_multimodal_data``
 """
@@ -24,6 +22,9 @@ from types import SimpleNamespace
 import pytest
 import torch
 
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+    MiniCPMO45OmniForConditionalGeneration,
+)
 from vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni import llm2tts
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -32,6 +33,56 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 _HIDDEN_DIM = 4
 
 
+@pytest.mark.skip(reason="Legacy fused Talker metadata is replaced by separate Talker and Code2Wav stage payloads.")
+def test_native_duplex_talker_emits_empty_text_metadata_to_clear_previous_segment() -> None:
+    class _Talker:
+        _ar_last_chunk_flags = [True]
+        _ar_turn_end_flags = [True]
+
+        def __call__(self, **kwargs):
+            del kwargs
+            return None, torch.zeros(0, dtype=torch.float32)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    torch.nn.Module.__init__(model)
+    model.model_stage = "tts"
+    model.config = SimpleNamespace(hidden_size=_HIDDEN_DIM)
+    model.talker = _Talker()
+
+    output = model.forward(
+        input_ids=torch.tensor([1]),
+        positions=torch.tensor([0]),
+        runtime_additional_information=[
+            {
+                "native_duplex": True,
+                "duplex": {"turn_id": 1, "epoch": 0},
+                "meta": {"native_duplex_segment_text": ""},
+            }
+        ],
+    )
+
+    assert output.multimodal_outputs is not None
+    assert output.multimodal_outputs["meta.llm_output_text_utf8"].numel() == 0
+    assert output.multimodal_outputs["meta.audio_text_total_chars"].tolist() == [0]
+
+
+def test_tts_embed_input_ids_uses_active_talker_embedding(monkeypatch) -> None:
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    torch.nn.Module.__init__(model)
+    model.model_stage = "tts"
+    expected = torch.ones((2, _HIDDEN_DIM))
+
+    monkeypatch.setattr(
+        model,
+        "get_input_embeddings",
+        lambda input_ids: expected,
+    )
+
+    actual = model.embed_input_ids(torch.tensor([11, 12]))
+
+    assert actual is expected
+
+
 def _make_thinker_output(
     *,
     prompt_token_ids: list[int],
@@ -40,26 +91,35 @@ def _make_thinker_output(
     request_id: str = "req-0",
     latent: torch.Tensor | None = None,
     hidden_states: torch.Tensor | None = None,
+    multimodal_output: dict[str, object] | None = None,
+    request_multimodal_output: dict[str, object] | None = None,
 ):
     """Construct a minimal mock of a thinker engine output entry.
 
     The real ``llm2tts`` only reads a tight slice of fields:
-      - top-level: ``request_id``, ``prompt_token_ids``, ``outputs[0]``
-      - per-output: ``multimodal_output`` (dict), ``hidden_states`` (opt),
-        ``text``, ``token_ids``
+      - top-level: ``request_id``, ``prompt_token_ids``, optional
+        ``multimodal_output``, and ``outputs[0]``
+      - per-output: fallback ``multimodal_output``, ``hidden_states`` (opt),
+        ``text``, and ``token_ids``
     """
+    mm_output = dict(multimodal_output or {})
+    if latent is not None:
+        mm_output["latent"] = latent
     output = SimpleNamespace(
-        multimodal_output={"latent": latent} if latent is not None else {},
+        multimodal_output=mm_output,
         token_ids=output_token_ids,
         text=text,
     )
     if hidden_states is not None:
         output.hidden_states = hidden_states
-    return SimpleNamespace(
+    request_output = SimpleNamespace(
         request_id=request_id,
         prompt_token_ids=prompt_token_ids,
         outputs=[output],
     )
+    if request_multimodal_output is not None:
+        request_output.multimodal_output = request_multimodal_output
+    return request_output
 
 
 class TestInputValidation:
@@ -77,6 +137,19 @@ class TestInputValidation:
 
 
 class TestBasicShape:
+    def test_request_level_multimodal_output_feeds_orchestrator_bridge(self) -> None:
+        hidden = torch.zeros((2, _HIDDEN_DIM))
+        thinker_output = _make_thinker_output(
+            prompt_token_ids=[10],
+            output_token_ids=[20],
+            request_multimodal_output={"latent": hidden},
+        )
+
+        out = llm2tts([thinker_output], prompt=None)
+
+        assert out[0]["prompt_token_ids"] == [0, 0, 0]
+        assert torch.equal(torch.tensor(out[0]["model_intermediate_buffer"]["hidden_states"]["tts"]), hidden[1:])
+
     def test_returns_one_entry_per_input(self) -> None:
         hidden = torch.zeros((3, _HIDDEN_DIM))
         out = llm2tts(
@@ -90,17 +163,16 @@ class TestBasicShape:
         )
         assert len(out) == 2
 
-    def test_talker_prompt_token_ids_dummy_bos_pad_eos(self) -> None:
+    def test_talker_scheduler_prompt_matches_condition_length(self) -> None:
         hidden = torch.zeros((2, _HIDDEN_DIM))
         out = llm2tts(
             [_make_thinker_output(prompt_token_ids=[10], output_token_ids=[20], hidden_states=hidden)],
             prompt=None,
         )
-        # The talker AR framework needs *some* tokens to do a single prefill;
-        # this is the agreed [BOS, PAD, EOS] minimal payload.
-        assert out[0]["prompt_token_ids"] == [1, 0, 2]
+        assert out[0]["prompt_token_ids"] == [0, 0, 0]
+        assert "stream_output" not in out[0]["model_intermediate_buffer"]
 
-    def test_additional_information_carries_thinker_outputs(self) -> None:
+    def test_model_intermediate_buffer_carries_thinker_outputs(self) -> None:
         prompt_ids = [10, 11, 12]
         out_ids = [20, 21]
         hidden = torch.randn(len(prompt_ids) + len(out_ids), _HIDDEN_DIM)
@@ -116,21 +188,35 @@ class TestBasicShape:
             ],
             prompt=None,
         )
-        ai = result[0]["additional_information"]
-        assert ai["prompt_token_ids"] == prompt_ids
-        assert ai["llm_output_token_ids"] == out_ids
-        assert ai["llm_output_text"] == ["hello"]
-        # prompt_embeds = float32 view of the prompt-portion of hidden states.
-        assert ai["prompt_embeds"].dtype == torch.float32
-        assert ai["prompt_embeds"].shape == (len(prompt_ids), _HIDDEN_DIM)
-        assert torch.equal(ai["prompt_embeds"], hidden[: len(prompt_ids)].to(torch.float32))
+        buffer = result[0]["model_intermediate_buffer"]
+        assert buffer["ids"]["prompt"] == prompt_ids
+        assert buffer["ids"]["output"] == out_ids
+        assert buffer["llm_output_text"] == ["hello"]
+
+    def test_strict_talker_receives_canonical_nested_handoff(self) -> None:
+        hidden = torch.arange(5 * _HIDDEN_DIM, dtype=torch.float32).reshape(5, _HIDDEN_DIM)
+        result = llm2tts(
+            [
+                _make_thinker_output(
+                    prompt_token_ids=[10],
+                    output_token_ids=[151703, 20, 21, 151704],
+                    hidden_states=hidden,
+                )
+            ],
+            prompt=None,
+        )[0]
+
+        buffer = result["model_intermediate_buffer"]
+        assert result["prompt_token_ids"] == [0, 0, 0, 0]
+        assert buffer["ids"]["tts"] == [20, 21]
+        assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), hidden[2:4])
 
     def test_latent_in_multimodal_output_takes_precedence(self) -> None:
         # When both ``multimodal_output["latent"]`` and ``hidden_states`` are
         # present, the latent payload must win (this is the steady-state path
         # produced by the thinker stage).
         prompt_ids = [10, 11]
-        out_ids = [20]
+        out_ids = [151703, 30, 151704]
         latent = torch.ones((len(prompt_ids) + len(out_ids), _HIDDEN_DIM))
         hidden = torch.zeros_like(latent)
 
@@ -145,19 +231,17 @@ class TestBasicShape:
             ],
             prompt=None,
         )
-        ai = result[0]["additional_information"]
+        buffer = result[0]["model_intermediate_buffer"]
         # latent (ones) won over hidden_states (zeros)
-        assert torch.equal(ai["prompt_embeds"], latent[: len(prompt_ids)].to(torch.float32))
+        assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), latent[3:4].to(torch.float32))
 
 
 class TestTtsRegionDetection:
-    """The bridge auto-detects which MiniCPM-o generation produced the output
-    by sniffing for 4.5-specific BOS/EOS token ids (151703 / 151704); when
-    those are absent it falls back to the 2.6 ids (151691 / 151692).
+    """The bridge detects MiniCPM-o 4.5 BOS/EOS ids (151703 / 151704).
 
     This is a regression guard: a single off-by-one or wrong branch
-    precedence here causes the talker to receive an empty / wrong-region
-    slice and emit silent audio.
+    causes the talker to receive an empty / wrong-region slice and emit
+    silent audio.
     """
 
     def _run(self, prompt_token_ids, output_token_ids):
@@ -173,7 +257,7 @@ class TestTtsRegionDetection:
             ],
             prompt=None,
         )
-        return result[0]["additional_information"], hidden
+        return result[0]["model_intermediate_buffer"], hidden
 
     def test_4_5_markers_detected(self) -> None:
         # prompt:        [10, 11]
@@ -181,45 +265,23 @@ class TestTtsRegionDetection:
         # full sequence: [10, 11, 151703, 30, 31, 151704, 40]
         #                  0   1     2    3   4     5     6
         # 4.5 BOS at idx 2 -> slice starts at 3; EOS at idx 5 -> slice ends at 5.
-        ai, hidden = self._run([10, 11], [151703, 30, 31, 151704, 40])
-        assert "tts_token_ids" in ai and "tts_hidden_states" in ai
-        assert ai["tts_token_ids"].tolist() == [30, 31]
-        assert torch.equal(ai["tts_hidden_states"], hidden[3:5])
-
-    def test_4_5_takes_precedence_when_both_markers_present(self) -> None:
-        # If both 2.6 and 4.5 markers appear (shouldn't really happen on a
-        # real checkpoint, but exercises the loop's break), the 4.5 markers
-        # win because the source loop pins on the first 4.5 id seen.
-        # sequence index: 0   1   2     3   4     5    6   7    8
-        ai, hidden = self._run([10], [151691, 70, 151692, 151703, 30, 151704, 40])
-        assert ai["tts_token_ids"].tolist() == [30]
-        assert torch.equal(ai["tts_hidden_states"], hidden[5:6])
-
-    def test_2_6_fallback(self) -> None:
-        # No 4.5 markers anywhere -> use 2.6 BOS/EOS pair.
-        # full sequence: [10, 151691, 30, 31, 151692, 40]
-        #                  0     1    2   3     4     5
-        # BOS at idx 1 -> slice starts at 2; EOS at idx 4 -> slice ends at 4.
-        ai, hidden = self._run([10], [151691, 30, 31, 151692, 40])
-        assert ai["tts_token_ids"].tolist() == [30, 31]
-        assert torch.equal(ai["tts_hidden_states"], hidden[2:4])
+        buffer, hidden = self._run([10, 11], [151703, 30, 31, 151704, 40])
+        assert buffer["ids"]["tts"] == [30, 31]
+        assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), hidden[3:5])
 
     def test_bos_without_eos_runs_to_end(self) -> None:
         # When BOS is found but EOS is missing (typical for an in-flight or
         # truncated decode), the slice should extend to the end of the
         # hidden-state matrix instead of being dropped.
         # sequence: [10, 11, 151703, 30, 31]
-        ai, hidden = self._run([10, 11], [151703, 30, 31])
-        assert ai["tts_token_ids"].tolist() == [30, 31]
-        assert torch.equal(ai["tts_hidden_states"], hidden[3:5])
+        buffer, hidden = self._run([10, 11], [151703, 30, 31])
+        assert buffer["ids"]["tts"] == [30, 31]
+        assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), hidden[3:5])
 
-    def test_no_tts_markers_omits_slice_keys(self) -> None:
-        # If neither marker pair is present, the bridge should NOT populate
-        # ``tts_token_ids`` / ``tts_hidden_states`` — the talker should fall
-        # through to the dummy path.
-        ai, _ = self._run([10, 11], [20, 21, 22])
-        assert "tts_token_ids" not in ai
-        assert "tts_hidden_states" not in ai
+    def test_plain_chat_without_tts_markers_uses_assistant_span(self) -> None:
+        buffer, hidden = self._run([10, 11], [20, 21, 22])
+        assert buffer["ids"]["tts"] == [20, 21, 22]
+        assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), hidden[2:5])
 
 
 class TestPromptAndMultiModal:
@@ -251,14 +313,11 @@ class TestPromptAndMultiModal:
         )
         assert out[0]["multi_modal_data"] == mm
 
-    def test_streaming_context_is_accepted_and_ignored(self) -> None:
-        # The framework passes ``streaming_context`` for streaming-capable
-        # pipelines; MiniCPM-o 4.5 is turn-taking so the bridge must accept
-        # but discard it without crashing.
+    def test_internal_streaming_context_is_accepted(self) -> None:
         hidden = torch.zeros((2, _HIDDEN_DIM))
         out = llm2tts(
             [_make_thinker_output(prompt_token_ids=[10], output_token_ids=[20], hidden_states=hidden)],
             prompt=None,
-            streaming_context=object(),
+            _streaming_context=object(),
         )
         assert len(out) == 1
diff --git a/tests/model_executor/models/minicpmo_4_5/test_long_audio_processing.py b/tests/model_executor/models/minicpmo_4_5/test_long_audio_processing.py
new file mode 100644
index 000000000..ba4015b98
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_long_audio_processing.py
@@ -0,0 +1,154 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression tests for MiniCPM-o 4.5 >30s audio preprocessing.
+
+Covers:
+  - ``_minicpmo_field_config``: <=30s audio keeps the batched layout
+  - >30s audio switches to ``flat`` with one slice per source audio
+  - mixed long + short audios group chunks by source audio
+  - no audio inputs -> batched (default path unchanged)
+  - ``process_audios``: >30s audio unpads per chunk without ``TypeError``
+  - multiple >30s audios unpad in chunk order
+  - <=30s audio unpadding byte-identical to the pre-fix behavior
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+from vllm.multimodal.inputs import (
+    MultiModalBatchedField,
+    MultiModalFlatField,
+)
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMMultiModalProcessor,
+    MiniCPMOMultiModalDataParser,
+    _minicpmo_field_config,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_SAMPLE_RATE = 16_000
+_FEAT_DIM = 128
+# Whisper pads every 30s chunk to 3000 mel frames.
+_CHUNK_FRAMES = 3000
+
+
+class TestMiniCPMOFieldConfig:
+    def test_short_audios_stay_batched(self) -> None:
+        # two <=30s audios: one feature entry + one 1-element lens per audio
+        hf_inputs = {
+            "audio_features": [torch.zeros(_FEAT_DIM, _CHUNK_FRAMES)] * 2,
+            "audio_feature_lens": [torch.tensor([980]), torch.tensor([1500])],
+        }
+
+        config = _minicpmo_field_config(hf_inputs)
+
+        assert isinstance(config["audio_features"].field, MultiModalBatchedField)
+
+    def test_long_audio_groups_chunks_per_audio(self) -> None:
+        # one 45s audio -> 2 chunks but a single lens tensor
+        hf_inputs = {
+            "audio_features": [torch.zeros(_FEAT_DIM, _CHUNK_FRAMES)] * 2,
+            "audio_feature_lens": [torch.tensor([_CHUNK_FRAMES, 1500])],
+        }
+
+        config = _minicpmo_field_config(hf_inputs)
+
+        field = config["audio_features"].field
+        assert isinstance(field, MultiModalFlatField)
+        assert field.slices == [slice(0, 2)]
+
+    def test_mixed_long_and_short_audios(self) -> None:
+        # 45s audio (2 chunks) + 10s audio (1 chunk)
+        hf_inputs = {
+            "audio_features": [torch.zeros(_FEAT_DIM, _CHUNK_FRAMES)] * 3,
+            "audio_feature_lens": [
+                torch.tensor([_CHUNK_FRAMES, 1500]),
+                torch.tensor([980]),
+            ],
+        }
+
+        config = _minicpmo_field_config(hf_inputs)
+
+        field = config["audio_features"].field
+        assert isinstance(field, MultiModalFlatField)
+        assert field.slices == [slice(0, 2), slice(2, 3)]
+
+    def test_no_audio_inputs_stay_batched(self) -> None:
+        config = _minicpmo_field_config({})
+
+        assert isinstance(config["audio_features"].field, MultiModalBatchedField)
+
+
+def _make_processor(
+    fake_hf_outputs: dict[str, list[torch.Tensor]],
+) -> MiniCPMO45OmniLLMMultiModalProcessor:
+    """Build a processor without a checkpoint: only what ``process_audios``
+    touches, with the HF processor call returning canned Whisper-style output."""
+    processor = object.__new__(MiniCPMO45OmniLLMMultiModalProcessor)
+    processor.info = SimpleNamespace(audio_pattern="(<audio>./</audio>)")
+    processor.data_parser = MiniCPMOMultiModalDataParser(target_sr=_SAMPLE_RATE)
+
+    def fake_base_call_hf_processor(prompts, mm_data, mm_kwargs, tok_kwargs, *, out_keys):
+        return {key: fake_hf_outputs[key] for key in out_keys}
+
+    processor._base_call_hf_processor = fake_base_call_hf_processor
+    return processor
+
+
+def _audio_seconds(seconds: float) -> np.ndarray:
+    return np.zeros(int(seconds * _SAMPLE_RATE), dtype=np.float32)
+
+
+class TestProcessAudiosUnpadding:
+    def test_long_audio_unpads_per_chunk(self) -> None:
+        # 45s audio: 2 padded chunks, one lens tensor -> pre-fix TypeError
+        chunk_lens = [_CHUNK_FRAMES, 1500]
+        fake_outputs = {
+            "audio_features": [torch.randn(_FEAT_DIM, _CHUNK_FRAMES) for _ in chunk_lens],
+            "audio_feature_lens": [torch.tensor(chunk_lens)],
+        }
+        processor = _make_processor(fake_outputs)
+
+        result = processor.process_audios({"audios": [_audio_seconds(45)]}, {}, {})
+
+        features = result["audio_features"]
+        assert [feat.shape[-1] for feat in features] == chunk_lens
+        for feat, padded, length in zip(features, fake_outputs["audio_features"], chunk_lens):
+            assert torch.equal(feat, padded[:, :length])
+
+    def test_multiple_long_audios(self) -> None:
+        # two >30s audios: 4 chunks total, 2-element lens tensor each
+        fake_outputs = {
+            "audio_features": [torch.randn(_FEAT_DIM, _CHUNK_FRAMES) for _ in range(4)],
+            "audio_feature_lens": [
+                torch.tensor([_CHUNK_FRAMES, 1200]),
+                torch.tensor([_CHUNK_FRAMES, 800]),
+            ],
+        }
+        processor = _make_processor(fake_outputs)
+
+        result = processor.process_audios({"audios": [_audio_seconds(42), _audio_seconds(38)]}, {}, {})
+
+        widths = [feat.shape[-1] for feat in result["audio_features"]]
+        assert widths == [_CHUNK_FRAMES, 1200, _CHUNK_FRAMES, 800]
+
+    def test_short_audio_unchanged(self) -> None:
+        # <=30s audio: single-chunk unpadding identical to pre-fix behavior
+        fake_outputs = {
+            "audio_features": [torch.randn(_FEAT_DIM, _CHUNK_FRAMES)],
+            "audio_feature_lens": [torch.tensor([980])],
+        }
+        processor = _make_processor(fake_outputs)
+
+        result = processor.process_audios({"audios": [_audio_seconds(9.8)]}, {}, {})
+
+        features = result["audio_features"]
+        assert len(features) == 1
+        assert features[0].shape == (_FEAT_DIM, 980)
+        assert torch.equal(features[0], fake_outputs["audio_features"][0][:, :980])
diff --git a/tests/model_executor/models/minicpmo_4_5/test_pipeline.py b/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
index 48db0d497..5236ea883 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
@@ -5,8 +5,8 @@
 Covers:
   - pipeline declared in the central registry
   - lazy loader returns the expected ``PipelineConfig``
-  - 2-stage topology (thinker LLM_AR + talker LLM_AR with audio output)
-  - stage 1 routes through ``llm2tts`` custom input processor
+  - split 3-stage topology with no fused compatibility registration
+  - stage 1 routes through ``llm2tts`` and mode-specific Code2Wav producers
   - ``hf_architectures`` covers both the shared ``MiniCPMO`` alias and the
     explicit 4.5 arch
   - ``hf_config_predicate`` selects MiniCPM-o 4.5 only and rejects 2.6
@@ -15,6 +15,7 @@ Covers:
 
 from __future__ import annotations
 
+from pathlib import Path
 from types import SimpleNamespace
 
 import pytest
@@ -23,20 +24,28 @@ from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
 from vllm_omni.config.stage_config import (
     PipelineConfig,
     StageExecutionType,
+    load_deploy_config,
+    merge_pipeline_deploy,
 )
+from vllm_omni.model_executor.models.registry import _OMNI_MODELS
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 _PIPELINE_KEY = "minicpmo_4_5"
+_DEPLOY_DIR = Path(__file__).resolve().parents[4] / "vllm_omni" / "deploy"
+_DEPLOY_LAYOUTS = {
+    "minicpmo_4_5.yaml": ["0", "0", "0"],
+    "minicpmo_4_5_2gpu.yaml": ["0", "1", "1"],
+    "minicpmo_4_5_3gpu.yaml": ["0", "1", "2"],
+    "minicpmo_4_5_8x4090.yaml": ["0,1,2,3", "4", "5"],
+}
 
 
 class TestRegistryDeclaration:
     def test_declared_in_omni_pipelines(self) -> None:
         assert _PIPELINE_KEY in OMNI_PIPELINES
-
-    def test_visible_in_central_registry(self) -> None:
-        assert _PIPELINE_KEY in OMNI_PIPELINES
+        assert "minicpmo_4_5_fused" not in OMNI_PIPELINES
 
     def test_lazy_load_returns_pipeline_config(self) -> None:
         pipeline = OMNI_PIPELINES[_PIPELINE_KEY]
@@ -44,15 +53,29 @@ class TestRegistryDeclaration:
         assert pipeline.model_type == _PIPELINE_KEY
         assert pipeline.model_arch == "MiniCPMO45OmniForConditionalGeneration"
 
+    def test_native_duplex_control_is_explicit_without_a_fixed_session_cap(self) -> None:
+        pipeline = OMNI_PIPELINES[_PIPELINE_KEY]
+        assert pipeline.duplex_control_enabled is True
+        assert pipeline.duplex_serving_adapter == (
+            "vllm_omni.experimental.fullduplex.minicpmo45.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
+        )
+        assert not hasattr(pipeline, "max_native_duplex_sessions")
+
+    def test_ordinary_pipeline_defaults_to_no_duplex_control(self) -> None:
+        pipeline = PipelineConfig(model_type="ordinary")
+        assert pipeline.duplex_control_enabled is False
+        assert pipeline.duplex_serving_adapter is None
+        assert not hasattr(pipeline, "max_native_duplex_sessions")
+
 
 class TestPipelineTopology:
     @pytest.fixture(scope="class")
     def pipeline(self) -> PipelineConfig:
         return OMNI_PIPELINES[_PIPELINE_KEY]
 
-    def test_two_stages(self, pipeline: PipelineConfig) -> None:
-        assert len(pipeline.stages) == 2
-        assert [s.stage_id for s in pipeline.stages] == [0, 1]
+    def test_three_stages(self, pipeline: PipelineConfig) -> None:
+        assert len(pipeline.stages) == 3
+        assert [s.stage_id for s in pipeline.stages] == [0, 1, 2]
 
     def test_topology_validates(self, pipeline: PipelineConfig) -> None:
         # ``validate`` returns a list of structural errors; empty == valid.
@@ -76,11 +99,17 @@ class TestPipelineTopology:
         assert talker.execution_type == StageExecutionType.LLM_AR
         # talker consumes thinker output
         assert talker.input_sources == (0,)
-        assert talker.final_output is True
-        assert talker.final_output_type == "audio"
-        assert talker.engine_output_type == "audio"
+        assert talker.final_output is False
+        assert talker.final_output_type is None
+        assert talker.engine_output_type == "latent"
         # scope KV cache / mrope sizing to talker sub-config
         assert talker.hf_config_name == "tts_config"
+        assert talker.custom_process_next_stage_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_full_payload"
+        )
+        assert talker.async_chunk_process_next_stage_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_async_chunk"
+        )
 
     def test_talker_routes_through_llm2tts(self, pipeline: PipelineConfig) -> None:
         talker = pipeline.get_stage(1)
@@ -92,6 +121,92 @@ class TestPipelineTopology:
             "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.llm2tts"
         )
 
+    def test_code2wav_stage(self, pipeline: PipelineConfig) -> None:
+        code2wav = pipeline.get_stage(2)
+        assert code2wav is not None
+        assert code2wav.model_stage == "code2wav"
+        assert code2wav.execution_type == StageExecutionType.LLM_GENERATION
+        assert code2wav.input_sources == (1,)
+        assert code2wav.final_output is True
+        assert code2wav.final_output_type == "audio"
+        assert code2wav.engine_output_type == "audio"
+        assert code2wav.model_arch == "MiniCPMO45Code2Wav"
+        assert code2wav.sync_process_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_token_only"
+        )
+
+
+class TestDeployTopology:
+    @pytest.mark.parametrize(("filename", "devices"), _DEPLOY_LAYOUTS.items())
+    def test_deploy_resolves_three_stage_pipeline(self, filename: str, devices: list[str]) -> None:
+        deploy = load_deploy_config(_DEPLOY_DIR / filename)
+        pipeline = OMNI_PIPELINES[deploy.pipeline]
+        stages = merge_pipeline_deploy(pipeline, deploy)
+
+        assert deploy.pipeline == _PIPELINE_KEY
+        assert deploy.async_chunk is True
+        assert [stage.stage_id for stage in stages] == [0, 1, 2]
+        assert [stage.yaml_runtime["devices"] for stage in stages] == devices
+        assert "additional_config" not in stages[1].yaml_engine_args
+        assert "skip_mm_profiling" not in stages[0].yaml_engine_args
+        assert stages[1].yaml_engine_args["skip_mm_profiling"] is True
+        assert stages[2].yaml_engine_args["skip_mm_profiling"] is True
+        assert stages[1].yaml_extras["output_connectors"]["to_stage_2"] == "connector_of_shared_memory"
+        assert stages[2].yaml_extras["input_connectors"]["from_stage_1"] == "connector_of_shared_memory"
+        connector = deploy.connectors["connector_of_shared_memory"]
+        assert connector["name"] == "SharedMemoryConnector"
+        assert connector["extra"]["codec_chunk_frames"] == 25
+        assert connector["extra"]["codec_left_context_frames"] == 3
+        assert connector["extra"]["connector_get_max_wait_first_chunk"] == 3000
+        assert connector["extra"]["connector_get_max_wait"] == 300
+        expected_processor = "tts2code2wav_async_chunk" if deploy.async_chunk else "tts2code2wav_full_payload"
+        assert stages[1].yaml_engine_args["custom_process_next_stage_input_func"].endswith(expected_processor)
+        if filename == "minicpmo_4_5.yaml":
+            assert [stage.yaml_engine_args["max_num_seqs"] for stage in stages] == [4, 4, 4]
+            memory_utilizations = [stage.yaml_engine_args["gpu_memory_utilization"] for stage in stages]
+            assert memory_utilizations == [
+                0.55,
+                0.15,
+                0.15,
+            ]
+            assert sum(memory_utilizations) <= 0.9 + 1e-6
+            # Daily-Omni minicpm-interleave: up to 64 image/audio items (+ optional video).
+            assert stages[0].yaml_engine_args["limit_mm_per_prompt"] == {
+                "image": 64,
+                "audio": 64,
+                "video": 1,
+            }
+        elif filename in {"minicpmo_4_5_2gpu.yaml"}:
+            assert [stage.yaml_engine_args["gpu_memory_utilization"] for stage in stages] == [
+                0.9,
+                0.55,
+                0.35,
+            ]
+
+    def test_pipeline_exposes_full_and_async_payload_hooks(self) -> None:
+        pipeline = OMNI_PIPELINES[_PIPELINE_KEY]
+        talker = pipeline.get_stage(1)
+        code2wav = pipeline.get_stage(2)
+        assert talker is not None
+        assert code2wav is not None
+        assert talker.custom_process_next_stage_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_full_payload"
+        )
+        assert talker.async_chunk_process_next_stage_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_async_chunk"
+        )
+        assert code2wav.sync_process_input_func == (
+            "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.tts2code2wav_token_only"
+        )
+
+
+def test_code2wav_model_is_lazily_registered() -> None:
+    assert _OMNI_MODELS["MiniCPMO45Code2Wav"] == (
+        "minicpmo_4_5",
+        "minicpmo_4_5_code2wav",
+        "MiniCPMO45Code2Wav",
+    )
+
 
 class TestArchAliases:
     """``hf_architectures`` must cover both the shared and explicit names."""
diff --git a/tests/model_executor/models/minicpmo_4_5/test_siglip_position_ids.py b/tests/model_executor/models/minicpmo_4_5/test_siglip_position_ids.py
new file mode 100644
index 000000000..ba2544c8d
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_siglip_position_ids.py
@@ -0,0 +1,214 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import SiglipVisionEmbeddings
+
+pytestmark = [pytest.mark.core_model]
+
+
+@dataclass(frozen=True)
+class _VisionConfig:
+    hidden_size: int = 4
+    image_size: int = 8
+    patch_size: int = 2
+    num_channels: int = 3
+
+
+def _reference_position_ids(
+    embeddings: SiglipVisionEmbeddings,
+    patch_attention_mask: torch.BoolTensor,
+    tgt_sizes: torch.IntTensor | None,
+) -> torch.Tensor:
+    batch_size = patch_attention_mask.size(0)
+    position_ids = torch.zeros((batch_size, patch_attention_mask[0].numel()), dtype=torch.long)
+    boundaries = torch.arange(
+        1 / embeddings.num_patches_per_side,
+        1.0,
+        1 / embeddings.num_patches_per_side,
+    )
+
+    for batch_idx, patch_mask in enumerate(patch_attention_mask):
+        if tgt_sizes is None:
+            patch_grid_height = int(patch_mask[:, 0].sum())
+            patch_grid_width = int(patch_mask[0].sum())
+        else:
+            patch_grid_height = int(tgt_sizes[batch_idx, 0])
+            patch_grid_width = int(tgt_sizes[batch_idx, 1])
+
+        fractional_coords_h = torch.arange(0, 1 - 1e-6, 1 / patch_grid_height)
+        fractional_coords_w = torch.arange(0, 1 - 1e-6, 1 / patch_grid_width)
+        bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
+        bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
+        grid_ids = (bucket_coords_h[:, None] * embeddings.num_patches_per_side + bucket_coords_w).flatten()
+        position_ids[batch_idx, patch_mask.flatten()] = grid_ids
+
+    return position_ids
+
+
+def _mixed_patch_masks() -> torch.BoolTensor:
+    return torch.tensor(
+        [
+            [
+                [True, True, True, False],
+                [True, True, True, False],
+                [False, False, False, False],
+            ],
+            [
+                [True, True, True, True],
+                [False, False, False, False],
+                [False, False, False, False],
+            ],
+            [
+                [True, False, True, True],
+                [False, True, False, True],
+                [True, False, False, False],
+            ],
+        ],
+        dtype=torch.bool,
+    )
+
+
+@pytest.mark.parametrize("num_patches_per_side", [1, 2, 7, 16, 70])
+@pytest.mark.cpu
+def test_grid_ids_match_bucketized_reference(num_patches_per_side: int) -> None:
+    embeddings = SiglipVisionEmbeddings(_VisionConfig(image_size=num_patches_per_side * 2))
+    boundaries = torch.arange(
+        1 / num_patches_per_side,
+        1.0,
+        1 / num_patches_per_side,
+    )
+    target_shapes = [
+        (1, 1),
+        (max(1, num_patches_per_side - 1), num_patches_per_side),
+        (num_patches_per_side, num_patches_per_side + 1),
+        (num_patches_per_side * 7, num_patches_per_side * 7),
+        (num_patches_per_side * 2 + 1, 3),
+    ]
+
+    for patch_grid_height, patch_grid_width in target_shapes:
+        fractional_coords_h = torch.arange(0, 1 - 1e-6, 1 / patch_grid_height)
+        fractional_coords_w = torch.arange(0, 1 - 1e-6, 1 / patch_grid_width)
+        bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
+        bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
+        expected = (bucket_coords_h[:, None] * num_patches_per_side + bucket_coords_w).flatten()
+
+        actual = embeddings._create_grid_position_ids(
+            patch_grid_height,
+            patch_grid_width,
+            boundaries,
+        )
+
+        torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+@pytest.mark.cpu
+def test_position_ids_match_reference_for_mixed_and_repeated_grids(mocker) -> None:
+    embeddings = SiglipVisionEmbeddings(_VisionConfig())
+    patch_attention_mask = _mixed_patch_masks()
+    tgt_sizes = torch.tensor([[2, 3], [1, 4], [2, 3]], dtype=torch.int32)
+    grid_builder = mocker.spy(embeddings, "_create_grid_position_ids")
+
+    actual = embeddings._create_position_ids(patch_attention_mask, tgt_sizes, device=torch.device("cpu"))
+    expected = _reference_position_ids(embeddings, patch_attention_mask, tgt_sizes)
+
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+    assert grid_builder.call_count == 2
+
+
+@pytest.mark.cpu
+def test_position_ids_match_reference_without_target_sizes() -> None:
+    embeddings = SiglipVisionEmbeddings(_VisionConfig())
+    patch_attention_mask = torch.tensor(
+        [
+            [
+                [True, True, True, False],
+                [True, True, True, False],
+                [False, False, False, False],
+            ],
+            [
+                [True, True, False, False],
+                [True, True, False, False],
+                [True, True, False, False],
+            ],
+        ],
+        dtype=torch.bool,
+    )
+
+    actual = embeddings._create_position_ids(patch_attention_mask, None, device=torch.device("cpu"))
+    expected = _reference_position_ids(embeddings, patch_attention_mask, None)
+
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+@pytest.mark.cpu
+def test_forward_matches_reference_position_embedding() -> None:
+    torch.manual_seed(0)
+    embeddings = SiglipVisionEmbeddings(_VisionConfig())
+    pixel_values = torch.randn(3, 3, 6, 8)
+    patch_attention_mask = _mixed_patch_masks()
+    tgt_sizes = torch.tensor([[2, 3], [1, 4], [2, 3]], dtype=torch.int32)
+
+    with torch.no_grad():
+        patch_embeds = embeddings.patch_embedding(pixel_values).flatten(2).transpose(1, 2)
+        reference_ids = _reference_position_ids(embeddings, patch_attention_mask, tgt_sizes)
+        expected = patch_embeds + embeddings.position_embedding(reference_ids)
+        actual = embeddings(pixel_values, patch_attention_mask, tgt_sizes)
+
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_cuda_position_ids_match_reference_for_processor_shapes(mocker) -> None:
+    embeddings = SiglipVisionEmbeddings(_VisionConfig(image_size=140)).to(device="cuda")
+    target_shapes = [(40, 25), (32, 32), (40, 25), (28, 37)]
+    max_num_patches = max(height * width for height, width in target_shapes)
+    patch_attention_mask = torch.zeros((len(target_shapes), 1, max_num_patches), dtype=torch.bool)
+    for batch_idx, (height, width) in enumerate(target_shapes):
+        patch_attention_mask[batch_idx, 0, : height * width] = True
+
+    # Keep the valid-patch count while exercising non-contiguous padding.
+    patch_attention_mask[0, 0, 5] = False
+    patch_attention_mask[0, 0, -1] = True
+    tgt_sizes = torch.tensor(target_shapes, dtype=torch.int32)
+    expected = _reference_position_ids(embeddings, patch_attention_mask, tgt_sizes)
+    grid_builder = mocker.spy(embeddings, "_create_grid_position_ids")
+
+    actual = embeddings._create_position_ids(
+        patch_attention_mask.to(device="cuda"),
+        tgt_sizes.to(device="cuda"),
+        device=torch.device("cuda"),
+    )
+
+    torch.testing.assert_close(actual.cpu(), expected, rtol=0, atol=0)
+    assert grid_builder.call_count == 3
+    assert all(call.args[2].device.type == "cpu" for call in grid_builder.call_args_list)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_cuda_forward_matches_reference_for_processor_shape() -> None:
+    torch.manual_seed(0)
+    embeddings = SiglipVisionEmbeddings(_VisionConfig(image_size=140)).to(device="cuda")
+    pixel_values = torch.randn(1, 3, 80, 50, device="cuda")
+    patch_attention_mask = torch.ones((1, 1, 40 * 25), dtype=torch.bool, device="cuda")
+    tgt_sizes = torch.tensor([[40, 25]], dtype=torch.int32, device="cuda")
+
+    with torch.no_grad():
+        patch_embeds = embeddings.patch_embedding(pixel_values).flatten(2).transpose(1, 2)
+        reference_ids = _reference_position_ids(
+            embeddings,
+            patch_attention_mask.cpu(),
+            tgt_sizes.cpu(),
+        ).to(device="cuda")
+        expected = patch_embeds + embeddings.position_embedding(reference_ids)
+        actual = embeddings(pixel_values, patch_attention_mask, tgt_sizes)
+
+    torch.testing.assert_close(actual, expected)
diff --git a/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py b/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py
new file mode 100644
index 000000000..975f2cdaa
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_talker_batching.py
@@ -0,0 +1,454 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Request-alignment tests for MiniCPM-o 4.5's native Talker."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+    MiniCPMO45OmniForConditionalGeneration,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_tts import (
+    MiniCPMO45OmniTTSForConditionalGeneration,
+    _max_audio_tokens,
+    _restore_weight_norm_weight,
+)
+from vllm_omni.utils.mm_outputs import to_payload_element
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeNativeTalker(nn.Module):
+    has_preprocess = True
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.forward_kwargs = None
+
+    def forward(self, **kwargs):
+        self.forward_kwargs = kwargs
+        return torch.ones(2, 4)
+
+
+def test_wrapper_always_delegates_talker_to_native_ar_path() -> None:
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    nn.Module.__init__(model)
+    model.model_stage = "tts"
+    model.talker = _FakeNativeTalker()
+
+    output = model(
+        input_ids=torch.tensor([1, 2]),
+        positions=torch.arange(2),
+        model_intermediate_buffer=[{"request_id": "req"}],
+    )
+
+    assert output.shape == (2, 4)
+    assert model.talker.forward_kwargs["model_intermediate_buffer"][0]["request_id"] == "req"
+
+
+def _make_talker() -> MiniCPMO45OmniTTSForConditionalGeneration:
+    talker = MiniCPMO45OmniTTSForConditionalGeneration.__new__(MiniCPMO45OmniTTSForConditionalGeneration)
+    nn.Module.__init__(talker)
+    talker._num_audio_tokens = 8
+    talker._batch_stop_logits = None
+    talker._request_generators = {}
+    talker._request_audio_states = {}
+    talker._deferred_cleanup_ids = set()
+    talker._codec_min_tokens = 50
+    talker._codec_seed = 42
+    return talker
+
+
+def _routed(output, index: int):
+    return to_payload_element(
+        output.multimodal_outputs,
+        index,
+        index,
+        index + 1,
+        seq_len=2,
+        scheduled_seq_len=2,
+    )
+
+
+@pytest.mark.parametrize(
+    ("condition_tokens", "expected"),
+    [(3, 64), (100, 1000), (1000, 2048)],
+)
+def test_audio_token_limit_scales_with_condition_length(
+    condition_tokens: int,
+    expected: int,
+) -> None:
+    assert _max_audio_tokens(condition_tokens) == expected
+
+
+def test_weight_norm_restore_matches_checkpoint_parametrization_in_bfloat16() -> None:
+    generator = torch.Generator().manual_seed(42)
+    weight_v = torch.randn(8, 16, generator=generator, dtype=torch.bfloat16)
+    weight_g = torch.rand(8, 1, generator=generator, dtype=torch.bfloat16)
+    linear = nn.utils.parametrizations.weight_norm(
+        nn.Linear(16, 8, bias=False, dtype=torch.bfloat16),
+        dim=0,
+    )
+    with torch.no_grad():
+        linear.parametrizations.weight.original0.copy_(weight_g)
+        linear.parametrizations.weight.original1.copy_(weight_v)
+
+    restored = _restore_weight_norm_weight(weight_g, weight_v)
+
+    assert torch.equal(restored, linear.weight)
+
+
+def test_talker_emits_request_aligned_codec_deltas_after_compaction(mocker) -> None:
+    talker = _make_talker()
+    seen: list[tuple[str, list[float], list[int]]] = []
+
+    def sample(hidden, history, request_id, step):
+        assert step == 0
+        seen.append((request_id, hidden.reshape(-1).tolist(), history.tolist()))
+        return torch.tensor(2 if request_id == "req-a" else 3)
+
+    mocker.patch.object(talker, "_sample_audio_code", side_effect=sample)
+    infos = [
+        {"request_id": "req-a", "audio_codes": {"accumulated": torch.tensor([1])}},
+        {"request_id": "req-b", "audio_codes": {"accumulated": torch.empty(0, dtype=torch.long)}},
+    ]
+
+    output = talker.make_omni_output(
+        torch.tensor([[1.0, 0.0], [2.0, 0.0], [3.0, 0.0]]),
+        model_intermediate_buffer=infos,
+        request_token_spans=[(0, 2), (2, 3)],
+    )
+
+    assert seen == [
+        ("req-a", [2.0, 0.0], [1]),
+        ("req-b", [3.0, 0.0], []),
+    ]
+    assert infos[0]["audio_codes"]["accumulated"].tolist() == [1, 2]
+    assert infos[1]["audio_codes"]["accumulated"].tolist() == [3]
+    assert set(output.multimodal_outputs) == {"codes", "meta"}
+    assert "model_outputs" not in output.multimodal_outputs
+    assert "sr" not in output.multimodal_outputs
+    assert _routed(output, 0)["codes"]["audio"].tolist() == [[2]]
+    assert _routed(output, 1)["codes"]["audio"].tolist() == [[3]]
+    assert _routed(output, 0)["meta"]["finished"].item() is False
+    assert set(output.multimodal_outputs["meta"]) == {"finished"}
+    assert talker.compute_logits(output.text_hidden_states).argmax(dim=-1).tolist() == [0, 0]
+
+
+def test_talker_projects_request_aligned_duplex_metadata(mocker) -> None:
+    talker = _make_talker()
+    mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(2))
+    infos = [
+        {
+            "request_id": "req-a",
+            "native_duplex": True,
+            "duplex": {"epoch": 3, "turn_id": 7},
+            "ids": {"tts": [41]},
+            "meta": {
+                "native_duplex_segment_text": "first",
+                "turn_eos_token_id": 99,
+            },
+            "audio_codes": {"accumulated": torch.empty(0, dtype=torch.long)},
+        },
+        {
+            "request_id": "req-b",
+            "native_duplex": True,
+            "duplex": {"epoch": 4, "turn_id": 8},
+            "ids": {"tts": [42, 99]},
+            "meta": {
+                "native_duplex_segment_text": "second",
+                "turn_eos_token_id": 99,
+            },
+            "audio_codes": {"accumulated": torch.empty(0, dtype=torch.long)},
+        },
+    ]
+
+    output = talker.make_omni_output(
+        torch.ones(2, 2),
+        model_intermediate_buffer=infos,
+        request_token_spans=[(0, 1), (1, 2)],
+    )
+
+    meta = output.multimodal_outputs["meta"]
+    assert [value.item() for value in meta["native_duplex"]] == [True, True]
+    assert [value.item() for value in meta["duplex_epoch"]] == [3, 4]
+    assert [value.item() for value in meta["duplex_turn_id"]] == [7, 8]
+    assert "native_duplex_segment_text" not in meta
+    assert [bytes(value.tolist()).decode("utf-8") for value in meta["llm_output_text_utf8"]] == [
+        "first",
+        "second",
+    ]
+    assert [value.item() for value in meta["turn_end"]] == [False, True]
+
+
+def test_talker_rejects_native_duplex_without_fence_identity(mocker) -> None:
+    talker = _make_talker()
+    mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(2))
+    info = {
+        "request_id": "req-missing-fence",
+        "native_duplex": True,
+        "audio_codes": {"accumulated": torch.empty(0, dtype=torch.long)},
+    }
+
+    with pytest.raises(RuntimeError, match="requires non-negative integer epoch and turn_id"):
+        talker.make_omni_output(
+            torch.ones(1, 2),
+            model_intermediate_buffer=[info],
+            request_token_spans=[(0, 1)],
+        )
+
+
+def test_incomplete_prefill_emits_no_code_and_does_not_advance_state(mocker) -> None:
+    talker = _make_talker()
+    sample = mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(2))
+    infos = [
+        {
+            "request_id": "req-prefill",
+            "audio_state": {"step": 0},
+            "audio_codes": {"accumulated": torch.empty(0, dtype=torch.long)},
+        },
+        {
+            "request_id": "req-decode",
+            "audio_state": {"step": 4},
+            "audio_codes": {"accumulated": torch.tensor([1])},
+        },
+    ]
+
+    output = talker.make_omni_output(
+        torch.tensor([[1.0, 0.0], [2.0, 0.0], [3.0, 0.0]]),
+        model_intermediate_buffer=infos,
+        request_token_spans=[(0, 2), (2, 3)],
+        request_sample_eligible=[False, True],
+    )
+
+    sample.assert_called_once()
+    assert sample.call_args.args[2] == "req-decode"
+    assert infos[0]["audio_state"]["step"] == 0
+    assert infos[0]["audio_codes"]["accumulated"].numel() == 0
+    assert infos[1]["audio_state"]["step"] == 5
+    assert _routed(output, 0)["codes"]["audio"].shape == (0, 1)
+    assert _routed(output, 1)["codes"]["audio"].tolist() == [[2]]
+
+
+def test_eos_is_terminal_once_and_never_enters_codec_history(mocker) -> None:
+    talker = _make_talker()
+    sample = mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(7))
+    info = {
+        "request_id": "req-stop",
+        "audio_state": {"step": 3},
+        "audio_codes": {"accumulated": torch.tensor([4, 5])},
+    }
+
+    first = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+    first_logits = talker.compute_logits(first.text_hidden_states)
+    second = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+
+    sample.assert_called_once()
+    assert info["audio_codes"]["accumulated"].tolist() == [4, 5]
+    assert first.multimodal_outputs["codes"]["audio"][0].shape == (0, 1)
+    assert first.multimodal_outputs["meta"]["finished"][0].item() is True
+    assert second.multimodal_outputs["meta"]["finished"][0].item() is False
+    assert first_logits.argmax(dim=-1).tolist() == [1]
+    assert talker.compute_logits(second.text_hidden_states).argmax(dim=-1).tolist() == [1]
+
+
+def test_max_token_terminal_drops_unconsumed_codec_delta(mocker) -> None:
+    talker = _make_talker()
+    mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(3))
+    info = {
+        "request_id": "req-limit",
+        "audio_state": {"step": 1, "max_tokens": 2},
+        "audio_codes": {"accumulated": torch.tensor([4, 5])},
+    }
+
+    output = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+
+    # MiniCPMTTS.generate_chunk samples once at the max-token boundary to
+    # advance RNG state, but the sampled code is not fed into KV or returned.
+    assert info["audio_codes"]["accumulated"].tolist() == [4, 5]
+    assert output.multimodal_outputs["codes"]["audio"][0].shape == (0, 1)
+    assert output.multimodal_outputs["meta"]["finished"][0].item() is True
+    assert talker.compute_logits(output.text_hidden_states).argmax(dim=-1).tolist() == [1]
+
+
+def test_request_local_state_survives_missing_runner_buffer_update(mocker) -> None:
+    talker = _make_talker()
+    mocker.patch.object(talker, "_sample_audio_code", return_value=torch.tensor(3))
+    first_info = {
+        "request_id": "req-local-state",
+        "audio_state": {"step": 1, "max_tokens": 3},
+        "audio_codes": {"accumulated": torch.tensor([4])},
+    }
+
+    talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[first_info],
+        request_token_spans=[(0, 1)],
+    )
+    second = talker.make_omni_output(
+        torch.ones(1, 2),
+        model_intermediate_buffer=[{"request_id": "req-local-state"}],
+        request_token_spans=[(0, 1)],
+    )
+
+    assert second.multimodal_outputs["meta"]["finished"][0].item() is True
+    assert talker._request_audio_states["req-local-state"]["step"] == 3
+
+
+def test_missing_conditioning_fails_clearly() -> None:
+    talker = _make_talker()
+
+    with pytest.raises(ValueError, match="tts_token_ids and tts_hidden_states"):
+        talker.preprocess(
+            torch.tensor([0]),
+            None,
+            _omni_is_prefill=True,
+            request_id="req-invalid",
+        )
+
+
+def test_empty_speech_segment_finishes_without_sampling_codes() -> None:
+    talker = _make_talker()
+    talker.emb_text = nn.Embedding(8, 4)
+    talker.emb_code = nn.ModuleList([nn.Embedding(8, 4)])
+    talker._text_eos_id = 5
+    talker._tts_bos_id = 6
+
+    _, embeds, updates = talker.preprocess(
+        torch.zeros(2, dtype=torch.long),
+        None,
+        _omni_is_prefill=True,
+        request_id="req-empty",
+        tts_token_ids=torch.empty(0, dtype=torch.long),
+        tts_hidden_states=torch.empty(0, 4),
+    )
+
+    assert torch.equal(embeds, talker.emb_text(torch.tensor([5, 6])))
+    assert updates["audio_state"]["finished"] is True
+
+    # Stage 1's sampling min_tokens keeps scheduling decode steps until the stop
+    # token becomes eligible, and those steps have no previous code to embed.
+    _, decode_embeds, _ = talker.preprocess(
+        torch.zeros(1, dtype=torch.long),
+        None,
+        request_id="req-empty",
+        audio_state=updates["audio_state"],
+        audio_codes=updates["audio_codes"],
+    )
+
+    assert decode_embeds.shape == (1, 4)
+
+
+def test_chunked_prefill_tail_aligns_condition_with_prompt_length(mocker) -> None:
+    talker = _make_talker()
+    talker.emb_text = nn.Embedding(1, 2)
+    condition = torch.arange(18, dtype=torch.float32).reshape(9, 2)
+    mocker.patch.object(talker, "_build_condition_embeddings", return_value=condition)
+
+    _, embeds, _ = talker.preprocess(
+        torch.zeros(9, dtype=torch.long),
+        None,
+        _omni_is_prefill=True,
+        _omni_num_computed_tokens=59,
+        _omni_prompt_len=68,
+        request_id="req-chunked-prefill",
+        tts_token_ids=torch.tensor([1]),
+        tts_hidden_states=torch.ones(1, 2),
+    )
+
+    assert torch.equal(embeds, condition)
+    state = talker._request_audio_states["req-chunked-prefill"]
+    assert state["min_tokens"] == 50
+    assert state["max_tokens"] == 64
+
+
+@pytest.mark.parametrize(
+    ("meta", "expected_min_tokens"),
+    [
+        ({"turn_start": True}, 0),
+        ({}, 26),
+        ({"turn_end": True}, 0),
+    ],
+)
+def test_native_duplex_prefill_uses_official_chunk_limits(
+    mocker,
+    meta,
+    expected_min_tokens,
+) -> None:
+    talker = _make_talker()
+    talker.emb_text = nn.Embedding(1, 2)
+    mocker.patch.object(
+        talker,
+        "_build_condition_embeddings",
+        return_value=torch.ones(3, 2),
+    )
+
+    talker.preprocess(
+        torch.zeros(3, dtype=torch.long),
+        None,
+        _omni_is_prefill=True,
+        request_id="req-duplex-chunk",
+        native_duplex=True,
+        meta=meta,
+        tts_token_ids=torch.tensor([1]),
+        tts_hidden_states=torch.ones(1, 2),
+    )
+
+    state = talker._request_audio_states["req-duplex-chunk"]
+    assert state["min_tokens"] == expected_min_tokens
+    assert state["max_tokens"] == 26
+
+
+def test_native_duplex_condition_matches_official_text_plus_audio_bos() -> None:
+    talker = _make_talker()
+    talker.emb_text = nn.Embedding(16, 2)
+    talker.projector_semantic = nn.Identity()
+    talker._normalize = False
+    talker._text_eos_id = 14
+    talker._tts_bos_id = 15
+    with torch.no_grad():
+        talker.emb_text.weight.copy_(torch.arange(32, dtype=torch.float32).reshape(16, 2))
+
+    token_ids = torch.tensor([2, 3])
+    hidden_states = torch.tensor([[0.5, 1.0], [1.5, 2.0]])
+
+    condition = talker._build_condition_embeddings(
+        token_ids,
+        hidden_states,
+        native_duplex=True,
+    )
+
+    expected_text = talker.emb_text(token_ids) + hidden_states
+    expected = torch.cat(
+        [expected_text, talker.emb_text(torch.tensor([talker._tts_bos_id]))],
+        dim=0,
+    )
+    assert torch.equal(condition, expected)
+    assert condition.shape[0] == token_ids.shape[0] + 1
+
+
+def test_request_cleanup_evicts_ar_rng_and_decode_state() -> None:
+    talker = _make_talker()
+    talker._request_generators["req-done"] = torch.Generator()
+    talker._request_audio_states["req-done"] = {"step": 1}
+
+    talker.on_requests_finished(["req-done"])
+    talker._flush_deferred_cleanup()
+
+    assert "req-done" not in talker._request_generators
+    assert "req-done" not in talker._request_audio_states
diff --git a/tests/model_executor/models/minicpmo_4_5/test_vision_batching.py b/tests/model_executor/models/minicpmo_4_5/test_vision_batching.py
new file mode 100644
index 000000000..250d63b12
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_vision_batching.py
@@ -0,0 +1,175 @@
+from dataclasses import dataclass
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@dataclass
+class _VisionEncoderOutput:
+    last_hidden_state: torch.Tensor
+
+
+@dataclass
+class _VisionConfig:
+    vision_batch_size: int
+
+
+@dataclass
+class _AudioConfig:
+    audio_chunk_length: float = 0
+    audio_pool_step: int = 1
+
+
+@dataclass
+class _FakeConv:
+    weight: torch.Tensor
+
+
+@dataclass
+class _AudioEncoderOutput:
+    last_hidden_state: torch.Tensor
+    hidden_states: tuple[torch.Tensor, ...] | None
+
+
+class _FakeVisionEncoder:
+    def __init__(self) -> None:
+        self.batch_sizes: list[int] = []
+
+    def __call__(
+        self,
+        pixel_values: torch.Tensor,
+        *,
+        patch_attention_mask: torch.Tensor,
+        tgt_sizes: torch.Tensor,
+    ) -> _VisionEncoderOutput:
+        batch_size = pixel_values.shape[0]
+        self.batch_sizes.append(batch_size)
+        assert patch_attention_mask.shape[0] == batch_size
+        assert tgt_sizes.shape[0] == batch_size
+
+        per_item = pixel_values.sum(dim=(1, 2, 3))
+        hidden_states = per_item[:, None, None].expand(-1, 3, 4).clone()
+        return _VisionEncoderOutput(last_hidden_state=hidden_states)
+
+
+class _FakeResampler:
+    def __init__(self) -> None:
+        self.batch_sizes: list[int] = []
+
+    def __call__(self, hidden_states: torch.Tensor, tgt_sizes: torch.Tensor) -> torch.Tensor:
+        self.batch_sizes.append(hidden_states.shape[0])
+        return hidden_states + tgt_sizes.sum(dim=1)[:, None, None]
+
+
+class _FakeAudioEncoder:
+    def __init__(self) -> None:
+        self.conv1 = _FakeConv(weight=torch.empty(1, dtype=torch.float32))
+        self.output_hidden_states: list[bool] = []
+
+    def __call__(
+        self,
+        input_features: torch.Tensor,
+        *,
+        attention_mask: torch.Tensor,
+        output_hidden_states: bool,
+    ) -> _AudioEncoderOutput:
+        self.output_hidden_states.append(output_hidden_states)
+        assert attention_mask.shape == (1, 1, 2, 2)
+        final = torch.full((1, 2, 4), 2.0)
+        earlier = torch.full((1, 2, 4), 1.0)
+        return _AudioEncoderOutput(
+            last_hidden_state=final,
+            hidden_states=(earlier, final) if output_hidden_states else None,
+        )
+
+
+class _FakeVisionModel:
+    def __init__(self, vision_batch_size: int) -> None:
+        self.config = _VisionConfig(vision_batch_size=vision_batch_size)
+        self.vpm = _FakeVisionEncoder()
+        self.resampler = _FakeResampler()
+
+
+class _FakeAudioModel:
+    def __init__(self, audio_encoder: _FakeAudioEncoder, audio_encoder_layer: int) -> None:
+        self.config = _AudioConfig()
+        self.apm = audio_encoder
+        self.audio_projection_layer = torch.nn.Identity()
+        self.audio_avg_pooler = torch.nn.Identity()
+        self.audio_encoder_layer = audio_encoder_layer
+
+    def _get_feat_extract_output_lengths(
+        self,
+        input_lengths: torch.LongTensor,
+    ) -> tuple[torch.LongTensor, torch.LongTensor]:
+        input_lengths_after_cnn = (input_lengths - 1) // 2 + 1
+        input_lengths_after_pooling = (
+            input_lengths_after_cnn - self.config.audio_pool_step
+        ) // self.config.audio_pool_step + 1
+        return input_lengths_after_cnn, input_lengths_after_pooling.to(dtype=torch.int32)
+
+
+def _run_vision_encoder(vision_batch_size: int) -> tuple[torch.Tensor, list[int], list[int]]:
+    model = _FakeVisionModel(vision_batch_size)
+    pixel_values = [
+        torch.full((3, 2, length), fill_value=index + 1, dtype=torch.float32)
+        for index, length in enumerate((4, 3, 2, 4, 1))
+    ]
+    tgt_sizes = torch.tensor([[1, 2], [1, 2], [1, 1], [2, 2], [1, 1]])
+
+    result = MiniCPMO45OmniLLMForConditionalGeneration.get_vision_hidden_states(
+        model,
+        {"pixel_values": pixel_values, "tgt_sizes": tgt_sizes},
+    )
+    return result, model.vpm.batch_sizes, model.resampler.batch_sizes
+
+
+def test_vision_encoder_batches_vpm_before_resampling() -> None:
+    chunked, vision_batches, resampler_batches = _run_vision_encoder(2)
+    unchunked, unchunked_vision_batches, unchunked_resampler_batches = _run_vision_encoder(16)
+
+    assert vision_batches == [2, 2, 1]
+    assert resampler_batches == [5]
+    assert unchunked_vision_batches == [5]
+    assert unchunked_resampler_batches == [5]
+    torch.testing.assert_close(chunked, unchunked, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("vision_batch_size", [0, -2])
+def test_vision_encoder_clamps_nonpositive_batch_size(vision_batch_size: int) -> None:
+    chunked, vision_batches, resampler_batches = _run_vision_encoder(vision_batch_size)
+    unchunked, _, _ = _run_vision_encoder(16)
+
+    assert vision_batches == [1, 1, 1, 1, 1]
+    assert resampler_batches == [5]
+    torch.testing.assert_close(chunked, unchunked, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize(
+    ("audio_encoder_layer", "expected_value", "expected_hidden_states"),
+    [(-1, 2.0, False), (0, 1.0, True)],
+)
+def test_audio_encoder_retains_layers_only_for_nonfinal_selection(
+    audio_encoder_layer: int,
+    expected_value: float,
+    expected_hidden_states: bool,
+) -> None:
+    audio_encoder = _FakeAudioEncoder()
+    model = _FakeAudioModel(audio_encoder, audio_encoder_layer)
+
+    result = MiniCPMO45OmniLLMForConditionalGeneration.get_audio_hidden_states(
+        model,
+        {
+            "audio_features": torch.zeros((1, 80, 4)),
+            "audio_feature_lens": [torch.tensor([4])],
+        },
+    )
+
+    assert audio_encoder.output_hidden_states == [expected_hidden_states]
+    torch.testing.assert_close(result[0], torch.full((2, 4), expected_value))
diff --git a/tests/model_executor/models/minicpmo_4_5/test_vision_flash_attention.py b/tests/model_executor/models/minicpmo_4_5/test_vision_flash_attention.py
new file mode 100644
index 000000000..3139dbeac
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_vision_flash_attention.py
@@ -0,0 +1,353 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression coverage for MiniCPM-o 4.5 SigLIP FlashAttention."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import pytest
+import torch
+from pytest_mock import MockerFixture
+from transformers.utils import is_flash_attn_2_available
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.model_executor.models.minicpmo_4_5 import minicpmo_4_5_omni_llm as minicpmo_model
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    SiglipAttention,
+    SiglipEncoder,
+    SiglipFlashAttention2,
+    SiglipVisionConfig,
+)
+
+_VISION_NUM_HEADS = 16
+_VISION_HEAD_DIM = 72
+_VISION_HIDDEN_SIZE = _VISION_NUM_HEADS * _VISION_HEAD_DIM
+_DTYPE = torch.bfloat16
+
+
+def _attention_config(*, hidden_size: int, num_heads: int) -> SiglipVisionConfig:
+    return SiglipVisionConfig(
+        hidden_size=hidden_size,
+        num_attention_heads=num_heads,
+        attention_dropout=0.0,
+    )
+
+
+def _encoder_config(*, num_layers: int = 3) -> SiglipVisionConfig:
+    config = SiglipVisionConfig(
+        hidden_size=32,
+        intermediate_size=64,
+        num_hidden_layers=num_layers,
+        num_attention_heads=4,
+        attention_dropout=0.0,
+    )
+    config._attn_implementation = "flash_attention_2"
+    return config
+
+
+def _capture_output(
+    outputs: dict[str, torch.Tensor], name: str
+) -> Callable[[torch.nn.Module, tuple[torch.Tensor, ...], torch.Tensor], None]:
+    def hook(
+        _module: torch.nn.Module,
+        _inputs: tuple[torch.Tensor, ...],
+        output: torch.Tensor,
+    ) -> None:
+        outputs[name] = output
+
+    return hook
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_qkv_bshd_layout_reuses_projection_storage(mocker: MockerFixture) -> None:
+    batch_size = 2
+    seq_len = 7
+    hidden_size = 32
+    num_heads = 4
+    head_dim = hidden_size // num_heads
+    attention = SiglipFlashAttention2(_attention_config(hidden_size=hidden_size, num_heads=num_heads)).eval()
+
+    projected: dict[str, torch.Tensor] = {}
+    attention.q_proj.register_forward_hook(_capture_output(projected, "query"))
+    attention.k_proj.register_forward_hook(_capture_output(projected, "key"))
+    attention.v_proj.register_forward_hook(_capture_output(projected, "value"))
+
+    flash_inputs: dict[str, torch.Tensor] = {}
+
+    def fake_flash_attention(
+        query_states: torch.Tensor,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        _attention_mask: torch.Tensor | None,
+        _query_length: int,
+        *,
+        dropout: float = 0.0,
+        softmax_scale: float | None = None,
+        unpadding_metadata: minicpmo_model.FlashAttentionUnpaddingMetadata | None = None,
+    ) -> torch.Tensor:
+        del dropout, softmax_scale, unpadding_metadata
+        assert _attention_mask is None
+        assert _query_length == seq_len
+        flash_inputs.update(
+            query=query_states,
+            key=key_states,
+            value=value_states,
+        )
+        return query_states
+
+    flash_forward = mocker.patch.object(
+        attention,
+        "_flash_attention_forward",
+        side_effect=fake_flash_attention,
+    )
+
+    hidden_states = torch.randn(batch_size, seq_len, hidden_size)
+    with torch.inference_mode():
+        output, _ = attention(hidden_states)
+
+    assert output.shape == hidden_states.shape
+    flash_forward.assert_called_once()
+
+    expected_shape = (batch_size, seq_len, num_heads, head_dim)
+    expected_stride = (
+        seq_len * num_heads * head_dim,
+        num_heads * head_dim,
+        head_dim,
+        1,
+    )
+    for name in ("query", "key", "value"):
+        projected_tensor = projected[name]
+        flash_tensor = flash_inputs[name]
+        assert flash_tensor.shape == expected_shape
+        assert flash_tensor.stride() == expected_stride
+        assert flash_tensor.is_contiguous()
+        assert flash_tensor.storage_offset() == projected_tensor.storage_offset()
+        assert flash_tensor.untyped_storage().data_ptr() == projected_tensor.untyped_storage().data_ptr()
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    ("attention_mask", "expected_calls"),
+    [
+        pytest.param(torch.tensor([[True, True, False], [True, False, False]]), 1, id="padded"),
+        pytest.param(None, 0, id="dense"),
+    ],
+)
+def test_encoder_computes_unpadding_metadata_once_per_forward(
+    mocker: MockerFixture,
+    attention_mask: torch.Tensor | None,
+    expected_calls: int,
+) -> None:
+    encoder = SiglipEncoder(_encoder_config()).eval()
+    metadata_spy = mocker.spy(minicpmo_model, "_get_unpad_data")
+    received_metadata: list[minicpmo_model.FlashAttentionUnpaddingMetadata | None] = []
+
+    def fake_flash_attention(
+        query_states: torch.Tensor,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        _attention_mask: torch.Tensor | None,
+        _query_length: int,
+        *,
+        dropout: float = 0.0,
+        softmax_scale: float | None = None,
+        unpadding_metadata: minicpmo_model.FlashAttentionUnpaddingMetadata | None = None,
+    ) -> torch.Tensor:
+        del key_states, value_states, _attention_mask, _query_length, dropout, softmax_scale
+        received_metadata.append(unpadding_metadata)
+        return query_states
+
+    for layer in encoder.layers:
+        mocker.patch.object(layer.self_attn, "_flash_attention_forward", side_effect=fake_flash_attention)
+
+    hidden_states = torch.randn(2, 3, 32)
+    with torch.inference_mode():
+        encoder(
+            inputs_embeds=hidden_states,
+            attention_mask=attention_mask,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=False,
+        )
+
+    assert metadata_spy.call_count == expected_calls
+    assert len(received_metadata) == len(encoder.layers)
+    if attention_mask is None:
+        assert all(metadata is None for metadata in received_metadata)
+    else:
+        assert received_metadata[0] is not None
+        assert all(metadata is received_metadata[0] for metadata in received_metadata)
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_encoder_recomputes_unpadding_metadata_for_new_mask(mocker: MockerFixture) -> None:
+    encoder = SiglipEncoder(_encoder_config(num_layers=1)).eval()
+    metadata_spy = mocker.spy(minicpmo_model, "_get_unpad_data")
+    received_metadata: list[minicpmo_model.FlashAttentionUnpaddingMetadata | None] = []
+
+    def fake_flash_attention(
+        query_states: torch.Tensor,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        _attention_mask: torch.Tensor | None,
+        _query_length: int,
+        *,
+        dropout: float = 0.0,
+        softmax_scale: float | None = None,
+        unpadding_metadata: minicpmo_model.FlashAttentionUnpaddingMetadata | None = None,
+    ) -> torch.Tensor:
+        del key_states, value_states, _attention_mask, _query_length, dropout, softmax_scale
+        received_metadata.append(unpadding_metadata)
+        return query_states
+
+    mocker.patch.object(
+        encoder.layers[0].self_attn,
+        "_flash_attention_forward",
+        side_effect=fake_flash_attention,
+    )
+    hidden_states = torch.randn(2, 4, 32)
+    masks = (
+        torch.tensor([[True, True, True, False], [True, True, False, False]]),
+        torch.tensor([[True, True, False, False], [True, False, False, False]]),
+    )
+
+    with torch.inference_mode():
+        for attention_mask in masks:
+            encoder(
+                inputs_embeds=hidden_states,
+                attention_mask=attention_mask,
+                output_attentions=False,
+                output_hidden_states=False,
+                return_dict=False,
+            )
+
+    assert metadata_spy.call_count == len(masks)
+    first_metadata, second_metadata = received_metadata
+    assert first_metadata is not None
+    assert second_metadata is not None
+    assert first_metadata is not second_metadata
+    assert not torch.equal(first_metadata[0], second_metadata[0])
+
+
+def _require_flash_attention() -> None:
+    if not torch.cuda.is_available():
+        pytest.skip("CUDA is required for FlashAttention execution")
+    if not is_flash_attn_2_available():
+        pytest.skip("Transformers reports that FlashAttention 2 is unavailable")
+
+
+def _make_cuda_attention_pair() -> tuple[SiglipAttention, SiglipFlashAttention2]:
+    config = _attention_config(
+        hidden_size=_VISION_HIDDEN_SIZE,
+        num_heads=_VISION_NUM_HEADS,
+    )
+    torch.manual_seed(0)
+    eager_attention = SiglipAttention(config).eval().to(device="cuda", dtype=_DTYPE)
+    flash_attention = SiglipFlashAttention2(config).eval().to(device="cuda", dtype=_DTYPE)
+    flash_attention.load_state_dict(eager_attention.state_dict())
+    return eager_attention, flash_attention
+
+
+@pytest.mark.core_model
+@hardware_test(res={"cuda": "L4"})
+def test_encoder_metadata_reuse_matches_per_layer_recomputation() -> None:
+    _require_flash_attention()
+    encoder = SiglipEncoder(_encoder_config()).eval().to(device="cuda", dtype=_DTYPE)
+    torch.manual_seed(3)
+    hidden_states = torch.randn(2, 64, 32, device="cuda", dtype=_DTYPE)
+    attention_mask = torch.arange(64, device="cuda").unsqueeze(0) < torch.tensor(
+        (64, 43),
+        device="cuda",
+    ).unsqueeze(1)
+
+    with torch.inference_mode():
+        expected = hidden_states
+        for encoder_layer in encoder.layers:
+            expected = encoder_layer(
+                expected,
+                attention_mask,
+                output_attentions=False,
+                unpadding_metadata=None,
+            )[0]
+        actual = encoder(
+            inputs_embeds=hidden_states,
+            attention_mask=attention_mask,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=False,
+        )[0]
+
+    torch.testing.assert_close(actual, expected, atol=0.0, rtol=0.0)
+
+
+@pytest.mark.core_model
+@hardware_test(res={"cuda": "L4"})
+def test_flash_attention_unpadded_matches_eager_reference() -> None:
+    _require_flash_attention()
+    eager_attention, flash_attention = _make_cuda_attention_pair()
+    torch.manual_seed(1)
+    hidden_states = torch.randn(
+        2,
+        64,
+        _VISION_HIDDEN_SIZE,
+        device="cuda",
+        dtype=_DTYPE,
+    )
+
+    with torch.inference_mode():
+        expected, _ = eager_attention(hidden_states)
+        actual, _ = flash_attention(hidden_states)
+
+    torch.testing.assert_close(actual, expected, atol=2e-2, rtol=2e-2)
+
+
+@pytest.mark.core_model
+@hardware_test(res={"cuda": "L4"})
+@pytest.mark.parametrize(
+    "valid_lengths",
+    [
+        pytest.param((64, 43), id="moderate_padding"),
+        pytest.param((64, 17), id="high_padding"),
+    ],
+)
+def test_flash_attention_padded_matches_per_sample_unpadded(
+    valid_lengths: tuple[int, int],
+) -> None:
+    _require_flash_attention()
+    _, flash_attention = _make_cuda_attention_pair()
+    batch_size = len(valid_lengths)
+    seq_len = max(valid_lengths)
+    torch.manual_seed(2)
+    hidden_states = torch.randn(
+        batch_size,
+        seq_len,
+        _VISION_HIDDEN_SIZE,
+        device="cuda",
+        dtype=_DTYPE,
+    )
+    attention_mask = torch.arange(seq_len, device="cuda").unsqueeze(0) < torch.tensor(
+        valid_lengths,
+        device="cuda",
+    ).unsqueeze(1)
+
+    with torch.inference_mode():
+        padded_output, _ = flash_attention(
+            hidden_states,
+            attention_mask=attention_mask,
+        )
+        unpadded_outputs = [
+            flash_attention(hidden_states[index : index + 1, :valid_length])[0]
+            for index, valid_length in enumerate(valid_lengths)
+        ]
+
+    for index, valid_length in enumerate(valid_lengths):
+        torch.testing.assert_close(
+            padded_output[index : index + 1, :valid_length],
+            unpadded_outputs[index],
+            atol=2e-2,
+            rtol=2e-2,
+        )
diff --git a/tests/model_executor/models/moss_tts/test_codec_cudagraph.py b/tests/model_executor/models/moss_tts/test_codec_cudagraph.py
index 49d6fa411..91a853d57 100644
--- a/tests/model_executor/models/moss_tts/test_codec_cudagraph.py
+++ b/tests/model_executor/models/moss_tts/test_codec_cudagraph.py
@@ -1,14 +1,15 @@
 """Tests for MossTTSCUDAGraphCodecWrapper numerical equivalence.
 
 Verifies that CUDA Graph-accelerated decoding produces results equivalent
-to eager mode, with special attention to the two-argument _decode interface
-(codes [NQ, 1, T] + lengths [1]) and the NQ-first input convention.
+to eager mode, with special attention to the two-argument _decode
+interface (codes [NQ, 1, T] + lengths [1]) and the NQ-first input convention.
 """
 
 import pytest
 import torch
 import torch.nn as nn
 
+from tests.helpers.mark import hardware_marks
 from vllm_omni.model_executor.models.moss_tts.audio_tokenizer import (
     MossAudioTokenizerDecoderOutput,
 )
@@ -16,8 +17,10 @@ from vllm_omni.model_executor.models.moss_tts.moss_codec_cudagraph import (
     MossTTSCUDAGraphCodecWrapper,
 )
 
-pytestmark = [pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")]
-
+pytestmark = [
+    pytest.mark.core_model,
+    *hardware_marks(res={"cuda": "L4"}, num_cards=1),
+]
 DEVICE = torch.device("cuda:0")
 NUM_QUANTIZERS = 8
 DOWNSAMPLE_RATE = 4  # synthetic; real checkpoint uses 1920
@@ -31,8 +34,9 @@ DOWNSAMPLE_RATE = 4  # synthetic; real checkpoint uses 1920
 class SyntheticCodecModel(nn.Module):
     """Minimal stand-in for MossAudioTokenizerModel.
 
-    Exposes the same two-argument _decode(codes, lengths) interface and
-    returns a MossAudioTokenizerDecoderOutput, mirroring the real model.
+    Exposes the same two-argument ``_decode(codes, lengths)`` interface
+    used by ``MossTTSCUDAGraphCodecWrapper`` and returns a
+    MossAudioTokenizerDecoderOutput.
 
     Input:
         codes:   [NQ, B, T]  long  — RVQ codes
diff --git a/tests/model_executor/models/moss_tts/test_per_request_codes.py b/tests/model_executor/models/moss_tts/test_per_request_codes.py
index b35346c2f..91804ee15 100644
--- a/tests/model_executor/models/moss_tts/test_per_request_codes.py
+++ b/tests/model_executor/models/moss_tts/test_per_request_codes.py
@@ -23,6 +23,9 @@ import functools
 
 import pytest
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 torch = pytest.importorskip("torch")
 
 N_VQ = 4
diff --git a/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py b/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py
new file mode 100644
index 000000000..4e325bbdc
--- /dev/null
+++ b/tests/model_executor/models/qwen2_5_omni/test_per_video_audio_mask.py
@@ -0,0 +1,819 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from vllm.multimodal.inputs import MultiModalBatchedField, MultiModalSharedField
+from vllm.multimodal.processing.processor import PlaceholderFeaturesInfo
+
+from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
+    _PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY,
+    Qwen2_5OmniThinkerMultiModalProcessor,
+    _coerce_use_audio_in_video_for_hf_processor,
+    _filter_video_use_audio_in_video_for_uncached_items,
+    _normalize_use_audio_in_video,
+)
+from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker import (
+    Qwen3OmniMoeThinkerForConditionalGeneration,
+    Qwen3OmniMoeThinkerMultiModalProcessor,
+)
+from vllm_omni.outputs import OmniModelRunnerOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+AUDIO_TOKEN_ID = 10
+VIDEO_TOKEN_ID = 20
+AUDIO_BOS_TOKEN_ID = 30
+AUDIO_EOS_TOKEN_ID = 31
+IMAGE_TOKEN_ID = 40
+
+
+class _Feature:
+    def __init__(self, data: torch.Tensor) -> None:
+        self.data = data
+
+
+def _fake_processor() -> SimpleNamespace:
+    tokenizer = SimpleNamespace(get_vocab=lambda: {"<|audio_pad|>": AUDIO_TOKEN_ID})
+    processor = SimpleNamespace(audio_token="<|audio_pad|>")
+    config = SimpleNamespace(audio_token_id=AUDIO_TOKEN_ID)
+    info = SimpleNamespace(
+        get_hf_config=lambda: config,
+        get_hf_processor=lambda: processor,
+        get_tokenizer=lambda: tokenizer,
+    )
+    return SimpleNamespace(info=info)
+
+
+def _fake_qwen2_prompt_processor() -> SimpleNamespace:
+    tokenizer = SimpleNamespace(
+        get_vocab=lambda: {
+            "<|audio_pad|>": AUDIO_TOKEN_ID,
+            "<|video_pad|>": VIDEO_TOKEN_ID,
+            "<|image_pad|>": IMAGE_TOKEN_ID,
+        }
+    )
+    processor = SimpleNamespace(
+        audio_token="<|audio_pad|>",
+        video_token="<|video_pad|>",
+        image_token="<|image_pad|>",
+    )
+    image_processor = SimpleNamespace(merge_size=1)
+    config = SimpleNamespace(audio_token_id=AUDIO_TOKEN_ID)
+    info = SimpleNamespace(
+        get_hf_config=lambda: config,
+        get_hf_processor=lambda **_kwargs: processor,
+        get_image_processor=lambda **_kwargs: image_processor,
+        get_tokenizer=lambda: tokenizer,
+    )
+
+    def omni_get_updates_use_audio_in_video(**_kwargs):
+        return [
+            AUDIO_BOS_TOKEN_ID,
+            VIDEO_TOKEN_ID,
+            AUDIO_TOKEN_ID,
+            AUDIO_EOS_TOKEN_ID,
+        ]
+
+    return SimpleNamespace(
+        info=info,
+        omni_get_updates_use_audio_in_video=omni_get_updates_use_audio_in_video,
+    )
+
+
+def _fake_processor_with_spatial_merge_size() -> SimpleNamespace:
+    hf_config = SimpleNamespace(vision_config=SimpleNamespace(spatial_merge_size=2))
+    return SimpleNamespace(info=SimpleNamespace(get_hf_config=lambda: hf_config))
+
+
+def _fake_qwen3_processor() -> SimpleNamespace:
+    tokenizer = SimpleNamespace(
+        get_vocab=lambda: {
+            "<|audio_pad|>": AUDIO_TOKEN_ID,
+            "<|video_pad|>": VIDEO_TOKEN_ID,
+        }
+    )
+    processor = SimpleNamespace(
+        audio_token="<|audio_pad|>",
+        video_token="<|video_pad|>",
+    )
+    info = SimpleNamespace(
+        get_hf_processor=lambda: processor,
+        get_tokenizer=lambda: tokenizer,
+    )
+    return SimpleNamespace(info=info)
+
+
+def _fake_qwen3_prompt_processor() -> SimpleNamespace:
+    tokenizer = SimpleNamespace(
+        get_vocab=lambda: {
+            "<|audio_pad|>": AUDIO_TOKEN_ID,
+            "<|video_pad|>": VIDEO_TOKEN_ID,
+            "<|image_pad|>": IMAGE_TOKEN_ID,
+        }
+    )
+    processor = SimpleNamespace(
+        audio_token="<|audio_pad|>",
+        video_token="<|video_pad|>",
+        image_token="<|image_pad|>",
+    )
+    image_processor = SimpleNamespace(merge_size=1)
+    config = SimpleNamespace(
+        audio_token_id=AUDIO_TOKEN_ID,
+        video_token_id=VIDEO_TOKEN_ID,
+        audio_start_token_id=AUDIO_BOS_TOKEN_ID,
+        audio_end_token_id=AUDIO_EOS_TOKEN_ID,
+        vision_config=SimpleNamespace(spatial_merge_size=1),
+        position_id_per_seconds=1,
+    )
+    info = SimpleNamespace(
+        get_hf_config=lambda: config,
+        get_hf_processor=lambda **_kwargs: processor,
+        get_image_processor=lambda **_kwargs: image_processor,
+        get_tokenizer=lambda: tokenizer,
+    )
+    return SimpleNamespace(info=info)
+
+
+def test_normalize_use_audio_in_video_accepts_bool_and_per_video_mask():
+    assert _normalize_use_audio_in_video(True, 2) == [True, True]
+    assert _normalize_use_audio_in_video(False, 2) == [False, False]
+    assert _normalize_use_audio_in_video([True, False], 2) == [True, False]
+    assert _normalize_use_audio_in_video(torch.tensor([1, 0]), 2) == [
+        True,
+        False,
+    ]
+
+
+def test_normalize_use_audio_in_video_rejects_wrong_length():
+    with pytest.raises(ValueError, match="one boolean per video"):
+        _normalize_use_audio_in_video([True], 2)
+
+
+def test_coerce_use_audio_in_video_for_hf_processor_keeps_global_bool():
+    mm_kwargs = {"use_audio_in_video": True}
+
+    result = _coerce_use_audio_in_video_for_hf_processor({"videos": [object(), object()]}, mm_kwargs)
+
+    assert result is mm_kwargs
+    assert result["use_audio_in_video"] is True
+
+
+def test_coerce_use_audio_in_video_for_hf_processor_hides_per_video_mask_from_hf():
+    mm_kwargs = {"use_audio_in_video": [True, False], "other": "kept"}
+
+    result = _coerce_use_audio_in_video_for_hf_processor({"videos": [object(), object()]}, mm_kwargs)
+
+    assert result is not mm_kwargs
+    assert result["use_audio_in_video"] is False
+    assert result[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] == [True, False]
+    assert result["other"] == "kept"
+    assert mm_kwargs["use_audio_in_video"] == [True, False]
+
+
+def test_coerce_use_audio_in_video_for_hf_processor_does_not_validate_against_empty_mm_data():
+    result = _coerce_use_audio_in_video_for_hf_processor(
+        {},
+        {"use_audio_in_video": [True, False]},
+    )
+
+    assert result["use_audio_in_video"] is False
+    assert result[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] == [True, False]
+
+
+def test_coerce_use_audio_in_video_for_hf_processor_does_not_validate_against_partial_mm_data():
+    result = _coerce_use_audio_in_video_for_hf_processor(
+        {"videos": [object()]},
+        {"use_audio_in_video": [True, False]},
+    )
+
+    assert result["use_audio_in_video"] is False
+    assert result[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] == [True, False]
+
+
+def test_filter_video_use_audio_in_video_for_uncached_items_aligns_partial_cache_mask():
+    result = _filter_video_use_audio_in_video_for_uncached_items(
+        {
+            "use_audio_in_video": [True, False, True],
+            "second_per_grid_ts": [0.5, 1.0, 1.5],
+        },
+        [True, False, False],
+    )
+
+    assert result["use_audio_in_video"] == [False, True]
+    assert result[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] == [False, True]
+    assert result["second_per_grid_ts"] == [1.0, 1.5]
+
+
+def test_filter_video_use_audio_in_video_for_uncached_items_validates_request_mask_length():
+    with pytest.raises(ValueError, match="one boolean per video"):
+        _filter_video_use_audio_in_video_for_uncached_items(
+            {"use_audio_in_video": [True]},
+            [False, False],
+        )
+
+
+def test_get_audio_in_video_pairs_respects_per_video_mask():
+    from unittest.mock import MagicMock
+
+    mm_data_items = MagicMock()
+    mm_data_items.get_count.side_effect = lambda modality, strict=False: {
+        "video": 2,
+        "audio": 1,
+    }[modality]
+
+    pairs = Qwen2_5OmniThinkerMultiModalProcessor._get_audio_in_video_pairs(
+        SimpleNamespace(),
+        mm_data_items,
+        {"use_audio_in_video": [False, True]},
+    )
+
+    # Second video uses audio and pairs with audio[0], not audio[1].
+    assert pairs == [(1, 0)]
+
+
+def test_paired_cache_keys_change_when_paired_video_changes():
+    """Same audio + different video must not reuse the audio cache entry."""
+    pairs = [(0, 0)]
+    keys_a = Qwen2_5OmniThinkerMultiModalProcessor._paired_cache_keys(
+        {"video": ["video-a"], "audio": ["audio-same"]},
+        pairs,
+    )
+    keys_b = Qwen2_5OmniThinkerMultiModalProcessor._paired_cache_keys(
+        {"video": ["video-b"], "audio": ["audio-same"]},
+        pairs,
+    )
+
+    assert keys_a["audio"][0] != keys_b["audio"][0]
+    assert keys_a["video"][0] != keys_b["video"][0]
+
+
+def test_cached_apply_hf_processor_expands_pair_miss_for_audio_hit_video_miss():
+    """Same audio + different video must reprocess both items together even when
+    the audio content hash alone would be a cache hit.
+    """
+    from unittest.mock import MagicMock, patch
+
+    mm_data_items = MagicMock()
+    mm_data_items.get_count.side_effect = lambda modality, strict=False: {
+        "video": 1,
+        "audio": 1,
+    }[modality]
+    mm_data_items.__getitem__ = MagicMock(side_effect=lambda modality: [f"{modality}-0"])
+
+    inputs = MagicMock()
+    inputs.mm_data_items = mm_data_items
+    inputs.hf_processor_mm_kwargs = {"use_audio_in_video": True}
+    inputs.tokenization_kwargs = {}
+    inputs.prompt = [1, 2, 3]
+    inputs.get_mm_hashes = MagicMock(return_value={"video": ["v0"], "audio": ["a0"]})
+
+    timing_ctx = MagicMock()
+    timing_ctx.record.return_value.__enter__ = MagicMock(return_value=None)
+    timing_ctx.record.return_value.__exit__ = MagicMock(return_value=False)
+
+    cache = MagicMock()
+    # Video miss, audio hit under pair-aware keys — expansion must force audio.
+    cache.is_cached.side_effect = lambda keys: [False] if keys[0].startswith("v") else [True]
+
+    captured = {}
+
+    def capture_merge(cache_arg, **kwargs):
+        captured["mm_is_cached"] = kwargs["mm_is_cached"]
+        captured["mm_cache_keys"] = kwargs["mm_hashes"]
+        return MagicMock(name="mm_kwargs"), {"video": [[]], "audio": [[]]}
+
+    fake_self = SimpleNamespace(cache=cache, info=SimpleNamespace(model_id="m"))
+    fake_self._get_hf_mm_data = MagicMock(return_value=({}, {}))
+    # Bound methods called via self inside _cached_apply_hf_processor.
+    fake_self._get_audio_in_video_pairs = lambda mm_data_items, hf_processor_mm_kwargs: (
+        Qwen2_5OmniThinkerMultiModalProcessor._get_audio_in_video_pairs(
+            fake_self,
+            mm_data_items,
+            hf_processor_mm_kwargs,
+        )
+    )
+    fake_self._paired_cache_keys = Qwen2_5OmniThinkerMultiModalProcessor._paired_cache_keys
+    fake_self.info.parse_mm_data = MagicMock(return_value=SimpleNamespace(name="missing"))
+    fake_self._apply_hf_processor_main = MagicMock(return_value=([9], {"video_grid_thw": object()}, False))
+    fake_self._get_mm_fields_config = MagicMock(return_value={})
+    fake_self._get_mm_prompt_updates = MagicMock(return_value={"video": [[object()]], "audio": [[object()]]})
+    fake_self._merge_mm_kwargs = capture_merge
+
+    with patch(
+        "vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.MultiModalKwargsItems.from_hf_inputs",
+        return_value={"video": [object()], "audio": [object()]},
+    ):
+        prompt_ids, mm_info, _ = Qwen2_5OmniThinkerMultiModalProcessor._cached_apply_hf_processor(
+            fake_self,
+            inputs,
+            timing_ctx,
+        )
+
+    assert prompt_ids == [9]
+    # Both modalities were reprocessed as one unit after pair-miss expansion.
+    assert fake_self.info.parse_mm_data.call_args.args[0] == {
+        "video": ["video-0"],
+        "audio": ["audio-0"],
+    }
+    assert captured["mm_is_cached"] == {"video": [False], "audio": [False]}
+    # Cache entries are stored under pair-aware keys...
+    assert captured["mm_cache_keys"]["video"][0].startswith("v0-aiv-")
+    assert captured["mm_cache_keys"]["audio"][0].startswith("a0-aiv-")
+    # ...while semantic hashes are exposed downstream.
+    assert mm_info.hashes == {"video": ["v0"], "audio": ["a0"]}
+
+
+def test_mm_fields_config_keeps_global_use_audio_in_video_shared():
+    fake_self = _fake_processor_with_spatial_merge_size()
+    hf_inputs = {
+        "video_grid_thw": torch.tensor([[1, 4, 4], [1, 4, 4]]),
+        "use_audio_in_video": torch.tensor(False),
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_mm_fields_config(
+        fake_self,
+        hf_inputs,
+        {},
+    )
+
+    assert isinstance(result["use_audio_in_video"].field, MultiModalSharedField)
+
+
+def test_mm_fields_config_uses_batched_field_for_per_video_audio_mask():
+    fake_self = _fake_processor_with_spatial_merge_size()
+    hf_inputs = {
+        "video_grid_thw": torch.tensor([[1, 4, 4], [1, 4, 4]]),
+        "use_audio_in_video": torch.tensor([True, False]),
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_mm_fields_config(
+        fake_self,
+        hf_inputs,
+        {_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY: [True, False]},
+    )
+
+    assert isinstance(result["use_audio_in_video"].field, MultiModalBatchedField)
+
+
+def test_mm_fields_config_uses_batched_field_for_vector_hf_audio_mask():
+    fake_self = _fake_processor_with_spatial_merge_size()
+    hf_inputs = {
+        "video_grid_thw": torch.tensor([[1, 4, 4], [1, 4, 4]]),
+        "use_audio_in_video": torch.tensor([True, False]),
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_mm_fields_config(
+        fake_self,
+        hf_inputs,
+        {},
+    )
+
+    assert isinstance(result["use_audio_in_video"].field, MultiModalBatchedField)
+
+
+def test_get_video_use_audio_in_video_preserves_explicit_false():
+    fake_self = _fake_processor()
+    mm_kwargs = {
+        "video": [
+            {"use_audio_in_video": _Feature(torch.tensor(True))},
+            {"use_audio_in_video": _Feature(torch.tensor(False))},
+        ]
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_video_use_audio_in_video(
+        fake_self,
+        mm_kwargs,
+        {},
+    )
+
+    assert result == [True, False]
+
+
+def test_get_video_use_audio_in_video_treats_missing_item_as_false_with_explicit_mask():
+    fake_self = _fake_processor()
+    mm_kwargs = {
+        "video": [
+            {"use_audio_in_video": _Feature(torch.tensor(True))},
+            None,
+        ]
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_video_use_audio_in_video(
+        fake_self,
+        mm_kwargs,
+        {},
+    )
+
+    assert result == [True, False]
+
+
+def test_get_video_use_audio_in_video_falls_back_for_partial_cache_hit_with_explicit_mask():
+    fake_self = _fake_processor()
+    update_with_audio = SimpleNamespace(content=SimpleNamespace(full=[VIDEO_TOKEN_ID, AUDIO_TOKEN_ID]))
+    mm_kwargs = {
+        "video": [
+            {"use_audio_in_video": _Feature(torch.tensor(True))},
+            None,
+        ]
+    }
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_video_use_audio_in_video(
+        fake_self,
+        mm_kwargs,
+        {"video": [[object()], [update_with_audio]]},
+    )
+
+    assert result == [True, True]
+
+
+def test_qwen2_5_prompt_updates_apply_audio_mask_per_video():
+    fake_self = _fake_qwen2_prompt_processor()
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "audio_feature_lengths": torch.tensor([100]),
+            "video_grid_thw": torch.tensor([[1, 1, 2], [1, 1, 2]]),
+        }
+    )
+    mm_items = SimpleNamespace(
+        get_all_counts=lambda: {"video": 2, "audio": 1},
+        get_items=lambda *_args, **_kwargs: SimpleNamespace(get=lambda _idx: [0] * 100),
+    )
+
+    updates = Qwen2_5OmniThinkerMultiModalProcessor._get_prompt_updates(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True, False]},
+        out_mm_kwargs,
+    )
+    video_update = next(update for update in updates if update.modality == "video")
+
+    assert video_update.resolve(0).content.full == [
+        AUDIO_BOS_TOKEN_ID,
+        VIDEO_TOKEN_ID,
+        AUDIO_TOKEN_ID,
+        AUDIO_EOS_TOKEN_ID,
+    ]
+    assert video_update.resolve(1).content.full == [VIDEO_TOKEN_ID, VIDEO_TOKEN_ID]
+
+
+def test_qwen2_5_prompt_updates_prefer_hf_second_per_grid_ts_from_outputs():
+    captured = {}
+    fake_self = _fake_qwen2_prompt_processor()
+
+    def omni_get_updates_use_audio_in_video(**kwargs):
+        captured["video_second_per_grid_t"] = kwargs["video_second_per_grid_t"]
+        return [VIDEO_TOKEN_ID]
+
+    fake_self.omni_get_updates_use_audio_in_video = omni_get_updates_use_audio_in_video
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "audio_feature_lengths": torch.tensor([100]),
+            "video_grid_thw": torch.tensor([[1, 1, 1]]),
+            "second_per_grid_ts": torch.tensor([0.25]),
+        }
+    )
+    mm_items = SimpleNamespace(
+        get_all_counts=lambda: {"video": 1, "audio": 1},
+        get_items=lambda *_args, **_kwargs: SimpleNamespace(get=lambda _idx: [0] * 100),
+    )
+
+    updates = Qwen2_5OmniThinkerMultiModalProcessor._get_prompt_updates(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True], "second_per_grid_ts": torch.tensor([0.5])},
+        out_mm_kwargs,
+    )
+    video_update = next(update for update in updates if update.modality == "video")
+    video_update.resolve(0)
+
+    assert captured["video_second_per_grid_t"] == 0.25
+
+
+def test_qwen2_5_prompt_updates_accept_tensor_second_per_grid_ts_from_kwargs():
+    captured = {}
+    fake_self = _fake_qwen2_prompt_processor()
+
+    def omni_get_updates_use_audio_in_video(**kwargs):
+        captured["video_second_per_grid_t"] = kwargs["video_second_per_grid_t"]
+        return [VIDEO_TOKEN_ID]
+
+    fake_self.omni_get_updates_use_audio_in_video = omni_get_updates_use_audio_in_video
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "audio_feature_lengths": torch.tensor([100]),
+            "video_grid_thw": torch.tensor([[1, 1, 1]]),
+        }
+    )
+    mm_items = SimpleNamespace(
+        get_all_counts=lambda: {"video": 1, "audio": 1},
+        get_items=lambda *_args, **_kwargs: SimpleNamespace(get=lambda _idx: [0] * 100),
+    )
+
+    updates = Qwen2_5OmniThinkerMultiModalProcessor._get_prompt_updates(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True], "second_per_grid_ts": torch.tensor([0.75, 1.0])},
+        out_mm_kwargs,
+    )
+    video_update = next(update for update in updates if update.modality == "video")
+    video_update.resolve(0)
+
+    assert captured["video_second_per_grid_t"] == 0.75
+
+
+def test_qwen2_5_prompt_updates_validate_mask_against_request_video_count():
+    fake_self = _fake_qwen2_prompt_processor()
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "video_grid_thw": torch.tensor([[1, 1, 2], [1, 1, 2]]),
+        }
+    )
+    mm_items = SimpleNamespace(get_all_counts=lambda: {"video": 2})
+
+    with pytest.raises(ValueError, match="one boolean per video"):
+        Qwen2_5OmniThinkerMultiModalProcessor._get_prompt_updates(
+            fake_self,
+            mm_items,
+            {"use_audio_in_video": [True]},
+            out_mm_kwargs,
+        )
+
+
+def test_qwen2_5_mm_only_dummy_counts_subtract_only_videos_using_audio():
+    captured_counts = {}
+    fake_self = SimpleNamespace(
+        dummy_inputs=SimpleNamespace(get_dummy_text=lambda counts: captured_counts.update(counts) or "dummy"),
+        _apply_hf_processor_text_mm=lambda **_kwargs: ([], {}, False),
+    )
+    mm_items = SimpleNamespace(get_all_counts=lambda: {"video": 2, "audio": 1})
+
+    Qwen2_5OmniThinkerMultiModalProcessor._apply_hf_processor_mm_only(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True, False]},
+        {},
+    )
+
+    assert captured_counts == {"video": 2, "audio": 0}
+
+
+def test_get_video_use_audio_in_video_falls_back_to_prompt_updates_for_cache_hits():
+    fake_self = _fake_processor()
+    update_with_audio = SimpleNamespace(content=SimpleNamespace(full=[VIDEO_TOKEN_ID, AUDIO_TOKEN_ID]))
+    update_without_audio = SimpleNamespace(content=SimpleNamespace(full=[VIDEO_TOKEN_ID]))
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._get_video_use_audio_in_video(
+        fake_self,
+        {"video": [None, None]},
+        {"video": [[update_with_audio], [update_without_audio]]},
+    )
+
+    assert result == [True, False]
+
+
+def test_derive_audio_from_video_placeholders_only_pairs_true_videos():
+    fake_self = _fake_processor()
+    video_placeholders = [
+        PlaceholderFeaturesInfo(
+            modality="video",
+            item_idx=0,
+            start_idx=5,
+            tokens=[VIDEO_TOKEN_ID, AUDIO_TOKEN_ID, VIDEO_TOKEN_ID],
+            is_embed=torch.tensor([True, True, True]),
+        ),
+        PlaceholderFeaturesInfo(
+            modality="video",
+            item_idx=1,
+            start_idx=12,
+            tokens=[VIDEO_TOKEN_ID, VIDEO_TOKEN_ID],
+            is_embed=torch.tensor([True, True]),
+        ),
+    ]
+
+    result = Qwen2_5OmniThinkerMultiModalProcessor._derive_audio_from_video_placeholders(
+        fake_self,
+        {"video": video_placeholders},
+        {"audio": [[object()]]},
+        [True, False],
+    )
+
+    assert len(result["audio"]) == 1
+    assert result["audio"][0].item_idx == 0
+    assert result["audio"][0].start_idx == 5
+    assert result["audio"][0].is_embed.tolist() == [False, True, False]
+
+    assert len(result["video"]) == 2
+    assert result["video"][0].item_idx == 0
+    assert result["video"][0].is_embed.tolist() == [True, False, True]
+    assert result["video"][1].item_idx == 1
+    assert result["video"][1].is_embed.tolist() == [True, True]
+
+
+def test_qwen3_processor_inherits_vllm_omni_per_video_helpers():
+    assert issubclass(
+        Qwen3OmniMoeThinkerMultiModalProcessor,
+        Qwen2_5OmniThinkerMultiModalProcessor,
+    )
+
+
+def test_qwen3_prompt_updates_prefer_hf_second_per_grid_ts_from_outputs():
+    captured = {}
+    fake_self = _fake_qwen3_prompt_processor()
+
+    def get_updates_use_audio_in_video(**kwargs):
+        captured["video_second_per_grid_t"] = kwargs["video_second_per_grid_t"]
+        return [VIDEO_TOKEN_ID]
+
+    fake_self.get_updates_use_audio_in_video = get_updates_use_audio_in_video
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "audio_feature_lengths": torch.tensor([100]),
+            "video_grid_thw": torch.tensor([[1, 1, 1]]),
+            "second_per_grid_ts": torch.tensor([0.25]),
+        }
+    )
+    mm_items = SimpleNamespace(
+        get_items=lambda *_args, **_kwargs: SimpleNamespace(get=lambda _idx: [0] * 100),
+    )
+
+    updates = Qwen3OmniMoeThinkerMultiModalProcessor._get_prompt_updates(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True], "second_per_grid_ts": torch.tensor([0.5])},
+        out_mm_kwargs,
+    )
+    video_update = next(update for update in updates if update.modality == "video")
+    video_update.resolve(0)
+
+    assert captured["video_second_per_grid_t"] == 0.25
+
+
+def test_qwen3_prompt_updates_accept_tensor_second_per_grid_ts_from_kwargs():
+    captured = {}
+    fake_self = _fake_qwen3_prompt_processor()
+
+    def get_updates_use_audio_in_video(**kwargs):
+        captured["video_second_per_grid_t"] = kwargs["video_second_per_grid_t"]
+        return [VIDEO_TOKEN_ID]
+
+    fake_self.get_updates_use_audio_in_video = get_updates_use_audio_in_video
+    out_mm_kwargs = SimpleNamespace(
+        get_data=lambda **_kwargs: {
+            "audio_feature_lengths": torch.tensor([100]),
+            "video_grid_thw": torch.tensor([[1, 1, 1]]),
+        }
+    )
+    mm_items = SimpleNamespace(
+        get_items=lambda *_args, **_kwargs: SimpleNamespace(get=lambda _idx: [0] * 100),
+    )
+
+    updates = Qwen3OmniMoeThinkerMultiModalProcessor._get_prompt_updates(
+        fake_self,
+        mm_items,
+        {"use_audio_in_video": [True], "second_per_grid_ts": torch.tensor([0.75, 1.0])},
+        out_mm_kwargs,
+    )
+    video_update = next(update for update in updates if update.modality == "video")
+    video_update.resolve(0)
+
+    assert captured["video_second_per_grid_t"] == 0.75
+
+
+def test_qwen3_derive_audio_from_video_placeholders_excludes_audio_wrappers_from_embeds():
+    fake_self = _fake_qwen3_processor()
+    video_placeholders = [
+        PlaceholderFeaturesInfo(
+            modality="video",
+            item_idx=0,
+            start_idx=5,
+            tokens=[
+                AUDIO_BOS_TOKEN_ID,
+                VIDEO_TOKEN_ID,
+                AUDIO_TOKEN_ID,
+                AUDIO_EOS_TOKEN_ID,
+                VIDEO_TOKEN_ID,
+            ],
+            is_embed=torch.ones(5, dtype=torch.bool),
+        )
+    ]
+
+    result = Qwen3OmniMoeThinkerMultiModalProcessor._derive_audio_from_video_placeholders(
+        fake_self,
+        {"video": video_placeholders},
+        {"audio": [[object()]]},
+        [True],
+    )
+
+    assert result["audio"][0].is_embed.tolist() == [
+        False,
+        False,
+        True,
+        False,
+        False,
+    ]
+    assert result["video"][0].is_embed.tolist() == [
+        False,
+        True,
+        False,
+        False,
+        True,
+    ]
+
+
+def test_qwen3_mrope_positions_match_plain_video_placeholder_length():
+    fake_self = SimpleNamespace(
+        iter_mm_features=lambda _: iter(
+            [
+                (
+                    2,
+                    "video",
+                    {
+                        "grid_t": 1,
+                        "grid_h": 2,
+                        "grid_w": 2,
+                        "t_factor": 1.0,
+                        "use_audio_in_video": False,
+                        "placeholder_len": 4,
+                    },
+                )
+            ]
+        )
+    )
+
+    positions, _ = Qwen3OmniMoeThinkerForConditionalGeneration.get_mrope_input_positions(
+        fake_self,
+        list(range(8)),
+        [],
+    )
+
+    assert positions.shape == (3, 8)
+
+
+def test_qwen3_mrope_positions_count_single_interleaved_audio_wrappers():
+    fake_self = SimpleNamespace(
+        iter_mm_features=lambda _: iter(
+            [
+                (
+                    2,
+                    "video",
+                    {
+                        "grid_t": 1,
+                        "grid_h": 2,
+                        "grid_w": 2,
+                        "t_factor": 1.0,
+                        "use_audio_in_video": True,
+                        "placeholder_len": 8,
+                    },
+                )
+            ]
+        ),
+        _compute_interleaved_positions=lambda _start_idx, _data: (
+            torch.zeros((3, 6), dtype=torch.long).numpy(),
+            6,
+        ),
+    )
+
+    positions, _ = Qwen3OmniMoeThinkerForConditionalGeneration.get_mrope_input_positions(
+        fake_self,
+        list(range(10)),
+        [],
+    )
+
+    assert positions.shape == (3, 10)
+
+
+def test_qwen3_interleaved_mrope_prefers_placeholder_length_for_audio_count():
+    fake_self = SimpleNamespace(
+        _compute_audio_token_count=lambda _audio_feature_length: 100,
+    )
+    data = {
+        "grid_t": 1,
+        "grid_h": 2,
+        "grid_w": 2,
+        "t_factor": 1.0,
+        "audio_feature_length": 999,
+        "placeholder_len": 8,
+    }
+
+    positions, token_count = Qwen3OmniMoeThinkerForConditionalGeneration._compute_interleaved_positions(
+        fake_self,
+        0,
+        data,
+    )
+
+    assert token_count == 6
+    assert positions.shape == (3, 6)
+
+
+def test_omni_model_runner_output_can_carry_kv_connector_output_only():
+    marker = object()
+
+    output = OmniModelRunnerOutput.with_kv_conn_output_only(marker)
+
+    assert output.req_ids == []
+    assert output.req_id_to_index == {}
+    assert output.sampled_token_ids == []
+    assert output.kv_connector_output is marker
diff --git a/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py b/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
index d4778b7e2..13899d47d 100644
--- a/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
+++ b/tests/model_executor/models/qwen2_5_omni/test_qwen2_5_omni_embed.py
@@ -15,6 +15,7 @@ import functools
 import pytest
 import torch
 from pytest_mock import MockerFixture
+from vllm.multimodal.utils import set_mm_embedding_modality
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -117,13 +118,30 @@ class TestCheckInterleavedAudioVideo:
 # ---------------------------------------------------------------------------
 
 
-def make_mock_model(mocker: MockerFixture, hidden: int = 8):
+@functools.lru_cache(maxsize=1)
+def _omni_qwen2_5_thinker_cls():
+    """vllm_omni's thinker override, loaded lazily like the upstream one."""
+    from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
+        Qwen2_5OmniThinkerForConditionalGeneration,
+    )
+
+    return Qwen2_5OmniThinkerForConditionalGeneration
+
+
+def make_mock_model(mocker: MockerFixture, hidden: int = 8, thinker_cls=None):
     """
     Return a minimal mock of Qwen2_5OmniThinkerForConditionalGeneration
     that has enough structure to run embed_input_ids.
+
+    ``thinker_cls`` selects whose ``embed_input_ids`` the mock dispatches to.
+    It defaults to upstream's. Only the interleaved case passes omni's override:
+    omni's non-interleaved path falls through to a zero-arg ``super()`` call,
+    which raises TypeError when ``self`` is a Mock rather than an instance.
     """
     m = _qwen2_5_omni_thinker_mod()
     Qwen2_5OmniThinkerForConditionalGeneration = m.Qwen2_5OmniThinkerForConditionalGeneration
+    if thinker_cls is None:
+        thinker_cls = Qwen2_5OmniThinkerForConditionalGeneration
 
     model = mocker.Mock(spec=Qwen2_5OmniThinkerForConditionalGeneration)
 
@@ -155,9 +173,7 @@ def make_mock_model(mocker: MockerFixture, hidden: int = 8):
             is_multimodal=is_multimodal,
         )
 
-    model.embed_input_ids = lambda *a, **kw: m.Qwen2_5OmniThinkerForConditionalGeneration.embed_input_ids(  # noqa: E501
-        model, *a, **kw
-    )
+    model.embed_input_ids = lambda *a, **kw: thinker_cls.embed_input_ids(model, *a, **kw)
 
     model._super_embed_input_ids = fake_super_embed
 
@@ -171,11 +187,11 @@ def build_mm_embeds(audio_n, image_n, video_n, hidden, audio_val=10.0, image_val
     """
     embs = []
     if audio_n:
-        embs.append(torch.full((audio_n, hidden), audio_val))
+        embs.append(set_mm_embedding_modality(torch.full((audio_n, hidden), audio_val), "audio"))
     if image_n:
-        embs.append(torch.full((image_n, hidden), image_val))
+        embs.append(set_mm_embedding_modality(torch.full((image_n, hidden), image_val), "image"))
     if video_n:
-        embs.append(torch.full((video_n, hidden), video_val))
+        embs.append(set_mm_embedding_modality(torch.full((video_n, hidden), video_val), "video"))
     return embs
 
 
@@ -259,6 +275,11 @@ class TestEmbedInputIds:
         """
         Interleaved (use_audio_in_video): video chunks interleaved with audio.
         Video embeddings must go to video positions, audio to audio positions.
+
+        Runs against **omni's** thinker override, not upstream's: this is the
+        only unit-level coverage of omni's call into
+        ``merge_interleaved_embeddings``, whose upstream signature dropped
+        ``num_video``/``num_audio`` in vLLM #46213.
         """
         hidden = 8
         audio_val, video_val = 10.0, 30.0
@@ -270,11 +291,11 @@ class TestEmbedInputIds:
         audio_n = sum(audio_chunks)  # 6
 
         mm_embeds = [
-            torch.full((video_n, hidden), video_val),
-            torch.full((audio_n, hidden), audio_val),
+            set_mm_embedding_modality(torch.full((video_n, hidden), video_val), "video"),
+            set_mm_embedding_modality(torch.full((audio_n, hidden), audio_val), "audio"),
         ]
 
-        model, _ = make_mock_model(mocker, hidden)
+        model, _ = make_mock_model(mocker, hidden, thinker_cls=_omni_qwen2_5_thinker_cls())
         result = model.embed_input_ids(input_ids, mm_embeds, is_multimodal=is_multimodal)
 
         video_pos = (input_ids == VIDEO_TOKEN_ID).nonzero(as_tuple=True)[0]
@@ -308,8 +329,8 @@ class TestMergeInterleavedEmbeddings:
 
         inputs_embeds = torch.zeros(len(input_ids), hidden)
         mm_embeds = [
-            torch.full((num_video, hidden), 30.0),
-            torch.full((num_audio, hidden), 10.0),
+            set_mm_embedding_modality(torch.full((num_video, hidden), 30.0), "video"),
+            set_mm_embedding_modality(torch.full((num_audio, hidden), 10.0), "audio"),
         ]
 
         result = m.merge_interleaved_embeddings(
@@ -318,8 +339,6 @@ class TestMergeInterleavedEmbeddings:
             is_video,
             is_audio,
             is_multimodal,
-            num_video,
-            num_audio,
         )
 
         video_pos = is_video.nonzero(as_tuple=True)[0]
diff --git a/tests/model_executor/models/qwen3_omni/test_qwen3_omni_moe_lora.py b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_moe_lora.py
new file mode 100644
index 000000000..75d81eed5
--- /dev/null
+++ b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_moe_lora.py
@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Regression tests for Qwen3-Omni Thinker fused-MoE LoRA setup."""
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+import torch
+from peft import LoraConfig as PeftLoraConfig
+from peft import get_peft_model
+from torch import nn
+from transformers import PretrainedConfig
+from vllm.config.lora import LoRAConfig
+from vllm.lora.layers.fused_moe import FusedMoE3DWithLoRA
+from vllm.lora.lora_model import LoRAModel
+from vllm.lora.model_manager import LoRAModelManager
+from vllm.lora.peft_helper import PEFTHelper
+
+from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker import (
+    Qwen3OmniMoeThinkerForConditionalGeneration,
+    _ensure_thinker_architecture,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_NUM_EXPERTS = 2
+_HIDDEN_SIZE = 4
+_INTERMEDIATE_SIZE = 4
+_LORA_RANK = 1
+_EXPERTS_MODULE = "language_model.model.layers.0.mlp.experts"
+_PEFT_TARGET_PARAMETERS = [
+    "thinker.model.layers.0.mlp.experts.gate_up_proj",
+    "thinker.model.layers.0.mlp.experts.down_proj",
+]
+
+
+class _TinyExperts(nn.Module):
+    """Expert parameters with the same 3-D layout as Qwen3-Omni."""
+
+    def __init__(self):
+        super().__init__()
+        self.gate_up_proj = nn.Parameter(torch.zeros(_NUM_EXPERTS, 2 * _INTERMEDIATE_SIZE, _HIDDEN_SIZE))
+        self.down_proj = nn.Parameter(torch.zeros(_NUM_EXPERTS, _HIDDEN_SIZE, _INTERMEDIATE_SIZE))
+
+
+class _TinyQwen3OmniMoe(nn.Module):
+    """Minimal module tree needed for PEFT to save expert LoRA weights."""
+
+    def __init__(self, model_path: Path):
+        super().__init__()
+        self.thinker = nn.ModuleDict(
+            {
+                "model": nn.ModuleDict(
+                    {"layers": nn.ModuleList([nn.ModuleDict({"mlp": nn.ModuleDict({"experts": _TinyExperts()})})])}
+                )
+            }
+        )
+        self.name_or_path = str(model_path)
+        self.config = {"model_type": "qwen3_omni_moe"}
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return inputs
+
+
+class _CpuFusedMoE3DWithLoRA(FusedMoE3DWithLoRA):
+    """CPU harness for the real 3-D MoE LoRA weight methods."""
+
+    def __init__(self):
+        nn.Module.__init__(self)
+        self.moe_config = SimpleNamespace(
+            hidden_dim=_HIDDEN_SIZE,
+            num_local_experts=_NUM_EXPERTS,
+            num_experts=_NUM_EXPERTS,
+            intermediate_size_per_partition=_INTERMEDIATE_SIZE,
+            moe_parallel_config=SimpleNamespace(
+                tp_size=1,
+                tp_rank=0,
+                ep_rank=0,
+                use_ep=False,
+            ),
+        )
+        self.device = torch.device("cpu")
+        self.tp_size = 1
+        self.tp_rank = 0
+        self._w13_slices = 1
+        self.enable_moe_shared_loras = False
+
+
+def _save_peft_adapter(tmp_path: Path) -> Path:
+    base_model_dir = tmp_path / "base_model"
+    base_model_dir.mkdir()
+    (base_model_dir / "config.json").write_text('{"model_type": "qwen3_omni_moe"}', encoding="utf-8")
+
+    peft_model = get_peft_model(
+        _TinyQwen3OmniMoe(base_model_dir),
+        PeftLoraConfig(
+            r=_LORA_RANK,
+            lora_alpha=_LORA_RANK,
+            target_modules=[],
+            target_parameters=_PEFT_TARGET_PARAMETERS,
+        ),
+    )
+    with torch.no_grad():
+        for value, parameter in enumerate(
+            (parameter for parameter in peft_model.parameters() if parameter.requires_grad),
+            start=1,
+        ):
+            parameter.fill_(value)
+
+    adapter_dir = tmp_path / "adapter"
+    peft_model.save_pretrained(adapter_dir)
+    return adapter_dir
+
+
+def test_peft_expert_lora_loads_into_thinker(tmp_path: Path):
+    adapter_dir = _save_peft_adapter(tmp_path)
+    peft_helper = PEFTHelper.from_local_dir(str(adapter_dir), max_position_embeddings=128)
+    lora_model = LoRAModel.from_local_checkpoint(
+        str(adapter_dir),
+        {"experts"},
+        peft_helper=peft_helper,
+        lora_model_id=1,
+        device="cpu",
+        dtype=torch.float32,
+        weights_mapper=Qwen3OmniMoeThinkerForConditionalGeneration.hf_to_vllm_mapper,
+    )
+
+    thinker_config = PretrainedConfig()
+    _ensure_thinker_architecture(thinker_config)
+    fused_moe = _CpuFusedMoE3DWithLoRA()
+    fused_moe.create_lora_weights(
+        max_loras=1,
+        lora_config=LoRAConfig(
+            max_lora_rank=_LORA_RANK,
+            max_loras=1,
+            lora_dtype=torch.float32,
+        ),
+        model_config=thinker_config,
+    )
+
+    manager = object.__new__(LoRAModelManager)
+    manager.is_pooling_model = False
+    manager._is_3d_moe_model = Qwen3OmniMoeThinkerForConditionalGeneration.is_3d_moe_weight
+    manager._stack_moe_lora_weights(lora_model, fused_moe, _EXPERTS_MODULE)
+
+    expert_lora = lora_model.get_lora(_EXPERTS_MODULE)
+    assert expert_lora is not None
+    fused_moe.set_lora(0, expert_lora.lora_a, expert_lora.lora_b)
+
+    assert fused_moe.adapter_enabled.tolist() == [1, 0]
+    for weights in (
+        fused_moe.w13_lora_a_stacked[0],
+        fused_moe.w13_lora_b_stacked[0],
+        fused_moe.w2_lora_a_stacked[0],
+        fused_moe.w2_lora_b_stacked[0],
+    ):
+        assert torch.count_nonzero(weights[0]) == weights[0].numel()
+
+
+def test_existing_thinker_architecture_is_preserved():
+    config = PretrainedConfig(architectures=["CustomThinkerArchitecture"])
+
+    _ensure_thinker_architecture(config)
+
+    assert config.architectures == ["CustomThinkerArchitecture"]
diff --git a/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py b/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
index 0f77455d7..f3e8d0166 100644
--- a/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
+++ b/tests/model_executor/models/qwen3_tts/test_cuda_graph_decoder.py
@@ -20,8 +20,9 @@ import pytest
 import torch
 import torch.nn as nn
 
-pytestmark = [pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")]
+from tests.helpers.mark import hardware_test
 
+pytestmark = [pytest.mark.core_model]
 DEVICE = torch.device("cuda:0")
 NUM_QUANTIZERS = 8
 TOTAL_UPSAMPLE = 4
@@ -112,6 +113,7 @@ def _random_codes(seq_len, batch_size=1, device=DEVICE):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [25, 50, 100])
 def test_exact_size_numerical_equivalence(decoder, wrapper, seq_len):
     """When input exactly matches a capture size, output must be bit-identical."""
@@ -127,6 +129,7 @@ def test_exact_size_numerical_equivalence(decoder, wrapper, seq_len):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [10, 30, 47, 73, 99])
 def test_padded_output_shape_and_length(decoder, wrapper, seq_len):
     """Padded decode must return output trimmed to actual input length."""
@@ -139,6 +142,7 @@ def test_padded_output_shape_and_length(decoder, wrapper, seq_len):
     assert graph_out.shape[-1] == expected_len
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [10, 30, 47, 73, 99])
 def test_padded_interior_positions_close(decoder, wrapper, seq_len):
     """Interior positions (away from padding boundary) should be very close.
@@ -160,6 +164,7 @@ def test_padded_interior_positions_close(decoder, wrapper, seq_len):
         torch.testing.assert_close(interior_graph, interior_eager, atol=1e-5, rtol=1e-5)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [10, 30, 47, 73, 99])
 def test_padded_output_bounded(decoder, wrapper, seq_len):
     """Padded output values must remain in [-1, 1] and max diff should be bounded."""
@@ -175,6 +180,7 @@ def test_padded_output_bounded(decoder, wrapper, seq_len):
     assert max_diff < 1.0, f"Max diff {max_diff} exceeds bound"
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [10, 30, 47, 73, 99])
 def test_padded_short_output_decode_length_matches_eager(seq_len):
     """Streaming ``decode()`` of a shorter-than-nominal decoder must match eager length.
@@ -210,6 +216,7 @@ def test_padded_short_output_decode_length_matches_eager(seq_len):
         torch.testing.assert_close(graph_out[..., :-boundary], eager_out[..., :-boundary], atol=1e-5, rtol=1e-5)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_compiled_padded_short_output_length_matches_eager(monkeypatch):
     """Compiled replay path must also trim short-output decoders to eager length.
 
@@ -251,6 +258,7 @@ def test_compiled_padded_short_output_length_matches_eager(monkeypatch):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("seq_len", [101, 150, 200])
 def test_fallback_eager_exact_match(decoder, wrapper, seq_len):
     """Input larger than all capture sizes falls back to eager -> bit-identical."""
@@ -266,6 +274,7 @@ def test_fallback_eager_exact_match(decoder, wrapper, seq_len):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("total_len", [60, 100, 150, 250])
 def test_chunked_decode_shape_match(decoder, wrapper, total_len):
     """Chunked decode output shape must match between eager and graph modes."""
@@ -279,6 +288,7 @@ def test_chunked_decode_shape_match(decoder, wrapper, total_len):
     assert eager_out.shape == graph_out.shape
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize("total_len", [50, 100])
 def test_chunked_decode_exact_size_equivalence(decoder, wrapper, total_len):
     """Chunked decode with chunks matching capture sizes should be bit-identical."""
@@ -293,6 +303,7 @@ def test_chunked_decode_exact_size_equivalence(decoder, wrapper, total_len):
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_chunked_decode_output_survives_later_replay(wrapper):
     """Chunked output must not alias graph static buffers overwritten by later replays."""
     codes = _random_codes(100)
@@ -307,6 +318,7 @@ def test_chunked_decode_output_survives_later_replay(wrapper):
     torch.testing.assert_close(graph_out, expected, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_chunked_decode_preserves_short_chunk_concat_semantics():
     """Chunked decode must allow shorter-than-nominal chunk outputs.
 
@@ -336,6 +348,7 @@ def test_chunked_decode_preserves_short_chunk_concat_semantics():
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_batched_chunked_decode_variable_lengths_matches_per_request_eager(decoder, wrapper):
     """Variable-length chunk batching should match independent chunked decodes."""
     long_codes = _random_codes(100)
@@ -380,6 +393,7 @@ def _eager_chunked(decoder, codes, chunk_size, left_context_size):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_single_frame(decoder, wrapper):
     """Single-frame input (seq_len=1) should work with padding."""
     codes = _random_codes(1)
@@ -390,6 +404,7 @@ def test_single_frame(decoder, wrapper):
     assert graph_out.shape[-1] == TOTAL_UPSAMPLE
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_disabled_wrapper_matches_eager(decoder, wrapper):
     """Disabled wrapper should produce bit-identical output to eager."""
     codes = _random_codes(30)
@@ -401,6 +416,7 @@ def test_disabled_wrapper_matches_eager(decoder, wrapper):
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_batch_size_gt1_uses_matching_graph(decoder, wrapper):
     """Captured batch size > 1 should replay a matching graph."""
     assert (2, 25) in wrapper.graphs
@@ -411,6 +427,7 @@ def test_batch_size_gt1_uses_matching_graph(decoder, wrapper):
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_uncaptured_batch_size_falls_back(decoder, wrapper):
     """Uncaptured batch sizes should fall back to eager."""
     assert (3, 25) not in wrapper.graphs
@@ -421,6 +438,7 @@ def test_uncaptured_batch_size_falls_back(decoder, wrapper):
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_extra_capture_shape_uses_sparse_graph(decoder):
     """Extra capture shapes should not expand to a full batch x size product."""
     sparse_wrapper = CUDAGraphDecoderWrapper(
@@ -444,6 +462,7 @@ def test_extra_capture_shape_uses_sparse_graph(decoder):
     torch.testing.assert_close(graph_out, eager_out, atol=0, rtol=0)
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_compile_shape_supports_exact_and_padded_buckets(decoder, monkeypatch):
     """Configured torch.compile shapes should replay exact and padded CUDA Graph buckets."""
 
@@ -490,6 +509,7 @@ def test_compile_shape_supports_exact_and_padded_buckets(decoder, monkeypatch):
     assert compile_kwargs["dynamic"] is False
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_deterministic_across_calls(decoder, wrapper):
     """Same input should produce identical CUDA graph output across calls."""
     codes = _random_codes(30)
@@ -504,6 +524,7 @@ def test_deterministic_across_calls(decoder, wrapper):
 # ──────────────────────────────────────────────────────────────────
 
 
+@pytest.mark.cpu
 @pytest.mark.parametrize(
     "kwargs,expected_in,not_expected",
     [
@@ -545,6 +566,7 @@ def test_compute_capture_sizes(kwargs, expected_in, not_expected):
 # ──────────────────────────────────────────────────────────────────
 
 
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
 @pytest.mark.parametrize(
     "batch,channels,seq_len",
     [(2, 64, 1000), (1, 32, 1), (1, 32, 7), (1, 32, 128), (1, 32, 1024), (1, 32, 4096)],
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
index 7358c7893..c76583a4e 100644
--- a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_talker_preprocess.py
@@ -17,6 +17,8 @@ from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_talker import (
     Qwen3TTSTalkerForConditionalGeneration,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _make_minimal_talker(
     tts_pad_embed: torch.Tensor | None = None,
diff --git a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_tokenizer_mask_cache.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_tokenizer_mask_cache.py
new file mode 100644
index 000000000..aeb538adc
--- /dev/null
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_tokenizer_mask_cache.py
@@ -0,0 +1,125 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import inspect
+
+import pytest
+import torch
+from transformers.masking_utils import create_sliding_window_causal_mask
+
+from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.configuration_qwen3_tts_tokenizer_v2 import (
+    Qwen3TTSTokenizerV2DecoderConfig,
+)
+from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz.modeling_qwen3_tts_tokenizer_v2 import (
+    Qwen3TTSTokenizerV2DecoderTransformerModel,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_config(attention_implementation: str) -> Qwen3TTSTokenizerV2DecoderConfig:
+    config = Qwen3TTSTokenizerV2DecoderConfig(
+        hidden_size=32,
+        latent_dim=16,
+        max_position_embeddings=512,
+        num_attention_heads=4,
+        num_key_value_heads=4,
+        intermediate_size=64,
+        num_hidden_layers=1,
+        num_quantizers=2,
+        decoder_dim=32,
+        upsample_rates=(2,),
+        upsampling_ratios=(2,),
+    )
+    config._attn_implementation = attention_implementation
+    return config
+
+
+def _make_model(
+    attention_implementation: str,
+    dtype: torch.dtype = torch.float32,
+) -> Qwen3TTSTokenizerV2DecoderTransformerModel:
+    model = Qwen3TTSTokenizerV2DecoderTransformerModel._from_config(_make_config(attention_implementation))
+    return model.to(dtype=dtype).eval()
+
+
+def _create_reference_mask(
+    model: Qwen3TTSTokenizerV2DecoderTransformerModel,
+    inputs_embeds: torch.Tensor,
+) -> torch.Tensor | None:
+    sequence_length = inputs_embeds.shape[1]
+    mask_kwargs = {
+        "config": model.config,
+        "attention_mask": None,
+        "past_key_values": None,
+        "position_ids": None,
+    }
+    sig = inspect.signature(create_sliding_window_causal_mask)
+    if "input_embeds" in sig.parameters:
+        mask_kwargs["input_embeds"] = inputs_embeds[:1]
+        mask_kwargs["cache_position"] = torch.arange(sequence_length)
+    else:
+        mask_kwargs["inputs_embeds"] = inputs_embeds[:1]
+    return create_sliding_window_causal_mask(**mask_kwargs)
+
+
+@pytest.mark.parametrize("sequence_length", [17, 72, 73, 169, 325])
+@pytest.mark.parametrize(
+    ("attention_implementation", "dtype"),
+    [("sdpa", torch.float32), ("eager", torch.float32), ("eager", torch.float16)],
+)
+def test_cached_sliding_mask_matches_transformers(
+    sequence_length: int,
+    attention_implementation: str,
+    dtype: torch.dtype,
+):
+    model = _make_model(attention_implementation, dtype)
+    inputs_embeds = torch.empty(2, sequence_length, model.config.hidden_size, dtype=dtype)
+
+    actual = model._get_sliding_attention_mask(inputs_embeds)
+    expected = _create_reference_mask(model, inputs_embeds)
+
+    if expected is None:
+        assert actual is None
+        assert model._get_sliding_attention_mask(inputs_embeds) is None
+        return
+
+    assert actual is not None
+    torch.testing.assert_close(actual, expected, atol=0, rtol=0)
+    assert actual.shape == (1, 1, sequence_length, sequence_length)
+    assert actual.is_contiguous()
+    assert model._get_sliding_attention_mask(inputs_embeds) is actual
+
+
+def test_cached_eager_mask_tracks_compute_dtype():
+    model = _make_model("eager")
+
+    fp32_inputs = torch.empty(1, 73, model.config.hidden_size)
+    fp32_mask = model._get_sliding_attention_mask(fp32_inputs)
+    assert fp32_mask is not None
+    assert fp32_mask.dtype == torch.float32
+
+    model.half()
+    fp16_inputs = fp32_inputs.half()
+    fp16_mask = model._get_sliding_attention_mask(fp16_inputs)
+    assert fp16_mask is not None
+    assert fp16_mask.dtype == torch.float16
+    assert torch.isfinite(fp16_mask).all()
+    assert fp16_mask.min() == torch.finfo(torch.float16).min
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "message"),
+    [
+        ({"use_cache": True}, "use_cache=True"),
+        ({"past_key_values": object()}, "past_key_values"),
+        ({"cache_position": torch.arange(1, 18)}, "zero-based cache_position"),
+        ({"position_ids": torch.arange(1, 18).unsqueeze(0)}, "zero-based position_ids"),
+    ],
+)
+def test_cached_mask_rejects_unsupported_cache_and_positions(kwargs: dict, message: str):
+    model = _make_model("sdpa")
+    inputs_embeds = torch.randn(1, 17, model.config.latent_dim)
+
+    with pytest.raises(ValueError, match=message):
+        model(inputs_embeds=inputs_embeds, **kwargs)
diff --git a/tests/test_tts_custom_voice_profiles.py b/tests/model_executor/models/qwen3_tts/test_tts_custom_voice_profiles.py
similarity index 100%
rename from tests/test_tts_custom_voice_profiles.py
rename to tests/model_executor/models/qwen3_tts/test_tts_custom_voice_profiles.py
diff --git a/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py b/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
index 8154ddd65..0007f021a 100644
--- a/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
+++ b/tests/model_executor/models/voxcpm2/test_runner_assisted_unified_graph_static.py
@@ -8,6 +8,11 @@ lightweight local checkout. Runtime audio quality still requires a CUDA test.
 
 from pathlib import Path
 
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 REPO_ROOT = Path(__file__).resolve().parents[4]
 RUNNER = REPO_ROOT / "vllm_omni" / "worker" / "gpu_ar_model_runner.py"
 RUNNER_ASSISTED_METADATA = REPO_ROOT / "vllm_omni" / "worker" / "runner_assisted_metadata.py"
diff --git a/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py b/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
index f5a94376a..e0b52d1aa 100644
--- a/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
+++ b/tests/model_executor/models/voxcpm2/test_talker_state_eviction.py
@@ -9,6 +9,9 @@ from types import SimpleNamespace
 
 import pytest
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 torch = pytest.importorskip("torch")
 
 
@@ -232,6 +235,9 @@ class _NoopPerf:
     def stop(self, name: str) -> None:
         pass
 
+    def reset(self) -> None:
+        pass
+
 
 class _FakeTTS:
     feat_decoder = SimpleNamespace(estimator=SimpleNamespace(_compiled=False))
@@ -250,6 +256,164 @@ class _FakeTTS:
         return x.squeeze(1).mean(dim=1).repeat(1, 4)
 
 
+class TestChunkedPrefillContract:
+    @staticmethod
+    def _make_talker(prompt_len: int = 30):
+        from vllm_omni.model_executor.models.voxcpm2.voxcpm2_talker import _PrefillInputs
+
+        class FakeTTS:
+            def feat_encoder(self, x: torch.Tensor) -> torch.Tensor:
+                return x
+
+            def enc_to_lm_proj(self, x: torch.Tensor) -> torch.Tensor:
+                return x.squeeze(2)
+
+            def stop_proj(self, x: torch.Tensor) -> torch.Tensor:
+                return x
+
+            def stop_actn(self, x: torch.Tensor) -> torch.Tensor:
+                return x
+
+            def stop_head(self, x: torch.Tensor) -> torch.Tensor:
+                return x[:, :2]
+
+            def lm_to_dit_proj(self, x: torch.Tensor) -> torch.Tensor:
+                return x
+
+            def res_to_dit_proj(self, x: torch.Tensor) -> torch.Tensor:
+                return x
+
+        class FakeScaffold:
+            def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+                return input_ids.to(torch.float32).unsqueeze(-1).repeat(1, 1, 4)
+
+        talker = _make_bare_talker()
+        talker._tts = FakeTTS()
+        talker.model = FakeScaffold()
+        talker.config = SimpleNamespace(bos_token_id=-1, hidden_size=4)
+        talker._side_dtype = torch.float32
+        talker._get_multichar_zh_split = lambda: {}
+        talker._perf = _NoopPerf()
+        talker._enable_torch_compile = False
+        talker._setup_cfm_buffers = lambda: None
+        talker._run_cfm_for_state = lambda *_args: torch.ones(1, 1, 4)
+
+        text_token = torch.arange(prompt_len, dtype=torch.int32).unsqueeze(0)
+        audio_feat = torch.zeros(1, prompt_len, 1, 4)
+        text_mask = torch.ones(1, prompt_len, dtype=torch.int32)
+        audio_mask = torch.zeros(1, prompt_len, dtype=torch.int32)
+        talker._build_prefill_inputs = lambda *_args, **_kwargs: _PrefillInputs(
+            text_token=text_token,
+            audio_feat=audio_feat,
+            text_mask=text_mask,
+            audio_mask=audio_mask,
+        )
+        return talker
+
+    def test_preprocess_slices_full_embeddings_by_request_position(self) -> None:
+        talker = self._make_talker()
+
+        _, first, _ = talker.preprocess(
+            input_ids=torch.ones(15, dtype=torch.int32),
+            input_embeds=None,
+            request_id="req",
+            text_token_ids=[list(range(29))],
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=0,
+        )
+        state = talker._active_states["req"]
+        state.decode_step_count = 7
+
+        _, second, _ = talker.preprocess(
+            input_ids=torch.ones(15, dtype=torch.int32),
+            input_embeds=None,
+            request_id="req",
+            text_token_ids=[list(range(29))],
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=15,
+        )
+
+        torch.testing.assert_close(first[:, 0], torch.arange(15, dtype=torch.float32))
+        torch.testing.assert_close(second[:, 0], torch.arange(15, 30, dtype=torch.float32))
+        assert state.decode_step_count == 7
+        assert state.is_last_prefill_chunk is True
+
+    def test_prefill_cache_lifecycle_across_chunks(self) -> None:
+        talker = self._make_talker()
+        prompt_cache = {"mode": "reference", "ref_audio_feat": torch.ones(1)}
+        build_calls = []
+
+        def _build_prompt_cache(**_kwargs):
+            build_calls.append(1)
+            return prompt_cache
+
+        talker._build_prompt_cache = _build_prompt_cache
+
+        talker.preprocess(
+            input_ids=torch.ones(15, dtype=torch.int32),
+            input_embeds=None,
+            request_id="req",
+            text_token_ids=[list(range(29))],
+            reference_audio="ref.wav",
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=0,
+        )
+        state = talker._active_states["req"]
+        prefill_embeds = state.prefill_embeds
+        prefill_masks = state.prefill_masks
+
+        talker.preprocess(
+            input_ids=torch.ones(15, dtype=torch.int32),
+            input_embeds=None,
+            request_id="req",
+            text_token_ids=[list(range(29))],
+            reference_audio="ref.wav",
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=15,
+        )
+
+        assert build_calls == [1]
+        assert state.prompt_cache is prompt_cache
+        assert state.prefill_embeds is prefill_embeds
+        assert state.prefill_masks is prefill_masks
+
+        from vllm_omni.model_executor.models.voxcpm2.voxcpm2_talker import _PrefillResidualMeta
+
+        talker._finish_prefill(
+            state,
+            _PrefillResidualMeta(
+                lm_hidden=torch.ones(1, 4),
+                prefix_feat_cond=torch.ones(1, 1, 4),
+            ),
+            res_out=torch.ones(1, 4),
+            dev=torch.device("cpu"),
+        )
+
+        assert state.prefill_completed is True
+        assert state.prompt_cache is None
+        assert state.prefill_embeds is None
+        assert state.prefill_masks is None
+        assert talker._active_states["req"] is state
+
+    def test_single_token_tail_is_still_prefill(self) -> None:
+        talker = self._make_talker()
+
+        _, embeds, _ = talker.preprocess(
+            input_ids=torch.ones(1, dtype=torch.int32),
+            input_embeds=None,
+            request_id="req",
+            text_token_ids=[list(range(29))],
+            _omni_is_prefill=True,
+            _omni_num_computed_tokens=29,
+        )
+        is_last_prefill_chunk = talker._active_states["req"].is_last_prefill_chunk
+        is_prefill = talker._pending_requests[-1][1]
+        assert embeds.shape == (1, 4)
+        assert embeds[0, 0] == 29
+        assert is_prefill is True
+        assert is_last_prefill_chunk is True
+
+
 class TestDecodeBatchContract:
     def test_forward_skip_pending_prefill_keeps_audio_queue_aligned(self) -> None:
         class FakeScaffold:
diff --git a/tests/model_executor/stage_input_processors/test_cosyvoice3_stage_input_processors.py b/tests/model_executor/stage_input_processors/test_cosyvoice3_stage_input_processors.py
index 5309c7675..d5971efe7 100644
--- a/tests/model_executor/stage_input_processors/test_cosyvoice3_stage_input_processors.py
+++ b/tests/model_executor/stage_input_processors/test_cosyvoice3_stage_input_processors.py
@@ -4,6 +4,7 @@
 from collections import defaultdict
 from types import SimpleNamespace
 
+import pytest
 import torch
 
 from vllm_omni.model_executor.stage_input_processors.cosyvoice3 import (
@@ -12,6 +13,8 @@ from vllm_omni.model_executor.stage_input_processors.cosyvoice3 import (
     text2flow_token_only,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _source_output(request_id: str, prompt_ids: list[int], out_ids: list[int], mm: dict, finished: bool = True):
     return SimpleNamespace(
diff --git a/tests/model_executor/stage_input_processors/test_indextts2.py b/tests/model_executor/stage_input_processors/test_indextts2.py
index 11468603e..1380b99ff 100644
--- a/tests/model_executor/stage_input_processors/test_indextts2.py
+++ b/tests/model_executor/stage_input_processors/test_indextts2.py
@@ -3,6 +3,7 @@
 
 from types import SimpleNamespace
 
+import pytest
 import torch
 
 from vllm_omni.model_executor.stage_input_processors.indextts2 import (
@@ -11,6 +12,9 @@ from vllm_omni.model_executor.stage_input_processors.indextts2 import (
     talker2s2mel_token_only,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 STOP_MEL_TOKEN = 8193
 LATENT_DIM = 16
 
diff --git a/tests/model_executor/stage_input_processors/test_minicpmo_4_5_async_chunk.py b/tests/model_executor/stage_input_processors/test_minicpmo_4_5_async_chunk.py
new file mode 100644
index 000000000..f0da872b9
--- /dev/null
+++ b/tests/model_executor/stage_input_processors/test_minicpmo_4_5_async_chunk.py
@@ -0,0 +1,474 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from collections import defaultdict
+from types import SimpleNamespace
+
+import pytest
+import torch
+from vllm.v1.request import RequestStatus
+
+from vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni import (
+    tts2code2wav_async_chunk,
+    tts2code2wav_full_payload,
+    tts2code2wav_token_only,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _manager():
+    return SimpleNamespace(
+        connector=SimpleNamespace(config={"extra": {"codec_chunk_frames": 25, "codec_left_context_frames": 3}}),
+        code_prompt_token_ids=defaultdict(list),
+        request_payload={},
+        put_req_chunk=defaultdict(int),
+    )
+
+
+def _request(external_id: str, internal_id: str | None = None):
+    request = SimpleNamespace(
+        external_req_id=external_id,
+        request_id=internal_id or external_id,
+        status=RequestStatus.RUNNING,
+    )
+    request.is_finished = lambda: RequestStatus.is_finished(request.status)
+    return request
+
+
+def _delta(*codes: int):
+    return {
+        "codes": {"audio": torch.tensor(codes, dtype=torch.long).reshape(-1, 1)},
+        "meta": {"finished": torch.tensor(False)},
+    }
+
+
+def _duplex_delta(
+    *codes: int,
+    epoch: int = 3,
+    turn_id: int = 7,
+    text: str = "segment",
+    turn_end: bool = False,
+):
+    text_utf8 = torch.tensor(list(text.encode("utf-8")), dtype=torch.uint8)
+    return {
+        "codes": {"audio": torch.tensor(codes, dtype=torch.long).reshape(-1, 1)},
+        "meta": {
+            "finished": torch.tensor(False),
+            "native_duplex": torch.tensor(True),
+            "duplex_epoch": torch.tensor(epoch),
+            "duplex_turn_id": torch.tensor(turn_id),
+            "llm_output_text_utf8": text_utf8,
+            "turn_end": torch.tensor(turn_end),
+        },
+    }
+
+
+def _codes(payload) -> list[int]:
+    assert payload.codes is not None
+    assert isinstance(payload.codes.audio, torch.Tensor)
+    assert payload.codes.audio.dtype == torch.long
+    assert payload.codes.audio.ndim == 1
+    return payload.codes.audio.tolist()
+
+
+@pytest.mark.parametrize(("count", "emitted"), [(24, False), (25, True), (26, True)])
+def test_first_chunk_threshold_is_25_generated_codes(count: int, emitted: bool) -> None:
+    manager = _manager()
+    payload = tts2code2wav_async_chunk(
+        transfer_manager=manager,
+        multimodal_output=_delta(*range(count)),
+        request=_request("req"),
+        is_finished=False,
+    )
+
+    assert (payload is not None) is emitted
+    if payload is not None:
+        assert _codes(payload) == [4218, 4218, 4218, *range(25)]
+        assert payload.meta.chunk_seq == 0
+        assert payload.meta.code_flat_numel == 28
+
+
+def test_steady_chunk_has_three_code_overlap_and_25_new_codes() -> None:
+    manager = _manager()
+    request = _request("req")
+
+    first = tts2code2wav_async_chunk(manager, _delta(*range(25)), request, False)
+    manager.put_req_chunk["req"] += 1
+    steady = tts2code2wav_async_chunk(manager, _delta(*range(25, 50)), request, False)
+
+    assert first is not None
+    assert steady is not None
+    assert _codes(steady) == [22, 23, 24, *range(25, 50)]
+    assert steady.meta.chunk_seq == 1
+
+
+def test_exact_boundary_final_flushes_held_lookahead() -> None:
+    manager = _manager()
+    request = _request("req")
+
+    assert tts2code2wav_async_chunk(manager, _delta(*range(25)), request, False) is not None
+    manager.put_req_chunk["req"] += 1
+    final = tts2code2wav_async_chunk(manager, None, request, True)
+
+    assert final is not None
+    assert _codes(final) == [22, 23, 24]
+    assert final.meta.chunk_seq == 1
+    assert final.meta.code_flat_numel == 3
+    assert final.meta.last_chunk is True
+    assert final.meta.finished.item() is True
+
+
+def test_short_final_flushes_silence_prefix_and_tail() -> None:
+    manager = _manager()
+    final = tts2code2wav_async_chunk(manager, _delta(*range(7)), _request("req"), True)
+
+    assert final is not None
+    assert _codes(final) == [4218, 4218, 4218, *range(7)]
+    assert final.meta.last_chunk is True
+    assert final.meta.finished.item() is True
+
+
+def test_duplex_turn_end_waits_for_terminal_codec_flush() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+
+    body = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(*range(25), turn_end=True),
+        request,
+        False,
+    )
+    final = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(turn_end=True),
+        request,
+        True,
+    )
+
+    assert body is not None
+    assert body.meta.last_chunk is False
+    assert body.meta.turn_end is False
+    assert final is not None
+    assert _codes(final) == [22, 23, 24]
+    assert final.meta.last_chunk is True
+    assert final.meta.turn_end is True
+
+
+def test_first_chunk_forwards_reference_voice_and_duplex_identity() -> None:
+    manager = _manager()
+    request = _request("req")
+    request.additional_information = {
+        "codes": {"ref": [0.1, -0.1]},
+        "meta": {"ref_audio_sr": 16000},
+    }
+
+    payload = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(*range(7), text="hello", turn_end=True),
+        request,
+        True,
+    )
+
+    assert payload is not None
+    assert payload.codes.ref.tolist() == pytest.approx([0.1, -0.1])
+    assert payload.meta.ref_audio_sr == 16000
+    torch.testing.assert_close(
+        payload.meta.llm_output_text_utf8,
+        torch.tensor(list(b"hello"), dtype=torch.uint8),
+    )
+    assert payload.meta.duplex_epoch == 3
+    assert payload.meta.duplex_turn_id == 7
+    assert payload.meta.tts_is_last_chunk is True
+    assert payload.meta.turn_end is True
+
+
+def test_full_payload_forwards_all_codes_and_request_metadata() -> None:
+    manager = _manager()
+    request = _request("req")
+    request.additional_information = {
+        "codes": {"ref": [0.1, -0.1]},
+        "meta": {
+            "ref_audio_sr": 16000,
+            "native_duplex_segment_text": "hello",
+            "segment_end": True,
+            "turn_end": True,
+        },
+        "duplex": {"epoch": 3, "model_turn_id": 7},
+    }
+
+    payload = tts2code2wav_full_payload(
+        transfer_manager=manager,
+        pooling_output={
+            "codes.audio": torch.arange(7, dtype=torch.long).reshape(-1, 1),
+            "meta.finished": torch.tensor(True),
+        },
+        request=request,
+    )
+
+    assert _codes(payload) == [4218, 4218, 4218, *range(7)]
+    assert payload.codes.ref.tolist() == pytest.approx([0.1, -0.1])
+    assert payload.meta.request_id == "req"
+    assert payload.meta.chunk_seq == 0
+    assert payload.meta.code_flat_numel == 10
+    assert payload.meta.codec_chunk_frames == 7
+    assert payload.meta.codec_left_context_frames == 3
+    assert payload.meta.left_context_size == 3
+    assert payload.meta.last_chunk is True
+    assert payload.meta.finished.item() is True
+    assert payload.meta.ref_audio_sr == 16000
+    assert payload.meta.native_duplex_segment_text == "hello"
+    assert payload.meta.duplex_epoch == 3
+    assert payload.meta.duplex_turn_id == 7
+    assert payload.meta.segment_end is True
+    assert payload.meta.turn_end is True
+
+
+def test_sync_token_only_reserves_codec_and_silence_slots() -> None:
+    output = SimpleNamespace(
+        finished=True,
+        outputs=[
+            SimpleNamespace(
+                multimodal_output={
+                    "codes.audio": torch.arange(7, dtype=torch.long).reshape(-1, 1),
+                    "meta.finished": torch.tensor(True),
+                }
+            )
+        ],
+    )
+
+    prompts = tts2code2wav_token_only([output])
+
+    assert len(prompts) == 1
+    assert prompts[0]["prompt_token_ids"] == [0] * 10
+    assert prompts[0]["additional_information"] is None
+
+
+def test_empty_final_releases_wait_gate_once() -> None:
+    manager = _manager()
+    request = _request("req")
+
+    final = tts2code2wav_async_chunk(manager, None, request, True)
+    duplicate = tts2code2wav_async_chunk(manager, None, request, True)
+
+    assert final is not None
+    assert _codes(final) == []
+    assert final.meta.chunk_seq == 0
+    assert final.meta.request_id == "req"
+    assert final.meta.cache_epoch == 0
+    assert final.meta.last_chunk is True
+    assert duplicate is None
+
+
+def test_empty_duplex_boundary_uses_zero_length_transport_placeholder() -> None:
+    manager = _manager()
+
+    boundary = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(text="boundary"),
+        _request("req-duplex"),
+        True,
+    )
+
+    assert boundary is not None
+    assert _codes(boundary) == [0]
+    assert boundary.meta.code_flat_numel == 0
+    assert boundary.meta.last_chunk is False
+    assert boundary.meta.is_segment_finished.item() is False
+    torch.testing.assert_close(
+        boundary.meta.llm_output_text_utf8,
+        torch.tensor(list(b"boundary"), dtype=torch.uint8),
+    )
+
+
+def test_duplex_segments_preserve_stream_state_without_closing_turn() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+    request.additional_information = {
+        "codes": {"ref": [0.1, 0.2, 0.3]},
+        "meta": {"ref_audio_sr": 16000},
+    }
+
+    first = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(10, 11, text="first"),
+        request,
+        True,
+    )
+    second = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(12, 13, text="second"),
+        request,
+        True,
+    )
+
+    assert first is not None
+    assert second is not None
+    assert first.meta.last_chunk is False
+    assert second.meta.last_chunk is False
+    assert first.codes is not None
+    assert torch.allclose(first.codes.ref, torch.tensor([0.1, 0.2, 0.3]))
+    assert first.meta.ref_audio_sr == 16000
+    assert second.codes is not None
+    assert second.codes.ref is None
+    assert second.meta.cache_epoch == first.meta.cache_epoch
+    assert second.meta.chunk_seq == first.meta.chunk_seq + 1
+    assert second.meta.duplex_epoch == 3
+    assert second.meta.duplex_turn_id == 7
+    torch.testing.assert_close(
+        second.meta.llm_output_text_utf8,
+        torch.tensor(list(b"second"), dtype=torch.uint8),
+    )
+    assert second.meta.tts_is_last_chunk is True
+    assert second.meta.turn_end is False
+    assert first.meta.is_segment_finished.item() is False
+    assert second.meta.is_segment_finished.item() is False
+
+
+def test_duplex_short_units_wait_for_minimum_stream_body() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+
+    first = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(10, 11, 12, text="first"),
+        request,
+        True,
+    )
+    second = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(13, 14, text="first"),
+        request,
+        True,
+    )
+
+    assert first is not None
+    assert _codes(first) == [0]
+    assert first.meta.code_flat_numel == 0
+    assert first.meta.last_chunk is False
+    assert first.meta.tts_is_last_chunk is True
+    assert second is not None
+    assert _codes(second) == [4218, 4218, 4218, 10, 11, 12, 13, 14]
+    assert second.meta.code_flat_numel == 8
+    torch.testing.assert_close(
+        second.meta.llm_output_text_utf8,
+        torch.tensor(list(b"firstfirst"), dtype=torch.uint8),
+    )
+
+
+def test_duplex_empty_finish_callback_does_not_replay_previous_text() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+
+    first = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(*range(25), text="first"),
+        request,
+        False,
+    )
+    boundary = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(text="first"),
+        request,
+        True,
+    )
+    second = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(*range(25, 50), text="second"),
+        request,
+        False,
+    )
+
+    assert first is not None
+    assert boundary is not None
+    assert boundary.meta.code_flat_numel == 0
+    assert second is not None
+    torch.testing.assert_close(
+        second.meta.llm_output_text_utf8,
+        torch.tensor(list(b"second"), dtype=torch.uint8),
+    )
+
+
+def test_duplex_short_tail_does_not_replay_previous_segment_text() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+
+    def chunk(codes, text: str, finished: bool):
+        return tts2code2wav_async_chunk(
+            manager,
+            _duplex_delta(*codes, text=text),
+            request,
+            finished,
+        )
+
+    first = chunk(range(25), "和上海之间", False)
+    first_tail = chunk([25, 26], "和上海之间", True)
+    assert first is not None
+    assert first.meta.llm_output_text_utf8.tolist() == list("和上海之间".encode())
+    assert first_tail is not None
+    assert first_tail.meta.code_flat_numel == 0
+    assert chunk([27, 28, 29], "的距离大约是", False) is None
+    next_flush = chunk([], "的距离大约是", True)
+    assert next_flush is not None
+    assert next_flush.meta.llm_output_text_utf8.tolist() == list("的距离大约是".encode())
+
+
+def test_duplex_turn_end_closes_epoch_and_next_turn_restarts_sequence() -> None:
+    manager = _manager()
+    request = _request("req-duplex")
+
+    turn_end = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(14, turn_id=7, turn_end=True),
+        request,
+        True,
+    )
+    next_turn = tts2code2wav_async_chunk(
+        manager,
+        _duplex_delta(20, turn_id=8),
+        request,
+        True,
+    )
+
+    assert turn_end is not None
+    assert next_turn is not None
+    assert turn_end.meta.last_chunk is True
+    assert turn_end.meta.turn_end is True
+    assert turn_end.meta.is_segment_finished.item() is True
+    assert next_turn.meta.cache_epoch == turn_end.meta.cache_epoch + 1
+    assert next_turn.meta.chunk_seq == 0
+    assert next_turn.meta.last_chunk is False
+
+
+def test_staggered_requests_keep_accumulators_isolated() -> None:
+    manager = _manager()
+    req_a = _request("a")
+    req_b = _request("b")
+
+    assert tts2code2wav_async_chunk(manager, _delta(*range(24)), req_a, False) is None
+    out_b = tts2code2wav_async_chunk(manager, _delta(*range(100, 125)), req_b, False)
+    out_a = tts2code2wav_async_chunk(manager, _delta(24), req_a, False)
+
+    assert out_b is not None
+    assert out_a is not None
+    assert _codes(out_b) == [4218, 4218, 4218, *range(100, 125)]
+    assert _codes(out_a) == [4218, 4218, 4218, *range(25)]
+    assert out_a.meta.request_id == "a"
+    assert out_b.meta.request_id == "b"
+
+
+def test_cancel_drops_epoch_state_and_stale_request_cannot_publish() -> None:
+    manager = _manager()
+    stale = _request("req", "internal-0")
+
+    assert tts2code2wav_async_chunk(manager, _delta(*range(10)), stale, False) is None
+    stale.status = RequestStatus.FINISHED_ABORTED
+    assert tts2code2wav_async_chunk(manager, None, stale, True) is None
+    assert tts2code2wav_async_chunk(manager, _delta(*range(25)), stale, False) is None
+
+    replacement = _request("req", "internal-1")
+    payload = tts2code2wav_async_chunk(manager, _delta(*range(25)), replacement, False)
+
+    assert payload is not None
+    assert payload.meta.cache_epoch == 1
+    assert _codes(payload) == [4218, 4218, 4218, *range(25)]
diff --git a/tests/model_executor/stage_input_processors/test_minicpmo_4_5_omni.py b/tests/model_executor/stage_input_processors/test_minicpmo_4_5_omni.py
new file mode 100644
index 000000000..652215a08
--- /dev/null
+++ b/tests/model_executor/stage_input_processors/test_minicpmo_4_5_omni.py
@@ -0,0 +1,276 @@
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni import (
+    _extract_first_audio_ref,
+    llm2tts,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _output(
+    *,
+    prompt_ids: list[int],
+    output_ids: list[int],
+    latent: torch.Tensor,
+    multimodal_output: dict | None = None,
+    token_list: list[int] | None = None,
+):
+    mm_output = dict(multimodal_output or {})
+    mm_output["latent"] = latent
+    completion = SimpleNamespace(
+        token_ids=output_ids if token_list is None else token_list,
+        text="hello",
+        multimodal_output=mm_output,
+    )
+    return SimpleNamespace(
+        request_id="req-1",
+        prompt_token_ids=prompt_ids,
+        outputs=[completion],
+    )
+
+
+def test_extract_first_audio_ref_accepts_dict_stereo_audio() -> None:
+    ref = _extract_first_audio_ref(
+        {
+            "audio": {
+                "array": [[1.0, 3.0, 5.0], [2.0, 4.0, 6.0]],
+                "sampling_rate": 16000,
+            }
+        }
+    )
+
+    assert ref is not None
+    waveform, sample_rate = ref
+    assert sample_rate == 16000
+    assert torch.allclose(waveform, torch.tensor([1.5, 3.5, 5.5]))
+
+
+def test_plain_chat_handoff_owns_talker_prompt_contract() -> None:
+    prompt_ids = [101, 102]
+    output_ids = [11, 12]
+    latent = torch.arange(16, dtype=torch.float32).reshape(4, 4)
+
+    converted = llm2tts(
+        [_output(prompt_ids=prompt_ids, output_ids=output_ids, latent=latent)],
+        prompt=[{}],
+    )[0]
+
+    info = converted["model_intermediate_buffer"]
+    assert info["ids"]["tts"] == output_ids
+    assert torch.equal(torch.tensor(info["hidden_states"]["tts"]), latent[2:4])
+    assert converted["prompt_token_ids"] == [0, 0, 0, 0]
+    assert info["meta"]["replace_streaming_prompt"] is True
+    assert info["meta"]["next_stage_prompt_len"] == 4
+
+
+def test_llm2tts_carries_request_ref_audio() -> None:
+    latent = torch.arange(20, dtype=torch.float32).reshape(5, 4)
+    source = _output(
+        prompt_ids=[101, 9001],
+        output_ids=[11, 12, 9002],
+        latent=latent,
+        multimodal_output={
+            "meta": {
+                "tts_bos_token_id": 9001,
+                "tts_eos_token_id": 9002,
+            }
+        },
+    )
+    ref_waveform = torch.tensor([0.1, 0.2, 0.3])
+
+    converted = llm2tts(
+        [source],
+        prompt=[{"multi_modal_data": {"audio": (ref_waveform, 22050)}}],
+    )[0]
+
+    info = converted["model_intermediate_buffer"]
+    assert info["codes"]["ref"] == ref_waveform.tolist()
+    assert info["meta"]["ref_audio_sr"] == 22050
+    assert info["ids"]["tts"] == [11, 12]
+
+
+def test_native_duplex_speak_segment_reaches_split_talker() -> None:
+    prompt_ids = [101, 102]
+    output_ids = [9304, 21, 22, 9308]
+    latent = torch.arange(24, dtype=torch.float32).reshape(6, 4)
+    source = _output(
+        prompt_ids=prompt_ids,
+        output_ids=output_ids,
+        latent=latent,
+        multimodal_output={
+            "duplex_prompt_token_ids": prompt_ids,
+            "meta": {
+                "tts_bos_token_id": 9301,
+                "tts_eos_token_id": 9302,
+                "listen_token_id": 9303,
+                "speak_token_id": 9304,
+                "chunk_eos_token_id": 9308,
+                "chunk_tts_eos_token_id": 9309,
+                "turn_eos_token_id": 9310,
+            },
+        },
+    )
+    context = SimpleNamespace(
+        bridge_states={
+            "duplex": {
+                "epoch": 3,
+                "model_turn_id": 7,
+            }
+        }
+    )
+
+    converted = llm2tts([source], prompt=[{}], _streaming_context=context)[0]
+
+    info = converted["model_intermediate_buffer"]
+    assert info["native_duplex"] is True
+    assert info["ids"]["tts"] == [21, 22]
+    assert converted["prompt_token_ids"] == [0, 0, 0]
+    assert info["meta"]["replace_streaming_prompt"] is True
+    assert info["meta"]["next_stage_prompt_len"] == 3
+    assert info["meta"]["turn_start"] is True
+    assert info["meta"]["segment_end"] is True
+    assert info["duplex"]["epoch"] == 3
+    assert info["duplex"]["turn_id"] == 7
+
+
+def test_native_duplex_continuation_appends_only_new_talker_condition() -> None:
+    prompt_ids = [101, 102]
+    token_ids = {
+        "tts_bos_token_id": 9301,
+        "tts_eos_token_id": 9302,
+        "listen_token_id": 9303,
+        "speak_token_id": 9304,
+        "chunk_eos_token_id": 9308,
+        "chunk_tts_eos_token_id": 9309,
+        "turn_eos_token_id": 9310,
+    }
+    context = SimpleNamespace(
+        bridge_states={
+            "duplex": {
+                "epoch": 3,
+                "model_turn_id": 7,
+            }
+        }
+    )
+
+    first_ids = [9304, 21, 22, 9308]
+    first = _output(
+        prompt_ids=prompt_ids,
+        output_ids=first_ids,
+        latent=torch.arange(24, dtype=torch.float32).reshape(6, 4),
+        multimodal_output={
+            "duplex_prompt_token_ids": prompt_ids,
+            "meta": token_ids,
+        },
+    )
+    second_ids = [*first_ids, 9304, 23, 24, 9308]
+    second = _output(
+        prompt_ids=prompt_ids,
+        output_ids=second_ids,
+        latent=torch.arange(40, dtype=torch.float32).reshape(10, 4),
+        multimodal_output={
+            "duplex_prompt_token_ids": prompt_ids,
+            "meta": token_ids,
+        },
+    )
+    third_ids = [*second_ids, 9304, 25, 26, 9308]
+    third = _output(
+        prompt_ids=prompt_ids,
+        output_ids=third_ids,
+        latent=torch.arange(56, dtype=torch.float32).reshape(14, 4),
+        multimodal_output={
+            "duplex_prompt_token_ids": prompt_ids,
+            "meta": token_ids,
+        },
+    )
+
+    first_input = llm2tts([first], prompt=[{}], _streaming_context=context)[0]
+    second_input = llm2tts([second], prompt=[{}], _streaming_context=context)[0]
+    context.bridge_states["duplex"]["model_turn_id"] = 8
+    third_input = llm2tts([third], prompt=[{}], _streaming_context=context)[0]
+
+    assert first_input["model_intermediate_buffer"]["ids"]["tts"] == [21, 22]
+    assert second_input["model_intermediate_buffer"]["ids"]["tts"] == [23, 24]
+    assert third_input["model_intermediate_buffer"]["ids"]["tts"] == [25, 26]
+    assert first_input["model_intermediate_buffer"]["meta"]["turn_start"] is True
+    assert second_input["model_intermediate_buffer"]["meta"]["turn_start"] is False
+    assert third_input["model_intermediate_buffer"]["meta"]["turn_start"] is True
+    assert first_input["model_intermediate_buffer"]["meta"]["replace_streaming_prompt"] is True
+    assert "replace_streaming_prompt" not in second_input["model_intermediate_buffer"]["meta"]
+    assert third_input["model_intermediate_buffer"]["meta"]["replace_streaming_prompt"] is True
+    assert second_input["model_intermediate_buffer"]["meta"]["next_stage_prompt_len"] == 3
+    assert second_input["prompt_token_ids"] == [0, 0, 0]
+
+
+def test_native_duplex_transcript_decodes_the_talker_condition_slice() -> None:
+    prompt_ids = [101, 102]
+    metadata = {
+        "tts_bos_token_id": 9301,
+        "tts_eos_token_id": 9302,
+        "listen_token_id": 9303,
+        "speak_token_id": 9304,
+        "chunk_eos_token_id": 9308,
+        "chunk_tts_eos_token_id": 9309,
+        "turn_eos_token_id": 9310,
+    }
+    token_text = {21: "杭州", 22: "和", 23: "州和", 24: "上海之间", 25: "大"}
+
+    def output(token_ids: list[int]):
+        return _output(
+            prompt_ids=prompt_ids,
+            output_ids=token_ids,
+            latent=torch.zeros((len(prompt_ids) + len(token_ids), 1)),
+            multimodal_output={
+                "duplex_prompt_token_ids": prompt_ids,
+                "meta": metadata,
+            },
+        )
+
+    context = SimpleNamespace(
+        bridge_states={"duplex": {"epoch": 3, "model_turn_id": 7}},
+        source_token_decoder=lambda ids, **_: "".join(token_text.get(int(token_id), "") for token_id in ids),
+    )
+    first_ids = [9304, 21, 22, 9308]
+    first_info = llm2tts([output(first_ids)], prompt=[{}], _streaming_context=context)[0]["model_intermediate_buffer"]
+    second_info = llm2tts(
+        [output([*first_ids, 23, 24, 25, 9308])],
+        prompt=[{}],
+        _streaming_context=context,
+    )[0]["model_intermediate_buffer"]
+
+    assert first_info["meta"]["native_duplex_segment_text"] == "杭州和"
+    assert second_info["ids"]["tts"] == [24, 25]
+    assert second_info["meta"]["native_duplex_segment_text"] == "上海之间大"
+
+
+def test_native_duplex_requires_tokenizer_boundary_metadata() -> None:
+    latent = torch.zeros((3, 4))
+    source = _output(
+        prompt_ids=[101],
+        output_ids=[21, 22],
+        latent=latent,
+        multimodal_output={"duplex_prompt_token_ids": [101]},
+    )
+
+    with pytest.raises(ValueError, match="tokenizer-derived.*metadata"):
+        llm2tts([source], prompt=[{}], _streaming_context=SimpleNamespace(bridge_states={}))
+
+
+def test_llm2tts_does_not_alias_live_thinker_token_list() -> None:
+    live_tokens = [11, 12]
+    latent = torch.zeros((3, 4))
+    source = _output(
+        prompt_ids=[101],
+        output_ids=list(live_tokens),
+        latent=latent,
+        token_list=live_tokens,
+    )
+
+    converted = llm2tts([source], prompt=[{}])[0]
+    live_tokens.append(13)
+
+    assert converted["model_intermediate_buffer"]["ids"]["output"] == [11, 12]
diff --git a/tests/model_executor/stage_input_processors/test_personaplex.py b/tests/model_executor/stage_input_processors/test_personaplex.py
new file mode 100644
index 000000000..37f464201
--- /dev/null
+++ b/tests/model_executor/stage_input_processors/test_personaplex.py
@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.personaplex.personaplex_talker import (
+    PersonaPlexTalkerForConditionalGeneration,
+)
+from vllm_omni.model_executor.stage_input_processors.personaplex import (
+    talker2code2wav_async_chunk,
+    talker2code2wav_full_payload,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _raw_agent_codes() -> torch.Tensor:
+    return torch.arange(16, dtype=torch.long).reshape(2, 8)
+
+
+@pytest.mark.parametrize("source", ["pooling_output", "additional_information_cpu"])
+def test_full_payload_accepts_worker_and_cached_payload_sources(source: str) -> None:
+    audio = _raw_agent_codes()
+    payload = talker2code2wav_full_payload(
+        pooling_output={"codes": {"audio": audio}} if source == "pooling_output" else None,
+        request=(
+            SimpleNamespace()
+            if source == "pooling_output"
+            else SimpleNamespace(additional_information_cpu={"codes": {"audio": audio}})
+        ),
+    )
+
+    expected = torch.cat([audio[:-1, :1], audio[1:, 1:]], dim=1).reshape(-1)
+    assert torch.equal(payload.codes.audio, expected)
+
+
+def test_async_chunk_keeps_delay_tail_across_resumable_segments() -> None:
+    manager = SimpleNamespace(
+        connector=SimpleNamespace(
+            config={
+                "extra": {
+                    "initial_codec_chunk_frames": 1,
+                    "codec_chunk_frames": 5,
+                }
+            }
+        )
+    )
+    request = SimpleNamespace(
+        request_id="req",
+        external_req_id="req",
+        resumable=True,
+        is_finished=lambda: True,
+        additional_information=None,
+    )
+    first_frame = torch.arange(8, dtype=torch.long).reshape(1, 8)
+    second_frame = torch.arange(8, 16, dtype=torch.long).reshape(1, 8)
+
+    request.additional_information = {"codes": {"audio": first_frame}}
+    first = talker2code2wav_async_chunk(
+        manager,
+        multimodal_output=None,
+        request=request,
+        is_finished=True,
+    )
+    request.additional_information = {"codes": {"audio": second_frame}}
+    second = talker2code2wav_async_chunk(
+        manager,
+        multimodal_output=None,
+        request=request,
+        is_finished=True,
+    )
+
+    assert first is not None
+    assert first.codes is None
+    assert first.meta is not None
+    assert first.meta.finished.item() is False
+    assert first.meta.is_segment_finished.item() is False
+    expected = torch.cat([first_frame[:, :1], second_frame[:, 1:]], dim=1).reshape(-1)
+    assert torch.equal(second.codes.audio, expected)
+    assert manager.request_payload["req"]["personaplex_frames"][0].equal(second_frame.reshape(-1))
+
+
+def test_post_sample_talker_mtp_uses_current_temporal_state() -> None:
+    received: dict[str, torch.Tensor] = {}
+    recorded: list[tuple[str, torch.Tensor, torch.Tensor]] = []
+
+    def depformer(
+        text_token: torch.Tensor,
+        hidden: torch.Tensor,
+        *,
+        audio_tokens: torch.Tensor | None = None,
+        audio_provided: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        received["text_token"] = text_token
+        received["hidden"] = hidden
+        received["audio_tokens"] = audio_tokens
+        received["audio_provided"] = audio_provided
+        return torch.arange(16, dtype=torch.long).reshape(1, 16)
+
+    model = SimpleNamespace(
+        _dtype=torch.float32,
+        depformer=depformer,
+        _duplex_stage0_runtime=lambda: SimpleNamespace(
+            record_sample=lambda *, request_id, text_token, agent_codes: recorded.append(
+                (request_id, text_token.clone(), agent_codes.clone())
+            )
+        ),
+    )
+    method = getattr(PersonaPlexTalkerForConditionalGeneration, "post_sample_talker_mtp", None)
+    assert callable(method)
+
+    codes = method(
+        model,
+        input_ids=torch.tensor([101]),
+        hidden_states=torch.arange(4, dtype=torch.float32).reshape(1, 4),
+        req_ids=["r1"],
+        req_infos=[
+            {
+                "duplex": {"data_plane": True},
+                "pplex_depformer_audio_tokens": torch.arange(16),
+                "pplex_depformer_audio_provided": torch.arange(16) > 0,
+            }
+        ],
+    )
+
+    assert codes.shape == (1, 16)
+    assert received["text_token"].tolist() == [101]
+    assert received["hidden"].shape == (1, 1, 4)
+    assert torch.equal(received["audio_tokens"], torch.arange(16).reshape(1, 16))
+    assert torch.equal(received["audio_provided"], (torch.arange(16) > 0).reshape(1, 16))
+    assert [(row[0], row[1].item()) for row in recorded] == [("r1", 101)]
+    assert torch.equal(recorded[0][2], codes[0])
diff --git a/tests/model_executor/stage_input_processors/test_qwen2_5_omni_thinker2talker.py b/tests/model_executor/stage_input_processors/test_qwen2_5_omni_thinker2talker.py
index 0cb61a972..3ecae3d56 100644
--- a/tests/model_executor/stage_input_processors/test_qwen2_5_omni_thinker2talker.py
+++ b/tests/model_executor/stage_input_processors/test_qwen2_5_omni_thinker2talker.py
@@ -20,6 +20,8 @@ from vllm_omni.model_executor.stage_input_processors.qwen2_5_omni import (
     thinker2talker_full_payload,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def _make_request(
     prompt_token_ids,
diff --git a/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py b/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
index 8a6dfbe94..96a938513 100644
--- a/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
+++ b/tests/model_executor/stage_input_processors/test_qwen3_omni_streaming_helpers.py
@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 from types import SimpleNamespace
 
 import pytest
@@ -227,6 +228,47 @@ def test_talker2code2wav_full_payload_keeps_all_zero_codec_rows() -> None:
     assert "code_predictor_codes" not in payload
 
 
+def test_talker2code2wav_async_chunk_flushes_cached_tail_on_stop_token() -> None:
+    request_id = "codec_tail"
+    stop_token_id = 999
+    transfer_manager = SimpleNamespace(
+        code_prompt_token_ids=defaultdict(list),
+        put_req_chunk=defaultdict(int, {request_id: 2}),
+        connector=SimpleNamespace(
+            config={
+                "extra": {
+                    "initial_codec_chunk_frames": 4,
+                    "codec_chunk_frames": 25,
+                    "codec_left_context_frames": 25,
+                }
+            }
+        ),
+    )
+    transfer_manager.code_prompt_token_ids[request_id] = [
+        torch.tensor([[frame, frame + 100]], dtype=torch.long) for frame in range(50)
+    ]
+    request = SimpleNamespace(
+        external_req_id=request_id,
+        sampling_params=SimpleNamespace(
+            stop_token_ids=[stop_token_id],
+            stop_token_id=None,
+        ),
+    )
+
+    payload = q3.talker2code2wav_async_chunk(
+        transfer_manager,
+        {"codes": {"audio": torch.tensor([[stop_token_id, 0]], dtype=torch.long)}},
+        request,
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.meta.finished.item() is True
+    # 4 initial frames and one 25-frame chunk were already emitted. The final
+    # payload contains 25 frames of left context plus the remaining 21 frames.
+    assert payload.codes.audio.numel() == (25 + 21) * 2
+
+
 def test_thinker2talker_full_payload_packs_complete_tensors() -> None:
     """Full-payload path drops the terminal thinker row before talker prefill."""
     request = SimpleNamespace(
diff --git a/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py b/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
index bc6239e29..c41541cc8 100644
--- a/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
+++ b/tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py
@@ -9,9 +9,15 @@ import torch
 
 from vllm_omni.model_executor.stage_input_processors.chunk_size_utils import (
     compute_dynamic_initial_chunk_size,
+    compute_ramp_emit,
     max_ic_for_chunk_size,
+    parse_chunk_ramp,
+    ramp_chunk_size,
+    ramp_cumulative,
 )
 from vllm_omni.model_executor.stage_input_processors.qwen3_tts import (
+    _NUM_QUANTIZERS_DEFAULT,
+    _filter_audio_codes_qwen3_tts,
     talker2code2wav_async_chunk,
     talker2code2wav_full_payload,
     talker2code2wav_token_only,
@@ -35,21 +41,21 @@ def _req(rid, *, finished, initial_codec_chunk_frames=None):
     )
 
 
-def _tm(*, chunk_frames=25, left_context=25, max_num_seqs=1, initial_chunk_frames=0):
+def _tm(*, chunk_frames=25, left_context=25, max_num_seqs=1, initial_chunk_frames=0, chunk_ramp=None):
+    extra = {
+        "codec_chunk_frames": chunk_frames,
+        "codec_left_context_frames": left_context,
+        "initial_codec_chunk_frames": initial_chunk_frames,
+    }
+    if chunk_ramp is not None:
+        extra["codec_chunk_ramp"] = chunk_ramp
     return SimpleNamespace(
         code_prompt_token_ids=defaultdict(list),
         scheduler_max_num_seqs=max_num_seqs,
         put_req_chunk=defaultdict(int),
+        ramp_chunk_count=defaultdict(int),
         request_payload={},
-        connector=SimpleNamespace(
-            config={
-                "extra": {
-                    "codec_chunk_frames": chunk_frames,
-                    "codec_left_context_frames": left_context,
-                    "initial_codec_chunk_frames": initial_chunk_frames,
-                }
-            }
-        ),
+        connector=SimpleNamespace(config={"extra": extra}),
     )
 
 
@@ -530,17 +536,23 @@ def test_full_payload_omits_left_context_size_without_ref():
         pytest.param({"codes.audio": torch.zeros((3, _Q), dtype=torch.long)}, id="all_codes_filtered"),
     ],
 )
-def test_full_payload_emits_empty_finished_payload_on_degenerate_take(pooling_output):
-    """Regression for #4463.
+def test_full_payload_emits_placeholder_frame_on_degenerate_take(pooling_output):
+    """Regression for #4463 and #5471 (the producer half of #5196).
 
-    A degenerate talker take used to return ``None`` from
-    ``talker2code2wav_full_payload``. The connector treats ``None`` as "drop the
+    A degenerate talker take must not return ``None`` from
+    ``talker2code2wav_full_payload``: the connector treats ``None`` as "drop the
     request", but Stage-1 was already scheduled to receive it, so its wait gate
-    polls to ``connector_get_max_wait`` (~300s) and the orchestrator aborts — one
-    stuck request stalls the whole two-stage pipeline. Each degenerate case
-    (non-dict pooling_output, missing ``codes.audio``, all codec frames dropped by
-    the filter) must instead return an empty-but-finished payload so the gate
-    releases and the request finishes immediately with zero-length audio.
+    polls to ``connector_get_max_wait`` (~300s) and one stuck request stalls the
+    whole two-stage pipeline (#4463). It must not return an *empty* finished
+    payload either: zero codec frames produce a zero-token Stage-1 request,
+    which full-payload scheduling placeholder-schedules once and never
+    collects; the base-scheduler fallback then schedules it at a negative span,
+    which killed the stage EngineCore before #5269 and leaves the request
+    parked in ``running`` forever after it (#5196, #5471). Each degenerate case
+    (non-dict pooling_output, missing ``codes.audio``, all codec frames dropped
+    by the filter) must instead return a finished payload with at least one
+    frame that survives the codec validity filter, so the request runs the
+    normal one-shot path and finishes cleanly.
     """
     request = SimpleNamespace(request_id="r", output_token_ids=[0, 1, 2])
 
@@ -548,4 +560,371 @@ def test_full_payload_emits_empty_finished_payload_on_degenerate_take(pooling_ou
 
     assert payload is not None
     assert payload["meta"]["finished"].item() is True
-    assert payload["codes"]["audio"].numel() == 0
+    audio = payload["codes"]["audio"]
+    # Same wire format as the normal path: flat, codebook-major, one frame.
+    assert audio.ndim == 1
+    assert audio.numel() == _NUM_QUANTIZERS_DEFAULT
+    # The placeholder must survive the same validity filter real takes go
+    # through; a frame the filter would drop re-creates the zero-token request.
+    frames = audio.reshape(-1, _NUM_QUANTIZERS_DEFAULT)
+    assert int(_filter_audio_codes_qwen3_tts(frames).shape[0]) >= 1
+
+
+_RAMP = [1, 4, 8, 16, 25]
+
+
+class TestRampHelpers:
+    def test_parse_ramp_none_when_absent(self):
+        assert parse_chunk_ramp({}) is None
+
+    def test_parse_ramp_valid(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": [1, 4, 8, 16, 25]}) == [1, 4, 8, 16, 25]
+
+    def test_parse_ramp_from_string(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": "1, 4, 8, 16, 25"}) == [1, 4, 8, 16, 25]
+
+    def test_parse_ramp_too_short(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": [25]}) is None
+
+    def test_parse_ramp_non_positive(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": [1, 0, 8]}) is None
+
+    def test_parse_ramp_bad_string(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": "a,b"}) is None
+
+    def test_parse_ramp_int_returns_none(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": 4}) is None
+
+    def test_parse_ramp_float_returns_none(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": 4.5}) is None
+
+    def test_parse_ramp_mixed_list_returns_none(self):
+        assert parse_chunk_ramp({"codec_chunk_ramp": [4, "x"]}) is None
+
+    def test_parse_ramp_warns_on_tail_mismatch(self, caplog):
+        import logging
+
+        with caplog.at_level(logging.WARNING):
+            result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8]}, steady=25)
+        assert result == [4, 4, 8]
+        assert any("reintroduces" in r.message for r in caplog.records)
+
+    def test_parse_ramp_no_warn_on_tail_match(self, caplog):
+        import logging
+
+        with caplog.at_level(logging.WARNING):
+            result = parse_chunk_ramp({"codec_chunk_ramp": [4, 4, 8, 16, 25]}, steady=25)
+        assert result == [4, 4, 8, 16, 25]
+        assert not any("reintroduces" in r.message for r in caplog.records)
+
+    @pytest.mark.parametrize(
+        "index,ramp,steady,expected",
+        [
+            (0, _RAMP, 25, 1),
+            (1, _RAMP, 25, 4),
+            (2, _RAMP, 25, 8),
+            (3, _RAMP, 25, 16),
+            (4, _RAMP, 25, 25),
+            (5, _RAMP, 25, 25),
+            (100, _RAMP, 25, 25),
+        ],
+    )
+    def test_ramp_chunk_size(self, index, ramp, steady, expected):
+        assert ramp_chunk_size(index, ramp, steady) == expected
+
+    @pytest.mark.parametrize(
+        "index,ramp,steady,expected",
+        [
+            (0, _RAMP, 25, 1),
+            (1, _RAMP, 25, 5),
+            (2, _RAMP, 25, 13),
+            (3, _RAMP, 25, 29),
+            (4, _RAMP, 25, 54),
+            (5, _RAMP, 25, 79),
+            (6, _RAMP, 25, 104),
+            (100, _RAMP, 25, 54 + 96 * 25),
+        ],
+    )
+    def test_ramp_cumulative(self, index, ramp, steady, expected):
+        assert ramp_cumulative(index, ramp, steady) == expected
+
+    @pytest.mark.parametrize(
+        "length,chunk_index,finished,expected_emit,expected_ctx",
+        [
+            (0, 0, False, False, 0),
+            (1, 0, False, True, 1),
+            (3, 1, False, False, 0),
+            (5, 1, False, True, 4),
+            (12, 2, False, False, 0),
+            (13, 2, False, True, 8),
+            (28, 3, False, False, 0),
+            (29, 3, False, True, 16),
+            (53, 4, False, False, 0),
+            (54, 4, False, True, 25),
+            (78, 5, False, False, 0),
+            (79, 5, False, True, 25),
+            (1, 1, True, True, 0),
+            (3, 1, True, True, 2),
+            (5, 1, True, True, 4),
+        ],
+    )
+    def test_compute_ramp_emit(self, length, chunk_index, finished, expected_emit, expected_ctx):
+        emit, ctx = compute_ramp_emit(length, chunk_index, _RAMP, 25, finished)
+        assert emit == expected_emit
+        assert ctx == expected_ctx
+
+
+class TestChunkRampEmission:
+    RAMP = [1, 4, 8, 16, 25]
+
+    def _emit(self, tm, rid, n_frames, finished=False):
+        tm.code_prompt_token_ids[rid] = [_FRAME[:] for _ in range(n_frames)]
+        return talker2code2wav_async_chunk(
+            transfer_manager=tm,
+            multimodal_output={"codes": {"audio": torch.zeros((0,))}},
+            request=_req(rid, finished=finished),
+            is_finished=finished,
+        )
+
+    def test_ramp_sequence_1_4_8_16_25(self):
+        tm = _tm(chunk_ramp=self.RAMP)
+        rid = "ramp-seq"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        assert len(p0.codes.audio) == _Q * 1
+        tm.ramp_chunk_count[rid] = 1
+
+        assert self._emit(tm, rid, 2) is None
+        assert self._emit(tm, rid, 3) is None
+        assert self._emit(tm, rid, 4) is None
+        p1 = self._emit(tm, rid, 5)
+        assert p1 is not None
+        assert len(p1.codes.audio) == _Q * 5
+        assert p1.meta.left_context_size == 1
+        tm.ramp_chunk_count[rid] = 2
+
+        for n in range(6, 13):
+            assert self._emit(tm, rid, n) is None
+        p2 = self._emit(tm, rid, 13)
+        assert p2 is not None
+        assert p2.meta.left_context_size == 5
+        tm.ramp_chunk_count[rid] = 3
+
+        for n in range(14, 29):
+            assert self._emit(tm, rid, n) is None
+        p3 = self._emit(tm, rid, 29)
+        assert p3 is not None
+        assert p3.meta.left_context_size == 13
+        tm.ramp_chunk_count[rid] = 4
+
+        for n in range(30, 54):
+            assert self._emit(tm, rid, n) is None
+        p4 = self._emit(tm, rid, 54)
+        assert p4 is not None
+        assert p4.meta.left_context_size == 25
+        tm.ramp_chunk_count[rid] = 5
+
+        for n in range(55, 79):
+            assert self._emit(tm, rid, n) is None
+        p5 = self._emit(tm, rid, 79)
+        assert p5 is not None
+        assert p5.meta.left_context_size == 25
+
+    def test_ramp_finished_flush_mid_chunk(self):
+        tm = _tm(chunk_ramp=self.RAMP)
+        rid = "ramp-flush"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        tm.ramp_chunk_count[rid] = 1
+
+        p_fin = self._emit(tm, rid, 3, finished=True)
+        assert p_fin is not None
+        assert p_fin.meta.finished.item() is True
+        assert len(p_fin.codes.audio) == _Q * (1 + 2)
+        assert p_fin.meta.left_context_size == 1
+
+    def test_ramp_finished_no_new_frames(self):
+        tm = _tm(chunk_ramp=self.RAMP)
+        rid = "ramp-no-new"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        tm.ramp_chunk_count[rid] = 1
+
+        p_fin = self._emit(tm, rid, 1, finished=True)
+        assert p_fin is not None
+        assert p_fin.meta.finished.item() is True
+        assert p_fin.codes.audio.numel() == 0
+
+    def test_ramp_finished_at_exact_threshold(self):
+        tm = _tm(chunk_ramp=self.RAMP)
+        rid = "ramp-exact"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        tm.ramp_chunk_count[rid] = 1
+
+        p1 = self._emit(tm, rid, 5, finished=True)
+        assert p1 is not None
+        assert p1.meta.finished.item() is True
+
+    def test_ramp_backward_compat_without_config(self):
+        tm = _tm(initial_chunk_frames=1)
+        rid = "no-ramp"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        assert len(p0.codes.audio) == _Q * 1
+        tm.put_req_chunk[rid] = 1
+
+        for n in range(2, 26):
+            assert self._emit(tm, rid, n) is None
+        p1 = self._emit(tm, rid, 26)
+        assert p1 is not None
+        assert p1.meta.left_context_size == 1
+
+    def test_ramp_with_ref_code_first_chunk(self):
+        tm = _tm(chunk_ramp=self.RAMP, left_context=25)
+        rid = "ramp-ref"
+        tm.code_prompt_token_ids[rid] = [_FRAME[:] for _ in range(1)]
+        ref_code = torch.tensor([[9, 9, 9, 9], [8, 8, 8, 8]], dtype=torch.long)
+
+        payload = talker2code2wav_async_chunk(
+            transfer_manager=tm,
+            multimodal_output={"codes": {"audio": torch.zeros((0,)), "ref": ref_code}},
+            request=_req(rid, finished=False),
+            is_finished=False,
+        )
+
+        assert payload is not None
+        assert payload.meta.ref_context_size == 2
+        assert payload.meta.ref_context_included is True
+        assert payload.meta.left_context_size == 2
+        assert len(payload.codes.audio) == _Q * (2 + 1)
+
+    def test_ramp_steady_state_after_ramp_exhausted(self):
+        tm = _tm(chunk_ramp=[1, 4], chunk_frames=25)
+        rid = "ramp-short"
+
+        p0 = self._emit(tm, rid, 1)
+        assert p0 is not None
+        tm.ramp_chunk_count[rid] = 1
+
+        p1 = self._emit(tm, rid, 5)
+        assert p1 is not None
+        tm.ramp_chunk_count[rid] = 2
+
+        for n in range(6, 30):
+            assert self._emit(tm, rid, n) is None
+        p2 = self._emit(tm, rid, 30)
+        assert p2 is not None
+        assert p2.meta.left_context_size == 5
+        tm.ramp_chunk_count[rid] = 3
+
+        for n in range(31, 55):
+            assert self._emit(tm, rid, n) is None
+        p3 = self._emit(tm, rid, 55)
+        assert p3 is not None
+        assert p3.meta.left_context_size == 25
+
+    def test_ramp_profile_4_4_8_16_25(self):
+        """Ramp [4,4,8,16,25]: chunk 0=4 frames (320ms audio covers chunk 1
+        gen time → no gap at chunk 0→1), gradual ramp to steady state."""
+        tm = _tm(chunk_ramp=[4, 4, 8, 16, 25])
+        rid = "ramp-4-4-8-16-25"
+
+        for n in range(1, 4):
+            assert self._emit(tm, rid, n) is None
+        p0 = self._emit(tm, rid, 4)
+        assert p0 is not None
+        assert p0.meta.left_context_size == 0
+        tm.ramp_chunk_count[rid] = 1
+
+        for n in range(5, 8):
+            assert self._emit(tm, rid, n) is None
+        p1 = self._emit(tm, rid, 8)
+        assert p1 is not None
+        assert p1.meta.left_context_size == 4
+        tm.ramp_chunk_count[rid] = 2
+
+        for n in range(9, 16):
+            assert self._emit(tm, rid, n) is None
+        p2 = self._emit(tm, rid, 16)
+        assert p2 is not None
+        assert p2.meta.left_context_size == 8
+        tm.ramp_chunk_count[rid] = 3
+
+        for n in range(17, 32):
+            assert self._emit(tm, rid, n) is None
+        p3 = self._emit(tm, rid, 32)
+        assert p3 is not None
+        assert p3.meta.left_context_size == 16
+        tm.ramp_chunk_count[rid] = 4
+
+        for n in range(33, 57):
+            assert self._emit(tm, rid, n) is None
+        p4 = self._emit(tm, rid, 57)
+        assert p4 is not None
+        assert p4.meta.left_context_size == 25
+        tm.ramp_chunk_count[rid] = 5
+
+        for n in range(58, 82):
+            assert self._emit(tm, rid, n) is None
+        p5 = self._emit(tm, rid, 82)
+        assert p5 is not None
+        assert p5.meta.left_context_size == 25
+
+    def test_ramp_resets_on_segment_boundary(self):
+        """After segment 1 emits chunks, a segment boundary clears
+        code_prompt_token_ids and ramp_chunk_count. Segment 2 must restart
+        from chunk index 0.
+
+        Regression for: put_req_chunk is request-global and not reset at
+        segment boundaries. ramp_chunk_count is popped alongside
+        code_prompt_token_ids on is_segment_finished, so the ramp index
+        resets by construction."""
+        tm = _tm(chunk_ramp=[4, 4, 8, 16, 25])
+        rid = "ramp-segment"
+
+        p0 = self._emit(tm, rid, 4)
+        assert p0 is not None
+        assert p0.meta.left_context_size == 0
+        tm.ramp_chunk_count[rid] = 1
+        tm.put_req_chunk[rid] = 1
+
+        p1 = self._emit(tm, rid, 8)
+        assert p1 is not None
+        tm.ramp_chunk_count[rid] = 2
+        tm.put_req_chunk[rid] = 2
+
+        tm.code_prompt_token_ids[rid] = []
+        tm.ramp_chunk_count.pop(rid, None)
+
+        p_seg2_0 = self._emit(tm, rid, 4)
+        assert p_seg2_0 is not None
+        assert p_seg2_0.meta.left_context_size == 0
+
+    def test_ramp_resets_on_segment_boundary_one_chunk_history(self):
+        """Segment 1 emitted exactly 1 chunk (put_req_chunk=1). Segment 2
+        must still restart from chunk index 0.
+
+        Regression for: the hybrid put_req_chunk/derived scheme collided
+        when put_chunk=1 because length >= ramp_cumulative(0) turned true
+        at length=4, causing chunk_index to jump to 1 and dropping the
+        first 4 frames of segment 2."""
+        tm = _tm(chunk_ramp=[4, 4, 8, 16, 25])
+        rid = "ramp-segment-1chunk"
+
+        p0 = self._emit(tm, rid, 4)
+        assert p0 is not None
+        tm.ramp_chunk_count[rid] = 1
+        tm.put_req_chunk[rid] = 1
+
+        tm.code_prompt_token_ids[rid] = []
+        tm.ramp_chunk_count.pop(rid, None)
+
+        p_seg2_0 = self._emit(tm, rid, 4)
+        assert p_seg2_0 is not None
+        assert p_seg2_0.meta.left_context_size == 0
diff --git a/tests/model_executor/stage_input_processors/test_step_audio2_async_chunk.py b/tests/model_executor/stage_input_processors/test_step_audio2_async_chunk.py
index 186f00890..9349c1cc6 100644
--- a/tests/model_executor/stage_input_processors/test_step_audio2_async_chunk.py
+++ b/tests/model_executor/stage_input_processors/test_step_audio2_async_chunk.py
@@ -5,7 +5,6 @@ from collections import defaultdict
 from types import SimpleNamespace
 
 import pytest
-import torch
 
 from vllm_omni.model_executor.models.step_audio2.step_audio2_constants import (
     DEFAULT_STREAM_CONFIG,
@@ -43,14 +42,14 @@ def test_step_audio2_async_chunk_uses_decode_only_tokens_not_prompt_history():
 
     payload = thinker2token2wav_async_chunk(
         transfer_manager=transfer_manager,
-        pooling_output=None,
+        multimodal_output=None,
         request=request,
     )
 
     assert payload is not None
-    assert payload["code_predictor_codes"] == [1, 2]
-    assert payload["left_context_size"] == 1
-    assert payload["finished"].item() is True
+    assert payload.codes.audio.tolist() == [1, 2]
+    assert payload.meta.left_context_size == 1
+    assert payload.meta.finished.item() is True
 
 
 def test_step_audio2_async_chunk_returns_none_when_not_enough_tokens():
@@ -68,7 +67,7 @@ def test_step_audio2_async_chunk_returns_none_when_not_enough_tokens():
 
     payload = thinker2token2wav_async_chunk(
         transfer_manager=transfer_manager,
-        pooling_output=None,
+        multimodal_output=None,
         request=request,
     )
 
@@ -91,14 +90,14 @@ def test_step_audio2_async_chunk_emits_non_last_chunk_and_advances_consumed_by_c
 
     payload = thinker2token2wav_async_chunk(
         transfer_manager=transfer_manager,
-        pooling_output=None,
+        multimodal_output=None,
         request=request,
     )
 
     assert payload is not None
-    assert payload["left_context_size"] == 0
-    assert payload["finished"].item() is False
-    assert payload["code_predictor_codes"] == list(range(required))
+    assert payload.meta.left_context_size == 0
+    assert payload.meta.finished.item() is False
+    assert payload.codes.audio.tolist() == list(range(required))
     assert transfer_manager.code_prompt_token_ids["rid-ready"] == list(range(chunk_size))
 
 
@@ -121,12 +120,11 @@ def test_step_audio2_async_chunk_emits_eof_when_finished_with_no_remaining_audio
 
     payload = thinker2token2wav_async_chunk(
         transfer_manager=transfer_manager,
-        pooling_output=None,
+        multimodal_output=None,
         request=request,
     )
 
-    assert payload == {
-        "code_predictor_codes": [],
-        "left_context_size": 1,
-        "finished": torch.tensor(True, dtype=torch.bool),
-    }
+    assert payload is not None
+    assert payload.codes.audio.numel() == 0
+    assert payload.meta.left_context_size == 1
+    assert payload.meta.finished.item() is True
diff --git a/tests/model_extras/test_model_extras.py b/tests/model_extras/test_model_extras.py
index f2db9ded0..c73dbdf1e 100644
--- a/tests/model_extras/test_model_extras.py
+++ b/tests/model_extras/test_model_extras.py
@@ -12,12 +12,66 @@ from vllm_omni.model_extras import (
     build_image_to_image_prompt,
     build_image_to_video_prompt,
     build_text_to_image_prompt,
+    build_x_to_text_prompt,
     get_extra_body_params,
     get_extra_output_params,
+    get_x_to_text_model_family,
     should_init_extra_args_for_non_diffusion_stages,
 )
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    ("config", "expected"),
+    [
+        ({"model_type": "bagel"}, "bagel"),
+        ({"architectures": ["HunyuanImage3ForConditionalGeneration"]}, "hunyuan_image3"),
+        ({"model_type": "mammothmoda2"}, "mammoth_moda2"),
+        ({"model_type": "qwen2_vl"}, "generic"),
+    ],
+)
+def test_x_to_text_model_family(monkeypatch: pytest.MonkeyPatch, config: dict[str, object], expected: str) -> None:
+    monkeypatch.setattr("vllm.transformers_utils.config.get_hf_file_to_dict", lambda *args: config)
+    assert get_x_to_text_model_family("unused") == expected
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_bagel_x_to_text_prompt_builder() -> None:
+    prompt, stop_token_ids = build_x_to_text_prompt("bagel", "unused", "Describe it.", has_image=True)
+    assert prompt == {
+        "prompt": "<|im_start|>user\n<|image_pad|>\nDescribe it.<|im_end|>\n<|im_start|>assistant\n",
+        "modalities": ["text"],
+    }
+    assert stop_token_ids is None
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_mammoth_x_to_text_prompt_builder() -> None:
+    prompt, stop_token_ids = build_x_to_text_prompt("mammoth_moda2", "unused", "Hello.", has_image=False)
+    assert prompt == {
+        "prompt": (
+            "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n"
+            "<|im_start|>user\nHello.<|im_end|>\n"
+            "<|im_start|>assistant\n"
+        ),
+        "modalities": ["text"],
+        "additional_information": {"omni_task": ["chat"]},
+    }
+    assert stop_token_ids is None
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_generic_x_to_text_prompt_builder() -> None:
+    assert build_x_to_text_prompt("generic", "unused", "Hello.", has_image=False) == (
+        {"prompt": "Hello.", "modalities": ["text"]},
+        None,
+    )
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_bagel_extra_registry_declares_request_and_response_params() -> None:
@@ -60,8 +114,9 @@ def test_sensenova_extra_registry_declares_request_and_response_params() -> None
 
 @pytest.mark.core_model
 @pytest.mark.cpu
-def test_cosmos3_extra_registry_declares_request_and_response_params() -> None:
-    assert get_extra_body_params("Cosmos3OmniDiffusersPipeline") == frozenset(
+@pytest.mark.parametrize("pipeline_name", ["Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"])
+def test_cosmos3_extra_registry_declares_request_and_response_params(pipeline_name: str) -> None:
+    assert get_extra_body_params(pipeline_name) == frozenset(
         {
             "flow_shift",
             "max_sequence_length",
@@ -98,7 +153,7 @@ def test_cosmos3_extra_registry_declares_request_and_response_params() -> None:
             "session_id",
         }
     )
-    assert get_extra_output_params("Cosmos3OmniDiffusersPipeline") == frozenset(
+    assert get_extra_output_params(pipeline_name) == frozenset(
         {
             "action",
             "raw_action_dim",
@@ -106,7 +161,7 @@ def test_cosmos3_extra_registry_declares_request_and_response_params() -> None:
             "action_mode",
         }
     )
-    assert should_init_extra_args_for_non_diffusion_stages("Cosmos3OmniDiffusersPipeline") is False
+    assert should_init_extra_args_for_non_diffusion_stages(pipeline_name) is False
 
 
 @pytest.mark.core_model
@@ -126,6 +181,36 @@ def test_magi_human_extra_registry_declares_request_and_response_params() -> Non
     assert should_init_extra_args_for_non_diffusion_stages("MagiHumanPipeline") is False
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_ltx_extra_registry_declares_official_guidance_params() -> None:
+    expected = frozenset(
+        {
+            "video_cfg_scale",
+            "audio_cfg_scale",
+            "video_cfg_guidance_scale",
+            "audio_cfg_guidance_scale",
+            "video_stg_scale",
+            "audio_stg_scale",
+            "video_stg_guidance_scale",
+            "audio_stg_guidance_scale",
+            "video_modality_scale",
+            "audio_modality_scale",
+            "a2v_guidance_scale",
+            "v2a_guidance_scale",
+            "video_rescale_scale",
+            "audio_rescale_scale",
+            "video_stg_blocks",
+            "audio_stg_blocks",
+        }
+    )
+
+    assert get_extra_body_params("LTX2Pipeline") == expected
+    assert get_extra_output_params("LTX2Pipeline") == frozenset()
+    assert get_extra_body_params("LTX2DistilledPipeline") == expected
+    assert get_extra_output_params("LTX2DistilledPipeline") == frozenset()
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_ming_flash_omni_extra_registry_declares_request_and_response_params() -> None:
@@ -224,9 +309,10 @@ def test_ming_flash_omni_image_to_image_prompt_builder() -> None:
 
 @pytest.mark.core_model
 @pytest.mark.cpu
-def test_cosmos3_text_to_image_prompt_builder_selects_image_modality() -> None:
+@pytest.mark.parametrize("pipeline_name", ["Cosmos3OmniDiffusersPipeline", "Cosmos3OmniPipeline"])
+def test_cosmos3_text_to_image_prompt_builder_selects_image_modality(pipeline_name: str) -> None:
     assert build_text_to_image_prompt(
-        "Cosmos3OmniDiffusersPipeline",
+        pipeline_name,
         prompt="a red sports car at golden hour",
         negative_prompt="blurry, distorted",
         height=1024,
@@ -237,7 +323,7 @@ def test_cosmos3_text_to_image_prompt_builder_selects_image_modality() -> None:
         "negative_prompt": "blurry, distorted",
     }
     assert build_text_to_image_prompt(
-        "Cosmos3OmniDiffusersPipeline",
+        pipeline_name,
         prompt="a red sports car",
         negative_prompt=None,
     ) == {"prompt": "a red sports car", "modalities": ["image"]}
@@ -477,15 +563,29 @@ def test_declared_extra_args_apply_to_existing_sampling_params() -> None:
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_mammothmoda2_extra_registry_declares_request_and_response_params() -> None:
-    assert get_extra_body_params("MammothModa2DiTPipeline") == frozenset(
-        {
-            "text_guidance_scale",
-            "cfg_range",
-            "num_inference_steps",
-        }
+    for model_class_name in (
+        "MammothModa2DiTPipeline",
+        "MammothModa2ForConditionalGeneration",
+        "Mammothmoda2Model",
+    ):
+        assert get_extra_body_params(model_class_name) == frozenset(
+            {
+                "text_guidance_scale",
+                "cfg_range",
+                "num_inference_steps",
+            }
+        )
+        assert get_extra_output_params(model_class_name) == frozenset()
+        assert should_init_extra_args_for_non_diffusion_stages(model_class_name) is True
+
+    wrapper_prompt = build_text_to_image_prompt(
+        "MammothModa2ForConditionalGeneration",
+        prompt="a cat",
+        negative_prompt=None,
+        height=256,
+        width=256,
     )
-    assert get_extra_output_params("MammothModa2DiTPipeline") == frozenset()
-    assert should_init_extra_args_for_non_diffusion_stages("MammothModa2DiTPipeline") is True
+    assert wrapper_prompt["additional_information"]["omni_task"] == ["t2i"]
 
 
 @pytest.mark.core_model
@@ -512,5 +612,8 @@ def test_mammothmoda2_text_to_image_prompt_builder() -> None:
             "ar_height": [32],
             "image_height": [512],
             "image_width": [768],
+            "eol_token_id": [152064],
+            "visual_token_start_id": [152072],
+            "visual_token_end_id": [168456],
         },
     }
diff --git a/tests/model_tests/diffusion/config_types.py b/tests/model_tests/diffusion/config_types.py
index 4120900fe..2872f7cec 100644
--- a/tests/model_tests/diffusion/config_types.py
+++ b/tests/model_tests/diffusion/config_types.py
@@ -3,7 +3,7 @@ Common definitions for controlling what tests run where.
 """
 
 from collections.abc import Callable
-from enum import StrEnum, auto
+from enum import Enum
 from typing import NamedTuple, TypeAlias
 
 from pytest import MarkDecorator
@@ -15,26 +15,28 @@ from vllm_omni.entrypoints.omni import Omni
 TinyDiffusionBuilder: TypeAlias = Callable[[], str]
 
 
-class DiffusionAccs(StrEnum):
+class DiffusionAccs(str, Enum):
     """Supported acceleration types / test settings for Diffusion Models."""
 
-    HSDP = auto()
-    TEA_CACHE = auto()
-    CACHE_DIT = auto()
-    SEQUENCE_PARALLEL = auto()
-    CFG_PARALLEL = auto()
-    TENSOR_PARALLEL = auto()
-    CPU_OFFLOAD = auto()
-    LAYERWISE_OFFLOAD = auto()
-    VAE_PATCH_PARALLEL = auto()
+    HSDP = "hsdp"
+    TEA_CACHE = "tea_cache"
+    CACHE_DIT = "cache_dit"
+    SEQUENCE_PARALLEL = "sequence_parallel"
+    CFG_PARALLEL = "cfg_parallel"
+    TENSOR_PARALLEL = "tensor_parallel"
+    CPU_OFFLOAD = "cpu_offload"
+    LAYERWISE_OFFLOAD = "layerwise_offload"
+    VAE_PATCH_PARALLEL = "vae_patch_parallel"
 
 
-class DiffusionTasks(StrEnum):
+class DiffusionTasks(str, Enum):
     """Supported tasks for Diffusion Models."""
 
-    TEXT_TO_IMAGE = auto()
-    IMAGE_TO_IMAGE = auto()
-    # Text to video, text to audio, etc should be added here as needed
+    TEXT_TO_IMAGE = "text_to_image"
+    IMAGE_TO_IMAGE = "image_to_image"
+    TEXT_TO_VIDEO = "text_to_video"
+    IMAGE_TO_VIDEO = "image_to_video"
+    # Text to audio, etc should be added here as needed
 
 
 class DiffusionModelTestOpts(NamedTuple):
diff --git a/tests/model_tests/diffusion/diff_model_builders.py b/tests/model_tests/diffusion/diff_model_builders.py
index 9bee71f9b..ea69d95e5 100644
--- a/tests/model_tests/diffusion/diff_model_builders.py
+++ b/tests/model_tests/diffusion/diff_model_builders.py
@@ -1,63 +1,106 @@
-import os
-import tempfile
+from functools import partial
+from pathlib import Path
 
-import torch
-from diffusers.models.autoencoders.autoencoder_kl_flux2 import AutoencoderKLFlux2
-from diffusers.models.transformers.transformer_flux2 import Flux2Transformer2DModel
-from diffusers.pipelines.flux2.pipeline_flux2_klein import Flux2KleinPipeline
-from diffusers.schedulers.scheduling_flow_match_euler_discrete import FlowMatchEulerDiscreteScheduler
-from transformers import AutoTokenizer, Qwen3Config, Qwen3ForCausalLM
+from tests.helpers.tiny_model import build_tiny_from_configs
 
-TINY_MODEL_DIR = os.path.join(tempfile.gettempdir(), "vllm-omni-tiny-models")
+TINY_CONFIGS_DIR = Path(__file__).parent / "tiny_configs"
 
 
-def _get_tiny_model_path(name: str) -> str:
-    path = os.path.join(TINY_MODEL_DIR, name)
-    os.makedirs(path, exist_ok=True)
-    return path
+def _shrink_dit_rope_config(
+    config: dict,
+    num_layers: int = 2,
+    num_single_layers: int | None = None,
+    target_head_dim: int = 32,
+    target_heads: int = 4,
+    default_axes_dims_rope: list[int] | None = None,
+) -> dict:
+    config["num_layers"] = num_layers
+    if num_single_layers is not None:
+        config["num_single_layers"] = num_single_layers
+    axes_dims_rope = config.get("axes_dims_rope", default_axes_dims_rope)
+    factor = config["attention_head_dim"] / target_head_dim
+    config["attention_head_dim"] = target_head_dim
+    config["num_attention_heads"] = target_heads
+    config["axes_dims_rope"] = [int(d / factor) for d in axes_dims_rope]
+    return config
 
 
 def tiny_flux2_klein_builder() -> str:
-    """Build a tiny Flux2Klein model."""
-    model_dir = _get_tiny_model_path("Flux2KleinPipeline")
-
-    pipe = Flux2KleinPipeline(
-        scheduler=FlowMatchEulerDiscreteScheduler(),
-        vae=AutoencoderKLFlux2(
-            down_block_types=("DownEncoderBlock2D",),
-            up_block_types=("UpDecoderBlock2D",),
-            block_out_channels=(32,),
-            layers_per_block=1,
-            latent_channels=16,
-            norm_num_groups=16,
-        ),
-        # NOTE: For now we need 28 layers because of hardcoded stuff in the model :(
-        text_encoder=Qwen3ForCausalLM(
-            Qwen3Config(
-                hidden_size=32,
-                intermediate_size=64,
-                num_hidden_layers=28,
-                num_attention_heads=2,
-                num_key_value_heads=2,
-                head_dim=16,
-                vocab_size=151936,
-                max_position_embeddings=512,
-            )
-        ),
-        tokenizer=AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B"),
-        # NOTE: For now we need at least 2 layers for the transformer
-        # due to hardcoded hacks in CacheDiT for Flux2Klein specifically.
-        transformer=Flux2Transformer2DModel(
-            in_channels=64,
-            num_layers=2,
-            num_single_layers=2,
-            attention_head_dim=16,
-            num_attention_heads=2,
-            joint_attention_dim=96,
-            timestep_guidance_channels=32,
-            axes_dims_rope=(4, 4, 4, 4),
-        ),
+    """Build a tiny Flux2Klein model from vendored configs."""
+    return build_tiny_from_configs(
+        "Flux2KleinPipeline", "black-forest-labs/FLUX.2-klein-4B", TINY_CONFIGS_DIR / "Flux2KleinPipeline"
+    )
+
+
+def tiny_ltx2_builder() -> str:
+    """Build a tiny LTX2 model from vendored configs."""
+    return build_tiny_from_configs("LTX2Pipeline", "Lightricks/LTX-2", TINY_CONFIGS_DIR / "LTX2Pipeline")
+
+
+def tiny_qwen_image_builder() -> str:
+    def shrink_text_encoder(config: dict) -> dict:
+        config["num_hidden_layers"] = 2
+        config["intermediate_size"] = 64
+        config["text_config"]["num_hidden_layers"] = 2
+        config["text_config"]["intermediate_size"] = 64
+        config["text_config"]["layer_types"] = config["text_config"]["layer_types"][:2]
+        config["vision_config"]["depth"] = 2
+        config["vision_config"]["intermediate_size"] = 64
+        config["vision_config"]["fullatt_block_indexes"] = [0, 1]
+        return config
+
+    return build_tiny_from_configs(
+        "QwenImagePipeline",
+        "Qwen/Qwen-Image",
+        transform={"text_encoder": shrink_text_encoder, "transformer": _shrink_dit_rope_config},
+    )
+
+
+def tiny_flux_builder() -> str:
+    def shrink_clip_text_encoder(config: dict) -> dict:
+        config["num_hidden_layers"] = 2
+        return config
+
+    def shrink_t5_text_encoder(config: dict) -> dict:
+        config["num_layers"] = 2
+        config["num_decoder_layers"] = 2
+        config["d_ff"] = 64
+        config["num_heads"] = 4
+        return config
+
+    return build_tiny_from_configs(
+        "FluxPipeline",
+        "black-forest-labs/FLUX.1-schnell",
+        transform={
+            "text_encoder": shrink_clip_text_encoder,
+            "text_encoder_2": shrink_t5_text_encoder,
+            "transformer": partial(_shrink_dit_rope_config, num_single_layers=2, default_axes_dims_rope=[16, 56, 56]),
+        },
+    )
+
+
+def tiny_flux2_builder() -> str:
+    def shrink_text_encoder(config: dict) -> dict:
+        # The real checkpoint ships language_model.lm_head.weight as its own
+        # tensor even though tie_word_embeddings defaults to True; keep it
+        # untied here too so transformers doesn't drop it on save.
+        config["tie_word_embeddings"] = False
+        config["text_config"]["num_hidden_layers"] = 31
+        config["text_config"]["intermediate_size"] = 64
+        config["text_config"]["num_attention_heads"] = 4
+        config["text_config"]["head_dim"] = 32
+        config["text_config"]["num_key_value_heads"] = 2
+        config["vision_config"]["num_hidden_layers"] = 2
+        config["vision_config"]["intermediate_size"] = 64
+        config["vision_config"]["num_attention_heads"] = 4
+        config["vision_config"]["head_dim"] = 32
+        return config
+
+    return build_tiny_from_configs(
+        "Flux2Pipeline",
+        "black-forest-labs/FLUX.2-dev",
+        transform={
+            "text_encoder": shrink_text_encoder,
+            "transformer": partial(_shrink_dit_rope_config, num_single_layers=2),
+        },
     )
-    # Need dtypes to be consistent; for now we just put it on bfloat16
-    pipe.to(torch.bfloat16).save_pretrained(model_dir)
-    return model_dir
diff --git a/tests/model_tests/diffusion/model_settings.py b/tests/model_tests/diffusion/model_settings.py
index 3f44afcae..037faf67d 100644
--- a/tests/model_tests/diffusion/model_settings.py
+++ b/tests/model_tests/diffusion/model_settings.py
@@ -38,5 +38,30 @@ DIFFUSION_TEST_SETTINGS = {
             [DiffusionAccs.SEQUENCE_PARALLEL, DiffusionAccs.CACHE_DIT, DiffusionAccs.LAYERWISE_OFFLOAD],
             [DiffusionAccs.CFG_PARALLEL, DiffusionAccs.TENSOR_PARALLEL, DiffusionAccs.CPU_OFFLOAD],
         ],
-    )
+    ),
+    "LTX2Pipeline": DiffusionModelTestOpts(
+        model="Lightricks/LTX-2",
+        builder=diff_model_builders.tiny_ltx2_builder,
+        supported_tasks=[DiffusionTasks.TEXT_TO_VIDEO, DiffusionTasks.IMAGE_TO_VIDEO],
+        extra_test_groups=[
+            [DiffusionAccs.HSDP, DiffusionAccs.CACHE_DIT],
+            [DiffusionAccs.SEQUENCE_PARALLEL, DiffusionAccs.CACHE_DIT, DiffusionAccs.LAYERWISE_OFFLOAD],
+            [DiffusionAccs.CFG_PARALLEL, DiffusionAccs.TENSOR_PARALLEL, DiffusionAccs.CPU_OFFLOAD],
+        ],
+    ),
+    "QwenImagePipeline": DiffusionModelTestOpts(
+        model="Qwen/Qwen-Image",
+        builder=diff_model_builders.tiny_qwen_image_builder,
+        supported_tasks=[DiffusionTasks.TEXT_TO_IMAGE],
+    ),
+    "FluxPipeline": DiffusionModelTestOpts(
+        model="black-forest-labs/FLUX.1-schnell",
+        builder=diff_model_builders.tiny_flux_builder,
+        supported_tasks=[DiffusionTasks.TEXT_TO_IMAGE],
+    ),
+    "Flux2Pipeline": DiffusionModelTestOpts(
+        model="black-forest-labs/FLUX.2-dev",
+        builder=diff_model_builders.tiny_flux2_builder,
+        supported_tasks=[DiffusionTasks.TEXT_TO_IMAGE],
+    ),
 }
diff --git a/tests/model_tests/diffusion/task_runners.py b/tests/model_tests/diffusion/task_runners.py
index 6b9c7ff99..2be2338c1 100644
--- a/tests/model_tests/diffusion/task_runners.py
+++ b/tests/model_tests/diffusion/task_runners.py
@@ -8,9 +8,11 @@ import io
 from dataclasses import replace
 
 import numpy as np
+import pytest
 from PIL import Image
 
 from tests.helpers.runtime import DiffusionResponse, OmniServer, OpenAIClientHandler, dummy_messages_from_mix_data
+from tests.model_tests.diffusion.config_types import DiffusionTasks
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
@@ -28,6 +30,15 @@ IMAGE_GEN_SAMPLING_PARAMS = OmniDiffusionSamplingParams(
     seed=42,
 )
 
+VIDEO_NUM_FRAMES = 9
+VIDEO_GEN_SAMPLING_PARAMS = OmniDiffusionSamplingParams(
+    num_inference_steps=4,
+    height=HEIGHT,
+    width=WIDTH,
+    num_frames=VIDEO_NUM_FRAMES,
+    seed=42,
+)
+
 # Online extra_body for diffusion requests
 IMAGE_GEN_EXTRA_BODY = {
     "height": HEIGHT,
@@ -36,6 +47,15 @@ IMAGE_GEN_EXTRA_BODY = {
     "seed": 42,
 }
 
+# Online form_data for video generation requests (multipart /v1/videos API)
+VIDEO_GEN_FORM_DATA = {
+    "height": HEIGHT,
+    "width": WIDTH,
+    "num_inference_steps": 4,
+    "num_frames": VIDEO_NUM_FRAMES,
+    "seed": 42,
+}
+
 
 ### Shared validation
 def _validate_images(images: list[Image.Image], expected_n: int = 1):
@@ -52,7 +72,9 @@ def _validate_image_gen_determinism(images_a: list[Image.Image], images_b: list[
     """Ensure that two image sets are valid and that the results match."""
     _validate_images(images_a)
     _validate_images(images_b)
-    assert np.array_equal(np.array(images_a[0]), np.array(images_b[0]))
+    assert len(images_a) == len(images_b)
+    for image_a, image_b in zip(images_a, images_b, strict=True):
+        assert np.array_equal(np.array(image_a), np.array(image_b))
 
 
 ### Output extractor utils for offline / online paths respectively
@@ -70,15 +92,72 @@ def _get_online_images(responses: list[DiffusionResponse]) -> list[Image.Image]:
     return images
 
 
+def _validate_video_frames(videos: list, expected_n: int = 1, expected_frames: int = VIDEO_NUM_FRAMES):
+    """Given a list of videos (one array per generation, each holding all of
+    that generation's frames), ensure count and shape are correct."""
+    assert len(videos) == expected_n
+    for video in videos:
+        assert isinstance(video, np.ndarray)
+        assert video.ndim == 4, f"Expected 4D video array (frames, H, W, C), got shape {video.shape}"
+        assert video.shape[-4] == expected_frames, f"Expected {expected_frames} frames, got {video.shape[-4]}"
+        assert video.shape[-3] == HEIGHT, f"Expected height {HEIGHT}, got {video.shape[-3]}"
+        assert video.shape[-2] == WIDTH, f"Expected width {WIDTH}, got {video.shape[-2]}"
+        assert video.shape[-1] == 3, f"Expected 3 channels (RGB), got {video.shape[-1]}"
+    return videos
+
+
+def _get_offline_videos(outputs: list[OmniRequestOutput]) -> list:
+    """Extract the list of videos (one array per generation) from an Omni .generate() call.
+
+    Multi-output video generations come back as a single 5D array
+    (num_outputs, num_frames, H, W, C) rather than one 4D array per output;
+    split it into a flat per-output list here so callers always see one
+    4D array per generation.
+    """
+    assert len(outputs) == 1
+    videos = []
+    for video in outputs[0].images:
+        if video.ndim == 5:
+            videos.extend(video)
+        else:
+            videos.append(video)
+    return videos
+
+
+def _validate_video(outputs: list[OmniRequestOutput], expected_n: int = 1):
+    """Given a set of outputs, ensure we got video frames with the expected shape."""
+    _validate_video_frames(_get_offline_videos(outputs), expected_n=expected_n)
+
+
+def _validate_video_gen_determinism(videos_a: list, videos_b: list):
+    """Ensure that two video generations are valid and that the results match."""
+    _validate_video_frames(videos_a)
+    _validate_video_frames(videos_b)
+    assert len(videos_a) == len(videos_b)
+    for video_a, video_b in zip(videos_a, videos_b, strict=True):
+        assert np.array_equal(video_a, video_b)
+
+
 ### Offline helpers
 def _run_offline_t2i(omni: Omni, params: OmniDiffusionSamplingParams = IMAGE_GEN_SAMPLING_PARAMS):
     return omni.generate({"prompt": PROMPT}, params)
 
 
-def _run_offline_i2i(omni: Omni):
+def _run_offline_t2v(omni: Omni, params: OmniDiffusionSamplingParams = VIDEO_GEN_SAMPLING_PARAMS):
+    return omni.generate({"prompt": PROMPT}, params)
+
+
+def _run_offline_i2i(omni: Omni, params: OmniDiffusionSamplingParams = IMAGE_GEN_SAMPLING_PARAMS):
     return omni.generate(
         {"prompt": PROMPT, "multi_modal_data": {"image": INPUT_IMAGE}},
-        IMAGE_GEN_SAMPLING_PARAMS,
+        params,
+    )
+
+
+def _run_offline_i2v(omni: Omni, params: OmniDiffusionSamplingParams = VIDEO_GEN_SAMPLING_PARAMS):
+    return omni.generate(
+        {"prompt": PROMPT, "multi_modal_data": {"image": INPUT_IMAGE}},
+        params,
     )
 
 
@@ -104,7 +183,9 @@ def _run_online_t2i(
     return client.send_diffusion_request(request_config)
 
 
-def _run_online_i2i(server: OmniServer, client: OpenAIClientHandler) -> list[DiffusionResponse]:
+def _run_online_i2i(
+    server: OmniServer, client: OpenAIClientHandler, extra_body: dict | None = None
+) -> list[DiffusionResponse]:
     """Run an image to image request through the server."""
     image_data_url = _build_online_image_data_url()
     messages = dummy_messages_from_mix_data(
@@ -114,7 +195,7 @@ def _run_online_i2i(server: OmniServer, client: OpenAIClientHandler) -> list[Dif
     request_config = {
         "model": server.model,
         "messages": messages,
-        "extra_body": IMAGE_GEN_EXTRA_BODY,
+        "extra_body": extra_body or IMAGE_GEN_EXTRA_BODY,
     }
     return client.send_diffusion_request(request_config)
 
@@ -130,18 +211,98 @@ def run_and_validate_image_to_image_request(omni: Omni):
     _validate_images(_get_offline_images(_run_offline_i2i(omni)))
 
 
-def run_and_validate_text_to_image_determinism(omni: Omni):
-    """Checks for determinism; for now we just keep this for TTI."""
-    _validate_image_gen_determinism(
-        _get_offline_images(_run_offline_t2i(omni)),
-        _get_offline_images(_run_offline_t2i(omni)),
+def run_and_validate_text_to_video_request(omni: Omni):
+    """Run and validate a text to video request."""
+    _validate_video(_run_offline_t2v(omni))
+
+
+def run_and_validate_image_to_video_request(omni: Omni):
+    """Run and validate an image to video request.
+
+    LTX2Pipeline uses a unified text/image entry and can fall back to T2V if
+    the image never reaches conditioning, so also run T2V with the same seed
+    and prompt and assert the outputs differ; a regression that silently
+    drops the input image would otherwise still pass a "did we get a valid
+    video back" check alone.
+    """
+    i2v_video = _validate_video_frames(_get_offline_videos(_run_offline_i2v(omni)))[0]
+    t2v_video = _validate_video_frames(_get_offline_videos(_run_offline_t2v(omni)))[0]
+    assert not np.array_equal(i2v_video, t2v_video), (
+        "I2V output is identical to T2V output with the same seed and prompt; "
+        "the input image may not be reaching conditioning."
     )
 
 
-def run_and_validate_text_to_image_multi_output(omni: Omni):
-    """Checks for multi-output; for now we just keep this for TTI."""
-    params = replace(IMAGE_GEN_SAMPLING_PARAMS, num_outputs_per_prompt=2)
-    _validate_images(_get_offline_images(_run_offline_t2i(omni, params)), expected_n=2)
+def run_and_validate_determinism(omni: Omni, task_type: DiffusionTasks):
+    """Checks for determinism, dispatching by task type."""
+    if task_type == DiffusionTasks.TEXT_TO_IMAGE:
+        _validate_image_gen_determinism(
+            _get_offline_images(_run_offline_t2i(omni)),
+            _get_offline_images(_run_offline_t2i(omni)),
+        )
+    elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
+        _validate_image_gen_determinism(
+            _get_offline_images(_run_offline_i2i(omni)),
+            _get_offline_images(_run_offline_i2i(omni)),
+        )
+    elif task_type == DiffusionTasks.TEXT_TO_VIDEO:
+        _validate_video_gen_determinism(
+            _get_offline_videos(_run_offline_t2v(omni)),
+            _get_offline_videos(_run_offline_t2v(omni)),
+        )
+    elif task_type == DiffusionTasks.IMAGE_TO_VIDEO:
+        _validate_video_gen_determinism(
+            _get_offline_videos(_run_offline_i2v(omni)),
+            _get_offline_videos(_run_offline_i2v(omni)),
+        )
+    else:
+        raise ValueError(f"Task type {task_type} is not yet supported for determinism checks")
+
+
+def run_and_validate_multi_output(omni: Omni, task_type: DiffusionTasks):
+    """Checks for multi-output, dispatching by task type."""
+    if task_type == DiffusionTasks.TEXT_TO_IMAGE:
+        params = replace(IMAGE_GEN_SAMPLING_PARAMS, num_outputs_per_prompt=2)
+        _validate_images(_get_offline_images(_run_offline_t2i(omni, params)), expected_n=2)
+    elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
+        params = replace(IMAGE_GEN_SAMPLING_PARAMS, num_outputs_per_prompt=2)
+        _validate_images(_get_offline_images(_run_offline_i2i(omni, params)), expected_n=2)
+    elif task_type == DiffusionTasks.TEXT_TO_VIDEO:
+        params = replace(VIDEO_GEN_SAMPLING_PARAMS, num_outputs_per_prompt=2)
+        _validate_video_frames(_get_offline_videos(_run_offline_t2v(omni, params)), expected_n=2)
+    elif task_type == DiffusionTasks.IMAGE_TO_VIDEO:
+        params = replace(VIDEO_GEN_SAMPLING_PARAMS, num_outputs_per_prompt=2)
+        _validate_video_frames(_get_offline_videos(_run_offline_i2v(omni, params)), expected_n=2)
+    else:
+        raise ValueError(f"Task type {task_type} is not yet supported for multi-output checks")
+
+
+def _run_online_t2v(
+    server: OmniServer, client: OpenAIClientHandler, form_data: dict | None = None
+) -> list[DiffusionResponse]:
+    """Run a text to video request through the server's /v1/videos API."""
+    data = dict(form_data or VIDEO_GEN_FORM_DATA)
+    data.setdefault("prompt", PROMPT)
+    data.setdefault("model", server.model)
+    return client.send_video_diffusion_request({"form_data": data})
+
+
+def _run_online_i2v(server: OmniServer, client: OpenAIClientHandler) -> list[DiffusionResponse]:
+    """Run an image to video request through the server's /v1/videos API."""
+    data = dict(VIDEO_GEN_FORM_DATA)
+    data.setdefault("prompt", PROMPT)
+    data.setdefault("model", server.model)
+    image_data_url = _build_online_image_data_url()
+    return client.send_video_diffusion_request({"form_data": data, "image_reference": image_data_url})
+
+
+def _get_online_videos(responses: list[DiffusionResponse]) -> list:
+    """Extract the videos from a server response."""
+    assert len(responses) == 1
+    videos = responses[0].videos
+    assert videos is not None
+    assert len(videos) > 0
+    return videos
 
 
 ### Online task runners
@@ -155,18 +316,63 @@ def run_and_validate_online_image_to_image_request(server: OmniServer, client: O
     _validate_images(_get_online_images(_run_online_i2i(server, client)))
 
 
-def run_and_validate_online_text_to_image_determinism(server: OmniServer, client: OpenAIClientHandler):
-    """Checks for determinism through the server; for now we just keep this for TTI."""
-    _validate_image_gen_determinism(
-        _get_online_images(_run_online_t2i(server, client)),
-        _get_online_images(_run_online_t2i(server, client)),
-    )
+def run_and_validate_online_determinism(server: OmniServer, client: OpenAIClientHandler, task_type: DiffusionTasks):
+    """Checks for determinism through the server, dispatching by task type.
+
+    Video is skipped online only: send_video_diffusion_request returns encoded
+    video bytes, not a frame-level array, and re-encoding the same content
+    isn't guaranteed to be byte-identical even for deterministic generation,
+    so a reliable check isn't possible with what's implemented here. The
+    offline determinism check (run_and_validate_determinism) does cover
+    video, since it has direct access to the raw frame arrays.
+    """
+    if task_type == DiffusionTasks.TEXT_TO_IMAGE:
+        _validate_image_gen_determinism(
+            _get_online_images(_run_online_t2i(server, client)),
+            _get_online_images(_run_online_t2i(server, client)),
+        )
+    elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
+        _validate_image_gen_determinism(
+            _get_online_images(_run_online_i2i(server, client)),
+            _get_online_images(_run_online_i2i(server, client)),
+        )
+    elif task_type in (DiffusionTasks.TEXT_TO_VIDEO, DiffusionTasks.IMAGE_TO_VIDEO):
+        pytest.skip(f"Online determinism isn't supported for {task_type}.")
+    else:
+        raise ValueError(f"Task type {task_type} is not yet supported for determinism checks")
 
 
-def run_and_validate_online_text_to_image_multi_output(server: OmniServer, client: OpenAIClientHandler):
-    """Checks for multi-output through the server; for now we just keep this for TTI."""
-    extra_body = {**IMAGE_GEN_EXTRA_BODY, "num_outputs_per_prompt": 2}
-    _validate_images(
-        _get_online_images(_run_online_t2i(server, client, extra_body=extra_body)),
-        expected_n=2,
-    )
+def run_and_validate_online_multi_output(server: OmniServer, client: OpenAIClientHandler, task_type: DiffusionTasks):
+    """Checks for multi-output through the server, dispatching by task type.
+
+    Video is skipped online only: send_video_diffusion_request explicitly
+    disallows more than one request/output per call. The offline multi-output
+    check (run_and_validate_multi_output) does cover video, since
+    Omni.generate() supports num_outputs_per_prompt directly.
+    """
+    if task_type == DiffusionTasks.TEXT_TO_IMAGE:
+        extra_body = {**IMAGE_GEN_EXTRA_BODY, "num_outputs_per_prompt": 2}
+        _validate_images(
+            _get_online_images(_run_online_t2i(server, client, extra_body=extra_body)),
+            expected_n=2,
+        )
+    elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
+        extra_body = {**IMAGE_GEN_EXTRA_BODY, "num_outputs_per_prompt": 2}
+        _validate_images(
+            _get_online_images(_run_online_i2i(server, client, extra_body=extra_body)),
+            expected_n=2,
+        )
+    elif task_type in (DiffusionTasks.TEXT_TO_VIDEO, DiffusionTasks.IMAGE_TO_VIDEO):
+        pytest.skip(f"Online multi-output isn't supported for {task_type}.")
+    else:
+        raise ValueError(f"Task type {task_type} is not yet supported for multi-output checks")
+
+
+def run_and_validate_online_text_to_video_request(server: OmniServer, client: OpenAIClientHandler):
+    """Run and validate a text to video request through the server."""
+    _get_online_videos(_run_online_t2v(server, client))
+
+
+def run_and_validate_online_image_to_video_request(server: OmniServer, client: OpenAIClientHandler):
+    """Run and validate an image to video request through the server."""
+    _get_online_videos(_run_online_i2v(server, client))
diff --git a/tests/model_tests/diffusion/test_alignment.py b/tests/model_tests/diffusion/test_alignment.py
index ae01334f6..f5d2768c5 100644
--- a/tests/model_tests/diffusion/test_alignment.py
+++ b/tests/model_tests/diffusion/test_alignment.py
@@ -21,7 +21,6 @@ pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
 # if you are adding a new model and see the tests below fail, please follow the pattern
 # for adding a new tiny model builder and corresponding entry in DIFFUSION_TEST_SETTINGS.
 EXCLUDED_MODELS = [
-    "QwenImagePipeline",
     "QwenImageEditPipeline",
     "QwenImageEditPlusPipeline",
     "QwenImageLayeredPipeline",
@@ -30,14 +29,11 @@ EXCLUDED_MODELS = [
     "OvisImagePipeline",
     "WanPipeline",
     "WanVACEPipeline",
-    "LTX2Pipeline",
-    "LTX2ImageToVideoPipeline",
-    "LTX2TwoStagesPipeline",
-    "LTX2ImageToVideoTwoStagesPipeline",
+    "LTX2DistilledPipeline",
     "LTX2T2VDMD2Pipeline",
     "LTX2I2VDMD2Pipeline",
-    "LTX23Pipeline",
-    "LTX23ImageToVideoPipeline",
+    "MiniMaxH3Pipeline",
+    "MiniMaxH3ModularPipeline",
     "StableAudioPipeline",
     "WanImageToVideoPipeline",
     "WanS2VPipeline",
@@ -45,6 +41,7 @@ EXCLUDED_MODELS = [
     "WanI2VDMD2Pipeline",
     "LongCatImagePipeline",
     "BagelPipeline",
+    "BooguImagePipeline",
     "LancePipeline",
     "MingImagePipeline",
     "InternVLAA1Pipeline",
@@ -54,23 +51,23 @@ EXCLUDED_MODELS = [
     "HunyuanImage3ForCausalMM",
     "ErnieImagePipeline",
     "NextStep11Pipeline",
-    "FluxPipeline",
     "FluxDMD2Pipeline",
     "Krea2Pipeline",
     "QwenImageDMD2Pipeline",
     "OmniGen2Pipeline",
     "HeliosPipeline",
     "HeliosPyramidPipeline",
-    "Flux2Pipeline",
     "DreamIDOmniPipeline",
     "SenseNovaU1Pipeline",
     "AudioXPipeline",
     "HunyuanVideo15Pipeline",
     "HunyuanVideo15ImageToVideoPipeline",
+    "LingBotVideoPipeline",
     "MagiHumanPipeline",
     "OmniVoicePipeline",
     "OmniVoice",
     "Cosmos3OmniDiffusersPipeline",
+    "Cosmos3OmniPipeline",
     "DiffusersAdapterPipeline",
     "HiDreamImagePipeline",
     "DreamZeroPipeline",
diff --git a/tests/model_tests/diffusion/test_common_offline.py b/tests/model_tests/diffusion/test_common_offline.py
index f24ed3780..b0eb26c9b 100644
--- a/tests/model_tests/diffusion/test_common_offline.py
+++ b/tests/model_tests/diffusion/test_common_offline.py
@@ -8,10 +8,12 @@ from tests.model_tests.diffusion.config_types import (
 )
 from tests.model_tests.diffusion.model_settings import DIFFUSION_TEST_SETTINGS
 from tests.model_tests.diffusion.task_runners import (
+    run_and_validate_determinism,
     run_and_validate_image_to_image_request,
-    run_and_validate_text_to_image_determinism,
-    run_and_validate_text_to_image_multi_output,
+    run_and_validate_image_to_video_request,
+    run_and_validate_multi_output,
     run_and_validate_text_to_image_request,
+    run_and_validate_text_to_video_request,
 )
 
 # NOTE : Hardware marks are added dynamically based on test requirements
@@ -53,6 +55,10 @@ def test_pipeline_on_supported_tasks(
                     run_and_validate_text_to_image_request(omni)
                 elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
                     run_and_validate_image_to_image_request(omni)
+                elif task_type == DiffusionTasks.TEXT_TO_VIDEO:
+                    run_and_validate_text_to_video_request(omni)
+                elif task_type == DiffusionTasks.IMAGE_TO_VIDEO:
+                    run_and_validate_image_to_video_request(omni)
                 else:
                     raise ValueError(f"Task type {task_type} is not yet supported")
 
@@ -60,10 +66,12 @@ def test_pipeline_on_supported_tasks(
         # since checking it on every extra acceleration configuration is redundant
         # (see case_filtering).
         if check_determinism:
-            with subtests.test(msg="determinism"):
-                run_and_validate_text_to_image_determinism(omni)
+            for task_type in supported_tasks:
+                with subtests.test(msg=f"determinism[{task_type}]"):
+                    run_and_validate_determinism(omni, task_type)
         if check_multioutput:
-            with subtests.test(msg="multi_output"):
-                run_and_validate_text_to_image_multi_output(omni)
+            for task_type in supported_tasks:
+                with subtests.test(msg=f"multi_output[{task_type}]"):
+                    run_and_validate_multi_output(omni, task_type)
     finally:
         omni.close()
diff --git a/tests/model_tests/diffusion/test_common_online.py b/tests/model_tests/diffusion/test_common_online.py
index e4c6be0d4..464adc13a 100644
--- a/tests/model_tests/diffusion/test_common_online.py
+++ b/tests/model_tests/diffusion/test_common_online.py
@@ -15,10 +15,12 @@ from tests.model_tests.diffusion.config_types import (
 )
 from tests.model_tests.diffusion.model_settings import DIFFUSION_TEST_SETTINGS
 from tests.model_tests.diffusion.task_runners import (
+    run_and_validate_online_determinism,
     run_and_validate_online_image_to_image_request,
-    run_and_validate_online_text_to_image_determinism,
-    run_and_validate_online_text_to_image_multi_output,
+    run_and_validate_online_image_to_video_request,
+    run_and_validate_online_multi_output,
     run_and_validate_online_text_to_image_request,
+    run_and_validate_online_text_to_video_request,
 )
 
 # NOTE : Hardware marks are added dynamically based on test requirements
@@ -61,6 +63,10 @@ def test_online_on_supported_tasks(
                     run_and_validate_online_text_to_image_request(server, client)
                 elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
                     run_and_validate_online_image_to_image_request(server, client)
+                elif task_type == DiffusionTasks.TEXT_TO_VIDEO:
+                    run_and_validate_online_text_to_video_request(server, client)
+                elif task_type == DiffusionTasks.IMAGE_TO_VIDEO:
+                    run_and_validate_online_image_to_video_request(server, client)
                 else:
                     raise ValueError(f"Task type {task_type} is not yet supported")
 
@@ -68,8 +74,10 @@ def test_online_on_supported_tasks(
         # since checking it on every extra acceleration configuration is redundant
         # (see case_filtering).
         if check_determinism:
-            with subtests.test(msg="determinism"):
-                run_and_validate_online_text_to_image_determinism(server, client)
+            for task_type in supported_tasks:
+                with subtests.test(msg=f"determinism[{task_type}]"):
+                    run_and_validate_online_determinism(server, client, task_type)
         if check_multioutput:
-            with subtests.test(msg="multi_output"):
-                run_and_validate_online_text_to_image_multi_output(server, client)
+            for task_type in supported_tasks:
+                with subtests.test(msg=f"multi_output[{task_type}]"):
+                    run_and_validate_online_multi_output(server, client, task_type)
diff --git a/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/model_index.json b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/model_index.json
new file mode 100644
index 000000000..554a39bf1
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/model_index.json
@@ -0,0 +1,25 @@
+{
+  "_class_name": "Flux2KleinPipeline",
+  "_diffusers_version": "0.37.0.dev0",
+  "is_distilled": true,
+  "scheduler": [
+    "diffusers",
+    "FlowMatchEulerDiscreteScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "Qwen3ForCausalLM"
+  ],
+  "tokenizer": [
+    "transformers",
+    "Qwen2TokenizerFast"
+  ],
+  "transformer": [
+    "diffusers",
+    "Flux2Transformer2DModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKLFlux2"
+  ]
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/text_encoder/config.json b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/text_encoder/config.json
new file mode 100644
index 000000000..19a6b4063
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/text_encoder/config.json
@@ -0,0 +1,36 @@
+{
+  "architectures": [
+    "Qwen3ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "dtype": "bfloat16",
+  "eos_token_id": 151645,
+  "head_dim": 16,
+  "hidden_act": "silu",
+  "hidden_size": 32,
+  "initializer_range": 0.02,
+  "intermediate_size": 64,
+  "layer_types": [
+    "full_attention",
+    "full_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 512,
+  "max_window_layers": 36,
+  "model_type": "qwen3",
+  "num_attention_heads": 2,
+  "num_hidden_layers": 3,
+  "num_key_value_heads": 2,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 1000000,
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "transformers_version": "4.56.1",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936,
+  "text_encoder_out_layers":[0, 1, 2]
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/transformer/config.json b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/transformer/config.json
new file mode 100644
index 000000000..6ff16e1e7
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/transformer/config.json
@@ -0,0 +1,24 @@
+{
+  "_class_name": "Flux2Transformer2DModel",
+  "_diffusers_version": "0.37.0.dev0",
+  "_name_or_path": "/raid/yiyi/klein-4b-distilled-diffusers/transformer",
+  "attention_head_dim": 16,
+  "axes_dims_rope": [
+    4,
+    4,
+    4,
+    4
+  ],
+  "eps": 1e-06,
+  "guidance_embeds": false,
+  "in_channels": 64,
+  "joint_attention_dim": 96,
+  "mlp_ratio": 3.0,
+  "num_attention_heads": 2,
+  "num_layers": 2,
+  "num_single_layers": 2,
+  "out_channels": null,
+  "patch_size": 1,
+  "rope_theta": 2000,
+  "timestep_guidance_channels": 32
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/vae/config.json b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/vae/config.json
new file mode 100644
index 000000000..6410d25bd
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/Flux2KleinPipeline/vae/config.json
@@ -0,0 +1,31 @@
+{
+  "_class_name": "AutoencoderKLFlux2",
+  "_diffusers_version": "0.37.0.dev0",
+  "_name_or_path": "black-forest-labs/FLUX.2-dev",
+  "act_fn": "silu",
+  "batch_norm_eps": 0.0001,
+  "batch_norm_momentum": 0.1,
+  "block_out_channels": [
+    32
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": true,
+  "in_channels": 3,
+  "latent_channels": 16,
+  "layers_per_block": 1,
+  "mid_block_add_attention": true,
+  "norm_num_groups": 16,
+  "out_channels": 3,
+  "patch_size": [
+    2,
+    2
+  ],
+  "sample_size": 1024,
+  "up_block_types": [
+    "UpDecoderBlock2D"
+  ],
+  "use_post_quant_conv": true,
+  "use_quant_conv": true
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/audio_vae/config.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/audio_vae/config.json
new file mode 100644
index 000000000..5ebd2f5e8
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/audio_vae/config.json
@@ -0,0 +1,25 @@
+{
+  "_class_name": "AutoencoderKLLTX2Audio",
+  "_diffusers_version": "0.37.0.dev0",
+  "attn_resolutions": null,
+  "base_channels": 128,
+  "causality_axis": "height",
+  "ch_mult": [
+    1,
+    2,
+    4
+  ],
+  "double_z": true,
+  "dropout": 0.0,
+  "in_channels": 2,
+  "is_causal": true,
+  "latent_channels": 8,
+  "mel_bins": 64,
+  "mel_hop_length": 160,
+  "mid_block_add_attention": false,
+  "norm_type": "pixel",
+  "num_res_blocks": 1,
+  "output_channels": 2,
+  "resolution": 256,
+  "sample_rate": 16000
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/connectors/config.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/connectors/config.json
new file mode 100644
index 000000000..c63177c7c
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/connectors/config.json
@@ -0,0 +1,21 @@
+{
+  "_class_name": "LTX2TextConnectors",
+  "_diffusers_version": "0.37.0.dev0",
+  "audio_connector_attention_head_dim": 16,
+  "audio_connector_num_attention_heads": 2,
+  "audio_connector_num_layers": 1,
+  "audio_connector_num_learnable_registers": 4,
+  "caption_channels": 32,
+  "causal_temporal_positioning": false,
+  "connector_rope_base_seq_len": 32,
+  "rope_double_precision": true,
+  "rope_theta": 10000.0,
+  "rope_type": "split",
+  "text_proj_in_factor": 3,
+  "video_connector_attention_head_dim": 16,
+  "video_connector_num_attention_heads": 2,
+  "video_connector_num_layers": 1,
+  "video_connector_num_learnable_registers": 4,
+  "video_hidden_dim": 32,
+  "audio_hidden_dim": 32
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/model_index.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/model_index.json
new file mode 100644
index 000000000..ef9de5d07
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/model_index.json
@@ -0,0 +1,36 @@
+{
+  "_class_name": "LTX2Pipeline",
+  "_diffusers_version": "0.37.0.dev0",
+  "audio_vae": [
+    "diffusers",
+    "AutoencoderKLLTX2Audio"
+  ],
+  "connectors": [
+    "ltx2",
+    "LTX2TextConnectors"
+  ],
+  "scheduler": [
+    "diffusers",
+    "FlowMatchEulerDiscreteScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "Gemma3ForConditionalGeneration"
+  ],
+  "tokenizer": [
+    "transformers",
+    "GemmaTokenizerFast"
+  ],
+  "transformer": [
+    "diffusers",
+    "LTX2VideoTransformer3DModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKLLTX2Video"
+  ],
+  "vocoder": [
+    "ltx2",
+    "LTX2Vocoder"
+  ]
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/text_encoder/config.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/text_encoder/config.json
new file mode 100644
index 000000000..0d722f0c1
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/text_encoder/config.json
@@ -0,0 +1,68 @@
+{
+  "architectures": [
+    "Gemma3ForConditionalGeneration"
+  ],
+  "boi_token_index": 255999,
+  "dtype": "float32",
+  "eoi_token_index": 256000,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "image_token_index": 262144,
+  "initializer_range": 0.02,
+  "mm_tokens_per_image": 256,
+  "model_type": "gemma3",
+  "text_config": {
+    "_sliding_window_pattern": 6,
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attn_logit_softcapping": null,
+    "cache_implementation": "hybrid",
+    "dtype": "float32",
+    "final_logit_softcapping": null,
+    "head_dim": 16,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 32,
+    "initializer_range": 0.02,
+    "intermediate_size": 64,
+    "layer_types": [
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 512,
+    "model_type": "gemma3_text",
+    "num_attention_heads": 2,
+    "num_hidden_layers": 2,
+    "num_key_value_heads": 2,
+    "query_pre_attn_scalar": 16,
+    "rms_norm_eps": 1e-06,
+    "rope_local_base_freq": 10000,
+    "rope_scaling": {
+      "factor": 8.0,
+      "rope_type": "linear"
+    },
+    "rope_theta": 1000000,
+    "sliding_window": 1024,
+    "sliding_window_pattern": 6,
+    "use_bidirectional_attention": false,
+    "use_cache": true,
+    "vocab_size": 262208
+  },
+  "transformers_version": "4.57.3",
+  "vision_config": {
+    "attention_dropout": 0.0,
+    "dtype": "float32",
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 32,
+    "image_size": 896,
+    "intermediate_size": 64,
+    "layer_norm_eps": 1e-06,
+    "model_type": "siglip_vision_model",
+    "num_attention_heads": 2,
+    "num_channels": 3,
+    "num_hidden_layers": 2,
+    "patch_size": 14,
+    "vision_use_head": false
+  }
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/transformer/config.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/transformer/config.json
new file mode 100644
index 000000000..577b0fb36
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/transformer/config.json
@@ -0,0 +1,44 @@
+{
+  "_class_name": "LTX2VideoTransformer3DModel",
+  "_diffusers_version": "0.37.0.dev0",
+  "activation_fn": "gelu-approximate",
+  "attention_bias": true,
+  "attention_head_dim": 16,
+  "attention_out_bias": true,
+  "audio_attention_head_dim": 16,
+  "audio_cross_attention_dim": 32,
+  "audio_hop_length": 160,
+  "audio_in_channels": 128,
+  "audio_num_attention_heads": 2,
+  "audio_out_channels": 128,
+  "audio_patch_size": 1,
+  "audio_patch_size_t": 1,
+  "audio_pos_embed_max_pos": 20,
+  "audio_sampling_rate": 16000,
+  "audio_scale_factor": 4,
+  "base_height": 2048,
+  "base_width": 2048,
+  "caption_channels": 32,
+  "causal_offset": 1,
+  "cross_attention_dim": 32,
+  "cross_attn_timestep_scale_multiplier": 1000,
+  "in_channels": 128,
+  "norm_elementwise_affine": false,
+  "norm_eps": 1e-06,
+  "num_attention_heads": 2,
+  "num_layers": 2,
+  "out_channels": 128,
+  "patch_size": 1,
+  "patch_size_t": 1,
+  "pos_embed_max_pos": 20,
+  "qk_norm": "rms_norm_across_heads",
+  "rope_double_precision": true,
+  "rope_theta": 10000.0,
+  "rope_type": "split",
+  "timestep_scale_multiplier": 1000,
+  "vae_scale_factors": [
+    8,
+    32,
+    32
+  ]
+}
diff --git a/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/vae/config.json b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/vae/config.json
new file mode 100644
index 000000000..a672971d4
--- /dev/null
+++ b/tests/model_tests/diffusion/tiny_configs/LTX2Pipeline/vae/config.json
@@ -0,0 +1,81 @@
+{
+  "_class_name": "AutoencoderKLLTX2Video",
+  "_diffusers_version": "0.37.0.dev0",
+  "block_out_channels": [
+    256,
+    512,
+    1024,
+    2048
+  ],
+  "decoder_block_out_channels": [
+    256,
+    512,
+    1024
+  ],
+  "decoder_causal": false,
+  "decoder_inject_noise": [
+    false,
+    false,
+    false,
+    false
+  ],
+  "decoder_layers_per_block": [
+    1,
+    1,
+    1,
+    1
+  ],
+  "decoder_spatial_padding_mode": "reflect",
+  "decoder_spatio_temporal_scaling": [
+    true,
+    true,
+    true
+  ],
+  "down_block_types": [
+    "LTX2VideoDownBlock3D",
+    "LTX2VideoDownBlock3D",
+    "LTX2VideoDownBlock3D",
+    "LTX2VideoDownBlock3D"
+  ],
+  "downsample_type": [
+    "spatial",
+    "temporal",
+    "spatiotemporal",
+    "spatiotemporal"
+  ],
+  "encoder_causal": true,
+  "encoder_spatial_padding_mode": "zeros",
+  "in_channels": 3,
+  "latent_channels": 128,
+  "layers_per_block": [
+    1,
+    1,
+    1,
+    1,
+    1
+  ],
+  "out_channels": 3,
+  "patch_size": 4,
+  "patch_size_t": 1,
+  "resnet_norm_eps": 1e-06,
+  "scaling_factor": 1.0,
+  "spatial_compression_ratio": 32,
+  "spatio_temporal_scaling": [
+    true,
+    true,
+    true,
+    true
+  ],
+  "temporal_compression_ratio": 8,
+  "timestep_conditioning": false,
+  "upsample_factor": [
+    2,
+    2,
+    2
+  ],
+  "upsample_residual": [
+    true,
+    true,
+    true
+  ]
+}
diff --git a/tests/platforms/npu/test_310p_patches.py b/tests/platforms/npu/test_310p_patches.py
index e138a6d63..99dbb4650 100644
--- a/tests/platforms/npu/test_310p_patches.py
+++ b/tests/platforms/npu/test_310p_patches.py
@@ -489,6 +489,14 @@ def test_qwen3_tts_tokenizer_npu_patch_dispatches_fused_ops(monkeypatch: pytest.
     _install_fake_module(monkeypatch, "vllm")
     _install_fake_module(monkeypatch, "vllm.logger", init_logger=lambda _name: SimpleNamespace(debug=lambda *_: None))
 
+    rotary_path = _repo_root() / "vllm_omni" / "platforms" / "npu" / "layers" / "rotary_embedding.py"
+    rotary_module = _load_source_module("vllm_omni_test_npu_rotary_embedding", rotary_path)
+    monkeypatch.setitem(
+        sys.modules,
+        "vllm_omni.platforms.npu.layers.rotary_embedding",
+        rotary_module,
+    )
+
     class FakeRMSNorm(torch.nn.Module):
         def __init__(self):
             super().__init__()
@@ -536,7 +544,7 @@ def test_qwen3_tts_tokenizer_npu_patch_dispatches_fused_ops(monkeypatch: pytest.
     norm_out = norm(torch.ones(1, 2))
 
     assert len(rotary_calls) == 2
-    assert rotary_calls[0][1].shape == (1, 1, 3, 2)
+    assert rotary_calls[0][1].shape == (1, 3, 1, 2)
     torch.testing.assert_close(q_out, q + 1)
     torch.testing.assert_close(k_out, k + 1)
     assert len(rms_calls) == 1
diff --git a/tests/platforms/npu/test_step_audio2_token2wav.py b/tests/platforms/npu/test_step_audio2_token2wav.py
new file mode 100644
index 000000000..ae86f92d9
--- /dev/null
+++ b/tests/platforms/npu/test_step_audio2_token2wav.py
@@ -0,0 +1,196 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""CPU unit tests for the Step-Audio2 Ascend HiFT patch."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+import torch.nn.functional as F
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _load_patch_module(monkeypatch: pytest.MonkeyPatch):
+    fake_logger = SimpleNamespace(info=lambda *_args, **_kwargs: None)
+    fake_vllm = types.ModuleType("vllm")
+    fake_vllm_logger = types.ModuleType("vllm.logger")
+    fake_vllm_logger.init_logger = lambda _name: fake_logger
+    monkeypatch.setitem(sys.modules, "vllm", fake_vllm)
+    monkeypatch.setitem(sys.modules, "vllm.logger", fake_vllm_logger)
+
+    root = next(parent for parent in Path(__file__).resolve().parents if (parent / "vllm_omni").is_dir())
+    path = root / "vllm_omni" / "platforms" / "npu" / "models" / "step_audio2_token2wav.py"
+    spec = importlib.util.spec_from_file_location("test_step_audio2_token2wav_npu_patch", path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _reference_f02sine(sine_gen, f0_values: torch.Tensor) -> torch.Tensor:
+    rad_values = (f0_values / sine_gen.sampling_rate) % 1
+    rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], device=f0_values.device)
+    rand_ini[:, 0] = 0
+    rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
+    rad_values = F.interpolate(
+        rad_values.transpose(1, 2),
+        scale_factor=1 / sine_gen.upsample_scale,
+        mode="linear",
+    ).transpose(1, 2)
+    phase = torch.cumsum(rad_values, dim=1) * 2 * np.pi
+    phase = F.interpolate(
+        phase.transpose(1, 2) * sine_gen.upsample_scale,
+        scale_factor=sine_gen.upsample_scale,
+        mode="linear",
+    ).transpose(1, 2)
+    return torch.sin(phase)
+
+
+def test_even_scale_downsample_matches_linear_interpolate(monkeypatch: pytest.MonkeyPatch) -> None:
+    module = _load_patch_module(monkeypatch)
+    x = torch.randn(2, 3, 960)
+
+    expected = F.interpolate(x, scale_factor=1 / 4, mode="linear")
+    actual = module._linear_downsample_even_scale(x, 4)
+
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize(("shape", "scale"), [((1, 2, 12), 3), ((1, 2, 10), 4)])
+def test_even_scale_downsample_rejects_unsupported_shapes(
+    monkeypatch: pytest.MonkeyPatch,
+    shape: tuple[int, ...],
+    scale: int,
+) -> None:
+    module = _load_patch_module(monkeypatch)
+    with pytest.raises(ValueError):
+        module._linear_downsample_even_scale(torch.randn(shape), scale)
+
+
+def test_hift_patch_is_exact_idempotent_and_stays_on_device(monkeypatch: pytest.MonkeyPatch) -> None:
+    module = _load_patch_module(monkeypatch)
+
+    class FakeSineGen:
+        sampling_rate = 24000
+        upsample_scale = 4
+        flag_for_pulse = False
+
+        def __init__(self):
+            self.original_calls = 0
+
+        def _f02sine(self, f0_values):
+            self.original_calls += 1
+            return _reference_f02sine(self, f0_values)
+
+    class FakeHiFT:
+        def __init__(self):
+            self.m_source = SimpleNamespace(l_sin_gen=FakeSineGen())
+
+        def to(self, *_args, **_kwargs):
+            raise AssertionError("HiFT must stay on its accelerator")
+
+    hift = FakeHiFT()
+    module.patch_step_audio2_hift_for_npu(hift)
+    patched_method = hift.m_source.l_sin_gen._f02sine
+    module.patch_step_audio2_hift_for_npu(hift)
+    assert hift.m_source.l_sin_gen._f02sine is patched_method
+
+    f0_values = torch.rand(1, 16, 3)
+    torch.manual_seed(7)
+    expected = _reference_f02sine(hift.m_source.l_sin_gen, f0_values)
+    torch.manual_seed(7)
+    actual = patched_method(f0_values)
+
+    assert hift.m_source.l_sin_gen.original_calls == 0
+    torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize(
+    ("flag_for_pulse", "upsample_scale", "input_length"),
+    [
+        (True, 4, 16),
+        (False, 3, 12),
+        (False, 4.5, 18),
+        (False, 4, 10),
+    ],
+)
+def test_hift_patch_delegates_unsupported_cases_to_original_f02sine_on_cpu(
+    monkeypatch: pytest.MonkeyPatch,
+    flag_for_pulse: bool,
+    upsample_scale: float,
+    input_length: int,
+) -> None:
+    module = _load_patch_module(monkeypatch)
+    calls: list[str] = []
+
+    class FakeSineGen:
+        def __init__(self):
+            self.flag_for_pulse = flag_for_pulse
+            self.upsample_scale = upsample_scale
+
+        def _f02sine(self, f0_values):
+            calls.append(f0_values.device.type)
+            return f0_values + 1
+
+    hift = SimpleNamespace(m_source=SimpleNamespace(l_sin_gen=FakeSineGen()))
+    module.patch_step_audio2_hift_for_npu(hift)
+
+    f0_values = torch.randn(1, input_length, 3)
+    output = hift.m_source.l_sin_gen._f02sine(f0_values)
+
+    assert calls == ["cpu"]
+    assert output.device == f0_values.device
+    torch.testing.assert_close(output, f0_values + 1)
+
+
+@pytest.mark.parametrize("upsample_scale", [0, -2])
+def test_hift_patch_rejects_non_positive_scale(
+    monkeypatch: pytest.MonkeyPatch,
+    upsample_scale: int,
+) -> None:
+    module = _load_patch_module(monkeypatch)
+
+    class FakeSineGen:
+        flag_for_pulse = False
+
+        def __init__(self):
+            self.upsample_scale = upsample_scale
+
+        def _f02sine(self, f0_values):
+            return f0_values
+
+    hift = SimpleNamespace(m_source=SimpleNamespace(l_sin_gen=FakeSineGen()))
+    module.patch_step_audio2_hift_for_npu(hift)
+
+    with pytest.raises(ValueError, match="upsample_scale must be positive"):
+        hift.m_source.l_sin_gen._f02sine(torch.randn(1, 16, 3))
+
+
+def test_hift_patch_rejects_causal_sinegen(monkeypatch: pytest.MonkeyPatch) -> None:
+    module = _load_patch_module(monkeypatch)
+
+    class FakeCausalSineGen:
+        causal = True
+
+        def _f02sine(self, f0_values):
+            return f0_values
+
+    hift = SimpleNamespace(m_source=SimpleNamespace(l_sin_gen=FakeCausalSineGen()))
+
+    with pytest.raises(ValueError, match="only supports non-causal SineGen2"):
+        module.patch_step_audio2_hift_for_npu(hift)
+
+
+def test_hift_patch_reports_incompatible_layout(monkeypatch: pytest.MonkeyPatch) -> None:
+    module = _load_patch_module(monkeypatch)
+
+    with pytest.raises(TypeError, match=r"m_source\.l_sin_gen\._f02sine"):
+        module.patch_step_audio2_hift_for_npu(SimpleNamespace())
diff --git a/tests/platforms/test_record_device_event.py b/tests/platforms/test_record_device_event.py
new file mode 100644
index 000000000..a979ca940
--- /dev/null
+++ b/tests/platforms/test_record_device_event.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Unit tests for OmniPlatform.record_device_event implementations."""
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class TestOmniPlatformRecordDeviceEventInterface:
+    """Test that the base OmniPlatform returns None (safe no-op fallback)."""
+
+    def test_base_class_returns_none(self):
+        from vllm_omni.platforms.interface import OmniPlatform
+
+        assert OmniPlatform.record_device_event() is None
+
+
+class TestCudaOmniPlatformRecordDeviceEvent:
+    """Test CudaOmniPlatform.record_device_event with mocked torch.Event."""
+
+    def test_records_event_successfully(self, mocker):
+        from vllm_omni.platforms.cuda.platform import CudaOmniPlatform
+
+        mock_event = mocker.MagicMock()
+        mocker.patch("torch.Event", return_value=mock_event)
+
+        result = CudaOmniPlatform.record_device_event()
+        assert result is mock_event
+        mock_event.record.assert_called_once()
+
+    def test_returns_none_on_failure(self, mocker):
+        from vllm_omni.platforms.cuda.platform import CudaOmniPlatform
+
+        mocker.patch("torch.Event", side_effect=RuntimeError("no CUDA"))
+
+        result = CudaOmniPlatform.record_device_event()
+        assert result is None
+
+
+class TestNPUOmniPlatformRecordDeviceEvent:
+    """Test NPUOmniPlatform.record_device_event with mocked torch.npu."""
+
+    def test_returns_none_on_failure(self, mocker):
+        """When torch.npu.current_stream().synchronize() fails, return None."""
+        try:
+            from vllm_omni.platforms.npu.platform import NPUOmniPlatform
+        except ModuleNotFoundError:
+            pytest.skip("vllm_ascend not available")
+
+        mock_torch = mocker.MagicMock()
+        mock_torch.npu.current_stream.return_value.synchronize.side_effect = RuntimeError("no NPU")
+        mocker.patch("vllm_omni.platforms.npu.platform.torch", mock_torch)
+
+        result = NPUOmniPlatform.record_device_event()
+        assert result is None
+
+    def test_synchronizes_stream_then_records_event(self, mocker):
+        """NPU should sync stream first, then create and record an Event."""
+        try:
+            from vllm_omni.platforms.npu.platform import NPUOmniPlatform
+        except ModuleNotFoundError:
+            pytest.skip("vllm_ascend not available")
+
+        mock_event = mocker.MagicMock()
+        mock_stream = mocker.MagicMock()
+        mock_torch = mocker.MagicMock()
+        mock_torch.npu.current_stream.return_value = mock_stream
+        mock_torch.npu.Event.return_value = mock_event
+        mocker.patch("vllm_omni.platforms.npu.platform.torch", mock_torch)
+
+        result = NPUOmniPlatform.record_device_event()
+
+        # Stream should be synced first (HCCL ordering)
+        mock_stream.synchronize.assert_called_once()
+        # Then event should be created and recorded
+        mock_torch.npu.Event.assert_called_once()
+        mock_event.record.assert_called_once()
+        assert result is mock_event
diff --git a/tests/plugin/__init__.py b/tests/plugin/__init__.py
deleted file mode 100644
index 988131360..000000000
--- a/tests/plugin/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/profile/test_omni_torch_profiler.py b/tests/profile/test_omni_torch_profiler.py
index 3920078af..7bfc8f8cc 100644
--- a/tests/profile/test_omni_torch_profiler.py
+++ b/tests/profile/test_omni_torch_profiler.py
@@ -12,6 +12,8 @@ from openpyxl import load_workbook
 import vllm_omni.profiler.omni_torch_profiler as profiler_mod
 from vllm_omni.profiler.omni_torch_profiler import OmniTorchProfilerWrapper
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 @pytest.fixture(autouse=True)
 def patch_worker_profiler_init(monkeypatch):
diff --git a/tests/quantization/test_quack_fp8_gate.py b/tests/quantization/test_quack_fp8_gate.py
index 4a8848ffa..843f4ff5f 100644
--- a/tests/quantization/test_quack_fp8_gate.py
+++ b/tests/quantization/test_quack_fp8_gate.py
@@ -20,6 +20,9 @@ import torch
 
 from vllm_omni.quantization import quack_fp8
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 _ENV = "VLLM_OMNI_USE_QUACK_FP8"
 
 
diff --git a/tests/reasoning/test_step_audio_reasoning_parser.py b/tests/reasoning/test_step_audio_reasoning_parser.py
index 7eb9fa17a..11105265c 100644
--- a/tests/reasoning/test_step_audio_reasoning_parser.py
+++ b/tests/reasoning/test_step_audio_reasoning_parser.py
@@ -21,6 +21,9 @@ from unittest.mock import MagicMock
 
 import pytest
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # ---------------------------------------------------------------------------
 # Bootstrap minimal vLLM stubs so the parser can be imported
 # ---------------------------------------------------------------------------
@@ -784,8 +787,8 @@ class TestExtractReasoningStreaming:
         """When buffered text turns out not to be a marker prefix, it is
         emitted as reasoning on the next call."""
         # "reason<" is buffered because "<" could start a marker.
-        # Next delta ">" doesn't form a marker, so the buffer is
-        # flushed as reasoning.
+        # Next delta ">" doesn't form a marker, so the buffer ("<") is
+        # prepended to the next delta and flushed as reasoning: "<> more".
         parser = multi_token_parser
         deltas_and_ids = [
             (TS, [100]),
@@ -794,7 +797,7 @@ class TestExtractReasoningStreaming:
             ("> more", [8]),  # ">" doesn't complete any marker
         ]
         r, c = _stream_extract(parser, deltas_and_ids)
-        assert r == "reason> more"
+        assert r == "reason<> more"
         assert c == ""
 
     def test_multi_token_end_with_reasoning_before_buffer(self, multi_token_parser):
@@ -837,7 +840,7 @@ class TestExtractReasoningStreaming:
             ("> not a marker", [8]),
         ]
         r, c = _stream_extract(parser, deltas_and_ids)
-        assert r == "reason> not a marker"
+        assert r == "reason<> not a marker"
         assert c == ""
 
 
diff --git a/tests/test_generate_nightly_perf_excel.py b/tests/tools/test_generate_nightly_perf_excel.py
similarity index 96%
rename from tests/test_generate_nightly_perf_excel.py
rename to tests/tools/test_generate_nightly_perf_excel.py
index 6658b89b8..80b27fbf5 100644
--- a/tests/test_generate_nightly_perf_excel.py
+++ b/tests/tools/test_generate_nightly_perf_excel.py
@@ -10,7 +10,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 def _load_excel_module():
-    repo_root = Path(__file__).resolve().parents[1]
+    repo_root = Path(__file__).resolve().parents[2]
     module_path = repo_root / "tools" / "nightly" / "generate_nightly_perf_excel.py"
     spec = importlib.util.spec_from_file_location("generate_nightly_perf_excel", module_path)
     module = importlib.util.module_from_spec(spec)
@@ -27,7 +27,7 @@ def _cell_value_by_header(ws, header_name: str, row_idx: int = 2):
 
 def test_generate_excel_report_with_perf_templates(tmp_path: Path):
     module = _load_excel_module()
-    repo_root = Path(__file__).resolve().parents[1]
+    repo_root = Path(__file__).resolve().parents[2]
     perf_scripts_dir = repo_root / "tests" / "dfx" / "perf" / "scripts"
 
     omni_template_path = perf_scripts_dir / "result_omni_template.json"
diff --git a/tests/test_generate_nightly_perf_html.py b/tests/tools/test_generate_nightly_perf_html.py
similarity index 95%
rename from tests/test_generate_nightly_perf_html.py
rename to tests/tools/test_generate_nightly_perf_html.py
index 7a05165da..4592c2183 100644
--- a/tests/test_generate_nightly_perf_html.py
+++ b/tests/tools/test_generate_nightly_perf_html.py
@@ -9,7 +9,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 def _load_html_module():
-    repo_root = Path(__file__).resolve().parents[1]
+    repo_root = Path(__file__).resolve().parents[2]
     module_path = repo_root / "tools" / "nightly" / "generate_nightly_perf_html.py"
     spec = importlib.util.spec_from_file_location("generate_nightly_perf_html", module_path)
     module = importlib.util.module_from_spec(spec)
@@ -20,7 +20,7 @@ def _load_html_module():
 
 def test_generate_html_report_with_perf_templates(tmp_path: Path):
     module = _load_html_module()
-    repo_root = Path(__file__).resolve().parents[1]
+    repo_root = Path(__file__).resolve().parents[2]
     perf_scripts_dir = repo_root / "tests" / "dfx" / "perf" / "scripts"
 
     omni_template_path = perf_scripts_dir / "result_omni_template.json"
diff --git a/tests/utils/test_audio.py b/tests/utils/test_audio.py
index 0e483e646..ff29b2d04 100644
--- a/tests/utils/test_audio.py
+++ b/tests/utils/test_audio.py
@@ -9,6 +9,9 @@ import torch
 
 from vllm_omni.utils.audio import mel_filter_bank, peak_normalize
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 # Parameter combinations used across the codebase.
 _PARAM_SETS = [
     # Qwen3-TTS talker / speaker encoder (sr=24000)
diff --git a/tests/utils/test_mm_outputs.py b/tests/utils/test_mm_outputs.py
new file mode 100644
index 000000000..a07effb98
--- /dev/null
+++ b/tests/utils/test_mm_outputs.py
@@ -0,0 +1,147 @@
+import pytest
+import torch
+
+from vllm_omni.utils import mm_outputs as mm_outputs_mod
+from vllm_omni.utils.mm_outputs import build_mm_cpu
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+TOTAL_TOKENS = 5
+NUM_TOKEN_ALIGNED_TENSORS = 3  # codes.audio, meta.ref_code_len, meta.codec_streaming
+
+
+def make_talker_passthrough_payload(num_requests: int, device: str = "cpu") -> dict:
+    """The passthrough set qwen3-tts actually hands to build_mm_cpu each decode
+    step (qwen3_tts_talker.make_omni_output): a nested codes/meta dict whose
+    ``codes.ref`` holds one tensor per request, alongside 1D int token-aligned
+    metadata. Under prefix caching only ``codes.audio`` is 2D and token-aligned,
+    so it is the sole cache key and this whole structure is passthrough.
+    """
+    return {
+        "codes": {
+            "audio": torch.rand(TOTAL_TOKENS, 4, device=device),
+            "ref": [torch.arange(idx + 1, dtype=torch.long, device=device) for idx in range(num_requests)],
+        },
+        "meta": {
+            "ref_code_len": torch.full((TOTAL_TOKENS,), 7, dtype=torch.int32, device=device),
+            "codec_streaming": torch.ones(TOTAL_TOKENS, dtype=torch.int8, device=device),
+        },
+    }
+
+
+def iter_tensors(value):
+    """Yield every tensor leaf, recursing the same dict/list nesting _to_cpu does."""
+    if isinstance(value, torch.Tensor):
+        yield value
+    elif isinstance(value, dict):
+        for item in value.values():
+            yield from iter_tensors(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from iter_tensors(item)
+
+
+@pytest.mark.parametrize("num_requests", [1, 3])
+def test_build_mm_cpu_d2h_count_grows_per_request(num_requests, mocker):
+    """Pins the pre-W2 cost: build_mm_cpu issues one per-tensor copy for each
+    token-aligned payload tensor plus one more for every request's ``codes.ref``
+    entry, so the transfer count grows linearly with batch size. That growth is
+    what RFC #4855 W2 sets out to batch away.
+
+    Counting tensor leaves rather than dict keys is deliberate: a flat dict of
+    K tensors makes ``call_count == K`` true by construction, since build_mm_cpu
+    is a loop over items. Only the per-request list can move this number.
+    """
+    spy = mocker.spy(mm_outputs_mod, "_to_cpu")
+
+    result = build_mm_cpu(multimodal_outputs=make_talker_passthrough_payload(num_requests))
+
+    tensor_copies = [call for call in spy.call_args_list if isinstance(call.args[0], torch.Tensor)]
+    assert len(tensor_copies) == NUM_TOKEN_ALIGNED_TENSORS + num_requests
+    assert len(result["codes"]["ref"]) == num_requests
+
+
+def test_build_mm_cpu_preserves_int_dtypes_of_talker_metadata():
+    """ref_code_len is int32 and codec_streaming int8 at the source; a W2 that
+    stages passthrough through a float buffer would corrupt both silently."""
+    result = build_mm_cpu(multimodal_outputs=make_talker_passthrough_payload(3))
+
+    assert result["meta"]["ref_code_len"].dtype == torch.int32
+    assert result["meta"]["codec_streaming"].dtype == torch.int8
+    assert all(ref.dtype == torch.long for ref in result["codes"]["ref"])
+
+
+def test_build_mm_cpu_returns_cpu_tensors_for_every_nested_leaf():
+    """The output contract: every tensor leaf, including those inside the
+    ``codes.ref`` list, comes back on CPU.
+
+    On this lane the inputs are already CPU, so this documents the contract
+    rather than proving it -- ``.to("cpu")`` is a no-op here. The GPU-gated
+    sibling below is the one that can actually fail.
+    """
+    result = build_mm_cpu(multimodal_outputs=make_talker_passthrough_payload(3))
+
+    leaves = list(iter_tensors(result))
+    assert len(leaves) == NUM_TOKEN_ALIGNED_TENSORS + 3
+    assert all(leaf.device.type == "cpu" for leaf in leaves)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="requires a CUDA device")
+def test_build_mm_cpu_moves_a_gpu_payload_off_the_device():
+    """D2H is the entire purpose of build_mm_cpu. RFC #4855 W2 lists "skip the
+    CPU conversion when the consumer is the same-GPU next stage" as one of its
+    three options; that option leaves every tensor on the device and no CPU-lane
+    test can observe it, because there ``.to("cpu")`` is a silent no-op.
+    """
+    payload = make_talker_passthrough_payload(3, device="cuda")
+    source_leaves = list(iter_tensors(payload))
+    assert all(leaf.device.type == "cuda" for leaf in source_leaves)
+
+    result = build_mm_cpu(multimodal_outputs=payload)
+
+    leaves = list(iter_tensors(result))
+    assert len(leaves) == len(source_leaves)
+    assert all(leaf.device.type == "cpu" for leaf in leaves)
+
+
+def test_build_mm_cpu_empty_input_is_a_noop(mocker):
+    spy = mocker.spy(mm_outputs_mod, "_to_cpu")
+
+    assert build_mm_cpu(multimodal_outputs={}) == {}
+    spy.assert_not_called()
+
+
+def test_build_mm_cpu_preserves_nested_and_non_tensor_payload_semantics():
+    """_to_cpu must recurse into nested dict/list structures, force
+    non-contiguous tensors to become contiguous, detach from autograd,
+    and leave dtype/shape/values unchanged; non-tensor leaves (scalar,
+    string) pass through untouched. Any W2 implementation (cat, deferral,
+    or a new materializer) must preserve this exact semantics."""
+    non_contig = torch.arange(9, dtype=torch.float32).reshape(3, 3).t()
+    assert not non_contig.is_contiguous()
+    grad_tensor = torch.tensor([5.0, 6.0], requires_grad=True)
+
+    payload = {
+        "nested": {"inner_tensor": non_contig, "inner_scalar": "keep-me"},
+        "list_of_tensors": [torch.tensor([1.0, 2.0]), "marker", torch.tensor([3.0, 4.0])],
+        "grad_key": grad_tensor,
+        "scalar": 42,
+    }
+    result = build_mm_cpu(multimodal_outputs=payload)
+
+    inner = result["nested"]["inner_tensor"]
+    assert inner.is_contiguous()
+    assert inner.dtype == non_contig.dtype
+    assert inner.shape == non_contig.shape
+    assert torch.equal(inner, non_contig)
+    assert result["nested"]["inner_scalar"] == "keep-me"
+
+    lst = result["list_of_tensors"]
+    assert torch.equal(lst[0], torch.tensor([1.0, 2.0]))
+    assert lst[1] == "marker"
+    assert torch.equal(lst[2], torch.tensor([3.0, 4.0]))
+
+    assert result["grad_key"].requires_grad is False
+    assert torch.equal(result["grad_key"], grad_tensor.detach())
+
+    assert result["scalar"] == 42
diff --git a/tests/utils/test_mm_outputs_partition.py b/tests/utils/test_mm_outputs_partition.py
index f9affa471..d70b95a79 100644
--- a/tests/utils/test_mm_outputs_partition.py
+++ b/tests/utils/test_mm_outputs_partition.py
@@ -1,7 +1,10 @@
+import pytest
 import torch
 
 from vllm_omni.utils.mm_outputs import partition_flat_payload, partition_payload_list
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 def test_partition_thinker_latent_payload():
     payload = {
@@ -42,3 +45,27 @@ def test_partition_payload_list_preserves_request_alignment():
     inter_list, client_list = partition_payload_list(payloads)
     assert inter_list == [payloads[0], None]
     assert client_list == [None, payloads[1]]
+
+
+def test_partition_duplex_audio_transcript_metadata_to_client_mm():
+    payload = {
+        "model_outputs": torch.zeros(1, 2400),
+        "meta.duplex_epoch": torch.tensor([3], dtype=torch.int32),
+        "meta.duplex_turn_id": torch.tensor([2], dtype=torch.int32),
+        "meta.llm_output_text_utf8": torch.tensor([104, 105], dtype=torch.uint8),
+        "meta.audio_text_total_chars": torch.tensor([2], dtype=torch.int32),
+        "meta.tts_is_last_chunk": torch.tensor([1], dtype=torch.int32),
+        "meta.turn_end": torch.tensor([1], dtype=torch.int32),
+        "meta.native_duplex_segment_text": "hi",
+    }
+
+    inter, client = partition_flat_payload(payload)
+
+    assert "meta.llm_output_text_utf8" in client
+    assert "meta.audio_text_total_chars" in client
+    assert "meta.duplex_epoch" in client
+    assert "meta.duplex_turn_id" in client
+    assert "meta.tts_is_last_chunk" in client
+    assert "meta.turn_end" in client
+    assert "meta.native_duplex_segment_text" not in client
+    assert "meta.native_duplex_segment_text" in inter
diff --git a/tests/test_speaker_cache.py b/tests/utils/test_speaker_cache.py
similarity index 100%
rename from tests/test_speaker_cache.py
rename to tests/utils/test_speaker_cache.py
diff --git a/tests/test_speaker_cache_integration.py b/tests/utils/test_speaker_cache_integration.py
similarity index 100%
rename from tests/test_speaker_cache_integration.py
rename to tests/utils/test_speaker_cache_integration.py
diff --git a/tests/utils/test_tracking_parser.py b/tests/utils/test_tracking_parser.py
index 5bee3e3b0..f00da2797 100644
--- a/tests/utils/test_tracking_parser.py
+++ b/tests/utils/test_tracking_parser.py
@@ -23,6 +23,9 @@ from vllm_omni.utils.tracking_parser import (
     build_shadow_kwargs,
 )
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
 ### Fake pipeline/deploy config for integration tests
 
 _TEST_MODEL = "_test_tracking"
@@ -49,6 +52,11 @@ _TEST_DEPLOY = DeployConfig(
 @pytest.fixture()
 def mock_stages(monkeypatch):
     """Register a fake pipeline and mock deploy YAML loading."""
+    from vllm_omni import platforms
+
+    platform = platforms.current_omni_platform
+    monkeypatch.setattr(platform, "device_name", "cpu", raising=False)
+    monkeypatch.setattr(platform, "device_type", "cpu", raising=False)
     monkeypatch.setitem(OMNI_PIPELINES, _TEST_MODEL, _TEST_PIPELINE)
     monkeypatch.setattr(
         "vllm_omni.config.config_factory.load_deploy_config",
@@ -211,6 +219,46 @@ def test_store_true_explicit():
     assert ns.verbose is True
 
 
+def test_unset_trust_remote_code_falls_back_to_engine_default_none():
+    """Regression guard for issue #5495 (the CLI-plumbing half).
+
+    The CI test ``test_completions_rejected_for_thinker_talker`` does NOT pass
+    ``--trust-remote-code``. Because it is a ``store_true`` flag, an omitted
+    value is dropped from ``get_explicit_kwargs_dict()`` (it is not user-typed),
+    so it is never forwarded to ``AsyncOmni(**kwargs)`` and the engine falls back
+    to ``AsyncOmniEngine.__init__``'s default of ``None`` — NOT argparse's
+    ``False``. That ``None`` is what used to break endpoint-restriction
+    resolution (see ``TestQwen3OmniPipeline.
+    test_endpoint_restrictions_survive_unset_trust_remote_code``).
+
+    This test locks in the "CI does not pass the flag => effective value is
+    None" premise so a future refactor cannot silently change it.
+    """
+    import inspect
+
+    from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+
+    p = TrackingArgumentParser()
+    # Mirror how --trust-remote-code is registered upstream (store_true).
+    p.add_argument("--trust-remote-code", action="store_true")
+
+    # Scenario A: CI — flag omitted.
+    ns = p.parse_args([])
+    assert "trust_remote_code" not in ns.explicit_keys
+    kwargs = ns.get_explicit_kwargs_dict()
+    assert "trust_remote_code" not in kwargs
+    engine_default = inspect.signature(AsyncOmniEngine.__init__).parameters["trust_remote_code"].default
+    assert engine_default is None
+    effective = kwargs.get("trust_remote_code", engine_default)
+    assert effective is None  # <- the value that reached the buggy restriction path
+
+    # Scenario B: flag passed (what earlier repros used) => True, restrictions fine.
+    ns2 = p.parse_args(["--trust-remote-code"])
+    assert "trust_remote_code" in ns2.explicit_keys
+    kwargs2 = ns2.get_explicit_kwargs_dict()
+    assert kwargs2.get("trust_remote_code", engine_default) is True
+
+
 def test_store_false_default():
     """Ensure that store false is handled correctly when omitted."""
     p = TrackingArgumentParser()
@@ -584,6 +632,12 @@ def test_cli_overrides_config(tmp_path):
 
 
 ### Integration tests for arg resolution through StageConfigFactory
+#
+# These tests still target the transitional legacy StageConfig path because the
+# current runtime reads explicit CLI values from ``stage.runtime_overrides``.
+# After RFC #4021 migrates engine startup to consume ``VllmOmniConfig`` directly,
+# these assertions should move to the structured config/runtime boundary and the
+# ``_create_legacy_from_registry`` calls should be removed.
 def test_explicit_cli_arg_reaches_runtime_overrides(mock_stages):
     """Explicitly passed CLI values reach runtime_overrides on all stages."""
     p = TrackingArgumentParser()
@@ -591,8 +645,7 @@ def test_explicit_cli_arg_reaches_runtime_overrides(mock_stages):
     ns = p.parse_args(["--max-num-seqs", "999"])
 
     explicit_kwargs = ns.get_explicit_kwargs_dict()
-    stages, _ = StageConfigFactory._create_from_registry(
-        _TEST_MODEL,
+    stages, _ = StageConfigFactory._create_legacy_from_registry(
         _TEST_PIPELINE,
         explicit_kwargs,
         deploy_config_path=mock_stages,
@@ -608,8 +661,7 @@ def test_omitted_default_not_in_runtime_overrides(mock_stages):
     ns = p.parse_args([])
 
     explicit_kwargs = ns.get_explicit_kwargs_dict()
-    stages, _ = StageConfigFactory._create_from_registry(
-        _TEST_MODEL,
+    stages, _ = StageConfigFactory._create_legacy_from_registry(
         _TEST_PIPELINE,
         explicit_kwargs,
         deploy_config_path=mock_stages,
@@ -630,8 +682,7 @@ def test_config_file_args_reach_runtime_overrides(mock_stages):
         ns = p.parse_args(["--config", "fake.yaml"])
 
     explicit_kwargs = ns.get_explicit_kwargs_dict()
-    stages, _ = StageConfigFactory._create_from_registry(
-        _TEST_MODEL,
+    stages, _ = StageConfigFactory._create_legacy_from_registry(
         _TEST_PIPELINE,
         explicit_kwargs,
         deploy_config_path=mock_stages,
@@ -648,8 +699,7 @@ def test_per_stage_override_routes_correctly(mock_stages):
     ns = p.parse_args(["--stage-0-gpu-memory-utilization", "0.42"])
 
     explicit_kwargs = ns.get_explicit_kwargs_dict()
-    stages, _ = StageConfigFactory._create_from_registry(
-        _TEST_MODEL,
+    stages, _ = StageConfigFactory._create_legacy_from_registry(
         _TEST_PIPELINE,
         explicit_kwargs,
         deploy_config_path=mock_stages,
@@ -670,8 +720,7 @@ def test_explicit_args_omitted_from_yaml(mock_stages):
     ns = p.parse_args(["--enforce-eager"])
 
     explicit_kwargs = ns.get_explicit_kwargs_dict()
-    stages, _ = StageConfigFactory._create_from_registry(
-        _TEST_MODEL,
+    stages, _ = StageConfigFactory._create_legacy_from_registry(
         _TEST_PIPELINE,
         explicit_kwargs,
         deploy_config_path=mock_stages,
diff --git a/tests/test_version.py b/tests/utils/test_version.py
similarity index 98%
rename from tests/test_version.py
rename to tests/utils/test_version.py
index 911a79611..0c666133c 100644
--- a/tests/test_version.py
+++ b/tests/utils/test_version.py
@@ -9,6 +9,8 @@ import pytest
 
 from vllm_omni.version import warn_if_misaligned_vllm_version
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 @mock.patch("vllm_omni.version.__version_tuple__", (0, 19, 0))
 @mock.patch("vllm_omni.version.__version__", "0.19.0")
diff --git a/tests/worker/test_capture_replay_contract.py b/tests/worker/test_capture_replay_contract.py
new file mode 100644
index 000000000..504aaa7b0
--- /dev/null
+++ b/tests/worker/test_capture_replay_contract.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Static coupling check for the ``has_preprocess`` capture/replay buffers.
+
+For models with ``has_preprocess``, CUDA-graph *capture* (``_dummy_run``) and
+*replay* (``_preprocess``) MUST read from the same pre-allocated buffers
+(``self.input_ids.gpu`` + ``self.inputs_embeds.gpu``); otherwise replay reads a
+buffer capture never wrote and produces garbage. This is a source-level check
+(no GPU) that catches a one-sided edit to either branch.
+
+The check is AST-scoped: it inspects ONLY the body of the ``has_preprocess``
+guarded branch (not a line window), so a buffer read removed from that branch
+cannot be masked by an adjacent ``else``/``elif`` that happens to read it. It
+matches by attribute chain (``self.input_ids.gpu``), so local variable renames
+do not break it.
+
+Scope: the BASE runner (``OmniGPUModelRunner``) only. The generation runner is
+KNOWN to lack the ``has_preprocess`` branch; extend this
+check to the generation file when it adds the branch.
+"""
+
+import ast
+import inspect
+import textwrap
+
+import pytest
+
+from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_REQUIRED_BUFFERS = {"self.input_ids.gpu", "self.inputs_embeds.gpu"}
+
+
+def _attr_chain(node: ast.AST) -> str | None:
+    """Reconstruct a dotted ``self.x.y`` chain from an ast.Attribute node."""
+    parts: list[str] = []
+    cur = node
+    while isinstance(cur, ast.Attribute):
+        parts.append(cur.attr)
+        cur = cur.value
+    if isinstance(cur, ast.Name):
+        parts.append(cur.id)
+        return ".".join(reversed(parts))
+    return None
+
+
+def _attr_chains_in(nodes: list[ast.stmt]) -> set[str]:
+    chains: set[str] = set()
+    for stmt in nodes:
+        for inner in ast.walk(stmt):
+            if isinstance(inner, ast.Attribute):
+                chain = _attr_chain(inner)
+                if chain is not None:
+                    chains.add(chain)
+    return chains
+
+
+def _has_preprocess_branch_reads_both_buffers(method) -> bool:
+    """True iff SOME ``if has_preprocess:`` branch body reads BOTH buffers.
+
+    Only the guarded branch's own ``body`` is inspected (elif/else excluded),
+    which is what makes a one-sided buffer removal fail.
+    """
+    src = textwrap.dedent(inspect.getsource(method))
+    tree = ast.parse(src)
+    guarded = [node for node in ast.walk(tree) if isinstance(node, ast.If) and "has_preprocess" in ast.dump(node.test)]
+    assert guarded, f"{method.__qualname__}: has_preprocess branch removed entirely"
+    return any(_REQUIRED_BUFFERS <= _attr_chains_in(node.body) for node in guarded)
+
+
+@pytest.mark.parametrize("method_name", ["_dummy_run", "_preprocess"])
+def test_has_preprocess_branch_reads_shared_buffers(method_name):
+    method = getattr(OmniGPUModelRunner, method_name)
+    assert _has_preprocess_branch_reads_both_buffers(method), (
+        f"{OmniGPUModelRunner.__name__}.{method_name}: the has_preprocess branch no "
+        "longer reads BOTH self.input_ids.gpu and self.inputs_embeds.gpu — capture "
+        "and replay would diverge."
+    )
diff --git a/tests/worker/test_fa3_scheduler_metadata_size.py b/tests/worker/test_fa3_scheduler_metadata_size.py
new file mode 100644
index 000000000..5e308bed7
--- /dev/null
+++ b/tests/worker/test_fa3_scheduler_metadata_size.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Characterization of ``OmniGPUModelRunner.initialize_metadata_builders``.
+
+Upstream ``FlashAttentionMetadataBuilder`` pre-allocates ``scheduler_metadata``
+for only ``max_num_seqs + 1`` entries, but FA3 with split scheduling
+(``max_num_splits > 1``) may need ``max_num_seqs * max_num_splits + 1`` during
+CUDA-graph capture. ``OmniGPUModelRunner`` re-sizes the buffer up to that
+requirement after upstream init — this test pins that Omni-specific workaround
+exactly.
+
+It drives the Omni runner's OWN method (with the upstream ``super()`` call
+stubbed and a fake builder standing in), so a change to the resize is caught and
+a failure is unambiguously an Omni-runner regression. Pure CPU — no model, no
+CUDA, no flashinfer.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# The class ``super().initialize_metadata_builders`` dispatches to.
+_UPSTREAM_RUNNER = OmniGPUModelRunner.__mro__[1]
+
+
+def _builder(*, prealloc: int | None, max_num_splits: int) -> SimpleNamespace:
+    sm = None if prealloc is None else torch.zeros(prealloc, dtype=torch.int32)
+    return SimpleNamespace(scheduler_metadata=sm, max_num_splits=max_num_splits)
+
+
+def _make_runner(monkeypatch, *, max_num_seqs: int, builders: list) -> OmniGPUModelRunner:
+    # Stub the upstream initialize_metadata_builders; our fake runner already
+    # carries the attn_groups the Omni override iterates over.
+    monkeypatch.setattr(_UPSTREAM_RUNNER, "initialize_metadata_builders", lambda self, *a, **k: None)
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.scheduler_config = SimpleNamespace(max_num_seqs=max_num_seqs)
+    runner.cache_config = SimpleNamespace(enable_prefix_caching=False)  # skip omni_prefix_cache branch
+    runner.attn_groups = [[SimpleNamespace(metadata_builders=builders)]]
+    return runner
+
+
+def test_resizes_up_when_split_scheduling_needs_more(monkeypatch):
+    max_num_seqs, splits, prealloc = 32, 4, 33  # 33 == upstream default (max_num_seqs + 1)
+    builder = _builder(prealloc=prealloc, max_num_splits=splits)
+    runner = _make_runner(monkeypatch, max_num_seqs=max_num_seqs, builders=[builder])
+
+    OmniGPUModelRunner.initialize_metadata_builders(runner, None, None)
+
+    assert builder.scheduler_metadata.shape[0] == max_num_seqs * splits + 1
+    assert builder.scheduler_metadata.dtype == torch.int32
+
+
+def test_no_resize_when_not_split_scheduling(monkeypatch):
+    builder = _builder(prealloc=33, max_num_splits=1)  # max_num_splits <= 1 -> workaround skipped
+    runner = _make_runner(monkeypatch, max_num_seqs=32, builders=[builder])
+    original = builder.scheduler_metadata
+
+    OmniGPUModelRunner.initialize_metadata_builders(runner, None, None)
+
+    assert builder.scheduler_metadata is original  # untouched
+
+
+def test_no_resize_when_prealloc_already_sufficient(monkeypatch):
+    max_num_seqs, splits = 32, 4
+    builder = _builder(prealloc=max_num_seqs * splits + 1, max_num_splits=splits)  # already big enough
+    runner = _make_runner(monkeypatch, max_num_seqs=max_num_seqs, builders=[builder])
+    original = builder.scheduler_metadata
+
+    OmniGPUModelRunner.initialize_metadata_builders(runner, None, None)
+
+    assert builder.scheduler_metadata is original
+
+
+def test_no_crash_when_builder_has_no_scheduler_metadata(monkeypatch):
+    builder = _builder(prealloc=None, max_num_splits=4)  # scheduler_metadata is None
+    runner = _make_runner(monkeypatch, max_num_seqs=32, builders=[builder])
+
+    OmniGPUModelRunner.initialize_metadata_builders(runner, None, None)
+
+    assert builder.scheduler_metadata is None
diff --git a/tests/worker/test_gpu_ar_model_runner.py b/tests/worker/test_gpu_ar_model_runner.py
index 90cf3afe1..116b5ee4d 100644
--- a/tests/worker/test_gpu_ar_model_runner.py
+++ b/tests/worker/test_gpu_ar_model_runner.py
@@ -1,10 +1,18 @@
+import asyncio
+import copy
 from collections.abc import Sequence
 from types import SimpleNamespace
 
 import numpy as np
 import pytest
 import torch
+from vllm.sampling_params import SamplingParams
+from vllm.v1.worker import gpu_input_batch
+from vllm.v1.worker.gpu_input_batch import CachedRequestState, InputBatch
 
+from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+from vllm_omni.entrypoints.openai.serving_speech import OmniOpenAIServingSpeech
+from vllm_omni.entrypoints.openai.tts_adapters.base import PreparedRequest
 from vllm_omni.outputs import OmniModelRunnerOutput
 from vllm_omni.worker.gpu_ar_model_runner import (
     ExecuteModelState,
@@ -25,6 +33,236 @@ def _make_runner(engine_output_type: str | None, downstream_req_ids: set[str]) -
     return runner
 
 
+def _mtp_runner(*, async_scheduling: bool, buffers: dict[str, dict]) -> tuple[GPUARModelRunner, dict[str, object]]:
+    received: dict[str, object] = {}
+
+    def post_sample_talker_mtp(*, input_ids, hidden_states, req_ids, req_infos):
+        received.update(
+            input_ids=input_ids.clone(),
+            hidden_states=hidden_states.clone(),
+            req_ids=list(req_ids),
+            req_infos=copy.deepcopy(req_infos),
+        )
+        return torch.tensor([[11, 12, 13]], dtype=torch.long)
+
+    runner = object.__new__(GPUARModelRunner)
+    runner.use_async_scheduling = async_scheduling
+    runner.model = SimpleNamespace(post_sample_talker_mtp=post_sample_talker_mtp)
+    runner.requests = {req_id: SimpleNamespace() for req_id in buffers}
+    runner.model_intermediate_buffer = buffers
+    return runner, received
+
+
+def test_post_sample_talker_mtp_uses_current_sample_and_hidden() -> None:
+    runner, received = _mtp_runner(
+        async_scheduling=False,
+        buffers={
+            "ready": {"duplex": {"data_plane": True}},
+            "partial-prefill": {
+                "duplex": {"data_plane": True},
+                "codes": {"audio": torch.tensor([[99]])},
+            },
+            "offline": {},
+        },
+    )
+
+    multimodal = GPUARModelRunner._run_post_sample_talker_mtp(
+        runner,
+        req_ids=["ready", "partial-prefill", "offline"],
+        valid_sampled_token_ids=[[101], [], [102]],
+        sampled_token_ids=torch.tensor([[101], [0], [102]], dtype=torch.long),
+        invalid_req_indices=[],
+        sample_hidden_states=torch.tensor(
+            [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]],
+        ),
+        multimodal_outputs={
+            "codes": {
+                "audio": torch.tensor(
+                    [[70, 71, 72], [80, 81, 82], [90, 91, 92]],
+                    dtype=torch.long,
+                )
+            },
+            "meta": {"source": "temporal"},
+        },
+    )
+
+    assert received["req_ids"] == ["ready"]
+    assert received["input_ids"].tolist() == [101]
+    assert received["hidden_states"].tolist() == [[1.0, 2.0]]
+    assert received["req_infos"] == [{"duplex": {"data_plane": True}}]
+    assert runner.model_intermediate_buffer["ready"]["codes"]["audio"].tolist() == [[11, 12, 13]]
+    # A partial-prefill row has no sampled token yet. It must not replay the
+    # prior frame's codes into the current connector payload.
+    audio = multimodal["codes"]["audio"]
+    assert audio[0].tolist() == [[11, 12, 13]]
+    assert audio[1].numel() == 0
+    # Mixed batches must retain outputs produced by non-duplex rows.
+    assert audio[2].tolist() == [[90, 91, 92]]
+    assert multimodal["meta"] == {"source": "temporal"}
+
+
+def test_post_sample_talker_mtp_uses_gpu_token_with_async_scheduling() -> None:
+    runner, received = _mtp_runner(
+        async_scheduling=True,
+        buffers={
+            "ready": {"duplex": {"data_plane": True}},
+            "discarded-prefill": {"duplex": {"data_plane": True}},
+        },
+    )
+
+    multimodal = GPUARModelRunner._run_post_sample_talker_mtp(
+        runner,
+        req_ids=["ready", "discarded-prefill"],
+        valid_sampled_token_ids=[],
+        sampled_token_ids=torch.tensor([[101], [102]], dtype=torch.long),
+        invalid_req_indices=[1],
+        sample_hidden_states=torch.tensor(
+            [[1.0, 2.0], [3.0, 4.0]],
+        ),
+        multimodal_outputs=None,
+    )
+
+    assert received["req_ids"] == ["ready"]
+    assert received["input_ids"].tolist() == [101]
+    assert received["hidden_states"].tolist() == [[1.0, 2.0]]
+    assert received["req_infos"] == [{"duplex": {"data_plane": True}}]
+    assert multimodal["codes"]["audio"][0].tolist() == [[11, 12, 13]]
+    assert multimodal["codes"]["audio"][1].numel() == 0
+
+
+def test_post_sample_talker_mtp_skips_shape_validation_without_duplex_rows() -> None:
+    runner = object.__new__(GPUARModelRunner)
+    runner.use_async_scheduling = False
+    runner.model = SimpleNamespace(
+        post_sample_talker_mtp=lambda **_: pytest.fail("hook must not run"),
+    )
+    runner.model_intermediate_buffer = {"offline": {}}
+    multimodal = {"codes": {"audio": torch.tensor([[7, 8]], dtype=torch.long)}}
+
+    result = GPUARModelRunner._run_post_sample_talker_mtp(
+        runner,
+        req_ids=["offline"],
+        valid_sampled_token_ids=[[101, 102]],
+        sampled_token_ids=torch.tensor([[101, 102]], dtype=torch.long),
+        invalid_req_indices=[],
+        sample_hidden_states=torch.tensor([[1.0, 2.0]]),
+        multimodal_outputs=multimodal,
+    )
+
+    assert result is multimodal
+
+
+@pytest.mark.parametrize(
+    ("sampled_token_ids", "error_match"),
+    [
+        (torch.tensor([101], dtype=torch.long), "rows do not match requests"),
+        (
+            torch.tensor([[101, 102]], dtype=torch.long),
+            "does not support speculative token rows",
+        ),
+    ],
+)
+def test_post_sample_talker_mtp_rejects_invalid_selected_token_shape(
+    sampled_token_ids: torch.Tensor,
+    error_match: str,
+) -> None:
+    runner = object.__new__(GPUARModelRunner)
+    runner.use_async_scheduling = False
+    runner.model = SimpleNamespace(
+        post_sample_talker_mtp=lambda **_: pytest.fail("hook must not run"),
+    )
+    runner.model_intermediate_buffer = {
+        "duplex": {"duplex": {"data_plane": True}},
+    }
+
+    with pytest.raises(ValueError, match=error_match):
+        GPUARModelRunner._run_post_sample_talker_mtp(
+            runner,
+            req_ids=["duplex"],
+            valid_sampled_token_ids=[[101]],
+            sampled_token_ids=sampled_token_ids,
+            invalid_req_indices=[],
+            sample_hidden_states=torch.tensor([[1.0, 2.0]]),
+            multimodal_outputs=None,
+        )
+
+
+def test_speech_extra_params_reach_model_sampler_as_sampling_metadata(monkeypatch):
+    requested = {"temperature": 0.7, "top_p": 0.8, "top_k": 17}
+    request = OpenAICreateSpeechRequest.model_validate(
+        {"input": "Hello", "extra_params": requested},
+    )
+
+    class Adapter:
+        def validate(self, request):
+            return None
+
+        async def build(self, request, sampling_params_list, has_inline_ref_audio):
+            return PreparedRequest(prompt={"prompt": request.input}, tts_params={}, model_type="higgs_audio_v3")
+
+    engine = SimpleNamespace(
+        errored=False,
+        default_sampling_params_list=[SamplingParams(temperature=1.0, top_p=0.95, top_k=50)],
+        generate=lambda **kwargs: kwargs["sampling_params_list"],
+    )
+    serving = object.__new__(OmniOpenAIServingSpeech)
+    serving.engine_client = engine
+    serving.model_config = SimpleNamespace(async_chunk=True)
+    serving._tts_model_type = "higgs_audio_v3"
+    serving._get_tts_adapter = lambda: Adapter()
+    serving._track_ref_audio_artifact_warmup = lambda *args, **kwargs: None
+
+    _, stage_sampling_params, _ = asyncio.run(serving._prepare_speech_generation(request, request_id="speech-test"))
+    stage0_params = stage_sampling_params[0]
+
+    monkeypatch.setattr(gpu_input_batch, "PIN_MEMORY", False)
+    input_batch = InputBatch(
+        max_num_reqs=1,
+        max_model_len=8,
+        max_num_batched_tokens=8,
+        device=torch.device("cpu"),
+        vocab_size=1024,
+        block_sizes=[1],
+        kernel_block_sizes=[1],
+        # vLLM 0.26: one entry per KV cache group; max_model_len=8 with
+        # block_sizes=[1] means one group of 8 blocks.
+        max_num_blocks_per_req=[8],
+    )
+    input_batch.add_request(
+        CachedRequestState(
+            req_id="speech-test",
+            prompt_token_ids=[1],
+            mm_features=[],
+            sampling_params=stage0_params,
+            generator=None,
+            block_ids=([],),
+            num_computed_tokens=0,
+            output_token_ids=[],
+        )
+    )
+    input_batch.sampling_metadata = input_batch._make_sampling_metadata()
+
+    received = []
+    runner = object.__new__(GPUARModelRunner)
+    runner.input_batch = input_batch
+    runner.model = SimpleNamespace(
+        prefer_model_sampler=True,
+        skips_model_sampler_output_token_history=True,
+        sample=lambda logits, metadata: received.append(metadata) or "model-sampler",
+    )
+    runner.sampler = SimpleNamespace()
+    logits = torch.zeros((1, 4))
+
+    output = runner._sample(logits, spec_decode_metadata=None)
+
+    assert output == "model-sampler"
+    assert len(received) == 1
+    sampling_metadata = received[0]
+    torch.testing.assert_close(sampling_metadata.temperature, torch.tensor([requested["temperature"]]))
+    torch.testing.assert_close(sampling_metadata.top_p, torch.tensor([requested["top_p"]]))
+    assert sampling_metadata.top_k.tolist() == [requested["top_k"]]
+
+
 def test_resolve_pooler_payload_req_ids_audio_terminal_stage_keeps_payload():
     runner = _make_runner(engine_output_type="audio", downstream_req_ids=set())
 
@@ -663,6 +901,7 @@ def test_sample_tokens_tail_only_prefix_cache_uses_staged_cpu_hidden_states(monk
     # inter_stage_outputs mirrors multimodal_outputs (PR #4792).
     assert output.inter_stage_outputs is not None
     assert output.multimodal_outputs is not None
+    assert output.inter_stage_outputs is output.multimodal_outputs
     assert torch.equal(output.inter_stage_outputs[0]["hidden"], output.multimodal_outputs[0]["hidden"])
     assert torch.equal(output.inter_stage_outputs[1]["hidden"], output.multimodal_outputs[1]["hidden"])
     assert torch.equal(output.multimodal_outputs[0]["hidden"], torch.tensor([[1.0, 10.0]]))
@@ -721,3 +960,231 @@ def test_build_omni_output_falls_back_to_mm_cpu_without_prefix_merge(monkeypatch
     assert torch.equal(output.inter_stage_outputs[0]["codes.audio"], codes[0:1])
     assert torch.equal(output.inter_stage_outputs[1]["codes.audio"], codes[1:2])
     assert output.multimodal_outputs is None
+
+
+# --- builder gap-fill: contract corners not covered by the tests above ---
+def test_build_omni_output_never_leaks_internal_pooler_output_on_wire(monkeypatch):
+    """The internal pooler_output feeds full-payload accumulation only; the wire
+    object's ``pooler_output`` is always None (builder NOTE at gpu_ar:1738)."""
+    runner = _make_async_output_runner()
+
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_resolve_pooler_payload_req_ids",
+        lambda self, req_ids: ("audio", req_ids),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_should_accumulate_full_payload_output", lambda self: True)
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "accumulate_full_payload_output",
+        lambda self, rid, payload, request: None,
+    )
+    monkeypatch.setattr(GPUARModelRunner, "get_omni_connector_output", lambda self: None)
+
+    output = GPUARModelRunner._build_omni_model_runner_output_from_snapshot(
+        runner,
+        scheduler_output=SimpleNamespace(
+            total_num_scheduled_tokens=3,
+            num_scheduled_tokens={"r1": 1, "r2": 2},
+        ),
+        hidden_states=torch.tensor([[1.0], [2.0], [3.0]]),
+        staged_hidden_states_cpu=None,
+        multimodal_outputs={"foo": torch.tensor([10.0, 20.0, 30.0])},
+        req_ids_output_copy=["r1", "r2"],
+        req_id_to_index_output_copy={"r1": 0, "r2": 1},
+        valid_sampled_token_ids=[[101], [102]],
+        logprobs_lists=None,
+        prompt_logprobs_dict={},
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        ec_connector_output=None,
+        cudagraph_stats=None,
+        kv_extracted_req_ids=None,
+        num_scheduled_tokens_np=np.array([1, 2], dtype=np.int32),
+        query_start_loc_cpu=torch.tensor([0, 1], dtype=torch.long),
+    )
+
+    assert output.pooler_output is None
+
+
+def test_build_omni_output_splits_client_mm_from_inter_stage_keys(monkeypatch):
+    """The inter-stage vs client-mm partition: a client-root key ("audio") lands in
+    ``multimodal_outputs`` while inter-stage keys ("hidden") stay in
+    ``inter_stage_outputs`` (partition_flat_payload / _CLIENT_MM_ROOT_KEYS)."""
+    runner = _make_async_output_runner()
+
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_resolve_pooler_payload_req_ids",
+        lambda self, req_ids: ("audio", req_ids),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_should_accumulate_full_payload_output", lambda self: False)
+    monkeypatch.setattr(GPUARModelRunner, "get_omni_connector_output", lambda self: None)
+
+    output = GPUARModelRunner._build_omni_model_runner_output_from_snapshot(
+        runner,
+        scheduler_output=SimpleNamespace(
+            total_num_scheduled_tokens=3,
+            num_scheduled_tokens={"r1": 1, "r2": 2},
+        ),
+        hidden_states=torch.tensor([[1.0], [2.0], [3.0]]),
+        staged_hidden_states_cpu=None,
+        # "audio" root is a client mm key; "codes.audio" root ("codes") is inter-stage.
+        multimodal_outputs={"audio": torch.tensor([10.0, 20.0, 30.0])},
+        req_ids_output_copy=["r1", "r2"],
+        req_id_to_index_output_copy={"r1": 0, "r2": 1},
+        valid_sampled_token_ids=[[101], [102]],
+        logprobs_lists=None,
+        prompt_logprobs_dict={},
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        ec_connector_output=None,
+        cudagraph_stats=None,
+        kv_extracted_req_ids=None,
+        num_scheduled_tokens_np=np.array([1, 2], dtype=np.int32),
+        query_start_loc_cpu=torch.tensor([0, 1], dtype=torch.long),
+    )
+
+    # Client mm key routed to the wire multimodal_outputs, per request.
+    assert output.multimodal_outputs is not None
+    assert "audio" in output.multimodal_outputs[0]
+    # Inter-stage hidden stayed on inter_stage_outputs and did NOT leak to client.
+    assert output.inter_stage_outputs is not None
+    assert "hidden" in output.inter_stage_outputs[0]
+    assert "audio" not in output.inter_stage_outputs[0]
+
+
+def test_build_omni_output_filters_multimodal_by_partial_downstream_batch(monkeypatch):
+    """When only a subset of req_ids_output_copy need the downstream
+    pooler payload, multimodal_outputs (not just hidden_states, which
+    test_build_omni_output_copies_hidden_for_partial_downstream_batch
+    already covers) must be attached only to the downstream requests, in
+    the right per-request slot -- a skipped middle request must not shift
+    a later request's slice onto the wrong index."""
+    runner = _make_async_output_runner(engine_output_type="latent")
+    runner.requests = {"r1": object(), "r2": object(), "r3": object()}
+    runner.omni_prefix_cache = object()
+
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_resolve_pooler_payload_req_ids",
+        lambda self, req_ids: ("latent", ["r1", "r3"]),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
+    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: {"codes.audio"})
+    monkeypatch.setattr(GPUARModelRunner, "_stage_deferred_prefix_cache_mm_outputs", lambda *args, **kwargs: None)
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_prepare_prefix_cache_pooler_payload_sources",
+        lambda *args, **kwargs: (None, None, None),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_process_additional_information_updates", lambda *args, **kwargs: None)
+    monkeypatch.setattr(GPUARModelRunner, "_should_accumulate_full_payload_output", lambda self: False)
+    monkeypatch.setattr(GPUARModelRunner, "get_omni_connector_output", lambda self: None)
+
+    codes = torch.tensor([[11.0, 12.0], [21.0, 22.0], [31.0, 32.0]], dtype=torch.float32)
+    output = GPUARModelRunner._build_omni_model_runner_output_from_snapshot(
+        runner,
+        scheduler_output=SimpleNamespace(
+            total_num_scheduled_tokens=3,
+            num_scheduled_tokens={"r1": 1, "r2": 1, "r3": 1},
+        ),
+        hidden_states=torch.tensor([[1.0], [2.0], [3.0]]),
+        staged_hidden_states_cpu=None,
+        multimodal_outputs={"codes.audio": codes},
+        req_ids_output_copy=["r1", "r2", "r3"],
+        req_id_to_index_output_copy={"r1": 0, "r2": 1, "r3": 2},
+        valid_sampled_token_ids=[[], [], []],
+        logprobs_lists=None,
+        prompt_logprobs_dict={},
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        ec_connector_output=None,
+        cudagraph_stats=None,
+        kv_extracted_req_ids=None,
+        num_scheduled_tokens_np=np.array([1, 1, 1], dtype=np.int32),
+        query_start_loc_cpu=torch.tensor([0, 1, 2], dtype=torch.long),
+    )
+
+    # Exact indices pin the mapping: r3 keeps slot 2 rather than shifting into
+    # the skipped r2's slot.
+    assert torch.equal(output.inter_stage_outputs[0]["codes.audio"], codes[0:1])
+    assert output.inter_stage_outputs[1] is None
+    assert torch.equal(output.inter_stage_outputs[2]["codes.audio"], codes[2:3])
+
+
+def test_build_omni_output_uses_combined_prefix_cache_mm_payload_for_partial_downstream_batch(monkeypatch):
+    """When the prefix-cache merge path is engaged (i.e.
+    _prepare_prefix_cache_pooler_payload_sources returns a non-None
+    combined_multimodal_outputs), _build_omni_mm_payload must take the
+    _build_combined_prefix_cache_mm_payload branch -- keyed by req_id,
+    not by row/slice -- rather than falling back to build_mm_cpu, and
+    must still map correctly onto a partial downstream batch. This is a
+    distinct code path from test_build_omni_output_filters_multimodal_by_partial_downstream_batch,
+    which only exercises the no-prefix-cache-merge (mm_cpu) fallback.
+
+    The merge itself is stubbed out here; what this pins is the branch selection
+    plus _unwrap_lists' batch-index selection for a list-valued key.
+    """
+    runner = _make_async_output_runner(engine_output_type="latent")
+    runner.requests = {"r1": object(), "r2": object(), "r3": object()}
+    runner.omni_prefix_cache = object()
+
+    # codes.ref arrives whole for every request: the prefix-cache merge uses
+    # pass_lists_through, so selecting this request's entry is _unwrap_lists'
+    # job, and it selects by batch index (r3 -> 2), not by downstream position.
+    ref_codes = [torch.tensor([1]), torch.tensor([2]), torch.tensor([3])]
+    combined_mm = {
+        "codes.audio": {
+            "r1": torch.tensor([[11.0, 12.0]]),
+            "r3": torch.tensor([[31.0, 32.0]]),
+        },
+        "codes.ref": {"r1": list(ref_codes), "r3": list(ref_codes)},
+    }
+
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_resolve_pooler_payload_req_ids",
+        lambda self, req_ids: ("latent", ["r1", "r3"]),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_model_needs_full_prefix_hidden_states", lambda self: False)
+    monkeypatch.setattr(GPUARModelRunner, "_deferred_prefix_cache_mm_keys", lambda self: {"codes.audio"})
+    monkeypatch.setattr(GPUARModelRunner, "_stage_deferred_prefix_cache_mm_outputs", lambda *args, **kwargs: None)
+    monkeypatch.setattr(
+        GPUARModelRunner,
+        "_prepare_prefix_cache_pooler_payload_sources",
+        lambda *args, **kwargs: (None, None, combined_mm),
+    )
+    monkeypatch.setattr(GPUARModelRunner, "_process_additional_information_updates", lambda *args, **kwargs: None)
+    monkeypatch.setattr(GPUARModelRunner, "_should_accumulate_full_payload_output", lambda self: False)
+    monkeypatch.setattr(GPUARModelRunner, "get_omni_connector_output", lambda self: None)
+
+    output = GPUARModelRunner._build_omni_model_runner_output_from_snapshot(
+        runner,
+        scheduler_output=SimpleNamespace(
+            total_num_scheduled_tokens=3,
+            num_scheduled_tokens={"r1": 1, "r2": 1, "r3": 1},
+        ),
+        hidden_states=torch.tensor([[1.0], [2.0], [3.0]]),
+        staged_hidden_states_cpu=None,
+        multimodal_outputs={},
+        req_ids_output_copy=["r1", "r2", "r3"],
+        req_id_to_index_output_copy={"r1": 0, "r2": 1, "r3": 2},
+        valid_sampled_token_ids=[[], [], []],
+        logprobs_lists=None,
+        prompt_logprobs_dict={},
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        ec_connector_output=None,
+        cudagraph_stats=None,
+        kv_extracted_req_ids=None,
+        num_scheduled_tokens_np=np.array([1, 1, 1], dtype=np.int32),
+        query_start_loc_cpu=torch.tensor([0, 1, 2], dtype=torch.long),
+    )
+
+    assert torch.equal(output.inter_stage_outputs[0]["codes.audio"], combined_mm["codes.audio"]["r1"])
+    assert output.inter_stage_outputs[1] is None
+    assert torch.equal(output.inter_stage_outputs[2]["codes.audio"], combined_mm["codes.audio"]["r3"])
+
+    assert torch.equal(output.inter_stage_outputs[0]["codes.ref"], ref_codes[0])
+    assert torch.equal(output.inter_stage_outputs[2]["codes.ref"], ref_codes[2])
diff --git a/tests/worker/test_gpu_generation_model_runner.py b/tests/worker/test_gpu_generation_model_runner.py
index 0cd9aeb26..a6df4732f 100644
--- a/tests/worker/test_gpu_generation_model_runner.py
+++ b/tests/worker/test_gpu_generation_model_runner.py
@@ -1,6 +1,12 @@
+import contextlib
+from types import SimpleNamespace
+
 import pytest
 import torch
+from vllm.config import CacheConfig
+from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT
 
+import vllm_omni.worker.gpu_generation_model_runner as gen_runner_module
 from vllm_omni.worker.gpu_generation_model_runner import (
     ExecuteModelState,
     GPUGenerationModelRunner,
@@ -84,3 +90,40 @@ def test_sample_tokens_dict_output():
     assert "audio" in output.multimodal_outputs[0]
     assert "unused" not in output.multimodal_outputs[0]
     assert output.multimodal_outputs[0]["audio"].shape == (1, 4)
+
+
+class _StubSchedulerOutput:
+    def __init__(self, total_num_scheduled_tokens):
+        self.total_num_scheduled_tokens = total_num_scheduled_tokens
+        self.num_scheduled_tokens = {"req-1": total_num_scheduled_tokens}
+        self.finished_req_ids = set()
+        self.kv_connector_metadata = None
+
+
+def _make_guard_runner():
+    # Stubbed far enough that a span escaping the guard reaches the real
+    # `_prepare_inputs`, i.e. fails the way the reported crash does.
+    runner = object.__new__(GPUGenerationModelRunner)
+    runner.execute_model_state = None
+    runner.routed_experts_initialized = False
+    runner.speculative_config = None
+    runner.model_config = SimpleNamespace(async_chunk=False)
+    runner.cache_config = CacheConfig()
+    runner.input_batch = _DummyInputBatch()
+    runner.model = object()
+    runner._update_states = lambda scheduler_output: None
+    runner.synchronize_input_prep = contextlib.nullcontext
+    runner.attach_omni_connector_output = lambda result: result
+    return runner
+
+
+@pytest.mark.parametrize("total", [-1, -512, 0])
+def test_execute_model_skips_non_positive_scheduled_span(monkeypatch, total):
+    """#5196: a negative span is truthy, so it used to reach `_prepare_inputs`,
+    whose `assert total_num_scheduled_tokens > 0` killed the stage EngineCore."""
+    monkeypatch.setattr(gen_runner_module, "has_kv_transfer_group", lambda: False)
+    runner = _make_guard_runner()
+
+    output = GPUGenerationModelRunner.execute_model(runner, _StubSchedulerOutput(total))
+
+    assert output is EMPTY_MODEL_RUNNER_OUTPUT
diff --git a/tests/worker/test_memory_utils.py b/tests/worker/test_memory_utils.py
new file mode 100644
index 000000000..672fa4648
--- /dev/null
+++ b/tests/worker/test_memory_utils.py
@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Characterization tests for ``vllm_omni.worker.memory_utils``.
+
+``request_memory_tolerant`` is still live in both workers
+(``gpu_ar_worker.py`` / ``gpu_generation_worker.py``); a later change makes its cap loud
+but must not change the numeric contract. These tests pin that contract with a
+mocked ``MemorySnapshot`` — pure CPU, no GPU / NVML.
+"""
+
+import math
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.worker.memory_utils import request_memory_tolerant
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+GIB = 1024**3
+
+
+def _snapshot(total: int, free: int) -> SimpleNamespace:
+    # Only the fields request_memory_tolerant reads (incl. device_ for the log).
+    return SimpleNamespace(total_memory=total, free_memory=free, device_="cuda:0")
+
+
+def _cache_config(util: float) -> SimpleNamespace:
+    return SimpleNamespace(gpu_memory_utilization=util)
+
+
+def test_passes_through_requested_when_free_suffices():
+    snap = _snapshot(total=40 * GIB, free=40 * GIB)
+    cfg = _cache_config(0.5)
+
+    out = request_memory_tolerant(snap, cfg)
+
+    assert out == math.ceil(40 * GIB * 0.5)
+
+
+def test_caps_to_free_when_insufficient():
+    cfg = _cache_config(0.9)
+    requested = math.ceil(40 * GIB * 0.9)
+    snap = _snapshot(total=40 * GIB, free=10 * GIB)  # free < requested
+
+    out = request_memory_tolerant(snap, cfg)
+
+    assert out == 10 * GIB
+    assert out < requested
+
+
+def test_boundary_free_equals_requested_is_not_capped():
+    util = 0.5
+    total = 40 * GIB
+    requested = math.ceil(total * util)
+    snap = _snapshot(total=total, free=requested)  # strict `<`, so no cap at equality
+
+    out = request_memory_tolerant(snap, _cache_config(util))
+
+    assert out == requested
+
+
+def test_requested_uses_ceil_of_total_times_util():
+    # 7 GiB * 0.3333... rounds UP (math.ceil), not down.
+    total = 7 * GIB
+    util = 1 / 3
+    snap = _snapshot(total=total, free=total)
+
+    out = request_memory_tolerant(snap, _cache_config(util))
+
+    assert out == math.ceil(total * util)
diff --git a/tests/worker/test_native_duplex_hooks.py b/tests/worker/test_native_duplex_hooks.py
new file mode 100644
index 000000000..383379202
--- /dev/null
+++ b/tests/worker/test_native_duplex_hooks.py
@@ -0,0 +1,2468 @@
+from __future__ import annotations
+
+import inspect
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _minicpmo_duplex_policy_case(
+    state: SimpleNamespace,
+    payload: dict[str, object],
+):
+    from vllm_omni.experimental.fullduplex.model_executor import DuplexSamplingRow
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    session_key = ("sid-policy", 1)
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model._minicpmo45_native_duplex_token_ids_cache = {
+        "listen_token_id": 7,
+        "tts_bos_token_id": 8,
+        "turn_eos_token_id": 9,
+    }
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
+    row = DuplexSamplingRow(
+        row_idx=0,
+        request_id="req-policy",
+        session_id=session_key[0],
+        incarnation=session_key[1],
+        seq=3,
+        payload=payload,
+        max_tokens=20,
+    )
+    return model, row
+
+
+def test_minicpmo_model_hook_owns_duplex_sampling_rows_and_force_listen():
+    from vllm_omni.experimental.fullduplex.model_executor import DuplexSamplingRow
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    listen_id = 7
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=None,
+        pending_terminator_token=None,
+    )
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model._minicpmo45_native_duplex_token_ids_cache = {
+        "listen_token_id": listen_id,
+        "tts_bos_token_id": 8,
+        "turn_eos_token_id": 9,
+    }
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={("sid-hook", 2): state})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    row = DuplexSamplingRow(
+        row_idx=0,
+        request_id="req-hook",
+        session_id="sid-hook",
+        incarnation=2,
+        seq=3,
+        payload={"force_listen": True, "is_speech": True},
+        max_tokens=20,
+    )
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert model._minicpmo45_active_duplex_rows == [0]
+    assert model._minicpmo45_duplex_row_sessions == {0: ("sid-hook", 2)}
+    assert model._minicpmo45_duplex_row_payloads == {0: row.payload}
+    assert model._minicpmo45_duplex_row_max_tokens == {0: 20}
+    assert logits[0, listen_id].item() == 0.0
+    assert torch.isneginf(logits[0, :listen_id]).all()
+    assert torch.isneginf(logits[0, listen_id + 1 :]).all()
+
+
+def test_minicpmo_model_hook_turn_end_latch_forces_silence_to_listen():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 10] = 20.0
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert logits[0, 7].item() == 0.0
+    assert torch.isneginf(logits[0, :7]).all()
+    assert torch.isneginf(logits[0, 8:]).all()
+
+
+def test_minicpmo_model_hook_pending_speech_after_turn_eos_allows_silence_sampling():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+        pending_speech_context=True,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert torch.equal(logits, original_logits)
+    assert state.pending_speech_context is True
+
+
+def test_minicpmo_model_hook_speech_row_does_not_create_pending_context():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+        pending_speech_context=False,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": True})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 8] = -2.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert state.current_turn_ended is True
+    assert state.last_terminator_token is None
+    assert state.pending_speech_context is False
+    assert torch.equal(logits, original_logits)
+
+
+def test_minicpmo_model_hook_old_response_output_does_not_clear_pending_speech_context():
+    state = SimpleNamespace(
+        current_turn_ended=False,
+        last_terminator_token=None,
+        pending_terminator_token=None,
+        pending_speech_context=True,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": True})
+    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_payloads = {0: row.payload}
+
+    model._record_minicpmo45_duplex_terminator(
+        0,
+        10,
+        {"listen_token_id": 7, "chunk_eos_token_id": -1, "chunk_tts_eos_token_id": -1, "turn_eos_token_id": 9},
+    )
+
+    assert state.pending_speech_context is True
+    assert state.current_turn_ended is False
+
+
+def test_minicpmo_model_hook_new_response_output_clears_pending_speech_context():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=7,
+        pending_terminator_token=7,
+        pending_speech_context=True,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
+    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_payloads = {0: row.payload}
+
+    model._record_minicpmo45_duplex_terminator(
+        0,
+        8,
+        {"listen_token_id": 7, "chunk_eos_token_id": -1, "chunk_tts_eos_token_id": -1, "turn_eos_token_id": 9},
+    )
+
+    assert state.pending_speech_context is False
+    assert state.current_turn_ended is False
+
+
+def test_minicpmo_model_hook_empty_speak_envelope_preserves_pending_speech_context():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+        pending_speech_context=True,
+        pending_speech_response_open=False,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
+    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_payloads = {0: row.payload}
+    token_ids = {
+        "listen_token_id": 7,
+        "tts_bos_token_id": 8,
+        "chunk_eos_token_id": -1,
+        "chunk_tts_eos_token_id": -1,
+        "turn_eos_token_id": 9,
+    }
+
+    model._record_minicpmo45_duplex_terminator(0, 8, token_ids)
+    model._record_minicpmo45_duplex_terminator(0, 9, token_ids)
+
+    assert state.current_turn_ended is True
+    assert state.pending_speech_context is True
+    assert state.pending_speech_response_open is False
+
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert torch.equal(logits, original_logits)
+
+
+def test_minicpmo_model_hook_second_new_response_step_is_not_forced_to_listen():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+        pending_speech_context=True,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_payloads = {0: row.payload}
+    model._record_minicpmo45_duplex_terminator(
+        0,
+        8,
+        {"listen_token_id": 7, "chunk_eos_token_id": -1, "chunk_tts_eos_token_id": -1, "turn_eos_token_id": 9},
+    )
+    next_logits = torch.zeros((1, 16), dtype=torch.float32)
+    next_logits[0, 7] = 30.0
+    next_logits[0, 10] = 20.0
+    next_original_logits = next_logits.clone()
+
+    model.prepare_duplex_sampling(next_logits, SimpleNamespace(), (row,))
+
+    assert torch.equal(logits, original_logits)
+    assert torch.equal(next_logits, next_original_logits)
+    assert state.pending_speech_context is False
+    assert state.current_turn_ended is False
+
+
+def test_minicpmo_model_hook_same_speech_row_second_step_does_not_rearm_pending_context():
+    state = SimpleNamespace(
+        current_turn_ended=True,
+        last_terminator_token=9,
+        pending_terminator_token=None,
+        pending_speech_context=True,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": True})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 10] = 20.0
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_payloads = {0: row.payload}
+    model._record_minicpmo45_duplex_terminator(
+        0,
+        10,
+        {"listen_token_id": 7, "chunk_eos_token_id": -1, "chunk_tts_eos_token_id": -1, "turn_eos_token_id": 9},
+    )
+    next_logits = torch.zeros((1, 16), dtype=torch.float32)
+    next_logits[0, 7] = 30.0
+    next_logits[0, 8] = -2.0
+    next_logits[0, 10] = 20.0
+    original_next_logits = next_logits.clone()
+
+    model.prepare_duplex_sampling(next_logits, SimpleNamespace(), (row,))
+
+    assert state.pending_speech_context is False
+    assert state.current_turn_ended is False
+    assert torch.equal(next_logits, original_next_logits)
+
+
+def test_minicpmo_model_hook_mid_turn_speech_preserves_logits_for_post_sample_redirect():
+    state = SimpleNamespace(
+        current_turn_ended=False,
+        last_terminator_token=None,
+        pending_terminator_token=None,
+    )
+    model, row = _minicpmo_duplex_policy_case(state, {"is_speech": True})
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 30.0
+    logits[0, 8] = -2.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert torch.equal(logits, original_logits)
+
+
+def test_minicpmo_model_hook_ignores_serving_new_user_turn_marker():
+    state = SimpleNamespace(
+        current_turn_ended=False,
+        last_terminator_token=8,
+        pending_terminator_token=8,
+    )
+    model, row = _minicpmo_duplex_policy_case(
+        state,
+        {"is_speech": True, "new_user_turn": True, "force_speak": True},
+    )
+    logits = torch.zeros((1, 16), dtype=torch.float32)
+    logits[0, 7] = 5.0
+    logits[0, 10] = 20.0
+    original_logits = logits.clone()
+    model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
+
+    assert state.current_turn_ended is False
+    assert state.last_terminator_token is None
+    assert torch.equal(logits, original_logits)
+
+
+def test_generic_ar_runner_builds_typed_duplex_sampling_rows():
+    from vllm_omni.experimental.fullduplex.model_executor import DuplexSamplingHelper
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    runner = GPUARModelRunner.__new__(GPUARModelRunner)
+    runner.input_batch = SimpleNamespace(req_ids=["req-duplex", "req-plain"])
+    runner.model_intermediate_buffer = {
+        "req-duplex": {
+            "duplex": {
+                "data_plane": True,
+                "session_id": "sid-runner-hook",
+                "incarnation": 4,
+                "seq": 4,
+                "payload": {"is_speech": True},
+            }
+        }
+    }
+    runner.requests = {
+        "req-duplex": SimpleNamespace(
+            sampling_params=SimpleNamespace(max_tokens=32),
+        )
+    }
+    helper = DuplexSamplingHelper()
+    helper.active_request_ids = {"req-duplex"}
+
+    rows = helper.rows(runner)
+
+    assert len(rows) == 1
+    assert rows[0].row_idx == 0
+    assert rows[0].request_id == "req-duplex"
+    assert rows[0].session_id == "sid-runner-hook"
+    assert rows[0].incarnation == 4
+    assert rows[0].seq == 4
+    assert rows[0].payload == {"is_speech": True}
+    assert rows[0].max_tokens == 32
+
+
+def test_generic_ar_runner_skips_duplex_rows_without_model_hook():
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    runner = GPUARModelRunner.__new__(GPUARModelRunner)
+    runner.input_batch = SimpleNamespace(
+        sampling_metadata=object(),
+        update_async_output_token_ids=lambda: None,
+    )
+    runner.model = SimpleNamespace(sample=lambda *_args, **_kwargs: None, prefer_model_sampler=False)
+    runner.sampler = lambda **_kwargs: "standard-sampler"
+    runner._duplex_sampling_helper = SimpleNamespace(
+        active_request_ids={"req-duplex"},
+        rows=lambda *_args: pytest.fail("duplex rows built without a model hook"),
+    )
+
+    assert runner._sample(torch.zeros((1, 4)), spec_decode_metadata=None) == "standard-sampler"
+
+
+def test_plain_model_hook_resolution_does_not_allocate_duplex_tracking():
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    runner = GPUARModelRunner.__new__(GPUARModelRunner)
+    runner.model = SimpleNamespace()
+    runner._duplex_sampling_hook = None
+    runner._duplex_sampling_hook_resolved = False
+
+    assert runner._resolve_duplex_sampling_hook() is None
+    assert not hasattr(runner, "_duplex_sampling_helper")
+
+
+def test_minicpmo_non_duplex_sample_skips_duplex_row_scan():
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    calls = []
+    runner = GPUARModelRunner.__new__(GPUARModelRunner)
+    runner.input_batch = SimpleNamespace(
+        sampling_metadata=SimpleNamespace(output_token_ids=[]),
+        update_async_output_token_ids=lambda: None,
+    )
+    runner.model = SimpleNamespace(
+        sample=lambda *_args, **_kwargs: "model-sampler",
+        prefer_model_sampler=True,
+        skips_model_sampler_output_token_history=True,
+        prepare_duplex_sampling=lambda *_args: calls.append("prepare"),
+    )
+    runner.sampler = SimpleNamespace()
+    runner._duplex_sampling_helper = SimpleNamespace(
+        active_request_ids=set(),
+        hook_active=False,
+        rows=lambda *_args: pytest.fail("non-duplex MiniCPM scanned request rows"),
+    )
+
+    assert runner._sample(torch.zeros((1, 4)), spec_decode_metadata=None) == "model-sampler"
+    assert calls == []
+
+
+def test_minicpmo_duplex_sample_clears_stale_rows_once_without_scanning():
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    calls = []
+    runner = GPUARModelRunner.__new__(GPUARModelRunner)
+    runner.input_batch = SimpleNamespace(
+        sampling_metadata=SimpleNamespace(output_token_ids=[]),
+        update_async_output_token_ids=lambda: None,
+    )
+    runner.model = SimpleNamespace(
+        sample=lambda *_args, **_kwargs: "model-sampler",
+        prefer_model_sampler=True,
+        skips_model_sampler_output_token_history=True,
+        prepare_duplex_sampling=lambda _logits, _metadata, rows: calls.append(rows),
+    )
+    runner.sampler = SimpleNamespace()
+    runner._duplex_sampling_helper = SimpleNamespace(
+        active_request_ids=set(),
+        hook_active=True,
+        rows=lambda *_args: pytest.fail("duplex cleanup scanned request rows"),
+    )
+
+    assert runner._sample(torch.zeros((1, 4)), spec_decode_metadata=None) == "model-sampler"
+    assert runner._sample(torch.zeros((1, 4)), spec_decode_metadata=None) == "model-sampler"
+    assert calls == [()]
+
+
+def test_generic_ar_runner_has_no_minicpmo_sampler_state_or_typeerror_probe():
+    from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+    source = inspect.getsource(GPUARModelRunner)
+
+    assert "_minicpmo45_duplex_row" not in source
+    assert "_minicpmo45_native_duplex_token_ids" not in source
+    assert 'if "duplex_rows" not in str(exc)' not in source
+
+
+def test_minicpmo_model_cleans_incarnation_state_when_request_finishes():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    request_id = "duplex-sid-cleanup-i3-e0-stage0"
+    session_key = ("sid-cleanup", 3)
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model = SimpleNamespace()
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: object()})
+    model._minicpmo45_duplex_request_sessions = {request_id: session_key}
+    model._minicpmo45_force_listen_applied_segments = {
+        (request_id, 1),
+        ("duplex-sid-other-e0-stage0", 2),
+    }
+
+    model.on_requests_finished({request_id})
+
+    assert model._minicpmo45_duplex_data_plane_helper.sessions == {}
+    assert model._minicpmo45_duplex_request_sessions == {}
+    assert model._minicpmo45_force_listen_applied_segments == {
+        ("duplex-sid-other-e0-stage0", 2),
+    }
+
+
+def test_minicpmo_stage0_routes_duplex_metadata_per_batched_request():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+    from vllm_omni.utils.mm_outputs import to_payload_element
+
+    class _Thinker(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.register_buffer("device_anchor", torch.zeros(1))
+
+        def forward(self, *, input_ids, **kwargs):
+            del kwargs
+            return torch.arange(input_ids.numel() * 4, dtype=torch.float32).reshape(input_ids.numel(), 4)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    torch.nn.Module.__init__(model)
+    model.model_stage = "llm"
+    model.thinker = _Thinker()
+    output = model.forward(
+        input_ids=torch.tensor([1, 2, 3, 4]),
+        positions=torch.arange(4),
+        runtime_additional_information=[
+            {
+                "global_request_id": ["req-a"],
+                "duplex": {
+                    "duplex_prompt_token_ids": [101, 102],
+                    "special_token_ids": {"listen_token_id": 701},
+                },
+            },
+            {
+                "global_request_id": ["req-b"],
+                "duplex": {
+                    "duplex_prompt_token_ids": [201, 202, 203],
+                    "special_token_ids": {"listen_token_id": 702},
+                },
+            },
+        ],
+    )
+
+    prompt_rows = output.multimodal_outputs["duplex_prompt_token_ids"]
+    listen_rows = output.multimodal_outputs["meta"]["listen_token_id"]
+    assert to_payload_element(prompt_rows, 0, 0, 2) == [101, 102]
+    assert to_payload_element(prompt_rows, 1, 2, 4) == [201, 202, 203]
+    assert int(to_payload_element(listen_rows, 0, 0, 2).reshape(-1)[0]) == 701
+    assert int(to_payload_element(listen_rows, 1, 2, 4).reshape(-1)[0]) == 702
+
+
+def test_minicpmo_stage0_rejects_invalid_resolved_ref_audio():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    with pytest.raises(ValueError, match="invalid native duplex ref_audio_data"):
+        MiniCPMO45Stage0DuplexRuntime._decode_ref_audio_from_session_config(
+            {
+                "ref_audio_data": "a",
+                "ref_audio_format": "pcm_f32le",
+            }
+        )
+
+
+def test_minicpmo_stage0_special_token_ids_are_tokenizer_derived():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    class _Tokenizer:
+        unk_token_id = 0
+        ids = {
+            "<unit>": 101,
+            "</unit>": 102,
+            "<|listen|>": 103,
+            "<|speak|>": 104,
+            "<|tts_bos|>": 105,
+            "<|tts_eos|>": 106,
+            "<|tts_pad|>": 107,
+            "<|chunk_eos|>": 108,
+            "<|chunk_tts_eos|>": 109,
+            "<|turn_eos|>": 110,
+        }
+
+        def convert_tokens_to_ids(self, token):
+            return self.ids.get(token, self.unk_token_id)
+
+        def encode(self, text, add_special_tokens=False):
+            del add_special_tokens
+            return [self.ids[text]] if text in self.ids else [201, self.ids["<|tts_bos|>"]]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.tokenizer = _Tokenizer()
+    runtime._init_token_ids()
+
+    runtime._require_special_token_ids()
+    assert runtime.tts_bos_token_id == 105
+    assert runtime.stage_padding_token_id() == 102
+    assert runtime._special_token_ids()["chunk_tts_eos_token_id"] == 109
+
+
+def test_minicpmo_stage0_rejects_unknown_special_token_fallbacks():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    class _Tokenizer:
+        unk_token_id = 0
+        ids = {
+            "<unit>": 101,
+            "</unit>": 102,
+            "<|listen|>": 103,
+            "<|speak|>": 104,
+            "<|tts_eos|>": 106,
+            "<|tts_pad|>": 107,
+            "<|chunk_eos|>": 108,
+            "<|chunk_tts_eos|>": 109,
+            "<|turn_eos|>": 110,
+        }
+
+        def convert_tokens_to_ids(self, token):
+            return self.ids.get(token, self.unk_token_id)
+
+        def encode(self, text, add_special_tokens=False):
+            del text, add_special_tokens
+            return [self.unk_token_id]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.tokenizer = _Tokenizer()
+    runtime._init_token_ids()
+
+    with pytest.raises(ValueError, match=r"<\|tts_bos\|>"):
+        runtime._require_special_token_ids()
+
+
+def _minicpmo45_tokenizer_stub():
+    token_ids = {
+        token: index
+        for index, token in enumerate(
+            (
+                "<unit>",
+                "</unit>",
+                "<|listen|>",
+                "<|speak|>",
+                "<|tts_bos|>",
+                "<|tts_eos|>",
+                "<|tts_pad|>",
+                "<|chunk_eos|>",
+                "<|chunk_tts_eos|>",
+                "<|turn_eos|>",
+            ),
+            start=101,
+        )
+    }
+    return SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: token_ids.get(token, 0),
+        encode=lambda token, add_special_tokens=False: (
+            [token_ids[token]] if not add_special_tokens and token in token_ids else [0]
+        ),
+    )
+
+
+def _transformers_processor_stub(auto_processor):
+    class _AutoImageProcessor:
+        @staticmethod
+        def register(*_args, **_kwargs):
+            return None
+
+    return SimpleNamespace(
+        AutoImageProcessor=_AutoImageProcessor,
+        AutoProcessor=auto_processor,
+    )
+
+
+def test_minicpmo_stage0_loads_processor_from_hf_id(monkeypatch):
+    import sys
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    model_id = "openbmb/MiniCPM-o-4_5"
+    processor = SimpleNamespace(tokenizer=_minicpmo45_tokenizer_stub())
+    load_calls = []
+
+    class _AutoImageProcessor:
+        @staticmethod
+        def register(config_class, image_processor_class):
+            del image_processor_class
+            if isinstance(config_class, str):
+                raise AttributeError("'str' object has no attribute '__module__'")
+
+    class _AutoProcessor:
+        @classmethod
+        def from_pretrained(cls, model_path, *, trust_remote_code):
+            load_calls.append((model_path, trust_remote_code))
+            _AutoImageProcessor.register("MiniCPMVImageProcessor", object)
+            return processor
+
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        SimpleNamespace(
+            AutoImageProcessor=_AutoImageProcessor,
+            AutoProcessor=_AutoProcessor,
+        ),
+    )
+
+    loaded = MiniCPMO45Stage0DuplexRuntime._load_processor_from_path(model_id)
+
+    assert loaded is processor
+    assert load_calls == [(model_id, True)]
+    with pytest.raises(AttributeError, match="__module__"):
+        _AutoImageProcessor.register("MiniCPMVImageProcessor", object)
+
+
+def test_minicpmo_stage0_processor_load_preserves_original_exception(monkeypatch):
+    import sys
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    original = ValueError("invalid processor config")
+
+    class _AutoProcessor:
+        @classmethod
+        def from_pretrained(cls, model_path, *, trust_remote_code):
+            del cls, model_path, trust_remote_code
+            raise original
+
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        _transformers_processor_stub(_AutoProcessor),
+    )
+
+    with pytest.raises(RuntimeError, match="Failed to load MiniCPM-o duplex processor") as exc_info:
+        MiniCPMO45Stage0DuplexRuntime._load_processor_from_path("openbmb/MiniCPM-o-4_5")
+
+    assert exc_info.value.__cause__ is original
+
+
+def test_minicpmo_stage0_processor_requires_tokenizer(monkeypatch):
+    import sys
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    class _AutoProcessor:
+        @classmethod
+        def from_pretrained(cls, model_path, *, trust_remote_code):
+            del cls, model_path, trust_remote_code
+            return object()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        _transformers_processor_stub(_AutoProcessor),
+    )
+
+    with pytest.raises(RuntimeError, match="does not expose a tokenizer"):
+        MiniCPMO45Stage0DuplexRuntime._load_processor_from_path("openbmb/MiniCPM-o-4_5")
+
+
+def test_minicpmo_stage0_loaded_processor_validates_special_tokens(monkeypatch):
+    import sys
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    processor = SimpleNamespace(tokenizer=_minicpmo45_tokenizer_stub())
+
+    class _AutoProcessor:
+        @classmethod
+        def from_pretrained(cls, model_path, *, trust_remote_code):
+            del cls, model_path, trust_remote_code
+            return processor
+
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        _transformers_processor_stub(_AutoProcessor),
+    )
+
+    runtime = MiniCPMO45Stage0DuplexRuntime(
+        SimpleNamespace(),
+        model_path="openbmb/MiniCPM-o-4_5",
+        device="cpu",
+    )
+
+    assert runtime.processor is processor
+    assert set(runtime._special_token_ids()) == {
+        "unit_token_id",
+        "unit_end_token_id",
+        "listen_token_id",
+        "speak_token_id",
+        "tts_bos_token_id",
+        "tts_eos_token_id",
+        "tts_pad_token_id",
+        "chunk_eos_token_id",
+        "chunk_tts_eos_token_id",
+        "turn_eos_token_id",
+    }
+
+
+def test_minicpmo_stage0_data_plane_prefill_matches_official_unit_format():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, _data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [201, 5],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-data-plane-prefill")
+
+    # Official duplex format: each unit is <unit> + audio embeddings with no
+    # per-chunk assistant header or <|tts_bos|> boundary. Decoding starts right
+    # after the audio so the first sampled token is the listen/speak decision.
+    result = runtime._stage_prefill_embeddings_only(state, np.zeros(4, dtype=np.float32), seq=1)
+
+    assert result["success"] is True
+    assert result["input_token_ids"] == [1, 11]
+    assert result["prompt_suffix_len"] == 0
+
+    # Subsequent units must close the previous unit with </unit> first,
+    # mirroring the official finalize_unit() feed.
+    result = runtime._stage_prefill_embeddings_only(state, np.zeros(4, dtype=np.float32), seq=2)
+
+    assert result["success"] is True
+    assert result["input_token_ids"] == [2, 1, 11]
+    assert result["prompt_suffix_len"] == 0
+
+
+def test_minicpmo_stage0_speech_append_sets_pending_context_once():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, _data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-speech-append")
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        epoch=0,
+        seq=1,
+        is_speech=True,
+    )
+
+    assert result["success"] is True
+    assert state.pending_speech_context is True
+    assert state.pending_speech_append_identity == (0, 1)
+
+    state.pending_speech_context = False
+    cached = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        epoch=0,
+        seq=1,
+        is_speech=True,
+    )
+
+    assert cached["success"] is True
+    assert state.pending_speech_context is False
+    assert state.pending_speech_append_identity == (0, 1)
+
+    next_seq = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        epoch=0,
+        seq=2,
+        is_speech=True,
+    )
+
+    assert next_seq["success"] is True
+    assert state.pending_speech_context is True
+    assert state.pending_speech_append_identity == (0, 2)
+
+    state.pending_speech_context = False
+    next_epoch = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        epoch=1,
+        seq=1,
+        is_speech=True,
+    )
+
+    assert next_epoch["success"] is True
+    assert state.pending_speech_context is True
+    assert state.pending_speech_append_identity == (1, 1)
+
+    state.pending_speech_context = False
+    silence = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        epoch=1,
+        seq=2,
+        is_speech=False,
+    )
+
+    assert silence["success"] is True
+    assert state.pending_speech_context is False
+    assert state.pending_speech_append_identity == (1, 1)
+
+
+def test_minicpmo_stage0_failed_append_does_not_set_pending_speech_context():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, _data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-failed-speech")
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(0, dtype=np.float32),
+        epoch=0,
+        seq=1,
+        is_speech=True,
+    )
+
+    assert result["success"] is False
+    assert state.pending_speech_context is False
+    assert state.pending_speech_append_identity is None
+
+
+def test_minicpmo_stage0_streaming_processor_is_isolated_per_session():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _Mel:
+        def __init__(self):
+            self.counter = 0
+
+    class _Processor:
+        def __init__(self):
+            self._streaming_mel_processor = _Mel()
+
+        def set_streaming_mode(self, **_kwargs):
+            return None
+
+        def reset_streaming(self):
+            self._streaming_mel_processor.counter = 0
+
+        def process_audio_streaming(self, _audio, **_kwargs):
+            self._streaming_mel_processor.counter += 1
+            return self._streaming_mel_processor.counter
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.processor = _Processor()
+    runtime.stage_model = SimpleNamespace()
+    runtime.thinker = runtime.stage_model
+    a = _MiniCPMO45Stage0SessionState(session_id="a")
+    b = _MiniCPMO45Stage0SessionState(session_id="b")
+    processor_a = runtime._configure_streaming_processor(a)
+    processor_b = runtime._configure_streaming_processor(b)
+
+    observed = [
+        runtime._process_streaming_audio([], 0, processor=processor_a),
+        runtime._process_streaming_audio([], 0, processor=processor_b),
+        runtime._process_streaming_audio([], 1, processor=processor_a),
+        runtime._process_streaming_audio([], 1, processor=processor_b),
+    ]
+
+    assert observed == [1, 1, 2, 2]
+    assert processor_a is not processor_b
+    assert runtime.processor._streaming_mel_processor.counter == 0
+
+
+def test_minicpmo_stage0_data_plane_next_append_reinjects_previous_listen():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(
+        session_id="sid-new-speech-prefill",
+        audio_chunk_idx=1,
+        pending_terminator_token=3,
+        last_terminator_token=3,
+        current_turn_ended=True,
+    )
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        seq=2,
+    )
+
+    assert result["success"] is True
+    assert result["input_token_ids"] == [3, 2, 1, 11]
+    assert state.pending_terminator_token is None
+    assert state.last_terminator_token == 3
+    assert state.current_turn_ended is True
+
+
+def test_minicpmo_stage0_data_plane_turn_eos_closes_previous_unit():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(
+        session_id="sid-new-user-turn-prefill",
+        audio_chunk_idx=1,
+        pending_terminator_token=10,
+        last_terminator_token=10,
+        current_turn_ended=True,
+    )
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        seq=2,
+    )
+
+    assert result["success"] is True
+    assert result["input_token_ids"] == [10, 2, 1, 11]
+    assert state.pending_terminator_token is None
+    assert state.last_terminator_token == 10
+    assert state.current_turn_ended is True
+
+
+def test_minicpmo_stage0_data_plane_model_owned_turn_boundary_preserves_audio_cache():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    stale_cache = object()
+
+    class _StageModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+            self.audio_past_key_values = stale_cache
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(get_streaming_chunk_size=lambda: 4)
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(
+        session_id="sid-new-user-turn-audio-cache",
+        audio_chunk_idx=1,
+        audio_past_key_values=stale_cache,
+        pending_terminator_token=8,
+        last_terminator_token=8,
+        current_turn_ended=True,
+    )
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(4, dtype=np.float32),
+        seq=2,
+    )
+
+    assert result["success"] is True
+    assert state.audio_past_key_values is stale_cache
+    assert runtime.thinker.audio_past_key_values is stale_cache
+
+
+def test_minicpmo_stage0_data_plane_final_first_chunk_does_not_add_silence_unit():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        first_chunk_ms = 10
+        sample_rate = 1000
+
+        def __init__(self):
+            super().__init__()
+            self.seen_audio = None
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, data):
+            self.seen_audio = np.asarray(data["audio_features"], dtype=np.float32)
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    class _MelProcessor:
+        sample_rate = 1000
+
+        def get_config(self):
+            return {"effective_first_chunk_ms": 10}
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = SimpleNamespace(
+        _streaming_mel_processor=_MelProcessor(),
+        get_streaming_chunk_size=lambda: 10,
+    )
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-first-chunk-padding")
+
+    result = runtime._stage_prefill_embeddings_only(
+        state,
+        np.arange(8, dtype=np.float32),
+        seq=1,
+        final=True,
+    )
+
+    assert result["success"] is True
+    assert result["input_token_ids"] == [1, 11]
+    assert runtime.stage_model.seen_audio is not None
+    np.testing.assert_allclose(
+        runtime.stage_model.seen_audio.reshape(-1),
+        np.array([0, 0, 0, 1, 2, 3, 4, 5, 6, 7], dtype=np.float32),
+    )
+
+
+def test_minicpmo_stage0_final_does_not_promote_first_chunk_alignment_tail_to_unit():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _StageModel(torch.nn.Module):
+        first_chunk_ms = 10
+        chunk_ms = 8
+        sample_rate = 1000
+
+        def __init__(self):
+            super().__init__()
+            self.embed = torch.nn.Embedding(256, 2)
+
+        def get_input_embeddings(self):
+            return self.embed
+
+        def get_audio_hidden_states(self, _data):
+            return [torch.tensor([[0.5, 0.5]], dtype=torch.float32)]
+
+    class _MelProcessor:
+        sample_rate = 1000
+        is_first = True
+
+        def get_config(self):
+            return {"effective_first_chunk_ms": 9}
+
+    class _Processor:
+        def __init__(self):
+            self._streaming_mel_processor = _MelProcessor()
+
+        def get_streaming_chunk_size(self):
+            return 9 if self._streaming_mel_processor.is_first else 8
+
+        def process_audio_streaming(self, audio, **_kwargs):
+            self._streaming_mel_processor.is_first = False
+            return {"audio_features": audio, "audio_feature_lens": [[len(audio)]]}
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = _StageModel()
+    runtime.thinker = runtime.stage_model
+    runtime.tokenizer = SimpleNamespace(
+        unk_token_id=0,
+        convert_tokens_to_ids=lambda token: {
+            "<unit>": 1,
+            "</unit>": 2,
+            "<|listen|>": 3,
+            "<|speak|>": 4,
+            "<|tts_bos|>": 5,
+            "<|tts_eos|>": 6,
+            "<|tts_pad|>": 7,
+            "<|chunk_eos|>": 8,
+            "<|chunk_tts_eos|>": 9,
+            "<|turn_eos|>": 10,
+            "<|audio|>": 11,
+        }.get(token, 0),
+        encode=lambda text, add_special_tokens=False: [],
+    )
+    runtime.processor = _Processor()
+    runtime.device = "cpu"
+    runtime._init_token_ids()
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-first-chunk-alignment-tail")
+
+    first = runtime._stage_prefill_embeddings_only(state, np.zeros(8, dtype=np.float32), seq=1)
+    second = runtime._stage_prefill_embeddings_only(state, np.zeros(8, dtype=np.float32), seq=2)
+    final = runtime._stage_prefill_embeddings_only(
+        state,
+        np.zeros(8, dtype=np.float32),
+        seq=3,
+        final=True,
+    )
+
+    assert first["input_token_ids"].count(1) == 1
+    assert second["input_token_ids"].count(1) == 1
+    assert final["input_token_ids"].count(1) == 1
+    assert state.audio_chunk_idx == 3
+    assert len(state.audio_buffer) == 1
+
+
+def test_minicpmo_stage0_runtime_uses_loaded_vllm_embed_tokens_when_get_input_embeddings_is_broken():
+    import torch
+
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+    )
+
+    class _Embed(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.weight = torch.nn.Parameter(torch.ones(128, 2))
+            self.calls = []
+
+        def forward(self, input_ids):
+            ids = input_ids.reshape(-1).tolist()
+            self.calls.append(ids)
+            return torch.tensor([[float(i), 0.0] for i in ids], dtype=torch.float32)
+
+    class _Thinker:
+        def __init__(self):
+            self.llm = SimpleNamespace(model=SimpleNamespace(embed_tokens=_Embed()))
+
+        def get_input_embeddings(self, input_ids, multimodal_embeddings=None):
+            raise AttributeError("'Qwen3ForCausalLM' object has no attribute 'get_input_embeddings'")
+
+    thinker = _Thinker()
+    stage_model = SimpleNamespace(model_stage="llm", thinker=thinker, processor=None)
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = stage_model
+    runtime.thinker = thinker
+    runtime.device = "cpu"
+
+    embeds = runtime._embed_token(11)
+
+    assert embeds.shape == (1, 2)
+    assert thinker.llm.model.embed_tokens.calls == [[11]]
+
+
+def test_minicpmo_remote_config_patch_handles_nested_and_dict_configs():
+    from vllm_omni.experimental.fullduplex.minicpmo45.compat import (
+        patch_minicpmo_remote_config,
+    )
+
+    nested = SimpleNamespace(base_model_tp_plan=None)
+    config = SimpleNamespace(
+        base_model_tp_plan=None,
+        text_config=nested,
+        tts_config={},
+    )
+
+    patch_minicpmo_remote_config(config)
+
+    assert config.base_model_tp_plan == {}
+    assert nested.base_model_tp_plan == {}
+    assert config.tts_config["top_p"] == 0.8
+    assert config.tts_config["top_k"] == 100
+    assert config.tts_config["temperature"] == 0.8
+    assert config.tts_config["repetition_penalty"] == 1.05
+
+
+def test_minicpmo_stage0_short_audio_buffers_without_context_mutation():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    class _Processor:
+        def get_streaming_chunk_size(self):
+            return 16000
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.stage_model = SimpleNamespace()
+    runtime.thinker = SimpleNamespace()
+    runtime.processor = _Processor()
+    runtime._require_special_token_ids = lambda: None
+    state = _MiniCPMO45Stage0SessionState(session_id="sid")
+
+    result = runtime._stage_prefill_embeddings_only(state, np.zeros(1600, dtype=np.float32))
+
+    assert result["success"] is False
+    assert result["reason"]
+    assert len(state.audio_buffer) >= 1600
+    assert state.context_embeds == []
+
+
+def test_minicpmo_stage0_native_sampler_penalizes_repeated_text_token():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    vocab_size = 151723
+    repeated = 198
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, repeated] = 20.0
+    logits[0, alternative] = 19.5
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[repeated] * 8],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[alternative]]
+
+
+def test_minicpmo_stage0_native_sampler_penalizes_text_from_prior_chunk():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        _MiniCPMO45Stage0SessionState,
+    )
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    session_key = ("sid-cross-chunk-repetition", 0)
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    state.generated_tokens = [198] * 8
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
+    model._minicpmo45_duplex_row_sessions = {0: session_key}
+
+    vocab_size = 151723
+    repeated = 198
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, repeated] = 20.0
+    logits[0, alternative] = 19.5
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[alternative]]
+
+
+def test_minicpmo_stage0_native_sampler_matches_official_negative_logit_penalty():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        _MiniCPMO45Stage0SessionState,
+    )
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    session_key = ("sid-negative-logit-repetition", 0)
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    repeated = 198
+    alternative = 1234
+    state.generated_tokens = [repeated]
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
+    model._minicpmo45_duplex_row_sessions = {0: session_key}
+
+    logits = torch.full((1, 151723), -100.0)
+    logits[0, repeated] = -1.0
+    logits[0, alternative] = -0.97
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[repeated]]
+
+
+def test_minicpmo_stage0_records_bounded_model_policy_history():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        _MiniCPMO45Stage0SessionState,
+    )
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    session_key = ("sid-text-history", 0)
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
+    model._minicpmo45_duplex_row_sessions = {0: session_key}
+    token_ids = {
+        "unit_token_id": 1,
+        "unit_end_token_id": 2,
+        "listen_token_id": 3,
+        "speak_token_id": 4,
+        "tts_bos_token_id": 5,
+        "tts_eos_token_id": 6,
+        "tts_pad_token_id": 7,
+        "chunk_eos_token_id": 8,
+        "chunk_tts_eos_token_id": 9,
+        "turn_eos_token_id": 10,
+    }
+
+    for sampled in range(1000, 1520):
+        model._record_minicpmo45_duplex_generation_token(0, sampled)
+
+    expected_history = list(range(1008, 1520))
+    assert state.generated_tokens == expected_history
+
+    for sampled in token_ids.values():
+        model._record_minicpmo45_duplex_generation_token(0, sampled)
+
+    assert state.generated_tokens == [*expected_history[len(token_ids) :], *token_ids.values()]
+
+
+def test_minicpmo_stage0_native_sampler_does_not_override_model_at_punctuation():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        text = {
+            200: "我",
+            201: "喜",
+            202: "欢",
+            203: "。",
+        }
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            del skip_special_tokens
+            return "".join(self.text.get(int(token_id), "") for token_id in ids)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.min_new_speak_tokens_before_chunk_boundary = 4
+    model.max_new_speak_tokens_per_chunk = 64
+    vocab_size = 151723
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, alternative] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201, 202, 203]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[alternative]]
+
+
+def test_minicpmo_stage0_native_sampler_does_not_cut_before_natural_boundary_minimum():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            del ids, skip_special_tokens
+            return "。"
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.min_new_speak_tokens_before_chunk_boundary = 4
+    model.max_new_speak_tokens_per_chunk = 64
+    vocab_size = 151723
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, alternative] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201, 202]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[alternative]]
+
+
+def test_minicpmo_stage0_native_sampler_does_not_rewrite_model_punctuation():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        text = {
+            108386: "你",
+            104256: "好",
+            3837: "，",
+            100644: "今",
+            99172: "天",
+            100281: "想",
+            27442: "聊",
+            99217: "什",
+            1773: "。",
+            99218: "么",
+        }
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def encode(self, text, add_special_tokens=False):
+            del add_special_tokens
+            return {"。": [1773]}.get(text, [])
+
+        def decode(self, ids, skip_special_tokens=True):
+            del skip_special_tokens
+            return "".join(self.text.get(int(token_id), "") for token_id in ids)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.min_new_speak_tokens_before_chunk_boundary = 4
+    model.max_new_speak_tokens_per_chunk = 64
+    vocab_size = 151723
+    period = 1773
+    continuation = 99218
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, period] = 30.0
+    logits[0, continuation] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 108386, 104256, 3837, 100644, 99172, 100281, 27442, 99217]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[period]]
+
+
+def test_minicpmo_stage0_native_sampler_preserves_model_chunk_eos_decision():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    logits = torch.full((1, 151723), -100.0)
+    logits[0, 151718] = 30.0
+    logits[0, 1234] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151718]]
+
+
+def test_minicpmo_stage0_native_sampler_preserves_early_model_turn_eos_decision():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.min_new_speak_tokens_before_chunk_boundary = 8
+    logits = torch.full((1, 151723), -100.0)
+    logits[0, 151717] = 30.0
+    logits[0, 1234] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151717]]
+
+
+def test_minicpmo_stage0_native_sampler_char_cap_does_not_override_special_token():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = [151706, 151717]
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            del skip_special_tokens
+            return "已经超过二十八个字符的当前语音分段文本"
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    logits = torch.full((1, 151723), -100.0)
+    logits[0, 151717] = 30.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151717]]
+
+
+def test_minicpmo_stage0_native_sampler_preserves_model_chunk_eos():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.min_new_speak_tokens_before_chunk_boundary = 8
+    model.max_new_speak_tokens_per_chunk = 64
+    vocab_size = 151723
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, 151718] = 30.0
+    logits[0, 1234] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201, 202]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151718]]
+
+
+def test_minicpmo_stage0_native_sampler_keeps_hard_chunk_cap():
+    from vllm_omni.experimental.fullduplex.minicpmo45.policy import (
+        MiniCPMO45DuplexPolicy,
+    )
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            del ids, skip_special_tokens
+            return "没有自然边界"
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    vocab_size = 151723
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, alternative] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[200] * (MiniCPMO45DuplexPolicy.DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK - 1)],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert MiniCPMO45DuplexPolicy.DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK == 20
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151718]]
+
+
+def test_minicpmo_stage0_native_sampler_cuts_before_request_length_cap():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            del ids, skip_special_tokens
+            return "没有自然边界"
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model.max_new_speak_tokens_per_chunk = 64
+    model._minicpmo45_duplex_row_max_tokens = {0: 20}
+    vocab_size = 151723
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, alternative] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706] + [200] * 18],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151718]]
+
+
+def test_minicpmo_stage0_native_sampler_cuts_on_decoded_text_length():
+    from vllm_omni.experimental.fullduplex.minicpmo45.policy import (
+        MiniCPMO45DuplexPolicy,
+    )
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = [151706, 151718, 151717, 151705]
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+        def decode(self, ids, skip_special_tokens=True):
+            token_text = {
+                200: "一二三四五六七八九十",
+                201: "十一十二十三十四十五",
+                202: "十六十七十八十九",
+            }
+            special = set(self.all_special_ids) if skip_special_tokens else set()
+            return "".join(token_text.get(int(token_id), "") for token_id in ids if int(token_id) not in special)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    vocab_size = 151723
+    candidate = 202
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, candidate] = 20.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[151706, 200, 201]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert MiniCPMO45DuplexPolicy.DEFAULT_MAX_SPEAK_CHARS_PER_CHUNK == 28
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151718]]
+
+
+def test_minicpmo_stage0_native_sampler_ignores_pending_placeholders():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    vocab_size = 151723
+    newline = 198
+    alternative = 1234
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, newline] = 20.0
+    logits[0, alternative] = 19.5
+    sampling_metadata = SimpleNamespace(
+        all_greedy=False,
+        all_random=True,
+        temperature=torch.tensor([1.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[-1, -1, -1]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[newline]]
+
+
+def test_minicpmo_stage0_native_sampler_converts_mid_turn_listen_to_tts_bos():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    state = SimpleNamespace(current_turn_ended=False)
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model._minicpmo45_duplex_row_sessions = {0: ("sid-native", 0)}
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={("sid-native", 0): state})
+    vocab_size = 151723
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, 151705] = 30.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151703]]
+    assert state.current_turn_ended is False
+
+
+def test_minicpmo_stage0_native_sampler_forced_listen_yields_floor():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    class _Tokenizer:
+        eos_token_id = 151705
+        unk_token_id = -1
+        bad_token_ids = []
+        all_special_ids = []
+
+        def convert_tokens_to_ids(self, token):
+            return {
+                "<unit>": 151683,
+                "</unit>": 151684,
+                "<|listen|>": 151705,
+                "<|speak|>": 151706,
+                "<|tts_bos|>": 151703,
+                "<|tts_eos|>": 151704,
+                "<|tts_pad|>": 151722,
+                "<|chunk_eos|>": 151718,
+                "<|chunk_tts_eos|>": 151721,
+                "<|turn_eos|>": 151717,
+            }.get(token, -1)
+
+    state = SimpleNamespace(current_turn_ended=False)
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    model.model_stage = "llm"
+    model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
+    model._minicpmo45_duplex_row_sessions = {0: ("sid-native", 0)}
+    model._minicpmo45_duplex_row_payloads = {0: {"force_listen": True}}
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={("sid-native", 0): state})
+    vocab_size = 151723
+    logits = torch.full((1, vocab_size), -100.0)
+    logits[0, 151705] = 30.0
+    sampling_metadata = SimpleNamespace(
+        all_greedy=True,
+        all_random=False,
+        temperature=torch.tensor([0.0]),
+        top_k=torch.tensor([1]),
+        top_p=torch.tensor([1.0]),
+        generators={},
+        prompt_token_ids=torch.tensor([[151683] * 16]),
+        output_token_ids=[[]],
+    )
+
+    sampled = model.sample(logits, sampling_metadata)
+
+    assert sampled is not None
+    assert sampled.sampled_token_ids.tolist() == [[151705]]
+    assert state.current_turn_ended is True
+
+
+def test_minicpmo_stage0_native_sampler_uses_runner_duplex_rows():
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+        MiniCPMO45OmniForConditionalGeneration,
+    )
+
+    model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    metadata = SimpleNamespace(
+        prompt_token_ids=torch.tensor([[1, 2, 3]]),
+    )
+
+    rows = model._minicpmo45_native_duplex_prompt_rows(
+        metadata,
+        unit_id=151683,
+        batch_size=1,
+        duplex_rows=[0],
+    )
+
+    assert rows == [0]
+
+
+def test_minicpmo_stage0_session_context_includes_resolved_ref_audio():
+    from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+        MiniCPMO45Stage0DuplexRuntime,
+        _MiniCPMO45Stage0SessionState,
+    )
+
+    runtime = MiniCPMO45Stage0DuplexRuntime.__new__(MiniCPMO45Stage0DuplexRuntime)
+    runtime.unit_token_id = 151683
+    runtime.processor = SimpleNamespace()
+    runtime.stage_model = SimpleNamespace()
+    runtime.thinker = SimpleNamespace()
+    runtime.device = "cpu"
+    token_map = {
+        "<|im_start|>system\nUse speech.\n<|audio_start|>": [1, 2, 3],
+        "<|audio_end|><|im_end|>": [4, 5],
+    }
+    runtime._stage_runtime_ready = lambda: True
+    runtime._require_special_token_ids = lambda: None
+    runtime._decode_ref_audio_from_session_config = lambda _config: np.array([0.1, -0.1], dtype=np.float32)
+    runtime._encode_text = lambda text: token_map[text]
+    runtime._embed_token = lambda token_id: torch.full((1, 2), float(token_id))
+    runtime._stage_ref_audio_embeddings = lambda ref_audio, state=None: torch.tensor([[10.0, 11.0], [12.0, 13.0]])
+
+    state = _MiniCPMO45Stage0SessionState(session_id="sid-ref")
+    runtime._prepare_session_context(state, {"instructions": "Use speech.", "extra_body": {"ref_audio_data": "x"}})
+
+    assert state.context_token_ids == [1, 2, 3, 151683, 151683, 4, 5]
+    assert len(state.context_embeds) == 6
diff --git a/tests/worker/test_omni_connector_mixin.py b/tests/worker/test_omni_connector_mixin.py
index b8eb899fa..af472fd95 100644
--- a/tests/worker/test_omni_connector_mixin.py
+++ b/tests/worker/test_omni_connector_mixin.py
@@ -17,6 +17,9 @@ from unittest.mock import MagicMock, patch
 import pytest
 import torch
 
+from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+    OmniKVTransferManager,
+)
 from vllm_omni.outputs import OmniConnectorOutput
 from vllm_omni.worker.omni_connector_model_runner_mixin import (
     OmniConnectorModelRunnerMixin,
@@ -102,6 +105,34 @@ class _FakeTPGroup:
 # ------------------------------------------------------------------ #
 
 
+@pytest.mark.parametrize(
+    ("role", "custom_func", "expected"),
+    [
+        ("sender", None, False),
+        ("sender", "package.build_payload", True),
+        ("receiver", None, True),
+    ],
+)
+def test_init_payload_connector_ownership(role, custom_func, expected):
+    model_config = _make_model_config(custom_func=custom_func)
+    model_config.stage_connector_config = {
+        "name": "MooncakeTransferEngineConnector",
+        "extra": {"role": role},
+    }
+
+    host = MixinHost()
+    connector = MockConnector()
+    with (
+        patch.object(host, "_create_connector", return_value=connector) as create,
+        patch.object(host, "_load_custom_func", return_value=(None, None)),
+    ):
+        host.init_omni_connectors(model_config)
+
+    assert (create.call_count == 1) is expected
+    assert (host._omni_connector is connector) is expected
+    host.shutdown_omni_connectors()
+
+
 class TestMixinAsyncChunkSendRecv(unittest.TestCase):
     """Test 2: Async chunk send/recv + bg threads."""
 
@@ -110,7 +141,6 @@ class TestMixinAsyncChunkSendRecv(unittest.TestCase):
 
         sender = MixinHost()
         sender.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0, async_chunk=True),
         )
         sender._omni_connector = connector
@@ -147,7 +177,6 @@ class TestMixinAsyncChunkSendRecv(unittest.TestCase):
 
         sender = MixinHost()
         sender.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0, async_chunk=True),
         )
         sender._omni_connector = connector
@@ -180,7 +209,6 @@ class TestMixinKVCacheTransfer(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
             kv_transfer_manager=mock_kvm,
         )
@@ -202,7 +230,6 @@ class TestMixinKVCacheTransfer(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
             kv_transfer_manager=mock_kvm,
         )
@@ -219,7 +246,6 @@ class TestMixinKVCacheTransfer(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
             kv_transfer_manager=mock_kvm,
         )
@@ -257,7 +283,6 @@ class TestMixinKVCacheTransfer(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
             kv_transfer_manager=mock_kvm,
         )
@@ -281,7 +306,6 @@ class TestOmniConnectorOutput(unittest.TestCase):
     def test_output_aggregation(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
         )
 
@@ -310,7 +334,6 @@ class TestMixinNoConnector(unittest.TestCase):
     def test_no_connector(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
         )
         self.assertIsNone(host._omni_connector)
@@ -336,7 +359,6 @@ class TestFinishedLoadReqsDrain(unittest.TestCase):
     def test_finished_load_reqs_flow_to_chunk_ready(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
         )
 
@@ -389,7 +411,6 @@ class TestFullPayloadSendWithCustomFunc(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
         )
         host._omni_connector = MockConnector(stage_id=0)
@@ -424,7 +445,6 @@ class TestFullPayloadSendWithCustomFunc(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
         )
         host._omni_connector = MockConnector(stage_id=0)
@@ -453,7 +473,6 @@ class TestKVSentReqIdsAccumulation(unittest.TestCase):
 
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(),
             kv_transfer_manager=mock_kvm,
         )
@@ -488,7 +507,6 @@ class TestChunkStreamCompletedGuard(unittest.TestCase):
     def _make_host(self, stage_id: int = 1) -> MixinHost:
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=stage_id, async_chunk=True),
         )
         host._omni_connector = MockConnector(stage_id=stage_id)
@@ -587,7 +605,6 @@ class TestCleanupFinishedRequest(unittest.TestCase):
     def _make_host(self, stage_id: int = 1) -> MixinHost:
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=stage_id, async_chunk=True),
         )
         host._omni_connector = MockConnector(stage_id=stage_id)
@@ -771,7 +788,6 @@ class TestSendChunkCachesMapping(unittest.TestCase):
         """send_chunk should cache the internal→external mapping."""
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0, async_chunk=True),
         )
         host._omni_connector = MockConnector(stage_id=0)
@@ -802,7 +818,6 @@ class TestLocalPayloadCacheLifecycle(unittest.TestCase):
     def _make_host(self) -> MixinHost:
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0),
         )
         host._omni_connector = MockConnector(stage_id=0)
@@ -901,7 +916,6 @@ class TestTPAsyncChunkFanout(unittest.TestCase):
     def _make_host(self, rank: int) -> MixinHost:
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=2, async_chunk=True, worker_type="gen"),
         )
         host._omni_connector = MagicMock()
@@ -984,7 +998,6 @@ class TestKVTransferLifecycle(unittest.TestCase):
     def _make_host(self) -> MixinHost:
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0),
         )
         return host
@@ -1039,7 +1052,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_send_side_request_payload_not_cleared_before_payload_is_consumable(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=1, async_chunk=True, worker_type="ar"),
         )
         host._request_ids_mapping["r1"] = "r1"
@@ -1063,7 +1075,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_payload_consumable_ignores_token_horizon_only_updates(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=1, async_chunk=True, worker_type="ar"),
         )
         payload = {
@@ -1084,7 +1095,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_payload_consumable_accepts_decode_embeddings(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=1, async_chunk=True, worker_type="ar"),
         )
         payload = {
@@ -1098,7 +1108,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_ar_metadata_only_followup_chunk_does_not_rewake_request(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=1, async_chunk=True, worker_type="ar"),
         )
         host._omni_connector = MagicMock()
@@ -1138,7 +1147,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_non_ar_recv_does_not_overwrite_unconsumed_staged_chunk(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=2, async_chunk=True, worker_type="gen"),
         )
         host._omni_connector = MagicMock()
@@ -1164,7 +1172,6 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
     def test_non_ar_recv_waits_for_scheduler_handoff_before_fetching_next_chunk(self):
         host = MixinHost()
         host.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=2, async_chunk=True, worker_type="gen"),
         )
         host._omni_connector = MagicMock()
@@ -1208,7 +1215,7 @@ class TestAsyncPayloadLifecycle(unittest.TestCase):
 class TestRankAwareKVRouting(unittest.TestCase):
     def _make_host(self, *, from_tp: int, to_tp: int, local_rank: int) -> MixinHost:
         host = MixinHost()
-        host.init_omni_connectors(vllm_config=None, model_config=_make_model_config(stage_id=1))
+        host.init_omni_connectors(model_config=_make_model_config(stage_id=1))
         host._from_tp = from_tp
         host._to_tp = to_tp
         host._local_rank = local_rank
@@ -1222,6 +1229,38 @@ class TestRankAwareKVRouting(unittest.TestCase):
         )
         host.shutdown_omni_connectors()
 
+    def test_single_rank_hooks_use_default_manager_key(self):
+        host = self._make_host(from_tp=1, to_tp=1, local_rank=0)
+        expected = ["omni_0_to_1_kv_cache_req"]
+
+        self.assertEqual(host.get_rank_aware_kv_send_keys("req", from_stage=0, to_stage=1), expected)
+        self.assertEqual(host.get_rank_aware_kv_keys("req", from_stage=0, to_stage=1), expected)
+        host.shutdown_omni_connectors()
+
+    def test_init_uses_effective_manager_tp2_topology(self):
+        model_config = _make_model_config(stage_id=0)
+        model_config.omni_kv_config = {
+            "need_send_cache": True,
+            "omni_from_stage": "0",
+            "omni_to_stage": "1",
+            "rank_mapping": {"from_tp": 2, "to_tp": 2},
+        }
+        with patch(
+            "vllm_omni.distributed.omni_connectors.kv_transfer_manager.get_local_tp_rank",
+            return_value=1,
+        ):
+            manager = OmniKVTransferManager.from_model_config(model_config)
+
+        host = MixinHost()
+        host.init_omni_connectors(model_config=model_config, kv_transfer_manager=manager)
+
+        expected = ["req_0_0_1_1"]
+        self.assertEqual(host.get_rank_aware_kv_send_keys("req", from_stage=0, to_stage=1), expected)
+        self.assertEqual(host.get_rank_aware_kv_keys("req", from_stage=0, to_stage=1), expected)
+        self.assertEqual(host.get_kv_rank_mapping()["from_tp"], 2)
+        self.assertEqual(host.get_kv_rank_mapping()["to_tp"], 2)
+        host.shutdown_omni_connectors()
+
     def test_send_keys_route_from_rank_gt_to_rank(self):
         host = self._make_host(from_tp=4, to_tp=2, local_rank=3)
         self.assertEqual(host.get_rank_aware_kv_send_keys("req", from_stage=0), ["req_0_0_3_1"])
@@ -1269,7 +1308,7 @@ class TestRankAwareKVRouting(unittest.TestCase):
 
 class TestAttachOmniConnectorOutput(unittest.TestCase):
     def test_wraps_empty_model_runner_output_when_signals_exist(self):
-        from vllm.v1.worker.gpu_model_runner import EMPTY_MODEL_RUNNER_OUTPUT
+        from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT
 
         host = MixinHost()
         host.get_omni_connector_output = lambda: OmniConnectorOutput(chunk_ready_req_ids={"req-1"})
@@ -1287,7 +1326,7 @@ class TestConnectorConfigValidation(unittest.TestCase):
         model_config.stage_connector_config = {"name": "   "}
 
         with self.assertRaisesRegex(RuntimeError, "missing connector name"):
-            host.init_omni_connectors(vllm_config=None, model_config=model_config)
+            host.init_omni_connectors(model_config=model_config)
 
 
 class _FailingConnector:
@@ -1319,7 +1358,6 @@ class TestSendRetry(unittest.TestCase):
     def _make_sender(self, connector):
         sender = MixinHost()
         sender.init_omni_connectors(
-            vllm_config=None,
             model_config=_make_model_config(stage_id=0, async_chunk=True),
         )
         sender._omni_connector = connector
diff --git a/tests/worker/test_omni_gpu_model_runner.py b/tests/worker/test_omni_gpu_model_runner.py
index 48c0bc6de..701e3b589 100644
--- a/tests/worker/test_omni_gpu_model_runner.py
+++ b/tests/worker/test_omni_gpu_model_runner.py
@@ -196,8 +196,7 @@ def _make_runner_for_mimo(req_id="r_mimo"):
 
 
 def test_talker_mtp_forward_cpu_updates_inputs_and_info(monkeypatch):
-    # `_talker_mtp_forward` calls `current_omni_platform.set_forward_context`,
-    # which would otherwise dispatch to the real device implementation.
+    # `_talker_mtp_forward` dispatches through the active platform.
     import vllm_omni.worker.gpu_model_runner as mod  # Must be the same module that defines OmniGPUModelRunner
 
     monkeypatch.setattr(mod.current_omni_platform, "set_forward_context", _noop_forward_context)
@@ -441,6 +440,33 @@ def test_update_intermediate_buffer_accumulates():
     assert torch.allclose(buf["b"], torch.tensor([2.0]))
 
 
+def test_update_additional_information_deserializes_new_request_payload():
+    from vllm_omni.engine.serialization import serialize_additional_information
+
+    runner = _make_runner(req_ids=("r1",), hidden_size=4)
+    conditioning = {
+        "tts_token_ids": torch.tensor([1, 2]),
+        "tts_hidden_states": torch.ones(2, 4),
+    }
+    scheduler_output = SimpleNamespace(
+        scheduled_new_reqs=[
+            SimpleNamespace(
+                req_id="r1",
+                additional_information=serialize_additional_information(conditioning),
+            )
+        ],
+        scheduled_cached_reqs=SimpleNamespace(),
+    )
+
+    OmniGPUModelRunner._update_additional_information(runner, scheduler_output)
+
+    assert torch.equal(runner.model_intermediate_buffer["r1"]["tts_token_ids"], conditioning["tts_token_ids"])
+    assert torch.equal(
+        runner.model_intermediate_buffer["r1"]["tts_hidden_states"],
+        conditioning["tts_hidden_states"],
+    )
+
+
 def test_update_intermediate_buffer_skips_empty_update():
     """Validate that an empty update dict is a no-op."""
     runner = _make_runner(req_ids=("r1",), hidden_size=4)
@@ -459,28 +485,33 @@ def test_update_intermediate_buffer_skips_unknown_req_id():
     assert "unknown_req" not in runner.model_intermediate_buffer
 
 
-def test_maybe_run_batch_preprocess_calls_model_hook():
-    runner = object.__new__(OmniGPUModelRunner)
-    runner.model_intermediate_buffer = {"r1": {"text": ["hello"]}}
-    calls = []
+def test_streaming_input_update_merges_model_intermediate_buffer():
+    runner = _make_runner(req_ids=("r1",), hidden_size=4)
+    runner.model_intermediate_buffer["r1"] = {
+        "duplex": {
+            "session_id": "sid",
+            "seq": 1,
+        }
+    }
+    runner.requests["r1"].additional_information_cpu = runner.model_intermediate_buffer["r1"]
+    new_req_data = SimpleNamespace(
+        model_intermediate_buffer={
+            "duplex": {
+                "session_id": "sid",
+                "seq": 2,
+                "payload": {"type": "audio"},
+            }
+        },
+        additional_information=None,
+    )
 
-    class DummyModel:
-        def preprocess_batch(self, *, req_ids, model_intermediate_buffer, device):
-            calls.append((req_ids, model_intermediate_buffer, device))
+    OmniGPUModelRunner._update_streaming_input_additional_info(runner, new_req_data, "r1")
 
-    runner.model = DummyModel()
-
-    OmniGPUModelRunner._maybe_run_batch_preprocess(runner, ["r1"], torch.device("cpu"))
-
-    assert calls == [(["r1"], runner.model_intermediate_buffer, torch.device("cpu"))]
-
-
-def test_maybe_run_batch_preprocess_skips_missing_hook():
-    runner = object.__new__(OmniGPUModelRunner)
-    runner.model_intermediate_buffer = {}
-    runner.model = object()
-
-    OmniGPUModelRunner._maybe_run_batch_preprocess(runner, ["r1"], torch.device("cpu"))
+    info = runner.model_intermediate_buffer["r1"]
+    assert info["duplex"]["session_id"] == "sid"
+    assert info["duplex"]["seq"] == 2
+    assert info["duplex"]["payload"] == {"type": "audio"}
+    assert runner.requests["r1"].additional_information_cpu is info
 
 
 def _make_full_payload_accumulation_runner(
@@ -501,8 +532,6 @@ def _make_full_payload_accumulation_runner(
     runner._custom_process_func = object()
     runner._pending_full_payload_send = {}
     runner._stage_id = 1
-    # Non-None sentinel: the gate short-circuits to False when no connector
-    # is configured at all (terminal stages in pipelines with no connector).
     runner._omni_connector = object()
     return runner
 
@@ -519,7 +548,7 @@ def test_accumulate_full_payload_output_preserves_aligned_all_zero_qwen3_omni_co
 
 
 def test_accumulate_full_payload_output_keeps_misaligned_all_zero_qwen3_omni_codec_rows():
-    # After removing the sender-side zero filter, the full-payload accumulator keeps every
+    # After removing the sender-side zero filter, the accumulator keeps every
     # codec row including misaligned all-zero rows. The downstream consumer
     # (_extract_qwen3_full_payload_codec_rows) is the authoritative crop and
     # filters by output_token_ids.
@@ -566,45 +595,25 @@ def test_accumulate_full_payload_output_keeps_all_zero_qwen3_omni_prefill_placeh
 
 
 def test_full_payload_output_accumulation_hook_matrix():
-    """Producer-side gate: fires iff an explicit next-stage payload hook is loaded.
-
-    A derived `*_full_payload` helper from `custom_process_input_func` is not
-    enough: terminal/input-only consumer stages must not enqueue orphan
-    downstream payloads.
-    """
-    # Thinker / talker producer stages: explicit next-stage payload hook -> gate fires.
     assert _make_full_payload_accumulation_runner(model_stage="thinker")._should_accumulate_full_payload_output()
     assert _make_full_payload_accumulation_runner(model_stage="talker")._should_accumulate_full_payload_output()
-
-    # Terminal stage: even if _load_custom_func derived a builder from
-    # custom_process_input_func, final output stages are not producers.
-    runner = _make_full_payload_accumulation_runner(model_stage="code2wav", final_output=True)
-    assert not runner._should_accumulate_full_payload_output()
-
-    # Input-only consumer stage without an explicit producer hook must not
-    # accumulate/send just because a same-module *_full_payload helper exists.
-    runner = _make_full_payload_accumulation_runner(
+    assert not _make_full_payload_accumulation_runner(
+        model_stage="code2wav", final_output=True
+    )._should_accumulate_full_payload_output()
+    assert not _make_full_payload_accumulation_runner(
         model_stage="token2audio",
         custom_process_next_stage_input_func=None,
-    )
-    assert not runner._should_accumulate_full_payload_output()
-
-    # async_chunk mode -> gate off.
+    )._should_accumulate_full_payload_output()
     assert not _make_full_payload_accumulation_runner(
         model_stage="talker", async_chunk=True
     )._should_accumulate_full_payload_output()
-
-    # Non-qwen3 arches: gate is arch-agnostic, but if the fixture's arch
-    # does not configure a connector payload builder, its runtime
-    # `_custom_process_func` is None.  Emulate that.
-    runner = _make_full_payload_accumulation_runner(model_arch="Qwen3TTSForConditionalGeneration")
-    runner._custom_process_func = None
-    runner._should_accumulate_full_payload_output_cached = None
-    assert not runner._should_accumulate_full_payload_output()
-    runner = _make_full_payload_accumulation_runner(model_arch="Qwen2_5OmniForConditionalGeneration")
-    runner._custom_process_func = None
-    runner._should_accumulate_full_payload_output_cached = None
-    assert not runner._should_accumulate_full_payload_output()
+    for model_arch in (
+        "Qwen3TTSForConditionalGeneration",
+        "Qwen2_5OmniForConditionalGeneration",
+    ):
+        runner = _make_full_payload_accumulation_runner(model_arch=model_arch)
+        runner._custom_process_func = None
+        assert not runner._should_accumulate_full_payload_output()
 
 
 def test_sync_local_stage_payloads_retains_payload_until_request_is_active():
diff --git a/tests/worker/test_payload_span.py b/tests/worker/test_payload_span.py
new file mode 100644
index 000000000..5eb4d8319
--- /dev/null
+++ b/tests/worker/test_payload_span.py
@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Characterization tests for ``vllm_omni.worker.payload_span``.
+
+These pin the CURRENT behaviour of the thinker-decode span helpers so the later
+worker refactors that touch span
+plumbing have a regression net. Pure CPU — no model, no CUDA.
+"""
+
+import pytest
+import torch
+
+from vllm_omni.worker.payload_span import (
+    get_tensor_span,
+    get_tensor_span_row,
+    merge_tensor_spans,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _rows(n: int, *, start_val: int = 0, hidden: int = 1) -> torch.Tensor:
+    """A ``[n, hidden]`` tensor whose first column counts up from ``start_val``.
+
+    ``[n, hidden]`` mirrors the connector async-chunk shape (tokens x hidden).
+    """
+    base = torch.arange(start_val, start_val + n, dtype=torch.float32).unsqueeze(1)
+    return base.repeat(1, hidden)
+
+
+# --------------------------------------------------------------------------- #
+# get_tensor_span                                                             #
+# --------------------------------------------------------------------------- #
+def test_get_tensor_span_valid_returns_triplet():
+    tensor = _rows(3, hidden=4)
+    payload = {"emb": tensor, "start": 5, "end": 8}
+
+    span = get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end")
+
+    assert span is not None
+    got_tensor, start, end = span
+    assert got_tensor is tensor
+    assert (start, end) == (5, 8)
+
+
+def test_get_tensor_span_non_tensor_returns_none():
+    payload = {"emb": None, "start": 0, "end": 0}
+    assert get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end") is None
+
+
+def test_get_tensor_span_non_int_bounds_returns_none():
+    tensor = _rows(2)
+    # start is a float, not an int -> rejected.
+    payload = {"emb": tensor, "start": 0.0, "end": 2}
+    assert get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end") is None
+
+
+def test_get_tensor_span_negative_start_returns_none():
+    tensor = _rows(1)
+    payload = {"emb": tensor, "start": -1, "end": 0}
+    assert get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end") is None
+
+
+def test_get_tensor_span_end_before_start_returns_none():
+    tensor = _rows(2)
+    payload = {"emb": tensor, "start": 5, "end": 3}
+    assert get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end") is None
+
+
+def test_get_tensor_span_length_mismatch_returns_none():
+    tensor = _rows(3)  # tensor.shape[0] == 3
+    payload = {"emb": tensor, "start": 0, "end": 2}  # end - start == 2
+    assert get_tensor_span(payload, tensor_key="emb", start_key="start", end_key="end") is None
+
+
+# --------------------------------------------------------------------------- #
+# merge_tensor_spans                                                          #
+# --------------------------------------------------------------------------- #
+def test_merge_none_operand_returns_none():
+    span = (_rows(2), 0, 2)
+    assert merge_tensor_spans(None, span) is None
+    assert merge_tensor_spans(span, None) is None
+
+
+def test_merge_adjacent_spans_concatenates():
+    existing = (_rows(3, start_val=0), 0, 3)
+    incoming = (_rows(2, start_val=3), 3, 5)
+
+    merged = merge_tensor_spans(existing, incoming)
+
+    assert merged is not None
+    tensor, start, end = merged
+    assert (start, end) == (0, 5)
+    assert tensor.shape[0] == 5
+    assert tensor[:, 0].tolist() == [0.0, 1.0, 2.0, 3.0, 4.0]
+
+
+def test_merge_overlapping_spans_trims_incoming():
+    # existing covers [0, 3); incoming covers [2, 5) -> 1 row of overlap.
+    existing = (_rows(3, start_val=0), 0, 3)
+    incoming = (_rows(3, start_val=100), 2, 5)
+
+    merged = merge_tensor_spans(existing, incoming)
+
+    assert merged is not None
+    tensor, start, end = merged
+    assert (start, end) == (0, 5)
+    # First 3 rows from existing, then incoming's tail (overlap=1 row trimmed).
+    assert tensor[:, 0].tolist() == [0.0, 1.0, 2.0, 101.0, 102.0]
+
+
+def test_merge_fully_overlapping_incoming_keeps_existing():
+    # incoming [1, 3) is fully covered by existing [0, 3): overlap >= incoming len.
+    existing = (_rows(3, start_val=0), 0, 3)
+    incoming = (_rows(2, start_val=100), 1, 3)
+
+    merged = merge_tensor_spans(existing, incoming)
+
+    assert merged is not None
+    tensor, start, end = merged
+    assert (start, end) == (0, 3)
+    assert tensor is existing[0]  # returned unchanged
+
+
+def test_merge_non_contiguous_spans_returns_none():
+    # gap between existing end (3) and incoming start (5).
+    existing = (_rows(3, start_val=0), 0, 3)
+    incoming = (_rows(2, start_val=100), 5, 7)
+
+    assert merge_tensor_spans(existing, incoming) is None
+
+
+def test_merge_casts_incoming_to_existing_dtype_and_device():
+    existing = (_rows(2, start_val=0).to(torch.float32), 0, 2)
+    incoming = (torch.arange(2, 4, dtype=torch.int64).unsqueeze(1), 2, 4)
+
+    merged = merge_tensor_spans(existing, incoming)
+
+    assert merged is not None
+    tensor, _, _ = merged
+    assert tensor.dtype == torch.float32
+    assert tensor.device == existing[0].device
+
+
+# --------------------------------------------------------------------------- #
+# get_tensor_span_row                                                         #
+# --------------------------------------------------------------------------- #
+def test_get_tensor_span_row_in_range():
+    span = (_rows(3, start_val=10), 5, 8)  # rows map to indices 5, 6, 7
+    row = get_tensor_span_row(span, 6)
+    assert row is not None
+    assert row[0].item() == 11.0  # second row (start_val 10 + 1)
+
+
+def test_get_tensor_span_row_none_span_returns_none():
+    assert get_tensor_span_row(None, 0) is None
+
+
+def test_get_tensor_span_row_below_start_returns_none():
+    span = (_rows(3), 5, 8)
+    assert get_tensor_span_row(span, 4) is None
+
+
+def test_get_tensor_span_row_at_or_above_end_returns_none():
+    span = (_rows(3), 5, 8)
+    assert get_tensor_span_row(span, 8) is None
diff --git a/tests/worker/test_sampler_history_backfill.py b/tests/worker/test_sampler_history_backfill.py
new file mode 100644
index 000000000..5f1b520b6
--- /dev/null
+++ b/tests/worker/test_sampler_history_backfill.py
@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Golden characterization of ``_build_model_sampler_output_token_ids``.
+
+The base runner (``OmniGPUModelRunner``) and the AR runner
+(``GPUARModelRunner``) implement the SAME async-placeholder backfill, but the
+AR copy adds a trailing crop step: after backfill it truncates every history at
+the first remaining ``-1``, while the base copy KEEPS residual ``-1``s.
+
+A later change collapses these two copies into one; these goldens pin today's divergence
+exactly (crop vs keep) so that merge is provably behaviour-preserving. Pure CPU.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _runner(
+    cls,
+    *,
+    req_ids,
+    req_output_token_ids,
+    sampled_token_ids_cpu,
+    prev_req_id_to_index,
+):
+    """Build a fake runner exposing only the ``input_batch`` fields the method reads."""
+    runner = object.__new__(cls)
+    event = SimpleNamespace(synchronize=lambda: None)
+    runner.input_batch = SimpleNamespace(
+        req_output_token_ids=req_output_token_ids,
+        req_ids=req_ids,
+        sampled_token_ids_cpu=(None if sampled_token_ids_cpu is None else torch.tensor(sampled_token_ids_cpu)),
+        async_copy_ready_event=event,
+        prev_req_id_to_index=prev_req_id_to_index,
+    )
+    return runner
+
+
+def _build(cls, **kwargs):
+    return cls._build_model_sampler_output_token_ids(_runner(cls, **kwargs))
+
+
+# --------------------------------------------------------------------------- #
+# Shared behaviour — base and AR agree                                        #
+# --------------------------------------------------------------------------- #
+@pytest.mark.parametrize("cls", [OmniGPUModelRunner, GPUARModelRunner])
+def test_full_backfill_no_residual_placeholder(cls):
+    # One trailing placeholder, one sampled token -> fully resolved for both.
+    out = _build(
+        cls,
+        req_ids=["r0"],
+        req_output_token_ids=[[10, 11, -1]],
+        sampled_token_ids_cpu=[[42]],
+        prev_req_id_to_index={"r0": 0},
+    )
+    assert out == [[10, 11, 42]]
+
+
+@pytest.mark.parametrize("cls", [OmniGPUModelRunner, GPUARModelRunner])
+def test_spec_decode_trailing_pad_in_sampled_is_trimmed(cls):
+    # sampled row has a trailing -1 pad; only the real prefix [42, 43] is used.
+    out = _build(
+        cls,
+        req_ids=["r0"],
+        req_output_token_ids=[[10, -1, -1]],
+        sampled_token_ids_cpu=[[42, 43, -1]],
+        prev_req_id_to_index={"r0": 0},
+    )
+    assert out == [[10, 42, 43]]
+
+
+@pytest.mark.parametrize("cls", [OmniGPUModelRunner, GPUARModelRunner])
+def test_no_trailing_placeholder_is_untouched(cls):
+    out = _build(
+        cls,
+        req_ids=["r0"],
+        req_output_token_ids=[[10, 11, 12]],
+        sampled_token_ids_cpu=[[42]],
+        prev_req_id_to_index={"r0": 0},
+    )
+    assert out == [[10, 11, 12]]
+
+
+@pytest.mark.parametrize("cls", [OmniGPUModelRunner, GPUARModelRunner])
+def test_early_return_when_sampled_absent_keeps_placeholders(cls):
+    # sampled_token_ids_cpu is None -> both copies return BEFORE the crop step,
+    # so even the AR copy keeps residual -1 here.
+    out = _build(
+        cls,
+        req_ids=["r0"],
+        req_output_token_ids=[[10, -1]],
+        sampled_token_ids_cpu=None,
+        prev_req_id_to_index={"r0": 0},
+    )
+    assert out == [[10, -1]]
+
+
+# --------------------------------------------------------------------------- #
+# Divergence — base KEEPS residual -1, AR CROPS at the first -1                #
+# --------------------------------------------------------------------------- #
+_RESIDUAL_CASE = dict(
+    req_ids=["r0"],
+    req_output_token_ids=[[10, -1, -1]],  # two placeholders
+    sampled_token_ids_cpu=[[42]],  # only one sampled token -> one -1 remains
+    prev_req_id_to_index={"r0": 0},
+)
+
+
+def test_base_keeps_residual_placeholder():
+    out = _build(OmniGPUModelRunner, **_RESIDUAL_CASE)
+    assert out == [[10, 42, -1]]
+
+
+def test_ar_crops_residual_placeholder():
+    out = _build(GPUARModelRunner, **_RESIDUAL_CASE)
+    assert out == [[10, 42]]
+
+
+_ABSENT_FROM_PREV_CASE = dict(
+    req_ids=["r0"],
+    req_output_token_ids=[[10, -1]],
+    sampled_token_ids_cpu=[[42]],
+    prev_req_id_to_index={},  # r0 not present last step -> no backfill happens
+)
+
+
+def test_base_keeps_placeholder_when_request_absent_from_prev_step():
+    out = _build(OmniGPUModelRunner, **_ABSENT_FROM_PREV_CASE)
+    assert out == [[10, -1]]
+
+
+def test_ar_crops_placeholder_when_request_absent_from_prev_step():
+    # No backfill occurred, but the AR crop pass still truncates at the -1.
+    out = _build(GPUARModelRunner, **_ABSENT_FROM_PREV_CASE)
+    assert out == [[10]]
diff --git a/tests/worker/test_worker_base.py b/tests/worker/test_worker_base.py
new file mode 100644
index 000000000..d470d86a8
--- /dev/null
+++ b/tests/worker/test_worker_base.py
@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Characterization tests for ``vllm_omni.worker.base.OmniGPUWorkerBase``.
+
+Pins the CURRENT behaviour of ``determine_available_memory`` (BOTH the NVML /
+process-scoped arm AND the profiling-fallback arm — this base still carries the
+NVML branch), plus the
+memory-pool / sleep / wake-up plumbing that a later change may touch.
+
+Workers are constructed via ``object.__new__`` with only the attributes each
+method reads; module-level collaborators are monkeypatched. Pure CPU.
+"""
+
+from contextlib import contextmanager, nullcontext
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+import vllm_omni.worker.base as base
+from vllm_omni.worker.base import OmniGPUWorkerBase
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+GIB = 1024**3
+
+
+def _fake_memory_profiling(*, non_torch: int, torch_peak: int):
+    """A stand-in for ``vllm.utils.mem_utils.memory_profiling`` context manager."""
+
+    @contextmanager
+    def _mp(snapshot, weights_memory):  # noqa: ARG001 - signature parity only
+        yield SimpleNamespace(
+            non_torch_increase=non_torch,
+            torch_peak_increase=torch_peak,
+        )
+
+    return _mp
+
+
+def _make_worker(*, requested_memory: int, kv_cache_memory_bytes: int = 0, model_memory_usage: int = 0):
+    worker = object.__new__(OmniGPUWorkerBase)
+    worker.cache_config = SimpleNamespace(kv_cache_memory_bytes=kv_cache_memory_bytes)
+    worker.model_runner = SimpleNamespace(
+        profile_run=lambda: None,
+        model_memory_usage=model_memory_usage,
+    )
+    worker.init_snapshot = object()  # unused once memory_profiling is faked
+    worker.requested_memory = requested_memory
+    worker.local_rank = 0
+    return worker
+
+
+# --------------------------------------------------------------------------- #
+# determine_available_memory                                                  #
+# --------------------------------------------------------------------------- #
+def test_determine_available_memory_nvml_arm(monkeypatch):
+    """NVML available -> available = requested - per-process memory."""
+    worker = _make_worker(requested_memory=30 * GIB, model_memory_usage=10 * GIB)
+    monkeypatch.setattr(base, "memory_profiling", _fake_memory_profiling(non_torch=1 * GIB, torch_peak=2 * GIB))
+    monkeypatch.setattr(base, "is_process_scoped_memory_available", lambda: True)
+    monkeypatch.setattr(base, "detect_pid_host", lambda: True)
+    monkeypatch.setattr(base, "get_process_gpu_memory", lambda local_rank: 8 * GIB)
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    # NVML arm ignores profiled usage; uses process_memory directly.
+    assert out == 30 * GIB - 8 * GIB
+
+
+def test_determine_available_memory_profiling_fallback_arm(monkeypatch):
+    """NVML unavailable -> available = requested - (weights + peak + non_torch)."""
+    worker = _make_worker(requested_memory=30 * GIB, model_memory_usage=10 * GIB)
+    monkeypatch.setattr(base, "memory_profiling", _fake_memory_profiling(non_torch=1 * GIB, torch_peak=2 * GIB))
+    monkeypatch.setattr(base, "is_process_scoped_memory_available", lambda: False)
+    # detect_pid_host is short-circuited by the `and`, but pin it anyway.
+    monkeypatch.setattr(base, "detect_pid_host", lambda: True)
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    profiled = 10 * GIB + 2 * GIB + 1 * GIB
+    assert out == 30 * GIB - profiled
+
+
+def test_determine_available_memory_falls_back_when_not_pid_host(monkeypatch):
+    """detect_pid_host False also routes to the profiling fallback."""
+    worker = _make_worker(requested_memory=20 * GIB, model_memory_usage=5 * GIB)
+    monkeypatch.setattr(base, "memory_profiling", _fake_memory_profiling(non_torch=0, torch_peak=0))
+    monkeypatch.setattr(base, "is_process_scoped_memory_available", lambda: True)
+    monkeypatch.setattr(base, "detect_pid_host", lambda: False)
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    assert out == 20 * GIB - 5 * GIB
+
+
+def test_determine_available_memory_clamps_to_zero(monkeypatch):
+    """Over-subscription clamps the KV budget to 0, never negative."""
+    worker = _make_worker(requested_memory=5 * GIB, model_memory_usage=0)
+    monkeypatch.setattr(base, "memory_profiling", _fake_memory_profiling(non_torch=0, torch_peak=0))
+    monkeypatch.setattr(base, "is_process_scoped_memory_available", lambda: True)
+    monkeypatch.setattr(base, "detect_pid_host", lambda: True)
+    monkeypatch.setattr(base, "get_process_gpu_memory", lambda local_rank: 8 * GIB)
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    assert out == 0
+
+
+def test_determine_available_memory_kv_cache_short_circuit(monkeypatch):
+    """A pre-set kv_cache_memory_bytes short-circuits profiling and is returned."""
+    worker = _make_worker(requested_memory=30 * GIB, kv_cache_memory_bytes=7 * GIB)
+    profile_calls = []
+    worker.model_runner.profile_run = lambda: profile_calls.append(True)
+    # is_rocm gates only an extra synchronize on the short-circuit path.
+    monkeypatch.setattr(base, "current_omni_platform", SimpleNamespace(is_rocm=lambda: False))
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    assert out == 7 * GIB
+    assert profile_calls == [True]  # profile_run still runs before returning
+
+
+def test_determine_available_memory_kv_short_circuit_syncs_on_rocm(monkeypatch):
+    """On ROCm the short-circuit adds an accelerator synchronize (a later change may remove it)."""
+    worker = _make_worker(requested_memory=30 * GIB, kv_cache_memory_bytes=7 * GIB)
+    monkeypatch.setattr(base, "current_omni_platform", SimpleNamespace(is_rocm=lambda: True))
+    synced = []
+    monkeypatch.setattr(torch.accelerator, "synchronize", lambda: synced.append(True))
+
+    out = OmniGPUWorkerBase.determine_available_memory(worker)
+
+    assert out == 7 * GIB
+    assert synced == [True]  # ROCm path synchronizes; non-ROCm path (above) does not
+
+
+# --------------------------------------------------------------------------- #
+# _maybe_get_memory_pool_context                                              #
+# --------------------------------------------------------------------------- #
+def test_memory_pool_context_disabled_returns_nullcontext():
+    worker = object.__new__(OmniGPUWorkerBase)
+    worker.rank = 0
+    worker.cache_config = SimpleNamespace(enable_sleep_mode=False)
+    # No vllm_config attribute -> v1_config_enabled stays False.
+
+    ctx = OmniGPUWorkerBase._maybe_get_memory_pool_context(worker, "weights")
+
+    assert isinstance(ctx, type(nullcontext()))
+
+
+def test_memory_pool_context_enabled_uses_cumem_pool_with_tag(monkeypatch):
+    import vllm.device_allocator.cumem as cumem_mod
+
+    worker = object.__new__(OmniGPUWorkerBase)
+    worker.rank = 0
+    worker.cache_config = SimpleNamespace(enable_sleep_mode=True)
+    monkeypatch.setattr(base, "current_omni_platform", SimpleNamespace(synchronize=lambda: None))
+
+    recorded = {}
+
+    class FakeAllocator:
+        @classmethod
+        def get_instance(cls):
+            return cls()
+
+        def use_memory_pool(self, tag):
+            recorded["tag"] = tag
+            return "POOL_CTX"
+
+    monkeypatch.setattr(cumem_mod, "CuMemAllocator", FakeAllocator)
+
+    ctx = OmniGPUWorkerBase._maybe_get_memory_pool_context(worker, "weights")
+
+    assert ctx == "POOL_CTX"
+    assert recorded["tag"] == "weights"
+
+
+# --------------------------------------------------------------------------- #
+# sleep / wake_up                                                             #
+# --------------------------------------------------------------------------- #
+def _fake_platform():
+    return SimpleNamespace(
+        get_current_memory_usage=lambda device: 0,
+        empty_cache=lambda: None,
+        synchronize=lambda: None,
+    )
+
+
+@pytest.mark.parametrize(
+    ("level", "expected_tags"),
+    [(1, ("weights",)), (2, tuple())],
+)
+def test_sleep_offload_tags_by_level(monkeypatch, level, expected_tags):
+    import vllm.device_allocator.cumem as cumem_mod
+
+    worker = object.__new__(OmniGPUWorkerBase)
+    worker.rank = 0
+    worker.device = "cuda:0"
+    monkeypatch.setattr(base, "current_omni_platform", _fake_platform())
+
+    calls = {}
+
+    class FakeAllocator:
+        @classmethod
+        def get_instance(cls):
+            return cls()
+
+        def sleep(self, offload_tags):
+            calls["offload_tags"] = offload_tags
+
+    monkeypatch.setattr(cumem_mod, "CuMemAllocator", FakeAllocator)
+
+    assert OmniGPUWorkerBase.sleep(worker, level=level) is True
+    assert calls["offload_tags"] == expected_tags
+
+
+def test_wake_up_forwards_tags_to_allocator(monkeypatch):
+    import vllm.device_allocator.cumem as cumem_mod
+
+    worker = object.__new__(OmniGPUWorkerBase)
+    worker.rank = 0
+    monkeypatch.setattr(base, "current_omni_platform", SimpleNamespace(synchronize=lambda: None))
+
+    calls = {}
+
+    class FakeAllocator:
+        @classmethod
+        def get_instance(cls):
+            return cls()
+
+        def wake_up(self, tags):
+            calls["tags"] = tags
+
+    monkeypatch.setattr(cumem_mod, "CuMemAllocator", FakeAllocator)
+
+    assert OmniGPUWorkerBase.wake_up(worker, tags=["weights"]) is True
+    assert calls["tags"] == ["weights"]
diff --git a/tools/baselines/omni_hash_baseline.py b/tools/baselines/omni_hash_baseline.py
new file mode 100644
index 000000000..1bb93099b
--- /dev/null
+++ b/tools/baselines/omni_hash_baseline.py
@@ -0,0 +1,276 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Record / verify a deterministic text+audio output hash baseline for an Omni model.
+
+This is the cheap "output is bit-identical" gate for the behaviour-preserving
+worker/model-runner changes: record a baseline on the bench box
+BEFORE any code moves, then re-run with ``--check`` after each refactor.
+
+Determinism: **batch size 1** (one prompt per ``generate`` call) + **fixed seed**.
+Thinker and code2wav run greedy (temperature 0); the talker's speech sampler needs
+temperature to emit valid codec tokens, so it runs at its natural sampling with a
+fixed seed (reproducible via seed + batch-1, not pure-greedy). 3 fixed prompts, run
+with async output OFF and ON (6 entries total). Hashes are only meaningful WITHIN a single recorded
+environment (driver/cuda/torch/gpu), so the baseline JSON records the env and
+``--check`` refuses to compare across a changed env unless ``--force-env``.
+
+Baseline JSON schema (results keyed by BOTH prompt_id and async_mode so the
+matrix is self-identifying)::
+
+    {
+      "model": "...",
+      "commit": "<git sha>",
+      "env": {"driver": "<nvidia driver>", "cuda": "<cuda build>", "torch": "...", "gpu": "..."},
+      "results": [
+        {"prompt_id": 0, "async_mode": false, "text_sha": "...", "wav_sha": "..."},
+        ...  # exactly len(FIXED_PROMPTS) * 2 entries
+      ]
+    }
+
+The file content is JSON, but committed baselines use a NON-``.json`` extension
+(``.baseline``) because the repo ``.gitignore`` excludes ``*.json``; ``--check``
+loads by content, so the extension does not matter to the script.
+
+Usage::
+
+    # record (run twice, confirm the two runs are identical before committing)
+    python tools/baselines/omni_hash_baseline.py <model> --yaml <deploy.yaml> \
+        --out tools/baselines/<model>_hash.baseline
+    # verify after a refactor (same bench box)
+    python tools/baselines/omni_hash_baseline.py <model> --yaml <deploy.yaml> \
+        --check tools/baselines/<model>_hash.baseline
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import subprocess
+import sys
+
+import torch
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.entrypoints.omni import Omni
+
+SEED = 42
+DEFAULT_SYSTEM = (
+    "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, "
+    "capable of perceiving auditory and visual inputs, as well as generating "
+    "text and speech."
+)
+
+# 3 fixed prompts — do NOT edit once a baseline is recorded (prompt_id is positional).
+FIXED_PROMPTS = [
+    "Explain the system architecture for a scalable audio generation pipeline. Answer in 15 words.",
+    "Describe how ocean tides work. Answer in 15 words.",
+    "List three benefits of unit tests. Answer in 15 words.",
+]
+ASYNC_MODES = (False, True)
+
+
+def _text_prompt(question: str) -> dict:
+    return {
+        "prompt": (
+            f"<|im_start|>system\n{DEFAULT_SYSTEM}<|im_end|>\n"
+            f"<|im_start|>user\n{question}<|im_end|>\n"
+            f"<|im_start|>assistant\n"
+        )
+    }
+
+
+def _sha(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _git_commit() -> str:
+    try:
+        return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip()
+    except Exception:
+        return "unknown"
+
+
+def _driver_version() -> str:
+    """The actual NVIDIA driver version (NOT torch.version.cuda, which is the build)."""
+    try:
+        out = subprocess.check_output(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"], text=True)
+        return out.strip().splitlines()[0].strip()
+    except Exception:
+        return "unknown"
+
+
+def _env_fingerprint() -> dict:
+    gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu"
+    return {
+        "driver": _driver_version(),
+        "cuda": str(torch.version.cuda),
+        "torch": torch.__version__,
+        "gpu": gpu,
+    }
+
+
+def _sampling_params() -> list[SamplingParams]:
+    # thinker + code2wav: greedy. talker: seeded (temperature>0) — its speech sampler
+    # needs temperature to emit valid codec tokens; the fixed seed keeps it reproducible.
+    thinker = SamplingParams(
+        temperature=0.0, top_p=1.0, top_k=-1, max_tokens=128, seed=SEED, detokenize=True, repetition_penalty=1.1
+    )
+    talker = SamplingParams(
+        temperature=0.9, top_p=0.8, top_k=40, max_tokens=256, seed=SEED, detokenize=True, repetition_penalty=1.05
+    )
+    code2wav = SamplingParams(
+        temperature=0.0, top_p=1.0, top_k=-1, max_tokens=256, seed=SEED, detokenize=True, repetition_penalty=1.1
+    )
+    return [thinker, talker, code2wav]
+
+
+def _audio_bytes(audio) -> bytes:
+    """Deterministic bytes for one request's audio, handling chunked (list) output.
+
+    async-chunk mode can emit a list of audio chunks instead of a single tensor;
+    concatenate them along the last axis in emit order.
+    """
+    if isinstance(audio, (list, tuple)):
+        chunks = [a for a in audio if a is not None]
+        if not chunks:
+            return b""
+        audio = torch.cat([torch.as_tensor(a).detach().to(torch.float32).cpu() for a in chunks], dim=-1)
+    if audio is None:
+        return b""
+    return torch.as_tensor(audio).detach().to(torch.float32).cpu().numpy().tobytes()
+
+
+def _run_once(model: str, yaml_path: str, *, async_mode: bool) -> list[dict]:
+    """One deterministic pass, batch size 1 per prompt; returns per-prompt hashes."""
+    # ``async_chunk`` is the repo's documented async-output toggle for streaming
+    # (see tests/e2e/accuracy/qwen3_omni). Confirm the exact knob at bench time.
+    omni = Omni(
+        model,
+        stage_configs_path=yaml_path,
+        stage_init_timeout=1800,
+        init_timeout=3600,
+        async_chunk=async_mode,
+    )
+    results: list[dict] = []
+    try:
+        for prompt_id, question in enumerate(FIXED_PROMPTS):
+            text: str | None = None
+            wav: bytes = b""
+            # Batch size 1: submit a single prompt so scheduling is deterministic.
+            for step in omni.generate([_text_prompt(question)], _sampling_params(), py_generator=False):
+                out = step.request_output
+                if step.final_output_type == "text":
+                    text = out.outputs[0].text  # exact text, no strip -> truly bit-identical
+                elif step.final_output_type == "audio":
+                    wav = _audio_bytes(out.outputs[0].multimodal_output["audio"])
+            if text is None:
+                raise RuntimeError(f"prompt_id={prompt_id} async={async_mode}: produced no text output")
+            if not wav:
+                raise RuntimeError(f"prompt_id={prompt_id} async={async_mode}: produced no/empty audio output")
+            results.append(
+                {
+                    "prompt_id": prompt_id,
+                    "async_mode": async_mode,
+                    "text_sha": _sha(text.encode("utf-8")),
+                    "wav_sha": _sha(wav),
+                }
+            )
+    finally:
+        omni.close()
+    return results
+
+
+def _record(model: str, yaml_path: str) -> dict:
+    results: list[dict] = []
+    for async_mode in ASYNC_MODES:
+        results.extend(_run_once(model, yaml_path, async_mode=async_mode))
+    return {"model": model, "commit": _git_commit(), "env": _env_fingerprint(), "results": results}
+
+
+def _key(record: dict):
+    return (record["prompt_id"], record["async_mode"])
+
+
+def _expected_keys() -> set:
+    return {(pid, mode) for pid in range(len(FIXED_PROMPTS)) for mode in ASYNC_MODES}
+
+
+def _check(model: str, yaml_path: str, baseline_path: str, *, force_env: bool) -> int:
+    with open(baseline_path) as fh:
+        baseline = json.load(fh)
+
+    now = _record(model, yaml_path)
+    if not force_env and baseline.get("env") != now["env"]:
+        print(
+            f"ENV MISMATCH: baseline={baseline.get('env')} now={now['env']} — hashes are "
+            "env-specific. Re-record on this box or pass --force-env.",
+            file=sys.stderr,
+        )
+        return 2
+
+    problems: list[str] = []
+
+    def _index_unique(records: list[dict], label: str) -> dict:
+        by_key: dict = {}
+        for record in records:
+            key = _key(record)
+            if key in by_key:
+                problems.append(f"{label}: duplicate entry for (prompt_id={key[0]}, async={key[1]})")
+            by_key[key] = record
+        return by_key
+
+    base_by_key = _index_unique(baseline["results"], "baseline")
+    now_by_key = _index_unique(now["results"], "current-run")
+    expected = _expected_keys()
+
+    # Guard against duplicate-collapse: the record count must match the key count.
+    if len(baseline["results"]) != len(expected):
+        problems.append(f"baseline has {len(baseline['results'])} records, expected exactly {len(expected)}")
+    if set(now_by_key) != expected:
+        problems.append(f"current-run key set {sorted(set(now_by_key))} != expected {sorted(expected)}")
+    if set(base_by_key) != set(now_by_key):
+        missing = sorted(set(base_by_key) - set(now_by_key))
+        extra = sorted(set(now_by_key) - set(base_by_key))
+        problems.append(f"baseline/run key-set mismatch: missing-from-run={missing} extra-in-run={extra}")
+    for key in sorted(set(base_by_key) & set(now_by_key)):
+        b, r = base_by_key[key], now_by_key[key]
+        if (b["text_sha"], b["wav_sha"]) != (r["text_sha"], r["wav_sha"]):
+            problems.append(
+                f"HASH MISMATCH (prompt_id={key[0]}, async={key[1]}): "
+                f"text {b['text_sha'][:8]}!={r['text_sha'][:8]} / wav {b['wav_sha'][:8]}!={r['wav_sha'][:8]}"
+            )
+
+    if problems:
+        for problem in problems:
+            print(problem, file=sys.stderr)
+        return 1
+    print(f"OK: all {len(expected)} (prompt_id, async_mode) entries match the baseline.")
+    return 0
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("model")
+    p.add_argument("--yaml", required=True, help="Stage deploy config path")
+    p.add_argument("--out", help="Write a new baseline JSON to this path")
+    p.add_argument("--check", metavar="BASELINE_JSON", help="Verify current output against this baseline")
+    p.add_argument("--force-env", action="store_true", help="Compare hashes even if the recorded env differs")
+    args = p.parse_args()
+
+    if args.check:
+        return _check(args.model, args.yaml, args.check, force_env=args.force_env)
+
+    baseline = _record(args.model, args.yaml)
+    payload = json.dumps(baseline, indent=2)
+    if args.out:
+        with open(args.out, "w") as fh:
+            fh.write(payload)
+        print(f"Wrote baseline: {args.out}")
+    else:
+        print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/baselines/qwen3_omni_hash.baseline b/tools/baselines/qwen3_omni_hash.baseline
new file mode 100644
index 000000000..7fed33016
--- /dev/null
+++ b/tools/baselines/qwen3_omni_hash.baseline
@@ -0,0 +1,48 @@
+{
+  "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+  "commit": "24eb4ab89cc2ad3f8cdd83f57b66ce7786a0d65c",
+  "env": {
+    "driver": "570.133.20",
+    "cuda": "13.0",
+    "torch": "2.11.0+cu130",
+    "gpu": "NVIDIA L20X"
+  },
+  "results": [
+    {
+      "prompt_id": 0,
+      "async_mode": false,
+      "text_sha": "e4bf6ed906c0dada879874a9cc09f9ba3a4399149262a831a01fd53e6a8fd043",
+      "wav_sha": "20a203a149005f948afd485bbea780fa06c109f3689ebb6b3110f51b3237bd35"
+    },
+    {
+      "prompt_id": 1,
+      "async_mode": false,
+      "text_sha": "2e8a6b141a9747bd68aadc2931f278b89712ad7ad7ae12b25b39e193b241bf68",
+      "wav_sha": "1839a759bb5d8671b6352b2e3110dab5edfa718e38ff073d379176201f1eac8c"
+    },
+    {
+      "prompt_id": 2,
+      "async_mode": false,
+      "text_sha": "e0aa5a513a5162024f35afee3830aeb67f2e378381726adb9d3a66b984aa652d",
+      "wav_sha": "74338df3e8357bc9d0c05bf141b63c45251b12807de34495097edb07fc7b19f8"
+    },
+    {
+      "prompt_id": 0,
+      "async_mode": true,
+      "text_sha": "e4bf6ed906c0dada879874a9cc09f9ba3a4399149262a831a01fd53e6a8fd043",
+      "wav_sha": "e09f862f54b553cc7c64e1631b821a768167768812b3f2cd3d0c69d0da991ee7"
+    },
+    {
+      "prompt_id": 1,
+      "async_mode": true,
+      "text_sha": "2e8a6b141a9747bd68aadc2931f278b89712ad7ad7ae12b25b39e193b241bf68",
+      "wav_sha": "9115d481f62a4b771c4c3d8b89d5c5a01149f002096289ab1da3f034fa388a2b"
+    },
+    {
+      "prompt_id": 2,
+      "async_mode": true,
+      "text_sha": "e0aa5a513a5162024f35afee3830aeb67f2e378381726adb9d3a66b984aa652d",
+      "wav_sha": "6a5985c9d4ca1596518c291228cd29239e76fcaf310c1cdb5921276b7efce801"
+    }
+  ]
+}
diff --git a/tools/install_torchcodec_rocm.sh b/tools/install_torchcodec_rocm.sh
new file mode 100755
index 000000000..787079603
--- /dev/null
+++ b/tools/install_torchcodec_rocm.sh
@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+# Build TorchCodec against the ROCm PyTorch installation.  The PyPI wheel is
+# built against upstream PyTorch and is not ABI-compatible with ROCm builds.
+
+set -euo pipefail
+
+TORCHCODEC_REPO="${TORCHCODEC_REPO:-https://github.com/pytorch/torchcodec.git}"
+# Keep this pinned for ROCm/PyTorch ABI compatibility. When rebasing the ROCm
+# base image or vLLM, revalidate this version against the active torch build.
+TORCHCODEC_BRANCH="${TORCHCODEC_BRANCH:-v0.10.0}"
+TORCHCODEC_WHEEL_CACHE="${TORCHCODEC_WHEEL_CACHE:-/root/.cache/torchcodec-wheels}"
+
+echo "=== TorchCodec ROCm installation ==="
+
+verify_torchcodec() {
+    python3 -c "from torchcodec.decoders import VideoDecoder"
+}
+
+if verify_torchcodec >/dev/null 2>&1; then
+    echo "TorchCodec is already installed and working."
+    exit 0
+fi
+
+install_system_deps() {
+    if ! command -v apt-get >/dev/null 2>&1; then
+        echo "TorchCodec build dependencies are missing and apt-get is unavailable."
+        return 1
+    fi
+    apt-get update
+    apt-get install -y --no-install-recommends \
+        pkg-config \
+        ffmpeg libavcodec-dev libavformat-dev libavutil-dev \
+        libswscale-dev libavdevice-dev libavfilter-dev libswresample-dev
+}
+
+if ! command -v pkg-config >/dev/null 2>&1 || \
+   ! pkg-config --exists libavcodec libavformat libavutil libswscale \
+       libavdevice libavfilter libswresample 2>/dev/null; then
+    echo "Installing missing FFmpeg development dependencies..."
+    install_system_deps
+fi
+
+if ! python3 -c "import packaging, pybind11" >/dev/null 2>&1; then
+    python3 -m pip install packaging pybind11 setuptools wheel
+fi
+
+PYBIND11_DIR=$(python3 -c "import pybind11; print(pybind11.get_cmake_dir())")
+export pybind11_DIR="$PYBIND11_DIR"
+export CMAKE_PREFIX_PATH="${PYBIND11_DIR}:${CMAKE_PREFIX_PATH:-}"
+
+safe_component() {
+    printf '%s' "$1" | sed 's/[^A-Za-z0-9_.-]/_/g'
+}
+
+PYTHON_SOABI=$(python3 -c \
+    "import sysconfig; print(sysconfig.get_config_var('SOABI') or 'unknown')")
+TORCH_VERSION=$(python3 -c "import torch; print(torch.__version__)")
+ROCM_VERSION=$(python3 -c "import torch; print(torch.version.hip or 'none')")
+FFMPEG_VERSION=$(pkg-config --modversion libavcodec 2>/dev/null || echo unknown)
+ARCH_TAG="${PYTORCH_ROCM_ARCH:-all}"
+
+CACHE_DIR="${TORCHCODEC_WHEEL_CACHE}/$(safe_component "$TORCHCODEC_BRANCH")/$(safe_component "$PYTHON_SOABI")/$(safe_component "$TORCH_VERSION")/$(safe_component "$ROCM_VERSION")/$(safe_component "$FFMPEG_VERSION")/$(safe_component "$ARCH_TAG")"
+CACHED_WHEEL=""
+if [ -d "$CACHE_DIR" ]; then
+    CACHED_WHEEL=$(find "$CACHE_DIR" -maxdepth 1 -type f -name 'torchcodec-*.whl' -print -quit)
+fi
+
+validate_wheel_filename() {
+    WHEEL_PATH="$1" python3 - <<'PY'
+from os import environ
+from pathlib import Path
+
+from packaging.utils import parse_wheel_filename
+
+wheel = Path(environ["WHEEL_PATH"])
+parse_wheel_filename(wheel.name)
+PY
+}
+
+if [ -n "$CACHED_WHEEL" ] && validate_wheel_filename "$CACHED_WHEEL"; then
+    echo "Trying cached wheel: $CACHED_WHEEL"
+    if python3 -m pip install --no-deps --force-reinstall "$CACHED_WHEEL" && \
+       verify_torchcodec; then
+        echo "Installed TorchCodec from cache."
+        exit 0
+    fi
+    echo "Cached wheel is incompatible; rebuilding TorchCodec."
+    rm -f "$CACHED_WHEEL"
+fi
+
+BUILD_DIR=$(mktemp -d -t torchcodec-XXXXXX)
+trap 'rm -rf "$BUILD_DIR"' EXIT
+
+cd "$BUILD_DIR"
+echo "Cloning TorchCodec $TORCHCODEC_BRANCH..."
+git clone --depth 1 --branch "$TORCHCODEC_BRANCH" "$TORCHCODEC_REPO" torchcodec
+cd torchcodec
+
+export TORCHCODEC_CMAKE_BUILD_DIR="${PWD}/build"
+export TORCHCODEC_DISABLE_COMPILE_WARNING_AS_ERROR=1
+export I_CONFIRM_THIS_IS_NOT_A_LICENSE_VIOLATION=1
+export CMAKE_GENERATOR=Ninja
+export MAX_JOBS="${MAX_JOBS:-$(nproc)}"
+
+if command -v ccache >/dev/null 2>&1; then
+    export CMAKE_C_COMPILER_LAUNCHER=ccache
+    export CMAKE_CXX_COMPILER_LAUNCHER=ccache
+fi
+
+echo "Building TorchCodec (MAX_JOBS=$MAX_JOBS)..."
+python3 -m pip wheel . --no-build-isolation --no-deps -w "$BUILD_DIR/dist"
+BUILT_WHEEL=$(find "$BUILD_DIR/dist" -maxdepth 1 -type f -name 'torchcodec-*.whl' -print -quit)
+test -n "$BUILT_WHEEL"
+validate_wheel_filename "$BUILT_WHEEL"
+
+python3 -m pip install --no-deps --force-reinstall "$BUILT_WHEEL"
+verify_torchcodec
+
+mkdir -p "$CACHE_DIR"
+cp "$BUILT_WHEEL" "$CACHE_DIR/$(basename "$BUILT_WHEEL")"
+echo "Cached TorchCodec wheel in $CACHE_DIR"
+echo "=== TorchCodec ROCm installation complete ==="
diff --git a/tools/nightly/buildkite_testcase_statistics.py b/tools/nightly/buildkite_testcase_statistics.py
index 7a4f9bff3..740f896f5 100644
--- a/tools/nightly/buildkite_testcase_statistics.py
+++ b/tools/nightly/buildkite_testcase_statistics.py
@@ -903,11 +903,11 @@ def _sample_preview_stats() -> list[tuple]:
             "test-ready",
             None,
             "Custom Pipeline Test",
-            ["tests/e2e/offline_inference/custom_pipeline/test_cp.py"],
+            ["tests/e2e/features/custom_pipeline/test_cp.py"],
             False,
             [],
             1,
-            ["tests/e2e/offline_inference/custom_pipeline/test_cp.py::test_cp_one"],
+            ["tests/e2e/features/custom_pipeline/test_cp.py::test_cp_one"],
             [""],
             set(),
         ),
diff --git a/tools/nightly/run_nightly_jobs.sh b/tools/nightly/run_nightly_jobs.sh
index 7134a36a1..a95eb8876 100644
--- a/tools/nightly/run_nightly_jobs.sh
+++ b/tools/nightly/run_nightly_jobs.sh
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 #
-# Extract steps from .buildkite/test-nightly.yml that contain pytest, synthesize
+# Extract steps from .buildkite/cuda/test-nightly.yml that contain pytest, synthesize
 # small bash wrappers (exports + pytest), run them, and tee output to logs named
 # after each step's Buildkite "key" when present (otherwise a slug of the label).
 # YAML steps whose label contains "Perf Test" run first, then
@@ -51,17 +51,17 @@
 # Usage:
 #   bash path/to/run_nightly_jobs.sh
 #   REPO_ROOT=/path/to/vllm-omni bash path/to/run_nightly_jobs.sh --test-type perf,acc --dry-run
-#   YML=/path/to/vllm-omni/.buildkite/test-nightly.yml bash path/to/run_nightly_jobs.sh
+#   YML=/path/to/vllm-omni/.buildkite/cuda/test-nightly.yml bash path/to/run_nightly_jobs.sh
 #
 # Repository / YAML (no dependency on where this script lives):
-#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/test-nightly.yml
+#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/cuda/test-nightly.yml
 #   • Or set YML (or --yaml) — repo root is inferred as parent of the .buildkite directory
 #   • Or run from inside the clone: git rev-parse --show-toplevel, else walk up from $PWD,
-#     then from the script's directory, until .buildkite/test-nightly.yml exists
+#     then from the script's directory, until .buildkite/cuda/test-nightly.yml exists
 #
 # Optional environment:
 #   REPO_ROOT     - vllm-omni root (working directory for pytest); see above
-#   YML           - path to test-nightly.yml (default: $REPO_ROOT/.buildkite/test-nightly.yml)
+#   YML           - path to test-nightly.yml (default: $REPO_ROOT/.buildkite/cuda/test-nightly.yml)
 #   LOG_DIR       - logs + generated job scripts; when unset, a timestamped directory under
 #                   $REPO_ROOT/logs/ is created:
 #                     nightly_jobs_YYYYMMDD-HHMMSS       (default / YAML nightly steps)
@@ -247,7 +247,7 @@ _nightly_log_dir_basename() {
   fi
 }
 
-BUILDKITE_REL=".buildkite/test-nightly.yml"
+BUILDKITE_REL=".buildkite/cuda/test-nightly.yml"
 
 _find_repo_containing_nightly() {
   local dir="${1:-}"
@@ -267,8 +267,14 @@ _derive_repo_root_from_yml() {
   local yml="$1"
   local d
   d="$(cd "$(dirname "${yml}")" && pwd)"
-  [[ "$(basename "${d}")" == ".buildkite" ]] || return 1
-  printf '%s\n' "$(dirname "${d}")"
+  while [[ "${d}" != "/" ]]; do
+    if [[ "$(basename "${d}")" == ".buildkite" ]]; then
+      printf '%s\n' "$(dirname "${d}")"
+      return 0
+    fi
+    d="$(dirname "${d}")"
+  done
+  return 1
 }
 
 # Resolve REPO_ROOT, YML (no relative path between script and repo)
@@ -278,7 +284,7 @@ if [[ -n "${YML:-}" && -n "${REPO_ROOT:-}" ]]; then
 elif [[ -n "${YML:-}" ]]; then
   YML="$(cd "$(dirname "${YML}")" && pwd)/$(basename "${YML}")"
   if ! REPO_ROOT="$(_derive_repo_root_from_yml "${YML}")"; then
-    echo "Could not derive REPO_ROOT from YML=${YML} (expected file at <repo>/.buildkite/test-nightly.yml)." >&2
+    echo "Could not derive REPO_ROOT from YML=${YML} (expected file at <repo>/.buildkite/cuda/test-nightly.yml)." >&2
     echo "Set REPO_ROOT explicitly (or pass --repo-root) for pytest working directory." >&2
     exit 2
   fi
diff --git a/tools/pre_commit/check_test_marks.py b/tools/pre_commit/check_test_marks.py
new file mode 100644
index 000000000..2afef8b6e
--- /dev/null
+++ b/tools/pre_commit/check_test_marks.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Run a pre-commit hook that fails if test files are modified or added
+that (probably) never run in the CI. For now, this means that every tests file
+needs to have a CI level marker (e.g., core_model, advanced_model, full_model,
+local_model, slow, etc) and hardware mark / helper so that we ensure mutated
+tests will actually be selected as long as there are pytest commands pointing
+at the right paths.
+"""
+
+import os
+import re
+import sys
+
+# CI level markers
+LEVEL_MARKERS = ("core_model", "advanced_model", "full_model", "local_model", "slow")
+
+# Hardware markers. These are platforms and resources that CI filters on.
+# NOTE: If new hardware marks are added to pyproject.toml etc, we need
+# to add them here as well.
+HARDWARE_MARKERS = (
+    "cpu",
+    "gpu",
+    "cuda",
+    "rocm",
+    "xpu",
+    "npu",
+    "musa",
+    "H100",
+    "L4",
+    "MI325",
+    "B60",
+    "S5000",
+    "A2",
+    "A3",
+)
+
+# Helpers from tests/helpers/mark.py that auto-apply hardware marks.
+HARDWARE_HELPERS = ("hardware_test", "hardware_marks")
+
+# Match mark.X since we could also do `from pytest import mark`.
+# \b prevents matching prefixes (e.g., mark.slow vs mark.slow_test).
+LEVEL_RE = re.compile(r"mark\.(?:" + "|".join(LEVEL_MARKERS) + r")\b")
+HARDWARE_RE = re.compile(r"mark\.(?:" + "|".join(HARDWARE_MARKERS) + r")\b")
+HELPER_RE = re.compile(r"(?:" + "|".join(HARDWARE_HELPERS) + r")\s*\(")
+
+MISSING_LEVEL_MARKER = "Level"
+MISSING_HARDWARE_MARKER = "Hardware"
+
+# Check if a file is located under tests/ and matches test_<something>.py
+# or <something>_test.py, since pytest technically collects on both.
+# Note that we use the former everywhere in this repo by convention.
+TEST_FILE_RE = re.compile(r"^tests/(?:.*/)?(?:test_[^/]*\.py$|[^/]*_test\.py$)")
+
+
+def is_test_file(path: str) -> bool:
+    """Determine whether or not a path is pointing at a test file or not."""
+    return bool(TEST_FILE_RE.match(path))
+
+
+def read_test_file(path: str) -> str | None:
+    """Read a test file's contents, or return None if it doesn't exist."""
+    if not os.path.isfile(path):
+        return None
+    with open(path, encoding="utf-8") as f:
+        return f.read()
+
+
+def has_level_marker(contents: str) -> bool:
+    """Check if file contents contain at least one CI level marker."""
+    return bool(LEVEL_RE.search(contents))
+
+
+def has_hardware_marker(contents: str) -> bool:
+    """Check if file contents contain any hardware marker or helpers."""
+    return bool(HARDWARE_RE.search(contents) or HELPER_RE.search(contents))
+
+
+def get_files_missing_markers(
+    staged_files: list[str],
+) -> dict[str, list[str]]:
+    """Return a dict mapping file path to list of missing marker types."""
+    results: dict[str, list[str]] = {}
+    for path in staged_files:
+        if is_test_file(path) and (contents := read_test_file(path)) is not None:
+            missing = []
+            if not has_level_marker(contents):
+                missing.append(MISSING_LEVEL_MARKER)
+            if not has_hardware_marker(contents):
+                missing.append(MISSING_HARDWARE_MARKER)
+            if missing:
+                results[path] = missing
+    return results
+
+
+if __name__ == "__main__":
+    missing = get_files_missing_markers(sys.argv[1:])
+
+    if missing:
+        file_lines = "\n".join(f"  - {path} [{' and '.join(problems)}]" for path, problems in missing.items())
+        print(
+            "\033[91merror:\033[0m test files are missing pytest marks "
+            "required for Buildkite CI collection.\n\n"
+            f"Level marks, e.g.: {', '.join(LEVEL_MARKERS[:4])}\n"
+            f"Hardware marks, e.g.: {', '.join(HARDWARE_MARKERS[:4])}, ...\n"
+            f"  or helpers: {', '.join(HARDWARE_HELPERS)}\n\n"
+            "The following files are missing marks:\n"
+            f"{file_lines}\n\n"
+            "To skip: SKIP=check-test-ci-coverage git commit ..."
+        )
+        sys.exit(1)
diff --git a/tools/run_jobs_common.sh b/tools/run_jobs_common.sh
index ddc1794dc..7aa0861e4 100644
--- a/tools/run_jobs_common.sh
+++ b/tools/run_jobs_common.sh
@@ -181,7 +181,7 @@ _run_jobs_print_timing_summary() {
 # tools/run_merge_jobs.sh). Nightly does not use this entrypoint.
 #
 # Entry scripts must set before calling run_yaml_ci_jobs_main:
-#   BUILDKITE_REL      - e.g. .buildkite/test-ready.yml
+#   BUILDKITE_REL      - e.g. .buildkite/cuda/test-ready.yml
 #   DEFAULT_LOG_SUBDIR - e.g. ready_jobs
 # ---------------------------------------------------------------------------
 
@@ -246,8 +246,14 @@ _run_jobs_derive_repo_root_from_yml() {
   local yml="$1"
   local d
   d="$(cd "$(dirname "${yml}")" && pwd)"
-  [[ "$(basename "${d}")" == ".buildkite" ]] || return 1
-  printf '%s\n' "$(dirname "${d}")"
+  while [[ "${d}" != "/" ]]; do
+    if [[ "$(basename "${d}")" == ".buildkite" ]]; then
+      printf '%s\n' "$(dirname "${d}")"
+      return 0
+    fi
+    d="$(dirname "${d}")"
+  done
+  return 1
 }
 
 run_yaml_ci_jobs_main() {
diff --git a/tools/run_merge_jobs.sh b/tools/run_merge_jobs.sh
index 35b38a8e0..9f9ab13b0 100644
--- a/tools/run_merge_jobs.sh
+++ b/tools/run_merge_jobs.sh
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 #
-# Extract steps from .buildkite/test-merge.yml that contain pytest, synthesize
+# Extract steps from .buildkite/cuda/test-merge.yml that contain pytest, synthesize
 # small bash wrappers (exports + pytest), run them, and tee output to logs named
 # after each step's Buildkite "key" when present (otherwise a slug of the label).
 #
@@ -21,17 +21,17 @@
 # Usage:
 #   bash tools/run_merge_jobs.sh
 #   REPO_ROOT=/path/to/vllm-omni bash tools/run_merge_jobs.sh --model-type diffusion --dry-run
-#   YML=/path/to/vllm-omni/.buildkite/test-merge.yml bash tools/run_merge_jobs.sh
+#   YML=/path/to/vllm-omni/.buildkite/cuda/test-merge.yml bash tools/run_merge_jobs.sh
 #
 # Repository / YAML (no dependency on where this script lives):
-#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/test-merge.yml
+#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/cuda/test-merge.yml
 #   • Or set YML (or --yaml) — repo root is inferred as parent of the .buildkite directory
 #   • Or run from inside the clone: git rev-parse --show-toplevel, else walk up from $PWD,
-#     then from the script's directory, until .buildkite/test-merge.yml exists
+#     then from the script's directory, until .buildkite/cuda/test-merge.yml exists
 #
 # Optional environment:
 #   REPO_ROOT     - vllm-omni root (working directory for pytest); see above
-#   YML           - path to test-merge.yml (default: $REPO_ROOT/.buildkite/test-merge.yml)
+#   YML           - path to test-merge.yml (default: $REPO_ROOT/.buildkite/cuda/test-merge.yml)
 #   LOG_DIR       - logs + generated job scripts (default: $REPO_ROOT/logs/merge_jobs);
 #                   per-job *.log plus timing_summary.log after the run
 #   MODEL_TYPE    - comma-separated and/or repeated flags (default: all); see above
@@ -41,7 +41,7 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-BUILDKITE_REL=".buildkite/test-merge.yml"
+BUILDKITE_REL=".buildkite/cuda/test-merge.yml"
 DEFAULT_LOG_SUBDIR="merge_jobs"
 
 # shellcheck source=tools/run_jobs_common.sh
diff --git a/tools/run_ready_jobs.sh b/tools/run_ready_jobs.sh
index 89f082436..b854faa07 100644
--- a/tools/run_ready_jobs.sh
+++ b/tools/run_ready_jobs.sh
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 #
-# Extract steps from .buildkite/test-ready.yml that contain pytest, synthesize
+# Extract steps from .buildkite/cuda/test-ready.yml that contain pytest, synthesize
 # small bash wrappers (exports + pytest), run them, and tee output to logs named
 # after each step's Buildkite "key" when present (otherwise a slug of the label).
 #
@@ -21,17 +21,17 @@
 # Usage:
 #   bash tools/run_ready_jobs.sh
 #   REPO_ROOT=/path/to/vllm-omni bash tools/run_ready_jobs.sh --model-type omni --dry-run
-#   YML=/path/to/vllm-omni/.buildkite/test-ready.yml bash tools/run_ready_jobs.sh
+#   YML=/path/to/vllm-omni/.buildkite/cuda/test-ready.yml bash tools/run_ready_jobs.sh
 #
 # Repository / YAML (no dependency on where this script lives):
-#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/test-ready.yml
+#   • Set REPO_ROOT (or pass --repo-root) — default YAML is $REPO_ROOT/.buildkite/cuda/test-ready.yml
 #   • Or set YML (or --yaml) — repo root is inferred as parent of the .buildkite directory
 #   • Or run from inside the clone: git rev-parse --show-toplevel, else walk up from $PWD,
-#     then from the script's directory, until .buildkite/test-ready.yml exists
+#     then from the script's directory, until .buildkite/cuda/test-ready.yml exists
 #
 # Optional environment:
 #   REPO_ROOT     - vllm-omni root (working directory for pytest); see above
-#   YML           - path to test-ready.yml (default: $REPO_ROOT/.buildkite/test-ready.yml)
+#   YML           - path to test-ready.yml (default: $REPO_ROOT/.buildkite/cuda/test-ready.yml)
 #   LOG_DIR       - logs + generated job scripts (default: $REPO_ROOT/logs/ready_jobs);
 #                   per-job *.log plus timing_summary.log after the run
 #   MODEL_TYPE    - comma-separated and/or repeated flags (default: all); see above
@@ -41,7 +41,7 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-BUILDKITE_REL=".buildkite/test-ready.yml"
+BUILDKITE_REL=".buildkite/cuda/test-ready.yml"
 DEFAULT_LOG_SUBDIR="ready_jobs"
 
 # shellcheck source=tools/run_jobs_common.sh
diff --git a/vllm_omni/__init__.py b/vllm_omni/__init__.py
index f3c9d9afd..c2cbe9d5c 100644
--- a/vllm_omni/__init__.py
+++ b/vllm_omni/__init__.py
@@ -27,8 +27,14 @@ except ModuleNotFoundError as exc:  # pragma: no cover - optional dependency
     patch = None  # type: ignore
 
 # Register custom configs (AutoConfig, AutoTokenizer) as early as possible.
-from vllm_omni.transformers_utils import configs as _configs  # noqa: F401, E402
-from vllm_omni.transformers_utils import parsers as _parsers  # noqa: F401, E402
+try:
+    from vllm_omni.transformers_utils import configs as _configs  # noqa: F401, E402
+    from vllm_omni.transformers_utils import parsers as _parsers  # noqa: F401, E402
+except ModuleNotFoundError as exc:  # pragma: no cover - optional dependency
+    if exc.name != "vllm":
+        raise
+    # Allow importing vllm_omni without vllm (e.g., documentation builds)
+    pass
 
 from .config import OmniModelConfig
 
diff --git a/vllm_omni/attention/fish_kvcache_attn.py b/vllm_omni/attention/fish_kvcache_attn.py
index 9e552e762..e7235168c 100644
--- a/vllm_omni/attention/fish_kvcache_attn.py
+++ b/vllm_omni/attention/fish_kvcache_attn.py
@@ -111,6 +111,8 @@ def can_use_fish_kvcache_attn(
 
 
 def _is_cuda_graph_capturing() -> bool:
+    if not torch.cuda.is_available():
+        return False
     return bool(torch.cuda.is_current_stream_capturing())
 
 
diff --git a/vllm_omni/attention/fish_kvcache_backend.py b/vllm_omni/attention/fish_kvcache_backend.py
index 0178f722e..4ca6d467b 100644
--- a/vllm_omni/attention/fish_kvcache_backend.py
+++ b/vllm_omni/attention/fish_kvcache_backend.py
@@ -234,11 +234,11 @@ def _forward_with_fish_kvcache(
     if attn_metadata is not None and not attn_metadata.use_cascade:
         num_actual_tokens = attn_metadata.num_actual_tokens
         # vLLM >=0.23.0 lays out the KV cache as
-        # (num_blocks, 2, block_size, num_kv_heads, head_size), so key/value
-        # live on dim 1 (matches FlashAttentionImpl's kv_cache.unbind(1)).
-        # The pre-0.23 layout had them on dim 0; unbind(0) here would split
-        # along num_blocks and raise "too many values to unpack".
-        key_cache, value_cache = kv_cache.unbind(1)
+        # (num_blocks, num_kv_heads, block_size, 2*head_size) with K and V
+        # packed in the last dimension.  Match FlashAttentionImpl's own
+        # unpacking: transpose(1, 2) then split on the content dim.
+        head_size = kv_cache.shape[-1] // 2
+        key_cache, value_cache = kv_cache.transpose(1, 2).split(head_size, dim=-1)
         q = query[:num_actual_tokens]
         out = output[:num_actual_tokens]
         active_batch = int(q.shape[0])
diff --git a/vllm_omni/benchmarks/data_modules/daily_omni_dataset.py b/vllm_omni/benchmarks/data_modules/daily_omni_dataset.py
index 65918414f..95d58e4b3 100644
--- a/vllm_omni/benchmarks/data_modules/daily_omni_dataset.py
+++ b/vllm_omni/benchmarks/data_modules/daily_omni_dataset.py
@@ -52,11 +52,14 @@ Usage:
 """
 
 import base64
+import io
 import json
 import logging
+import math
 import os
 import shutil
 import tarfile
+import wave
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Literal
@@ -77,6 +80,10 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+# Official MiniCPM ``get_video_frame_audio_segments`` default (env ``MAX_NUM_FRAMES``).
+_MINICPM_MAX_NUM_FRAMES = int(os.environ.get("MAX_NUM_FRAMES", "64"))
+_MINICPM_AUDIO_SR = 16000
+
 
 def _daily_omni_hf_cache_root() -> Path:
     return Path(os.environ.get("HF_HOME", Path.home() / ".cache" / "huggingface")).expanduser().resolve()
@@ -203,12 +210,62 @@ class _ListDatasetIterator:
 # Aligns with Lliar-liar/Daily-Omni CLI ``--input_mode`` (test_model/*/testmodel.py).
 DailyOmniInputMode = Literal["all", "visual", "audio"]
 
+# How multimodal parts are packed into OpenAI chat messages:
+# - ``qwen``: one ``video_url`` + one ``audio_url`` (upstream Daily-Omni / Qwen protocol).
+# - ``minicpm-interleave``: 1fps ``[image_i, audio_i, ...]`` matching OpenBMB MiniCPM-o
+#   ``get_video_frame_audio_segments`` + interleaved omni contents (paper ~80% recipe).
+DailyOmniPackMode = Literal["qwen", "minicpm-interleave"]
+
 # ``build_conversation()`` in Daily-Omni ``test_model/Qwen2.5-Omni/testmodel.py`` (verbatim).
 DAILY_OMNI_SYSTEM_TEXT = (
     "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, "
     "capable of perceiving auditory and visual inputs, as well as generating text and speech."
 )
 
+# MiniCPM-o ``get_sys_prompt(mode="omni")`` without ref-audio is an empty system string
+# (still sent as role=system; see ``_build_daily_omni_openai_messages``).
+MINICPM_OMNI_SYSTEM_TEXT = ""
+
+
+def _uniform_sample_indices(n: int, k: int) -> list[int]:
+    """Evenly pick ``k`` indices from ``0..n-1`` (OpenBMB ``uniform_sample`` midpoint bins).
+
+    Matches OmniEvalKit / MiniCPM ``uniform_sample``: midpoint of each equal-width bin,
+    not ``np.linspace`` endpoints. See
+    https://github.com/OpenBMB/OmniEvalKit/blob/1adac0577258d539efc03f16d8a0f4b3f7df6c19/o_e_Kit/utils/utils.py#L50-L54
+    """
+    if k <= 0:
+        return []
+    if n <= k:
+        return list(range(n))
+    gap = n / k
+    return [int(i * gap + gap / 2) for i in range(k)]
+
+
+def _numpy_to_wav_bytes(audio_np: Any, sample_rate: int = _MINICPM_AUDIO_SR) -> bytes:
+    """Encode a mono float/int numpy waveform as 16-bit PCM WAV bytes."""
+    import numpy as np
+
+    arr = np.asarray(audio_np)
+    if arr.ndim > 1:
+        arr = arr.reshape(-1)
+    if arr.dtype != np.int16:
+        arr = np.clip(arr.astype(np.float64), -1.0, 1.0)
+        arr = (arr * 32767.0).astype(np.int16)
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(sample_rate)
+        wf.writeframes(arr.tobytes())
+    return buf.getvalue()
+
+
+def _pil_to_jpeg_bytes(image: Any, quality: int = 85) -> bytes:
+    buf = io.BytesIO()
+    image.save(buf, format="JPEG", quality=quality)
+    return buf.getvalue()
+
 
 @dataclass
 class DailyOmniSampleRequest(SampleRequest):
@@ -262,6 +319,11 @@ class DailyOmniDataset(BenchmarkDataset):
             ``all`` — video + WAV (default; official audio-visual protocol);
             ``visual`` — video only;
             ``audio`` — extracted WAV only (requires ``{video_id}/{video_id}_audio.wav`` under ``video_dir``).
+        pack_mode: Multimodal packing recipe:
+            ``qwen`` — one ``video_url`` + optional ``audio_url`` (default; Daily-Omni/Qwen);
+            ``minicpm-interleave`` — MiniCPM-o paper recipe: 1fps frames interleaved with
+            matching 1s audio segments as ``image_url``/``audio_url`` pairs (required to approach
+            OpenBMB ~80% Daily-Omni; needs local video+WAV under ``video_dir``).
         max_duration_seconds: Reserved for future ffprobe-based filtering; currently **not applied**
             when building requests (metadata ``video_duration`` is still passed through for eval).
         dataset_subset: Optional HuggingFace subset name (``load_dataset(..., name=...)``); used by bench
@@ -270,7 +332,8 @@ class DailyOmniDataset(BenchmarkDataset):
         inline_local_video: If True, embed local MP4 as ``data:video/mp4;base64,...`` in requests so
             the API server does not need ``--allowed-local-media-path`` (large JSON; use for small runs).
             When ``input_mode`` is ``audio`` or ``all``, local WAV is embedded the same way
-            (``data:audio/wav;base64,...``).
+            (``data:audio/wav;base64,...``). For ``minicpm-interleave``, embeds JPEG/WAV segment
+            data URLs instead of the raw MP4.
         trust_remote_code: Whether to trust remote code when loading HuggingFace dataset
             (online mode only).
     """
@@ -291,6 +354,7 @@ class DailyOmniDataset(BenchmarkDataset):
         random_seed: int = 0,
         video_dir: str | None = None,
         input_mode: DailyOmniInputMode = "all",
+        pack_mode: DailyOmniPackMode = "qwen",
         inline_local_video: bool = False,
         trust_remote_code: bool = False,
         max_duration_seconds: float | None = None,
@@ -300,6 +364,8 @@ class DailyOmniDataset(BenchmarkDataset):
     ) -> None:
         if input_mode not in ("all", "visual", "audio"):
             raise ValueError(f"input_mode must be 'all', 'visual', or 'audio', got {input_mode!r}")
+        if pack_mode not in ("qwen", "minicpm-interleave"):
+            raise ValueError(f"pack_mode must be 'qwen' or 'minicpm-interleave', got {pack_mode!r}")
 
         # Validate arguments: need either local JSON or HF path
         if qa_json_path is None and dataset_path is None:
@@ -318,11 +384,14 @@ class DailyOmniDataset(BenchmarkDataset):
         self.video_dir = Path(video_dir) if video_dir else None
         self.inline_local_video = inline_local_video
         self.input_mode: DailyOmniInputMode = input_mode
+        self.pack_mode: DailyOmniPackMode = pack_mode
         self.max_duration_seconds = max_duration_seconds
         self.trust_remote_code = trust_remote_code
 
         #: In-process cache of ffprobe durations only (no disk persistence).
         self._video_durations: dict[str, float] = {}
+        #: Cache of MiniCPM 1fps interleaved expansions: video_id -> content parts.
+        self._minicpm_interleave_cache: dict[str, list[dict[str, Any]]] = {}
 
         # Initialize parent BenchmarkDataset
         super().__init__(
@@ -336,11 +405,13 @@ class DailyOmniDataset(BenchmarkDataset):
 
         # Verify dataset info
         logger.info(
-            "Loaded Daily-Omni dataset: mode=%s, source=%s, random_seed=%d, input_mode=%s, max_duration=%s",
+            "Loaded Daily-Omni dataset: mode=%s, source=%s, random_seed=%d, "
+            "input_mode=%s, pack_mode=%s, max_duration=%s",
             "local_json" if self.qa_json_path else "huggingface",
             str(self.qa_json_path) if self.qa_json_path else f"{dataset_path}/{dataset_split}",
             random_seed,
             input_mode,
+            pack_mode,
             f"{max_duration_seconds}s" if max_duration_seconds else "unlimited",
         )
 
@@ -575,7 +646,8 @@ class DailyOmniDataset(BenchmarkDataset):
         messages = self._build_daily_omni_openai_messages(mm_payload, question, choice)
         user_text = self._official_daily_omni_user_prompt(question, choice)
         # Text-only length estimate (same as before: no MM token count in bench).
-        prompt_len = len(tokenizer.encode(f"{DAILY_OMNI_SYSTEM_TEXT}\n{user_text}"))
+        system_text = self._system_text_for_pack_mode()
+        prompt_len = len(tokenizer.encode(f"{system_text}\n{user_text}" if system_text else user_text))
 
         return DailyOmniSampleRequest(
             prompt=user_text,
@@ -766,10 +838,11 @@ class DailyOmniDataset(BenchmarkDataset):
         video_id: str,
         video_url: str | None,
     ) -> tuple[dict[str, Any] | list[dict[str, Any]] | None, dict[str, Any] | None, Literal["first", "last"]]:
-        """Build ``multi_modal_data`` and request extras for the active ``input_mode``.
+        """Build multimodal OpenAI content parts and request extras for the active modes."""
+        if self.pack_mode == "minicpm-interleave":
+            return self._compose_minicpm_interleaved_multimodal(video_id, video_url)
 
-        Mirrors upstream Daily-Omni: separate video + WAV with ``use_audio_in_video=False``.
-        """
+        # Qwen / upstream Daily-Omni: separate video + WAV with ``use_audio_in_video=False``.
         extra: dict[str, Any] = {"mm_processor_kwargs": {"use_audio_in_video": False}}
         mode = self.input_mode
 
@@ -787,6 +860,219 @@ class DailyOmniDataset(BenchmarkDataset):
             return None, None, "first"
         return [v, a], extra, "first"
 
+    def _compose_minicpm_interleaved_multimodal(
+        self,
+        video_id: str,
+        video_url: str | None,
+    ) -> tuple[list[dict[str, Any]] | None, dict[str, Any] | None, Literal["first", "last"]]:
+        """Pack media like MiniCPM-o official omni chat: 1fps ``[frame_i, audio_i, ...]``.
+
+        OpenBMB's HF / utils path expands ``video_url`` with ``use_audio=True`` into interleaved
+        PIL frames and 1s audio ndarrays. vLLM-Omni does not implement that expansion, so the
+        bench client builds ordered ``image_url`` / ``audio_url`` parts instead. MiniCPM-o 5.0's
+        OpenAI chat template preserves content-part order, so placeholders stay time-aligned.
+
+        ``max_slice_nums=1`` and ``use_image_id=False`` mirror MiniCPM-o's omni path
+        (``modeling_minicpmo.py`` passes both for interleaved frames): slicing every frame with
+        the config default of 9 would blow past ``max_model_len``, and ``<image_id>N</image_id>``
+        prefixes would label each frame as a separate picture instead of a video timeline.
+        """
+        del video_url  # Hub HTTP URLs are not used; local extract is required.
+        extra: dict[str, Any] = {
+            "mm_processor_kwargs": {
+                "use_audio_in_video": False,
+                "max_slice_nums": 1,
+                "use_image_id": False,
+            }
+        }
+        mode = self.input_mode
+        if mode == "audio":
+            # Fall back to whole-WAV for audio-only ablations.
+            a = self._get_audio_content(video_id)
+            return ([a] if a else None), extra, "first"
+
+        parts = self._get_minicpm_interleaved_parts(video_id, include_audio=(mode == "all"))
+        if not parts:
+            return None, None, "first"
+        return parts, extra, "first"
+
+    def _get_minicpm_interleaved_parts(
+        self,
+        video_id: str,
+        *,
+        include_audio: bool,
+    ) -> list[dict[str, Any]] | None:
+        """Return cached or freshly extracted MiniCPM-style interleaved OpenAI content parts."""
+        cache_key = f"{video_id}|audio={int(include_audio)}|inline={int(self.inline_local_video)}"
+        cached = self._minicpm_interleave_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        self._lazy_ensure_hub_media_dir()
+        video_path = self._resolve_local_video_path(video_id)
+        if video_path is None:
+            logger.warning(
+                "MiniCPM interleave pack requires local video under video_dir=%s for video_id=%r",
+                self.video_dir,
+                video_id,
+            )
+            return None
+        audio_path = self._resolve_local_audio_path(video_id) if include_audio else None
+        if include_audio and audio_path is None:
+            logger.warning(
+                "MiniCPM interleave pack (input_mode=all) missing WAV for video_id=%r under %s",
+                video_id,
+                self.video_dir,
+            )
+            return None
+
+        try:
+            frames, audio_segments = self._extract_minicpm_frame_audio_segments(
+                video_path,
+                audio_path=audio_path,
+                include_audio=include_audio,
+            )
+        except Exception:
+            logger.exception(
+                "Failed MiniCPM 1fps extract for video_id=%r path=%s",
+                video_id,
+                video_path,
+            )
+            return None
+
+        if not frames:
+            logger.warning("No frames extracted for video_id=%r", video_id)
+            return None
+        if include_audio and len(audio_segments) != len(frames):
+            logger.warning(
+                "Frame/audio length mismatch for video_id=%r: frames=%d audios=%d",
+                video_id,
+                len(frames),
+                len(audio_segments),
+            )
+            n = min(len(frames), len(audio_segments))
+            frames = frames[:n]
+            audio_segments = audio_segments[:n]
+
+        cache_root: Path | None = None
+        if not self.inline_local_video:
+            assert self.video_dir is not None
+            cache_root = self.video_dir / ".minicpm_daily_omni_interleave" / video_id
+            cache_root.mkdir(parents=True, exist_ok=True)
+
+        parts: list[dict[str, Any]] = []
+        for i, frame in enumerate(frames):
+            jpeg = _pil_to_jpeg_bytes(frame)
+            if self.inline_local_video:
+                b64 = base64.b64encode(jpeg).decode("ascii")
+                parts.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
+                    }
+                )
+            else:
+                assert cache_root is not None
+                frame_path = cache_root / f"frame_{i:04d}.jpg"
+                if not frame_path.is_file() or frame_path.stat().st_size == 0:
+                    frame_path.write_bytes(jpeg)
+                parts.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": frame_path.expanduser().resolve().as_uri()},
+                    }
+                )
+
+            if include_audio:
+                wav = _numpy_to_wav_bytes(audio_segments[i])
+                if self.inline_local_video:
+                    b64 = base64.b64encode(wav).decode("ascii")
+                    parts.append(
+                        {
+                            "type": "audio_url",
+                            "audio_url": {"url": f"data:audio/wav;base64,{b64}"},
+                        }
+                    )
+                else:
+                    assert cache_root is not None
+                    audio_seg_path = cache_root / f"audio_{i:04d}.wav"
+                    if not audio_seg_path.is_file() or audio_seg_path.stat().st_size == 0:
+                        audio_seg_path.write_bytes(wav)
+                    parts.append(
+                        {
+                            "type": "audio_url",
+                            "audio_url": {"url": audio_seg_path.expanduser().resolve().as_uri()},
+                        }
+                    )
+
+        # File URLs are tiny; cache them so repeated QA on the same video skips re-extract.
+        # Inline base64 must not be retained: ~700 Daily-Omni videos would pin GBs of RSS.
+        if not self.inline_local_video:
+            self._minicpm_interleave_cache[cache_key] = parts
+        logger.debug(
+            "MiniCPM interleave packed video_id=%r frames=%d include_audio=%s parts=%d",
+            video_id,
+            len(frames),
+            include_audio,
+            len(parts),
+        )
+        return parts
+
+    @staticmethod
+    def _extract_minicpm_frame_audio_segments(
+        video_path: Path,
+        *,
+        audio_path: Path | None,
+        include_audio: bool,
+        max_num_frames: int = _MINICPM_MAX_NUM_FRAMES,
+    ) -> tuple[list[Any], list[Any]]:
+        """Port of MiniCPM ``get_video_frame_audio_segments`` (stack_frames=1, 1fps)."""
+        import numpy as np
+        from decord import VideoReader, cpu
+        from PIL import Image
+        from vllm.multimodal.media.audio import load_audio
+
+        vr = VideoReader(str(video_path), ctx=cpu(0))
+        avg_fps = float(vr.get_avg_fps()) or 1.0
+        duration = len(vr) / avg_fps
+        num_seconds = max(1, int(math.ceil(duration)))
+        second_timestamps = list(range(num_seconds))
+
+        if duration > max_num_frames:
+            timestamps = [round(i * 0.1, 1) for i in range(int(duration / 0.1))]
+            frame_idx = [min(int(ts * avg_fps), len(vr) - 1) for ts in timestamps]
+            pick = _uniform_sample_indices(len(frame_idx), max_num_frames)
+            frame_idx = [frame_idx[i] for i in pick]
+            timestamps = [timestamps[i] for i in pick]
+        else:
+            frame_idx = [min(int(i * avg_fps), len(vr) - 1) for i in range(num_seconds)]
+            timestamps = second_timestamps
+
+        video = vr.get_batch(frame_idx).asnumpy()
+        frames = [Image.fromarray(v.astype("uint8")).convert("RGB") for v in video]
+
+        audio_segments: list[Any] = []
+        if include_audio:
+            load_path = str(audio_path) if audio_path is not None else str(video_path)
+            audio_np, sr = load_audio(load_path, sr=_MINICPM_AUDIO_SR, mono=True)
+            for i, start_time in enumerate(timestamps):
+                end_time = timestamps[i + 1] if i < len(timestamps) - 1 else duration
+                start_sample = int(start_time * sr)
+                end_sample = int(end_time * sr)
+                segment = audio_np[start_sample:end_sample]
+                if i == len(timestamps) - 1 and len(segment) < 1600:
+                    segment = np.concatenate([segment, np.zeros(1600 - len(segment), dtype=segment.dtype)])
+                if len(segment) == 0:
+                    segment = np.zeros(1600, dtype=np.float32)
+                audio_segments.append(segment)
+
+        return frames, audio_segments
+
+    def _system_text_for_pack_mode(self) -> str:
+        if self.pack_mode == "minicpm-interleave":
+            return MINICPM_OMNI_SYSTEM_TEXT
+        return DAILY_OMNI_SYSTEM_TEXT
+
     @staticmethod
     def _media_desc_for_official_prompt(mode: DailyOmniInputMode) -> str:
         """``media_desc`` in upstream ``build_conversation``."""
@@ -835,14 +1121,19 @@ class DailyOmniDataset(BenchmarkDataset):
         question: str,
         choice: Any,
     ) -> list[dict[str, Any]]:
-        """Map upstream conversation to OpenAI Chat Completions ``messages`` (video_url / audio_url parts)."""
+        """Map upstream conversation to OpenAI Chat Completions ``messages``."""
         user_text = self._official_daily_omni_user_prompt(question, choice)
         mm_list: list[dict[str, Any]] = mm_payload if isinstance(mm_payload, list) else [mm_payload]
         user_content: list[dict[str, Any]] = [*mm_list, {"type": "text", "text": user_text}]
-        return [
-            {"role": "system", "content": [{"type": "text", "text": DAILY_OMNI_SYSTEM_TEXT}]},
-            {"role": "user", "content": user_content},
-        ]
+        system_text = self._system_text_for_pack_mode()
+        messages: list[dict[str, Any]] = []
+        # MiniCPM-o ``get_sys_prompt(mode="omni")`` still emits role=system with empty
+        # content (no ref-audio). Truthiness would drop that role and change chat-template
+        # control tokens; keep the empty system message for minicpm-interleave.
+        if self.pack_mode == "minicpm-interleave" or system_text:
+            messages.append({"role": "system", "content": [{"type": "text", "text": system_text}]})
+        messages.append({"role": "user", "content": user_content})
+        return messages
 
     def sample_by_task_type(
         self,
@@ -900,6 +1191,7 @@ class DailyOmniDataset(BenchmarkDataset):
             f"dataset_split={self.dataset_split!r}, "
             f"video_dir={self.video_dir!r}, "
             f"input_mode={self.input_mode!r}, "
+            f"pack_mode={self.pack_mode!r}, "
             f"inline_local_video={self.inline_local_video!r}, "
             f"max_duration_seconds={self.max_duration_seconds}, "
             f"random_seed={self.random_seed}"
diff --git a/vllm_omni/benchmarks/data_modules/seed_tts_eval.py b/vllm_omni/benchmarks/data_modules/seed_tts_eval.py
index 70ed7cfef..13c1f2c21 100644
--- a/vllm_omni/benchmarks/data_modules/seed_tts_eval.py
+++ b/vllm_omni/benchmarks/data_modules/seed_tts_eval.py
@@ -613,7 +613,12 @@ def compute_seed_tts_wer_metrics(
                 e,
             )
 
-        wav_16k = _pcm_s16le_to_f32_16k(pcm)
+        # Request functions normalize ``tts_output_pcm_bytes`` to Seed-TTS WER
+        # format before it reaches this evaluator: 24 kHz mono int16 PCM.
+        # Do not apply the streamed-response env format here again; for MOSS
+        # local that would reinterpret already-normalized 24 kHz mono audio as
+        # 48 kHz stereo and corrupt ASR/WER.
+        wav_16k = _pcm_s16le_to_f32_16k(pcm, pcm_sample_rate=24000, channels=1)
         if len(wav_16k) == 0:
             asr_failed += 1
             if include_per_item:
diff --git a/vllm_omni/benchmarks/patch/patch.py b/vllm_omni/benchmarks/patch/patch.py
index e4f11b1e7..2d816d718 100644
--- a/vllm_omni/benchmarks/patch/patch.py
+++ b/vllm_omni/benchmarks/patch/patch.py
@@ -48,6 +48,7 @@ from vllm_omni.benchmarks.data_modules.seed_tts_dataset import (
 from vllm_omni.benchmarks.data_modules.sound_effect_dataset import SoundEffectDataset
 from vllm_omni.benchmarks.data_modules.ttsd_dataset import TTSDDataset
 from vllm_omni.metrics import definitions as defs
+from vllm_omni.metrics.utils import coerce_positive_int_scalar
 
 logger = init_logger(__name__)
 
@@ -279,6 +280,7 @@ def get_samples(args, tokenizer):
                 random_seed=args.seed,
                 video_dir=video_dir,
                 input_mode=getattr(args, "daily_omni_input_mode", "all"),
+                pack_mode=getattr(args, "daily_omni_pack_mode", "qwen"),
                 inline_local_video=getattr(args, "daily_omni_inline_local_video", False),
                 trust_remote_code=getattr(args, "trust_remote_code", False),
                 disable_shuffle=getattr(args, "disable_shuffle", False),
@@ -309,6 +311,7 @@ def get_samples(args, tokenizer):
                 random_seed=args.seed,
                 video_dir=video_dir,
                 input_mode=getattr(args, "daily_omni_input_mode", "all"),
+                pack_mode=getattr(args, "daily_omni_pack_mode", "qwen"),
                 inline_local_video=getattr(args, "daily_omni_inline_local_video", False),
                 trust_remote_code=getattr(args, "trust_remote_code", False),
                 no_stream=getattr(args, "no_stream", False),
@@ -524,16 +527,8 @@ def _add_image_edit_extra_body_to_form(form: aiohttp.FormData, extra_body: dict[
             form.add_field(key, str(value))
 
 
-def _coerce_positive_int(value: Any) -> int | None:
-    try:
-        coerced = int(value)
-    except (TypeError, ValueError):
-        return None
-    return coerced if coerced > 0 else None
-
-
 def _extract_output_tokens_from_metrics(metrics: dict[str, Any]) -> int | None:
-    top_level_tokens = _coerce_positive_int(metrics.get(defs.NUM_TOKENS_OUT))
+    top_level_tokens = coerce_positive_int_scalar(metrics.get(defs.NUM_TOKENS_OUT))
     if top_level_tokens is not None:
         return top_level_tokens
 
@@ -545,7 +540,7 @@ def _extract_output_tokens_from_metrics(metrics: dict[str, Any]) -> int | None:
     for info in stage_snapshot.values():
         if not isinstance(info, dict):
             continue
-        num_tokens_out = _coerce_positive_int(info.get(defs.NUM_TOKENS_OUT))
+        num_tokens_out = coerce_positive_int_scalar(info.get(defs.NUM_TOKENS_OUT))
         if num_tokens_out is None:
             continue
         if info.get("final_output_type") == "text" or info.get("output_unit_type") == "token":
@@ -556,9 +551,9 @@ def _extract_output_tokens_from_metrics(metrics: dict[str, Any]) -> int | None:
 
 def _apply_usage_to_output(output: MixRequestFuncOutput, usage: dict[str, Any]) -> int | None:
     """Apply OpenAI ``usage`` fields to the benchmark output."""
-    if (pt := _coerce_positive_int(usage.get("prompt_tokens"))) is not None:
+    if (pt := coerce_positive_int_scalar(usage.get("prompt_tokens"))) is not None:
         output.prompt_len = pt
-    completion_tokens = _coerce_positive_int(usage.get("completion_tokens"))
+    completion_tokens = coerce_positive_int_scalar(usage.get("completion_tokens"))
     if completion_tokens is not None:
         output.output_tokens = max(int(output.output_tokens or 0), completion_tokens)
     return completion_tokens
@@ -901,12 +896,22 @@ async def async_request_openai_chat_omni_completions(
                     audio_frames = 0
                     if response_format == "wav" and wav_pcm_buffer and wav_audio_params is not None:
                         channels, sample_width, frame_rate = wav_audio_params
-                        frame_width = sample_width * channels
-                        if frame_width > 0:
-                            audio_frames = len(wav_pcm_buffer) // frame_width
-                            audio_duration_sec = audio_frames / frame_rate
+                        audio_frames = defs.compute_audio_frames(
+                            len(wav_pcm_buffer),
+                            sample_width=sample_width,
+                            channels=channels,
+                        )
+                        if audio_frames > 0 and frame_rate > 0:
+                            audio_duration_sec = audio_frames / float(frame_rate)
                         else:
-                            logger.warning("Audio frame width is zero")
+                            logger.warning(
+                                "Unable to derive audio frames/duration from wav pcm "
+                                "(pcm_nbytes=%d, sample_width=%d, channels=%d, sample_rate=%d)",
+                                len(wav_pcm_buffer),
+                                sample_width,
+                                channels,
+                                frame_rate,
+                            )
                     elif audio_bytes_buffer:
                         try:
                             from vllm.multimodal.audio import get_audio_duration
@@ -925,10 +930,8 @@ async def async_request_openai_chat_omni_completions(
                         output.audio_duration = audio_duration_sec
                         output.audio_frames = audio_frames
                         audio_duration = output.audio_duration
-                        if audio_duration > 0:
-                            output.audio_rtf = audio_generate_time / output.audio_duration
-                        else:
-                            output.audio_rtf = 0
+                        output.audio_rtf = defs.compute_audio_rtf(audio_generate_time, audio_duration)
+                        if audio_duration <= 0:
                             logger.warning("Audio duration is zero")
                         if _seed_tts_capture_pcm_for_wer() and getattr(request_func_input, "seed_tts_row", False):
                             try:
@@ -1161,7 +1164,7 @@ async def async_request_openai_audio_speech(
 
     # PCM format: 16-bit signed; sample_rate/channels are model-dependent.
     sample_rate, channels = defs.stream_pcm_format_from_env()
-    sample_width = 2  # 16-bit = 2 bytes
+    sample_width = defs.DEFAULT_AUDIO_SAMPLE_WIDTH
 
     st = time.perf_counter()
     output.start_time = st
@@ -1190,13 +1193,17 @@ async def async_request_openai_audio_speech(
                 end_time = time.perf_counter()
                 output.latency = end_time - st
 
-                total_samples = total_pcm_bytes // (sample_width * channels)
-                output.audio_duration = total_samples / sample_rate
+                total_samples = defs.compute_audio_frames(
+                    total_pcm_bytes,
+                    sample_width=sample_width,
+                    channels=channels,
+                )
                 output.audio_frames = total_samples
-                if output.audio_duration > 0:
-                    output.audio_rtf = output.latency / output.audio_duration
-                else:
-                    output.audio_rtf = 0
+                output.audio_duration = (
+                    float(total_samples) / float(sample_rate) if total_samples > 0 and sample_rate > 0 else 0.0
+                )
+                output.audio_rtf = defs.compute_audio_rtf(output.latency, output.audio_duration)
+                if output.audio_duration <= 0:
                     logger.warning("Audio duration is zero")
 
                 continuity = compute_continuity_stats(
diff --git a/vllm_omni/config/config_factory.py b/vllm_omni/config/config_factory.py
index 1b38a3d34..ed9b05f1e 100644
--- a/vllm_omni/config/config_factory.py
+++ b/vllm_omni/config/config_factory.py
@@ -17,7 +17,8 @@ from vllm.transformers_utils.config import get_config
 from vllm.transformers_utils.repo_utils import get_hf_file_to_dict
 
 from vllm_omni.config.endpoint_policy import EndpointRestriction
-from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
+from vllm_omni.config.omni_config import VllmOmniConfig
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
 from vllm_omni.config.stage_config import (
     _DEPLOY_DIR,
     DeployConfig,
@@ -44,6 +45,26 @@ logger = init_logger(__name__)
 _DEFAULT_PARALLEL_DEGREE = 1
 
 
+def with_trust_remote_code_override(
+    overrides: Mapping[str, Any],
+    trust_remote_code: bool | None,
+) -> dict[str, Any]:
+    """Merge the tri-state ``trust_remote_code`` into an override mapping.
+
+    Single home for the precedence rule (explicit caller value > deploy
+    yaml per-stage value > vLLM default False): a non-None value becomes an
+    explicit override; ``None`` means "not specified" and leaves the deploy
+    yaml's per-stage setting in effect. The serve ``--trust-remote-code``
+    flag is store_true — its absent-False must be mapped to ``None`` at the
+    CLI boundary before reaching here, since it cannot express an explicit
+    False.
+    """
+    merged = dict(overrides)
+    if trust_remote_code is not None:
+        merged["trust_remote_code"] = trust_remote_code
+    return merged
+
+
 class StageConfigFactory:
     """Factory that loads pipeline YAML and merges CLI overrides.
 
@@ -197,12 +218,12 @@ class StageConfigFactory:
         return None
 
     @classmethod
-    @functools.cache
     def get_pipeline_config(
         cls,
         model: str,
         trust_remote_code: bool,
         deploy_config_path: str | None = None,
+        user_deploy_config: DeployConfig | None = None,
     ) -> PipelineConfig | None:
         """Resolve the PipelineConfig for a model path/name."""
         model_type = cls.try_infer_model_type(model=model, trust_remote_code=trust_remote_code)
@@ -210,13 +231,15 @@ class StageConfigFactory:
 
         # Resolve the deploy config & check if the user set the pipeline;
         # If the pipeline is explicitly set, it takes highest priority
-        deploy_config_pipe = cls._get_deploy_override_pipe_config(hf_config, deploy_config_path)
+        if user_deploy_config is None:
+            user_deploy_config = cls._load_user_deploy_config(deploy_config_path)
+        deploy_config_pipe = cls._get_deploy_override_pipe_config(hf_config, user_deploy_config)
         if deploy_config_pipe is not None:
             return deploy_config_pipe
 
         # Pipeline isn't set in the yaml spec, so we need infer it ourselves.
         if model_type and model_type in OMNI_PIPELINES:
-            pipeline_cfg = cls.resolve_pipeline_config(model_type, hf_config)
+            pipeline_cfg = resolve_pipeline_config(model_type, hf_config)
             if pipeline_cfg is not None:
                 return pipeline_cfg
 
@@ -257,78 +280,113 @@ class StageConfigFactory:
     def _get_deploy_override_pipe_config(
         cls,
         hf_config: PretrainedConfig | None,
-        deploy_config_path: str | None,
+        deploy_config: DeployConfig | None,
     ) -> PipelineConfig | None:
-        """Load the deploy config and extract + resolve its pipeline field."""
-        if deploy_config_path is None:
+        """Resolve an explicit pipeline override from a loaded deploy config."""
+        if deploy_config is None or deploy_config.pipeline is None:
             return None
 
+        pipeline_cfg = resolve_pipeline_config(deploy_config.pipeline, hf_config)
+        if pipeline_cfg is None:
+            raise KeyError(
+                f"Pipeline {deploy_config.pipeline!r} from deploy config is not registered "
+                f"to OMNI_PIPELINES. Available: {sorted(OMNI_PIPELINES)}"
+            )
+        return pipeline_cfg
+
+    @staticmethod
+    def _load_user_deploy_config(deploy_config_path: str | None) -> DeployConfig | None:
+        """Load an explicit deploy YAML once for resolution and construction."""
+        if deploy_config_path is None:
+            return None
         deploy_path = Path(deploy_config_path)
-        if deploy_path.exists():
-            deploy_cfg = load_deploy_config(deploy_path)
-            if deploy_cfg.pipeline is not None:
-                return cls.resolve_pipeline_config(deploy_cfg.pipeline, hf_config)
-        return None
+        if not deploy_path.exists() and deploy_path.parent == Path("."):
+            candidate = _DEPLOY_DIR / deploy_path
+            if candidate.exists():
+                deploy_path = candidate
+        if not deploy_path.exists():
+            raise FileNotFoundError(f"Deploy config not found: {deploy_path}")
+        return load_deploy_config(deploy_path)
 
     @classmethod
     def create_from_model(
         cls,
         model: str,
         *,
-        trust_remote_code: bool = False,
-        cli_overrides: dict[str, Any] | None = None,
-        deploy_config_path: str | None = None,
-        strategy_specs: Mapping[Any, Any] | None = None,
-        **deprecated_kwargs: Any,
-    ) -> tuple[list[StageConfig] | None, str | None]:
-        """Load pipeline + deploy config, merge with CLI overrides.
-
-        Checks OMNI_PIPELINES first, since supported models should be explicitly
-        registered. If a model is not registered in OMNI_PIPELINES, tries to fall
-        back to using the Transformers config & finding pipelines that have overlapping
-        supported architectures.
-
-        When ``strategy_specs`` is provided (a mapping of role -> list of
-        ``StrategySpec``), the derived parallel sizing is overlaid onto the
-        merged stages (see ``vllm_omni.config.composable_parallel``). This is
-        opt-in: omitting it leaves the existing merge path untouched.
-
-        Returns ``(stages, omni_lb_policy)``: the merged stages (``None`` when the
-        model is not in the pipeline registry and the caller should fall back to
-        the legacy YAML path) and the strategy-derived, pipeline-wide
-        ``omni_lb_policy`` (``None`` when no stage_replica axis set one). The
-        policy is returned rather than threaded through a mutable out-param so the
-        engine can apply it without every intermediate call carrying the dict.
-        """
-        if cli_overrides is None:
-            cli_overrides = {}
-
+        trust_remote_code: bool | None,
+        cli_overrides: dict[str, Any],
+        deploy_config_path: str | None,
+    ) -> VllmOmniConfig | None:
+        """Build the structured Omni config for a model/deploy pair."""
+        user_deploy_config = cls._load_user_deploy_config(deploy_config_path)
         pipeline_cfg = cls.get_pipeline_config(
             model=model,
-            trust_remote_code=trust_remote_code,
+            # HF config resolution needs a real bool: transformers treats
+            # None as "prompt for consent", which blocks non-interactively.
+            trust_remote_code=bool(trust_remote_code),
             deploy_config_path=deploy_config_path,
+            user_deploy_config=user_deploy_config,
+        )
+        if pipeline_cfg is None:
+            return None
+
+        registry_cli_overrides = with_trust_remote_code_override(
+            {**cli_overrides, "model": model},
+            trust_remote_code,
+        )
+        return VllmOmniConfig.from_pipeline_config(
+            pipeline_cfg,
+            user_deploy_config=user_deploy_config,
+            deploy_config_path=deploy_config_path,
+            cli_overrides=registry_cli_overrides,
         )
-        if pipeline_cfg is not None:
-            return cls._create_from_registry(
-                pipeline_cfg.model_type,
-                pipeline_cfg,
-                cli_overrides,
-                deploy_config_path,
-                strategy_specs=strategy_specs,
-            )
-        return None, None
 
     @classmethod
-    def _create_from_registry(
+    def create_legacy_stage_configs_from_model(
+        cls,
+        model: str,
+        *,
+        trust_remote_code: bool | None,
+        cli_overrides: dict[str, Any],
+        deploy_config_path: str | None,
+        strategy_specs: Mapping[Any, Any] | None = None,
+    ) -> tuple[list[StageConfig] | None, str | None]:
+        """Build current runtime stage configs from the shared resolution.
+
+        The engine still consumes the legacy StageConfig/OmegaConf shape.
+        RFC #4021 will replace this transitional path as runtime consumers move
+        to VllmOmniConfig.
+        """
+        user_deploy_config = cls._load_user_deploy_config(deploy_config_path)
+        pipeline_cfg = cls.get_pipeline_config(
+            model=model,
+            # See create_from_model: HF resolution needs a real bool.
+            trust_remote_code=bool(trust_remote_code),
+            deploy_config_path=deploy_config_path,
+            user_deploy_config=user_deploy_config,
+        )
+        if pipeline_cfg is None:
+            return None, None
+
+        legacy_cli_overrides = with_trust_remote_code_override(cli_overrides, trust_remote_code)
+        return cls._create_legacy_from_registry(
+            pipeline_cfg,
+            legacy_cli_overrides,
+            deploy_config_path,
+            user_deploy_config=user_deploy_config,
+            strategy_specs=strategy_specs,
+        )
+
+    @classmethod
+    def _create_legacy_from_registry(
         cls,
-        model_type: str,
         pipeline_cfg: PipelineConfig,
         cli_overrides: dict[str, Any],
         deploy_config_path: str | None = None,
+        user_deploy_config: DeployConfig | None = None,
         strategy_specs: Mapping[Any, Any] | None = None,
-        **deprecated_kwargs: Any,
     ) -> tuple[list[StageConfig], str | None]:
-        """Create StageConfigs from pipeline registry + deploy YAML.
+        """Create current runtime StageConfigs from registry + deploy YAML.
 
         Precedence: caller-typed (non-None) value > deploy YAML >
         StageDeployConfig dataclass default.
@@ -337,30 +395,15 @@ class StageConfigFactory:
         load-balancer policy (``None`` when no strategy set one) travels with the
         stages instead of through a mutable out-param.
         """
-        # Resolve deploy config path
-        if deploy_config_path is None:
-            deploy_path = _DEPLOY_DIR / f"{model_type}.yaml"
+        if user_deploy_config is not None:
+            deploy_cfg = user_deploy_config
+        elif deploy_config_path is not None:
+            deploy_cfg = cls._load_user_deploy_config(deploy_config_path)
+            assert deploy_cfg is not None
+        elif pipeline_cfg.default_deploy_config_name is not None:
+            deploy_cfg = load_deploy_config(_DEPLOY_DIR / pipeline_cfg.default_deploy_config_name)
         else:
-            deploy_path = Path(deploy_config_path)
-
-        if not deploy_path.exists():
-            logger.warning(
-                "Deploy config not found: %s — using pipeline defaults only",
-                deploy_path,
-            )
             deploy_cfg = DeployConfig()
-        else:
-            deploy_cfg = load_deploy_config(deploy_path)
-            # Fallback to using the deploy config pipeline class if it's a mismatch
-            if deploy_cfg.pipeline and deploy_cfg.pipeline != model_type:
-                resolved = cls.resolve_pipeline_config(deploy_cfg.pipeline)
-                if resolved is None:
-                    raise KeyError(
-                        f"Pipeline {deploy_cfg.pipeline!r} from {deploy_path.name!r} "
-                        f"not found in OMNI_PIPELINES. Available: "
-                        f"{sorted(OMNI_PIPELINES.keys())}"
-                    )
-                pipeline_cfg = resolved
 
         cli_async_chunk = cli_overrides.get("async_chunk")
         if cli_async_chunk is not None:
@@ -565,13 +608,3 @@ class StageConfigFactory:
         ``filter_dataclass_kwargs(OmniEngineArgs, ...)``.
         """
         return build_stage_runtime_overrides(stage.stage_id, cli_overrides)
-
-    @staticmethod
-    def resolve_pipeline_config(model_type: str, hf_config: PretrainedConfig | None = None) -> PipelineConfig | None:
-        """Given a model type, resolve to the pipeline to be used. If the pipeline
-        maps to a callable we resolve based on the HF config."""
-        if model_type not in OMNI_PIPELINES:
-            logger.warning("Model type %s is not registered to OMNI_PIPELINES", model_type)
-            return None
-        obj = OMNI_PIPELINES[model_type]
-        return obj(hf_config) if callable(obj) else obj
diff --git a/vllm_omni/config/model.py b/vllm_omni/config/model.py
index a5f1376e8..d18cabcf5 100644
--- a/vllm_omni/config/model.py
+++ b/vllm_omni/config/model.py
@@ -17,6 +17,8 @@ import vllm_omni.model_executor.models as me_models
 
 logger = init_logger(__name__)
 
+_QWEN3_TTS_TASK_TYPES = frozenset({"CustomVoice", "VoiceDesign", "Base"})
+
 
 class OmniModelArchConfigConvertor(ModelArchConfigConvertorBase):
     """Config convertor for Omni multi-stage models.
@@ -101,8 +103,8 @@ class OmniModelConfig(ModelConfig):
              "audio", "latents"). If None, output type is inferred.
          stage_connector_config: Stage connector configuration dictionary.
              Contains "name" (connector name), "extra" (extra connector config).
-         task_type: Default task type for TTS models (CustomVoice, VoiceDesign, or Base).
-             If not specified, will be inferred from model path.
+         task_type: Model-defined startup task type. Each model validates its
+             supported values and applies the corresponding behavior.
 
 
     The correct way to initialize this class is via vLLM config, as most
@@ -119,8 +121,10 @@ class OmniModelConfig(ModelConfig):
 
     stage_id: int = 0
     async_chunk: bool = False
+    retains_state_across_chunks: bool = False
     # Stage-1 active stream slots; 0 keeps legacy chunk-level round-robin.
     active_stream_window: int = 0
+    duplex_max_sessions: int = 1
     model_stage: str = "thinker"
     model_arch: str | None = None
     worker_type: str | None = None
@@ -146,7 +150,10 @@ class OmniModelConfig(ModelConfig):
 
     @property
     def architectures(self) -> list[str]:
-        if self.model_arch is not None:
+        # Falsy (None or "") means "no stage override": fall back to the
+        # checkpoint config's own architectures. The stage-config builder
+        # emits None; "" is tolerated for legacy callers.
+        if self.model_arch:
             return [self.model_arch]
         return super().architectures
 
@@ -203,6 +210,14 @@ class OmniModelConfig(ModelConfig):
             )
             return get_hf_text_config(self.hf_config)
 
+    def _validate_startup_task_type(self) -> None:
+        """Validate startup-only task selectors owned by an AR model."""
+        if self.model_arch != "Qwen3TTSTalkerForConditionalGenerationARVLLM" or self.task_type is None:
+            return
+        if self.task_type not in _QWEN3_TTS_TASK_TYPES:
+            supported = ", ".join(sorted(_QWEN3_TTS_TASK_TYPES))
+            raise ValueError(f"Qwen3-TTS --task-type must be one of {supported}; got {self.task_type!r}")
+
     def _patch_qwen3_tts(self):
         """Patches the value of `position_id_per_seconds` in Qwen3's
         TTS's talker_config into the this class's codec_frame_rate_hz.
@@ -270,6 +285,7 @@ class OmniModelConfig(ModelConfig):
             omni_cfg._patch_qwen3_tts()
 
         omni_cfg._maybe_override_text_config()
+        omni_cfg._validate_startup_task_type()
 
         if omni_cfg.hf_config is not None:
             omni_cfg.hf_config.architectures = omni_cfg.architectures
diff --git a/vllm_omni/config/omni_config.py b/vllm_omni/config/omni_config.py
index dc5f4ef9c..0ddcb2b37 100644
--- a/vllm_omni/config/omni_config.py
+++ b/vllm_omni/config/omni_config.py
@@ -2,9 +2,10 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Structured vLLM-Omni configuration classes.
 
-This module is additive for Phase 2 of RFC #4021.  ``VllmOmniConfig.from_registry``
-builds the structured view directly from the pipeline registry and deploy config
-so parity can be proven before later PRs cut consumers over to these classes.
+This module is additive for Phase 2 of RFC #4021.
+``VllmOmniConfig.from_pipeline_config`` builds the structured view from an
+already-resolved pipeline and deploy config so parity can be proven before
+later PRs cut consumers over to these classes.
 """
 
 from __future__ import annotations
@@ -13,7 +14,7 @@ import copy
 from collections.abc import Mapping
 from dataclasses import dataclass, field, fields
 from pathlib import Path
-from typing import Any, TypeAlias, TypedDict, cast
+from typing import Any, Literal, TypeAlias, TypedDict, cast
 
 from pydantic import ConfigDict, Field
 from vllm.config.utils import config
@@ -45,6 +46,29 @@ _EXECUTION_TYPE_TO_STAGE_WORKER: dict[StageExecutionType, tuple[StageType, str |
 
 _PIPELINE_DEPLOY_CLI_FIELDS = PIPELINE_WIDE_ENGINE_FIELDS
 
+_NON_STAGE_ENGINE_CLI_FIELDS = frozenset(
+    {
+        "async_chunk",
+        "model",
+        "omni",
+        "output_modalities",
+        "stage_configs_path",
+        "stage_id",
+        "tokenizer",
+    }
+)
+
+# Legacy deploy files can still carry StageConfig metadata in engine_extras.
+# Those values are not backend engine inputs, and the additive typed path keeps
+# sourcing their effective values from the immutable pipeline topology.
+_LEGACY_STAGE_METADATA_EXTRA_FIELDS = frozenset(
+    {
+        "final_output",
+        "final_output_type",
+        "is_comprehension",
+    }
+)
+
 _QuantizationConfigType: TypeAlias = QuantizationConfig | str | Mapping[str, Any] | None
 
 
@@ -54,6 +78,21 @@ class _QuantizationEngineOverrides(TypedDict, total=False):
 
 
 class _ModelEngineOverrides(TypedDict, total=False):
+    model: str
+    model_arch: str
+    model_subdir: str
+    tokenizer_subdir: str
+    revision: str
+    tokenizer_revision: str
+    code_revision: str
+    seed: int
+    logits_processors: list[str | type]
+    trust_remote_code: bool
+    dtype: Any
+    attention_backend: Any
+    moe_backend: str
+    hf_overrides: Any
+    limit_mm_per_prompt: dict[str, Any]
     active_stream_window: int
     enable_sleep_mode: bool
     subtalker_sampling_params: dict[str, Any]
@@ -62,6 +101,7 @@ class _ModelEngineOverrides(TypedDict, total=False):
     task_type: str
     codec_frame_rate_hz: float
     enforce_eager: bool
+    max_cudagraph_capture_size: int
     enable_flashinfer_autotune: bool
     compilation_config: dict[str, Any]
     enable_multithread_weight_load: bool
@@ -70,6 +110,9 @@ class _ModelEngineOverrides(TypedDict, total=False):
 
 
 class _LoadEngineOverrides(TypedDict, total=False):
+    tokenizer: str
+    download_dir: str
+    skip_tokenizer_init: bool
     load_format: str
     tokenizer_mode: str
     config_format: str
@@ -77,6 +120,7 @@ class _LoadEngineOverrides(TypedDict, total=False):
 
 
 class _CacheEngineOverrides(TypedDict, total=False):
+    kv_cache_memory_bytes: int
     gpu_memory_utilization: float
     enable_prefix_caching: bool
     disable_hybrid_kv_cache_manager: bool
@@ -92,6 +136,8 @@ class _SchedulerEngineOverrides(TypedDict, total=False):
 
 
 class _RuntimeEngineOverrides(TypedDict, total=False):
+    distributed_executor_backend: Any
+    worker_cls: str
     devices: str
     num_replicas: int
     env: dict[str, Any]
@@ -108,9 +154,12 @@ class _ParallelConfigEngineOverrides(TypedDict, total=False):
     sequence_parallel_size: int
     ulysses_degree: int
     ring_degree: int
+    allgather_degree: int
     ulysses_mode: str
     cfg_parallel_size: int
     vae_patch_parallel_size: int
+    vae_parallel_mode: str
+    text_encoder_tp_size: int
     use_hsdp: bool
     mask_sp_padding: bool
     hsdp_shard_size: int
@@ -122,6 +171,10 @@ class _ParallelEngineOverrides(_ParallelConfigEngineOverrides, total=False):
     parallel_config: _ParallelConfigEngineOverrides | Mapping[str, Any]
 
 
+class _ConnectorEngineOverrides(TypedDict, total=False):
+    omni_kv_config: dict[str, Any]
+
+
 @dataclass(frozen=True)
 class _StageEngineValues:
     """Typed projections of legacy flat per-stage ``yaml_engine_args``."""
@@ -131,6 +184,7 @@ class _StageEngineValues:
     load: _LoadEngineOverrides
     cache: _CacheEngineOverrides
     scheduler: _SchedulerEngineOverrides
+    connector: _ConnectorEngineOverrides
     runtime: _RuntimeEngineOverrides
     parallel: _ParallelEngineOverrides
     diffusion: _DiffusionEngineOverrides
@@ -215,10 +269,7 @@ def _stage_cli_overrides(stage_id: int, cli_overrides: Mapping[str, Any]) -> dic
     return result
 
 
-def _resolve_deploy_path(model_type: str, deploy_config_path: str | None = None) -> Path:
-    if deploy_config_path is None:
-        return _DEPLOY_DIR / f"{model_type}.yaml"
-
+def _resolve_deploy_path(deploy_config_path: str) -> Path:
     deploy_path = Path(deploy_config_path)
     if not deploy_path.exists() and deploy_path.parent == Path("."):
         bare_name = deploy_path.name
@@ -230,24 +281,48 @@ def _resolve_deploy_path(model_type: str, deploy_config_path: str | None = None)
     return deploy_path
 
 
-def _registered_pipeline_keys() -> list[str]:
-    from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
+def _get_deploy_config(
+    pipeline_cfg: PipelineConfig,
+    user_deploy_config: DeployConfig | None,
+    deploy_config_path: str | None,
+) -> tuple[DeployConfig, str | None]:
+    """Select user-provided, pipeline-default, or empty deploy settings."""
+    if user_deploy_config is not None:
+        loaded_path = str(_resolve_deploy_path(deploy_config_path)) if deploy_config_path is not None else None
+        return copy.deepcopy(user_deploy_config), loaded_path
 
-    return sorted(OMNI_PIPELINES)
+    if deploy_config_path is not None:
+        resolved_path = _resolve_deploy_path(deploy_config_path)
+        if not resolved_path.exists():
+            raise FileNotFoundError(f"Deploy config not found: {resolved_path}")
+        return load_deploy_config(resolved_path), str(resolved_path)
 
+    if pipeline_cfg.default_deploy_config_name is not None:
+        default_path = _DEPLOY_DIR / pipeline_cfg.default_deploy_config_name
+        return load_deploy_config(default_path), str(default_path)
 
-def _resolve_registered_pipeline(model_type: str) -> PipelineConfig | None:
-    from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
-
-    registered = OMNI_PIPELINES[model_type]
-    return registered(None) if callable(registered) else registered
+    return DeployConfig(), None
 
 
 @config
 class OmniStageModelConfig:
-    """Per-stage model behavior."""
+    """Per-stage model behavior and resolved model-engine inputs."""
 
+    model: str | None = None
+    model_arch: str | None = None
+    revision: str | None = None
+    tokenizer_revision: str | None = None
+    code_revision: str | None = None
+    seed: int | None = None
+    logits_processors: list[str | type] | None = None
+    trust_remote_code: bool = False
+    dtype: Any = "auto"
+    attention_backend: Any = None
+    moe_backend: str = "auto"
+    hf_overrides: Any = None
+    limit_mm_per_prompt: dict[str, Any] | None = None
     active_stream_window: int = Field(default=0, ge=0)
+    duplex_max_sessions: int = Field(default=1, ge=1)
     enable_sleep_mode: bool = False
     default_sampling_params: dict[str, Any] | None = None
     subtalker_sampling_params: dict[str, Any] | None = None
@@ -256,17 +331,26 @@ class OmniStageModelConfig:
     task_type: str | None = None
     codec_frame_rate_hz: float | None = None
     enforce_eager: bool = False
+    max_cudagraph_capture_size: int | None = Field(default=None, ge=0)
     enable_flashinfer_autotune: bool | None = None
     compilation_config: dict[str, Any] | None = None
     enable_multithread_weight_load: bool = True
     num_weight_load_threads: int = Field(default=4, ge=1)
     disable_autocast: bool = False
+    # Per-stage checkpoint/tokenizer subdirectories under the model root
+    # (e.g. Audex stage 0 → checkpoint_folder_audiogen). Mirrors
+    # StagePipelineConfig.model_subdir/tokenizer_subdir on the legacy path.
+    model_subdir: str | None = None
+    tokenizer_subdir: str | None = None
 
 
 @config
 class OmniStageLoadConfig:
-    """Per-stage loading behavior."""
+    """Per-stage loading behavior and resolved tokenizer input."""
 
+    tokenizer: str | None = None
+    download_dir: str | None = None
+    skip_tokenizer_init: bool = False
     load_format: str = "auto"
     tokenizer_mode: str = "auto"
     config_format: str | None = None
@@ -281,9 +365,11 @@ class OmniStageCacheConfig:
     vLLM-Omni diffusion-specific cache backends such as TeaCache and Cache-DiT.
     """
 
-    gpu_memory_utilization: float = Field(default=0.90, gt=0.0, le=1.0)
-    enable_prefix_caching: bool = False
-    disable_hybrid_kv_cache_manager: bool = False
+    kv_cache_memory_bytes: int | None = Field(default=None, ge=0)
+    # None preserves backend-owned defaults; explicit values still project.
+    gpu_memory_utilization: float | None = Field(default=None, gt=0.0, le=1.0)
+    enable_prefix_caching: bool | None = None
+    disable_hybrid_kv_cache_manager: bool | None = None
     mm_processor_cache_gb: float | None = Field(default=None, ge=0.0)
 
 
@@ -291,14 +377,18 @@ class OmniStageCacheConfig:
 class OmniStageSchedulerConfig:
     """Per-stage request scheduling behavior."""
 
-    max_num_seqs: int = Field(default=128, ge=1)
+    max_num_seqs: int | None = Field(default=None, ge=1)
     max_num_batched_tokens: int | None = Field(default=None, ge=1)
     max_model_len: int | None = Field(default=None, ge=-1)
-    enable_chunked_prefill: bool = False
-    async_scheduling: bool = True
+    enable_chunked_prefill: bool | None = None
+    async_scheduling: bool | None = None
 
     def __post_init__(self) -> None:
-        if self.max_num_batched_tokens is not None and self.max_num_batched_tokens < self.max_num_seqs:
+        if (
+            self.max_num_batched_tokens is not None
+            and self.max_num_seqs is not None
+            and self.max_num_batched_tokens < self.max_num_seqs
+        ):
             raise ValueError(
                 f"max_num_batched_tokens ({self.max_num_batched_tokens}) must be >= max_num_seqs ({self.max_num_seqs})"
             )
@@ -306,8 +396,10 @@ class OmniStageSchedulerConfig:
 
 @config
 class OmniStageConnectorConfig:
-    """Per-stage inter-stage connector wiring."""
+    """Per-stage connector wiring and resolved transfer mode."""
 
+    async_chunk: bool = False
+    omni_kv_config: dict[str, Any] | None = None
     stage_connector: dict[str, Any] = field(
         default_factory=lambda: {
             "name": "SharedMemoryConnector",
@@ -320,8 +412,10 @@ class OmniStageConnectorConfig:
 
 @config
 class OmniStageRuntimeConfig:
-    """Per-stage process placement and runtime behavior."""
+    """Per-stage process placement and backend runtime behavior."""
 
+    distributed_executor_backend: Any = None
+    worker_cls: str | None = None
     devices: str | None = None
     num_replicas: int = Field(default=1, ge=1)
     env: dict[str, Any] | None = None
@@ -352,9 +446,11 @@ class OmniStageDiffusionParallelConfig(OmniStageParallelConfig):
     sequence_parallel_size: int = Field(default=1, ge=1, init=False)
     ulysses_degree: int = Field(default=1, ge=1)
     ring_degree: int = Field(default=1, ge=1)
+    allgather_degree: int = Field(default=1, ge=1)
     ulysses_mode: str = "strict"
-    cfg_parallel_size: int = Field(default=1, ge=1, le=3)
+    cfg_parallel_size: int = Field(default=1, ge=1)
     vae_patch_parallel_size: int = Field(default=1, ge=1)
+    text_encoder_tp_size: int = Field(default=1, ge=1)
     vae_parallel_mode: str = "tile"
     use_hsdp: bool = False
     mask_sp_padding: bool = False
@@ -362,7 +458,11 @@ class OmniStageDiffusionParallelConfig(OmniStageParallelConfig):
     hsdp_replicate_size: int = Field(default=1, ge=1)
 
     def __post_init__(self) -> None:
-        self.sequence_parallel_size = self.ulysses_degree * self.ring_degree
+        self.sequence_parallel_size = (
+            self.allgather_degree if self.allgather_degree > 1 else self.ulysses_degree * self.ring_degree
+        )
+        if self.allgather_degree > 1 and (self.ulysses_degree > 1 or self.ring_degree > 1):
+            raise ValueError("allgather_degree > 1 is mutually exclusive with ulysses_degree/ring_degree > 1")
         if self.ulysses_mode not in {"strict", "advanced_uaa"}:
             raise ValueError("ulysses_mode must be 'strict' or 'advanced_uaa'")
         if self.vae_parallel_mode not in {"tile", "spatial_shard_height", "spatial_shard_width"}:
@@ -426,7 +526,12 @@ class _DiffusionConfigProjection:
     stage_id: int = 0
     model: str | None = None
     model_class_name: str | None = None
+    engine_backend: str | type = "default"
+    diffusion_model_runner_cls: str | type | None = None
+    request_batch_max_wait_ms: float = 0.0
+    streaming_output: bool = False
     model_arch: str | None = None
+    task_type: str | None = None
     dtype: Any = "auto"
     trust_remote_code: bool = False
     revision: str | None = None
@@ -434,6 +539,7 @@ class _DiffusionConfigProjection:
     dist_timeout: int | None = None
     nccl_port: int | None = None
     master_port: int | None = None
+    scheduler_port: int | None = None
     host: str | None = None
     port: int | None = None
     model_config: dict[str, Any] = field(default_factory=dict)
@@ -445,6 +551,7 @@ class _DiffusionConfigProjection:
     enable_cache_dit_summary: bool = False
     enable_prompt_embed_cache: bool = False
     prompt_embed_cache_size: int = Field(default=32, ge=1)
+    enable_session_state_manager: bool = False
     diffusion_load_format: str = "default"
     diffusers_load_kwargs: dict[str, Any] = field(default_factory=dict)
     diffusers_call_kwargs: dict[str, Any] = field(default_factory=dict)
@@ -455,7 +562,12 @@ class _DiffusionConfigProjection:
     output_type: str = "pil"
     enable_cpu_offload: bool = False
     enable_layerwise_offload: bool = False
+    enable_distributed_layerwise_offload: bool = False
+    dlo_use_allgather: bool = True
+    dlo_resident_layers: int = Field(default=0, ge=0)
     pin_cpu_memory: bool = True
+    diffusion_compile_granularity: Literal["regional", "full"] = "regional"
+    diffusion_compile_dynamic: bool = Field(default=True, strict=True)
     vae_use_slicing: bool = False
     vae_use_tiling: bool = False
     mask_strategy_file_path: str | None = None
@@ -469,11 +581,13 @@ class _DiffusionConfigProjection:
     diffusion_kv_cache_skip_layers: str | list[int] | tuple[int, ...] | set[int] | None = None
     diffusion_kv_cache_skip_step_indices: set[int] | None = None
     diffusion_kv_cache_skip_layer_indices: set[int] | None = None
+    moe_backend: str = "auto"
     force_cutlass_fp8: bool = False
     enable_diffusion_pipeline_profiler: bool = False
     step_execution: bool = False
     supports_multimodal_inputs: bool = False
     max_multimodal_image_inputs: int | None = None
+    supports_mixed_reference_inputs: bool = False
     model_paths: dict[str, str] = field(default_factory=dict)
     model_loaded: dict[str, bool] = field(
         default_factory=lambda: {
@@ -651,6 +765,7 @@ _DIFFUSION_SHARED_CONFIG_FIELDS = frozenset(
         "stage_id",
         "model",
         "model_arch",
+        "task_type",
         "dtype",
         "trust_remote_code",
         "revision",
@@ -666,6 +781,7 @@ _DIFFUSION_RUNTIME_CONFIG_FIELDS = frozenset(
         "port",
         "nccl_port",
         "master_port",
+        "scheduler_port",
         "worker_extension_cls",
         "enable_stage_verification",
         "prompt_file_path",
@@ -713,21 +829,85 @@ _MODEL_ENGINE_FIELDS = frozenset(_ModelEngineOverrides.__annotations__)
 _LOAD_ENGINE_FIELDS = frozenset(_LoadEngineOverrides.__annotations__)
 _CACHE_ENGINE_FIELDS = frozenset(_CacheEngineOverrides.__annotations__)
 _SCHEDULER_ENGINE_FIELDS = frozenset(_SchedulerEngineOverrides.__annotations__)
+_CONNECTOR_ENGINE_FIELDS = frozenset(_ConnectorEngineOverrides.__annotations__)
 _RUNTIME_ENGINE_FIELDS = frozenset(_RuntimeEngineOverrides.__annotations__)
 _PARALLEL_CONFIG_ENGINE_FIELDS = frozenset(_ParallelConfigEngineOverrides.__annotations__)
 _PARALLEL_ENGINE_FIELDS = _PARALLEL_CONFIG_ENGINE_FIELDS | {"parallel_config"}
+_COMMON_STAGE_ENGINE_FIELDS = (
+    _QUANTIZATION_ENGINE_FIELDS
+    | _MODEL_ENGINE_FIELDS
+    | _LOAD_ENGINE_FIELDS
+    | _CACHE_ENGINE_FIELDS
+    | _SCHEDULER_ENGINE_FIELDS
+    | _CONNECTOR_ENGINE_FIELDS
+    | _RUNTIME_ENGINE_FIELDS
+)
+_LLM_PARALLEL_CONFIG_ENGINE_FIELDS = frozenset(f.name for f in fields(OmniStageParallelConfig)) - {"world_size"}
+_DIFFUSION_PARALLEL_CONFIG_ENGINE_FIELDS = frozenset(f.name for f in fields(OmniStageDiffusionParallelConfig)) - {
+    "world_size"
+}
+_LLM_STAGE_ENGINE_FIELDS = _COMMON_STAGE_ENGINE_FIELDS | _LLM_PARALLEL_CONFIG_ENGINE_FIELDS | {"parallel_config"}
+_DIFFUSION_OWNED_STAGE_ENGINE_FIELDS = (
+    _COMMON_STAGE_ENGINE_FIELDS
+    | _DIFFUSION_PARALLEL_CONFIG_ENGINE_FIELDS
+    | _DIFFUSION_STAGE_ENGINE_FIELDS
+    | {"parallel_config"}
+)
+
+# This all-stage union is used only to discover global CLI candidates. Stage
+# validation must use the execution-type-specific sets below.
+_STAGE_ENGINE_FIELDS = _LLM_STAGE_ENGINE_FIELDS | _DIFFUSION_OWNED_STAGE_ENGINE_FIELDS
+_STAGE_ENGINE_FIELDS_BY_EXECUTION_TYPE = {
+    StageExecutionType.LLM_AR: _LLM_STAGE_ENGINE_FIELDS,
+    StageExecutionType.LLM_GENERATION: _LLM_STAGE_ENGINE_FIELDS,
+    StageExecutionType.DIFFUSION: _DIFFUSION_OWNED_STAGE_ENGINE_FIELDS,
+}
+_PARALLEL_CONFIG_ENGINE_FIELDS_BY_EXECUTION_TYPE = {
+    StageExecutionType.LLM_AR: _LLM_PARALLEL_CONFIG_ENGINE_FIELDS,
+    StageExecutionType.LLM_GENERATION: _LLM_PARALLEL_CONFIG_ENGINE_FIELDS,
+    StageExecutionType.DIFFUSION: _DIFFUSION_PARALLEL_CONFIG_ENGINE_FIELDS,
+}
+
+
+def _validate_stage_engine_override_ownership(
+    stage_id: int,
+    execution_type: StageExecutionType,
+    overrides: Mapping[str, Any],
+) -> None:
+    try:
+        owner_fields = _STAGE_ENGINE_FIELDS_BY_EXECUTION_TYPE[execution_type]
+        parallel_owner_fields = _PARALLEL_CONFIG_ENGINE_FIELDS_BY_EXECUTION_TYPE[execution_type]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported stage execution type: {execution_type!r}") from exc
+
+    unowned_fields = set(overrides) - owner_fields
+    parallel_config = overrides.get("parallel_config")
+    if isinstance(parallel_config, Mapping):
+        unowned_fields.update(f"parallel_config.{name}" for name in set(parallel_config) - parallel_owner_fields)
+    if unowned_fields:
+        names = ", ".join(sorted(unowned_fields))
+        raise ValueError(
+            f"Stage {stage_id} ({execution_type.value}) has explicit engine argument(s) "
+            f"with no structured config owner: {names}"
+        )
 
 
 def _global_stage_cli_fields() -> frozenset[str]:
     # Lazy import avoids vllm_omni.config -> omni_config -> engine.arg_utils ->
     # vllm_omni.config during package-level config imports.
-    from vllm_omni.engine.arg_utils import OmniEngineArgs
+    from vllm_omni.engine.arg_utils import OmniEngineArgs, orchestrator_field_names
 
-    return (
+    candidates = (
         frozenset(f.name for f in fields(OmniEngineArgs))
         | frozenset(_STAGE_DEPLOY_ENGINE_FIELDS)
         | frozenset(_PIPELINE_DEPLOY_CLI_FIELDS)
-    ) - {"model", "stage_id", "stage_configs_path", "async_chunk"}
+    )
+    externally_consumed = (
+        _NON_STAGE_ENGINE_CLI_FIELDS
+        | frozenset(f.name for f in fields(VllmOmniOrchestratorConfig))
+        | (orchestrator_field_names() - _STAGE_ENGINE_FIELDS)
+    )
+    return candidates - externally_consumed
 
 
 def _mapping_or_empty(value: Any) -> Mapping[str, Any]:
@@ -747,17 +927,33 @@ def _stage_engine_overrides(stage_deploy: StageDeployConfig | None) -> dict[str,
         value = getattr(stage_deploy, name)
         if value is not None:
             overrides[name] = _copy_value(value)
-    overrides.update(_copy_value(stage_deploy.engine_extras))
+    overrides.update(
+        {
+            name: _copy_value(value)
+            for name, value in stage_deploy.engine_extras.items()
+            if name not in _LEGACY_STAGE_METADATA_EXTRA_FIELDS
+        }
+    )
     return overrides
 
 
 def _stage_engine_values(
     stage_deploy: StageDeployConfig | None,
+    topology: StagePipelineConfig,
     stage_cli_overrides: Mapping[str, Any] | None = None,
 ) -> _StageEngineValues:
     engine = _stage_engine_overrides(stage_deploy)
+    # Preserve legacy ordering: topology-owned KV roles override deploy
+    # extras, while an explicit CLI override remains highest priority.
+    if topology.omni_kv_config:
+        engine["omni_kv_config"] = _copy_value(topology.omni_kv_config)
     if stage_cli_overrides:
         engine.update(_copy_value(stage_cli_overrides))
+    _validate_stage_engine_override_ownership(
+        topology.stage_id,
+        topology.execution_type,
+        engine,
+    )
     return _StageEngineValues(
         quantization=cast(
             _QuantizationEngineOverrides,
@@ -770,6 +966,10 @@ def _stage_engine_values(
             _SchedulerEngineOverrides,
             _select_engine_overrides(engine, _SCHEDULER_ENGINE_FIELDS),
         ),
+        connector=cast(
+            _ConnectorEngineOverrides,
+            _select_engine_overrides(engine, _CONNECTOR_ENGINE_FIELDS),
+        ),
         runtime=cast(_RuntimeEngineOverrides, _select_engine_overrides(engine, _RUNTIME_ENGINE_FIELDS)),
         parallel=cast(_ParallelEngineOverrides, _select_engine_overrides(engine, _PARALLEL_ENGINE_FIELDS)),
         diffusion=_DiffusionEngineOverrides.from_engine(engine),
@@ -812,7 +1012,6 @@ class VllmOmniOrchestratorConfig:
     omni_dp_size_local: int = Field(default=1, ge=1)
     omni_lb_policy: str = "random"
     omni_heartbeat_timeout: float = Field(default=30.0, gt=0.0)
-    shm_threshold_bytes: int = Field(default=65536, ge=0)
     batch_timeout: int = Field(default=10, ge=0)
 
 
@@ -866,9 +1065,10 @@ class BaseVllmOmniStageConfig:
 
     @property
     def scheduler_cls(self) -> str | None:
-        return _resolve_scheduler_path(
+        async_scheduling = self.scheduler_config.async_scheduling
+        return self.stage_pipeline_config.scheduler_cls or _resolve_scheduler_path(
             self.stage_pipeline_config.execution_type,
-            self.scheduler_config.async_scheduling,
+            True if async_scheduling is None else async_scheduling,
         )
 
     @property
@@ -930,11 +1130,14 @@ StageConfigType: TypeAlias = VllmOmniARStageConfig | VllmOmniGenerationStageConf
 
 
 def _build_common_stage_config_kwargs(
+    pipeline: PipelineConfig,
     deploy: DeployConfig,
     topology: StagePipelineConfig,
     stage_deploy: StageDeployConfig | None,
     engine: _StageEngineValues,
     parallel_config_cls: type[OmniStageParallelConfig] = OmniStageParallelConfig,
+    *,
+    model: str | None,
 ) -> tuple[dict[str, Any], str | None, str | None]:
     input_proc, next_stage_proc = _select_processor_funcs(topology, bool(deploy.async_chunk))
     quantization_config = _build_quantization_config(deploy, engine.quantization)
@@ -943,12 +1146,37 @@ def _build_common_stage_config_kwargs(
     return (
         {
             "stage_pipeline_config": topology,
-            "model_config": _build_model_config(topology, stage_deploy, engine.model),
-            "load_config": _build_load_config(engine.load),
-            "cache_config": _build_cache_config(deploy, engine.cache),
-            "scheduler_config": _build_scheduler_config(deploy, engine.scheduler),
-            "connector_config": _build_connector_config(stage_deploy),
-            "runtime_config": _build_runtime_config(stage_deploy, engine.runtime, parallel_config),
+            "model_config": _build_model_config(
+                pipeline,
+                deploy,
+                topology,
+                stage_deploy,
+                engine.model,
+                duplex_max_sessions=(deploy.duplex_session.max_sessions if deploy.session_mode == "duplex" else 1),
+                model=model,
+            ),
+            "load_config": _build_load_config(topology, engine.load),
+            "cache_config": _build_cache_config(
+                deploy,
+                engine.cache,
+                topology.execution_type,
+            ),
+            "scheduler_config": _build_scheduler_config(
+                deploy,
+                engine.scheduler,
+                topology.execution_type,
+            ),
+            "connector_config": _build_connector_config(
+                deploy,
+                stage_deploy,
+                engine.connector,
+            ),
+            "runtime_config": _build_runtime_config(
+                deploy,
+                stage_deploy,
+                engine.runtime,
+                parallel_config,
+            ),
             "parallel_config": parallel_config,
             "quantization_config": _copy_value(quantization_config),
         },
@@ -977,10 +1205,12 @@ def _build_ar_stage_config(
     model: str | None,
 ) -> VllmOmniARStageConfig:
     common_kwargs, input_proc, next_stage_proc = _build_common_stage_config_kwargs(
+        pipeline,
         deploy,
         topology,
         stage_deploy,
         engine,
+        model=model,
     )
     return cast(
         VllmOmniARStageConfig,
@@ -1002,10 +1232,12 @@ def _build_generation_stage_config(
     model: str | None,
 ) -> VllmOmniGenerationStageConfig:
     common_kwargs, input_proc, next_stage_proc = _build_common_stage_config_kwargs(
+        pipeline,
         deploy,
         topology,
         stage_deploy,
         engine,
+        model=model,
     )
     return cast(
         VllmOmniGenerationStageConfig,
@@ -1027,18 +1259,20 @@ def _build_diffusion_stage_config(
     model: str | None,
 ) -> VllmOmniDiffusionStageConfig:
     common_kwargs, input_proc, next_stage_proc = _build_common_stage_config_kwargs(
+        pipeline,
         deploy,
         topology,
         stage_deploy,
         engine,
         OmniStageDiffusionParallelConfig,
+        model=model,
     )
     common_kwargs["diffusion_config"] = _build_diffusion_config_projection(
         pipeline,
         deploy,
         topology,
         engine.diffusion,
-        model=model,
+        model=common_kwargs["model_config"].model,
         quantization_config=common_kwargs["quantization_config"],
     )
     return cast(
@@ -1093,59 +1327,102 @@ def _build_quantization_config(
 
 
 def _build_model_config(
+    pipeline: PipelineConfig,
+    deploy: DeployConfig,
     topology: StagePipelineConfig,
     stage_deploy: StageDeployConfig | None,
     engine: _ModelEngineOverrides,
+    *,
+    duplex_max_sessions: int,
+    model: str | None,
 ) -> OmniStageModelConfig:
     default_sampling_params = _stage_sampling_params(stage_deploy, topology)
     kwargs = _config_kwargs(engine)
+    kwargs["model"] = _first_defined(kwargs.get("model"), model)
+    if "model_arch" not in kwargs:
+        kwargs["model_arch"] = topology.model_arch or pipeline.model_arch or None
+    if "trust_remote_code" not in kwargs and deploy.trust_remote_code is not None:
+        kwargs["trust_remote_code"] = _copy_value(deploy.trust_remote_code)
+    if "dtype" not in kwargs and deploy.dtype is not None:
+        kwargs["dtype"] = _copy_value(deploy.dtype)
+    if "active_stream_window" not in kwargs:
+        kwargs["active_stream_window"] = _copy_value(deploy.active_stream_window)
+    if "custom_voice_dir" not in kwargs and deploy.custom_voice_dir is not None:
+        kwargs["custom_voice_dir"] = _copy_value(deploy.custom_voice_dir)
     if "has_sampling_extra_args" not in kwargs:
         kwargs["has_sampling_extra_args"] = bool((default_sampling_params or {}).get("extra_args"))
+    if "model_subdir" not in kwargs and topology.model_subdir is not None:
+        kwargs["model_subdir"] = topology.model_subdir
+    if "tokenizer_subdir" not in kwargs and topology.tokenizer_subdir is not None:
+        kwargs["tokenizer_subdir"] = topology.tokenizer_subdir
     return OmniStageModelConfig(
         default_sampling_params=default_sampling_params,
+        duplex_max_sessions=duplex_max_sessions,
         **kwargs,
     )
 
 
-def _build_load_config(engine: _LoadEngineOverrides) -> OmniStageLoadConfig:
-    return OmniStageLoadConfig(**_config_kwargs(engine))
+def _build_load_config(
+    topology: StagePipelineConfig,
+    engine: _LoadEngineOverrides,
+) -> OmniStageLoadConfig:
+    kwargs = _config_kwargs(engine)
+    if "skip_mm_profiling" not in kwargs and not topology.requires_multimodal_data:
+        kwargs["skip_mm_profiling"] = True
+    return OmniStageLoadConfig(**kwargs)
 
 
 def _build_cache_config(
     deploy: DeployConfig,
     engine: _CacheEngineOverrides,
+    execution_type: StageExecutionType,
 ) -> OmniStageCacheConfig:
     kwargs = _config_kwargs(engine)
     if "enable_prefix_caching" not in kwargs and deploy.enable_prefix_caching is not None:
         kwargs["enable_prefix_caching"] = _copy_value(deploy.enable_prefix_caching)
+    if "disable_hybrid_kv_cache_manager" not in kwargs and execution_type == StageExecutionType.LLM_GENERATION:
+        # Match the generation-stage override applied by legacy finalization.
+        kwargs["disable_hybrid_kv_cache_manager"] = True
     return OmniStageCacheConfig(**kwargs)
 
 
 def _build_scheduler_config(
     deploy: DeployConfig,
     engine: _SchedulerEngineOverrides,
+    execution_type: StageExecutionType,
 ) -> OmniStageSchedulerConfig:
     kwargs = _config_kwargs(engine)
     if "enable_chunked_prefill" not in kwargs and deploy.enable_chunked_prefill is not None:
         kwargs["enable_chunked_prefill"] = _copy_value(deploy.enable_chunked_prefill)
+    if "async_scheduling" not in kwargs and execution_type == StageExecutionType.LLM_AR:
+        kwargs["async_scheduling"] = True
     return OmniStageSchedulerConfig(**kwargs)
 
 
-def _build_connector_config(stage_deploy: StageDeployConfig | None) -> OmniStageConnectorConfig:
+def _build_connector_config(
+    deploy: DeployConfig,
+    stage_deploy: StageDeployConfig | None,
+    engine: _ConnectorEngineOverrides,
+) -> OmniStageConnectorConfig:
     output_connectors = stage_deploy.output_connectors if stage_deploy is not None else None
     input_connectors = stage_deploy.input_connectors if stage_deploy is not None else None
     return OmniStageConnectorConfig(
+        async_chunk=bool(deploy.async_chunk),
+        omni_kv_config=_copy_value(engine.get("omni_kv_config")),
         output_connectors=_copy_value(output_connectors) if output_connectors else None,
         input_connectors=_copy_value(input_connectors) if input_connectors else None,
     )
 
 
 def _build_runtime_config(
+    deploy: DeployConfig,
     stage_deploy: StageDeployConfig | None,
     engine: _RuntimeEngineOverrides,
     parallel_config: OmniStageParallelConfig,
 ) -> OmniStageRuntimeConfig:
     kwargs = _config_kwargs(engine)
+    if "distributed_executor_backend" not in kwargs and deploy.distributed_executor_backend is not None:
+        kwargs["distributed_executor_backend"] = _copy_value(deploy.distributed_executor_backend)
     if "devices" not in kwargs and stage_deploy is not None and stage_deploy.devices is not None:
         kwargs["devices"] = _copy_value(stage_deploy.devices)
     if "num_replicas" not in kwargs and stage_deploy is not None:
@@ -1195,13 +1472,15 @@ def _build_diffusion_config_projection(
         topology.model_arch,
         pipeline.model_arch,
     )
+    if "model_class_name" not in diffusion_kwargs and topology.model_arch is not None:
+        diffusion_kwargs["model_class_name"] = _copy_value(topology.model_arch)
     if "dtype" not in diffusion_kwargs and deploy.dtype is not None:
         diffusion_kwargs["dtype"] = _copy_value(deploy.dtype)
     if "trust_remote_code" not in diffusion_kwargs and deploy.trust_remote_code is not None:
         diffusion_kwargs["trust_remote_code"] = _copy_value(deploy.trust_remote_code)
     if "distributed_executor_backend" not in diffusion_kwargs and deploy.distributed_executor_backend is not None:
         diffusion_kwargs["distributed_executor_backend"] = _copy_value(deploy.distributed_executor_backend)
-    if model is not None:
+    if "model" not in diffusion_kwargs and model is not None:
         diffusion_kwargs["model"] = model
     if quantization_config is not None:
         diffusion_kwargs["quantization_config"] = _copy_value(quantization_config)
@@ -1224,61 +1503,51 @@ class VllmOmniConfig:
         raise KeyError(f"no stage {stage_id}")
 
     @classmethod
-    def from_registry(
+    def from_pipeline_config(
         cls,
-        model_type: str,
+        pipeline_cfg: PipelineConfig,
+        *,
+        user_deploy_config: DeployConfig | None = None,
         deploy_config_path: str | None = None,
         cli_overrides: dict[str, Any] | None = None,
     ) -> VllmOmniConfig:
-        """Create a structured config from a registered pipeline and deploy YAML."""
+        """Create a structured config from a resolved pipeline and deploy YAML."""
         if cli_overrides is None:
             cli_overrides = {}
 
-        deploy_path = _resolve_deploy_path(model_type, deploy_config_path)
-        loaded_deploy_config_path = str(deploy_path) if deploy_path.exists() else None
-        if loaded_deploy_config_path is not None:
-            deploy = load_deploy_config(deploy_path)
-        else:
-            deploy = DeployConfig()
+        deploy, loaded_deploy_config_path = _get_deploy_config(
+            pipeline_cfg,
+            user_deploy_config,
+            deploy_config_path,
+        )
 
-        pipeline_key = deploy.pipeline or model_type
-        if pipeline_key not in _registered_pipeline_keys():
-            raise KeyError(
-                f"Pipeline {pipeline_key!r} not in registry "
-                f"(resolved from {deploy_path.name!r}). Available: "
-                f"{_registered_pipeline_keys()}"
-            )
-        pipeline = _resolve_registered_pipeline(pipeline_key)
-        if pipeline is None:
-            raise ValueError(
-                f"Pipeline {pipeline_key!r} did not resolve to a concrete PipelineConfig without an HF config"
-            )
-
-        deploy_for_registry = copy.deepcopy(deploy)
         if cli_overrides.get("async_chunk") is not None:
-            deploy_for_registry.async_chunk = bool(cli_overrides["async_chunk"])
+            deploy.async_chunk = bool(cli_overrides["async_chunk"])
         for name in _PIPELINE_DEPLOY_CLI_FIELDS:
             if cli_overrides.get(name) is not None:
-                setattr(deploy_for_registry, name, _copy_value(cli_overrides[name]))
+                setattr(deploy, name, _copy_value(cli_overrides[name]))
 
-        deploy_for_registry = _apply_platform_overrides(deploy_for_registry)
-        _validate_async_chunk_support(pipeline, deploy_for_registry)
-        deploy_by_id = {stage.stage_id: stage for stage in deploy_for_registry.stages}
+        deploy = _apply_platform_overrides(deploy)
+        if len(pipeline_cfg.stages) <= 1:
+            deploy.async_chunk = False
+        _validate_async_chunk_support(pipeline_cfg, deploy)
+        deploy_by_id = {stage.stage_id: stage for stage in deploy.stages}
         model = cli_overrides.get("model")
 
         stage_configs = tuple(
             _build_stage_config(
-                pipeline,
-                deploy_for_registry,
+                pipeline_cfg,
+                deploy,
                 topology,
                 deploy_by_id.get(topology.stage_id),
                 _stage_engine_values(
                     deploy_by_id.get(topology.stage_id),
+                    topology,
                     _stage_cli_overrides(topology.stage_id, cli_overrides),
                 ),
                 model=model,
             )
-            for topology in pipeline.stages
+            for topology in pipeline_cfg.stages
         )
 
         orchestrator_config = VllmOmniOrchestratorConfig(
@@ -1286,7 +1555,7 @@ class VllmOmniConfig:
             **_orchestrator_cli_overrides(cli_overrides),
         )
         return cls(
-            pipeline_config=pipeline,
+            pipeline_config=pipeline_cfg,
             stage_configs=stage_configs,
             orchestrator_config=orchestrator_config,
         )
diff --git a/vllm_omni/config/pipeline_registry.py b/vllm_omni/config/pipeline_registry.py
index 934d15d18..d702f1ace 100644
--- a/vllm_omni/config/pipeline_registry.py
+++ b/vllm_omni/config/pipeline_registry.py
@@ -33,6 +33,12 @@ from vllm.logger import init_logger
 from vllm_omni.config.stage_config import (
     PipelineConfig,
 )
+from vllm_omni.model_executor.models.audex.pipeline import (
+    AUDEX_S2S_PIPELINE,
+    AUDEX_THINKER_ONLY_PIPELINE,
+    AUDEX_TTA_PIPELINE,
+    AUDEX_TTS_PIPELINE,
+)
 from vllm_omni.model_executor.models.aura_omni.pipeline import AURA_OMNI_PIPELINE
 from vllm_omni.model_executor.models.bagel.pipeline import (
     BAGEL_PIPELINE,
@@ -54,6 +60,7 @@ from vllm_omni.model_executor.models.hunyuan_image3.pipeline import (
     HUNYUAN_IMAGE3_DIT_PIPELINE,
     HUNYUAN_IMAGE3_PIPELINE,
 )
+from vllm_omni.model_executor.models.hunyuan_video.pipeline import HUNYUAN_VIDEO_15_PIPELINE
 from vllm_omni.model_executor.models.indextts2.pipeline import INDEXTTS2_PIPELINE
 from vllm_omni.model_executor.models.lance.pipeline import LANCE_PIPELINE
 from vllm_omni.model_executor.models.mammoth_moda2.pipeline import (
@@ -79,14 +86,24 @@ from vllm_omni.model_executor.models.moss_tts.pipeline import (
 )
 from vllm_omni.model_executor.models.moss_tts_nano.pipeline import MOSS_TTS_NANO_PIPELINE
 from vllm_omni.model_executor.models.omnivoice.pipeline import OMNIVOICE_PIPELINE
+from vllm_omni.model_executor.models.personaplex.pipeline import PERSONAPLEX_PIPELINE
 from vllm_omni.model_executor.models.qwen2_5_omni.pipeline import (
     QWEN2_5_OMNI_PIPELINE,
     QWEN2_5_OMNI_THINKER_ONLY_PIPELINE,
 )
 from vllm_omni.model_executor.models.qwen3_omni.pipeline import resolve_qwen3_omni_pipeline
 from vllm_omni.model_executor.models.qwen3_tts.pipeline import QWEN3_TTS_PIPELINE
+from vllm_omni.model_executor.models.soulx_singer.pipeline import (
+    SOULXSINGER_SVC_PIPELINE,
+    SOULXSINGER_SVS_PIPELINE,
+)
+from vllm_omni.model_executor.models.step_audio2.pipeline import (
+    STEP_AUDIO2_ASR_PIPELINE,
+    STEP_AUDIO2_PIPELINE,
+)
 from vllm_omni.model_executor.models.voxcpm2.pipeline import VOXCPM2_PIPELINE
 from vllm_omni.model_executor.models.voxtral_tts.pipeline import VOXTRAL_TTS_PIPELINE
+from vllm_omni.model_executor.models.wan2_2.pipeline import WAN2_2_TI2V_PIPELINE
 
 logger = init_logger(__name__)
 
@@ -97,8 +114,11 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "aura_omni": AURA_OMNI_PIPELINE,
     "qwen2_5_omni": QWEN2_5_OMNI_PIPELINE,
     "qwen2_5_omni_thinker_only": QWEN2_5_OMNI_THINKER_ONLY_PIPELINE,
+    "personaplex": PERSONAPLEX_PIPELINE,
     "qwen3_omni_moe": resolve_qwen3_omni_pipeline,
     "qwen3_tts": QWEN3_TTS_PIPELINE,
+    "step_audio_2": STEP_AUDIO2_PIPELINE,
+    "step_audio_2_asr": STEP_AUDIO2_ASR_PIPELINE,
     "covo_audio": COVO_AUDIO_PIPELINE,
     "bagel": BAGEL_PIPELINE,
     "bagel_think": BAGEL_THINK_PIPELINE,
@@ -110,8 +130,18 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "hunyuan_image_3_moe": HUNYUAN_IMAGE3_PIPELINE,
     "hunyuan_image3_ar": HUNYUAN_IMAGE3_AR_PIPELINE,
     "hunyuan_image3_dit": HUNYUAN_IMAGE3_DIT_PIPELINE,
+    "hunyuan_video_15": HUNYUAN_VIDEO_15_PIPELINE,
+    "wan2_2_ti2v": WAN2_2_TI2V_PIPELINE,
     "voxcpm2": VOXCPM2_PIPELINE,
     "cosyvoice3": COSYVOICE3_PIPELINE,
+    "audex_tts": AUDEX_TTS_PIPELINE,
+    "audex_tta": AUDEX_TTA_PIPELINE,
+    "audex_thinker_only": AUDEX_THINKER_ONLY_PIPELINE,
+    "audex_s2s": AUDEX_S2S_PIPELINE,
+    # Alias: the Nemotron-Labs-Audex-2B repo-root config.json reports
+    # ``model_type: nemotron_labs_audex``; bare ``vllm-omni serve <repo>``
+    # auto-detects through it and must land on the default (TTS) pipeline.
+    "nemotron_labs_audex": AUDEX_TTS_PIPELINE,
     "mimo_audio": MIMO_AUDIO_PIPELINE,
     "ming_tts": MING_TTS_PIPELINE,
     "ming_tts_moe": MING_TTS_MOE_PIPELINE,
@@ -134,6 +164,8 @@ OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "higgs_multimodal_qwen3": HIGGS_AUDIO_V3_PIPELINE,
     "dynin_omni": DYNIN_OMNI_PIPELINE,
     "indextts2": INDEXTTS2_PIPELINE,
+    "soulxsinger_svc": SOULXSINGER_SVC_PIPELINE,
+    "soulxsinger_svs": SOULXSINGER_SVS_PIPELINE,
 }
 
 
@@ -157,3 +189,15 @@ def register_pipeline(pipeline: PipelineConfig | PipelineResolverFunc, model_typ
     if errors:
         logger.warning("Registration for pipeline of type %s produced the following issues: %s", model_type, errors)
     OMNI_PIPELINES[model_type] = pipeline
+
+
+def resolve_pipeline_config(
+    model_type: str,
+    hf_config: PretrainedConfig | None = None,
+) -> PipelineConfig | None:
+    """Resolve a registry key to a concrete pipeline config."""
+    if model_type not in OMNI_PIPELINES:
+        logger.warning("Model type %s is not registered to OMNI_PIPELINES", model_type)
+        return None
+    pipeline = OMNI_PIPELINES[model_type]
+    return pipeline(hf_config) if callable(pipeline) else pipeline
diff --git a/vllm_omni/config/stage_config.py b/vllm_omni/config/stage_config.py
index 6b8a09423..602ca1e20 100644
--- a/vllm_omni/config/stage_config.py
+++ b/vllm_omni/config/stage_config.py
@@ -149,14 +149,17 @@ def _apply_diffusion_parallel_runtime_overrides(
             continue
         if parallel_config_dict is None:
             parallel_config_dict = {}
-        if key in ("ulysses_degree", "ring_degree"):
+        if key in ("ulysses_degree", "ring_degree", "allgather_degree"):
             degree_overridden = True
         parallel_config_dict[key] = runtime_overrides.pop(key)
 
     if parallel_config_dict is not None and degree_overridden and not sequence_parallel_explicit:
         ulysses_degree = parallel_config_dict.get("ulysses_degree") or 1
         ring_degree = parallel_config_dict.get("ring_degree") or 1
-        parallel_config_dict["sequence_parallel_size"] = ulysses_degree * ring_degree
+        allgather_degree = parallel_config_dict.get("allgather_degree") or 1
+        parallel_config_dict["sequence_parallel_size"] = (
+            allgather_degree if allgather_degree > 1 else ulysses_degree * ring_degree
+        )
 
     if parallel_config_dict is not None:
         engine_args["parallel_config"] = parallel_config_dict
@@ -220,6 +223,9 @@ class StagePipelineConfig:
     hf_config_name: str | None = None
     engine_output_type: str | None = None
     model_arch: str | None = None
+    # The model keeps per-request execution state while awaiting the next
+    # async chunk, so the parked request continues to consume model capacity.
+    retains_state_across_chunks: bool = False
     sampling_constraints: dict[str, Any] = field(default_factory=dict)
     custom_process_input_func: str | None = None
     custom_process_next_stage_input_func: str | None = None
@@ -270,6 +276,18 @@ class PipelineConfig:
     # multi-component repos (e.g. GLM-Image).  ``None`` = not a diffusers model.
     diffusers_class_name: str | None = None
     endpoint_restrictions: tuple[EndpointRestriction, ...] = ()
+    # Optional model-owned duplex planner loaded by the stable engine runtime.
+    duplex_runtime_extension: str | None = None
+    # Optional model-owned Serving adapter loaded only when the Realtime duplex
+    # endpoint is enabled. Generic OpenAI modules must not select a model.
+    duplex_serving_adapter: str | None = None
+    # Explicitly enable the stable duplex control mechanism. This is separate
+    # from the optional model extension because turn-commit-only deployments
+    # do not require a model planner.
+    duplex_control_enabled: bool = False
+    # Bundled deploy defaults for this concrete pipeline topology. The file is
+    # loaded from vllm_omni/deploy; None uses DeployConfig defaults.
+    default_deploy_config_name: str | None = None
 
     def get_stage(self, stage_id: int) -> StagePipelineConfig | None:
         """Look up a stage by its ID."""
@@ -354,10 +372,12 @@ class StageDeployConfig:
     ulysses_degree: int | None = None
     ulysses_mode: str | None = None
     ring_degree: int | None = None
+    allgather_degree: int | None = None
     sequence_parallel_size: int | None = None
     cfg_parallel_size: int | None = None
     vae_patch_parallel_size: int | None = None
     vae_parallel_mode: str | None = None
+    text_encoder_tp_size: int | None = None
     use_hsdp: bool | None = None
     hsdp_shard_size: int | None = None
     hsdp_replicate_size: int | None = None
@@ -372,6 +392,8 @@ class StageDeployConfig:
     diffusion_attention_config: dict[str, Any] | None = None
 
     # Diffusion execution, cache, and VAE behavior.
+    diffusion_compile_granularity: str | None = None
+    diffusion_compile_dynamic: bool | None = None
     cache_backend: str | None = None
     cache_config: dict[str, Any] | None = None
     enable_cache_dit_summary: bool | None = None
@@ -391,6 +413,9 @@ class StageDeployConfig:
     enable_cpu_offload: bool | None = None
     enable_layerwise_offload: bool | None = None
 
+    enable_distributed_layerwise_offload: bool | None = None
+    dlo_use_allgather: bool | None = None
+    dlo_resident_layers: int | None = None
     # Diffusion-specific debug and observability knobs.
     enable_diffusion_pipeline_profiler: bool | None = None
 
@@ -403,6 +428,38 @@ class StageDeployConfig:
     engine_extras: dict[str, Any] = field(default_factory=dict)
 
 
+@dataclass(frozen=True)
+class DuplexSessionRuntimeConfig:
+    """Server-owned lifecycle and per-session buffering limits."""
+
+    idle_ttl_s: float | None = 300.0
+    disconnect_grace_s: float = 30.0
+    reaper_interval_s: float = 5.0
+    resume_replay_ttl_s: float = 60.0
+    resume_replay_max_bytes_per_session: int = 8 * 1024 * 1024
+    max_pending_input_bytes_per_session: int = 16 * 1024 * 1024
+    max_pending_turns_per_session: int = 4
+    max_sessions: int = 1
+    completed_append_cache_size: int = 256
+
+    def __post_init__(self) -> None:
+        positive = {
+            "disconnect_grace_s": self.disconnect_grace_s,
+            "reaper_interval_s": self.reaper_interval_s,
+            "resume_replay_ttl_s": self.resume_replay_ttl_s,
+            "resume_replay_max_bytes_per_session": self.resume_replay_max_bytes_per_session,
+            "max_pending_input_bytes_per_session": self.max_pending_input_bytes_per_session,
+            "max_pending_turns_per_session": self.max_pending_turns_per_session,
+            "max_sessions": self.max_sessions,
+            "completed_append_cache_size": self.completed_append_cache_size,
+        }
+        if self.idle_ttl_s is not None and self.idle_ttl_s <= 0:
+            raise ValueError("duplex_session.idle_ttl_s must be positive or null")
+        for name, value in positive.items():
+            if value <= 0:
+                raise ValueError(f"duplex_session.{name} must be positive")
+
+
 @dataclass
 class DeployConfig:
     """Loaded from deploy/<model>.yaml — the only config file users edit.
@@ -416,8 +473,10 @@ class DeployConfig:
     """
 
     async_chunk: bool = True
+    session_mode: str = "turn"
     # Stage-1 active stream slots; 0 preserves legacy all-stream cycling.
     active_stream_window: int = 0
+    duplex_session: DuplexSessionRuntimeConfig = field(default_factory=DuplexSessionRuntimeConfig)
     connectors: dict[str, Any] | None = None
     edges: list[dict[str, Any]] | None = None
     stages: list[StageDeployConfig] = field(default_factory=list)
@@ -607,7 +666,9 @@ def load_deploy_config(path: str | Path) -> DeployConfig:
 
     kwargs: dict[str, Any] = {
         "async_chunk": raw_dict.get("async_chunk", True),
+        "session_mode": raw_dict.get("session_mode", "turn"),
         "active_stream_window": int(raw_dict.get("active_stream_window", 0) or 0),
+        "duplex_session": DuplexSessionRuntimeConfig(**(raw_dict.get("duplex_session") or {})),
         "connectors": raw_dict.get("connectors", None),
         "edges": raw_dict.get("edges", None),
         "stages": stages,
@@ -767,7 +828,8 @@ def _build_engine_args(
     per-stage StageDeployConfig overrides take precedence when present (e.g.
     ``engine_extras`` can still carry a stage-specific ``dtype``).
     """
-    engine_args: dict[str, Any] = {"model_arch": ps.model_arch or pipeline.model_arch}
+    engine_args: dict[str, Any] = {"model_arch": ps.model_arch or pipeline.model_arch or None}
+    engine_args["retains_state_across_chunks"] = ps.retains_state_across_chunks
     if ps.execution_type == StageExecutionType.DIFFUSION and ps.model_arch:
         engine_args.setdefault("model_class_name", ps.model_arch)
     if ps.engine_output_type:
@@ -798,6 +860,11 @@ def _build_engine_args(
     # Materialize the resolved pipeline-wide async_chunk value into every
     # stage so explicit False overrides do not get lost downstream.
     engine_args["async_chunk"] = bool(deploy.async_chunk)
+    if deploy.session_mode == "duplex":
+        # The engine admission limit is also the authoritative capacity for
+        # model-owned streaming state. Propagate it to every stage instead of
+        # making individual models duplicate the value in connector extras.
+        engine_args["duplex_max_sessions"] = deploy.duplex_session.max_sessions
     if ps.omni_kv_config:
         engine_args["omni_kv_config"] = dict(ps.omni_kv_config)
     return engine_args
@@ -873,6 +940,10 @@ def merge_pipeline_deploy(
         stage_type, worker_type = _resolve_execution_mode(ps.execution_type)
         input_proc, next_stage_proc = _select_processor_funcs(ps, deploy.async_chunk)
         engine_args = _build_engine_args(ps, ds, pipeline, deploy, next_stage_proc)
+        # Downstream stages may share a multimodal wrapper class without owning
+        # an encoder. Do not make vLLM profile dummy multimodal inputs for them.
+        if not ps.requires_multimodal_data:
+            engine_args.setdefault("skip_mm_profiling", True)
         sched_cls = _resolve_scheduler(
             ps.execution_type,
             engine_args.get("async_scheduling", True),
@@ -893,6 +964,7 @@ def merge_pipeline_deploy(
             StageConfig(
                 stage_id=ps.stage_id,
                 model_stage=ps.model_stage,
+                session_mode=deploy.session_mode,
                 stage_type=stage_type,
                 input_sources=list(ps.input_sources),
                 custom_process_input_func=input_proc,
@@ -919,6 +991,7 @@ class StageConfig:
 
     stage_id: int
     model_stage: str
+    session_mode: str = "turn"
     stage_type: StageType = StageType.LLM
     input_sources: list[int] = field(default_factory=list)
     custom_process_input_func: str | None = None
@@ -981,6 +1054,7 @@ class StageConfig:
         config_dict: dict[str, Any] = {
             "stage_id": self.stage_id,
             "stage_type": StageType(self.stage_type).value,
+            "session_mode": self.session_mode,
             "engine_args": create_config(engine_args),
             "runtime": create_config(runtime),
             "engine_input_source": self.input_sources,  # Legacy field name
diff --git a/vllm_omni/core/sched/__init__.py b/vllm_omni/core/sched/__init__.py
index 0f80769d3..ce968893d 100644
--- a/vllm_omni/core/sched/__init__.py
+++ b/vllm_omni/core/sched/__init__.py
@@ -2,9 +2,28 @@
 Scheduling components for vLLM-Omni.
 """
 
-from .omni_ar_scheduler import OmniARAsyncScheduler, OmniARScheduler
-from .omni_generation_scheduler import OmniGenerationScheduler
-from .output import OmniNewRequestData
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+_LAZY_EXPORTS = {
+    "OmniARAsyncScheduler": (".omni_ar_scheduler", "OmniARAsyncScheduler"),
+    "OmniARScheduler": (".omni_ar_scheduler", "OmniARScheduler"),
+    "OmniGenerationScheduler": (".omni_generation_scheduler", "OmniGenerationScheduler"),
+    "OmniNewRequestData": (".output", "OmniNewRequestData"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(name)
+    module_name, attribute_name = target
+    value = getattr(import_module(module_name, __name__), attribute_name)
+    globals()[name] = value
+    return value
+
 
 __all__ = [
     "OmniARAsyncScheduler",
diff --git a/vllm_omni/core/sched/omni_ar_scheduler.py b/vllm_omni/core/sched/omni_ar_scheduler.py
index 74d09ab60..5a36d969a 100644
--- a/vllm_omni/core/sched/omni_ar_scheduler.py
+++ b/vllm_omni/core/sched/omni_ar_scheduler.py
@@ -1,50 +1,73 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from dataclasses import asdict, dataclass
-from time import time
+from collections.abc import Iterable
 from typing import Any
 
+import numpy as np
 from vllm.compilation.cuda_graph import CUDAGraphStat
-from vllm.distributed.kv_events import KVEventBatch
-from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorStats
 from vllm.logger import init_logger
 from vllm.v1.core.sched.async_scheduler import AsyncScheduler as AsyncVLLMScheduler
 from vllm.v1.core.sched.output import SchedulerOutput
 from vllm.v1.core.sched.request_queue import create_request_queue
 from vllm.v1.core.sched.scheduler import Scheduler as VLLMScheduler
-from vllm.v1.core.sched.utils import remove_all
-from vllm.v1.engine import EngineCoreEventType, EngineCoreOutput, EngineCoreOutputs, FinishReason
+from vllm.v1.engine import EngineCoreEventType, EngineCoreOutput, EngineCoreOutputs
 from vllm.v1.metrics.perf import PerfStats
 from vllm.v1.outputs import ModelRunnerOutput
 from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm.v1.spec_decode.metrics import SpecDecodingStats
 
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
-from vllm_omni.core.sched.omni_scheduling_coordinator import (
-    OmniSchedulingCoordinator,
-    uses_full_payload_input_coordinator,
-)
 from vllm_omni.core.sched.utils import omni_routed_experts_for_request
-from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter import (
-    OmniChunkTransferAdapter,
-)
 from vllm_omni.engine import OmniEngineCoreOutput
 from vllm_omni.engine.serialization import deserialize_additional_information
-from vllm_omni.outputs import OmniConnectorOutput
 
 logger = init_logger(__name__)
 
 
-@dataclass
-class KVCacheTransferData:
-    request_id: str
-    layer_blocks: dict[str, Any]
-    block_ids: list[int]
-    metadata: dict[str, Any]
+class SampledLogprobContractError(RuntimeError):
+    """The model runner returned unusable sampled-token logprobs."""
 
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
+
+def _slice_sampled_logprobs(logprobs: Any, req_index: int, sampled_token_ids: list[int]) -> Any:
+    """Slice and validate the sampled-token logprobs for one AR request."""
+    if logprobs is None:
+        raise SampledLogprobContractError("AR logprobs were requested, but the model runner returned none")
+
+    sliced = logprobs.slice_request(req_index, len(sampled_token_ids))
+    token_rows = np.asarray(sliced.logprob_token_ids)
+    value_rows = np.asarray(sliced.logprobs)
+    expected_rows = len(sampled_token_ids)
+
+    if token_rows.ndim != 2 or value_rows.ndim != 2:
+        raise SampledLogprobContractError(
+            "AR sampled-token logprobs must be rank-2 arrays, "
+            f"got token_ids={token_rows.shape} logprobs={value_rows.shape}"
+        )
+    if token_rows.shape[0] != expected_rows or value_rows.shape[0] != expected_rows:
+        raise SampledLogprobContractError(
+            "AR sampled-token logprob row count does not match generated tokens: "
+            f"tokens={expected_rows} token_id_rows={token_rows.shape[0]} "
+            f"logprob_rows={value_rows.shape[0]}"
+        )
+    if expected_rows == 0:
+        return sliced
+    if token_rows.shape[1] == 0 or value_rows.shape[1] == 0:
+        raise SampledLogprobContractError("AR sampled-token logprob rows are empty")
+
+    sampled = np.asarray(sampled_token_ids)
+    if not np.array_equal(token_rows[:, 0], sampled):
+        mismatch = np.flatnonzero(token_rows[:, 0] != sampled)
+        first = int(mismatch[0])
+        raise SampledLogprobContractError(
+            "AR sampled-token logprobs are misaligned: "
+            f"row={first} generated_token={int(sampled[first])} "
+            f"logprob_token={int(token_rows[first, 0])}"
+        )
+    if not np.isfinite(value_rows[:, 0]).all():
+        bad_rows = np.flatnonzero(~np.isfinite(value_rows[:, 0])).tolist()
+        raise SampledLogprobContractError(f"AR sampled-token logprobs contain non-finite values at rows {bad_rows}")
+    return sliced
 
 
 class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
@@ -73,6 +96,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         self.finished_req_ids_dict = defaultdict(set)
 
         # [Omni] Pre-parse KV transfer criteria
+        self._omni_kv_config = getattr(self.vllm_config.model_config, "omni_kv_config", None)
         self.kv_transfer_criteria = self._get_kv_transfer_criteria()
 
         # Track requests that have already triggered prefill transfer to avoid duplicates
@@ -80,18 +104,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         # Cache per-request flag to avoid repeated deserialization of additional_information
         self._omits_kv_transfer_cache: dict[str, bool] = {}
-        model_config = self.vllm_config.model_config
-        self.chunk_transfer_adapter = None
-        if getattr(model_config, "async_chunk", False):
-            self.chunk_transfer_adapter = OmniChunkTransferAdapter(self.vllm_config)
-        self.input_coordinator: OmniSchedulingCoordinator | None = None
-        if uses_full_payload_input_coordinator(model_config):
-            self.input_coordinator = OmniSchedulingCoordinator(
-                scheduler_max_num_seqs=self.vllm_config.scheduler_config.max_num_seqs,
-                stage_id=getattr(model_config, "stage_id", 0),
-                async_chunk=False,
-            )
-        self._latest_omni_connector_output: OmniConnectorOutput | None = None
+        self._init_omni_io_scheduling_state()
         # Snapshot prompt length for each streaming input update
         self._new_prompt_len_snapshot: dict[str, int] = {}
 
@@ -101,20 +114,18 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         return request.num_computed_tokens - request.num_output_placeholders
 
     def _get_kv_transfer_criteria(self) -> dict | None:
-        # Note: vllm_config is available in Scheduler after super().__init__
-        if not hasattr(self, "vllm_config"):
-            return None
+        return self._get_omni_kv_config_value("kv_transfer_criteria")
 
-        omni_kv_config = getattr(self.vllm_config.model_config, "omni_kv_config", None)
-        if omni_kv_config:
-            if isinstance(omni_kv_config, dict):
-                return omni_kv_config.get("kv_transfer_criteria", None)
-            else:
-                return getattr(omni_kv_config, "kv_transfer_criteria", None)
-        return None
+    def _get_omni_kv_config_value(self, key: str, default: Any = None) -> Any:
+        config = getattr(self, "_omni_kv_config", None)
+        if config is None and hasattr(self, "vllm_config"):
+            config = getattr(self.vllm_config.model_config, "omni_kv_config", None)
+        if isinstance(config, dict):
+            return config.get(key, default)
+        return getattr(config, key, default) if config is not None else default
 
     def _request_omits_kv_transfer_to_next_stage(self, request: Request) -> bool:
-        """True when orchestrator will not run stage 1+ for this request (e.g. text-only).
+        """True when this stage-zero-final request does not need downstream KV.
 
         The result is cached per request to avoid repeated deserialization of
         additional_information on every scheduler tick.
@@ -129,7 +140,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             result = False
         else:
             info = deserialize_additional_information(payload)
-            result = info.get("omni_final_stage_id") == 0
+            result = info.get("omni_final_stage_id") == 0 and not bool(info.get("omni_force_kv_transfer", False))
 
         self._omits_kv_transfer_cache[rid] = result
         return result
@@ -174,41 +185,39 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         if criteria_type == "prefill_finished":
             if confirmed_computed >= request.num_prompt_tokens:
-                self.transfer_triggered_requests.add(request.request_id)
-                self._mark_request_for_kv_transfer(request.request_id, confirmed_computed)
-                actually_queued = request.request_id in self.requests_needing_kv_transfer
-
-                if stop_decode_on_trigger and actually_queued:
-                    # Defer the stop until KV extraction completes so that
-                    # the kv_ready signal can be emitted while the request
-                    # is still alive.  The request will be stopped on the
-                    # next scheduler step after extraction ack arrives.
-                    self.pending_stop_after_extraction.add(request.request_id)
-
+                self._commit_kv_transfer_trigger(
+                    request.request_id,
+                    confirmed_computed,
+                    stop_decode_on_trigger,
+                )
                 return False
 
         elif criteria_type == "special_token":
             target_token_id = self.kv_transfer_criteria.get("token_id")
             if target_token_id is not None and target_token_id in new_token_ids:
-                self.transfer_triggered_requests.add(request.request_id)
-
-                try:
-                    idx = new_token_ids.index(target_token_id)
-                    tokens_to_exclude = len(new_token_ids) - (idx + 1)
-                    snapshot_len = confirmed_computed - tokens_to_exclude
-                except ValueError:
-                    snapshot_len = confirmed_computed
-
-                self._mark_request_for_kv_transfer(request.request_id, snapshot_len)
-                actually_queued = request.request_id in self.requests_needing_kv_transfer
-
-                if stop_decode_on_trigger and actually_queued:
-                    self.pending_stop_after_extraction.add(request.request_id)
-
+                idx = new_token_ids.index(target_token_id)
+                tokens_to_exclude = len(new_token_ids) - (idx + 1)
+                snapshot_len = confirmed_computed - tokens_to_exclude
+                self._commit_kv_transfer_trigger(
+                    request.request_id,
+                    snapshot_len,
+                    stop_decode_on_trigger,
+                )
                 return False
 
         return False
 
+    def _commit_kv_transfer_trigger(
+        self,
+        req_id: str,
+        seq_len: int,
+        stop_after_transfer: bool,
+    ) -> None:
+        self.transfer_triggered_requests.add(req_id)
+        self._mark_request_for_kv_transfer(req_id, seq_len)
+        if stop_after_transfer and req_id in self.requests_needing_kv_transfer:
+            self.pending_stop_after_extraction.add(req_id)
+
     def schedule(self, throttle_prefills: bool = False) -> SchedulerOutput:
         # Remove FINISHED_ABORTED requests before the upstream scheduler sees
         # them. Upstream vllm raises RuntimeError on this status; omni allows
@@ -218,13 +227,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             for req in list(queue):
                 if getattr(req, "status", None) == RequestStatus.FINISHED_ABORTED:
                     queue.remove(req)
-        self._consume_pending_connector_output(model_mode="ar")
-        self._process_pending_input_timeouts()
-
-        if self.chunk_transfer_adapter:
-            self.chunk_transfer_adapter.process_pending_chunks(
-                self.waiting, self.running, scheduler_requests=self.requests
-            )
+        self._process_pending_omni_inputs(model_mode="ar")
 
         original_waiting = None
         if self._should_defer_waiting_admission():
@@ -239,52 +242,13 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 if deferred_waiting:
                     original_waiting.prepend_requests(deferred_waiting)
                 self.waiting = original_waiting
-            if self.chunk_transfer_adapter:
-                # Add request waiting for chunk to the waiting and running queue
-                self.chunk_transfer_adapter.restore_queues(
-                    self.waiting,
-                    self.running,
-                    scheduler_requests=self.requests,
-                )
-            if self.input_coordinator:
-                self.input_coordinator.restore_queues(self.waiting, self.running)
-        try:
-            # Late import to avoid circulars in some launch modes
-            from .output import OmniNewRequestData
+            self._restore_omni_wait_queues()
 
-            # Rewrap base NewRequestData entries with OmniNewRequestData,
-            # enriching with request-level payloads
-            new_list = []
-            for nr in scheduler_output.scheduled_new_reqs:
-                req_id = getattr(nr, "req_id", None)
-                request = self.requests.get(req_id) if req_id else None
-                # Build omni entry preserving all base fields
-                omni_nr = OmniNewRequestData(
-                    req_id=nr.req_id,
-                    external_req_id=(getattr(request, "external_req_id", None) if request else None),
-                    prompt_token_ids=nr.prompt_token_ids,
-                    mm_features=nr.mm_features,
-                    sampling_params=nr.sampling_params,
-                    pooling_params=nr.pooling_params,
-                    block_ids=nr.block_ids,
-                    num_computed_tokens=nr.num_computed_tokens,
-                    lora_request=nr.lora_request,
-                    # Enrich with omni payloads from the live request object
-                    prompt_embeds=(getattr(request, "prompt_embeds", None) if request else None),
-                    prompt_is_token_ids=nr.prompt_is_token_ids,
-                    additional_information=(getattr(request, "additional_information", None) if request else None),
-                )
-                new_list.append(omni_nr)
-
-            scheduler_output.scheduled_new_reqs = new_list  # type: ignore[assignment]
-            if self.chunk_transfer_adapter:
-                self.chunk_transfer_adapter.postprocess_scheduler_output(scheduler_output, self.requests)
-            # Add information about requests needing KV cache transfer
-            finished_reqs = self.get_finished_requests_needing_kv_transfer()
-        except Exception:
-            # If anything goes wrong, leave the original output unchanged
-            init_logger(__name__).exception("Failed to wrap scheduled_new_reqs with OmniNewRequestData")
-            finished_reqs = {}
+        self._postprocess_omni_schedule_output(
+            scheduler_output,
+            include_cached_payloads=True,
+        )
+        finished_reqs = self.get_finished_requests_needing_kv_transfer()
 
         # Wrap in omni scheduler output to carry transfer metadata.
         return self._wrap_omni_scheduler_output(
@@ -352,10 +316,18 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         stopped_preempted_reqs: set[Request] = set()
         for req_id, num_tokens_scheduled in num_scheduled_tokens.items():
             assert num_tokens_scheduled > 0
+            request = self.requests.get(req_id)
+            if request is not None:
+                # vLLM 0.26: settle the in-flight tokens counted in schedule().
+                # Must happen before the skips below — failed-KV-load and
+                # already-finished requests were incremented too, and the two
+                # readers (allocate_slots, _connector_finished) clamp with
+                # max(0, computed - in_flight), so a leaked counter silently
+                # freezes sliding-window block freeing.
+                request.num_in_flight_tokens -= num_tokens_scheduled
             if failed_kv_load_req_ids and req_id in failed_kv_load_req_ids:
                 # Skip requests that were recovered from KV load failure
                 continue
-            request = self.requests.get(req_id)
             if request is None or request.is_finished():
                 # The request is already finished. This can happen if the
                 # request is aborted while the model is executing it (e.g.,
@@ -364,6 +336,27 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
             req_index = model_runner_output.req_id_to_index[req_id]
             generated_token_ids = sampled_token_ids[req_index] if sampled_token_ids else []
+            status_before_stop = request.status
+            new_logprobs = None
+            logprob_validation_failed = False
+
+            # Validate before mutating request token state. A bad runner output
+            # is request-local: terminate only this request and keep processing
+            # the rest of the batch.
+            if (
+                generated_token_ids
+                and request.sampling_params is not None
+                and request.sampling_params.num_logprobs is not None
+            ):
+                try:
+                    new_logprobs = _slice_sampled_logprobs(logprobs, req_index, generated_token_ids)
+                except SampledLogprobContractError as exc:
+                    logger.error("Invalid AR sampled-token logprobs for request %s: %s", req_id, exc)
+                    request.status = RequestStatus.FINISHED_ERROR
+                    request.stop_reason = str(exc)
+                    request.resumable = False
+                    generated_token_ids = []
+                    logprob_validation_failed = True
 
             scheduled_spec_token_ids = scheduler_output.scheduled_spec_decode_tokens.get(req_id)
             if scheduled_spec_token_ids and generated_token_ids:
@@ -393,21 +386,28 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             if request.has_encoder_inputs:
                 self._free_encoder_inputs(request)
 
-            stopped = False
+            stopped = logprob_validation_failed
             is_segment_finished = False
-            new_logprobs = None
+            finished = False
             new_token_ids = generated_token_ids
             pooler_output = pooler_outputs[req_index] if pooler_outputs else None
             mm_output = mm_outputs[req_index] if mm_outputs else None
             inter_stage_output = inter_stage_outputs[req_index] if inter_stage_outputs else None
             kv_transfer_params = None
-            status_before_stop = request.status
             finish_reason = None
             routed_experts = None
 
             # Check for stop and update request status.
             if new_token_ids:
+                num_sampled_tokens = len(new_token_ids)
                 new_token_ids, stopped = self._update_request_with_output(request, new_token_ids)
+                if new_logprobs is not None and len(new_token_ids) < num_sampled_tokens:
+                    # A mid-step stop (e.g. spec-decode tokens sampled past
+                    # EOS) trims new_token_ids after the validation slice
+                    # above; re-slice so the emitted logprob rows stay 1:1
+                    # with the emitted tokens, as upstream vLLM does by
+                    # slicing after the trim.
+                    new_logprobs = logprobs.slice_request(req_index, len(new_token_ids))
             elif request.pooling_params and pooler_output is not None:
                 # Pooling stops as soon as there is output.
                 request.status = RequestStatus.FINISHED_STOPPED
@@ -440,8 +440,10 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 # Capture finish_reason BEFORE _handle_stopped_request, which may
                 # reset the status to WAITING for streaming requests that continue.
                 finish_reason = request.get_finished_reason()
-                is_segment_finished = True
                 finished = self._handle_stopped_request(request)
+                is_segment_finished = not finished
+                if finished:
+                    request.resumable = False
                 if not finished:
                     # for streaming input request only
                     if self.chunk_transfer_adapter:
@@ -449,12 +451,17 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                             # Downstream async-chunk stages receive real payloads from the
                             # connector. This update only resumes polling for the next segment.
                             self.chunk_transfer_adapter.segment_finished_requests.discard(request.request_id)
-                    request.async_tokens_to_discard = 1
-                    request.num_output_placeholders = 0
+                    outstanding_async_tokens = request.num_output_placeholders
+                    if outstanding_async_tokens > 0:
+                        # Discard only outputs that are already in flight and
+                        # roll back their optimistic computed-token accounting.
+                        request.async_tokens_to_discard = outstanding_async_tokens
+                        request.num_computed_tokens -= outstanding_async_tokens
+                        request.num_output_placeholders = 0
                     request.spec_token_ids = []
                     request._output_token_ids.clear()
                 if finished:
-                    kv_transfer_params = self._free_request(request)
+                    kv_transfer_params, _ = self._free_request(request)
                 if status_before_stop == RequestStatus.RUNNING:
                     stopped_running_reqs.add(request)
                 elif status_before_stop == RequestStatus.WAITING_FOR_CHUNK:
@@ -465,159 +472,81 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 else:
                     stopped_preempted_reqs.add(request)
 
-            # Extract sample logprobs if needed.
-            if request.sampling_params is not None and request.sampling_params.num_logprobs is not None and logprobs:
-                new_logprobs = logprobs.slice_request(req_index, len(new_token_ids))
-
             if num_nans_in_logits is not None and req_id in num_nans_in_logits:
                 request.num_nans_in_logits = num_nans_in_logits[req_id]
 
             # Get prompt logprobs for this request.
             prompt_logprobs_tensors = prompt_logprobs_dict.get(req_id)
             if new_token_ids or mm_output is not None or pooler_output is not None or kv_transfer_params or stopped:
-                # Add EngineCoreOutput for this Request.
-                outputs[request.client_index].append(
-                    OmniEngineCoreOutput(
-                        request_id=req_id,
-                        new_token_ids=new_token_ids,
-                        finish_reason=finish_reason,
-                        new_logprobs=new_logprobs,
-                        new_prompt_logprobs_tensors=prompt_logprobs_tensors,
-                        pooling_output=pooler_output,
-                        multimodal_output=mm_output,
-                        stop_reason=request.stop_reason,
-                        events=request.take_events(),
-                        prefill_stats=request.take_prefill_stats(),
-                        kv_transfer_params=kv_transfer_params,
-                        trace_headers=request.trace_headers,
-                        routed_experts=routed_experts,
-                        num_nans_in_logits=request.num_nans_in_logits,
-                        is_segment_finished=is_segment_finished,
-                        new_prompt_len_snapshot=self._new_prompt_len_snapshot.get(req_id, None),
-                    )
+                OmniSchedulerMixin._append_request_output(
+                    self,
+                    outputs,
+                    request,
+                    new_token_ids=new_token_ids,
+                    finish_reason=finish_reason,
+                    new_logprobs=new_logprobs,
+                    new_prompt_logprobs_tensors=prompt_logprobs_tensors,
+                    pooling_output=pooler_output,
+                    multimodal_output=mm_output,
+                    stop_reason=request.stop_reason,
+                    prefill_stats=request.take_prefill_stats(),
+                    kv_transfer_params=kv_transfer_params,
+                    routed_experts=routed_experts,
+                    num_nans_in_logits=request.num_nans_in_logits,
+                    is_segment_finished=is_segment_finished,
+                    new_prompt_len_snapshot=self._new_prompt_len_snapshot.get(req_id),
                 )
             else:
                 # Invariant: EngineCore returns no partial prefill outputs.
                 assert not prompt_logprobs_tensors
 
-            if self.chunk_transfer_adapter is not None and (inter_stage_output is not None or is_segment_finished):
+            if self.chunk_transfer_adapter is not None and (
+                inter_stage_output is not None or is_segment_finished or finished
+            ):
                 self.chunk_transfer_adapter.save_async(
                     inter_stage_output,
                     request,
                     is_segment_finished,
                 )
 
-        # Remove the stopped requests from the running and waiting queues.
-        if stopped_running_reqs:
-            self.running = remove_all(self.running, stopped_running_reqs)
-        if stopped_preempted_reqs:
-            # This is a rare case and unlikely to impact performance.
-            self.waiting.remove_requests(stopped_preempted_reqs)
-            self.skipped_waiting.remove_requests(stopped_preempted_reqs)
+        self._remove_stopped_requests_from_queues(
+            stopped_running_reqs,
+            stopped_preempted_reqs,
+        )
 
-        # [Main] Handle failed KV load requests
-        if failed_kv_load_req_ids and not self.recompute_kv_load_failures:
-            requests = [self.requests[req_id] for req_id in failed_kv_load_req_ids]
-            self.finish_requests(failed_kv_load_req_ids, RequestStatus.FINISHED_ERROR)
-            for request in requests:
-                outputs[request.client_index].append(
-                    OmniEngineCoreOutput(
-                        request_id=request.request_id,
-                        new_token_ids=[],
-                        finish_reason=request.get_finished_reason(),
-                        events=request.take_events(),
-                        trace_headers=request.trace_headers,
-                    )
-                )
-                if self.chunk_transfer_adapter is not None:
-                    self.chunk_transfer_adapter.cleanup_receiver(
-                        request.request_id,
-                    )
+        failed_requests = self._handle_failed_kv_load_outputs(
+            failed_kv_load_req_ids,
+            outputs,
+        )
+        if self.chunk_transfer_adapter is not None:
+            for request in failed_requests:
+                self.chunk_transfer_adapter.cleanup_receiver(request.request_id)
 
-        # [Omni] Cleanup state for finished requests
-        for req in stopped_running_reqs:
-            if req.request_id not in self.waiting_for_transfer_free:
-                if req.request_id in self.transfer_triggered_requests:
-                    self.transfer_triggered_requests.remove(req.request_id)
-                if req.request_id in self.active_kv_transfers:
-                    self.active_kv_transfers.remove(req.request_id)
-                self.pending_stop_after_extraction.discard(req.request_id)
-
-        # Same for preempted
-        for req in stopped_preempted_reqs:
-            if req.request_id not in self.waiting_for_transfer_free:
-                if req.request_id in self.transfer_triggered_requests:
-                    self.transfer_triggered_requests.remove(req.request_id)
-                if req.request_id in self.active_kv_transfers:
-                    self.active_kv_transfers.remove(req.request_id)
-                self.pending_stop_after_extraction.discard(req.request_id)
+        self._cleanup_kv_tracking(req.request_id for req in stopped_running_reqs | stopped_preempted_reqs)
 
         # KV Connector: update state for finished KV Transfers.
         if kv_connector_output:
             self._update_from_kv_xfer_finished(kv_connector_output)
 
-        # Worker-side KV connector stats from the model runner output.
-        kv_connector_stats: KVConnectorStats | None = (
-            kv_connector_output.kv_connector_stats if kv_connector_output else None
-        )
-        if self.connector:
-            # Scheduler-side KV connector stats collected after connector update.
-            scheduler_kv_connector_stats = self.connector.get_kv_connector_stats()
-            if scheduler_kv_connector_stats is not None and not scheduler_kv_connector_stats.is_empty():
-                kv_connector_stats = (
-                    kv_connector_stats.aggregate(scheduler_kv_connector_stats)
-                    if kv_connector_stats is not None
-                    else scheduler_kv_connector_stats
-                )
-
-        # collect KV cache events from KV cache manager
-        events = self.kv_cache_manager.take_events()
-
-        # collect KV cache events from connector
-        if self.connector is not None:
-            connector_events = self.connector.take_events()
-            if connector_events:
-                if events is None:
-                    events = list(connector_events)
-                else:
-                    events.extend(connector_events)
-
-        # publish collected KV cache events
-        if events:
-            batch = KVEventBatch(ts=time(), events=events)
-            self.kv_event_publisher.publish(batch)
+        kv_connector_stats = self._aggregate_kv_connector_stats(kv_connector_output)
+        self._publish_kv_cache_events()
 
         # Create EngineCoreOutputs for all clients that have requests with
         # outputs in this step.
         engine_core_outputs = {client_index: EngineCoreOutputs(outputs=outs) for client_index, outs in outputs.items()}
 
-        # FIXME: finished_req_ids_dict is unconditionally initialized as
-        # defaultdict(set) in __init__ (not gated by include_finished_set).
-        # This branch is therefore always eligible once any client_index is
-        # populated; revisit when wiring streaming-only / upstream semantics.
-        finished_req_ids = self.finished_req_ids_dict
-        if finished_req_ids:
-            # Include ids of requests that finished since last outputs
-            # were sent.
-            for client_index, finished_set in finished_req_ids.items():
-                eco = engine_core_outputs.get(client_index)
-                if eco is None:
-                    eco = EngineCoreOutputs()
-                    engine_core_outputs[client_index] = eco
-                emitted = {o.request_id for o in eco.outputs}
-                for req_id in finished_set:
-                    if req_id not in emitted:
-                        eco.outputs.append(EngineCoreOutput(req_id, [], finish_reason=FinishReason.ABORT))
-                eco.finished_requests = finished_set
-            finished_req_ids.clear()
+        self._attach_finished_request_sets(
+            engine_core_outputs,
+            synthesize_abort_outputs=True,
+        )
 
-        if (stats := self.make_stats(spec_decoding_stats, kv_connector_stats, cudagraph_stats, perf_stats)) is not None:
-            # Return stats to only one of the front-ends.
-            if (eco := next(iter(engine_core_outputs.values()), None)) is None:
-                # We must return the stats even if there are no request
-                # outputs this step.
-                engine_core_outputs[0] = eco = EngineCoreOutputs()
-            eco.scheduler_stats = stats
+        self._attach_scheduler_stats(
+            engine_core_outputs,
+            spec_decoding_stats,
+            kv_connector_stats,
+            cudagraph_stats,
+            perf_stats,
+        )
 
         self._capture_omni_connector_output(model_runner_output)
 
@@ -643,56 +572,6 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         return engine_core_outputs
 
-    def finish_requests(self, request_ids: Any, finished_status: RequestStatus) -> list[tuple[str, int]]:
-        """Handles the finish signal from outside the scheduler.
-
-        For example, the API server can abort a request when the client
-        disconnects.
-
-        If request_ids is None, all requests will be finished.
-
-        Returns:
-            Tuple of (req_id, client_index) for requests that were aborted. Will not
-            include any that were already finished.
-        """
-
-        if self.chunk_transfer_adapter:
-            self.chunk_transfer_adapter.finish_requests(request_ids, finished_status, self.requests)
-
-        # Realign stale ``request.status`` (chunk-transfer-adapter's
-        # ``requests_origin_status`` table doesn't follow the
-        # ``waiting → running`` admit transition; without this, an abort
-        # arriving between admit and the next deque round-trip leaves
-        # the request in ``self.running`` with ``status=WAITING`` and
-        # upstream ``Scheduler.finish_requests`` silently fails to
-        # release the worker's ``input_batch`` slot -- after
-        # ``max_num_seqs`` such aborts new requests hang at
-        # ``chunks=0``). Only the ``async_chunk`` path triggers the
-        # staleness; with ``async_chunk`` disabled this is a cheap O(n)
-        # no-op over an already-aligned set, kept unconditional so the
-        # abort path stays uniform across configurations. See
-        # ``OmniSchedulerMixin._realign_request_status_to_queues`` and
-        # #3774 discussion.
-        self._realign_request_status_to_queues(request_ids)
-
-        finished = super().finish_requests(request_ids, finished_status)
-
-        # Defensive post-finish purge: belt-and-suspenders to the
-        # realignment above. Even after realign + ``super()``, corner
-        # cases (mid-transition status, connector cleanups that pop
-        # from ``self.requests`` without unwinding ``self.running``)
-        # can leave already-finished or untracked entries in
-        # ``self.running``. Sweep them now so the worker's
-        # ``input_batch`` slot never pins a freed request and starves
-        # new admissions. See ``OmniSchedulerMixin._purge_finished_from_running``.
-        self._purge_finished_from_running()
-
-        input_coordinator = getattr(self, "input_coordinator", None)
-        if input_coordinator is not None:
-            for request_id, _ in finished:
-                self._free_input_coordinator_request(request_id)
-        return finished
-
     def _update_request_as_session(self, session: Request, update: StreamingUpdate) -> None:
         """
         Override: Only extend prompt at stage 0, and replace
@@ -711,9 +590,10 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             session.num_computed_tokens -= session.num_output_placeholders
             session.num_output_placeholders = 0
             session.spec_token_ids = []
-        if self.chunk_transfer_adapter:
+        stage_id = self.vllm_config.model_config.stage_id
+        if self.chunk_transfer_adapter and self.chunk_transfer_adapter.receives_chunks:
             self.chunk_transfer_adapter.requests_num_chunks_sent.pop(session.external_req_id, None)
-            if self.vllm_config.model_config.stage_id != 0:
+            if stage_id != 0:
                 # Downstream async-chunk stages receive real payloads from the
                 # connector. This update only resumes polling for the next segment.
                 self.chunk_transfer_adapter.segment_finished_requests.discard(session.request_id)
@@ -731,9 +611,26 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                 if self.log_stats:
                     session.record_event(EngineCoreEventType.QUEUED)
                 return
+        update_infos = (
+            getattr(update, "model_intermediate_buffer", None),
+            getattr(update, "additional_information", None),
+        )
+        replace_streaming_prompt = any(
+            isinstance(info, dict)
+            and isinstance(info.get("meta"), dict)
+            and info["meta"].get("replace_streaming_prompt") is True
+            for info in update_infos
+        )
+        if replace_streaming_prompt:
+            self._replace_streaming_session(session, update)
+            return
         super()._update_request_as_session(session, update)
+        if hasattr(update, "model_intermediate_buffer"):
+            session.model_intermediate_buffer = update.model_intermediate_buffer
 
-    def _free_request(self, request: Request, delay_free_blocks: bool = False) -> dict[str, Any] | None:
+    def _free_request(
+        self, request: Request, delay_free_blocks: bool = False
+    ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
         # TODO(wzliu)! for offline mode, we should not end process until all data is transferred
         """Mark a request as finished and free its resources."""
         assert request.is_finished()
@@ -772,10 +669,10 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                         logger.debug(f"[Omni] Request {request_id} finished but transfer is still ACTIVE. Waiting.")
                         self.waiting_for_transfer_free.add(request_id)
                         kv_xfer_params = None
-                        return kv_xfer_params
+                        return kv_xfer_params, None
                     elif request_id in self.waiting_for_transfer_free:
                         # Blocks held until KV extraction completes in a future step.
-                        return None
+                        return None, None
                     else:
                         logger.debug(
                             f"[Omni] Request {request_id} finished and transfer no longer ACTIVE (extracted/acked). "
@@ -812,21 +709,20 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
                         if isinstance(add_info, dict):
                             add_info.update(kv_xfer_params)
 
-                    return kv_xfer_params
+                    return kv_xfer_params, None
 
             # 3. Standard Freeing
             delay_free_blocks |= connector_delay_free_blocks
             if not delay_free_blocks:
                 self._free_blocks(request)
 
-            return kv_xfer_params
+            return kv_xfer_params, None
         finally:
             self._free_input_coordinator_request(request_id)
-
-    def _free_blocks(self, request: Request):
-        # Helper to match base class structure if not directly available
-        # VLLMScheduler has _free_blocks
-        super()._free_blocks(request)
+            # Normal completion runs through here, not finish_requests()
+            # (the abort path) -- see vllm-project/vllm-omni#5349.
+            if self.chunk_transfer_adapter is not None:
+                self.chunk_transfer_adapter.cleanup_receiver(request_id)
 
     def _mark_request_for_kv_transfer(self, req_id: str, seq_len: int) -> None:
         """Mark a request as needing KV cache transfer when it finishes."""
@@ -873,44 +769,35 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
 
     def _should_transfer_kv_for_request(self, req_id: str) -> bool:
         """Determine if a request should trigger KV cache transfer."""
-        need_send = False
-        # Try to read from vLLM Config (where YAML config is typically loaded)
-        # Check for omni_kv_config attribute
-        omni_kv_config = getattr(self.vllm_config.model_config, "omni_kv_config", None)
-        if omni_kv_config:
-            # omni_kv_config could be an object or a dict
-            if isinstance(omni_kv_config, dict):
-                need_send = omni_kv_config.get("need_send_cache", False)
-            else:
-                need_send = getattr(omni_kv_config, "need_send_cache", False)
-        if not need_send:
+        if not self._get_omni_kv_config_value("need_send_cache", False):
             return False
         request = self.requests.get(req_id)
         if request is not None and self._request_omits_kv_transfer_to_next_stage(request):
             return False
         return True
 
+    def _cleanup_kv_tracking(self, request_ids: Iterable[str]) -> None:
+        for req_id in request_ids:
+            if req_id in self.waiting_for_transfer_free:
+                continue
+            self.transfer_triggered_requests.discard(req_id)
+            self.active_kv_transfers.discard(req_id)
+            self.pending_stop_after_extraction.discard(req_id)
+
+    def _has_pending_kv_work(self) -> bool:
+        return bool(self.requests_needing_kv_transfer or self.active_kv_transfers or self.waiting_for_transfer_free)
+
     def has_requests(self) -> bool:
         """Check if there are any requests to process, including KV transfers."""
-        # [Omni] Also check for pending KV transfers
-        if self.requests_needing_kv_transfer or self.active_kv_transfers or self.waiting_for_transfer_free:
-            return True
-        return super().has_requests()
+        return self._has_pending_kv_work() or super().has_requests()
 
     def has_finished_requests(self) -> bool:
         """Check if there are any finished requests (including those needing KV transfer)."""
-        if self.requests_needing_kv_transfer or self.active_kv_transfers or self.waiting_for_transfer_free:
-            return True
-        return super().has_finished_requests()
+        return self._has_pending_kv_work() or super().has_finished_requests()
 
     def has_unfinished_requests(self) -> bool:
         """Check if there are any unfinished requests (including those needing KV transfer)."""
-        # [Omni] Also check for pending KV transfers to ensure the engine loop continues
-        # MUST verify waiting_for_transfer_free and active_kv_transfers
-        # Otherwise engine loop might exit before transfer Ack is received.
-        if self.requests_needing_kv_transfer or self.active_kv_transfers or self.waiting_for_transfer_free:
-            return True
-        return super().has_unfinished_requests()
+        return self._has_pending_kv_work() or super().has_unfinished_requests()
 
     def get_finished_requests_needing_kv_transfer(self) -> dict[str, dict]:
         """Get and clear the list of requests needing KV cache transfer.
diff --git a/vllm_omni/core/sched/omni_generation_scheduler.py b/vllm_omni/core/sched/omni_generation_scheduler.py
index 973b8c55a..e1632764c 100644
--- a/vllm_omni/core/sched/omni_generation_scheduler.py
+++ b/vllm_omni/core/sched/omni_generation_scheduler.py
@@ -5,9 +5,6 @@ from collections import defaultdict
 from typing import Any
 
 from vllm.compilation.cuda_graph import CUDAGraphStat
-from vllm.distributed.kv_events import KVEventBatch
-from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorStats
-from vllm.logger import init_logger
 from vllm.v1.core.kv_cache_manager import KVCacheBlocks
 from vllm.v1.core.sched.interface import PauseState
 from vllm.v1.core.sched.output import SchedulerOutput
@@ -24,40 +21,54 @@ from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm.v1.spec_decode.metrics import SpecDecodingStats
 
 from vllm_omni.core.sched.omni_scheduler_mixin import OmniSchedulerMixin
-from vllm_omni.core.sched.omni_scheduling_coordinator import (
-    OmniSchedulingCoordinator,
-    uses_full_payload_input_coordinator,
-)
 from vllm_omni.core.sched.output import OmniCachedRequestData, OmniNewRequestData
 from vllm_omni.core.sched.utils import omni_routed_experts_for_request
-from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter import (
-    OmniChunkTransferAdapter,
-)
-from vllm_omni.engine import OmniEngineCoreOutput
-from vllm_omni.outputs import OmniConnectorOutput, OmniModelRunnerOutput
-
-logger = init_logger(__name__)
+from vllm_omni.outputs import OmniModelRunnerOutput
 
 
 class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         model_config = self.vllm_config.model_config
-        self.chunk_transfer_adapter = None
-        if getattr(model_config, "async_chunk", False):
-            self.chunk_transfer_adapter = OmniChunkTransferAdapter(self.vllm_config)
+        self._init_omni_io_scheduling_state()
+        self._retains_state_across_chunks = bool(getattr(model_config, "retains_state_across_chunks", False))
         self._pending_finish_reqs: list[Request] = []
-        self.input_coordinator: OmniSchedulingCoordinator | None = None
-        if uses_full_payload_input_coordinator(model_config):
-            self.input_coordinator = OmniSchedulingCoordinator(
-                scheduler_max_num_seqs=self.vllm_config.scheduler_config.max_num_seqs,
-                stage_id=getattr(model_config, "stage_id", 0),
-                async_chunk=False,
-            )
-        self._latest_omni_connector_output: OmniConnectorOutput | None = None
+
+    @staticmethod
+    def _record_prefill_stats(request: Request) -> None:
+        """Mirror upstream first-prefill prompt accounting for generation stages.
+
+        Async-chunk generation stages can grow ``prompt_token_ids`` after the
+        first schedule; until this path tracks final chunk lengths, this records
+        the first scheduled prompt snapshot. Keep this in sync with vLLM
+        Scheduler.schedule() if this fast path gains prefix-cache or external-KV
+        accounting.
+        """
+        if request.prefill_stats is None:
+            return
+        request.prefill_stats.set(
+            num_prompt_tokens=request.num_prompt_tokens,
+            num_local_cached_tokens=0,
+            num_external_cached_tokens=0,
+        )
+
+    def _handle_stopped_request(self, request: Request) -> bool:
+        if (
+            request.resumable
+            and not request.streaming_queue
+            and self.chunk_transfer_adapter is not None
+            and self.chunk_transfer_adapter.receives_chunks
+        ):
+            # Downstream async-chunk stages receive the next segment from the
+            # connector, not from an API StreamingUpdate. Enqueue them as
+            # schedulable before the base class can park them in skipped_waiting.
+            request.status = RequestStatus.WAITING
+            self._enqueue_waiting_request(request)
+            return False
+        return super()._handle_stopped_request(request)
 
     def schedule(self, throttle_prefills: bool = False) -> SchedulerOutput:
-        """Diffusion fast path:
+        """One-shot generation fast path:
         - Feed all input tokens of the request at once
           (if 0, allocate 1 placeholder token).
         - If the token budget cannot be satisfied at once, fall back to the
@@ -81,15 +92,10 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         cached_prompt_token_ids: dict[str, list[int]] = {}
         cached_additional_information: dict[str, dict | None] = {}
 
-        # Temporary queue: preserve waiting order, do not disturb non-diffusion requests
+        # Temporary queue: preserve waiting order while requests await input.
         skipped_waiting_requests = create_request_queue(self.policy)
         req_index = 0
-        self._consume_pending_connector_output(model_mode="generation")
-        self._process_pending_input_timeouts()
-        if self.chunk_transfer_adapter:
-            self.chunk_transfer_adapter.process_pending_chunks(
-                self.waiting, self.running, scheduler_requests=self.requests
-            )
+        self._process_pending_omni_inputs(model_mode="generation")
 
         # OMNI: Track requests that are already finished (e.g., marked by connector)
         # These should be removed from running and not scheduled
@@ -132,6 +138,8 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 break
             if self.log_stats:
                 request.record_event(EngineCoreEventType.SCHEDULED, scheduled_timestamp)
+            if num_computed_tokens == 0:
+                self._record_prefill_stats(request)
             req_to_new_blocks[request.request_id] = new_blocks
             num_scheduled_tokens[request.request_id] = num_new_tokens
             cached_prompt_token_ids[request.request_id] = request.prompt_token_ids
@@ -144,14 +152,19 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         if already_finished_reqs:
             self.running = remove_all(self.running, already_finished_reqs)
 
-        # Fast path selection and scheduling (treat all as diffusion requests,
-        # independent of pooling_params)
-        while (
-            self.waiting
-            and token_budget > 0
-            and len(self.running) < self.max_num_running_reqs
-            and self._pause_state == PauseState.UNPAUSED
-        ):
+        # Fast path selection and scheduling for one-shot generation requests,
+        # independent of pooling_params.
+        while self.waiting and token_budget > 0 and self._pause_state == PauseState.UNPAUSED:
+            # Requests waiting for their next chunk are temporarily absent
+            # from `running`, but stateful models still retain their model
+            # runner slot. Mirror vLLM's treatment of
+            # `num_waiting_for_streaming_input` when enforcing max_num_seqs.
+            num_running = len(self.running)
+            if self._retains_state_across_chunks and self.chunk_transfer_adapter is not None:
+                num_running += self.chunk_transfer_adapter.num_running_waiting_for_chunk
+            if num_running >= self.max_num_running_reqs:
+                break
+
             request = self.waiting.peek_request()
             # OMNI: Skip requests that are not in self.requests
             if request.request_id not in self.requests or (
@@ -172,9 +185,6 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                     skipped_waiting_requests.prepend_request(request)
                     continue
 
-            # Uniformly treat as diffusion. A feature flag can be added later
-            # via config or request tag.
-
             # Allocate all input tokens for the request in one shot
             # (allocate 1 placeholder if zero)
             required_tokens = max(len(request.prompt_token_ids), 1)
@@ -196,6 +206,8 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             self.running.append(request)
             if self.log_stats:
                 request.record_event(EngineCoreEventType.SCHEDULED, scheduled_timestamp)
+            if request.num_computed_tokens == 0:
+                self._record_prefill_stats(request)
 
             req_to_new_blocks[request.request_id] = new_blocks
             num_scheduled_tokens[request.request_id] = num_new_tokens
@@ -211,15 +223,11 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             if self.chunk_transfer_adapter:
                 # Don't fall back: base scheduler doesn't handle async_chunk
                 # requests with empty prompt_token_ids.
-                self.chunk_transfer_adapter.restore_queues(
-                    self.waiting,
-                    self.running,
-                    scheduler_requests=self.requests,
-                )
+                self._restore_omni_wait_queues()
             else:
                 res = super().schedule(throttle_prefills)
-                if self.input_coordinator:
-                    self.input_coordinator.restore_queues(self.waiting, self.running)
+                self._restore_omni_wait_queues()
+                self._postprocess_omni_schedule_output(res)
                 return self._wrap_omni_scheduler_output(res)
 
         # Compute common prefix blocks (aligned with v1)
@@ -303,92 +311,15 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         self._update_after_schedule(scheduler_output)
 
         try:
-            # Rewrap base NewRequestData entries with OmniNewRequestData,
-            # enriching with request-level payloads
-            new_list = []
-            for nr in scheduler_output.scheduled_new_reqs:
-                req_id = getattr(nr, "req_id", None)
-                request = self.requests.get(req_id) if req_id else None
-                # Build omni entry preserving all base fields
-                omni_nr = OmniNewRequestData(
-                    req_id=nr.req_id,
-                    external_req_id=(getattr(request, "external_req_id", None) if request else None),
-                    prompt_token_ids=nr.prompt_token_ids,
-                    mm_features=nr.mm_features,
-                    sampling_params=nr.sampling_params,
-                    pooling_params=nr.pooling_params,
-                    block_ids=nr.block_ids,
-                    num_computed_tokens=nr.num_computed_tokens,
-                    lora_request=nr.lora_request,
-                    # Enrich with omni payloads from the live request object
-                    prompt_embeds=(getattr(request, "prompt_embeds", None) if request else None),
-                    prompt_is_token_ids=nr.prompt_is_token_ids,
-                    additional_information=(getattr(request, "additional_information", None) if request else None),
-                )
-                new_list.append(omni_nr)
-
-            scheduler_output.scheduled_new_reqs = new_list  # type: ignore[assignment]
-
-            if self.chunk_transfer_adapter:
-                self.chunk_transfer_adapter.postprocess_scheduler_output(scheduler_output)
-
-        except Exception:
-            # If anything goes wrong, leave the original output unchanged
-            logger.exception("Failed to wrap scheduled_new_reqs with OmniNewRequestData")
+            self._postprocess_omni_schedule_output(scheduler_output)
         finally:
-            # Ensure chunk-waiting requests are restored even on error,
-            # otherwise they are permanently orphaned in the adapter's
-            # internal deques and never scheduled again.
-            if self.chunk_transfer_adapter:
-                self.chunk_transfer_adapter.restore_queues(
-                    self.waiting,
-                    self.running,
-                    scheduler_requests=self.requests,
-                )
-            if self.input_coordinator:
-                self.input_coordinator.restore_queues(self.waiting, self.running)
+            self._restore_omni_wait_queues()
 
         return self._wrap_omni_scheduler_output(scheduler_output)
 
-    def finish_requests(self, request_ids, finished_status: RequestStatus) -> list[tuple[str, int]]:
-        """Handles the finish signal from outside the scheduler.
-
-        For example, the API server can abort a request when the client
-        disconnects.
-
-        If request_ids is None, all requests will be finished.
-
-        Returns:
-            Tuple of (req_id, client_index) for requests that were aborted. Will not
-            include any that were already finished.
-        """
-
-        if self.chunk_transfer_adapter:
-            self.chunk_transfer_adapter.finish_requests(request_ids, finished_status, self.requests)
-
-        # See ``OmniSchedulerMixin._realign_request_status_to_queues`` --
-        # closes the residual hang on the
-        # ``waiting → running → abort-before-next-deque-round-trip`` race
-        # surfaced by #3774's reproduction matrix. Only the
-        # ``async_chunk`` path actually triggers the staleness; with
-        # ``async_chunk`` disabled this is a cheap O(n) no-op, kept
-        # unconditional so the abort path stays uniform.
-        self._realign_request_status_to_queues(request_ids)
-
-        finished = super().finish_requests(request_ids, finished_status)
-
-        # See ``OmniSchedulerMixin._purge_finished_from_running`` --
-        # defensive belt-and-suspenders sweep paired with the realign
-        # above. Closes residual ``self.running`` slot leaks if any
-        # corner case slips past upstream's status-driven removal.
-        self._purge_finished_from_running()
-
-        if self.input_coordinator is not None:
-            for request_id, _ in finished:
-                self._free_input_coordinator_request(request_id)
-        return finished
-
-    def _free_request(self, request: Request, delay_free_blocks: bool = False) -> dict[str, Any] | None:
+    def _free_request(
+        self, request: Request, delay_free_blocks: bool = False
+    ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
         if self.input_coordinator is None:
             return super()._free_request(request, delay_free_blocks)
 
@@ -397,24 +328,12 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         finally:
             self._free_input_coordinator_request(request.request_id)
 
-    """
-    Scheduler for the diffusion model.
-    This scheduler is modified to stop the request immediately for the diffusion model.
-    This is because the diffusion model can generate the final image/audio in one step.
-    Note: This is just a minimal modification to the original scheduler,
-    and there should be some further efforts to optimize the scheduler.
-    The original scheduler is still used for the AR model.
-    """
-
     def update_from_output(
         self,
         scheduler_output: SchedulerOutput,
         model_runner_output: OmniModelRunnerOutput,
     ) -> dict[int, EngineCoreOutputs]:
-        """Update the scheduler state based on the model runner output.
-
-        This method is modified to stop the request immediately for the diffusion model.
-        """
+        """Update scheduler state and finish completed one-shot work."""
         sampled_token_ids = model_runner_output.sampled_token_ids
         logprobs = model_runner_output.logprobs
         prompt_logprobs_dict = model_runner_output.prompt_logprobs_dict
@@ -446,10 +365,18 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         stopped_preempted_reqs: set[Request] = set()
         for req_id, num_tokens_scheduled in num_scheduled_tokens.items():
             assert num_tokens_scheduled > 0
+            request = self.requests.get(req_id)
+            if request is not None:
+                # vLLM 0.26: settle the in-flight tokens counted in schedule().
+                # Must happen before the skips below — failed-KV-load and
+                # already-finished requests were incremented too, and the two
+                # readers (allocate_slots, _connector_finished) clamp with
+                # max(0, computed - in_flight), so a leaked counter silently
+                # freezes sliding-window block freeing.
+                request.num_in_flight_tokens -= num_tokens_scheduled
             if failed_kv_load_req_ids and req_id in failed_kv_load_req_ids:
                 # Skip requests that were recovered from KV load failure
                 continue
-            request = self.requests.get(req_id)
             if request is None or request.is_finished():
                 # Request may already be finished (e.g., aborted during
                 # execution / pipeline parallelism / async scheduling).
@@ -494,9 +421,11 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             mm_output = mm_outputs[req_index] if mm_outputs else None
             status_before_stop = request.status
             finish_reason = None
+            is_segment_finished = False
             routed_experts = None
 
-            # Diffusion request: completes in one step; mark finished and free resources
+            # One-shot generation request: finish after its current input unit
+            # has been fully processed.
             if (
                 request.status == RequestStatus.FINISHED_STOPPED
                 or (self.chunk_transfer_adapter is None and request.num_computed_tokens >= request.num_prompt_tokens)
@@ -509,7 +438,6 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                 request.status = RequestStatus.FINISHED_STOPPED
                 # Optional: set a stop_reason for front-end clarity
                 # (does not affect protocol)
-                request.stop_reason = request.stop_reason  # or "generation_done"
                 stopped = True
 
             if stopped:
@@ -517,12 +445,13 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
                     routed_experts = omni_routed_experts_for_request(model_runner_output.routed_experts, request)
                 finish_reason = request.get_finished_reason()
                 finished = self._handle_stopped_request(request)
+                is_segment_finished = not finished
                 if not finished:
                     # for streaming input request only
                     if self.chunk_transfer_adapter:
                         self.chunk_transfer_adapter.segment_finished_requests.discard(req_id)
                 if finished:
-                    kv_transfer_params = self._free_request(request)
+                    kv_transfer_params, _ = self._free_request(request)
                     if self.chunk_transfer_adapter is not None:
                         self.chunk_transfer_adapter.cleanup(
                             request.request_id,
@@ -553,24 +482,22 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
             # Get prompt logprobs for this request.
             prompt_logprobs_tensors = prompt_logprobs_dict.get(req_id)
             if new_token_ids or mm_output is not None or pooler_output is not None or kv_transfer_params or stopped:
-                # Add EngineCoreOutput for this Request.
-                outputs[request.client_index].append(
-                    OmniEngineCoreOutput(
-                        request_id=req_id,
-                        new_token_ids=new_token_ids,
-                        finish_reason=finish_reason,
-                        new_logprobs=new_logprobs,
-                        new_prompt_logprobs_tensors=prompt_logprobs_tensors,
-                        pooling_output=pooler_output,
-                        multimodal_output=mm_output,
-                        stop_reason=request.stop_reason,
-                        events=request.take_events(),
-                        prefill_stats=request.take_prefill_stats(),
-                        kv_transfer_params=kv_transfer_params,
-                        trace_headers=request.trace_headers,
-                        routed_experts=routed_experts,
-                        num_nans_in_logits=request.num_nans_in_logits,
-                    )
+                OmniSchedulerMixin._append_request_output(
+                    self,
+                    outputs,
+                    request,
+                    new_token_ids=new_token_ids,
+                    finish_reason=finish_reason,
+                    new_logprobs=new_logprobs,
+                    new_prompt_logprobs_tensors=prompt_logprobs_tensors,
+                    pooling_output=pooler_output,
+                    multimodal_output=mm_output,
+                    stop_reason=request.stop_reason,
+                    prefill_stats=request.take_prefill_stats(),
+                    kv_transfer_params=kv_transfer_params,
+                    routed_experts=routed_experts,
+                    num_nans_in_logits=request.num_nans_in_logits,
+                    is_segment_finished=is_segment_finished,
                 )
             else:
                 # Invariant: EngineCore returns no partial prefill outputs.
@@ -579,115 +506,72 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
         # Finish async_chunk requests that schedule() collected because their
         # upstream completed with no remaining codec tokens.
         for request in self._pending_finish_reqs:
-            if request.is_finished():
+            if request in stopped_running_reqs or request.is_finished():
                 continue
             request.status = RequestStatus.FINISHED_STOPPED
             finish_reason = request.get_finished_reason()
             finished = self._handle_stopped_request(request)
+            is_segment_finished = not finished
             kv_transfer_params = None
             if finished:
-                kv_transfer_params = self._free_request(request)
+                kv_transfer_params, _ = self._free_request(request)
                 if self.chunk_transfer_adapter is not None:
                     self.chunk_transfer_adapter.cleanup(
                         request.request_id,
                         getattr(request, "external_req_id", None),
                     )
-            outputs[request.client_index].append(
-                OmniEngineCoreOutput(
-                    request_id=request.request_id,
-                    new_token_ids=[],
-                    finish_reason=finish_reason,
-                    stop_reason=request.stop_reason,
-                    events=request.take_events(),
-                    kv_transfer_params=kv_transfer_params,
-                    trace_headers=request.trace_headers,
-                )
+            OmniSchedulerMixin._append_request_output(
+                self,
+                outputs,
+                request,
+                new_token_ids=[],
+                finish_reason=finish_reason,
+                stop_reason=request.stop_reason,
+                kv_transfer_params=kv_transfer_params,
+                is_segment_finished=is_segment_finished,
             )
             stopped_running_reqs.add(request)
         self._pending_finish_reqs.clear()
 
-        # Remove the stopped requests from the running and waiting queues.
-        if stopped_running_reqs:
-            self.running = remove_all(self.running, stopped_running_reqs)
-        if stopped_preempted_reqs:
-            # This is a rare case and unlikely to impact performance.
-            self.waiting.remove_requests(stopped_preempted_reqs)
-            self.skipped_waiting.remove_requests(stopped_preempted_reqs)
+        self._remove_stopped_requests_from_queues(
+            stopped_running_reqs,
+            stopped_preempted_reqs,
+        )
 
-        # Handle failed KV load requests
-        if failed_kv_load_req_ids and not self.recompute_kv_load_failures:
-            requests = [self.requests[req_id] for req_id in failed_kv_load_req_ids]
-            self.finish_requests(failed_kv_load_req_ids, RequestStatus.FINISHED_ERROR)
-            for request in requests:
-                outputs[request.client_index].append(
-                    OmniEngineCoreOutput(
-                        request_id=request.request_id,
-                        new_token_ids=[],
-                        finish_reason=request.get_finished_reason(),
-                        events=request.take_events(),
-                        trace_headers=request.trace_headers,
-                    )
+        failed_requests = self._handle_failed_kv_load_outputs(
+            failed_kv_load_req_ids,
+            outputs,
+        )
+        if self.chunk_transfer_adapter is not None:
+            for request in failed_requests:
+                self.chunk_transfer_adapter.cleanup(
+                    request.request_id,
+                    getattr(request, "external_req_id", None),
                 )
-                if self.chunk_transfer_adapter is not None:
-                    self.chunk_transfer_adapter.cleanup(
-                        request.request_id,
-                        getattr(request, "external_req_id", None),
-                    )
 
         # KV Connector: update state for finished KV Transfers.
         if kv_connector_output:
             self._update_from_kv_xfer_finished(kv_connector_output)
 
-        # Worker-side KV connector stats from the model runner output.
-        kv_connector_stats: KVConnectorStats | None = (
-            kv_connector_output.kv_connector_stats if kv_connector_output else None
-        )
-        if self.connector:
-            # Scheduler-side KV connector stats collected after connector update.
-            scheduler_kv_connector_stats = self.connector.get_kv_connector_stats()
-            if scheduler_kv_connector_stats is not None and not scheduler_kv_connector_stats.is_empty():
-                kv_connector_stats = (
-                    kv_connector_stats.aggregate(scheduler_kv_connector_stats)
-                    if kv_connector_stats is not None
-                    else scheduler_kv_connector_stats
-                )
-
-        # Collect and publish KV cache events (align with v0.14.0)
-        events = self.kv_cache_manager.take_events()
-        if self.connector is not None:
-            connector_events = self.connector.take_events()
-            if connector_events:
-                if events is None:
-                    events = list(connector_events)
-                else:
-                    events.extend(connector_events)
-        if events:
-            batch = KVEventBatch(ts=time.time(), events=events)
-            self.kv_event_publisher.publish(batch)
+        kv_connector_stats = self._aggregate_kv_connector_stats(kv_connector_output)
+        self._publish_kv_cache_events()
 
         # Create EngineCoreOutputs for all clients that have requests with
         # outputs in this step.
         engine_core_outputs = {client_index: EngineCoreOutputs(outputs=outs) for client_index, outs in outputs.items()}
 
-        finished_req_ids = self.finished_req_ids_dict
-        if finished_req_ids:
-            # Include ids of requests that finished since last outputs
-            # were sent.
-            for client_index, finished_set in finished_req_ids.items():
-                # Set finished request set in EngineCoreOutputs for this client.
-                if (eco := engine_core_outputs.get(client_index)) is not None:
-                    eco.finished_requests = finished_set
-                else:
-                    engine_core_outputs[client_index] = EngineCoreOutputs(finished_requests=finished_set)
-            finished_req_ids.clear()
+        self._attach_finished_request_sets(
+            engine_core_outputs,
+            synthesize_abort_outputs=False,
+        )
 
-        if (stats := self.make_stats(spec_decoding_stats, kv_connector_stats, cudagraph_stats, perf_stats)) is not None:
-            # Return stats to only one of the front-ends.
-            if (eco := next(iter(engine_core_outputs.values()), None)) is None:
-                # We must return the stats even if there are no request
-                # outputs this step.
-                engine_core_outputs[0] = eco = EngineCoreOutputs()
-            eco.scheduler_stats = stats
+        self._attach_scheduler_stats(
+            engine_core_outputs,
+            spec_decoding_stats,
+            kv_connector_stats,
+            cudagraph_stats,
+            perf_stats,
+        )
 
         self._capture_omni_connector_output(model_runner_output)
 
@@ -699,26 +583,4 @@ class OmniGenerationScheduler(OmniSchedulerMixin, VLLMScheduler):
 
         Do not expend prompt id using update.
         """
-        if self.chunk_transfer_adapter:
-            self.chunk_transfer_adapter.segment_finished_requests.discard(session.request_id)
-        session._output_token_ids.clear()
-        session._all_token_ids.clear()
-        new_prompt = update.prompt_token_ids or ()
-        session._all_token_ids.extend(new_prompt)
-        session.num_computed_tokens = 0
-        session.prompt_token_ids = update.prompt_token_ids or ()
-        session.additional_information = update.additional_information or None
-        # Update block hashes for the new tokens.
-        session.update_block_hashes()
-        session.num_prompt_tokens = len(session.prompt_token_ids)
-        session.arrival_time = update.arrival_time
-        session.sampling_params = update.sampling_params
-        if session.status == RequestStatus.WAITING_FOR_STREAMING_REQ:
-            self.num_waiting_for_streaming_input -= 1
-        session.status = RequestStatus.WAITING
-        if session in self.skipped_waiting:
-            self.skipped_waiting.remove_requests((session,))
-            self._enqueue_waiting_request(session)
-
-        if self.log_stats:
-            session.record_event(EngineCoreEventType.QUEUED)
+        self._replace_streaming_session(session, update)
diff --git a/vllm_omni/core/sched/omni_scheduler_mixin.py b/vllm_omni/core/sched/omni_scheduler_mixin.py
index be73db9c3..7b0b37e7e 100644
--- a/vllm_omni/core/sched/omni_scheduler_mixin.py
+++ b/vllm_omni/core/sched/omni_scheduler_mixin.py
@@ -5,12 +5,36 @@ import time
 from collections.abc import Iterable
 from typing import Any
 
+from vllm.compilation.cuda_graph import CUDAGraphStat
+from vllm.distributed.kv_events import KVEventBatch
+from vllm.distributed.kv_transfer.kv_connector.v1.metrics import KVConnectorStats
 from vllm.logger import init_logger
 from vllm.v1.core.sched.output import SchedulerOutput
+from vllm.v1.core.sched.utils import remove_all
+from vllm.v1.engine import (
+    EngineCoreEventType,
+    EngineCoreOutput,
+    EngineCoreOutputs,
+    FinishReason,
+)
+from vllm.v1.metrics.perf import PerfStats
 from vllm.v1.metrics.stats import SchedulerStats
-from vllm.v1.request import RequestStatus
+from vllm.v1.request import Request, RequestStatus, StreamingUpdate
+from vllm.v1.spec_decode.metrics import SpecDecodingStats
 
-from vllm_omni.core.sched.output import OmniChunkRecvHandle, OmniSchedulerOutput
+from vllm_omni.core.sched.omni_scheduling_coordinator import (
+    OmniSchedulingCoordinator,
+    uses_full_payload_input_coordinator,
+)
+from vllm_omni.core.sched.output import (
+    OmniChunkRecvHandle,
+    OmniNewRequestData,
+    OmniSchedulerOutput,
+)
+from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter import (
+    OmniChunkTransferAdapter,
+)
+from vllm_omni.engine import OmniEngineCoreOutput
 
 logger = init_logger(__name__)
 
@@ -40,15 +64,58 @@ except ValueError:
 class OmniSchedulerMixin:
     """Shared scheduler helpers for omni-specific request handling."""
 
+    # ------------------------------------------------------------------ #
+    #  Shared scheduler/output helpers (lift the AR / generation duplicates)
+    # ------------------------------------------------------------------ #
+
+    def _init_omni_io_scheduling_state(self) -> None:
+        """Initialize scheduler state shared by AR and generation stages."""
+        model_config = self.vllm_config.model_config
+        self.chunk_transfer_adapter = (
+            OmniChunkTransferAdapter(self.vllm_config) if getattr(model_config, "async_chunk", False) else None
+        )
+        self.input_coordinator = (
+            OmniSchedulingCoordinator(stage_id=getattr(model_config, "stage_id", 0))
+            if uses_full_payload_input_coordinator(model_config)
+            else None
+        )
+        self._latest_omni_connector_output = None
+
     def _free_input_coordinator_request(self, request_id: str) -> None:
         """Prune full-payload coordinator state for a completed request."""
         input_coordinator = getattr(self, "input_coordinator", None)
         if input_coordinator is not None:
             input_coordinator.free_finished_request(request_id)
 
-    # ------------------------------------------------------------------ #
-    #  Shared scheduler/output helpers (lift the AR / generation duplicates)
-    # ------------------------------------------------------------------ #
+    def _replace_streaming_session(self, session: Request, update: StreamingUpdate) -> None:
+        """Replace a downstream stage's placeholder with its next payload."""
+        adapter = getattr(self, "chunk_transfer_adapter", None)
+        if adapter is not None:
+            adapter.segment_finished_requests.discard(session.request_id)
+        session._output_token_ids.clear()
+        session._all_token_ids.clear()
+        new_prompt = update.prompt_token_ids or ()
+        session._all_token_ids.extend(new_prompt)
+        session.num_computed_tokens = 0
+        session.prompt_token_ids = new_prompt
+        session.additional_information = update.additional_information or None
+        session.model_intermediate_buffer = getattr(
+            update,
+            "model_intermediate_buffer",
+            None,
+        )
+        session.update_block_hashes()
+        session.num_prompt_tokens = len(new_prompt)
+        session.arrival_time = update.arrival_time
+        session.sampling_params = update.sampling_params
+        if session.status == RequestStatus.WAITING_FOR_STREAMING_REQ:
+            self.num_waiting_for_streaming_input -= 1
+        session.status = RequestStatus.WAITING
+        if session in self.skipped_waiting:
+            self.skipped_waiting.remove_requests((session,))
+            self._enqueue_waiting_request(session)
+        if self.log_stats:
+            session.record_event(EngineCoreEventType.QUEUED)
 
     def _consume_pending_connector_output(self, model_mode: str) -> None:
         """Drain ``self._latest_omni_connector_output`` into the coordinator.
@@ -68,10 +135,31 @@ class OmniSchedulerMixin:
             )
         input_coordinator.process_pending_full_payload_inputs(
             self.waiting,
-            self.running,
             connector_output.stage_recv_req_ids if connector_output else set(),
         )
 
+    def _process_pending_omni_inputs(self, model_mode: str) -> None:
+        """Apply pending connector inputs, timeouts, and async chunks."""
+        self._consume_pending_connector_output(model_mode)
+        self._process_pending_input_timeouts()
+        if self.chunk_transfer_adapter:
+            self.chunk_transfer_adapter.process_pending_chunks(
+                self.waiting,
+                self.running,
+                scheduler_requests=self.requests,
+            )
+
+    def _restore_omni_wait_queues(self) -> None:
+        """Restore requests temporarily parked by Omni input gates."""
+        if self.chunk_transfer_adapter:
+            self.chunk_transfer_adapter.restore_queues(
+                self.waiting,
+                self.running,
+                scheduler_requests=self.requests,
+            )
+        if self.input_coordinator:
+            self.input_coordinator.restore_queues(self.waiting)
+
     def _process_pending_input_timeouts(self) -> None:
         """Force-fail requests waiting on the full-payload coordinator too long.
 
@@ -151,6 +239,201 @@ class OmniSchedulerMixin:
             pending_input_registrations=pending_input_registrations,
         )
 
+    def _rewrap_scheduled_new_reqs(self, scheduler_output: SchedulerOutput) -> None:
+        """Attach Omni payloads without reconstructing existing Omni entries."""
+        scheduler_output.scheduled_new_reqs = [  # type: ignore[assignment]
+            data
+            if isinstance(data, OmniNewRequestData)
+            else OmniNewRequestData.from_base(data, self.requests.get(data.req_id))
+            for data in scheduler_output.scheduled_new_reqs
+        ]
+
+    def _postprocess_omni_schedule_output(
+        self,
+        scheduler_output: SchedulerOutput,
+        *,
+        include_cached_payloads: bool = False,
+    ) -> None:
+        """Enrich new requests and apply async-chunk output bookkeeping."""
+        self._rewrap_scheduled_new_reqs(scheduler_output)
+        if not self.chunk_transfer_adapter:
+            return
+        if include_cached_payloads:
+            self.chunk_transfer_adapter.postprocess_scheduler_output(
+                scheduler_output,
+                self.requests,
+            )
+        else:
+            self.chunk_transfer_adapter.postprocess_scheduler_output(scheduler_output)
+
+    def _make_omni_engine_output(
+        self,
+        request: Request,
+        *,
+        new_token_ids: list[int],
+        finish_reason: Any = None,
+        new_logprobs: Any = None,
+        new_prompt_logprobs_tensors: Any = None,
+        pooling_output: Any = None,
+        multimodal_output: Any = None,
+        stop_reason: Any = None,
+        prefill_stats: Any = None,
+        kv_transfer_params: Any = None,
+        routed_experts: Any = None,
+        num_nans_in_logits: int = 0,
+        is_segment_finished: bool | None = False,
+        new_prompt_len_snapshot: int | None = None,
+    ) -> OmniEngineCoreOutput:
+        """Build the common request-output envelope used by LLM schedulers."""
+        return OmniEngineCoreOutput(
+            request_id=request.request_id,
+            new_token_ids=new_token_ids,
+            finish_reason=finish_reason,
+            new_logprobs=new_logprobs,
+            new_prompt_logprobs_tensors=new_prompt_logprobs_tensors,
+            pooling_output=pooling_output,
+            multimodal_output=multimodal_output,
+            stop_reason=stop_reason,
+            events=request.take_events(),
+            prefill_stats=prefill_stats,
+            kv_transfer_params=kv_transfer_params,
+            trace_headers=request.trace_headers,
+            routed_experts=routed_experts,
+            num_nans_in_logits=num_nans_in_logits,
+            is_segment_finished=is_segment_finished,
+            new_prompt_len_snapshot=new_prompt_len_snapshot,
+        )
+
+    def _append_request_output(
+        self,
+        outputs: dict[int, list[EngineCoreOutput]],
+        request: Request,
+        **output_fields: Any,
+    ) -> None:
+        outputs[request.client_index].append(
+            OmniSchedulerMixin._make_omni_engine_output(
+                self,
+                request,
+                **output_fields,
+            )
+        )
+
+    def _handle_failed_kv_load_outputs(
+        self,
+        failed_request_ids: set[str] | None,
+        outputs: dict[int, list[EngineCoreOutput]],
+    ) -> list[Request]:
+        """Finish unrecoverable KV loads and emit their terminal outputs."""
+        if not failed_request_ids or self.recompute_kv_load_failures:
+            return []
+        requests = [self.requests[req_id] for req_id in failed_request_ids]
+        self.finish_requests(failed_request_ids, RequestStatus.FINISHED_ERROR)
+        for request in requests:
+            OmniSchedulerMixin._append_request_output(
+                self,
+                outputs,
+                request,
+                new_token_ids=[],
+                finish_reason=request.get_finished_reason(),
+            )
+        return requests
+
+    def _attach_finished_request_sets(
+        self,
+        engine_core_outputs: dict[int, EngineCoreOutputs],
+        *,
+        synthesize_abort_outputs: bool,
+    ) -> None:
+        """Attach finished IDs while keeping AR's synthetic-abort policy explicit."""
+        finished_req_ids = self.finished_req_ids_dict
+        if not finished_req_ids:
+            return
+        for client_index, finished_set in finished_req_ids.items():
+            output = engine_core_outputs.get(client_index)
+            if output is None:
+                output = EngineCoreOutputs()
+                engine_core_outputs[client_index] = output
+            if synthesize_abort_outputs:
+                emitted = {item.request_id for item in output.outputs}
+                output.outputs.extend(
+                    EngineCoreOutput(req_id, [], finish_reason=FinishReason.ABORT)
+                    for req_id in finished_set
+                    if req_id not in emitted
+                )
+            output.finished_requests = finished_set
+        finished_req_ids.clear()
+
+    def _remove_stopped_requests_from_queues(
+        self,
+        stopped_running_reqs: set[Request],
+        stopped_preempted_reqs: set[Request],
+    ) -> None:
+        if stopped_running_reqs:
+            self.running = remove_all(self.running, stopped_running_reqs)
+        if stopped_preempted_reqs:
+            self.waiting.remove_requests(stopped_preempted_reqs)
+            self.skipped_waiting.remove_requests(stopped_preempted_reqs)
+
+    def _aggregate_kv_connector_stats(
+        self,
+        kv_connector_output: Any,
+    ) -> KVConnectorStats | None:
+        stats = kv_connector_output.kv_connector_stats if kv_connector_output else None
+        if self.connector:
+            scheduler_stats = self.connector.get_kv_connector_stats()
+            if scheduler_stats is not None and not scheduler_stats.is_empty():
+                stats = stats.aggregate(scheduler_stats) if stats is not None else scheduler_stats
+        return stats
+
+    def _publish_kv_cache_events(self) -> None:
+        events = self.kv_cache_manager.take_events()
+        if self.connector is not None:
+            connector_events = self.connector.take_events()
+            if connector_events:
+                if events is None:
+                    events = list(connector_events)
+                else:
+                    events.extend(connector_events)
+        if events:
+            self.kv_event_publisher.publish(KVEventBatch(ts=time.time(), events=events))
+
+    def _attach_scheduler_stats(
+        self,
+        engine_core_outputs: dict[int, EngineCoreOutputs],
+        spec_decoding_stats: SpecDecodingStats | None,
+        kv_connector_stats: KVConnectorStats | None,
+        cudagraph_stats: CUDAGraphStat | None,
+        perf_stats: PerfStats | None,
+    ) -> None:
+        stats = self.make_stats(
+            spec_decoding_stats,
+            kv_connector_stats,
+            cudagraph_stats,
+            perf_stats,
+        )
+        if stats is None:
+            return
+        if (output := next(iter(engine_core_outputs.values()), None)) is None:
+            engine_core_outputs[0] = output = EngineCoreOutputs()
+        output.scheduler_stats = stats
+
+    def finish_requests(
+        self,
+        request_ids: str | Iterable[str] | None,
+        finished_status: RequestStatus,
+    ) -> list[Request]:
+        """Finish requests and clean all Omni-owned queue/coordinator state."""
+        if self.chunk_transfer_adapter:
+            self.chunk_transfer_adapter.finish_requests(request_ids, finished_status, self.requests)
+
+        self._realign_request_status_to_queues(request_ids)
+        finished = super().finish_requests(request_ids, finished_status)
+        self._purge_finished_from_running()
+
+        for request in finished:
+            self._free_input_coordinator_request(request.request_id)
+        return finished
+
     def make_stats(self, *args, **kwargs) -> SchedulerStats | None:
         now = time.monotonic()
         if now - getattr(self, "_last_stats_time", 0.0) < _STATS_INTERVAL_S:
diff --git a/vllm_omni/core/sched/omni_scheduling_coordinator.py b/vllm_omni/core/sched/omni_scheduling_coordinator.py
index af6c73d6d..90820e51a 100644
--- a/vllm_omni/core/sched/omni_scheduling_coordinator.py
+++ b/vllm_omni/core/sched/omni_scheduling_coordinator.py
@@ -1,13 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Scheduling-side coordination for chunk and full_payload input waiting.
+"""Scheduling-side coordination for full_payload input waiting.
 
-Manages WAITING_FOR_CHUNK and WAITING_FOR_INPUT state transitions
-based on readiness signals from OmniConnectorOutput, without ever
-calling connector.put()/get().
+Manages WAITING_FOR_INPUT state transitions based on readiness signals
+from OmniConnectorOutput, without ever calling connector.put()/get().
 
-This replaces the scheduling half of OmniChunkTransferAdapter; the
-transport half lives in OmniConnectorModelRunnerMixin.
+Chunk waiting (WAITING_FOR_CHUNK) lives on OmniChunkTransferAdapter.
 """
 
 from __future__ import annotations
@@ -49,8 +47,16 @@ _FULL_PAYLOAD_INPUT_STAGES: frozenset[tuple[str, str]] = frozenset(
         # qwen3_tts: Qwen3TTSTalkerForConditionalGeneration (Stage 0)
         # -> Qwen3TTSCode2Wav (Stage 1).  Stage 1 is the consumer.
         ("Qwen3TTSCode2Wav", "code2wav"),
+        # minicpmo_4_5: Talker (Stage 1) -> Code2Wav (Stage 2).
+        ("MiniCPMO45Code2Wav", "code2wav"),
         # cosyvoice3: cosyvoice3_talker (Stage 0) -> cosyvoice3_code2wav (Stage 1).
         ("CosyVoice3Model", "cosyvoice3_code2wav"),
+        # audex TTS sync path: thinker (Stage 0) -> streaming decoder (Stage 1).
+        # The default deploy is async_chunk; this covers async_chunk: false.
+        ("AudexCode2Wav", "audex_code2wav"),
+        # audex TTA: tta thinker (Stage 0) -> XCodec1 (Stage 1, always sync
+        # full-payload — CNN codec decoded over the full sequence).
+        ("AudexXCodec1", "audex_xcodec"),
         # indextts2: indextts2_talker (Stage 0) -> indextts2_s2mel_decoder
         # (Stage 1). Stage 1 consumes the complete mel/latent payload.
         ("IndexTTS2S2MelDecoder", "indextts2_s2mel_decoder"),
@@ -64,7 +70,7 @@ _FULL_PAYLOAD_INPUT_STAGES: frozenset[tuple[str, str]] = frozenset(
 
 
 def uses_full_payload_input_coordinator(model_config: Any) -> bool:
-    """Returns True iff this stage parks pending requests in
+    """Returns True if this stage parks pending requests in
     WAITING_FOR_INPUT awaiting a full_payload delivery on the worker connector.
 
     Gated by (model_arch, model_stage) — see _FULL_PAYLOAD_INPUT_STAGES for the
@@ -83,31 +89,20 @@ def uses_full_payload_input_coordinator(model_config: Any) -> bool:
 
 
 class OmniSchedulingCoordinator:
-    """Pure-scheduling coordinator for chunk and full_payload input waiting.
+    """Pure-scheduling coordinator for full_payload input waiting.
 
     The Scheduler owns an instance of this class.  It consumes readiness
     signals produced by the Model Runner's ``OmniConnectorModelRunnerMixin``
-    (via ``OmniConnectorOutput``) and manages ``WAITING_FOR_CHUNK`` and
-    ``WAITING_FOR_INPUT`` state transitions accordingly.
+    (via ``OmniConnectorOutput``) and manages ``WAITING_FOR_INPUT`` state
+    transitions accordingly.
     """
 
-    def __init__(self, scheduler_max_num_seqs: int, stage_id: int = 0, async_chunk: bool = False):
+    def __init__(self, stage_id: int = 0):
         self._stage_id = stage_id
-        self._scheduler_max_num_seqs = scheduler_max_num_seqs
-        self._async_chunk = async_chunk
 
         self.finished_requests: set[str] = set()
-        self.requests_with_ready_chunks: set[str] = set()
         self._full_payload_input_received: set[str] = set()
 
-        self._waiting_for_chunk_waiting: deque[Any] = deque()
-        self._waiting_for_chunk_running: deque[Any] = deque()
-
-        # Request IDs that were newly registered for chunk recv this cycle.
-        # The engine/Model Runner should call register_chunk_recv() for these
-        # so the bg thread starts polling.
-        self.pending_chunk_registrations: list[Any] = []
-
         # Requests waiting for full_payload stage input (WAITING_FOR_INPUT).
         self._waiting_for_input: deque[Any] = deque()
         # Per-cycle list of minimal handles to ship to the model runner so it
@@ -117,67 +112,22 @@ class OmniSchedulingCoordinator:
         self.pending_input_registrations: list[OmniChunkRecvHandle] = []
 
         # Monotonic timestamp recording when each request first entered
-        # WAITING_FOR_CHUNK or WAITING_FOR_INPUT.  Used by
-        # collect_timed_out_request_ids() to detect orphaned waits.
+        # WAITING_FOR_INPUT.  Used by collect_timed_out_request_ids() to
+        # detect orphaned waits.
         self._waiting_since: dict[str, float] = {}
 
     # ------------------------------------------------------------------ #
     #  Core scheduling methods
     # ------------------------------------------------------------------ #
 
-    def process_pending_chunks(
-        self,
-        waiting_queue: Any,
-        running_queue: list[Request],
-        chunk_ready_req_ids: set[str],
-        chunk_finished_req_ids: set[str],
-    ) -> None:
-        """Transition requests whose chunks have arrived.
-
-        Args:
-            waiting_queue: Scheduler's waiting request queue.
-            running_queue: Scheduler's running request list.
-            chunk_ready_req_ids: IDs with a newly arrived chunk this cycle.
-            chunk_finished_req_ids: IDs whose final chunk has arrived.
-        """
-        if self._stage_id == 0 or not self._async_chunk:
-            return
-
-        terminal_ready_req_ids = chunk_ready_req_ids.intersection(chunk_finished_req_ids)
-        self.finished_requests.update(chunk_finished_req_ids - terminal_ready_req_ids)
-        self.pending_chunk_registrations = []
-
-        self._process_chunk_queue(
-            waiting_queue,
-            self._waiting_for_chunk_waiting,
-            RequestStatus.WAITING,
-            chunk_ready_req_ids,
-        )
-        self._process_chunk_queue(
-            running_queue,
-            self._waiting_for_chunk_running,
-            RequestStatus.RUNNING,
-            chunk_ready_req_ids,
-        )
-        self.finished_requests.update(terminal_ready_req_ids)
-
-        while len(running_queue) > self._scheduler_max_num_seqs:
-            request = running_queue.pop()
-            # Must reset status to WAITING so the scheduler treats it as
-            # schedulable work.  KV blocks are NOT freed here (unlike a
-            # real preemption), so PREEMPTED would be incorrect.
-            request.status = RequestStatus.WAITING
-            waiting_queue.prepend_requests([request])
-
     def process_pending_full_payload_inputs(
         self,
         waiting_queue: Any,
-        running_queue: list[Request],
         stage_recv_req_ids: set[str],
     ) -> None:
         """Manage WAITING_FOR_INPUT lifecycle for full_payload_mode.
 
-        For non-Stage-0 stages in full_payload_mode (``async_chunk=False``):
+        For non-Stage-0 stages in full_payload mode:
         1. Fresh WAITING requests are transitioned to WAITING_FOR_INPUT
            and registered for bg-thread polling.
         2. WAITING_FOR_INPUT requests whose data has arrived (in
@@ -187,7 +137,7 @@ class OmniSchedulingCoordinator:
             return
 
         self._full_payload_input_received.update(stage_recv_req_ids)
-        if not self._async_chunk and stage_recv_req_ids:
+        if stage_recv_req_ids:
             self.finished_requests.update(stage_recv_req_ids)
             logger.debug(
                 "[Coordinator stage-%s] full_payload recv -> finished_requests: %s",
@@ -206,19 +156,29 @@ class OmniSchedulingCoordinator:
                 remaining.append(request)
         self._waiting_for_input = remaining
 
-        if not self._async_chunk:
-            to_remove: list[Any] = []
-            queue_snapshot = list(waiting_queue)
-            for request in queue_snapshot:
-                if request.status == RequestStatus.WAITING:
-                    if request.request_id in self._full_payload_input_received:
-                        continue
-                    if request.request_id in self.requests_with_ready_chunks:
-                        continue
-                    if request.request_id in self.finished_requests:
-                        continue
-                    request.status = RequestStatus.WAITING_FOR_INPUT
-                    self._waiting_since.setdefault(request.request_id, time.monotonic())
+        to_remove: list[Any] = []
+        queue_snapshot = list(waiting_queue)
+        for request in queue_snapshot:
+            if request.status == RequestStatus.WAITING:
+                if request.request_id in self._full_payload_input_received:
+                    continue
+                if request.request_id in self.finished_requests:
+                    continue
+                request.status = RequestStatus.WAITING_FOR_INPUT
+                self._waiting_since.setdefault(request.request_id, time.monotonic())
+                to_remove.append(request)
+                self._waiting_for_input.append(request)
+                self.pending_input_registrations.append(
+                    OmniChunkRecvHandle(
+                        request_id=request.request_id,
+                        external_req_id=getattr(request, "external_req_id", None),
+                    )
+                )
+            elif request.status == RequestStatus.WAITING_FOR_INPUT:
+                if request.request_id in stage_recv_req_ids:
+                    request.status = RequestStatus.WAITING
+                    self._waiting_since.pop(request.request_id, None)
+                else:
                     to_remove.append(request)
                     self._waiting_for_input.append(request)
                     self.pending_input_registrations.append(
@@ -227,38 +187,15 @@ class OmniSchedulingCoordinator:
                             external_req_id=getattr(request, "external_req_id", None),
                         )
                     )
-                elif request.status == RequestStatus.WAITING_FOR_INPUT:
-                    if request.request_id in stage_recv_req_ids:
-                        request.status = RequestStatus.WAITING
-                        self._waiting_since.pop(request.request_id, None)
-                    else:
-                        to_remove.append(request)
-                        self._waiting_for_input.append(request)
-                        self.pending_input_registrations.append(
-                            OmniChunkRecvHandle(
-                                request_id=request.request_id,
-                                external_req_id=getattr(request, "external_req_id", None),
-                            )
-                        )
-            if to_remove:
-                # Use the bulk-remove helper: one O(N) sweep instead of N
-                # repeated O(N) removes from a list-backed queue.
-                waiting_queue.remove_requests(to_remove)
-
-    def process_pending_full_payload_inputs_legacy(
-        self,
-        waiting_queue: Any,
-        running_queue: list[Request],
-        stage_recv_req_ids: set[str],
-    ) -> None:
-        """Compatibility wrapper for ``process_pending_full_payload_inputs``."""
-        self.process_pending_full_payload_inputs(waiting_queue, running_queue, stage_recv_req_ids)
+        if to_remove:
+            # Use the bulk-remove helper: one O(N) sweep instead of N
+            # repeated O(N) removes from a list-backed queue.
+            waiting_queue.remove_requests(to_remove)
 
     def free_finished_request(self, request_id: str) -> None:
         """Prune internal tracking sets for a freed request to prevent unbounded growth."""
         self._full_payload_input_received.discard(request_id)
         self.finished_requests.discard(request_id)
-        self.requests_with_ready_chunks.discard(request_id)
         self._waiting_since.pop(request_id, None)
 
     def collect_timed_out_request_ids(
@@ -290,22 +227,16 @@ class OmniSchedulingCoordinator:
 
         # Defensively remove from coordinator internal queues (may already
         # be empty if restore_queues() has run).
-        for queue_attr in (
-            "_waiting_for_chunk_waiting",
-            "_waiting_for_chunk_running",
-            "_waiting_for_input",
-        ):
-            queue = getattr(self, queue_attr)
-            remaining: deque[Any] = deque()
-            for request in queue:
-                if request.request_id not in timed_out_ids:
-                    remaining.append(request)
-            setattr(self, queue_attr, remaining)
+        remaining: deque[Any] = deque()
+        for request in self._waiting_for_input:
+            if request.request_id not in timed_out_ids:
+                remaining.append(request)
+        self._waiting_for_input = remaining
 
         for req_id in timed_out_ids:
             self._waiting_since.pop(req_id, None)
             logger.warning(
-                "[Coordinator stage-%s] Request %s timed out waiting for chunk/input (waited > %.0fs)",
+                "[Coordinator stage-%s] Request %s timed out waiting for input (waited > %.0fs)",
                 self._stage_id,
                 req_id,
                 timeout_s,
@@ -316,17 +247,8 @@ class OmniSchedulingCoordinator:
     def restore_queues(
         self,
         waiting_queue: Any,
-        running_queue: list[Request],
     ) -> None:
-        """Return waiting-for-chunk/input requests to scheduling queues."""
-        for request in self._waiting_for_chunk_waiting:
-            waiting_queue.add_request(request)
-        self._waiting_for_chunk_waiting = deque()
-
-        if self._waiting_for_chunk_running:
-            running_queue.extend(self._waiting_for_chunk_running)
-        self._waiting_for_chunk_running = deque()
-
+        """Return waiting-for-input requests to the waiting queue."""
         for request in self._waiting_for_input:
             waiting_queue.add_request(request)
         self._waiting_for_input = deque()
@@ -411,12 +333,6 @@ class OmniSchedulingCoordinator:
 
             if model_mode != "ar":
                 new_ids = self._flatten_prompt_token_ids(metadata.get("code_predictor_codes"))
-                runtime_seed = None
-                if "left_context_size" in metadata:
-                    runtime_seed = {
-                        "meta": {"left_context_size": metadata["left_context_size"]},
-                    }
-                request._omni_initial_model_buffer = runtime_seed
                 if new_ids:
                     request.prompt_token_ids = new_ids
                     request.num_prompt_tokens = len(new_ids)
@@ -424,57 +340,3 @@ class OmniSchedulingCoordinator:
                     request._all_token_ids.extend(new_ids)
                     request._output_token_ids.clear()
                     request.num_computed_tokens = 0
-
-    def postprocess_scheduler_output(
-        self,
-        scheduler_output: Any,
-        requests: dict[str, Request] | None = None,
-    ) -> None:
-        """Clear per-cycle ready state after scheduler output is materialized."""
-        self._clear_chunk_ready(scheduler_output)
-
-    # ------------------------------------------------------------------ #
-    #  Internal helpers
-    # ------------------------------------------------------------------ #
-
-    def _process_chunk_queue(
-        self,
-        queue: Any,
-        waiting_for_chunk_list: deque[Any],
-        target_status: RequestStatus,
-        chunk_ready_req_ids: set[str],
-    ) -> None:
-        queue_snapshot = list(queue)
-        for request in queue_snapshot:
-            if request.status != RequestStatus.WAITING_FOR_CHUNK:
-                if request.request_id in self.requests_with_ready_chunks:
-                    continue
-                if request.request_id in self.finished_requests:
-                    continue
-                if request.status == RequestStatus.WAITING_FOR_INPUT:
-                    continue
-                if request.request_id in chunk_ready_req_ids:
-                    self.requests_with_ready_chunks.add(request.request_id)
-                    continue
-                self.pending_chunk_registrations.append(request)
-                request.status = RequestStatus.WAITING_FOR_CHUNK
-                self._waiting_since.setdefault(request.request_id, time.monotonic())
-            else:
-                if request.request_id in chunk_ready_req_ids:
-                    request.status = target_status
-                    self.requests_with_ready_chunks.add(request.request_id)
-                    self._waiting_since.pop(request.request_id, None)
-                    continue
-            queue.remove(request)
-            waiting_for_chunk_list.append(request)
-
-    def _clear_chunk_ready(self, scheduler_output: Any) -> None:
-        if scheduler_output.scheduled_new_reqs:
-            for req_data in scheduler_output.scheduled_new_reqs:
-                self.requests_with_ready_chunks.discard(
-                    getattr(req_data, "req_id", None),
-                )
-
-        if scheduler_output.scheduled_cached_reqs:
-            for req_id in scheduler_output.scheduled_cached_reqs.req_ids:
-                self.requests_with_ready_chunks.discard(req_id)
diff --git a/vllm_omni/core/sched/output.py b/vllm_omni/core/sched/output.py
index 29cd87299..b73fbd6aa 100644
--- a/vllm_omni/core/sched/output.py
+++ b/vllm_omni/core/sched/output.py
@@ -1,4 +1,4 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, fields
 
 from vllm.v1.core.sched.output import CachedRequestData, NewRequestData, SchedulerOutput
 from vllm.v1.request import Request
@@ -20,10 +20,28 @@ class OmniNewRequestData(NewRequestData):
         external_req_id: Optional external request ID for tracking
         additional_information: Optional serialized additional information
             dictionary containing tensors or lists
+        model_intermediate_buffer: Optional runner-owned payload for
+            GPUModelRunner.model_intermediate_buffer
     """
 
     external_req_id: str | None = None
     additional_information: AdditionalInformationPayload | None = None
+    model_intermediate_buffer: dict[str, object] | None = None
+
+    @classmethod
+    def from_base(
+        cls,
+        data: NewRequestData,
+        request: Request | None,
+    ) -> "OmniNewRequestData":
+        """Preserve upstream request data while attaching Omni payloads."""
+        base_data = {field.name: getattr(data, field.name) for field in fields(NewRequestData)}
+        return cls(
+            **base_data,
+            external_req_id=getattr(request, "external_req_id", None),
+            additional_information=getattr(request, "additional_information", None),
+            model_intermediate_buffer=getattr(request, "model_intermediate_buffer", None),
+        )
 
     @classmethod
     def from_request(
@@ -56,6 +74,7 @@ class OmniNewRequestData(NewRequestData):
             prompt_is_token_ids=getattr(request, "prompt_is_token_ids", None),
             prefill_token_ids=prefill_token_ids,
             additional_information=getattr(request, "additional_information", None),
+            model_intermediate_buffer=getattr(request, "model_intermediate_buffer", None),
         )
 
 
@@ -73,7 +92,7 @@ class OmniCachedRequestData(CachedRequestData):
 
 @dataclass
 class OmniChunkRecvHandle:
-    """Minimal identifier carried from scheduler to runner for chunk-recv
+    """Minimal identifier carried from scheduler to runner for input-receive
     registration.
 
     The runner's ``register_chunk_recv`` only consumes ``request_id`` and
diff --git a/vllm_omni/data_entry_keys.py b/vllm_omni/data_entry_keys.py
index eec3e5c33..db2cf15ea 100644
--- a/vllm_omni/data_entry_keys.py
+++ b/vllm_omni/data_entry_keys.py
@@ -61,12 +61,20 @@ class OmniPayloadMeta(TypedDict, total=False):
     finished: torch.Tensor
     is_segment_finished: torch.Tensor
     stream_finished: torch.Tensor
+    request_id: str
+    chunk_seq: int
+    cache_epoch: int
+    codec_chunk_frames: int
+    codec_left_context_frames: int
+    code_flat_numel: int
+    last_chunk: bool
     req_id: list[str]
     left_context_size: int
     right_holdback_size: int
     override_keys: list[tuple[str, str]]
     num_processed_tokens: int
     next_stage_prompt_len: int
+    replace_streaming_prompt: bool
     ar_width: int
     eol_token_id: int
     visual_token_start_id: int
@@ -82,6 +90,7 @@ class OmniPayloadMeta(TypedDict, total=False):
     ref_context_request_id: str
     ref_context_included: bool
     talker_prefill_offset: int
+    omni_final_stage_id: int
 
 
 class OmniPayload(TypedDict, total=False):
@@ -150,12 +159,17 @@ class MetaStruct(_StructBase):
     finished: torch.Tensor | None = None
     is_segment_finished: torch.Tensor | None = None
     stream_finished: torch.Tensor | None = None
+    request_id: str | None = None
+    chunk_seq: int | None = None
+    cache_epoch: int | None = None
+    last_chunk: bool | None = None
     req_id: list[str] | None = None
     left_context_size: int | None = None
     right_holdback_size: int | None = None
     override_keys: list[tuple[str, str]] | None = None
     num_processed_tokens: int | None = None
     next_stage_prompt_len: int | None = None
+    replace_streaming_prompt: bool | None = None
     ar_width: int | None = None
     eol_token_id: int | None = None
     visual_token_start_id: int | None = None
diff --git a/vllm_omni/deploy/audex_s2s.yaml b/vllm_omni/deploy/audex_s2s.yaml
new file mode 100644
index 000000000..861106315
--- /dev/null
+++ b/vllm_omni/deploy/audex_s2s.yaml
@@ -0,0 +1,65 @@
+# Audex (Nemotron-Labs-Audex-2B) full deploy: cascaded speech-to-speech.
+#
+# One audio-capable thinker (checkpoint_folder_full) serves the official
+# three-pass cascade — (1) ASR: audio -> transcript, (2) chat: transcript ->
+# answer, (3) TTS: answer -> speech — plus the streaming causal speech
+# decoder as stage 1. Per-request output modalities route the passes: text
+# passes finish at stage 0; only audio-modality requests stream codec frames
+# into code2wav. CFG applies to the TTS pass via extra_params.cfg_scale
+# (recommended 1.5; 1.0 = off).
+pipeline: audex_s2s
+async_chunk: true
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      initial_codec_chunk_frames: 1
+      codec_token_offset: 131077
+      codec_vocab_size: 65536
+      decoder_emit_chunk_frames: 5
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.5
+    trust_remote_code: true
+    enable_prefix_caching: true
+    async_scheduling: true
+    max_num_batched_tokens: 8192
+    # Sound embeddings (up to 30 clips x 750) + speech-token generation.
+    max_model_len: 32768
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.1
+      top_k: 80
+      max_tokens: 2048
+      seed: 0
+
+  - stage_id: 1
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.25
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/audex_s2s_30b.yaml b/vllm_omni/deploy/audex_s2s_30b.yaml
new file mode 100644
index 000000000..5921e8308
--- /dev/null
+++ b/vllm_omni/deploy/audex_s2s_30b.yaml
@@ -0,0 +1,60 @@
+# Audex 30B-A3B full deploy: cascaded speech-to-speech.
+# See audex_s2s.yaml for the cascade/routing notes and audex_tts_30b.yaml
+# for the 30B sizing notes (hybrid Mamba: no prefix caching; single-H100
+# layout, TP2 fallback; pass this yaml explicitly).
+pipeline: audex_s2s
+async_chunk: true
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      initial_codec_chunk_frames: 1
+      codec_token_offset: 131077
+      codec_vocab_size: 65536
+      decoder_emit_chunk_frames: 5
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.85
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 8192
+    # Sound embeddings (up to 30 clips x 750) + speech-token generation.
+    max_model_len: 32768
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.1
+      top_k: 80
+      max_tokens: 2048
+      seed: 0
+
+  - stage_id: 1
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.08
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/audex_thinker_only.yaml b/vllm_omni/deploy/audex_thinker_only.yaml
new file mode 100644
index 000000000..8672d12c4
--- /dev/null
+++ b/vllm_omni/deploy/audex_thinker_only.yaml
@@ -0,0 +1,25 @@
+# Audex (Nemotron-Labs-Audex-2B) thinker-only deploy: audio understanding
+# (ASR / audio QA) -> text. Single-stage configuration of the audio-capable
+# full checkpoint (checkpoint_folder_full): NV-Whisper encoder + relu2
+# projector + 2B dense LM.
+#
+# The official audioqa script decodes ASR at temperature 0; max_tokens 256
+# covers transcription and short QA answers (raise for long-form answers).
+pipeline: audex_thinker_only
+async_chunk: false
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.7
+    trust_remote_code: true
+    enable_prefix_caching: true
+    max_num_batched_tokens: 8192
+    # 30 clips x 750 sound embeddings (900 s cap) + text headroom.
+    max_model_len: 32768
+    dtype: bfloat16
+    devices: "0"
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 256
+      seed: 0
diff --git a/vllm_omni/deploy/audex_thinker_only_30b.yaml b/vllm_omni/deploy/audex_thinker_only_30b.yaml
new file mode 100644
index 000000000..aaef42b17
--- /dev/null
+++ b/vllm_omni/deploy/audex_thinker_only_30b.yaml
@@ -0,0 +1,22 @@
+# Audex 30B-A3B thinker-only deploy: audio understanding (ASR / audio QA).
+# Single-stage NemotronHAudexForConditionalGeneration on
+# checkpoint_folder_full. Hybrid Mamba: no prefix caching. Pass this yaml
+# explicitly (see audex_tts_30b.yaml).
+pipeline: audex_thinker_only
+async_chunk: false
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.9
+    trust_remote_code: true
+    enable_prefix_caching: false
+    max_num_batched_tokens: 8192
+    # 30 clips x 750 sound embeddings (900 s cap) + text headroom.
+    max_model_len: 32768
+    dtype: bfloat16
+    devices: "0"
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 256
+      seed: 0
diff --git a/vllm_omni/deploy/audex_tta.yaml b/vllm_omni/deploy/audex_tta.yaml
new file mode 100644
index 000000000..d5419e00b
--- /dev/null
+++ b/vllm_omni/deploy/audex_tta.yaml
@@ -0,0 +1,69 @@
+# Audex (Nemotron-Labs-Audex-2B) text-to-audio deploy: TTA thinker → XCodec1.
+#
+# Notable choices:
+#   * Sync full-payload (async_chunk: false): XCodec1 is a CNN codec the
+#     official flow decodes over the full sequence; there is no streaming
+#     reference and chunked decode risks boundary artifacts.
+#   * Stage 0 sampling defaults follow the official TTA script (temperature
+#     1.0, top_k 80; stop on <audiogen_end>; codec cap 4000 tokens = 1000
+#     frames generated, decode truncates at 500 frames ≈ 10 s).
+#   * Classifier-free guidance is effectively mandatory for TTA quality; the
+#     official default is cfg_scale 3.0. The RVQ phase mask is required for
+#     validity — both logits processors are registered here and driven per
+#     request via extra_args (cfg_* and tta_rvq).
+#   * Stage 1's model is the EXTERNAL hf-audio XCodec1 checkpoint (override
+#     with a local path here or via XCODEC1_PATH); its tokenizer is borrowed
+#     from the thinker checkpoint automatically.
+pipeline: audex_tta
+async_chunk: false
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      audiocodec_token_offset: 196613
+      audiocodec_vocab_size: 8192
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.4
+    trust_remote_code: true
+    enable_prefix_caching: true
+    async_scheduling: true
+    max_num_batched_tokens: 512
+    max_model_len: 8192
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+      - "vllm_omni.model_executor.models.audex.tta:TTARVQPhaseMaskLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 1.0
+      top_k: 80
+      max_tokens: 4200
+      seed: 0
+
+  - stage_id: 1
+    model: hf-audio/xcodec-hubert-general-balanced
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.25
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/audex_tta_30b.yaml b/vllm_omni/deploy/audex_tta_30b.yaml
new file mode 100644
index 000000000..52c7fdc27
--- /dev/null
+++ b/vllm_omni/deploy/audex_tta_30b.yaml
@@ -0,0 +1,57 @@
+# Audex 30B-A3B text-to-audio deploy: TTA thinker → XCodec1.
+# See audex_tta.yaml for the task notes and audex_tts_30b.yaml for the
+# 30B sizing notes (hybrid Mamba: no prefix caching; single-H100 layout,
+# TP2 fallback; pass this yaml explicitly).
+pipeline: audex_tta
+async_chunk: false
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      audiocodec_token_offset: 196613
+      audiocodec_vocab_size: 8192
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.85
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 512
+    max_model_len: 8192
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+      - "vllm_omni.model_executor.models.audex.tta:TTARVQPhaseMaskLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 1.0
+      top_k: 80
+      max_tokens: 4200
+      seed: 0
+
+  - stage_id: 1
+    model: hf-audio/xcodec-hubert-general-balanced
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.08
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/audex_tts.yaml b/vllm_omni/deploy/audex_tts.yaml
new file mode 100644
index 000000000..f0509ec30
--- /dev/null
+++ b/vllm_omni/deploy/audex_tts.yaml
@@ -0,0 +1,83 @@
+# Audex (Nemotron-Labs-Audex-2B) TTS deploy: thinker → code2wav via
+# shared-memory chunk streaming. Verified on 1x H100.
+#
+# Notable choices:
+#   * The code2wav decoder is a stateful streaming session per request — no
+#     left-context replay; chunks carry only new frames, so
+#     codec_left_context_frames stays 0.
+#   * codec_token_offset / codec_vocab_size mirror the checkpoint tokenizer's
+#     <speechcodec_N> block (pinned by a unit test).
+#   * Stage 0 sampling defaults follow the official TTS script
+#     (temperature 0.1, top_k 80, max_tokens 2048).
+#   * Classifier-free guidance: the stage-0 logits processor + scheduler
+#     pair patches are always installed but idle until a request carries
+#     extra_args.cfg_scale > 1.0 (serving: extra_params.cfg_scale; offline:
+#     --cfg-scale). Guided requests decode at temperature 0.05 (CFG
+#     sharpens the distribution; measured en-24 cfg1.5 CER: 6.87% at
+#     temp 0.05 vs 7.31% at the unguided 0.1 — baseline 7.24%).
+#     Every guided request adds an unconditional companion sequence in
+#     stage 0 — at max_num_seqs 8 that means at most 4 guided requests
+#     decode concurrently; raise max_num_seqs if CFG-heavy traffic needs
+#     more parallelism.
+pipeline: audex_tts
+async_chunk: true
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      # Emit the first chunk early for a fast first audible sample.
+      initial_codec_chunk_frames: 1
+      codec_token_offset: 131077
+      codec_vocab_size: 65536
+      # Decoder-internal emit granularity (frames per decode call).
+      decoder_emit_chunk_frames: 5
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.4
+    trust_remote_code: true
+    enable_prefix_caching: true
+    async_scheduling: true
+    max_num_batched_tokens: 512
+    max_model_len: 4096
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.1
+      top_k: 80
+      max_tokens: 2048
+      seed: 0
+
+  - stage_id: 1
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.25
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    # Sync scheduling: with async scheduling the runner builds per-request
+    # payloads against the NEXT step's input batch, tripping the one-entry-
+    # per-request check when chunk arrival staggers requests.
+    async_scheduling: false
+    # async_chunk appends codec frames per step; max_model_len must cover the
+    # accumulated stream (max_tokens 2048 codes plus prompt headroom).
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/audex_tts_30b.yaml b/vllm_omni/deploy/audex_tts_30b.yaml
new file mode 100644
index 000000000..a4aa2d4cc
--- /dev/null
+++ b/vllm_omni/deploy/audex_tts_30b.yaml
@@ -0,0 +1,76 @@
+# Audex 30B-A3B (nvidia/Nemotron-Labs-Audex-30B-A3B) TTS deploy.
+#
+# Same pipeline/topology/token space as the 2B (audex_tts.yaml); the thinker
+# is the hybrid Mamba+MoE NemotronHForCausalLM (~60 GB bf16), so:
+#   * enable_prefix_caching: false — hybrid Mamba stage.
+#   * Single H100 80GB layout: thinker 0.85 + decoder 0.08 share GPU 0.
+#     If weights + state do not fit (long sequences OOM), set
+#     tensor_parallel_size: 2 on stage 0 and move stage 1 to devices "2".
+#   * CUDA graphs stay ON for stage 0: the hybrid Mamba+MoE thinker
+#     captures cleanly and review benchmarks measured ~7x lower TTS RTF
+#     vs enforce_eager (0.30 vs 2.08 single-stream), on par with the 2B
+#     and NVIDIA's reference demo.
+#   * Classifier-free guidance quality (en-24, self-transcribed ASR CER):
+#     baseline cfg=1.0 -> 0.72%; guided cfg=1.5 at temperature 0.1 -> 0.72%
+#     (gate: guided <= baseline, PASS). Note the 30B's best guided
+#     temperature is 0.1 (the yaml default) — unlike the 2B's 0.05, which
+#     measured 0.79% here. The serving layer currently injects 0.05 for
+#     guided requests on all sizes; acceptable (still within the anchor
+#     +2pp standing gate) but a size-aware refinement is a known follow-up.
+# ALWAYS pass this yaml explicitly (--deploy-config): bare serve of the
+# 30B repo auto-detects the shared model_type and lands on the 2B-tuned yaml.
+pipeline: audex_tts
+async_chunk: true
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      initial_codec_chunk_frames: 1
+      codec_token_offset: 131077
+      codec_vocab_size: 65536
+      decoder_emit_chunk_frames: 5
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.85
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 512
+    max_model_len: 4096
+    dtype: bfloat16
+    devices: "0"
+    logits_processors:
+      - "vllm_omni.model_executor.models.audex.cfg:AudexCFGLogitsProcessor"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.1
+      top_k: 80
+      max_tokens: 2048
+      seed: 0
+
+  - stage_id: 1
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.08
+    enforce_eager: true
+    trust_remote_code: true
+    enable_prefix_caching: false
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    max_model_len: 8192
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 8192
+      seed: 0
diff --git a/vllm_omni/deploy/aura_omni.yaml b/vllm_omni/deploy/aura_omni.yaml
index 486e44b57..cf6826fdd 100644
--- a/vllm_omni/deploy/aura_omni.yaml
+++ b/vllm_omni/deploy/aura_omni.yaml
@@ -12,7 +12,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/bagel.yaml b/vllm_omni/deploy/bagel.yaml
index 8de6f9305..644e2c3c0 100644
--- a/vllm_omni/deploy/bagel.yaml
+++ b/vllm_omni/deploy/bagel.yaml
@@ -40,8 +40,6 @@ stages:
 connectors:
   shared_memory_connector:
     name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 65536
 
   rdma_connector:
     name: MooncakeTransferEngineConnector
diff --git a/vllm_omni/deploy/cosyvoice3.yaml b/vllm_omni/deploy/cosyvoice3.yaml
index d81cf4a9b..551b42af6 100644
--- a/vllm_omni/deploy/cosyvoice3.yaml
+++ b/vllm_omni/deploy/cosyvoice3.yaml
@@ -24,8 +24,6 @@
 #   first. Raising connector_get_sleep_s also relaxes the consumer's polling
 #   cadence, but trades against TTFP — keep it as a last resort.
 async_chunk: true
-dtype: float32
-
 connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
diff --git a/vllm_omni/deploy/dreamzero_tp1_cfg2.yaml b/vllm_omni/deploy/dreamzero_tp1_cfg2.yaml
index a453d43f3..0bf3d9517 100644
--- a/vllm_omni/deploy/dreamzero_tp1_cfg2.yaml
+++ b/vllm_omni/deploy/dreamzero_tp1_cfg2.yaml
@@ -11,6 +11,8 @@ stages:
     max_num_seqs: 1
     enforce_eager: false
     model_class_name: DreamZeroPipeline
+    # DreamZero runs on the AR-Diffusion engine (engine-level paged KV cache).
+    engine_backend: vllm_omni.experimental.ar_diffusion.engine.ARDiffusionEngine
     parallel_config:
       tensor_parallel_size: 1
       cfg_parallel_size: 2
diff --git a/vllm_omni/deploy/dynin_omni_multiconnector.yaml b/vllm_omni/deploy/dynin_omni_multiconnector.yaml
index c863ec3d5..5abb4c5a3 100644
--- a/vllm_omni/deploy/dynin_omni_multiconnector.yaml
+++ b/vllm_omni/deploy/dynin_omni_multiconnector.yaml
@@ -31,8 +31,6 @@ connectors:
   # Alternative SHM connector with an explicit threshold.
   shared_memory_connector:
     name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 65536    # 64KB threshold
 
 stages:
   - stage_id: 0
diff --git a/vllm_omni/deploy/fish_qwen3_omni.yaml b/vllm_omni/deploy/fish_qwen3_omni.yaml
index 5b0c44988..f10ed1656 100644
--- a/vllm_omni/deploy/fish_qwen3_omni.yaml
+++ b/vllm_omni/deploy/fish_qwen3_omni.yaml
@@ -9,7 +9,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
@@ -63,3 +62,15 @@ stages:
       max_tokens: 65536
       seed: 42
       repetition_penalty: 1.0
+
+platforms:
+  xpu:
+    stages:
+      # Verified on Intel Arc B60.
+      - stage_id: 0
+        gpu_memory_utilization: 0.8
+        max_model_len: 2048
+        max_num_batched_tokens: 2048
+      - stage_id: 1
+        max_model_len: 2048
+        max_num_batched_tokens: 2048
diff --git a/vllm_omni/deploy/fish_qwen3_omni_2gpu.yaml b/vllm_omni/deploy/fish_qwen3_omni_2gpu.yaml
index 9fec34d69..360b72974 100644
--- a/vllm_omni/deploy/fish_qwen3_omni_2gpu.yaml
+++ b/vllm_omni/deploy/fish_qwen3_omni_2gpu.yaml
@@ -20,7 +20,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       # Tightened from 10ms to 1ms: chunks become available sooner under
       # cross-GPU pipelining, so connector idle waiting dominates if left high.
diff --git a/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_dual_gpu.yaml b/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_dual_gpu.yaml
index a65609c6c..57ea6e757 100644
--- a/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_dual_gpu.yaml
+++ b/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_dual_gpu.yaml
@@ -10,7 +10,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.001
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_single_gpu.yaml b/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_single_gpu.yaml
index d771e4163..0c9771b18 100644
--- a/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_single_gpu.yaml
+++ b/vllm_omni/deploy/fish_qwen3_omni_high_concurrency_single_gpu.yaml
@@ -10,7 +10,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.001
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/higgs_audio_v2.yaml b/vllm_omni/deploy/higgs_audio_v2.yaml
index 07e25d5c1..9c181400b 100644
--- a/vllm_omni/deploy/higgs_audio_v2.yaml
+++ b/vllm_omni/deploy/higgs_audio_v2.yaml
@@ -17,7 +17,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 5000
diff --git a/vllm_omni/deploy/higgs_multimodal_qwen3.yaml b/vllm_omni/deploy/higgs_multimodal_qwen3.yaml
index 5fc44a295..da299415b 100644
--- a/vllm_omni/deploy/higgs_multimodal_qwen3.yaml
+++ b/vllm_omni/deploy/higgs_multimodal_qwen3.yaml
@@ -16,7 +16,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       # Stream PCM bytes back to the client as Stage 1 emits each chunk.
       codec_streaming: true
       # Streaming chunk shape for talker2code2wav_async_chunk:
diff --git a/vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml b/vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml
index 86427be13..8a751483c 100644
--- a/vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml
+++ b/vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml
@@ -15,7 +15,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       # Stream PCM bytes back to the client as Stage 1 emits each chunk.
       codec_streaming: true
       # Streaming chunk shape for talker2code2wav_async_chunk:
diff --git a/vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml b/vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml
index 8210db4a8..0d6ae8218 100644
--- a/vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml
+++ b/vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml
@@ -21,7 +21,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       # Stream PCM bytes back to the client as Stage 1 emits each chunk.
       codec_streaming: true
       # Streaming chunk shape for talker2code2wav_async_chunk:
diff --git a/vllm_omni/deploy/hunyuan_image3_dit.yaml b/vllm_omni/deploy/hunyuan_image3_dit.yaml
index 3c0ba1901..537afadc0 100644
--- a/vllm_omni/deploy/hunyuan_image3_dit.yaml
+++ b/vllm_omni/deploy/hunyuan_image3_dit.yaml
@@ -24,6 +24,7 @@ stages:
       sequence_parallel_size: 1
       ulysses_degree: 1
       ring_degree: 1
+      allgather_degree: 1
       cfg_parallel_size: 1
       vae_patch_parallel_size: 1
       use_hsdp: false
diff --git a/vllm_omni/deploy/hunyuan_image_3_moe.yaml b/vllm_omni/deploy/hunyuan_image_3_moe.yaml
index b661674c7..4ae4520a7 100644
--- a/vllm_omni/deploy/hunyuan_image_3_moe.yaml
+++ b/vllm_omni/deploy/hunyuan_image_3_moe.yaml
@@ -27,8 +27,6 @@ connectors:
       memory_pool_device: "npu"
   shared_memory_connector:
     name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 65536
 
 stages:
   - stage_id: 0
diff --git a/vllm_omni/deploy/hunyuan_video_15.yaml b/vllm_omni/deploy/hunyuan_video_15.yaml
new file mode 100644
index 000000000..b1f4f7351
--- /dev/null
+++ b/vllm_omni/deploy/hunyuan_video_15.yaml
@@ -0,0 +1,18 @@
+# HunyuanVideo-1.5 deploy.
+#
+# Single GPU by default. Increase tensor_parallel_size and devices for multi-GPU TP.
+async_chunk: false
+trust_remote_code: true
+distributed_executor_backend: mp
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    max_num_seqs: 1
+    tensor_parallel_size: 1
+    enforce_eager: true
+    # HunyuanVideo-1.5 peak VRAM is dominated by the single-shot VAE decode of
+    # the full video, so tiling the decode is the main memory lever.
+    vae_use_tiling: true
+    default_sampling_params:
+      seed: 42
diff --git a/vllm_omni/deploy/indextts2.yaml b/vllm_omni/deploy/indextts2.yaml
index 75eb60188..c5fefcf30 100644
--- a/vllm_omni/deploy/indextts2.yaml
+++ b/vllm_omni/deploy/indextts2.yaml
@@ -4,7 +4,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: false
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 5000
diff --git a/vllm_omni/deploy/indextts2_low_latency.yaml b/vllm_omni/deploy/indextts2_low_latency.yaml
index 621116ab2..678144a2b 100644
--- a/vllm_omni/deploy/indextts2_low_latency.yaml
+++ b/vllm_omni/deploy/indextts2_low_latency.yaml
@@ -17,7 +17,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: false
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 5000
diff --git a/vllm_omni/deploy/mimo_audio.yaml b/vllm_omni/deploy/mimo_audio.yaml
index a50632964..daeedec99 100644
--- a/vllm_omni/deploy/mimo_audio.yaml
+++ b/vllm_omni/deploy/mimo_audio.yaml
@@ -13,7 +13,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 365536
       codec_streaming: true
       connector_get_sleep_s: 0.001
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/ming_flash_omni_image.yaml b/vllm_omni/deploy/ming_flash_omni_image.yaml
index 9f7c6a34d..a02bd07e5 100644
--- a/vllm_omni/deploy/ming_flash_omni_image.yaml
+++ b/vllm_omni/deploy/ming_flash_omni_image.yaml
@@ -50,8 +50,6 @@ stages:
 connectors:
   shared_memory_connector:
     name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 65536  # 64KB threshold
 
 edges:
   - from: 0
diff --git a/vllm_omni/deploy/minicpmo_4_5.yaml b/vllm_omni/deploy/minicpmo_4_5.yaml
index 980615479..66a5f3ac9 100644
--- a/vllm_omni/deploy/minicpmo_4_5.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5.yaml
@@ -1,25 +1,32 @@
-# MiniCPM-o 4.5 default deploy: 2-GPU layout.
-#
-# Stage 0 (thinker): GPU 0 — multimodal understanding, ~70% mem.
-# Stage 1 (talker) : GPU 1 — MiniCPMTTS + Token2Wav, ~75% mem
-#                            (covers both the talker LM and the in-process
-#                            Token2Wav vocoder that emits the waveform).
-#
-# Other GPU layouts: minicpmo_4_5_3gpu.yaml, minicpmo_4_5_8x4090.yaml.
-async_chunk: false
+# MiniCPM-o 4.5 three-stage deploy on one large-memory GPU.
+pipeline: minicpmo_4_5
+async_chunk: true
 
 trust_remote_code: true
 enable_prefix_caching: false
 
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      codec_left_context_frames: 3
+
 stages:
   - stage_id: 0
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.7
-    enforce_eager: true
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.55
+    enforce_eager: false
     tensor_parallel_size: 1
     max_num_batched_tokens: 16384
     devices: "0"
     limit_mm_per_prompt:
+      # Daily-Omni MiniCPM pack: up to 64 interleaved image/audio pairs (1fps).
+      image: 64
+      audio: 64
       video: 1
     default_sampling_params:
       temperature: 0.0
@@ -28,24 +35,62 @@ stages:
       max_tokens: 2048
       seed: 42
       detokenize: true
-      repetition_penalty: 1.1
+      # 1.0 for MCQ accuracy; 1.1 can bias short A–D answers.
+      repetition_penalty: 1.0
 
   - stage_id: 1
-    # Talker only consumes runtime_additional_information[0]; any value > 1
-    # makes concurrent requests share request-0's audio (mm_outputs fallback).
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.75
-    enforce_eager: true
+    max_num_seqs: 4
+    # Leave device-level headroom for the colocated HiFi-GAN cuDNN workspace.
+    gpu_memory_utilization: 0.15
+    enforce_eager: false
     max_num_batched_tokens: 8192
-    devices: "1"
+    devices: "0"
+    output_connectors:
+      to_stage_2: connector_of_shared_memory
+    # Codec sampling comes from the checkpoint's tts_config. These parameters
+    # govern only vLLM's binary continue/stop token.
     default_sampling_params:
       temperature: 0.0
       top_p: 1.0
       top_k: -1
-      max_tokens: 1
+      min_tokens: 50
+      max_tokens: 2048
+      stop_token_ids: [1]
       seed: 42
       detokenize: false
 
-# MiniCPM-o 4.5 has only been verified on CUDA devices.  Add per-platform
-# overrides here when other backends (ROCm/XPU/NPU) are verified end-to-end.
-platforms: {}
+  - stage_id: 2
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.15
+    enforce_eager: true
+    enable_chunked_prefill: false
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "0"
+    input_connectors:
+      from_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      detokenize: true
+
+platforms:
+  cuda:
+    stages:
+      - stage_id: 1
+        # Four Talker streams need much less KV than automatic sizing.
+        # Leave single-GPU headroom for concurrent Stage 2 diffusion batches.
+        kv_cache_memory_bytes: 2147483648  # 2 GiB
+
+  npu:
+    stages:
+      - stage_id: 0
+        max_num_batched_tokens: 8192
+        compilation_config:
+          cudagraph_mode: PIECEWISE
+      - stage_id: 1
+        max_num_batched_tokens: 8192
+        compilation_config:
+          cudagraph_mode: PIECEWISE
diff --git a/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml b/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
new file mode 100644
index 000000000..75693feb7
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
@@ -0,0 +1,88 @@
+# MiniCPM-o 4.5 two-GPU continuous-batching layout.
+#
+# Thinker owns GPU 0. Talker and Code2Wav share GPU 1, keeping text decoding
+# isolated from codec/vocoder contention while preserving stage-2 batching.
+pipeline: minicpmo_4_5
+async_chunk: true
+
+trust_remote_code: true
+enable_prefix_caching: false
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      codec_left_context_frames: 3
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.9
+    enforce_eager: false
+    tensor_parallel_size: 1
+    max_num_batched_tokens: 16384
+    devices: "0"
+    limit_mm_per_prompt:
+      video: 1
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 2048
+      seed: 42
+      detokenize: true
+      repetition_penalty: 1.1
+
+  - stage_id: 1
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.55
+    enforce_eager: false
+    max_num_batched_tokens: 8192
+    devices: "1"
+    output_connectors:
+      to_stage_2: connector_of_shared_memory
+    # Codec sampling is model-owned by the checkpoint's tts_config (defaults:
+    # T=0.8, top-k=25, top-p=0.85, repetition penalty=1.05, seed=42).
+    # These parameters only govern vLLM's binary continue/stop token.
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      min_tokens: 50
+      max_tokens: 2048
+      stop_token_ids: [1]
+      seed: 42
+      detokenize: false
+
+  - stage_id: 2
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.35
+    enforce_eager: true
+    enable_chunked_prefill: false
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "1"
+    input_connectors:
+      from_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      detokenize: true
+
+platforms:
+  npu:
+    stages:
+      - stage_id: 0
+        max_num_batched_tokens: 8192
+        compilation_config:
+          cudagraph_mode: PIECEWISE
+      - stage_id: 1
+        max_num_batched_tokens: 8192
+        compilation_config:
+          cudagraph_mode: PIECEWISE
diff --git a/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml b/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
index f5c0b03a6..9254d3c70 100644
--- a/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
@@ -1,23 +1,31 @@
-# MiniCPM-o 4.5 deploy: 3-GPU layout (thinker TP=2 + talker on GPU 2).
+# MiniCPM-o 4.5 three-stage deploy with one GPU per stage.
 #
-# Stage 0 (thinker): GPU 0,1 — 2-way tensor parallel, ~70% mem each.
-# Stage 1 (talker) : GPU 2   — MiniCPMTTS + Token2Wav, ~75% mem
-#                              (covers both the talker LM and the in-process
-#                              Token2Wav vocoder that emits the waveform).
+# This replaces the former fused two-stage layout: Thinker, Talker, and
+# Code2Wav run independently on GPUs 0, 1, and 2.
 pipeline: minicpmo_4_5
-async_chunk: false
+async_chunk: true
 
 trust_remote_code: true
 enable_prefix_caching: false
 
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      codec_left_context_frames: 3
+
 stages:
   - stage_id: 0
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.7
-    enforce_eager: true
-    tensor_parallel_size: 2
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.9
+    enforce_eager: false
+    tensor_parallel_size: 1
     max_num_batched_tokens: 16384
-    devices: "0,1"
+    devices: "0"
     limit_mm_per_prompt:
       video: 1
     default_sampling_params:
@@ -30,19 +38,40 @@ stages:
       repetition_penalty: 1.1
 
   - stage_id: 1
-    # Talker only consumes runtime_additional_information[0]; any value > 1
-    # makes concurrent requests share request-0's audio (mm_outputs fallback).
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.75
-    enforce_eager: true
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.9
+    enforce_eager: false
     max_num_batched_tokens: 8192
-    devices: "2"
+    devices: "1"
+    output_connectors:
+      to_stage_2: connector_of_shared_memory
+    # vLLM samples the binary continue/stop row; codec sampling comes from
+    # the checkpoint's tts_config and currently uses a deterministic seed.
     default_sampling_params:
       temperature: 0.0
       top_p: 1.0
       top_k: -1
-      max_tokens: 1
+      min_tokens: 50
+      max_tokens: 2048
+      stop_token_ids: [1]
       seed: 42
       detokenize: false
 
+  - stage_id: 2
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.9
+    enforce_eager: true
+    enable_chunked_prefill: false
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "2"
+    input_connectors:
+      from_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      detokenize: true
+
 platforms: {}
diff --git a/vllm_omni/deploy/minicpmo_4_5_3gpu_stage1_replicas.yaml b/vllm_omni/deploy/minicpmo_4_5_3gpu_stage1_replicas.yaml
new file mode 100644
index 000000000..7a0513167
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_3gpu_stage1_replicas.yaml
@@ -0,0 +1,24 @@
+# Experimental validation profile: one thinker and two Stage1 replicas.
+# This is not a recommended production entrypoint.
+#
+# Stage 0: GPU 0
+# Stage 1: replicas on GPU 1 and 2
+base_config: minicpmo_4_5.yaml
+pipeline: minicpmo_4_5
+session_mode: duplex
+
+stages:
+  - stage_id: 0
+    async_scheduling: false
+
+  - stage_id: 1
+    devices: "1,2"
+    num_replicas: 2
+    async_scheduling: false
+
+platforms:
+  cuda:
+    stages:
+      - stage_id: 1
+        # Stage 1 has dedicated GPUs in this profile; retain automatic sizing.
+        kv_cache_memory_bytes: null
diff --git a/vllm_omni/deploy/minicpmo_4_5_4gpu_stage1_replicas.yaml b/vllm_omni/deploy/minicpmo_4_5_4gpu_stage1_replicas.yaml
new file mode 100644
index 000000000..da28456fe
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_4gpu_stage1_replicas.yaml
@@ -0,0 +1,24 @@
+# Experimental validation profile: one thinker and three Stage1 replicas.
+# This is not a recommended production entrypoint.
+#
+# Stage 0: GPU 0
+# Stage 1: replicas on GPU 1, 2, and 3
+base_config: minicpmo_4_5.yaml
+pipeline: minicpmo_4_5
+session_mode: duplex
+
+stages:
+  - stage_id: 0
+    async_scheduling: false
+
+  - stage_id: 1
+    devices: "1,2,3"
+    num_replicas: 3
+    async_scheduling: false
+
+platforms:
+  cuda:
+    stages:
+      - stage_id: 1
+        # Stage 1 has dedicated GPUs in this profile; retain automatic sizing.
+        kv_cache_memory_bytes: null
diff --git a/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml b/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
index dd249c70a..1b38059a3 100644
--- a/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
@@ -4,10 +4,8 @@
 #                                  thinker weights take ~17.5 GB per card
 #                                  on 4090, leaving ~3 GB for KV cache /
 #                                  activations).
-# Stage 1 (talker) : GPU 4       — MiniCPMTTS + Token2Wav, ~90% mem
-#                                  (covers both the talker LM and the
-#                                  in-process Token2Wav vocoder that emits
-#                                  the waveform).
+# Stage 1 (talker) : GPU 4       — MiniCPMTTS codec generation, ~90% mem.
+# Stage 2 (code2wav): GPU 5      — codec-to-waveform generation, ~90% mem.
 #
 # max_model_len is pinned to 4096 because the upstream config.json
 # advertises max_position_embeddings=40960 (tuned for H20 141GB); on a
@@ -16,11 +14,21 @@
 # this thinker model + vision/audio encoders + Whisper preallocation,
 # so 4096 is the empirically-verified safe ceiling.
 pipeline: minicpmo_4_5
-async_chunk: false
+async_chunk: true
 
 trust_remote_code: true
 enable_prefix_caching: false
 
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      codec_left_context_frames: 3
+
 stages:
   - stage_id: 0
     max_num_seqs: 1
@@ -42,19 +50,40 @@ stages:
       repetition_penalty: 1.1
 
   - stage_id: 1
-    # Talker only consumes runtime_additional_information[0]; any value > 1
-    # makes concurrent requests share request-0's audio (mm_outputs fallback).
     max_num_seqs: 1
     gpu_memory_utilization: 0.9
     enforce_eager: true
     max_num_batched_tokens: 8192
     devices: "4"
+    output_connectors:
+      to_stage_2: connector_of_shared_memory
+    # vLLM samples the binary continue/stop row; codec sampling comes from
+    # the checkpoint's tts_config and currently uses a deterministic seed.
     default_sampling_params:
       temperature: 0.0
       top_p: 1.0
       top_k: -1
-      max_tokens: 1
+      min_tokens: 50
+      max_tokens: 2048
+      stop_token_ids: [1]
       seed: 42
       detokenize: false
 
+  - stage_id: 2
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.9
+    enforce_eager: true
+    enable_chunked_prefill: false
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "5"
+    input_connectors:
+      from_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      detokenize: true
+
 platforms: {}
diff --git a/vllm_omni/deploy/minicpmo_4_5_8x4090_stage1_replicas.yaml b/vllm_omni/deploy/minicpmo_4_5_8x4090_stage1_replicas.yaml
new file mode 100644
index 000000000..f4ad2c6b4
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_8x4090_stage1_replicas.yaml
@@ -0,0 +1,20 @@
+# Experimental validation profile: 4-way thinker TP and four Stage1 replicas.
+# This is not a recommended production entrypoint.
+#
+# Stage 0: GPU 0, 1, 2, and 3
+# Stage 1: replicas on GPU 4, 5, 6, and 7
+base_config: minicpmo_4_5_8x4090.yaml
+pipeline: minicpmo_4_5
+session_mode: duplex
+
+stages:
+  - stage_id: 0
+    async_scheduling: false
+    gpu_memory_utilization: 0.40
+    max_num_batched_tokens: 16384
+
+  - stage_id: 1
+    devices: "4,5,6,7"
+    num_replicas: 4
+    async_scheduling: false
+    gpu_memory_utilization: 0.8
diff --git a/vllm_omni/deploy/minicpmo_4_5_duplex.yaml b/vllm_omni/deploy/minicpmo_4_5_duplex.yaml
new file mode 100644
index 000000000..d8ae8aebe
--- /dev/null
+++ b/vllm_omni/deploy/minicpmo_4_5_duplex.yaml
@@ -0,0 +1,39 @@
+# MiniCPM-o 4.5 native duplex deployment.
+#
+# The registered minicpmo_4_5 pipeline owns the fixed
+# Thinker -> Talker -> Code2Wav topology. This overlay changes session
+# lifetime and bounds all three stages to two live duplex sessions.
+base_config: minicpmo_4_5.yaml
+pipeline: minicpmo_4_5
+session_mode: duplex
+active_stream_window: 1
+duplex_session:
+  idle_ttl_s: 300
+  disconnect_grace_s: 30
+  reaper_interval_s: 5
+  resume_replay_ttl_s: 60
+  resume_replay_max_bytes_per_session: 8388608
+  max_pending_input_bytes_per_session: 16777216
+  max_pending_turns_per_session: 4
+  # Matches the configured Stage0/Stage1 sequence capacity below.
+  max_sessions: 2
+  completed_append_cache_size: 256
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 2
+    async_scheduling: false
+
+  - stage_id: 1
+    max_num_seqs: 2
+    async_scheduling: false
+    # The split Talker exposes a binary continue/stop vocabulary; native
+    # segment and turn boundaries travel as explicit output metadata.
+    default_sampling_params:
+      max_tokens: 2048
+      min_tokens: 0
+      stop_token_ids: [1]
+
+  - stage_id: 2
+    max_num_seqs: 2
+    async_scheduling: false
diff --git a/vllm_omni/deploy/moss_sound_effect.yaml b/vllm_omni/deploy/moss_sound_effect.yaml
index 0fe616290..1dcf0d42f 100644
--- a/vllm_omni/deploy/moss_sound_effect.yaml
+++ b/vllm_omni/deploy/moss_sound_effect.yaml
@@ -10,7 +10,6 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/moss_tts.yaml b/vllm_omni/deploy/moss_tts.yaml
index b1549d0d0..92bd2f3ba 100644
--- a/vllm_omni/deploy/moss_tts.yaml
+++ b/vllm_omni/deploy/moss_tts.yaml
@@ -8,7 +8,6 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/moss_tts_80gb.yaml b/vllm_omni/deploy/moss_tts_80gb.yaml
new file mode 100644
index 000000000..57dcbc1df
--- /dev/null
+++ b/vllm_omni/deploy/moss_tts_80gb.yaml
@@ -0,0 +1,63 @@
+# Single-80GB variant of moss_tts.yaml (see #4643): lowers stage-0
+# gpu_memory_utilization and disables codec FlashInfer autotune so both
+# stages initialize on one H100/H800 80GB at full max_model_len.
+# MOSS-TTS (MossTTSDelayModel, 8B, n_vq=32, 24 kHz)
+# HF: OpenMOSS-Team/MOSS-TTS
+# General-purpose TTS with voice cloning. Production-recommended variant.
+async_chunk: true
+trust_remote_code: true  # OpenMOSS-Team/MOSS-TTS ships custom modeling code
+
+connectors:
+  shm:
+    name: SharedMemoryConnector
+    extra:
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      codec_chunk_frames: 25
+      codec_left_context_frames: 0
+      decode_cudagraph_capture_sizes: [4, 8, 16, 25, 32, 50, 64, 100, 128, 200, 256]
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 4
+    gpu_memory_utilization: 0.60
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 4096
+    max_model_len: 4096
+    devices: "0"
+    output_connectors:
+      to_stage_1: shm
+    default_sampling_params:
+      temperature: 1.7
+      top_p: 0.8
+      top_k: 25
+      max_tokens: 4096
+      seed: 42
+      repetition_penalty: 1.0
+      stop_token_ids: [151645]  # <|im_end|> — terminates the talker AR loop
+
+  - stage_id: 1
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.12
+    enforce_eager: true
+    enable_flashinfer_autotune: false
+    enable_prefix_caching: false
+    async_scheduling: true
+    # Talker can emit up to max_tokens=4096 frames × n_vq=32 = 131072 codec
+    # tokens per request; cap codec stage above that so a single long output
+    # doesn't trigger "could not broadcast (>65536,) into (65536,)".
+    max_num_batched_tokens: 196608
+    max_model_len: 196608
+    devices: "0"
+    input_connectors:
+      from_stage_0: shm
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      seed: 42
+      repetition_penalty: 1.0
diff --git a/vllm_omni/deploy/moss_tts_local.yaml b/vllm_omni/deploy/moss_tts_local.yaml
index 1455ccc09..2ed937e0a 100644
--- a/vllm_omni/deploy/moss_tts_local.yaml
+++ b/vllm_omni/deploy/moss_tts_local.yaml
@@ -9,25 +9,25 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
-      codec_streaming: true
       connector_get_sleep_s: 0.005
       connector_get_max_wait_first_chunk: 1000
       connector_get_max_wait: 300
       initial_codec_chunk_frames: 1   # 1 frame * 80 ms/frame = 80 ms first audio chunk
       codec_chunk_frames: 15          # 15 frames * 80 ms/frame = 1.2 s steady chunks
       codec_left_context_frames: 0
-      codec_stream_slots: 8
 
 stages:
   - stage_id: 0
-    max_num_seqs: 8
+    max_num_seqs: 64
     gpu_memory_utilization: 0.60
     enable_prefix_caching: false
     async_scheduling: true
-    max_num_batched_tokens: 4096
+    max_num_batched_tokens: 65536
     max_model_len: 4096
     devices: "0"
+    # profiler_config:
+    #   profiler: torch
+    #   torch_profiler_dir: /root/vllm-omni-workspace/vllm-omni/results/moss_local_stage0/batch_8
     output_connectors:
       to_stage_1: shm
     default_sampling_params:
@@ -39,11 +39,19 @@ stages:
       repetition_penalty: 1.1
 
   - stage_id: 1
-    max_num_seqs: 8
-    gpu_memory_utilization: 0.15
-    enforce_eager: true
+    max_num_seqs: 64
+    gpu_memory_utilization: 0.30
+    enforce_eager: false
     enable_prefix_caching: false
     async_scheduling: true
+    compilation_config:
+      # Reused by the codec as execution-batch buckets; T is derived from
+      # initial_codec_chunk_frames and codec_chunk_frames.
+      cudagraph_capture_sizes: [1, 2, 4, 8, 16, 32, 64]
+      cudagraph_num_of_warmups: 1
+    # profiler_config:
+    #   profiler: torch
+    #   torch_profiler_dir: /root/vllm-omni-workspace/vllm-omni/results/moss_local_stage1/batch_8
     max_num_batched_tokens: 65536
     max_model_len: 65536
     devices: "0"
diff --git a/vllm_omni/deploy/moss_tts_realtime.yaml b/vllm_omni/deploy/moss_tts_realtime.yaml
index b7909661a..ca63161e2 100644
--- a/vllm_omni/deploy/moss_tts_realtime.yaml
+++ b/vllm_omni/deploy/moss_tts_realtime.yaml
@@ -11,7 +11,6 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.005
       connector_get_max_wait_first_chunk: 1000
diff --git a/vllm_omni/deploy/moss_ttsd.yaml b/vllm_omni/deploy/moss_ttsd.yaml
index f0b5f6eae..3ffba8678 100644
--- a/vllm_omni/deploy/moss_ttsd.yaml
+++ b/vllm_omni/deploy/moss_ttsd.yaml
@@ -8,7 +8,6 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/moss_voice_generator.yaml b/vllm_omni/deploy/moss_voice_generator.yaml
index 010f04205..fa3cd91af 100644
--- a/vllm_omni/deploy/moss_voice_generator.yaml
+++ b/vllm_omni/deploy/moss_voice_generator.yaml
@@ -10,7 +10,6 @@ connectors:
   shm:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
diff --git a/vllm_omni/deploy/personaplex.yaml b/vllm_omni/deploy/personaplex.yaml
new file mode 100644
index 000000000..9f1da7e63
--- /dev/null
+++ b/vllm_omni/deploy/personaplex.yaml
@@ -0,0 +1,90 @@
+# PersonaPlex deploy: talker -> code2wav (Mimi) via shared-memory chunk streaming.
+#
+# PersonaPlex is a Moshi finetune (full-duplex S2S), served offline as a 2-stage
+# audio->audio pipeline that reuses the Qwen3-TTS staged deploy layout. Fields
+# omitted from a stage fall back to StageDeployConfig defaults (see
+# vllm_omni/config/stage_config.py).
+#
+# Notable choices for this model:
+#   * Stage 0 (talker) keeps a small max_num_batched_tokens for async-chunk
+#     first-chunk latency (not correctness).
+#   * Stage 1 (code2wav) wraps the external Mimi codec. Each codec frame is
+#     8 active codebooks (cb 0..7) -> 1920 PCM samples @ 24 kHz / 12.5 Hz.
+#   * Stage 0 runs cudagraph by default; Stage 1 (Mimi) is eager because the
+#     external decoder performs host-to-device copies that cannot be captured.
+pipeline: personaplex
+session_mode: duplex
+duplex_session:
+  max_sessions: 2
+
+async_chunk: true
+
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      shm_threshold_bytes: 65536
+      codec_streaming: true
+      connector_get_sleep_s: 0.01
+      connector_get_max_wait_first_chunk: 3000
+      connector_get_max_wait: 300
+      # Mimi runs at 12.5 Hz (80 ms / frame). Stream a few frames per chunk.
+      codec_chunk_frames: 5
+      codec_left_context_frames: 10
+      # Emit only the first audio chunk early, then return to codec_chunk_frames.
+      initial_codec_chunk_frames: 1
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 10
+    gpu_memory_utilization: 0.4
+    trust_remote_code: true
+    skip_tokenizer_init: true
+    # Prompt IDs are placeholders; voice/persona/audio semantics live in
+    # request-specific embeddings, so token-ID prefix caching is invalid.
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 512
+    # Temporal transformer sliding_window is 3000 frames; keep model len within.
+    max_model_len: 3000
+    devices: "0"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      # Greedy talker decoding: the HeliumModel temporal matches Moshi within cos
+      # 0.999 (not bit-exact), and chaotic sampling amplifies that into divergence.
+      # Greedy is reliably coherent; raise temperature only once the temporal is
+      # bit-exact.
+      temperature: 0.0
+      top_k: 1
+      max_tokens: 3000
+      seed: 42
+      repetition_penalty: 1.0
+
+  - stage_id: 1
+    max_num_seqs: 10
+    gpu_memory_utilization: 0.3
+    enforce_eager: true
+    trust_remote_code: true
+    skip_tokenizer_init: true
+    enable_prefix_caching: false
+    async_scheduling: true
+    # Codec prefill length is num_codebooks * num_frames; keep ample headroom.
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "0"
+    input_connectors:
+      from_stage_0: connector_of_shared_memory
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
+      seed: 42
+      repetition_penalty: 1.0
+
+platforms:
+  npu:
+    stages:
+      - stage_id: 0
+        enforce_eager: false
diff --git a/vllm_omni/deploy/qwen3_omni_moe_thinking.yaml b/vllm_omni/deploy/qwen3_omni_moe_thinking.yaml
new file mode 100644
index 000000000..7ccc64750
--- /dev/null
+++ b/vllm_omni/deploy/qwen3_omni_moe_thinking.yaml
@@ -0,0 +1,21 @@
+# Deploy config for Qwen3-Omni-MoE thinker-only checkpoints.
+# Verified on 2x H100-80G GPUs.
+pipeline: qwen3_omni_moe
+distributed_executor_backend: mp
+enable_prefix_caching: true
+
+stages:
+  - stage_id: 0
+    devices: "0,1"
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.9
+    enforce_eager: true
+    async_scheduling: false
+    tensor_parallel_size: 2
+    default_sampling_params:
+      temperature: 0.4
+      top_p: 0.9
+      top_k: 1
+      max_tokens: 2048
+      seed: 42
+      repetition_penalty: 1.05
diff --git a/vllm_omni/deploy/qwen3_tts.yaml b/vllm_omni/deploy/qwen3_tts.yaml
index f27da1b5b..ad154bed2 100644
--- a/vllm_omni/deploy/qwen3_tts.yaml
+++ b/vllm_omni/deploy/qwen3_tts.yaml
@@ -17,7 +17,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
@@ -27,6 +26,13 @@ connectors:
       codec_left_context_frames: 72
       # Emit only the first audio chunk early, then return to codec_chunk_frames.
       initial_codec_chunk_frames: 1
+      # Chunk ramp (opt-in): gradual size increase for first N chunks to
+      # eliminate the IC→steady cliff (1→25). Uncomment to enable.
+      # Each entry is the size of that chunk index; indices past the table
+      # fall back to codec_chunk_frames. When enabled, ramp overrides
+      # initial_codec_chunk_frames (including the per-request API field).
+      # Example:
+      #   codec_chunk_ramp: [4, 4, 8, 16, 25]
       # Common Stage1 decode buckets:
           #   no-ref first/steady chunks: 25 / 97 frames
           #   Base ref-context first/steady chunks: 73 / 169 frames
@@ -91,6 +97,13 @@ stages:
       repetition_penalty: 1.0
 
 platforms:
+  rocm:
+    stages:
+      - stage_id: 1
+        # MIOpen Conv1d cannot be invoked while vLLM captures the outer
+        # Code2Wav model graph. Keep CUDA's graph-enabled default, but run
+        # Stage 1 eager on ROCm so decoder convolutions execute normally.
+        enforce_eager: true
   npu:
     stages:
       - stage_id: 0
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
index 939396840..25bac72c0 100644
--- a/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
+++ b/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
@@ -15,7 +15,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
@@ -32,6 +31,13 @@ connectors:
       ref_code_context_frames: 72
       # Emit only the first audio chunk early, then return to codec_chunk_frames.
       initial_codec_chunk_frames: 1
+      # Chunk ramp (opt-in): gradual size increase for first N chunks to
+      # eliminate the IC→steady cliff (1→25). Uncomment to enable.
+      # Each entry is the size of that chunk index; indices past the table
+      # fall back to codec_chunk_frames. When enabled, ramp overrides
+      # initial_codec_chunk_frames (including the per-request API field).
+      # Example:
+      #   codec_chunk_ramp: [4, 4, 8, 16, 25]
       # Common Stage1 decode buckets:
       #   no-ref first/steady chunks: 25 / 97 frames
       #   Base ref-context first/steady chunks: 73 / 169 frames
diff --git a/vllm_omni/deploy/step_audio2_ci.yaml b/vllm_omni/deploy/step_audio2_ci.yaml
new file mode 100644
index 000000000..4373dfaa8
--- /dev/null
+++ b/vllm_omni/deploy/step_audio2_ci.yaml
@@ -0,0 +1,31 @@
+# Step-Audio2 online CI deploy: thinker only (audio/text -> text).
+#
+# The two-stage topology can deadlock when an audio-to-text request skips the
+# Token2Wav stage, so this config explicitly selects the ASR pipeline.
+# Keeps the legacy 1x 24GB CI sizing; validated here on 1x H100-80GB.
+pipeline: step_audio_2_asr
+async_chunk: false
+trust_remote_code: true
+enable_prefix_caching: false
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    tensor_parallel_size: 1
+    max_model_len: 1024
+    max_num_batched_tokens: 1024
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.7
+    skip_mm_profiling: true
+    enforce_eager: true
+    async_scheduling: false
+    hf_overrides:
+      architectures: ["StepAudio2ThinkerForConditionalGeneration"]
+    default_sampling_params:
+      temperature: 0.7
+      top_p: 0.9
+      top_k: -1
+      max_tokens: 256
+      seed: 42
+      detokenize: true
+      repetition_penalty: 1.05
diff --git a/vllm_omni/deploy/step_audio_2.yaml b/vllm_omni/deploy/step_audio_2.yaml
new file mode 100644
index 000000000..d225e9741
--- /dev/null
+++ b/vllm_omni/deploy/step_audio_2.yaml
@@ -0,0 +1,39 @@
+# Step-Audio2 deploy: thinker -> token2wav.
+#
+# Sequential mode waits for the full Thinker output before running Token2Wav.
+async_chunk: false
+trust_remote_code: true
+enable_prefix_caching: false
+
+stages:
+  - stage_id: 0
+    devices: "0,1"
+    tensor_parallel_size: 2
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.7
+    enforce_eager: true
+    async_scheduling: false
+    max_num_batched_tokens: 8192
+    default_sampling_params:
+      temperature: 0.7
+      top_p: 0.9
+      top_k: -1
+      max_tokens: 1024
+      seed: 42
+      repetition_penalty: 1.05
+
+  - stage_id: 1
+    devices: "1"
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.2
+    enforce_eager: true
+    async_scheduling: false
+    max_num_batched_tokens: 4096
+    hf_overrides:
+      architectures: ["StepAudio2Token2WavForConditionalGeneration"]
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 1
+      seed: 42
diff --git a/vllm_omni/deploy/step_audio_2_asr.yaml b/vllm_omni/deploy/step_audio_2_asr.yaml
new file mode 100644
index 000000000..0eb0a8523
--- /dev/null
+++ b/vllm_omni/deploy/step_audio_2_asr.yaml
@@ -0,0 +1,22 @@
+# Step-Audio2 ASR deploy: thinker only.
+pipeline: step_audio_2_asr
+async_chunk: false
+trust_remote_code: true
+enable_prefix_caching: false
+
+stages:
+  - stage_id: 0
+    devices: "0,1"
+    tensor_parallel_size: 2
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.8
+    enforce_eager: true
+    async_scheduling: false
+    max_num_batched_tokens: 2048
+    default_sampling_params:
+      temperature: 0.7
+      top_p: 0.9
+      top_k: -1
+      max_tokens: 1024
+      seed: 42
+      repetition_penalty: 1.05
diff --git a/vllm_omni/deploy/step_audio_2_async_chunk.yaml b/vllm_omni/deploy/step_audio_2_async_chunk.yaml
new file mode 100644
index 000000000..75b5cf901
--- /dev/null
+++ b/vllm_omni/deploy/step_audio_2_async_chunk.yaml
@@ -0,0 +1,37 @@
+# Step-Audio2 deploy: thinker -> token2wav with async chunk streaming.
+async_chunk: true
+trust_remote_code: true
+enable_prefix_caching: false
+
+stages:
+  - stage_id: 0
+    devices: "0,1"
+    tensor_parallel_size: 2
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.7
+    enforce_eager: true
+    async_scheduling: false
+    max_num_batched_tokens: 1024
+    default_sampling_params:
+      temperature: 0.7
+      top_p: 0.9
+      top_k: -1
+      max_tokens: 1024
+      seed: 42
+      repetition_penalty: 1.05
+
+  - stage_id: 1
+    devices: "1"
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.2
+    enforce_eager: true
+    async_scheduling: false
+    max_num_batched_tokens: 2048
+    hf_overrides:
+      architectures: ["StepAudio2Token2WavForConditionalGeneration"]
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 1
+      seed: 42
diff --git a/vllm_omni/deploy/voxtral_tts.yaml b/vllm_omni/deploy/voxtral_tts.yaml
index 929daddb1..5524c5cc8 100644
--- a/vllm_omni/deploy/voxtral_tts.yaml
+++ b/vllm_omni/deploy/voxtral_tts.yaml
@@ -10,7 +10,6 @@ connectors:
   connector_of_shared_memory:
     name: SharedMemoryConnector
     extra:
-      shm_threshold_bytes: 65536
       codec_streaming: true
       connector_get_sleep_s: 0.01
       connector_get_max_wait_first_chunk: 3000
@@ -70,3 +69,14 @@ stages:
     config_format: mistral
     load_format: mistral
     skip_mm_profiling: true
+
+platforms:
+  xpu:
+    stages:
+      - stage_id: 0
+        enforce_eager: true
+        gpu_memory_utilization: 0.7
+        distributed_executor_backend: "mp"
+      - stage_id: 1
+        gpu_memory_utilization: 0.28
+        distributed_executor_backend: "mp"
diff --git a/vllm_omni/deploy/wan2_2_ti2v.yaml b/vllm_omni/deploy/wan2_2_ti2v.yaml
new file mode 100644
index 000000000..bdb5cfecb
--- /dev/null
+++ b/vllm_omni/deploy/wan2_2_ti2v.yaml
@@ -0,0 +1,17 @@
+# Wan2.2 TI2V-5B deploy.
+#
+# Single GPU by default. Increase tensor_parallel_size and devices for A14B MoE variants.
+async_chunk: false
+trust_remote_code: true
+distributed_executor_backend: mp
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    max_num_seqs: 1
+    tensor_parallel_size: 1
+    enforce_eager: true
+    # Keep VAE tiling on by default for higher resolutions / longer clips.
+    vae_use_tiling: true
+    default_sampling_params:
+      seed: 42
diff --git a/vllm_omni/diffusion/attention/backends/abstract.py b/vllm_omni/diffusion/attention/backends/abstract.py
index cd0408f3c..68e152063 100644
--- a/vllm_omni/diffusion/attention/backends/abstract.py
+++ b/vllm_omni/diffusion/attention/backends/abstract.py
@@ -14,6 +14,26 @@ class AttentionBackend(ABC):
     """Abstract class for diffusion attention backends."""
 
     accept_output_buffer: bool = False
+    supports_piecewise_spans: bool = False
+    # The backend can represent a contiguous valid K/V prefix by slicing the
+    # tensors instead of materializing a padding mask. Models may use this to
+    # avoid a slower masked-attention plan when tail padding is not semantic.
+    supports_prefix_kv_slicing: bool = False
+
+    # ``OmniPlatformEnum`` values this backend runs on; None means unrestricted.
+    # Platform resolution rejects an explicit selection outside this set, so a
+    # hardware-specific backend fails before the model is built.
+    supported_platforms: tuple[str, ...] | None = None
+
+    @classmethod
+    def validate_available(cls) -> None:
+        """Raise if this backend's optional dependencies are missing.
+
+        Called during platform resolution, i.e. before model construction, so a
+        backend that probes its kernel package lazily still reports the problem
+        while the user can still act on it.
+        """
+        return None
 
     @classmethod
     def supports_attention_mask(cls) -> bool:
@@ -51,6 +71,30 @@ class AttentionBackend(ABC):
         return (not supported_head_sizes) or head_size in supported_head_sizes
 
 
+@dataclass(frozen=True, slots=True)
+class QueryRange:
+    local_start: int
+    local_end: int
+    global_start: int
+
+
+@dataclass(frozen=True, slots=True)
+class VideoTokenLayout:
+    """Where the video segment sits inside a packed multimodal sequence.
+
+    A model that packs its sequence as ``[prefix | t*h*w video rows | padding]``
+    publishes this so backends can recover spatiotemporal locality; the prefix
+    holds everything that is not video (text, visual conditions, audio).
+    Publishing it also asserts that any ``attn_mask`` masks only the trailing
+    padding, so ``prefix_len + t*h*w`` is the used length of the sequence.
+
+    Plain ints, so reading it never forces a device-to-host sync.
+    """
+
+    prefix_len: int
+    latent_grid: tuple[int, int, int]
+
+
 @dataclass
 class AttentionMetadata:
     attn_mask: torch.Tensor | None = None
@@ -71,10 +115,21 @@ class AttentionMetadata:
     # Well-known optional keys (convention, not required on all forwards):
     #   "kv_cache_dtype": str | None — quantized KV dtype (e.g. "fp8"); backends
     #     decide whether/how to apply.
+    #   "cu_seqlens_q" / "cu_seqlens_k": int32 CUDA tensors describing packed
+    #     variable-length query/key sequences for FlashAttention.
+    #   "max_seqlen_q" / "max_seqlen_k": maximum sequence lengths paired with
+    #     the packed cu_seqlens tensors.
+    #   "valid_kv_length": int — contiguous valid K/V prefix length for a
+    #     backend that advertises supports_prefix_kv_slicing.
 
     # Piecewise attention metadata (mixed causal/full masks).
     # full_attn_spans: per-sample [start, end) spans in global coordinates using full attention.
     full_attn_spans: list[list[tuple[int, int]]] | None = None
+    query_ranges: tuple[QueryRange, ...] | None = None
+
+    # Geometry of the video segment for backends that exploit spatiotemporal
+    # locality (block-sparse selection, tiled masks). Dense backends ignore it.
+    video_layout: VideoTokenLayout | None = None
 
 
 T = TypeVar("T", bound=AttentionMetadata)
diff --git a/vllm_omni/diffusion/attention/backends/cudnn_attn.py b/vllm_omni/diffusion/attention/backends/cudnn_attn.py
index 357a2c0fd..ffcc2fb44 100644
--- a/vllm_omni/diffusion/attention/backends/cudnn_attn.py
+++ b/vllm_omni/diffusion/attention/backends/cudnn_attn.py
@@ -17,6 +17,7 @@ logger = init_logger(__name__)
 
 class CuDNNAttentionBackend(AttentionBackend):
     accept_output_buffer: bool = True
+    supports_prefix_kv_slicing: bool = True
 
     @classmethod
     def supports_attention_mask(cls) -> bool:
@@ -51,7 +52,6 @@ class CuDNNAttentionImpl(AttentionImpl):
     ) -> None:
         self.causal = causal
         self.softmax_scale = softmax_scale
-        self.requires_gqa = num_heads != num_kv_heads
 
     def forward_cuda(
         self,
@@ -62,8 +62,28 @@ class CuDNNAttentionImpl(AttentionImpl):
     ) -> torch.Tensor:
         attention_mask = None
         if attn_metadata:
-            attention_mask = _maybe_reshape_attn_mask(query, key, attn_metadata.attn_mask, mask_mode="broadcast_k")
+            valid_kv_length = attn_metadata.extra.get("valid_kv_length")
+            if attn_metadata.attn_mask is None and isinstance(valid_kv_length, int):
+                if not 0 < valid_kv_length <= key.shape[1]:
+                    raise ValueError(
+                        "valid_kv_length must be within the K/V sequence, "
+                        f"got {valid_kv_length} for length {key.shape[1]}"
+                    )
+                # A contiguous valid prefix is mathematically equivalent to a
+                # broadcast key-padding mask. Slicing K/V keeps Q/output in the
+                # checkpoint's aligned layout while letting cuDNN select its
+                # much faster mask-free FMHA plan.
+                key = key[:, :valid_kv_length]
+                value = value[:, :valid_kv_length]
+            else:
+                attention_mask = _maybe_reshape_attn_mask(
+                    query,
+                    key,
+                    attn_metadata.attn_mask,
+                    mask_mode="broadcast_k",
+                )
 
+        enable_gqa = query.shape[2] != key.shape[2]
         query, key, value = (x.permute(0, 2, 1, 3) for x in (query, key, value))
         # Pin cuDNN exclusively. A priority list like [CUDNN, FLASH, MATH] hits a
         # PyTorch SDPA dispatch quirk: when FLASH rejects a non-None attn_mask,
@@ -85,7 +105,7 @@ class CuDNNAttentionImpl(AttentionImpl):
                     dropout_p=0.0,
                     is_causal=self.causal,
                     scale=self.softmax_scale,
-                    enable_gqa=self.requires_gqa,
+                    enable_gqa=enable_gqa,
                 )
         except RuntimeError as e:
             if "No available kernel" not in str(e):
@@ -102,6 +122,6 @@ class CuDNNAttentionImpl(AttentionImpl):
                 dropout_p=0.0,
                 is_causal=self.causal,
                 scale=self.softmax_scale,
-                enable_gqa=self.requires_gqa,
+                enable_gqa=enable_gqa,
             )
         return output.permute(0, 2, 1, 3)
diff --git a/vllm_omni/diffusion/attention/backends/flash_attn.py b/vllm_omni/diffusion/attention/backends/flash_attn.py
index 19ec49417..467a9ad16 100644
--- a/vllm_omni/diffusion/attention/backends/flash_attn.py
+++ b/vllm_omni/diffusion/attention/backends/flash_attn.py
@@ -21,6 +21,7 @@ logger = init_logger(__name__)
 
 class FlashAttentionBackend(AttentionBackend):
     accept_output_buffer: bool = True
+    supports_piecewise_spans: bool = True
 
     @classmethod
     def supports_attention_mask(cls) -> bool:
@@ -82,6 +83,28 @@ class FlashAttentionImpl(AttentionImpl):
     def _flash_wrapper(q, k, v, *, attn_func, **kwargs):
         return FlashAttentionImpl._unwrap_flash_output(attn_func(q, k, v, **kwargs))
 
+    @staticmethod
+    def _flash_varlen_wrapper(q, k, v, *, attn_func, causal, softmax_scale, **kwargs):
+        """Call a varlen-only FlashAttention backend for a dense segment."""
+        del kwargs
+        batch_size, q_len = q.shape[:2]
+        k_len = k.shape[1]
+        cu_seqlens_q = torch.arange(0, (batch_size + 1) * q_len, q_len, dtype=torch.int32, device=q.device)
+        cu_seqlens_k = torch.arange(0, (batch_size + 1) * k_len, k_len, dtype=torch.int32, device=q.device)
+        out = attn_func(
+            q=q.flatten(0, 1),
+            k=k.flatten(0, 1),
+            v=v.flatten(0, 1),
+            cu_seqlens_q=cu_seqlens_q,
+            cu_seqlens_k=cu_seqlens_k,
+            max_seqlen_q=q_len,
+            max_seqlen_k=k_len,
+            causal=causal,
+            softmax_scale=softmax_scale,
+        )
+        out = FlashAttentionImpl._unwrap_flash_output(out)
+        return out.reshape(batch_size, q_len, *out.shape[1:])
+
     def _forward_varlen_masked(
         self,
         query: torch.Tensor,
@@ -118,6 +141,46 @@ class FlashAttentionImpl(AttentionImpl):
         out_unpad = self._unwrap_flash_output(out_unpad)
         return _pad_input(out_unpad, indices_q, query.size(0), query_length)
 
+    def _forward_varlen_packed(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        *,
+        cu_seqlens_q: torch.Tensor,
+        cu_seqlens_k: torch.Tensor,
+        max_seqlen_q: int,
+        max_seqlen_k: int,
+    ) -> torch.Tensor:
+        """Run FlashAttention directly on an already packed sequence.
+
+        Some diffusion transformers already maintain exact packed-document
+        boundaries. Reusing those boundaries avoids rebuilding boolean masks
+        and gathering/scattering Q/K/V in every attention layer.
+        """
+        from vllm_omni.diffusion.attention.backends.utils.fa import (
+            flash_attn_varlen_func,
+        )
+
+        if flash_attn_varlen_func is None:
+            raise ImportError("Packed variable-length attention requires flash_attn_varlen_func")
+        if query.shape[0] != 1 or key.shape[0] != 1 or value.shape[0] != 1:
+            raise ValueError("Packed variable-length attention currently requires batch size 1")
+
+        out = flash_attn_varlen_func(
+            q=query.flatten(0, 1),
+            k=key.flatten(0, 1),
+            v=value.flatten(0, 1),
+            cu_seqlens_q=cu_seqlens_q,
+            cu_seqlens_k=cu_seqlens_k,
+            max_seqlen_q=max_seqlen_q,
+            max_seqlen_k=max_seqlen_k,
+            causal=self.causal,
+            softmax_scale=self.softmax_scale,
+        )
+        out = self._unwrap_flash_output(out)
+        return out.reshape_as(query)
+
     def _forward_varlen_dense(
         self,
         query: torch.Tensor,
@@ -171,6 +234,7 @@ class FlashAttentionImpl(AttentionImpl):
         from vllm_omni.diffusion.attention.backends.utils.fa import (
             HAS_FLASH_ATTN,
             flash_attn_func,
+            flash_attn_varlen_func,
         )
 
         if not HAS_FLASH_ATTN:
@@ -182,14 +246,23 @@ class FlashAttentionImpl(AttentionImpl):
 
         attention_mask = attn_metadata.attn_mask if attn_metadata is not None else None
         full_attn_spans = attn_metadata.full_attn_spans if attn_metadata is not None else None
+        extra = attn_metadata.extra if attn_metadata is not None else {}
 
         # Try piecewise attention
         if full_attn_spans is not None:
             logger.debug("Using piecewise Flash Attention for mixed causal/full mask")
-            attn_func = partial(
-                FlashAttentionImpl._flash_wrapper,
-                attn_func=flash_attn_func,
-            )
+            if flash_attn_func is not None:
+                attn_func = partial(
+                    FlashAttentionImpl._flash_wrapper,
+                    attn_func=flash_attn_func,
+                )
+            elif flash_attn_varlen_func is not None:
+                attn_func = partial(
+                    FlashAttentionImpl._flash_varlen_wrapper,
+                    attn_func=flash_attn_varlen_func,
+                )
+            else:
+                raise ImportError("Piecewise FlashAttention requires a dense or varlen FlashAttention function")
 
             return piecewise_attn(
                 query,
@@ -198,6 +271,23 @@ class FlashAttentionImpl(AttentionImpl):
                 full_attn_spans,
                 self.softmax_scale,
                 attn_func,
+                query_ranges=attn_metadata.query_ranges,
+            )
+
+        packed_keys = ("cu_seqlens_q", "cu_seqlens_k", "max_seqlen_q", "max_seqlen_k")
+        present_packed_keys = [key for key in packed_keys if key in extra]
+        if present_packed_keys:
+            if len(present_packed_keys) != len(packed_keys):
+                missing = sorted(set(packed_keys) - set(present_packed_keys))
+                raise ValueError(f"Incomplete packed FlashAttention metadata; missing {missing}")
+            return self._forward_varlen_packed(
+                query,
+                key,
+                value,
+                cu_seqlens_q=extra["cu_seqlens_q"],
+                cu_seqlens_k=extra["cu_seqlens_k"],
+                max_seqlen_q=extra["max_seqlen_q"],
+                max_seqlen_k=extra["max_seqlen_k"],
             )
 
         if attention_mask is not None and torch.any(~attention_mask):
diff --git a/vllm_omni/diffusion/attention/backends/flash_attn_hub.py b/vllm_omni/diffusion/attention/backends/flash_attn_hub.py
index bce607888..73faa57a9 100644
--- a/vllm_omni/diffusion/attention/backends/flash_attn_hub.py
+++ b/vllm_omni/diffusion/attention/backends/flash_attn_hub.py
@@ -12,9 +12,7 @@ from vllm_omni.diffusion.attention.backends.abstract import (
     AttentionImpl,
     AttentionMetadata,
 )
-from vllm_omni.diffusion.attention.backends.utils.piecewise_attn import (
-    piecewise_attn,
-)
+from vllm_omni.diffusion.attention.backends.utils.piecewise_attn import piecewise_attn
 
 logger = init_logger(__name__)
 
@@ -78,6 +76,7 @@ def _run_varlen_dense(
 
 class FlashAttentionHubBackend(AttentionBackend):
     accept_output_buffer: bool = True
+    supports_piecewise_spans: bool = True
 
     @classmethod
     def supports_attention_mask(cls) -> bool:
@@ -214,6 +213,7 @@ class FlashAttentionHubImpl(AttentionImpl):
                 full_attn_spans,
                 self.softmax_scale,
                 attn_func,
+                query_ranges=attn_metadata.query_ranges,
             )
 
         if attention_mask is not None and torch.any(~attention_mask):
@@ -243,6 +243,7 @@ class FlashAttentionHubImpl(AttentionImpl):
 
 class FlashAttention3HubBackend(AttentionBackend):
     accept_output_buffer: bool = True
+    supports_piecewise_spans: bool = True
 
     @classmethod
     def supports_attention_mask(cls) -> bool:
@@ -379,6 +380,7 @@ class FlashAttention3HubImpl(AttentionImpl):
                 full_attn_spans,
                 self.softmax_scale,
                 attn_func,
+                query_ranges=attn_metadata.query_ranges,
             )
 
         if attention_mask is not None and torch.any(~attention_mask):
diff --git a/vllm_omni/diffusion/attention/backends/rainfusion_attn.py b/vllm_omni/diffusion/attention/backends/rainfusion_attn.py
new file mode 100644
index 000000000..10ab55991
--- /dev/null
+++ b/vllm_omni/diffusion/attention/backends/rainfusion_attn.py
@@ -0,0 +1,366 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from vllm.logger import init_logger
+from vllm.model_executor.models.utils import extract_layer_index
+
+from vllm_omni.diffusion.attention.backends.abstract import (
+    AttentionBackend,
+    AttentionImpl,
+    AttentionMetadata,
+)
+from vllm_omni.diffusion.attention.backends.flash_attn import FlashAttentionBackend
+from vllm_omni.diffusion.config import get_current_diffusion_config_or_none
+from vllm_omni.diffusion.forward_context import get_forward_context, is_forward_context_available
+
+logger = init_logger(__name__)
+
+# The rf_v2 kernel only implements a 128-token block.
+_BLOCK_SIZE = 128
+
+# Below this many video blocks, the pooling and gather that block selection adds
+# cost more than the QK work it removes, so stay dense.
+_MIN_VIDEO_BLOCKS = 32
+
+# rf_v2's ``input_layout`` describes the caller's tensors, and everything below
+# slices the sequence on dim 1. vLLM-Omni diffusion attention hands the impl
+# [B, S, N, D], so that is the only layout this backend accepts.
+_INPUT_LAYOUT = "BSND"
+
+# rf_v2 precision mode: 0 = high precision, 1 = high performance. Kept at the
+# precise setting because the sparsity knob is the intended perf lever, and on
+# A5 devices the kernel is routed to rf_v3, which overrides this anyway.
+_INNER_PRECISE = 0
+
+_WRONG_PLATFORM = (
+    "RAINFUSION_ATTN runs the MindIE-SD rf_v2 kernel and is available on Ascend NPU only. "
+    "Select FLASH_ATTN or TORCH_SDPA on this platform."
+)
+
+_MISSING_MINDIESD = (
+    "RAINFUSION_ATTN requires MindIE-SD. Please install MindIE-SD to enable RainFusion sparse "
+    "attention on Ascend NPU. For installation details, see https://gitcode.com/Ascend/MindIE-SD "
+    "Otherwise, use FlashAttention by setting DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN"
+)
+
+
+def _try_extract_layer_index(prefix: str) -> int | None:
+    if not prefix:
+        return None
+    try:
+        return extract_layer_index(prefix)
+    except (AssertionError, ValueError):
+        return None
+
+
+@dataclass(frozen=True)
+class RainFusionConfig:
+    """Resolved RainFusion controls for one attention layer.
+
+    ``sparsity`` is the nominal fraction of key blocks dropped per query block.
+    The realized sparsity is lower because rf_v2 always keeps the prefix rows and
+    the first-frame blocks. ``start_step`` and ``skip_layers`` are the accuracy
+    knobs: early denoise steps and specific DiT blocks stay dense.
+    """
+
+    sparsity: float = 0.0
+    start_step: int = 0
+    skip_layers: frozenset[int] = frozenset()
+
+    @classmethod
+    def from_backend_kwargs(cls, backend_kwargs: dict | None) -> RainFusionConfig:
+        bk = backend_kwargs or {}
+        return cls(
+            sparsity=float(bk.get("sparsity", 0.0)),
+            start_step=int(bk.get("start_step", 0)),
+            skip_layers=frozenset(bk.get("skip_layers") or ()),
+        )
+
+    @property
+    def enabled(self) -> bool:
+        return self.sparsity > 0.0
+
+
+@dataclass(frozen=True)
+class RainFusionPlan:
+    """Per-forward geometry handed to the rf_v2 kernel."""
+
+    prefix_len: int
+    used_len: int
+    latent_shape: list[int]
+
+
+class RainFusionAttentionBackend(AttentionBackend):
+    accept_output_buffer: bool = True
+    supported_platforms: tuple[str, ...] = ("npu",)
+
+    @classmethod
+    def validate_available(cls) -> None:
+        from importlib.util import find_spec
+
+        if find_spec("mindiesd") is None:
+            raise ValueError(_MISSING_MINDIESD)
+
+    @staticmethod
+    def get_supported_head_sizes() -> list[int]:
+        return [64, 96, 128, 192, 256]
+
+    @staticmethod
+    def get_name() -> str:
+        return "RAINFUSION_ATTN"
+
+    @staticmethod
+    def get_impl_cls() -> type[RainFusionAttentionImpl]:
+        return RainFusionAttentionImpl
+
+
+class RainFusionAttentionImpl(AttentionImpl):
+    """Block-sparse video attention via MindIE-SD RainFusion (rf_v2) on Ascend NPU.
+
+    Sparsity applies only to the video segment of a packed multimodal sequence,
+    whose extent the model publishes as ``AttentionMetadata.video_layout``. Every
+    other case — warmup denoise steps, exempt layers, a layer that does not declare
+    ``qkv_layout="BSND"``, sequences without a published video segment, video
+    segments too short to pay for block selection or not aligned to the kernel's
+    block size — delegates to FlashAttention, so a model can select this backend
+    unconditionally.
+    """
+
+    def __init__(
+        self,
+        num_heads: int,
+        head_size: int,
+        softmax_scale: float,
+        causal: bool = False,
+        num_kv_heads: int | None = None,
+        prefix: str = "",
+        qkv_layout: str | None = None,
+        backend_kwargs: dict[str, Any] | None = None,
+        **extra_impl_args,
+    ) -> None:
+        self.num_heads = num_heads
+        self.causal = causal
+        self.softmax_scale = softmax_scale
+        self.qkv_layout = qkv_layout
+
+        self.rainfusion = RainFusionConfig.from_backend_kwargs(backend_kwargs)
+        self.layer_idx = _try_extract_layer_index(prefix)
+
+        if self.rainfusion.enabled:
+            self._validate_parallel_config()
+            if causal:
+                raise ValueError(
+                    "RAINFUSION_ATTN does not support causal attention: rf_v2 selects key "
+                    "blocks by pooled relevance and cannot express a causal mask. Select "
+                    "FLASH_ATTN for causal roles."
+                )
+            if qkv_layout is not None and qkv_layout.upper() != _INPUT_LAYOUT:
+                raise ValueError(
+                    f"RAINFUSION_ATTN needs {_INPUT_LAYOUT} tensors to locate the video segment along "
+                    f"the sequence axis, but this layer declares qkv_layout={qkv_layout!r}. Select "
+                    "FLASH_ATTN for this role."
+                )
+
+        self.dense_fallback = FlashAttentionBackend.get_impl_cls()(
+            num_heads=num_heads,
+            head_size=head_size,
+            softmax_scale=softmax_scale,
+            causal=causal,
+            num_kv_heads=num_kv_heads,
+            prefix=prefix,
+            qkv_layout=qkv_layout,
+        )
+
+    def _validate_parallel_config(self) -> None:
+        config = get_current_diffusion_config_or_none()
+        parallel_config = getattr(config, "parallel_config", None)
+        ring_degree = getattr(parallel_config, "ring_degree", 1)
+        if ring_degree > 1:
+            # Ring gives each rank a slice of the sequence, so block selection
+            # would score only local keys and the layer bypasses the backend
+            # entirely (see Attention._run_ring_attention).
+            raise ValueError(
+                "RAINFUSION_ATTN is not compatible with ring sequence parallelism "
+                f"(ring_degree={ring_degree}): rf_v2 needs the whole key sequence to rank "
+                "blocks. Use Ulysses SP (ring_degree=1) instead."
+            )
+
+    def forward_cuda(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None = None,
+    ) -> torch.Tensor:
+        # ROCm and MUSA route through forward_cuda by default, so this covers them too.
+        raise NotImplementedError(_WRONG_PLATFORM)
+
+    def forward_xpu(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None = None,
+    ) -> torch.Tensor:
+        raise NotImplementedError(_WRONG_PLATFORM)
+
+    def forward_npu(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None = None,
+    ) -> torch.Tensor:
+        plan = self._resolve_plan(attn_metadata)
+        if plan is None:
+            return self.dense_fallback.forward_npu(query, key, value, attn_metadata)
+        return self._forward_sparse_npu(query, key, value, plan)
+
+    def _resolve_plan(self, attn_metadata: AttentionMetadata | None) -> RainFusionPlan | None:
+        """Return the rf_v2 geometry, or None when this forward must stay dense."""
+        rf = self.rainfusion
+        if not rf.enabled:
+            return None
+        if self.layer_idx is not None and self.layer_idx in rf.skip_layers:
+            return None
+        if is_forward_context_available():
+            step_idx = get_forward_context().denoise_step_idx
+            if step_idx is not None and step_idx < rf.start_step:
+                return None
+        if self.qkv_layout is None:
+            # The sparse path reads the sequence off dim 1, which the tensors alone
+            # do not establish, and the dense fallback resolves an absent layout its
+            # own way. Sparsifying on an assumption would put the two paths on
+            # different axes, so an undeclared layout stays dense.
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: this layer does not declare qkv_layout, and rf_v2 "
+                "needs %s to locate the video segment along the sequence axis. Set qkv_layout=%r on "
+                "the Attention layer to enable sparsity.",
+                _INPUT_LAYOUT,
+                _INPUT_LAYOUT,
+            )
+            return None
+
+        if attn_metadata is None:
+            return None
+
+        layout = attn_metadata.video_layout
+        if layout is None:
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: this attention role carries no video segment. The "
+                "model must publish AttentionMetadata.video_layout for the sequence to be sparsified."
+            )
+            return None
+        max_seqlen_q = attn_metadata.extra.get("max_seqlen_q")
+        if max_seqlen_q is None:
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: attention metadata is missing max_seqlen_q, so the "
+                "video segment cannot be confirmed to be the tail of packed document 0."
+            )
+            return None
+
+        prefix_len = int(layout.prefix_len)
+        latent_shape = [int(dim) for dim in layout.latent_grid]
+        # rf_v2 splits the sequence as [prefix | t*h*w video rows]. Document 0 of
+        # the packed sequence holds those rows; anything past it is alignment
+        # padding that rf_v2 must not see.
+        video_len = math.prod(latent_shape)
+        used_len = prefix_len + video_len
+
+        if used_len != int(max_seqlen_q):
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: prefix (%d) plus latent grid %s does not fill "
+                "packed document 0 (%d rows). rf_v2 requires the video segment to be its tail.",
+                prefix_len,
+                tuple(latent_shape),
+                int(max_seqlen_q),
+            )
+            return None
+        if video_len < _MIN_VIDEO_BLOCKS * _BLOCK_SIZE:
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: %d video rows is under the %d-row "
+                "(%d block) threshold where sparse selection pays off.",
+                video_len,
+                _MIN_VIDEO_BLOCKS * _BLOCK_SIZE,
+                _MIN_VIDEO_BLOCKS,
+            )
+            return None
+        if video_len % _BLOCK_SIZE != 0:
+            # rf_v2 tiles the sequence into ceil((video + prefix) / 128) blocks but
+            # builds its block mask from the two segments pooled apart. The counts
+            # only agree when the video segment ends on a block boundary; otherwise
+            # a prefix block is forced on out of range, and the block straddling the
+            # seam holds real prefix rows that selection may drop. Padding the
+            # sequence to realign it is not an option because rf_v2 ignores
+            # attn_mask, so pad keys would take a share of every softmax denominator.
+            logger.warning_once(
+                "RAINFUSION_ATTN staying dense: latent grid %s gives %d video rows, which is not a "
+                "multiple of the %d-row kernel block. Choose a geometry whose latent_t * h * w is a "
+                "multiple of %d to enable sparsity.",
+                tuple(latent_shape),
+                video_len,
+                _BLOCK_SIZE,
+                _BLOCK_SIZE,
+            )
+            return None
+
+        logger.info_once(
+            "RAINFUSION_ATTN active: sparsity=%.2f, start_step=%d, exempt_layers=%d, "
+            "latent_grid=%s, prefix_rows=%d, video_rows=%d. Realized sparsity is lower than nominal "
+            "because prefix and first-frame blocks are always kept.",
+            rf.sparsity,
+            rf.start_step,
+            len(rf.skip_layers),
+            tuple(latent_shape),
+            prefix_len,
+            video_len,
+        )
+        return RainFusionPlan(
+            prefix_len=prefix_len,
+            used_len=used_len,
+            latent_shape=latent_shape,
+        )
+
+    def _forward_sparse_npu(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        plan: RainFusionPlan,
+    ) -> torch.Tensor:
+        try:
+            from mindiesd import sparse_attention
+        except ImportError:
+            raise ImportError(_MISSING_MINDIESD)
+
+        used = plan.used_len
+        q, k, v = (tensor[:, :used] for tensor in (query, key, value))
+        # Ulysses has already gathered the full sequence onto this rank and split
+        # the heads, so read the head count off the tensor rather than num_heads.
+        out = sparse_attention(
+            q,
+            k,
+            v,
+            scale=self.softmax_scale,
+            head_num=query.shape[-2],
+            input_layout=_INPUT_LAYOUT,
+            inner_precise=_INNER_PRECISE,
+            sparse_type="rf_v2",
+            txt_len=plan.prefix_len,
+            block_size=_BLOCK_SIZE,
+            latent_shape_q=plan.latent_shape,
+            latent_shape_k=plan.latent_shape,
+            sparsity=self.rainfusion.sparsity,
+        )
+        if used == query.shape[1]:
+            return out
+        padded = torch.zeros_like(query)
+        padded[:, :used] = out
+        return padded
diff --git a/vllm_omni/diffusion/attention/backends/registry.py b/vllm_omni/diffusion/attention/backends/registry.py
index a822d78fb..fdfaf5f9c 100644
--- a/vllm_omni/diffusion/attention/backends/registry.py
+++ b/vllm_omni/diffusion/attention/backends/registry.py
@@ -64,6 +64,8 @@ class DiffusionAttentionBackendEnum(Enum, metaclass=_DiffusionBackendEnumMeta):
     FLASHINFER_ATTN = "vllm_omni.diffusion.attention.backends.flashinfer_attn.FlashInferAttentionBackend"
     FLASH_ATTN_HUB = "vllm_omni.diffusion.attention.backends.flash_attn_hub.FlashAttentionHubBackend"
     FLASH_ATTN_3_HUB = "vllm_omni.diffusion.attention.backends.flash_attn_hub.FlashAttention3HubBackend"
+    TRTLLM_ATTN = "vllm_omni.diffusion.attention.backends.trtllm_attn.TrtllmAttentionBackend"
+    RAINFUSION_ATTN = "vllm_omni.diffusion.attention.backends.rainfusion_attn.RainFusionAttentionBackend"
 
     def get_path(self, include_classname: bool = True) -> str:
         """Get the class path for this backend (respects overrides).
diff --git a/vllm_omni/diffusion/attention/backends/ring/ring_globals.py b/vllm_omni/diffusion/attention/backends/ring/ring_globals.py
index 4ac7d1456..25f9a41cc 100644
--- a/vllm_omni/diffusion/attention/backends/ring/ring_globals.py
+++ b/vllm_omni/diffusion/attention/backends/ring/ring_globals.py
@@ -23,6 +23,19 @@ HAS_FA3 = False
 fa3_fwd_func = None  # Low-level forward function (_flash_attn_forward)
 fa3_attn_func = None  # High-level attention function (flash_attn_func)
 
+# FA4 detection. The CuTe API returns LSE directly, so it can participate in
+# Ring Attention's numerically stable block-wise output accumulation.
+HAS_FA4 = False
+fa4_attn_func = None
+try:
+    from flash_attn.cute import flash_attn_func as fa4_attn_func  # noqa: F401
+
+    HAS_FA4 = True
+except Exception:
+    # Optional CuTe/CUTLASS/Quack components can be importable but
+    # ABI-incompatible. Treat the whole optional backend as unavailable.
+    pass
+
 # Try flash_attn_interface first (from flash-attention source build)
 try:
     from flash_attn_interface import _flash_attn_forward as fa3_fwd_func  # noqa: F401
diff --git a/vllm_omni/diffusion/attention/backends/ring/ring_kernels.py b/vllm_omni/diffusion/attention/backends/ring/ring_kernels.py
index 51cf8bbc3..838726396 100644
--- a/vllm_omni/diffusion/attention/backends/ring/ring_kernels.py
+++ b/vllm_omni/diffusion/attention/backends/ring/ring_kernels.py
@@ -9,9 +9,11 @@ import torch
 from .ring_globals import (
     HAS_AITER,
     HAS_FA3,
+    HAS_FA4,
     HAS_FLASH_ATTN,
     HAS_FLASHINFER,
     fa3_fwd_func,
+    fa4_attn_func,
 )
 
 _scaled_dot_product_flash_attention = torch.ops.aten._scaled_dot_product_flash_attention
@@ -190,6 +192,40 @@ def fa3_forward(q, k, v, dropout_p, softmax_scale, causal, window_size, softcap,
 flash_attn3_func_forward = fa3_forward
 
 
+def flash_attn4_func_forward(
+    q,
+    k,
+    v,
+    dropout_p=0.0,
+    softmax_scale=None,
+    causal=False,
+    window_size=(-1, -1),
+    softcap=None,
+    alibi_slopes=None,
+    return_softmax=False,
+):
+    """FA4 forward pass returning the LSE required by Ring Attention."""
+    del dropout_p, alibi_slopes, return_softmax
+    assert HAS_FA4, "FA4 is not available"
+    assert fa4_attn_func is not None, "FA4 high-level API is not available"
+
+    left, right = window_size if window_size else (-1, -1)
+    out, softmax_lse = fa4_attn_func(
+        q,
+        k,
+        v,
+        softmax_scale=softmax_scale,
+        causal=causal,
+        window_size=(
+            None if left == -1 else left,
+            None if right == -1 else right,
+        ),
+        softcap=softcap or 0.0,
+        return_lse=True,
+    )
+    return out, softmax_lse
+
+
 def flash_attn_forward_aiter(
     q,
     k,
diff --git a/vllm_omni/diffusion/attention/backends/ring/ring_selector.py b/vllm_omni/diffusion/attention/backends/ring/ring_selector.py
index 77189c61b..05522c506 100644
--- a/vllm_omni/diffusion/attention/backends/ring/ring_selector.py
+++ b/vllm_omni/diffusion/attention/backends/ring/ring_selector.py
@@ -15,6 +15,7 @@ from .ring_globals import (
 )
 from .ring_kernels import (
     flash_attn3_func_forward,
+    flash_attn4_func_forward,
     flash_attn_forward,
     flash_attn_forward_aiter,
     flashinfer_attn_forward,
@@ -32,6 +33,7 @@ class AttnType(Enum):
     AITER = "aiter"
     FA = "fa"
     FA3 = "fa3"
+    FA4 = "fa4"
     FLASHINFER = "flashinfer"
     TORCH = "torch"
     SAGE_AUTO = "sage_auto"
@@ -77,6 +79,9 @@ def select_flash_attn_impl(
     elif impl_type == AttnType.FA3:
         return flash_attn3_func_forward
 
+    elif impl_type == AttnType.FA4:
+        return flash_attn4_func_forward
+
     elif impl_type == AttnType.FLASHINFER:
         return flashinfer_attn_forward
 
diff --git a/vllm_omni/diffusion/attention/backends/sdpa.py b/vllm_omni/diffusion/attention/backends/sdpa.py
index f8d607e48..aec8eb50b 100644
--- a/vllm_omni/diffusion/attention/backends/sdpa.py
+++ b/vllm_omni/diffusion/attention/backends/sdpa.py
@@ -11,6 +11,7 @@ from vllm_omni.diffusion.attention.backends.abstract import (
     AttentionImpl,
     AttentionMetadata,
 )
+from vllm_omni.diffusion.attention.backends.utils.attn_runtime_selector import can_sdpa_use_fused_gqa
 
 logger = init_logger(__name__)
 
@@ -85,7 +86,6 @@ class SDPAImpl(AttentionImpl):
     ) -> None:
         self.causal = causal
         self.softmax_scale = softmax_scale
-        self.requires_gqa = num_heads != num_kv_heads
         if backend_kwargs:
             logger.warning("SDPAImpl ignoring backend_kwargs: %s", list(backend_kwargs.keys()))
 
@@ -103,7 +103,24 @@ class SDPAImpl(AttentionImpl):
         if attn_metadata:
             attention_mask = _maybe_reshape_attn_mask(query, key, attn_metadata.attn_mask, mask_mode=mask_mode)
 
+        enable_gqa = query.shape[2] != key.shape[2]
         query, key, value = (x.permute(0, 2, 1, 3) for x in (query, key, value))
+        # Only the PyTorch SDPA backend needs this dispatch check. If SDPA
+        # cannot select a fused GQA kernel for the runtime shape/mask, expand
+        # K/V locally so it can use the better-supported equal-head path.
+        if enable_gqa and not can_sdpa_use_fused_gqa(query, key, value, attention_mask, self.causal):
+            if query.shape[1] % key.shape[1] != 0:
+                raise ValueError(
+                    "GQA requires query heads to be a multiple of KV heads, "
+                    f"got q_heads={query.shape[1]} and kv_heads={key.shape[1]}."
+                )
+            repeat_num = query.shape[1] // key.shape[1]
+            key = key.repeat_interleave(repeat_num, dim=1)
+            value = value.repeat_interleave(repeat_num, dim=1)
+            enable_gqa = False
+            logger.debug(
+                "CUDA SDPA cannot use a fused native-GQA kernel for this shape; expanding K/V heads before SDPA."
+            )
         output = torch.nn.functional.scaled_dot_product_attention(
             query,
             key,
@@ -112,7 +129,7 @@ class SDPAImpl(AttentionImpl):
             dropout_p=0.0,
             is_causal=self.causal,
             scale=self.softmax_scale,
-            enable_gqa=self.requires_gqa,
+            enable_gqa=enable_gqa,
         )
         out = output.permute(0, 2, 1, 3)
         return out
diff --git a/vllm_omni/diffusion/attention/backends/trtllm_attn.py b/vllm_omni/diffusion/attention/backends/trtllm_attn.py
new file mode 100644
index 000000000..c63280fc8
--- /dev/null
+++ b/vllm_omni/diffusion/attention/backends/trtllm_attn.py
@@ -0,0 +1,406 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import functools
+import inspect
+import math
+from dataclasses import dataclass, replace
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.attention.backends.abstract import (
+    AttentionBackend,
+    AttentionImpl,
+    AttentionMetadata,
+)
+
+logger = init_logger(__name__)
+
+
+def _validate_control(value, name: str, lo: float, hi: float | None) -> float | None:
+    if value is None:
+        return None
+    v = float(value)
+    if not math.isfinite(v) or v < lo or (hi is not None and v > hi):
+        rng = f"in [{lo}, {hi}]" if hi is not None else f">= {lo}"
+        raise ValueError(f"{name} must be finite and {rng}; got {value!r}.")
+    return v
+
+
+@dataclass(frozen=True)
+class SkipSoftmaxConfig:
+    threshold: float | None = None
+    target_sparsity: float | None = None
+    disabled_until_timestep: float = 0.0
+    a: float | None = None
+    b: float | None = None
+
+    @classmethod
+    def from_backend_kwargs(cls, backend_kwargs: dict | None) -> "SkipSoftmaxConfig":
+        bk = backend_kwargs or {}
+        return cls(
+            threshold=_validate_control(bk.get("skip_softmax_threshold"), "skip_softmax_threshold", 0.0, None),
+            target_sparsity=_validate_control(bk.get("target_sparsity"), "target_sparsity", 0.0, 1.0),
+            disabled_until_timestep=_validate_control(
+                bk.get("disabled_until_timestep", 0.0), "disabled_until_timestep", 0.0, 1.0
+            ),
+        )
+
+    @property
+    def enabled(self) -> bool:
+        return self.threshold is not None or (
+            self.target_sparsity is not None and self.a is not None and self.b is not None
+        )
+
+    @property
+    def configured(self) -> bool:
+        return self.threshold is not None or self.target_sparsity is not None
+
+    @property
+    def gated(self) -> bool:
+        return self.disabled_until_timestep > 0.0
+
+    def resolve_factor(self, seqlen: int, timestep: float | None) -> float | None:
+        if self.threshold is not None:
+            factor = self.threshold * seqlen
+        elif self.target_sparsity is not None and self.a is not None and self.b is not None:
+            factor = self.a * math.exp(self.b * self.target_sparsity)
+        else:
+            return None
+        if self.gated and timestep is not None and timestep > self.disabled_until_timestep:
+            return None
+        return factor
+
+
+try:
+    from flashinfer.prefill import trtllm_ragged_attention_deepseek
+
+    HAS_FLASHINFER = True
+except Exception as e:  # pragma: no cover - import guard
+    HAS_FLASHINFER = False
+    logger.warning(
+        "FlashInfer is unavailable; TRTLLM_ATTN backend will not work. Reason: %s",
+        e,
+    )
+
+
+@functools.lru_cache(maxsize=1)
+def _sage_kernel_available() -> bool:
+    if not HAS_FLASHINFER:
+        return False
+    try:
+        return "sage_attn_sfs" in inspect.signature(trtllm_ragged_attention_deepseek).parameters
+    except (TypeError, ValueError):
+        return False
+
+
+@functools.lru_cache(maxsize=1)
+def _sage_quantize_fn():
+    try:
+        from flashinfer import trtllm_sage_attention_quantize
+
+        return trtllm_sage_attention_quantize
+    except Exception:  # pragma: no cover
+        return None
+
+
+_QK_QUANT_DTYPES = {
+    "int8": torch.int8,
+    "fp8_e4m3": torch.float8_e4m3fn,
+}
+
+
+@dataclass(frozen=True)
+class QuantConfig:
+    dtype_qk: str | None = None
+    q_block_size: int = 1
+    k_block_size: int = 16
+
+    @classmethod
+    def from_backend_kwargs(cls, backend_kwargs: dict | None) -> "QuantConfig":
+        q = (backend_kwargs or {}).get("quant") or {}
+        return cls(
+            dtype_qk=q.get("dtype_qk"),
+            q_block_size=int(q.get("q_block_size", 1) or 1),
+            k_block_size=int(q.get("k_block_size", 16) or 16),
+        )
+
+    @property
+    def enabled(self) -> bool:
+        return self.dtype_qk is not None
+
+    def quantize(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, quantize_fn):
+        qk_quant_dtype = _QK_QUANT_DTYPES[self.dtype_qk]
+        q_q, k_q, v_q, q_sfs, k_sfs, v_sfs = quantize_fn(
+            q,
+            k,
+            v,
+            q_block_size=self.q_block_size,
+            k_block_size=self.k_block_size,
+            qk_quant_dtype=qk_quant_dtype,
+        )
+        sage_attn_sfs = (q_sfs, k_sfs, None, v_sfs)
+        num_elts_per_sage_attn_blk = (self.q_block_size, self.k_block_size, 0, 1)
+        return q_q, k_q, v_q, sage_attn_sfs, num_elts_per_sage_attn_blk
+
+
+def _workspace_bytes() -> int:
+    import vllm.envs as envs
+
+    return getattr(envs, "VLLM_FLASHINFER_WORKSPACE_BUFFER_SIZE", 394 * 1024 * 1024)
+
+
+class TrtllmAttentionBackend(AttentionBackend):
+    accept_output_buffer: bool = True
+
+    @staticmethod
+    def get_supported_head_sizes() -> list[int]:
+        return [128]
+
+    @staticmethod
+    def get_name() -> str:
+        return "TRTLLM_ATTN"
+
+    @staticmethod
+    def get_impl_cls() -> type["TrtllmAttentionImpl"]:
+        return TrtllmAttentionImpl
+
+
+class TrtllmAttentionImpl(AttentionImpl):
+    _workspace: torch.Tensor | None = None
+
+    def __init__(
+        self,
+        num_heads: int,
+        head_size: int,
+        softmax_scale: float,
+        causal: bool = False,
+        num_kv_heads: int | None = None,
+        prefix: str = "",
+        qkv_layout: str | None = None,
+        backend_kwargs: dict | None = None,
+        role: str = "self",
+        **extra_impl_args,
+    ) -> None:
+        self.num_heads = num_heads
+        self.head_size = head_size
+        self.softmax_scale = softmax_scale
+        self.causal = causal
+        self.num_kv_heads = num_kv_heads if num_kv_heads is not None else num_heads
+        self.role = role
+
+        self.skip = SkipSoftmaxConfig.from_backend_kwargs(backend_kwargs)
+        self._warned_missing_timestep = False
+
+        self.quant = QuantConfig.from_backend_kwargs(backend_kwargs)
+        # Resolve the SAGE quantize fn once at init so the compiled forward path never calls the
+        # lru_cache-wrapped getter (which triggers a Dynamo graph break every step).
+        self._sage_quantize_fn = None
+        if self.quant.enabled:
+            if self.quant.dtype_qk not in _QK_QUANT_DTYPES:
+                raise RuntimeError(
+                    f"TRTLLM_ATTN quant (SAGE) supports dtype_qk in {sorted(_QK_QUANT_DTYPES)}, got "
+                    f"{self.quant.dtype_qk!r}. FLASHINFER_ATTN dtypes (float16/bfloat16) are not SAGE."
+                )
+            if not _sage_kernel_available():
+                raise RuntimeError(
+                    "TRTLLM_ATTN quant (SAGE) was requested but this FlashInfer build does not "
+                    "expose the trtllm-gen sage_attn_sfs kernel path. Install a FlashInfer build "
+                    "that provides it, or remove the quant config."
+                )
+            self._sage_quantize_fn = _sage_quantize_fn()
+            if self._sage_quantize_fn is None:
+                raise RuntimeError(
+                    "TRTLLM_ATTN quant (SAGE) was requested but this FlashInfer build lacks "
+                    "trtllm_sage_attention_quantize (added in flashinfer >= 0.6.16rc1). Upgrade "
+                    "FlashInfer, or remove the quant config."
+                )
+
+    def set_layer_calibration(self, a: float, b: float) -> None:
+        self.skip = replace(self.skip, a=a, b=b)
+
+    def _resolve_skip_factor(self, seqlen: int) -> float | None:
+        if not self.skip.enabled:
+            return None
+
+        timestep = None
+        if self.skip.gated:
+            from vllm_omni.diffusion.forward_context import get_forward_context
+
+            timestep = getattr(get_forward_context(), "denoise_timestep", None)
+            if timestep is None:
+                if not self._warned_missing_timestep:
+                    logger.warning(
+                        "TRTLLM skip: disabled_until_timestep=%s set but this pipeline does not "
+                        "publish denoise_timestep; staying dense. Have the pipeline call "
+                        "DenoiseProgressMixin.record_denoise_step to enable timestep gating.",
+                        self.skip.disabled_until_timestep,
+                    )
+                    self._warned_missing_timestep = True
+                return None
+        return self.skip.resolve_factor(seqlen, timestep)
+
+    @classmethod
+    def _get_workspace(cls, device: torch.device) -> torch.Tensor:
+        nbytes = _workspace_bytes()
+        ws = cls._workspace
+        if ws is None or ws.device != device or ws.numel() < nbytes:
+            ws = torch.zeros(nbytes, dtype=torch.uint8, device=device)
+            cls._workspace = ws
+        return ws
+
+    def forward_cuda(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None = None,
+    ) -> torch.Tensor:
+        extra = getattr(attn_metadata, "extra", {}) if attn_metadata is not None else {}
+        packed_keys = ("cu_seqlens_q", "cu_seqlens_k", "max_seqlen_q", "max_seqlen_k")
+        present_packed_keys = [key for key in packed_keys if key in extra]
+        if present_packed_keys and len(present_packed_keys) != len(packed_keys):
+            missing = sorted(set(packed_keys) - set(present_packed_keys))
+            raise ValueError(f"Incomplete packed TRTLLM attention metadata; missing {missing}")
+        has_packed_metadata = len(present_packed_keys) == len(packed_keys)
+
+        attn_mask = getattr(attn_metadata, "attn_mask", None) if attn_metadata is not None else None
+        if attn_mask is not None and not has_packed_metadata:
+            raise ValueError(
+                "TRTLLM_ATTN does not support attn_mask (Wan sets one only under SP with "
+                "mask_sp_padding=True and a non-divisible seq len). Either set "
+                "parallel_config.mask_sp_padding=False, or select a mask-capable backend "
+                "(e.g. CUDNN_ATTN / TORCH_SDPA)."
+            )
+
+        if not HAS_FLASHINFER:
+            raise ImportError(
+                "TRTLLM_ATTN backend requires flashinfer. Install it or select "
+                "another backend via --diffusion-attention-backend."
+            )
+
+        physical_batch, q_len, num_q_heads, head_dim = query.shape
+        kv_len, num_kv_heads = key.shape[1], key.shape[2]
+
+        device = query.device
+
+        q = query.reshape(physical_batch * q_len, num_q_heads, head_dim).contiguous()
+        k = key.reshape(physical_batch * kv_len, num_kv_heads, head_dim).contiguous()
+        v = value.reshape(physical_batch * kv_len, num_kv_heads, head_dim).contiguous()
+        output_tokens = q.shape[0]
+
+        if has_packed_metadata:
+            cu_seq_lens_q = extra["cu_seqlens_q"]
+            cu_seq_lens_kv = extra["cu_seqlens_k"]
+            if cu_seq_lens_q.ndim != 1 or cu_seq_lens_kv.ndim != 1:
+                raise ValueError("Packed TRTLLM attention cu_seqlens tensors must be one-dimensional")
+            if cu_seq_lens_q.numel() != cu_seq_lens_kv.numel() or cu_seq_lens_q.numel() < 2:
+                raise ValueError("Packed TRTLLM attention requires matching non-empty Q and KV sequence batches")
+            if int(cu_seq_lens_q[-1].item()) != q.shape[0] or int(cu_seq_lens_kv[-1].item()) != k.shape[0]:
+                raise ValueError("Packed TRTLLM attention cu_seqlens must cover all Q/K/V tokens")
+
+            # Drop trailing empty sequences retained by packed producers when
+            # alignment adds no padding tokens.
+            while (
+                cu_seq_lens_q.numel() > 2
+                and int(cu_seq_lens_q[-1].item()) == int(cu_seq_lens_q[-2].item())
+                and int(cu_seq_lens_kv[-1].item()) == int(cu_seq_lens_kv[-2].item())
+            ):
+                cu_seq_lens_q = cu_seq_lens_q[:-1]
+                cu_seq_lens_kv = cu_seq_lens_kv[:-1]
+
+            # A packed prefix mask denotes structural suffix padding, not another
+            # document. Exclude it before quantization and attention; in particular,
+            # SAGE block quantization must not span the valid/padding boundary.
+            if attn_mask is not None:
+                if q.shape[0] != k.shape[0] or attn_mask.numel() != q.shape[0]:
+                    raise ValueError("Packed TRTLLM prefix masks require equal Q/K lengths")
+                flat_mask = attn_mask.reshape(-1).to(dtype=torch.bool)
+                valid_tokens = int(flat_mask.sum().item())
+                expected_mask = torch.arange(flat_mask.numel(), device=device) < valid_tokens
+                if not torch.equal(flat_mask, expected_mask):
+                    raise ValueError("TRTLLM_ATTN only supports prefix-valid packed attention masks")
+
+                q_boundary = (cu_seq_lens_q == valid_tokens).nonzero(as_tuple=False)
+                kv_boundary = (cu_seq_lens_kv == valid_tokens).nonzero(as_tuple=False)
+                if q_boundary.numel() != 1 or kv_boundary.numel() != 1:
+                    raise ValueError("Packed TRTLLM prefix length must be a Q/K sequence boundary")
+                q_end = int(q_boundary.item()) + 1
+                kv_end = int(kv_boundary.item()) + 1
+                if q_end != kv_end:
+                    raise ValueError("Packed TRTLLM prefix masks require matching Q/K sequence batches")
+
+                q = q[:valid_tokens]
+                k = k[:valid_tokens]
+                v = v[:valid_tokens]
+                cu_seq_lens_q = cu_seq_lens_q[:q_end].contiguous()
+                cu_seq_lens_kv = cu_seq_lens_kv[:kv_end].contiguous()
+
+            batch = cu_seq_lens_q.numel() - 1
+            seq_lens = (cu_seq_lens_kv[1:] - cu_seq_lens_kv[:-1]).to(dtype=torch.int32).contiguous()
+            max_q_len = int(extra["max_seqlen_q"])
+            max_kv_len = int(extra["max_seqlen_k"])
+        else:
+            batch = physical_batch
+            seq_lens = torch.full((batch,), kv_len, dtype=torch.int32, device=device)
+            cu_seq_lens_q = torch.arange(0, (batch + 1) * q_len, step=q_len, dtype=torch.int32, device=device)
+            cu_seq_lens_kv = torch.arange(0, (batch + 1) * kv_len, step=kv_len, dtype=torch.int32, device=device)
+            max_q_len = q_len
+            max_kv_len = kv_len
+        workspace = self._get_workspace(device)
+
+        bmm1_scale = self.softmax_scale
+        bmm2_scale = 1.0
+
+        _skip_factor = self._resolve_skip_factor(max_kv_len)
+
+        # SAGE kwargs are only understood by newer FlashInfer builds; pass them exclusively when
+        # SAGE quant is active (which already requires the kernel, checked at init) so the dense
+        # path stays compatible with older builds that lack these parameters.
+        sage_kwargs: dict = {}
+        # The SAGE kernel requires every KV sequence to contain at least one full
+        # quantization block. Small auxiliary attention sites use the dense kernel.
+        use_sage = self.quant.enabled and bool(torch.all(seq_lens >= self.quant.k_block_size).item())
+        if self.quant.enabled and not use_sage:
+            message = (
+                f"TRTLLM_ATTN SAGE quantization is configured for attention role {self.role!r}, but at least one "
+                f"KV sequence is shorter than k_block_size={self.quant.k_block_size}. Falling back to dense "
+                "attention for this input."
+            )
+            logger.warning_once(message)
+        if use_sage:
+            q, k, v, sage_attn_sfs, sage_block_sizes = self.quant.quantize(q, k, v, self._sage_quantize_fn)
+            sage_kwargs["sage_attn_sfs"] = sage_attn_sfs
+            sage_kwargs["num_elts_per_sage_attn_blk"] = sage_block_sizes
+
+        out = trtllm_ragged_attention_deepseek(
+            query=q,
+            key=k,
+            value=v,
+            workspace_buffer=workspace,
+            seq_lens=seq_lens,
+            max_q_len=max_q_len,
+            max_kv_len=max_kv_len,
+            bmm1_scale=bmm1_scale,
+            bmm2_scale=bmm2_scale,
+            o_sf_scale=-1.0,
+            batch_size=batch,
+            window_left=-1,
+            cum_seq_lens_q=cu_seq_lens_q,
+            cum_seq_lens_kv=cu_seq_lens_kv,
+            enable_pdl=False,
+            is_causal=self.causal,
+            return_lse=False,
+            skip_softmax_threshold_scale_factor=_skip_factor,
+            **sage_kwargs,
+        )
+        if out.shape[0] != output_tokens:
+            padded_out = torch.zeros(
+                (output_tokens, num_q_heads, head_dim),
+                dtype=out.dtype,
+                device=out.device,
+            )
+            padded_out[: out.shape[0]] = out
+            out = padded_out
+        return out.reshape(physical_batch, q_len, num_q_heads, head_dim)
diff --git a/vllm_omni/diffusion/attention/backends/trtllm_calibration.py b/vllm_omni/diffusion/attention/backends/trtllm_calibration.py
new file mode 100644
index 000000000..71b26a53f
--- /dev/null
+++ b/vllm_omni/diffusion/attention/backends/trtllm_calibration.py
@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+from __future__ import annotations
+
+import fnmatch
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_SUPPORTED_FORMULA = "a*exp(b*target_sparsity)"
+
+
+def parse_sparse_attention_config(sac: dict | None) -> dict | None:
+    if not sac:
+        return None
+    group: dict = {}
+    for g in (sac.get("config_groups") or {}).values():
+        if isinstance(g, dict) and (g.get("algorithm") == "skip_softmax" or g.get("threshold_scale_factor")):
+            group = g
+            break
+    tsf = group.get("threshold_scale_factor") or sac.get("threshold_scale_factor") or {}
+    ab = tsf.get("coefficients") or tsf.get("prefill") or {}
+    if "a" not in ab or "b" not in ab:
+        return None
+
+    formula = (tsf.get("formula") or _SUPPORTED_FORMULA).replace(" ", "")
+    if formula != _SUPPORTED_FORMULA:
+        raise ValueError(
+            f"unsupported skip-softmax formula {tsf.get('formula')!r}; this backend implements '{_SUPPORTED_FORMULA}'."
+        )
+
+    return {"a": float(ab["a"]), "b": float(ab["b"]), "ignore": list(group.get("ignore") or [])}
+
+
+def parse_secondary_expert_calibration(model: str | None) -> dict | None:
+    from vllm.transformers_utils.config import get_hf_file_to_dict
+
+    if not model:
+        return None
+    try:
+        cfg = get_hf_file_to_dict("transformer_2/config.json", model)
+        return parse_sparse_attention_config(cfg.get("sparse_attention_config")) if cfg else None
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(
+            "Could not read transformer_2 skip-softmax calibration (%s); transformer_2 will stay uncalibrated (dense).",
+            exc,
+        )
+        return None
+
+
+def propagate_skip_softmax_calibration(specs: list, model: str | None, tf_config: Any) -> None:
+    calibration = parse_sparse_attention_config(
+        tf_config.get("sparse_attention_config") if tf_config is not None else None
+    )
+    if calibration is not None:
+        by_expert = {"transformer": calibration}
+        ckpt2 = parse_secondary_expert_calibration(model)
+        if ckpt2 is not None:
+            by_expert["transformer_2"] = ckpt2
+        calibration = {"by_expert": by_expert}
+
+    if calibration is None:
+        for spec in specs:
+            ss = spec.skip_softmax
+            if ss is not None and ss.target_sparsity is not None and ss.threshold is None:
+                raise ValueError(
+                    f"target_sparsity was requested but the checkpoint for model '{model}' carries no "
+                    f"skip-softmax calibration. Either set skip_softmax.threshold for the "
+                    f"calibration-free path or load a calibrated checkpoint."
+                )
+        return
+
+    for spec in specs:
+        if spec.skip_calibration is None:
+            spec.skip_calibration = calibration
+
+    experts = list(calibration["by_expert"])
+    logger.info("Loaded skip-softmax calibration from checkpoint (%d curve(s): %s).", len(experts), ", ".join(experts))
+
+
+def apply_skip_softmax_calibration(attention_config: Any, model: Any) -> None:
+    cfg = attention_config
+    specs = getattr(cfg, "per_role", None)
+    calibration = None
+    for spec in (getattr(cfg, "default", None), *(specs.values() if specs else ())):
+        calibration = calibration or getattr(spec, "skip_calibration", None)
+    if not calibration:
+        return
+
+    stamped = apply_to_pipeline(model, calibration)
+    logger.info("Skip-softmax: stamped calibration onto %d attention layer(s).", stamped)
+
+
+_EXPERT_PREFIXES = ("transformer.", "transformer_2.")
+
+
+def layer_match_names(module_name: str) -> tuple[str, ...]:
+    names = {module_name, module_name.replace("._orig_mod.", ".")}
+    for name in tuple(names):
+        for pfx in _EXPERT_PREFIXES:
+            if name.startswith(pfx):
+                names.add(name[len(pfx) :])
+    return tuple(names)
+
+
+def is_ignored(module_name: str, ignore_patterns) -> bool:
+    names = layer_match_names(module_name)
+    for p in ignore_patterns or ():
+        for n in names:
+            if fnmatch.fnmatch(n, p) or fnmatch.fnmatch(n, p + ".*"):
+                return True
+    return False
+
+
+def select_expert(module_name: str, expert_keys) -> str | None:
+    for key in sorted(expert_keys or (), key=len, reverse=True):
+        if module_name == key or module_name.startswith(key + "."):
+            return key
+    return None
+
+
+def resolve_layer_calibration(module_name: str, calibration: dict) -> dict | None:
+    if not calibration:
+        return None
+    by_expert = calibration.get("by_expert")
+    if by_expert:
+        key = select_expert(module_name, by_expert.keys())
+        if key is None:
+            return None
+        entry = by_expert[key]
+    else:
+        entry = calibration
+    if is_ignored(module_name, entry.get("ignore")):
+        return None
+    return {"a": entry.get("a"), "b": entry.get("b")}
+
+
+def apply_to_pipeline(pipeline, calibration: dict) -> int:
+    if not calibration:
+        return 0
+    stamped = 0
+    for name, module in pipeline.named_modules():
+        impl = getattr(module, "attention", None)
+        set_layer = getattr(impl, "set_layer_calibration", None)
+        if set_layer is None:
+            continue
+        per = resolve_layer_calibration(name, calibration)
+        if per and per.get("a") is not None and per.get("b") is not None:
+            set_layer(per["a"], per["b"])
+            stamped += 1
+    return stamped
diff --git a/vllm_omni/diffusion/attention/backends/utils/attn_runtime_selector.py b/vllm_omni/diffusion/attention/backends/utils/attn_runtime_selector.py
new file mode 100644
index 000000000..84170dcd7
--- /dev/null
+++ b/vllm_omni/diffusion/attention/backends/utils/attn_runtime_selector.py
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Runtime kernel-selection helpers for attention backends."""
+
+import torch
+
+
+def can_sdpa_use_fused_gqa(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attention_mask: torch.Tensor | None,
+    causal: bool,
+) -> bool:
+    """Return whether PyTorch SDPA can use a fused kernel for this GQA call.
+
+    This check is specific to the SDPA backend. Native GQA backends such as
+    FlashAttention should keep compressed K/V heads and do not use this helper.
+    """
+    if not query.is_cuda:
+        return False
+
+    try:
+        params = torch.backends.cuda.SDPAParams(
+            query,
+            key,
+            value,
+            attention_mask,
+            0.0,
+            causal,
+            True,
+        )
+        can_use_flash = torch.backends.cuda.can_use_flash_attention(params)
+        can_use_cudnn = getattr(torch.backends.cuda, "can_use_cudnn_attention", None)
+        return can_use_flash or (can_use_cudnn is not None and can_use_cudnn(params))
+    except (AttributeError, RuntimeError, TypeError):
+        # Older PyTorch versions may not expose GQA-aware SDPA capability checks.
+        # Returning False lets the SDPA backend expand K/V and use the mature
+        # equal-head fused-kernel path instead.
+        return False
diff --git a/vllm_omni/diffusion/attention/backends/utils/fa.py b/vllm_omni/diffusion/attention/backends/utils/fa.py
index e30d45ff2..d7a3a703f 100644
--- a/vllm_omni/diffusion/attention/backends/utils/fa.py
+++ b/vllm_omni/diffusion/attention/backends/utils/fa.py
@@ -22,6 +22,15 @@ from vllm_omni.platforms import current_omni_platform
 
 logger = init_logger(__name__)
 
+
+def _is_blackwell() -> bool:
+    try:
+        capability = current_omni_platform.get_device_capability()
+    except Exception:
+        return False
+    return capability is not None and capability.major >= 10
+
+
 # Flash Attention function detection with fallback chain
 flash_attn_func = None
 flash_attn_varlen_func = None
@@ -48,12 +57,27 @@ elif current_omni_platform.is_musa():
     except (ImportError, ModuleNotFoundError):
         pass
 else:
-    # CUDA: try FA3 -> FA2 fallback chain
+    # CUDA: prefer the CuTe-based FA4 package when present.  This matters on
+    # Blackwell, where an importable Hopper-only FA3 wheel may otherwise be
+    # selected and fail at launch with "no kernel image is available".
+    if _is_blackwell():
+        try:
+            from flash_attn.cute import flash_attn_func, flash_attn_varlen_func  # noqa: F401
+
+            logger.info("Using CuTe FlashAttention-4 on Blackwell")
+        except Exception as exc:
+            # Optional FA4 dependencies may be present but ABI-incompatible
+            # (for example, mismatched CUTLASS DSL and Quack builds). Treat
+            # that as unavailable so backend discovery can continue.
+            logger.debug("CuTe FlashAttention-4 is unavailable: %s", exc)
+
+    # Try FA3 -> FA2 fallback chain.
     # Try FA3 from fa3-fwd PyPI package
-    try:
-        from fa3_fwd_interface import flash_attn_func, flash_attn_varlen_func  # noqa: F401
-    except (ImportError, ModuleNotFoundError):
-        pass
+    if flash_attn_func is None:
+        try:
+            from fa3_fwd_interface import flash_attn_func, flash_attn_varlen_func  # noqa: F401
+        except (ImportError, ModuleNotFoundError):
+            pass
 
     # Fallback: Try FA3 from flash-attention source build
     if flash_attn_func is None:
@@ -100,7 +124,16 @@ def is_flash_attn_installed() -> bool:
     Shared by CUDA/ROCm/MUSA platforms.
     """
     try:
-        # Check for any FA backend: FA3 (fa3_fwd_interface, flash_attn_interface) or FA2 (flash_attn)
+        # Check for any FA backend: FA4 (flash_attn.cute), FA3
+        # (fa3_fwd_interface, flash_attn_interface), or FA2 (flash_attn).
+        if _is_blackwell():
+            try:
+                from flash_attn.cute import flash_attn_varlen_func  # noqa: F401
+
+                return True
+            except Exception as exc:
+                logger.debug("CuTe FlashAttention-4 is unavailable: %s", exc)
+
         # Try FA3 from fa3-fwd PyPI package
         try:
             import fa3_fwd_interface  # noqa: F401
diff --git a/vllm_omni/diffusion/attention/backends/utils/piecewise_attn.py b/vllm_omni/diffusion/attention/backends/utils/piecewise_attn.py
index fbbd3c8e0..5d83d8dbf 100644
--- a/vllm_omni/diffusion/attention/backends/utils/piecewise_attn.py
+++ b/vllm_omni/diffusion/attention/backends/utils/piecewise_attn.py
@@ -9,17 +9,24 @@ follows FlashAttention's bottom-right convention (``K[:e]`` is attended by
 
 Per segment:
   - causal segment ``[s, e)``: ``attn(Q[:, s:e], K[:, :e], V[:, :e], causal=True)``
-  - full-attn span ``[a, e)``: ``attn(Q[:, a:e], K[:, :e], V[:, :e], causal=False)``
+  - full-attn span ``[a, b)`` intersecting the query range at ``[s, e)``:
+    ``attn(Q[:, s:e], K[:, :b], V[:, :b], causal=False)``
 """
 
 from __future__ import annotations
 
-from typing import Literal, NamedTuple
+from typing import TYPE_CHECKING, Literal, NamedTuple
+
+import torch
+
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.attention.backends.abstract import QueryRange
 
 
 class Segment(NamedTuple):
-    start: int
-    end: int
+    q_start: int
+    q_end: int
+    kv_end: int
     mode: Literal["causal", "full"]
 
 
@@ -30,30 +37,33 @@ def build_segments(full_attn_spans, query_offset, query_len):
     query_len: length of the query
 
     return:
-        List[Segment] in global coordinates, clipped to [query_offset, query_offset + query_len)
+        List[Segment] in global coordinates, clipped to
+        [query_offset, query_offset + query_len). Full-attention segments retain
+        the original span end as kv_end so a local query shard can attend past
+        its own boundary.
     """
     q_start = query_offset
     q_end = query_offset + query_len
 
-    segs: list[Segment] = []
+    segments: list[Segment] = []
     cur = q_start
 
-    for a, e in full_attn_spans:
+    for span_start, span_end in full_attn_spans:
         # clip span to query range
-        a_clipped = max(a, q_start)
-        e_clipped = min(e, q_end)
-        if a_clipped >= e_clipped:
+        overlap_start = max(span_start, q_start)
+        overlap_end = min(span_end, q_end)
+        if overlap_start >= overlap_end:
             continue
 
-        if cur < a_clipped:
-            segs.append(Segment(cur, a_clipped, "causal"))
-        segs.append(Segment(a_clipped, e_clipped, "full"))
-        cur = e_clipped
+        if cur < overlap_start:
+            segments.append(Segment(cur, overlap_start, overlap_start, "causal"))
+        segments.append(Segment(overlap_start, overlap_end, span_end, "full"))
+        cur = overlap_end
 
     if cur < q_end:
-        segs.append(Segment(cur, q_end, "causal"))
+        segments.append(Segment(cur, q_end, q_end, "causal"))
 
-    return segs
+    return segments
 
 
 def _check_homogeneous(
@@ -76,23 +86,40 @@ def piecewise_attn(
     full_attn_spans: list[list[tuple[int, int]]],
     softmax_scale: float,
     attn_func,
+    query_ranges: tuple[QueryRange, ...] | None = None,
 ):
-    B, Sq, H, D = query.shape
     _check_homogeneous(full_attn_spans)
-
-    query_offset = key.shape[1] - Sq
     spans = full_attn_spans[0]
-    out = query.new_zeros(B, Sq, H, D)
+    if query_ranges is None:
+        query_len = query.shape[1]
+        ranges = ((0, query_len, key.shape[1] - query_len),)
+    else:
+        ranges = tuple((r.local_start, r.local_end, r.global_start) for r in query_ranges)
 
-    for s, e, mode in build_segments(spans, query_offset, Sq):
-        q_s = s - query_offset
-        q_e = e - query_offset
-        out_seg = attn_func(
-            query[:, q_s:q_e],
-            key[:, :e],
-            value[:, :e],
-            causal=(mode == "causal"),
-            softmax_scale=softmax_scale,
-        )
-        out[:, q_s:q_e] = out_seg
-    return out
+    outputs = []
+    covered = 0
+    for local_start, local_end, global_start in ranges:
+        query_len = local_end - local_start
+        if local_start != covered or query_len < 0:
+            raise ValueError("query_ranges must cover local query contiguously")
+        for segment in build_segments(spans, global_start, query_len):
+            q_start = local_start + segment.q_start - global_start
+            q_end = local_start + segment.q_end - global_start
+            outputs.append(
+                attn_func(
+                    query[:, q_start:q_end],
+                    key[:, : segment.kv_end],
+                    value[:, : segment.kv_end],
+                    causal=(segment.mode == "causal"),
+                    softmax_scale=softmax_scale,
+                )
+            )
+        covered = local_end
+
+    if covered != query.shape[1]:
+        raise ValueError("query_ranges must cover the full local query")
+    if not outputs:
+        return torch.empty_like(query)
+    if len(outputs) == 1:
+        return outputs[0]
+    return torch.cat(outputs, dim=1)
diff --git a/vllm_omni/diffusion/attention/layer.py b/vllm_omni/diffusion/attention/layer.py
index 0ea122273..7eb74a941 100644
--- a/vllm_omni/diffusion/attention/layer.py
+++ b/vllm_omni/diffusion/attention/layer.py
@@ -77,14 +77,29 @@ class Attention(nn.Module):
         config = get_current_diffusion_config_or_none()
         attention_config = config.diffusion_attention_config if config is not None else None
 
+        from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
+
+        model_class_name = getattr(config, "model_class_name", None) if config is not None else None
+        allow_trtllm_default = get_diffusion_model_metadata(model_class_name).attention_mask_free
+
         attn_backend_cls, spec = get_attn_backend_for_role(
             role=role,
             head_size=head_size,
             attention_config=attention_config,
             role_category=role_category,
+            allow_trtllm_default=allow_trtllm_default,
         )
+        parallel_config = getattr(config, "parallel_config", None)
+        allgather_degree = getattr(parallel_config, "allgather_degree", 1)
+        # TODO: Move AllGather-KV compatibility into an AttentionBackend capability
+        # so validation does not depend on backend names.
+        if not skip_sequence_parallel and allgather_degree > 1 and attn_backend_cls.get_name() == "TRTLLM_ATTN":
+            raise ValueError(
+                "TRTLLM_ATTN does not support AllGather-KV sequence parallelism. "
+                "Set --allgather-degree 1 or select another diffusion attention backend."
+            )
         if spec is not None:
-            backend_kwargs = spec.extra or None
+            backend_kwargs = spec.backend_kwargs()
             self.backend_pref = spec.backend
             logger.debug("Attention(role=%s) → backend=%s", role, spec.backend)
         else:
@@ -99,7 +114,9 @@ class Attention(nn.Module):
             causal=causal,
             num_kv_heads=num_kv_heads,
             qkv_layout=qkv_layout,
+            prefix=prefix,
             backend_kwargs=backend_kwargs,
+            role=role,
         )
         # Instantiate fallback backend for float32 support
         self.sdpa_fallback = SDPABackend.get_impl_cls()(
@@ -140,6 +157,7 @@ class Attention(nn.Module):
             scatter_idx=scatter_idx,
             gather_idx=gather_idx,
             use_sync=use_sync,
+            causal=causal,
         )
         # Fallback strategy when SP is not active (outside sharded regions)
         self._no_parallel_strategy = NoParallelAttention()
@@ -282,6 +300,8 @@ class Attention(nn.Module):
         return out
 
     def _run_local_attention(self, query, key, value, attn_metadata):
+        self._assert_piecewise_compatible(attn_metadata)
+
         if query.dtype == torch.float32:
             logger.warning_once(
                 f"Only SDPA supports float32. Overriding user config {type(self.attention)} "
@@ -292,7 +312,28 @@ class Attention(nn.Module):
         # Fallback to standard attention
         return self.attention.forward(query, key, value, attn_metadata)
 
+    def _assert_piecewise_compatible(self, attn_metadata: AttentionMetadata | None) -> None:
+        if attn_metadata is None or attn_metadata.full_attn_spans is None:
+            return
+        if attn_metadata.attn_mask is not None and attn_metadata.attn_mask.ndim == 4:
+            return
+        backend_name = self.attn_backend.get_name()
+        if not self.attn_backend.supports_piecewise_spans:
+            raise ValueError(
+                f"Attention backend '{backend_name}' does not support "
+                f"piecewise attention (full_attn_spans without a 4D attn_mask). "
+                f"Use a Flash backend (FLASH_ATTN / FLASH_ATTN_HUB / FLASH_ATTN_3_HUB), "
+                f"or provide a 4D attn_mask that encodes the mixed causal/full pattern."
+            )
+
     def _run_ring_attention(self, query, key, value, attn_metadata):
+        skip = getattr(self.attention, "skip", None)
+        if skip is not None and getattr(skip, "configured", False):
+            raise NotImplementedError(
+                "Skip-Softmax (TRTLLM_ATTN) is not supported with ring sequence parallelism: "
+                "the ring path bypasses the backend, so the skip config would be silently ignored. "
+                "Use Ulysses SP instead, or remove the skip_softmax config."
+            )
         # Delegate to RingParallelAttention strategy if available
         if self.ring_runner is not None:
             return self.ring_runner.run_attention(
diff --git a/vllm_omni/diffusion/attention/parallel/allgather_kv.py b/vllm_omni/diffusion/attention/parallel/allgather_kv.py
new file mode 100644
index 000000000..51a463bb1
--- /dev/null
+++ b/vllm_omni/diffusion/attention/parallel/allgather_kv.py
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import QueryRange
+from vllm_omni.diffusion.attention.parallel.base import ParallelAttentionContext
+from vllm_omni.diffusion.distributed.group_coordinator import (
+    SequenceParallelGroupCoordinator,
+)
+
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+
+
+@dataclass(frozen=True, slots=True)
+class _AllGatherKVCtx(ParallelAttentionContext):
+    pass
+
+
+class AllGatherKVParallelAttention:
+    """Compute local Q against AllGathered K/V."""
+
+    def __init__(
+        self,
+        sp_group: SequenceParallelGroupCoordinator,
+    ) -> None:
+        self._sp_group = sp_group
+        self._allgather_group = sp_group.allgather_group
+        self._sp_size = sp_group.allgather_world_size
+        self._sp_rank = sp_group.allgather_rank
+
+    @property
+    def enabled(self) -> bool:
+        return True
+
+    @property
+    def name(self) -> str:
+        return "allgather_kv"
+
+    def pre_attention(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None,
+    ):
+        joint_q = joint_k = joint_v = None
+        joint_strategy = "front"
+        if attn_metadata is not None:
+            joint_q = attn_metadata.joint_query
+            joint_k = attn_metadata.joint_key
+            joint_v = attn_metadata.joint_value
+            joint_strategy = attn_metadata.joint_strategy or "front"
+        if joint_strategy not in {"front", "rear"}:
+            raise ValueError(f"Unsupported joint_strategy: {joint_strategy!r}")
+
+        k_img_full = self._sp_group.all_gather(key, dim=1, group=self._allgather_group)
+        v_img_full = self._sp_group.all_gather(value, dim=1, group=self._allgather_group)
+
+        if joint_k is not None:
+            if joint_k.shape[2] != key.shape[2]:
+                raise ValueError(
+                    "AllGather-KV SP expects joint_k to be GQA-compressed with the "
+                    f"same num_kv_heads as the image shard, got joint_k.heads="
+                    f"{joint_k.shape[2]} vs key.heads={key.shape[2]}."
+                )
+            if joint_strategy == "front":
+                k_full = torch.cat([joint_k, k_img_full], dim=1)
+                v_full = torch.cat([joint_v, v_img_full], dim=1)
+            else:
+                k_full = torch.cat([k_img_full, joint_k], dim=1)
+                v_full = torch.cat([v_img_full, joint_v], dim=1)
+        else:
+            k_full, v_full = k_img_full, v_img_full
+
+        joint_len = joint_q.shape[1] if joint_q is not None else 0
+        logical_q_full_len = joint_len + k_img_full.shape[1]
+        query_global_offset = k_full.shape[1] - logical_q_full_len
+        if query_global_offset < 0:
+            raise ValueError(
+                "AllGather-KV SP global K length is shorter than the logical Q length: "
+                f"k_len={k_full.shape[1]}, logical_q_len={logical_q_full_len}."
+            )
+
+        if joint_q is not None:
+            if joint_strategy == "front":
+                q_local = torch.cat([joint_q, query], dim=1)
+            else:
+                q_local = torch.cat([query, joint_q], dim=1)
+        else:
+            q_local = query
+
+        attn_metadata = self._slice_attn_metadata_for_local_query(
+            attn_metadata,
+            q_local_len=q_local.shape[1],
+            img_seq_local=query.shape[1],
+            img_seq_full=k_img_full.shape[1],
+            joint_len=joint_len,
+            joint_strategy=joint_strategy,
+            query_global_offset=query_global_offset,
+        )
+
+        return q_local, k_full, v_full, attn_metadata, _AllGatherKVCtx(name=self.name)
+
+    def _slice_attn_metadata_for_local_query(
+        self,
+        attn_metadata: AttentionMetadata | None,
+        *,
+        q_local_len: int,
+        img_seq_local: int,
+        img_seq_full: int,
+        joint_len: int,
+        joint_strategy: str,
+        query_global_offset: int,
+    ) -> AttentionMetadata | None:
+        """Slice global query metadata for the local query shard."""
+        if attn_metadata is None:
+            return None
+
+        img_start = self._sp_rank * img_seq_local
+        img_end = img_start + img_seq_local
+        if img_end > img_seq_full:
+            raise ValueError(
+                "AllGather-KV SP local image query range exceeds gathered image length: "
+                f"rank={self._sp_rank}, img_start={img_start}, img_end={img_end}, img_seq_full={img_seq_full}."
+            )
+
+        if joint_strategy == "front":
+            ranges = (
+                *((QueryRange(0, joint_len, query_global_offset),) if joint_len else ()),
+                QueryRange(joint_len, q_local_len, query_global_offset + joint_len + img_start),
+            )
+        else:
+            ranges = (
+                QueryRange(0, img_seq_local, query_global_offset + img_start),
+                *((QueryRange(img_seq_local, q_local_len, query_global_offset + img_seq_full),) if joint_len else ()),
+            )
+
+        if attn_metadata.attn_mask is None:
+            return replace(attn_metadata, query_ranges=ranges)
+
+        mask = attn_metadata.attn_mask
+        if mask.ndim != 4:
+            return replace(attn_metadata, query_ranges=ranges)
+
+        if mask.shape[-2] == q_local_len:
+            local_mask = mask
+        else:
+            q_full_len = joint_len + img_seq_full
+            if mask.shape[-2] != q_full_len:
+                raise ValueError(
+                    "AllGather-KV SP received an attention mask with incompatible Q length: "
+                    f"mask_q={mask.shape[-2]}, expected local_q={q_local_len} or full_q={q_full_len} "
+                    f"(joint_len={joint_len}, img_seq_local={img_seq_local}, img_seq_full={img_seq_full})."
+                )
+
+            parts = [
+                mask[..., local_start : local_start + (r.local_end - r.local_start), :]
+                for r in ranges
+                for local_start in (r.global_start - query_global_offset,)
+            ]
+            local_mask = torch.cat(parts, dim=-2)
+
+        if local_mask.shape[-2] != q_local_len:
+            raise ValueError(
+                "AllGather-KV SP produced an attention mask with incompatible local Q length: "
+                f"mask_q={local_mask.shape[-2]}, q_local={q_local_len}."
+            )
+        return replace(attn_metadata, attn_mask=local_mask.contiguous(), query_ranges=ranges)
+
+    def post_attention(
+        self,
+        attn_output: torch.Tensor,
+        ctx: ParallelAttentionContext | None,
+    ) -> torch.Tensor:
+        return attn_output
diff --git a/vllm_omni/diffusion/attention/parallel/factory.py b/vllm_omni/diffusion/attention/parallel/factory.py
index ce95d409a..76f7a78da 100644
--- a/vllm_omni/diffusion/attention/parallel/factory.py
+++ b/vllm_omni/diffusion/attention/parallel/factory.py
@@ -5,10 +5,19 @@ from __future__ import annotations
 
 from vllm.logger import init_logger
 
-from vllm_omni.diffusion.attention.parallel.base import NoParallelAttention, ParallelAttentionStrategy
+from vllm_omni.diffusion.attention.parallel.allgather_kv import (
+    AllGatherKVParallelAttention,
+)
+from vllm_omni.diffusion.attention.parallel.base import (
+    NoParallelAttention,
+    ParallelAttentionStrategy,
+)
 from vllm_omni.diffusion.attention.parallel.ring import RingParallelAttention
 from vllm_omni.diffusion.attention.parallel.ulysses import UlyssesParallelAttention
-from vllm_omni.diffusion.distributed.parallel_state import get_sequence_parallel_world_size, get_sp_group
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_sequence_parallel_world_size,
+    get_sp_group,
+)
 from vllm_omni.diffusion.forward_context import get_forward_context
 
 logger = init_logger(__name__)
@@ -19,6 +28,7 @@ def build_parallel_attention_strategy(
     scatter_idx: int,
     gather_idx: int,
     use_sync: bool,
+    causal: bool = False,
 ) -> ParallelAttentionStrategy:
     """Select a parallel attention strategy based on current diffusion config.
 
@@ -36,6 +46,7 @@ def build_parallel_attention_strategy(
 
     ulysses_degree = getattr(p, "ulysses_degree", 1)
     ring_degree = getattr(p, "ring_degree", 1)
+    allgather_degree = getattr(p, "allgather_degree", 1)
 
     try:
         sp_group = get_sp_group()
@@ -44,13 +55,26 @@ def build_parallel_attention_strategy(
             return NoParallelAttention()
     except Exception as e:
         # Log warning if SP is configured but group is not available
-        if ulysses_degree > 1 or ring_degree > 1:
+        if ulysses_degree > 1 or ring_degree > 1 or allgather_degree > 1:
             logger.warning(
-                f"SP configured (ulysses={ulysses_degree}, ring={ring_degree}) but SP group not available: {e}. "
+                f"SP configured (ulysses={ulysses_degree}, ring={ring_degree}, "
+                f"allgather={allgather_degree}) but SP group not available: {e}. "
                 f"Falling back to NoParallelAttention. This may cause incorrect results."
             )
         return NoParallelAttention()
 
+    if allgather_degree > 1:
+        if causal:
+            raise ValueError("AllGather-KV SP only supports non-causal attention.")
+        if ulysses_degree > 1 or ring_degree > 1:
+            raise ValueError(
+                f"AllGather-KV SP is mutually exclusive with Ulysses/Ring in v1 "
+                f"(got ulysses_degree={ulysses_degree}, ring_degree={ring_degree}, "
+                f"allgather_degree={allgather_degree})."
+            )
+        logger.debug(f"Using AllGatherKVParallelAttention (allgather_degree={allgather_degree})")
+        return AllGatherKVParallelAttention(sp_group=sp_group)
+
     # Ulysses (or Hybrid Ulysses+Ring)
     if ulysses_degree > 1:
         logger.debug(f"Using UlyssesParallelAttention (ulysses_degree={ulysses_degree})")
diff --git a/vllm_omni/diffusion/attention/parallel/ring.py b/vllm_omni/diffusion/attention/parallel/ring.py
index 745b25ccf..74c6fc3fb 100644
--- a/vllm_omni/diffusion/attention/parallel/ring.py
+++ b/vllm_omni/diffusion/attention/parallel/ring.py
@@ -10,7 +10,7 @@ import torch
 from vllm.logger import init_logger
 
 # import torch.distributed as dist # Not used directly here, but good practice if needed
-from vllm_omni.diffusion.attention.backends.ring.ring_globals import HAS_AITER, HAS_FA3, HAS_FLASH_ATTN
+from vllm_omni.diffusion.attention.backends.ring.ring_globals import HAS_AITER, HAS_FA3, HAS_FA4, HAS_FLASH_ATTN
 from vllm_omni.diffusion.attention.backends.ring.ring_selector import AttnType
 from vllm_omni.diffusion.attention.parallel.base import (
     ParallelAttentionContext,
@@ -145,9 +145,12 @@ class RingParallelAttention:
 
         from vllm_omni.diffusion.attention.backends.ring_flash_attn import ring_flash_attn_func
 
-        # Prefer FA3 over FA2 for better performance (FA3 supports Ampere/Ada/Hopper)
-        # On ROCm, use AITER
-        if HAS_FA3:
+        # Prefer FA4 on Blackwell. An importable Hopper-only FA3 wheel can
+        # otherwise be selected and fail at launch with "no kernel image".
+        if HAS_FA4 and query.is_cuda and torch.cuda.get_device_capability(query.device)[0] >= 10:
+            attn_type = AttnType.FA4
+        # Prefer FA3 over FA2 on Ampere/Ada/Hopper. On ROCm, use AITER.
+        elif HAS_FA3:
             attn_type = AttnType.FA3
         elif HAS_AITER:
             attn_type = AttnType.AITER
diff --git a/vllm_omni/diffusion/attention/selector.py b/vllm_omni/diffusion/attention/selector.py
index 6eede02c2..9d357b4f6 100644
--- a/vllm_omni/diffusion/attention/selector.py
+++ b/vllm_omni/diffusion/attention/selector.py
@@ -51,18 +51,20 @@ def _load_backend_cls(cls_path: str) -> type[AttentionBackend]:
 def _cached_get_backend_cls(
     backend_name: str | None,
     head_size: int,
+    allow_trtllm_default: bool = True,
 ) -> type[AttentionBackend]:
-    """Cache backend class resolution by (backend_name, head_size).
+    """Cache backend class resolution by (backend_name, head_size, allow_trtllm_default).
 
     This ensures platform validation (compute capability checks, package
-    availability, etc.) runs only once per unique (backend_name, head_size)
-    combination, avoiding repeated log messages.
+    availability, etc.) runs only once per unique combination, avoiding
+    repeated log messages.
     """
     from vllm_omni.platforms import current_omni_platform
 
     backend_cls_path = current_omni_platform.get_diffusion_attn_backend_cls(
         selected_backend=backend_name,
         head_size=head_size,
+        allow_trtllm_default=allow_trtllm_default,
     )
     return _load_backend_cls(backend_cls_path)
 
@@ -97,6 +99,7 @@ def get_attn_backend_for_role(
     head_size: int,
     attention_config: AttentionConfig | None = None,
     role_category: str | None = None,
+    allow_trtllm_default: bool = True,
 ) -> tuple[type[AttentionBackend], AttentionSpec | None]:
     """
     Get attention backend for a specific attention role.
@@ -140,7 +143,7 @@ def get_attn_backend_for_role(
         return backend_cls, spec
 
     # 2. Platform default
-    backend_cls = _cached_get_backend_cls(None, head_size)
+    backend_cls = _cached_get_backend_cls(None, head_size, allow_trtllm_default)
     _log_backend_resolution(
         role=role,
         role_category=role_category,
diff --git a/vllm_omni/diffusion/cache/cachedit/__init__.py b/vllm_omni/diffusion/cache/cachedit/__init__.py
new file mode 100644
index 000000000..f3d075489
--- /dev/null
+++ b/vllm_omni/diffusion/cache/cachedit/__init__.py
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Public API for the Cache-DiT diffusion cache backend."""
+
+from vllm_omni.diffusion.cache.cachedit.backend import (
+    CUSTOM_DIT_ENABLERS,
+    CacheDiTBackend,
+    cache_summary,
+    enable_cache_for_dit,
+)
+from vllm_omni.diffusion.cache.cachedit.config import (
+    CacheDiTAdapterConfig,
+    CacheDiTConfig,
+)
+from vllm_omni.diffusion.cache.cachedit.model_specific import (
+    BagelCachedAdapter,
+    SensenovaCachedAdapter,
+)
+from vllm_omni.diffusion.cache.cachedit.model_specific import (
+    register_custom_dit_enablers as _register_custom_dit_enablers,
+)
+
+_register_custom_dit_enablers()
+
+__all__ = [
+    "BagelCachedAdapter",
+    "CUSTOM_DIT_ENABLERS",
+    "CacheDiTAdapterConfig",
+    "CacheDiTBackend",
+    "CacheDiTConfig",
+    "SensenovaCachedAdapter",
+    "cache_summary",
+    "enable_cache_for_dit",
+]
diff --git a/vllm_omni/diffusion/cache/cachedit/backend.py b/vllm_omni/diffusion/cache/cachedit/backend.py
new file mode 100644
index 000000000..c30a888a8
--- /dev/null
+++ b/vllm_omni/diffusion/cache/cachedit/backend.py
@@ -0,0 +1,263 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Generic Cache-DiT backend lifecycle and integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeAlias, cast
+
+import cache_dit
+import torch.nn as nn
+from cache_dit import BlockAdapter, DBCacheConfig
+from cache_dit.caching.cache_adapters.cache_adapter import CachedAdapter
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.cache.base import CacheBackend
+from vllm_omni.diffusion.cache.cachedit.config import (
+    CacheDiTAdapterConfig,
+    CacheDiTConfig,
+)
+from vllm_omni.diffusion.data import DiffusionCacheConfig
+
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
+
+logger = init_logger(__name__)
+
+RefreshCacheContextFunc: TypeAlias = Callable[[Any, int, bool], None]
+CacheDiTEnabler: TypeAlias = Callable[[Any, DiffusionCacheConfig], RefreshCacheContextFunc]
+
+# Model-specific implementations register themselves when the package loads.
+CUSTOM_DIT_ENABLERS: dict[str, CacheDiTEnabler] = {}
+
+
+def _dit_module_names(pipeline: SupportsComponentDiscovery) -> tuple[str, ...]:
+    """Return the pipeline DiT attributes that are present at runtime."""
+    names = getattr(pipeline, "_dit_modules", None)
+    if not isinstance(names, (list, tuple)):
+        names = ("transformer",)
+    return tuple(name for name in names if isinstance(name, str) and getattr(pipeline, name, None) is not None)
+
+
+def cache_summary(pipeline: SupportsComponentDiscovery, details: bool = True) -> None:
+    """Log Cache-DiT statistics for every transformer on the pipeline."""
+
+    transformers = [getattr(pipeline, name) for name in _dit_module_names(pipeline)]
+    for transformer in transformers:
+        cache_dit.summary(transformer, details=details)
+
+    if not transformers:
+        logger.warning("CacheDiT summary failed; this pipeline has no defined transformer attribute")
+
+
+def _default_get_pipeline_transformer(
+    pipeline: SupportsComponentDiscovery,
+) -> nn.Module:
+    return cast(nn.Module, getattr(pipeline, "transformer"))
+
+
+def _make_pipeline_transformer_getter(
+    name: str,
+) -> Callable[[SupportsComponentDiscovery], nn.Module]:
+    def get_pipeline_transformer(
+        pipeline: SupportsComponentDiscovery,
+    ) -> nn.Module:
+        return cast(nn.Module, getattr(pipeline, name))
+
+    return get_pipeline_transformer
+
+
+def _build_cache_context_refresh(
+    cache_config: DiffusionCacheConfig,
+    get_pipeline_transformer: Callable[[SupportsComponentDiscovery], nn.Module] = _default_get_pipeline_transformer,
+) -> RefreshCacheContextFunc:
+    """Build the cache context refresh callback for one transformer."""
+
+    projected_config = CacheDiTConfig.from_diffusion_config(cache_config)
+
+    def refresh_cache_context(
+        pipeline: SupportsComponentDiscovery, num_inference_steps: int, verbose: bool = True
+    ) -> None:
+        transformer = get_pipeline_transformer(pipeline)
+
+        # Cache-DiT has no predefined SCM mask for these small step counts.
+        scm_supported_steps = num_inference_steps >= 8 or num_inference_steps in (4, 6)
+        if projected_config.scm_steps_mask_policy is None or not scm_supported_steps:
+            cache_dit.refresh_context(transformer, num_inference_steps=num_inference_steps, verbose=verbose)
+            return
+
+        cache_dit.refresh_context(
+            transformer,
+            cache_config=DBCacheConfig().reset(
+                num_inference_steps=num_inference_steps,
+                steps_computation_mask=cache_dit.steps_mask(
+                    mask_policy=projected_config.scm_steps_mask_policy,
+                    total_steps=num_inference_steps,
+                ),
+                steps_computation_policy=projected_config.scm_steps_policy,
+            ),
+            verbose=verbose,
+        )
+
+    return refresh_cache_context
+
+
+def enable_cache_for_dit(
+    pipeline: SupportsComponentDiscovery,
+    cache_config: DiffusionCacheConfig,
+    block_adapter: BlockAdapter | None = None,
+    adapter_cls: type[CachedAdapter] | None = None,
+    get_pipeline_transformer: Callable[[SupportsComponentDiscovery], nn.Module] = _default_get_pipeline_transformer,
+) -> RefreshCacheContextFunc:
+    """Enable Cache-DiT for a standard single-transformer DiT pipeline."""
+
+    projected_config = CacheDiTConfig.from_diffusion_config(cache_config)
+    db_cache_config = projected_config.to_db_cache_config()
+    calibrator_config = projected_config.to_calibrator_config()
+
+    logger.info(
+        "Enabling cache-dit on transformer: Fn=%s, Bn=%s, W=%s",
+        db_cache_config.Fn_compute_blocks,
+        db_cache_config.Bn_compute_blocks,
+        db_cache_config.max_warmup_steps,
+    )
+
+    transformer = get_pipeline_transformer(pipeline)
+    cache_target = transformer if block_adapter is None else block_adapter
+    if adapter_cls is not None:
+        adapter_cls.apply(
+            cache_target,
+            cache_config=db_cache_config,
+            calibrator_config=calibrator_config,
+        )
+    elif block_adapter is None:
+        try:
+            cache_dit.enable_cache(
+                cache_target,
+                cache_config=db_cache_config,
+                calibrator_config=calibrator_config,
+            )
+        except ValueError as exc:
+            raise ValueError(
+                "Failed to enable Cache-DiT for pipeline "
+                f"{type(pipeline).__name__} with transformer "
+                f"{type(transformer).__name__}: no model-declared "
+                "_cache_dit_adapter_config or compatible Cache-DiT built-in "
+                "adapter was found."
+            ) from exc
+    else:
+        cache_dit.enable_cache(
+            cache_target,
+            cache_config=db_cache_config,
+            calibrator_config=calibrator_config,
+        )
+
+    return _build_cache_context_refresh(cache_config, get_pipeline_transformer)
+
+
+def _maybe_build_block_adapter(
+    pipeline: SupportsComponentDiscovery,
+    get_pipeline_transformer: Callable[[SupportsComponentDiscovery], nn.Module] = _default_get_pipeline_transformer,
+) -> BlockAdapter | None:
+    """Build the model-declared block adapter, when one is configured."""
+
+    transformer = get_pipeline_transformer(pipeline)
+    adapter_config: CacheDiTAdapterConfig | None = getattr(transformer, "_cache_dit_adapter_config", None)
+    if adapter_config is None:
+        logger.info(
+            "Transformer %s does not declare _cache_dit_adapter_config; "
+            "falling back to Cache-DiT's built-in adapter registry.",
+            type(transformer).__name__,
+        )
+        return None
+
+    block_attributes, forward_patterns = zip(*adapter_config.block_forward_patterns.items())
+    missing_attributes = [
+        block_attribute for block_attribute in block_attributes if not hasattr(transformer, block_attribute)
+    ]
+    if missing_attributes:
+        raise AttributeError(f"Missing Cache-DiT block attributes: {missing_attributes}")
+
+    return BlockAdapter(
+        transformer=transformer,
+        blocks=[getattr(transformer, block_attribute) for block_attribute in block_attributes],
+        forward_pattern=list(forward_patterns),
+        has_separate_cfg=adapter_config.has_separate_cfg,
+        check_forward_pattern=adapter_config.check_forward_pattern,
+    )
+
+
+def _maybe_get_cached_adapter_cls(
+    pipeline: SupportsComponentDiscovery,
+    get_pipeline_transformer: Callable[[SupportsComponentDiscovery], nn.Module] = _default_get_pipeline_transformer,
+) -> type[CachedAdapter] | None:
+    """Return the custom cached adapter declared by the transformer."""
+
+    transformer = get_pipeline_transformer(pipeline)
+    adapter_config: CacheDiTAdapterConfig | None = getattr(transformer, "_cache_dit_adapter_config", None)
+    return None if adapter_config is None else adapter_config.cached_adapter_cls
+
+
+class CacheDiTBackend(CacheBackend):
+    """Manage Cache-DiT through the common diffusion cache lifecycle."""
+
+    def __init__(self, cache_config: Any = None):
+        if cache_config is None:
+            config = DiffusionCacheConfig()
+        elif isinstance(cache_config, dict):
+            config = DiffusionCacheConfig.from_dict(cache_config)
+        else:
+            config = cache_config
+
+        super().__init__(config)
+        self._refresh_funcs: list[RefreshCacheContextFunc] = []
+
+    def enable(self, pipeline: SupportsComponentDiscovery) -> None:
+        pipeline_name = type(pipeline).__name__
+        custom_enabler = CUSTOM_DIT_ENABLERS.get(pipeline_name)
+        if custom_enabler is not None:
+            logger.info("Using custom cache-dit enabler for model: %s", pipeline_name)
+            self._refresh_funcs = [custom_enabler(pipeline, self.config)]
+        else:
+            self._refresh_funcs = []
+            for name in _dit_module_names(pipeline):
+                get_transformer = _make_pipeline_transformer_getter(name)
+                block_adapter = _maybe_build_block_adapter(pipeline, get_transformer)
+                adapter_cls = _maybe_get_cached_adapter_cls(pipeline, get_transformer)
+                self._refresh_funcs.append(
+                    enable_cache_for_dit(
+                        pipeline,
+                        self.config,
+                        block_adapter,
+                        adapter_cls,
+                        get_transformer,
+                    )
+                )
+            if not self._refresh_funcs:
+                raise ValueError(f"Pipeline {pipeline_name} has no declared DiT modules for Cache-DiT")
+
+        self.enabled = True
+        logger.info("Cache-dit enabled successfully on %s", pipeline_name)
+
+    def refresh(self, pipeline: SupportsComponentDiscovery, num_inference_steps: int, verbose: bool = True) -> None:
+        if not self.enabled or not self._refresh_funcs:
+            logger.warning("Cache-dit is not enabled. Cannot refresh cache context.")
+            return
+
+        if verbose:
+            logger.info(
+                "Refreshing cache context for transformer with num_inference_steps: %s",
+                num_inference_steps,
+            )
+        for refresh_func in self._refresh_funcs:
+            refresh_func(pipeline, num_inference_steps, verbose)
+
+
+__all__ = [
+    "CUSTOM_DIT_ENABLERS",
+    "CacheDiTBackend",
+    "cache_summary",
+    "enable_cache_for_dit",
+]
diff --git a/vllm_omni/diffusion/cache/cachedit/config.py b/vllm_omni/diffusion/cache/cachedit/config.py
new file mode 100644
index 000000000..8fcaa517b
--- /dev/null
+++ b/vllm_omni/diffusion/cache/cachedit/config.py
@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Configuration types and conversion helpers for Cache-DiT."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from cache_dit import (
+    CalibratorConfig,
+    DBCacheConfig,
+    ForwardPattern,
+    TaylorSeerCalibratorConfig,
+)
+from cache_dit.caching.cache_adapters.cache_adapter import CachedAdapter
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.data import DiffusionCacheConfig
+
+logger = init_logger(__name__)
+
+
+@dataclass
+class CacheDiTAdapterConfig:
+    """Describe how Cache-DiT wraps a model's transformer blocks."""
+
+    block_forward_patterns: dict[str, ForwardPattern]
+    has_separate_cfg: bool = False
+    cached_adapter_cls: type[CachedAdapter] | None = None
+    check_forward_pattern: bool = True
+
+
+@dataclass(frozen=True)
+class CacheDiTConfig:
+    """Cache-DiT-specific projection of the shared diffusion cache config."""
+
+    Fn_compute_blocks: int = 1
+    Bn_compute_blocks: int = 0
+    max_warmup_steps: int = 4
+    max_cached_steps: int = -1
+    residual_diff_threshold: float = 0.24
+    max_continuous_cached_steps: int = 3
+    enable_taylorseer: bool = False
+    taylorseer_order: int = 1
+    scm_steps_mask_policy: str | None = None
+    scm_steps_policy: str = "dynamic"
+    force_refresh_step_hint: int | None = None
+    force_refresh_step_policy: str = "once"
+
+    @classmethod
+    def from_diffusion_config(cls, config: DiffusionCacheConfig) -> CacheDiTConfig:
+        """Project the shared config onto fields consumed by Cache-DiT."""
+
+        return cls(
+            Fn_compute_blocks=config.Fn_compute_blocks,
+            Bn_compute_blocks=config.Bn_compute_blocks,
+            max_warmup_steps=config.max_warmup_steps,
+            max_cached_steps=config.max_cached_steps,
+            residual_diff_threshold=config.residual_diff_threshold,
+            max_continuous_cached_steps=config.max_continuous_cached_steps,
+            enable_taylorseer=config.enable_taylorseer,
+            taylorseer_order=config.taylorseer_order,
+            scm_steps_mask_policy=config.scm_steps_mask_policy,
+            scm_steps_policy=config.scm_steps_policy,
+            force_refresh_step_hint=config.force_refresh_step_hint,
+            force_refresh_step_policy=config.force_refresh_step_policy,
+        )
+
+    def to_db_cache_config(self) -> DBCacheConfig:
+        """Build the third-party cache configuration used during installation."""
+
+        return DBCacheConfig(
+            # The request step count is supplied by ``CacheDiTBackend.refresh``.
+            num_inference_steps=None,
+            Fn_compute_blocks=self.Fn_compute_blocks,
+            Bn_compute_blocks=self.Bn_compute_blocks,
+            max_warmup_steps=self.max_warmup_steps,
+            max_cached_steps=self.max_cached_steps,
+            max_continuous_cached_steps=self.max_continuous_cached_steps,
+            residual_diff_threshold=self.residual_diff_threshold,
+            force_refresh_step_hint=self.force_refresh_step_hint,
+            force_refresh_step_policy=self.force_refresh_step_policy,
+        )
+
+    def to_calibrator_config(self) -> CalibratorConfig | None:
+        """Build the optional TaylorSeer calibrator configuration."""
+
+        if not self.enable_taylorseer:
+            return None
+
+        logger.info("TaylorSeer enabled with order=%s", self.taylorseer_order)
+        return TaylorSeerCalibratorConfig(taylorseer_order=self.taylorseer_order)
+
+
+__all__ = ["CacheDiTAdapterConfig", "CacheDiTConfig"]
diff --git a/vllm_omni/diffusion/cache/cache_dit_backend.py b/vllm_omni/diffusion/cache/cachedit/model_specific.py
similarity index 67%
rename from vllm_omni/diffusion/cache/cache_dit_backend.py
rename to vllm_omni/diffusion/cache/cachedit/model_specific.py
index 48e64de0a..f7af987ce 100644
--- a/vllm_omni/diffusion/cache/cache_dit_backend.py
+++ b/vllm_omni/diffusion/cache/cachedit/model_specific.py
@@ -1,27 +1,19 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""
-cache-dit integration backend for vllm-omni.
 
-This module provides a CacheDiTBackend class to enable cache-dit acceleration on diffusion
-pipelines in vllm-omni, supporting both single and dual-transformer architectures.
-"""
+"""Model-specific Cache-DiT adapters and enablers."""
 
 import functools
-from collections.abc import Callable
 from contextlib import ExitStack
-from dataclasses import dataclass
-from typing import Any, Optional, TypeAlias
+from typing import Any
 
 import cache_dit
 import torch
 from cache_dit import (
     BlockAdapter,
-    CalibratorConfig,
     DBCacheConfig,
     ForwardPattern,
     ParamsModifier,
-    TaylorSeerCalibratorConfig,
 )
 from cache_dit.caching.block_adapters import FakeDiffusionPipeline
 from cache_dit.caching.cache_adapters.cache_adapter import CachedAdapter
@@ -31,178 +23,18 @@ from cache_dit.caching.cache_contexts import BasicCacheConfig
 from cache_dit.caching.cache_contexts.cache_manager import CachedContextManager
 from vllm.logger import init_logger
 
-from vllm_omni.diffusion.cache.base import CacheBackend
-from vllm_omni.diffusion.data import DiffusionCacheConfig, OmniDiffusionConfig
+from vllm_omni.diffusion.cache.cachedit.backend import (
+    CUSTOM_DIT_ENABLERS,
+    RefreshCacheContextFunc,
+    _build_cache_context_refresh,
+    _default_get_pipeline_transformer,
+    _maybe_build_block_adapter,
+    enable_cache_for_dit,
+)
+from vllm_omni.diffusion.cache.cachedit.config import CacheDiTConfig
 
 logger = init_logger(__name__)
 
-RefreshCacheContextFunc: TypeAlias = Callable[[Any, int, bool], None]
-
-
-@dataclass
-class CacheDiTAdapterConfig:
-    """Config for creating a Cache DiT's block adapter; to enable CacheDiT,
-    most models just need to define an instance of this class as a class
-    var in the DiT.
-    """
-
-    block_forward_patterns: dict[str, ForwardPattern]
-    has_separate_cfg: bool = False
-    cached_adapter_cls: type[CachedAdapter] | None = None
-    check_forward_pattern: bool = True
-
-
-# Registry of custom cache-dit enablers for specific models
-# Maps pipeline names to their cache-dit enablement functions
-CUSTOM_DIT_ENABLERS: dict[str, Callable] = {}
-
-
-# Small helper to centralize cache-dit summaries.
-def cache_summary(pipeline: Any, details: bool = True) -> None:
-    if hasattr(pipeline, "transformer"):
-        cache_dit.summary(pipeline.transformer, details=details)
-    if hasattr(pipeline, "transformer_2"):
-        cache_dit.summary(pipeline.transformer_2, details=details)
-    if not hasattr(pipeline, "transformer") and not hasattr(pipeline, "transformer_2"):
-        logger.warning("CacheDiT summary failed; this pipeline has no defined transformer attribute")
-
-
-def default_get_pipeline_transformer(pipeline: Any) -> Any:
-    return pipeline.transformer
-
-
-def build_cache_context_refresh(
-    cache_config: DiffusionCacheConfig,
-    get_pipeline_transformer: Callable[[Any], Any] = default_get_pipeline_transformer,
-) -> RefreshCacheContextFunc:
-    """Build the cache context refresh func for a single Transformer."""
-
-    def refresh_cache_context(pipeline: Any, num_inference_steps: int, verbose: bool = True) -> None:
-        """Refresh cache context for the transformer with new num_inference_steps.
-
-        Args:
-            pipeline: The pipeline instance.
-            num_inference_steps: New number of inference steps.
-        """
-        transformer = get_pipeline_transformer(pipeline)
-
-        # Bypass SCM for step counts that don't support predefined masks (e.g., vLLM's 1-step dummy run)
-        scm_supported_steps = num_inference_steps >= 8 or num_inference_steps in (4, 6)
-
-        if cache_config.scm_steps_mask_policy is None or not scm_supported_steps:
-            cache_dit.refresh_context(transformer, num_inference_steps=num_inference_steps, verbose=verbose)
-        else:
-            cache_dit.refresh_context(
-                transformer,
-                cache_config=DBCacheConfig().reset(
-                    num_inference_steps=num_inference_steps,
-                    steps_computation_mask=cache_dit.steps_mask(
-                        mask_policy=cache_config.scm_steps_mask_policy,
-                        total_steps=num_inference_steps,
-                    ),
-                    steps_computation_policy=cache_config.scm_steps_policy,
-                ),
-                verbose=verbose,
-            )
-
-    return refresh_cache_context
-
-
-def _resolve_calibrator_config(cache_config: DiffusionCacheConfig) -> CalibratorConfig | None:
-    """Resolves the Calibrator subconfig For DiT cache."""
-    calibrator = None
-    if cache_config.enable_taylorseer:
-        taylorseer_order = cache_config.taylorseer_order
-        calibrator = TaylorSeerCalibratorConfig(taylorseer_order=taylorseer_order)
-        logger.info(f"TaylorSeer enabled with order={taylorseer_order}")
-    # In the future, more calibrators will likely be added to DiT Cache,
-    # e.g., focal; handle them generically here.
-    return calibrator
-
-
-def _build_db_cache_config(cache_config: DiffusionCacheConfig) -> DBCacheConfig:
-    """Build DBCacheConfig with optional SCM (Step Computation Masking) support.
-
-    Args:
-        cache_config: DiffusionCacheConfig instance.
-
-    Returns:
-        DBCacheConfig instance with SCM support if configured.
-    """
-    return DBCacheConfig(
-        # we will refresh the context when we get num_inference_steps in the first inference request
-        num_inference_steps=None,
-        Fn_compute_blocks=cache_config.Fn_compute_blocks,
-        Bn_compute_blocks=cache_config.Bn_compute_blocks,
-        max_warmup_steps=cache_config.max_warmup_steps,
-        max_cached_steps=cache_config.max_cached_steps,
-        max_continuous_cached_steps=cache_config.max_continuous_cached_steps,
-        residual_diff_threshold=cache_config.residual_diff_threshold,
-        force_refresh_step_hint=cache_config.force_refresh_step_hint,
-        force_refresh_step_policy=cache_config.force_refresh_step_policy,
-    )
-
-
-def enable_cache_for_dit(
-    pipeline: Any,
-    cache_config: Any,
-    block_adapter: BlockAdapter | None = None,
-    adapter_cls: type[CachedAdapter] | None = None,
-) -> RefreshCacheContextFunc:
-    """Enable cache-dit for regular single-transformer DiT models.
-
-    Args:
-        pipeline: The diffusion pipeline instance.
-        cache_config: DiffusionCacheConfig instance with cache configuration.
-        block_adapter: Custom block adapters for specific model architectures.
-        adapter_cls: Custom cached adapter class for specific model architectures.
-
-    Returns:
-        A refresh function that can be called to update cache context with new num_inference_steps.
-    """
-    # Build DBCacheConfig with optional SCM support
-    db_cache_config = _build_db_cache_config(cache_config)
-
-    # Build calibrator config if TaylorSeer is enabled
-    calibrator_config = _resolve_calibrator_config(cache_config)
-
-    logger.info(
-        f"Enabling cache-dit on transformer: "
-        f"Fn={db_cache_config.Fn_compute_blocks}, "
-        f"Bn={db_cache_config.Bn_compute_blocks}, "
-        f"W={db_cache_config.max_warmup_steps}, "
-    )
-
-    # Enable cache-dit on the transformer
-    transformer = default_get_pipeline_transformer(pipeline)
-
-    # If we have a custom cached adapter subclass, call apply directly
-    if adapter_cls is not None:
-        adapter_cls.apply(
-            transformer if block_adapter is None else block_adapter,
-            cache_config=db_cache_config,
-            calibrator_config=calibrator_config,
-        )
-    else:
-        # Otherwise, call enable cache, which will call CachedAdapter.apply for us
-        cache_dit.enable_cache(
-            transformer if block_adapter is None else block_adapter,
-            cache_config=db_cache_config,
-            calibrator_config=calibrator_config,
-        )
-
-    return build_cache_context_refresh(cache_config)
-
-
-### Complex / custom enablers for DiT cache
-# NOTE (Alex): This case is rare; you should only really need to do this if you have a dual transformer
-# architecture, since it hasn't been handled generically yet, or if the model class has unique attributes
-# that it sets during Cache DiT enablement.
-#
-# For the vast majority of models, you should only need to add a _cache_dit_adapter_config attribute
-# to the Transformer class, which controls the forward pattern, whether or not we have separate CFG,
-# and so on.
-
 
 # from https://github.com/vipshop/cache-dit/pull/542
 def _split_wan22_inference_steps(pipeline, num_inference_steps: int) -> tuple[int, int]:
@@ -249,9 +81,9 @@ def enable_cache_for_wan22(pipeline: Any, cache_config: Any) -> RefreshCacheCont
     Returns:
         A refresh function that can be called to update cache context with new num_inference_steps.
     """
-    # Build DBCacheConfig with optional SCM support
-    db_cache_config = _build_db_cache_config(cache_config)
-    calibrator_config = _resolve_calibrator_config(cache_config)
+    projected_config = CacheDiTConfig.from_diffusion_config(cache_config)
+    db_cache_config = projected_config.to_db_cache_config()
+    calibrator_config = projected_config.to_calibrator_config()
 
     if getattr(pipeline, "transformer_2", None) is None:
         logger.info("transformer_2 not found, enabling cache-dit for single transformer mode")
@@ -273,7 +105,7 @@ def enable_cache_for_wan22(pipeline: Any, cache_config: Any) -> RefreshCacheCont
             cache_config=db_cache_config,
             calibrator_config=calibrator_config,
         )
-        return build_cache_context_refresh(cache_config)
+        return _build_cache_context_refresh(cache_config)
 
     cache_dit.enable_cache(
         BlockAdapter(
@@ -296,8 +128,8 @@ def enable_cache_for_wan22(pipeline: Any, cache_config: Any) -> RefreshCacheCont
                 # high-noise transformer only have 30% steps
                 ParamsModifier(
                     cache_config=DBCacheConfig().reset(
-                        max_warmup_steps=cache_config.max_warmup_steps,
-                        max_cached_steps=cache_config.max_cached_steps,
+                        max_warmup_steps=projected_config.max_warmup_steps,
+                        max_cached_steps=projected_config.max_cached_steps,
                     ),
                     calibrator_config=calibrator_config,
                 ),
@@ -315,8 +147,8 @@ def enable_cache_for_wan22(pipeline: Any, cache_config: Any) -> RefreshCacheCont
         calibrator_config=calibrator_config,
     )
 
-    refresh_trans_one = build_cache_context_refresh(cache_config)
-    refresh_trans_two = build_cache_context_refresh(cache_config, lambda pipeline: pipeline.transformer_2)
+    refresh_trans_one = _build_cache_context_refresh(cache_config)
+    refresh_trans_two = _build_cache_context_refresh(cache_config, lambda pipeline: pipeline.transformer_2)
 
     def refresh_cache_context(pipeline: Any, num_inference_steps: int, verbose: bool = True) -> None:
         """Refresh cache context for both transformers with new num_inference_steps.
@@ -347,12 +179,9 @@ def enable_cache_for_wan22_s2v(pipeline: Any, cache_config: Any) -> RefreshCache
     permanently replace it with a no-op on the transformer to prevent double
     injection from the main forward loop.
     """
-    db_cache_config = _build_db_cache_config(cache_config)
-    calibrator_config = None
-    if cache_config.enable_taylorseer:
-        taylorseer_order = cache_config.taylorseer_order
-        calibrator_config = TaylorSeerCalibratorConfig(taylorseer_order=taylorseer_order)
-        logger.info(f"TaylorSeer enabled with order={taylorseer_order}")
+    projected_config = CacheDiTConfig.from_diffusion_config(cache_config)
+    db_cache_config = projected_config.to_db_cache_config()
+    calibrator_config = projected_config.to_calibrator_config()
 
     # Save the original after_transformer_block before cache-dit wrapping
     transformer = pipeline.transformer
@@ -383,7 +212,7 @@ def enable_cache_for_wan22_s2v(pipeline: Any, cache_config: Any) -> RefreshCache
 
     def refresh_cache_context(pipeline: Any, num_inference_steps: int, verbose: bool = True) -> None:
         """Refresh cache context for the S2V transformer."""
-        if cache_config.scm_steps_mask_policy is None:
+        if projected_config.scm_steps_mask_policy is None:
             cache_dit.refresh_context(
                 pipeline.transformer,
                 num_inference_steps=num_inference_steps,
@@ -395,10 +224,10 @@ def enable_cache_for_wan22_s2v(pipeline: Any, cache_config: Any) -> RefreshCache
                 cache_config=DBCacheConfig().reset(
                     num_inference_steps=num_inference_steps,
                     steps_computation_mask=cache_dit.steps_mask(
-                        mask_policy=cache_config.scm_steps_mask_policy,
+                        mask_policy=projected_config.scm_steps_mask_policy,
                         total_steps=num_inference_steps,
                     ),
-                    steps_computation_policy=cache_config.scm_steps_policy,
+                    steps_computation_policy=projected_config.scm_steps_policy,
                 ),
                 verbose=verbose,
             )
@@ -971,7 +800,7 @@ def enable_cache_for_cosmos3(pipeline: Any, cache_config: Any) -> RefreshCacheCo
     # step accounting. Still do both cond/uncond CFG steps when cache-dit is active.
     # CFG is instead neutralized via scale=1.0 outside the interval.
     pipeline._cache_dit_requires_paired_cfg = True
-    block_adapter = CacheDiTBackend.maybe_build_block_adapter(pipeline)
+    block_adapter = _maybe_build_block_adapter(pipeline)
     return enable_cache_for_dit(pipeline, cache_config, block_adapter)
 
 
@@ -996,7 +825,7 @@ def enable_cache_for_krea2(pipeline: Any, cache_config: Any) -> RefreshCacheCont
     Returns:
         A refresh function that can be called to update cache context with new num_inference_steps.
     """
-    transformer = default_get_pipeline_transformer(pipeline)
+    transformer = _default_get_pipeline_transformer(pipeline)
     block_adapter = BlockAdapter(
         transformer=transformer,
         blocks=[transformer.transformer_blocks],
@@ -1007,170 +836,28 @@ def enable_cache_for_krea2(pipeline: Any, cache_config: Any) -> RefreshCacheCont
     return enable_cache_for_dit(pipeline, cache_config, block_adapter)
 
 
-# Register custom cache-dit enablers after function definitions
-CUSTOM_DIT_ENABLERS.update(
-    {
-        "Wan22Pipeline": enable_cache_for_wan22,
-        "Wan22I2VPipeline": enable_cache_for_wan22,
-        "Wan22TI2VPipeline": enable_cache_for_wan22,
-        "Wan22VACEPipeline": enable_cache_for_wan22,
-        "Wan22S2VPipeline": enable_cache_for_wan22_s2v,
-        "Cosmos3OmniDiffusersPipeline": enable_cache_for_cosmos3,
-        "Krea2Pipeline": enable_cache_for_krea2,
-    }
-)
+def register_custom_dit_enablers() -> None:
+    """Register model-specific Cache-DiT enablers.
 
-
-class CacheDiTBackend(CacheBackend):
-    """Backend class for cache-dit acceleration on diffusion pipelines.
-
-    This class implements cache-dit acceleration (DBCache, SCM, TaylorSeer) using
-    the cache-dit library. It inherits from CacheBackend and provides a unified
-    interface for managing cache-dit acceleration on diffusion models.
-
-    Attributes:
-        config: Cache configuration (DiffusionCacheConfig instance), inherited from CacheBackend.
-        enabled: Whether cache-dit is enabled on this pipeline, inherited from CacheBackend.
-        _refresh_func: Internal refresh function for updating cache context.
-        _last_num_inference_steps: Last num_inference_steps used for refresh optimization.
+    This is called explicitly by the package initializer so registration does
+    not depend on unrelated model-specific symbols being imported for their
+    side effects.
     """
-
-    def __init__(self, cache_config: Any = None):
-        """Initialize the cache-dit backend.
-
-        Args:
-            cache_config: Cache configuration (DiffusionCacheConfig instance, dict, or None).
-                         If None or empty, uses default DiffusionCacheConfig().
-        """
-        # Use default config if cache_config is not provided or is empty
-        if cache_config is None:
-            config = DiffusionCacheConfig()
-        elif isinstance(cache_config, dict):
-            # Convert dict to DiffusionCacheConfig, using defaults for missing keys
-            config = DiffusionCacheConfig.from_dict(cache_config)
-        else:
-            config = cache_config
-
-        # Initialize base class with normalized config
-        super().__init__(config)
-
-        # Cache-dit specific attributes
-        self._refresh_func: Callable[[Any, int, bool], None] | None = None
-        self._last_num_inference_steps: int | None = None
-
-    @staticmethod
-    def maybe_build_block_adapter(pipeline) -> BlockAdapter | None:
-        """If a module defines `_cache_dit_adapter_config`, build the corresponding
-        block adapter.
-        """
-        transformer = default_get_pipeline_transformer(pipeline)
-
-        adapter_cfg: CacheDiTAdapterConfig | None = getattr(transformer, "_cache_dit_adapter_config", None)
-        if adapter_cfg is None:
-            return None
-
-        block_attrs, forward_pattern = zip(*(adapter_cfg.block_forward_patterns).items())
-        missing_attrs = [block_attr for block_attr in block_attrs if not hasattr(transformer, block_attr)]
-
-        if missing_attrs:
-            logger.warning("Missing Cache DiT block attributes: %s", missing_attrs)
-
-        block_adapter = BlockAdapter(
-            transformer=transformer,
-            blocks=[getattr(transformer, block_attr) for block_attr in block_attrs],
-            forward_pattern=list(forward_pattern),
-            has_separate_cfg=adapter_cfg.has_separate_cfg,
-            check_forward_pattern=adapter_cfg.check_forward_pattern,
-        )
-        return block_adapter
-
-    @staticmethod
-    def maybe_get_cached_adapter_cls(pipeline) -> type[CachedAdapter] | None:
-        """If a module has a custom cached adapter type registered, e.g., SenseNova, retrieve it
-        from the transformer's CacheDiTAdapterConfig."""
-        transformer = default_get_pipeline_transformer(pipeline)
-
-        adapter_cfg: CacheDiTAdapterConfig | None = getattr(transformer, "_cache_dit_adapter_config", None)
-        if adapter_cfg is None:
-            return None
-        return adapter_cfg.cached_adapter_cls
-
-    def enable(self, pipeline: Any) -> None:
-        """Enable cache-dit on the pipeline if configured.
-
-        This method applies cache-dit acceleration to the appropriate transformer(s)
-        in the pipeline. It handles both single-transformer and dual-transformer
-        architectures (e.g., Wan2.2).
-
-        Args:
-            pipeline: The diffusion pipeline instance.
-        """
-
-        # Extract pipeline name from pipeline
-        pipeline_name = pipeline.__class__.__name__
-        # Check if this model has a custom cache-dit enabler
-        if pipeline_name in CUSTOM_DIT_ENABLERS:
-            logger.info(f"Using custom cache-dit enabler for model: {pipeline_name}")
-            self._refresh_func = CUSTOM_DIT_ENABLERS[pipeline_name](pipeline, self.config)
-        else:
-            # Common case; either the model doesn't explicitly support dit cache yet,
-            # Or it defines its _cache_dit_adapter_config, which describes how we should
-            # create its block adapter.
-            block_adapter = self.maybe_build_block_adapter(pipeline)
-            adapter_cls = self.maybe_get_cached_adapter_cls(pipeline)
-            self._refresh_func = enable_cache_for_dit(pipeline, self.config, block_adapter, adapter_cls)
-
-        self.enabled = True
-        logger.info(f"Cache-dit enabled successfully on {pipeline_name}")
-
-    def refresh(self, pipeline: Any, num_inference_steps: int, verbose: bool = True) -> None:
-        """Refresh cache context with new num_inference_steps.
-
-        This method updates the cache context when num_inference_steps changes
-        during inference. For dual-transformer models (e.g., Wan2.2), it automatically
-        splits the steps based on boundary_ratio.
-
-        Args:
-            pipeline: The diffusion pipeline instance.
-            num_inference_steps: New number of inference steps.
-            verbose: Whether to log refresh operations.
-        """
-        if not self.enabled or self._refresh_func is None:
-            logger.warning("Cache-dit is not enabled. Cannot refresh cache context.")
-            return
-
-        # Only refresh if num_inference_steps has changed
-        if self._last_num_inference_steps is None or num_inference_steps != self._last_num_inference_steps:
-            if verbose:
-                logger.info(f"Refreshing cache context for transformer with num_inference_steps: {num_inference_steps}")
-            self._refresh_func(pipeline, num_inference_steps, verbose)
-            self._last_num_inference_steps = num_inference_steps
-
-    def is_enabled(self) -> bool:
-        """Check if cache-dit is enabled on this pipeline.
-
-        Returns:
-            True if cache-dit is enabled, False otherwise.
-        """
-        return self.enabled
+    CUSTOM_DIT_ENABLERS.update(
+        {
+            "Wan22Pipeline": enable_cache_for_wan22,
+            "Wan22I2VPipeline": enable_cache_for_wan22,
+            "Wan22TI2VPipeline": enable_cache_for_wan22,
+            "Wan22VACEPipeline": enable_cache_for_wan22,
+            "Wan22S2VPipeline": enable_cache_for_wan22_s2v,
+            "Cosmos3OmniDiffusersPipeline": enable_cache_for_cosmos3,
+            "Cosmos3OmniPipeline": enable_cache_for_cosmos3,
+            "Krea2Pipeline": enable_cache_for_krea2,
+        }
+    )
 
 
-def may_enable_cache_dit(pipeline: Any, od_config: OmniDiffusionConfig) -> Optional["CacheDiTBackend"]:
-    """Enable cache-dit on the pipeline if configured (convenience function).
-
-    This is a convenience function that creates and enables a CacheDiTBackend.
-    For new code, consider using CacheDiTBackend directly.
-
-    Args:
-        pipeline: The diffusion pipeline instance.
-        od_config: OmniDiffusionConfig with cache configuration.
-
-    Returns:
-        A CacheDiTBackend instance if cache-dit is enabled, None otherwise.
-    """
-    if od_config.cache_backend != "cache-dit" or not od_config.cache_config:
-        return None
-
-    backend = CacheDiTBackend(od_config.cache_config)
-    backend.enable(pipeline)
-    return backend if backend.is_enabled() else None
+__all__ = [
+    "BagelCachedAdapter",
+    "SensenovaCachedAdapter",
+]
diff --git a/vllm_omni/diffusion/cache/magcache/__init__.py b/vllm_omni/diffusion/cache/magcache/__init__.py
index 08f0d88fa..c68ebd169 100644
--- a/vllm_omni/diffusion/cache/magcache/__init__.py
+++ b/vllm_omni/diffusion/cache/magcache/__init__.py
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+from vllm_omni.diffusion.cache.magcache.backend import MagCacheBackend
 from vllm_omni.diffusion.cache.magcache.config import MagCacheConfig
 from vllm_omni.diffusion.cache.magcache.hook import (
     MagCacheBlockHook,
@@ -21,6 +22,7 @@ __all__ = [
     "Flux2MagCacheStrategy",
     "FluxMagCacheStrategy",
     "MagCacheBlockHook",
+    "MagCacheBackend",
     "MagCacheConfig",
     "MagCacheHeadHook",
     "MagCacheState",
diff --git a/vllm_omni/diffusion/cache/magcache/hook.py b/vllm_omni/diffusion/cache/magcache/hook.py
index 6a440e020..4b2b4ea06 100644
--- a/vllm_omni/diffusion/cache/magcache/hook.py
+++ b/vllm_omni/diffusion/cache/magcache/hook.py
@@ -143,6 +143,11 @@ class MagCacheHeadHook(ModelHook):
         if not should_compute:
             res = state.previous_residual
 
+            if self._is_tail:
+                # Single-block configuration: this hook is also the tail, so
+                # the step schedule must advance on skipped steps too.
+                self._advance_step_head(state)
+
             if isinstance(res, tuple):
                 res = tuple(r.to(hidden_states.device) for r in res)
 
@@ -363,10 +368,11 @@ class MagCacheBlockHook(ModelHook):
         state: MagCacheState = self.state_manager.get_state()
 
         if not state.should_compute:
-            res = state.previous_residual
-            if res is None:
-                res = torch.zeros_like(args[0])
-
+            # The head hook already applied the cached residual, which is the
+            # residual of the whole block stack (tail output - head input).
+            # Non-head blocks must pass their inputs through unchanged on a
+            # skipped step; adding the residual here again would apply it once
+            # per hooked block.
             if hasattr(self._metadata, "hidden_states_argument_name"):
                 arg_name = self._metadata.hidden_states_argument_name
             else:
@@ -380,27 +386,15 @@ class MagCacheBlockHook(ModelHook):
                 encoder_hidden_states = self._metadata._get_parameter_from_args_kwargs(
                     "encoder_hidden_states", args, kwargs
                 )
-
-                if self._strategy is not None:
-                    out_hidden, enc_out = self._strategy.apply_residual_tuple(hidden_states, encoder_hidden_states, res)
-                else:
-                    out_hidden = hidden_states + res
-                    enc_out = encoder_hidden_states
-
                 max_idx = max(
                     self._metadata.return_hidden_states_index, self._metadata.return_encoder_hidden_states_index
                 )
                 ret_list = [None] * (max_idx + 1)
-                ret_list[self._metadata.return_hidden_states_index] = out_hidden
-                ret_list[self._metadata.return_encoder_hidden_states_index] = enc_out
+                ret_list[self._metadata.return_hidden_states_index] = hidden_states
+                ret_list[self._metadata.return_encoder_hidden_states_index] = encoder_hidden_states
                 return tuple(ret_list)
 
-            if self._strategy is not None:
-                output = self._strategy.apply_residual(hidden_states, res)
-            else:
-                output = hidden_states + res
-
-            return output
+            return hidden_states
 
         output = self.fn_ref.original_forward(*args, **kwargs)
 
diff --git a/vllm_omni/diffusion/cache/selector.py b/vllm_omni/diffusion/cache/selector.py
index 3b002abe0..d58bada6c 100644
--- a/vllm_omni/diffusion/cache/selector.py
+++ b/vllm_omni/diffusion/cache/selector.py
@@ -1,10 +1,10 @@
 from typing import Any
 
 from vllm_omni.diffusion.cache.base import CacheBackend
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTBackend
-from vllm_omni.diffusion.cache.magcache.backend import MagCacheBackend
+from vllm_omni.diffusion.cache.cachedit import CacheDiTBackend
+from vllm_omni.diffusion.cache.magcache import MagCacheBackend
 from vllm_omni.diffusion.cache.stepcache import StepCacheBackend
-from vllm_omni.diffusion.cache.teacache.backend import TeaCacheBackend
+from vllm_omni.diffusion.cache.teacache import TeaCacheBackend
 from vllm_omni.diffusion.data import DiffusionCacheConfig
 
 
diff --git a/vllm_omni/diffusion/compile.py b/vllm_omni/diffusion/compile.py
index 45216febc..227d4f330 100644
--- a/vllm_omni/diffusion/compile.py
+++ b/vllm_omni/diffusion/compile.py
@@ -53,23 +53,29 @@ def regionally_compile(
 
     repeated_block_attrs = getattr(model, "_layerwise_offload_blocks_attrs", [])
 
-    # Check if we have modules with the specified class names
-    has_compiled_region = False
-    compiled_region_count = 0
+    # Build all compiled callables before mutating the model. This keeps setup
+    # failures atomic: callers can safely continue with the uncompiled model if
+    # torch.compile raises synchronously for any repeated block.
+    compiled_forwards: list[tuple[nn.Module, Any]] = []
     for name, submod in model.named_modules():
         if _matches_repeated_block(name, submod, repeated_blocks, repeated_block_attrs):
             # Compile the block compute while keeping nn.Module.__call__ hooks
             # outside the compiled graph.
-            submod.forward = torch.compile(submod.forward, *compile_args, **compile_kwargs)
-            has_compiled_region = True
-            compiled_region_count += 1
+            compiled_forwards.append(
+                (
+                    submod,
+                    torch.compile(submod.forward, *compile_args, **compile_kwargs),
+                )
+            )
 
-    if not has_compiled_region:
+    if not compiled_forwards:
         logger.warning(f"Regional compilation skipped because {repeated_blocks} classes are not found in the model.")
     else:
+        for submod, compiled_forward in compiled_forwards:
+            submod.forward = compiled_forward
         logger.info(
             "Regional compilation applied to %d module(s) for repeated blocks %s.",
-            compiled_region_count,
+            len(compiled_forwards),
             repeated_blocks,
         )
 
diff --git a/vllm_omni/diffusion/data.py b/vllm_omni/diffusion/data.py
index 0feab5b28..b0ef2a74a 100644
--- a/vllm_omni/diffusion/data.py
+++ b/vllm_omni/diffusion/data.py
@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 import copy
+import math
 import os
 import random
 from collections.abc import Callable, Mapping
@@ -10,6 +11,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 import diffusers
+import huggingface_hub
 import torch
 from PIL import Image
 from pydantic import Field, model_validator
@@ -19,6 +21,7 @@ from vllm.logger import init_logger
 from vllm.model_executor.layers.quantization.base_config import (
     QuantizationConfig,
 )
+from vllm.transformers_utils.repo_utils import get_model_path
 
 from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 from vllm_omni.diffusion.utils.network_utils import is_port_available
@@ -156,7 +159,9 @@ class DiffusionParallelConfig:
     """Enable expert parallelism for MoE layers (TP is still used for non-MoE layers)."""
 
     sequence_parallel_size: int | None = None
-    """Number of sequence parallel groups. sequence_parallel_size = ring_degree * ulysses_degree"""
+    """Number of sequence parallel groups.
+    sequence_parallel_size = ulysses_degree * ring_degree, or allgather_degree
+    when AllGather-KV is enabled."""
 
     ulysses_degree: int = 1
     """Number of GPUs used for ulysses sequence parallelism."""
@@ -164,6 +169,9 @@ class DiffusionParallelConfig:
     ring_degree: int = 1
     """Number of GPUs used for ring sequence parallelism."""
 
+    allgather_degree: int = 1
+    """Number of GPUs used for AllGather-KV sequence parallelism (causal=False only)."""
+
     ulysses_mode: str = "strict"
     """Ulysses sequence-parallel mode.
 
@@ -179,11 +187,21 @@ class DiffusionParallelConfig:
     """
 
     cfg_parallel_size: int = 1
-    """Number of Classifier Free Guidance (CFG) parallel groups."""
+    """Number of ranks used to execute guidance passes in parallel."""
 
     vae_patch_parallel_size: int = 1
     """Number of ranks used for VAE patch/tile parallelism (decode/encode)."""
 
+    text_encoder_tp_size: int = 1
+    """Number of ranks used to tensor-parallel shard the diffusion text encoder.
+
+    Ranks are the first ``text_encoder_tp_size`` DiT ranks.  Defaults to 1,
+    which keeps the encoder fully resident on the DiT main rank (historical
+    behavior).  Values > 1 shard the Qwen3-VL encoder across the encoder TP
+    ranks and run the encode with distributed collectives over the encoder
+    process group.
+    """
+
     vae_parallel_mode: str = "tile"
     """VAE parallel decode strategy.
 
@@ -225,18 +243,24 @@ class DiffusionParallelConfig:
         assert self.sequence_parallel_size > 0, "Sequence parallel size must be > 0"
         assert self.ulysses_degree > 0, "Ulysses degree must be > 0"
         assert self.ring_degree > 0, "Ring degree must be > 0"
+        assert self.allgather_degree > 0, "AllGather degree must be > 0"
         assert self.cfg_parallel_size > 0, "CFG parallel size must be > 0"
-        assert self.cfg_parallel_size in [1, 2, 3], (
-            f"CFG parallel size must be 1, 2, or 3, but got {self.cfg_parallel_size}"
-        )
         assert self.vae_patch_parallel_size > 0, "VAE patch parallel size must be > 0"
         assert self.vae_parallel_mode in {"tile", "spatial_shard_height", "spatial_shard_width"}, (
             "vae_parallel_mode must be one of {'tile', 'spatial_shard_height', 'spatial_shard_width'}, "
             f"but got {self.vae_parallel_mode!r}."
         )
-        assert self.sequence_parallel_size == self.ulysses_degree * self.ring_degree, (
-            "Sequence parallel size must be equal to the product of ulysses degree and ring degree,"
-            f" but got {self.sequence_parallel_size} != {self.ulysses_degree} * {self.ring_degree}"
+        if self.allgather_degree > 1:
+            assert self.ulysses_degree == 1 and self.ring_degree == 1, (
+                "AllGather-KV (allgather_degree>1) is mutually exclusive with Ulysses/Ring in v1. "
+                f"Got ulysses_degree={self.ulysses_degree}, ring_degree={self.ring_degree}, "
+                f"allgather_degree={self.allgather_degree}."
+            )
+        expected_sp_size = (
+            self.allgather_degree if self.allgather_degree > 1 else self.ulysses_degree * self.ring_degree
+        )
+        assert self.sequence_parallel_size == expected_sp_size, (
+            f"Sequence parallel size must be {expected_sp_size}, but got {self.sequence_parallel_size}"
         )
         assert self.ulysses_mode in {"strict", "advanced_uaa"}, (
             f"ulysses_mode must be one of {{'strict','advanced_uaa'}}, but got {self.ulysses_mode!r}."
@@ -250,15 +274,16 @@ class DiffusionParallelConfig:
 
     def __post_init__(self) -> None:
         if self.sequence_parallel_size is None:
-            self.sequence_parallel_size = self.ulysses_degree * self.ring_degree
+            self.sequence_parallel_size = (
+                self.allgather_degree if self.allgather_degree > 1 else self.ulysses_degree * self.ring_degree
+            )
 
         # Calculate world_size from other parallelism dimensions
         other_parallel_world_size = (
             self.pipeline_parallel_size
             * self.data_parallel_size
             * self.tensor_parallel_size
-            * self.ulysses_degree
-            * self.ring_degree
+            * self.sequence_parallel_size
             * self.cfg_parallel_size
         )
 
@@ -516,16 +541,15 @@ def resolve_model_class_name(model: str | None, diffusion_load_format: str = "de
     """
     from vllm.transformers_utils.config import get_hf_file_to_dict
 
+    from vllm_omni.diffusion.utils.hf_utils import get_diffusion_model_index
+
     if not model:
         return None
 
     is_lance_subfolder = os.path.basename(str(model).rstrip("/")) in {"Lance_3B", "Lance_3B_Video"}
 
-    # Diffusers models: read _class_name from model_index.json.
-    try:
-        model_index = get_hf_file_to_dict("model_index.json", model)
-    except Exception:
-        model_index = None
+    # Diffusers models: read _class_name from the pipeline index.
+    model_index = get_diffusion_model_index(model)
     if model_index is not None:
         return model_index.get("_class_name")
     if diffusion_load_format == "diffusers":
@@ -578,6 +602,10 @@ class OmniDiffusionConfig:
 
     model_class_name: str | None = None
 
+    # Optional model-defined startup task. Pipelines may use this to select
+    # task-specific components or weights before serving requests.
+    task_type: str | None = None
+
     dtype: torch.dtype = torch.bfloat16
 
     model_config: dict[str, Any] = field(default_factory=dict)
@@ -610,6 +638,13 @@ class OmniDiffusionConfig:
     enable_prompt_embed_cache: bool = False
     prompt_embed_cache_size: int = 32
 
+    # Opt-in: route per-session world-model state through the shared
+    # SessionStateManager (RFC #4480) instead of the model's bespoke cache.
+    # Default off; the bespoke path remains the default. A *set*
+    # OMNI_DIFFUSION_SESSION_STATE_MANAGER environment variable overrides this
+    # in both directions. See docs/features/session_state_manager.md.
+    enable_session_state_manager: bool = False
+
     # Distributed executor backend
     distributed_executor_backend: str = "mp"
     nccl_port: int | None = None
@@ -652,6 +687,16 @@ class OmniDiffusionConfig:
     enable_cpu_offload: bool = False
     # Layer-wise offloading (block-level offloading) parameters
     enable_layerwise_offload: bool = False
+    # Distributed layer-wise offloading with H2D + AllGather overlap (RFC-1)
+    enable_distributed_layerwise_offload: bool = False
+    # If True: shard weights 1/dp_size + AllGather (saves CPU memory, requires
+    # concurrent requests in DP mode). If False: each rank streams the standard
+    # loader's rank-local tensors (including TP-local shards) via H2D only.
+    # This avoids AllGather synchronization, while host memory follows the
+    # loader's existing rank-local layout instead of adding a second DP shard.
+    dlo_use_allgather: bool = True
+    # Leading main-DiT blocks kept resident by distributed layerwise offload.
+    dlo_resident_layers: int = 0
 
     pin_cpu_memory: bool = True  # Use pinned memory for faster transfers when offloading
 
@@ -664,8 +709,15 @@ class OmniDiffusionConfig:
     # STA_mode: STA_Mode = STA_Mode.STA_INFERENCE
     skip_time_steps: int = 15
 
+    # MoE kernel backend selection
+    moe_backend: str = "auto"
+
     # Compilation
     enforce_eager: bool = False
+    # Controls the generic compilation path used when a pipeline does not
+    # provide its own setup_compile() implementation.
+    diffusion_compile_granularity: str = "regional"
+    diffusion_compile_dynamic: bool = True
 
     # Parallel weight loading (for faster diffusion model startup)
     enable_multithread_weight_load: bool = True
@@ -739,6 +791,7 @@ class OmniDiffusionConfig:
     # through a generic config field so serving code stays model-agnostic.
     supports_multimodal_inputs: bool = False
     max_multimodal_image_inputs: int | None = None
+    supports_mixed_reference_inputs: bool = False
 
     log_level: str = "info"
 
@@ -862,6 +915,13 @@ class OmniDiffusionConfig:
         )
 
     def __post_init__(self):
+        if self.diffusion_compile_granularity not in {"regional", "full"}:
+            raise ValueError(
+                "diffusion_compile_granularity must be 'regional' or 'full', "
+                f"got {self.diffusion_compile_granularity!r}"
+            )
+        if not isinstance(self.diffusion_compile_dynamic, bool):
+            raise TypeError(f"diffusion_compile_dynamic must be a bool, got {type(self.diffusion_compile_dynamic)!r}")
         self.master_port = self._resolve_master_port()
         self.request_batch_max_wait_ms = float(self.request_batch_max_wait_ms or 0.0)
         if self.request_batch_max_wait_ms < 0:
@@ -897,6 +957,23 @@ class OmniDiffusionConfig:
                 f"num_gpus ({self.num_gpus}) < parallel_config.world_size ({self.parallel_config.world_size})"
             )
 
+        if self.diffusion_compile_granularity == "full":
+            incompatible_features = []
+            if self.parallel_config.use_hsdp:
+                incompatible_features.append("HSDP")
+            if self.parallel_config.sequence_parallel_size > 1:
+                incompatible_features.append("sequence parallelism")
+            if self.enable_cpu_offload:
+                incompatible_features.append("CPU offload")
+            if self.enable_layerwise_offload:
+                incompatible_features.append("layerwise offload")
+            if incompatible_features:
+                features = ", ".join(incompatible_features)
+                raise ValueError(
+                    "diffusion_compile_granularity='full' is incompatible with "
+                    f"{features}; use 'regional' compilation instead"
+                )
+
         # Convert string dtype to torch.dtype if needed
         if isinstance(self.dtype, str):
             dtype_map = {
@@ -961,6 +1038,18 @@ class OmniDiffusionConfig:
                 "valid together with diffusion_load_format=diffusers"
             )
 
+        # when use hf offline, replace model to local model path
+        # align with ar stage behavior, see vllm/engine/arg_utils.py
+        if huggingface_hub.constants.HF_HUB_OFFLINE and self.model:
+            model_id = self.model
+            self.model = get_model_path(self.model, self.revision)
+            if model_id != self.model:
+                logger.info(
+                    "HF_HUB_OFFLINE is True, replace model_id [%s] to model_path [%s]",
+                    model_id,
+                    self.model,
+                )
+
     def _propagate_quantization_from_tf_config(self, tf_config: "TransformerConfig") -> None:
         if tf_config.quant_config is None:
             return
@@ -1017,6 +1106,19 @@ class OmniDiffusionConfig:
         """
         self.tf_model_config = tf_config
         self._propagate_quantization_from_tf_config(tf_config)
+        self._propagate_skip_softmax_calibration(tf_config)
+
+    def _propagate_skip_softmax_calibration(self, tf_config: "TransformerConfig") -> None:
+        cfg = getattr(self, "diffusion_attention_config", None)
+        if not isinstance(cfg, AttentionConfig):
+            return
+        specs = [s for s in (cfg.default, *cfg.per_role.values()) if s is not None]
+
+        from vllm_omni.diffusion.attention.backends.trtllm_calibration import (
+            propagate_skip_softmax_calibration,
+        )
+
+        propagate_skip_softmax_calibration(specs, self.model, tf_config)
 
     def update_multimodal_support(self) -> None:
         # Resolve serving-visible multimodal behavior from shared metadata
@@ -1024,6 +1126,7 @@ class OmniDiffusionConfig:
         metadata = get_diffusion_model_metadata(self.model_class_name)
         self.supports_multimodal_inputs = metadata.supports_multimodal_inputs
         self.max_multimodal_image_inputs = metadata.max_multimodal_image_inputs
+        self.supports_mixed_reference_inputs = metadata.supports_mixed_reference_inputs
 
     @staticmethod
     def _looks_like_lance_subfolder(model: str | None) -> bool:
@@ -1043,18 +1146,23 @@ class OmniDiffusionConfig:
     def enrich_config(self) -> None:
         """Load model metadata from HuggingFace and populate config fields.
 
-        Diffusers-style models expose ``model_index.json`` with ``_class_name``.
+        Diffusers-style models expose a pipeline index with ``_class_name``.
         Non-diffusers models (e.g. Bagel, NextStep) only have ``config.json``,
         so we fall back to reading that and mapping model_type manually.
         """
         from vllm.transformers_utils.config import get_hf_file_to_dict
 
+        from vllm_omni.diffusion.utils.hf_utils import get_diffusion_model_index
+
         # Default model_class_name for diffusers adapter
         if self.model_class_name is None and self.diffusion_load_format == "diffusers":
             self.model_class_name = "DiffusersAdapterPipeline"
 
         try:
-            config_dict = get_hf_file_to_dict("model_index.json", self.model)
+            config_dict = get_diffusion_model_index(
+                self.model,
+                revision=self.revision,
+            )
             if config_dict is not None:
                 if self.model_class_name is None:
                     self.model_class_name = config_dict.get("_class_name", None)
@@ -1069,7 +1177,7 @@ class OmniDiffusionConfig:
                         self.diffusers_pipeline_cls = getattr(diffusers, diffusers_pipeline_cls_name)
                     except (KeyError, AttributeError) as exc:
                         logger.warning(
-                            "Could not find valid _class_name for diffusers pipeline in model_index.json: %s. "
+                            "Could not find a valid _class_name in the Diffusers pipeline index: %s. "
                             "Without the underlying pipeline class the dummy run may omit required inputs.",
                             exc,
                         )
@@ -1082,16 +1190,16 @@ class OmniDiffusionConfig:
                     else:
                         self.set_tf_model_config(TransformerConfig())
             else:
-                raise FileNotFoundError("model_index.json not found")
+                raise FileNotFoundError("Diffusers pipeline index not found")
         except (AttributeError, OSError, ValueError, FileNotFoundError):
             # Skip transformer config loading for diffusers adapter
             # (non-DiT models don't have a separate transformer folder/config)
             if self.diffusion_load_format == "diffusers":
                 self.set_tf_model_config(TransformerConfig())
                 logger.warning(
-                    "Could not find valid model_index.json per diffusers format. "
+                    "Could not find a valid pipeline index per Diffusers format. "
                     "This model is likely unsupported by the diffusers backend. "
-                    "Also, without knowing the underlying diffusers pipeline class from model_index.json, "
+                    "Also, without knowing the underlying pipeline class from its index, "
                     "the dummy run will input only text prompt, which may cause errors for pipelines "
                     "that require additional inputs."
                 )
@@ -1107,7 +1215,7 @@ class OmniDiffusionConfig:
                         self.set_tf_model_config(TransformerConfig())
                         self.update_multimodal_support()
                         return
-                    raise ValueError(f"Could not find config.json or model_index.json for model {self.model}")
+                    raise ValueError(f"Could not find config.json or a Diffusers pipeline index for {self.model}")
 
                 self.set_tf_model_config(TransformerConfig.from_dict(cfg))
                 model_type = cfg.get("model_type")
@@ -1206,6 +1314,7 @@ class DiffusionOutput:
     trajectory_latents: torch.Tensor | dict[str, Any] | None = None
     trajectory_log_probs: torch.Tensor | dict[str, Any] | None = None
     trajectory_decoded: list[Image.Image] | None = None
+    async_output_id: str | None = None
     error: str | None = None
     error_status_code: int | None = None
     error_type: str | None = None
@@ -1221,6 +1330,9 @@ class DiffusionOutput:
     finished: bool = True
     chunk_index: int = 0
     total_chunks: int = 1
+    started_event_ids: list[str] = field(default_factory=list)
+    active_event_ids: list[str] = field(default_factory=list)
+    completed_event_ids: list[str] = field(default_factory=list)
 
     # logged duration of stages
     stage_durations: dict[str, float] = field(default_factory=dict)
@@ -1263,27 +1375,205 @@ class DiffusionOutput:
         )
 
 
+class AsyncOutputKind(Enum):
+    """Message kind for ``AsyncDiffusionOutput`` — routes async results.
+
+    * ``RPC_RESULT`` — ordinary RPC return (sleep, wake, profile, etc.)
+    * ``COMPUTE_DONE`` — worker forward finished, GPU can start next request
+    * ``OUTPUT_READY`` — background D2H/SHM packing finished, final output
+      is available via ``async_output_id``
+    """
+
+    RPC_RESULT = "rpc_result"
+    COMPUTE_DONE = "compute_done"
+    OUTPUT_READY = "output_ready"
+
+
+@dataclass
+class AsyncDiffusionOutput:
+    """Async protocol envelope for ``result_mq`` messages.
+
+    In request-mode (``step_execution=False``), all ``result_mq``
+    messages use this envelope.  The ``kind`` field routes the message
+    to the correct consumer.
+    """
+
+    kind: AsyncOutputKind
+    rpc_id: str | None = None
+    async_output_id: str | None = None
+    result: Any | None = None
+    output: DiffusionOutput | None = None
+    error: str | None = None
+
+
 class DiffusionRequestAbortedError(RuntimeError):
     """Raised when a diffusion request ends via user-visible abort."""
 
 
+def _in_range(value: Any, name: str, lo: float, hi: float | None) -> float | None:
+    """Validate an optional numeric control at config-parse time."""
+    if value is None:
+        return None
+    x = float(value)
+    if not math.isfinite(x) or x < lo or (hi is not None and x > hi):
+        rng = f"in [{lo}, {hi}]" if hi is not None else f">= {lo}"
+        raise ValueError(f"{name} must be finite and {rng}; got {value!r}.")
+    return x
+
+
+@dataclass
+class SkipSoftmaxSpec:
+    """User-facing skip-softmax controls for the TRTLLM_ATTN backend.
+
+    ``target_sparsity`` uses the checkpoint's calibrated curve (a·exp(b·s)); ``threshold``
+    is the calibration-free absolute skip threshold. They are mutually exclusive.
+    """
+
+    target_sparsity: float | None = None
+    threshold: float | None = None
+    disabled_until_timestep: float = 0.0
+
+    def __post_init__(self) -> None:
+        self.target_sparsity = _in_range(self.target_sparsity, "skip_softmax.target_sparsity", 0.0, 1.0)
+        self.threshold = _in_range(self.threshold, "skip_softmax.threshold", 0.0, None)
+        self.disabled_until_timestep = (
+            _in_range(self.disabled_until_timestep, "skip_softmax.disabled_until_timestep", 0.0, 1.0) or 0.0
+        )
+        if self.target_sparsity is not None and self.threshold is not None:
+            raise ValueError("skip_softmax: set either target_sparsity or threshold, not both.")
+
+    @property
+    def enabled(self) -> bool:
+        return self.threshold is not None or self.target_sparsity is not None
+
+
+@dataclass
+class AttnQuantSpec:
+    dtype_qk: str | None = None
+    dtype_vo: str | None = None
+    q_block_size: int = 1
+    k_block_size: int = 16
+    flashinfer_backend: str | None = None
+
+    _VALID_DTYPES = frozenset({"float16", "bfloat16", "int8", "fp8_e4m3"})
+    _VALID_BLOCK_SIZES = frozenset({1, 4, 16})
+
+    def __post_init__(self) -> None:
+        for name, v in (("dtype_qk", self.dtype_qk), ("dtype_vo", self.dtype_vo)):
+            if v is not None and v not in self._VALID_DTYPES:
+                raise ValueError(f"quant.{name}={v!r} unsupported; use one of {sorted(self._VALID_DTYPES)}.")
+        for name, v in (("q_block_size", self.q_block_size), ("k_block_size", self.k_block_size)):
+            if v not in self._VALID_BLOCK_SIZES:
+                raise ValueError(
+                    f"quant.{name}={v!r} unsupported; kernels exist only for {sorted(self._VALID_BLOCK_SIZES)}."
+                )
+
+    @property
+    def enabled(self) -> bool:
+        return self.dtype_qk is not None or self.dtype_vo is not None
+
+
+# Backends that select key blocks instead of attending densely, and so accept
+# a ``block_sparse`` spec. Each maps the same knobs onto its own kernel.
+BLOCK_SPARSE_BACKENDS = frozenset({"RAINFUSION_ATTN"})
+
+
+@dataclass
+class BlockSparseSpec:
+    """User-facing controls shared by block-sparse attention backends.
+
+    ``sparsity`` is the nominal fraction of key blocks dropped per query block;
+    ``start_step`` keeps the first N denoise steps dense and ``skip_layers`` (an
+    index selector such as "0-3,38") exempts individual DiT blocks. Those two are
+    the accuracy knobs to trade back quality at a fixed ``sparsity``.
+    """
+
+    sparsity: float = 0.8
+    start_step: int = 0
+    skip_layers: str | list[int] | None = None
+    skip_layer_indices: set[int] | None = field(default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.sparsity = _in_range(self.sparsity, "block_sparse.sparsity", 0.0, 1.0) or 0.0
+        if self.start_step < 0:
+            raise ValueError(f"block_sparse.start_step must be >= 0; got {self.start_step!r}.")
+        self.skip_layer_indices = parse_kv_cache_skip_selector(self.skip_layers)
+
+
 @dataclass
 class AttentionSpec:
-    """Specifies a backend and its backend-specific parameters for one attention role."""
+    """Specifies a backend and its typed backend-specific config for one attention role."""
 
-    backend: str  # registry name, e.g. "FLASH_ATTN"
-    extra: dict[str, Any] = field(default_factory=dict)  # backend-specific kwargs
+    backend: str
+    skip_softmax: SkipSoftmaxSpec | None = None
+    quant: AttnQuantSpec | None = None
+    block_sparse: BlockSparseSpec | None = None
+    skip_calibration: dict | None = field(default=None, repr=False)
 
     def __post_init__(self) -> None:
         if not isinstance(self.backend, str):
             raise TypeError(f"Expected str for AttentionSpec.backend, got {type(self.backend)!r}")
+        self.skip_softmax = self._coerce(self.skip_softmax, SkipSoftmaxSpec, "skip_softmax")
+        self.quant = self._coerce(self.quant, AttnQuantSpec, "quant")
+        self.block_sparse = self._coerce(self.block_sparse, BlockSparseSpec, "block_sparse")
+        if self.skip_softmax is not None and self.backend.upper() != "TRTLLM_ATTN":
+            raise ValueError(
+                f"skip_softmax is only supported by the TRTLLM_ATTN backend, but backend={self.backend!r}. "
+                "Remove skip_softmax or set backend to TRTLLM_ATTN."
+            )
+        if self.quant is not None and self.backend.upper() not in ("TRTLLM_ATTN", "FLASHINFER_ATTN"):
+            raise ValueError(
+                f"quant is only supported by the TRTLLM_ATTN and FLASHINFER_ATTN backends, but "
+                f"backend={self.backend!r}. Remove quant or set a supported backend."
+            )
+        if self.backend.upper() in BLOCK_SPARSE_BACKENDS:
+            # Selecting the backend is the opt-in; without an explicit block the
+            # defaults apply rather than silently running dense.
+            self.block_sparse = self.block_sparse or BlockSparseSpec()
+        elif self.block_sparse is not None:
+            raise ValueError(
+                f"block_sparse is only supported by the {sorted(BLOCK_SPARSE_BACKENDS)} backends, but "
+                f"backend={self.backend!r}. Remove block_sparse or set a supported backend."
+            )
 
-        if self.extra is None:
-            self.extra = {}
-        elif isinstance(self.extra, Mapping):
-            self.extra = dict(self.extra)
-        else:
-            raise TypeError(f"Expected dict for AttentionSpec.extra, got {type(self.extra)!r}")
+    @staticmethod
+    def _coerce(value: Any, cls: type, field_name: str) -> Any:
+        if value is None or isinstance(value, cls):
+            return value
+        if isinstance(value, Mapping):
+            return cls(**dict(value))
+        raise TypeError(f"Expected dict or {cls.__name__} for {field_name}, got {type(value)!r}")
+
+    def backend_kwargs(self) -> dict[str, Any] | None:
+        """Serialize typed backend config into the kwargs dict the backend impl consumes."""
+        kw: dict[str, Any] = {}
+        if self.skip_softmax is not None:
+            ss = self.skip_softmax
+            if ss.threshold is not None:
+                kw["skip_softmax_threshold"] = ss.threshold
+            if ss.target_sparsity is not None:
+                kw["target_sparsity"] = ss.target_sparsity
+            if ss.disabled_until_timestep:
+                kw["disabled_until_timestep"] = ss.disabled_until_timestep
+        if self.quant is not None and self.quant.enabled:
+            q = self.quant
+            quant_kw: dict[str, Any] = {
+                "dtype_qk": q.dtype_qk,
+                "q_block_size": q.q_block_size,
+                "k_block_size": q.k_block_size,
+            }
+            if q.dtype_vo is not None:
+                quant_kw["dtype_vo"] = q.dtype_vo
+            if q.flashinfer_backend is not None:
+                quant_kw["flashinfer_backend"] = q.flashinfer_backend
+            kw["quant"] = quant_kw
+        if self.block_sparse is not None:
+            bs = self.block_sparse
+            kw["sparsity"] = bs.sparsity
+            kw["start_step"] = bs.start_step
+            if bs.skip_layer_indices:
+                kw["skip_layers"] = sorted(bs.skip_layer_indices)
+        return kw or None
 
 
 @dataclass
@@ -1352,13 +1642,13 @@ class AttentionConfig:
             normalized[role] = node
             return
 
-        spec_keys = {"backend", "extra"}
+        spec_keys = {"backend", "skip_softmax", "quant", "block_sparse"}
         node_dict = dict(node)
         node_keys = set(node_dict)
         if node_keys & spec_keys:
             if not node_keys <= spec_keys:
                 raise ValueError(
-                    f"Invalid per_role entry for role {role!r}: cannot mix backend/extra with nested role keys."
+                    f"Invalid per_role entry for role {role!r}: cannot mix backend/skip_softmax with nested role keys."
                 )
             normalized[role] = node_dict
             return
diff --git a/vllm_omni/diffusion/diffusion_engine.py b/vllm_omni/diffusion/diffusion_engine.py
index d6e7b35de..086206fa0 100644
--- a/vllm_omni/diffusion/diffusion_engine.py
+++ b/vllm_omni/diffusion/diffusion_engine.py
@@ -11,6 +11,7 @@ import threading
 import time
 from collections.abc import AsyncGenerator, Iterable
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
@@ -33,7 +34,6 @@ from vllm_omni.diffusion.io_support import (
     supports_multimodal_input,
 )
 from vllm_omni.diffusion.output_formatter import (
-    DiffusionStepTimings,
     format_diffusion_outputs,
     format_empty_diffusion_outputs,
     normalize_diffusion_postprocess_output,
@@ -44,7 +44,7 @@ from vllm_omni.diffusion.registry import (
     get_diffusion_pre_process_func,
 )
 from vllm_omni.diffusion.request import DUMMY_DIFFUSION_REQUEST_ID, OmniDiffusionRequest
-from vllm_omni.diffusion.sched import RequestScheduler, SchedulerInterface, StepScheduler
+from vllm_omni.diffusion.sched import BaseScheduler, RequestScheduler, StepScheduler
 from vllm_omni.diffusion.sched.interface import DiffusionRequestStatus
 from vllm_omni.diffusion.worker.utils import BaseRunnerOutput, BatchRunnerOutput, RunnerOutput
 from vllm_omni.errors import client_error_from_metadata, is_client_error_status
@@ -55,8 +55,11 @@ if TYPE_CHECKING:
 
 logger = init_logger(__name__)
 
+_ASYNC_OUTPUT_TIMEOUT = 30.0  # seconds
+
 __all__ = [
     "DiffusionEngine",
+    "DiffusionExecutionMode",
     "_RpcTask",
     "_move_tensor_tree_to_cpu",
     "get_dummy_run_num_frames",
@@ -106,6 +109,13 @@ def supports_request_batch(od_config: OmniDiffusionConfig) -> bool:
     return bool(getattr(model_cls, "supports_request_batch", False))
 
 
+def _max_num_seqs(od_config: OmniDiffusionConfig) -> int:
+    try:
+        return max(1, int(getattr(od_config, "max_num_seqs", 1)))
+    except (TypeError, ValueError):
+        return 1
+
+
 def _move_tensor_tree_to_cpu(value: object) -> object:
     if isinstance(value, torch.Tensor):
         return value.cpu() if value.device.type != "cpu" else value
@@ -130,6 +140,11 @@ class _RpcTask:
     future: concurrent.futures.Future = field(default_factory=concurrent.futures.Future)
 
 
+class DiffusionExecutionMode(str, Enum):
+    REQUEST_BATCH = "request_batch"
+    STEP_BATCH = "step_batch"
+
+
 class DiffusionEngine:
     """The diffusion engine for vLLM-Omni diffusion models."""
 
@@ -141,37 +156,101 @@ class DiffusionEngine:
     #: remains a pure explicit user override (never mutated by engines).
     default_diffusion_model_runner_cls: str | None = None
 
+    # Class-level default so tests using object.__new__ (without __init__)
+    # don't hit AttributeError when _busy_loop accesses self.dp_concurrent.
+    dp_concurrent: bool = False
+
     def __init__(
         self,
         od_config: OmniDiffusionConfig,
-        scheduler: SchedulerInterface | None = None,
+        scheduler: BaseScheduler | None = None,
     ):
         """Initialize the diffusion engine.
 
         Args:
-            config: The configuration for the diffusion engine.
+            od_config: The configuration for the diffusion engine.
+            scheduler: Optional scheduler override for tests or custom engine
+                integrations. When omitted, the engine selects a scheduler
+                from the resolved execution mode.
         """
         self.od_config = od_config
 
+        self._init_process_hooks(od_config)
+        self.execution_mode = self._resolve_execution_mode(od_config)
+        self._init_executor(od_config)
+        self._init_scheduler(od_config, scheduler)
+        self._init_runtime_state()
+        self._init_execute_fn()
+        self._log_execution_mode(od_config)
+
+    def _init_process_hooks(self, od_config: OmniDiffusionConfig) -> None:
         self.post_process_func = get_diffusion_post_process_func(od_config)
         self.pre_process_func = get_diffusion_pre_process_func(od_config)
         # Cache whether the model-specific postprocess accepts request-level
         # sampling params so step() can support both legacy and extended hooks.
         self._post_process_accepts_sampling_params = _func_accepts_parameter(self.post_process_func, "sampling_params")
 
+    def _resolve_execution_mode(self, od_config: OmniDiffusionConfig) -> DiffusionExecutionMode:
         self.step_execution = bool(getattr(od_config, "step_execution", False))
-        if self.od_config.streaming_output and not self.step_execution:
+        if od_config.streaming_output and not self.step_execution:
             logger.warning("streaming_output=True requires step_execution=True; enabling step execution.")
-            self.od_config.step_execution = True
+            od_config.step_execution = True
             self.step_execution = True
 
+        if self.step_execution:
+            self.supports_request_batch = False
+            return DiffusionExecutionMode.STEP_BATCH
+
+        self.supports_request_batch = supports_request_batch(od_config)
+        if not self.supports_request_batch and _max_num_seqs(od_config) > 1:
+            raise ValueError(
+                f"{getattr(od_config, 'model_class_name', None)!r} does not support request-level batching. "
+                "Use max_num_seqs=1 for serial request execution, or choose a pipeline with "
+                "supports_request_batch=True."
+            )
+        return DiffusionExecutionMode.REQUEST_BATCH
+
+    def _init_executor(self, od_config: OmniDiffusionConfig) -> None:
         executor_class = DiffusionExecutor.get_class(od_config)
         self.executor = executor_class(od_config)
-        self.scheduler: SchedulerInterface = scheduler or (
-            StepScheduler() if self.step_execution else RequestScheduler()
-        )
+
+    def _init_scheduler(
+        self,
+        od_config: OmniDiffusionConfig,
+        scheduler: BaseScheduler | None = None,
+    ) -> None:
+        if scheduler is not None:
+            self.scheduler = scheduler
+        elif self.execution_mode == DiffusionExecutionMode.STEP_BATCH:
+            self.scheduler = StepScheduler()
+        else:
+            self.scheduler = RequestScheduler()
         self.scheduler.initialize(od_config)
-        self.supports_request_batch = False if self.step_execution else supports_request_batch(od_config)
+
+    def _init_runtime_state(self) -> None:
+        # DP multi-concurrency: allow batching dp_size requests so each
+        # worker processes a different request in parallel.  Only enabled
+        # for distributed layerwise offload (which shards weights and
+        # needs all ranks active simultaneously).  Ordinary DP with a
+        # non-batch pipeline should not schedule multiple requests.
+        dp_size = 1
+        if getattr(self.od_config, "parallel_config", None) is not None:
+            dp_size = getattr(self.od_config.parallel_config, "data_parallel_size", 1)
+        dist_offload = getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+        if dp_size > 1 and dist_offload and getattr(self.od_config, "dlo_use_allgather", True):
+            self.scheduler.max_num_running_reqs = dp_size
+            self.dp_concurrent = True
+            # Set batch admission wait so concurrent requests accumulate
+            # before scheduling.  The scheduler reads this from od_config.
+            if getattr(self.od_config, "request_batch_max_wait_ms", 0) == 0:
+                self.od_config.request_batch_max_wait_ms = 500.0
+            logger.info(
+                "dp_concurrent: max_num_running_reqs=%d, batch_wait=%sms",
+                dp_size,
+                self.od_config.request_batch_max_wait_ms,
+            )
+        else:
+            self.dp_concurrent = False
         self.main_loop: asyncio.AbstractEventLoop | None = None
         self.stop_event: threading.Event | None = None
         self.worker_thread: threading.Thread | None = None
@@ -183,33 +262,26 @@ class DiffusionEngine:
         # busy loop rather than via mutual exclusion.
         self._rpc_lock = threading.RLock()
         self._cv = threading.Condition(self._rpc_lock)
-        self._out_queue: dict[str, asyncio.Future] = {}
-        self._out_queue_streaming: dict[str, asyncio.Queue[DiffusionOutput]] = {}
+        self._out_streams: dict[str, asyncio.Queue[DiffusionOutput]] = {}
         self._closed = False
         self._shutdown_complete = False
         self.abort_queue: queue.Queue[str] = queue.Queue()
         self._rpc_queue: queue.Queue[_RpcTask] = queue.Queue()
-        if self.step_execution:
-            self.execute_fn = self.executor.execute_step
-        elif self.supports_request_batch:
-            self.execute_fn = self.executor.execute_batch
-        else:
-            self.execute_fn = self.executor.execute_request
 
-        if self.supports_request_batch:
+    def _init_execute_fn(self) -> None:
+        if self.execution_mode == DiffusionExecutionMode.STEP_BATCH:
+            self.execute_fn = self.executor.execute_step
+        else:
+            self.execute_fn = self.executor.execute_batch
+
+    def _log_execution_mode(self, od_config: OmniDiffusionConfig) -> None:
+        if self.execution_mode == DiffusionExecutionMode.REQUEST_BATCH:
             logger.info(
                 "[RequestBatch] engine init max_num_seqs=%s max_wait_ms=%s",
                 getattr(od_config, "max_num_seqs", None),
                 getattr(od_config, "request_batch_max_wait_ms", None),
             )
 
-        try:
-            self._dummy_run()
-        except Exception as e:
-            logger.error(f"Dummy run failed: {e}")
-            self.close()
-            raise e
-
     async def _check_and_start_background_loop(self):
         if self._closed:
             raise RuntimeError("DiffusionEngine is closed.")
@@ -229,24 +301,6 @@ class DiffusionEngine:
             self.worker_thread.start()
             self._loop_started = True
 
-    async def step(self, request: OmniDiffusionRequest) -> list[OmniRequestOutput]:
-        await self._check_and_start_background_loop()
-
-        diffusion_engine_start_time = time.perf_counter()
-
-        # Apply pre-processing if available
-        preprocess_time = 0.0
-        if self.pre_process_func is not None:
-            preprocess_start_time = time.perf_counter()
-            request = self.pre_process_func(request)
-            preprocess_time = time.perf_counter() - preprocess_start_time
-            logger.debug("Pre-processing completed in %.4f seconds", preprocess_time)
-
-        exec_start_time = time.perf_counter()
-        output = await self.async_add_req_and_wait_for_response(request)
-        exec_total_time = time.perf_counter() - exec_start_time
-        return self.postprocess_output(request, output, diffusion_engine_start_time, preprocess_time, exec_total_time)
-
     async def step_streaming(self, request: OmniDiffusionRequest) -> AsyncGenerator[list[OmniRequestOutput], None]:
         await self._check_and_start_background_loop()
 
@@ -263,19 +317,54 @@ class DiffusionEngine:
         generator = self.async_add_req_and_stream_response(request)
         async for output in generator:
             exec_total_time = time.perf_counter() - exec_start_time
-            yield self.postprocess_output(
-                request, output, diffusion_engine_start_time, preprocess_time, exec_total_time
+            # Async mode: wait for background D2H/SHM to complete.
+            if output.async_output_id:
+                fut = self.executor.wait_output_ready(output.async_output_id)
+                output = await asyncio.wait_for(asyncio.wrap_future(fut), timeout=_ASYNC_OUTPUT_TIMEOUT)
+            postprocess_start_time = time.perf_counter()
+            formatted_outputs = self.postprocess_output(request, output)
+            postprocess_time = time.perf_counter() - postprocess_start_time
+            step_total_ms = (time.perf_counter() - diffusion_engine_start_time) * 1000
+            logger.debug(
+                "DiffusionEngine.step_streaming breakdown: preprocess=%.2f ms, "
+                "add_req_and_wait=%.2f ms, postprocess=%.2f ms, total=%.2f ms",
+                preprocess_time * 1000,
+                exec_total_time * 1000,
+                postprocess_time * 1000,
+                step_total_ms,
             )
+            for request_output in formatted_outputs:
+                request_output.metrics.update(
+                    {
+                        "preprocess_time_ms": preprocess_time * 1000,
+                        "diffusion_engine_exec_time_ms": exec_total_time * 1000,
+                        "diffusion_engine_total_time_ms": step_total_ms,
+                        "postprocess_time_ms": postprocess_time * 1000,
+                    }
+                )
+            yield formatted_outputs
+
+    async def step(self, request: OmniDiffusionRequest) -> list[OmniRequestOutput]:
+        """Deprecated compatibility wrapper over ``step_streaming()``.
+
+        Use ``step_streaming()`` for new callers. This method drains the
+        unified output stream and returns only the final output batch, matching
+        the historical non-streaming ``step()`` behavior.
+        """
+        logger.warning_once(
+            "DiffusionEngine.step() is deprecated; use step_streaming() and consume the final output batch instead."
+        )
+        final_output: list[OmniRequestOutput] | None = None
+        async for output in self.step_streaming(request):
+            final_output = output
+        return final_output or []
 
     def postprocess_output(
         self,
         request: OmniDiffusionRequest,
         output: DiffusionOutput,
-        diffusion_engine_start_time: float,
-        preprocess_time: float,
-        exec_total_time: float,
     ) -> list[OmniRequestOutput]:
-        """Convert a DiffusionOutput to a list of OmniRequestOutput, attaching profiling metrics."""
+        """Convert a DiffusionOutput to a list of OmniRequestOutput."""
         if output.aborted:
             raise DiffusionRequestAbortedError(output.abort_message or "Diffusion request aborted.")
         if output.error:
@@ -299,7 +388,6 @@ class DiffusionEngine:
         if self.od_config.enable_cpu_offload:
             output_data = _move_tensor_tree_to_cpu(output_data)
 
-        postprocess_start_time = time.perf_counter()
         if self.post_process_func is not None:
             # Some video pipelines need request-level controls during
             # postprocess (for example worker-side frame interpolation).
@@ -311,18 +399,6 @@ class DiffusionEngine:
             outputs = output_data
 
         postprocess_output = normalize_diffusion_postprocess_output(outputs)
-        postprocess_time = time.perf_counter() - postprocess_start_time
-        logger.debug("Post-processing completed in %.4f seconds", postprocess_time)
-
-        step_total_ms = (time.perf_counter() - diffusion_engine_start_time) * 1000
-        logger.debug(
-            "DiffusionEngine.step breakdown: preprocess=%.2f ms, "
-            "add_req_and_wait=%.2f ms, postprocess=%.2f ms, total=%.2f ms",
-            preprocess_time * 1000,
-            exec_total_time * 1000,
-            postprocess_time * 1000,
-            step_total_ms,
-        )
 
         return format_diffusion_outputs(
             request=request,
@@ -330,12 +406,6 @@ class DiffusionEngine:
             diffusion_output=output,
             output_data=output_data,
             postprocess_output=postprocess_output,
-            timings=DiffusionStepTimings(
-                preprocess_time_s=preprocess_time,
-                exec_time_s=exec_total_time,
-                postprocess_time_s=postprocess_time,
-                total_time_ms=step_total_ms,
-            ),
         )
 
     def _busy_loop(self):
@@ -359,16 +429,13 @@ class DiffusionEngine:
                     # Only RPC / abort work pending; loop back to drain it.
                     continue
 
-                if self.supports_request_batch:
+                if self.supports_request_batch or self.dp_concurrent:
                     self._wait_for_request_batch_admission_locked()
 
                 sched_output = self.scheduler.schedule()
 
             if sched_output.is_empty:
-                if self.od_config.streaming_output:
-                    self._handle_empty_streaming_requests(sched_output.finished_req_ids)
-                else:
-                    self._handle_finished_requests(sched_output.finished_req_ids, None)
+                self._emit_finished_outputs(sched_output.finished_req_ids, None)
                 continue
 
             try:
@@ -392,14 +459,7 @@ class DiffusionEngine:
             self._process_aborts_queue()
             self._process_rpc_queue()
             finished_req_ids = self.scheduler.update_from_output(sched_output, runner_output)
-            if self.od_config.streaming_output:
-                self._handle_step_streaming_runner_output(
-                    finished_req_ids,
-                    sched_output.scheduled_request_ids,
-                    runner_output,
-                )
-            else:
-                self._handle_finished_requests(finished_req_ids, runner_output)
+            self._emit_outputs(finished_req_ids, sched_output.scheduled_request_ids, runner_output)
 
         # Engine is stopping: fail any RPCs still queued so callers don't hang.
         self._fail_pending_rpcs(RuntimeError("DiffusionEngine is shutting down."))
@@ -409,7 +469,7 @@ class DiffusionEngine:
 
         Caller must hold ``self._cv``.
         """
-        if self.step_execution or not self.supports_request_batch:
+        if self.step_execution or (not self.supports_request_batch and not self.dp_concurrent):
             return
 
         max_wait_s = self.od_config.request_batch_max_wait_ms / 1000.0
@@ -427,9 +487,12 @@ class DiffusionEngine:
         deadline = start + max_wait_s
         last_waiting = -1
         stable_since = start
-        # Require a short idle period with no queue growth so bursty HTTP
-        # ingress can land before the first schedule() of a wave.
-        stable_window_s = min(0.05, max_wait_s / 5.0)
+        # For dp_concurrent, use a longer stable window so all dp_size
+        # HTTP requests have time to land before scheduling.
+        if self.dp_concurrent:
+            stable_window_s = min(0.3, max_wait_s / 2.0)
+        else:
+            stable_window_s = min(0.05, max_wait_s / 5.0)
 
         while not self.stop_event.is_set():
             waiting = self.scheduler.num_waiting_requests()
@@ -511,74 +574,62 @@ class DiffusionEngine:
             if not task.future.done():
                 task.future.set_exception(exc)
 
-    def _handle_finished_requests(
+    def _emit_finished_outputs(
         self,
         finished_ids: set[str],
         runner_output: BaseRunnerOutput | None = None,
         missing_result_error: str = "Diffusion execution finished without a final output",
-    ):
+    ) -> None:
         for rid in finished_ids:
-            with self._cv:
-                fut = self._out_queue.pop(rid, None)
-            if fut is None:
-                continue
             if runner_output is not None:
                 _output = runner_output.get_request_output(rid)
             else:
                 _output = None
             out = self._finalize_finished_request(rid, _output, missing_result_error)
-            self._complete_future(fut, out)
+            self._put_output(rid, out)
 
-    def _handle_empty_streaming_requests(
+    def _emit_outputs(
         self,
         finished_ids: set[str],
-        missing_result_error: str = "Diffusion streaming request finished without execution output.",
-    ) -> None:
-        """Mirrors `_handle_finished_requests()` in non-streaming mode when used for empty scheduler output."""
-        for rid in finished_ids:
-            out = self._finalize_finished_request(rid, None, missing_result_error=missing_result_error)
-            self._put_streaming_output_with_cv(rid, out)
-
-    def _handle_step_streaming_runner_output(
-        self,
-        finished_req_ids: set[str],
         scheduled_request_ids: list[str],
         runner_output: BaseRunnerOutput,
     ) -> None:
-        """
-        Deliver partial step-execution outputs in streaming mode.
+        """Emit output chunks for every request through the unified output stream."""
+        if self.execution_mode != DiffusionExecutionMode.STEP_BATCH:
+            self._emit_finished_outputs(finished_ids, runner_output)
+            return
 
-        Step execution returns one ``RunnerOutput`` per scheduled request per
-        engine tick. Most denoise steps have ``result=None``; chunk boundaries
-        return a ``DiffusionOutput`` that must be delivered even before the
-        scheduler marks the request finished.
-        """
         delivered_finished_req_ids: set[str] = set()
 
         # finished_ids may have some requests that are not scheduler in this round.
         # First handle this-round requests.
         for request_id in scheduled_request_ids:
             req_output = runner_output.get_request_output(request_id)
-            if request_id in finished_req_ids:
+            if request_id in finished_ids:
                 # This entire request is finished (this is the last chunk)
                 out = self._finalize_finished_request(
                     request_id,
                     req_output,
-                    missing_result_error="Diffusion streaming execution finished without a final output.",
+                    missing_result_error="Diffusion step execution finished without a final output.",
                 )
-                self._put_streaming_output_with_cv(request_id, out)
+                self._put_output(request_id, out)
                 delivered_finished_req_ids.add(request_id)
             elif req_output is not None and req_output.result is not None:
-                # This is a non-terminal chunk. So it is not in scheduler's finished_req_ids, but still need delivering.
-                self._put_streaming_output_with_cv(request_id, req_output.result)
+                # This is a non-terminal chunk. It is not in scheduler's
+                # finished_ids, but it still belongs on the request stream.
+                self._put_output(request_id, req_output.result)
 
         # Then handle other requests that are finished in this round.
-        for request_id in finished_req_ids - delivered_finished_req_ids:
+        for request_id in finished_ids - delivered_finished_req_ids:
             out = self._finalize_finished_request(
                 request_id,
-                missing_result_error="Diffusion streaming request finished without execution output.",
+                missing_result_error="Diffusion step request finished without execution output.",
             )
-            self._put_streaming_output_with_cv(request_id, out)
+            self._put_output(request_id, out)
+
+    def _has_output_stream(self, request_id: str) -> bool:
+        with self._cv:
+            return request_id in self._out_streams
 
     @staticmethod
     def resolve_engine_class(config: OmniDiffusionConfig) -> type[DiffusionEngine]:
@@ -618,50 +669,37 @@ class DiffusionEngine:
     @staticmethod
     def make_engine(
         config: OmniDiffusionConfig,
-        scheduler: SchedulerInterface | None = None,
+        scheduler: BaseScheduler | None = None,
     ) -> DiffusionEngine:
         """Factory method to create the engine selected by ``config.engine_backend``.
 
         Args:
             config: The configuration for the diffusion engine.
+            scheduler: Optional scheduler override. When omitted, the selected
+                engine chooses the scheduler from its execution mode.
 
         Returns:
             An instance of the resolved ``DiffusionEngine`` (sub)class.
         """
         engine_class = DiffusionEngine.resolve_engine_class(config)
-        return engine_class(config, scheduler=scheduler)
+        engine = engine_class(config, scheduler=scheduler)
+        engine.run_startup_warmup()
+        return engine
 
     def add_request(self, request: OmniDiffusionRequest) -> str:
         with self._cv:
             if self._closed:
                 raise RuntimeError("DiffusionEngine is closed.")
-            if not self.od_config.streaming_output:
-                fut = self.main_loop.create_future()
-                request_id = self.scheduler.add_request(request)
-                self._out_queue[request_id] = fut
-            else:
-                queue: asyncio.Queue[DiffusionOutput] = asyncio.Queue()
-                request_id = self.scheduler.add_request(request)
-                self._out_queue_streaming[request_id] = queue
+            queue: asyncio.Queue[DiffusionOutput] = asyncio.Queue()
+            request_id = self.scheduler.add_request(request)
+            self._out_streams[request_id] = queue
             self._cv.notify_all()
 
         return request_id
 
-    async def get_result(self, request_id: str) -> DiffusionOutput:
-        fut = self._out_queue.get(request_id)
-
-        if fut is None:
-            raise RuntimeError(f"Request {request_id} not found in output queue.")
-        try:
-            return await fut
-        except Exception as e:
-            logger.error(f"Wait for response failed: {e}")
-            raise
-
-    async def get_streaming_result(self, request_id: str) -> AsyncGenerator[DiffusionOutput, None]:
-        """Mirrors `get_result()` in non-streaming mode."""
+    async def get_output_stream(self, request_id: str) -> AsyncGenerator[DiffusionOutput, None]:
         with self._cv:
-            queue = self._out_queue_streaming.get(request_id)
+            queue = self._out_streams.get(request_id)
         if queue is None:
             raise RuntimeError(f"Request {request_id} not found in output queue.")
         try:
@@ -674,22 +712,31 @@ class DiffusionEngine:
             logger.error(f"Wait for response failed: {e}")
             raise
         finally:
-            # In streaming mode, an output queue is maintained until the terminal chunk is met.
-            # So unlike the non-streaming mode where output Future is popped in `_handle_finished_requests` (immediately
-            # after the request is returned), the streaming mode needs to pop the output queue here (one layer above).
             with self._cv:
-                if self._out_queue_streaming.get(request_id) is queue:
-                    self._out_queue_streaming.pop(request_id, None)
-
-    async def async_add_req_and_wait_for_response(self, request: OmniDiffusionRequest) -> DiffusionOutput:
-        # No lock needed: add_request is already protected by self._cv, and
-        # all executor calls are serialized inside the busy loop.
-        request_id = self.add_request(request)
-        return await self.get_result(request_id)
+                if self._out_streams.get(request_id) is queue:
+                    self._out_streams.pop(request_id, None)
 
     def async_add_req_and_stream_response(self, request: OmniDiffusionRequest) -> AsyncGenerator[DiffusionOutput, None]:
         request_id = self.add_request(request)
-        return self.get_streaming_result(request_id)
+        return self.get_output_stream(request_id)
+
+    async def async_add_req_and_wait_for_response(self, request: OmniDiffusionRequest) -> DiffusionOutput:
+        """Deprecated compatibility wrapper over ``async_add_req_and_stream_response()``.
+
+        Use ``async_add_req_and_stream_response()`` for new callers. This
+        method drains the unified output stream and returns only the final
+        ``DiffusionOutput``, matching the historical non-streaming behavior.
+        """
+        logger.warning_once(
+            "DiffusionEngine.async_add_req_and_wait_for_response() is deprecated; "
+            "use async_add_req_and_stream_response() and consume the final output instead."
+        )
+        final_output: DiffusionOutput | None = None
+        async for output in self.async_add_req_and_stream_response(request):
+            final_output = output
+        if final_output is None:
+            raise RuntimeError("Diffusion execution completed without an output.")
+        return final_output
 
     def add_req_and_wait_for_response(self, request: OmniDiffusionRequest) -> DiffusionOutput:
         with self._rpc_lock:
@@ -733,11 +780,15 @@ class DiffusionEngine:
                     raise ValueError("Sync func should receive one result at one time")
                 if target_request_id in finished_req_ids:
                     req_output = runner_output.get_request_output(target_request_id)
-                    return self._finalize_finished_request(
+                    output = self._finalize_finished_request(
                         target_request_id,
                         runner_output=req_output,
                         missing_result_error="Diffusion execution finished without a final output.",
                     )
+                    if output.async_output_id:
+                        fut = self.executor.wait_output_ready(output.async_output_id)
+                        output = fut.result(timeout=_ASYNC_OUTPUT_TIMEOUT)
+                    return output
 
     def profile(self, is_start: bool = True, profile_prefix: str | None = None) -> None:
         """Start or stop profiling on all diffusion workers.
@@ -761,6 +812,35 @@ class DiffusionEngine:
             if is_start:
                 raise RuntimeError(f"Could not {action} profiler: {e}") from e
 
+    def run_startup_warmup(self) -> None:
+        dlo_use_allgather = getattr(self.od_config, "dlo_use_allgather", True)
+        # Skip dummy run when AllGather is used with more than 1 rank,
+        # because the dummy run sends only 1 request but AllGather requires
+        # all ranks to participate simultaneously.  This covers both DP > 1
+        # and SP > 1 (where dp_size is derived from sp_size in OffloadConfig).
+        pc = getattr(self.od_config, "parallel_config", None)
+        dp_size = getattr(pc, "data_parallel_size", 1) if pc else 1
+        sp_size = getattr(pc, "sequence_parallel_size", 1) if pc else 1
+        effective_shard_size = max(dp_size, sp_size)
+        skip_dummy = (
+            getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+            and dlo_use_allgather
+            and effective_shard_size > 1
+        )
+        if skip_dummy:
+            logger.info(
+                "Skipping dummy run (dist_offload with AllGather, dp_size=%d, sp_size=%d)",
+                dp_size,
+                sp_size,
+            )
+            return
+        try:
+            self._dummy_run()
+        except Exception as e:
+            logger.error(f"Dummy run failed: {e}")
+            self.close()
+            raise e
+
     def _dummy_run(self):
         """A dummy run to warm up the model."""
         num_inference_steps = 1
@@ -893,8 +973,8 @@ class DiffusionEngine:
     ) -> Any:
         """Async variant of :meth:`collective_rpc` for event-loop callers.
 
-        Mirrors :meth:`async_add_req_and_wait_for_response`: enqueue a task
-        keyed by a future and ``await`` the result without blocking the loop.
+        Enqueue a task keyed by a future and ``await`` the result without
+        blocking the loop.
         """
         await self._check_and_start_background_loop()
         task = self._submit_rpc(method, timeout, args, kwargs, unique_reply_rank)
@@ -907,51 +987,26 @@ class DiffusionEngine:
             task.future.cancel()
             raise TimeoutError(f"RPC call to {method} timed out.") from exc
 
-    def _complete_future(self, fut: asyncio.Future, output: DiffusionOutput) -> None:
-        if fut.done():
-            return
-
-        def _set_result() -> None:
-            if not fut.done():
-                fut.set_result(output)
-
-        try:
-            loop = fut.get_loop()
-        except AttributeError:
-            loop = self.main_loop
-
-        try:
-            running_loop = asyncio.get_running_loop()
-        except RuntimeError:
-            running_loop = None
-
-        if loop is not None and loop.is_running() and loop is not running_loop:
-            loop.call_soon_threadsafe(_set_result)
-        else:
-            _set_result()
-
-    def _put_streaming_queue_output(
+    def _put_queue_output(
         self,
         queue: asyncio.Queue[DiffusionOutput],
         output: DiffusionOutput,
     ) -> None:
-        """Append to streaming output queue in a safe event loop. Mirrors `_complete_future()` in non-streaming mode."""
         loop = self.main_loop
         if loop is not None and loop.is_running():
             loop.call_soon_threadsafe(queue.put_nowait, output)
         else:
             queue.put_nowait(output)
 
-    def _put_streaming_output_with_cv(self, request_id: str, output: DiffusionOutput) -> None:
+    def _put_output(self, request_id: str, output: DiffusionOutput) -> None:
         with self._cv:
-            queue = self._out_queue_streaming.get(request_id)
+            queue = self._out_streams.get(request_id)
         if queue is None:
             return
-        self._put_streaming_queue_output(queue, output)
+        self._put_queue_output(queue, output)
 
     def close(self) -> None:
-        pending_futures: list[asyncio.Future] = []
-        pending_streaming_queues: list[asyncio.Queue[DiffusionOutput]] = []
+        pending_streams: list[asyncio.Queue[DiffusionOutput]] = []
         with self._cv:
             if self._closed and self._shutdown_complete:
                 return
@@ -959,17 +1014,13 @@ class DiffusionEngine:
                 self._closed = True
                 if self.stop_event is not None:
                     self.stop_event.set()
-                pending_futures = list(self._out_queue.values())
-                pending_streaming_queues = list(self._out_queue_streaming.values())
-                self._out_queue.clear()
-                self._out_queue_streaming.clear()
+                pending_streams = list(self._out_streams.values())
+                self._out_streams.clear()
                 self._cv.notify_all()
 
         closed_output = DiffusionOutput(error="DiffusionEngine is closed.")
-        for fut in pending_futures:
-            self._complete_future(fut, closed_output)
-        for streaming_queue in pending_streaming_queues:
-            self._put_streaming_queue_output(streaming_queue, closed_output)
+        for stream in pending_streams:
+            self._put_queue_output(stream, closed_output)
 
         worker_thread = self.worker_thread
         if worker_thread is not None:
@@ -1046,4 +1097,7 @@ class DiffusionEngine:
         if runner_output is not None and runner_output.result is not None:
             return runner_output.result
 
+        if runner_output is not None and runner_output.async_output_id is not None:
+            return DiffusionOutput(async_output_id=runner_output.async_output_id)
+
         return DiffusionOutput(error=missing_result_error)
diff --git a/vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_flux2.py b/vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_flux2.py
new file mode 100644
index 000000000..7c0cee0f5
--- /dev/null
+++ b/vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_flux2.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import Any
+
+import torch
+from diffusers.models.autoencoders.autoencoder_kl_flux2 import AutoencoderKLFlux2
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl import DistributedAutoencoderKL_base
+from vllm_omni.diffusion.distributed.autoencoders.distributed_vae_executor import (
+    DistributedOperator,
+    GridSpec,
+    TileTask,
+)
+
+logger = init_logger(__name__)
+
+
+class DistributedAutoencoderKLFlux2(DistributedAutoencoderKL_base, AutoencoderKLFlux2):
+    def encode_tile_split(self, x: torch.Tensor) -> tuple[list[TileTask], GridSpec]:
+        _, _, height, width = x.shape
+        overlap_size = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor))
+        blend_extent = int(self.tile_latent_min_size * self.tile_overlap_factor)
+        row_limit = self.tile_latent_min_size - blend_extent
+
+        tiletask_list = []
+        for i in range(0, height, overlap_size):
+            for j in range(0, width, overlap_size):
+                tile = x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
+                tiletask_list.append(
+                    TileTask(
+                        len(tiletask_list),
+                        (i // overlap_size, j // overlap_size),
+                        tile,
+                        workload=tile.shape[2] * tile.shape[3],
+                    )
+                )
+
+        grid_spec = GridSpec(
+            split_dims=(2, 3),
+            grid_shape=(tiletask_list[-1].grid_coord[0] + 1, tiletask_list[-1].grid_coord[1] + 1),
+            tile_spec={
+                "blend_extent": blend_extent,
+                "row_limit": row_limit,
+            },
+            output_dtype=self.dtype,
+        )
+        return tiletask_list, grid_spec
+
+    def encode_tile_exec(self, task: TileTask) -> torch.Tensor:
+        tile = self.encoder(task.tensor)
+        if self.quant_conv is not None:
+            tile = self.quant_conv(tile)
+        return tile
+
+    def encode_tile_merge(
+        self, coord_tensor_map: dict[tuple[int, ...], torch.Tensor], grid_spec: GridSpec
+    ) -> torch.Tensor:
+        grid_h, grid_w = grid_spec.grid_shape
+        result_rows = []
+        for i in range(grid_h):
+            result_row = []
+            for j in range(grid_w):
+                tile = coord_tensor_map[(i, j)]
+                if i > 0:
+                    tile = self.blend_v(coord_tensor_map[(i - 1, j)], tile, grid_spec.tile_spec["blend_extent"])
+                if j > 0:
+                    tile = self.blend_h(coord_tensor_map[(i, j - 1)], tile, grid_spec.tile_spec["blend_extent"])
+                result_row.append(tile[:, :, : grid_spec.tile_spec["row_limit"], : grid_spec.tile_spec["row_limit"]])
+            result_rows.append(torch.cat(result_row, dim=-1))
+        return torch.cat(result_rows, dim=-2)
+
+    def _encode(self, x: torch.Tensor) -> torch.Tensor:
+        _, _, height, width = x.shape
+        if self.use_tiling and (width > self.tile_sample_min_size or height > self.tile_sample_min_size):
+            if self.is_distributed_enabled():
+                logger.debug("Encode running with distributed executor")
+                return self.distributed_executor.execute(
+                    x,
+                    DistributedOperator(
+                        split=self.encode_tile_split,
+                        exec=self.encode_tile_exec,
+                        merge=self.encode_tile_merge,
+                    ),
+                    broadcast_result=True,
+                )
+            return self._tiled_encode(x)
+
+        enc = self.encoder(x)
+        if self.quant_conv is not None:
+            enc = self.quant_conv(enc)
+        return enc
+
+    def decode(self, z: torch.Tensor, return_dict: bool = True, *args: Any, **kwargs: Any):
+        if not self.is_distributed_enabled():
+            return super().decode(z, return_dict=return_dict, *args, **kwargs)
+
+        split, exec_fn, merge = self._strategy_select(z)
+
+        if split is not None:
+            strategy = "tile" if split == self.tile_split else "patch"
+            logger.info(f"Decode run with distributed executor, split strategy is {strategy}")
+            result = self.distributed_executor.execute(
+                z,
+                DistributedOperator(split=split, exec=exec_fn, merge=merge),
+                broadcast_result=True,
+            )
+            if not return_dict:
+                return (result,)
+
+            from diffusers.models.autoencoders.vae import DecoderOutput
+
+            return DecoderOutput(sample=result)
+
+        return super().decode(z, return_dict=return_dict, *args, **kwargs)
diff --git a/vllm_omni/diffusion/distributed/cfg_parallel.py b/vllm_omni/diffusion/distributed/cfg_parallel.py
index 83ce73b16..55130e0cf 100644
--- a/vllm_omni/diffusion/distributed/cfg_parallel.py
+++ b/vllm_omni/diffusion/distributed/cfg_parallel.py
@@ -463,6 +463,31 @@ class CFGParallelMixin(metaclass=ABCMeta):
         """
         raise NotImplementedError("Subclasses must implement diffuse")
 
+    def check_cfg_parallel_validity(self, true_cfg_scale: float, has_neg_prompt: bool) -> bool:
+        """
+        Check if CFG parallel configuration is valid.
+
+        Args:
+            true_cfg_scale: The classifier-free guidance scale value
+            has_neg_prompt: Whether a negative prompt is provided
+
+        Returns:
+            True if CFG parallel configuration is valid, False otherwise
+        """
+        if get_classifier_free_guidance_world_size() == 1:
+            return True
+
+        if true_cfg_scale <= 1:
+            logger.warning("CFG parallel is NOT working correctly when true_cfg_scale <= 1.")
+            return False
+
+        if not has_neg_prompt:
+            logger.warning(
+                "CFG parallel is NOT working correctly when there is no negative prompt or negative prompt embeddings."
+            )
+            return False
+        return True
+
     def scheduler_step(
         self,
         noise_pred: torch.Tensor | tuple[torch.Tensor, ...],
diff --git a/vllm_omni/diffusion/distributed/group_coordinator.py b/vllm_omni/diffusion/distributed/group_coordinator.py
index 0a67fd941..14847007f 100644
--- a/vllm_omni/diffusion/distributed/group_coordinator.py
+++ b/vllm_omni/diffusion/distributed/group_coordinator.py
@@ -199,9 +199,15 @@ class GroupCoordinator:
         return input_
 
     def all_gather(
-        self, input_: torch.Tensor, dim: int = 0, separate_tensors: bool = False
+        self,
+        input_: torch.Tensor,
+        dim: int = 0,
+        separate_tensors: bool = False,
+        group: ProcessGroup | None = None,
     ) -> torch.Tensor | list[torch.Tensor]:
-        world_size = self.world_size
+        if group is None:
+            group = self.device_group
+        world_size = torch.distributed.get_world_size(group)
         # Bypass the function if we are using only 1 GPU.
         if world_size == 1:
             return input_
@@ -214,7 +220,7 @@ class GroupCoordinator:
         input_size[0] *= world_size
         output_tensor = torch.empty(input_size, dtype=input_.dtype, device=input_.device)
         # All-gather.
-        torch.distributed.all_gather_into_tensor(output_tensor, input_.contiguous(), group=self.device_group)
+        torch.distributed.all_gather_into_tensor(output_tensor, input_.contiguous(), group=group)
         if dim != 0:
             input_size[0] //= world_size
             output_tensor = output_tensor.reshape(
@@ -1002,6 +1008,7 @@ class SequenceParallelGroupCoordinator(GroupCoordinator):
 
         ulysses_group = kwargs.get("ulysses_group", None)
         ring_group = kwargs.get("ring_group", None)
+        allgather_group = kwargs.get("allgather_group", None)
         if ulysses_group is None:
             raise RuntimeError(
                 "Please pass argument 'ulysses_group' when calling init func of SequenceParallelGroupCoordinator"
@@ -1010,10 +1017,17 @@ class SequenceParallelGroupCoordinator(GroupCoordinator):
             raise RuntimeError(
                 "Please pass argument 'ring_group' when calling init func of SequenceParallelGroupCoordinator"
             )
+        if allgather_group is None:
+            raise RuntimeError(
+                "Please pass argument 'allgather_group' when calling init func of SequenceParallelGroupCoordinator"
+            )
         self.ulysses_group = ulysses_group
         self.ring_group = ring_group
+        self.allgather_group = allgather_group
 
         self.ulysses_world_size = torch.distributed.get_world_size(self.ulysses_group)
         self.ulysses_rank = torch.distributed.get_rank(self.ulysses_group)
         self.ring_world_size = torch.distributed.get_world_size(self.ring_group)
         self.ring_rank = torch.distributed.get_rank(self.ring_group)
+        self.allgather_world_size = torch.distributed.get_world_size(self.allgather_group)
+        self.allgather_rank = torch.distributed.get_rank(self.allgather_group)
diff --git a/vllm_omni/diffusion/distributed/parallel_state.py b/vllm_omni/diffusion/distributed/parallel_state.py
index 7b38d3775..20fcc9dea 100644
--- a/vllm_omni/diffusion/distributed/parallel_state.py
+++ b/vllm_omni/diffusion/distributed/parallel_state.py
@@ -303,8 +303,15 @@ def get_ring_parallel_rank():
     return get_sp_group().ring_rank
 
 
+def get_allgather_parallel_world_size():
+    return get_sp_group().allgather_world_size
+
+
+def get_allgather_parallel_rank():
+    return get_sp_group().allgather_rank
+
+
 def get_expert_parallel_group_ranks() -> list[list[int]]:
-    assert vllm_parallel_state._EP is not None, "expert parallel group is not initialized"
     assert _EXPERT_PARALLEL_GROUP_RANKS is not None, "expert parallel group ranks are not initialized"
     return _EXPERT_PARALLEL_GROUP_RANKS
 
@@ -548,13 +555,12 @@ def set_seq_parallel_pg(
     world_size: int,
     use_ulysses_low: bool = True,
     sp_group_ranks: list[list[int]] | None = None,
-) -> tuple[torch.distributed.ProcessGroup, torch.distributed.ProcessGroup]:
+    sp_allgather_degree: int = 1,
+) -> tuple[torch.distributed.ProcessGroup, torch.distributed.ProcessGroup, torch.distributed.ProcessGroup]:
     """
-    Initialize sequence-parallel Ulysses and Ring process groups.
+    Initialize Ulysses, Ring, and AllGather-KV process groups.
 
-    This builds sequence-parallel (SP) subgroups inside each data-parallel (DP)
-    slice. The SP group size is sp_ulysses_degree * sp_ring_degree, and
-    world_size must be divisible by that size.
+    AllGather-KV is mutually exclusive with Ulysses and Ring.
 
     Args:
         sp_ulysses_degree: Size of each Ulysses subgroup.
@@ -569,7 +575,7 @@ def set_seq_parallel_pg(
             ranges.
 
     Returns:
-        ulyssess_pg (torch.distributed.ProcessGroup): The Ulysses process group
+        ulysses_pg (torch.distributed.ProcessGroup): The Ulysses process group
             for this rank.
         ring_pg (torch.distributed.ProcessGroup): The Ring process group for
             this rank.
@@ -586,6 +592,31 @@ def set_seq_parallel_pg(
         - If sp_group_ranks is None, groups are auto-generated within each DP
           slice using offsets of size sp_size.
     """
+    if sp_allgather_degree > 1:
+        if sp_ulysses_degree > 1 or sp_ring_degree > 1:
+            raise ValueError("AllGather-KV is mutually exclusive with Ulysses and Ring")
+        sp_size = sp_allgather_degree
+        if sp_group_ranks is None:
+            sp_group_ranks = [list(range(offset, offset + sp_size)) for offset in range(0, world_size, sp_size)]
+        if len(sp_group_ranks) * sp_size != world_size or any(len(ranks) != sp_size for ranks in sp_group_ranks):
+            raise ValueError(f"Invalid sp_group_ranks: expected {world_size // sp_size} groups of size {sp_size}.")
+
+        ulysses_pg = ring_pg = allgather_pg = None
+        for group_ranks in sp_group_ranks:
+            group = torch.distributed.new_group(group_ranks)
+            if rank in group_ranks:
+                allgather_pg = group
+        for singleton_rank in range(world_size):
+            group = torch.distributed.new_group([singleton_rank])
+            if rank == singleton_rank:
+                ulysses_pg = group
+        for singleton_rank in range(world_size):
+            group = torch.distributed.new_group([singleton_rank])
+            if rank == singleton_rank:
+                ring_pg = group
+        assert ulysses_pg is not None and ring_pg is not None and allgather_pg is not None
+        return ulysses_pg, ring_pg, allgather_pg
+
     sp_size = sp_ring_degree * sp_ulysses_degree
     dp_size = world_size // sp_size
 
@@ -619,7 +650,7 @@ def set_seq_parallel_pg(
                     ulysses_ranks = group_ranks[i * sp_ulysses_degree : (i + 1) * sp_ulysses_degree]
                     group = torch.distributed.new_group(ulysses_ranks)
                     if rank in ulysses_ranks:
-                        ulyssess_pg = group
+                        ulysses_pg = group
                         local_ulysses = list(ulysses_ranks)
                 for i in range(num_ring_pgs):
                     ring_ranks = group_ranks[i::num_ring_pgs]
@@ -639,7 +670,7 @@ def set_seq_parallel_pg(
                     ulysses_ranks = group_ranks[i::num_ulysses_pgs]
                     group = torch.distributed.new_group(ulysses_ranks)
                     if rank in ulysses_ranks:
-                        ulyssess_pg = group
+                        ulysses_pg = group
                         local_ulysses = list(ulysses_ranks)
         if local_sp_group is not None:
             logger.info(
@@ -662,7 +693,7 @@ def set_seq_parallel_pg(
                     )
                     group = torch.distributed.new_group(ulysses_ranks)
                     if rank in ulysses_ranks:
-                        ulyssess_pg = group
+                        ulysses_pg = group
 
                 for i in range(num_ring_pgs):
                     ring_ranks = list(range(i + offset, sp_size + offset, num_ring_pgs))
@@ -683,9 +714,15 @@ def set_seq_parallel_pg(
                     ulysses_ranks = list(range(i + offset, sp_size + offset, num_ulysses_pgs))
                     group = torch.distributed.new_group(ulysses_ranks)
                     if rank in ulysses_ranks:
-                        ulyssess_pg = group
+                        ulysses_pg = group
 
-    return ulyssess_pg, ring_pg
+    allgather_pg = None
+    for singleton_rank in range(world_size):
+        group = torch.distributed.new_group([singleton_rank])
+        if rank == singleton_rank:
+            allgather_pg = group
+    assert allgather_pg is not None
+    return ulysses_pg, ring_pg, allgather_pg
 
 
 def initialize_model_parallel(
@@ -694,6 +731,7 @@ def initialize_model_parallel(
     sequence_parallel_size: int | None = None,
     ulysses_degree: int = 1,
     ring_degree: int = 1,
+    allgather_degree: int = 1,
     tensor_parallel_size: int = 1,
     pipeline_parallel_size: int = 1,
     fully_shard_degree: int = 1,
@@ -710,9 +748,12 @@ def initialize_model_parallel(
         data_parallel_size: number of data parallelism groups.
         cfg_parallel_size: number of GPUs used for Classifier Free Guidance (CFG) parallelism.
         sequence_parallel_size: number of GPUs used for sequence parallelism.
-            sequence_parallel_size = ulysses_degree * ring_degree
+            Uses allgather_degree when AllGather-KV is enabled, otherwise
+            ulysses_degree * ring_degree.
         ulysses_degree: number of GPUs used for ulysses sequence parallelism.
         ring_degree: number of GPUs used for ring sequence parallelism.
+        allgather_degree: number of GPUs used for AllGather-KV sequence parallelism
+            (causal=False only). Mutually exclusive with ulysses/ring in v1.
         tensor_parallel_size: number of GPUs used for tensor parallelism.
         pipeline_parallel_size: number of GPUs used for pipeline parallelism.
         fully_shard_degree: number of GPUs used for fully sharded data parallelism (HSDP shard dimension).
@@ -749,16 +790,22 @@ def initialize_model_parallel(
     world_size: int = torch.distributed.get_world_size()
     backend = backend or torch.distributed.get_backend(get_world_group().device_group)
 
-    if sequence_parallel_size is None:
-        sequence_parallel_size = ring_degree * ulysses_degree
-        logger.info(
-            f"sequence_parallel_size is not provided, using ring_degree * ulysses_degree = {sequence_parallel_size}"
+    if allgather_degree > 1:
+        assert ulysses_degree == 1 and ring_degree == 1, (
+            "AllGather-KV (allgather_degree>1) is mutually exclusive with Ulysses/Ring in v1. "
+            f"Got ulysses_degree={ulysses_degree}, ring_degree={ring_degree}, "
+            f"allgather_degree={allgather_degree}."
         )
 
-    if sequence_parallel_size != ring_degree * ulysses_degree:
+    expected_sequence_parallel_size = allgather_degree if allgather_degree > 1 else ring_degree * ulysses_degree
+    if sequence_parallel_size is None:
+        sequence_parallel_size = expected_sequence_parallel_size
+        logger.info("sequence_parallel_size is not provided, using %d", sequence_parallel_size)
+
+    if sequence_parallel_size != expected_sequence_parallel_size:
         raise ValueError(
-            "sequence_parallel_size is not equal to ring_degree * ulysses_degree,"
-            f" but got {sequence_parallel_size} != {ring_degree} * {ulysses_degree}"
+            f"sequence_parallel_size must be {expected_sequence_parallel_size} for the configured SP mode, "
+            f"but got {sequence_parallel_size}"
         )
 
     dit_parallel_size = (
@@ -835,9 +882,10 @@ def initialize_model_parallel(
 
     global _SP
     assert _SP is None, "sequence parallel group is already initialized"
-    ulysses_pg, ring_pg = set_seq_parallel_pg(
+    ulysses_pg, ring_pg, allgather_pg = set_seq_parallel_pg(
         sp_ulysses_degree=ulysses_degree,
         sp_ring_degree=ring_degree,
+        sp_allgather_degree=allgather_degree,
         rank=get_world_group().rank_in_group,
         world_size=dit_parallel_size,
         sp_group_ranks=sp_group_ranks,
@@ -849,6 +897,7 @@ def initialize_model_parallel(
         parallel_mode="sequence",
         ulysses_group=ulysses_pg,
         ring_group=ring_pg,
+        allgather_group=allgather_pg,
     )
     if use_moe_parallel_mapping:
         # Diffusion normally uses its own SP group. Map it to vLLM PCP only for
@@ -898,16 +947,14 @@ def initialize_model_parallel(
         parallel_mode="fully_shard",
     )
 
-    _EXPERT_PARALLEL_GROUP_RANKS = None
+    _EXPERT_PARALLEL_GROUP_RANKS = rank_generator.get_ranks("tp-sp-cfg-dp")
     if use_moe_parallel_mapping:
-        ep_group_ranks = rank_generator.get_ranks("tp-sp-cfg-dp")
         vllm_parallel_state._EP = init_vllm_model_parallel_group(
-            group_ranks=ep_group_ranks,
+            group_ranks=_EXPERT_PARALLEL_GROUP_RANKS,
             local_rank=get_world_group().local_rank,
             backend=backend,
             group_name="ep",
         )
-        _EXPERT_PARALLEL_GROUP_RANKS = ep_group_ranks
 
     init_dit_group(dit_parallel_size, backend)
 
diff --git a/vllm_omni/diffusion/distributed/sp_plan.py b/vllm_omni/diffusion/distributed/sp_plan.py
index ee7b1d66b..b8d248865 100644
--- a/vllm_omni/diffusion/distributed/sp_plan.py
+++ b/vllm_omni/diffusion/distributed/sp_plan.py
@@ -77,6 +77,7 @@ class SequenceParallelConfig:
 
     ulysses_degree: int = 1
     ring_degree: int = 1
+    allgather_degree: int = 1
     convert_to_fp32: bool = True
 
     # Internal state - populated by setup()
@@ -85,18 +86,18 @@ class SequenceParallelConfig:
     _device: torch.device | None = None
 
     def __post_init__(self) -> None:
-        if self.ulysses_degree < 1 or self.ring_degree < 1:
-            raise ValueError("`ulysses_degree` and `ring_degree` must be >= 1.")
+        if self.ulysses_degree < 1 or self.ring_degree < 1 or self.allgather_degree < 1:
+            raise ValueError("SP degrees must be >= 1.")
 
-        if self.ulysses_degree == 1 and self.ring_degree == 1:
-            raise ValueError(
-                "At least one of `ulysses_degree` or `ring_degree` must be > 1 to use sequence parallelism."
-            )
+        if self.allgather_degree > 1 and (self.ulysses_degree > 1 or self.ring_degree > 1):
+            raise ValueError("AllGather-KV is mutually exclusive with Ulysses and Ring.")
+        if self.ulysses_degree == self.ring_degree == self.allgather_degree == 1:
+            raise ValueError("At least one SP degree must be > 1.")
 
     @property
     def sequence_parallel_size(self) -> int:
         """Total sequence parallel world size."""
-        return self.ulysses_degree * self.ring_degree
+        return self.allgather_degree if self.allgather_degree > 1 else self.ulysses_degree * self.ring_degree
 
     def get_world_size(self) -> int:
         """Get the sequence parallel world size from parallel state.
@@ -178,13 +179,12 @@ class SequenceParallelConfig:
         self._world_size = world_size
         self._device = device
 
-        expected_sp_size = self.ulysses_degree * self.ring_degree
+        expected_sp_size = self.sequence_parallel_size
         actual_sp_size = self.get_world_size()
 
         if expected_sp_size != actual_sp_size:
             raise ValueError(
-                f"Configuration mismatch: ulysses_degree ({self.ulysses_degree}) * "
-                f"ring_degree ({self.ring_degree}) = {expected_sp_size}, but "
+                f"Configuration mismatch: expected SP size {expected_sp_size}, but "
                 f"actual sequence parallel world size is {actual_sp_size}."
             )
 
diff --git a/vllm_omni/diffusion/executor/abstract.py b/vllm_omni/diffusion/executor/abstract.py
index 8bfb5923a..ec6b3486a 100644
--- a/vllm_omni/diffusion/executor/abstract.py
+++ b/vllm_omni/diffusion/executor/abstract.py
@@ -59,7 +59,7 @@ class DiffusionExecutor(ABC):
             raise ValueError(f"Unknown distributed executor backend: {distributed_executor_backend}")
         return executor_class
 
-    def __init__(self, od_config: OmniDiffusionConfig):
+    def __init__(self, od_config: OmniDiffusionConfig) -> None:
         self.od_config = od_config
         self._init_executor()
 
@@ -68,6 +68,12 @@ class DiffusionExecutor(ABC):
         """Initialize the executor (e.g., launch workers, setup IPC)."""
         pass
 
+    @property
+    @abstractmethod
+    def is_dead(self) -> bool:
+        """Whether the executor is shut down or has failed fatally."""
+        pass
+
     @abstractmethod
     def execute_request(self, scheduler_output: DiffusionSchedulerOutput) -> BaseRunnerOutput:
         """Execute request-mode work from a scheduler output."""
@@ -75,7 +81,7 @@ class DiffusionExecutor(ABC):
 
     @abstractmethod
     def execute_batch(self, scheduler_output: DiffusionSchedulerOutput) -> BaseRunnerOutput:
-        """Execute request-mode work as a single batched RPC."""
+        """Execute request-mode work through the request-batch path."""
         pass
 
     @abstractmethod
diff --git a/vllm_omni/diffusion/executor/multiproc_executor.py b/vllm_omni/diffusion/executor/multiproc_executor.py
index 2e491ff69..fa7130e40 100644
--- a/vllm_omni/diffusion/executor/multiproc_executor.py
+++ b/vllm_omni/diffusion/executor/multiproc_executor.py
@@ -1,20 +1,24 @@
 from __future__ import annotations
 
+import concurrent.futures
+import json
 import multiprocessing as mp
 import multiprocessing.connection
+import queue
 import threading
 import time
 import weakref
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from multiprocessing.synchronize import Event
+from typing import TYPE_CHECKING, Any, cast
 
 import zmq
-from vllm.distributed.device_communicators.shm_broadcast import MessageQueue
+from vllm.distributed.device_communicators.shm_broadcast import Handle, MessageQueue
 from vllm.logger import init_logger
 from vllm.v1.engine.exceptions import EngineDeadError
 
-from vllm_omni.diffusion.data import SHUTDOWN_MESSAGE, DiffusionOutput
+from vllm_omni.diffusion.data import SHUTDOWN_MESSAGE, AsyncDiffusionOutput, AsyncOutputKind, DiffusionOutput
 from vllm_omni.diffusion.executor.abstract import DiffusionExecutor
 from vllm_omni.diffusion.ipc import DIFFUSION_RPC_RESULT_ENVELOPE, unpack_diffusion_output_shm
 from vllm_omni.diffusion.worker import WorkerProc
@@ -29,29 +33,21 @@ _DEQUEUE_TIMEOUT_S = 5.0
 
 
 @dataclass
-class BackgroundResources:
-    """
-    Used as a finalizer for clean shutdown.
-    """
+class _ExecutorShutdownCleaner:
+    """Finalizer that shuts down executor worker processes."""
 
     broadcast_mq: MessageQueue | None = None
-    result_mq: MessageQueue | None = None
     num_workers: int = 0
     processes: list[mp.Process] | None = None
 
-    def __call__(self):
+    def __call__(self) -> None:
         """Clean up background resources."""
-        if hasattr(self, "wake_events") and self.wake_events:
-            for ev in self.wake_events:
-                ev.set()
-
         if self.broadcast_mq is not None:
             try:
                 for _ in range(self.num_workers):
                     self.broadcast_mq.enqueue(SHUTDOWN_MESSAGE, timeout=1.0)
 
                 self.broadcast_mq = None
-                self.result_mq = None
             except Exception as exc:
                 logger.warning("Failed to send shutdown signal: %s", exc)
 
@@ -69,13 +65,19 @@ class BackgroundResources:
 class MultiprocDiffusionExecutor(DiffusionExecutor):
     uses_multiproc: bool = True
 
+    # Class-level defaults so tests using object.__new__ (without _init_executor)
+    # don't hit AttributeError when collective_rpc accesses these.
+    _rpc_wave_id: int = 0
+
     def _init_executor(self) -> None:
         self._processes: list[mp.Process] = []
         self._closed = False
-        self.is_failed = False
+        self._is_failed = False
         self._failure_callbacks: list[Callable[[], None]] = []
+        self._result_mq: MessageQueue | None = None
+        self._rpc_wave_id: int = 0
 
-        num_workers = self.od_config.num_gpus
+        num_workers = cast(int, self.od_config.num_gpus)
         self.wake_events = [mp.Event() for _ in range(num_workers)]
 
         self._broadcast_mq = self._init_broadcast_queue(num_workers)
@@ -83,18 +85,40 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
 
         # Launch workers
         processes, result_handle = self._launch_workers(broadcast_handle, self.wake_events)
-        self._result_mq = self._init_result_queue(result_handle)
         self._processes = processes
 
-        self.resources = BackgroundResources(
+        shutdown_cleaner = _ExecutorShutdownCleaner(
             broadcast_mq=self._broadcast_mq,
-            result_mq=self._result_mq,
             num_workers=num_workers,
             processes=self._processes,
         )
-        self._finalizer = weakref.finalize(self, self.resources)
+        self._shutdown_cleaner: _ExecutorShutdownCleaner | None = shutdown_cleaner
+        self._finalizer = weakref.finalize(self, shutdown_cleaner)
 
-        self.start_worker_monitor()
+        try:
+            self._result_mq = self._init_result_queue(result_handle)
+        except Exception:
+            self.shutdown()
+            raise
+
+        # Async output: result pump thread for dispatching AsyncDiffusionOutput
+        # messages in request-mode (step_execution=False).
+        self._rpc_id_counter = 0
+        self._rpc_id_lock = threading.Lock()
+        self._rpc_futures: dict[str, concurrent.futures.Future[AsyncDiffusionOutput]] = {}
+        self._output_futures: dict[str, concurrent.futures.Future[DiffusionOutput]] = {}
+        self._completed_outputs: dict[str, concurrent.futures.Future[DiffusionOutput]] = {}
+        self._batch_split_map: dict[str, dict[str, str]] = {}  # batch_id -> {per_req_id: request_id}
+        self._futures_lock = threading.RLock()
+        self._pump_running = False
+        self._pump_stop = threading.Event()
+        # When pump is active it is the sole reader of result_mq; non-async
+        # messages are placed here for collective_rpc() to consume.
+        self._sync_result_buffer: queue.Queue = queue.Queue()
+        if not self.od_config.step_execution:
+            self._start_result_pump()
+
+        self._start_worker_monitor()
 
     def _init_broadcast_queue(self, num_workers: int) -> MessageQueue:
         return MessageQueue(
@@ -103,20 +127,26 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
             local_reader_ranks=list(range(num_workers)),
         )
 
-    def _init_result_queue(self, result_handle) -> MessageQueue | None:
+    def _init_result_queue(self, result_handle: Handle | None) -> MessageQueue:
         if result_handle is None:
-            logger.error("Failed to get result queue handle from workers")
-            return None
+            raise RuntimeError("Failed to get result queue handle from workers")
         return MessageQueue.create_from_handle(result_handle, 0)
 
     def _ensure_open(self) -> None:
         if self._closed:
             raise RuntimeError("DiffusionExecutor is closed.")
         if self._result_mq is None:
-            raise RuntimeError("Result queue not initialized")
+            raise RuntimeError("Result queue is closed")
+        if self._broadcast_mq is None:
+            raise RuntimeError("Broadcast queue is closed")
 
     def _dequeue_one_with_failure_polling(self, deadline: float | None, method: str) -> Any:
-        """Block until one result message, polling ``is_failed`` between chunk timeouts."""
+        """Block until one result message, polling ``_is_failed`` between chunk timeouts.
+
+        When async output is enabled, pump is the sole reader of result_mq;
+        non-async messages are placed in _sync_result_buffer, so this method
+        reads from there instead of result_mq directly.
+        """
         while True:
             if deadline is None:
                 chunk_timeout = _DEQUEUE_TIMEOUT_S
@@ -125,12 +155,20 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
                 if remaining <= 0:
                     raise TimeoutError(f"RPC call to {method} timed out.")
                 chunk_timeout = min(_DEQUEUE_TIMEOUT_S, remaining)
-            try:
-                return self._result_mq.dequeue(timeout=chunk_timeout)
-            except (TimeoutError, zmq.error.Again):
-                if self.is_failed:
-                    raise EngineDeadError()
-                continue
+            if not self.od_config.step_execution:
+                try:
+                    return self._sync_result_buffer.get(timeout=chunk_timeout)
+                except queue.Empty:
+                    if self._is_failed or self._closed:
+                        raise EngineDeadError()
+                    continue
+            else:
+                try:
+                    return self._result_mq.dequeue(timeout=chunk_timeout)  # pyright: ignore[reportOptionalMemberAccess] MQ is not None before shutdown
+                except (TimeoutError, zmq.error.Again):
+                    if self._is_failed:
+                        raise EngineDeadError()
+                    continue
 
     @staticmethod
     def _raise_for_rpc_error_dict(response: Any) -> None:
@@ -183,11 +221,39 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
         MultiprocDiffusionExecutor._raise_for_rpc_error_dict(response)
         return response
 
-    def _launch_workers(self, broadcast_handle, wake_events):
+    _MAX_STALE_DISCARDS = 16
+
+    def _validate_wave_id(self, response: Any, expected_wave_id: int, deadline: float | None, method: str) -> Any:
+        """Discard stale RPC responses from a previous wave."""
+        discards = 0
+        while discards < self._MAX_STALE_DISCARDS:
+            if not isinstance(response, dict):
+                return response
+            resp_wave_id = response.get("wave_id")
+            if resp_wave_id is None or resp_wave_id == expected_wave_id:
+                return response
+            logger.warning(
+                "Discarding stale RPC response (wave_id=%s, expected=%s, method=%s)",
+                resp_wave_id,
+                expected_wave_id,
+                method,
+            )
+            discards += 1
+            response = self._dequeue_one_with_failure_polling(deadline, method)
+        raise TimeoutError(
+            f"Discarded {self._MAX_STALE_DISCARDS} stale RPC responses "
+            f"without finding wave_id={expected_wave_id} for method={method}."
+        )
+
+    def _launch_workers(
+        self,
+        broadcast_handle: Handle,
+        wake_events: list[Event],
+    ) -> tuple[list[mp.Process], Handle | None]:
         od_config = self.od_config
         logger.info("Starting server...")
 
-        num_gpus = od_config.num_gpus
+        num_gpus = cast(int, od_config.num_gpus)
         mp.set_start_method("spawn", force=True)
         processes = []
 
@@ -221,7 +287,6 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
             processes.append(process)
 
         # Wait for all workers to be ready
-        scheduler_infos = []
         result_handle = None
         for writer in scheduler_pipe_writers:
             writer.close()
@@ -241,14 +306,18 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
             if i == 0:
                 result_handle = data.get("result_handle")
 
-            scheduler_infos.append(data)
             reader.close()
 
         logger.debug("All workers are ready")
 
         return processes, result_handle
 
-    def start_worker_monitor(self) -> None:
+    @property
+    def is_dead(self) -> bool:
+        """Whether the executor is shut down or a worker has failed fatally."""
+        return self._closed or self._is_failed
+
+    def _start_worker_monitor(self) -> None:
         # Monitors worker process liveness. If any die unexpectedly,
         # logs an error, shuts down the executor and invokes the failure
         # callback to inform the engine.
@@ -287,7 +356,7 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
                     "Diffusion worker(s) died unexpectedly: %s",
                     details,
                 )
-                self.is_failed = True
+                self._is_failed = True
 
             self.shutdown()
 
@@ -311,31 +380,115 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
         """Adapt request-mode scheduler output to worker execute_model RPCs.
 
         Returns a BatchRunnerOutput with one RunnerOutput per scheduled request.
+        In async mode the result may carry async_output_id instead of the final output.
         """
         from vllm_omni.diffusion.worker.utils import BatchRunnerOutput, RunnerOutput
 
         self._ensure_open()
+        new_reqs = scheduler_output.scheduled_new_reqs
         runner_outputs: list[RunnerOutput] = []
 
-        for new_req in scheduler_output.scheduled_new_reqs:
+        # DP multi-concurrency: when DLO+AllGather is active and multiple
+        # requests are scheduled, send ALL requests in one broadcast RPC.
+        # Each rank picks req[rank % len(reqs)] and computes independently.
+        # All ranks reply (unique_reply_rank=None) so we collect dp_size
+        # responses and match by dp_rank.
+        if (
+            len(new_reqs) > 1
+            and getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+            and getattr(self.od_config, "dlo_use_allgather", True)
+        ):
+            # Validate: all concurrent requests must share the same
+            # num_inference_steps and identical extra_args, because
+            # AllGather is a collective that requires every rank to
+            # participate at each step.
+            step_counts = {
+                nr.req.sampling_params.num_inference_steps
+                for nr in new_reqs
+                if nr.req.sampling_params.num_inference_steps is not None
+            }
+            has_none = any(nr.req.sampling_params.num_inference_steps is None for nr in new_reqs)
+            if (len(step_counts) > 1) or has_none:
+                raise ValueError(
+                    "DP multi-concurrency requires all concurrent requests to have "
+                    "the same explicit num_inference_steps (None is not allowed), got "
+                    f"{[nr.req.sampling_params.num_inference_steps for nr in new_reqs]}."
+                )
+            extra_args_signatures: set = set()
+            for nr in new_reqs:
+                ea = getattr(nr.req.sampling_params, "extra_args", None)
+                extra_args_signatures.add(json.dumps(ea, sort_keys=True, default=repr) if ea is not None else None)
+            if len(extra_args_signatures) > 1:
+                raise ValueError(
+                    "DP multi-concurrency requires all concurrent requests to "
+                    "share identical extra_args. Different extra_args can change "
+                    "the forward schedule and cause AllGather deadlock."
+                )
+
+            reqs_list = [nr.req for nr in new_reqs]
+            try:
+                results = self.collective_rpc(
+                    "execute_model",
+                    args=(reqs_list, self.od_config, scheduler_output.kv_prefetch_job),
+                    unique_reply_rank=None,
+                    exec_all_ranks=True,
+                )
+                results = results if isinstance(results, list) else [results]
+                for i, new_req in enumerate(new_reqs):
+                    res = results[i] if i < len(results) else results[0]
+                    if isinstance(res, DiffusionOutput):
+                        runner_outputs.append(
+                            RunnerOutput(
+                                request_id=new_req.request_id,
+                                step_index=None,
+                                finished=True,
+                                result=res,
+                            )
+                        )
+                    else:
+                        raise RuntimeError(f"Unexpected response type [{i}]: {type(res)!r}")
+            except Exception as exc:
+                for new_req in new_reqs:
+                    runner_outputs.append(
+                        RunnerOutput(
+                            request_id=new_req.request_id,
+                            step_index=None,
+                            finished=True,
+                            result=DiffusionOutput(error=str(exc)),
+                        )
+                    )
+            return BatchRunnerOutput.from_list(runner_outputs)
+
+        for new_req in new_reqs:
             req = new_req.req
             try:
                 result = self.collective_rpc(
                     "execute_model",
-                    args=(req, self.od_config, scheduler_output.kv_prefetch_jobs),
+                    args=(req, self.od_config, scheduler_output.kv_prefetch_job),
                     unique_reply_rank=0,
                     exec_all_ranks=True,
                 )
-                if not isinstance(result, DiffusionOutput):
-                    raise RuntimeError(f"Unexpected response type: {type(result)!r}")
-                runner_outputs.append(
-                    RunnerOutput(
-                        request_id=new_req.request_id,
-                        step_index=None,
-                        finished=True,
-                        result=result,
+                if isinstance(result, AsyncDiffusionOutput) and result.kind == AsyncOutputKind.COMPUTE_DONE:
+                    runner_outputs.append(
+                        RunnerOutput(
+                            request_id=new_req.request_id,
+                            step_index=None,
+                            finished=True,
+                            result=None,
+                            async_output_id=result.async_output_id,
+                        )
                     )
-                )
+                elif isinstance(result, DiffusionOutput):
+                    runner_outputs.append(
+                        RunnerOutput(
+                            request_id=new_req.request_id,
+                            step_index=None,
+                            finished=True,
+                            result=result,
+                        )
+                    )
+                else:
+                    raise RuntimeError(f"Unexpected response type: {type(result)!r}")
             except Exception as exc:
                 runner_outputs.append(
                     RunnerOutput(
@@ -349,20 +502,61 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
         return BatchRunnerOutput.from_list(runner_outputs)
 
     def execute_batch(self, scheduler_output: DiffusionSchedulerOutput) -> BaseRunnerOutput:
-        """Execute request-mode work through a single batched worker RPC.
+        """Execute request-mode work through the unified request-batch path.
 
-        The worker builds DiffusionRequestBatch from scheduler output and returns
-        BatchRunnerOutput with one RunnerOutput per scheduled request.
+        A scheduler wave with one request is the conservative serial case and
+        uses the single-request worker RPC. Waves with multiple requests use the
+        fused request-batch RPC and require pipeline request-batch support.
+
+        When async output is enabled, per-request async_output_ids are
+        propagated through RunnerOutput so the engine waits in
+        step_streaming() instead of blocking the busy loop here.
         """
-        from vllm_omni.diffusion.worker.utils import BatchRunnerOutput
+        from vllm_omni.diffusion.worker.utils import BatchRunnerOutput, RunnerOutput
 
         self._ensure_open()
+        if len(scheduler_output.scheduled_new_reqs) <= 1:
+            return self.execute_request(scheduler_output)
+
+        parallel_config = getattr(self.od_config, "parallel_config", None)
+        dp_size = getattr(parallel_config, "data_parallel_size", 1)
+        if (
+            dp_size > 1
+            and getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+            and getattr(self.od_config, "dlo_use_allgather", True)
+        ):
+            # DLO DP uses one independent request per DP replica.  It is not a
+            # fused pipeline request batch, so models such as MiniMax-H3 do not
+            # need to advertise supports_request_batch=True.
+            return self.execute_request(scheduler_output)
+
         result = self.collective_rpc(
             "execute_model_batch",
             args=(scheduler_output, self.od_config),
             unique_reply_rank=0,
             exec_all_ranks=True,
         )
+        if isinstance(result, AsyncDiffusionOutput) and result.kind == AsyncOutputKind.COMPUTE_DONE:
+            # Propagate async_output_id to per-request RunnerOutputs so the
+            # engine waits in step_streaming() instead of blocking here.
+            batch_id = result.async_output_id
+            per_req_map: dict[str, str] = {}
+            runner_outputs: list[RunnerOutput] = []
+            for new_req in scheduler_output.scheduled_new_reqs:
+                per_req_id = f"{batch_id}/{new_req.request_id}"
+                per_req_map[per_req_id] = new_req.request_id
+                runner_outputs.append(
+                    RunnerOutput(
+                        request_id=new_req.request_id,
+                        step_index=None,
+                        finished=True,
+                        result=None,
+                        async_output_id=per_req_id,
+                    )
+                )
+            with self._futures_lock:
+                self._batch_split_map[batch_id] = per_req_map
+            return BatchRunnerOutput.from_list(runner_outputs)
         if not isinstance(result, BatchRunnerOutput):
             raise RuntimeError(f"Unexpected response type for execute_batch: {type(result)!r}")
         return result
@@ -397,11 +591,6 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
         deadline = None if timeout is None else time.monotonic() + timeout
         kwargs = kwargs or {}
 
-        # Prepare RPC request message. When unique_reply_rank is None, all
-        # workers must execute the RPC but only rank 0 can reply (it's the
-        # only one with a result_mq). Collect detailed rank statuses only for
-        # this control-plane all-rank path; forward-path exec_all_ranks RPCs
-        # avoid the per-step host object gather.
         execute_all_ranks = unique_reply_rank is None or exec_all_ranks
         collect_rank_status = unique_reply_rank is None
         rpc_request = {
@@ -414,46 +603,237 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
             "collect_rank_status": collect_rank_status,
         }
 
+        # ── Path 1: async execute_model / execute_model_batch ──
+        # Request-mode methods use the compute_done/output_ready split
+        # so the D2H copy runs on a side stream in the worker background
+        # thread while the default stream is free for the next forward.
+        # pump routes the result back to a Future via rpc_id.
+        multi_rank_reply = unique_reply_rank is None and exec_all_ranks
+        if (
+            not self.od_config.step_execution
+            and method in ("execute_model", "execute_model_batch")
+            and not multi_rank_reply
+        ):
+            rpc_id = self._next_rpc_id()
+            rpc_request["rpc_id"] = rpc_id
+            fut: concurrent.futures.Future = concurrent.futures.Future()
+            with self._futures_lock:
+                self._rpc_futures[rpc_id] = fut
+            self._broadcast_mq.enqueue(rpc_request)  # pyright: ignore[reportOptionalMemberAccess] MQ is not None before shutdown
+            try:
+                return fut.result(timeout=timeout)
+            except concurrent.futures.TimeoutError:
+                with self._futures_lock:
+                    self._rpc_futures.pop(rpc_id, None)
+                raise TimeoutError(f"RPC call to {method} timed out.")
+
+        # ── Path 2: step-execution or other non-execute_model RPCs ──
+        # _dequeue_one_with_failure_polling reads from _sync_result_buffer
+        # when pump is active (request-mode), or result_mq directly otherwise.
+        self._rpc_wave_id += 1
+        wave_id = self._rpc_wave_id
+        rpc_request["wave_id"] = wave_id
+
         try:
             # Broadcast RPC request to all workers via unified message queue
-            self._broadcast_mq.enqueue(rpc_request)
+            self._broadcast_mq.enqueue(rpc_request)  # pyright: ignore[reportOptionalMemberAccess] MQ is not None before shutdown
 
-            # Only rank 0 has a result_mq, so we always expect exactly 1 response
-            num_responses = 1
+            # Determine number of responses to collect:
+            # - unique_reply_rank=None + exec_all_ranks=True: all DP ranks reply
+            #   (N responses, one per DP worker).
+            # - Otherwise: 1 response (only rank 0 or specified rank)
+            if unique_reply_rank is None and exec_all_ranks:
+                dp_size = getattr(self.od_config.parallel_config, "data_parallel_size", 1)
+                num_responses = max(1, dp_size)
+            else:
+                num_responses = 1
 
-            responses = []
-            for _ in range(num_responses):
-                response = self._dequeue_one_with_failure_polling(deadline, method)
+            responses: list = []
+            if unique_reply_rank is None and exec_all_ranks and num_responses > 1:
+                # DP multi-concurrency: collect num_responses replies, sort by dp_rank.
+                tagged: list[tuple[int, Any]] = []
+                collected_errors: list[str] = []
+                for _ in range(num_responses):
+                    response = self._dequeue_one_with_failure_polling(deadline, method)
+                    response = self._validate_wave_id(response, wave_id, deadline, method)
+                    try:
+                        unpack_diffusion_output_shm(response)
+                    except Exception as e:
+                        logger.warning("SHM unpack failed (data may already be inline): %s", e)
+                    if isinstance(response, dict) and response.get("status") == "error":
+                        collected_errors.append(str(response.get("error", "unknown")))
+                    else:
+                        response = MultiprocDiffusionExecutor._handle_rpc_response(response)
+                        if isinstance(response, dict) and "dp_rank" in response:
+                            tagged.append((response["dp_rank"], response["output"]))
+                        else:
+                            tagged.append((len(tagged), response))
+                if collected_errors:
+                    raise RuntimeError(f"Worker error: {collected_errors[0]}")
+                tagged.sort(key=lambda x: x[0])
+                responses = [r for _, r in tagged]
+            else:
+                for _ in range(num_responses):
+                    response = self._dequeue_one_with_failure_polling(deadline, method)
+                    response = self._validate_wave_id(response, wave_id, deadline, method)
 
-                try:
-                    unpack_diffusion_output_shm(response)
-                except Exception as e:
-                    logger.warning("SHM unpack failed (data may already be inline): %s", e)
+                    try:
+                        unpack_diffusion_output_shm(response)
+                    except Exception as e:
+                        logger.warning("SHM unpack failed (data may already be inline): %s", e)
 
-                response = MultiprocDiffusionExecutor._handle_rpc_response(response)
+                    response = MultiprocDiffusionExecutor._handle_rpc_response(response)
 
-                responses.append(response)
+                    responses.append(response)
 
             return responses[0] if unique_reply_rank is not None else responses
         except Exception as e:
             logger.error(f"RPC call failed: {e}")
             raise
 
+    # ------------------------------------------------------------------
+    # Async output: result pump
+    # ------------------------------------------------------------------
+
+    def _start_result_pump(self) -> None:
+        self._pump_running = True
+        self._pump_stop.clear()
+        self._result_pump_thread = threading.Thread(target=self._result_pump, daemon=True, name="DiffusionResultPump")
+        self._result_pump_thread.start()
+        logger.info("Async result pump started")
+
+    def _result_pump(self) -> None:
+        """Sole reader of result_mq when async output is enabled.
+
+        Dispatches AsyncDiffusionOutput messages to the appropriate future:
+        * RPC_RESULT / COMPUTE_DONE → _rpc_futures[rpc_id]
+        * OUTPUT_READY → _output_futures[async_output_id]
+        """
+        while not self._pump_stop.is_set():
+            try:
+                msg = self._result_mq.dequeue(timeout=1.0)
+            except TimeoutError:
+                if self._is_failed:
+                    break
+                continue
+            except Exception:
+                logger.exception("Result pump dequeue failed")
+                if self._is_failed:
+                    break
+                continue
+
+            if not isinstance(msg, AsyncDiffusionOutput):
+                # Non-async message: place into the sync buffer for
+                # collective_rpc() to consume via Path 2.
+                self._sync_result_buffer.put(msg)
+                continue
+
+            if msg.kind in (AsyncOutputKind.RPC_RESULT, AsyncOutputKind.COMPUTE_DONE):
+                with self._futures_lock:
+                    fut = self._rpc_futures.pop(msg.rpc_id, None) if msg.rpc_id else None
+                if fut is not None and not fut.done():
+                    if msg.error:
+                        fut.set_exception(RuntimeError(msg.error))
+                    else:
+                        fut.set_result(msg)
+            elif msg.kind == AsyncOutputKind.OUTPUT_READY:
+                batch_id = msg.async_output_id
+                with self._futures_lock:
+                    per_req_map = self._batch_split_map.pop(batch_id, None) if batch_id else None
+                if per_req_map is not None:
+                    # Batch result: split into per-request DiffusionOutputs.
+                    try:
+                        unpack_diffusion_output_shm(msg.output)
+                    except Exception:
+                        logger.exception("SHM unpack failed for batch %s", batch_id)
+                    batch_output = msg.output
+                    for per_req_id, req_id in per_req_map.items():
+                        req_output = batch_output.get_request_output(req_id)
+                        per_req_result: DiffusionOutput
+                        if req_output is not None and req_output.result is not None:
+                            per_req_result = req_output.result
+                        elif msg.error:
+                            per_req_result = DiffusionOutput(error=msg.error)
+                        else:
+                            per_req_result = DiffusionOutput(error="No output result for batch request")
+                        fut: concurrent.futures.Future = concurrent.futures.Future()
+                        fut.set_result(per_req_result)
+                        with self._futures_lock:
+                            pending = self._output_futures.pop(per_req_id, None)
+                            if pending is not None and not pending.done():
+                                pending.set_result(per_req_result)
+                            else:
+                                self._completed_outputs[per_req_id] = fut
+                else:
+                    with self._futures_lock:
+                        fut = self._output_futures.pop(batch_id, None) if batch_id else None
+                    if fut is not None and not fut.done():
+                        if msg.error:
+                            fut.set_exception(RuntimeError(msg.error))
+                        else:
+                            try:
+                                unpack_diffusion_output_shm(msg.output)
+                            except Exception as e:
+                                logger.exception("SHM unpack failed in result pump")
+                                fut.set_exception(e)
+                                continue
+                            fut.set_result(msg.output)
+                    elif batch_id:
+                        fut = concurrent.futures.Future()
+                        if msg.error:
+                            fut.set_exception(RuntimeError(msg.error))
+                        else:
+                            try:
+                                unpack_diffusion_output_shm(msg.output)
+                            except Exception as e:
+                                logger.exception("SHM unpack failed in result pump (cached)")
+                                fut.set_exception(e)
+                            else:
+                                fut.set_result(msg.output)
+                        with self._futures_lock:
+                            self._completed_outputs[batch_id] = fut
+
+    def _next_rpc_id(self) -> str:
+        with self._rpc_id_lock:
+            self._rpc_id_counter += 1
+            return str(self._rpc_id_counter)
+
+    def wait_output_ready(self, async_output_id: str) -> concurrent.futures.Future[DiffusionOutput]:
+        """Return a Future that resolves when the async output is ready."""
+        with self._futures_lock:
+            cached = self._completed_outputs.pop(async_output_id, None)
+            if cached is not None:
+                return cached
+            fut: concurrent.futures.Future = concurrent.futures.Future()
+            self._output_futures[async_output_id] = fut
+        return fut
+
     def check_health(self) -> None:
-        if self.is_failed:
+        if self._is_failed:
             raise EngineDeadError()
         self._ensure_open()
         for p in self._processes:
             if not p.is_alive():
-                self.is_failed = True
+                self._is_failed = True
                 raise EngineDeadError(f"Worker process {p.name} is dead")
 
     def shutdown(self) -> None:
         self._closed = True
+        self._pump_stop.set()
         try:
             self._finalizer()
         finally:
             self._broadcast_mq = None
             self._result_mq = None
-            self.resources = None
+            with self._futures_lock:
+                for fut in self._rpc_futures.values():
+                    if not fut.done():
+                        fut.set_exception(RuntimeError("Executor shut down"))
+                for fut in self._output_futures.values():
+                    if not fut.done():
+                        fut.set_exception(RuntimeError("Executor shut down"))
+                self._rpc_futures.clear()
+                self._output_futures.clear()
+                self._batch_split_map.clear()
+            self._shutdown_cleaner = None
             self._processes = []
diff --git a/vllm_omni/diffusion/forward_context.py b/vllm_omni/diffusion/forward_context.py
index ea230ed9b..bb589d7bb 100644
--- a/vllm_omni/diffusion/forward_context.py
+++ b/vllm_omni/diffusion/forward_context.py
@@ -28,6 +28,7 @@ class ForwardContext:
     attn_metadata: dict[str, AttentionMetadata] | list[dict[str, AttentionMetadata]] | None = None
     split_text_embed_in_sp: bool = False
     denoise_step_idx: int | None = None
+    denoise_timestep: float | None = None
     # Per-request reference latent for img2img DiT models (e.g. Ming)
     ref_latent: torch.Tensor | None = None
     # whether to split the text embed in sequence parallel, if True, the text embed will be split in sequence parallel
@@ -214,6 +215,27 @@ def set_forward_context_denoise_step_idx(step_idx: int | None) -> None:
         _forward_context.denoise_step_idx = step_idx
 
 
+class DenoiseProgressMixin:
+    def record_denoise_step(
+        self,
+        step_idx: int | None,
+        timestep=None,
+        scheduler=None,
+        normalized_timestep: float | None = None,
+    ) -> None:
+        set_forward_context_denoise_step_idx(step_idx)
+        if _forward_context is None:
+            return
+        if normalized_timestep is not None:
+            _forward_context.denoise_timestep = float(normalized_timestep)
+            return
+        if timestep is None:
+            return
+        scheduler = scheduler if scheduler is not None else getattr(self, "scheduler", None)
+        ntt = getattr(getattr(scheduler, "config", None), "num_train_timesteps", None)
+        _forward_context.denoise_timestep = float(timestep) / ntt if ntt else None
+
+
 def set_forward_context_ref_latent(ref_latent: torch.Tensor | None) -> None:
     """Set the per-request reference latent on the active ForwardContext.
 
diff --git a/vllm_omni/diffusion/hooks/__init__.py b/vllm_omni/diffusion/hooks/__init__.py
index 68f918383..ea1a28a6c 100644
--- a/vllm_omni/diffusion/hooks/__init__.py
+++ b/vllm_omni/diffusion/hooks/__init__.py
@@ -3,7 +3,6 @@
 """Hook mechanism for model forward interception."""
 
 from vllm_omni.diffusion.hooks.base import (
-    BaseState,
     HookRegistry,
     ModelHook,
     StateManager,
@@ -12,14 +11,11 @@ from vllm_omni.diffusion.hooks.sequence_parallel import (
     SequenceParallelGatherHook,
     SequenceParallelSplitHook,
     apply_sequence_parallel,
-    disable_sequence_parallel_for_model,
-    enable_sequence_parallel_for_model,
     remove_sequence_parallel,
 )
 
 __all__ = [
     # Base hooks
-    "BaseState",
     "StateManager",
     "ModelHook",
     "HookRegistry",
@@ -28,6 +24,4 @@ __all__ = [
     "SequenceParallelGatherHook",
     "apply_sequence_parallel",
     "remove_sequence_parallel",
-    "enable_sequence_parallel_for_model",
-    "disable_sequence_parallel_for_model",
 ]
diff --git a/vllm_omni/diffusion/hooks/base.py b/vllm_omni/diffusion/hooks/base.py
index 6863a4594..8857737ca 100644
--- a/vllm_omni/diffusion/hooks/base.py
+++ b/vllm_omni/diffusion/hooks/base.py
@@ -20,21 +20,18 @@ from vllm.logger import init_logger
 logger = init_logger(__name__)
 
 
-class BaseState:
-    """Base class for hook state containers."""
-
-    def reset(self) -> None:  # pragma: no cover - default is no-op
-        pass
-
-
 class StateManager:
-    """Manage per-context hook state instances."""
+    """Manage per-context hook state instances.
 
-    def __init__(self, state_cls: Callable[[], BaseState], init_args: tuple = (), init_kwargs: dict | None = None):
+    State classes (e.g. TeaCacheState, MagCacheState) are plain classes;
+    they only need to be constructible with the given init args.
+    """
+
+    def __init__(self, state_cls: Callable[..., Any], init_args: tuple = (), init_kwargs: dict | None = None):
         self._state_cls = state_cls
         self._init_args = init_args
         self._init_kwargs = init_kwargs or {}
-        self._states: dict[str, BaseState] = {}
+        self._states: dict[str, Any] = {}
         self._context: str = "default"
 
     @property
@@ -45,7 +42,7 @@ class StateManager:
     def set_context(self, name: str) -> None:
         self._context = name or "default"
 
-    def get_state(self) -> BaseState:
+    def get_state(self) -> Any:
         if self._context not in self._states:
             self._states[self._context] = self._state_cls(*self._init_args, **self._init_kwargs)
         return self._states[self._context]
@@ -332,17 +329,3 @@ class HookRegistry:
         hook = self._hooks.get(name)
         if hook is not None:
             hook.reset_state(self.module)
-
-    def reset(self) -> None:
-        """Reset all hooks and clear the registry.
-
-        This removes all hooks from the registry and resets each hook's state.
-        Also restores module.forward to its original implementation.
-        """
-        for name, hook in list(self._hooks.items()):
-            hook.reset_state(self.module)
-        self._hooks.clear()
-
-        if hasattr(self.module, "_omni_original_forward"):
-            self.module.forward = self.module._omni_original_forward  # type: ignore[attr-defined]
-            delattr(self.module, "_omni_original_forward")
diff --git a/vllm_omni/diffusion/hooks/sequence_parallel.py b/vllm_omni/diffusion/hooks/sequence_parallel.py
index 0c6cda334..e8f88c8a9 100644
--- a/vllm_omni/diffusion/hooks/sequence_parallel.py
+++ b/vllm_omni/diffusion/hooks/sequence_parallel.py
@@ -679,87 +679,3 @@ def remove_sequence_parallel(
                 continue
 
             registry.remove_hook(hook_name)
-
-
-def enable_sequence_parallel_for_model(
-    model: nn.Module,
-    config: SequenceParallelConfig | None = None,
-) -> None:
-    """Enable sequence parallelism for a model using its _sp_plan.
-
-    This is a convenience function that reads the model's _sp_plan attribute
-    and applies sequence parallelism automatically.
-
-    Note: This corresponds to `enable_context_parallel_for_model` in diffusers,
-    but uses vLLM-Omni's _sp_plan instead of diffusers' _cp_plan.
-
-    The function performs two main tasks:
-    1. Applies _sp_plan hooks to shard inputs and gather outputs
-    2. Ensures Attention layers are configured for the correct parallel mode
-       (handled automatically by vLLM-Omni's forward_context mechanism)
-
-    Args:
-        model: The model to enable SP for. Must have a _sp_plan attribute.
-        config: Optional config. If None, uses default based on current
-            parallel state.
-
-    Raises:
-        ValueError: If model has no _sp_plan defined.
-
-    Note:
-        vLLM-Omni supports Ulysses + Ring hybrid parallelism:
-        - ulysses_degree > 1: Uses All-to-All communication over Q/K/V heads
-        - ring_degree > 1: Uses Ring attention with K/V passing
-        - Both > 1: Hybrid mode (Ulysses handles head redistribution,
-          Ring handles K/V circulation)
-    """
-    from vllm_omni.diffusion.distributed.parallel_state import (
-        get_ring_parallel_world_size,
-        get_ulysses_parallel_world_size,
-    )
-    from vllm_omni.diffusion.distributed.sp_plan import get_sp_plan_from_model
-
-    plan = get_sp_plan_from_model(model)
-    if plan is None:
-        raise ValueError(
-            f"Model {model.__class__.__name__} has no _sp_plan defined. "
-            f"Define _sp_plan as a class attribute or pass a plan explicitly."
-        )
-
-    if config is None:
-        # Create config from current parallel state
-        ulysses_degree = get_ulysses_parallel_world_size()
-        ring_degree = get_ring_parallel_world_size()
-        config = SequenceParallelConfig(
-            ulysses_degree=ulysses_degree,
-            ring_degree=ring_degree,
-        )
-        if ulysses_degree > 1 and ring_degree > 1:
-            mode = "hybrid"
-        elif ulysses_degree > 1:
-            mode = "ulysses"
-        else:
-            mode = "ring"
-        logger.info(
-            f"Created SP config from parallel state: "
-            f"ulysses_degree={ulysses_degree}, ring_degree={ring_degree}, "
-            f"mode={mode}"
-        )
-
-    apply_sequence_parallel(model, config, plan)
-    logger.info(f"Enabled sequence parallelism for {model.__class__.__name__}")
-
-
-def disable_sequence_parallel_for_model(model: nn.Module) -> None:
-    """Disable sequence parallelism for a model.
-
-    Note: This corresponds to `disable_context_parallel_for_model` in diffusers.
-
-    Args:
-        model: The model to disable SP for.
-    """
-    from vllm_omni.diffusion.distributed.sp_plan import get_sp_plan_from_model
-
-    plan = get_sp_plan_from_model(model)
-    if plan is not None:
-        remove_sequence_parallel(model, plan)
diff --git a/vllm_omni/diffusion/inline_stage_diffusion_client.py b/vllm_omni/diffusion/inline_stage_diffusion_client.py
index 8b3d90f00..3c4edda26 100644
--- a/vllm_omni/diffusion/inline_stage_diffusion_client.py
+++ b/vllm_omni/diffusion/inline_stage_diffusion_client.py
@@ -21,7 +21,7 @@ from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.engine.stage_client import StageClientBase
 from vllm_omni.engine.stage_init_utils import StageMetadata
 from vllm_omni.errors import client_error_metadata
-from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniInteractionPrompt
 from vllm_omni.outputs import OmniRequestOutput
 
 if TYPE_CHECKING:
@@ -139,8 +139,13 @@ class InlineStageDiffusionClient(StageClientBase):
                         result.request_id = request_id
                     self._output_queue.put_nowait(result)
             else:
-                results = await self._engine.step(request)
-                result = results[0]
+                # Non-streaming callers share the streaming engine path but
+                # only publish the final output.
+                result = None
+                async for results in self._engine.step_streaming(request):
+                    result = results[0]
+                if result is None:
+                    raise RuntimeError("Diffusion execution finished without output.")
                 if not result.request_id:
                     result.request_id = request_id
                 self._output_queue.put_nowait(result)
@@ -174,6 +179,25 @@ class InlineStageDiffusionClient(StageClientBase):
                 task.cancel()
             self._engine.abort(rid)
 
+    async def submit_interaction_async(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+        timeout: float | None = None,
+    ) -> Any:
+        """Apply a midway interaction to an active streaming request."""
+        logger.debug(
+            "[InlineStageDiffusionClient] stage-%s [rep-%s] interaction: %s",
+            self.stage_id,
+            self.replica_id,
+            request_id,
+        )
+        return await self.collective_rpc_async(
+            "submit_interaction",
+            timeout=timeout,
+            args=(request_id, interaction),
+        )
+
     async def collective_rpc_async(
         self,
         method: str,
diff --git a/vllm_omni/diffusion/ipc.py b/vllm_omni/diffusion/ipc.py
index cd83e718c..5b7465af0 100644
--- a/vllm_omni/diffusion/ipc.py
+++ b/vllm_omni/diffusion/ipc.py
@@ -21,23 +21,43 @@ _SHM_TENSOR_THRESHOLD = 1_000_000  # 1 MB
 DIFFUSION_RPC_RESULT_ENVELOPE = "diffusion_rpc_result"
 
 
-def _tensor_to_shm(tensor: torch.Tensor) -> dict[str, Any]:
+def _tensor_to_shm(
+    tensor: torch.Tensor,
+    d2h_stream: torch.Stream | None = None,
+) -> dict[str, Any]:
     """Copy a tensor into POSIX shared memory and return a metadata handle.
 
     The shared memory segment remains alive after this call (the local fd is
     closed, but the segment persists until ``_tensor_from_shm`` unlinks it).
+
+    If *d2h_stream* is provided, the D2H copy uses ``copy_()`` with
+    ``pin_memory=True`` on that stream instead of the synchronous ``.cpu()``
+    path.  The caller must synchronize *d2h_stream* after all tensors are
+    packed.
     """
     from multiprocessing import shared_memory
 
     import numpy as np
 
-    tensor = tensor.detach().cpu().contiguous()
     original_dtype = tensor.dtype
-    # NumPy does not support bfloat16; promote to float32 for the SHM
-    # transfer and record the original dtype so _tensor_from_shm can
-    # convert back.  The round-trip is lossless for bfloat16 values.
-    if original_dtype == torch.bfloat16:
-        tensor = tensor.to(torch.float32)
+    if d2h_stream is not None:
+        # Non-blocking D2H: copy on side stream to pinned CPU memory.
+        old_stream = torch.accelerator.current_stream()
+        torch.accelerator.set_stream(d2h_stream)
+        try:
+            t = tensor.detach()
+            if original_dtype == torch.bfloat16:
+                t = t.to(torch.float32)
+            cpu = torch.empty(t.shape, dtype=t.dtype, pin_memory=True)
+            cpu.copy_(t, non_blocking=True)
+        finally:
+            torch.accelerator.set_stream(old_stream)
+        d2h_stream.synchronize()
+        tensor = cpu
+    else:
+        tensor = tensor.detach().cpu().contiguous()
+        if original_dtype == torch.bfloat16:
+            tensor = tensor.to(torch.float32)
     arr = tensor.numpy()
     nbytes = arr.nbytes
     shm = shared_memory.SharedMemory(create=True, size=nbytes)
@@ -79,14 +99,20 @@ def _tensor_from_shm(handle: dict[str, Any]) -> torch.Tensor:
     return tensor
 
 
-def _pack_tensor_if_large(val: torch.Tensor) -> torch.Tensor | dict:
+def _pack_tensor_if_large(
+    val: torch.Tensor,
+    d2h_stream: torch.Stream | None = None,
+) -> torch.Tensor | dict:
     """Replace a tensor with an SHM handle if it exceeds the threshold."""
     if val.nelement() * val.element_size() > _SHM_TENSOR_THRESHOLD:
-        return _tensor_to_shm(val)
+        return _tensor_to_shm(val, d2h_stream=d2h_stream)
     return val
 
 
-def _pack_value_if_large(val: object) -> object:
+def _pack_value_if_large(
+    val: object,
+    d2h_stream: torch.Stream | None = None,
+) -> object:
     """Recursively replace large tensors with SHM handles.
 
     Walks the container shapes pipelines return as ``DiffusionOutput.output``:
@@ -96,13 +122,13 @@ def _pack_value_if_large(val: object) -> object:
     the two in sync.
     """
     if isinstance(val, torch.Tensor):
-        return _pack_tensor_if_large(val)
+        return _pack_tensor_if_large(val, d2h_stream=d2h_stream)
     if isinstance(val, dict):
-        return {key: _pack_value_if_large(value) for key, value in val.items()}
+        return {key: _pack_value_if_large(value, d2h_stream=d2h_stream) for key, value in val.items()}
     if isinstance(val, list):
-        return [_pack_value_if_large(item) for item in val]
+        return [_pack_value_if_large(item, d2h_stream=d2h_stream) for item in val]
     if isinstance(val, tuple):
-        return tuple(_pack_value_if_large(item) for item in val)
+        return tuple(_pack_value_if_large(item, d2h_stream=d2h_stream) for item in val)
     return val
 
 
@@ -119,15 +145,18 @@ def _unpack_if_shm_handle(val: object) -> object:
     return val
 
 
-def _pack_diffusion_fields(output: DiffusionOutput) -> DiffusionOutput:
+def _pack_diffusion_fields(
+    output: DiffusionOutput,
+    d2h_stream: torch.Stream | None = None,
+) -> DiffusionOutput:
     if output.output is not None:
-        output.output = _pack_value_if_large(output.output)
+        output.output = _pack_value_if_large(output.output, d2h_stream=d2h_stream)
     if output.trajectory_latents is not None and isinstance(output.trajectory_latents, torch.Tensor):
-        output.trajectory_latents = _pack_tensor_if_large(output.trajectory_latents)
+        output.trajectory_latents = _pack_tensor_if_large(output.trajectory_latents, d2h_stream=d2h_stream)
     if output.trajectory_timesteps is not None and isinstance(output.trajectory_timesteps, torch.Tensor):
-        output.trajectory_timesteps = _pack_tensor_if_large(output.trajectory_timesteps)
+        output.trajectory_timesteps = _pack_tensor_if_large(output.trajectory_timesteps, d2h_stream=d2h_stream)
     if output.trajectory_log_probs is not None and isinstance(output.trajectory_log_probs, torch.Tensor):
-        output.trajectory_log_probs = _pack_tensor_if_large(output.trajectory_log_probs)
+        output.trajectory_log_probs = _pack_tensor_if_large(output.trajectory_log_probs, d2h_stream=d2h_stream)
     return output
 
 
@@ -135,31 +164,45 @@ def _is_rpc_result_envelope(output: object) -> bool:
     return isinstance(output, dict) and output.get("type") == DIFFUSION_RPC_RESULT_ENVELOPE
 
 
-def pack_diffusion_output_shm(output: object) -> object:
+def pack_diffusion_output_shm(
+    output: object,
+    d2h_stream: torch.Stream | None = None,
+) -> object:
     """Replace large tensors in diffusion worker outputs with SHM handles.
 
     Supports a bare ``DiffusionOutput``, a wrapper object carrying one in
     ``.result`` (for example ``RunnerOutput``), an RPC result envelope carrying
-    the diffusion output in ``["result"]``, or a batch wrapper carrying
-    ``RunnerOutput`` objects in ``.runner_outputs``.
+    the diffusion output in ``["result"]``, a batch wrapper carrying
+    ``RunnerOutput`` objects in ``.runner_outputs``, or a DP-tagged dict
+    ``{"dp_rank": int, "output": DiffusionOutput}`` used by DP multi-concurrency.
+
+    If *d2h_stream* is provided, D2H copies use that stream (non-blocking on
+    the default stream).  The caller must synchronize *d2h_stream* afterward.
     """
     if isinstance(output, DiffusionOutput):
-        return _pack_diffusion_fields(output)
+        return _pack_diffusion_fields(output, d2h_stream=d2h_stream)
+
+    # DP multi-concurrency: {"dp_rank": int, "output": DiffusionOutput}
+    if isinstance(output, dict) and "dp_rank" in output and "output" in output:
+        inner = output["output"]
+        if isinstance(inner, DiffusionOutput):
+            output["output"] = _pack_diffusion_fields(inner)
+        return output
 
     if _is_rpc_result_envelope(output):
         result = output.get("result")
         if isinstance(result, DiffusionOutput):
-            output["result"] = _pack_diffusion_fields(result)
+            output["result"] = _pack_diffusion_fields(result, d2h_stream=d2h_stream)
         return output
 
     result = getattr(output, "result", None)
     if isinstance(result, DiffusionOutput):
-        output.result = _pack_diffusion_fields(result)
+        output.result = _pack_diffusion_fields(result, d2h_stream=d2h_stream)
 
     runner_outputs = getattr(output, "runner_outputs", None)
     if isinstance(runner_outputs, list):
         for runner_output in runner_outputs:
-            pack_diffusion_output_shm(runner_output)
+            pack_diffusion_output_shm(runner_output, d2h_stream=d2h_stream)
     return output
 
 
@@ -176,6 +219,13 @@ def unpack_diffusion_output_shm(output: object) -> object:
     if isinstance(output, DiffusionOutput):
         return _unpack_diffusion_fields(output)
 
+    # DP multi-concurrency: {"dp_rank": int, "output": DiffusionOutput}
+    if isinstance(output, dict) and "dp_rank" in output and "output" in output:
+        inner = output["output"]
+        if isinstance(inner, DiffusionOutput):
+            output["output"] = _unpack_diffusion_fields(inner)
+        return output
+
     if _is_rpc_result_envelope(output):
         result = output.get("result")
         if isinstance(result, DiffusionOutput):
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_fused_moe.py b/vllm_omni/diffusion/layers/fused_moe.py
similarity index 66%
rename from vllm_omni/diffusion/models/hunyuan_image3/hunyuan_fused_moe.py
rename to vllm_omni/diffusion/layers/fused_moe.py
index fc1317a48..c5ee02487 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_fused_moe.py
+++ b/vllm_omni/diffusion/layers/fused_moe.py
@@ -6,7 +6,6 @@ from typing import Any
 import torch
 import vllm.distributed.parallel_state as _vllm_ps
 import vllm.forward_context as _vllm_fc
-from vllm.utils.import_utils import resolve_obj_by_qualname
 
 from vllm_omni.platforms import current_omni_platform
 
@@ -50,18 +49,18 @@ def _set_forward_context_dp_metadata(num_tokens: int) -> None:
     forward_context.dp_metadata = _vllm_fc.DPMetadata(torch.tensor(gathered_num_tokens, dtype=torch.int64))
 
 
-class HunyuanFusedMoEDefault:
-    """Adapter that configures the upstream FusedMoE ``MoERunner`` for HunyuanImage3.
+class FusedMoE:
+    """Adapter that configures the upstream FusedMoE ``MoERunner`` for diffusion models.
 
     Upstream commit dc68bd8c41 refactored FusedMoE from a class (``nn.Module``)
     into a factory function that returns a ``MoERunner`` instance, whose expert
     weights live in a ``routed_experts`` submodule
     (``...experts.routed_experts.w13_weight`` / ``...w2_weight``).
 
-    This adapter builds that runner, installs the omni-specific forward-context
-    setup and one-shot kernel-initialisation hook, and returns the runner
-    *directly* from ``__new__`` so the parent MoE block registers it as a real
-    ``nn.Module`` submodule.
+    This adapter builds that runner, installs the diffusion forward-context
+    setup and additional platform hooks, and returns the runner *directly* from
+    ``__new__`` so the parent MoE block registers it as a real ``nn.Module``
+    submodule.
 
     Returning the runner (rather than wrapping it in a plain object that holds it
     in an attribute) is required for correctness: a non-Module wrapper hides the
@@ -71,9 +70,11 @@ class HunyuanFusedMoEDefault:
     """
 
     def __new__(cls, *, prefix: str = "", **kwargs: Any) -> Any:
+        current_omni_platform.prepare_diffusion_op_runtime("fused_moe")
+
         # Current vLLM FusedMoE handles output reduction internally.
         kwargs.pop("reduce_results", None)
-        # FusedMoE is now a factory function — call it to get a MoERunner.
+        # FusedMoE is now a factory function; call it to get a MoERunner.
         from vllm.model_executor.layers.fused_moe import FusedMoE as _FusedMoE
 
         moe_runner = _FusedMoE(prefix=prefix, **kwargs)
@@ -91,21 +92,7 @@ class HunyuanFusedMoEDefault:
                 _set_forward_context_dp_metadata(hidden_states.shape[0])
 
         moe_runner.register_forward_pre_hook(_num_tokens_pre_hook, with_kwargs=True)
-
-        # One-shot lazy kernel initialisation on the first forward (no-op unless
-        # the runner exposes an uninitialised quant_method). Mirrors the prior
-        # wrapper behaviour exactly, just bound to the runner module.
-        init_handle: Any = None
-
-        def _kernel_init_pre_hook(module: Any, args: Any, kwargs: Any) -> None:
-            nonlocal init_handle
-            quant_method = getattr(module, "quant_method", None)
-            if quant_method is not None and getattr(quant_method, "moe_kernel", None) is None:
-                quant_method.process_weights_after_loading(module)
-            if init_handle is not None:
-                init_handle.remove()
-
-        init_handle = moe_runner.register_forward_pre_hook(_kernel_init_pre_hook, with_kwargs=True)
+        current_omni_platform.register_additional_diffusion_fused_moe_hooks(moe_runner)
 
         return moe_runner
 
@@ -138,35 +125,3 @@ class HunyuanFusedMoEDefault:
             num_experts=num_experts,
             num_redundant_experts=num_redundant_experts,
         )
-
-
-class HunyuanFusedMoE:
-    def __new__(cls, *, prefix: str = "", **kwargs: Any) -> Any:
-        op_name = "hunyuan_fused_moe"
-        current_omni_platform.prepare_diffusion_op_runtime(op_name)
-        impl = resolve_obj_by_qualname(
-            current_omni_platform.get_diffusion_model_impl_qualname(op_name),
-        )
-        return impl(prefix=prefix, **kwargs)
-
-    @classmethod
-    def make_expert_params_mapping(
-        cls,
-        model: Any,
-        ckpt_gate_proj_name: str,
-        ckpt_down_proj_name: str,
-        ckpt_up_proj_name: str,
-        num_experts: int,
-        num_redundant_experts: int = 0,
-    ) -> list[tuple[str, str, int, str]]:
-        impl = resolve_obj_by_qualname(
-            current_omni_platform.get_diffusion_model_impl_qualname("hunyuan_fused_moe"),
-        )
-        return impl.make_expert_params_mapping(
-            model,
-            ckpt_gate_proj_name=ckpt_gate_proj_name,
-            ckpt_down_proj_name=ckpt_down_proj_name,
-            ckpt_up_proj_name=ckpt_up_proj_name,
-            num_experts=num_experts,
-            num_redundant_experts=num_redundant_experts,
-        )
diff --git a/vllm_omni/diffusion/layers/norm.py b/vllm_omni/diffusion/layers/norm.py
index 51c627975..14ab677a0 100644
--- a/vllm_omni/diffusion/layers/norm.py
+++ b/vllm_omni/diffusion/layers/norm.py
@@ -65,9 +65,9 @@ class LayerNorm(nn.LayerNorm, CustomOp):
 
 
 class RMSNorm(CustomOp):
-    def __init__(self, hidden_size: int, eps: float = 1e-6) -> None:
+    def __init__(self, hidden_size: int, eps: float = 1e-6, dtype: torch.dtype = torch.float32) -> None:
         super().__init__()
-        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.weight = nn.Parameter(torch.ones(hidden_size, dtype=dtype))
         self.variance_epsilon = eps
 
     def _forward_fused(self, x: torch.Tensor) -> torch.Tensor:
diff --git a/vllm_omni/diffusion/layers/rope.py b/vllm_omni/diffusion/layers/rope.py
index 6a045fca2..5d934866b 100644
--- a/vllm_omni/diffusion/layers/rope.py
+++ b/vllm_omni/diffusion/layers/rope.py
@@ -89,10 +89,11 @@ class RotaryEmbedding(CustomOp):
            of 1st half and 2nd half (GPT-NeoX style).
     """
 
-    def __init__(self, is_neox_style: bool = False) -> None:
+    def __init__(self, is_neox_style: bool = False, half_head_dim: bool = True) -> None:
         super().__init__()
         self.is_neox_style = is_neox_style
         self.interleaved = not is_neox_style
+        self.half_head_dim = half_head_dim
         self.apply_rotary_emb_flash_attn = None
         self.has_mindie = False
         # ``find_spec("flash_attn")`` is True as long as *any* package publishes
@@ -110,6 +111,21 @@ class RotaryEmbedding(CustomOp):
         if find_spec("mindiesd") is not None:
             self.has_mindie = True
 
+    def _prepare_half_head_dim_cos_sin(
+        self,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Normalize shared cos/sin to the half-dim layout used by CUDA/native kernels."""
+        if cos.dim() == 3:
+            # All batch elements share the same rotary position encoding.
+            cos = cos[0]
+            sin = sin[0]
+        if not self.half_head_dim:
+            cos = cos[..., ::2] if self.interleaved else cos[..., : cos.shape[-1] // 2]
+            sin = sin[..., ::2] if self.interleaved else sin[..., : sin.shape[-1] // 2]
+        return cos, sin
+
     def forward_cuda(
         self,
         x: torch.Tensor,
@@ -118,10 +134,7 @@ class RotaryEmbedding(CustomOp):
     ) -> torch.Tensor:
         from vllm.vllm_flash_attn.layers.rotary import apply_rotary_emb
 
-        if cos.dim() == 3:
-            # (B, S, D/2) -> (S, D/2)
-            cos = cos[0]
-            sin = sin[0]
+        cos, sin = self._prepare_half_head_dim_cos_sin(cos, sin)
 
         x, squeezed = _ensure_batch_dim(x)
         output = apply_rotary_emb(
@@ -141,10 +154,7 @@ class RotaryEmbedding(CustomOp):
         if self.apply_rotary_emb_flash_attn is None:
             return self.forward_cuda(x, cos, sin)
 
-        if cos.dim() == 3:
-            # (B, S, D/2) -> (S, D/2)
-            cos = cos[0]
-            sin = sin[0]
+        cos, sin = self._prepare_half_head_dim_cos_sin(cos, sin)
 
         x, squeezed = _ensure_batch_dim(x)
         output = self.apply_rotary_emb_flash_attn(
@@ -162,7 +172,7 @@ class RotaryEmbedding(CustomOp):
         sin: torch.Tensor,
     ) -> torch.Tensor:
         if self.has_mindie:
-            return apply_rotary_emb_mindiesd(x, cos, sin, self.interleaved)
+            return apply_rotary_emb_mindiesd(x, cos, sin, self.interleaved, self.half_head_dim)
         else:
             return self.forward_native(x, cos, sin)
 
@@ -191,9 +201,7 @@ class RotaryEmbedding(CustomOp):
         # All batch elements share the same rotary position encoding.
         # Strip the batch dim so the underlying op broadcasts over the batch,
         # consistent with forward_cuda / forward_hip / apply_rotary_emb_mindiesd.
-        if cos.dim() == 3:
-            cos = cos[0]
-            sin = sin[0]
+        cos, sin = self._prepare_half_head_dim_cos_sin(cos, sin)
         return apply_rotary_emb_torch(
             x,
             cos,
diff --git a/vllm_omni/diffusion/lora/manager.py b/vllm_omni/diffusion/lora/manager.py
index 2fcf43b6e..9098fec2a 100644
--- a/vllm_omni/diffusion/lora/manager.py
+++ b/vllm_omni/diffusion/lora/manager.py
@@ -366,8 +366,8 @@ class DiffusionLoRAManager:
             fully_sharded_loras=False,
         )
 
-        # Default denoising components plus any a pipeline opts into via
-        # ``_lora_components`` (opt-in; other pipelines unchanged).
+        # Default denoising components, declared DiT components, and any a
+        # pipeline opts into via ``_lora_components``.
         #
         # NOTE: SDXL-style pipelines expose the denoiser as ``unet``.
         # Without scanning this component, adapters can load/activate while
@@ -379,8 +379,10 @@ class DiffusionLoRAManager:
             "bagel",
             "unet",
         )
+        declared_components = tuple(getattr(self.pipeline, "_dit_modules", ()) or ())
         extra_components = tuple(getattr(self.pipeline, "_lora_components", ()) or ())
-        for component_name in (*default_components, *extra_components):
+        component_names = dict.fromkeys((*default_components, *declared_components, *extra_components))
+        for component_name in component_names:
             if not hasattr(self.pipeline, component_name):
                 continue
             component = getattr(self.pipeline, component_name)
diff --git a/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py b/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
index d6f7b3e0c..68ec98d5a 100644
--- a/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
+++ b/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
@@ -11,7 +11,12 @@ from vllm.model_executor.utils import get_packed_modules_mapping
 
 logger = init_logger(__name__)
 
-MODEL_OPT_SCALE_SUFFIXES = (".input_scale", ".weight_scale", ".weight_scale_2", ".weight_scale_inv")
+MODEL_OPT_SCALE_SUFFIXES = (
+    ".input_scale",
+    ".weight_scale",
+    ".weight_scale_2",
+    ".weight_scale_inv",
+)
 DEFAULT_PACKED_MODULES_MAPPING = {
     "to_qkv": ("to_q", "to_k", "to_v"),
     "add_kv_proj": ("add_q_proj", "add_k_proj", "add_v_proj"),
@@ -122,6 +127,7 @@ class ModelOptFp8CheckpointAdapter:
 
         for candidate in self._weights_mapper.apply_list([name]):
             if candidate != name and candidate in self._loadable_tensors:
+                # Preserve shard names so downstream packed-weight loaders can route them.
                 return candidate, name
         return None, name
 
@@ -178,6 +184,7 @@ class ModelOptFp8CheckpointAdapter:
     def _handle_scale_tensor(
         self,
         name: str,
+        output_name: str,
         tensor: torch.Tensor,
         target_name: str | None,
         state: _AdaptState,
@@ -186,7 +193,7 @@ class ModelOptFp8CheckpointAdapter:
         if target_name is None:
             state.skipped_scales += 1
         else:
-            yield name, tensor
+            yield output_name, tensor
         yield from self._flush_pending_weights(name, state)
 
     def _target_dtype_for_dequantization(
@@ -249,7 +256,7 @@ class ModelOptFp8CheckpointAdapter:
         for name, tensor in weights:
             target_name, output_name = self._resolve_target_and_output_names(name)
             if self._is_scale(name):
-                yield from self._handle_scale_tensor(name, tensor, target_name, state)
+                yield from self._handle_scale_tensor(name, output_name, tensor, target_name, state)
                 continue
 
             target_dtype = self._target_dtype_for_dequantization(tensor, target_name)
@@ -264,6 +271,8 @@ class ModelOptFp8CheckpointAdapter:
 
 
 class ModelOptNvFp4CheckpointAdapter(ModelOptFp8CheckpointAdapter):
+    _PRE_QUANT_SCALE_SUFFIX = ".pre_quant_scale"
+
     @staticmethod
     def _is_checkpoint_quant_config(quant_config: object | None) -> bool:
         return (
@@ -273,6 +282,22 @@ class ModelOptNvFp4CheckpointAdapter(ModelOptFp8CheckpointAdapter):
             and bool(getattr(quant_config, "is_checkpoint_nvfp4_serialized", False))
         )
 
+    def adapt(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]],
+    ) -> Generator[tuple[str, torch.Tensor], None, None]:
+        def validated_weights() -> Generator[tuple[str, torch.Tensor], None, None]:
+            for name, tensor in weights:
+                if name.endswith(self._PRE_QUANT_SCALE_SUFFIX):
+                    raise ValueError(
+                        f"ModelOpt NVFP4 checkpoint tensor {name!r} is unsupported: "
+                        "vLLM 0.25.0 does not consume pre_quant_scale. Export the checkpoint "
+                        "with pre-quant scales folded into the weights."
+                    )
+                yield name, tensor
+
+        yield from super().adapt(validated_weights())
+
 
 class ModelOptMixedPrecisionCheckpointAdapter(ModelOptFp8CheckpointAdapter):
     @staticmethod
diff --git a/vllm_omni/diffusion/model_loader/diffusers_loader.py b/vllm_omni/diffusion/model_loader/diffusers_loader.py
index 8ee172e6b..d1a1ed15e 100644
--- a/vllm_omni/diffusion/model_loader/diffusers_loader.py
+++ b/vllm_omni/diffusion/model_loader/diffusers_loader.py
@@ -12,7 +12,6 @@ from typing import cast
 
 import torch
 from torch import nn
-from vllm.config import ModelConfig
 from vllm.config.load import LoadConfig
 from vllm.logger import init_logger
 from vllm.model_executor.layers.quantization.base_config import QuantizeMethodBase
@@ -81,7 +80,6 @@ def _natural_sort_key(filepath: str) -> list:
     return [int(s) if s.isdigit() else s for s in re.split(r"(\d+)", os.path.basename(filepath))]
 
 
-MODEL_INDEX = "model_index.json"
 DIFFUSION_MODEL_WEIGHTS_INDEX = "diffusion_pytorch_model.safetensors.index.json"
 TRANSFORMER_WEIGHTS_INDEX = "model.safetensors.index.json"
 INDEX_FILES = [DIFFUSION_MODEL_WEIGHTS_INDEX, TRANSFORMER_WEIGHTS_INDEX]
@@ -326,15 +324,6 @@ class DiffusersPipelineLoader:
             return all_parameter_names
         return {name for name in all_parameter_names if name.startswith(source_prefixes)}
 
-    def download_model(self, model_config: ModelConfig) -> None:
-        self._prepare_weights(
-            model_name_or_path=model_config.model,
-            subfolder=None,
-            revision=model_config.revision,
-            fall_back_to_pt=True,
-            allow_patterns_overrides=None,
-        )
-
     def load_model(
         self,
         load_device: str,
@@ -373,24 +362,80 @@ class DiffusersPipelineLoader:
                 )
             else:
                 model = self._init_from_load_format(load_format, target_device, custom_pipeline_name, is_hsdp=False)
-                logger.debug("Loading weights on %s ...", load_device)
-                if load_format == "diffusers":
-                    # DiffusersAdapterPipeline.load_weights() calls
-                    # DiffusionPipeline.from_pretrained() internally; it does
-                    # not use our native customized pipeline classes.
-                    cast(DiffusersAdapterPipeline, model).load_weights()
+
+                # Skip load_weights only for DLO+AllGather when the model
+                # supports mmap loading and no online quantization is active.
+                # This condition MUST match the gate in
+                # DistributedLayerwiseOffloadBackend.enable() so that the
+                # loader skips ⟺ enable() uses mmap.
+                from vllm_omni.diffusion.offloader.offload_plan import supports_mmap_loading
+
+                _dist_offload = getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+                _use_ag = getattr(self.od_config, "dlo_use_allgather", True)
+                _has_online_quant = self._has_online_quant(model)
+                _supports_mmap = supports_mmap_loading(model)
+
+                _skip_load = _dist_offload and _use_ag and _supports_mmap and not _has_online_quant
+
+                if _skip_load:
+                    logger.info("DLO+AllGather active: skipping load_weights (will load via mmap in enable())")
                 else:
-                    self.load_weights(model)
-                # HSDP processes quantized weights before wrapping parameters as
-                # DTensors. The non-HSDP path can process them here as usual.
-                self._process_weights_after_loading(model, target_device)
+                    if _dist_offload and _use_ag and _has_online_quant:
+                        raise ValueError(
+                            "Online quantization is incompatible with DLO+AllGather: "
+                            "the sharding + AllGather mechanism flattens weights by "
+                            "dtype, which breaks quantized weight/scale layouts. "
+                            "Please use --dlo-no-use-allgather or disable online "
+                            "quantization."
+                        )
+                    if _dist_offload and _use_ag and not _supports_mmap:
+                        logger.info(
+                            "DLO+AllGather active but model does not support mmap: loading weights via regular loader."
+                        )
+                    logger.debug("Loading weights on %s ...", load_device)
+                    if offload_after_quant:
+                        marked = self._request_offload_after_quant(model)
+                        if marked:
+                            logger.info(
+                                "Online quantization will return each of %d layers to CPU as it is quantized",
+                                marked,
+                            )
+                    if load_format == "diffusers":
+                        cast(DiffusersAdapterPipeline, model).load_weights()
+                    else:
+                        self.load_weights(model)
+                    self._process_weights_after_loading(model, target_device)
 
             if offload_after_quant:
                 model.to("cpu")
                 logger.info("Quantization complete, offloaded model back to CPU")
 
+        self._apply_skip_softmax_calibration(model)
         return model.eval()
 
+    @staticmethod
+    def _request_offload_after_quant(model: nn.Module) -> int:
+        """Ask online-quant layers to return to host memory once quantized.
+
+        The weights only visit the accelerator so the quant kernels can run on
+        them; ``load_model`` sends the model back to the host afterwards either
+        way. Without this the whole transformer accumulates on device until that
+        final move, which for MiniMax H3 is a ~43 GiB peak that no longer fits
+        beside a resident TP-sharded text encoder — even though layer-wise
+        offload means none of it is supposed to be resident at inference time.
+
+        Only quant methods that advertise ``supports_offload_after_quant`` are
+        asked, since the implementation has to know when a layer is finished.
+        Deferring materialization to the ``meta`` device does not imply that.
+        """
+        marked = 0
+        for module in model.modules():
+            quant_method = getattr(module, "quant_method", None)
+            if getattr(quant_method, "supports_offload_after_quant", False):
+                quant_method.enable_offload_after_quant()
+                marked += 1
+        return marked
+
     @staticmethod
     def _has_online_quant(model: nn.Module) -> bool:
         """Whether any layer uses an online-quant method that defers weight
@@ -402,6 +447,14 @@ class DiffusersPipelineLoader:
                 return True
         return False
 
+    def _apply_skip_softmax_calibration(self, model: nn.Module) -> None:
+        from vllm_omni.diffusion.attention.backends.trtllm_calibration import (
+            apply_skip_softmax_calibration,
+        )
+
+        cfg = getattr(self.od_config, "diffusion_attention_config", None)
+        apply_skip_softmax_calibration(cfg, model)
+
     def _process_weights_after_loading(self, model: nn.Module, target_device: torch.device) -> None:
         """Process weights after loading for quantization methods.
 
@@ -437,6 +490,13 @@ class DiffusersPipelineLoader:
             if quant_method is None or not isinstance(quant_method, QuantizeMethodBase):
                 continue
 
+            # Layers finished during loading would only be staged onto the target
+            # device for a process call that immediately returns. That round trip
+            # is wasted work in general, and undoes the point of the offload for
+            # layers that already went back to the host.
+            if getattr(module, "_already_called_process_weights_after_loading", False):
+                continue
+
             if has_online_quant:
                 # Online quant may leave straggler params on the ``meta`` device.
                 # Move only real (non-meta) params onto the target device for
@@ -636,7 +696,7 @@ class DiffusersPipelineLoader:
         # Discover pipeline components (DiT, encoders, VAEs) via
         # ModuleDiscovery, which consults SupportsComponentDiscovery
         # when available and falls back to well-known attribute names.
-        # This supports nested pipelines (e.g. LTX2TwoStagesPipeline
+        # This supports nested pipelines (e.g. LTX2DistilledPipeline
         # where the transformer lives at "pipe.transformer").
         discovered_modules = ModuleDiscovery.discover(model)
 
diff --git a/vllm_omni/diffusion/model_loader/hub_prefetch.py b/vllm_omni/diffusion/model_loader/hub_prefetch.py
index a33dca74d..9a9295ab9 100644
--- a/vllm_omni/diffusion/model_loader/hub_prefetch.py
+++ b/vllm_omni/diffusion/model_loader/hub_prefetch.py
@@ -433,10 +433,7 @@ def from_pretrained_with_prefetch(
     ``factory`` is a bound ``SomeModel.from_pretrained`` (or any callable with
     the same ``(model, *, subfolder, local_files_only, **kwargs)`` signature).
 
-    This is a stronger sibling of :func:`retry_on_missing_shard`: that helper
-    only retries the missing-shard ``OSError`` and never re-prefetches, so it
-    cannot recover the second face of the same race. Two shapes of partial
-    -cache failure crash the diffusion server outright:
+    Two shapes of partial-cache failure crash the diffusion server outright:
 
     * ``OSError: <repo> does not appear to have a file named
       text_encoder/model-0000X-of-0000Y.safetensors`` - a shard is still under
@@ -488,31 +485,3 @@ def from_pretrained_with_prefetch(
 
     assert last_exc is not None  # loop only exits via return or a caught exc
     raise last_exc
-
-
-def retry_on_missing_shard(load_fn, *, max_retries: int = 3, base_delay: float = 5.0):
-    """Call *load_fn* with retry on the transformers v5 shard-resolution race.
-
-    When the prefetch lock cannot be acquired (e.g. flock unsupported on
-    the filesystem and dotfile lock times out), ``from_pretrained`` may
-    still hit the ``cached_files`` race. This wrapper retries with
-    exponential backoff when the OSError message matches the specific
-    "does not appear to have a file named" pattern.
-    """
-    for attempt in range(max_retries):
-        try:
-            return load_fn()
-        except OSError as exc:
-            if "does not appear to have a file" not in str(exc):
-                raise
-            if attempt == max_retries - 1:
-                raise
-            delay = base_delay * (attempt + 1)
-            logger.warning(
-                "from_pretrained failed with shard-resolution race (%s); retrying in %.1fs (attempt %d/%d)",
-                exc,
-                delay,
-                attempt + 1,
-                max_retries,
-            )
-            time.sleep(delay)
diff --git a/vllm_omni/diffusion/model_metadata.py b/vllm_omni/diffusion/model_metadata.py
index f33463384..6184478b8 100644
--- a/vllm_omni/diffusion/model_metadata.py
+++ b/vllm_omni/diffusion/model_metadata.py
@@ -10,11 +10,15 @@ class DiffusionModelMetadata:
     # config/model plumbing can read it without importing concrete pipelines.
     supports_multimodal_inputs: bool = False
     max_multimodal_image_inputs: int | None = None
+    supports_mixed_reference_inputs: bool = False
+    attention_mask_free: bool = False
 
 
 QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES = 4
 # Upstream HunyuanImage-3.0 "Multi-Image Fusion" caps reference images at 3.
 HUNYUAN_IMAGE3_MAX_INPUT_IMAGES = 3
+# Boogu-Image editing (TI2I) supports a single reference image for now.
+BOOGU_IMAGE_MAX_INPUT_IMAGES = 1
 
 
 _DIFFUSION_MODEL_METADATA: dict[str, DiffusionModelMetadata] = {
@@ -26,6 +30,32 @@ _DIFFUSION_MODEL_METADATA: dict[str, DiffusionModelMetadata] = {
         supports_multimodal_inputs=True,
         max_multimodal_image_inputs=HUNYUAN_IMAGE3_MAX_INPUT_IMAGES,
     ),
+    # Shared by the Base (text-to-image) and Edit (TI2I) checkpoints, which use
+    # the same ``BooguImagePipeline`` class. Text-to-image requests simply carry
+    # no reference image.
+    "BooguImagePipeline": DiffusionModelMetadata(
+        supports_multimodal_inputs=True,
+        max_multimodal_image_inputs=BOOGU_IMAGE_MAX_INPUT_IMAGES,
+    ),
+    "MiniMaxH3Pipeline": DiffusionModelMetadata(
+        supports_multimodal_inputs=True,
+        max_multimodal_image_inputs=9,
+        supports_mixed_reference_inputs=True,
+        # H3 represents alignment padding as a second packed sequence.  The
+        # packed TRTLLM backend consumes cu_seqlens and isolates that padding.
+        attention_mask_free=True,
+    ),
+    # The modular alias is served by MiniMaxH3Pipeline and has the same
+    # Ref2VA request contract. Keep admission limits in sync with it.
+    "MiniMaxH3ModularPipeline": DiffusionModelMetadata(
+        supports_multimodal_inputs=True,
+        max_multimodal_image_inputs=9,
+        supports_mixed_reference_inputs=True,
+    ),
+    "WanPipeline": DiffusionModelMetadata(attention_mask_free=True),
+    "WanImageToVideoPipeline": DiffusionModelMetadata(attention_mask_free=True),
+    "WanVACEPipeline": DiffusionModelMetadata(attention_mask_free=True),
+    "WanS2VPipeline": DiffusionModelMetadata(attention_mask_free=True),
 }
 
 
diff --git a/vllm_omni/diffusion/models/bagel/bagel_transformer.py b/vllm_omni/diffusion/models/bagel/bagel_transformer.py
index 30f4a041b..de21ddccf 100644
--- a/vllm_omni/diffusion/models/bagel/bagel_transformer.py
+++ b/vllm_omni/diffusion/models/bagel/bagel_transformer.py
@@ -37,7 +37,7 @@ from vllm.transformers_utils.configs.bagel import BagelConfig
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata as DiffusionAttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention as DiffusionAttention
-from vllm_omni.diffusion.cache.cache_dit_backend import BagelCachedAdapter, CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import BagelCachedAdapter, CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.parallel_state import (
@@ -2426,7 +2426,7 @@ class Bagel(CFGParallelMixin, nn.Module):
 
             batched_sequence = packed_sequence.repeat(num_branches, 1)
             batched_vae_indexes = torch.cat([packed_vae_token_indexes + i * seq_len for i in range(num_branches)])
-            batched_position_ids = torch.cat(cfg_branch_pids)
+            batched_position_ids = torch.cat(cfg_branch_pids, dim=1 if cfg_branch_pids[0].ndim == 2 else 0)
             batched_seqlens = packed_seqlens.repeat(num_branches)
             merged_cache = NaiveCache.merge(cfg_branch_caches)
 
diff --git a/vllm_omni/diffusion/models/bagel/pipeline_bagel.py b/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
index 9786e2b47..6ca306c60 100644
--- a/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
+++ b/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
@@ -610,7 +610,8 @@ class BagelPipeline(nn.Module, SupportsComponentDiscovery, DiffusionPipelineProf
             # cfg_text_context: update with negative prompt (no text condition).
             # When empty, keep cfg_text_context as-is (kv_lens=0) to match
             # original BAGEL.
-            neg_prompt = extra_args.get("negative_prompt", "")
+            prompt_negative = first_prompt.get("negative_prompt") if isinstance(first_prompt, dict) else None
+            neg_prompt = prompt_negative if prompt_negative is not None else extra_args.get("negative_prompt", "")
             if neg_prompt:
                 neg_input, neg_newlens, neg_rope = self.bagel.prepare_prompts(
                     curr_kvlens=cfg_text_context["kv_lens"],
diff --git a/vllm_omni/diffusion/models/boogu_image/__init__.py b/vllm_omni/diffusion/models/boogu_image/__init__.py
new file mode 100644
index 000000000..7ec9c167c
--- /dev/null
+++ b/vllm_omni/diffusion/models/boogu_image/__init__.py
@@ -0,0 +1,12 @@
+from .boogu_image_transformer import BooguImageTransformer2DModel
+from .image_processor import BooguImageProcessor
+from .pipeline_boogu_image import BooguImagePipeline, get_boogu_image_pre_process_func
+from .scheduling_flow_match_euler_discrete_time_shifting import FlowMatchEulerDiscreteScheduler
+
+__all__ = [
+    "BooguImagePipeline",
+    "BooguImageProcessor",
+    "BooguImageTransformer2DModel",
+    "FlowMatchEulerDiscreteScheduler",
+    "get_boogu_image_pre_process_func",
+]
diff --git a/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py b/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py
new file mode 100644
index 000000000..e7489c868
--- /dev/null
+++ b/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py
@@ -0,0 +1,1372 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+#
+# Native vLLM-Omni port of the Boogu-Image transformer.
+#
+# Ported from the upstream `boogu` package
+# (boogu/models/transformers/transformer_boogu.py and friends) with the
+# following changes:
+#   - Diffusers mixins (ModelMixin/ConfigMixin/PeftAdapterMixin) removed;
+#     configuration is read from `od_config.tf_model_config`.
+#   - diffusers Attention + custom processors replaced by the vLLM-Omni
+#     `Attention` layer (backend/SP/KV-quant handled by the framework).
+#   - Q/K/V and FFN projections use vLLM parallel linears for TP support.
+#   - Training-time features (prompt tuning, gradient checkpointing) and
+#     inference caches (TeaCache/TaylorSeer) are not ported.
+
+import itertools
+from collections.abc import Iterable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers.models.embeddings import Timesteps, get_1d_rotary_pos_embed
+from einops import rearrange, repeat
+from vllm.logger import init_logger
+from vllm.model_executor.layers.layernorm import RMSNorm
+from vllm.model_executor.layers.linear import (
+    ColumnParallelLinear,
+    ReplicatedLinear,
+    RowParallelLinear,
+)
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.layer import Attention
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+logger = init_logger(__name__)
+
+
+def apply_rotary_emb(x: torch.Tensor, freqs_cis: torch.Tensor) -> torch.Tensor:
+    """Apply rotary embeddings in complex form (upstream `use_real=False` path).
+
+    Args:
+        x: Query or key tensor of shape [B, S, H, D].
+        freqs_cis: Complex frequency tensor of shape [B, S, D // 2].
+    """
+    x_rotated = torch.view_as_complex(x.float().reshape(*x.shape[:-1], x.shape[-1] // 2, 2))
+    freqs_cis = freqs_cis.unsqueeze(2)
+    x_out = torch.view_as_real(x_rotated * freqs_cis).flatten(3)
+    return x_out.type_as(x)
+
+
+def swiglu(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    return F.silu(x.float(), inplace=False).to(x.dtype) * y
+
+
+class TimestepEmbedding(nn.Module):
+    def __init__(self, in_channels: int, time_embed_dim: int) -> None:
+        super().__init__()
+        self.linear_1 = nn.Linear(in_channels, time_embed_dim, bias=True)
+        self.act = nn.SiLU()
+        self.linear_2 = nn.Linear(time_embed_dim, time_embed_dim, bias=True)
+
+    def forward(self, sample: torch.Tensor) -> torch.Tensor:
+        return self.linear_2(self.act(self.linear_1(sample)))
+
+
+class LuminaRMSNormZero(nn.Module):
+    """AdaRMS modulation: projects `temb` into scale/gate terms."""
+
+    def __init__(self, embedding_dim: int, norm_eps: float) -> None:
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(min(embedding_dim, 1024), 4 * embedding_dim, bias=True)
+        self.norm = RMSNorm(embedding_dim, eps=norm_eps)
+
+    def forward(
+        self, x: torch.Tensor, emb: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        emb = self.linear(self.silu(emb))
+        scale_msa, gate_msa, scale_mlp, gate_mlp = emb.chunk(4, dim=1)
+        x = self.norm(x) * (1 + scale_msa[:, None])
+        return x, gate_msa, scale_mlp, gate_mlp
+
+
+class LuminaLayerNormContinuous(nn.Module):
+    """Final AdaLN + optional output projection (upstream `norm_out`)."""
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        conditioning_embedding_dim: int,
+        elementwise_affine: bool = True,
+        eps: float = 1e-5,
+        bias: bool = True,
+        out_dim: int | None = None,
+    ) -> None:
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear_1 = nn.Linear(conditioning_embedding_dim, embedding_dim, bias=bias)
+        self.norm = nn.LayerNorm(embedding_dim, eps, elementwise_affine, bias)
+        self.linear_2 = nn.Linear(embedding_dim, out_dim, bias=bias) if out_dim is not None else None
+
+    def forward(self, x: torch.Tensor, conditioning_embedding: torch.Tensor) -> torch.Tensor:
+        scale = self.linear_1(self.silu(conditioning_embedding).to(x.dtype))
+        x = self.norm(x) * (1 + scale)[:, None, :]
+        if self.linear_2 is not None:
+            x = self.linear_2(x)
+        return x
+
+
+class LuminaFeedForward(nn.Module):
+    """SwiGLU feed-forward with tensor-parallel projections."""
+
+    def __init__(
+        self,
+        dim: int,
+        inner_dim: int,
+        multiple_of: int = 256,
+        ffn_dim_multiplier: float | None = None,
+    ) -> None:
+        super().__init__()
+        if ffn_dim_multiplier is not None:
+            inner_dim = int(ffn_dim_multiplier * inner_dim)
+        inner_dim = multiple_of * ((inner_dim + multiple_of - 1) // multiple_of)
+
+        self.linear_1 = ColumnParallelLinear(dim, inner_dim, bias=False)  # gate
+        self.linear_3 = ColumnParallelLinear(dim, inner_dim, bias=False)  # input
+        self.linear_2 = RowParallelLinear(inner_dim, dim, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        h1, _ = self.linear_1(x)
+        h2, _ = self.linear_3(x)
+        out, _ = self.linear_2(swiglu(h1, h2))
+        return out
+
+
+class Lumina2CombinedTimestepCaptionEmbedding(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int = 4096,
+        instruction_feat_dim: int = 2048,
+        frequency_embedding_size: int = 256,
+        norm_eps: float = 1e-5,
+        timestep_scale: float = 1.0,
+    ) -> None:
+        super().__init__()
+        self.time_proj = Timesteps(
+            num_channels=frequency_embedding_size,
+            flip_sin_to_cos=True,
+            downscale_freq_shift=0.0,
+            scale=timestep_scale,
+        )
+        self.timestep_embedder = TimestepEmbedding(
+            in_channels=frequency_embedding_size, time_embed_dim=min(hidden_size, 1024)
+        )
+        self.caption_embedder = nn.Sequential(
+            RMSNorm(instruction_feat_dim, eps=norm_eps),
+            nn.Linear(instruction_feat_dim, hidden_size, bias=True),
+        )
+
+    def forward(
+        self,
+        timestep: torch.Tensor,
+        instruction_hidden_states: torch.Tensor,
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        timestep_proj = self.time_proj(timestep).to(dtype=dtype)
+        time_embed = self.timestep_embedder(timestep_proj)
+        caption_embed = self.caption_embedder(instruction_hidden_states)
+        return time_embed, caption_embed
+
+
+class BooguImageDoubleStreamRotaryPosEmbed(nn.Module):
+    """3-axis RoPE producing per-segment frequency tensors.
+
+    Returns separate frequency tensors for instruction tokens, reference-image
+    tokens, noise-image tokens, the full joint sequence, and the combined
+    (ref + noise) image sequence used by the double-stream blocks.
+    """
+
+    def __init__(
+        self,
+        theta: int,
+        axes_dim: tuple[int, int, int],
+        axes_lens: tuple[int, int, int] = (300, 512, 512),
+        patch_size: int = 2,
+    ) -> None:
+        super().__init__()
+        self.theta = theta
+        self.axes_dim = axes_dim
+        self.axes_lens = axes_lens
+        self.patch_size = patch_size
+
+    @staticmethod
+    def get_freqs_cis(
+        axes_dim: tuple[int, int, int], axes_lens: tuple[int, int, int], theta: int
+    ) -> list[torch.Tensor]:
+        freqs_cis = []
+        freqs_dtype = torch.float32 if torch.backends.mps.is_available() else torch.float64
+        for d, e in zip(axes_dim, axes_lens):
+            emb = get_1d_rotary_pos_embed(d, e, theta=theta, freqs_dtype=freqs_dtype)
+            freqs_cis.append(emb)
+        return freqs_cis
+
+    def _get_freqs_cis(self, freqs_cis: list[torch.Tensor], ids: torch.Tensor) -> torch.Tensor:
+        device = ids.device
+        if ids.device.type == "mps":
+            ids = ids.to("cpu")
+
+        result = []
+        for i in range(len(self.axes_dim)):
+            freqs = freqs_cis[i].to(ids.device)
+            index = ids[:, :, i : i + 1].repeat(1, 1, freqs.shape[-1]).to(torch.int64)
+            result.append(torch.gather(freqs.unsqueeze(0).repeat(index.shape[0], 1, 1), dim=1, index=index))
+        return torch.cat(result, dim=-1).to(device)
+
+    def forward(
+        self,
+        freqs_cis: list[torch.Tensor],
+        attention_mask: torch.Tensor,
+        l_effective_ref_img_len: list[list[int]],
+        l_effective_img_len: list[int],
+        ref_img_sizes: list[list[tuple[int, int]] | None],
+        img_sizes: list[tuple[int, int]],
+        device: torch.device,
+    ):
+        batch_size = len(attention_mask)
+        p = self.patch_size
+
+        encoder_seq_len = attention_mask.shape[1]
+        l_effective_cap_len = attention_mask.sum(dim=1).tolist()
+
+        seq_lengths = [
+            cap_len + sum(ref_img_len) + img_len
+            for cap_len, ref_img_len, img_len in zip(l_effective_cap_len, l_effective_ref_img_len, l_effective_img_len)
+        ]
+
+        max_seq_len = max(seq_lengths)
+        max_ref_img_len = max(sum(ref_img_len) for ref_img_len in l_effective_ref_img_len)
+        max_img_len = max(l_effective_img_len)
+
+        position_ids = torch.zeros(batch_size, max_seq_len, 3, dtype=torch.int32, device=device)
+
+        for i, (cap_seq_len, seq_len) in enumerate(zip(l_effective_cap_len, seq_lengths)):
+            position_ids[i, :cap_seq_len] = repeat(
+                torch.arange(cap_seq_len, dtype=torch.int32, device=device), "l -> l 3"
+            )
+
+            pe_shift = cap_seq_len
+            pe_shift_len = cap_seq_len
+
+            if ref_img_sizes[i] is not None:
+                for ref_img_size, ref_img_len in zip(ref_img_sizes[i], l_effective_ref_img_len[i]):
+                    H, W = ref_img_size
+                    ref_H_tokens, ref_W_tokens = H // p, W // p
+                    assert ref_H_tokens * ref_W_tokens == ref_img_len
+
+                    row_ids = repeat(
+                        torch.arange(ref_H_tokens, dtype=torch.int32, device=device),
+                        "h -> h w",
+                        w=ref_W_tokens,
+                    ).flatten()
+                    col_ids = repeat(
+                        torch.arange(ref_W_tokens, dtype=torch.int32, device=device),
+                        "w -> h w",
+                        h=ref_H_tokens,
+                    ).flatten()
+                    position_ids[i, pe_shift_len : pe_shift_len + ref_img_len, 0] = pe_shift
+                    position_ids[i, pe_shift_len : pe_shift_len + ref_img_len, 1] = row_ids
+                    position_ids[i, pe_shift_len : pe_shift_len + ref_img_len, 2] = col_ids
+
+                    pe_shift += max(ref_H_tokens, ref_W_tokens)
+                    pe_shift_len += ref_img_len
+
+            H, W = img_sizes[i]
+            H_tokens, W_tokens = H // p, W // p
+            assert H_tokens * W_tokens == l_effective_img_len[i]
+
+            row_ids = repeat(torch.arange(H_tokens, dtype=torch.int32, device=device), "h -> h w", w=W_tokens).flatten()
+            col_ids = repeat(torch.arange(W_tokens, dtype=torch.int32, device=device), "w -> h w", h=H_tokens).flatten()
+
+            assert pe_shift_len + l_effective_img_len[i] == seq_len
+            position_ids[i, pe_shift_len:seq_len, 0] = pe_shift
+            position_ids[i, pe_shift_len:seq_len, 1] = row_ids
+            position_ids[i, pe_shift_len:seq_len, 2] = col_ids
+
+        freqs_cis = self._get_freqs_cis(freqs_cis, position_ids)
+
+        cap_freqs_cis = torch.zeros(
+            batch_size, encoder_seq_len, freqs_cis.shape[-1], device=device, dtype=freqs_cis.dtype
+        )
+        ref_img_freqs_cis = torch.zeros(
+            batch_size, max_ref_img_len, freqs_cis.shape[-1], device=device, dtype=freqs_cis.dtype
+        )
+        img_freqs_cis = torch.zeros(batch_size, max_img_len, freqs_cis.shape[-1], device=device, dtype=freqs_cis.dtype)
+
+        combined_img_seq_lengths = [
+            sum(ref_img_len) + img_len for ref_img_len, img_len in zip(l_effective_ref_img_len, l_effective_img_len)
+        ]
+        max_combined_img_len = max(combined_img_seq_lengths)
+
+        combined_img_freqs_cis = torch.zeros(
+            batch_size, max_combined_img_len, freqs_cis.shape[-1], device=device, dtype=freqs_cis.dtype
+        )
+
+        for i, (cap_seq_len, ref_img_len, img_len, seq_len) in enumerate(
+            zip(l_effective_cap_len, l_effective_ref_img_len, l_effective_img_len, seq_lengths)
+        ):
+            cap_freqs_cis[i, :cap_seq_len] = freqs_cis[i, :cap_seq_len]
+            ref_img_freqs_cis[i, : sum(ref_img_len)] = freqs_cis[i, cap_seq_len : cap_seq_len + sum(ref_img_len)]
+            img_freqs_cis[i, :img_len] = freqs_cis[
+                i, cap_seq_len + sum(ref_img_len) : cap_seq_len + sum(ref_img_len) + img_len
+            ]
+
+            combined_img_freqs_cis[i, : sum(ref_img_len)] = freqs_cis[i, cap_seq_len : cap_seq_len + sum(ref_img_len)]
+            combined_img_freqs_cis[i, sum(ref_img_len) : sum(ref_img_len) + img_len] = freqs_cis[
+                i, cap_seq_len + sum(ref_img_len) : cap_seq_len + sum(ref_img_len) + img_len
+            ]
+
+        return (
+            cap_freqs_cis,
+            ref_img_freqs_cis,
+            img_freqs_cis,
+            freqs_cis,
+            l_effective_cap_len,
+            seq_lengths,
+            combined_img_freqs_cis,
+            combined_img_seq_lengths,
+        )
+
+
+def _concat_instruction_image_features(
+    img_tensors: list[torch.Tensor],
+    instruct_tensors: list[torch.Tensor],
+    encoder_seq_lengths: list[int],
+    seq_lengths: list[int],
+) -> list[torch.Tensor]:
+    """Pack per-stream tensors into joint sequences (instruction first, then image)."""
+    assert len(img_tensors) == len(instruct_tensors)
+
+    batch_size = img_tensors[0].shape[0]
+    max_seq_len = max(seq_lengths)
+
+    concatenated_list = []
+    for img_tensor, instruct_tensor in zip(img_tensors, instruct_tensors):
+        feature_dim = img_tensor.shape[-1]
+        concatenated = img_tensor.new_zeros(batch_size, max_seq_len, feature_dim)
+        for i, (encoder_seq_len, seq_len) in enumerate(zip(encoder_seq_lengths, seq_lengths)):
+            concatenated[i, :encoder_seq_len] = instruct_tensor[i, :encoder_seq_len]
+            concatenated[i, encoder_seq_len:seq_len] = img_tensor[i, : seq_len - encoder_seq_len]
+        concatenated_list.append(concatenated)
+
+    return concatenated_list
+
+
+def _split_instruction_image_features(
+    hidden_states: torch.Tensor,
+    encoder_seq_lengths: list[int],
+    seq_lengths: list[int],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Unpack a joint sequence back into (instruction, image) streams."""
+    batch_size = hidden_states.shape[0]
+    feature_dim = hidden_states.shape[-1]
+
+    max_instruct_len = max(encoder_seq_lengths)
+    max_img_len = max(seq_len - encoder_seq_len for seq_len, encoder_seq_len in zip(seq_lengths, encoder_seq_lengths))
+
+    instruct_hidden_states = hidden_states.new_zeros(batch_size, max_instruct_len, feature_dim)
+    img_hidden_states = hidden_states.new_zeros(batch_size, max_img_len, feature_dim)
+
+    for i, (encoder_seq_len, seq_len) in enumerate(zip(encoder_seq_lengths, seq_lengths)):
+        img_len = seq_len - encoder_seq_len
+        instruct_hidden_states[i, :encoder_seq_len] = hidden_states[i, :encoder_seq_len]
+        img_hidden_states[i, :img_len] = hidden_states[i, encoder_seq_len:seq_len]
+
+    return instruct_hidden_states, img_hidden_states
+
+
+class BooguImageSelfAttention(nn.Module):
+    """GQA self-attention with QK RMSNorm and complex RoPE.
+
+    Replaces the upstream diffusers `Attention` + Boogu attention processors;
+    the vLLM-Omni `Attention` layer picks the kernel backend and handles
+    SP/KV-cache concerns.
+    """
+
+    def __init__(self, dim: int, num_attention_heads: int, num_kv_heads: int) -> None:
+        super().__init__()
+        self.head_dim = dim // num_attention_heads
+        kv_dim = self.head_dim * num_kv_heads
+
+        self.to_q = ColumnParallelLinear(dim, dim, bias=False)
+        self.to_k = ColumnParallelLinear(dim, kv_dim, bias=False)
+        self.to_v = ColumnParallelLinear(dim, kv_dim, bias=False)
+        self.norm_q = RMSNorm(self.head_dim, eps=1e-5)
+        self.norm_k = RMSNorm(self.head_dim, eps=1e-5)
+        self.to_out = RowParallelLinear(dim, dim, bias=False)
+
+        self.num_local_heads = self.to_q.output_size_per_partition // self.head_dim
+        self.num_local_kv_heads = self.to_k.output_size_per_partition // self.head_dim
+
+        self.attn = Attention(
+            num_heads=self.num_local_heads,
+            head_size=self.head_dim,
+            softmax_scale=self.head_dim**-0.5,
+            causal=False,
+            num_kv_heads=self.num_local_kv_heads,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None,
+        rotary_emb: torch.Tensor | None,
+    ) -> torch.Tensor:
+        dtype = hidden_states.dtype
+
+        query, _ = self.to_q(hidden_states)
+        key, _ = self.to_k(hidden_states)
+        value, _ = self.to_v(hidden_states)
+
+        query = query.unflatten(-1, (self.num_local_heads, self.head_dim))
+        key = key.unflatten(-1, (self.num_local_kv_heads, self.head_dim))
+        value = value.unflatten(-1, (self.num_local_kv_heads, self.head_dim))
+
+        query = self.norm_q(query)
+        key = self.norm_k(key)
+
+        if rotary_emb is not None:
+            query = apply_rotary_emb(query, rotary_emb)
+            key = apply_rotary_emb(key, rotary_emb)
+        query, key = query.to(dtype), key.to(dtype)
+
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        attn_output = self.attn(query, key, value, attn_metadata)
+        attn_output = attn_output.flatten(2, 3).type_as(hidden_states)
+
+        attn_output, _ = self.to_out(attn_output)
+        return attn_output
+
+
+class BooguImageJointAttention(nn.Module):
+    """Joint instruction+image attention for the double-stream blocks.
+
+    The upstream implementation keeps the per-stream Q/K/V and output
+    projections on the attention *processor*
+    (`BooguImageDoubleStreamSelfAttnProcessor*`); here they are promoted onto
+    this module. The final joint output projection corresponds to the upstream
+    `img_instruct_attn.to_out[0]`.
+    """
+
+    def __init__(self, dim: int, num_attention_heads: int, num_kv_heads: int) -> None:
+        super().__init__()
+        self.head_dim = dim // num_attention_heads
+        kv_dim = self.head_dim * num_kv_heads
+
+        self.img_to_q = ColumnParallelLinear(dim, dim, bias=False)
+        self.img_to_k = ColumnParallelLinear(dim, kv_dim, bias=False)
+        self.img_to_v = ColumnParallelLinear(dim, kv_dim, bias=False)
+
+        self.instruct_to_q = ColumnParallelLinear(dim, dim, bias=False)
+        self.instruct_to_k = ColumnParallelLinear(dim, kv_dim, bias=False)
+        self.instruct_to_v = ColumnParallelLinear(dim, kv_dim, bias=False)
+
+        self.norm_q = RMSNorm(self.head_dim, eps=1e-5)
+        self.norm_k = RMSNorm(self.head_dim, eps=1e-5)
+
+        # Per-stream output projections (attention output is head-sharded
+        # under TP, hence row-parallel).
+        self.instruct_out = RowParallelLinear(dim, dim, bias=False)
+        self.img_out = RowParallelLinear(dim, dim, bias=False)
+        # Final joint projection applied to the merged full-dim sequence.
+        self.to_out = ReplicatedLinear(dim, dim, bias=False)
+
+        self.num_local_heads = self.img_to_q.output_size_per_partition // self.head_dim
+        self.num_local_kv_heads = self.img_to_k.output_size_per_partition // self.head_dim
+
+        self.attn = Attention(
+            num_heads=self.num_local_heads,
+            head_size=self.head_dim,
+            softmax_scale=self.head_dim**-0.5,
+            causal=False,
+            num_kv_heads=self.num_local_kv_heads,
+        )
+
+    def forward(
+        self,
+        img_hidden_states: torch.Tensor,
+        instruct_hidden_states: torch.Tensor,
+        joint_attention_mask: torch.Tensor | None,
+        rotary_emb: torch.Tensor | None,
+        encoder_seq_lengths: list[int],
+        seq_lengths: list[int],
+    ) -> torch.Tensor:
+        dtype = img_hidden_states.dtype
+        batch_size = img_hidden_states.shape[0]
+
+        img_query, _ = self.img_to_q(img_hidden_states)
+        img_key, _ = self.img_to_k(img_hidden_states)
+        img_value, _ = self.img_to_v(img_hidden_states)
+
+        instruct_query, _ = self.instruct_to_q(instruct_hidden_states)
+        instruct_key, _ = self.instruct_to_k(instruct_hidden_states)
+        instruct_value, _ = self.instruct_to_v(instruct_hidden_states)
+
+        query, key, value = _concat_instruction_image_features(
+            [img_query, img_key, img_value],
+            [instruct_query, instruct_key, instruct_value],
+            encoder_seq_lengths,
+            seq_lengths,
+        )
+
+        query = query.view(batch_size, -1, self.num_local_heads, self.head_dim)
+        key = key.view(batch_size, -1, self.num_local_kv_heads, self.head_dim)
+        value = value.view(batch_size, -1, self.num_local_kv_heads, self.head_dim)
+
+        query = self.norm_q(query)
+        key = self.norm_k(key)
+
+        if rotary_emb is not None:
+            query = apply_rotary_emb(query, rotary_emb)
+            key = apply_rotary_emb(key, rotary_emb)
+        query, key = query.to(dtype), key.to(dtype)
+
+        attn_metadata = AttentionMetadata(attn_mask=joint_attention_mask) if joint_attention_mask is not None else None
+        attn_output = self.attn(query, key, value, attn_metadata)
+        attn_output = attn_output.flatten(2, 3).to(dtype)
+
+        instruct_attn_out, img_attn_out = _split_instruction_image_features(
+            attn_output, encoder_seq_lengths, seq_lengths
+        )
+        instruct_projected, _ = self.instruct_out(instruct_attn_out)
+        img_projected, _ = self.img_out(img_attn_out)
+
+        merged = _concat_instruction_image_features(
+            [img_projected], [instruct_projected], encoder_seq_lengths, seq_lengths
+        )[0]
+        merged, _ = self.to_out(merged)
+        return merged
+
+
+class BooguImageTransformerBlock(nn.Module):
+    """Single-stream block: GQA attention + SwiGLU FFN with optional AdaRMS modulation."""
+
+    def __init__(
+        self,
+        dim: int,
+        num_attention_heads: int,
+        num_kv_heads: int,
+        multiple_of: int,
+        ffn_dim_multiplier: float | None,
+        norm_eps: float,
+        modulation: bool = True,
+    ) -> None:
+        super().__init__()
+        self.head_dim = dim // num_attention_heads
+        self.modulation = modulation
+
+        self.attn = BooguImageSelfAttention(dim, num_attention_heads, num_kv_heads)
+        self.feed_forward = LuminaFeedForward(
+            dim=dim,
+            inner_dim=4 * dim,
+            multiple_of=multiple_of,
+            ffn_dim_multiplier=ffn_dim_multiplier,
+        )
+
+        if modulation:
+            self.norm1 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+        else:
+            self.norm1 = RMSNorm(dim, eps=norm_eps)
+
+        self.ffn_norm1 = RMSNorm(dim, eps=norm_eps)
+        self.norm2 = RMSNorm(dim, eps=norm_eps)
+        self.ffn_norm2 = RMSNorm(dim, eps=norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None,
+        image_rotary_emb: torch.Tensor | None,
+        temb: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if self.modulation:
+            if temb is None:
+                raise ValueError("temb must be provided when modulation is enabled")
+            norm_hidden_states, gate_msa, scale_mlp, gate_mlp = self.norm1(hidden_states, temb)
+            attn_output = self.attn(norm_hidden_states, attention_mask, image_rotary_emb)
+            hidden_states = hidden_states + gate_msa.unsqueeze(1).tanh() * self.norm2(attn_output)
+            mlp_output = self.feed_forward(self.ffn_norm1(hidden_states) * (1 + scale_mlp.unsqueeze(1)))
+            hidden_states = hidden_states + gate_mlp.unsqueeze(1).tanh() * self.ffn_norm2(mlp_output)
+        else:
+            norm_hidden_states = self.norm1(hidden_states)
+            attn_output = self.attn(norm_hidden_states, attention_mask, image_rotary_emb)
+            hidden_states = hidden_states + self.norm2(attn_output)
+            mlp_output = self.feed_forward(self.ffn_norm1(hidden_states))
+            hidden_states = hidden_states + self.ffn_norm2(mlp_output)
+
+        return hidden_states
+
+
+class BooguImageNoiseRefinerTransformerBlock(BooguImageTransformerBlock):
+    pass
+
+
+class BooguImageRefImgRefinerTransformerBlock(BooguImageTransformerBlock):
+    pass
+
+
+class BooguImageContextRefinerTransformerBlock(BooguImageTransformerBlock):
+    pass
+
+
+class BooguImageSingleStreamTransformerBlock(BooguImageTransformerBlock):
+    pass
+
+
+class BooguImageDoubleStreamTransformerBlock(nn.Module):
+    """Double-stream block: instruction and image tokens are processed in
+    parallel streams coupled by a joint attention, plus an extra image
+    self-attention."""
+
+    def __init__(
+        self,
+        dim: int,
+        num_attention_heads: int,
+        num_kv_heads: int,
+        multiple_of: int,
+        ffn_dim_multiplier: float | None,
+        norm_eps: float,
+        modulation: bool = True,
+    ) -> None:
+        super().__init__()
+        self.head_dim = dim // num_attention_heads
+        self.num_attention_heads = num_attention_heads
+        self.modulation = modulation
+        self.hidden_size = dim
+
+        self.img_instruct_attn = BooguImageJointAttention(dim, num_attention_heads, num_kv_heads)
+        self.img_self_attn = BooguImageSelfAttention(dim, num_attention_heads, num_kv_heads)
+
+        self.img_feed_forward = LuminaFeedForward(
+            dim=dim,
+            inner_dim=4 * dim,
+            multiple_of=multiple_of,
+            ffn_dim_multiplier=ffn_dim_multiplier,
+        )
+
+        if modulation:
+            # Image modulation terms: cross-attn, MLP, self-attn.
+            self.img_norm1 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+            self.img_norm2 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+            self.img_norm3 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+        else:
+            self.img_norm1 = RMSNorm(dim, eps=norm_eps)
+            self.img_norm2 = RMSNorm(dim, eps=norm_eps)
+            self.img_norm3 = RMSNorm(dim, eps=norm_eps)
+
+        self.img_ffn_norm1 = RMSNorm(dim, eps=norm_eps)
+        self.img_attn_norm = RMSNorm(dim, eps=norm_eps)
+        self.img_self_attn_norm = RMSNorm(dim, eps=norm_eps)
+        self.img_ffn_norm2 = RMSNorm(dim, eps=norm_eps)
+
+        self.instruct_feed_forward = LuminaFeedForward(
+            dim=dim,
+            inner_dim=4 * dim,
+            multiple_of=multiple_of,
+            ffn_dim_multiplier=ffn_dim_multiplier,
+        )
+
+        if modulation:
+            # Instruction modulation terms: cross-attn, MLP.
+            self.instruct_norm1 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+            self.instruct_norm2 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps)
+        else:
+            self.instruct_norm1 = RMSNorm(dim, eps=norm_eps)
+            self.instruct_norm2 = RMSNorm(dim, eps=norm_eps)
+
+        self.instruct_ffn_norm1 = RMSNorm(dim, eps=norm_eps)
+        self.instruct_attn_norm = RMSNorm(dim, eps=norm_eps)
+        self.instruct_ffn_norm2 = RMSNorm(dim, eps=norm_eps)
+
+    def forward(
+        self,
+        img_hidden_states: torch.Tensor,  # [B, L_img, D] (ref_img + noise_img)
+        instruct_hidden_states: torch.Tensor,  # [B, L_instruct, D]
+        img_attention_mask: torch.Tensor | None,  # [B, L_img]
+        joint_attention_mask: torch.Tensor | None,  # [B, L_total]
+        image_rotary_emb: torch.Tensor | None,  # [B, L_img, head_dim // 2]
+        rotary_emb: torch.Tensor | None,  # [B, L_total, head_dim // 2]
+        temb: torch.Tensor | None = None,
+        encoder_seq_lengths: list[int] | None = None,
+        seq_lengths: list[int] | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if self.modulation and temb is None:
+            raise ValueError("temb must be provided when modulation is enabled")
+
+        batch_size = img_hidden_states.shape[0]
+        L_instruct = instruct_hidden_states.shape[1]
+        L_img = img_hidden_states.shape[1]
+
+        if self.modulation:
+            img_norm1_out, img_gate_msa, img_scale_mlp, img_gate_mlp = self.img_norm1(img_hidden_states, temb)
+            img_norm2_out, img_shift_mlp, _, _ = self.img_norm2(img_hidden_states, temb)
+            img_norm3_out, img_gate_self, _, _ = self.img_norm3(img_hidden_states, temb)
+
+            (
+                instruct_norm1_out,
+                instruct_gate_msa,
+                instruct_scale_mlp,
+                instruct_gate_mlp,
+            ) = self.instruct_norm1(instruct_hidden_states, temb)
+            instruct_norm2_out, instruct_shift_mlp, _, _ = self.instruct_norm2(instruct_hidden_states, temb)
+
+            joint_attn_out = self.img_instruct_attn(
+                img_norm1_out,
+                instruct_norm1_out,
+                joint_attention_mask,
+                rotary_emb,
+                encoder_seq_lengths,
+                seq_lengths,
+            )
+
+            # Split the joint output back into instruction/image segments.
+            instruct_attn_out = instruct_hidden_states.new_zeros(batch_size, L_instruct, self.hidden_size)
+            img_attn_out = img_hidden_states.new_zeros(batch_size, L_img, self.hidden_size)
+            for i, (encoder_seq_len, seq_len) in enumerate(zip(encoder_seq_lengths, seq_lengths)):
+                instruct_attn_out[i, :encoder_seq_len] = joint_attn_out[i, :encoder_seq_len]
+                img_attn_out[i, : seq_len - encoder_seq_len] = joint_attn_out[i, encoder_seq_len:seq_len]
+
+            img_self_attn_out = self.img_self_attn(img_norm3_out, img_attention_mask, image_rotary_emb)
+
+            img_hidden_states = img_hidden_states + img_gate_msa.unsqueeze(1).tanh() * self.img_attn_norm(img_attn_out)
+            img_hidden_states = img_hidden_states + img_gate_self.unsqueeze(1).tanh() * self.img_self_attn_norm(
+                img_self_attn_out
+            )
+
+            img_mlp_input = (1 + img_scale_mlp.unsqueeze(1)) * img_norm2_out + img_shift_mlp.unsqueeze(1)
+            img_mlp_out = self.img_feed_forward(self.img_ffn_norm1(img_mlp_input))
+            img_hidden_states = img_hidden_states + img_gate_mlp.unsqueeze(1).tanh() * self.img_ffn_norm2(img_mlp_out)
+
+            instruct_hidden_states = instruct_hidden_states + instruct_gate_msa.unsqueeze(
+                1
+            ).tanh() * self.instruct_attn_norm(instruct_attn_out)
+
+            instruct_mlp_input = (
+                1 + instruct_scale_mlp.unsqueeze(1)
+            ) * instruct_norm2_out + instruct_shift_mlp.unsqueeze(1)
+            instruct_mlp_out = self.instruct_feed_forward(self.instruct_ffn_norm1(instruct_mlp_input))
+            instruct_hidden_states = instruct_hidden_states + instruct_gate_mlp.unsqueeze(
+                1
+            ).tanh() * self.instruct_ffn_norm2(instruct_mlp_out)
+
+        else:
+            img_norm1_out = self.img_norm1(img_hidden_states)
+            img_norm3_out = self.img_norm3(img_hidden_states)
+            instruct_norm1_out = self.instruct_norm1(instruct_hidden_states)
+
+            joint_attn_out = self.img_instruct_attn(
+                img_norm1_out,
+                instruct_norm1_out,
+                joint_attention_mask,
+                rotary_emb,
+                encoder_seq_lengths,
+                seq_lengths,
+            )
+
+            instruct_attn_out = instruct_hidden_states.new_zeros(batch_size, L_instruct, self.hidden_size)
+            img_attn_out = img_hidden_states.new_zeros(batch_size, L_img, self.hidden_size)
+            for i, (encoder_seq_len, seq_len) in enumerate(zip(encoder_seq_lengths, seq_lengths)):
+                instruct_attn_out[i, :encoder_seq_len] = joint_attn_out[i, :encoder_seq_len]
+                img_attn_out[i, : seq_len - encoder_seq_len] = joint_attn_out[i, encoder_seq_len:seq_len]
+
+            img_self_attn_out = self.img_self_attn(img_norm3_out, img_attention_mask, image_rotary_emb)
+
+            img_hidden_states = img_hidden_states + self.img_attn_norm(img_attn_out)
+            img_hidden_states = img_hidden_states + self.img_self_attn_norm(img_self_attn_out)
+            img_norm2_out = self.img_norm2(img_hidden_states)
+            img_mlp_out = self.img_feed_forward(self.img_ffn_norm1(img_norm2_out))
+            img_hidden_states = img_hidden_states + self.img_ffn_norm2(img_mlp_out)
+
+            instruct_hidden_states = instruct_hidden_states + self.instruct_attn_norm(instruct_attn_out)
+            instruct_norm2_out = self.instruct_norm2(instruct_hidden_states)
+            instruct_mlp_out = self.instruct_feed_forward(self.instruct_ffn_norm1(instruct_norm2_out))
+            instruct_hidden_states = instruct_hidden_states + self.instruct_ffn_norm2(instruct_mlp_out)
+
+        return img_hidden_states, instruct_hidden_states
+
+
+def _cal_preprocessed_instruction_feat_dim(instruction_feature_configs: dict) -> int:
+    num_instruction_feature_layers = max(instruction_feature_configs.get("num_instruction_feature_layers", 1), 1)
+    instruction_feat_dim = instruction_feature_configs.get("instruction_feat_dim", 4096)
+    reduce_type = instruction_feature_configs.get("reduce_type", "concat")
+    if "cat" in reduce_type.lower():
+        return num_instruction_feature_layers * instruction_feat_dim
+    elif "mean" in reduce_type.lower():
+        return instruction_feat_dim
+    else:
+        raise ValueError(f"Invalid reduce_type: {reduce_type}")
+
+
+class BooguImageTransformer2DModel(nn.Module):
+    """Boogu-Image transformer with mixed stream topology.
+
+    Early layers use double-stream (dual-stream) processing, then switch to
+    single-stream joint processing. Context/noise/reference-image refiner
+    blocks run before the main stack.
+    """
+
+    # Noise refiner, reference image refiner, and double stream layers are
+    # kept out of regional torch.compile for numerical stability (matches the
+    # upstream `_repeated_blocks`).
+    _repeated_blocks = [
+        "BooguImageTransformerBlock",
+        "BooguImageContextRefinerTransformerBlock",
+        "BooguImageSingleStreamTransformerBlock",
+    ]
+    _layerwise_offload_blocks_attrs = ["single_stream_layers", "double_stream_layers"]
+
+    def __init__(self, od_config: OmniDiffusionConfig) -> None:
+        super().__init__()
+        self.od_config = od_config
+        cfg = od_config.tf_model_config
+
+        patch_size = cfg.get("patch_size", 2)
+        in_channels = cfg.get("in_channels", 16)
+        out_channels = cfg.get("out_channels", None)
+        hidden_size = cfg.get("hidden_size", 2304)
+        num_layers = cfg.get("num_layers", 26)
+        num_double_stream_layers = cfg.get("num_double_stream_layers", 2)
+        num_refiner_layers = cfg.get("num_refiner_layers", 2)
+        num_attention_heads = cfg.get("num_attention_heads", 24)
+        num_kv_heads = cfg.get("num_kv_heads", 8)
+        multiple_of = cfg.get("multiple_of", 256)
+        ffn_dim_multiplier = cfg.get("ffn_dim_multiplier", None)
+        norm_eps = cfg.get("norm_eps", 1e-5)
+        axes_dim_rope = tuple(cfg.get("axes_dim_rope", (40, 40, 40)))
+        axes_lens = tuple(cfg.get("axes_lens", (2048, 1664, 1664)))
+        instruction_feature_configs = cfg.get(
+            "instruction_feature_configs",
+            {"instruction_feat_dim": 1024, "reduce_type": "mean", "num_instruction_feature_layers": 1},
+        )
+        prompt_tuning_configs = cfg.get("prompt_tuning_configs", {"use_prompt_tuning": False})
+        timestep_scale = cfg.get("timestep_scale", 1.0)
+
+        if (hidden_size // num_attention_heads) != sum(axes_dim_rope):
+            raise ValueError(
+                f"hidden_size // num_attention_heads ({hidden_size // num_attention_heads}) "
+                f"must equal sum(axes_dim_rope) ({sum(axes_dim_rope)})"
+            )
+        if num_double_stream_layers > num_layers:
+            raise ValueError(
+                f"num_double_stream_layers ({num_double_stream_layers}) cannot be greater than "
+                f"num_layers ({num_layers})"
+            )
+        if prompt_tuning_configs.get("use_prompt_tuning", False):
+            raise NotImplementedError(
+                "Prompt tuning is a training-time feature and is not supported by the "
+                "native vLLM-Omni BooguImageTransformer2DModel."
+            )
+
+        self.patch_size = patch_size
+        self.in_channels = in_channels
+        self.out_channels = out_channels or in_channels
+        self.hidden_size = hidden_size
+        self.num_attention_heads = num_attention_heads
+        self.num_double_stream_layers = num_double_stream_layers
+        self.num_single_stream_layers = num_layers - num_double_stream_layers
+        self.axes_dim_rope = axes_dim_rope
+        self.axes_lens = axes_lens
+        self.instruction_feature_configs = instruction_feature_configs
+        self.preprocessed_instruction_feat_dim = _cal_preprocessed_instruction_feat_dim(instruction_feature_configs)
+
+        self.rope_embedder = BooguImageDoubleStreamRotaryPosEmbed(
+            theta=10000,
+            axes_dim=axes_dim_rope,
+            axes_lens=axes_lens,
+            patch_size=patch_size,
+        )
+
+        self.x_embedder = nn.Linear(
+            in_features=patch_size * patch_size * in_channels,
+            out_features=hidden_size,
+        )
+        self.ref_image_patch_embedder = nn.Linear(
+            in_features=patch_size * patch_size * in_channels,
+            out_features=hidden_size,
+        )
+
+        self.time_caption_embed = Lumina2CombinedTimestepCaptionEmbedding(
+            hidden_size=hidden_size,
+            instruction_feat_dim=self.preprocessed_instruction_feat_dim,
+            norm_eps=norm_eps,
+            timestep_scale=timestep_scale,
+        )
+
+        self.noise_refiner = nn.ModuleList(
+            [
+                BooguImageNoiseRefinerTransformerBlock(
+                    hidden_size,
+                    num_attention_heads,
+                    num_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    modulation=True,
+                )
+                for _ in range(num_refiner_layers)
+            ]
+        )
+
+        self.ref_image_refiner = nn.ModuleList(
+            [
+                BooguImageRefImgRefinerTransformerBlock(
+                    hidden_size,
+                    num_attention_heads,
+                    num_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    modulation=True,
+                )
+                for _ in range(num_refiner_layers)
+            ]
+        )
+
+        self.context_refiner = nn.ModuleList(
+            [
+                BooguImageContextRefinerTransformerBlock(
+                    hidden_size,
+                    num_attention_heads,
+                    num_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    modulation=False,
+                )
+                for _ in range(num_refiner_layers)
+            ]
+        )
+
+        # Mixed architecture: dual-stream first, then single-stream.
+        self.double_stream_layers = nn.ModuleList(
+            [
+                BooguImageDoubleStreamTransformerBlock(
+                    hidden_size,
+                    num_attention_heads,
+                    num_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    modulation=True,
+                )
+                for _ in range(num_double_stream_layers)
+            ]
+        )
+
+        self.single_stream_layers = nn.ModuleList(
+            [
+                BooguImageSingleStreamTransformerBlock(
+                    hidden_size,
+                    num_attention_heads,
+                    num_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    modulation=True,
+                )
+                for _ in range(self.num_single_stream_layers)
+            ]
+        )
+
+        self.norm_out = LuminaLayerNormContinuous(
+            embedding_dim=hidden_size,
+            conditioning_embedding_dim=min(hidden_size, 1024),
+            elementwise_affine=False,
+            eps=1e-6,
+            bias=True,
+            out_dim=patch_size * patch_size * self.out_channels,
+        )
+
+        # Distinguish multiple reference images (max 5).
+        self.image_index_embedding = nn.Parameter(torch.randn(5, hidden_size))
+
+    def preprocess_instruction_hidden_states(self, raw_instruction_hidden_states):
+        """Reduce the raw MLLM hidden states to the transformer feature dim.
+
+        Mirrors upstream ``preprocess_instruction_hidden_states``: a single
+        tensor passes through unchanged; a list of per-layer states is combined
+        by ``concat`` or ``mean`` according to ``instruction_feature_configs``.
+        """
+        cfg = self.instruction_feature_configs
+        num_instruction_feature_layers = max(cfg.get("num_instruction_feature_layers", 1), 1)
+        reduce_type = cfg.get("reduce_type", "concat")
+
+        if isinstance(raw_instruction_hidden_states, torch.Tensor):
+            instruction_hidden_states = raw_instruction_hidden_states
+        elif isinstance(raw_instruction_hidden_states, (list, tuple)):
+            assert len(raw_instruction_hidden_states) == num_instruction_feature_layers
+            if "cat" in reduce_type.lower():
+                instruction_hidden_states = torch.cat(raw_instruction_hidden_states, dim=-1)
+            elif "mean" in reduce_type.lower():
+                instruction_hidden_states = torch.mean(torch.stack(raw_instruction_hidden_states), dim=0)
+            else:
+                raise ValueError(f"Invalid reduce_type: {reduce_type}")
+        else:
+            raise ValueError(
+                "Invalid type of raw_instruction_hidden_states, expected torch.Tensor or list, "
+                f"but got {type(raw_instruction_hidden_states)}"
+            )
+
+        assert self.preprocessed_instruction_feat_dim == instruction_hidden_states.shape[-1]
+        return instruction_hidden_states
+
+    def flat_and_pad_to_seq(self, hidden_states, ref_image_hidden_states):
+        """Flatten patch tokens and pad to batched sequences.
+
+        Ported from upstream; for text-to-image ``ref_image_hidden_states`` is
+        ``None`` and the reference-image branch collapses to zero-length.
+        """
+        batch_size = len(hidden_states)
+        p = self.patch_size
+        device = hidden_states[0].device
+
+        img_sizes = [(img.size(1), img.size(2)) for img in hidden_states]
+        l_effective_img_len = [(H // p) * (W // p) for (H, W) in img_sizes]
+
+        if ref_image_hidden_states is not None:
+            ref_img_sizes = [
+                [(img.size(1), img.size(2)) for img in imgs] if imgs is not None else None
+                for imgs in ref_image_hidden_states
+            ]
+            l_effective_ref_img_len = [
+                [(ref_img_size[0] // p) * (ref_img_size[1] // p) for ref_img_size in _ref_img_sizes]
+                if _ref_img_sizes is not None
+                else [0]
+                for _ref_img_sizes in ref_img_sizes
+            ]
+        else:
+            ref_img_sizes = [None for _ in range(batch_size)]
+            l_effective_ref_img_len = [[0] for _ in range(batch_size)]
+
+        max_ref_img_len = max(sum(ref_img_len) for ref_img_len in l_effective_ref_img_len)
+        max_img_len = max(l_effective_img_len)
+
+        # Reference-image patch embeddings.
+        flat_ref_img_hidden_states = []
+        for i in range(batch_size):
+            if ref_img_sizes[i] is not None:
+                imgs = []
+                for ref_img in ref_image_hidden_states[i]:
+                    C, H, W = ref_img.size()
+                    ref_img = rearrange(ref_img, "c (h p1) (w p2) -> (h w) (p1 p2 c)", p1=p, p2=p)
+                    imgs.append(ref_img)
+                flat_ref_img_hidden_states.append(torch.cat(imgs, dim=0))
+            else:
+                flat_ref_img_hidden_states.append(None)
+
+        # Noise-image patch embeddings.
+        flat_hidden_states = []
+        for i in range(batch_size):
+            img = hidden_states[i]
+            C, H, W = img.size()
+            img = rearrange(img, "c (h p1) (w p2) -> (h w) (p1 p2 c)", p1=p, p2=p)
+            flat_hidden_states.append(img)
+
+        padded_ref_img_hidden_states = torch.zeros(
+            batch_size,
+            max_ref_img_len,
+            flat_hidden_states[0].shape[-1],
+            device=device,
+            dtype=flat_hidden_states[0].dtype,
+        )
+        padded_ref_img_mask = torch.zeros(batch_size, max_ref_img_len, dtype=torch.bool, device=device)
+        for i in range(batch_size):
+            if ref_img_sizes[i] is not None:
+                padded_ref_img_hidden_states[i, : sum(l_effective_ref_img_len[i])] = flat_ref_img_hidden_states[i]
+                padded_ref_img_mask[i, : sum(l_effective_ref_img_len[i])] = True
+
+        padded_hidden_states = torch.zeros(
+            batch_size,
+            max_img_len,
+            flat_hidden_states[0].shape[-1],
+            device=device,
+            dtype=flat_hidden_states[0].dtype,
+        )
+        padded_img_mask = torch.zeros(batch_size, max_img_len, dtype=torch.bool, device=device)
+        for i in range(batch_size):
+            padded_hidden_states[i, : l_effective_img_len[i]] = flat_hidden_states[i]
+            padded_img_mask[i, : l_effective_img_len[i]] = True
+
+        return (
+            padded_hidden_states,
+            padded_ref_img_hidden_states,
+            padded_img_mask,
+            padded_ref_img_mask,
+            l_effective_ref_img_len,
+            l_effective_img_len,
+            ref_img_sizes,
+            img_sizes,
+        )
+
+    def img_patch_embed_and_refine(
+        self,
+        hidden_states,
+        ref_image_hidden_states,
+        padded_img_mask,
+        padded_ref_img_mask,
+        noise_rotary_emb,
+        ref_img_rotary_emb,
+        l_effective_ref_img_len,
+        l_effective_img_len,
+        temb,
+    ):
+        """Embed image patches and run the refiner blocks.
+
+        The reference-image refiner is skipped when there are no reference-image
+        tokens (text-to-image), which is numerically identical to upstream (the
+        combined sequence only reads ``[:sum(ref_img_len)]`` = empty) while
+        avoiding a degenerate zero-length attention.
+        """
+        batch_size = len(hidden_states)
+        max_combined_img_len = max(
+            img_len + sum(ref_img_len) for img_len, ref_img_len in zip(l_effective_img_len, l_effective_ref_img_len)
+        )
+
+        hidden_states = self.x_embedder(hidden_states)
+        ref_image_hidden_states = self.ref_image_patch_embedder(ref_image_hidden_states)
+
+        for i in range(batch_size):
+            shift = 0
+            for j, ref_img_len in enumerate(l_effective_ref_img_len[i]):
+                ref_image_hidden_states[i, shift : shift + ref_img_len, :] = (
+                    ref_image_hidden_states[i, shift : shift + ref_img_len, :] + self.image_index_embedding[j]
+                )
+                shift += ref_img_len
+
+        for layer in self.noise_refiner:
+            hidden_states = layer(hidden_states, padded_img_mask, noise_rotary_emb, temb)
+
+        flat_l_effective_ref_img_len = list(itertools.chain(*l_effective_ref_img_len))
+        num_ref_images = len(flat_l_effective_ref_img_len)
+        max_ref_img_len = max(flat_l_effective_ref_img_len)
+
+        if max_ref_img_len > 0:
+            batch_ref_img_mask = ref_image_hidden_states.new_zeros(num_ref_images, max_ref_img_len, dtype=torch.bool)
+            batch_ref_image_hidden_states = ref_image_hidden_states.new_zeros(
+                num_ref_images, max_ref_img_len, self.hidden_size
+            )
+            batch_ref_img_rotary_emb = hidden_states.new_zeros(
+                num_ref_images, max_ref_img_len, ref_img_rotary_emb.shape[-1], dtype=ref_img_rotary_emb.dtype
+            )
+            batch_temb = temb.new_zeros(num_ref_images, *temb.shape[1:], dtype=temb.dtype)
+
+            # Flatten reference images into a temporary batch.
+            idx = 0
+            for i in range(batch_size):
+                shift = 0
+                for ref_img_len in l_effective_ref_img_len[i]:
+                    batch_ref_img_mask[idx, :ref_img_len] = True
+                    batch_ref_image_hidden_states[idx, :ref_img_len] = ref_image_hidden_states[
+                        i, shift : shift + ref_img_len
+                    ]
+                    batch_ref_img_rotary_emb[idx, :ref_img_len] = ref_img_rotary_emb[i, shift : shift + ref_img_len]
+                    batch_temb[idx] = temb[i]
+                    shift += ref_img_len
+                    idx += 1
+
+            for layer in self.ref_image_refiner:
+                batch_ref_image_hidden_states = layer(
+                    batch_ref_image_hidden_states, batch_ref_img_mask, batch_ref_img_rotary_emb, batch_temb
+                )
+
+            # Restore reference-image sequence layout.
+            idx = 0
+            for i in range(batch_size):
+                shift = 0
+                for ref_img_len in l_effective_ref_img_len[i]:
+                    ref_image_hidden_states[i, shift : shift + ref_img_len] = batch_ref_image_hidden_states[
+                        idx, :ref_img_len
+                    ]
+                    shift += ref_img_len
+                    idx += 1
+
+        combined_img_hidden_states = hidden_states.new_zeros(batch_size, max_combined_img_len, self.hidden_size)
+        for i, (ref_img_len, img_len) in enumerate(zip(l_effective_ref_img_len, l_effective_img_len)):
+            combined_img_hidden_states[i, : sum(ref_img_len)] = ref_image_hidden_states[i, : sum(ref_img_len)]
+            combined_img_hidden_states[i, sum(ref_img_len) : sum(ref_img_len) + img_len] = hidden_states[i, :img_len]
+
+        return combined_img_hidden_states
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor | list[torch.Tensor],
+        timestep: torch.Tensor,
+        instruction_hidden_states: torch.Tensor,
+        freqs_cis: torch.Tensor,
+        instruction_attention_mask: torch.Tensor,
+        ref_image_hidden_states: list[list[torch.Tensor]] | None = None,
+    ) -> torch.Tensor:
+        """Denoise one step: refiner -> double-stream -> fuse -> single-stream -> unpatchify.
+
+        Ported from upstream ``BooguImageTransformer2DModel.forward`` with the
+        TeaCache/TaylorSeer/PEFT/gradient-checkpointing branches removed. Returns
+        the velocity prediction as a ``[B, C, H_lat, W_lat]`` tensor.
+        """
+        instruction_hidden_states = self.preprocess_instruction_hidden_states(instruction_hidden_states)
+
+        batch_size = len(hidden_states)
+        is_hidden_states_tensor = isinstance(hidden_states, torch.Tensor)
+        if is_hidden_states_tensor:
+            assert hidden_states.ndim == 4
+            hidden_states = [_hidden_states for _hidden_states in hidden_states]
+
+        device = hidden_states[0].device
+
+        # Timestep and instruction embedding.
+        temb, instruction_hidden_states = self.time_caption_embed(
+            timestep, instruction_hidden_states, hidden_states[0].dtype
+        )
+
+        # Flatten and pad token sequences.
+        (
+            hidden_states,
+            ref_image_hidden_states,
+            img_mask,
+            ref_img_mask,
+            l_effective_ref_img_len,
+            l_effective_img_len,
+            ref_img_sizes,
+            img_sizes,
+        ) = self.flat_and_pad_to_seq(hidden_states, ref_image_hidden_states)
+
+        # Build rotary embeddings and sequence lengths.
+        (
+            context_rotary_emb,
+            ref_img_rotary_emb,
+            noise_rotary_emb,
+            rotary_emb,
+            encoder_seq_lengths,
+            seq_lengths,
+            combined_img_rotary_emb,
+            combined_img_seq_lengths,
+        ) = self.rope_embedder(
+            freqs_cis,
+            instruction_attention_mask,
+            l_effective_ref_img_len,
+            l_effective_img_len,
+            ref_img_sizes,
+            img_sizes,
+            device,
+        )
+
+        # Context refinement.
+        for layer in self.context_refiner:
+            instruction_hidden_states = layer(instruction_hidden_states, instruction_attention_mask, context_rotary_emb)
+
+        # Image patch embedding and refinement.
+        combined_img_hidden_states = self.img_patch_embed_and_refine(
+            hidden_states,
+            ref_image_hidden_states,
+            img_mask,
+            ref_img_mask,
+            noise_rotary_emb,
+            ref_img_rotary_emb,
+            l_effective_ref_img_len,
+            l_effective_img_len,
+            temb,
+        )
+
+        instruct_hidden_states = instruction_hidden_states
+        img_hidden_states = combined_img_hidden_states
+
+        # Joint mask for [instruct + image].
+        max_seq_len = max(seq_lengths)
+        joint_attention_mask = hidden_states.new_zeros(batch_size, max_seq_len, dtype=torch.bool)
+        for i, seq_len in enumerate(seq_lengths):
+            joint_attention_mask[i, :seq_len] = True
+
+        # Dual-stream (double-stream) stage.
+        if self.num_double_stream_layers > 0:
+            max_img_len = max(combined_img_seq_lengths)
+            img_attention_mask = hidden_states.new_zeros(batch_size, max_img_len, dtype=torch.bool)
+            for i, img_seq_len in enumerate(combined_img_seq_lengths):
+                img_attention_mask[i, :img_seq_len] = True
+
+            for layer in self.double_stream_layers:
+                img_hidden_states, instruct_hidden_states = layer(
+                    img_hidden_states,
+                    instruct_hidden_states,
+                    img_attention_mask,
+                    joint_attention_mask,
+                    combined_img_rotary_emb,
+                    rotary_emb,
+                    temb,
+                    encoder_seq_lengths,
+                    seq_lengths,
+                )
+
+        # Fuse streams to joint sequence.
+        joint_hidden_states = hidden_states.new_zeros(batch_size, max(seq_lengths), self.hidden_size)
+        for i, (encoder_seq_len, seq_len) in enumerate(zip(encoder_seq_lengths, seq_lengths)):
+            joint_hidden_states[i, :encoder_seq_len] = instruct_hidden_states[i, :encoder_seq_len]
+            joint_hidden_states[i, encoder_seq_len:seq_len] = img_hidden_states[i, : seq_len - encoder_seq_len]
+
+        # Single-stream stage.
+        hidden_states = joint_hidden_states
+        for layer in self.single_stream_layers:
+            hidden_states = layer(hidden_states, joint_attention_mask, rotary_emb, temb)
+
+        # Output projection.
+        hidden_states = self.norm_out(hidden_states, temb)
+
+        # Reshape back to image format.
+        p = self.patch_size
+        output = []
+        for i, (img_size, img_len, seq_len) in enumerate(zip(img_sizes, l_effective_img_len, seq_lengths)):
+            height, width = img_size
+            img_tokens = hidden_states[i][seq_len - img_len : seq_len]
+            img_output = rearrange(
+                img_tokens,
+                "(h w) (p1 p2 c) -> c (h p1) (w p2)",
+                h=height // p,
+                w=width // p,
+                p1=p,
+                p2=p,
+            )
+            output.append(img_output)
+
+        if is_hidden_states_tensor:
+            output = torch.stack(output, dim=0)
+
+        return output
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        """Load diffusers-named checkpoint weights into the native module.
+
+        Two name promotions relative to upstream (see step 8/10 findings):
+
+        - ``*.img_instruct_attn.processor.{img,instruct}_{to_q,to_k,to_v}`` /
+          ``{instruct,img}_out`` -> drop ``.processor`` (upstream keeps the
+          joint-attention projections on the attention processor; the native
+          module hosts them directly).
+        - ``*.to_out.0.weight`` -> ``*.to_out.weight`` (diffusers wraps the
+          output projection in a ``ModuleList``; the native module uses a plain
+          linear).
+        """
+        params_dict = dict(self.named_parameters())
+        loaded_params: set[str] = set()
+
+        for name, loaded_weight in weights:
+            original_name = name
+            if ".img_instruct_attn.processor." in name:
+                name = name.replace(".img_instruct_attn.processor.", ".img_instruct_attn.")
+            if ".to_out.0." in name:
+                name = name.replace(".to_out.0.", ".to_out.")
+
+            if name not in params_dict:
+                logger.warning("Skipping unexpected checkpoint weight %s", original_name)
+                continue
+
+            param = params_dict[name]
+            weight_loader = getattr(param, "weight_loader", default_weight_loader)
+            weight_loader(param, loaded_weight)
+            loaded_params.add(name)
+
+        unloaded_params = sorted(params_dict.keys() - loaded_params)
+        if unloaded_params:
+            logger.warning("Model parameters not loaded from checkpoint: %s", unloaded_params)
+
+        return loaded_params
diff --git a/vllm_omni/diffusion/models/boogu_image/image_processor.py b/vllm_omni/diffusion/models/boogu_image/image_processor.py
new file mode 100644
index 000000000..3edf67bcc
--- /dev/null
+++ b/vllm_omni/diffusion/models/boogu_image/image_processor.py
@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Native port of the upstream ``BooguImageProcessor``.
+
+Ported from the external ``boogu`` package
+(``boogu/pipelines/image_processor.py``) so the native vLLM-Omni pipeline can
+reproduce Boogu-Image's reference-image and VLM preprocessing without requiring
+``pip install boogu-image``.
+
+Only the two Boogu-specific methods are ported: ``get_new_height_width`` (the
+``max_pixels`` / ``max_side_length`` aware downscale-only resize) and
+``preprocess`` (which routes through it). Everything else is inherited from the
+stock diffusers ``VaeImageProcessor``.
+"""
+
+import warnings
+
+import numpy as np
+import PIL.Image
+import torch
+from diffusers.image_processor import (
+    PipelineImageInput,
+    VaeImageProcessor,
+    is_valid_image_imagelist,
+)
+
+
+class BooguImageProcessor(VaeImageProcessor):
+    """VaeImageProcessor variant with Boogu-Image pixel/side-length constraints.
+
+    Resizing never upscales (the ratio is clamped to ``<= 1``) and always aligns
+    the target height/width to multiples of ``vae_scale_factor``.
+    """
+
+    def __init__(
+        self,
+        do_resize: bool = True,
+        vae_scale_factor: int = 16,
+        resample: str = "lanczos",
+        max_pixels: int | None = None,
+        max_side_length: int | None = None,
+        do_normalize: bool = True,
+        do_binarize: bool = False,
+        do_convert_rgb: bool = False,
+        do_convert_grayscale: bool = False,
+    ):
+        super().__init__(
+            do_resize=do_resize,
+            vae_scale_factor=vae_scale_factor,
+            resample=resample,
+            do_normalize=do_normalize,
+            do_binarize=do_binarize,
+            do_convert_rgb=do_convert_rgb,
+            do_convert_grayscale=do_convert_grayscale,
+        )
+        self.max_pixels = max_pixels
+        self.max_side_length = max_side_length
+
+    def get_new_height_width(
+        self,
+        image: PIL.Image.Image | np.ndarray | torch.Tensor,
+        height: int | None = None,
+        width: int | None = None,
+        max_pixels: int | None = None,
+        max_side_length: int | None = None,
+    ) -> tuple[int, int]:
+        """Return target ``(height, width)`` after downscale + alignment.
+
+        Faithful port of upstream ``BooguImageProcessor.get_new_height_width``.
+        """
+        if height is None:
+            if isinstance(image, PIL.Image.Image):
+                height = image.height
+            elif isinstance(image, torch.Tensor):
+                height = image.shape[2]
+            else:
+                height = image.shape[1]
+
+        if width is None:
+            if isinstance(image, PIL.Image.Image):
+                width = image.width
+            elif isinstance(image, torch.Tensor):
+                width = image.shape[3]
+            else:
+                width = image.shape[2]
+
+        if max_side_length is None:
+            max_side_length = self.max_side_length
+
+        if max_pixels is None:
+            max_pixels = self.max_pixels
+
+        if height <= 0 or width <= 0:
+            raise ValueError(f"Image height and width must be positive, got height={height}, width={width}")
+
+        max_side_length_ratio = 1.0
+        if max_side_length is not None:
+            if height > width:
+                max_side_length_ratio = max_side_length / height
+            else:
+                max_side_length_ratio = max_side_length / width
+
+        cur_pixels = height * width
+        max_pixels_ratio = (max_pixels / cur_pixels) ** 0.5 if max_pixels is not None else 1.0
+        # Clamp ratio to <=1 to avoid upscaling input images in preprocessing.
+        ratio = min(max_pixels_ratio, max_side_length_ratio, 1.0)
+
+        new_height, new_width = (
+            int(height * ratio) // self.config.vae_scale_factor * self.config.vae_scale_factor,
+            int(width * ratio) // self.config.vae_scale_factor * self.config.vae_scale_factor,
+        )
+        return new_height, new_width
+
+    def preprocess(
+        self,
+        image: PipelineImageInput,
+        height: int | None = None,
+        width: int | None = None,
+        max_pixels: int | None = None,
+        max_side_length: int | None = None,
+        resize_mode: str = "default",
+        crops_coords: tuple[int, int, int, int] | None = None,
+    ) -> torch.Tensor:
+        """Preprocess an image into a normalized ``[B, C, H, W]`` tensor.
+
+        Faithful port of upstream ``BooguImageProcessor.preprocess`` (PixArt-style
+        downscale). Only the PIL branch is exercised by the native pipeline, but
+        the numpy/tensor branches are kept for parity.
+        """
+        supported_formats = (PIL.Image.Image, np.ndarray, torch.Tensor)
+
+        if self.config.do_convert_grayscale and isinstance(image, (torch.Tensor, np.ndarray)) and image.ndim == 3:
+            if isinstance(image, torch.Tensor):
+                image = image.unsqueeze(1)
+            else:
+                if image.shape[-1] == 1:
+                    image = np.expand_dims(image, axis=0)
+                else:
+                    image = np.expand_dims(image, axis=-1)
+
+        if isinstance(image, list) and isinstance(image[0], np.ndarray) and image[0].ndim == 4:
+            warnings.warn(
+                "Passing `image` as a list of 4d np.ndarray is deprecated."
+                "Please concatenate the list along the batch dimension and pass it as a single 4d np.ndarray",
+                FutureWarning,
+            )
+            image = np.concatenate(image, axis=0)
+        if isinstance(image, list) and isinstance(image[0], torch.Tensor) and image[0].ndim == 4:
+            warnings.warn(
+                "Passing `image` as a list of 4d torch.Tensor is deprecated."
+                "Please concatenate the list along the batch dimension and pass it as a single 4d torch.Tensor",
+                FutureWarning,
+            )
+            image = torch.cat(image, axis=0)
+
+        if not is_valid_image_imagelist(image):
+            supported_formats_str = ", ".join(str(x) for x in supported_formats)
+            raise ValueError(f"Input is in incorrect format. Currently, we only support {supported_formats_str}")
+
+        if not isinstance(image, list):
+            image = [image]
+
+        if isinstance(image[0], PIL.Image.Image):
+            if crops_coords is not None:
+                image = [i.crop(crops_coords) for i in image]
+            if self.config.do_resize:
+                height, width = self.get_new_height_width(image[0], height, width, max_pixels, max_side_length)
+                image = [self.resize(i, height, width, resize_mode=resize_mode) for i in image]
+            if self.config.do_convert_rgb:
+                image = [self.convert_to_rgb(i) for i in image]
+            elif self.config.do_convert_grayscale:
+                image = [self.convert_to_grayscale(i) for i in image]
+            image = self.pil_to_numpy(image)
+            image = self.numpy_to_pt(image)
+
+        elif isinstance(image[0], np.ndarray):
+            image = np.concatenate(image, axis=0) if image[0].ndim == 4 else np.stack(image, axis=0)
+            image = self.numpy_to_pt(image)
+            height, width = self.get_new_height_width(image, height, width, max_pixels, max_side_length)
+            if self.config.do_resize:
+                image = self.resize(image, height, width)
+
+        elif isinstance(image[0], torch.Tensor):
+            image = torch.cat(image, axis=0) if image[0].ndim == 4 else torch.stack(image, axis=0)
+
+            if self.config.do_convert_grayscale and image.ndim == 3:
+                image = image.unsqueeze(1)
+
+            channel = image.shape[1]
+            if channel == self.config.vae_latent_channels:
+                return image
+
+            height, width = self.get_new_height_width(image, height, width, max_pixels, max_side_length)
+            if self.config.do_resize:
+                image = self.resize(image, height, width)
+
+        do_normalize = self.config.do_normalize
+        if do_normalize and image.min() < 0:
+            warnings.warn(
+                "Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range "
+                f"for image tensor is [0,1] when passing as pytorch tensor or numpy Array. You passed `image` with "
+                f"value range [{image.min()},{image.max()}]",
+                FutureWarning,
+            )
+            do_normalize = False
+        if do_normalize:
+            image = self.normalize(image)
+
+        if self.config.do_binarize:
+            image = self.binarize(image)
+
+        return image
diff --git a/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py b/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py
new file mode 100644
index 000000000..7ef6877c8
--- /dev/null
+++ b/vllm_omni/diffusion/models/boogu_image/pipeline_boogu_image.py
@@ -0,0 +1,793 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Native vLLM-Omni pipeline for Boogu-Image-0.1.
+
+Ported from the upstream ``boogu`` package
+(``boogu/pipelines/boogu/pipeline_boogu.py``) with the following changes:
+
+- Diffusers ``DiffusionPipeline``/``register_modules`` machinery replaced by a
+  plain ``nn.Module`` constructed from ``OmniDiffusionConfig`` (components are
+  loaded from the checkpoint subfolders; transformer weights arrive later via
+  ``weights_sources`` + ``load_weights``).
+- Upstream ``encode_instruction`` is exposed as ``encode_prompt`` (the
+  vLLM-Omni convention, also hooked by the prompt-embed cache); only the
+  text-to-image path is ported. Instruction rewriting, prompt tuning,
+  reference-image (TI2I/I2I) encoding, double guidance, and vision-token
+  stripping are not ported.
+- ``forward()`` (denoise loop + VAE decode) is intentionally not implemented
+  yet; it lands together with the post-process registration.
+"""
+
+import json
+import os
+from collections.abc import Iterable
+from typing import ClassVar, cast
+
+import PIL.Image
+import torch
+import torch.nn.functional as F
+from diffusers.image_processor import VaeImageProcessor
+from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
+from diffusers.utils.torch_utils import randn_tensor
+from torch import nn
+from transformers import Qwen3VLForConditionalGeneration, Qwen3VLProcessor
+from vllm.logger import init_logger
+from vllm.model_executor.models.utils import AutoWeightsLoader
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
+from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
+from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+    BooguImageDoubleStreamRotaryPosEmbed,
+    BooguImageTransformer2DModel,
+)
+from vllm_omni.diffusion.models.boogu_image.image_processor import BooguImageProcessor
+from vllm_omni.diffusion.models.boogu_image.scheduling_flow_match_euler_discrete_time_shifting import (
+    FlowMatchEulerDiscreteScheduler,
+)
+from vllm_omni.diffusion.models.interface import SupportImageInput, SupportsComponentDiscovery
+from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
+
+logger = init_logger(__name__)
+
+# Reference-image preprocessing limits (upstream ``BooguImagePipeline.__call__``
+# defaults). The VLM copy is aggressively downscaled for the Qwen3VL encoder;
+# the VAE copy keeps near-native resolution for the reference latents.
+_MAX_VLM_INPUT_PIL_PIXELS = 384 * 384
+_MAX_VLM_INPUT_PIL_SIDE_LENGTH = 384 * 2
+_MAX_INPUT_IMAGE_PIXELS = 2048 * 2048
+_MAX_INPUT_IMAGE_SIDE_LENGTH = 2048 * 2
+
+
+def _load_vae_scale_factor(model_path: str) -> int:
+    vae_config_path = os.path.join(model_path, "vae/config.json")
+    try:
+        with open(vae_config_path) as f:
+            vae_config = json.load(f)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"Failed to load Boogu VAE config from {vae_config_path}: {exc}") from exc
+
+    if "block_out_channels" not in vae_config:
+        return 8
+    return 2 ** (len(vae_config["block_out_channels"]) - 1)
+
+
+def get_boogu_image_post_process_func(od_config: OmniDiffusionConfig):
+    """Build the post-process callable that converts decoded tensors to images.
+
+    Upstream ``BooguImageProcessor`` only customizes *pre*-processing; the
+    ``postprocess`` path is inherited from the stock diffusers
+    ``VaeImageProcessor``, so we reuse it directly here.
+    """
+    model_name = od_config.model
+    if os.path.exists(model_name):
+        model_path = model_name
+    else:
+        model_path = download_weights_from_hf_specific(model_name, None, ["*"])
+
+    vae_scale_factor = _load_vae_scale_factor(model_path)
+
+    image_processor = VaeImageProcessor(vae_scale_factor=vae_scale_factor * 2)
+
+    def post_process_func(images: torch.Tensor):
+        return image_processor.postprocess(images)
+
+    return post_process_func
+
+
+def get_boogu_image_pre_process_func(od_config: OmniDiffusionConfig):
+    """Build the pre-process callable for Boogu-Image reference (edit) input.
+
+    Text-to-image requests carry no image and are passed through unchanged (the
+    Base checkpoint shares this pipeline class). Edit (TI2I) requests carry a
+    single reference PIL image on ``prompt["multi_modal_data"]["image"]``; it is
+    resized twice — once for the Qwen3VL encoder (``prompt_image``) and once for
+    the VAE reference latents (``preprocessed_image``) — and stashed in
+    ``additional_information`` for ``forward`` to consume. Mirrors upstream
+    ``preprocess_vlm_input_pil_images`` + ``prepare_image``.
+
+    For a single reference image, upstream ``align_res`` (default ``True``)
+    derives the output resolution from the VAE-encoded reference dimensions, so
+    the request height/width are overwritten accordingly.
+    """
+    model_name = od_config.model
+    if os.path.exists(model_name):
+        model_path = model_name
+    else:
+        model_path = download_weights_from_hf_specific(model_name, None, ["*"])
+
+    vae_scale_factor = _load_vae_scale_factor(model_path)
+
+    # Upstream builds ``BooguImageProcessor(vae_scale_factor=vae_scale_factor*2)``
+    # so all resize targets align to multiples of ``vae_scale_factor * 2``.
+    image_processor = BooguImageProcessor(vae_scale_factor=vae_scale_factor * 2, do_resize=True)
+
+    def pre_process_func(request: OmniDiffusionRequest):
+        prompt = request.prompt
+        if isinstance(prompt, str):
+            # Plain-text prompt cannot carry an image -> text-to-image, no-op.
+            return request
+
+        multi_modal_data = prompt.get("multi_modal_data") or {}
+        raw_image = multi_modal_data.get("image")
+        if not raw_image:
+            # No reference image -> text-to-image, no-op (Base checkpoint).
+            return request
+
+        if isinstance(raw_image, list):
+            if len(raw_image) > 1:
+                raise ValueError(f"Boogu-Image editing supports a single reference image; received {len(raw_image)}.")
+            raw_image = raw_image[0]
+
+        if isinstance(raw_image, str):
+            image = PIL.Image.open(raw_image)
+        else:
+            image = cast(PIL.Image.Image, raw_image)
+        image = image.convert("RGB")
+
+        if "additional_information" not in prompt:
+            prompt["additional_information"] = {}
+
+        # VLM-resized copy (PIL) for the Qwen3VL instruction encoder.
+        vlm_height, vlm_width = image_processor.get_new_height_width(
+            image, None, None, _MAX_VLM_INPUT_PIL_PIXELS, _MAX_VLM_INPUT_PIL_SIDE_LENGTH
+        )
+        prompt_image = image_processor.resize(image, vlm_height, vlm_width)
+
+        # VAE-ready copy (normalized [1, C, H, W] tensor) for reference latents.
+        preprocessed_image = image_processor.preprocess(
+            image, max_pixels=_MAX_INPUT_IMAGE_PIXELS, max_side_length=_MAX_INPUT_IMAGE_SIDE_LENGTH
+        )
+
+        # align_res: single-image output resolution follows the reference dims.
+        request.sampling_params.height = int(preprocessed_image.shape[-2])
+        request.sampling_params.width = int(preprocessed_image.shape[-1])
+
+        prompt["additional_information"]["preprocessed_image"] = preprocessed_image
+        prompt["additional_information"]["prompt_image"] = prompt_image
+        request.prompt = prompt
+        return request
+
+    return pre_process_func
+
+
+# System prompts matching upstream dataset logic (ported verbatim from
+# ``BooguImagePipeline.__init__``).
+SYSTEM_PROMPT_4_TI2I_UNIFIED = (
+    "Describe the key features of the input image (color, shape, size, texture, objects, background), "
+    "then explain how the user's text instruction should alter or modify the image. Generate a new image "
+    "that meets the user's requirements while maintaining consistency with the original input where appropriate."
+)
+SYSTEM_PROMPT_4_T2I_UNIFIED = (
+    "You are a helpful assistant that generates high-quality images based on user instructions. "
+    "The instructions are as follows."
+)
+
+
+class BooguImagePipeline(nn.Module, ProgressBarMixin, SupportsComponentDiscovery, SupportImageInput):
+    """Boogu-Image text-to-image and image-editing (TI2I) pipeline.
+
+    Native vLLM-Omni implementation. A request with a reference image (edit /
+    TI2I) is served by the same class as text-to-image; the reference latents
+    and Qwen3VL image tokens are threaded through ``forward`` and the ported
+    transformer's reference-image refiner path.
+    """
+
+    supports_request_batch = False
+
+    support_image_input: ClassVar[bool] = True
+    color_format: ClassVar[str] = "RGB"
+
+    _dit_modules: ClassVar[list[str]] = ["transformer"]
+    _encoder_modules: ClassVar[list[str]] = ["mllm"]
+    _vae_modules: ClassVar[list[str]] = ["vae"]
+
+    def __init__(
+        self,
+        *,
+        od_config: OmniDiffusionConfig,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.od_config = od_config
+        self._raise_unsupported_features()
+        self.weights_sources = [
+            DiffusersPipelineLoader.ComponentSource(
+                model_or_path=od_config.model,
+                subfolder="transformer",
+                revision=None,
+                prefix="transformer.",
+                fall_back_to_pt=True,
+            )
+        ]
+
+        self._execution_device = get_local_device()
+        model = od_config.model
+        local_files_only = os.path.exists(model)
+
+        # See ``hub_prefetch.py`` for the transformers v5 multi-worker subfolder
+        # race; prefetch the whole component set before any from_pretrained.
+        boogu_subfolders = ["scheduler", "vae", "mllm", "processor"]
+        prefetch_subfolders(model, boogu_subfolders, local_files_only=local_files_only)
+
+        self.scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+            model, subfolder="scheduler", local_files_only=local_files_only
+        )
+
+        mllm = from_pretrained_with_prefetch(
+            Qwen3VLForConditionalGeneration.from_pretrained,
+            model,
+            subfolder="mllm",
+            prefetch_list=boogu_subfolders,
+            local_files_only=local_files_only,
+            torch_dtype=od_config.dtype,
+        )
+        # Upstream reuses the full VLM as an optional instruction rewriter and
+        # encodes with its inner model (no ``lm_head``); the rewriter is not
+        # ported, so keep only the inner ``Qwen3VLModel`` as the encoder.
+        if hasattr(mllm, "lm_head"):
+            mllm = mllm.model
+        self.mllm = mllm.to(self._execution_device)
+
+        self.processor = Qwen3VLProcessor.from_pretrained(
+            model, subfolder="processor", local_files_only=local_files_only
+        )
+
+        self.vae = from_pretrained_with_prefetch(
+            AutoencoderKL.from_pretrained,
+            model,
+            subfolder="vae",
+            prefetch_list=boogu_subfolders,
+            local_files_only=local_files_only,
+        ).to(self._execution_device)
+
+        self.transformer = BooguImageTransformer2DModel(od_config=od_config)
+
+        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) if getattr(self, "vae", None) else 8
+        self.default_sample_size = 128
+
+        self.SYSTEM_PROMPT_4_T2I = SYSTEM_PROMPT_4_T2I_UNIFIED
+        # Upstream uses the TI2I prompt for empty instructions (the default
+        # negative prompt "" hits this path).
+        self.SYSTEM_PROMPT_DROP = SYSTEM_PROMPT_4_TI2I_UNIFIED
+        # Edit (TI2I / I2I) system prompts (image present in the chat template).
+        self.SYSTEM_PROMPT_4_TI2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
+        self.SYSTEM_PROMPT_4_I2I = SYSTEM_PROMPT_4_TI2I_UNIFIED
+
+    def _raise_unsupported_features(self) -> None:
+        """Reject execution modes that do not have Boogu-specific support."""
+        parallel_config = self.od_config.parallel_config
+        if parallel_config.tensor_parallel_size > 1:
+            raise NotImplementedError("Tensor parallelism is not supported by BooguImagePipeline.")
+        if (parallel_config.sequence_parallel_size or 1) > 1:
+            raise NotImplementedError("Sequence parallelism is not supported by BooguImagePipeline.")
+        if parallel_config.cfg_parallel_size > 1:
+            raise NotImplementedError("CFG parallelism is not supported by BooguImagePipeline.")
+        if parallel_config.use_hsdp:
+            raise NotImplementedError("HSDP is not supported by BooguImagePipeline.")
+        if self.od_config.cache_backend not in (None, "", "none"):
+            raise NotImplementedError(
+                f"Cache backend '{self.od_config.cache_backend}' is not supported by BooguImagePipeline."
+            )
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        loader = AutoWeightsLoader(self)
+        return loader.load_weights(weights)
+
+    # ------------------------------------------------------------------
+    # Prompt encoding (upstream ``encode_instruction``, t2i path)
+    # ------------------------------------------------------------------
+
+    def _apply_chat_template(
+        self,
+        instruction: str,
+        input_pil_images: list[PIL.Image.Image] | None = None,
+    ) -> list[dict]:
+        """Build the chat messages for one instruction (text-to-image or edit).
+
+        Mirrors upstream ``_apply_chat_template`` (``system_prompt_follows_task_type``
+        is always ``False`` here): the system prompt is picked by whether images
+        are present and whether the instruction is empty, and reference images
+        are placed *before* the instruction text in the user turn.
+        """
+        user_text_content = [{"type": "text", "text": instruction}]
+
+        has_images = input_pil_images is not None and len(input_pil_images) > 0
+        instruction_empty = instruction is None or len(instruction.strip()) == 0
+
+        if not has_images:
+            system_prompt = self.SYSTEM_PROMPT_DROP if instruction_empty else self.SYSTEM_PROMPT_4_T2I
+        else:
+            system_prompt = self.SYSTEM_PROMPT_4_I2I if instruction_empty else self.SYSTEM_PROMPT_4_TI2I
+
+        system_role = {"role": "system", "content": [{"type": "text", "text": system_prompt}]}
+        if not has_images:
+            return [system_role, {"role": "user", "content": user_text_content}]
+
+        images_content = [{"type": "image", "image": pil_img} for pil_img in input_pil_images]
+        return [system_role, {"role": "user", "content": images_content + user_text_content}]
+
+    def _get_instruction_feature_embeds(
+        self,
+        instruction: str | list[str],
+        input_pil_images: list[list[PIL.Image.Image] | None] | None = None,
+        device: torch.device | None = None,
+        max_sequence_length: int = 256,
+        truncate_instruction_sequence: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Encode instructions (and optional reference images) with Qwen3VL.
+
+        ``input_pil_images`` is a per-sample list (outer length == batch size);
+        each entry is the sample's already-VLM-resized reference images or
+        ``None``. Returns the last hidden state (or the last-N layers as a list
+        when the transformer config asks for more than one) and the attention
+        mask.
+        """
+        device = device or self._execution_device
+        instruction = [instruction] if isinstance(instruction, str) else instruction
+
+        if input_pil_images is None:
+            per_sample_images: list[list[PIL.Image.Image] | None] = [None] * len(instruction)
+        else:
+            assert len(input_pil_images) == len(instruction), (
+                "`input_pil_images` outer length must match the instruction batch size."
+            )
+            per_sample_images = input_pil_images
+
+        prompts = [self._apply_chat_template(text, per_sample_images[i]) for i, text in enumerate(instruction)]
+
+        vlm_inputs = self.processor.apply_chat_template(
+            prompts,
+            padding="longest",
+            max_length=max_sequence_length,
+            truncation=truncate_instruction_sequence,
+            padding_side="right",
+            return_tensors="pt",
+            tokenize=True,
+            return_dict=True,
+        )
+        for k in vlm_inputs.keys():
+            if isinstance(vlm_inputs[k], torch.Tensor):
+                vlm_inputs[k] = vlm_inputs[k].to(device)
+
+        final_instruction_mask = vlm_inputs["attention_mask"]
+
+        num_instruction_feature_layers = self.transformer.instruction_feature_configs.get(
+            "num_instruction_feature_layers", 1
+        )
+
+        with torch.no_grad():
+            text_encoder_outputs = self.mllm(**vlm_inputs, output_hidden_states=True, return_dict=True)
+            if num_instruction_feature_layers > 1:
+                instruction_feats = list(text_encoder_outputs.hidden_states)[-num_instruction_feature_layers:]
+            else:
+                instruction_feats = text_encoder_outputs.hidden_states[-1]
+
+        dtype = self.mllm.dtype if self.mllm is not None else self.transformer.dtype
+
+        if isinstance(instruction_feats, (list, tuple)):
+            final_instruction_feats = [feat.to(dtype=dtype, device=device) for feat in instruction_feats]
+        else:
+            final_instruction_feats = instruction_feats.to(dtype=dtype, device=device)
+        final_instruction_mask = final_instruction_mask.to(device=device)
+
+        return final_instruction_feats, final_instruction_mask
+
+    def _reshape_embeds_and_mask(self, embeds, mask, num_images_per_prompt: int):
+        """Duplicate embeddings/mask for each generation per prompt (mps-friendly)."""
+        if isinstance(embeds, (list, tuple)):
+            batch_size, seq_len, _ = embeds[0].shape
+            reshaped_embeds = []
+            for embed in embeds:
+                embed = embed.repeat(1, num_images_per_prompt, 1)
+                reshaped_embeds.append(embed.view(batch_size * num_images_per_prompt, seq_len, -1))
+        else:
+            batch_size, seq_len, _ = embeds.shape
+            embeds = embeds.repeat(1, num_images_per_prompt, 1)
+            reshaped_embeds = embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
+
+        mask = mask.repeat(num_images_per_prompt, 1)
+        reshaped_mask = mask.view(batch_size * num_images_per_prompt, -1)
+
+        return batch_size, seq_len, reshaped_embeds, reshaped_mask
+
+    def encode_prompt(
+        self,
+        prompt: str | list[str],
+        do_classifier_free_guidance: bool = True,
+        negative_prompt: str | list[str] | None = None,
+        num_images_per_prompt: int = 1,
+        device: torch.device | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        prompt_attention_mask: torch.Tensor | None = None,
+        negative_prompt_attention_mask: torch.Tensor | None = None,
+        max_sequence_length: int = 1280,
+        truncate_instruction_sequence: bool = False,
+        input_images: list[list[PIL.Image.Image] | None] | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """Encode prompt (and negative prompt for CFG) into Qwen3VL hidden states.
+
+        Port of upstream ``encode_instruction`` for text-to-image and the
+        text-guided image-editing (TI2I) path. Reference images are attached to
+        the *positive* instruction only (upstream default
+        ``use_input_images_4_neg_instruct=False``). Instruction rewriting,
+        prompt tuning, and double-guidance empty instructions are not ported.
+        The default ``max_sequence_length`` matches the upstream ``__call__``
+        default (1280), not the upstream ``encode_instruction`` default (256).
+
+        Args:
+            input_images: Per-sample list (outer length == batch size) of
+                already-VLM-resized reference images, or ``None`` for pure
+                text-to-image.
+
+        Returns:
+            ``(prompt_embeds, prompt_attention_mask, negative_prompt_embeds,
+            negative_prompt_attention_mask)`` where each embeds tensor has shape
+            ``[batch_size * num_images_per_prompt, seq_len, dim]``. The negative
+            pair is ``None`` when ``do_classifier_free_guidance`` is off and no
+            precomputed negative embeddings were passed.
+        """
+        device = device or self._execution_device
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+
+        if prompt_embeds is None:
+            prompt_embeds, prompt_attention_mask = self._get_instruction_feature_embeds(
+                instruction=prompt,
+                input_pil_images=input_images,
+                device=device,
+                max_sequence_length=max_sequence_length,
+                truncate_instruction_sequence=truncate_instruction_sequence,
+            )
+
+        batch_size, _, prompt_embeds, prompt_attention_mask = self._reshape_embeds_and_mask(
+            prompt_embeds, prompt_attention_mask, num_images_per_prompt
+        )
+
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt if negative_prompt is not None else ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+
+            if batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt` has batch size {len(negative_prompt)}, but `prompt` has"
+                    f" batch size {batch_size}. Please make sure that passed `negative_prompt`"
+                    " matches the batch size of `prompt`."
+                )
+
+            negative_prompt_embeds, negative_prompt_attention_mask = self._get_instruction_feature_embeds(
+                instruction=negative_prompt,
+                device=device,
+                max_sequence_length=max_sequence_length,
+                truncate_instruction_sequence=truncate_instruction_sequence,
+            )
+
+            _, _, negative_prompt_embeds, negative_prompt_attention_mask = self._reshape_embeds_and_mask(
+                negative_prompt_embeds, negative_prompt_attention_mask, num_images_per_prompt
+            )
+
+        return (
+            prompt_embeds,
+            prompt_attention_mask,
+            negative_prompt_embeds,
+            negative_prompt_attention_mask,
+        )
+
+    # ------------------------------------------------------------------
+    # Denoise loop + VAE decode (upstream ``__call__`` / ``processing``, t2i)
+    # ------------------------------------------------------------------
+
+    def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
+        """Sample initial noise latents (upstream ``prepare_latents``)."""
+        height = int(height) // self.vae_scale_factor
+        width = int(width) // self.vae_scale_factor
+        shape = (batch_size, num_channels_latents, height, width)
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        else:
+            latents = latents.to(device)
+        return latents
+
+    def _resolve_output_size(self, height, width):
+        """t2i branch of upstream ``_resolve_output_and_original_size``.
+
+        Clamps the working resolution to ``max_input_image_pixels`` (2048**2),
+        rounding down to a multiple of ``vae_scale_factor * 2``; the requested
+        size is remembered so the decoded image can be resized back.
+        """
+        img_scale_num = self.vae_scale_factor * 2
+        ori_height, ori_width = height, width
+        max_pixels = 2048 * 2048
+        cur_pixels = height * width
+        ratio = min((max_pixels / cur_pixels) ** 0.5, 1.0)
+        height = int(height * ratio) // img_scale_num * img_scale_num
+        width = int(width * ratio) // img_scale_num * img_scale_num
+        return height, width, ori_height, ori_width
+
+    def predict(
+        self, t, latents, instruction_embeds, freqs_cis, instruction_attention_mask, ref_image_hidden_states=None
+    ):
+        """One transformer velocity prediction (upstream ``predict``).
+
+        ``ref_image_hidden_states`` is ``None`` for text-to-image, or the
+        per-sample reference latents (``list[list[Tensor[C, H, W]]]``) for the
+        image-editing path.
+        """
+        timestep = t.expand(latents.shape[0]).to(latents.dtype)
+        return self.transformer(
+            latents,
+            timestep,
+            instruction_embeds,
+            freqs_cis,
+            instruction_attention_mask,
+            ref_image_hidden_states=ref_image_hidden_states,
+        )
+
+    def _encode_vae_image(self, img: torch.Tensor, generator=None) -> torch.Tensor:
+        """Encode an image tensor into the VAE latent space (upstream ``encode_vae``).
+
+        Upstream leaves ``latent_dist.sample()`` unseeded; the native path
+        threads the request generator through so a fixed seed gives a
+        reproducible reference latent.
+        """
+        z0 = self.vae.encode(img.to(dtype=self.vae.dtype)).latent_dist.sample(generator=generator)
+        if self.vae.config.shift_factor is not None:
+            z0 = z0 - self.vae.config.shift_factor
+        if self.vae.config.scaling_factor is not None:
+            z0 = z0 * self.vae.config.scaling_factor
+        return z0.to(dtype=self.vae.dtype)
+
+    def _build_ref_latents(
+        self,
+        preprocessed_images: list[torch.Tensor | None],
+        num_images_per_prompt: int,
+        device: torch.device,
+        generator=None,
+    ) -> list[list[torch.Tensor] | None]:
+        """VAE-encode per-sample reference images into the transformer's format.
+
+        Mirrors upstream ``prepare_image``: returns a list of length
+        ``batch_size * num_images_per_prompt`` where each entry is either
+        ``None`` (no reference / text-to-image) or a list of ``[C, H, W]``
+        reference latents (one per reference image). Boogu editing uses a single
+        reference image, so each non-empty entry is a one-element list.
+        """
+        # ``latent_dist.sample`` accepts only a single generator; a per-output
+        # generator list (num_outputs_per_prompt > 1) falls back to unseeded.
+        vae_generator = generator if isinstance(generator, torch.Generator) else None
+
+        ref_latents: list[list[torch.Tensor] | None] = []
+        for image in preprocessed_images:
+            if image is None:
+                sample_latents: list[torch.Tensor] | None = None
+            else:
+                latent = self._encode_vae_image(image.to(device=device), generator=vae_generator).squeeze(0)
+                sample_latents = [latent]
+            for _ in range(num_images_per_prompt):
+                ref_latents.append(sample_latents)
+        return ref_latents
+
+    @staticmethod
+    def _extract_reference_images(
+        prompts: list,
+    ) -> tuple[list[PIL.Image.Image | None], list[torch.Tensor | None]]:
+        """Pull per-sample reference images out of ``additional_information``.
+
+        Returns ``(prompt_images, preprocessed_images)`` where entries are
+        ``None`` for pure text-to-image samples. Populated by
+        :func:`get_boogu_image_pre_process_func`.
+        """
+        prompt_images: list[PIL.Image.Image | None] = []
+        preprocessed_images: list[torch.Tensor | None] = []
+        for p in prompts:
+            if isinstance(p, str):
+                prompt_images.append(None)
+                preprocessed_images.append(None)
+                continue
+            ai = p.get("additional_information") or {}
+            prompt_images.append(ai.get("prompt_image"))
+            preprocessed_images.append(ai.get("preprocessed_image"))
+        return prompt_images, preprocessed_images
+
+    def forward(self, req: DiffusionRequestBatch) -> DiffusionOutput:
+        # Prompt / negative-prompt extraction (mirrors the Ovis pattern; the
+        # online API sometimes passes ``{"negative_prompt": None}``).
+        prompt = [p if isinstance(p, str) else (p.get("prompt") or "") for p in req.prompts]
+        if all(isinstance(p, str) or p.get("negative_prompt") is None for p in req.prompts):
+            negative_prompt = None
+        else:
+            negative_prompt = ["" if isinstance(p, str) else (p.get("negative_prompt") or "") for p in req.prompts]
+
+        # Reference (edit / TI2I) images, if any.
+        prompt_images, preprocessed_images = self._extract_reference_images(req.prompts)
+        has_reference = any(img is not None for img in preprocessed_images)
+        task_type = "ti2i" if has_reference else "t2i"
+
+        sp = req.sampling_params
+        device = self._execution_device
+
+        height = sp.height or self.default_sample_size * self.vae_scale_factor
+        width = sp.width or self.default_sample_size * self.vae_scale_factor
+        num_inference_steps = sp.num_inference_steps or 50
+        # Upstream default text guidance is 4.0; the engine coerces an unset
+        # guidance_scale to 1.0, so only honor a caller-provided value.
+        text_guidance_scale = sp.guidance_scale if sp.guidance_scale_provided else 4.0
+        # Image guidance rides on ``guidance_scale_2`` (upstream default 1.0 =
+        # off); only a caller-provided value enables the double-guidance path.
+        image_guidance_scale = sp.guidance_scale_2 if sp.guidance_scale_2_provided else 1.0
+        if not has_reference:
+            image_guidance_scale = 1.0
+        num_images_per_prompt = sp.num_outputs_per_prompt if sp.num_outputs_per_prompt > 0 else 1
+        generator = sp.generator
+        max_sequence_length = sp.max_sequence_length or 1280
+        output_type = sp.output_type or "pil"
+        cfg_range = (0.0, 1.0)
+
+        # Negative instruction embeddings are needed whenever text guidance is
+        # active (t2i text CFG, ti2i text-only, and ti2i double guidance).
+        do_classifier_free_guidance = text_guidance_scale > 1.0
+
+        batch_size = len(prompt)
+
+        # Per-sample VLM reference images for the positive instruction only
+        # (upstream default ``use_input_images_4_neg_instruct=False``).
+        input_images = None
+        if has_reference:
+            input_images = [[img] if img is not None else None for img in prompt_images]
+
+        # 1. Encode prompts.
+        (
+            instruction_embeds,
+            instruction_attention_mask,
+            negative_instruction_embeds,
+            negative_instruction_attention_mask,
+        ) = self.encode_prompt(
+            prompt,
+            do_classifier_free_guidance=do_classifier_free_guidance,
+            negative_prompt=negative_prompt,
+            num_images_per_prompt=num_images_per_prompt,
+            device=device,
+            max_sequence_length=max_sequence_length,
+            input_images=input_images,
+        )
+
+        # 2. Resolve working / output resolution.
+        height, width, ori_height, ori_width = self._resolve_output_size(height, width)
+
+        # 3. Reference latents (edit path) and initial noise latents.
+        dtype = self.vae.dtype
+        latent_channels = self.transformer.in_channels
+        ref_latents = None
+        if has_reference:
+            ref_latents = self._build_ref_latents(preprocessed_images, num_images_per_prompt, device, generator)
+
+        latents = self.prepare_latents(
+            batch_size * num_images_per_prompt,
+            latent_channels,
+            height,
+            width,
+            instruction_embeds.dtype,
+            device,
+            generator,
+        )
+
+        freqs_cis = BooguImageDoubleStreamRotaryPosEmbed.get_freqs_cis(
+            self.transformer.axes_dim_rope,
+            self.transformer.axes_lens,
+            theta=10000,
+        )
+
+        # 4. Timesteps (the ported scheduler consumes ``num_tokens``).
+        num_tokens = latents.shape[-2] * latents.shape[-1]
+        self.scheduler.set_timesteps(num_inference_steps, device=device, num_tokens=num_tokens)
+        timesteps = self.scheduler.timesteps
+        num_timesteps = len(timesteps)
+
+        # 5. Denoise loop with (sequential) classifier-free guidance. Reproduces
+        # the branch priority of upstream ``processing`` (double > text-only >
+        # image-only > t2i text). Reference latents are kept in the conditional
+        # (and, for text-only ti2i, the unconditional) predictions.
+        with self.progress_bar(total=num_timesteps) as progress_bar:
+            for i, t in enumerate(timesteps):
+                in_cfg_range = cfg_range[0] <= i / num_timesteps <= cfg_range[1]
+                text_gs = text_guidance_scale if in_cfg_range else 1.0
+                image_gs = image_guidance_scale if in_cfg_range else 1.0
+
+                model_pred = self.predict(
+                    t, latents, instruction_embeds, freqs_cis, instruction_attention_mask, ref_latents
+                )
+
+                if task_type == "ti2i" and text_gs > 1.0 and image_gs > 1.0:
+                    # Double guidance: 3 predictions (cond+ref, neg+ref, neg+no-ref).
+                    model_pred_drop_text = self.predict(
+                        t,
+                        latents,
+                        negative_instruction_embeds,
+                        freqs_cis,
+                        negative_instruction_attention_mask,
+                        ref_latents,
+                    )
+                    model_pred_drop_all = self.predict(
+                        t,
+                        latents,
+                        negative_instruction_embeds,
+                        freqs_cis,
+                        negative_instruction_attention_mask,
+                        None,
+                    )
+                    delta_text = model_pred - model_pred_drop_text
+                    delta_image = model_pred_drop_text - model_pred_drop_all
+                    model_pred = model_pred + (text_gs - 1) * delta_text + (image_gs - 1) * delta_image
+                elif task_type == "ti2i" and text_gs > 1.0:
+                    # Text-only ti2i guidance: reference kept in the uncond pred.
+                    model_pred_drop_text = self.predict(
+                        t,
+                        latents,
+                        negative_instruction_embeds,
+                        freqs_cis,
+                        negative_instruction_attention_mask,
+                        ref_latents,
+                    )
+                    model_pred = model_pred + (text_gs - 1) * (model_pred - model_pred_drop_text)
+                elif task_type == "ti2i" and image_gs > 1.0:
+                    # Image-only ti2i guidance: drop the reference in the uncond pred.
+                    model_pred_drop_image = self.predict(
+                        t, latents, instruction_embeds, freqs_cis, instruction_attention_mask, None
+                    )
+                    model_pred = model_pred + (image_gs - 1) * (model_pred - model_pred_drop_image)
+                elif text_gs > 1.0:
+                    # Text-to-image classifier-free guidance.
+                    model_pred_drop_all = self.predict(
+                        t,
+                        latents,
+                        negative_instruction_embeds,
+                        freqs_cis,
+                        negative_instruction_attention_mask,
+                        None,
+                    )
+                    model_pred = model_pred + (text_gs - 1) * (model_pred - model_pred_drop_all)
+
+                latents = self.scheduler.step(model_pred, t, latents, return_dict=False)[0]
+                latents = latents.to(dtype=instruction_embeds.dtype)
+                progress_bar.update()
+
+        # 6. Decode.
+        if output_type == "latent":
+            image = latents
+        else:
+            latents = latents.to(dtype=dtype)
+            if self.vae.config.scaling_factor is not None:
+                latents = latents / self.vae.config.scaling_factor
+            if self.vae.config.shift_factor is not None:
+                latents = latents + self.vae.config.shift_factor
+            image = self.vae.decode(latents, return_dict=False)[0]
+            if (ori_height, ori_width) != (height, width):
+                image = F.interpolate(image, size=(ori_height, ori_width), mode="bilinear")
+
+        return DiffusionOutput(output=image)
diff --git a/vllm_omni/diffusion/models/boogu_image/scheduling_flow_match_euler_discrete_time_shifting.py b/vllm_omni/diffusion/models/boogu_image/scheduling_flow_match_euler_discrete_time_shifting.py
new file mode 100644
index 000000000..656594221
--- /dev/null
+++ b/vllm_omni/diffusion/models/boogu_image/scheduling_flow_match_euler_discrete_time_shifting.py
@@ -0,0 +1,318 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Ported for vLLM-Omni native Boogu-Image support from
+# boogu/schedulers/scheduling_flow_match_euler_discrete_time_shifting.py
+# (https://github.com/boogu-project/Boogu-Image). The scheduling logic is
+# kept verbatim; only debug comments were removed and typing modernized.
+#
+# --- Upstream header preserved below ---
+#
+# Copyright (C) 2026 Boogu Team.
+#
+# This file is adapted by Boogu Team from prior open-source scheduler work.
+# Boogu-specific modifications include static/dynamic time-shift handling used
+# by the released Boogu pipeline.
+#
+# Original work:
+# Copyright 2024 Stability AI, Katherine Crowson and The HuggingFace Team.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, logging
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class FlowMatchEulerDiscreteSchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+
+
+class FlowMatchEulerDiscreteScheduler(SchedulerMixin, ConfigMixin):
+    """
+    Euler scheduler with Boogu's training-consistent time shifting.
+
+    Timesteps run ascending 0 -> 1 (not descending sigmas as in stock
+    diffusers), `set_timesteps` accepts a `num_tokens` argument for the
+    dynamic-shift variants, and `step()` integrates with `t_next - t`
+    directly.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        do_shift (`bool`, defaults to `True`):
+            Whether to apply the training-consistent time shift in `set_timesteps`.
+        dynamic_time_shift (`bool`, defaults to `True`):
+            If `True`, the shift depends on the per-sample `num_tokens`; if `False`, it uses the configured `seq_len`.
+        time_shift_version (`str`, defaults to `"v2"`):
+            `"v1"` (logistic transform with a linear mu mapping) or `"v2"` (rational transform).
+        seq_len (`int`, *optional*):
+            Token count used to compute the static shift when `dynamic_time_shift=False` (mirrors training).
+        base_shift (`float`, defaults to 0.5):
+            v1 linear mapping lower bound (matches training defaults).
+        max_shift (`float`, defaults to 1.15):
+            v1 linear mapping upper bound (matches training defaults).
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        do_shift: bool = True,
+        dynamic_time_shift: bool = True,
+        time_shift_version: str = "v2",
+        # seq_len is used to mirror training-side static time shift (when dynamic_time_shift=False)
+        # In training, seq_len is the token count used to compute shift.
+        seq_len: int | None = None,
+        # v1 linear mapping range (matches training defaults)
+        base_shift: float = 0.5,
+        max_shift: float = 1.15,
+        time_shift_v2_half_scaling_factor: float = 60.0,
+    ):
+        timesteps = torch.linspace(0, 1, num_train_timesteps + 1, dtype=torch.float32)[:-1]
+
+        self.timesteps = timesteps
+
+        self._step_index = None
+        self._begin_index = None
+        self.time_shift_v2_scaling_factor = time_shift_v2_half_scaling_factor * 2
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self._timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    # --- Helpers to mirror training-side shift logic ---
+    @staticmethod
+    def _get_lin_function(x1: float = 256, y1: float = 0.5, x2: float = 4096, y2: float = 1.15):
+        m = (y2 - y1) / (x2 - x1)
+        b = y1 - m * x1
+        return lambda x: m * x + b
+
+    @staticmethod
+    def _time_shift_v1(t_np: np.ndarray, mu: float, sigma: float = 1.0) -> np.ndarray:
+        # Matches training: t <- 1 - t; logistic transform; then t <- 1 - t
+        eps = 1e-8
+        t1 = 1.0 - t_np
+        t1 = np.clip(t1, eps, 1.0 - eps)
+        num = math.exp(mu)
+        denom = num + np.power(1.0 / t1 - 1.0, sigma)
+        y = num / denom
+        out = 1.0 - y
+        return out.astype(np.float32)
+
+    @staticmethod
+    def _time_shift_v2(t_np: np.ndarray, m: float) -> np.ndarray:
+        # Matches training: t' = t / (m - m t + t)
+        return (t_np / (m - m * t_np + t_np)).astype(np.float32)
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int | None = None,
+        device: str | torch.device | None = None,
+        timesteps: list[float] | None = None,
+        num_tokens: int | None = None,
+    ):
+        """
+        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
+
+        Args:
+            num_inference_steps (`int`):
+                The number of diffusion steps used when generating samples with a pre-trained model.
+            device (`str` or `torch.device`, *optional*):
+                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+            timesteps (`list[float]`, *optional*):
+                Custom timesteps to use. If provided, `num_inference_steps` is ignored.
+            num_tokens (`int`, *optional*):
+                Per-sample token count, used by the dynamic time-shift variants.
+        """
+
+        if timesteps is None:
+            self.num_inference_steps = num_inference_steps
+            t_arr = np.linspace(0, 1, num_inference_steps + 1, dtype=np.float32)[:-1]
+
+            # Apply training-consistent time shift only when requested
+            if self.config.do_shift:
+                # dynamic or static
+                if self.config.dynamic_time_shift:
+                    # dynamic: depend on per-sample token count
+                    if self.config.time_shift_version == "v1":
+                        # In training dynamic v1: mu is computed from tokens' linear map where
+                        # tokens are approximately (H_lat//2)*(W_lat//2). We approximate this with num_tokens//4.
+                        if num_tokens is not None and num_tokens > 0:
+                            tokens_reduced = max(1, int(num_tokens) // 4)
+                            lin = self._get_lin_function(y1=self.config.base_shift, y2=self.config.max_shift)
+                            mu = lin(tokens_reduced)  ## 4096 for 1024x1024 resolution
+
+                            t_arr = self._time_shift_v1(t_arr, mu, sigma=1.0)
+                        # else: no-op if we lack num_tokens
+                    elif self.config.time_shift_version == "v2":
+                        # MUST remain identical to current behavior when v2 + dynamic=True
+                        # m = sqrt(num_tokens) / 40; t' = t / (m - m t + t)
+                        # When input resolution is 320 * 320, m = 1, when input resolution is 512 * 512,
+                        # m = 1.6, when input resolution is 1024 * 1024, m = 3.2
+                        if num_tokens is not None and num_tokens > 0:
+                            m = float(np.sqrt(num_tokens)) / self.time_shift_v2_scaling_factor
+                            t_arr = self._time_shift_v2(t_arr, m)
+                        # else: no-op
+                else:
+                    # static: depend on seq_len configured at scheduler init
+                    if self.config.time_shift_version == "v1":
+                        if self.config.seq_len is not None and self.config.seq_len > 0:
+                            lin = self._get_lin_function(y1=self.config.base_shift, y2=self.config.max_shift)
+                            mu = lin(int(self.config.seq_len))
+                            t_arr = self._time_shift_v1(t_arr, mu, sigma=1.0)
+                    elif self.config.time_shift_version == "v2":
+                        if self.config.seq_len is not None and self.config.seq_len > 0:
+                            # training static v2 uses m = sqrt(seq_len) / 40
+                            m = float(np.sqrt(self.config.seq_len)) / self.time_shift_v2_scaling_factor
+                            t_arr = self._time_shift_v2(t_arr, m)
+
+            timesteps = t_arr
+
+        timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32, device=device)
+        _timesteps = torch.cat([timesteps, torch.ones(1, device=timesteps.device)])
+
+        self.timesteps = timesteps
+        self._timesteps = _timesteps
+        self._step_index = None
+        self._begin_index = None
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        sample: torch.FloatTensor,
+        generator: torch.Generator | None = None,  # noqa: ARG002 - kept for API compatibility
+        return_dict: bool = True,
+    ) -> FlowMatchEulerDiscreteSchedulerOutput | tuple:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            return_dict (`bool`):
+                Whether or not to return a [`FlowMatchEulerDiscreteSchedulerOutput`] or tuple.
+
+        Returns:
+            [`FlowMatchEulerDiscreteSchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`FlowMatchEulerDiscreteSchedulerOutput`] is returned, otherwise a tuple is
+                returned where the first element is the sample tensor.
+        """
+
+        if isinstance(timestep, int) or isinstance(timestep, torch.IntTensor) or isinstance(timestep, torch.LongTensor):
+            raise ValueError(
+                (
+                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                    " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                    " one of the `scheduler.timesteps` as a timestep."
+                ),
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+        t = self._timesteps[self.step_index]
+        t_next = self._timesteps[self.step_index + 1]
+
+        prev_sample = sample + (t_next - t) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return FlowMatchEulerDiscreteSchedulerOutput(prev_sample=prev_sample)
+
+    def __len__(self):
+        return self.config.num_train_timesteps
diff --git a/vllm_omni/diffusion/models/cosmos3/__init__.py b/vllm_omni/diffusion/models/cosmos3/__init__.py
index 6df062b5c..af4eeaacf 100644
--- a/vllm_omni/diffusion/models/cosmos3/__init__.py
+++ b/vllm_omni/diffusion/models/cosmos3/__init__.py
@@ -7,10 +7,12 @@ from .pipeline_cosmos3 import (
     get_cosmos3_pre_process_func,
 )
 from .transformer_cosmos3 import Cosmos3VFMTransformer
+from .transformer_cosmos3_edge import Cosmos3EdgeVFMTransformer
 
 __all__ = [
     "Cosmos3OmniDiffusersPipeline",
     "get_cosmos3_post_process_func",
     "get_cosmos3_pre_process_func",
     "Cosmos3VFMTransformer",
+    "Cosmos3EdgeVFMTransformer",
 ]
diff --git a/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py b/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py
index 5d0e24789..fcc2a8b6c 100644
--- a/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py
+++ b/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py
@@ -29,6 +29,7 @@ is produced from sound latents rather than from ``multi_modal_data["audio"]``.
 
 from __future__ import annotations
 
+import json
 import math
 import os
 import time
@@ -39,7 +40,6 @@ from typing import Any, ClassVar
 import numpy as np
 import PIL.Image
 import torch
-from diffusers import UniPCMultistepScheduler
 from diffusers.utils.torch_utils import randn_tensor
 from diffusers.video_processor import VideoProcessor
 from torch import nn
@@ -61,6 +61,12 @@ from vllm_omni.diffusion.models.interface import (
     SupportsComponentDiscovery,
 )
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin, _is_rank_zero
+from vllm_omni.diffusion.models.schedulers.scheduling_flow_match_euler_discrete import (
+    FlowMatchEulerDiscreteScheduler,
+)
+from vllm_omni.diffusion.models.schedulers.scheduling_flow_unipc_multistep import (
+    FlowUniPCMultistepScheduler,
+)
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
@@ -94,7 +100,8 @@ from .transfer import (
     transfer_max_frames_from_extra_args,
     uint8_cthw_to_normalized_5d,
 )
-from .transformer_cosmos3 import Cosmos3VFMTransformer, resolve_sound_gen
+from .transformer_cosmos3 import Cosmos3VFMTransformer, _tf_config_get, resolve_sound_gen
+from .transformer_cosmos3_edge import COSMOS3_EDGE_BACKBONE_TYPE, Cosmos3EdgeVFMTransformer
 from .utils import (
     COSMOS3_DEFAULT_CONDITION_FRAME_INDEXES_VISION,
     COSMOS3_VAE_TEMPORAL_COMPRESSION,
@@ -154,6 +161,7 @@ COSMOS3_T2V_DEFAULT_WIDTH = 1280
 COSMOS3_T2V_DEFAULT_NUM_FRAMES = 189
 COSMOS3_T2V_DEFAULT_NUM_INFERENCE_STEPS = 35
 COSMOS3_T2V_DEFAULT_GUIDANCE_SCALE = 6.0
+COSMOS3_VIDEO_DEFAULT_FLOW_SHIFT = 10.0
 
 COSMOS3_T2I_DEFAULT_HEIGHT = 1024
 COSMOS3_T2I_DEFAULT_WIDTH = 1024
@@ -162,12 +170,73 @@ COSMOS3_T2I_DEFAULT_GUIDANCE_SCALE = 7.0
 COSMOS3_T2I_DEFAULT_FLOW_SHIFT = 3.0
 COSMOS3_T2I_DEFAULT_GUIDANCE_INTERVAL: tuple[float, float] = (400.0, 1000.0)
 
+COSMOS3_EDGE_T2V_DEFAULT_HEIGHT = 480
+COSMOS3_EDGE_T2V_DEFAULT_WIDTH = 832
+COSMOS3_EDGE_T2V_DEFAULT_GUIDANCE_SCALE = 5.0
+COSMOS3_EDGE_VIDEO_DEFAULT_FLOW_SHIFT = 3.0
+COSMOS3_EDGE_T2I_DEFAULT_HEIGHT = 640
+COSMOS3_EDGE_T2I_DEFAULT_WIDTH = 640
+
+COSMOS3_DISTILLED_CHECKPOINT_SCHEDULER_CLASS = "FlowMatchEulerDiscreteScheduler"
+
 # Truncation cap on the prompt token count (shared by T2I and T2V).  Prompts
 # are tokenized to their natural length (no padding); this only bounds the
 # UND pathway / GEN cross-attention cost for pathologically long prompts.
 COSMOS3_DEFAULT_MAX_SEQUENCE_LENGTH = 4096
 
 
+def _ceil_video_num_frames(num_frames: int, temporal_compression_factor: int) -> int:
+    """Round a video length up to the causal VAE's ``factor * k + 1`` grid."""
+    if temporal_compression_factor <= 0:
+        raise ValueError(f"Cosmos3 temporal_compression_factor must be positive, got {temporal_compression_factor}.")
+    if num_frames <= 1:
+        return num_frames
+    latent_frames = math.ceil((num_frames - 1) / temporal_compression_factor)
+    return latent_frames * temporal_compression_factor + 1
+
+
+def _format_json_object_prompt(
+    prompt: str,
+    *,
+    num_frames: int,
+    frame_rate: float,
+    height: int,
+    width: int,
+    aspect_ratio: str | None,
+) -> str | None:
+    """Match Imaginaire4 metadata injection for JSON-object prompts."""
+    try:
+        prompt_obj = json.loads(prompt)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return None
+    if not isinstance(prompt_obj, dict):
+        return None
+
+    metadata: dict[str, Any] = {}
+    if num_frames > 1:
+        duration_seconds = int(num_frames / frame_rate) if frame_rate > 0 else 0
+        metadata.update({"duration": f"{duration_seconds}s", "fps": float(frame_rate)})
+    else:
+        prompt_obj.pop("duration", None)
+        prompt_obj.pop("fps", None)
+    metadata["resolution"] = {"H": int(height), "W": int(width)}
+    if aspect_ratio is not None:
+        metadata["aspect_ratio"] = aspect_ratio
+
+    prompt_obj.update(metadata)
+    return json.dumps(prompt_obj)
+
+
+def resolve_cosmos3_transformer_cls(model_config: Any) -> type[Cosmos3VFMTransformer]:
+    """Select the Cosmos3 transformer implementation from transformer/config.json."""
+    backbone_type = _tf_config_get(model_config, "backbone_type", None)
+    if backbone_type is None:
+        return Cosmos3VFMTransformer
+    if backbone_type == COSMOS3_EDGE_BACKBONE_TYPE:
+        return Cosmos3EdgeVFMTransformer
+    raise ValueError(f"Unsupported Cosmos3 transformer backbone_type={backbone_type!r}.")
+
+
 # ---------------------------------------------------------------------------
 # Post-process function (registered in registry.py)
 # ---------------------------------------------------------------------------
@@ -190,6 +259,9 @@ def get_cosmos3_pre_process_func(od_config: OmniDiffusionConfig):
     from .guardrails import check_text_safety, ensure_initialized, is_guardrails_enabled
 
     video_processor = VideoProcessor(vae_scale_factor=16)
+    is_edge_model = (
+        _tf_config_get(getattr(od_config, "tf_model_config", None), "backbone_type", None) == COSMOS3_EDGE_BACKBONE_TYPE
+    )
     # Eager-load guardrail models at pipeline build time when the server-level
     # gate is on. Per-request overrides only decide whether the loaded models
     # are *invoked* — they cannot turn checks on without a server-side preload.
@@ -410,12 +482,17 @@ def get_cosmos3_pre_process_func(od_config: OmniDiffusionConfig):
         extra = _extra_args(request)
         transfer_requested = action_mode is None and has_transfer_hints(extra)
 
-        # Auto-calculate H/W from aspect ratio (720p max area)
+        # Resolve missing H/W.
         if transfer_requested:
             _set_transfer_size_from_image(request, image)
         elif request.sampling_params.height is None or request.sampling_params.width is None:
             if action_mode is not None:
                 _set_action_size_from_image(request, image)
+            elif is_edge_model:
+                if request.sampling_params.height is None:
+                    request.sampling_params.height = COSMOS3_EDGE_T2V_DEFAULT_HEIGHT
+                if request.sampling_params.width is None:
+                    request.sampling_params.width = COSMOS3_EDGE_T2V_DEFAULT_WIDTH
             else:
                 max_area = 720 * 1280
                 aspect_ratio = image.height / image.width
@@ -823,27 +900,52 @@ class Cosmos3OmniDiffusersPipeline(
             sound_latent_fps = self._sound_tokenizer.latent_fps
 
         # --- Transformer (weights loaded later via weights_sources) ---
-        self.transformer = Cosmos3VFMTransformer(
+        transformer_cls = resolve_cosmos3_transformer_cls(od_config.tf_model_config)
+        self.transformer = transformer_cls(
             od_config=od_config,
             temporal_compression_factor=self.vae_scale_factor_temporal,
             sound_gen=sound_gen,
             sound_dim=sound_dim,
             sound_latent_fps=sound_latent_fps,
         )
+        self.is_edge_model = transformer_cls is Cosmos3EdgeVFMTransformer
 
         # --- Scheduler ---
-        # Load from checkpoint to preserve solver_order, timestep_spacing,
-        # beta_schedule, sigma bounds, flow_shift, etc. Only override
-        # flow_shift when explicitly requested by the user.
-        self.scheduler = UniPCMultistepScheduler.from_pretrained(
+        # Distilled model differs from regular one only by scheduler,
+        # distilled one uses FlowMatchEulerDiscreteScheduler, while
+        # regular should use FlowUniPCMultistepScheduler
+
+        scheduler_config = FlowUniPCMultistepScheduler.load_config(
             model_path,
             subfolder="scheduler",
             local_files_only=local_files_only,
         )
-        if od_config.flow_shift is not None:
-            self.scheduler = UniPCMultistepScheduler.from_config(
-                self.scheduler.config,
-                flow_shift=od_config.flow_shift,
+
+        scheduler_class_name = scheduler_config.get("_class_name")
+
+        self.is_distilled_model = False
+        if scheduler_class_name == COSMOS3_DISTILLED_CHECKPOINT_SCHEDULER_CLASS:
+            fixed_step_config = scheduler_config.get("fixed_step_sampler_config")
+            if not isinstance(fixed_step_config, dict) or fixed_step_config.get("sample_type") != "sde":
+                raise ValueError("Cosmos3 distilled scheduler requires fixed_step_sampler_config.sample_type=sde.")
+            t_list = fixed_step_config.get("t_list")
+            if not isinstance(t_list, list) or not t_list:
+                raise ValueError("Cosmos3 distilled scheduler requires a non-empty fixed_step_sampler_config.t_list.")
+            self.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
+                scheduler_config,
+                stochastic_sampling=True,
+            )
+            self._scheduler_init_t_list = list(t_list)
+            self.is_distilled_model = True
+        else:
+            # Preserve compatible solver settings from the checkpoint, but keep
+            # the base shift neutral. The concrete request shift is applied when
+            # FlowUniPC builds its timesteps.
+            self.scheduler = FlowUniPCMultistepScheduler.from_config(
+                scheduler_config,
+                shift=1.0,
+                use_dynamic_shifting=False,
+                prediction_type="flow_prediction",
             )
         self._cpu_scheduler_state()
 
@@ -854,22 +956,23 @@ class Cosmos3OmniDiffusersPipeline(
         self.weights_sources = [
             DiffusersPipelineLoader.ComponentSource(
                 model_or_path=model_path,
-                subfolder=None,
+                subfolder="transformer",
                 revision=None,
                 prefix="transformer.",
                 fall_back_to_pt=True,
-                allow_patterns_overrides=["transformer/*.safetensors"],
             ),
         ]
 
-        # Snapshot the loaded scheduler config so we can rebuild the
-        # scheduler at request time when a per-request flow_shift override
-        # is supplied (T2I uses shift=3.0; T2V/I2V use the engine default).
-        self._base_scheduler_config = self.scheduler.config
-        self._engine_init_flow_shift = float(getattr(self.scheduler.config, "flow_shift", 1.0) or 1.0)
+        # An engine-level override becomes the video default; otherwise use
+        # the matching regular/Edge default. Per-request values still take
+        # precedence.
+        default_video_flow_shift = (
+            COSMOS3_EDGE_VIDEO_DEFAULT_FLOW_SHIFT if self.is_edge_model else COSMOS3_VIDEO_DEFAULT_FLOW_SHIFT
+        )
+        self._engine_init_flow_shift = float(
+            od_config.flow_shift if od_config.flow_shift is not None else default_video_flow_shift
+        )
         self._current_flow_shift = self._engine_init_flow_shift
-        self._base_scheduler_use_karras_sigmas = self._scheduler_use_karras_sigmas(self.scheduler.config)
-        self._current_scheduler_use_karras_sigmas = self._base_scheduler_use_karras_sigmas
 
         self._guidance_scale = None
         self._num_timesteps = None
@@ -989,6 +1092,7 @@ class Cosmos3OmniDiffusersPipeline(
             "self_attn.to_out.": f"{und_lp}.self_attn.to_out.",
             "self_attn.norm_q.": f"{und_lp}.self_attn.norm_q.",
             "self_attn.norm_k.": f"{und_lp}.self_attn.norm_k.",
+            "self_attn.k_norm_und_for_gen.": f"{und_lp}.self_attn.k_norm_und_for_gen.",
             # GEN attention
             "self_attn.add_q_proj.": f"{gen_lp}.cross_attention.to_q.",
             "self_attn.add_k_proj.": f"{gen_lp}.cross_attention.to_k.",
@@ -1054,6 +1158,7 @@ class Cosmos3OmniDiffusersPipeline(
         loaded = loader.load_weights(_remapped_weights())
         self.transformer.post_load_weights()
         self.transformer.eval()
+        self.transformer.validate_loaded_weights(loaded)
         if getattr(self.transformer, "sound_gen", False):
             sound_markers = ("audio_proj_in.", "audio_proj_out.", "audio_modality_embed")
             missing = [marker.rstrip(".") for marker in sound_markers if not any(marker in name for name in loaded)]
@@ -1359,6 +1464,8 @@ class Cosmos3OmniDiffusersPipeline(
         inputs: RoboLabPolicyInputs,
         pipeline_start: float,
     ) -> DiffusionOutput:
+        if self.is_distilled_model:
+            raise self._distilled_unsupported_error("RoboLab/action policy requests are unsupported.")
         if not getattr(self.transformer, "action_gen", False):
             raise ValueError(
                 "Cosmos3 RoboLab policy serving was requested, but the transformer "
@@ -1469,6 +1576,7 @@ class Cosmos3OmniDiffusersPipeline(
             guidance_interval=None,
             raw_action_dim=raw_action_dim,
             scheduler=scheduler,
+            generator=generator,
         )
 
         if _is_rank_zero():
@@ -1560,38 +1668,34 @@ class Cosmos3OmniDiffusersPipeline(
             raise ValueError(f"Incorrect modality value in {modalities}, expected one of {accepted_modalities}.")
         return "image" in modalities
 
+    def _set_timesteps(self, num_inference_steps: int, device: str | torch.device, shift: float) -> None:
+        if self.is_distilled_model:
+            self.scheduler.set_timesteps(sigmas=self._scheduler_init_t_list, device=device)
+        else:
+            self.scheduler.set_timesteps(
+                num_inference_steps,
+                device=device,
+                shift=shift,
+            )
+
+    def _set_flow_shift(self, target_shift: float) -> None:
+        """Select the shift applied by FlowUniPC when timesteps are built."""
+        self._current_flow_shift = float(target_shift)
+
     @staticmethod
-    def _scheduler_use_karras_sigmas(config: Any) -> bool | None:
-        value = getattr(config, "use_karras_sigmas", None)
-        return None if value is None else bool(value)
+    def _resolve_seed(sp: OmniDiffusionSamplingParams, generator: torch.Generator | None, default: int = 42) -> int:
+        if sp.seed is not None:
+            return int(sp.seed)
+        if isinstance(generator, torch.Generator):
+            return int(generator.initial_seed())
+        return int(default)
 
-    def _set_flow_shift(self, target_shift: float, *, use_karras_sigmas: bool | None = None) -> None:
-        """Set UniPC scheduler mode for a concrete request.
-
-        The scheduler is rebuilt from the saved base config if
-        the target differs from the current shift or Karras-sigma mode.
-        Tracking explicit scheduler state is required because the previous
-        mode may have rebuilt the scheduler - we cannot rely on
-        ``self.scheduler.config`` reflecting the last requested target if a
-        rebuild was skipped via the equality check.
-        """
-        target = float(target_shift)
-        target_use_karras_sigmas = (
-            self._base_scheduler_use_karras_sigmas if use_karras_sigmas is None else bool(use_karras_sigmas)
-        )
-        if (
-            target == float(self._current_flow_shift)
-            and target_use_karras_sigmas == self._current_scheduler_use_karras_sigmas
-        ):
-            return
-
-        scheduler_kwargs: dict[str, Any] = {"flow_shift": target}
-        if use_karras_sigmas is not None:
-            scheduler_kwargs["use_karras_sigmas"] = bool(use_karras_sigmas)
-        self.scheduler = UniPCMultistepScheduler.from_config(self._base_scheduler_config, **scheduler_kwargs)
-        self._cpu_scheduler_state()
-        self._current_flow_shift = target
-        self._current_scheduler_use_karras_sigmas = self._scheduler_use_karras_sigmas(self.scheduler.config)
+    def _resolve_guidance_scale(self, sp: OmniDiffusionSamplingParams, default: float) -> float:
+        if self.is_distilled_model:
+            return 1.0
+        if sp.guidance_scale_provided:
+            return float(sp.guidance_scale)
+        return float(default)
 
     def _cpu_scheduler_state(self) -> None:
         # We need to move scheduler tensors to CPU, as unipc from diffusers assumes they are on CPU.
@@ -1612,6 +1716,53 @@ class Cosmos3OmniDiffusersPipeline(
     def num_timesteps(self):
         return self._num_timesteps
 
+    @staticmethod
+    def _distilled_unsupported_error(detail: str) -> ValueError:
+        return ValueError(
+            f"Cosmos3 distilled checkpoints support only text-to-image and image-to-video generation; {detail}"
+        )
+
+    def _validate_distilled_generation_mode(
+        self,
+        *,
+        is_t2i: bool,
+        image_tensor: torch.Tensor | None,
+        action_enabled: bool,
+        transfer_config: Cosmos3TransferConfig | None,
+        is_v2v: bool,
+        sound_enabled: bool,
+    ) -> None:
+        if not self.is_distilled_model:
+            return
+        if action_enabled:
+            raise self._distilled_unsupported_error("action requests are unsupported.")
+        if transfer_config is not None:
+            raise self._distilled_unsupported_error("transfer requests are unsupported.")
+        if is_v2v:
+            raise self._distilled_unsupported_error("video-to-video requests are unsupported.")
+        if sound_enabled:
+            raise self._distilled_unsupported_error("sound generation is unsupported.")
+        if not is_t2i and image_tensor is None:
+            raise self._distilled_unsupported_error("text-to-video requests are unsupported.")
+        if is_t2i and image_tensor is not None:
+            raise self._distilled_unsupported_error("image-conditioned image generation is unsupported.")
+
+    def _validate_edge_generation_mode(
+        self,
+        *,
+        transfer_config: Cosmos3TransferConfig | None,
+        is_v2v: bool,
+        sound_enabled: bool,
+    ) -> None:
+        if not self.is_edge_model:
+            return
+        if sound_enabled:
+            raise ValueError("Cosmos3 Edge checkpoints do not support sound generation.")
+        if transfer_config is not None:
+            raise ValueError("Cosmos3 Edge checkpoints do not support transfer inference.")
+        if is_v2v:
+            raise ValueError("Cosmos3 Edge checkpoints do not support video-to-video generation.")
+
     # -- Prompt formatting -----------------------------------------------------
 
     @staticmethod
@@ -1628,6 +1779,10 @@ class Cosmos3OmniDiffusersPipeline(
         """
         Append duration and resolution metadata to a prompt.
         """
+        prompt = prompt.strip()
+        if duration_template is None and resolution_template is None:
+            return prompt
+
         parts: list[str] = []
         head = prompt.rstrip(".").strip()
         if head:
@@ -1903,15 +2058,26 @@ class Cosmos3OmniDiffusersPipeline(
             res_tmpl = COSMOS3_IMAGE_RESOLUTION_TEMPLATE if is_t2i else COSMOS3_RESOLUTION_TEMPLATE
         else:
             res_tmpl = None
-        prompt = self._apply_metadata_templates(
+        json_prompt = _format_json_object_prompt(
             prompt,
-            num_frames,
-            frame_rate,
-            height,
-            width,
-            duration_template=dur_tmpl,
-            resolution_template=res_tmpl,
+            num_frames=num_frames,
+            frame_rate=frame_rate,
+            height=height,
+            width=width,
+            aspect_ratio=self._get_sp_param(sp, "aspect_ratio", None),
         )
+        if json_prompt is not None:
+            prompt = json_prompt
+        else:
+            prompt = self._apply_metadata_templates(
+                prompt,
+                num_frames,
+                frame_rate,
+                height,
+                width,
+                duration_template=dur_tmpl,
+                resolution_template=res_tmpl,
+            )
         if _is_rank_zero():
             logger.info("Final prompt: '%s'", prompt)
 
@@ -2272,6 +2438,7 @@ class Cosmos3OmniDiffusersPipeline(
         guidance_interval: tuple[float, float] | None = None,
         raw_action_dim: int | None = None,
         scheduler: Any | None = None,
+        generator: torch.Generator | None = None,
     ) -> torch.Tensor | tuple[torch.Tensor, ...]:
         """Denoising loop with 3-mode CFG support (parallel, sequential, none).
 
@@ -2383,11 +2550,23 @@ class Cosmos3OmniDiffusersPipeline(
                 if raw_action_dim is not None and 0 < raw_action_dim < action_pred.shape[-1]:
                     action_pred[..., raw_action_dim:] = 0
             if action_latents is None and sound_latents is None:
-                latents = step_scheduler.step(video_pred, t, latents, return_dict=False)[0]
+                latents = step_scheduler.step(
+                    video_pred,
+                    t,
+                    latents,
+                    generator=generator,
+                    return_dict=False,
+                )[0]
             else:
                 packed_noise, shapes, numels = _pack_joint(video_pred, action_pred, sound_pred)
                 packed_latents, _, _ = _pack_joint(latents, action_latents, sound_latents)
-                packed_next = step_scheduler.step(packed_noise, t, packed_latents, return_dict=False)[0]
+                packed_next = step_scheduler.step(
+                    packed_noise,
+                    t,
+                    packed_latents,
+                    generator=generator,
+                    return_dict=False,
+                )[0]
                 unpacked = _unpack_joint(packed_next, shapes, numels)
                 latents = unpacked[0]
                 idx = 1
@@ -2613,6 +2792,7 @@ class Cosmos3OmniDiffusersPipeline(
         velocity_mask: torch.Tensor,
         condition_latents: torch.Tensor,
         guidance_interval: tuple[float, float] | None = None,
+        generator: torch.Generator | None = None,
     ) -> torch.Tensor:
         def _active_at(t: torch.Tensor, interval: tuple[float, float] | None) -> bool:
             if interval is None:
@@ -2724,7 +2904,13 @@ class Cosmos3OmniDiffusersPipeline(
                 if isinstance(noise_pred, tuple):
                     raise ValueError("Cosmos3 transfer diffusion expects video-only tensor predictions.")
                 noise_pred = noise_pred * velocity_mask
-                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+                latents = self.scheduler.step(
+                    noise_pred,
+                    t,
+                    latents,
+                    generator=generator,
+                    return_dict=False,
+                )[0]
                 latents = velocity_mask * latents + (1.0 - velocity_mask) * condition_latents
         finally:
             self._cosmos3_branch_caches = None
@@ -2741,6 +2927,8 @@ class Cosmos3OmniDiffusersPipeline(
         transfer_video_tensor: torch.Tensor | None,
         transfer_input_fps: float | None,
     ) -> DiffusionOutput:
+        if self.is_distilled_model:
+            raise self._distilled_unsupported_error("transfer requests are unsupported.")
         input_frames = None
         if transfer_video_tensor is not None:
             input_frames = normalized_video_to_uint8_cthw(transfer_video_tensor)
@@ -2806,7 +2994,7 @@ class Cosmos3OmniDiffusersPipeline(
         guidance_scale = (
             float(transfer_config.guidance_scale)
             if transfer_config.guidance_scale is not None
-            else float(sp.guidance_scale or COSMOS3_T2V_DEFAULT_GUIDANCE_SCALE)
+            else self._resolve_guidance_scale(sp, COSMOS3_T2V_DEFAULT_GUIDANCE_SCALE)
         )
         flow_shift_target = float(
             transfer_config.flow_shift
@@ -2821,11 +3009,11 @@ class Cosmos3OmniDiffusersPipeline(
 
         self._guidance_scale = guidance_scale
         self._num_timesteps = num_inference_steps
-        self._set_flow_shift(flow_shift_target, use_karras_sigmas=False)
+        self._set_flow_shift(flow_shift_target)
 
         generator = sp.generator
+        seed = self._resolve_seed(sp, generator)
         if generator is None:
-            seed = sp.seed if sp.seed is not None else 42
             generator = torch.Generator(device=self.device).manual_seed(seed)
 
         cond_ids, cond_mask, uncond_ids, uncond_mask = self._format_and_tokenize_prompts(
@@ -2915,7 +3103,11 @@ class Cosmos3OmniDiffusersPipeline(
                 transfer_share_vision_temporal_positions=transfer_config.share_vision_temporal_positions,
             )
 
-            self.scheduler.set_timesteps(num_inference_steps, device=self.device)
+            self._set_timesteps(
+                num_inference_steps,
+                device=self.device,
+                shift=self._current_flow_shift,
+            )
             latents = self.diffuse_transfer(
                 latents=latents,
                 timesteps=self.scheduler.timesteps,
@@ -2930,6 +3122,7 @@ class Cosmos3OmniDiffusersPipeline(
                 shared_kwargs=shared_kwargs,
                 velocity_mask=velocity_mask,
                 condition_latents=condition_latents,
+                generator=generator,
             )
             output_video = self._decode_latents(latents).clamp(-1, 1)
             previous_output = output_video
@@ -3009,6 +3202,20 @@ class Cosmos3OmniDiffusersPipeline(
         action_enabled = action_mode is not None
         transfer_config = resolve_transfer_config(sp, prompt_data)
         action_video_tensor = video_tensor if action_enabled else None
+        is_v2v = video_tensor is not None and not is_t2i and not action_enabled
+        self._validate_distilled_generation_mode(
+            is_t2i=is_t2i,
+            image_tensor=image_tensor,
+            action_enabled=action_enabled,
+            transfer_config=transfer_config,
+            is_v2v=is_v2v,
+            sound_enabled=sound_enabled,
+        )
+        self._validate_edge_generation_mode(
+            transfer_config=transfer_config,
+            is_v2v=is_v2v,
+            sound_enabled=sound_enabled,
+        )
         if transfer_config is not None:
             if is_t2i:
                 raise ValueError("Cosmos3 transfer inference is supported only for video outputs.")
@@ -3056,31 +3263,36 @@ class Cosmos3OmniDiffusersPipeline(
             raise ValueError("Cosmos3 non-action generation accepts either image or video input, not both.")
         if video_tensor is not None and is_t2i:
             raise ValueError("Cosmos3 video-to-video generation is supported only for video outputs.")
-        is_v2v = video_tensor is not None and not is_t2i and not action_enabled
 
-        # T2I and T2V share the same model + forward path; only defaults
-        # differ:
-        #   T2I: 1024x1024, 50 steps, shift=3.0, guidance_interval=[400, 1000]
-        #   T2V: 720x1280,  35 steps, shift=engine-init, no interval
+        # T2I and T2V share the same model and forward path; their defaults are:
+        #   T2I: regular 1024x1024, Edge 640x640; 50 steps, shift=3.0,
+        #        guidance_interval=[400, 1000]
+        #   T2V: 189 frames and 35 steps; regular guidance=6, shift=10;
+        #        Edge guidance=5, shift=3;
+        #        no guidance interval
         if is_t2i:
-            height = sp.height or COSMOS3_T2I_DEFAULT_HEIGHT
-            width = sp.width or COSMOS3_T2I_DEFAULT_WIDTH
+            height = sp.height or (
+                COSMOS3_EDGE_T2I_DEFAULT_HEIGHT if self.is_edge_model else COSMOS3_T2I_DEFAULT_HEIGHT
+            )
+            width = sp.width or (COSMOS3_EDGE_T2I_DEFAULT_WIDTH if self.is_edge_model else COSMOS3_T2I_DEFAULT_WIDTH)
             num_frames = 1
             num_inference_steps = sp.num_inference_steps or COSMOS3_T2I_DEFAULT_NUM_INFERENCE_STEPS
-            guidance_scale = sp.guidance_scale if sp.guidance_scale else COSMOS3_T2I_DEFAULT_GUIDANCE_SCALE
+            guidance_scale = self._resolve_guidance_scale(sp, COSMOS3_T2I_DEFAULT_GUIDANCE_SCALE)
             default_flow_shift = COSMOS3_T2I_DEFAULT_FLOW_SHIFT
             default_guidance_interval: tuple[float, float] | None = COSMOS3_T2I_DEFAULT_GUIDANCE_INTERVAL
             batch_size = max(1, int(sp.num_outputs_per_prompt or 1))
         else:
-            height = sp.height or COSMOS3_T2V_DEFAULT_HEIGHT
-            width = sp.width or COSMOS3_T2V_DEFAULT_WIDTH
+            height = sp.height or (
+                COSMOS3_EDGE_T2V_DEFAULT_HEIGHT if self.is_edge_model else COSMOS3_T2V_DEFAULT_HEIGHT
+            )
+            width = sp.width or (COSMOS3_EDGE_T2V_DEFAULT_WIDTH if self.is_edge_model else COSMOS3_T2V_DEFAULT_WIDTH)
+            default_guidance_scale = (
+                COSMOS3_EDGE_T2V_DEFAULT_GUIDANCE_SCALE if self.is_edge_model else COSMOS3_T2V_DEFAULT_GUIDANCE_SCALE
+            )
             num_frames = sp.num_frames or COSMOS3_T2V_DEFAULT_NUM_FRAMES
             num_inference_steps = sp.num_inference_steps or COSMOS3_T2V_DEFAULT_NUM_INFERENCE_STEPS
-            guidance_scale = sp.guidance_scale if sp.guidance_scale else COSMOS3_T2V_DEFAULT_GUIDANCE_SCALE
-            # Fall back to the engine-init shift, NOT None: passing None
-            # to ``_set_flow_shift`` would leak a prior T2I rebuild
-            # (shift=3.0) into a subsequent video request.
-            default_flow_shift = COSMOS3_V2V_DEFAULT_FLOW_SHIFT if is_v2v else self._engine_init_flow_shift
+            guidance_scale = self._resolve_guidance_scale(sp, default_guidance_scale)
+            default_flow_shift = self._engine_init_flow_shift
             default_guidance_interval = None
             batch_size = 1  # Existing video pipeline assumes B=1.
 
@@ -3103,9 +3315,23 @@ class Cosmos3OmniDiffusersPipeline(
                     f"or action_chunk_size + 1; got num_frames={num_frames}, action_chunk_size={action_chunk_size}."
                 )
             num_inference_steps = sp.num_inference_steps or 30
-            guidance_scale = sp.guidance_scale if sp.guidance_scale is not None else 1.0
+            guidance_scale = self._resolve_guidance_scale(sp, 1.0)
             default_flow_shift = 5.0
 
+        if not is_t2i and not action_enabled:
+            requested_num_frames = int(num_frames)
+            num_frames = _ceil_video_num_frames(
+                requested_num_frames,
+                self.vae_scale_factor_temporal,
+            )
+            if num_frames != requested_num_frames and _is_rank_zero():
+                logger.info(
+                    "Rounded Cosmos3 num_frames from %d to %d for temporal compression factor %d.",
+                    requested_num_frames,
+                    num_frames,
+                    self.vae_scale_factor_temporal,
+                )
+
         domain_id = None
         if action_enabled:
             domain_id = resolve_domain_id(
@@ -3146,13 +3372,12 @@ class Cosmos3OmniDiffusersPipeline(
         self._guidance_scale = guidance_scale
         self._num_timesteps = num_inference_steps
 
-        # Always resolve to a concrete target shift for this request, then
-        # update the shared Diffusers scheduler.
-        self._set_flow_shift(flow_shift_target, use_karras_sigmas=False if is_v2v else None)
+        # Always resolve to a concrete target shift for this request.
+        self._set_flow_shift(flow_shift_target)
 
         generator = sp.generator
+        seed = self._resolve_seed(sp, generator)
         if generator is None:
-            seed = sp.seed if sp.seed is not None else 42
             generator = torch.Generator(device=self.device).manual_seed(seed)
 
         # --- Format prompts & tokenize (B=1; reused across loop iterations
@@ -3293,7 +3518,11 @@ class Cosmos3OmniDiffusersPipeline(
             )
 
         def _run_diffusion(start_latents):
-            self.scheduler.set_timesteps(num_inference_steps, device=self.device)
+            self._set_timesteps(
+                num_inference_steps,
+                device=self.device,
+                shift=self._current_flow_shift,
+            )
             scheduler = self.scheduler
             return self.diffuse(
                 latents=start_latents,
@@ -3314,6 +3543,7 @@ class Cosmos3OmniDiffusersPipeline(
                 guidance_interval=guidance_interval,
                 raw_action_dim=raw_action_dim,
                 scheduler=scheduler,
+                generator=generator,
             )
 
         if is_t2i and batch_size > 1:
diff --git a/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py
index 21e723ced..475c02889 100644
--- a/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py
+++ b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py
@@ -33,7 +33,7 @@ from vllm.model_executor.layers.quantization.base_config import (
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention as FrameworkAttention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelInput, SequenceParallelOutput
 from vllm_omni.diffusion.forward_context import get_forward_context, is_forward_context_available
@@ -55,6 +55,9 @@ class RMSNorm(_VllmRMSNorm):
     def forward_hip(self, x: torch.Tensor) -> torch.Tensor:
         return self.forward_native(x)
 
+    def forward_npu(self, x: torch.Tensor) -> torch.Tensor:
+        return self.forward_native(x)
+
 
 def _get_ulysses_state() -> tuple[int, int, dist.ProcessGroup | None]:
     """Return (ulysses_size, ulysses_rank, ulysses_pg) from vllm-omni parallel state.
@@ -396,7 +399,6 @@ class TimestepEmbedder(nn.Module):
         hidden_size: int,
         frequency_embedding_size: int = 256,
         max_period: int = 10000,
-        target_dtype: torch.dtype = torch.bfloat16,
     ) -> None:
         super().__init__()
         # Following diffusers naming pattern here for checkpoint compatibility.
@@ -407,7 +409,7 @@ class TimestepEmbedder(nn.Module):
         self.hidden_size = hidden_size
 
         half = frequency_embedding_size // 2
-        freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=target_dtype) / half)
+        freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half)
         self.register_buffer("freqs", freqs, persistent=False)
 
     def forward(self, t: torch.Tensor) -> torch.Tensor:
@@ -587,6 +589,7 @@ class Cosmos3CrossAttention(nn.Module):
         head_dim: int,
         rms_norm_eps: float,
         quant_config: QuantizationConfig | None = None,
+        qk_norm: bool = True,
         prefix: str = "",
     ) -> None:
         super().__init__()
@@ -636,8 +639,10 @@ class Cosmos3CrossAttention(nn.Module):
             prefix=f"{prefix}.to_out",
         )
 
-        self.norm_q = RMSNorm(self.head_dim, eps=rms_norm_eps)
-        self.norm_k = RMSNorm(self.head_dim, eps=rms_norm_eps)
+        self.qk_norm = qk_norm
+        if self.qk_norm:
+            self.norm_q = RMSNorm(self.head_dim, eps=rms_norm_eps)
+            self.norm_k = RMSNorm(self.head_dim, eps=rms_norm_eps)
 
         self.attn = FrameworkAttention(
             num_heads=self.num_heads,
@@ -721,8 +726,9 @@ class Cosmos3CrossAttention(nn.Module):
         v = self.to_v(hidden_states).view(B, S_gen, self.num_kv_heads_local, self.head_dim)
 
         # Per-head QK norm
-        q = F.rms_norm(q, (self.head_dim,), self.norm_q.weight, eps=self.norm_q.variance_epsilon)
-        k = F.rms_norm(k, (self.head_dim,), self.norm_k.weight, eps=self.norm_k.variance_epsilon)
+        if self.qk_norm:
+            q = F.rms_norm(q, (self.head_dim,), self.norm_q.weight, eps=self.norm_q.variance_epsilon)
+            k = F.rms_norm(k, (self.head_dim,), self.norm_k.weight, eps=self.norm_k.variance_epsilon)
 
         # Qwen3-style RoPE
         q, k = _apply_rotary_pos_emb(q, k, freqs_cos, freqs_sin)
@@ -806,6 +812,8 @@ class Cosmos3GenDecoderLayer(nn.Module):
         head_dim: int,
         rms_norm_eps: float,
         quant_config: QuantizationConfig | None = None,
+        mlp_cls: type[nn.Module] = Cosmos3GatedMLP,
+        qk_norm: bool = True,
         prefix: str = "",
     ) -> None:
         super().__init__()
@@ -817,11 +825,12 @@ class Cosmos3GenDecoderLayer(nn.Module):
             head_dim=head_dim,
             rms_norm_eps=rms_norm_eps,
             quant_config=quant_config,
+            qk_norm=qk_norm,
             prefix=f"{prefix}.cross_attention",
         )
         self.input_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
         self.post_attention_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
-        self.mlp = Cosmos3GatedMLP(
+        self.mlp = mlp_cls(
             hidden_size=hidden_size,
             intermediate_size=intermediate_size,
             quant_config=quant_config,
@@ -996,6 +1005,9 @@ class Cosmos3VFMTransformer(nn.Module):
 
     packed_modules_mapping = {}
 
+    _language_model_cls = Cosmos3LanguageModel
+    _gen_mlp_cls = Cosmos3GatedMLP
+
     @staticmethod
     def _is_transformer_block(name: str, module) -> bool:
         return ("gen_layers" in name or "language_model.layers" in name) and name.split(".")[-1].isdigit()
@@ -1032,6 +1044,25 @@ class Cosmos3VFMTransformer(nn.Module):
             if actual != expected:
                 raise ValueError(f"Unsupported Cosmos3 transformer config: {key}={actual!r}; expected {expected!r}.")
 
+    @classmethod
+    def _resolve_rms_norm_eps(cls, model_config: Any) -> float:
+        return float(_tf_config_get(model_config, "rms_norm_eps", 1e-6))
+
+    @classmethod
+    def _resolve_rope_theta(cls, model_config: Any) -> float:
+        return float(_tf_config_get(model_config, "rope_theta", 5_000_000))
+
+    @classmethod
+    def _resolve_mrope_section(cls, model_config: Any) -> list[int]:
+        rope_scaling = _tf_config_get(model_config, "rope_scaling", {}) or {}
+        return list(rope_scaling.get("mrope_section", [24, 20, 20]))
+
+    def _language_model_kwargs(self) -> dict[str, Any]:
+        return {}
+
+    def validate_loaded_weights(self, loaded: set[str]) -> None:
+        del loaded
+
     def __init__(
         self,
         od_config: OmniDiffusionConfig,
@@ -1044,7 +1075,6 @@ class Cosmos3VFMTransformer(nn.Module):
         super().__init__()
         model_config = od_config.tf_model_config
         self._validate_supported_config(model_config)
-        rope_scaling = _tf_config_get(model_config, "rope_scaling", {}) or {}
 
         self.hidden_size = int(_tf_config_get(model_config, "hidden_size", 4096))
         self.num_hidden_layers = int(_tf_config_get(model_config, "num_hidden_layers", 36))
@@ -1053,9 +1083,10 @@ class Cosmos3VFMTransformer(nn.Module):
         self.head_dim = int(_tf_config_get(model_config, "head_dim", 128))
         self.intermediate_size = int(_tf_config_get(model_config, "intermediate_size", 12288))
         self.vocab_size = int(_tf_config_get(model_config, "vocab_size", 151936))
-        self.rms_norm_eps = float(_tf_config_get(model_config, "rms_norm_eps", 1e-6))
-        self.rope_theta = float(_tf_config_get(model_config, "rope_theta", 5_000_000))
-        self.mrope_section = list(rope_scaling.get("mrope_section", [24, 20, 20]))
+        self.rms_norm_eps = self._resolve_rms_norm_eps(model_config)
+        self.rope_theta = self._resolve_rope_theta(model_config)
+        self.mrope_section = self._resolve_mrope_section(model_config)
+        self.qk_norm_for_diffusion = bool(_tf_config_get(model_config, "qk_norm_for_diffusion", True))
         self.latent_patch_size = int(_tf_config_get(model_config, "latent_patch_size", 2))
         self.latent_channel_size = int(_tf_config_get(model_config, "latent_channel", 48))
         self.timestep_scale = float(_tf_config_get(model_config, "timestep_scale", 0.001))
@@ -1095,10 +1126,12 @@ class Cosmos3VFMTransformer(nn.Module):
         )
         self.patch_latent_dim = (self.latent_patch_size**2) * self.latent_channel_size
 
+        self.use_und_k_norm_for_gen = _tf_config_get(model_config, "use_und_k_norm_for_gen", None)
+
         dtype = od_config.dtype
         quant_config = getattr(od_config, "quantization_config", None) if od_config else None
 
-        self.language_model = Cosmos3LanguageModel(
+        self.language_model = self._language_model_cls(
             hidden_size=self.hidden_size,
             intermediate_size=self.intermediate_size,
             num_hidden_layers=self.num_hidden_layers,
@@ -1111,12 +1144,13 @@ class Cosmos3VFMTransformer(nn.Module):
             mrope_section=self.mrope_section,
             quant_config=quant_config,
             prefix="language_model",
+            **self._language_model_kwargs(),
         )
 
         # Video projection layers are small; not worth quantizing.
         self.proj_in = nn.Linear(self.patch_latent_dim, self.hidden_size)
         self.proj_out = nn.Linear(self.hidden_size, self.patch_latent_dim)
-        self.time_embedder = TimestepEmbedder(self.hidden_size, target_dtype=dtype)
+        self.time_embedder = TimestepEmbedder(self.hidden_size)
         if self.action_gen:
             self.action_proj_in = DomainAwareLinear(
                 self.action_dim,
@@ -1147,6 +1181,8 @@ class Cosmos3VFMTransformer(nn.Module):
                     head_dim=self.head_dim,
                     rms_norm_eps=self.rms_norm_eps,
                     quant_config=quant_config,
+                    mlp_cls=self._gen_mlp_cls,
+                    qk_norm=self.qk_norm_for_diffusion,
                     prefix=f"gen_layers.{i}",
                 )
                 for i in range(self.num_hidden_layers)
diff --git a/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3_edge.py b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3_edge.py
new file mode 100644
index 000000000..c9a7d856e
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3_edge.py
@@ -0,0 +1,396 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Cosmos3 Edge transformer variant with a Nemotron dense UND backbone."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from vllm.distributed import get_tensor_model_parallel_world_size
+from vllm.model_executor.layers.linear import ColumnParallelLinear, RowParallelLinear
+from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
+
+from vllm_omni.diffusion.attention.layer import Attention as FrameworkAttention
+
+from .transformer_cosmos3 import (
+    Cosmos3VFMTransformer,
+    Qwen3VLTextRotaryEmbedding,
+    RMSNorm,
+    _apply_rotary_pos_emb,
+    _nested_get,
+    _tf_config_get,
+)
+
+COSMOS3_EDGE_BACKBONE_TYPE = "cosmos3_edge_nemotron_dense"
+
+
+def _tf_config_nested_get(config: Any, key: str, default: Any = None) -> Any:
+    if config is None:
+        return default
+    if isinstance(config, dict):
+        value = _nested_get(config, key)
+    elif hasattr(config, "to_dict"):
+        value = _nested_get(config.to_dict(), key)
+    elif hasattr(config, "params"):
+        value = _nested_get(config.params, key)
+    else:
+        value = getattr(config, key, None)
+    return default if value is None else value
+
+
+class Cosmos3Relu2MLP(nn.Module):
+    """Nemotron dense MLP: down_proj(relu(up_proj(x)) ** 2)."""
+
+    def __init__(
+        self,
+        hidden_size: int,
+        intermediate_size: int,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.up_proj = ColumnParallelLinear(
+            hidden_size,
+            intermediate_size,
+            bias=False,
+            gather_output=False,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.up_proj",
+        )
+        self.down_proj = RowParallelLinear(
+            intermediate_size,
+            hidden_size,
+            bias=False,
+            input_is_parallel=True,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.down_proj",
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        hidden = F.relu(self.up_proj(x))
+        return self.down_proj(hidden * hidden)
+
+
+class Cosmos3EdgeCausalAttention(nn.Module):
+    """Edge UND causal attention.
+
+    Reasoner self-attention uses raw UND Q/K with RoPE because
+    ``qk_norm_for_text=false``.  The GEN-facing UND key cache is a separate
+    normalized-then-RoPE'd view of the raw K tensor when GEN QK norm is enabled;
+    no-GEN-QK-norm checkpoints reuse the raw RoPE'd UND K.
+    """
+
+    def __init__(
+        self,
+        *,
+        hidden_size: int,
+        num_attention_heads: int,
+        num_key_value_heads: int,
+        head_dim: int,
+        rms_norm_eps: float,
+        use_und_k_norm_for_gen: bool,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.num_heads = num_attention_heads
+        self.num_kv_heads = num_key_value_heads
+        self.head_dim = head_dim
+
+        tp_size = get_tensor_model_parallel_world_size()
+        self.num_heads_local = self.num_heads // tp_size
+        self.num_kv_heads_local = self.num_kv_heads // tp_size
+
+        self.to_q = ColumnParallelLinear(
+            hidden_size,
+            self.num_heads * self.head_dim,
+            bias=False,
+            gather_output=False,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.to_q",
+        )
+        self.to_k = ColumnParallelLinear(
+            hidden_size,
+            self.num_kv_heads * self.head_dim,
+            bias=False,
+            gather_output=False,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.to_k",
+        )
+        self.to_v = ColumnParallelLinear(
+            hidden_size,
+            self.num_kv_heads * self.head_dim,
+            bias=False,
+            gather_output=False,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.to_v",
+        )
+        self.to_out = RowParallelLinear(
+            self.num_heads * self.head_dim,
+            hidden_size,
+            bias=False,
+            input_is_parallel=True,
+            return_bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.to_out",
+        )
+
+        self.k_norm_und_for_gen = RMSNorm(self.head_dim, eps=rms_norm_eps) if use_und_k_norm_for_gen else None
+        self.attn = FrameworkAttention(
+            num_heads=self.num_heads,
+            head_size=self.head_dim,
+            causal=True,
+            softmax_scale=1.0 / (self.head_dim**0.5),
+            num_kv_heads=self.num_kv_heads,
+            skip_sequence_parallel=True,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        freqs_cos: torch.Tensor,
+        freqs_sin: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        B, S, _ = hidden_states.shape
+
+        q = self.to_q(hidden_states).view(B, S, self.num_heads_local, self.head_dim)
+        k = self.to_k(hidden_states).view(B, S, self.num_kv_heads_local, self.head_dim)
+        v = self.to_v(hidden_states).view(B, S, self.num_kv_heads_local, self.head_dim)
+
+        q_reasoner, k_reasoner = _apply_rotary_pos_emb(q, k, freqs_cos, freqs_sin)
+
+        if self.k_norm_und_for_gen is not None:
+            k_gen = F.rms_norm(
+                k,
+                (self.head_dim,),
+                self.k_norm_und_for_gen.weight,
+                eps=self.k_norm_und_for_gen.variance_epsilon,
+            )
+            _, k_gen = _apply_rotary_pos_emb(q, k_gen, freqs_cos, freqs_sin)
+        else:
+            k_gen = k_reasoner
+
+        out = self.attn(q_reasoner, k_reasoner, v).reshape(B, S, -1)
+        return self.to_out(out), k_gen, v
+
+
+class Cosmos3EdgeUndDecoderLayer(nn.Module):
+    """Edge UND decoder layer: causal self-attention + ReLU2 MLP."""
+
+    def __init__(
+        self,
+        *,
+        hidden_size: int,
+        intermediate_size: int,
+        num_attention_heads: int,
+        num_key_value_heads: int,
+        head_dim: int,
+        rms_norm_eps: float,
+        use_und_k_norm_for_gen: bool,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.self_attn = Cosmos3EdgeCausalAttention(
+            hidden_size=hidden_size,
+            num_attention_heads=num_attention_heads,
+            num_key_value_heads=num_key_value_heads,
+            head_dim=head_dim,
+            rms_norm_eps=rms_norm_eps,
+            use_und_k_norm_for_gen=use_und_k_norm_for_gen,
+            quant_config=quant_config,
+            prefix=f"{prefix}.self_attn",
+        )
+        self.input_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
+        self.post_attention_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
+        self.mlp = Cosmos3Relu2MLP(
+            hidden_size=hidden_size,
+            intermediate_size=intermediate_size,
+            quant_config=quant_config,
+            prefix=f"{prefix}.mlp",
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        freqs: tuple[torch.Tensor, torch.Tensor],
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+
+        cos, sin = freqs
+        attn_out, k, v = self.self_attn(hidden_states, cos, sin)
+        hidden_states = residual + attn_out
+
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = residual + self.mlp(hidden_states)
+
+        return hidden_states, k, v
+
+
+class Cosmos3EdgeLanguageModel(nn.Module):
+    """Nemotron dense UND tower that returns GEN-facing K plus raw V per layer."""
+
+    _layerwise_offload_blocks_attrs = ["layers"]
+
+    def __init__(
+        self,
+        *,
+        hidden_size: int,
+        intermediate_size: int,
+        num_hidden_layers: int,
+        num_attention_heads: int,
+        num_key_value_heads: int,
+        head_dim: int,
+        vocab_size: int,
+        rms_norm_eps: float,
+        rope_theta: float,
+        mrope_section: list[int],
+        use_und_k_norm_for_gen: bool,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.embed_tokens = nn.Embedding(vocab_size, hidden_size)
+        self.rotary_emb = Qwen3VLTextRotaryEmbedding(
+            head_dim=head_dim,
+            rope_theta=rope_theta,
+            mrope_section=mrope_section,
+        )
+        self.layers = nn.ModuleList(
+            [
+                Cosmos3EdgeUndDecoderLayer(
+                    hidden_size=hidden_size,
+                    intermediate_size=intermediate_size,
+                    num_attention_heads=num_attention_heads,
+                    num_key_value_heads=num_key_value_heads,
+                    head_dim=head_dim,
+                    rms_norm_eps=rms_norm_eps,
+                    use_und_k_norm_for_gen=use_und_k_norm_for_gen,
+                    quant_config=quant_config,
+                    prefix=f"{prefix}.layers.{i}",
+                )
+                for i in range(num_hidden_layers)
+            ]
+        )
+        self.norm = RMSNorm(hidden_size, eps=rms_norm_eps)
+
+    def forward(
+        self,
+        text_ids: torch.Tensor,
+        freqs: tuple[torch.Tensor, torch.Tensor],
+    ) -> list[tuple[torch.Tensor, torch.Tensor]]:
+        hidden = self.embed_tokens(text_ids)
+
+        cached_kv: list[tuple[torch.Tensor, torch.Tensor]] = []
+        for layer in self.layers:
+            hidden, k, v = layer(hidden, freqs)
+            cached_kv.append((k, v))
+
+        return cached_kv
+
+
+class Cosmos3EdgeVFMTransformer(Cosmos3VFMTransformer):
+    """Cosmos3 Edge variant with Nemotron dense UND and shared GEN diffusion."""
+
+    _language_model_cls = Cosmos3EdgeLanguageModel
+    _gen_mlp_cls = Cosmos3Relu2MLP
+
+    @staticmethod
+    def _validate_supported_config(model_config: Any) -> None:
+        expected_values = {
+            "qk_norm_for_text": False,
+            "position_embedding_type": "unified_3d_mrope",
+            "unified_3d_mrope_reset_spatial_ids": True,
+            "joint_attn_implementation": "two_way",
+        }
+        for key, expected in expected_values.items():
+            actual = _tf_config_get(model_config, key, expected)
+            if actual != expected:
+                raise ValueError(
+                    f"Unsupported Cosmos3 Edge transformer config: {key}={actual!r}; expected {expected!r}."
+                )
+
+        backbone_type = _tf_config_get(model_config, "backbone_type", None)
+        if backbone_type is None:
+            raise ValueError(
+                f"Cosmos3 Edge transformer config must declare backbone_type={COSMOS3_EDGE_BACKBONE_TYPE!r}."
+            )
+        if backbone_type != COSMOS3_EDGE_BACKBONE_TYPE:
+            raise ValueError(
+                "Unsupported Cosmos3 Edge transformer config: "
+                f"backbone_type={backbone_type!r}; expected {COSMOS3_EDGE_BACKBONE_TYPE!r}."
+            )
+
+        required_values = {
+            "latent_channel": 48,
+            "latent_patch_size": 2,
+            "temporal_compression_factor": 4,
+        }
+        for key, expected in required_values.items():
+            actual = _tf_config_get(model_config, key, None)
+            if actual is None:
+                raise ValueError(f"Cosmos3 Edge transformer config must declare {key}={expected}.")
+            if int(actual) != expected:
+                raise ValueError(
+                    f"Unsupported Cosmos3 Edge transformer config: {key}={actual!r}; expected {expected!r}."
+                )
+
+    @classmethod
+    def _resolve_rms_norm_eps(cls, model_config: Any) -> float:
+        return float(
+            _tf_config_get(
+                model_config,
+                "rms_norm_eps",
+                _tf_config_get(model_config, "layer_norm_epsilon", 1e-5),
+            )
+        )
+
+    @classmethod
+    def _resolve_rope_theta(cls, model_config: Any) -> float:
+        return float(_tf_config_get(model_config, "rope_theta", 100_000_000))
+
+    @classmethod
+    def _resolve_mrope_section(cls, model_config: Any) -> list[int]:
+        mrope_section = _tf_config_get(model_config, "mrope_section", None)
+        if mrope_section is None:
+            mrope_section = _tf_config_nested_get(model_config, "mrope_section", [24, 20, 20])
+        return list(mrope_section)
+
+    def _language_model_kwargs(self) -> dict[str, Any]:
+        return {"use_und_k_norm_for_gen": self.use_und_k_norm_for_gen}
+
+    def validate_loaded_weights(self, loaded: set[str]) -> None:
+        missing: list[str] = []
+        for layer_idx in range(self.num_hidden_layers):
+            required_markers = (
+                f"language_model.layers.{layer_idx}.mlp.up_proj.",
+                f"language_model.layers.{layer_idx}.mlp.down_proj.",
+                f"gen_layers.{layer_idx}.mlp.up_proj.",
+                f"gen_layers.{layer_idx}.mlp.down_proj.",
+            )
+            if self.use_und_k_norm_for_gen:
+                required_markers = (
+                    *required_markers,
+                    f"language_model.layers.{layer_idx}.self_attn.k_norm_und_for_gen.",
+                )
+            missing.extend(
+                marker.rstrip(".") for marker in required_markers if not any(marker in name for name in loaded)
+            )
+        if missing:
+            preview = ", ".join(missing[:10])
+            suffix = " ..." if len(missing) > 10 else ""
+            raise ValueError(
+                "Cosmos3 Edge transformer checkpoint is missing required weights for "
+                f"{preview}{suffix}. Use a converted Edge checkpoint with ReLU2 UND/GEN MLP weights."
+            )
diff --git a/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py b/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py
index 6333819b0..5ae75b256 100644
--- a/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py
+++ b/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py
@@ -135,8 +135,8 @@ class DiTAttention(nn.Module):
         # The diffusion Attention layer expects (batch, seq, heads, head_dim)
         out = self.attn(query, key, value, attn_metadata=None)
 
-        # Reshape back: (batch, seq, dim)
-        out = out.view(batch_size, seq_len, self.inner_dim)
+        # Some attention backends return a non-contiguous layout.
+        out = out.reshape(batch_size, seq_len, self.inner_dim)
         out = out.to(query.dtype)
 
         # Output projection
diff --git a/vllm_omni/diffusion/models/dmd2/mixin.py b/vllm_omni/diffusion/models/dmd2/mixin.py
index 873120fc1..9c98e96b4 100644
--- a/vllm_omni/diffusion/models/dmd2/mixin.py
+++ b/vllm_omni/diffusion/models/dmd2/mixin.py
@@ -37,43 +37,42 @@ class DMD2PipelineMixin:
 
     def _sanitize_dmd2_request(self, req) -> None:
         """Sanitize CFG-related fields in-place. Works with both OmniDiffusionRequest and DiffusionRequestBatch."""
-        sp = req.sampling_params
+        sampling_params = req.sampling_params_list if isinstance(req, DiffusionRequestBatch) else [req.sampling_params]
+        for sp in sampling_params:
+            if sp.num_inference_steps and sp.num_inference_steps != self.dmd2_config.num_inference_steps:
+                logger.warning(
+                    "DMD2: ignoring num_inference_steps=%d, forcing %d.",
+                    sp.num_inference_steps,
+                    self.dmd2_config.num_inference_steps,
+                )
+            sp.num_inference_steps = self.dmd2_config.num_inference_steps
 
-        if sp.num_inference_steps and sp.num_inference_steps != self.dmd2_config.num_inference_steps:
-            logger.warning(
-                "DMD2: ignoring num_inference_steps=%d, forcing %d.",
-                sp.num_inference_steps,
-                self.dmd2_config.num_inference_steps,
-            )
-        sp.num_inference_steps = self.dmd2_config.num_inference_steps
+            if sp.guidance_scale_provided and sp.guidance_scale != self.dmd2_config.guidance_scale:
+                logger.warning(
+                    "DMD2: ignoring guidance_scale=%.2f, forcing %.2f.",
+                    sp.guidance_scale,
+                    self.dmd2_config.guidance_scale,
+                )
+            sp.guidance_scale = self.dmd2_config.guidance_scale
+            sp.guidance_scale_provided = False
 
-        if sp.guidance_scale_provided and sp.guidance_scale != self.dmd2_config.guidance_scale:
-            logger.warning(
-                "DMD2: ignoring guidance_scale=%.2f, forcing %.2f.",
-                sp.guidance_scale,
-                self.dmd2_config.guidance_scale,
-            )
-        sp.guidance_scale = self.dmd2_config.guidance_scale
-        sp.guidance_scale_provided = False
+            if sp.guidance_scale_2 is not None:
+                logger.warning("DMD2: ignoring guidance_scale_2.")
+                sp.guidance_scale_2 = None
 
-        if sp.guidance_scale_2 is not None:
-            logger.warning("DMD2: ignoring guidance_scale_2.")
-            sp.guidance_scale_2 = None
+            if sp.true_cfg_scale is not None:
+                logger.warning("DMD2: ignoring true_cfg_scale.")
+                sp.true_cfg_scale = None
 
-        if sp.true_cfg_scale is not None:
-            logger.warning("DMD2: ignoring true_cfg_scale.")
-            sp.true_cfg_scale = None
+            sp.do_classifier_free_guidance = False
+            sp.is_cfg_negative = False
 
-        sp.do_classifier_free_guidance = False
-        sp.is_cfg_negative = False
-
-        # defense: strip scheduler-override extra_args that would let the base pipeline
-        # (e.g. Wan22Pipeline.forward) rebuild self.scheduler mid-forward and clobber DMD2EulerScheduler.
-        extra_args = getattr(sp, "extra_args", None) or {}
-        for key in ("sample_solver", "flow_shift"):
-            if key in extra_args:
-                logger.warning("DMD2: ignoring extra_args.%s.", key)
-                extra_args.pop(key)
+            # Prevent base pipelines from replacing the DMD2 scheduler.
+            extra_args = getattr(sp, "extra_args", None) or {}
+            for key in ("sample_solver", "flow_shift"):
+                if key in extra_args:
+                    logger.warning("DMD2: ignoring extra_args.%s.", key)
+                    extra_args.pop(key)
 
         # Strip negative_prompt from each request's prompt in-place.
         requests = req.requests if hasattr(req, "requests") else [req]
diff --git a/vllm_omni/diffusion/models/dreamid_omni/fusion.py b/vllm_omni/diffusion/models/dreamid_omni/fusion.py
index acf24dd2f..8bcbbbb64 100644
--- a/vllm_omni/diffusion/models/dreamid_omni/fusion.py
+++ b/vllm_omni/diffusion/models/dreamid_omni/fusion.py
@@ -9,7 +9,7 @@ from vllm.logger import init_logger
 from vllm.model_executor.layers.linear import ColumnParallelLinear
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 
 if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
diff --git a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
index 107638f81..b2668b0a5 100644
--- a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
+++ b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
@@ -3,7 +3,7 @@
 
 """DreamZero pipeline for vllm-omni.
 
-Entry point for DiffusionEngine.step() -> pipeline.forward(req)
+Entry point for DiffusionEngine.step_streaming() -> pipeline.forward(req)
 """
 
 from __future__ import annotations
@@ -11,10 +11,12 @@ from __future__ import annotations
 import copy
 import json
 import logging
+import math
 import os
 import re as re_module
 from collections import OrderedDict
 from collections.abc import Iterable
+from contextlib import contextmanager
 
 import numpy as np
 import torch
@@ -52,11 +54,29 @@ from vllm_omni.diffusion.models.dreamzero.utils import (
     DEFAULT_SIGMA_SHIFT,
 )
 from vllm_omni.diffusion.models.schedulers.scheduling_flow_unipc_multistep import FlowUniPCMultistepScheduler
+from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.experimental.ar_diffusion.capability import (
+    ARDiffusionCrossAttentionKVSpec,
+    ARDiffusionKVBranchSpec,
+    ARDiffusionKVCacheSpec,
+)
+from vllm_omni.experimental.world_models.adapters.state_dreamzero_adapter import DreamZeroStateAdapter
+from vllm_omni.experimental.world_models.session_state import (
+    SessionStateManager,
+    resolve_session_state_config,
+)
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 logger = logging.getLogger(__name__)
 MAX_DREAMZERO_SESSIONS = 64
 
+# The pipeline's per-session state is a bespoke ``DreamZeroState`` by default, or
+# a ``DreamZeroStateAdapter`` view when the opt-in session manager is enabled.
+# The adapter mirrors ``DreamZeroState``'s surface, so every helper that reads or
+# writes session state accepts either.
+DreamZeroSessionState = DreamZeroState | DreamZeroStateAdapter
+
 
 class VideoActionScheduler:
     """Wraps video + action schedulers into single .step() interface."""
@@ -92,18 +112,142 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
     """DreamZero world model pipeline.
 
     Multi-output: predict_noise() returns (video_pred, action_pred).
-    CFG: video gets standard CFG, action takes positive branch only.
+    CFG: video gets standard CFG, action takes the positive KV branch only.
 
-    KV is managed by the AR-Diffusion engine: ``self._ar_diffusion_kv_state`` is set by the
-    runner before ``forward()`` and the pipeline routes all KV access (get / update /
-    commit / reset) through the pool-backed state. Purely duck-typed (no engine import).
+    KV is managed by the AR-Diffusion engine through the explicit capability
+    methods below. The runner binds one session state only for ``forward()``.
     """
 
-    _ar_diffusion_kv_state = None  # set by the runner before each forward
+    _POSITIVE_BRANCH = "positive"
+    _NEGATIVE_BRANCH = "negative"
+    _ar_diffusion_kv_state = None
+    state: DreamZeroSessionState | None
+
+    def ar_diffusion_kv_cache_spec(self) -> ARDiffusionKVCacheSpec:
+        """Describe DreamZero's local KV geometry to the generic runner."""
+        transformer = self.transformer
+        frame_tokens = int(transformer.frame_seqlen)
+        max_attention_tokens = int(transformer.blocks[0].self_attn.max_attention_size)
+        cfg_world = int(get_classifier_free_guidance_world_size())
+        negative_local_index = 0 if cfg_world >= 2 else 1
+        cross_attention = [
+            ARDiffusionCrossAttentionKVSpec("text", int(transformer.text_len)),
+        ]
+        if transformer.model_type == "i2v":
+            cross_attention.append(ARDiffusionCrossAttentionKVSpec("image", 257))
+        return ARDiffusionKVCacheSpec(
+            num_layers=int(transformer.num_layers),
+            num_kv_heads=int(transformer.blocks[0].self_attn.tp_num_heads),
+            head_size=int(transformer.dim // transformer.num_heads),
+            tokens_per_frame=frame_tokens,
+            frames_per_block=int(transformer.num_frame_per_block),
+            window_frames=max_attention_tokens // frame_tokens,
+            kv_branches=(
+                ARDiffusionKVBranchSpec(self._POSITIVE_BRANCH, 0),
+                ARDiffusionKVBranchSpec(self._NEGATIVE_BRANCH, negative_local_index),
+            ),
+            session_capacity=MAX_DREAMZERO_SESSIONS,
+            cross_attention=tuple(cross_attention),
+            max_scratch_tokens_per_branch=int(transformer.num_action_per_block + transformer.num_state_per_block),
+        )
+
+    @contextmanager
+    def bind_ar_diffusion_state(self, session_id, state):
+        """Bind runner-owned KV only for the duration of one forward."""
+        if self._ar_diffusion_kv_state is not None:
+            raise RuntimeError("DreamZero AR-Diffusion state is already bound")
+        if state.session_id != session_id:
+            raise ValueError(f"DreamZero bound session mismatch: {state.session_id!r} != {session_id!r}")
+        self._ar_diffusion_kv_state = state
+        try:
+            yield
+        finally:
+            self._ar_diffusion_kv_state = None
+
+    def reset_ar_diffusion_session(self, session_id: str) -> None:
+        """Reset DreamZero-owned state after the runner releases session KV."""
+        self._drop_ar_diffusion_session_state(session_id)
+
+    def close_ar_diffusion_session(self, session_id: str) -> None:
+        """Drop DreamZero-owned state after close, eviction, or failed forward."""
+        self._drop_ar_diffusion_session_state(session_id)
+
+    def _drop_ar_diffusion_session_state(self, session_id: str) -> None:
+        """Remove model state and clear the compatibility alias when it points there."""
+        key = str(session_id or "default")
+        # Local binding narrows the Optional and guards lightweight test fixtures
+        # that build the pipeline via __new__ without setting _memory_manager.
+        manager = getattr(self, "_memory_manager", None)
+        if manager is not None:
+            # Manager-backed path: the session lives in the manager, not in
+            # ``_states``. The runner's explicit close/reset is the session's
+            # end-of-life signal, so release it there (freeing its buffers) and
+            # drop the alias if it still views this session.
+            manager.drop_session(key)
+            current = getattr(self, "state", None)
+            if isinstance(current, DreamZeroStateAdapter) and str(current.session_id or "default") == key:
+                self.state = None
+            return
+        removed = self._states.pop(key, None)
+        if removed is not None and getattr(self, "state", None) is removed:
+            self.state = None
+
+    @staticmethod
+    def _ar_warmup_robot_obs(height: int, width: int, n_frames: int, session_id: str) -> dict:
+        image = (
+            np.zeros((height, width, 3), dtype=np.uint8)
+            if n_frames == 1
+            else np.zeros((n_frames, height, width, 3), dtype=np.uint8)
+        )
+        return {
+            "observation/exterior_image_0_left": image,
+            "observation/exterior_image_1_left": image,
+            "observation/wrist_image_left": image,
+            "observation/joint_position": np.zeros(7, dtype=np.float32),
+            "observation/cartesian_position": np.zeros(6, dtype=np.float32),
+            "observation/gripper_position": np.zeros(1, dtype=np.float32),
+            "prompt": "warmup",
+            "session_id": session_id,
+        }
+
+    def ar_diffusion_warmup_requests(self, session_id: str) -> Iterable[OmniDiffusionRequest]:
+        """Yield DreamZero-valid requests covering each resident window shape."""
+        spec = self.ar_diffusion_kv_cache_spec()
+        n_forwards = 1 + math.ceil(max(0, spec.window_frames - 1) / spec.frames_per_block)
+        raw_kv_config = getattr(self.od_config, "ar_diffusion_kv_config", None)
+        if raw_kv_config is None and isinstance(self.od_config.model_config, dict):
+            raw_kv_config = self.od_config.model_config.get("ar_diffusion_kv_config")
+        capture_reset = (
+            bool(raw_kv_config.get("warmup_capture_reset", False))
+            if isinstance(raw_kv_config, dict)
+            else bool(getattr(raw_kv_config, "warmup_capture_reset", False))
+        )
+        if capture_reset:
+            n_forwards += 1
+        policy_config = self.od_config.model_config.get("policy_server_config", {})
+        height, width = (int(value) for value in policy_config.get("image_resolution", [180, 320]))
+        for index in range(n_forwards):
+            n_frames = 1 if index == 0 else 4
+            robot_obs = self._ar_warmup_robot_obs(height, width, n_frames, session_id)
+            sampling_params = OmniDiffusionSamplingParams(
+                extra_args={
+                    "reset": index == 0,
+                    "session_id": session_id,
+                    "robot_obs": robot_obs,
+                }
+            )
+            yield OmniDiffusionRequest(
+                prompt="warmup",
+                sampling_params=sampling_params,
+                request_id=f"ardiffusion-warmup-{index}",
+            )
+
+    def _ar_branch(self, is_negative: bool) -> str:
+        return self._NEGATIVE_BRANCH if is_negative else self._POSITIVE_BRANCH
 
     def _kv_get(self, state, is_negative, seq_len=None, update_kv_cache=False):
         return self._ar_diffusion_kv_state.get_kv_caches(
-            is_negative,
+            self._ar_branch(is_negative),
             seq_len=seq_len,
             commit_current=update_kv_cache,
         )
@@ -115,11 +259,18 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         return
 
     def _kv_commit(self, is_negative: bool):
-        self._ar_diffusion_kv_state.commit_paged_context(is_negative)
+        self._ar_diffusion_kv_state.commit_paged_context(self._ar_branch(is_negative))
 
     def _kv_get_cross(self, state, is_negative):
         """Cross-attn cache from the engine pool (text k/v + I2V image k_img/v_img)."""
-        return self._ar_diffusion_kv_state.get_cross_kv_caches(is_negative)
+        kv_branch = self._ar_branch(is_negative)
+        text_caches = self._ar_diffusion_kv_state.get_cross_attention_kv(kv_branch, "text")
+        if "image" in self._ar_diffusion_kv_state.kv_cache.cross_attention_lengths:
+            image_caches = self._ar_diffusion_kv_state.get_cross_attention_kv(kv_branch, "image")
+            for text_cache, image_cache in zip(text_caches, image_caches, strict=True):
+                text_cache["k_img"] = image_cache["k"]
+                text_cache["v_img"] = image_cache["v"]
+        return text_caches
 
     def _kv_populate_cross(self, context: torch.Tensor, clip_feature, is_negative: bool) -> None:
         """Eagerly project cross-attn K/V for all layers into the AR-Diffusion pool.
@@ -133,32 +284,41 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         after the image is encoded so ``clip_feature`` is available.
         """
         s = self._ar_diffusion_kv_state
-        need_text = not s._cross_text_populated.get(is_negative, False)
+        kv_branch = self._ar_branch(is_negative)
+        need_text = not s.is_cross_attention_populated(kv_branch, "text")
         need_img = (
             clip_feature is not None
-            and getattr(self.transformer, "model_type", "t2v") == "i2v"
-            and not s._cross_img_populated.get(is_negative, False)
+            and self.transformer.model_type == "i2v"
+            and not s.is_cross_attention_populated(kv_branch, "image")
         )
         if not need_text and not need_img:
             return
         projected = self.transformer.text_embedding(context) if need_text else None
         img_ctx = self.transformer.img_emb(clip_feature) if need_img else None
-        for i, block in enumerate(self.transformer.blocks):
-            ca = block.cross_attn
-            n, d = ca.tp_num_heads, ca.head_dim
-            k = v = None
-            if projected is not None:
-                k = ca.norm_k(ca.k(projected)).unflatten(2, (n, d))
-                v = ca.v(projected).unflatten(2, (n, d))
-            k_img = v_img = None
-            if img_ctx is not None:
-                k_img = ca.norm_k_img(ca.k_img(img_ctx)).unflatten(2, (n, d))
-                v_img = ca.v_img(img_ctx).unflatten(2, (n, d))
-            s.kv_cache.write_cross_kv(i, is_negative, k, v, k_img, v_img)
-        if need_text:
-            s._cross_text_populated[is_negative] = True
-        if need_img:
-            s._cross_img_populated[is_negative] = True
+        if projected is not None:
+
+            def text_layer_kv():
+                for block in self.transformer.blocks:
+                    ca = block.cross_attn
+                    n, d = ca.tp_num_heads, ca.head_dim
+                    yield (
+                        ca.norm_k(ca.k(projected)).unflatten(2, (n, d)),
+                        ca.v(projected).unflatten(2, (n, d)),
+                    )
+
+            s.populate_cross_attention(kv_branch, "text", text_layer_kv())
+        if img_ctx is not None:
+
+            def image_layer_kv():
+                for block in self.transformer.blocks:
+                    ca = block.cross_attn
+                    n, d = ca.tp_num_heads, ca.head_dim
+                    yield (
+                        ca.norm_k_img(ca.k_img(img_ctx)).unflatten(2, (n, d)),
+                        ca.v_img(img_ctx).unflatten(2, (n, d)),
+                    )
+
+            s.populate_cross_attention(kv_branch, "image", image_layer_kv())
         logger.info(
             "AR-Diffusion CROSS POPULATE [%s]: %d layers, text=%s img=%s",
             "neg" if is_negative else "pos",
@@ -179,7 +339,8 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         image half repopulates on the restart forward.
         """
         state.reset(clear_video_latents=clear_video_latents)
-        self._ar_diffusion_kv_state.reset(keep_cross_text=not clear_video_latents)
+        keep_cross = ("text",) if not clear_video_latents else ()
+        self._ar_diffusion_kv_state.reset(keep_cross_attention=keep_cross)
 
     def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = "") -> None:
         """Initialize pipeline components.
@@ -297,8 +458,22 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
             use_dynamic_shifting=False,
         )
 
+        # Read before the first `_get_or_create_state` below: the manager-backed
+        # state bounds its VAE encoder history to this many latent frames.
+        self.num_frame_per_block: int = ah_config["num_frame_per_block"]
+
         self._states: OrderedDict[str, DreamZeroState] = OrderedDict()
-        self._max_session_states = MAX_DREAMZERO_SESSIONS
+        # Opt-in: back per-session state with the shared SessionStateManager
+        # (RFC #4480). Default off -> the bespoke DreamZeroState path above.
+        self._use_memory_manager, mm_max_sessions = resolve_session_state_config(
+            enable=od_config.enable_session_state_manager,
+            max_sessions=MAX_DREAMZERO_SESSIONS,
+        )
+        self._memory_manager: SessionStateManager | None = (
+            SessionStateManager(max_sessions=mm_max_sessions) if self._use_memory_manager else None
+        )
+        if self._use_memory_manager:
+            logger.info("DreamZero: session state manager enabled (max_sessions=%d)", mm_max_sessions)
         self.state = self._get_or_create_state("default")
 
         # DiT step cache is configured by StepCacheBackend
@@ -312,7 +487,6 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         self.cfg_scale: float = model_config.get("cfg_scale", DEFAULT_CFG_SCALE)
         self.sigma_shift: float = model_config.get("sigma_shift", DEFAULT_SIGMA_SHIFT)
         self.num_frames: int = ah_config["num_frames"]
-        self.num_frame_per_block: int = ah_config["num_frame_per_block"]
         self.action_horizon: int = ah_config["action_horizon"]
 
         self.decouple_inference_noise: bool = ah_config["decouple_inference_noise"]
@@ -367,15 +541,23 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
             ),
         ]
 
-    def _get_or_create_state(self, session_id: str | None) -> DreamZeroState:
+    def _get_or_create_state(self, session_id: str | None) -> DreamZeroState | DreamZeroStateAdapter:
+        # getattr guards lightweight test fixtures that build the pipeline via
+        # __new__ and seed only the bespoke fields, never setting _memory_manager.
+        if getattr(self, "_memory_manager", None) is not None:
+            # The manager owns session lifecycle and LRU; the adapter is a thin
+            # per-call view over it (no second LRU to drift).
+            return DreamZeroStateAdapter(
+                session_id,
+                self._memory_manager,
+                vae_encoder_window=self.num_frame_per_block,
+            )
+
         session_key = str(session_id or "default")
         state = self._states.get(session_key)
         if state is None:
             state = DreamZeroState()
             self._states[session_key] = state
-            max_states = getattr(self, "_max_session_states", MAX_DREAMZERO_SESSIONS)
-            while len(self._states) > max_states:
-                self._states.popitem(last=False)
         else:
             self._states.move_to_end(session_key)
         return state
@@ -536,6 +718,10 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         if not torch.cuda.is_available():
             return
 
+        state = self.state
+        if state is None:
+            state = self._get_or_create_state("default")
+            self.state = state
         device = next(self.text_encoder.parameters()).device
         with torch.inference_mode():
             try:
@@ -547,18 +733,18 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
 
             try:
                 image = torch.zeros(1, 1, 3, 180, 320, dtype=torch.bfloat16, device=device)
-                self._encode_image(image, self.num_frames, 180, 320, state=self.state)
+                self._encode_image(image, self.num_frames, 180, 320, state=state)
             except Exception as exc:
                 logger.warning("DreamZero compile warmup (image_encoder) skipped: %s", exc)
 
             try:
-                self.state.reset_vae_encoder_stream()
+                state.reset_vae_encoder_stream()
                 dummy_video = torch.zeros(1, 3, 1, 180, 320, dtype=torch.bfloat16, device=device)
-                self._vae_stream_seed(self.state, dummy_video[:, :, :1])
+                self._vae_stream_seed(state, dummy_video[:, :, :1])
                 for _ in range(4):
-                    self._vae_stream_append_frame(self.state, dummy_video[:, :, :1])
+                    self._vae_stream_append_frame(state, dummy_video[:, :, :1])
                 self._vae_stream_get_observation_latents(
-                    self.state,
+                    state,
                     self.num_frame_per_block,
                     dtype=torch.bfloat16,
                 )
@@ -671,7 +857,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         height: int,
         width: int,
         *,
-        state: DreamZeroState | None = None,
+        state: DreamZeroSessionState | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         """Encode first frame via CLIP + VAE.
         Returns: (clip_feas, ys, image_latent)
@@ -762,7 +948,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         inv_std = self.vae_latents_inv_std.to(device=mu.device, dtype=mu.dtype)
         return (mu - mean) * inv_std
 
-    def _vae_stream_seed(self, state: DreamZeroState, first_frame: torch.Tensor) -> None:
+    def _vae_stream_seed(self, state: DreamZeroSessionState, first_frame: torch.Tensor) -> None:
         """Seed incremental VAE encode with the first observation frame."""
         state.reset_vae_encoder_stream()
         feat_map = self._vae_init_enc_feat_map()
@@ -774,7 +960,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         state.vae_pending_body_frames = None
         state.vae_stream_initialized = True
 
-    def _vae_stream_append_frame(self, state: DreamZeroState, new_frame: torch.Tensor) -> None:
+    def _vae_stream_append_frame(self, state: DreamZeroSessionState, new_frame: torch.Tensor) -> None:
         """Append one pixel frame and encode a 4-frame body chunk when ready."""
         if not state.vae_stream_initialized or state.vae_enc_feat_map is None or state.vae_encoder_out is None:
             raise RuntimeError("VAE encoder stream is not initialized.")
@@ -793,19 +979,27 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
                 state.vae_pending_body_frames = None
             chunk = self._vae_patchify(body)
             encoder_chunk, feat_map = self._vae_encode_encoder_chunk(chunk, state.vae_enc_feat_map)
-            state.vae_encoder_out = torch.cat([state.vae_encoder_out, encoder_chunk], dim=2)
+            state.append_vae_encoder_chunk(encoder_chunk)
             state.vae_enc_feat_map = feat_map
 
     def _vae_stream_get_observation_latents(
         self,
-        state: DreamZeroState,
+        state: DreamZeroSessionState,
         num_latent_frames: int,
         *,
         dtype: torch.dtype,
     ) -> torch.Tensor:
-        if state.vae_encoder_out is None:
+        # Read once: the manager-backed state rebuilds this from its ring.
+        encoder_out = state.vae_encoder_out
+        if encoder_out is None:
             raise RuntimeError("VAE encoder stream has no accumulated encoder output.")
-        latents = self._vae_quantize_encoder_out(state.vae_encoder_out).to(dtype=dtype)
+        # A state that bounds its encoder history keeps only the most recent
+        # frames. Asking for more than it retains would silently return a
+        # shorter (and differently padded) window, so fail instead.
+        window = state.vae_encoder_window
+        if window is not None and num_latent_frames > window:
+            raise ValueError(f"Requested {num_latent_frames} latent frames but the session retains at most {window}.")
+        latents = self._vae_quantize_encoder_out(encoder_out).to(dtype=dtype)
         if latents.shape[2] >= num_latent_frames:
             return latents[:, :, -num_latent_frames:]
         pad_count = num_latent_frames - latents.shape[2]
@@ -826,7 +1020,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
 
     def _encode_observation_latents(
         self,
-        state: DreamZeroState,
+        state: DreamZeroSessionState,
         videos: torch.Tensor,
         *,
         latent_dtype: torch.dtype,
@@ -893,7 +1087,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         frame_seqlen: int,
         seq_len: int,
         do_true_cfg: bool,
-        state: DreamZeroState,
+        state: DreamZeroSessionState,
     ) -> None:
         """Prefill KV cache with first frame and/or current observation.
 
@@ -1019,7 +1213,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         negative_prompt_embeds: torch.Tensor | None,
         video_action_scheduler: VideoActionScheduler,
         do_true_cfg: bool,
-        state: DreamZeroState,
+        state: DreamZeroSessionState,
         **kwargs,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         """Denoising loop with CFG parallel support.
@@ -1034,7 +1228,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         state_features = kwargs.get("state_features")
         embodiment_id = kwargs.get("embodiment_id")
 
-        # Shared kwargs for predict_noise (both cond & uncond branches)
+        # Shared kwargs for predict_noise (both conditional and unconditional branches)
         common_kwargs = dict(
             seq_len=seq_len,
             current_start_frame=state.current_start_frame,
@@ -1075,10 +1269,13 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
             )
 
             csf = state.current_start_frame
-            if csf + self.num_frame_per_block <= state.ys.shape[2]:
-                y = state.ys[:, :, csf : csf + self.num_frame_per_block]
+            ys = state.ys
+            if ys is None:
+                raise RuntimeError("diffuse() requires state.ys, populated by the forward pass before denoising")
+            if csf + self.num_frame_per_block <= ys.shape[2]:
+                y = ys[:, :, csf : csf + self.num_frame_per_block]
             else:
-                y = state.ys[:, :, -self.num_frame_per_block :]
+                y = ys[:, :, -self.num_frame_per_block :]
 
             run_dit = _step_cache is None or _step_cache.should_run_step(_prev_predictions)
             if run_dit:
@@ -1163,7 +1360,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
 
     @torch.no_grad()
     def forward(self, req: DiffusionRequestBatch, **kwargs) -> DiffusionOutput:
-        """Full inference step. Called by DiffusionEngine.step()."""
+        """Full inference step. Called by DiffusionEngine.step_streaming()."""
         extra_args = req.sampling_params.extra_args or {}
         robot_obs = extra_args.get("robot_obs")
         if robot_obs is None:
@@ -1236,21 +1433,14 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         text_tokens = text_inputs["input_ids"].to(device)
         attention_mask = text_inputs["attention_mask"].to(device)
 
-        # Explicit reset from OpenPI serving is carried by `extra_args["reset"]`
-        # on the next inference request after websocket reset/session switch.
-        if extra_args.get("reset", False):
+        # Explicit request reset is handled by ARDiffusionModelRunner before it
+        # binds this forward. Model-detected prompt/window resets still happen
+        # here because they depend on tokenized DreamZero state.
+        reset_reason = state.reset_reason(text_tokens, 0, self.transformer.local_attn_size)
+        if reset_reason == "session":
             self._kv_reset(state)
-        else:
-            # Auto-reset based on model state (before accumulation). Both a "session"
-            # reset and an "inference" (window-boundary) reset clear the model-local
-            # KV window, so route both through _kv_reset to drop the AR-Diffusion pool window
-            # too and stay parity-exact; "inference" keeps the accumulated video
-            # latents (reset_inference_state == reset(clear_video_latents=False)).
-            reset_reason = state.reset_reason(text_tokens, 0, self.transformer.local_attn_size)
-            if reset_reason == "session":
-                self._kv_reset(state)
-            elif reset_reason == "inference":
-                self._kv_reset(state, clear_video_latents=False)
+        elif reset_reason == "inference":
+            self._kv_reset(state, clear_video_latents=False)
         state.language = text_tokens
 
         # Frame accumulation: stitched single frame -> multi-frame video
@@ -1280,7 +1470,7 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
         if state.prompt_embeds is None:
             state.prompt_embeds = self._encode_text(text_tokens, attention_mask)
         prompt_embeds = state.prompt_embeds
-        # Negative prompt for CFG uncond branch (model constant)
+        # Negative prompt for the unconditional CFG branch (model constant)
         negative_prompt_embeds = None
         if self.cfg_scale > 1.0:
             if self._negative_prompt_embeds_cache is None:
diff --git a/vllm_omni/diffusion/models/dreamzero/state_dreamzero.py b/vllm_omni/diffusion/models/dreamzero/state_dreamzero.py
index 4c9209808..bfd4f7aa9 100644
--- a/vllm_omni/diffusion/models/dreamzero/state_dreamzero.py
+++ b/vllm_omni/diffusion/models/dreamzero/state_dreamzero.py
@@ -134,6 +134,18 @@ class DreamZeroState:
         self.vae_encoder_out: torch.Tensor | None = None
         self.vae_pending_body_frames: torch.Tensor | None = None
 
+    # How many latent frames of encoder output this state retains. ``None``
+    # means "everything", which is what this path has always done -- the
+    # accumulated output is cleared only by a session reset, so it grows for as
+    # long as the session lives. The manager-backed adapter bounds it instead.
+    vae_encoder_window: int | None = None
+
+    def append_vae_encoder_chunk(self, encoder_chunk: torch.Tensor) -> None:
+        """Append one encoded chunk to the accumulated encoder output."""
+        if self.vae_encoder_out is None:
+            raise RuntimeError("VAE encoder stream is not seeded; call reset_vae_encoder_stream first.")
+        self.vae_encoder_out = torch.cat([self.vae_encoder_out, encoder_chunk], dim=2)
+
     def reset_inference_state(self) -> None:
         """Reset KV/frame state after local attention rolls without dropping video latents."""
         self.reset(clear_video_latents=False)
diff --git a/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py b/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
index 8398cb7ab..244aeeb95 100644
--- a/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
+++ b/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
@@ -22,7 +22,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
diff --git a/vllm_omni/diffusion/models/flux/flux_transformer.py b/vllm_omni/diffusion/models/flux/flux_transformer.py
index 952ee9eb4..db36e7097 100644
--- a/vllm_omni/diffusion/models/flux/flux_transformer.py
+++ b/vllm_omni/diffusion/models/flux/flux_transformer.py
@@ -26,7 +26,7 @@ from vllm.model_executor.layers.linear import (
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.quantization.component_config import safe_quant_config
 
 if TYPE_CHECKING:
diff --git a/vllm_omni/diffusion/models/flux/pipeline_flux_kontext.py b/vllm_omni/diffusion/models/flux/pipeline_flux_kontext.py
index 0b3b80cbd..7edc4751a 100644
--- a/vllm_omni/diffusion/models/flux/pipeline_flux_kontext.py
+++ b/vllm_omni/diffusion/models/flux/pipeline_flux_kontext.py
@@ -24,6 +24,7 @@ from transformers import CLIPTextModel, CLIPTokenizer, T5EncoderModel, T5Tokeniz
 from vllm.model_executor.models.utils import AutoWeightsLoader
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.models.flux import (
@@ -72,6 +73,7 @@ def get_flux_kontext_post_process_func(od_config: OmniDiffusionConfig) -> Callab
 class FluxKontextPipeline(
     nn.Module,
     FluxPipelineMixin,
+    CFGParallelMixin,
     SupportImageInput,
     ProgressBarMixin,
     DiffusionPipelineProfilerMixin,
@@ -157,6 +159,7 @@ class FluxKontextPipeline(
         self._attention_kwargs = None
         self._joint_attention_kwargs = None
         self._num_timesteps = None
+        self._current_timestep = None
         self._interrupt = False
         self._callback_tensor_inputs = ["latents", "prompt_embeds"]
         self.latent_channels = self.vae.config.latent_channels if hasattr(self.vae, "config") else 16
@@ -465,6 +468,113 @@ class FluxKontextPipeline(
     def num_timesteps(self):
         return self._num_timesteps
 
+    @property
+    def current_timestep(self) -> torch.Tensor | None:
+        return self._current_timestep
+
+    def predict_noise(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.Tensor,
+        guidance: torch.Tensor | None,
+        pooled_projections: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        txt_ids: torch.Tensor,
+        img_ids: torch.Tensor,
+        joint_attention_kwargs: dict[str, Any] | None,
+        return_dict: bool = False,
+    ) -> torch.Tensor:
+        return self.transformer(
+            hidden_states=hidden_states,
+            timestep=timestep,
+            guidance=guidance,
+            pooled_projections=pooled_projections,
+            encoder_hidden_states=encoder_hidden_states,
+            txt_ids=txt_ids,
+            img_ids=img_ids,
+            joint_attention_kwargs=joint_attention_kwargs,
+            return_dict=return_dict,
+        )[0]
+
+    def diffuse(
+        self,
+        prompt_embeds: torch.Tensor,
+        pooled_prompt_embeds: torch.Tensor,
+        negative_prompt_embeds: torch.Tensor | None,
+        negative_pooled_prompt_embeds: torch.Tensor | None,
+        latents: torch.Tensor,
+        image_latents: torch.Tensor | None,
+        latent_ids: torch.Tensor,
+        text_ids: torch.Tensor,
+        negative_text_ids: torch.Tensor | None,
+        timesteps: torch.Tensor,
+        do_true_cfg: bool,
+        guidance: torch.Tensor | None,
+        true_cfg_scale: float,
+        callback_on_step_end: Callable[[int, int, dict], None] | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+    ) -> torch.Tensor:
+        self.scheduler.set_begin_index(0)
+        self.transformer.do_true_cfg = do_true_cfg
+        with self.progress_bar(total=len(timesteps)) as pbar:
+            for i, t in enumerate(timesteps):
+                if self.interrupt:
+                    continue
+
+                self._current_timestep = t
+                latent_model_input = latents
+                if image_latents is not None:
+                    latent_model_input = torch.cat([latents, image_latents], dim=1)
+                timestep = t.expand(latents.shape[0]).to(device=latents.device, dtype=latents.dtype)
+
+                positive_kwargs = {
+                    "hidden_states": latent_model_input,
+                    "timestep": timestep / 1000,
+                    "guidance": guidance,
+                    "pooled_projections": pooled_prompt_embeds,
+                    "encoder_hidden_states": prompt_embeds,
+                    "txt_ids": text_ids,
+                    "img_ids": latent_ids,
+                    "joint_attention_kwargs": self.joint_attention_kwargs,
+                    "return_dict": False,
+                }
+                negative_kwargs = None
+                if do_true_cfg:
+                    negative_kwargs = {
+                        "hidden_states": latent_model_input,
+                        "timestep": timestep / 1000,
+                        "guidance": guidance,
+                        "pooled_projections": negative_pooled_prompt_embeds,
+                        "encoder_hidden_states": negative_prompt_embeds,
+                        "txt_ids": negative_text_ids,
+                        "img_ids": latent_ids,
+                        "joint_attention_kwargs": self.joint_attention_kwargs,
+                        "return_dict": False,
+                    }
+
+                noise_pred = self.predict_noise_maybe_with_cfg(
+                    do_true_cfg,
+                    true_cfg_scale,
+                    positive_kwargs,
+                    negative_kwargs,
+                    cfg_normalize=False,
+                    output_slice=latents.size(1),
+                )
+
+                latents = self.scheduler_step_maybe_with_cfg(noise_pred, t, latents, do_true_cfg)
+
+                if callback_on_step_end is not None:
+                    callback_kwargs = {}
+                    for k in callback_on_step_end_tensor_inputs:
+                        callback_kwargs[k] = locals()[k]
+                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                    latents = callback_outputs.pop("latents", latents)
+                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+
+                pbar.update()
+        return latents
+
     @torch.no_grad()
     def forward(
         self,
@@ -503,8 +613,13 @@ class FluxKontextPipeline(
 
         if isinstance(first_prompt, str):
             prompt = first_prompt
+            # Keep negative_prompt from function parameter (passed via API)
         elif first_prompt:
             prompt = first_prompt.get("prompt") or ""
+            # Prefer negative_prompt from prompt dict, fallback to function parameter
+            np_from_dict = first_prompt.get("negative_prompt")
+            if np_from_dict is not None:
+                negative_prompt = np_from_dict
         # else: keep original prompt unchanged
 
         # Handle image from prompt data
@@ -524,8 +639,24 @@ class FluxKontextPipeline(
         height = req.sampling_params.height or height
         width = req.sampling_params.width or width
         num_inference_steps = req.sampling_params.num_inference_steps or num_inference_steps
-        guidance_scale = req.sampling_params.guidance_scale or guidance_scale
+        sigmas = req.sampling_params.sigmas or sigmas
+        guidance_scale = (
+            req.sampling_params.guidance_scale if req.sampling_params.guidance_scale_provided else guidance_scale
+        )
+        num_images_per_prompt = (
+            req.sampling_params.num_outputs_per_prompt
+            if req.sampling_params.num_outputs_per_prompt > 0
+            else num_images_per_prompt
+        )
+        true_cfg_scale = (
+            req.sampling_params.true_cfg_scale if req.sampling_params.true_cfg_scale is not None else true_cfg_scale
+        )
         generator = req.sampling_params.generator or generator
+        num_images_per_prompt = (
+            req.sampling_params.num_outputs_per_prompt
+            if req.sampling_params.num_outputs_per_prompt > 0
+            else num_images_per_prompt
+        )
         latents = (
             req.sampling_params.extra_args.get("latents")
             if req.sampling_params.extra_args.get("latents") is not None
@@ -568,6 +699,8 @@ class FluxKontextPipeline(
         )
         do_true_cfg = true_cfg_scale > 1.0 and has_neg_prompt
 
+        do_true_cfg = do_true_cfg and self.check_cfg_parallel_validity(true_cfg_scale, has_neg_prompt)
+
         # 1. Prepare text embeddings
         prompt_embeds, pooled_prompt_embeds, text_ids = self.encode_prompt(
             prompt=prompt,
@@ -651,57 +784,23 @@ class FluxKontextPipeline(
             self._joint_attention_kwargs = {}
 
         # 5. Denoising loop
-        self.scheduler.set_begin_index(0)
-        with self.progress_bar(total=len(timesteps)) as pbar:
-            for i, t in enumerate(timesteps):
-                if self.interrupt:
-                    continue
-
-                latent_model_input = latents
-                if image_latents is not None:
-                    latent_model_input = torch.cat([latents, image_latents], dim=1)
-                timestep = t.expand(latents.shape[0]).to(latents.dtype)
-
-                noise_pred = self.transformer(
-                    hidden_states=latent_model_input,
-                    timestep=timestep / 1000,
-                    guidance=guidance,
-                    pooled_projections=pooled_prompt_embeds,
-                    encoder_hidden_states=prompt_embeds,
-                    txt_ids=text_ids,
-                    img_ids=latent_ids,
-                    joint_attention_kwargs=self.joint_attention_kwargs,
-                    return_dict=False,
-                )[0]
-                noise_pred = noise_pred[:, : latents.size(1)]
-
-                if do_true_cfg:
-                    neg_noise_pred = self.transformer(
-                        hidden_states=latent_model_input,
-                        timestep=timestep / 1000,
-                        guidance=guidance,
-                        pooled_projections=negative_pooled_prompt_embeds,
-                        encoder_hidden_states=negative_prompt_embeds,
-                        txt_ids=negative_text_ids,
-                        img_ids=latent_ids,
-                        joint_attention_kwargs=self.joint_attention_kwargs,
-                        return_dict=False,
-                    )[0]
-                    neg_noise_pred = neg_noise_pred[:, : latents.size(1)]
-                    noise_pred = neg_noise_pred + true_cfg_scale * (noise_pred - neg_noise_pred)
-
-                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
-
-                if callback_on_step_end is not None:
-                    callback_kwargs = {}
-                    for k in callback_on_step_end_tensor_inputs:
-                        callback_kwargs[k] = locals()[k]
-                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
-
-                    latents = callback_outputs.pop("latents", latents)
-                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
-
-                pbar.update()
+        latents = self.diffuse(
+            prompt_embeds=prompt_embeds,
+            pooled_prompt_embeds=pooled_prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
+            latents=latents,
+            image_latents=image_latents,
+            latent_ids=latent_ids,
+            text_ids=text_ids,
+            negative_text_ids=negative_text_ids if do_true_cfg else None,
+            timesteps=timesteps,
+            do_true_cfg=do_true_cfg,
+            guidance=guidance,
+            true_cfg_scale=true_cfg_scale,
+            callback_on_step_end=callback_on_step_end,
+            callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+        )
         if output_type == "latent":
             image = latents
         else:
diff --git a/vllm_omni/diffusion/models/flux2/flux2_transformer.py b/vllm_omni/diffusion/models/flux2/flux2_transformer.py
index 52e0a4430..f05632efd 100644
--- a/vllm_omni/diffusion/models/flux2/flux2_transformer.py
+++ b/vllm_omni/diffusion/models/flux2/flux2_transformer.py
@@ -26,7 +26,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
@@ -765,6 +765,7 @@ class Flux2Transformer2DModel(nn.Module):
     )
 
     _repeated_blocks = ["Flux2TransformerBlock", "Flux2SingleTransformerBlock"]
+    _layerwise_offload_blocks_attrs = ["transformer_blocks", "single_transformer_blocks"]
     _sp_plan = {
         "": {
             "hidden_states": SequenceParallelInput(split_dim=1, expected_dims=3, auto_pad=True),
diff --git a/vllm_omni/diffusion/models/flux2/pipeline_flux2.py b/vllm_omni/diffusion/models/flux2/pipeline_flux2.py
index f88e582e3..0dbfe0f8c 100644
--- a/vllm_omni/diffusion/models/flux2/pipeline_flux2.py
+++ b/vllm_omni/diffusion/models/flux2/pipeline_flux2.py
@@ -11,7 +11,7 @@ from typing import Any, ClassVar, cast
 import numpy as np
 import PIL.Image
 import torch
-from diffusers import AutoencoderKLFlux2, FlowMatchEulerDiscreteScheduler
+from diffusers import FlowMatchEulerDiscreteScheduler
 from diffusers.image_processor import VaeImageProcessor
 from diffusers.pipelines.flux2.pipeline_flux2 import UPSAMPLING_MAX_IMAGE_SIZE
 from diffusers.pipelines.flux2.system_messages import (
@@ -25,6 +25,7 @@ from transformers import AutoConfig, AutoProcessor, PixtralProcessor
 from vllm.model_executor.models.utils import AutoWeightsLoader
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_flux2 import DistributedAutoencoderKLFlux2
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.parallel_state import get_classifier_free_guidance_world_size
 from vllm_omni.diffusion.distributed.utils import get_local_device
@@ -37,10 +38,17 @@ from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPi
 from vllm_omni.diffusion.utils.tf_utils import get_transformer_config_kwargs
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
+from vllm_omni.platforms import current_omni_platform
 
 logger = logging.getLogger(__name__)
 
 
+def _resolve_component_quant_config(quant_config, component: str):
+    if hasattr(quant_config, "resolve"):
+        return quant_config.resolve(component)
+    return quant_config
+
+
 class Flux2ImageProcessor(VaeImageProcessor):
     """Image processor to preprocess the reference image for Flux2."""
 
@@ -393,10 +401,14 @@ class Flux2Pipeline(
         text_encoder_config = AutoConfig.from_pretrained(
             model, subfolder="text_encoder", local_files_only=local_files_only
         )
+        te_quant_config = _resolve_component_quant_config(od_config.quantization_config, "text_encoder")
         self.text_encoder = MistralEncoderModel(
             text_encoder_config,
             prefix="text_encoder",
-        ).to(self._execution_device)
+            quant_config=te_quant_config,
+        )
+        if not any(param.is_meta for param in self.text_encoder.parameters()):
+            self.text_encoder.to(self._execution_device)
         self.tokenizer = PixtralProcessor.from_pretrained(
             model, subfolder="tokenizer", local_files_only=local_files_only
         )
@@ -405,12 +417,13 @@ class Flux2Pipeline(
             system_message_t2i=SYSTEM_MESSAGE_UPSAMPLING_T2I,
             system_message_i2i=SYSTEM_MESSAGE_UPSAMPLING_I2I,
         )
-        self.vae = AutoencoderKLFlux2.from_pretrained(model, subfolder="vae", local_files_only=local_files_only).to(
-            self._execution_device
-        )
+        self.vae = DistributedAutoencoderKLFlux2.from_pretrained(
+            model, subfolder="vae", local_files_only=local_files_only
+        ).to(self._execution_device)
         transformer_kwargs = get_transformer_config_kwargs(od_config.tf_model_config, Flux2Transformer2DModel)
+        transformer_quant_config = _resolve_component_quant_config(od_config.quantization_config, "transformer")
         self.transformer = Flux2Transformer2DModel(
-            quant_config=od_config.quantization_config, od_config=od_config, **transformer_kwargs
+            quant_config=transformer_quant_config, od_config=od_config, **transformer_kwargs
         )
 
         self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) if getattr(self, "vae", None) else 8
@@ -1148,5 +1161,26 @@ class Flux2Pipeline(
         return DiffusionOutput(output=image)
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        text_encoder_quant_config = _resolve_component_quant_config(self.od_config.quantization_config, "text_encoder")
+        transformer_quant_config = _resolve_component_quant_config(self.od_config.quantization_config, "transformer")
+        if (
+            self.od_config.enable_cpu_offload
+            and text_encoder_quant_config is not None
+            and transformer_quant_config is None
+        ):
+            weights = self._offload_transformer_before_text_encoder(weights)
+
         loader = AutoWeightsLoader(self)
         return loader.load_weights(weights)
+
+    def _offload_transformer_before_text_encoder(
+        self, weights: Iterable[tuple[str, torch.Tensor]]
+    ) -> Iterable[tuple[str, torch.Tensor]]:
+        transformer_offloaded = False
+        for name, weight in weights:
+            if not transformer_offloaded and name.startswith("text_encoder."):
+                self.transformer.to("cpu")
+                current_omni_platform.empty_cache()
+                transformer_offloaded = True
+                logger.info("Offloaded the unquantized transformer before text encoder quantization")
+            yield name, weight
diff --git a/vllm_omni/diffusion/models/flux2_klein/flux2_klein_transformer.py b/vllm_omni/diffusion/models/flux2_klein/flux2_klein_transformer.py
index e62fccba0..72bed54cb 100644
--- a/vllm_omni/diffusion/models/flux2_klein/flux2_klein_transformer.py
+++ b/vllm_omni/diffusion/models/flux2_klein/flux2_klein_transformer.py
@@ -41,7 +41,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
diff --git a/vllm_omni/diffusion/models/flux2_klein/pipeline_flux2_klein.py b/vllm_omni/diffusion/models/flux2_klein/pipeline_flux2_klein.py
index 184b5d402..a4350373b 100644
--- a/vllm_omni/diffusion/models/flux2_klein/pipeline_flux2_klein.py
+++ b/vllm_omni/diffusion/models/flux2_klein/pipeline_flux2_klein.py
@@ -271,6 +271,15 @@ class Flux2KleinPipeline(
         self.tokenizer_max_length = 512
         self.default_sample_size = 128
 
+        # text_encoder_out_layers is hardcoded to (9, 18, 27) in Diffusers,
+        # but this won't necessarily work for all text encoders. We allow
+        # setting the text_encoder_out_layers in the config to allow
+        # custom text encoders
+        if hasattr(self.text_encoder.config, "text_encoder_out_layers"):
+            self.text_encoder_out_layers = self.text_encoder.config.text_encoder_out_layers
+        else:
+            self.text_encoder_out_layers = (9, 18, 27)
+
         self._guidance_scale = None
         self._attention_kwargs = None
         self._num_timesteps = None
@@ -293,10 +302,10 @@ class Flux2KleinPipeline(
         text_encoder: Qwen3ForCausalLM,
         tokenizer: Qwen2TokenizerFast,
         prompt: str | list[str],
+        hidden_states_layers: tuple[int, ...],
         dtype: torch.dtype | None = None,
         device: torch.device | None = None,
         max_sequence_length: int = 512,
-        hidden_states_layers: list[int] = (9, 18, 27),
     ):
         dtype = text_encoder.dtype if dtype is None else dtype
         device = text_encoder.device if device is None else device
@@ -513,7 +522,6 @@ class Flux2KleinPipeline(
         num_images_per_prompt: int = 1,
         prompt_embeds: torch.Tensor | None = None,
         max_sequence_length: int = 512,
-        text_encoder_out_layers: tuple[int, ...] = (9, 18, 27),
     ):
         device = device or self._execution_device
 
@@ -527,9 +535,9 @@ class Flux2KleinPipeline(
                 text_encoder=self.text_encoder,
                 tokenizer=self.tokenizer,
                 prompt=prompt,
+                hidden_states_layers=self.text_encoder_out_layers,
                 device=device,
                 max_sequence_length=max_sequence_length,
-                hidden_states_layers=text_encoder_out_layers,
             )
 
         batch_size, seq_len, _ = prompt_embeds.shape
@@ -795,9 +803,6 @@ class Flux2KleinPipeline(
         latents = req.sampling_params.latents
         strength = req.sampling_params.strength if req.sampling_params.strength is not None else 1.0
 
-        text_encoder_out_layers: tuple[int, ...] = req.sampling_params.extra_args.get(
-            "text_encoder_out_layers", (9, 18, 27)
-        )
         padding_mask_crop: int | None = req.sampling_params.extra_args.get("padding_mask_crop")
         attention_kwargs: dict[str, Any] | None = None
         callback_on_step_end: Callable[[int, int, dict], None] | None = None
@@ -833,7 +838,6 @@ class Flux2KleinPipeline(
             device=device,
             num_images_per_prompt=num_images_per_prompt,
             max_sequence_length=max_sequence_length,
-            text_encoder_out_layers=text_encoder_out_layers,
         )
 
         if self.do_classifier_free_guidance:
@@ -846,7 +850,6 @@ class Flux2KleinPipeline(
                 device=device,
                 num_images_per_prompt=num_images_per_prompt,
                 max_sequence_length=max_sequence_length,
-                text_encoder_out_layers=text_encoder_out_layers,
             )
 
         # 4. process images
diff --git a/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py b/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py
index c933d4e7f..75ba60203 100644
--- a/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py
+++ b/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py
@@ -21,7 +21,7 @@ from vllm.model_executor.layers.linear import (
 )
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 
 if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
diff --git a/vllm_omni/diffusion/models/glm_image/pipeline_glm_image.py b/vllm_omni/diffusion/models/glm_image/pipeline_glm_image.py
index 9f3d29400..6ceb5959b 100644
--- a/vllm_omni/diffusion/models/glm_image/pipeline_glm_image.py
+++ b/vllm_omni/diffusion/models/glm_image/pipeline_glm_image.py
@@ -733,7 +733,7 @@ class GlmImagePipeline(nn.Module, DiffusionPipelineProfilerMixin, SupportsCompon
         )
         width = ar_width or req.sampling_params.width or img_width or self.default_sample_size * self.vae_scale_factor
         num_inference_steps = req.sampling_params.num_inference_steps or 50
-        guidance_scale = req.sampling_params.guidance_scale or 1.5
+        guidance_scale = req.sampling_params.guidance_scale if req.sampling_params.guidance_scale_provided else 1.5
 
         # Ensure dimensions are multiples of vae_scale_factor * patch_size
         multiple_of = self.vae_scale_factor * self._patch_size
diff --git a/vllm_omni/diffusion/models/helios/helios_transformer.py b/vllm_omni/diffusion/models/helios/helios_transformer.py
index 730c10f1c..4e3cf5078 100644
--- a/vllm_omni/diffusion/models/helios/helios_transformer.py
+++ b/vllm_omni/diffusion/models/helios/helios_transformer.py
@@ -26,7 +26,7 @@ from vllm.model_executor.layers.linear import ColumnParallelLinear, QKVParallelL
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
     SequenceParallelOutput,
diff --git a/vllm_omni/diffusion/models/helios/pipeline_helios.py b/vllm_omni/diffusion/models/helios/pipeline_helios.py
index 12ecda368..cb11eb847 100644
--- a/vllm_omni/diffusion/models/helios/pipeline_helios.py
+++ b/vllm_omni/diffusion/models/helios/pipeline_helios.py
@@ -29,6 +29,7 @@ from vllm_omni.diffusion.models.helios.scheduling_helios import HeliosScheduler
 from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
+from vllm_omni.diffusion.prompt_update import PromptUpdateMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 from vllm_omni.platforms import current_omni_platform
@@ -37,7 +38,7 @@ if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
 
     from vllm_omni.diffusion.worker.input_batch import InputBatch
-    from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+    from vllm_omni.diffusion.worker.utils import StepRequestState
 
 logger = logging.getLogger(__name__)
 
@@ -155,7 +156,12 @@ def get_helios_pre_process_func(
 
 
 class HeliosPipeline(
-    nn.Module, CFGParallelMixin, ProgressBarMixin, DiffusionPipelineProfilerMixin, SupportsComponentDiscovery
+    nn.Module,
+    CFGParallelMixin,
+    ProgressBarMixin,
+    DiffusionPipelineProfilerMixin,
+    PromptUpdateMixin,
+    SupportsComponentDiscovery,
 ):
     """Helios text-to-video / image-to-video / video-to-video pipeline for vllm-omni.
 
@@ -279,9 +285,9 @@ class HeliosPipeline(
 
     def prepare_encode(
         self,
-        state: DiffusionRequestState,
+        state: StepRequestState,
         **kwargs: Any,
-    ) -> DiffusionRequestState:
+    ) -> StepRequestState:
         """Initialize Helios request state for chunk-wise step execution."""
         del kwargs
         # Wrap the single request in a DiffusionRequestBatch so the batch
@@ -530,7 +536,7 @@ class HeliosPipeline(
         self._prepare_next_chunk(state)
         return state
 
-    def _prepare_next_chunk(self, state: DiffusionRequestState) -> None:
+    def _prepare_next_chunk(self, state: StepRequestState) -> None:
         extra = state.extra
         k = state.chunk_index
         is_first_chunk = k == 0
@@ -604,7 +610,7 @@ class HeliosPipeline(
         state.step_index = 0
         self._num_timesteps = state.chunk_num_steps
 
-    def _prepare_stage2_chunk(self, state: DiffusionRequestState) -> None:
+    def _prepare_stage2_chunk(self, state: StepRequestState) -> None:
         extra = state.extra
         batch_size, num_channel, num_frames_lat, height, width = state.latents.shape
         latents_flat = state.latents.permute(0, 2, 1, 3, 4).reshape(
@@ -634,7 +640,7 @@ class HeliosPipeline(
             return num_steps * 2
         return num_steps
 
-    def _set_stage2_timesteps(self, state: DiffusionRequestState) -> None:
+    def _set_stage2_timesteps(self, state: StepRequestState) -> None:
         extra = state.extra
         patch_size = self.transformer.config.patch_size
         image_seq_len = (state.latents.shape[-1] * state.latents.shape[-2] * state.latents.shape[-3]) // (
@@ -655,7 +661,7 @@ class HeliosPipeline(
     def denoise_step(
         self,
         input_batch: InputBatch,
-        states: Sequence[DiffusionRequestState],
+        states: Sequence[StepRequestState],
         **kwargs: Any,
     ) -> torch.Tensor | None:
         del kwargs
@@ -668,7 +674,7 @@ class HeliosPipeline(
 
     def _denoise_stage1_step(
         self,
-        state: DiffusionRequestState,
+        state: StepRequestState,
         latents: torch.Tensor,
         timesteps: torch.Tensor,
     ) -> torch.Tensor:
@@ -727,7 +733,7 @@ class HeliosPipeline(
             cfg_normalize=False,
         )
 
-    def _denoise_stage2_step(self, state: DiffusionRequestState) -> torch.Tensor:
+    def _denoise_stage2_step(self, state: StepRequestState) -> torch.Tensor:
         extra = state.extra
         latents = state.latents
         assert latents is not None
@@ -773,7 +779,7 @@ class HeliosPipeline(
 
     def step_scheduler(
         self,
-        state: DiffusionRequestState,
+        state: StepRequestState,
         noise_pred: torch.Tensor,
         **kwargs: Any,
     ) -> None:
@@ -800,7 +806,7 @@ class HeliosPipeline(
             state.step_in_chunk += 1
             state.step_index = state.step_in_chunk
 
-    def _step_scheduler_stage2(self, state: DiffusionRequestState, noise_pred: torch.Tensor) -> None:
+    def _step_scheduler_stage2(self, state: StepRequestState, noise_pred: torch.Tensor) -> None:
         extra = state.extra
         t = state.current_timestep
         assert t is not None and state.latents is not None
@@ -866,7 +872,7 @@ class HeliosPipeline(
 
     def post_decode(
         self,
-        state: DiffusionRequestState,
+        state: StepRequestState,
         **kwargs: Any,
     ) -> DiffusionOutput:
         del kwargs
@@ -894,9 +900,12 @@ class HeliosPipeline(
 
         output = current_latents if extra["output_type"] == "latent" else current_video
         completed_chunk_index = state.chunk_index
+        prompt_update_metadata = state.extra.pop("prompt_update_chunk_metadata", {})
         state.chunk_index += 1
         finished = state.request_denoise_completed
         if not finished:
+            # Apply queued/advancing prompt updates before preparing the next chunk.
+            self._apply_prompt_update_at_chunk_boundary(state)
             self._prepare_next_chunk(state)
         else:
             self._current_timestep = None
@@ -908,6 +917,9 @@ class HeliosPipeline(
             stage_durations=self.stage_durations if hasattr(self, "stage_durations") else {},
             chunk_index=completed_chunk_index,
             total_chunks=state.total_chunks,
+            started_event_ids=prompt_update_metadata.get("started_event_ids", []),
+            active_event_ids=prompt_update_metadata.get("active_event_ids", []),
+            completed_event_ids=prompt_update_metadata.get("completed_event_ids", []),
             finished=finished,
         )
 
@@ -1561,11 +1573,12 @@ class HeliosPipeline(
 
         device = generator.device if generator is not None else self.device
 
-        cov = torch.eye(block_size) * (1 + gamma) - torch.ones(block_size, block_size) * gamma
-        cov += torch.eye(block_size) * 1e-8
-        cov = cov.float()  # Upcast to fp32 for numerical stability — cholesky is unreliable in fp16/bf16.
-
-        L = torch.linalg.cholesky(cov).to(device)
+        # Allocate directly on the execution device in float32 to use the device solver
+        # and avoid fp16/bf16 Cholesky on the covariance matrix.
+        eye = torch.eye(block_size, device=device, dtype=torch.float32)
+        cov = eye * (1 + gamma) - torch.ones(block_size, block_size, device=device, dtype=torch.float32) * gamma
+        cov += eye * 1e-8
+        L = torch.linalg.cholesky(cov)
         block_number = batch_size * channel * num_frames * (height // ph) * (width // pw)
         z = torch.randn(block_number, block_size, generator=generator, device=device)
         noise = z @ L.T
@@ -1584,12 +1597,13 @@ class HeliosPipeline(
         negative_prompt: str | list[str] | None = None,
         do_classifier_free_guidance: bool = True,
         num_videos_per_prompt: int = 1,
-        max_sequence_length: int = 226,
+        max_sequence_length: int | None = None,
         device: torch.device | None = None,
         dtype: torch.dtype | None = None,
     ):
         device = device or self.device
         dtype = dtype or self.text_encoder.dtype
+        max_sequence_length = max_sequence_length or 226
 
         prompt = [prompt] if isinstance(prompt, str) else prompt
         prompt_clean = [self._prompt_clean(p) for p in prompt]
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/__init__.py b/vllm_omni/diffusion/models/hunyuan_image3/__init__.py
index 6612bd855..625895d99 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/__init__.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/__init__.py
@@ -2,7 +2,6 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Hunyuan Image 3 diffusion model components."""
 
-from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe import HunyuanFusedMoE
 from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_image3_transformer import (
     HunyuanImage3Model,
     HunyuanImage3Text2ImagePipeline,
@@ -11,4 +10,4 @@ from vllm_omni.diffusion.models.hunyuan_image3.pipeline_hunyuan_image3 import (
     HunyuanImage3Pipeline,
 )
 
-__all__ = ["HunyuanImage3Pipeline", "HunyuanImage3Model", "HunyuanImage3Text2ImagePipeline", "HunyuanFusedMoE"]
+__all__ = ["HunyuanImage3Pipeline", "HunyuanImage3Model", "HunyuanImage3Text2ImagePipeline"]
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_tokenizer.py b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_tokenizer.py
index 751bfb21a..e7bb75fbe 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_tokenizer.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_tokenizer.py
@@ -384,7 +384,7 @@ class TokenizerWrapper:
                     drop_last_break = True
                     break
                 if source.get("front_boi", use_front_boi_token):
-                    token_seq.append(self.boi_token_id)  # Use patched boi for Janus, otherwise useing default <boi>
+                    token_seq.append(self.boi_token_id)  # Use patched boi for Janus, otherwise using default <boi>
                     extra_token_pos["boi"].append(token_count)
                     token_count += 1
                 token_count = self._add_image_meta_info_token(
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
index f38d1ca7c..877fd1c3f 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/hunyuan_image3_transformer.py
@@ -60,8 +60,9 @@ from vllm_omni.diffusion.attention.backends.abstract import (
     AttentionMetadata,
 )
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.distributed.parallel_state import (
+    get_allgather_parallel_world_size,
     get_cfg_group,
     get_classifier_free_guidance_rank,
     get_classifier_free_guidance_world_size,
@@ -75,10 +76,12 @@ from vllm_omni.diffusion.distributed.sp_plan import (
 )
 from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
+from vllm_omni.diffusion.layers.fused_moe import FusedMoE
 from vllm_omni.diffusion.layers.norm import RMSNorm
 from vllm_omni.diffusion.layers.rope import RotaryEmbedding
-from vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe import HunyuanFusedMoE
+from vllm_omni.diffusion.utils.kv_utils import repeat_kv
 from vllm_omni.model_executor.layers.timestep_embedding import timestep_embedding
+from vllm_omni.platforms import current_omni_platform
 
 logger = logging.getLogger(__name__)
 
@@ -426,22 +429,6 @@ def apply_rotary_pos_emb(
     return q_embed, k_embed
 
 
-def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
-    """
-    Equivalent to torch.repeat_interleave(x, dim=2, repeats=n_rep).
-    Input:  (batch, seqlen, num_key_value_heads, head_dim)
-    Output: (batch, seqlen, num_attention_heads, head_dim)
-    """
-    batch, slen, num_key_value_heads, head_dim = hidden_states.shape
-
-    if n_rep == 1:
-        return hidden_states
-
-    hidden_states = hidden_states[:, :, :, None, :].expand(batch, slen, num_key_value_heads, n_rep, head_dim)
-
-    return hidden_states.reshape(batch, slen, num_key_value_heads * n_rep, head_dim)
-
-
 def default(value, default_value):
     return value if value is not None else default_value
 
@@ -957,6 +944,7 @@ class ImageKVCacheManager:
         self._injected_ar_kv: list[tuple[torch.Tensor, torch.Tensor]] | None = None
 
         self.sp_size = get_sequence_parallel_world_size()
+        self.allgather_size = get_allgather_parallel_world_size()
         self.sp_rank = get_sequence_parallel_rank()
         self.attn = Attention(
             num_heads=self.num_heads,
@@ -1130,6 +1118,7 @@ class ImageKVCacheManager:
         head_num_per_rank = query.shape[1]
         kv_head_num_per_rank = key.shape[1]
         repeat_num = head_num_per_rank // kv_head_num_per_rank
+        keep_kv_compressed = self.allgather_size > 1
         head_dim = query.shape[2]
 
         query = query.reshape(bs, q_len, head_num_per_rank, head_dim)
@@ -1171,11 +1160,12 @@ class ImageKVCacheManager:
                 joint_text_query = query[:, :0, :, :]
                 joint_text_key, joint_text_value = self._reuse_prompt_kv(key, value, seq_len, bs, shard_image_size)
 
-        key = repeat_kv(key, repeat_num)
-        value = repeat_kv(value, repeat_num)
-        if self.sp_size > 1:
-            joint_text_key = repeat_kv(joint_text_key, repeat_num)
-            joint_text_value = repeat_kv(joint_text_value, repeat_num)
+        if not keep_kv_compressed:
+            key = repeat_kv(key, repeat_num)
+            value = repeat_kv(value, repeat_num)
+            if self.sp_size > 1:
+                joint_text_key = repeat_kv(joint_text_key, repeat_num)
+                joint_text_value = repeat_kv(joint_text_value, repeat_num)
 
         attention_mask = attention_mask.contiguous()
 
@@ -1631,7 +1621,7 @@ class HunYuanSparseMoeBlock(nn.Module):
             self.shared_mlp = None
 
         enable_expert_parallel = get_current_vllm_config().parallel_config.enable_expert_parallel
-        self.experts = HunyuanFusedMoE(
+        self.experts = FusedMoE(
             shared_experts=self.shared_mlp,
             num_experts=self.n_routed_experts,
             top_k=top_k,
@@ -2111,7 +2101,7 @@ class HunyuanImage3Model(nn.Module):
         if _is_moe(self.config):
             # Params for weights, fp8 weight scales, fp8 activation scales
             # (param_name, weight_name, expert_id, shard_id)
-            fused_moe_expert_mapping = HunyuanFusedMoE.make_expert_params_mapping(
+            fused_moe_expert_mapping = FusedMoE.make_expert_params_mapping(
                 self,
                 ckpt_gate_proj_name="gate_proj",
                 ckpt_down_proj_name="down_proj",
@@ -2392,6 +2382,8 @@ class HunyuanImage3Model(nn.Module):
         ar_kv_reuse_len: int = 0,
         full_attn_spans: list[list[tuple[int, int]]] | None = None,
     ) -> tuple | BaseModelOutputWithPast:
+        current_omni_platform.reset_diffusion_fused_moe_forward_context()
+
         output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
         output_hidden_states = (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
@@ -3241,8 +3233,7 @@ class HunyuanImage3Text2ImagePipeline(DiffusionPipeline):
             assert image.shape[2] == 1, "image should have shape [B, C, T, H, W] and T should be 1"
             image = image.squeeze(2)
 
-        do_denormalize = [True] * image.shape[0]
-        image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
+        # Denormalize + PIL moved to engine post_process_func for overlap with next request.
 
         if not return_dict:
             return (image,)
diff --git a/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py b/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
index c0476b879..36e69302e 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/pipeline_hunyuan_image3.py
@@ -54,7 +54,7 @@ from .system_prompt import get_system_prompt
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.worker.input_batch import InputBatch
-    from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+    from vllm_omni.diffusion.worker.utils import StepRequestState
 
 logger = logging.getLogger(__name__)
 
@@ -71,6 +71,8 @@ _STEP_COT_TEXT_LIST = "hunyuan_cot_text_list"
 _STEP_AR_KV = "hunyuan_ar_kv"
 _STEP_PROMPT_KV = "hunyuan_prompt_kv"
 
+_HUNYUAN_DEFAULT_OUTPUT_TYPE = "pil"
+
 
 def default(val, d):
     return val if val is not None else d
@@ -333,6 +335,41 @@ def get_hunyuan_image_3_pre_process_func(od_config: OmniDiffusionConfig):
     return pre_process_func
 
 
+def get_hunyuan_image3_post_process_func(od_config: OmniDiffusionConfig):
+    """GPU tensor → PIL, runs outside pipeline_forward to overlap with next request."""
+    from diffusers.image_processor import VaeImageProcessor
+
+    image_processor = VaeImageProcessor()
+
+    def post_process_func(images: torch.Tensor | dict):
+        # Handle dict envelope format (upstream): {"payload": {"image": ...}, "metadata": ...}
+        if isinstance(images, dict) and "payload" in images:
+            tensor = images["payload"].get("image")
+            if tensor is None:
+                return images
+            if tensor.dim() == 3:
+                tensor = tensor.unsqueeze(0)
+            do_denormalize = [True] * tensor.shape[0]
+            images["payload"]["image"] = image_processor.postprocess(
+                tensor,
+                output_type=_HUNYUAN_DEFAULT_OUTPUT_TYPE,
+                do_denormalize=do_denormalize,
+            )
+            return images
+
+        # Legacy raw tensor format
+        if images.dim() == 3:
+            images = images.unsqueeze(0)
+        do_denormalize = [True] * images.shape[0]
+        return image_processor.postprocess(
+            images,
+            output_type=_HUNYUAN_DEFAULT_OUTPUT_TYPE,
+            do_denormalize=do_denormalize,
+        )
+
+    return post_process_func
+
+
 class HunyuanImage3Pipeline(
     HunyuanImage3PreTrainedModel,
     GenerationMixin,
@@ -486,7 +523,7 @@ class HunyuanImage3Pipeline(
             self._pipeline = HunyuanImage3Text2ImagePipeline(model=self, scheduler=self.scheduler, vae=self.vae)
         return self._pipeline
 
-    def _validate_step_request(self, state: "DiffusionRequestState") -> None:
+    def _validate_step_request(self, state: "StepRequestState") -> None:
         prompt = state.prompt
         sampling = state.sampling
         if prompt is None:
@@ -584,7 +621,7 @@ class HunyuanImage3Pipeline(
 
     def _extract_step_prompt_inputs(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
     ) -> tuple[list[str], list[str | None], str | None, list[list[JointImageInfo]] | None, str]:
         sampling = state.sampling
         return self._extract_prompt_inputs(
@@ -610,7 +647,7 @@ class HunyuanImage3Pipeline(
 
     def _restore_injected_ar_kv(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         row_state_indexes: list[int],
         row_branches: list[int],
     ) -> None:
@@ -755,7 +792,7 @@ class HunyuanImage3Pipeline(
 
     def _prompt_kv_prefix_lens(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         row_state_indexes: list[int],
         row_branches: list[int],
     ) -> list[int] | None:
@@ -774,7 +811,7 @@ class HunyuanImage3Pipeline(
 
     def _merge_step_model_inputs(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         row_state_indexes: list[int],
         row_branches: list[int],
         first_step: bool,
@@ -828,7 +865,7 @@ class HunyuanImage3Pipeline(
 
     def _restore_prompt_kv_cache(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         row_state_indexes: list[int],
         row_branches: list[int],
     ) -> None:
@@ -855,7 +892,7 @@ class HunyuanImage3Pipeline(
 
     def _capture_prompt_kv_cache(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         row_state_indexes: list[int],
         row_branches: list[int],
     ) -> None:
@@ -1838,9 +1875,9 @@ class HunyuanImage3Pipeline(
 
     def prepare_encode(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         **kwargs: Any,
-    ) -> "DiffusionRequestState":
+    ) -> "StepRequestState":
         del kwargs
         self._validate_step_request(state)
         pipe = self.pipeline
@@ -1955,7 +1992,7 @@ class HunyuanImage3Pipeline(
         }
         return state
 
-    def _step_group_key(self, state: "DiffusionRequestState") -> tuple[Any, ...]:
+    def _step_group_key(self, state: "StepRequestState") -> tuple[Any, ...]:
         if _STEP_CFG_FACTOR not in state.extra:
             raise ValueError(f"Missing Hunyuan CFG factor for request {state.request_id}.")
         if _STEP_MODEL_KWARGS not in state.extra:
@@ -1989,16 +2026,16 @@ class HunyuanImage3Pipeline(
 
     def _split_step_groups(
         self,
-        states: list["DiffusionRequestState"],
-    ) -> list[list["DiffusionRequestState"]]:
-        grouped: dict[tuple[Any, ...], list[DiffusionRequestState]] = {}
+        states: list["StepRequestState"],
+    ) -> list[list["StepRequestState"]]:
+        grouped: dict[tuple[Any, ...], list[StepRequestState]] = {}
         for state in states:
             grouped.setdefault(self._step_group_key(state), []).append(state)
         return list(grouped.values())
 
     @staticmethod
     def _step_row_order(
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         cfg_factor: int,
     ) -> tuple[list[int], list[int]]:
         row_state_indexes = [state_idx for _ in range(cfg_factor) for state_idx in range(len(states))]
@@ -2006,7 +2043,7 @@ class HunyuanImage3Pipeline(
         return row_state_indexes, row_branches
 
     @staticmethod
-    def _validate_step_group_states(states: list["DiffusionRequestState"]) -> tuple[bool, int]:
+    def _validate_step_group_states(states: list["StepRequestState"]) -> tuple[bool, int]:
         if not states:
             raise ValueError("HunyuanImage3 denoise_step received an empty group.")
 
@@ -2043,7 +2080,7 @@ class HunyuanImage3Pipeline(
 
     def _split_merged_kwargs_to_states(
         self,
-        states: list["DiffusionRequestState"],
+        states: list["StepRequestState"],
         merged_kwargs: dict[str, Any],
         row_state_indexes: list[int],
         row_branches: list[int],
@@ -2094,7 +2131,7 @@ class HunyuanImage3Pipeline(
             state.extra[_STEP_MODEL_KWARGS] = next_kwargs
             state.extra[_STEP_INPUT_IDS] = None
 
-    def _denoise_step_group(self, states: list["DiffusionRequestState"]) -> torch.Tensor:
+    def _denoise_step_group(self, states: list["StepRequestState"]) -> torch.Tensor:
         first_step, cfg_factor = self._validate_step_group_states(states)
         row_state_indexes, row_branches = self._step_row_order(states, cfg_factor)
         latents = torch.cat([state.latents for state in states], dim=0)
@@ -2179,7 +2216,7 @@ class HunyuanImage3Pipeline(
 
     def step_scheduler(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         noise_pred: torch.Tensor,
         **kwargs: Any,
     ) -> None:
@@ -2200,7 +2237,7 @@ class HunyuanImage3Pipeline(
 
     def post_decode(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         **kwargs: Any,
     ) -> DiffusionOutput:
         output_type = kwargs.get("output_type", "pil")
@@ -2224,11 +2261,7 @@ class HunyuanImage3Pipeline(
         if hasattr(self.vae, "ffactor_temporal"):
             assert image.shape[2] == 1, "image should have shape [B, C, T, H, W] and T should be 1"
             image = image.squeeze(2)
-        image = self.pipeline.image_processor.postprocess(
-            image,
-            output_type=output_type,
-            do_denormalize=[True] * image.shape[0],
-        )
+        # Postprocess deferred to engine post_process_func for overlap with next request.
 
         cot_text_list = state.extra.get(_STEP_COT_TEXT_LIST) or []
         metadata = {}
diff --git a/vllm_omni/diffusion/models/hunyuan_video/hunyuan_video_15_transformer.py b/vllm_omni/diffusion/models/hunyuan_video/hunyuan_video_15_transformer.py
index 9224973dd..04862fe0a 100644
--- a/vllm_omni/diffusion/models/hunyuan_video/hunyuan_video_15_transformer.py
+++ b/vllm_omni/diffusion/models/hunyuan_video/hunyuan_video_15_transformer.py
@@ -23,7 +23,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.hsdp_utils import is_transformer_block_module
 from vllm_omni.diffusion.distributed.parallel_state import get_sequence_parallel_world_size
diff --git a/vllm_omni/diffusion/models/interface.py b/vllm_omni/diffusion/models/interface.py
index 657a45bf8..1f2c8c226 100644
--- a/vllm_omni/diffusion/models/interface.py
+++ b/vllm_omni/diffusion/models/interface.py
@@ -13,11 +13,13 @@ from typing import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     import torch
 
     from vllm_omni.diffusion.data import DiffusionOutput
     from vllm_omni.diffusion.worker.input_batch import InputBatch
-    from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+    from vllm_omni.diffusion.worker.utils import StepRequestState
 
 
 @runtime_checkable
@@ -54,19 +56,21 @@ class SupportsStepExecution(Protocol):
 
     supports_step_execution: ClassVar[bool] = True
 
-    def prepare_encode(self, state: DiffusionRequestState, **kwargs: Any) -> DiffusionRequestState:
+    def prepare_encode(self, state: StepRequestState, **kwargs: Any) -> StepRequestState:
         """Prepare request-level inputs and return initialized state."""
         ...
 
-    def denoise_step(self, input_batch: InputBatch, **kwargs: Any) -> torch.Tensor | None:
+    def denoise_step(
+        self, input_batch: InputBatch, *, states: Sequence[StepRequestState] | None = None, **kwargs: Any
+    ) -> torch.Tensor | None:
         """Run one denoise forward on the runner-assembled batch."""
         ...
 
-    def step_scheduler(self, state: DiffusionRequestState, noise_pred: torch.Tensor, **kwargs: Any) -> None:
+    def step_scheduler(self, state: StepRequestState, noise_pred: torch.Tensor, **kwargs: Any) -> None:
         """Run one scheduler step."""
         ...
 
-    def post_decode(self, state: DiffusionRequestState, **kwargs: Any) -> DiffusionOutput:
+    def post_decode(self, state: StepRequestState, **kwargs: Any) -> DiffusionOutput:
         """Decode output after denoise loop or at a partial chunk boundary."""
         ...
 
@@ -100,3 +104,30 @@ def supports_step_execution(pipeline: object) -> bool:
     """Return whether `pipeline` implements :class:`SupportsStepExecution`."""
 
     return isinstance(pipeline, SupportsStepExecution)
+
+
+@runtime_checkable
+class SupportsPromptUpdate(Protocol):
+    """Optional protocol for pipelines that support midway prompt updates.
+
+    Pipelines typically implement this via
+    :class:`~vllm_omni.diffusion.prompt_update.PromptUpdateMixin`.
+    """
+
+    supports_prompt_update: ClassVar[bool] = True
+
+    def prepare_prompt_update(
+        self,
+        state: StepRequestState,
+        prompt: str,
+        event_id: str,
+        transition_chunks: int | None = None,
+    ) -> None:
+        """Encode and queue a prompt update on request-local state."""
+        ...
+
+
+def supports_prompt_update(pipeline: object) -> bool:
+    """Return whether ``pipeline`` implements :class:`SupportsPromptUpdate`."""
+
+    return isinstance(pipeline, SupportsPromptUpdate)
diff --git a/vllm_omni/diffusion/models/lingbot_video/__init__.py b/vllm_omni/diffusion/models/lingbot_video/__init__.py
new file mode 100644
index 000000000..013f7b2c3
--- /dev/null
+++ b/vllm_omni/diffusion/models/lingbot_video/__init__.py
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from vllm_omni.diffusion.models.lingbot_video.lingbot_video_transformer import (
+    LingBotVideoTransformer3DModel,
+)
+from vllm_omni.diffusion.models.lingbot_video.pipeline_lingbot_video import (
+    LingBotVideoPipeline,
+    get_lingbot_video_post_process_func,
+)
+
+__all__ = [
+    "LingBotVideoPipeline",
+    "LingBotVideoTransformer3DModel",
+    "get_lingbot_video_post_process_func",
+]
diff --git a/vllm_omni/diffusion/models/lingbot_video/lingbot_video_transformer.py b/vllm_omni/diffusion/models/lingbot_video/lingbot_video_transformer.py
new file mode 100644
index 000000000..ad820eba3
--- /dev/null
+++ b/vllm_omni/diffusion/models/lingbot_video/lingbot_video_transformer.py
@@ -0,0 +1,1005 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# Adapted from LingBot-Video (https://github.com/Robbyant/lingbot-video).
+
+import math
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.embeddings import TimestepEmbedding, Timesteps
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from diffusers.models.modeling_utils import ModelMixin
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.utils.fa import (
+    flash_attn_varlen_func as flash_attn_varlen_func_v3,
+)
+from vllm_omni.diffusion.attention.layer import Attention
+
+LINGBOT_VIDEO_FP32_MODULES = (
+    "time_embedder",
+    "time_modulation",
+    "scale_shift_table",
+    "norm",
+    "norm1",
+    "norm2",
+    "norm_q",
+    "norm_k",
+    "norm_post_attn",
+    "norm_post_ffn",
+    "norm_out",
+    "norm_out_modulation",
+    "router",
+)
+
+
+def should_keep_in_fp32(name: str) -> bool:
+    return any(module_name in name.split(".") for module_name in LINGBOT_VIDEO_FP32_MODULES)
+
+
+def _all_to_all_split_cat(
+    local_input: torch.Tensor,
+    scatter_dim: int,
+    gather_dim: int,
+    group: dist.ProcessGroup,
+) -> torch.Tensor:
+    world_size = dist.get_world_size(group)
+    input_list = [tensor.contiguous() for tensor in torch.tensor_split(local_input, world_size, scatter_dim)]
+    output_list = [torch.empty_like(input_list[0]) for _ in range(world_size)]
+    dist.all_to_all(output_list, input_list, group=group)
+    return torch.cat(output_list, dim=gather_dim).contiguous()
+
+
+class LingBotVideoRMSNorm(nn.Module):
+    """RMSNorm with fp32 accumulation."""
+
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(dim))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return (self.weight * hidden_states).to(input_dtype)
+
+
+def apply_rotary_emb(x: torch.Tensor, freqs_cis: torch.Tensor) -> torch.Tensor:
+    """Apply complex RoPE to `(B, S, H, D)` attention tensors."""
+    with torch.amp.autocast("cuda", enabled=False):
+        x_c = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2))
+        out = torch.view_as_real(x_c * freqs_cis.unsqueeze(2)).flatten(3)
+        return out.type_as(x)
+
+
+class LingBotVideoRotaryEmbedding(nn.Module):
+    """Complex64 RoPE table indexed by position ids."""
+
+    def __init__(self, axes_dims: tuple[int, ...], axes_lens: tuple[int, ...], theta: float):
+        super().__init__()
+        self.axes_dims = tuple(axes_dims)
+        self.axes_lens = list(axes_lens)
+        self.theta = theta
+        self.freqs_cis = None
+
+    @staticmethod
+    def precompute_freqs_cis(dim: tuple[int, ...], end: tuple[int, ...], theta: float):
+        freqs_cis = []
+        for d, e in zip(dim, end):
+            freqs = 1.0 / (theta ** (torch.arange(0, d, 2, dtype=torch.float64, device="cpu") / d))
+            timestep = torch.arange(e, device=freqs.device, dtype=torch.float64)
+            freqs = torch.outer(timestep, freqs).float()
+            freqs_cis.append(torch.polar(torch.ones_like(freqs), freqs).to(torch.complex64))
+        return freqs_cis
+
+    def forward(self, position_ids: torch.Tensor) -> torch.Tensor:
+        # position_ids: (S, 3) int -> (S, head_dim/2) complex64
+        device = position_ids.device
+        max_vals = position_ids.max(dim=0).values.tolist()
+        needs_rebuild = self.freqs_cis is None or any(
+            max_val >= axis_len for max_val, axis_len in zip(max_vals, self.axes_lens)
+        )
+        if needs_rebuild:
+            for i in range(len(self.axes_lens)):
+                if max_vals[i] >= self.axes_lens[i]:
+                    self.axes_lens[i] = int(max_vals[i] * 1.5) + 1
+            self.freqs_cis = self.precompute_freqs_cis(self.axes_dims, tuple(self.axes_lens), theta=self.theta)
+            self.freqs_cis = [freqs_cis.to(device) for freqs_cis in self.freqs_cis]
+        elif self.freqs_cis[0].device != device:
+            self.freqs_cis = [freqs_cis.to(device) for freqs_cis in self.freqs_cis]
+
+        return torch.cat([self.freqs_cis[i][position_ids[:, i]] for i in range(len(self.axes_dims))], dim=-1)
+
+
+def make_joint_position_ids(text_len: int, grid_t: int, grid_h: int, grid_w: int, device: torch.device) -> torch.Tensor:
+    """Return ``(t, h, w)`` positions with video rows before text rows.
+
+    Text t-axis positions are 1..text_len, and video t-axis positions start at
+    text_len + 1. This matches the token order produced by ``_cat_interleave``.
+    """
+    tt = torch.arange(grid_t, device=device, dtype=torch.int32) + (text_len + 1)
+    hh = torch.arange(grid_h, device=device, dtype=torch.int32)
+    ww = torch.arange(grid_w, device=device, dtype=torch.int32)
+    grid = torch.stack(torch.meshgrid(tt, hh, ww, indexing="ij"), dim=-1).flatten(0, 2)
+    text_t = torch.arange(text_len, device=device, dtype=torch.int32) + 1
+    text_pos = torch.stack([text_t, torch.zeros_like(text_t), torch.zeros_like(text_t)], dim=-1)
+    return torch.cat([grid, text_pos], dim=0)  # (Nx + L, 3)
+
+
+def _cat_interleave(
+    a: torch.Tensor,
+    len_a: list[int],
+    b: torch.Tensor,
+    len_b: list[int],
+) -> torch.Tensor:
+    a_split = torch.split(a, len_a, dim=1)
+    b_split = torch.split(b, len_b, dim=1)
+    blocks: list[torch.Tensor] = []
+    for x_part, text_part in zip(a_split, b_split):
+        blocks.extend([x_part, text_part])
+    return torch.cat(blocks, dim=1)
+
+
+def _packed_block_attention_mask(sample_seq_lens: list[int], device: torch.device) -> torch.Tensor:
+    total_seq_len = sum(sample_seq_lens)
+    mask = torch.zeros(
+        1,
+        1,
+        total_seq_len,
+        total_seq_len,
+        dtype=torch.bool,
+        device=device,
+    )
+    start = 0
+    for seq_len in sample_seq_lens:
+        end = start + seq_len
+        mask[:, :, start:end, start:end] = True
+        start = end
+    return mask
+
+
+class LingBotVideoTextEmbedder(nn.Module):
+    """Matches CondProjection: RMSNorm(text_dim, eps=1e-6 fixed) -> Linear-SiLU-Linear."""
+
+    def __init__(self, text_dim: int, hidden_size: int):
+        super().__init__()
+        self.norm = LingBotVideoRMSNorm(text_dim, eps=1e-6)
+        self.linear_1 = nn.Linear(text_dim, hidden_size, bias=True)
+        self.linear_2 = nn.Linear(hidden_size, hidden_size, bias=True)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.norm(x)
+        return self.linear_2(F.silu(self.linear_1(x)))
+
+
+class LingBotVideoAttention(nn.Module):
+    def __init__(self, hidden_size, num_heads, norm_eps, qkv_bias, out_bias):
+        super().__init__()
+        self.num_heads = num_heads
+        self.head_dim = hidden_size // num_heads
+        self.to_q = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
+        self.to_k = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
+        self.to_v = nn.Linear(hidden_size, hidden_size, bias=qkv_bias)
+        self.norm_q = LingBotVideoRMSNorm(self.head_dim, norm_eps)
+        self.norm_k = LingBotVideoRMSNorm(self.head_dim, norm_eps)
+        self.to_out = nn.Linear(hidden_size, hidden_size, bias=out_bias)
+        self.attn = Attention(
+            num_heads=num_heads,
+            head_size=self.head_dim,
+            softmax_scale=1.0 / math.sqrt(self.head_dim),
+            causal=False,
+            num_kv_heads=num_heads,
+        )
+
+    def forward(
+        self,
+        x,
+        rotary_emb,
+        attention_mask=None,
+        packed_indices: dict[str, torch.Tensor] | None = None,
+        parallel_config=None,
+    ):
+        B, S, _ = x.shape
+        q = self.to_q(x).unflatten(2, (self.num_heads, self.head_dim))
+        k = self.to_k(x).unflatten(2, (self.num_heads, self.head_dim))
+        v = self.to_v(x).unflatten(2, (self.num_heads, self.head_dim))
+        q = apply_rotary_emb(self.norm_q(q), rotary_emb)
+        k = apply_rotary_emb(self.norm_k(k), rotary_emb)
+        if packed_indices is None:
+            out = self.attn(q, k, v, attn_metadata=AttentionMetadata(attn_mask=attention_mask))
+        else:
+            packed_attention_mask = packed_indices.get("attention_mask")
+            if packed_attention_mask is not None and parallel_config is None:
+                out = self.attn.sdpa_fallback.forward(
+                    q,
+                    k,
+                    v,
+                    AttentionMetadata(attn_mask=packed_attention_mask),
+                )
+                return self.to_out(out.flatten(2, 3).type_as(x))
+            if flash_attn_varlen_func_v3 is None:
+                raise RuntimeError(
+                    "A flash attention varlen function is required for packed context parallel attention."
+                )
+            if parallel_config is None:
+                result = flash_attn_varlen_func_v3(
+                    q=q.reshape(-1, self.num_heads, self.head_dim),
+                    k=k.reshape(-1, self.num_heads, self.head_dim),
+                    v=v.reshape(-1, self.num_heads, self.head_dim),
+                    cu_seqlens_q=packed_indices["cu_seqlens_kv"],
+                    cu_seqlens_k=packed_indices["cu_seqlens_kv"],
+                    max_seqlen_q=packed_indices["max_seqlen_in_batch_kv"],
+                    max_seqlen_k=packed_indices["max_seqlen_in_batch_kv"],
+                    causal=False,
+                )
+                out = result[0] if isinstance(result, tuple) else result
+                out = out.reshape(B, S, self.num_heads, self.head_dim)
+            else:
+                group = parallel_config.context_parallel_config._ulysses_mesh.get_group()
+                world_size = dist.get_world_size(group)
+                local_heads = self.num_heads // world_size
+                q_global = _all_to_all_split_cat(
+                    q.reshape(B, S, self.num_heads * self.head_dim),
+                    scatter_dim=2,
+                    gather_dim=1,
+                    group=group,
+                ).view(B, S * world_size, local_heads, self.head_dim)
+                k_global = _all_to_all_split_cat(
+                    k.reshape(B, S, self.num_heads * self.head_dim),
+                    scatter_dim=2,
+                    gather_dim=1,
+                    group=group,
+                ).view(B, S * world_size, local_heads, self.head_dim)
+                v_global = _all_to_all_split_cat(
+                    v.reshape(B, S, self.num_heads * self.head_dim),
+                    scatter_dim=2,
+                    gather_dim=1,
+                    group=group,
+                ).view(B, S * world_size, local_heads, self.head_dim)
+                q_flat = q_global.reshape(-1, local_heads, self.head_dim)
+                k_flat = k_global.reshape(-1, local_heads, self.head_dim)
+                v_flat = v_global.reshape(-1, local_heads, self.head_dim)
+                result = flash_attn_varlen_func_v3(
+                    q=q_flat,
+                    k=k_flat,
+                    v=v_flat,
+                    cu_seqlens_q=packed_indices["cu_seqlens_kv"],
+                    cu_seqlens_k=packed_indices["cu_seqlens_kv"],
+                    max_seqlen_q=packed_indices["max_seqlen_in_batch_kv"],
+                    max_seqlen_k=packed_indices["max_seqlen_in_batch_kv"],
+                    causal=False,
+                )
+                out_global = result[0] if isinstance(result, tuple) else result
+                out_global = out_global.reshape(B, S * world_size, local_heads * self.head_dim)
+                out = _all_to_all_split_cat(
+                    out_global,
+                    scatter_dim=1,
+                    gather_dim=2,
+                    group=group,
+                ).view(B, S, self.num_heads, self.head_dim)
+        return self.to_out(out.flatten(2, 3).type_as(x))
+
+
+class LingBotVideoMLP(nn.Module):
+    def __init__(self, hidden_size, intermediate_size):
+        super().__init__()
+        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)
+
+    def forward(self, x):
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+
+
+class LingBotVideoRouter(nn.Module):
+    """Token-choice top-k router used by the LingBot MoE checkpoints.
+
+    Selection uses the bias-corrected score, while the gating weights use the
+    original score. This asymmetry matches the reference LingBot inference path.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_experts: int,
+        top_k: int,
+        score_func: str,
+        norm_topk_prob: bool,
+        n_group: int | None,
+        topk_group: int | None,
+        route_scale: float,
+    ):
+        super().__init__()
+        self.num_experts = num_experts
+        self.top_k = top_k
+        self.score_func = score_func
+        self.norm_topk_prob = norm_topk_prob
+        self.n_group = n_group
+        self.topk_group = topk_group
+        self.route_scale = route_scale
+        self.weight = nn.Parameter(torch.empty(num_experts, hidden_size))
+        self.register_buffer(
+            "e_score_correction_bias",
+            torch.zeros(num_experts),
+            persistent=True,
+        )
+
+    def _group_limited_topk(self, scores_for_choice: torch.Tensor) -> torch.Tensor:
+        if self.n_group is None or self.topk_group is None:
+            raise ValueError("group-limited top-k requires n_group and topk_group.")
+        seq_len = scores_for_choice.shape[0]
+        experts_per_group = self.num_experts // self.n_group
+        grouped = scores_for_choice.view(seq_len, self.n_group, experts_per_group)
+        group_scores = grouped.topk(2, dim=-1)[0].sum(dim=-1)
+        group_idx = torch.topk(group_scores, k=self.topk_group, dim=-1, sorted=False)[1]
+        group_mask = torch.zeros_like(group_scores)
+        group_mask.scatter_(1, group_idx, 1)
+        score_mask = group_mask.unsqueeze(-1).expand(seq_len, self.n_group, experts_per_group).reshape(seq_len, -1)
+        masked = scores_for_choice.masked_fill(~score_mask.bool(), float("-inf"))
+        return torch.topk(masked, k=self.top_k, dim=-1, sorted=False)[1]
+
+    def forward(self, tokens: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        with torch.amp.autocast(tokens.device.type, enabled=False):
+            logits = F.linear(tokens.float(), self.weight.float())
+        if self.score_func == "softmax":
+            scores = F.softmax(logits, dim=-1)
+        elif self.score_func == "sigmoid":
+            scores = logits.sigmoid()
+        else:
+            raise ValueError(f"Unsupported LingBot router score_func: {self.score_func!r}.")
+
+        scores_for_choice = scores + self.e_score_correction_bias.unsqueeze(0)
+        if self.n_group is not None and self.n_group > 1:
+            top_indices = self._group_limited_topk(scores_for_choice)
+        else:
+            top_indices = torch.topk(scores_for_choice, k=self.top_k, dim=-1, sorted=False)[1]
+        top_scores = scores.gather(1, top_indices)
+        if self.top_k > 1 and self.norm_topk_prob:
+            top_scores = top_scores / (top_scores.sum(dim=-1, keepdim=True) + 1e-20)
+        top_scores = top_scores * self.route_scale
+        return top_indices, top_scores.to(tokens.dtype)
+
+
+class LingBotVideoGroupedExperts(nn.Module):
+    """Grouped expert weights.
+
+    Weight layout matches the reference checkpoint:
+    w1 [E, I, H], w2 [E, H, I], w3 [E, I, H].
+    """
+
+    def __init__(self, num_experts: int, hidden_size: int, intermediate_size: int):
+        super().__init__()
+        self.num_experts = num_experts
+        self.w1 = nn.Parameter(torch.empty(num_experts, intermediate_size, hidden_size))
+        self.w2 = nn.Parameter(torch.empty(num_experts, hidden_size, intermediate_size))
+        self.w3 = nn.Parameter(torch.empty(num_experts, intermediate_size, hidden_size))
+
+
+def _round_up_to_multiple(value: int, multiple: int) -> int:
+    return ((value + multiple - 1) // multiple) * multiple
+
+
+class LingBotVideoSparseMoeBlock(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        num_experts: int,
+        top_k: int,
+        moe_intermediate_size: int,
+        score_func: str,
+        norm_topk_prob: bool,
+        n_group: int | None,
+        topk_group: int | None,
+        routed_scaling_factor: float,
+        n_shared_experts: int | None,
+    ):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.num_experts = num_experts
+        self.router = LingBotVideoRouter(
+            hidden_size,
+            num_experts,
+            top_k,
+            score_func,
+            norm_topk_prob,
+            n_group,
+            topk_group,
+            routed_scaling_factor,
+        )
+        self.experts = LingBotVideoGroupedExperts(num_experts, hidden_size, moe_intermediate_size)
+        self.shared_experts = None
+        if n_shared_experts is not None and n_shared_experts > 0:
+            self.shared_experts = LingBotVideoMLP(
+                hidden_size,
+                moe_intermediate_size * n_shared_experts,
+            )
+
+    @staticmethod
+    def _reorder_tokens(
+        tokens: torch.Tensor,
+        top_scores: torch.Tensor,
+        top_indices: torch.Tensor,
+        num_experts: int,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int, int]:
+        num_tokens = tokens.shape[0]
+        top_k = top_indices.shape[1]
+        flat_scores = top_scores.reshape(-1)
+        flat_indices = top_indices.reshape(-1)
+        active_positions = torch.where(flat_scores != 0)[0]
+        active_experts = flat_indices[active_positions]
+
+        counts = torch.zeros(num_experts, device=tokens.device, dtype=torch.int64)
+        counts.scatter_add_(
+            0,
+            active_experts,
+            torch.ones_like(active_experts, dtype=torch.int64),
+        )
+
+        sort_order = torch.argsort(active_experts, stable=True)
+        sorted_positions = active_positions[sort_order]
+        sorted_scores = flat_scores[sorted_positions]
+        original_token_idx = sorted_positions // top_k
+        permuted_tokens = tokens[original_token_idx]
+        return permuted_tokens, counts, sorted_positions, sorted_scores, num_tokens, top_k
+
+    @staticmethod
+    def _pad_grouped_tokens(
+        tokens: torch.Tensor,
+        counts: torch.Tensor,
+        align: int = 8,
+    ) -> tuple[torch.Size, torch.Tensor, torch.Tensor, torch.Tensor]:
+        num_tokens = tokens.shape[0]
+        num_experts = int(counts.shape[0])
+        max_len = _round_up_to_multiple(num_tokens + num_experts * align, align)
+        counts_i64 = counts.to(torch.int64)
+        total_per_expert = torch.clamp_min(counts_i64, align)
+        aligned_counts_i64 = (total_per_expert + align - 1) // align * align
+        write_offsets = torch.cumsum(aligned_counts_i64, dim=0) - aligned_counts_i64
+        end_offsets = torch.cumsum(aligned_counts_i64, dim=0)
+        start_indices = torch.cumsum(counts_i64, dim=0) - counts_i64
+
+        slots = torch.arange(max_len, dtype=torch.int64, device=tokens.device)
+        expert_idx = torch.bucketize(slots, end_offsets, right=True)
+        valid_expert = expert_idx < num_experts
+        safe_expert_idx = expert_idx.clamp(max=num_experts - 1)
+        local_idx = slots - write_offsets[safe_expert_idx]
+        source_idx = start_indices[safe_expert_idx] + local_idx
+        valid = valid_expert & (local_idx < counts_i64[safe_expert_idx])
+        fill = torch.full_like(source_idx, num_tokens)
+        permuted_indices = torch.where(valid, source_idx, fill)
+
+        tokens_with_pad = torch.vstack((tokens, tokens.new_zeros((tokens.shape[-1],))))
+        input_shape = tokens_with_pad.shape
+        return (
+            input_shape,
+            tokens_with_pad[permuted_indices],
+            permuted_indices,
+            aligned_counts_i64.to(torch.int32),
+        )
+
+    @staticmethod
+    def _unpad_grouped_tokens(
+        output: torch.Tensor,
+        input_shape: torch.Size,
+        permuted_indices: torch.Tensor,
+    ) -> torch.Tensor:
+        unpermuted = output.new_empty(input_shape)
+        unpermuted[permuted_indices, :] = output
+        return unpermuted[:-1]
+
+    def _run_experts_for_loop(self, tokens: torch.Tensor, counts: torch.Tensor) -> torch.Tensor:
+        count_list = counts.tolist()
+        splits = torch.split(tokens, count_list, dim=0)
+        outputs = []
+        for expert_idx, expert_tokens in enumerate(splits):
+            if expert_tokens.numel() == 0:
+                continue
+            h = F.silu(expert_tokens @ self.experts.w1[expert_idx].transpose(-2, -1))
+            h = h * (expert_tokens @ self.experts.w3[expert_idx].transpose(-2, -1))
+            h = h @ self.experts.w2[expert_idx].transpose(-2, -1)
+            outputs.append(h)
+        if not outputs:
+            return tokens.new_zeros(tokens.shape)
+        return torch.cat(outputs, dim=0)
+
+    def _run_grouped_experts(self, tokens: torch.Tensor, counts: torch.Tensor) -> torch.Tensor:
+        if not hasattr(torch, "_grouped_mm") or tokens.device.type != "cuda":
+            return self._run_experts_for_loop(tokens, counts)
+        input_shape, padded_tokens, permuted_indices, aligned_counts = self._pad_grouped_tokens(tokens, counts)
+        offsets = torch.cumsum(aligned_counts, dim=0, dtype=torch.int32)
+        h = F.silu(
+            torch._grouped_mm(
+                padded_tokens.bfloat16(),
+                self.experts.w1.bfloat16().transpose(-2, -1),
+                offs=offsets,
+            )
+        )
+        h = h * torch._grouped_mm(
+            padded_tokens.bfloat16(),
+            self.experts.w3.bfloat16().transpose(-2, -1),
+            offs=offsets,
+        )
+        out = torch._grouped_mm(
+            h,
+            self.experts.w2.bfloat16().transpose(-2, -1),
+            offs=offsets,
+        ).type_as(padded_tokens)
+        return self._unpad_grouped_tokens(out, input_shape, permuted_indices)
+
+    @staticmethod
+    def _restore_tokens(
+        expert_output: torch.Tensor,
+        sorted_positions: torch.Tensor,
+        sorted_scores: torch.Tensor,
+        num_tokens: int,
+        top_k: int,
+    ) -> torch.Tensor:
+        hidden_size = expert_output.shape[-1]
+        unsorted = torch.zeros(
+            (num_tokens * top_k, hidden_size),
+            dtype=expert_output.dtype,
+            device=expert_output.device,
+        )
+        unsorted[sorted_positions] = expert_output
+        unsorted = unsorted.reshape(num_tokens, top_k, hidden_size)
+
+        scores_unsorted = torch.zeros(
+            num_tokens * top_k,
+            dtype=sorted_scores.dtype,
+            device=sorted_scores.device,
+        )
+        scores_unsorted[sorted_positions] = sorted_scores
+        scores_unsorted = scores_unsorted.reshape(num_tokens, top_k, 1)
+        return (unsorted.float() * scores_unsorted).sum(dim=1).to(expert_output.dtype)
+
+    def _run_selected_experts(
+        self,
+        tokens: torch.Tensor,
+        top_scores: torch.Tensor,
+        top_indices: torch.Tensor,
+    ) -> torch.Tensor:
+        (
+            permuted_tokens,
+            counts,
+            sorted_positions,
+            sorted_scores,
+            num_tokens,
+            top_k,
+        ) = self._reorder_tokens(tokens, top_scores, top_indices, self.router.num_experts)
+        expert_output = self._run_grouped_experts(permuted_tokens, counts)
+        return self._restore_tokens(
+            expert_output,
+            sorted_positions,
+            sorted_scores,
+            num_tokens,
+            top_k,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        padding_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        batch_size = hidden_states.shape[0]
+        tokens = hidden_states.reshape(-1, self.hidden_size)
+        top_indices, top_scores = self.router(tokens)
+        if padding_mask is not None:
+            mask = padding_mask.unsqueeze(-1).to(top_scores.dtype)
+            top_scores = top_scores * mask
+            top_scores = top_scores / (top_scores.sum(dim=-1, keepdim=True) + 1e-9)
+            top_scores = top_scores * self.router.route_scale
+
+        out = self._run_selected_experts(tokens, top_scores, top_indices)
+        out = out.reshape(batch_size, -1, self.hidden_size)
+        if self.shared_experts is not None:
+            out = out + self.shared_experts(hidden_states)
+        return out
+
+
+class LingBotVideoBlock(nn.Module):
+    def __init__(
+        self,
+        hidden_size,
+        num_attention_heads,
+        intermediate_size,
+        norm_eps,
+        qkv_bias,
+        out_bias,
+        num_experts,
+        num_experts_per_tok,
+        moe_intermediate_size,
+        decoder_sparse_step,
+        mlp_only_layers,
+        n_shared_experts,
+        score_func,
+        norm_topk_prob,
+        n_group,
+        topk_group,
+        routed_scaling_factor,
+        layer_idx: int,
+    ):
+        super().__init__()
+        self.layer_idx = layer_idx
+        h = hidden_size
+        self.scale_shift_table = nn.Parameter(torch.zeros(1, 6 * h))
+        self.norm1 = LingBotVideoRMSNorm(h, norm_eps)
+        self.attn = LingBotVideoAttention(h, num_attention_heads, norm_eps, qkv_bias, out_bias)
+        self.norm_post_attn = LingBotVideoRMSNorm(h, norm_eps)
+        self.norm2 = LingBotVideoRMSNorm(h, norm_eps)
+        use_sparse_moe = (
+            num_experts > 0 and layer_idx not in mlp_only_layers and (layer_idx + 1) % decoder_sparse_step == 0
+        )
+        if use_sparse_moe:
+            self.ffn = LingBotVideoSparseMoeBlock(
+                hidden_size=h,
+                num_experts=num_experts,
+                top_k=num_experts_per_tok,
+                moe_intermediate_size=moe_intermediate_size,
+                score_func=score_func,
+                norm_topk_prob=norm_topk_prob,
+                n_group=n_group,
+                topk_group=topk_group,
+                routed_scaling_factor=routed_scaling_factor,
+                n_shared_experts=n_shared_experts,
+            )
+        else:
+            self.ffn = LingBotVideoMLP(h, intermediate_size)
+        self.norm_post_ffn = LingBotVideoRMSNorm(h, norm_eps)
+
+    def forward(
+        self,
+        x,
+        temb6,
+        rotary_emb,
+        attention_mask=None,
+        moe_padding_mask=None,
+        packed_indices: dict[str, torch.Tensor] | None = None,
+        parallel_config=None,
+    ):
+        expected_tokens = x.shape[0] * x.shape[1]
+        if temb6.ndim != 2 or temb6.shape[0] != expected_tokens:
+            raise ValueError(
+                "LingBotVideoBlock expects token-level temb6 with shape "
+                f"(B*S, 6D); got {tuple(temb6.shape)} for hidden states {tuple(x.shape)}."
+            )
+        # AdaLN modulation and normalization stay in fp32 for the sensitive path.
+        mod = temb6.view(x.shape[0], x.shape[1], -1) + self.scale_shift_table.unsqueeze(0)
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=-1)
+        gate_msa, gate_mlp = gate_msa.tanh(), gate_mlp.tanh()
+        scale_msa, scale_mlp = 1.0 + scale_msa, 1.0 + scale_mlp
+
+        # AdaLN modulation and norms stay in fp32; cast to the transformer
+        # compute dtype only at Linear boundaries.
+        bulk_dtype = self.attn.to_q.weight.dtype
+        attn_in = (self.norm1(x) * scale_msa + shift_msa).to(bulk_dtype)
+        attn_out = self.attn(
+            attn_in,
+            rotary_emb,
+            attention_mask,
+            packed_indices=packed_indices,
+            parallel_config=parallel_config,
+        )
+        x = x + (gate_msa * self.norm_post_attn(attn_out)).to(x.dtype)
+
+        ffn_in = (self.norm2(x) * scale_mlp + shift_mlp).to(bulk_dtype)
+        if isinstance(self.ffn, LingBotVideoSparseMoeBlock):
+            ffn_out = self.ffn(ffn_in, padding_mask=moe_padding_mask)
+        else:
+            ffn_out = self.ffn(ffn_in)
+        ffn_normed = self.norm_post_ffn(ffn_out)
+        x = x + (gate_mlp * ffn_normed).to(x.dtype)
+        return x
+
+
+class LingBotVideoTransformer3DModel(ModelMixin, ConfigMixin):
+    _supports_gradient_checkpointing = False
+    _repeated_blocks = ["LingBotVideoBlock"]
+    _layerwise_offload_blocks_attr = "blocks"
+    _no_split_modules = ["LingBotVideoBlock"]
+    _keep_in_fp32_modules = list(LINGBOT_VIDEO_FP32_MODULES)
+
+    def to(self, *args, **kwargs):
+        device, dtype, non_blocking, _ = torch._C._nn._parse_to(*args, **kwargs)
+        if dtype is None or dtype == torch.float32:
+            return super().to(*args, **kwargs)
+
+        dtype_is_floating = torch.is_floating_point(torch.empty((), dtype=dtype))
+        if not dtype_is_floating:
+            return super().to(*args, **kwargs)
+
+        if device is not None:
+            super().to(device=device, non_blocking=non_blocking)
+
+        for name, param in self.named_parameters():
+            if not torch.is_floating_point(param):
+                continue
+            target_dtype = torch.float32 if should_keep_in_fp32(name) else dtype
+            param.data = param.data.to(dtype=target_dtype, non_blocking=non_blocking)
+            if param.grad is not None:
+                param.grad.data = param.grad.data.to(dtype=target_dtype, non_blocking=non_blocking)
+
+        for name, buffer in self.named_buffers():
+            if not torch.is_floating_point(buffer):
+                continue
+            target_dtype = torch.float32 if should_keep_in_fp32(name) else dtype
+            buffer.data = buffer.data.to(dtype=target_dtype, non_blocking=non_blocking)
+
+        return self
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: tuple[int, int, int] = (1, 2, 2),
+        in_channels: int = 16,
+        out_channels: int = 16,
+        hidden_size: int = 2048,
+        num_attention_heads: int = 16,
+        depth: int = 24,
+        intermediate_size: int = 6144,
+        text_dim: int = 2560,
+        freq_dim: int = 256,
+        norm_eps: float = 1e-6,
+        rope_theta: float = 256.0,
+        axes_dims: tuple[int, int, int] = (32, 48, 48),
+        axes_lens: tuple[int, int, int] = (8192, 1024, 1024),
+        qkv_bias: bool = False,
+        out_bias: bool = True,
+        patch_embed_bias: bool = True,
+        timestep_mlp_bias: bool = True,
+        num_experts: int = 0,
+        num_experts_per_tok: int = 8,
+        moe_intermediate_size: int = 512,
+        decoder_sparse_step: int = 1,
+        mlp_only_layers: tuple[int, ...] = (),
+        n_shared_experts: int | None = None,
+        score_func: str = "sigmoid",
+        norm_topk_prob: bool = True,
+        n_group: int | None = None,
+        topk_group: int | None = None,
+        routed_scaling_factor: float = 1.0,
+    ):
+        super().__init__()
+        head_dim = hidden_size // num_attention_heads
+        assert head_dim == sum(axes_dims), f"head_dim {head_dim} != sum(axes_dims) {sum(axes_dims)}"
+        mlp_only_layers = tuple(mlp_only_layers)
+
+        self.patch_embedder = nn.Linear(in_channels * math.prod(patch_size), hidden_size, bias=patch_embed_bias)
+        self.time_proj = Timesteps(freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(freq_dim, hidden_size, act_fn="silu", sample_proj_bias=timestep_mlp_bias)
+        self.time_modulation = nn.Sequential(nn.SiLU(), nn.Linear(hidden_size, 6 * hidden_size))
+        self.text_embedder = LingBotVideoTextEmbedder(text_dim, hidden_size)
+        self.rope = LingBotVideoRotaryEmbedding(axes_dims, axes_lens, rope_theta)
+        self.blocks = nn.ModuleList(
+            [
+                LingBotVideoBlock(
+                    hidden_size=hidden_size,
+                    num_attention_heads=num_attention_heads,
+                    intermediate_size=intermediate_size,
+                    norm_eps=norm_eps,
+                    qkv_bias=qkv_bias,
+                    out_bias=out_bias,
+                    num_experts=num_experts,
+                    num_experts_per_tok=num_experts_per_tok,
+                    moe_intermediate_size=moe_intermediate_size,
+                    decoder_sparse_step=decoder_sparse_step,
+                    mlp_only_layers=mlp_only_layers,
+                    n_shared_experts=n_shared_experts,
+                    score_func=score_func,
+                    norm_topk_prob=norm_topk_prob,
+                    n_group=n_group,
+                    topk_group=topk_group,
+                    routed_scaling_factor=routed_scaling_factor,
+                    layer_idx=i,
+                )
+                for i in range(depth)
+            ]
+        )
+        self.norm_out = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=norm_eps)
+        self.norm_out_modulation = nn.Sequential(nn.SiLU(), nn.Linear(hidden_size, 2 * hidden_size))
+        self.proj_out = nn.Linear(hidden_size, math.prod(patch_size) * out_channels)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,  # (B, C, T, H, W)
+        timestep: torch.Tensor,  # (B,) in [0, 1000](= sigma*1000)
+        encoder_hidden_states: torch.Tensor,  # (B, L, text_dim)
+        encoder_attention_mask: torch.Tensor | None = None,  # (B, L) 1=valid
+        return_dict: bool = True,
+    ):
+        B, C, T, H, W = hidden_states.shape
+        pF, pH, pW = self.config.patch_size
+        gt, gh, gw = T // pF, H // pH, W // pW
+        n_video = gt * gh * gw
+        L = encoder_hidden_states.shape[1]
+        device = hidden_states.device
+        if encoder_attention_mask is not None:
+            text_lens = encoder_attention_mask.sum(dim=-1).long()
+        else:
+            text_lens = torch.full((B,), L, dtype=torch.long, device=device)
+        text_lens_list = [int(v) for v in text_lens.detach().cpu().tolist()]
+        packed_batch = B > 1
+
+        # patchify: token order (f h w), feature order (pf ph pw c) -- matches patchify_and_embed
+        patch_tokens = hidden_states.reshape(B, C, gt, pF, gh, pH, gw, pW)
+        patch_tokens = patch_tokens.permute(0, 2, 4, 6, 3, 5, 7, 1).reshape(
+            B,
+            n_video,
+            pF * pH * pW * C,
+        )
+        if packed_batch:
+            x = torch.cat(
+                [self.patch_embedder(patch_tokens[i : i + 1]) for i in range(B)],
+                dim=1,
+            )
+        else:
+            x = self.patch_embedder(patch_tokens)
+
+        if packed_batch:
+            text_parts = [
+                self.text_embedder(encoder_hidden_states[i : i + 1, : text_lens_list[i], :]) for i in range(B)
+            ]
+            text = torch.cat(text_parts, dim=1)
+            joint = _cat_interleave(
+                x,
+                [n_video] * B,
+                text,
+                text_lens_list,
+            )
+        else:
+            text = self.text_embedder(encoder_hidden_states)
+            joint = torch.cat([x, text], dim=1)  # [video; text]
+        joint_seq_len = joint.shape[1]
+
+        # Per-sample RoPE: video t-axis start = real text length of this sample + 1
+        rotary_parts = [self.rope(make_joint_position_ids(text_lens_list[i], gt, gh, gw, device)) for i in range(B)]
+        if packed_batch:
+            rotary = torch.cat(rotary_parts, dim=0).unsqueeze(0)
+        else:
+            rotary = torch.stack(rotary_parts, dim=0)  # (B, S, head_dim/2) complex64
+
+        parallel_config = getattr(self, "_parallel_config", None)
+        use_packed_attention = parallel_config is not None
+
+        attention_mask = None
+        moe_padding_mask = None
+        packed_indices = None
+        has_padding = encoder_attention_mask is not None and bool((text_lens < L).any())
+        if packed_batch or use_packed_attention:
+            sample_seq_lens = [n_video + text_len for text_len in text_lens_list]
+            cu_seqlens = torch.zeros(B + 1, device=device, dtype=torch.int32)
+            cu_seqlens[1:] = torch.cumsum(
+                torch.tensor(sample_seq_lens, device=device, dtype=torch.int32),
+                dim=0,
+            )
+            packed_indices = {
+                "cu_seqlens_kv": cu_seqlens,
+                "max_seqlen_in_batch_kv": max(sample_seq_lens),
+            }
+            if packed_batch and not use_packed_attention:
+                packed_indices["attention_mask"] = _packed_block_attention_mask(sample_seq_lens, device)
+            has_padding = False
+        if has_padding:
+            key_mask = torch.cat(
+                [torch.ones(B, n_video, dtype=torch.bool, device=device), encoder_attention_mask.bool()],
+                dim=1,
+            )
+            attention_mask = key_mask[:, None, None, :]  # (B,1,1,S) -> SDPA broadcast
+            moe_padding_mask = key_mask.reshape(-1).float()  # (B*S,)
+        packed_cp = packed_indices is not None and parallel_config is not None
+        padding_size = 0
+        if packed_cp:
+            cp_config = parallel_config.context_parallel_config
+            cp_world_size = int(getattr(cp_config, "ulysses_degree", getattr(cp_config, "_world_size", 1)))
+            padding_size = (cp_world_size - (joint_seq_len % cp_world_size)) % cp_world_size
+            if padding_size:
+                joint = torch.cat(
+                    [
+                        joint,
+                        torch.zeros(
+                            joint.shape[0],
+                            padding_size,
+                            joint.shape[2],
+                            device=joint.device,
+                            dtype=joint.dtype,
+                        ),
+                    ],
+                    dim=1,
+                )
+                rotary = torch.cat(
+                    [
+                        rotary,
+                        torch.zeros(
+                            rotary.shape[0],
+                            padding_size,
+                            rotary.shape[2],
+                            device=rotary.device,
+                            dtype=rotary.dtype,
+                        ),
+                    ],
+                    dim=1,
+                )
+                if packed_indices is None:
+                    raise RuntimeError("packed_indices must be initialized for packed context parallel.")
+                packed_indices["cu_seqlens_kv"] = torch.cat(
+                    [
+                        packed_indices["cu_seqlens_kv"],
+                        packed_indices["cu_seqlens_kv"][-1:] + padding_size,
+                    ],
+                    dim=0,
+                )
+                packed_indices["max_seqlen_in_batch_kv"] = max(
+                    int(packed_indices["max_seqlen_in_batch_kv"]),
+                    int(padding_size),
+                )
+                joint_seq_len = joint.shape[1]
+
+        timestep_for_embed = timestep.float()
+        timestep_proj = self.time_proj(timestep_for_embed)
+        t_emb = self.time_embedder(timestep_proj)  # (B, D)
+        if packed_batch:
+            temb_input = torch.cat(
+                [t_emb[i : i + 1].unsqueeze(1).expand(1, n_video + text_lens_list[i], -1) for i in range(B)],
+                dim=1,
+            )
+            if padding_size:
+                temb_input = torch.cat(
+                    [
+                        temb_input,
+                        torch.zeros(
+                            temb_input.shape[0],
+                            padding_size,
+                            temb_input.shape[2],
+                            device=temb_input.device,
+                            dtype=temb_input.dtype,
+                        ),
+                    ],
+                    dim=1,
+                )
+            temb6 = self.time_modulation(temb_input.reshape(joint_seq_len, -1))
+            temb6 = temb6.reshape(1, joint_seq_len, -1)
+        else:
+            temb_input = t_emb.unsqueeze(1).expand(B, joint_seq_len, -1)  # (B, S, D)
+            temb6 = self.time_modulation(temb_input.reshape(B * joint_seq_len, -1))
+            temb6 = temb6.reshape(B, joint_seq_len, -1)  # (B, S, 6D)
+
+        temb6 = temb6.reshape(temb6.shape[0] * temb6.shape[1], -1)
+
+        for block in self.blocks:
+            joint = block(
+                joint,
+                temb6,
+                rotary,
+                attention_mask,
+                moe_padding_mask,
+                packed_indices=packed_indices,
+                parallel_config=parallel_config,
+            )
+        final_mod = self.norm_out_modulation(temb_input.reshape(joint.shape[0] * joint.shape[1], -1))
+        shift, scale = final_mod.reshape(joint.shape[0], joint.shape[1], -1).chunk(2, dim=-1)
+        final_hidden = self.norm_out(joint) * (1.0 + scale) + shift
+        projected = self.proj_out(final_hidden.to(self.proj_out.weight.dtype))
+        if packed_cp:
+            if padding_size:
+                projected = projected[:, :-padding_size, :]
+        if packed_batch:
+            split_lengths: list[int] = []
+            for text_len in text_lens_list:
+                split_lengths.extend([n_video, text_len])
+            parts = torch.split(projected, split_lengths, dim=1)
+            x = torch.cat(parts[::2], dim=1).reshape(B, n_video, -1)
+        else:
+            x = projected[:, :n_video]
+
+        # unpatchify (matches the rearrange in postprocess)
+        Cout = self.config.out_channels
+        x = x.reshape(B, gt, gh, gw, pF, pH, pW, Cout)
+        x = x.permute(0, 7, 1, 4, 2, 5, 3, 6).reshape(B, Cout, T, H, W)
+
+        if not return_dict:
+            return (x,)
+        return Transformer2DModelOutput(sample=x)
diff --git a/vllm_omni/diffusion/models/lingbot_video/pipeline_lingbot_video.py b/vllm_omni/diffusion/models/lingbot_video/pipeline_lingbot_video.py
new file mode 100644
index 000000000..f54fa387c
--- /dev/null
+++ b/vllm_omni/diffusion/models/lingbot_video/pipeline_lingbot_video.py
@@ -0,0 +1,695 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# Adapted from LingBot-Video (https://github.com/Robbyant/lingbot-video).
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Mapping
+from contextlib import nullcontext
+from typing import Any, ClassVar
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from diffusers import AutoencoderKLWan
+from diffusers.utils.torch_utils import randn_tensor
+from torch import nn
+from transformers import Qwen3VLForConditionalGeneration, Qwen3VLProcessor
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
+from vllm_omni.diffusion.models.lingbot_video.lingbot_video_transformer import LingBotVideoTransformer3DModel
+from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.models.schedulers import FlowUniPCMultistepScheduler
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+
+TOKEN_LENGTH = 37698
+HIDDEN_STATE_SKIP_LAYER = 0
+LOW_NOISE_TAIL_V1_DEFAULT_STEPS = 2
+
+PROMPT_TEMPLATE = (
+    "<|im_start|>system\nGiven a user input that may include a text prompt alone, "
+    "a text prompt with an image reference, or a text prompt with a video reference "
+    'or a video reference alone, generate an "Enhanced prompt" that provides detailed '
+    "visual descriptions suitable for video generation. Evaluate the level of detail "
+    "in the user's input: if it is simple, enrich it by adding specifics about colors, "
+    "shapes, sizes, textures, lighting, motion dynamics, camera movement, temporal "
+    "progression, and spatial relationships to create vivid, concrete, and temporally "
+    "coherent scenes to create vivid and concrete scenes. Please generate only the "
+    "enhanced description for the prompt below and avoid including any additional "
+    "commentary or evaluations:<|im_end|>\n<|im_start|>user\n{}<|im_end|>\n"
+    "<|im_start|>assistant\n"
+)
+DEFAULT_NEGATIVE_PROMPT = (
+    '{"universal_negative": {"visual_quality": ["low quality", "worst quality", "blurry", '
+    '"pixelated", "jpeg artifacts", "low resolution", "unstable color", "color flicker", '
+    '"underexposed", "overexposed", "invisible subject", "subject hidden in darkness"], '
+    '"artistic_style": ["painting", "illustration", "drawing", "cartoon", "3d render", '
+    '"cgi", "sketch", "digital art"], "composition_and_content": ["text", "watermark", '
+    '"signature", "logo", "subtitles", "pillarboxed", "side bars", '
+    '"portrait image in landscape frame"], "temporal_and_motion_stability": ["flickering", '
+    '"jittery", "motion blur", "temporal inconsistency", "warping", "morphing", '
+    '"incoherent motion", "unnatural movement", "static object with sudden jump", '
+    '"frame-to-frame inconsistency"], "material_and_structure": ["plastic-like glass", '
+    '"unrealistic texture", "deformed bottle", "liquid freezing improperly", '
+    '"distorted reflections"]}}'
+)
+
+
+def _dtype_from_name(value: Any, default: torch.dtype) -> torch.dtype:
+    if isinstance(value, torch.dtype):
+        return value
+    if value is None:
+        return default
+    normalized = str(value).lower()
+    if normalized in {"bf16", "bfloat16", "torch.bfloat16"}:
+        return torch.bfloat16
+    if normalized in {"fp16", "float16", "torch.float16"}:
+        return torch.float16
+    if normalized in {"fp32", "float32", "torch.float32"}:
+        return torch.float32
+    raise ValueError(f"Unsupported LingBot dtype: {value!r}.")
+
+
+def _extract_prompt(req: OmniDiffusionRequest) -> tuple[str, str | None]:
+    prompt_obj = req.prompt
+    if isinstance(prompt_obj, str):
+        return prompt_obj, None
+    if isinstance(prompt_obj, Mapping):
+        prompt = prompt_obj.get("prompt", "")
+        negative_prompt = prompt_obj.get("negative_prompt")
+        return str(prompt), None if negative_prompt is None else str(negative_prompt)
+    raise TypeError(f"Unsupported LingBot prompt type: {type(prompt_obj)!r}.")
+
+
+def _module_dtype(module: torch.nn.Module) -> torch.dtype:
+    try:
+        return next(module.parameters()).dtype
+    except StopIteration:
+        return torch.float32
+
+
+def _module_device(module: torch.nn.Module) -> torch.device:
+    try:
+        return next(module.parameters()).device
+    except StopIteration:
+        return torch.device("cpu")
+
+
+def _transformer_timestep(timestep: torch.Tensor, transformer_dtype: torch.dtype) -> torch.Tensor:
+    sigma = timestep.float() / 1000.0
+    if transformer_dtype in {torch.bfloat16, torch.float16}:
+        sigma = sigma.to(transformer_dtype)
+    return (sigma * 1000.0).float()
+
+
+def _transformer_autocast(device: torch.device, transformer_dtype: torch.dtype):
+    if device.type != "cuda" or transformer_dtype not in {torch.bfloat16, torch.float16}:
+        return nullcontext()
+    return torch.autocast(device_type="cuda", dtype=transformer_dtype)
+
+
+def _group_global_rank(group: Any | None, group_rank: int) -> int:
+    if group is None:
+        return group_rank
+    get_global_rank = getattr(dist, "get_global_rank", None)
+    if get_global_rank is None:
+        return group_rank
+    return int(get_global_rank(group, group_rank))
+
+
+def _validate_refiner_sigmas(sigmas: np.ndarray, t_thresh: float | None = None) -> np.ndarray:
+    arr = np.asarray(list(sigmas), dtype=np.float64)
+    if arr.ndim != 1 or arr.size == 0:
+        raise ValueError("refiner sigma schedule must be a non-empty 1D list")
+    if not np.all(np.isfinite(arr)):
+        raise ValueError("refiner sigma schedule contains non-finite values")
+    if np.any(arr < 0.0) or np.any(arr > 1.0):
+        raise ValueError(f"refiner sigma schedule values must be in [0, 1], got {arr.tolist()}")
+    if arr.size > 1 and not np.all(np.diff(arr) < 0.0):
+        raise ValueError(f"refiner sigma schedule must be strictly descending, got {arr.tolist()}")
+    if t_thresh is not None and abs(float(arr[0]) - float(t_thresh)) > 1e-6:
+        raise ValueError(f"refiner sigma schedule must start at t_thresh={float(t_thresh)}, got {float(arr[0])}")
+    return arr
+
+
+def _compute_refiner_sigmas(
+    *,
+    sigma_max: float,
+    sigma_min: float,
+    num_inference_steps: int,
+    shift: float,
+    t_thresh: float | None,
+    tail_steps: int = 0,
+) -> np.ndarray | None:
+    if t_thresh is None:
+        return None
+    t_value = float(t_thresh)
+    if not (0.0 < t_value <= 1.0):
+        raise ValueError(f"refiner t_thresh must lie in (0, 1], got {t_value}")
+    steps = int(num_inference_steps)
+    if steps < 1:
+        raise ValueError(f"num_inference_steps must be >= 1, got {steps}")
+    tail = int(tail_steps or 0)
+    if tail < 0:
+        raise ValueError(f"refiner_sigma_tail_steps must be >= 0, got {tail}")
+
+    base = np.linspace(float(sigma_max), float(sigma_min), steps + 1).copy()[:-1]
+    shift_value = float(shift)
+    shifted = shift_value * base / (1.0 + (shift_value - 1.0) * base)
+    eps = 1e-6
+    sigmas = shifted[shifted <= t_value + eps]
+    if sigmas.size == 0 or abs(float(sigmas[0]) - t_value) > eps:
+        sigmas = np.concatenate([[t_value], sigmas])
+    if tail > 0:
+        start = float(sigmas[-1])
+        stop = min(float(sigma_min), start)
+        extra = np.linspace(start, stop, tail + 2, dtype=np.float64)[1:-1]
+        sigmas = np.concatenate([sigmas, extra])
+    return _validate_refiner_sigmas(sigmas, t_value).astype(np.float32)
+
+
+def _pad_prompt_embeds(
+    embeds: torch.Tensor,
+    mask: torch.Tensor,
+    target_length: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if embeds.shape[0] != 1:
+        raise ValueError(f"batched CFG helper expects batch=1 inputs, got {embeds.shape[0]}")
+    if embeds.shape[1] > target_length:
+        raise ValueError(f"cannot pad length {embeds.shape[1]} down to {target_length}")
+    pad_len = target_length - embeds.shape[1]
+    if pad_len == 0:
+        return embeds, mask
+    embed_pad = torch.zeros(embeds.shape[0], pad_len, embeds.shape[2], dtype=embeds.dtype, device=embeds.device)
+    mask_pad = torch.zeros(mask.shape[0], pad_len, dtype=mask.dtype, device=mask.device)
+    return torch.cat([embeds, embed_pad], dim=1), torch.cat([mask, mask_pad], dim=1)
+
+
+def _batch_cfg_prompt_inputs(
+    prompt_embeds: torch.Tensor,
+    prompt_mask: torch.Tensor,
+    negative_embeds: torch.Tensor,
+    negative_mask: torch.Tensor,
+    *,
+    null_cond_clone_zero: bool = False,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if null_cond_clone_zero:
+        zero_negative = torch.zeros_like(prompt_embeds)
+        return (
+            torch.cat([prompt_embeds, zero_negative], dim=0),
+            torch.cat([prompt_mask, prompt_mask.clone()], dim=0),
+        )
+
+    target_length = max(int(prompt_embeds.shape[1]), int(negative_embeds.shape[1]))
+    prompt_padded, prompt_mask_padded = _pad_prompt_embeds(prompt_embeds, prompt_mask, target_length)
+    negative_padded, negative_mask_padded = _pad_prompt_embeds(negative_embeds, negative_mask, target_length)
+    return (
+        torch.cat([prompt_padded, negative_padded], dim=0),
+        torch.cat([prompt_mask_padded, negative_mask_padded], dim=0),
+    )
+
+
+def get_lingbot_video_post_process_func(od_config: OmniDiffusionConfig):
+    del od_config
+
+    def post_process_func(frames: torch.Tensor, sampling_params=None):
+        output_type = getattr(sampling_params, "output_type", None) or "pt"
+        if output_type == "np" and isinstance(frames, torch.Tensor):
+            return frames.float().cpu().numpy()
+        return frames
+
+    return post_process_func
+
+
+class LingBotVideoPipeline(nn.Module, ProgressBarMixin, SupportsComponentDiscovery):
+    """Native vLLM-Omni entry for LingBot-Video checkpoints.
+
+    The in-tree transformer supports both dense MLP blocks and routed MoE blocks.
+    Fused expert kernels and the optional ``refiner/`` transformer are not loaded
+    or executed. ``t_thresh`` only selects a low-noise sigma schedule for the
+    primary transformer; it does not enable automatic refiner orchestration.
+    """
+
+    supports_step_execution: ClassVar[bool] = False
+    _dit_modules: ClassVar[list[str]] = ["transformer"]
+    _encoder_modules: ClassVar[list[str]] = ["text_encoder"]
+    _vae_modules: ClassVar[list[str]] = ["vae"]
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
+        super().__init__()
+        del prefix
+        self.od_config = od_config
+        self.device = get_local_device()
+        self.vae_scale_factor_temporal = 4
+        self.vae_scale_factor_spatial = 8
+        self.token_length = TOKEN_LENGTH
+        self.hidden_state_skip_layer = HIDDEN_STATE_SKIP_LAYER
+        self.prompt_template = PROMPT_TEMPLATE
+        self._crop_start: int | None = None
+
+        model = od_config.model
+        local_files_only = os.path.exists(model)
+        dtype = getattr(od_config, "dtype", torch.bfloat16)
+        model_config = getattr(od_config, "model_config", None) or {}
+        transformer_dtype = _dtype_from_name(model_config.get("transformer_dtype"), dtype)
+        text_encoder_dtype = _dtype_from_name(model_config.get("text_encoder_dtype"), dtype)
+        vae_dtype = _dtype_from_name(model_config.get("vae_dtype"), torch.float32)
+
+        transformer_subfolder = str(model_config.get("transformer_subfolder", "transformer"))
+        text_encoder_subfolder = str(model_config.get("text_encoder_subfolder", "text_encoder"))
+        processor_subfolder = str(model_config.get("processor_subfolder", "processor"))
+        vae_subfolder = str(model_config.get("vae_subfolder", "vae"))
+        scheduler_subfolder = str(model_config.get("scheduler_subfolder", "scheduler"))
+
+        self.transformer = LingBotVideoTransformer3DModel.from_pretrained(
+            model,
+            subfolder=transformer_subfolder,
+            torch_dtype=transformer_dtype,
+            local_files_only=local_files_only,
+        ).to(self.device)
+        text_encoder_kwargs: dict[str, Any] = {
+            "dtype": text_encoder_dtype,
+            "local_files_only": local_files_only,
+        }
+        self.text_encoder = Qwen3VLForConditionalGeneration.from_pretrained(
+            model,
+            subfolder=text_encoder_subfolder,
+            **text_encoder_kwargs,
+        ).to(self.device)
+        self.processor = Qwen3VLProcessor.from_pretrained(
+            model,
+            subfolder=processor_subfolder,
+            local_files_only=local_files_only,
+        )
+        self.vae = AutoencoderKLWan.from_pretrained(
+            model,
+            subfolder=vae_subfolder,
+            torch_dtype=vae_dtype,
+            local_files_only=local_files_only,
+        ).to(self.device)
+        self.scheduler = FlowUniPCMultistepScheduler.from_pretrained(
+            model,
+            subfolder=scheduler_subfolder,
+            local_files_only=local_files_only,
+        )
+        self.set_progress_bar_config(disable=bool(model_config.get("quiet_progress", True)))
+        self.default_negative_prompt = DEFAULT_NEGATIVE_PROMPT
+
+    def to(self, *args, **kwargs):
+        device, dtype, non_blocking, _ = torch._C._nn._parse_to(*args, **kwargs)
+        super().to(*args, **kwargs)
+        if device is not None:
+            self.device = torch.device(device)
+            self.transformer.to(device=self.device, non_blocking=non_blocking)
+            self.text_encoder.to(device=self.device, non_blocking=non_blocking)
+            self.vae.to(device=self.device, non_blocking=non_blocking)
+        if dtype is not None:
+            self.transformer.to(dtype=dtype, non_blocking=non_blocking)
+        return self
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        consumed = list(weights)
+        if consumed:
+            raise RuntimeError(
+                f"{self.__class__.__name__}.load_weights received {len(consumed)} weight tensors; "
+                "LingBot components are loaded directly from subfolders during __init__."
+            )
+        return {name for name, _ in self.named_parameters()}
+
+    @staticmethod
+    def check_inputs(height: int, width: int, num_frames: int) -> None:
+        if num_frames != 1 and (num_frames - 1) % 4 != 0:
+            raise ValueError(f"`num_frames` must be 1 or 4n+1, got {num_frames}.")
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"`height` and `width` must be multiples of 16, got {height}x{width}.")
+
+    @staticmethod
+    def apply_text_to_template(text: str, template: str = PROMPT_TEMPLATE) -> str:
+        return template.format(text)
+
+    def _compute_crop_start(self) -> int:
+        if self._crop_start is None:
+            marker = "<|USER_INPUT_MARKER|>"
+            marked = self.prompt_template.format(marker)
+            marker_pos = marked.find(marker)
+            if marker_pos < 0:
+                self._crop_start = 0
+            else:
+                prefix = self.processor(
+                    text=marked[:marker_pos],
+                    images=None,
+                    videos=None,
+                    return_tensors="pt",
+                )
+                self._crop_start = int(prefix["input_ids"].shape[1])
+        return self._crop_start
+
+    def _build_prompt_inputs(self, prompt: str | list[str]):
+        prompts = [prompt] if isinstance(prompt, str) else list(prompt)
+        texts = [self.apply_text_to_template(text, self.prompt_template) for text in prompts]
+        return self.processor(
+            text=texts,
+            images=None,
+            videos=None,
+            do_resize=False,
+            truncation=True,
+            max_length=self.token_length,
+            padding="longest",
+            return_tensors="pt",
+        )
+
+    @torch.no_grad()
+    def encode_prompt(
+        self,
+        prompt: str | list[str],
+        *,
+        device: str | torch.device | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        device = torch.device(device) if device is not None else self.device
+        inputs = self._build_prompt_inputs(prompt).to(device)
+        outputs = self.text_encoder(
+            **inputs,
+            output_hidden_states=self.hidden_state_skip_layer is not None,
+        )
+        if self.hidden_state_skip_layer is not None:
+            prompt_embeds = outputs.hidden_states[-(self.hidden_state_skip_layer + 1)]
+        else:
+            prompt_embeds = outputs.last_hidden_state
+
+        prompt_mask = inputs["attention_mask"]
+        crop_start = self._compute_crop_start()
+        if crop_start > 0:
+            prompt_embeds = prompt_embeds[:, crop_start:]
+            prompt_mask = prompt_mask[:, crop_start:]
+
+        if prompt_embeds.shape[0] == 1:
+            true_len = int(prompt_mask[0].sum().item())
+            prompt_embeds = prompt_embeds[:, :true_len]
+            prompt_mask = prompt_mask[:, :true_len]
+        return prompt_embeds, prompt_mask
+
+    def prepare_latents(
+        self,
+        num_frames: int,
+        height: int,
+        width: int,
+        generator: torch.Generator | None,
+        latents: torch.Tensor | None,
+        device: torch.device,
+    ) -> torch.Tensor:
+        latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+        latent_height = height // self.vae_scale_factor_spatial
+        latent_width = width // self.vae_scale_factor_spatial
+        shape = (1, self.transformer.config.in_channels, latent_frames, latent_height, latent_width)
+        if latents is None:
+            return randn_tensor(shape, generator=generator, device=device, dtype=torch.float32)
+        if tuple(latents.shape) != shape:
+            raise ValueError(f"`latents` shape must be {shape}, got {tuple(latents.shape)}.")
+        return latents.to(device=device, dtype=torch.float32)
+
+    def _dit_latent_to_vae(self, latents: torch.Tensor) -> torch.Tensor:
+        mean = torch.tensor(self.vae.config.latents_mean, device=latents.device, dtype=torch.float32)
+        std_inv = 1.0 / torch.tensor(self.vae.config.latents_std, device=latents.device, dtype=torch.float32)
+        mean = mean.view(1, -1, 1, 1, 1)
+        std_inv = std_inv.view(1, -1, 1, 1, 1)
+        return latents.float() / std_inv + mean
+
+    @torch.no_grad()
+    def _decode_latents(self, latents: torch.Tensor) -> torch.Tensor:
+        vae_device = _module_device(self.vae)
+        vae_dtype = _module_dtype(self.vae)
+        vae_latents = self._dit_latent_to_vae(latents).to(device=vae_device, dtype=torch.float32)
+        if vae_latents.ndim == 5:
+            vae_latents = vae_latents.contiguous(memory_format=torch.channels_last_3d)
+        autocast_dtype = (
+            vae_dtype if vae_device.type == "cuda" and vae_dtype in {torch.bfloat16, torch.float16} else None
+        )
+        with torch.autocast("cuda", dtype=autocast_dtype or torch.bfloat16, enabled=autocast_dtype is not None):
+            decoded = self.vae.decode(vae_latents)
+        frames = decoded[0] if isinstance(decoded, tuple) else decoded.sample
+        frames = frames.float().clamp_(-1, 1)
+        frames = (frames + 1.0) / 2.0
+        frames = frames.permute(0, 2, 3, 4, 1).cpu()
+        return frames[0]
+
+    @torch.no_grad()
+    def _generate(
+        self,
+        *,
+        prompt: str,
+        negative_prompt: str = DEFAULT_NEGATIVE_PROMPT,
+        height: int = 480,
+        width: int = 480,
+        num_frames: int = 81,
+        num_inference_steps: int = 40,
+        guidance_scale: float = 6.0,
+        shift: float = 3.0,
+        generator: torch.Generator | None = None,
+        latents: torch.Tensor | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        prompt_mask: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_mask: torch.Tensor | None = None,
+        output_type: str = "pt",
+        cfg_parallel_group: Any | None = None,
+        batch_cfg: bool = False,
+        null_cond_clone_zero: bool = False,
+        t_thresh: float | None = None,
+        refiner_sigma_tail_steps: int = LOW_NOISE_TAIL_V1_DEFAULT_STEPS,
+        offload_vae_during_denoise: bool = False,
+        **extra_args,
+    ) -> torch.Tensor:
+        del extra_args
+        self.check_inputs(height, width, num_frames)
+        device = self.device
+        do_cfg = guidance_scale > 1.0
+        effective_batch_cfg = bool(batch_cfg)
+        cfg_parallel = cfg_parallel_group is not None
+        cfg_parallel_rank = 0
+        if cfg_parallel:
+            if not dist.is_available() or not dist.is_initialized():
+                raise ValueError("`cfg_parallel_group` requires an initialized process group.")
+            if effective_batch_cfg:
+                raise ValueError("`cfg_parallel_group` and `batch_cfg` are mutually exclusive.")
+            if not do_cfg:
+                raise ValueError("CFG parallel requires `guidance_scale > 1.0`.")
+            cfg_parallel_rank = dist.get_rank(cfg_parallel_group)
+            cfg_parallel_world_size = dist.get_world_size(cfg_parallel_group)
+            if cfg_parallel_world_size != 2:
+                raise ValueError(f"CFG parallel currently requires exactly 2 ranks, got {cfg_parallel_world_size}.")
+
+        if prompt_embeds is not None:
+            if prompt_mask is None:
+                raise ValueError("`prompt_mask` is required when `prompt_embeds` is provided.")
+            prompt_embeds = prompt_embeds.to(device=device)
+            prompt_mask = prompt_mask.to(device=device)
+        if negative_prompt_embeds is not None:
+            if negative_prompt_mask is None:
+                raise ValueError("`negative_prompt_mask` is required when `negative_prompt_embeds` is provided.")
+            negative_prompt_embeds = negative_prompt_embeds.to(device=device)
+            negative_prompt_mask = negative_prompt_mask.to(device=device)
+
+        negative_embeds = None
+        negative_mask = None
+        if cfg_parallel and cfg_parallel_rank == 1:
+            if negative_prompt_embeds is not None:
+                negative_embeds, negative_mask = negative_prompt_embeds, negative_prompt_mask
+            else:
+                negative_embeds, negative_mask = self.encode_prompt(negative_prompt, device=device)
+            prompt_embeds = prompt_mask = None
+        else:
+            if prompt_embeds is None:
+                prompt_embeds, prompt_mask = self.encode_prompt(prompt, device=device)
+            if do_cfg and not cfg_parallel:
+                if null_cond_clone_zero:
+                    negative_embeds = torch.zeros_like(prompt_embeds)
+                    negative_mask = prompt_mask.clone()
+                elif negative_prompt_embeds is not None:
+                    negative_embeds, negative_mask = negative_prompt_embeds, negative_prompt_mask
+                else:
+                    negative_embeds, negative_mask = self.encode_prompt(negative_prompt, device=device)
+
+        latents = self.prepare_latents(num_frames, height, width, generator, latents, device)
+        sigmas = _compute_refiner_sigmas(
+            sigma_max=float(self.scheduler.sigma_max),
+            sigma_min=float(self.scheduler.sigma_min),
+            num_inference_steps=num_inference_steps,
+            shift=shift,
+            t_thresh=t_thresh,
+            tail_steps=refiner_sigma_tail_steps,
+        )
+        if sigmas is None:
+            self.scheduler.set_timesteps(num_inference_steps, device=device, shift=shift)
+        else:
+            self.scheduler.set_timesteps(int(sigmas.shape[0]), device=device, sigmas=sigmas, shift=1.0)
+
+        transformer_dtype = _module_dtype(self.transformer)
+        vae_restore_device: torch.device | None = None
+        vae_offloaded = False
+        if offload_vae_during_denoise and output_type != "latent":
+            vae_device = _module_device(self.vae)
+            if vae_device.type == "cuda":
+                self.vae.to("cpu")
+                torch.accelerator.empty_cache()
+                vae_restore_device = vae_device
+                vae_offloaded = True
+
+        cfg_latent_src = _group_global_rank(cfg_parallel_group, 0)
+        cfg_uncond_src = _group_global_rank(cfg_parallel_group, 1)
+        for timestep in self.progress_bar(self.scheduler.timesteps):
+            if cfg_parallel:
+                dist.broadcast(latents, src=cfg_latent_src, group=cfg_parallel_group)
+            timestep_batch = _transformer_timestep(timestep, transformer_dtype).expand(1).to(device)
+            latent_model_input = latents
+            if cfg_parallel:
+                if cfg_parallel_rank == 0:
+                    branch_embeds = prompt_embeds
+                    branch_mask = prompt_mask
+                else:
+                    branch_embeds = negative_embeds
+                    branch_mask = negative_mask
+                if branch_embeds is None:
+                    raise RuntimeError("CFG branch embeddings were not initialized.")
+                with _transformer_autocast(device, transformer_dtype):
+                    branch_noise_pred = self.transformer(
+                        latent_model_input,
+                        timestep_batch,
+                        branch_embeds.to(transformer_dtype),
+                        encoder_attention_mask=branch_mask,
+                        return_dict=False,
+                    )[0].float()
+                if cfg_parallel_rank == 0:
+                    noise_pred = branch_noise_pred
+                    noise_pred_uncond = torch.empty_like(noise_pred)
+                else:
+                    noise_pred_uncond = branch_noise_pred
+                dist.broadcast(noise_pred_uncond, src=cfg_uncond_src, group=cfg_parallel_group)
+                if cfg_parallel_rank != 0:
+                    continue
+                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)
+            else:
+                if prompt_embeds is None:
+                    raise RuntimeError("Prompt embeddings were not initialized.")
+                prompt_model_input = prompt_embeds.to(transformer_dtype)
+                if do_cfg and effective_batch_cfg:
+                    if negative_embeds is None or negative_mask is None:
+                        raise RuntimeError("Negative embeddings were not initialized for CFG.")
+                    cfg_embeds, cfg_mask = _batch_cfg_prompt_inputs(
+                        prompt_model_input,
+                        prompt_mask,
+                        negative_embeds.to(transformer_dtype),
+                        negative_mask,
+                        null_cond_clone_zero=False,
+                    )
+                    cfg_latents = torch.cat([latent_model_input, latent_model_input], dim=0)
+                    cfg_timesteps = torch.cat([timestep_batch, timestep_batch], dim=0)
+                    with _transformer_autocast(device, transformer_dtype):
+                        noise_batched = self.transformer(
+                            cfg_latents,
+                            cfg_timesteps,
+                            cfg_embeds,
+                            encoder_attention_mask=cfg_mask,
+                            return_dict=False,
+                        )[0].float()
+                    noise_pred, noise_pred_uncond = noise_batched.chunk(2, dim=0)
+                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)
+                else:
+                    with _transformer_autocast(device, transformer_dtype):
+                        noise_pred = self.transformer(
+                            latent_model_input,
+                            timestep_batch,
+                            prompt_model_input,
+                            encoder_attention_mask=prompt_mask,
+                            return_dict=False,
+                        )[0].float()
+
+                if do_cfg and not effective_batch_cfg:
+                    if negative_embeds is None or negative_mask is None:
+                        raise RuntimeError("Negative embeddings were not initialized for CFG.")
+                    with _transformer_autocast(device, transformer_dtype):
+                        noise_pred_uncond = self.transformer(
+                            latent_model_input,
+                            timestep_batch,
+                            negative_embeds.to(transformer_dtype),
+                            encoder_attention_mask=negative_mask,
+                            return_dict=False,
+                        )[0].float()
+                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)
+
+            latents = self.scheduler.step(noise_pred, timestep, latents, return_dict=False, generator=generator)[0]
+
+        if cfg_parallel:
+            dist.barrier(group=cfg_parallel_group)
+            if cfg_parallel_rank != 0:
+                return latents if output_type == "latent" else []
+
+        if output_type == "latent":
+            return latents
+        if output_type in {"pt", "np"}:
+            if vae_offloaded and vae_restore_device is not None:
+                self.vae.to(device=vae_restore_device)
+                torch.accelerator.empty_cache()
+            return self._decode_latents(latents)
+        raise ValueError(f"Unsupported output_type: {output_type}")
+
+    @torch.inference_mode()
+    def forward(self, req: DiffusionRequestBatch) -> DiffusionOutput:
+        if req.num_reqs != 1:
+            raise ValueError(f"LingBotVideoPipeline only supports one request per batch, got {req.num_reqs}.")
+        request = req.requests[0]
+        prompt, prompt_negative = _extract_prompt(request)
+        sampling = request.sampling_params
+        extra_args = dict(sampling.extra_args or {})
+
+        generator = sampling.generator
+        if isinstance(generator, list):
+            generator = generator[0] if generator else None
+        if generator is None and sampling.seed is not None:
+            generator = torch.Generator(device=self.device).manual_seed(int(sampling.seed))
+
+        height = sampling.height if sampling.height is not None else extra_args.pop("height", 480)
+        width = sampling.width if sampling.width is not None else extra_args.pop("width", 480)
+        num_frames = sampling.num_frames or extra_args.pop("num_frames", 81)
+        num_inference_steps = (
+            sampling.num_inference_steps
+            if sampling.num_inference_steps is not None
+            else extra_args.pop("num_inference_steps", 40)
+        )
+        guidance_scale = (
+            sampling.guidance_scale if sampling.guidance_scale_provided else extra_args.pop("guidance_scale", 6.0)
+        )
+        shift = extra_args.pop(
+            "shift",
+            extra_args.pop("flow_shift", getattr(self.od_config, "flow_shift", None) or 3.0),
+        )
+        negative_prompt = extra_args.pop("negative_prompt", prompt_negative or self.default_negative_prompt)
+        output_type = (
+            sampling.output_type or getattr(self.od_config, "output_type", None) or extra_args.pop("output_type", "pt")
+        )
+        if output_type not in {"pt", "np", "latent"}:
+            output_type = "pt"
+        sampling.output_type = output_type
+
+        frames = self._generate(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            shift=shift,
+            generator=generator,
+            latents=sampling.latents,
+            output_type=output_type,
+            batch_cfg=bool(extra_args.pop("batch_cfg", False)),
+            null_cond_clone_zero=bool(extra_args.pop("null_cond_clone_zero", False)),
+            offload_vae_during_denoise=bool(extra_args.pop("offload_vae_during_denoise", False)),
+            t_thresh=extra_args.pop("t_thresh", None),
+            refiner_sigma_tail_steps=int(extra_args.pop("refiner_sigma_tail_steps", LOW_NOISE_TAIL_V1_DEFAULT_STEPS)),
+        )
+        return DiffusionOutput(output=frames)
diff --git a/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py b/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
index 744c1806a..3cde2a868 100644
--- a/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
+++ b/vllm_omni/diffusion/models/longcat_image/longcat_image_transformer.py
@@ -19,7 +19,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
diff --git a/vllm_omni/diffusion/models/ltx2/__init__.py b/vllm_omni/diffusion/models/ltx2/__init__.py
index 76a26b5b0..300295bd8 100644
--- a/vllm_omni/diffusion/models/ltx2/__init__.py
+++ b/vllm_omni/diffusion/models/ltx2/__init__.py
@@ -1,34 +1,24 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
-from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import (
-    LTX2Pipeline,
-    LTX2T2VDMD2Pipeline,
-    LTX2TwoStagesPipeline,
+from vllm_omni.diffusion.models.ltx2.ltx2_components import (
     create_transformer_from_config,
     get_ltx2_post_process_func,
     load_transformer_config,
 )
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3 import LTX23Pipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_3_image2video import LTX23ImageToVideoPipeline
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_image2video import (
+from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2 import (
     LTX2I2VDMD2Pipeline,
-    LTX2ImageToVideoPipeline,
-    LTX2ImageToVideoTwoStagesPipeline,
+    LTX2Pipeline,
+    LTX2T2VDMD2Pipeline,
 )
-from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_latent_upsample import LTX2LatentUpsamplePipeline
+from vllm_omni.diffusion.models.ltx2.pipeline_ltx2_two_stage import LTX2DistilledPipeline
 
 __all__ = [
     "LTX2Pipeline",
     "LTX2T2VDMD2Pipeline",
-    "LTX2ImageToVideoPipeline",
     "LTX2I2VDMD2Pipeline",
-    "LTX2LatentUpsamplePipeline",
-    "LTX2TwoStagesPipeline",
-    "LTX2ImageToVideoTwoStagesPipeline",
-    "LTX23Pipeline",
-    "LTX23ImageToVideoPipeline",
+    "LTX2DistilledPipeline",
     "get_ltx2_post_process_func",
     "load_transformer_config",
     "create_transformer_from_config",
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_components.py b/vllm_omni/diffusion/models/ltx2/ltx2_components.py
new file mode 100644
index 000000000..54c866eb7
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_components.py
@@ -0,0 +1,470 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Shared component construction helpers for the LTX model family."""
+
+from __future__ import annotations
+
+import inspect
+import json
+import logging
+import os
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import torch
+from diffusers import AutoencoderKLLTX2Audio, AutoencoderKLLTX2Video, FlowMatchEulerDiscreteScheduler
+from diffusers.pipelines.ltx2 import LTX2TextConnectors
+from diffusers.pipelines.ltx2.latent_upsampler import LTX2LatentUpsamplerModel
+from diffusers.pipelines.ltx2.vocoder import LTX2Vocoder
+from diffusers.video_processor import VideoProcessor
+from huggingface_hub import hf_hub_download
+from transformers import AutoTokenizer, Gemma3ForConditionalGeneration
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.layer import Attention as OmniAttention
+from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 import DistributedAutoencoderKLLTX2Video
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
+from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
+from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
+
+if TYPE_CHECKING:
+    from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
+
+from .ltx2_transformer import (
+    LTX2VideoTransformer3DModel,
+    apply_interleaved_rotary_emb,
+    apply_split_rotary_emb,
+    to_ltx_padding_mask,
+)
+
+try:
+    from diffusers.pipelines.ltx2.vocoder import LTX2VocoderWithBWE
+except ImportError:
+    LTX2VocoderWithBWE = None
+
+
+_LTX_COMPONENT_SUBFOLDERS = (
+    "tokenizer",
+    "text_encoder",
+    "connectors",
+    "vae",
+    "audio_vae",
+    "vocoder",
+    "scheduler",
+    "latent_upsampler",
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class LTXComponentProfile:
+    """Component construction and discovery contract for an LTX variant."""
+
+    name: str
+    dit_modules: tuple[str, ...]
+    encoder_modules: tuple[str, ...]
+    vae_modules: tuple[str, ...]
+    resident_modules: tuple[str, ...] = ()
+    video_vae_cls: type = AutoencoderKLLTX2Video
+    vocoder_cls: type = LTX2Vocoder
+    vocoder_fallback_cls: type | None = None
+
+
+LTX2_COMPONENT_PROFILE = LTXComponentProfile(
+    name="ltx2",
+    dit_modules=("transformer",),
+    encoder_modules=("text_encoder", "connectors"),
+    vae_modules=("vae", "audio_vae"),
+    resident_modules=("vocoder",),
+    video_vae_cls=DistributedAutoencoderKLLTX2Video,
+)
+
+LTX23_COMPONENT_PROFILE = LTXComponentProfile(
+    name="ltx2_3",
+    dit_modules=("transformer",),
+    encoder_modules=("text_encoder", "connectors"),
+    vae_modules=("vae", "audio_vae"),
+    resident_modules=("vocoder",),
+    video_vae_cls=DistributedAutoencoderKLLTX2Video,
+    vocoder_cls=LTX2VocoderWithBWE or LTX2Vocoder,
+    vocoder_fallback_cls=LTX2Vocoder,
+)
+
+LTX2_DISTILLED_COMPONENT_PROFILE = LTXComponentProfile(
+    name="ltx2_distilled",
+    dit_modules=("transformer",),
+    encoder_modules=("text_encoder", "connectors"),
+    vae_modules=("vae", "audio_vae"),
+    resident_modules=("vocoder", "latent_upsampler"),
+    video_vae_cls=DistributedAutoencoderKLLTX2Video,
+)
+
+
+_COMPONENT_PROFILES: dict[tuple[str, str], LTXComponentProfile] = {
+    ("one_stage", "2"): LTX2_COMPONENT_PROFILE,
+    ("one_stage", "2.3"): LTX23_COMPONENT_PROFILE,
+    ("distilled_two_stage", "2"): LTX2_DISTILLED_COMPONENT_PROFILE,
+    ("dmd2", "2"): LTX2_COMPONENT_PROFILE,
+    ("dmd2", "2.3"): LTX23_COMPONENT_PROFILE,
+}
+
+
+def resolve_ltx_component_profile(pipeline_kind: str, model_version: str) -> LTXComponentProfile:
+    """Resolve component construction independently from execution recipes."""
+    try:
+        return _COMPONENT_PROFILES[(pipeline_kind, model_version)]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported LTX component kind/version: {pipeline_kind!r}/{model_version!r}.") from exc
+
+
+def _load_ltx_metadata_json(model: str, filename: str) -> dict[str, Any]:
+    """Load small checkpoint metadata without relying on repository names."""
+    if os.path.isdir(model):
+        path = os.path.join(model, filename)
+        if not os.path.isfile(path):
+            return {}
+    else:
+        try:
+            path = hf_hub_download(repo_id=model, filename=filename)
+        except Exception:
+            return {}
+    try:
+        with open(path) as config_file:
+            value = json.load(config_file)
+    except (OSError, TypeError, ValueError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def detect_ltx_model_version(model: str) -> str:
+    """Detect LTX-2 versus LTX-2.3 from checkpoint component metadata.
+
+    Official checkpoints use ``model_version`` metadata. Diffusers repositories
+    expose the equivalent distinction through the BWE vocoder introduced by
+    LTX-2.3. Unknown conversions retain the official LTX-2 fallback.
+    """
+    model_index = _load_ltx_metadata_json(model, "model_index.json")
+    if str(model_index.get("model_version", "")).startswith("2.3"):
+        return "2.3"
+
+    vocoder_entry = model_index.get("vocoder")
+    if isinstance(vocoder_entry, (list, tuple)) and vocoder_entry:
+        vocoder_class = str(vocoder_entry[-1])
+    elif isinstance(vocoder_entry, dict):
+        vocoder_class = str(vocoder_entry.get("_class_name", ""))
+    else:
+        vocoder_class = ""
+    if vocoder_class == "LTX2VocoderWithBWE":
+        return "2.3"
+
+    vocoder_config = _load_ltx_metadata_json(model, "vocoder/config.json")
+    if str(vocoder_config.get("model_version", "")).startswith("2.3"):
+        return "2.3"
+    if vocoder_config.get("_class_name") == "LTX2VocoderWithBWE":
+        return "2.3"
+
+    logger.info("Using LTX-2 defaults for checkpoint %s", model)
+    return "2"
+
+
+class _LTXConnectorAttnProcessor:
+    """Preserve official connector math around Omni attention dispatch."""
+
+    def __init__(self, *, has_learned_registers: bool) -> None:
+        self.has_learned_registers = has_learned_registers
+
+    def __call__(
+        self,
+        attn: Any,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        query_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        key_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        encoder_hidden_states = encoder_hidden_states if encoder_hidden_states is not None else hidden_states
+        gate_logits = attn.to_gate_logits(hidden_states) if attn.to_gate_logits is not None else None
+
+        query = attn.norm_q(attn.to_q(hidden_states))
+        key = attn.norm_k(attn.to_k(encoder_hidden_states))
+        value = attn.to_v(encoder_hidden_states)
+
+        if query_rotary_emb is not None:
+            key_rotary_emb = key_rotary_emb if key_rotary_emb is not None else query_rotary_emb
+            if attn.rope_type == "interleaved":
+                query = apply_interleaved_rotary_emb(query, query_rotary_emb)
+                key = apply_interleaved_rotary_emb(key, key_rotary_emb)
+            elif attn.rope_type == "split":
+                query = apply_split_rotary_emb(query, query_rotary_emb, head_dim=attn.head_dim)
+                key = apply_split_rotary_emb(key, key_rotary_emb, head_dim=attn.head_dim)
+            else:
+                raise ValueError(f"Unsupported LTX connector RoPE type: {attn.rope_type}")
+
+        batch_size, _, inner_dim = query.shape
+        head_dim = inner_dim // attn.heads
+        kv_heads = attn.inner_kv_dim // attn.head_dim
+        query = query.view(batch_size, -1, attn.heads, head_dim)
+        key = key.view(batch_size, -1, kv_heads, head_dim)
+        value = value.view(batch_size, -1, kv_heads, head_dim)
+
+        # The connector replaces padding tokens with learned registers before
+        # entering its blocks, so every key is valid and the old padding mask
+        # becomes an all-keep no-op.
+        if self.has_learned_registers:
+            attention_mask = None
+        elif attention_mask is not None and attn.omni_attention.attn_backend.get_name().upper() == "FLASH_ATTN":
+            attention_mask = to_ltx_padding_mask(attention_mask)
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        hidden_states = attn.omni_attention(query, key, value, attn_metadata)
+        hidden_states = hidden_states.reshape(batch_size, -1, inner_dim)
+
+        if gate_logits is not None:
+            hidden_states = hidden_states.unflatten(2, (attn.heads, -1))
+            hidden_states = hidden_states * (2.0 * torch.sigmoid(gate_logits)).unsqueeze(-1)
+            hidden_states = hidden_states.flatten(2, 3)
+
+        hidden_states = attn.to_out[0](hidden_states)
+        return attn.to_out[1](hidden_states)
+
+
+def _install_connector_attention(connectors: LTX2TextConnectors) -> None:
+    for connector_name in ("video_connector", "audio_connector"):
+        connector = getattr(connectors, connector_name, None)
+        has_learned_registers = getattr(connector, "learnable_registers", None) is not None
+        for block_index, block in enumerate(getattr(connector, "transformer_blocks", ())):
+            attention = getattr(block, "attn1", None)
+            if attention is not None:
+                attention.omni_attention = OmniAttention(
+                    num_heads=attention.heads,
+                    head_size=attention.head_dim,
+                    num_kv_heads=attention.inner_kv_dim // attention.head_dim,
+                    softmax_scale=1.0 / (attention.head_dim**0.5),
+                    causal=False,
+                    prefix=f"connectors.{connector_name}.transformer_blocks.{block_index}.attn1",
+                    role="ltx2.connector",
+                    role_category="self",
+                    skip_sequence_parallel=True,
+                    disable_kv_quant=True,
+                )
+                attention.set_processor(_LTXConnectorAttnProcessor(has_learned_registers=has_learned_registers))
+
+
+def _detect_vocoder_output_sample_rate(model: str) -> int | None:
+    """Read the generated waveform sample rate from the vocoder config."""
+    vocoder_config_path = os.path.join(model, "vocoder", "config.json")
+    if not os.path.exists(vocoder_config_path):
+        try:
+            vocoder_config_path = hf_hub_download(model, "vocoder/config.json")
+        except Exception:
+            return None
+    try:
+        with open(vocoder_config_path) as config_file:
+            return json.load(config_file).get("output_sampling_rate")
+    except Exception:
+        return None
+
+
+def get_ltx2_post_process_func(od_config: Any):
+    """Build the common LTX engine-output adapter."""
+    output_sample_rate = _detect_vocoder_output_sample_rate(od_config.model)
+
+    def post_process_func(output: tuple[torch.Tensor, torch.Tensor] | torch.Tensor):
+        if not (isinstance(output, tuple) and len(output) == 2):
+            return output
+        video, audio = output
+        if isinstance(audio, torch.Tensor):
+            audio = audio.detach().cpu()
+        result: dict[str, Any] = {"video": video, "audio": audio}
+        if output_sample_rate is not None:
+            result["audio_sample_rate"] = output_sample_rate
+        return result
+
+    return post_process_func
+
+
+def _load_component(
+    component_cls: type,
+    model: str,
+    subfolder: str,
+    *,
+    local_files_only: bool,
+    dtype: torch.dtype,
+) -> Any:
+    return from_pretrained_with_prefetch(
+        component_cls.from_pretrained,
+        model,
+        subfolder=subfolder,
+        prefetch_list=_LTX_COMPONENT_SUBFOLDERS,
+        local_files_only=local_files_only,
+        torch_dtype=dtype,
+    )
+
+
+def _place_aux_components(pipeline: Any) -> None:
+    parallel_config = getattr(pipeline.od_config, "parallel_config", None)
+    use_managed_placement = bool(
+        getattr(pipeline.od_config, "enable_cpu_offload", False)
+        or getattr(pipeline.od_config, "enable_layerwise_offload", False)
+        or getattr(parallel_config, "use_hsdp", False)
+    )
+    if use_managed_placement:
+        return
+
+    modules = ModuleDiscovery.discover(pipeline)
+    for module in (*modules.encoders, *modules.vaes, *modules.resident_modules):
+        module.to(pipeline.device)
+
+
+def initialize_pipeline_components(pipeline: Any, od_config: Any) -> None:
+    """Build the common LTX component graph selected by ``component_profile``."""
+    profile: LTXComponentProfile = pipeline.component_profile
+    pipeline.od_config = od_config
+    pipeline.device = get_local_device()
+    dtype = getattr(od_config, "dtype", torch.bfloat16)
+    model = od_config.model
+    local_files_only = os.path.exists(model)
+
+    pipeline.weights_sources = [
+        DiffusersPipelineLoader.ComponentSource(
+            model_or_path=model,
+            subfolder="transformer",
+            revision=None,
+            prefix="transformer.",
+            fall_back_to_pt=True,
+        ),
+    ]
+    prefetch_subfolders(model, _LTX_COMPONENT_SUBFOLDERS, local_files_only=local_files_only)
+
+    pipeline.tokenizer = AutoTokenizer.from_pretrained(
+        model,
+        subfolder="tokenizer",
+        local_files_only=local_files_only,
+    )
+    with torch.device("cpu"):
+        pipeline.text_encoder = _load_component(
+            Gemma3ForConditionalGeneration,
+            model,
+            "text_encoder",
+            local_files_only=local_files_only,
+            dtype=dtype,
+        )
+    pipeline.connectors = _load_component(
+        LTX2TextConnectors,
+        model,
+        "connectors",
+        local_files_only=local_files_only,
+        dtype=dtype,
+    )
+    _install_connector_attention(pipeline.connectors)
+    pipeline.vae = _load_component(
+        profile.video_vae_cls,
+        model,
+        "vae",
+        local_files_only=local_files_only,
+        dtype=dtype,
+    )
+    pipeline.audio_vae = _load_component(
+        AutoencoderKLLTX2Audio,
+        model,
+        "audio_vae",
+        local_files_only=local_files_only,
+        dtype=dtype,
+    )
+    try:
+        pipeline.vocoder = _load_component(
+            profile.vocoder_cls,
+            model,
+            "vocoder",
+            local_files_only=local_files_only,
+            dtype=dtype,
+        )
+    except (TypeError, OSError, ValueError):
+        if profile.vocoder_fallback_cls is None or profile.vocoder_fallback_cls is profile.vocoder_cls:
+            raise
+        pipeline.vocoder = _load_component(
+            profile.vocoder_fallback_cls,
+            model,
+            "vocoder",
+            local_files_only=local_files_only,
+            dtype=dtype,
+        )
+
+    if "latent_upsampler" in profile.resident_modules:
+        # BlurDownsample constructs an integer kernel that must be initialized
+        # on CPU; component placement is handled uniformly after construction.
+        with torch.device("cpu"):
+            pipeline.latent_upsampler = _load_component(
+                LTX2LatentUpsamplerModel,
+                model,
+                "latent_upsampler",
+                local_files_only=local_files_only,
+                dtype=dtype,
+            )
+
+    transformer_config = load_transformer_config(model, "transformer", local_files_only)
+    quant_config = getattr(od_config, "quantization_config", None)
+    pipeline.transformer = create_transformer_from_config(transformer_config, quant_config=quant_config)
+    _place_aux_components(pipeline)
+    pipeline.scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+        model,
+        subfolder="scheduler",
+        local_files_only=local_files_only,
+    )
+
+    pipeline.vae_spatial_compression_ratio = pipeline.vae.spatial_compression_ratio
+    pipeline.vae_temporal_compression_ratio = pipeline.vae.temporal_compression_ratio
+    pipeline.audio_vae_mel_compression_ratio = pipeline.audio_vae.mel_compression_ratio
+    pipeline.audio_vae_temporal_compression_ratio = pipeline.audio_vae.temporal_compression_ratio
+    pipeline.transformer_spatial_patch_size = pipeline.transformer.config.patch_size
+    pipeline.transformer_temporal_patch_size = pipeline.transformer.config.patch_size_t
+    pipeline.audio_sampling_rate = pipeline.audio_vae.config.sample_rate
+    pipeline.audio_hop_length = pipeline.audio_vae.config.mel_hop_length
+    pipeline.video_processor = VideoProcessor(vae_scale_factor=pipeline.vae_spatial_compression_ratio)
+
+    tokenizer_max_length = pipeline.tokenizer.model_max_length
+    if tokenizer_max_length is None or tokenizer_max_length > 100000:
+        encoder_config = getattr(pipeline.text_encoder, "config", None)
+        tokenizer_max_length = getattr(encoder_config, "max_position_embeddings", None)
+        if tokenizer_max_length is None:
+            tokenizer_max_length = getattr(encoder_config, "max_seq_len", None)
+    pipeline.tokenizer_max_length = int(tokenizer_max_length or 1024)
+
+    pipeline._interrupt = False
+
+
+def load_transformer_config(
+    model_path: str,
+    subfolder: str = "transformer",
+    local_files_only: bool = True,
+) -> dict:
+    """Load an LTX transformer config from a local model or the HF Hub."""
+    if local_files_only:
+        config_path = os.path.join(model_path, subfolder, "config.json")
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"LTX transformer config not found: {config_path}")
+    else:
+        config_path = hf_hub_download(
+            repo_id=model_path,
+            filename=f"{subfolder}/config.json",
+        )
+    with open(config_path) as config_file:
+        return json.load(config_file)
+
+
+def create_transformer_from_config(
+    config: dict,
+    quant_config: QuantizationConfig | None = None,
+) -> LTX2VideoTransformer3DModel:
+    """Construct the shared LTX transformer from a Diffusers config."""
+    if not config and quant_config is None:
+        return LTX2VideoTransformer3DModel()
+
+    signature = inspect.signature(LTX2VideoTransformer3DModel.__init__)
+    allowed_keys = set(signature.parameters)
+    kwargs = {key: value for key, value in config.items() if key in allowed_keys}
+    if quant_config is not None:
+        kwargs["quant_config"] = quant_config
+
+    return LTX2VideoTransformer3DModel(**kwargs)
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_conditioning.py b/vllm_omni/diffusion/models/ltx2/ltx2_conditioning.py
new file mode 100644
index 000000000..f4d2f26f6
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_conditioning.py
@@ -0,0 +1,777 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Task-specific conditioning shared by LTX model versions."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import PIL.Image
+import torch
+import torch.nn.functional as F
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import retrieve_latents
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+
+from . import ltx2_latents as latent_ops
+from .ltx2_guidance import euler_step_from_velocity
+
+if TYPE_CHECKING:
+    from .ltx2_denoise import LTXDenoiseContext, LTXForwardContext
+    from .ltx2_request import LTXRequestInputs
+
+
+@dataclass
+class LTXPromptContext:
+    """Connector outputs consumed by an LTX denoise phase."""
+
+    batch_size: int
+    connector_prompt_embeds: torch.Tensor
+    connector_audio_prompt_embeds: torch.Tensor
+    connector_attention_mask: torch.Tensor
+    positive_connector_prompt_embeds: torch.Tensor
+    positive_connector_audio_prompt_embeds: torch.Tensor
+    positive_connector_attention_mask: torch.Tensor
+    negative_connector_prompt_embeds: torch.Tensor | None
+    negative_connector_audio_prompt_embeds: torch.Tensor | None
+    negative_connector_attention_mask: torch.Tensor | None
+
+
+def _repeat_prompt_tensor_for_outputs(tensor: torch.Tensor, num_outputs: int) -> torch.Tensor:
+    if num_outputs == 1:
+        return tensor
+    return tensor.repeat_interleave(num_outputs, dim=0)
+
+
+def _preprocess_i2v_pil_images(
+    images: PIL.Image.Image | list[PIL.Image.Image],
+    *,
+    height: int,
+    width: int,
+    device: torch.device | None = None,
+    dtype: torch.dtype | None = None,
+) -> torch.Tensor:
+    """Match official LTX aspect-preserving resize and center crop."""
+    image_list = images if isinstance(images, list) else [images]
+    processed = []
+    for image in image_list:
+        pixels = (
+            torch.from_numpy(np.array(image.convert("RGB"), copy=True))
+            .permute(2, 0, 1)
+            .unsqueeze(0)
+            .to(device=device, dtype=torch.float32)
+        )
+        source_height, source_width = pixels.shape[-2:]
+        scale = max(height / source_height, width / source_width)
+        resized_height = math.ceil(source_height * scale)
+        resized_width = math.ceil(source_width * scale)
+        pixels = F.interpolate(
+            pixels,
+            size=(resized_height, resized_width),
+            mode="bilinear",
+            align_corners=False,
+        )
+        crop_top = (resized_height - height) // 2
+        crop_left = (resized_width - width) // 2
+        pixels = pixels[:, :, crop_top : crop_top + height, crop_left : crop_left + width]
+        processed.append((pixels / 127.5 - 1.0).to(dtype=dtype))
+    return torch.cat(processed, dim=0)
+
+
+class LTXTextConditioningMixin:
+    """Shared Gemma encoding and text connector orchestration."""
+
+    connector_batches_cfg = False
+
+    def _get_gemma_prompt_embeds(
+        self,
+        prompt: str | list[str],
+        num_videos_per_prompt: int = 1,
+        max_sequence_length: int = 1024,
+        scale_factor: int = 8,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        del scale_factor
+        device = device or self.device
+        dtype = dtype or self.text_encoder.dtype
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        batch_size = len(prompt)
+
+        self.tokenizer.padding_side = "left"
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        text_inputs = self.tokenizer(
+            [text.strip() for text in prompt],
+            padding="max_length",
+            max_length=max_sequence_length,
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        )
+        text_input_ids = text_inputs.input_ids.to(device)
+        prompt_attention_mask = text_inputs.attention_mask.to(device)
+        hidden_states = self.text_encoder(
+            input_ids=text_input_ids,
+            attention_mask=prompt_attention_mask,
+            output_hidden_states=True,
+        ).hidden_states
+
+        prompt_embeds = torch.stack(hidden_states, dim=-1).flatten(2, 3).to(dtype=dtype)
+        prompt_embeds = _repeat_prompt_tensor_for_outputs(prompt_embeds, num_videos_per_prompt)
+        prompt_attention_mask = prompt_attention_mask.view(batch_size, -1)
+        prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
+            prompt_attention_mask,
+            num_videos_per_prompt,
+        )
+        return prompt_embeds, prompt_attention_mask
+
+    def encode_prompt(
+        self,
+        prompt: str | list[str] | None,
+        negative_prompt: str | list[str] | None = None,
+        do_classifier_free_guidance: bool = True,
+        num_videos_per_prompt: int = 1,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        prompt_attention_mask: torch.Tensor | None = None,
+        negative_prompt_attention_mask: torch.Tensor | None = None,
+        max_sequence_length: int = 1024,
+        scale_factor: int = 8,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        device = device or self.device
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        batch_size = len(prompt) if prompt is not None else prompt_embeds.shape[0]
+        negative_prompt_embeds_provided = negative_prompt_embeds is not None
+
+        if do_classifier_free_guidance and prompt_embeds is None and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type as `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            if isinstance(negative_prompt, list) and batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt` has batch size {len(negative_prompt)}, but `prompt` has batch size"
+                    f" {batch_size}."
+                )
+
+            # Official LTX encodes positive and negative prompts in one Gemma batch;
+            # separate bf16 GEMMs produce a different conditioning trajectory.
+            combined_embeds, combined_mask = self._get_gemma_prompt_embeds(
+                prompt=prompt + negative_prompt,
+                num_videos_per_prompt=1,
+                max_sequence_length=max_sequence_length,
+                scale_factor=scale_factor,
+                device=device,
+                dtype=dtype,
+            )
+            prompt_embeds = combined_embeds[:batch_size]
+            negative_prompt_embeds = combined_embeds[batch_size:]
+            prompt_attention_mask = combined_mask[:batch_size]
+            negative_prompt_attention_mask = combined_mask[batch_size:]
+            if num_videos_per_prompt > 1:
+                prompt_embeds = _repeat_prompt_tensor_for_outputs(prompt_embeds, num_videos_per_prompt)
+                negative_prompt_embeds = _repeat_prompt_tensor_for_outputs(
+                    negative_prompt_embeds,
+                    num_videos_per_prompt,
+                )
+                prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
+                    prompt_attention_mask,
+                    num_videos_per_prompt,
+                )
+                negative_prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
+                    negative_prompt_attention_mask,
+                    num_videos_per_prompt,
+                )
+        else:
+            if prompt_embeds is None:
+                prompt_embeds, prompt_attention_mask = self._get_gemma_prompt_embeds(
+                    prompt=prompt,
+                    num_videos_per_prompt=num_videos_per_prompt,
+                    max_sequence_length=max_sequence_length,
+                    scale_factor=scale_factor,
+                    device=device,
+                    dtype=dtype,
+                )
+            elif num_videos_per_prompt > 1:
+                prompt_embeds = _repeat_prompt_tensor_for_outputs(prompt_embeds, num_videos_per_prompt)
+                prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
+                    prompt_attention_mask,
+                    num_videos_per_prompt,
+                )
+
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type as `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            if isinstance(negative_prompt, list) and batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt` has batch size {len(negative_prompt)}, but `prompt` has batch size"
+                    f" {batch_size}."
+                )
+            negative_prompt_embeds, negative_prompt_attention_mask = self._get_gemma_prompt_embeds(
+                prompt=negative_prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                scale_factor=scale_factor,
+                device=device,
+                dtype=dtype,
+            )
+        elif do_classifier_free_guidance and negative_prompt_embeds_provided and num_videos_per_prompt > 1:
+            negative_prompt_embeds = _repeat_prompt_tensor_for_outputs(
+                negative_prompt_embeds,
+                num_videos_per_prompt,
+            )
+            negative_prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
+                negative_prompt_attention_mask,
+                num_videos_per_prompt,
+            )
+
+        return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask
+
+    def _prepare_prompt_context(
+        self,
+        *,
+        prompt: str | list[str] | None,
+        negative_prompt: str | list[str] | None,
+        prompt_embeds: torch.Tensor | None,
+        negative_prompt_embeds: torch.Tensor | None,
+        prompt_attention_mask: torch.Tensor | None,
+        negative_prompt_attention_mask: torch.Tensor | None,
+        num_videos_per_prompt: int,
+        max_sequence_length: int,
+    ) -> LTXPromptContext:
+        if isinstance(prompt, str):
+            batch_size = 1
+        elif isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
+            self.encode_prompt(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                do_classifier_free_guidance=self.do_classifier_free_guidance,
+                num_videos_per_prompt=num_videos_per_prompt,
+                prompt_embeds=prompt_embeds,
+                negative_prompt_embeds=negative_prompt_embeds,
+                prompt_attention_mask=prompt_attention_mask,
+                negative_prompt_attention_mask=negative_prompt_attention_mask,
+                max_sequence_length=max_sequence_length,
+                device=self.device,
+            )
+        )
+        padding_side = getattr(self.tokenizer, "padding_side", "left")
+
+        if self.do_classifier_free_guidance and self.connector_batches_cfg:
+            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
+            prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0)
+
+        video_context, audio_context, attention_mask = self.connectors(
+            prompt_embeds,
+            prompt_attention_mask,
+            padding_side=padding_side,
+        )
+        positive_video_context = video_context
+        positive_audio_context = audio_context
+        positive_attention_mask = attention_mask
+        negative_video_context = None
+        negative_audio_context = None
+        negative_attention_mask = None
+
+        if self.do_classifier_free_guidance and self.connector_batches_cfg:
+            split_batch = batch_size * num_videos_per_prompt
+            negative_video_context = video_context[:split_batch]
+            positive_video_context = video_context[split_batch:]
+            negative_audio_context = audio_context[:split_batch]
+            positive_audio_context = audio_context[split_batch:]
+            negative_attention_mask = attention_mask[:split_batch]
+            positive_attention_mask = attention_mask[split_batch:]
+        elif self.do_classifier_free_guidance:
+            negative_video_context, negative_audio_context, negative_attention_mask = self.connectors(
+                negative_prompt_embeds,
+                negative_prompt_attention_mask,
+                padding_side=padding_side,
+            )
+
+        return LTXPromptContext(
+            batch_size=batch_size,
+            connector_prompt_embeds=video_context,
+            connector_audio_prompt_embeds=audio_context,
+            connector_attention_mask=attention_mask,
+            positive_connector_prompt_embeds=positive_video_context,
+            positive_connector_audio_prompt_embeds=positive_audio_context,
+            positive_connector_attention_mask=positive_attention_mask,
+            negative_connector_prompt_embeds=negative_video_context,
+            negative_connector_audio_prompt_embeds=negative_audio_context,
+            negative_connector_attention_mask=negative_attention_mask,
+        )
+
+
+class LTXI2VConditioningMixin:
+    """First-frame conditioning with optional unified T2V/I2V dispatch."""
+
+    support_image_input = True
+    unified_text_image_entry = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.video_processor = VideoProcessor(
+            vae_scale_factor=self.vae_spatial_compression_ratio,
+            resample="bilinear",
+        )
+
+    @staticmethod
+    def _resolve_single_prompt_image(raw_image: Any) -> Any:
+        if isinstance(raw_image, list):
+            if len(raw_image) != 1:
+                raise ValueError(
+                    "LTX I2V prompt dictionaries support exactly one image per prompt. "
+                    "Pass one image per prompt for batched I2V requests."
+                )
+            return raw_image[0]
+        return raw_image
+
+    @staticmethod
+    def _resolve_additional_image(additional: dict[str, Any]) -> Any:
+        for field_name in ("preprocessed_image", "pixel_values", "image"):
+            raw_image = additional.get(field_name)
+            if raw_image is not None:
+                return raw_image
+        return None
+
+    def _resolve_request_image(
+        self,
+        req: Any,
+        image: Any | None,
+        request_inputs: LTXRequestInputs,
+    ) -> Any | None:
+        prompts = getattr(req, "prompts", None)
+        if image is not None or not prompts:
+            return image
+
+        raw_images = []
+        for prompt_item in prompts:
+            if isinstance(prompt_item, str):
+                raw_image = None
+            else:
+                multi_modal_data = prompt_item.get("multi_modal_data") or {}
+                raw_image = multi_modal_data.get("image")
+                if raw_image is None:
+                    raw_image = self._resolve_additional_image(prompt_item.get("additional_information") or {})
+            raw_image = self._resolve_single_prompt_image(raw_image)
+            if isinstance(raw_image, str):
+                raw_image = PIL.Image.open(raw_image).convert("RGB")
+            raw_images.append(raw_image)
+
+        if all(raw_image is None for raw_image in raw_images) and self.unified_text_image_entry:
+            return None
+        if any(raw_image is None for raw_image in raw_images) and request_inputs.latents is None:
+            if not self.unified_text_image_entry:
+                raise ValueError("Image is required for LTX I2V generation.")
+            raise ValueError("LTX request batches cannot mix text-to-video and image-to-video prompts.")
+        if len(raw_images) == 1:
+            return raw_images[0]
+        return raw_images or image
+
+    def _check_forward_inputs(
+        self,
+        request_inputs: LTXRequestInputs,
+        image: Any | None = None,
+    ) -> None:
+        if not self.unified_text_image_entry and image is None and request_inputs.latents is None:
+            raise ValueError("Provide either `image` or `latents`. Cannot leave both undefined.")
+        super()._check_forward_inputs(request_inputs, image=image)
+
+    def _encode_i2v_image_latents(
+        self,
+        image: torch.Tensor,
+        *,
+        batch_size: int,
+        generator: torch.Generator | list[torch.Generator] | None,
+        dtype: torch.dtype | None,
+    ) -> torch.Tensor:
+        """Encode one conditioning frame per prompt into normalized latents."""
+        image_batch_size = image.shape[0]
+        if image_batch_size == 0:
+            raise ValueError("`image` batch is empty.")
+        if batch_size % image_batch_size != 0:
+            raise ValueError(
+                f"`batch_size` ({batch_size}) must be divisible by image batch size ({image_batch_size}) "
+                "for image-to-video outputs."
+            )
+        num_videos_per_prompt = batch_size // image_batch_size
+
+        if isinstance(generator, list):
+            if len(generator) != batch_size:
+                raise ValueError(
+                    f"You have passed a list of generators of length {len(generator)}, but requested an effective"
+                    f" batch size of {batch_size}. Make sure the batch size matches the length of the generators."
+                )
+            image_generators = [generator[i * num_videos_per_prompt] for i in range(image_batch_size)]
+            init_latents = [
+                retrieve_latents(
+                    self.vae.encode(image[i].unsqueeze(0).unsqueeze(2)),
+                    image_generators[i],
+                    "argmax",
+                )
+                for i in range(image_batch_size)
+            ]
+        else:
+            init_latents = [
+                retrieve_latents(
+                    self.vae.encode(img.unsqueeze(0).unsqueeze(2)),
+                    generator,
+                    "argmax",
+                )
+                for img in image
+            ]
+
+        init_latents = torch.cat(init_latents, dim=0).to(dtype=dtype)
+        if num_videos_per_prompt > 1:
+            init_latents = init_latents.repeat_interleave(num_videos_per_prompt, dim=0)
+        return latent_ops.normalize_latents(
+            init_latents,
+            self.vae.latents_mean,
+            self.vae.latents_std,
+        )
+
+    @staticmethod
+    def _replace_first_latent_frame(
+        latents: torch.Tensor,
+        image_latents: torch.Tensor,
+    ) -> torch.Tensor:
+        expected_shape = (latents.shape[0], latents.shape[1], 1, latents.shape[3], latents.shape[4])
+        if tuple(image_latents.shape) != expected_shape:
+            raise ValueError(
+                f"Encoded LTX conditioning image has shape {tuple(image_latents.shape)}, expected {expected_shape}."
+            )
+        latents = latents.clone()
+        latents[:, :, :1] = image_latents
+        return latents
+
+    def prepare_latents(
+        self,
+        image: torch.Tensor | None = None,
+        batch_size: int = 1,
+        num_channels_latents: int = 128,
+        height: int = 512,
+        width: int = 768,
+        num_frames: int = 121,
+        noise_scale: float = 0.0,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        if image is None and self.unified_text_image_entry:
+            return super().prepare_latents(
+                batch_size=batch_size,
+                num_channels_latents=num_channels_latents,
+                height=height,
+                width=width,
+                num_frames=num_frames,
+                noise_scale=noise_scale,
+                dtype=dtype,
+                device=device,
+                generator=generator,
+                latents=latents,
+            )
+
+        num_frames, height, width = latent_ops.resolve_video_latent_shape(
+            height,
+            width,
+            num_frames,
+            vae_spatial_compression_ratio=self.vae_spatial_compression_ratio,
+            vae_temporal_compression_ratio=self.vae_temporal_compression_ratio,
+        )
+        mask_shape = (batch_size, 1, num_frames, height, width)
+
+        if latents is not None:
+            unpacked_latents = latents.ndim == 5
+            if latents.ndim == 5:
+                expected_shape = (batch_size, num_channels_latents, num_frames, height, width)
+                if tuple(latents.shape) != expected_shape:
+                    raise ValueError(
+                        f"Provided unpacked `latents` have shape {tuple(latents.shape)}, expected {expected_shape}."
+                    )
+                conditioning_mask = latents.new_zeros(mask_shape)
+                conditioning_mask[:, :, 0] = 1.0
+                latents = latent_ops.normalize_latents(
+                    latents,
+                    self.vae.latents_mean,
+                    self.vae.latents_std,
+                    self.vae.config.scaling_factor,
+                )
+                if image is not None:
+                    image_latents = self._encode_i2v_image_latents(
+                        image,
+                        batch_size=batch_size,
+                        generator=generator,
+                        dtype=dtype,
+                    )
+                    # Official distilled Stage 2 starts from the upsampled Stage 1
+                    # state, then reapplies the source image at final resolution.
+                    latents = self._replace_first_latent_frame(latents, image_latents)
+                latents = latent_ops.pack_latents(
+                    latents,
+                    self.transformer_spatial_patch_size,
+                    self.transformer_temporal_patch_size,
+                )
+            else:
+                conditioning_mask = latents.new_zeros(mask_shape)
+                conditioning_mask[:, :, 0] = 1.0
+
+            conditioning_mask = latent_ops.pack_latents(
+                conditioning_mask,
+                self.transformer_spatial_patch_size,
+                self.transformer_temporal_patch_size,
+            ).squeeze(-1)
+            if latents.ndim != 3 or latents.shape[:2] != conditioning_mask.shape:
+                raise ValueError(
+                    "Provided `latents` tensor has shape"
+                    f" {latents.shape}, but the expected shape is {conditioning_mask.shape + (num_channels_latents,)}."
+                )
+            if unpacked_latents:
+                # Official LTX patchifies the latent state before drawing noise.
+                # Sampling the packed shape preserves its seed-to-output contract.
+                latents = latent_ops.create_noised_state(
+                    latents,
+                    noise_scale * (1 - conditioning_mask).unsqueeze(-1),
+                    generator,
+                )
+            elif image is not None:
+                image_latents = self._encode_i2v_image_latents(
+                    image,
+                    batch_size=batch_size,
+                    generator=generator,
+                    dtype=dtype,
+                )
+                unpacked = latent_ops.unpack_latents(
+                    latents,
+                    num_frames,
+                    height,
+                    width,
+                    self.transformer_spatial_patch_size,
+                    self.transformer_temporal_patch_size,
+                )
+                unpacked = self._replace_first_latent_frame(unpacked, image_latents)
+                latents = latent_ops.pack_latents(
+                    unpacked,
+                    self.transformer_spatial_patch_size,
+                    self.transformer_temporal_patch_size,
+                )
+            return latents.to(device=device, dtype=dtype), conditioning_mask
+
+        if image is None:
+            raise ValueError("`image` must be provided when `latents` is None.")
+        init_latents = self._encode_i2v_image_latents(
+            image,
+            batch_size=batch_size,
+            generator=generator,
+            dtype=dtype,
+        )
+        init_latents = init_latents.repeat(1, 1, num_frames, 1, 1)
+
+        conditioning_mask = torch.zeros(mask_shape, device=device, dtype=dtype)
+        conditioning_mask[:, :, 0] = 1.0
+        init_latents = latent_ops.pack_latents(
+            init_latents,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        )
+        conditioning_mask = latent_ops.pack_latents(
+            conditioning_mask,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        ).squeeze(-1)
+        noise = randn_tensor(init_latents.shape, generator=generator, device=device, dtype=dtype)
+        latents = init_latents * conditioning_mask.unsqueeze(-1) + noise * (1 - conditioning_mask).unsqueeze(-1)
+        return latents, conditioning_mask
+
+    def _step_video_latents_i2v(
+        self,
+        noise_pred_video: torch.Tensor,
+        latents: torch.Tensor,
+        step_index: int,
+        latent_num_frames: int,
+        latent_height: int,
+        latent_width: int,
+    ) -> torch.Tensor:
+        noise_pred_video = latent_ops.unpack_latents(
+            noise_pred_video,
+            latent_num_frames,
+            latent_height,
+            latent_width,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        )
+        latents_unpacked = latent_ops.unpack_latents(
+            latents,
+            latent_num_frames,
+            latent_height,
+            latent_width,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        )
+        noise_pred_video = noise_pred_video[:, :, 1:]
+        noise_latents = latents_unpacked[:, :, 1:]
+        # Official LTX advances the unconditioned frames directly on the
+        # sigma trajectory; the first frame remains fixed conditioning.
+        pred_latents = euler_step_from_velocity(
+            noise_latents,
+            noise_pred_video,
+            self.scheduler.sigmas,
+            step_index,
+        )
+        latents_unpacked = torch.cat([latents_unpacked[:, :, :1], pred_latents], dim=2)
+        return latent_ops.pack_latents(
+            latents_unpacked,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        )
+
+    def _prepare_video_latents_stage(
+        self,
+        request_inputs: LTXRequestInputs,
+        prompt_context: LTXPromptContext,
+        *,
+        device: torch.device,
+        noise_scale: float,
+        image: Any | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        if image is None and self.unified_text_image_entry:
+            return super()._prepare_video_latents_stage(
+                request_inputs,
+                prompt_context,
+                device=device,
+                noise_scale=noise_scale,
+                image=None,
+            )
+
+        if image is not None:
+            if isinstance(image, torch.Tensor):
+                if image.ndim == 3:
+                    image = image.unsqueeze(0)
+            elif isinstance(image, list) and image and isinstance(image[0], torch.Tensor):
+                image = torch.stack(image, dim=0)
+            elif isinstance(image, PIL.Image.Image) or (
+                isinstance(image, list) and image and isinstance(image[0], PIL.Image.Image)
+            ):
+                image = _preprocess_i2v_pil_images(
+                    image,
+                    height=request_inputs.height,
+                    width=request_inputs.width,
+                    device=device,
+                    dtype=prompt_context.positive_connector_prompt_embeds.dtype,
+                )
+            else:
+                image = self.video_processor.preprocess(
+                    image,
+                    height=request_inputs.height,
+                    width=request_inputs.width,
+                )
+            image = image.to(
+                device=device,
+                dtype=prompt_context.positive_connector_prompt_embeds.dtype,
+            )
+
+        return self.prepare_latents(
+            image=image,
+            batch_size=prompt_context.batch_size * request_inputs.num_videos_per_prompt,
+            num_channels_latents=self.transformer.config.in_channels,
+            height=request_inputs.height,
+            width=request_inputs.width,
+            num_frames=request_inputs.num_frames,
+            noise_scale=noise_scale,
+            dtype=prompt_context.positive_connector_prompt_embeds.dtype,
+            device=device,
+            generator=request_inputs.generator,
+            latents=request_inputs.latents,
+        )
+
+    def _prepare_denoise_context_for_guidance(
+        self,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> LTXDenoiseContext:
+        denoise_ctx = super()._prepare_denoise_context_for_guidance(forward_ctx, denoise_ctx)
+        if denoise_ctx.conditioning_mask is None:
+            if self.unified_text_image_entry:
+                return denoise_ctx
+            raise ValueError("LTX I2V denoising requires a conditioning mask.")
+
+        mask_batch = denoise_ctx.conditioning_mask.shape[0]
+        model_batch = denoise_ctx.video_coords.shape[0]
+        if model_batch % mask_batch != 0:
+            raise ValueError(
+                "I2V conditioning-mask batch must divide the Transformer input batch, "
+                f"but got {mask_batch} and {model_batch}."
+            )
+        repeats = model_batch // mask_batch
+        denoise_ctx.conditioning_mask_for_model = (
+            denoise_ctx.conditioning_mask if repeats == 1 else torch.cat([denoise_ctx.conditioning_mask] * repeats)
+        )
+        return denoise_ctx
+
+    def _denoise_timestep_kwargs(
+        self,
+        ts: torch.Tensor,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+        *,
+        video_token_count: int,
+        audio_token_count: int,
+    ) -> dict[str, torch.Tensor]:
+        if denoise_ctx.conditioning_mask is None:
+            if self.unified_text_image_entry:
+                return super()._denoise_timestep_kwargs(
+                    ts,
+                    forward_ctx,
+                    denoise_ctx,
+                    video_token_count=video_token_count,
+                    audio_token_count=audio_token_count,
+                )
+            raise ValueError("LTX I2V denoising requires a conditioning mask.")
+        kwargs = super()._denoise_timestep_kwargs(
+            ts,
+            forward_ctx,
+            denoise_ctx,
+            video_token_count=video_token_count,
+            audio_token_count=audio_token_count,
+        )
+        conditioning_mask = denoise_ctx.conditioning_mask_for_model
+        if conditioning_mask is None:
+            raise ValueError("LTX I2V denoising requires a conditioning mask.")
+        kwargs.update(
+            timestep=ts.reshape(-1, 1) * (1 - conditioning_mask),
+        )
+        return kwargs
+
+    def _video_guidance_model_sigma(
+        self,
+        sigma: torch.Tensor,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> torch.Tensor:
+        if denoise_ctx.conditioning_mask is None:
+            if self.unified_text_image_entry:
+                return super()._video_guidance_model_sigma(sigma, denoise_ctx)
+            raise ValueError("LTX I2V guidance requires a conditioning mask.")
+        # The conditioned tokens are evaluated at timestep zero by the model,
+        # so velocity-to-x0 guidance must use that same per-token sigma.
+        return sigma.reshape(-1, 1, 1) * (1 - denoise_ctx.conditioning_mask).unsqueeze(-1)
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_denoise.py b/vllm_omni/diffusion/models/ltx2/ltx2_denoise.py
new file mode 100644
index 000000000..4a149be85
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_denoise.py
@@ -0,0 +1,481 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Shared denoise execution primitives for LTX pipelines."""
+
+from __future__ import annotations
+
+import copy
+import math
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Protocol
+
+import torch
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import retrieve_timesteps
+
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+
+from .ltx2_guidance import euler_step_from_velocity
+from .ltx2_latents import LTXAVState, unpack_audio_latents, unpad_audio_latents
+
+if TYPE_CHECKING:
+    from .ltx2_conditioning import LTXPromptContext
+    from .ltx2_recipes import LTXPhaseRecipe
+    from .ltx2_request import LTXRequestInputs
+
+
+@dataclass
+class LTXForwardContext:
+    """Immutable metadata and schedulers for one LTX denoise phase."""
+
+    req: DiffusionRequestBatch
+    request_inputs: LTXRequestInputs
+    prompt_context: LTXPromptContext
+    device: torch.device
+    guidance_parallel_ready: bool
+    attention_kwargs: dict[str, Any] | None
+    latent_num_frames: int
+    latent_height: int
+    latent_width: int
+    latent_mel_bins: int
+    original_audio_num_frames: int
+    padded_audio_num_frames: int
+    timesteps: torch.Tensor
+    audio_scheduler: Any
+    video_audio_step_adapter: Any
+
+    @property
+    def batch_size(self) -> int:
+        return self.prompt_context.batch_size
+
+    @property
+    def num_videos_per_prompt(self) -> int:
+        return self.request_inputs.num_videos_per_prompt
+
+
+@dataclass
+class LTXDenoiseContext:
+    """Mutable AV state and positional metadata for a denoise phase."""
+
+    latents: torch.Tensor
+    audio_latents: torch.Tensor
+    video_coords: torch.Tensor
+    audio_coords: torch.Tensor
+    conditioning_mask: torch.Tensor | None = None
+    conditioning_mask_for_model: torch.Tensor | None = None
+
+
+@dataclass
+class LTXPhaseResult:
+    """Denoised, unpacked AV latents and the context used to produce them."""
+
+    forward_context: LTXForwardContext
+    video: torch.Tensor
+    audio: torch.Tensor
+    audio_for_next_phase: torch.Tensor | None = None
+
+
+class LTXDenoisePipeline(Protocol):
+    """Pipeline state required by :class:`LTXDenoiseExecutor`."""
+
+    @property
+    def interrupt(self) -> bool: ...
+
+    def progress_bar(self, iterable=None, total=None): ...
+
+
+LTXDenoiseStep = Callable[[int, torch.Tensor, LTXAVState], LTXAVState]
+
+
+class LTXDenoiseExecutor:
+    """Run the one shared LTX denoise loop.
+
+    Prediction and scheduler math remain injectable so structural refactors do
+    not change the existing LTX2/LTX2.3 numerical paths. Guidance will replace
+    that step policy independently.
+    """
+
+    @staticmethod
+    def run(
+        pipeline: LTXDenoisePipeline,
+        state: LTXAVState,
+        timesteps: Iterable[torch.Tensor],
+        step: LTXDenoiseStep,
+    ) -> LTXAVState:
+        timesteps = tuple(timesteps)
+        with pipeline.progress_bar(total=len(timesteps)) as progress_bar:
+            for index, timestep in enumerate(timesteps):
+                if pipeline.interrupt:
+                    continue
+                state = step(index, timestep, state)
+                progress_bar.update()
+        return state
+
+
+def calculate_shift(
+    image_seq_len: int,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+) -> float:
+    slope = (max_shift - base_shift) / (max_seq_len - base_seq_len)
+    intercept = base_shift - slope * base_seq_len
+    return image_seq_len * slope + intercept
+
+
+class LTXVideoAudioStepAdapter:
+    """Expose the shared LTX Euler update through the distributed scheduler API."""
+
+    def __init__(
+        self,
+        pipeline: Any,
+        audio_scheduler: Any,
+        latent_num_frames: int,
+        latent_height: int,
+        latent_width: int,
+        *,
+        image_conditioned: bool,
+    ) -> None:
+        self._pipeline = pipeline
+        self._audio_scheduler = audio_scheduler
+        self._latent_num_frames = latent_num_frames
+        self._latent_height = latent_height
+        self._latent_width = latent_width
+        self._image_conditioned = image_conditioned
+        self._step_index = 0
+
+    def step(self, noise_pred, t, latents, return_dict=False, generator=None):
+        del t, return_dict, generator
+        if self._image_conditioned:
+            video_out = self._pipeline._step_video_latents_i2v(
+                noise_pred[0],
+                latents[0],
+                self._step_index,
+                self._latent_num_frames,
+                self._latent_height,
+                self._latent_width,
+            )
+        else:
+            video_out = euler_step_from_velocity(
+                latents[0],
+                noise_pred[0],
+                self._pipeline.scheduler.sigmas,
+                self._step_index,
+            )
+        audio_out = euler_step_from_velocity(
+            latents[1],
+            noise_pred[1],
+            self._audio_scheduler.sigmas,
+            self._step_index,
+        )
+        self._step_index += 1
+        return ((video_out, audio_out),)
+
+
+def _official_ltx_sigmas(scheduler: Any, steps: int, device: torch.device) -> torch.Tensor:
+    """Build the official LTX one-stage sigma schedule in torch fp32."""
+    config = scheduler.config
+    base_anchor = config.get("base_image_seq_len", 1024)
+    max_anchor = config.get("max_image_seq_len", 4096)
+    base_shift = config.get("base_shift", 0.95)
+    max_shift = config.get("max_shift", 2.05)
+
+    sigmas = torch.linspace(1.0, 0.0, steps + 1)
+    slope = (max_shift - base_shift) / (max_anchor - base_anchor)
+    # Official LTX2 one-stage intentionally uses the max sequence anchor, so the shift stays at max_shift.
+    sigma_shift = max_anchor * slope + (base_shift - slope * base_anchor)
+    exp_shift = math.exp(sigma_shift)
+    sigmas = torch.where(sigmas != 0, exp_shift / (exp_shift + (1 / sigmas - 1)), 0)
+
+    # Official non-distilled checkpoints explicitly set this to 0.1. Missing
+    # or None means the loaded scheduler disabled terminal stretching.
+    terminal = config.get("shift_terminal")
+    if terminal is not None:
+        non_zero = sigmas != 0
+        one_minus_sigmas = 1.0 - sigmas[non_zero]
+        scale = one_minus_sigmas[-1] / (1.0 - terminal)
+        sigmas[non_zero] = 1.0 - one_minus_sigmas / scale
+    return sigmas.to(dtype=torch.float32, device=device)
+
+
+def _set_scheduler_sigmas(scheduler: Any, sigmas: torch.Tensor) -> torch.Tensor:
+    sigmas = sigmas.to(torch.float32)
+    timesteps = sigmas[:-1] * scheduler.config.get("num_train_timesteps", 1000)
+    scheduler.sigmas = sigmas
+    scheduler.timesteps = timesteps
+    scheduler.num_inference_steps = len(timesteps)
+    scheduler._step_index = None
+    scheduler._begin_index = None
+    return timesteps
+
+
+def prepare_scheduler_stage(
+    pipeline: Any,
+    request_inputs: LTXRequestInputs,
+    *,
+    device: torch.device,
+    sigmas: list[float] | None,
+    timesteps: list[int] | None,
+    latent_num_frames: int,
+    latent_height: int,
+    latent_width: int,
+    use_official_sigma_schedule: bool,
+    image_conditioned: bool = False,
+) -> tuple[Any, Any, torch.Tensor]:
+    if sigmas is not None and timesteps is not None:
+        raise ValueError("Only one of `sigmas` or `timesteps` may be provided.")
+
+    audio_scheduler = copy.deepcopy(pipeline.scheduler)
+    video_audio_step_adapter = LTXVideoAudioStepAdapter(
+        pipeline,
+        audio_scheduler,
+        latent_num_frames,
+        latent_height,
+        latent_width,
+        image_conditioned=image_conditioned,
+    )
+    if sigmas is not None:
+        scheduler_sigmas = torch.as_tensor(sigmas, dtype=torch.float32, device=device)
+        if scheduler_sigmas.ndim != 1 or scheduler_sigmas.numel() < 2:
+            raise ValueError("An LTX custom sigma schedule must contain at least two boundary values.")
+        if scheduler_sigmas[-1] != 0:
+            scheduler_sigmas = torch.cat([scheduler_sigmas, scheduler_sigmas.new_zeros(1)])
+        timesteps_tensor = _set_scheduler_sigmas(pipeline.scheduler, scheduler_sigmas)
+        _set_scheduler_sigmas(audio_scheduler, scheduler_sigmas.clone())
+        return audio_scheduler, video_audio_step_adapter, timesteps_tensor
+
+    if sigmas is None and timesteps is None and use_official_sigma_schedule:
+        scheduler_sigmas = _official_ltx_sigmas(pipeline.scheduler, request_inputs.num_inference_steps, device)
+        timesteps_tensor = _set_scheduler_sigmas(pipeline.scheduler, scheduler_sigmas)
+        _set_scheduler_sigmas(audio_scheduler, scheduler_sigmas.clone())
+        return audio_scheduler, video_audio_step_adapter, timesteps_tensor
+
+    mu = calculate_shift(
+        pipeline.scheduler.config.get("max_image_seq_len", 4096),
+        pipeline.scheduler.config.get("base_image_seq_len", 1024),
+        pipeline.scheduler.config.get("max_image_seq_len", 4096),
+        pipeline.scheduler.config.get("base_shift", 0.95),
+        pipeline.scheduler.config.get("max_shift", 2.05),
+    )
+    retrieve_timesteps(
+        audio_scheduler,
+        request_inputs.num_inference_steps,
+        device,
+        timesteps,
+        sigmas=sigmas,
+        mu=mu,
+    )
+    timesteps_tensor, _ = retrieve_timesteps(
+        pipeline.scheduler,
+        request_inputs.num_inference_steps,
+        device,
+        timesteps,
+        sigmas=sigmas,
+        mu=mu,
+    )
+    return audio_scheduler, video_audio_step_adapter, timesteps_tensor
+
+
+def prepare_rope_coords_stage(
+    pipeline: Any,
+    forward_ctx: LTXForwardContext,
+    latents: torch.Tensor,
+    audio_latents: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    video_coords = pipeline.transformer.rope.prepare_video_coords(
+        latents.shape[0],
+        forward_ctx.latent_num_frames,
+        forward_ctx.latent_height,
+        forward_ctx.latent_width,
+        latents.device,
+        fps=forward_ctx.request_inputs.frame_rate,
+    )
+    audio_coords = pipeline.transformer.audio_rope.prepare_audio_coords(
+        audio_latents.shape[0],
+        forward_ctx.padded_audio_num_frames,
+        audio_latents.device,
+    )
+    return video_coords, audio_coords
+
+
+def build_transformer_kwargs(
+    pipeline: Any,
+    forward_ctx: LTXForwardContext,
+    denoise_ctx: LTXDenoiseContext,
+    *,
+    hidden_states: torch.Tensor,
+    audio_hidden_states: torch.Tensor,
+    encoder_hidden_states: torch.Tensor,
+    audio_encoder_hidden_states: torch.Tensor,
+    encoder_attention_mask: torch.Tensor | None,
+    audio_encoder_attention_mask: torch.Tensor | None,
+    ts: torch.Tensor,
+    attention_kwargs: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    del encoder_attention_mask, audio_encoder_attention_mask
+    return {
+        "hidden_states": hidden_states,
+        "audio_hidden_states": audio_hidden_states,
+        "encoder_hidden_states": encoder_hidden_states,
+        "audio_encoder_hidden_states": audio_encoder_hidden_states,
+        **pipeline._denoise_timestep_kwargs(
+            ts,
+            forward_ctx,
+            denoise_ctx,
+            video_token_count=hidden_states.shape[1],
+            audio_token_count=audio_hidden_states.shape[1],
+        ),
+        # This is valid only because LTX connectors replace every padding token
+        # with a learned register, making all output context tokens valid.
+        "encoder_attention_mask": None,
+        "audio_encoder_attention_mask": None,
+        "num_frames": forward_ctx.latent_num_frames,
+        "height": forward_ctx.latent_height,
+        "width": forward_ctx.latent_width,
+        "fps": forward_ctx.request_inputs.frame_rate,
+        "audio_num_frames": forward_ctx.padded_audio_num_frames,
+        "video_coords": denoise_ctx.video_coords,
+        "audio_coords": denoise_ctx.audio_coords,
+        "attention_kwargs": forward_ctx.attention_kwargs if attention_kwargs is None else attention_kwargs,
+        "return_dict": False,
+    }
+
+
+def step_denoised_latents(
+    pipeline: Any,
+    forward_ctx: LTXForwardContext,
+    denoise_ctx: LTXDenoiseContext,
+    noise_pred_video: torch.Tensor,
+    noise_pred_audio: torch.Tensor,
+    timestep: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    latents = pipeline.scheduler_step_maybe_with_cfg(
+        (noise_pred_video, noise_pred_audio),
+        (timestep, timestep),
+        (denoise_ctx.latents, denoise_ctx.audio_latents),
+        do_true_cfg=pipeline.do_classifier_free_guidance,
+        per_request_scheduler=forward_ctx.video_audio_step_adapter,
+    )
+    return pipeline._synchronize_guidance_parallel_step_output(
+        latents,
+        guidance_parallel_ready=forward_ctx.guidance_parallel_ready,
+    )
+
+
+class LTXPhaseExecutor:
+    """Prepare and execute one LTX phase without owning model modules."""
+
+    @staticmethod
+    def run(
+        pipeline: Any,
+        req: DiffusionRequestBatch,
+        request_inputs: LTXRequestInputs,
+        *,
+        noise_scale: float,
+        sigmas: list[float] | None,
+        timesteps: list[int] | None,
+        attention_kwargs: dict[str, Any] | None,
+        phase_recipe: LTXPhaseRecipe,
+        image: Any | None = None,
+        prompt_context: LTXPromptContext | None = None,
+    ) -> LTXPhaseResult:
+        pipeline._check_forward_inputs(request_inputs, image=image)
+        guidance_parallel_ready = pipeline._setup_forward_runtime(req, request_inputs, attention_kwargs)
+        device = pipeline.device
+        if prompt_context is None:
+            prompt_context = pipeline._prepare_prompt_context(
+                prompt=request_inputs.prompt,
+                negative_prompt=request_inputs.negative_prompt,
+                prompt_embeds=request_inputs.prompt_embeds,
+                negative_prompt_embeds=request_inputs.negative_prompt_embeds,
+                prompt_attention_mask=request_inputs.prompt_attention_mask,
+                negative_prompt_attention_mask=request_inputs.negative_prompt_attention_mask,
+                num_videos_per_prompt=request_inputs.num_videos_per_prompt,
+                max_sequence_length=request_inputs.max_sequence_length,
+            )
+
+        latent_num_frames, latent_height, latent_width = pipeline._resolve_video_latent_dimensions(request_inputs)
+        latents, conditioning_mask = pipeline._prepare_video_latents_stage(
+            request_inputs,
+            prompt_context,
+            device=device,
+            noise_scale=noise_scale,
+            image=image,
+        )
+        audio_latents, original_audio_num_frames, padded_audio_num_frames, latent_mel_bins = (
+            pipeline._prepare_audio_latents_stage(
+                request_inputs,
+                prompt_context,
+                device=device,
+                noise_scale=noise_scale,
+            )
+        )
+        audio_scheduler, video_audio_step_adapter, timesteps_tensor = prepare_scheduler_stage(
+            pipeline,
+            request_inputs,
+            device=device,
+            sigmas=sigmas,
+            timesteps=timesteps,
+            latent_num_frames=latent_num_frames,
+            latent_height=latent_height,
+            latent_width=latent_width,
+            use_official_sigma_schedule=phase_recipe.use_official_sigma_schedule,
+            image_conditioned=conditioning_mask is not None,
+        )
+        forward_ctx = LTXForwardContext(
+            req=req,
+            request_inputs=request_inputs,
+            prompt_context=prompt_context,
+            device=device,
+            guidance_parallel_ready=guidance_parallel_ready,
+            attention_kwargs=attention_kwargs,
+            latent_num_frames=latent_num_frames,
+            latent_height=latent_height,
+            latent_width=latent_width,
+            latent_mel_bins=latent_mel_bins,
+            original_audio_num_frames=original_audio_num_frames,
+            padded_audio_num_frames=padded_audio_num_frames,
+            timesteps=timesteps_tensor,
+            audio_scheduler=audio_scheduler,
+            video_audio_step_adapter=video_audio_step_adapter,
+        )
+        video_coords, audio_coords = prepare_rope_coords_stage(pipeline, forward_ctx, latents, audio_latents)
+        denoise_ctx = LTXDenoiseContext(
+            latents=latents,
+            audio_latents=audio_latents,
+            video_coords=video_coords,
+            audio_coords=audio_coords,
+            conditioning_mask=conditioning_mask,
+        )
+        denoise_ctx = pipeline._prepare_denoise_context_for_guidance(forward_ctx, denoise_ctx)
+        state = LTXDenoiseExecutor.run(
+            pipeline,
+            LTXAVState(video=denoise_ctx.latents, audio=denoise_ctx.audio_latents),
+            forward_ctx.timesteps,
+            lambda index, timestep, state: pipeline._denoise_step(
+                index,
+                timestep,
+                state,
+                forward_ctx,
+                denoise_ctx,
+            ),
+        )
+        denoise_ctx.latents = state.video
+        denoise_ctx.audio_latents = state.audio
+        latents, audio_latents = pipeline._unpack_and_denormalize_stage(
+            forward_ctx,
+            state.video,
+            state.audio,
+        )
+        normalized_audio = unpack_audio_latents(
+            unpad_audio_latents(state.audio, forward_ctx.original_audio_num_frames),
+            num_mel_bins=forward_ctx.latent_mel_bins,
+        )
+        return LTXPhaseResult(
+            forward_context=forward_ctx,
+            video=latents,
+            audio=audio_latents,
+            audio_for_next_phase=normalized_audio,
+        )
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_guidance.py b/vllm_omni/diffusion/models/ltx2/ltx2_guidance.py
new file mode 100644
index 000000000..f35f5b998
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_guidance.py
@@ -0,0 +1,519 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Official multi-modal guidance for the LTX model family."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_cfg_group as get_guidance_parallel_group,
+)
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_classifier_free_guidance_rank as get_guidance_parallel_rank,
+)
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_classifier_free_guidance_world_size as get_guidance_parallel_world_size,
+)
+
+logger = init_logger(__name__)
+
+if TYPE_CHECKING:
+    from .ltx2_denoise import LTXDenoiseContext, LTXForwardContext
+    from .ltx2_latents import LTXAVState
+
+
+@dataclass(frozen=True)
+class LTXModalityGuidance:
+    """Guidance parameters applied to one LTX output modality."""
+
+    cfg_scale: float = 1.0
+    stg_scale: float = 0.0
+    modality_scale: float = 1.0
+    rescale_scale: float = 0.0
+    stg_blocks: tuple[int, ...] = ()
+
+    @property
+    def do_cfg(self) -> bool:
+        return not math.isclose(self.cfg_scale, 1.0)
+
+    @property
+    def do_stg(self) -> bool:
+        return not math.isclose(self.stg_scale, 0.0) and bool(self.stg_blocks)
+
+    @property
+    def do_modality_guidance(self) -> bool:
+        return not math.isclose(self.modality_scale, 1.0)
+
+
+@dataclass(frozen=True)
+class LTXGuidanceSpec:
+    """Video and audio guidance requested for one denoise phase."""
+
+    video: LTXModalityGuidance = LTXModalityGuidance()
+    audio: LTXModalityGuidance = LTXModalityGuidance()
+
+    @classmethod
+    def positive_only(cls) -> LTXGuidanceSpec:
+        return cls()
+
+    @property
+    def do_cfg(self) -> bool:
+        return self.video.do_cfg or self.audio.do_cfg
+
+    @property
+    def do_stg(self) -> bool:
+        return self.video.do_stg or self.audio.do_stg
+
+    @property
+    def do_modality_guidance(self) -> bool:
+        return self.video.do_modality_guidance or self.audio.do_modality_guidance
+
+    @property
+    def do_rescale(self) -> bool:
+        return self.video.rescale_scale != 0.0 or self.audio.rescale_scale != 0.0
+
+
+@dataclass(frozen=True)
+class LTXDenoisePass:
+    """One conditioned Transformer evaluation in a guidance batch."""
+
+    name: str
+    negative_video_context: bool = False
+    negative_audio_context: bool = False
+
+
+@dataclass(frozen=True)
+class LTXGuidancePlan:
+    """Concrete Transformer passes derived from a guidance specification."""
+
+    spec: LTXGuidanceSpec
+    passes: tuple[LTXDenoisePass, ...]
+
+    @classmethod
+    def build(cls, spec: LTXGuidanceSpec) -> LTXGuidancePlan:
+        passes = [LTXDenoisePass("cond")]
+        if spec.do_cfg:
+            passes.append(
+                LTXDenoisePass(
+                    "uncond",
+                    negative_video_context=spec.video.do_cfg,
+                    negative_audio_context=spec.audio.do_cfg,
+                )
+            )
+        if spec.do_stg:
+            passes.append(LTXDenoisePass("ptb"))
+        if spec.do_modality_guidance:
+            passes.append(LTXDenoisePass("mod"))
+        return cls(spec=spec, passes=tuple(passes))
+
+    @property
+    def names(self) -> tuple[str, ...]:
+        return tuple(item.name for item in self.passes)
+
+
+def x0_from_velocity(sample: torch.Tensor, velocity: torch.Tensor, sigma: torch.Tensor) -> torch.Tensor:
+    """Convert velocity to x0 using the official fp32 arithmetic order."""
+    sigma = sigma.to(torch.float32)
+    return (sample.to(torch.float32) - velocity.to(torch.float32) * sigma).to(sample.dtype)
+
+
+def velocity_from_x0(sample: torch.Tensor, x0: torch.Tensor, sigma: torch.Tensor) -> torch.Tensor:
+    """Convert x0 back to velocity using the official fp32 arithmetic order."""
+    sigma = sigma.to(torch.float32)
+    return ((sample.to(torch.float32) - x0.to(torch.float32)) / sigma).to(sample.dtype)
+
+
+def euler_step_from_velocity(
+    sample: torch.Tensor,
+    velocity: torch.Tensor,
+    sigmas: torch.Tensor,
+    step_index: int,
+) -> torch.Tensor:
+    sigma = sigmas[step_index].to(torch.float32)
+    sigma_next = sigmas[step_index + 1].to(torch.float32)
+    return (sample.float() + velocity.float() * (sigma_next - sigma)).to(sample.dtype)
+
+
+def combine_guided_x0(
+    *,
+    cond: torch.Tensor,
+    uncond_text: torch.Tensor | float,
+    uncond_perturbed: torch.Tensor | float,
+    uncond_modality: torch.Tensor | float,
+    guidance: LTXModalityGuidance,
+) -> torch.Tensor:
+    dtype = cond.dtype
+    cond = cond.float()
+    uncond_text = uncond_text.float() if isinstance(uncond_text, torch.Tensor) else uncond_text
+    uncond_perturbed = uncond_perturbed.float() if isinstance(uncond_perturbed, torch.Tensor) else uncond_perturbed
+    uncond_modality = uncond_modality.float() if isinstance(uncond_modality, torch.Tensor) else uncond_modality
+    pred = cond + (guidance.cfg_scale - 1) * (cond - uncond_text)
+    if guidance.do_stg:
+        pred = pred + guidance.stg_scale * (cond - uncond_perturbed)
+    pred = pred + (guidance.modality_scale - 1) * (cond - uncond_modality)
+    if guidance.rescale_scale != 0.0:
+        # The pinned official one-stage entry runs one generated sample and
+        # uses its full-tensor standard deviation. In Omni, dimension 0 may
+        # instead contain independently scheduled requests. Reduce each item
+        # separately so its result cannot depend on unrelated co-batched work.
+        reduce_dims = tuple(range(1, pred.ndim))
+        cond_std = cond.std(dim=reduce_dims, keepdim=True)
+        pred_std = pred.std(dim=reduce_dims, keepdim=True)
+        eps = torch.finfo(pred.dtype).eps
+        factor = cond_std / pred_std.clamp_min(eps)
+        factor = torch.where(pred_std > eps, factor, torch.ones_like(factor))
+        factor = guidance.rescale_scale * factor + (1 - guidance.rescale_scale)
+        pred = pred * factor
+    return pred.to(dtype)
+
+
+def _repeat_batch(tensor: torch.Tensor, repeats: int) -> torch.Tensor:
+    return tensor.repeat((repeats,) + (1,) * (tensor.ndim - 1))
+
+
+def _mask_for_pass(
+    pass_count: int,
+    batch_size: int,
+    pass_index: int,
+    reference: torch.Tensor,
+) -> torch.Tensor:
+    mask = reference.new_ones((pass_count * batch_size, 1, 1))
+    start = pass_index * batch_size
+    mask[start : start + batch_size] = 0
+    return mask
+
+
+def build_perturbation_kwargs(
+    plan: LTXGuidancePlan,
+    batch_size: int,
+    reference: torch.Tensor,
+) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {}
+    if "ptb" in plan.names:
+        mask = _mask_for_pass(len(plan.passes), batch_size, plan.names.index("ptb"), reference)
+        if plan.spec.video.do_stg:
+            kwargs["video_self_attention_mask"] = mask
+            kwargs["video_self_attention_blocks"] = plan.spec.video.stg_blocks
+        if plan.spec.audio.do_stg:
+            kwargs["audio_self_attention_mask"] = mask
+            kwargs["audio_self_attention_blocks"] = plan.spec.audio.stg_blocks
+    if "mod" in plan.names:
+        mask = _mask_for_pass(len(plan.passes), batch_size, plan.names.index("mod"), reference)
+        kwargs["a2v_cross_attention_mask"] = mask
+        kwargs["v2a_cross_attention_mask"] = mask
+    return kwargs
+
+
+class LTXGuidanceExecutor:
+    """Build and execute official LTX multi-guidance Transformer passes."""
+
+    @staticmethod
+    def validate_guidance_world_size(plan: LTXGuidancePlan, guidance_world_size: int) -> None:
+        del plan
+        if guidance_world_size < 1:
+            raise ValueError(f"LTX guidance parallelism requires a positive parallel size, got {guidance_world_size}.")
+
+    @staticmethod
+    def _parallel_assignments(pass_count: int, world_size: int) -> list[list[int]]:
+        assignments: list[list[int]] = [[] for _ in range(world_size)]
+        for pass_index in range(pass_count):
+            assignments[pass_index % world_size].append(pass_index)
+        return assignments
+
+    @classmethod
+    def _model_pass_count(
+        cls,
+        plan: LTXGuidancePlan,
+        guidance_parallel_ready: bool,
+        guidance_world_size: int,
+    ) -> int:
+        if not guidance_parallel_ready:
+            return len(plan.passes)
+        assignments = cls._parallel_assignments(len(plan.passes), guidance_world_size)
+        return max(len(indices) for indices in assignments)
+
+    @classmethod
+    def warn_if_imbalanced(
+        cls,
+        plan: LTXGuidancePlan,
+        guidance_world_size: int,
+        phase_name: str,
+    ) -> None:
+        pass_count = len(plan.passes)
+        if guidance_world_size <= 1 or pass_count % guidance_world_size == 0 or get_guidance_parallel_rank() != 0:
+            return
+        slots_per_rank = math.ceil(pass_count / guidance_world_size)
+        total_slots = slots_per_rank * guidance_world_size
+        wasted_slots = total_slots - pass_count
+        utilization = 100.0 * pass_count / total_slots
+        logger.warning_once(
+            "LTX guidance parallelism is imbalanced for phase %r: %d guidance passes across %d ranks. "
+            "%d padded/discarded rank slot(s); expected guidance-slot utilization is %.1f%%.",
+            phase_name,
+            pass_count,
+            guidance_world_size,
+            wasted_slots,
+            utilization,
+        )
+
+    @staticmethod
+    def prepare_denoise_context(
+        plan: LTXGuidancePlan,
+        guidance_parallel_ready: bool,
+        guidance_world_size: int,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> LTXDenoiseContext:
+        model_pass_count = LTXGuidanceExecutor._model_pass_count(
+            plan,
+            guidance_parallel_ready,
+            guidance_world_size,
+        )
+        if model_pass_count > 1:
+            denoise_ctx.video_coords = _repeat_batch(denoise_ctx.video_coords, model_pass_count)
+            denoise_ctx.audio_coords = _repeat_batch(denoise_ctx.audio_coords, model_pass_count)
+        return denoise_ctx
+
+    @staticmethod
+    def timestep_kwargs(
+        ts: torch.Tensor,
+        video_token_count: int,
+        audio_token_count: int,
+    ) -> dict[str, torch.Tensor]:
+        return {
+            "timestep": ts.reshape(-1, 1).expand(-1, video_token_count),
+            "audio_timestep": ts.reshape(-1, 1).expand(-1, audio_token_count),
+            "sigma": ts,
+            "audio_sigma": ts,
+        }
+
+    @staticmethod
+    def combine_cfg_velocity(
+        sample: torch.Tensor,
+        positive_velocity: torch.Tensor,
+        negative_velocity: torch.Tensor,
+        sigma: torch.Tensor,
+        guidance_scale: float,
+        *,
+        model_sigma: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        guidance = LTXModalityGuidance(cfg_scale=guidance_scale)
+        model_sigma = sigma if model_sigma is None else model_sigma
+        guided_x0 = combine_guided_x0(
+            cond=x0_from_velocity(sample, positive_velocity, model_sigma),
+            uncond_text=x0_from_velocity(sample, negative_velocity, model_sigma),
+            uncond_perturbed=0.0,
+            uncond_modality=0.0,
+            guidance=guidance,
+        )
+        return velocity_from_x0(sample, guided_x0, sigma)
+
+    @staticmethod
+    def _guide_modality(
+        sample: torch.Tensor,
+        splits: dict[str, torch.Tensor],
+        sigma: torch.Tensor,
+        guidance: LTXModalityGuidance,
+        *,
+        model_sigma: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        model_sigma = sigma if model_sigma is None else model_sigma
+        # Official guidance reduces contiguous BSC tensors. The fused
+        # transformer output may be channel-major after splitting, which
+        # changes fp32 reduction order and can cross bf16 rounding bounds.
+        x0 = {name: x0_from_velocity(sample, value, model_sigma).contiguous() for name, value in splits.items()}
+        guided = combine_guided_x0(
+            cond=x0["cond"],
+            uncond_text=x0.get("uncond", 0.0),
+            uncond_perturbed=x0.get("ptb", 0.0),
+            uncond_modality=x0.get("mod", 0.0),
+            guidance=guidance,
+        )
+        return velocity_from_x0(sample, guided, sigma)
+
+    def predict_parallel_guidance(
+        self,
+        pipeline: Any,
+        plan: LTXGuidancePlan,
+        index: int,
+        timestep: torch.Tensor,
+        state: LTXAVState,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        guidance_world_size = get_guidance_parallel_world_size()
+        self.validate_guidance_world_size(plan, guidance_world_size)
+        guidance_rank = get_guidance_parallel_rank()
+        assignments = self._parallel_assignments(len(plan.passes), guidance_world_size)
+        local_pass_indices = assignments[guidance_rank]
+        model_pass_count = max(len(indices) for indices in assignments)
+
+        # Every rank executes and gathers the same number of slots. Shorter
+        # assignments use a conditional pass whose output is discarded.
+        padded_pass_indices: list[int | None] = local_pass_indices + [None] * (
+            model_pass_count - len(local_pass_indices)
+        )
+        local_passes = tuple(
+            plan.passes[0] if pass_index is None else plan.passes[pass_index] for pass_index in padded_pass_indices
+        )
+        local_plan = LTXGuidancePlan(spec=plan.spec, passes=local_passes)
+
+        prompt = forward_ctx.prompt_context
+        video_contexts: list[torch.Tensor] = []
+        audio_contexts: list[torch.Tensor] = []
+        for denoise_pass in local_passes:
+            video_context = (
+                prompt.negative_connector_prompt_embeds
+                if denoise_pass.negative_video_context
+                else prompt.positive_connector_prompt_embeds
+            )
+            audio_context = (
+                prompt.negative_connector_audio_prompt_embeds
+                if denoise_pass.negative_audio_context
+                else prompt.positive_connector_audio_prompt_embeds
+            )
+            if video_context is None or audio_context is None:
+                raise ValueError("Negative prompt context is required when LTX CFG is enabled.")
+            video_contexts.append(video_context)
+            audio_contexts.append(audio_context)
+
+        video_input = _repeat_batch(state.video, model_pass_count).to(prompt.positive_connector_prompt_embeds.dtype)
+        audio_input = _repeat_batch(state.audio, model_pass_count).to(
+            prompt.positive_connector_audio_prompt_embeds.dtype
+        )
+        attention_kwargs = dict(forward_ctx.attention_kwargs or {})
+        perturbations = build_perturbation_kwargs(local_plan, state.video.shape[0], video_input)
+        if perturbations:
+            attention_kwargs["ltx_perturbation_kwargs"] = perturbations
+        kwargs = pipeline._build_transformer_kwargs(
+            forward_ctx,
+            denoise_ctx,
+            hidden_states=video_input,
+            audio_hidden_states=audio_input,
+            encoder_hidden_states=torch.cat(video_contexts),
+            audio_encoder_hidden_states=torch.cat(audio_contexts),
+            encoder_attention_mask=None,
+            audio_encoder_attention_mask=None,
+            ts=timestep.expand(video_input.shape[0]),
+            attention_kwargs=attention_kwargs,
+        )
+        with pipeline._transformer_cache_context("guided"):
+            local_video, local_audio = pipeline.transformer(**kwargs)
+        local_video_slots = local_video.chunk(model_pass_count)
+        local_audio_slots = local_audio.chunk(model_pass_count)
+
+        group = get_guidance_parallel_group()
+        gathered_video_slots = [group.all_gather(value, separate_tensors=True) for value in local_video_slots]
+        gathered_audio_slots = [group.all_gather(value, separate_tensors=True) for value in local_audio_slots]
+
+        video_splits: dict[str, torch.Tensor] = {}
+        audio_splits: dict[str, torch.Tensor] = {}
+        for pass_index, denoise_pass in enumerate(plan.passes):
+            owner_rank = pass_index % guidance_world_size
+            slot_index = pass_index // guidance_world_size
+            video_splits[denoise_pass.name] = gathered_video_slots[slot_index][owner_rank]
+            audio_splits[denoise_pass.name] = gathered_audio_slots[slot_index][owner_rank]
+
+        video_sigma = pipeline.scheduler.sigmas[index]
+        return (
+            self._guide_modality(
+                state.video,
+                video_splits,
+                video_sigma,
+                plan.spec.video,
+                model_sigma=pipeline._video_guidance_model_sigma(video_sigma, denoise_ctx),
+            ),
+            self._guide_modality(
+                state.audio,
+                audio_splits,
+                forward_ctx.audio_scheduler.sigmas[index],
+                plan.spec.audio,
+            ),
+        )
+
+    def predict_noise(
+        self,
+        pipeline: Any,
+        plan: LTXGuidancePlan,
+        index: int,
+        timestep: torch.Tensor,
+        state: LTXAVState,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if forward_ctx.guidance_parallel_ready:
+            return self.predict_parallel_guidance(pipeline, plan, index, timestep, state, forward_ctx, denoise_ctx)
+
+        prompt = forward_ctx.prompt_context
+        video_contexts: list[torch.Tensor] = []
+        audio_contexts: list[torch.Tensor] = []
+        for denoise_pass in plan.passes:
+            video_context = (
+                prompt.negative_connector_prompt_embeds
+                if denoise_pass.negative_video_context
+                else prompt.positive_connector_prompt_embeds
+            )
+            audio_context = (
+                prompt.negative_connector_audio_prompt_embeds
+                if denoise_pass.negative_audio_context
+                else prompt.positive_connector_audio_prompt_embeds
+            )
+            if video_context is None or audio_context is None:
+                raise ValueError("Negative prompt context is required when LTX CFG is enabled.")
+            video_contexts.append(video_context)
+            audio_contexts.append(audio_context)
+
+        pass_count = len(plan.passes)
+        video_input = _repeat_batch(state.video, pass_count).to(prompt.positive_connector_prompt_embeds.dtype)
+        audio_input = _repeat_batch(state.audio, pass_count).to(prompt.positive_connector_audio_prompt_embeds.dtype)
+        attention_kwargs = dict(forward_ctx.attention_kwargs or {})
+        perturbations = build_perturbation_kwargs(plan, state.video.shape[0], video_input)
+        if perturbations:
+            attention_kwargs["ltx_perturbation_kwargs"] = perturbations
+        kwargs = pipeline._build_transformer_kwargs(
+            forward_ctx,
+            denoise_ctx,
+            hidden_states=video_input,
+            audio_hidden_states=audio_input,
+            encoder_hidden_states=torch.cat(video_contexts),
+            audio_encoder_hidden_states=torch.cat(audio_contexts),
+            encoder_attention_mask=None,
+            audio_encoder_attention_mask=None,
+            ts=timestep.expand(video_input.shape[0]),
+            attention_kwargs=attention_kwargs,
+        )
+        with pipeline._transformer_cache_context("guided"):
+            video_velocity, audio_velocity = pipeline.transformer(**kwargs)
+        video_splits = dict(zip(plan.names, video_velocity.chunk(pass_count), strict=True))
+        audio_splits = dict(zip(plan.names, audio_velocity.chunk(pass_count), strict=True))
+
+        return (
+            self._guide_modality(
+                state.video,
+                video_splits,
+                pipeline.scheduler.sigmas[index],
+                plan.spec.video,
+                model_sigma=pipeline._video_guidance_model_sigma(
+                    pipeline.scheduler.sigmas[index],
+                    denoise_ctx,
+                ),
+            ),
+            self._guide_modality(
+                state.audio,
+                audio_splits,
+                forward_ctx.audio_scheduler.sigmas[index],
+                plan.spec.audio,
+            ),
+        )
+
+
+LTX_GUIDANCE_EXECUTOR = LTXGuidanceExecutor()
+
+# Kept as a narrow compatibility helper for CFG-parallel tests and extensions.
+combine_velocity_via_x0 = LTXGuidanceExecutor.combine_cfg_velocity
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_latents.py b/vllm_omni/diffusion/models/ltx2/ltx2_latents.py
new file mode 100644
index 000000000..bb0155e79
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_latents.py
@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Shared latent layout and normalization primitives for LTX pipelines."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from diffusers.utils.torch_utils import randn_tensor
+
+
+@dataclass
+class LTXAVState:
+    """Packed video and audio latents carried between denoise steps."""
+
+    video: torch.Tensor
+    audio: torch.Tensor
+
+
+def pack_latents(
+    latents: torch.Tensor,
+    patch_size: int = 1,
+    patch_size_t: int = 1,
+) -> torch.Tensor:
+    batch_size, _, num_frames, height, width = latents.shape
+    post_patch_num_frames = num_frames // patch_size_t
+    post_patch_height = height // patch_size
+    post_patch_width = width // patch_size
+    latents = latents.reshape(
+        batch_size,
+        -1,
+        post_patch_num_frames,
+        patch_size_t,
+        post_patch_height,
+        patch_size,
+        post_patch_width,
+        patch_size,
+    )
+    return latents.permute(0, 2, 4, 6, 1, 3, 5, 7).flatten(4, 7).flatten(1, 3)
+
+
+def unpack_latents(
+    latents: torch.Tensor,
+    num_frames: int,
+    height: int,
+    width: int,
+    patch_size: int = 1,
+    patch_size_t: int = 1,
+) -> torch.Tensor:
+    batch_size = latents.size(0)
+    latents = latents.reshape(
+        batch_size,
+        num_frames,
+        height,
+        width,
+        -1,
+        patch_size_t,
+        patch_size,
+        patch_size,
+    )
+    return latents.permute(0, 4, 1, 5, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+
+def normalize_latents(
+    latents: torch.Tensor,
+    latents_mean: torch.Tensor,
+    latents_std: torch.Tensor,
+    scaling_factor: float = 1.0,
+) -> torch.Tensor:
+    latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
+    latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
+    return (latents - latents_mean) * scaling_factor / latents_std
+
+
+def normalize_audio_latents(
+    latents: torch.Tensor,
+    latents_mean: torch.Tensor,
+    latents_std: torch.Tensor,
+) -> torch.Tensor:
+    latents_mean = latents_mean.to(latents.device, latents.dtype)
+    latents_std = latents_std.to(latents.device, latents.dtype)
+    return (latents - latents_mean) / latents_std
+
+
+def denormalize_latents(
+    latents: torch.Tensor,
+    latents_mean: torch.Tensor,
+    latents_std: torch.Tensor,
+    scaling_factor: float = 1.0,
+) -> torch.Tensor:
+    latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
+    latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
+    return latents * latents_std / scaling_factor + latents_mean
+
+
+def denormalize_audio_latents(
+    latents: torch.Tensor,
+    latents_mean: torch.Tensor,
+    latents_std: torch.Tensor,
+) -> torch.Tensor:
+    latents_mean = latents_mean.to(latents.device, latents.dtype)
+    latents_std = latents_std.to(latents.device, latents.dtype)
+    return latents * latents_std + latents_mean
+
+
+def create_noised_state(
+    latents: torch.Tensor,
+    noise_scale: float | torch.Tensor,
+    generator: torch.Generator | list[torch.Generator] | None = None,
+) -> torch.Tensor:
+    noise = randn_tensor(
+        latents.shape,
+        generator=generator,
+        device=latents.device,
+        dtype=latents.dtype,
+    )
+    return noise_scale * noise + (1 - noise_scale) * latents
+
+
+def pack_audio_latents(latents: torch.Tensor) -> torch.Tensor:
+    return latents.transpose(1, 2).flatten(2, 3)
+
+
+def unpack_audio_latents(
+    latents: torch.Tensor,
+    num_mel_bins: int,
+) -> torch.Tensor:
+    return latents.unflatten(2, (-1, num_mel_bins)).transpose(1, 2)
+
+
+def unpad_audio_latents(latents: torch.Tensor, num_frames: int) -> torch.Tensor:
+    return latents[:, :num_frames]
+
+
+def get_sp_padded_audio_latent_length(audio_latent_length: int, sp_size: int) -> int:
+    if sp_size > 1:
+        audio_latent_length += (sp_size - (audio_latent_length % sp_size)) % sp_size
+    return audio_latent_length
+
+
+def resolve_video_latent_shape(
+    height: int,
+    width: int,
+    num_frames: int,
+    *,
+    vae_spatial_compression_ratio: int,
+    vae_temporal_compression_ratio: int,
+) -> tuple[int, int, int]:
+    return (
+        (num_frames - 1) // vae_temporal_compression_ratio + 1,
+        height // vae_spatial_compression_ratio,
+        width // vae_spatial_compression_ratio,
+    )
+
+
+def prepare_video_latents(
+    pipeline: Any,
+    batch_size: int = 1,
+    num_channels_latents: int = 128,
+    height: int = 512,
+    width: int = 768,
+    num_frames: int = 121,
+    noise_scale: float = 0.0,
+    dtype: torch.dtype | None = None,
+    device: torch.device | None = None,
+    generator: torch.Generator | list[torch.Generator] | None = None,
+    latents: torch.Tensor | None = None,
+) -> torch.Tensor:
+    if latents is not None:
+        if latents.ndim == 5:
+            latents = normalize_latents(
+                latents,
+                pipeline.vae.latents_mean,
+                pipeline.vae.latents_std,
+                pipeline.vae.config.scaling_factor,
+            )
+            latents = pack_latents(
+                latents,
+                pipeline.transformer_spatial_patch_size,
+                pipeline.transformer_temporal_patch_size,
+            )
+        if latents.ndim != 3:
+            raise ValueError(f"Provided `latents` has shape {latents.shape}, expected [batch, seq, features].")
+        return create_noised_state(latents, noise_scale, generator).to(device=device, dtype=dtype)
+
+    num_frames, height, width = resolve_video_latent_shape(
+        height,
+        width,
+        num_frames,
+        vae_spatial_compression_ratio=pipeline.vae_spatial_compression_ratio,
+        vae_temporal_compression_ratio=pipeline.vae_temporal_compression_ratio,
+    )
+    spatial_patch_size = pipeline.transformer_spatial_patch_size
+    temporal_patch_size = pipeline.transformer_temporal_patch_size
+    shape = (
+        batch_size,
+        (num_frames // temporal_patch_size) * (height // spatial_patch_size) * (width // spatial_patch_size),
+        num_channels_latents * temporal_patch_size * spatial_patch_size * spatial_patch_size,
+    )
+    if isinstance(generator, list) and len(generator) != batch_size:
+        raise ValueError(
+            f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+            f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+        )
+    return randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+
+
+def prepare_audio_latents(
+    pipeline: Any,
+    batch_size: int = 1,
+    num_channels_latents: int = 8,
+    audio_latent_length: int = 1,
+    num_mel_bins: int = 64,
+    noise_scale: float = 0.0,
+    dtype: torch.dtype | None = None,
+    device: torch.device | None = None,
+    generator: torch.Generator | list[torch.Generator] | None = None,
+    latents: torch.Tensor | None = None,
+    latents_normalized: bool = False,
+) -> tuple[torch.Tensor, int, int]:
+    original_latent_length = audio_latent_length
+    latent_mel_bins = num_mel_bins // pipeline.audio_vae_mel_compression_ratio
+    sp_size = getattr(pipeline.od_config.parallel_config, "sequence_parallel_size", 1) or 1
+    padded_latent_length = get_sp_padded_audio_latent_length(original_latent_length, int(sp_size))
+
+    if latents is not None:
+        if latents.ndim == 4:
+            latents = pack_audio_latents(latents)
+        if latents.ndim != 3:
+            raise ValueError(f"Provided `latents` has shape {latents.shape}, expected [batch, seq, features].")
+        if not latents_normalized:
+            latents = normalize_audio_latents(
+                latents,
+                pipeline.audio_vae.latents_mean,
+                pipeline.audio_vae.latents_std,
+            )
+        latents = create_noised_state(latents, noise_scale, generator)
+
+        if latents.shape[1] not in {original_latent_length, padded_latent_length}:
+            raise ValueError(
+                "Provided `audio_latents` has incompatible audio frame count "
+                f"{latents.shape[1]}; expected {original_latent_length} or {padded_latent_length}."
+            )
+        if latents.shape[1] == original_latent_length and padded_latent_length > original_latent_length:
+            padding = torch.zeros(
+                latents.shape[0],
+                padded_latent_length - original_latent_length,
+                latents.shape[2],
+                dtype=latents.dtype,
+                device=latents.device,
+            )
+            latents = torch.cat([latents, padding], dim=1)
+        return latents.to(device=device, dtype=dtype), original_latent_length, padded_latent_length
+
+    shape = (batch_size, padded_latent_length, num_channels_latents * latent_mel_bins)
+    if isinstance(generator, list) and len(generator) != batch_size:
+        raise ValueError(
+            f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+            f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+        )
+    latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+    return latents, original_latent_length, padded_latent_length
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_recipes.py b/vllm_omni/diffusion/models/ltx2/ltx2_recipes.py
new file mode 100644
index 000000000..a70f349ac
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_recipes.py
@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Declarative execution recipes for the LTX model family."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from .ltx2_guidance import LTXGuidanceSpec, LTXModalityGuidance
+
+LTX_DEFAULT_NEGATIVE_PROMPT = (
+    "blurry, out of focus, overexposed, underexposed, low contrast, washed out colors, excessive noise, "
+    "grainy texture, poor lighting, flickering, motion blur, distorted proportions, unnatural skin tones, "
+    "deformed facial features, asymmetrical face, missing facial features, extra limbs, disfigured hands, "
+    "wrong hand count, artifacts around text, inconsistent perspective, camera shake, incorrect depth of "
+    "field, background too sharp, background clutter, distracting reflections, harsh shadows, inconsistent "
+    "lighting direction, color banding, cartoonish rendering, 3D CGI look, unrealistic materials, uncanny "
+    "valley effect, incorrect ethnicity, wrong gender, exaggerated expressions, wrong gaze direction, "
+    "mismatched lip sync, silent or muted audio, distorted voice, robotic voice, echo, background noise, "
+    "off-sync audio, incorrect dialogue, added dialogue, repetitive speech, jittery movement, awkward "
+    "pauses, incorrect timing, unnatural transitions, inconsistent framing, tilted camera, flat lighting, "
+    "inconsistent tone, cinematic oversaturation, stylized filters, or AI artifacts."
+)
+
+LTX_DISTILLED_SIGMAS = (1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0)
+LTX_STAGE_2_DISTILLED_SIGMAS = (0.909375, 0.725, 0.421875, 0.0)
+
+
+@dataclass(frozen=True)
+class LTXPhaseRecipe:
+    """One denoise phase and the transition used to construct its input."""
+
+    name: str
+    guidance: LTXGuidanceSpec
+    spatial_downscale: int = 1
+    sigmas: tuple[float, ...] | None = None
+    noise_scale: float = 0.0
+    input_transform: Literal["initial", "spatial_upsample"] = "initial"
+    allow_guidance_override: bool = True
+    use_official_sigma_schedule: bool = True
+
+    def __post_init__(self) -> None:
+        if self.spatial_downscale < 1:
+            raise ValueError("LTX phase spatial_downscale must be positive.")
+        if self.sigmas is not None and len(self.sigmas) < 2:
+            raise ValueError("An explicit LTX sigma schedule must contain at least two denoise sigmas.")
+
+    @property
+    def num_inference_steps(self) -> int | None:
+        return None if self.sigmas is None else len(self.sigmas) - 1
+
+
+@dataclass(frozen=True)
+class LTXPipelineRecipe:
+    """Request defaults, ordered phases, output routing, and request capabilities."""
+
+    phases: tuple[LTXPhaseRecipe, ...]
+    height: int = 512
+    width: int = 768
+    num_frames: int = 121
+    frame_rate: float = 24.0
+    num_inference_steps: int = 40
+    negative_prompt: str = LTX_DEFAULT_NEGATIVE_PROMPT
+    video_output_phase: int = -1
+    audio_output_phase: int = -1
+    allow_request_sigmas: bool = True
+    allow_request_latents: bool = True
+    allow_negative_prompt: bool = True
+    fixed_num_inference_steps: bool = False
+
+    def __post_init__(self) -> None:
+        if not self.phases:
+            raise ValueError("An LTX pipeline recipe must contain at least one phase.")
+        if self.phases[0].input_transform != "initial":
+            raise ValueError("The first LTX phase must use the initial request input.")
+        phase_count = len(self.phases)
+        for output_phase in (self.video_output_phase, self.audio_output_phase):
+            if not -phase_count <= output_phase < phase_count:
+                raise ValueError(f"LTX output phase {output_phase} is outside a {phase_count}-phase recipe.")
+
+    @property
+    def request_guidance(self) -> LTXGuidanceSpec:
+        return self.phases[0].guidance
+
+    @property
+    def max_spatial_downscale(self) -> int:
+        return max(phase.spatial_downscale for phase in self.phases)
+
+
+def _official_guidance(stg_block: int) -> LTXGuidanceSpec:
+    return LTXGuidanceSpec(
+        video=LTXModalityGuidance(
+            cfg_scale=3.0,
+            stg_scale=1.0,
+            modality_scale=3.0,
+            rescale_scale=0.7,
+            stg_blocks=(stg_block,),
+        ),
+        audio=LTXModalityGuidance(
+            cfg_scale=7.0,
+            stg_scale=1.0,
+            modality_scale=3.0,
+            rescale_scale=0.7,
+            stg_blocks=(stg_block,),
+        ),
+    )
+
+
+LTX2_ONE_STAGE_RECIPE = LTXPipelineRecipe(
+    phases=(LTXPhaseRecipe(name="generate", guidance=_official_guidance(29)),),
+)
+LTX23_ONE_STAGE_RECIPE = LTXPipelineRecipe(
+    num_inference_steps=30,
+    phases=(LTXPhaseRecipe(name="generate", guidance=_official_guidance(28)),),
+)
+LTX_POSITIVE_ONLY_RECIPE = LTXPipelineRecipe(
+    phases=(
+        LTXPhaseRecipe(
+            name="generate",
+            guidance=LTXGuidanceSpec.positive_only(),
+            use_official_sigma_schedule=False,
+        ),
+    ),
+)
+LTX2_DISTILLED_TWO_STAGE_RECIPE = LTXPipelineRecipe(
+    # Official distilled arguments describe the final output. Stage 1 applies
+    # spatial_downscale=2 and therefore runs at 512x768.
+    height=1024,
+    width=1536,
+    num_inference_steps=len(LTX_DISTILLED_SIGMAS) - 1,
+    negative_prompt="",
+    phases=(
+        LTXPhaseRecipe(
+            name="generate_lowres",
+            guidance=LTXGuidanceSpec.positive_only(),
+            spatial_downscale=2,
+            sigmas=LTX_DISTILLED_SIGMAS,
+            noise_scale=1.0,
+            allow_guidance_override=False,
+            use_official_sigma_schedule=False,
+        ),
+        LTXPhaseRecipe(
+            name="refine",
+            guidance=LTXGuidanceSpec.positive_only(),
+            sigmas=LTX_STAGE_2_DISTILLED_SIGMAS,
+            noise_scale=LTX_STAGE_2_DISTILLED_SIGMAS[0],
+            input_transform="spatial_upsample",
+            allow_guidance_override=False,
+            use_official_sigma_schedule=False,
+        ),
+    ),
+    video_output_phase=1,
+    audio_output_phase=1,
+    allow_request_sigmas=False,
+    allow_request_latents=False,
+    allow_negative_prompt=False,
+    fixed_num_inference_steps=True,
+)
+
+
+_PIPELINE_RECIPES: dict[tuple[str, str], LTXPipelineRecipe] = {
+    ("one_stage", "2"): LTX2_ONE_STAGE_RECIPE,
+    ("one_stage", "2.3"): LTX23_ONE_STAGE_RECIPE,
+    ("distilled_two_stage", "2"): LTX2_DISTILLED_TWO_STAGE_RECIPE,
+    ("dmd2", "2"): LTX_POSITIVE_ONLY_RECIPE,
+    ("dmd2", "2.3"): LTX_POSITIVE_ONLY_RECIPE,
+}
+
+
+def resolve_ltx_pipeline_recipe(pipeline_kind: str, model_version: str) -> LTXPipelineRecipe:
+    """Resolve execution independently from component loading."""
+    try:
+        return _PIPELINE_RECIPES[(pipeline_kind, model_version)]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported LTX pipeline kind/version: {pipeline_kind!r}/{model_version!r}.") from exc
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_request.py b/vllm_omni/diffusion/models/ltx2/ltx2_request.py
new file mode 100644
index 000000000..e2eef19df
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_request.py
@@ -0,0 +1,525 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Request normalization and validation shared by LTX pipeline variants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Any
+
+import torch
+
+from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+
+from .ltx2_guidance import LTXGuidanceSpec, LTXModalityGuidance
+from .ltx2_recipes import LTXPipelineRecipe
+
+
+@dataclass
+class LTXRequestInputs:
+    """Resolved request values shared by all LTX execution variants."""
+
+    prompt: str | list[str] | None
+    negative_prompt: str | list[str] | None
+    height: int
+    width: int
+    num_frames: int
+    frame_rate: float
+    num_inference_steps: int
+    guidance: LTXGuidanceSpec
+    num_videos_per_prompt: int
+    generator: torch.Generator | list[torch.Generator] | None
+    latents: torch.Tensor | None
+    audio_latents: torch.Tensor | None
+    prompt_embeds: torch.Tensor | None
+    negative_prompt_embeds: torch.Tensor | None
+    prompt_attention_mask: torch.Tensor | None
+    negative_prompt_attention_mask: torch.Tensor | None
+    decode_timestep: float | list[float]
+    decode_noise_scale: float | list[float] | None
+    output_type: str
+    max_sequence_length: int
+    audio_latents_normalized: bool = False
+
+    @property
+    def guidance_scale(self) -> float:
+        """Compatibility view for callers that only understand video CFG."""
+        return self.guidance.video.cfg_scale
+
+
+def validate_pipeline_request(
+    request_inputs: LTXRequestInputs,
+    *,
+    pipeline_recipe: LTXPipelineRecipe,
+    vae_spatial_compression_ratio: int,
+    vae_temporal_compression_ratio: int,
+    pipeline_name: str,
+    request_sigmas: list[float] | None = None,
+) -> None:
+    """Validate the request capabilities declared by an execution recipe."""
+    alignment = vae_spatial_compression_ratio * pipeline_recipe.max_spatial_downscale
+    if request_inputs.height % alignment != 0 or request_inputs.width % alignment != 0:
+        raise ValueError(
+            f"{pipeline_name} resolution must be divisible by {alignment}, got "
+            f"{request_inputs.width}x{request_inputs.height}."
+        )
+
+    if request_inputs.num_frames < 1 or (request_inputs.num_frames - 1) % vae_temporal_compression_ratio != 0:
+        raise ValueError(
+            f"{pipeline_name} `num_frames` must be {vae_temporal_compression_ratio} * k + 1, "
+            f"got {request_inputs.num_frames}."
+        )
+
+    if not pipeline_recipe.allow_request_latents and (
+        request_inputs.latents is not None or request_inputs.audio_latents is not None
+    ):
+        raise ValueError(f"{pipeline_name} does not accept request-provided video or audio latents.")
+
+    if not pipeline_recipe.allow_request_sigmas and request_sigmas is not None:
+        raise ValueError(f"{pipeline_name} uses fixed phase sigma schedules.")
+
+    if pipeline_recipe.fixed_num_inference_steps and (
+        request_inputs.num_inference_steps != pipeline_recipe.num_inference_steps
+    ):
+        raise ValueError(
+            f"{pipeline_name} uses {pipeline_recipe.num_inference_steps} fixed Stage 1 denoise steps; "
+            f"got {request_inputs.num_inference_steps}."
+        )
+
+    negative_prompt = request_inputs.negative_prompt
+    has_negative_prompt = (
+        any(bool(value) for value in negative_prompt) if isinstance(negative_prompt, list) else bool(negative_prompt)
+    )
+    if not pipeline_recipe.allow_negative_prompt and (
+        has_negative_prompt or request_inputs.negative_prompt_embeds is not None
+    ):
+        raise ValueError(f"{pipeline_name} uses positive-only guidance and does not accept negative conditioning.")
+
+    first_phase = pipeline_recipe.phases[0]
+    if not first_phase.allow_guidance_override and request_inputs.guidance != first_phase.guidance:
+        raise ValueError(f"{pipeline_name} uses fixed positive-only guidance and cannot override it.")
+
+
+def _unwrap_request_tensor(value: Any) -> Any:
+    if isinstance(value, list):
+        return value[0] if value else None
+    return value
+
+
+def _get_prompt_field(prompt: Any, *keys: str) -> Any:
+    if isinstance(prompt, str):
+        return None
+    additional = prompt.get("additional_information")
+    for key in keys:
+        value = prompt.get(key)
+        if value is None and isinstance(additional, dict):
+            value = additional.get(key)
+        if value is not None:
+            return _unwrap_request_tensor(value)
+    return None
+
+
+def _get_audio_latents_from_sampling(sampling: Any) -> torch.Tensor | None:
+    if sampling.audio_latents is not None:
+        return sampling.audio_latents
+    return sampling.extra_args.get("audio_latents")
+
+
+def _get_extra_arg(sampling: Any, *names: str) -> Any:
+    extra_args = sampling.extra_args or {}
+    for name in names:
+        value = extra_args.get(name)
+        if value is not None:
+            return value
+    return None
+
+
+def _normalize_stg_blocks(value: Any, default: tuple[int, ...]) -> tuple[int, ...]:
+    if value is None:
+        return default
+    if isinstance(value, int):
+        return (value,)
+    if not isinstance(value, (list, tuple)):
+        raise ValueError(f"STG blocks must be an integer or a list of integers, got {value!r}.")
+    return tuple(int(item) for item in value)
+
+
+def _resolve_negative_prompts(
+    prompts: list[Any],
+    fallback: str | list[str],
+) -> str | list[str]:
+    if not prompts:
+        return fallback
+    if isinstance(fallback, list) and len(fallback) != len(prompts):
+        raise ValueError(
+            f"`negative_prompt` has batch size {len(fallback)}, but the request batch has size {len(prompts)}."
+        )
+
+    resolved = []
+    for index, item in enumerate(prompts):
+        request_value = None if isinstance(item, str) else item.get("negative_prompt")
+        if request_value is not None:
+            resolved.append(request_value)
+        else:
+            resolved.append(fallback[index] if isinstance(fallback, list) else fallback)
+    return resolved
+
+
+def _resolve_modality_guidance(
+    sampling: Any,
+    modality: str,
+    default: LTXModalityGuidance,
+) -> LTXModalityGuidance:
+    cfg_aliases = (f"{modality}_cfg_scale", f"{modality}_cfg_guidance_scale")
+    stg_aliases = (f"{modality}_stg_scale", f"{modality}_stg_guidance_scale")
+    modality_aliases = (
+        ("video_modality_scale", "a2v_guidance_scale")
+        if modality == "video"
+        else ("audio_modality_scale", "v2a_guidance_scale")
+    )
+    cfg_scale = _get_extra_arg(sampling, *cfg_aliases)
+    stg_scale = _get_extra_arg(sampling, *stg_aliases)
+    modality_scale = _get_extra_arg(sampling, *modality_aliases)
+    rescale_scale = _get_extra_arg(sampling, f"{modality}_rescale_scale")
+    stg_blocks = _get_extra_arg(sampling, f"{modality}_stg_blocks")
+    return replace(
+        default,
+        cfg_scale=default.cfg_scale if cfg_scale is None else float(cfg_scale),
+        stg_scale=default.stg_scale if stg_scale is None else float(stg_scale),
+        modality_scale=default.modality_scale if modality_scale is None else float(modality_scale),
+        rescale_scale=default.rescale_scale if rescale_scale is None else float(rescale_scale),
+        stg_blocks=_normalize_stg_blocks(stg_blocks, default.stg_blocks),
+    )
+
+
+def _resolve_guidance_spec(
+    sampling: Any,
+    default: LTXGuidanceSpec,
+    *,
+    guidance_scale: float | None,
+) -> LTXGuidanceSpec:
+    video = _resolve_modality_guidance(sampling, "video", default.video)
+    audio = _resolve_modality_guidance(sampling, "audio", default.audio)
+
+    common_cfg = sampling.guidance_scale if sampling.guidance_scale_provided else guidance_scale
+    if common_cfg is not None:
+        video = replace(video, cfg_scale=float(common_cfg))
+        audio = replace(audio, cfg_scale=float(common_cfg))
+
+    return LTXGuidanceSpec(video=video, audio=audio)
+
+
+class LTXRequestMixin:
+    """Normalize serving requests without coupling them to a model version."""
+
+    supports_request_batch = False
+
+    @staticmethod
+    def _validate_forward_options(
+        *,
+        timesteps: list[int] | None,
+        guidance_rescale: float | None,
+        noise_scale: float,
+        return_dict: bool,
+        attention_kwargs: dict[str, Any] | None,
+    ) -> None:
+        if timesteps is not None:
+            raise ValueError("LTX does not support `timesteps`; use `sigmas` for a custom schedule.")
+        if guidance_rescale not in (None, 0.0):
+            raise ValueError(
+                "LTX does not support the common `guidance_rescale`; use `video_rescale_scale` and "
+                "`audio_rescale_scale`."
+            )
+        if noise_scale != 0.0:
+            raise ValueError("LTX only supports `noise_scale=0.0`.")
+        if return_dict is not True:
+            raise ValueError("LTX only supports `return_dict=True`.")
+        if attention_kwargs is not None:
+            raise ValueError("LTX does not support public `attention_kwargs`.")
+
+    @torch.no_grad()
+    def forward(
+        self,
+        req: DiffusionRequestBatch,
+        *,
+        image: Any | None = None,
+        prompt: str | list[str] | None = None,
+        negative_prompt: str | list[str] | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        num_frames: int | None = None,
+        frame_rate: float | None = None,
+        num_inference_steps: int | None = None,
+        sigmas: list[float] | None = None,
+        timesteps: list[int] | None = None,
+        guidance_scale: float | None = None,
+        guidance_rescale: float | None = None,
+        noise_scale: float = 0.0,
+        num_videos_per_prompt: int | None = 1,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        audio_latents: torch.Tensor | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        prompt_attention_mask: torch.Tensor | None = None,
+        negative_prompt_attention_mask: torch.Tensor | None = None,
+        decode_timestep: float | list[float] = 0.0,
+        decode_noise_scale: float | list[float] | None = None,
+        output_type: str = "np",
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+        max_sequence_length: int | None = None,
+    ) -> DiffusionOutput | list[DiffusionOutput]:
+        """Validate and normalize the public LTX request surface."""
+        self._validate_forward_options(
+            timesteps=timesteps,
+            guidance_rescale=guidance_rescale,
+            noise_scale=noise_scale,
+            return_dict=return_dict,
+            attention_kwargs=attention_kwargs,
+        )
+        if image is not None and not self.support_image_input:
+            raise ValueError(f"{self.__class__.__name__} does not support `image` input.")
+
+        return self._forward_request(
+            req,
+            image=image,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            frame_rate=frame_rate,
+            num_inference_steps=num_inference_steps,
+            sigmas=sigmas,
+            guidance_scale=guidance_scale,
+            num_videos_per_prompt=num_videos_per_prompt,
+            generator=generator,
+            latents=latents,
+            audio_latents=audio_latents,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            prompt_attention_mask=prompt_attention_mask,
+            negative_prompt_attention_mask=negative_prompt_attention_mask,
+            decode_timestep=decode_timestep,
+            decode_noise_scale=decode_noise_scale,
+            output_type=output_type,
+            max_sequence_length=max_sequence_length,
+        )
+
+    @staticmethod
+    def _resolve_request_sigmas(
+        req: DiffusionRequestBatch,
+        fallback: list[float] | None,
+    ) -> list[float] | None:
+        request_sigmas = [sampling.sigmas for sampling in req.sampling_params_list]
+        first = request_sigmas[0] if request_sigmas else None
+        if any(item != first for item in request_sigmas[1:]):
+            raise ValueError("Batched LTX requests must use identical custom sigmas.")
+        return first if first is not None else fallback
+
+    def check_inputs(
+        self,
+        prompt: str | list[str] | None,
+        height: int,
+        width: int,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        prompt_attention_mask: torch.Tensor | None = None,
+        negative_prompt_attention_mask: torch.Tensor | None = None,
+    ) -> None:
+        if height % 32 != 0 or width % 32 != 0:
+            raise ValueError(f"`height` and `width` must be divisible by 32 but are {height} and {width}.")
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError("Cannot forward both `prompt` and `prompt_embeds`.")
+        if prompt is None and prompt_embeds is None:
+            raise ValueError("Provide either `prompt` or `prompt_embeds`.")
+        if prompt is not None and not isinstance(prompt, (str, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+        if prompt_embeds is not None and prompt_attention_mask is None:
+            raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.")
+        if negative_prompt_embeds is not None and negative_prompt_attention_mask is None:
+            raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.")
+        if prompt_embeds is not None and negative_prompt_embeds is not None:
+            if prompt_embeds.shape != negative_prompt_embeds.shape:
+                raise ValueError(
+                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
+                    f" got {prompt_embeds.shape} and {negative_prompt_embeds.shape}."
+                )
+            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
+                raise ValueError(
+                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when"
+                    f" passed directly, but got {prompt_attention_mask.shape} and"
+                    f" {negative_prompt_attention_mask.shape}."
+                )
+
+    def _resolve_request_inputs(
+        self,
+        req: DiffusionRequestBatch,
+        *,
+        prompt: str | list[str] | None,
+        negative_prompt: str | list[str] | None,
+        height: int | None,
+        width: int | None,
+        num_frames: int | None,
+        frame_rate: float | None,
+        num_inference_steps: int | None,
+        guidance_scale: float | None,
+        num_videos_per_prompt: int | None,
+        generator: torch.Generator | list[torch.Generator] | None,
+        latents: torch.Tensor | None,
+        audio_latents: torch.Tensor | None,
+        prompt_embeds: torch.Tensor | None,
+        negative_prompt_embeds: torch.Tensor | None,
+        prompt_attention_mask: torch.Tensor | None,
+        negative_prompt_attention_mask: torch.Tensor | None,
+        decode_timestep: float | list[float],
+        decode_noise_scale: float | list[float] | None,
+        output_type: str,
+        max_sequence_length: int | None,
+    ) -> LTXRequestInputs:
+        sampling_params_list = req.sampling_params_list
+        for sampling in sampling_params_list:
+            if sampling.timesteps is not None:
+                raise ValueError("LTX does not support `timesteps`; use `sigmas` for a custom schedule.")
+            if sampling.guidance_rescale:
+                raise ValueError(
+                    "LTX does not support the common `guidance_rescale`; use `video_rescale_scale` and "
+                    "`audio_rescale_scale`."
+                )
+            if _get_extra_arg(sampling, "flow_shift") is not None:
+                raise ValueError("LTX does not support `flow_shift`; use `sigmas` for a custom schedule.")
+
+        sampling = sampling_params_list[0]
+        is_dummy_run = req.is_dummy_run()
+        prompt = [item if isinstance(item, str) else (item.get("prompt") or "") for item in req.prompts] or prompt
+        negative_prompt = _resolve_negative_prompts(
+            req.prompts,
+            negative_prompt if negative_prompt is not None else self.pipeline_recipe.negative_prompt,
+        )
+
+        height = sampling.height or height or self.pipeline_recipe.height
+        width = sampling.width or width or self.pipeline_recipe.width
+        num_frames = sampling.num_frames or num_frames or self.pipeline_recipe.num_frames
+        frame_rate = sampling.resolved_frame_rate or frame_rate or self.pipeline_recipe.frame_rate
+        num_inference_steps = (
+            sampling.num_inference_steps or num_inference_steps or self.pipeline_recipe.num_inference_steps
+        )
+        if is_dummy_run and self.pipeline_recipe.fixed_num_inference_steps:
+            num_inference_steps = self.pipeline_recipe.num_inference_steps
+        num_inference_steps = max(int(num_inference_steps), 2)
+
+        num_videos_per_prompt = (
+            sampling.num_outputs_per_prompt if sampling.num_outputs_per_prompt > 0 else num_videos_per_prompt or 1
+        )
+        max_sequence_length = sampling.max_sequence_length or max_sequence_length or self.tokenizer_max_length
+        guidance_specs = [
+            _resolve_guidance_spec(
+                item,
+                self.pipeline_recipe.request_guidance,
+                guidance_scale=guidance_scale,
+            )
+            for item in sampling_params_list
+        ]
+        guidance = guidance_specs[0]
+        if is_dummy_run and not self.pipeline_recipe.phases[0].allow_guidance_override:
+            guidance = self.pipeline_recipe.request_guidance
+        if any(item != guidance for item in guidance_specs[1:]):
+            raise ValueError("Batched LTX requests must use identical video/audio guidance parameters.")
+
+        if self.supports_request_batch:
+            if generator is None:
+                generator = req.collate_request_generators(num_videos_per_prompt, generator)
+            latents = req.collate_request_tensors("latents", latents)
+            audio_latents = DiffusionRequestBatch.collate_tensors(
+                [_get_audio_latents_from_sampling(item) for item in sampling_params_list],
+                "audio_latents",
+                audio_latents,
+            )
+            prompt_fields = DiffusionRequestBatch.collate_prompt_field_map(
+                req.prompts,
+                {
+                    "prompt_embeds": prompt_embeds,
+                    "negative_prompt_embeds": negative_prompt_embeds,
+                    "prompt_attention_mask": prompt_attention_mask,
+                    "negative_prompt_attention_mask": negative_prompt_attention_mask,
+                },
+                field_aliases={
+                    "prompt_attention_mask": ("prompt_attention_mask", "attention_mask"),
+                    "negative_prompt_attention_mask": (
+                        "negative_prompt_attention_mask",
+                        "negative_attention_mask",
+                    ),
+                },
+            )
+            prompt_embeds = prompt_fields["prompt_embeds"]
+            negative_prompt_embeds = prompt_fields["negative_prompt_embeds"]
+            prompt_attention_mask = prompt_fields["prompt_attention_mask"]
+            negative_prompt_attention_mask = prompt_fields["negative_prompt_attention_mask"]
+            if prompt_embeds is not None:
+                prompt = None
+            if negative_prompt_embeds is not None:
+                negative_prompt = None
+        else:
+            if generator is None:
+                generator = sampling.generator
+            if generator is None and sampling.seed is not None:
+                generator = torch.Generator(device=self.device).manual_seed(sampling.seed)
+            latents = sampling.latents if sampling.latents is not None else latents
+            sampling_audio_latents = _get_audio_latents_from_sampling(sampling)
+            if sampling_audio_latents is not None:
+                audio_latents = sampling_audio_latents
+
+            request_prompt_embeds = [_get_prompt_field(item, "prompt_embeds") for item in req.prompts]
+            if any(value is not None for value in request_prompt_embeds):
+                prompt_embeds = torch.stack(request_prompt_embeds)  # type: ignore[arg-type]
+            request_negative_embeds = [_get_prompt_field(item, "negative_prompt_embeds") for item in req.prompts]
+            if any(value is not None for value in request_negative_embeds):
+                negative_prompt_embeds = torch.stack(request_negative_embeds)  # type: ignore[arg-type]
+            request_prompt_masks = [
+                _get_prompt_field(item, "prompt_attention_mask", "attention_mask") for item in req.prompts
+            ]
+            if any(value is not None for value in request_prompt_masks):
+                prompt_attention_mask = torch.stack(request_prompt_masks)  # type: ignore[arg-type]
+            request_negative_masks = [
+                _get_prompt_field(item, "negative_prompt_attention_mask", "negative_attention_mask")
+                for item in req.prompts
+            ]
+            if any(value is not None for value in request_negative_masks):
+                negative_prompt_attention_mask = torch.stack(request_negative_masks)  # type: ignore[arg-type]
+            if prompt_embeds is not None:
+                prompt = None
+            if negative_prompt_embeds is not None:
+                negative_prompt = None
+
+        if sampling.decode_timestep is not None:
+            decode_timestep = sampling.decode_timestep
+        if sampling.decode_noise_scale is not None:
+            decode_noise_scale = sampling.decode_noise_scale
+        if sampling.output_type is not None:
+            output_type = sampling.output_type
+
+        return LTXRequestInputs(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=int(height),
+            width=int(width),
+            num_frames=int(num_frames),
+            frame_rate=float(frame_rate),
+            num_inference_steps=int(num_inference_steps),
+            guidance=guidance,
+            num_videos_per_prompt=int(num_videos_per_prompt),
+            generator=generator,
+            latents=latents,
+            audio_latents=audio_latents,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            prompt_attention_mask=prompt_attention_mask,
+            negative_prompt_attention_mask=negative_prompt_attention_mask,
+            decode_timestep=decode_timestep,
+            decode_noise_scale=decode_noise_scale,
+            output_type=output_type,
+            max_sequence_length=int(max_sequence_length),
+        )
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_runtime.py b/vllm_omni/diffusion/models/ltx2/ltx2_runtime.py
new file mode 100644
index 000000000..4b74ebcb8
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_runtime.py
@@ -0,0 +1,854 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Shared recipe-driven runtime for LTX pipeline variants."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from contextlib import nullcontext
+from dataclasses import replace
+from typing import Any, ClassVar
+
+import torch
+from diffusers.utils.torch_utils import randn_tensor
+from torch import nn
+from vllm.model_executor.models.utils import AutoWeightsLoader
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_classifier_free_guidance_world_size as get_guidance_parallel_world_size,
+)
+from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
+from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
+from vllm_omni.platforms import current_omni_platform
+
+from . import ltx2_latents as latent_ops
+from .ltx2_components import (
+    LTXComponentProfile,
+    detect_ltx_model_version,
+    initialize_pipeline_components,
+    resolve_ltx_component_profile,
+)
+from .ltx2_conditioning import LTXPromptContext, LTXTextConditioningMixin
+from .ltx2_denoise import (
+    LTXDenoiseContext,
+    LTXForwardContext,
+    LTXPhaseExecutor,
+    LTXPhaseResult,
+    build_transformer_kwargs,
+    step_denoised_latents,
+)
+from .ltx2_guidance import (
+    LTX_GUIDANCE_EXECUTOR,
+    LTXGuidanceExecutor,
+    LTXGuidancePlan,
+)
+from .ltx2_recipes import (
+    LTXPhaseRecipe,
+    LTXPipelineRecipe,
+    resolve_ltx_pipeline_recipe,
+)
+from .ltx2_request import (
+    LTXRequestInputs,
+    LTXRequestMixin,
+    validate_pipeline_request,
+)
+
+
+def _expand_per_prompt_decode_value(
+    value: float | list[float],
+    *,
+    prompt_batch_size: int,
+    effective_batch_size: int,
+    field_name: str,
+) -> list[float]:
+    if not isinstance(value, list):
+        return [value] * effective_batch_size
+    if len(value) == 1:
+        return value * effective_batch_size
+    if len(value) == effective_batch_size:
+        return value
+    if prompt_batch_size > 0 and len(value) == prompt_batch_size and effective_batch_size % prompt_batch_size == 0:
+        repeats = effective_batch_size // prompt_batch_size
+        return [item for item in value for _ in range(repeats)]
+    raise ValueError(
+        f"`{field_name}` must have length 1, prompt batch size ({prompt_batch_size}), or effective batch size"
+        f" ({effective_batch_size}); got {len(value)}."
+    )
+
+
+def _prepare_decode_timestep_conditioning(
+    *,
+    decode_timestep: float | list[float],
+    decode_noise_scale: float | list[float] | None,
+    prompt_batch_size: int,
+    effective_batch_size: int,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    decode_timestep_values = _expand_per_prompt_decode_value(
+        decode_timestep,
+        prompt_batch_size=prompt_batch_size,
+        effective_batch_size=effective_batch_size,
+        field_name="decode_timestep",
+    )
+    decode_noise_scale_values = (
+        decode_timestep_values
+        if decode_noise_scale is None
+        else _expand_per_prompt_decode_value(
+            decode_noise_scale,
+            prompt_batch_size=prompt_batch_size,
+            effective_batch_size=effective_batch_size,
+            field_name="decode_noise_scale",
+        )
+    )
+    return (
+        torch.tensor(decode_timestep_values, device=device, dtype=dtype),
+        torch.tensor(decode_noise_scale_values, device=device, dtype=dtype)[:, None, None, None, None],
+    )
+
+
+class LTXRuntime(
+    LTXRequestMixin,
+    LTXTextConditioningMixin,
+    nn.Module,
+    CFGParallelMixin,
+    ProgressBarMixin,
+    SupportsComponentDiscovery,
+    DiffusionPipelineProfilerMixin,
+):
+    """Shared Omni runtime for recipe-driven LTX denoise phases."""
+
+    pipeline_kind: ClassVar[str] = "one_stage"
+    component_profile: ClassVar[LTXComponentProfile]
+    pipeline_recipe: ClassVar[LTXPipelineRecipe]
+    guidance_executor: ClassVar[LTXGuidanceExecutor] = LTX_GUIDANCE_EXECUTOR
+    supports_request_batch = False
+    connector_batches_cfg = False
+    distributed_video_decode = True
+    support_image_input = False
+    dummy_run_num_frames = 1
+    preserve_sp_padded_audio_duration = False
+    reports_stage_durations = False
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = "") -> None:
+        del prefix
+        self.model_version = detect_ltx_model_version(od_config.model)
+        self.component_profile = resolve_ltx_component_profile(self.pipeline_kind, self.model_version)
+        self.pipeline_recipe = resolve_ltx_pipeline_recipe(self.pipeline_kind, self.model_version)
+        self._dit_modules = list(self.component_profile.dit_modules)
+        self._encoder_modules = list(self.component_profile.encoder_modules)
+        self._vae_modules = list(self.component_profile.vae_modules)
+        self._resident_modules = list(self.component_profile.resident_modules)
+        if self.model_version == "2.3":
+            self.preserve_sp_padded_audio_duration = True
+            self.reports_stage_durations = True
+        super().__init__()
+        self._guidance_plan = LTXGuidancePlan.build(self.pipeline_recipe.request_guidance)
+        initialize_pipeline_components(self, od_config)
+        self.setup_diffusion_pipeline_profiler(
+            enable_diffusion_pipeline_profiler=self.od_config.enable_diffusion_pipeline_profiler
+        )
+
+    def _forward_request(
+        self,
+        req: DiffusionRequestBatch,
+        *,
+        image: Any | None = None,
+        prompt: str | list[str] | None = None,
+        negative_prompt: str | list[str] | None = None,
+        height: int | None = None,
+        width: int | None = None,
+        num_frames: int | None = None,
+        frame_rate: float | None = None,
+        num_inference_steps: int | None = None,
+        sigmas: list[float] | None = None,
+        guidance_scale: float | None = None,
+        num_videos_per_prompt: int | None = 1,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        audio_latents: torch.Tensor | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        prompt_attention_mask: torch.Tensor | None = None,
+        negative_prompt_attention_mask: torch.Tensor | None = None,
+        decode_timestep: float | list[float] = 0.0,
+        decode_noise_scale: float | list[float] | None = None,
+        output_type: str = "np",
+        max_sequence_length: int | None = None,
+    ) -> DiffusionOutput | list[DiffusionOutput]:
+        request_inputs = self._resolve_request_inputs(
+            req,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            frame_rate=frame_rate,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            num_videos_per_prompt=num_videos_per_prompt,
+            generator=generator,
+            latents=latents,
+            audio_latents=audio_latents,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            prompt_attention_mask=prompt_attention_mask,
+            negative_prompt_attention_mask=negative_prompt_attention_mask,
+            decode_timestep=decode_timestep,
+            decode_noise_scale=decode_noise_scale,
+            output_type=output_type,
+            max_sequence_length=max_sequence_length,
+        )
+        image = self._resolve_request_image(req, image, request_inputs)
+        request_sigmas = self._resolve_request_sigmas(req, sigmas)
+        validate_pipeline_request(
+            request_inputs,
+            pipeline_recipe=self.pipeline_recipe,
+            vae_spatial_compression_ratio=self.vae_spatial_compression_ratio,
+            vae_temporal_compression_ratio=self.vae_temporal_compression_ratio,
+            pipeline_name=self.__class__.__name__,
+            request_sigmas=request_sigmas,
+        )
+        return self._run_recipe(req, request_inputs, request_sigmas=request_sigmas, image=image)
+
+    def _run_recipe(
+        self,
+        req: DiffusionRequestBatch,
+        request_inputs: LTXRequestInputs,
+        *,
+        request_sigmas: list[float] | None,
+        image: Any | None = None,
+    ) -> DiffusionOutput | list[DiffusionOutput]:
+        """Execute one- and multi-phase recipes through the same control flow."""
+        phase_results: list[LTXPhaseResult] = []
+        prompt_context = None
+
+        for phase_recipe in self.pipeline_recipe.phases:
+            self._enter_phase(phase_recipe)
+            phase_inputs = self._build_phase_inputs(
+                request_inputs,
+                phase_recipe,
+                phase_results[-1] if phase_results else None,
+            )
+            phase_result = self.run_phase(
+                req,
+                phase_inputs,
+                noise_scale=phase_recipe.noise_scale,
+                sigmas=list(phase_recipe.sigmas) if phase_recipe.sigmas is not None else request_sigmas,
+                timesteps=None,
+                attention_kwargs=None,
+                phase_recipe=phase_recipe,
+                image=image,
+                prompt_context=prompt_context,
+            )
+            phase_results.append(phase_result)
+            prompt_context = phase_result.forward_context.prompt_context
+
+        final_context = phase_results[-1].forward_context
+        output_phase = LTXPhaseResult(
+            forward_context=final_context,
+            video=phase_results[self.pipeline_recipe.video_output_phase].video,
+            audio=phase_results[self.pipeline_recipe.audio_output_phase].audio,
+        )
+        return self.decode_phase(output_phase)
+
+    def _enter_phase(self, phase: LTXPhaseRecipe) -> None:
+        """Hook for a future phase-weight strategy."""
+        self._active_phase_name = phase.name
+
+    def prepare_latents(
+        self,
+        batch_size: int = 1,
+        num_channels_latents: int = 128,
+        height: int = 512,
+        width: int = 768,
+        num_frames: int = 121,
+        noise_scale: float = 0.0,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        return latent_ops.prepare_video_latents(
+            self,
+            batch_size,
+            num_channels_latents,
+            height,
+            width,
+            num_frames,
+            noise_scale,
+            dtype,
+            device,
+            generator,
+            latents,
+        )
+
+    def prepare_audio_latents(
+        self,
+        batch_size: int = 1,
+        num_channels_latents: int = 8,
+        audio_latent_length: int = 1,
+        num_mel_bins: int = 64,
+        noise_scale: float = 0.0,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        latents_normalized: bool = False,
+    ) -> tuple[torch.Tensor, int, int]:
+        return latent_ops.prepare_audio_latents(
+            self,
+            batch_size,
+            num_channels_latents,
+            audio_latent_length,
+            num_mel_bins,
+            noise_scale,
+            dtype,
+            device,
+            generator,
+            latents,
+            latents_normalized,
+        )
+
+    @property
+    def guidance_scale(self):
+        return self._guidance_plan.spec.video.cfg_scale
+
+    @property
+    def do_classifier_free_guidance(self):
+        return self._guidance_plan.spec.do_cfg
+
+    @property
+    def do_guidance(self):
+        return len(self._guidance_plan.passes) > 1
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    def _transformer_cache_context(self, context_name: str):
+        cache_context = getattr(self.transformer, "cache_context", None)
+        if callable(cache_context):
+            return cache_context(context_name)
+        return nullcontext()
+
+    def predict_noise(self, **kwargs):
+        with self._transformer_cache_context("cond_uncond"):
+            noise_pred_video, noise_pred_audio = self.transformer(**kwargs)
+        return noise_pred_video.float(), noise_pred_audio.float()
+
+    def combine_cfg_noise(
+        self,
+        positive_noise_pred,
+        negative_noise_pred,
+        true_cfg_scale,
+        cfg_normalize=False,
+        kwargs: dict[str, Any] | None = None,
+        **context: Any,
+    ):
+        if kwargs is not None:
+            context = {**kwargs, **context}
+        del cfg_normalize
+        required = ("video_latents", "audio_latents", "video_sigma", "audio_sigma")
+        if any(context.get(name) is None for name in required):
+            raise ValueError("LTX x0-space CFG requires video/audio latents and sigmas.")
+        video_pos, audio_pos = positive_noise_pred
+        video_neg, audio_neg = negative_noise_pred
+        return (
+            self.guidance_executor.combine_cfg_velocity(
+                context["video_latents"],
+                video_pos,
+                video_neg,
+                context["video_sigma"],
+                true_cfg_scale,
+            ),
+            self.guidance_executor.combine_cfg_velocity(
+                context["audio_latents"],
+                audio_pos,
+                audio_neg,
+                context["audio_sigma"],
+                true_cfg_scale,
+            ),
+        )
+
+    def _synchronize_guidance_parallel_step_output(
+        self,
+        latents: tuple[torch.Tensor, torch.Tensor],
+        guidance_parallel_ready: bool,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if not (guidance_parallel_ready and get_guidance_parallel_world_size() > 1):
+            return latents
+
+        # CUDA async execution otherwise permits numerical drift to accumulate
+        # across guidance-parallel denoise steps.
+        latents = tuple(tensor.contiguous() for tensor in latents)
+        current_omni_platform.synchronize()
+        return latents
+
+    def _setup_forward_runtime(
+        self,
+        req: DiffusionRequestBatch,
+        request_inputs: LTXRequestInputs,
+        attention_kwargs: dict[str, Any] | None,
+    ) -> bool:
+        self._guidance_plan = LTXGuidancePlan.build(request_inputs.guidance)
+        del req, attention_kwargs
+        self._interrupt = False
+        guidance_world_size = get_guidance_parallel_world_size()
+        self.guidance_executor.validate_guidance_world_size(self._guidance_plan, guidance_world_size)
+        self.guidance_executor.warn_if_imbalanced(
+            self._guidance_plan,
+            guidance_world_size,
+            getattr(self, "_active_phase_name", "generate"),
+        )
+        return self.do_guidance and guidance_world_size > 1
+
+    def _check_forward_inputs(
+        self,
+        request_inputs: LTXRequestInputs,
+        image: Any | None = None,
+    ) -> None:
+        self.check_inputs(
+            prompt=request_inputs.prompt,
+            height=request_inputs.height,
+            width=request_inputs.width,
+            prompt_embeds=request_inputs.prompt_embeds,
+            negative_prompt_embeds=request_inputs.negative_prompt_embeds,
+            prompt_attention_mask=request_inputs.prompt_attention_mask,
+            negative_prompt_attention_mask=request_inputs.negative_prompt_attention_mask,
+        )
+
+    def _resolve_request_image(
+        self,
+        req: DiffusionRequestBatch,
+        image: Any | None,
+        request_inputs: LTXRequestInputs,
+    ) -> Any | None:
+        del req, request_inputs
+        return image
+
+    def _make_output(self, output: tuple[torch.Tensor, torch.Tensor]) -> DiffusionOutput:
+        if self.reports_stage_durations:
+            return DiffusionOutput(
+                output=output,
+                stage_durations=getattr(self, "stage_durations", None),
+            )
+        return DiffusionOutput(output=output)
+
+    def _decode_output(
+        self,
+        *,
+        latents: torch.Tensor,
+        audio_latents: torch.Tensor,
+        output_type: str,
+        connector_prompt_embeds: torch.Tensor,
+        generator: torch.Generator | list[torch.Generator] | None,
+        device: torch.device,
+        decode_timestep: float | list[float],
+        decode_noise_scale: float | list[float] | None,
+        prompt_batch_size: int,
+    ) -> DiffusionOutput:
+        if output_type == "latent":
+            return self._make_output((latents, audio_latents))
+
+        latents = latents.to(connector_prompt_embeds.dtype)
+        if not self.vae.config.timestep_conditioning:
+            timestep_decode = None
+        else:
+            noise = randn_tensor(latents.shape, generator=generator, device=device, dtype=latents.dtype)
+            timestep_decode, decode_noise_scale_t = _prepare_decode_timestep_conditioning(
+                decode_timestep=decode_timestep,
+                decode_noise_scale=decode_noise_scale,
+                prompt_batch_size=prompt_batch_size,
+                effective_batch_size=latents.shape[0],
+                device=device,
+                dtype=latents.dtype,
+            )
+            latents = (1 - decode_noise_scale_t) * latents + decode_noise_scale_t * noise
+
+        dist_initialized = torch.distributed.is_initialized()
+        is_output_rank = not dist_initialized or torch.distributed.get_rank() == 0
+        vae_decode_needs_all_ranks = False
+        is_distributed_vae_enabled = getattr(self.vae, "is_distributed_enabled", None)
+        if self.distributed_video_decode and dist_initialized and callable(is_distributed_vae_enabled):
+            # Distributed tiled decode is collective, so every rank must enter it.
+            vae_decode_needs_all_ranks = bool(is_distributed_vae_enabled())
+
+        should_decode_video = not self.distributed_video_decode or is_output_rank or vae_decode_needs_all_ranks
+        if should_decode_video:
+            video = self.vae.decode(latents.to(self.vae.dtype), timestep_decode, return_dict=False)[0]
+        else:
+            video = torch.empty(0, device=latents.device, dtype=latents.dtype)
+
+        if self.distributed_video_decode and not is_output_rank:
+            return self._make_output(
+                (
+                    torch.empty(0, device=video.device, dtype=video.dtype),
+                    torch.empty(0, device=audio_latents.device, dtype=audio_latents.dtype),
+                )
+            )
+
+        if video.numel() > 0:
+            video = self.video_processor.postprocess_video(video, output_type=output_type)
+        generated_mel = self.audio_vae.decode(audio_latents.to(self.audio_vae.dtype), return_dict=False)[0]
+        audio = self.vocoder(generated_mel)
+        return self._make_output((video, audio))
+
+    def _prepare_video_latents_stage(
+        self,
+        request_inputs: LTXRequestInputs,
+        prompt_context: LTXPromptContext,
+        *,
+        device: torch.device,
+        noise_scale: float,
+        image: Any | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        latents = self.prepare_latents(
+            batch_size=prompt_context.batch_size * request_inputs.num_videos_per_prompt,
+            num_channels_latents=self.transformer.config.in_channels,
+            height=request_inputs.height,
+            width=request_inputs.width,
+            num_frames=request_inputs.num_frames,
+            noise_scale=noise_scale,
+            dtype=prompt_context.positive_connector_prompt_embeds.dtype,
+            device=device,
+            generator=request_inputs.generator,
+            latents=request_inputs.latents,
+        )
+        return latents, None
+
+    def _resolve_video_latent_dimensions(self, request_inputs: LTXRequestInputs) -> tuple[int, int, int]:
+        latent_num_frames, latent_height, latent_width = latent_ops.resolve_video_latent_shape(
+            request_inputs.height,
+            request_inputs.width,
+            request_inputs.num_frames,
+            vae_spatial_compression_ratio=self.vae_spatial_compression_ratio,
+            vae_temporal_compression_ratio=self.vae_temporal_compression_ratio,
+        )
+        latents = request_inputs.latents
+        if latents is not None:
+            if latents.ndim == 5:
+                _, _, latent_num_frames, latent_height, latent_width = latents.shape
+            elif latents.ndim != 3:
+                raise ValueError(
+                    f"Provided `latents` tensor has shape {latents.shape}, expected a packed 3D or unpacked 5D tensor."
+                )
+        return latent_num_frames, latent_height, latent_width
+
+    def _prepare_audio_latents_stage(
+        self,
+        request_inputs: LTXRequestInputs,
+        prompt_context: LTXPromptContext,
+        *,
+        device: torch.device,
+        noise_scale: float,
+    ) -> tuple[torch.Tensor, int, int, int]:
+        duration_s = request_inputs.num_frames / request_inputs.frame_rate
+        audio_latents_per_second = (
+            self.audio_sampling_rate / self.audio_hop_length / float(self.audio_vae_temporal_compression_ratio)
+        )
+        audio_num_frames = round(duration_s * audio_latents_per_second)
+        audio_num_frames = self._resolve_audio_latent_length(audio_num_frames, request_inputs.audio_latents)
+
+        num_mel_bins = self.audio_vae.config.mel_bins if self.audio_vae is not None else 64
+        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
+        num_channels = self.audio_vae.config.latent_channels if self.audio_vae is not None else 8
+        audio_latents, original_num_frames, padded_num_frames = self.prepare_audio_latents(
+            prompt_context.batch_size * request_inputs.num_videos_per_prompt,
+            num_channels_latents=num_channels,
+            audio_latent_length=audio_num_frames,
+            num_mel_bins=num_mel_bins,
+            noise_scale=noise_scale,
+            dtype=prompt_context.positive_connector_audio_prompt_embeds.dtype,
+            device=device,
+            generator=request_inputs.generator,
+            latents=request_inputs.audio_latents,
+            latents_normalized=request_inputs.audio_latents_normalized,
+        )
+        return audio_latents, original_num_frames, padded_num_frames, latent_mel_bins
+
+    def _resolve_audio_latent_length(
+        self,
+        requested_length: int,
+        audio_latents: torch.Tensor | None,
+    ) -> int:
+        if audio_latents is None or audio_latents.ndim != 4:
+            return requested_length
+
+        provided_length = audio_latents.shape[2]
+        if not self.preserve_sp_padded_audio_duration:
+            return provided_length
+
+        sp_size = getattr(self.od_config.parallel_config, "sequence_parallel_size", 1) or 1
+        padded_length = latent_ops.get_sp_padded_audio_latent_length(requested_length, int(sp_size))
+        return requested_length if provided_length in {requested_length, padded_length} else provided_length
+
+    def _prepare_denoise_context_for_guidance(
+        self,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> LTXDenoiseContext:
+        return self.guidance_executor.prepare_denoise_context(
+            self._guidance_plan,
+            forward_ctx.guidance_parallel_ready,
+            get_guidance_parallel_world_size(),
+            denoise_ctx,
+        )
+
+    def _denoise_timestep_kwargs(
+        self,
+        ts: torch.Tensor,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+        *,
+        video_token_count: int,
+        audio_token_count: int,
+    ) -> dict[str, torch.Tensor]:
+        del forward_ctx, denoise_ctx
+        return self.guidance_executor.timestep_kwargs(ts, video_token_count, audio_token_count)
+
+    def _video_guidance_model_sigma(
+        self,
+        sigma: torch.Tensor,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> torch.Tensor:
+        """Return the video timestep used to convert velocity predictions to x0."""
+        del denoise_ctx
+        return sigma
+
+    def _build_transformer_kwargs(
+        self,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+        *,
+        hidden_states: torch.Tensor,
+        audio_hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        audio_encoder_hidden_states: torch.Tensor,
+        encoder_attention_mask: torch.Tensor | None,
+        audio_encoder_attention_mask: torch.Tensor | None,
+        ts: torch.Tensor,
+        attention_kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return build_transformer_kwargs(
+            self,
+            forward_ctx,
+            denoise_ctx,
+            hidden_states=hidden_states,
+            audio_hidden_states=audio_hidden_states,
+            encoder_hidden_states=encoder_hidden_states,
+            audio_encoder_hidden_states=audio_encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            audio_encoder_attention_mask=audio_encoder_attention_mask,
+            ts=ts,
+            attention_kwargs=attention_kwargs,
+        )
+
+    def _predict_noise_for_step(
+        self,
+        index: int,
+        timestep: torch.Tensor,
+        state: latent_ops.LTXAVState,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        return self.guidance_executor.predict_noise(
+            self,
+            self._guidance_plan,
+            index,
+            timestep,
+            state,
+            forward_ctx,
+            denoise_ctx,
+        )
+
+    def _denoise_step(
+        self,
+        index: int,
+        timestep: torch.Tensor,
+        state: latent_ops.LTXAVState,
+        forward_ctx: LTXForwardContext,
+        denoise_ctx: LTXDenoiseContext,
+    ) -> latent_ops.LTXAVState:
+        denoise_ctx.latents = state.video
+        denoise_ctx.audio_latents = state.audio
+        noise_pred_video, noise_pred_audio = self._predict_noise_for_step(
+            index,
+            timestep,
+            state,
+            forward_ctx,
+            denoise_ctx,
+        )
+        video, audio = step_denoised_latents(
+            self,
+            forward_ctx,
+            denoise_ctx,
+            noise_pred_video,
+            noise_pred_audio,
+            timestep,
+        )
+        return latent_ops.LTXAVState(video=video, audio=audio)
+
+    def _unpack_and_denormalize_stage(
+        self,
+        forward_ctx: LTXForwardContext,
+        latents: torch.Tensor,
+        audio_latents: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        latents = latent_ops.unpack_latents(
+            latents,
+            forward_ctx.latent_num_frames,
+            forward_ctx.latent_height,
+            forward_ctx.latent_width,
+            self.transformer_spatial_patch_size,
+            self.transformer_temporal_patch_size,
+        )
+        latents = latent_ops.denormalize_latents(
+            latents,
+            self.vae.latents_mean,
+            self.vae.latents_std,
+            self.vae.config.scaling_factor,
+        )
+
+        audio_latents = latent_ops.unpad_audio_latents(audio_latents, forward_ctx.original_audio_num_frames)
+        audio_latents = latent_ops.denormalize_audio_latents(
+            audio_latents,
+            self.audio_vae.latents_mean,
+            self.audio_vae.latents_std,
+        )
+        audio_latents = latent_ops.unpack_audio_latents(
+            audio_latents,
+            num_mel_bins=forward_ctx.latent_mel_bins,
+        )
+        return latents, audio_latents
+
+    def run_phase(
+        self,
+        req: DiffusionRequestBatch,
+        request_inputs: LTXRequestInputs,
+        *,
+        noise_scale: float,
+        sigmas: list[float] | None,
+        timesteps: list[int] | None,
+        attention_kwargs: dict[str, Any] | None,
+        phase_recipe: LTXPhaseRecipe,
+        image: Any | None = None,
+        prompt_context: LTXPromptContext | None = None,
+    ) -> LTXPhaseResult:
+        """Prepare and execute one phase without decoding its output."""
+        return LTXPhaseExecutor.run(
+            self,
+            req,
+            request_inputs,
+            noise_scale=noise_scale,
+            sigmas=sigmas,
+            timesteps=timesteps,
+            attention_kwargs=attention_kwargs,
+            phase_recipe=phase_recipe,
+            image=image,
+            prompt_context=prompt_context,
+        )
+
+    def _build_phase_inputs(
+        self,
+        request_inputs: LTXRequestInputs,
+        phase: LTXPhaseRecipe,
+        previous_phase: LTXPhaseResult | None,
+    ) -> LTXRequestInputs:
+        """Resolve one phase from immutable request inputs and prior AV state."""
+        divisor = phase.spatial_downscale
+        if request_inputs.height % divisor != 0 or request_inputs.width % divisor != 0:
+            raise ValueError(
+                f"LTX phase {phase.name!r} cannot scale resolution "
+                f"{request_inputs.width}x{request_inputs.height} by {divisor}."
+            )
+        height = request_inputs.height // divisor
+        width = request_inputs.width // divisor
+        latents = request_inputs.latents
+        audio_latents = request_inputs.audio_latents
+        audio_latents_normalized = request_inputs.audio_latents_normalized
+        decode_timestep = request_inputs.decode_timestep
+        decode_noise_scale = request_inputs.decode_noise_scale
+
+        if phase.input_transform == "spatial_upsample":
+            if previous_phase is None:
+                raise ValueError(f"LTX phase {phase.name!r} requires a previous phase to upsample.")
+            if previous_phase.video.ndim != 5:
+                raise ValueError(f"LTX spatial upsampling expects a 5D video latent, got {previous_phase.video.shape}.")
+            latents = self._spatial_upsample_phase(previous_phase.video)
+            if previous_phase.audio_for_next_phase is not None:
+                audio_latents = previous_phase.audio_for_next_phase
+                audio_latents_normalized = True
+            else:
+                audio_latents = previous_phase.audio
+                audio_latents_normalized = False
+            decode_timestep = 0.0
+            decode_noise_scale = None
+
+            expected_shape = latent_ops.resolve_video_latent_shape(
+                height,
+                width,
+                request_inputs.num_frames,
+                vae_spatial_compression_ratio=self.vae_spatial_compression_ratio,
+                vae_temporal_compression_ratio=self.vae_temporal_compression_ratio,
+            )
+            if latents.shape[2:] != expected_shape:
+                raise ValueError(
+                    f"LTX phase {phase.name!r} upsampler produced {tuple(latents.shape[2:])}, expected "
+                    f"{expected_shape} for {width}x{height}."
+                )
+        elif phase.input_transform != "initial":
+            raise ValueError(f"Unsupported LTX phase input transform: {phase.input_transform!r}.")
+
+        guidance = request_inputs.guidance if phase.allow_guidance_override else phase.guidance
+        return replace(
+            request_inputs,
+            height=height,
+            width=width,
+            num_inference_steps=phase.num_inference_steps or request_inputs.num_inference_steps,
+            guidance=guidance,
+            latents=latents,
+            audio_latents=audio_latents,
+            audio_latents_normalized=audio_latents_normalized,
+            decode_timestep=decode_timestep,
+            decode_noise_scale=decode_noise_scale,
+        )
+
+    def _spatial_upsample_phase(self, latents: torch.Tensor) -> torch.Tensor:
+        """Apply the recipe-managed spatial upsampler to unpacked latents."""
+        latent_upsampler = getattr(self, "latent_upsampler", None)
+        if latent_upsampler is None:
+            raise RuntimeError("This LTX pipeline recipe requires a spatial latent upsampler.")
+        dtype = getattr(latent_upsampler, "dtype", latents.dtype)
+        return latent_upsampler(latents.to(device=self.device, dtype=dtype))
+
+    def decode_phase(self, phase: LTXPhaseResult) -> DiffusionOutput | list[DiffusionOutput]:
+        """Decode one completed phase and restore per-request outputs."""
+        forward_ctx = phase.forward_context
+        request_inputs = forward_ctx.request_inputs
+        output = self._decode_output(
+            latents=phase.video,
+            audio_latents=phase.audio,
+            output_type=request_inputs.output_type,
+            connector_prompt_embeds=forward_ctx.prompt_context.connector_prompt_embeds,
+            generator=request_inputs.generator,
+            device=forward_ctx.device,
+            decode_timestep=request_inputs.decode_timestep,
+            decode_noise_scale=request_inputs.decode_noise_scale,
+            prompt_batch_size=forward_ctx.batch_size,
+        )
+        if not self.supports_request_batch:
+            return output
+        return split_diffusion_output_by_request(
+            output,
+            forward_ctx.req,
+            num_outputs_per_prompt=forward_ctx.num_videos_per_prompt,
+        )
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        return AutoWeightsLoader(self).load_weights(weights)
diff --git a/vllm_omni/diffusion/models/ltx2/ltx2_transformer.py b/vllm_omni/diffusion/models/ltx2/ltx2_transformer.py
index 6072c0456..95724bd19 100644
--- a/vllm_omni/diffusion/models/ltx2/ltx2_transformer.py
+++ b/vllm_omni/diffusion/models/ltx2/ltx2_transformer.py
@@ -45,7 +45,7 @@ if TYPE_CHECKING:
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.distributed.hsdp_utils import is_transformer_block_module
 from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelInput, SequenceParallelOutput
 from vllm_omni.diffusion.forward_context import get_forward_context, is_forward_context_available
@@ -57,6 +57,9 @@ _RMSNORM_INIT_PARAMS = inspect.signature(RMSNorm.__init__).parameters
 
 def _make_rms_norm(hidden_size: int, *, eps: float, elementwise_affine: bool) -> nn.Module:
     """Bridge diffusers' RMSNorm API onto vLLM's `has_weight` variant."""
+    if not elementwise_affine:
+        return nn.RMSNorm(hidden_size, eps=eps, elementwise_affine=False)
+
     kwargs: dict[str, Any] = {"eps": eps}
     if "elementwise_affine" in _RMSNORM_INIT_PARAMS:
         kwargs["elementwise_affine"] = elementwise_affine
@@ -79,10 +82,14 @@ def _make_rms_norm(hidden_size: int, *, eps: float, elementwise_affine: bool) ->
 
 def apply_interleaved_rotary_emb(x: torch.Tensor, freqs: tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor:
     cos, sin = freqs
+    if cos.dtype != x.dtype:
+        cos = cos.to(dtype=x.dtype)
+    if sin.dtype != x.dtype:
+        sin = sin.to(dtype=x.dtype)
     # Concrete pair count instead of -1 keeps SDPA shape static under torch.compile.
     x_real, x_imag = x.unflatten(2, (x.shape[2] // 2, 2)).unbind(-1)  # [B, S, C // 2]
     x_rotated = torch.stack([-x_imag, x_real], dim=-1).flatten(2)
-    out = (x.float() * cos + x_rotated.float() * sin).to(x.dtype)
+    out = x * cos + x_rotated * sin
     return out
 
 
@@ -94,6 +101,10 @@ def apply_split_rotary_emb(
 ) -> torch.Tensor:
     # `head_dim` is plumbed in (not inferred via `-1`) so SDPA shape stays static under torch.compile.
     cos, sin = freqs
+    if cos.dtype != x.dtype:
+        cos = cos.to(dtype=x.dtype)
+    if sin.dtype != x.dtype:
+        sin = sin.to(dtype=x.dtype)
 
     x_dtype = x.dtype
     needs_reshape = False
@@ -112,7 +123,7 @@ def apply_split_rotary_emb(
     r = last // 2
 
     # (..., 2, r)
-    split_x = x.reshape(*x.shape[:-1], 2, r).float()  # Explicitly upcast to float
+    split_x = x.reshape(*x.shape[:-1], 2, r)
     first_x = split_x[..., :1, :]  # (..., 1, r)
     second_x = split_x[..., 1:, :]  # (..., 1, r)
 
@@ -327,6 +338,23 @@ class TensorParallelRMSNorm(nn.Module):
         return out.to(dtype=x_dtype)
 
 
+def to_ltx_padding_mask(attention_mask: torch.Tensor) -> torch.Tensor:
+    """Convert an additive/expanded LTX mask to a 2D padding mask."""
+    if attention_mask.ndim > 2:
+        if attention_mask.is_floating_point():
+            valid = attention_mask >= 0
+        else:
+            valid = attention_mask.to(torch.bool)
+        batch_size = valid.shape[0]
+        key_length = valid.shape[-1]
+        attention_mask = valid.reshape(batch_size, -1, key_length).all(dim=1)
+    if attention_mask.is_floating_point():
+        attention_mask = attention_mask >= 0
+    if attention_mask.dtype != torch.bool:
+        attention_mask = attention_mask.to(torch.bool)
+    return attention_mask
+
+
 class LTX2AudioVideoAttnProcessor:
     r"""
     Processor for implementing attention (SDPA is used by default if you're using PyTorch 2.0) for the LTX-2.0 model.
@@ -344,24 +372,6 @@ class LTX2AudioVideoAttnProcessor:
                 "Please upgrade your PyTorch installation."
             )
 
-    @staticmethod
-    def _to_padding_mask(attention_mask: torch.Tensor) -> torch.Tensor:
-        # Convert additive/expanded masks into a 2D padding mask for flash-attn.
-        if attention_mask.ndim > 2:
-            if attention_mask.is_floating_point():
-                valid = attention_mask >= 0
-            else:
-                valid = attention_mask.to(torch.bool)
-            b = valid.shape[0]
-            key_len = valid.shape[-1]
-            valid = valid.reshape(b, -1, key_len).all(dim=1)
-            attention_mask = valid
-        if attention_mask.is_floating_point():
-            attention_mask = attention_mask >= 0
-        if attention_mask.dtype != torch.bool:
-            attention_mask = attention_mask.to(torch.bool)
-        return attention_mask
-
     @staticmethod
     def _is_sp_enabled() -> bool:
         if not is_forward_context_available():
@@ -390,12 +400,12 @@ class LTX2AudioVideoAttnProcessor:
             # For cross-attention, encoder sequence length != query length, so drop the mask.
             if encoder_hidden_states is not None and encoder_hidden_states.shape[1] != hidden_states.shape[1]:
                 return None
-            return self._to_padding_mask(attention_mask)
+            return to_ltx_padding_mask(attention_mask)
 
         attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
         attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
         if attn.attn.attn_backend.get_name().upper() == "FLASH_ATTN":
-            attention_mask = self._to_padding_mask(attention_mask)
+            attention_mask = to_ltx_padding_mask(attention_mask)
         return attention_mask
 
     @staticmethod
@@ -467,6 +477,7 @@ class LTX2AudioVideoAttnProcessor:
         attention_mask: torch.Tensor | None = None,
         query_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
         key_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        perturbation_mask: torch.Tensor | None = None,
     ) -> torch.Tensor:
         is_self_attention = encoder_hidden_states is None
         batch_size, sequence_length, _ = hidden_states.shape if is_self_attention else encoder_hidden_states.shape
@@ -509,17 +520,21 @@ class LTX2AudioVideoAttnProcessor:
             elif attn.rope_type == "split":
                 query = apply_split_rotary_emb(query, query_rotary_emb, head_dim=attn.head_dim)
                 key = apply_split_rotary_emb(
-                    key, key_rotary_emb if key_rotary_emb is not None else query_rotary_emb, head_dim=attn.head_dim
+                    key,
+                    key_rotary_emb if key_rotary_emb is not None else query_rotary_emb,
+                    head_dim=attn.head_dim,
                 )
 
         query = query.unflatten(2, (attn.heads, attn.head_dim))
         key = key.unflatten(2, (attn.heads, attn.head_dim))
-        value = value.unflatten(2, (attn.heads, attn.head_dim))
+        value_heads = value.unflatten(2, (attn.heads, attn.head_dim))
 
         attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
-        hidden_states = attn.attn(query, key, value, attn_metadata)
+        hidden_states = attn.attn(query, key, value_heads, attn_metadata)
         hidden_states = hidden_states.flatten(2, 3)
         hidden_states = hidden_states.to(query.dtype)
+        if perturbation_mask is not None:
+            hidden_states = hidden_states * perturbation_mask + value * (1 - perturbation_mask)
 
         # LTX-2.3: per-head gated attention
         if attn.to_gate_logits is not None:
@@ -560,6 +575,7 @@ class LTX2Attention(torch.nn.Module):
         norm_elementwise_affine: bool = True,
         rope_type: str = "interleaved",
         apply_gated_attention: bool = False,
+        pack_qkv: bool = True,
         processor=None,
         quant_config: "QuantizationConfig | None" = None,
         prefix: str = "",
@@ -591,7 +607,7 @@ class LTX2Attention(torch.nn.Module):
         self.to_q = None
         self.to_k = None
         self.to_v = None
-        if cross_attention_dim is None:
+        if cross_attention_dim is None and pack_qkv:
             self.to_qkv = QKVParallelLinear(
                 hidden_size=query_dim,
                 head_size=self.head_dim,
@@ -847,6 +863,9 @@ class LTX2VideoTransformerBlock(nn.Module):
             qk_norm=qk_norm,
             rope_type=rope_type,
             apply_gated_attention=audio_gated_attn,
+            # The official checkpoint evaluates audio Q/K/V separately. Fusing
+            # the bf16 GEMMs changes denoise numerics enough to accumulate.
+            pack_qkv=False,
             quant_config=quant_config,
             prefix=f"{prefix}.audio_attn1" if prefix else "audio_attn1",
         )
@@ -992,8 +1011,10 @@ class LTX2VideoTransformerBlock(nn.Module):
         v2a_cross_attention_mask: torch.Tensor | None = None,
         use_a2v_cross_attention: bool = True,
         use_v2a_cross_attention: bool = True,
-        perturbation_mask: torch.Tensor | None = None,
-        all_perturbed: bool | None = None,
+        video_self_attention_perturbation_mask: torch.Tensor | None = None,
+        audio_self_attention_perturbation_mask: torch.Tensor | None = None,
+        a2v_cross_attention_perturbation_mask: torch.Tensor | None = None,
+        v2a_cross_attention_perturbation_mask: torch.Tensor | None = None,
     ) -> torch.Tensor:
         batch_size = hidden_states.size(0)
 
@@ -1012,6 +1033,7 @@ class LTX2VideoTransformerBlock(nn.Module):
             encoder_hidden_states=None,
             query_rotary_emb=video_rotary_emb,
             attention_mask=self_attention_mask,
+            perturbation_mask=video_self_attention_perturbation_mask,
         )
         hidden_states = hidden_states + attn_hidden_states * gate_msa
 
@@ -1031,6 +1053,7 @@ class LTX2VideoTransformerBlock(nn.Module):
             encoder_hidden_states=None,
             query_rotary_emb=audio_rotary_emb,
             attention_mask=audio_self_attention_mask,
+            perturbation_mask=audio_self_attention_perturbation_mask,
         )
         audio_hidden_states = audio_hidden_states + attn_audio_hidden_states * audio_gate_msa
 
@@ -1123,6 +1146,8 @@ class LTX2VideoTransformerBlock(nn.Module):
                     key_rotary_emb=ca_audio_rotary_emb,
                     attention_mask=a2v_cross_attention_mask,
                 )
+                if a2v_cross_attention_perturbation_mask is not None:
+                    a2v_attn_hidden_states = a2v_attn_hidden_states * a2v_cross_attention_perturbation_mask
                 hidden_states = hidden_states + a2v_gate * a2v_attn_hidden_states
 
             # 3.3. Video-to-Audio Cross Attention: Q: Audio; K,V: Video
@@ -1141,6 +1166,8 @@ class LTX2VideoTransformerBlock(nn.Module):
                     key_rotary_emb=ca_video_rotary_emb,
                     attention_mask=v2a_cross_attention_mask,
                 )
+                if v2a_cross_attention_perturbation_mask is not None:
+                    v2a_attn_hidden_states = v2a_attn_hidden_states * v2a_cross_attention_perturbation_mask
                 audio_hidden_states = audio_hidden_states + v2a_gate * v2a_attn_hidden_states
 
         # 4. Feedforward
@@ -1345,7 +1372,10 @@ class LTX2AudioVideoRotaryPosEmbed(nn.Module):
             return self.prepare_audio_coords(*args, **kwargs)
 
     def forward(
-        self, coords: torch.Tensor, device: str | torch.device | None = None
+        self,
+        coords: torch.Tensor,
+        device: str | torch.device | None = None,
+        out_dtype: torch.dtype | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         device = device or coords.device
 
@@ -1421,6 +1451,9 @@ class LTX2AudioVideoRotaryPosEmbed(nn.Module):
             cos_freqs = torch.swapaxes(cos_freq, 1, 2)  # (B,H,T,D//2)
             sin_freqs = torch.swapaxes(sin_freq, 1, 2)  # (B,H,T,D//2)
 
+        if out_dtype is not None:
+            cos_freqs = cos_freqs.to(out_dtype)
+            sin_freqs = sin_freqs.to(out_dtype)
         return cos_freqs, sin_freqs
 
 
@@ -1488,8 +1521,11 @@ class LTX2VideoTransformer3DModel(nn.Module):
                 # Shard prompt embeds across sequence
                 "encoder_hidden_states": SequenceParallelInput(split_dim=1, expected_dims=3, split_output=False),
                 "audio_encoder_hidden_states": SequenceParallelInput(split_dim=1, expected_dims=3, split_output=False),
-                # Shard video timestep when provided as (B, seq_len)
+                # Keep per-token video/audio timestep embeddings aligned with
+                # their corresponding latent sequence shards. Official LTX
+                # multi-guidance supplies both tensors as (B, seq_len).
                 "timestep": SequenceParallelInput(split_dim=1, expected_dims=2, split_output=False),
+                "audio_timestep": SequenceParallelInput(split_dim=1, expected_dims=2, split_output=False),
             },
             "rope": {
                 0: SequenceParallelInput(split_dim=rope_split_dim, expected_dims=rope_expected_dims, split_output=True),
@@ -1856,6 +1892,12 @@ class LTX2VideoTransformer3DModel(nn.Module):
         # Determine timestep for audio.
         audio_timestep = audio_timestep if audio_timestep is not None else timestep
 
+        def batch_step(step: torch.Tensor) -> torch.Tensor:
+            return step[:, 0] if step.ndim > 1 else step
+
+        sigma = sigma if sigma is not None else batch_step(timestep)
+        audio_sigma = audio_sigma if audio_sigma is not None else batch_step(audio_timestep)
+
         # convert encoder_attention_mask to a bias the same way we do for attention_mask
         if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
             encoder_attention_mask = (1 - encoder_attention_mask.to(hidden_states.dtype)) * -10000.0
@@ -1877,12 +1919,22 @@ class LTX2VideoTransformer3DModel(nn.Module):
                 batch_size, audio_num_frames, audio_hidden_states.device
             )
 
-        video_rotary_emb = self.rope(video_coords, device=hidden_states.device)
-        audio_rotary_emb = self.audio_rope(audio_coords, device=audio_hidden_states.device)
+        video_rotary_emb = self.rope(video_coords, device=hidden_states.device, out_dtype=hidden_states.dtype)
+        audio_rotary_emb = self.audio_rope(
+            audio_coords,
+            device=audio_hidden_states.device,
+            out_dtype=audio_hidden_states.dtype,
+        )
 
-        video_cross_attn_rotary_emb = self.cross_attn_rope(video_coords[:, 0:1, :], device=hidden_states.device)
+        video_cross_attn_rotary_emb = self.cross_attn_rope(
+            video_coords[:, 0:1, :],
+            device=hidden_states.device,
+            out_dtype=hidden_states.dtype,
+        )
         audio_cross_attn_rotary_emb = self.cross_attn_audio_rope(
-            audio_coords[:, 0:1, :], device=audio_hidden_states.device
+            audio_coords[:, 0:1, :],
+            device=audio_hidden_states.device,
+            out_dtype=audio_hidden_states.dtype,
         )
 
         # 2. Patchify input projections
@@ -1920,7 +1972,7 @@ class LTX2VideoTransformer3DModel(nn.Module):
             hidden_dtype=hidden_states.dtype,
         )
         video_cross_attn_a2v_gate, _ = self.av_cross_attn_video_a2v_gate(
-            timestep.flatten() * timestep_cross_attn_gate_scale_factor,
+            audio_sigma.flatten() * timestep_cross_attn_gate_scale_factor,
             batch_size=batch_size,
             hidden_dtype=hidden_states.dtype,
         )
@@ -1935,7 +1987,7 @@ class LTX2VideoTransformer3DModel(nn.Module):
             hidden_dtype=audio_hidden_states.dtype,
         )
         audio_cross_attn_v2a_gate, _ = self.av_cross_attn_audio_v2a_gate(
-            audio_timestep.flatten() * timestep_cross_attn_gate_scale_factor,
+            sigma.flatten() * timestep_cross_attn_gate_scale_factor,
             batch_size=batch_size,
             hidden_dtype=audio_hidden_states.dtype,
         )
@@ -1945,7 +1997,6 @@ class LTX2VideoTransformer3DModel(nn.Module):
         audio_cross_attn_v2a_gate = audio_cross_attn_v2a_gate.view(batch_size, -1, audio_cross_attn_v2a_gate.shape[-1])
 
         # 3.3. LTX-2.3: Compute prompt modulation from sigma
-        audio_sigma = audio_sigma if audio_sigma is not None else sigma
         if self.prompt_modulation and sigma is not None:
             temb_prompt, _ = self.prompt_adaln(sigma.flatten(), batch_size=batch_size, hidden_dtype=hidden_states.dtype)
             temb_prompt_audio, _ = self.audio_prompt_adaln(
@@ -1967,8 +2018,17 @@ class LTX2VideoTransformer3DModel(nn.Module):
             audio_encoder_hidden_states = self.audio_caption_projection(audio_encoder_hidden_states)
             audio_encoder_hidden_states = audio_encoder_hidden_states.view(batch_size, -1, audio_hidden_states.size(-1))
 
+        perturbation_kwargs = (attention_kwargs or {}).get("ltx_perturbation_kwargs", {})
+
+        def perturbation_mask_for(name: str, block_idx: int) -> torch.Tensor | None:
+            mask = perturbation_kwargs.get(f"{name}_mask")
+            blocks = perturbation_kwargs.get(f"{name}_blocks")
+            if mask is None or (blocks is not None and block_idx not in blocks):
+                return None
+            return mask
+
         # 5. Run transformer blocks
-        for block in self.transformer_blocks:
+        for block_idx, block in enumerate(self.transformer_blocks):
             block_kwargs = {
                 "temb": temb,
                 "temb_audio": temb_audio,
@@ -1984,6 +2044,10 @@ class LTX2VideoTransformer3DModel(nn.Module):
                 "ca_audio_rotary_emb": audio_cross_attn_rotary_emb,
                 "encoder_attention_mask": encoder_attention_mask,
                 "audio_encoder_attention_mask": audio_encoder_attention_mask,
+                "video_self_attention_perturbation_mask": perturbation_mask_for("video_self_attention", block_idx),
+                "audio_self_attention_perturbation_mask": perturbation_mask_for("audio_self_attention", block_idx),
+                "a2v_cross_attention_perturbation_mask": perturbation_mask_for("a2v_cross_attention", block_idx),
+                "v2a_cross_attention_perturbation_mask": perturbation_mask_for("v2a_cross_attention", block_idx),
             }
             # NOTE: We intentionally pass the first 4 args here positionally,
             # because CacheDiT expects the first 2 args to be hidden_states
@@ -2066,7 +2130,10 @@ class LTX2VideoTransformer3DModel(nn.Module):
             for param_name, weight_name, shard_id in stacked_params_mapping:
                 if weight_name not in name:
                     continue
-                name = name.replace(weight_name, param_name)
+                packed_name = name.replace(weight_name, param_name)
+                if packed_name not in params_dict:
+                    continue
+                name = packed_name
                 param = params_dict[name]
                 weight_loader = param.weight_loader
                 weight_loader(param, loaded_weight, shard_id)
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2.py
index bce0813e9..ff66af5e1 100644
--- a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2.py
+++ b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2.py
@@ -1,1320 +1,59 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+"""One-stage entry points for the LTX model family."""
+
 from __future__ import annotations
 
-import copy
-import inspect
-import json
-import os
-from collections.abc import Iterable
-from contextlib import nullcontext
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import ClassVar
 
-import numpy as np
-import torch
-
-if TYPE_CHECKING:
-    from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
-from diffusers import AutoencoderKLLTX2Audio, AutoencoderKLLTX2Video, FlowMatchEulerDiscreteScheduler
-from diffusers.pipelines.ltx2 import LTX2TextConnectors
-from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
-from diffusers.pipelines.ltx2.vocoder import LTX2Vocoder
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import rescale_noise_cfg, retrieve_timesteps
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from torch import nn
-from transformers import AutoTokenizer, Gemma3ForConditionalGeneration
-from vllm.logger import init_logger
-from vllm.model_executor.models.utils import AutoWeightsLoader
-
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
-from vllm_omni.diffusion.distributed.parallel_state import (
-    get_classifier_free_guidance_world_size,
-)
-from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.lora.manager import DiffusionLoRAManager
-from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
-from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
+from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
-from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
-from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
-from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-from vllm_omni.lora.request import LoRARequest
 
-from .ltx2_transformer import LTX2VideoTransformer3DModel
-from .pipeline_ltx2_latent_upsample import LTX2LatentUpsamplePipeline
-
-logger = init_logger(__name__)
-
-
-def load_transformer_config(model_path: str, subfolder: str = "transformer", local_files_only: bool = True) -> dict:
-    """Load transformer config from model directory or HF Hub."""
-    if local_files_only:
-        config_path = os.path.join(model_path, subfolder, "config.json")
-        if os.path.exists(config_path):
-            with open(config_path) as f:
-                return json.load(f)
-    else:
-        try:
-            from huggingface_hub import hf_hub_download
-
-            config_path = hf_hub_download(
-                repo_id=model_path,
-                filename=f"{subfolder}/config.json",
-            )
-            with open(config_path) as f:
-                return json.load(f)
-        except Exception:
-            pass
-    return {}
-
-
-def create_transformer_from_config(
-    config: dict,
-    quant_config: QuantizationConfig | None = None,
-) -> LTX2VideoTransformer3DModel:
-    """Create LTX2VideoTransformer3DModel from config dict."""
-    if not config and quant_config is None:
-        return LTX2VideoTransformer3DModel()
-
-    signature = inspect.signature(LTX2VideoTransformer3DModel.__init__)
-    allowed_keys = set(signature.parameters.keys())
-    kwargs = {k: v for k, v in config.items() if k in allowed_keys}
-    if quant_config is not None:
-        kwargs["quant_config"] = quant_config
-
-    return LTX2VideoTransformer3DModel(**kwargs)
-
-
-def get_ltx2_post_process_func(
-    od_config: OmniDiffusionConfig,
-):
-    def post_process_func(output: tuple[torch.Tensor, torch.Tensor] | torch.Tensor):
-        if isinstance(output, tuple) and len(output) == 2:
-            video, audio = output
-            if isinstance(audio, torch.Tensor):
-                audio = audio.detach().cpu()
-            return {"video": video, "audio": audio}
-        return output
-
-    return post_process_func
-
-
-def _unwrap_request_tensor(value: Any) -> Any:
-    if isinstance(value, list):
-        return value[0] if value else None
-    return value
-
-
-def _get_prompt_field(prompt: Any, key: str) -> Any:
-    if isinstance(prompt, str):
-        return None
-    value = prompt.get(key)
-    if value is None:
-        additional = prompt.get("additional_information")
-        if isinstance(additional, dict):
-            value = additional.get(key)
-    return _unwrap_request_tensor(value)
-
-
-def calculate_shift(
-    image_seq_len,
-    base_seq_len: int = 256,
-    max_seq_len: int = 4096,
-    base_shift: float = 0.5,
-    max_shift: float = 1.15,
-):
-    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
-    b = base_shift - m * base_seq_len
-    mu = image_seq_len * m + b
-    return mu
-
-
-class _VideoAudioScheduler:
-    """Composite scheduler dispatching to video and audio schedulers."""
-
-    def __init__(self, video_scheduler, audio_scheduler):
-        self.video_scheduler = video_scheduler
-        self.audio_scheduler = audio_scheduler
-
-    def step(self, noise_pred, t, latents, return_dict=False, generator=None):
-        video_out = self.video_scheduler.step(
-            noise_pred[0],
-            t[0],
-            latents[0],
-            return_dict=False,
-            generator=generator,
-        )[0]
-        audio_out = self.audio_scheduler.step(
-            noise_pred[1],
-            t[1],
-            latents[1],
-            return_dict=False,
-            generator=generator,
-        )[0]
-        return ((video_out, audio_out),)
-
-
-class LTX2Pipeline(nn.Module, CFGParallelMixin, ProgressBarMixin, SupportsComponentDiscovery):
-    supports_request_batch = False
-
-    _dit_modules: ClassVar[list[str]] = ["transformer"]
-    _encoder_modules: ClassVar[list[str]] = ["text_encoder"]
-    _vae_modules: ClassVar[list[str]] = ["vae", "audio_vae"]
-
-    # Audio is diffused jointly with video; warmup must size audio tokens.
-    dummy_run_num_frames = 2
-
-    def __init__(
-        self,
-        *,
-        od_config: OmniDiffusionConfig,
-        prefix: str = "",
-    ):
-        super().__init__()
-        self.od_config = od_config
-
-        self.device = get_local_device()
-        dtype = getattr(od_config, "dtype", torch.bfloat16)
-
-        model = od_config.model
-        local_files_only = os.path.exists(model)
-
-        self.weights_sources = [
-            DiffusersPipelineLoader.ComponentSource(
-                model_or_path=od_config.model,
-                subfolder="transformer",
-                revision=None,
-                prefix="transformer.",
-                fall_back_to_pt=True,
-            ),
-        ]
-
-        # See ``hub_prefetch.py`` for the transformers v5 multi-worker subfolder
-        # race; prefetch the whole component set before any from_pretrained.
-        ltx2_subfolders = [
-            "tokenizer",
-            "text_encoder",
-            "connectors",
-            "vae",
-            "audio_vae",
-            "vocoder",
-            "scheduler",
-        ]
-        prefetch_subfolders(model, ltx2_subfolders, local_files_only=local_files_only)
-
-        self.tokenizer = AutoTokenizer.from_pretrained(
-            model,
-            subfolder="tokenizer",
-            local_files_only=local_files_only,
-        )
-        # prefer mmap loading as default device is cuda, and the output of text encoder
-        # could be deterministic.
-        with torch.device("cpu"):
-            self.text_encoder = from_pretrained_with_prefetch(
-                Gemma3ForConditionalGeneration.from_pretrained,
-                model,
-                subfolder="text_encoder",
-                prefetch_list=ltx2_subfolders,
-                local_files_only=local_files_only,
-                torch_dtype=dtype,
-            ).to(self.device)
-        self.connectors = from_pretrained_with_prefetch(
-            LTX2TextConnectors.from_pretrained,
-            model,
-            subfolder="connectors",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        ).to(self.device)
-
-        self.vae = from_pretrained_with_prefetch(
-            AutoencoderKLLTX2Video.from_pretrained,
-            model,
-            subfolder="vae",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        ).to(self.device)
-        self.audio_vae = from_pretrained_with_prefetch(
-            AutoencoderKLLTX2Audio.from_pretrained,
-            model,
-            subfolder="audio_vae",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        ).to(self.device)
-        self.vocoder = from_pretrained_with_prefetch(
-            LTX2Vocoder.from_pretrained,
-            model,
-            subfolder="vocoder",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        ).to(self.device)
-
-        transformer_config = load_transformer_config(model, "transformer", local_files_only)
-        quant_config = getattr(self.od_config, "quantization_config", None)
-        self.transformer = create_transformer_from_config(transformer_config, quant_config=quant_config)
-
-        self.scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
-            model, subfolder="scheduler", local_files_only=local_files_only
-        )
-
-        self.vae_spatial_compression_ratio = (
-            self.vae.spatial_compression_ratio if getattr(self, "vae", None) is not None else 32
-        )
-        self.vae_temporal_compression_ratio = (
-            self.vae.temporal_compression_ratio if getattr(self, "vae", None) is not None else 8
-        )
-        self.audio_vae_mel_compression_ratio = (
-            self.audio_vae.mel_compression_ratio if getattr(self, "audio_vae", None) is not None else 4
-        )
-        self.audio_vae_temporal_compression_ratio = (
-            self.audio_vae.temporal_compression_ratio if getattr(self, "audio_vae", None) is not None else 4
-        )
-        self.transformer_spatial_patch_size = (
-            self.transformer.config.patch_size if getattr(self, "transformer", None) is not None else 1
-        )
-        self.transformer_temporal_patch_size = (
-            self.transformer.config.patch_size_t if getattr(self, "transformer", None) is not None else 1
-        )
-
-        self.audio_sampling_rate = (
-            self.audio_vae.config.sample_rate if getattr(self, "audio_vae", None) is not None else 16000
-        )
-        self.audio_hop_length = (
-            self.audio_vae.config.mel_hop_length if getattr(self, "audio_vae", None) is not None else 160
-        )
-
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_spatial_compression_ratio)
-        tokenizer_max_length = 1024
-        if getattr(self, "tokenizer", None) is not None:
-            tokenizer_max_length = self.tokenizer.model_max_length
-            if tokenizer_max_length is None or tokenizer_max_length > 100000:
-                encoder_config = getattr(self.text_encoder, "config", None)
-                config_max_len = getattr(encoder_config, "max_position_embeddings", None)
-                if config_max_len is None:
-                    config_max_len = getattr(encoder_config, "max_seq_len", None)
-                tokenizer_max_length = config_max_len or 1024
-        self.tokenizer_max_length = int(tokenizer_max_length)
-
-        self._guidance_scale = None
-        self._guidance_rescale = None
-        self._attention_kwargs = None
-        self._interrupt = False
-        self._num_timesteps = None
-        self._current_timestep = None
-
-    def _get_gemma_prompt_embeds(
-        self,
-        prompt: str | list[str],
-        num_videos_per_prompt: int = 1,
-        max_sequence_length: int = 1024,
-        scale_factor: int = 8,
-        device: torch.device | None = None,
-        dtype: torch.dtype | None = None,
-    ):
-        device = device or self.device
-        dtype = dtype or self.text_encoder.dtype
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        batch_size = len(prompt)
-
-        if getattr(self, "tokenizer", None) is not None:
-            self.tokenizer.padding_side = "left"
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-
-        prompt = [p.strip() for p in prompt]
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=max_sequence_length,
-            truncation=True,
-            add_special_tokens=True,
-            return_tensors="pt",
-        )
-        text_input_ids = text_inputs.input_ids
-        prompt_attention_mask = text_inputs.attention_mask
-        text_input_ids = text_input_ids.to(device)
-        prompt_attention_mask = prompt_attention_mask.to(device)
-
-        text_encoder_outputs = self.text_encoder(
-            input_ids=text_input_ids, attention_mask=prompt_attention_mask, output_hidden_states=True
-        )
-        text_encoder_hidden_states = text_encoder_outputs.hidden_states
-        text_encoder_hidden_states = torch.stack(text_encoder_hidden_states, dim=-1)
-        # `diffusers>=0.38` moved per_layer_masked_mean_norm inside the connector,
-        # so pack to 3D here and let the connector handle normalization.
-        prompt_embeds = text_encoder_hidden_states.flatten(2, 3).to(dtype=dtype)
-
-        _, seq_len, _ = prompt_embeds.shape
-        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
-
-        prompt_attention_mask = prompt_attention_mask.view(batch_size, -1)
-        prompt_attention_mask = prompt_attention_mask.repeat(num_videos_per_prompt, 1)
-
-        return prompt_embeds, prompt_attention_mask
-
-    def encode_prompt(
-        self,
-        prompt: str | list[str],
-        negative_prompt: str | list[str] | None = None,
-        do_classifier_free_guidance: bool = True,
-        num_videos_per_prompt: int = 1,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        max_sequence_length: int = 1024,
-        scale_factor: int = 8,
-        device: torch.device | None = None,
-        dtype: torch.dtype | None = None,
-    ):
-        device = device or self.device
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        if prompt is not None:
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        if prompt_embeds is None:
-            prompt_embeds, prompt_attention_mask = self._get_gemma_prompt_embeds(
-                prompt=prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                scale_factor=scale_factor,
-                device=device,
-                dtype=dtype,
-            )
-
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            negative_prompt = negative_prompt or ""
-            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
-
-            if prompt is not None and type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-
-            negative_prompt_embeds, negative_prompt_attention_mask = self._get_gemma_prompt_embeds(
-                prompt=negative_prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                scale_factor=scale_factor,
-                device=device,
-                dtype=dtype,
-            )
-
-        return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask
-
-    def check_inputs(
-        self,
-        prompt,
-        height,
-        width,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        if height % 32 != 0 or width % 32 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.")
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if prompt_embeds is not None and prompt_attention_mask is None:
-            raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.")
-
-        if negative_prompt_embeds is not None and negative_prompt_attention_mask is None:
-            raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.")
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
-                raise ValueError(
-                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when "
-                    "passed directly, but got: `prompt_attention_mask` "
-                    f"{prompt_attention_mask.shape} != `negative_prompt_attention_mask` "
-                    f"{negative_prompt_attention_mask.shape}."
-                )
-
-    @staticmethod
-    def _pack_latents(latents: torch.Tensor, patch_size: int = 1, patch_size_t: int = 1) -> torch.Tensor:
-        batch_size, num_channels, num_frames, height, width = latents.shape
-        post_patch_num_frames = num_frames // patch_size_t
-        post_patch_height = height // patch_size
-        post_patch_width = width // patch_size
-        latents = latents.reshape(
-            batch_size,
-            -1,
-            post_patch_num_frames,
-            patch_size_t,
-            post_patch_height,
-            patch_size,
-            post_patch_width,
-            patch_size,
-        )
-        latents = latents.permute(0, 2, 4, 6, 1, 3, 5, 7).flatten(4, 7).flatten(1, 3)
-        return latents
-
-    @staticmethod
-    def _unpack_latents(
-        latents: torch.Tensor, num_frames: int, height: int, width: int, patch_size: int = 1, patch_size_t: int = 1
-    ) -> torch.Tensor:
-        batch_size = latents.size(0)
-        latents = latents.reshape(batch_size, num_frames, height, width, -1, patch_size_t, patch_size, patch_size)
-        latents = latents.permute(0, 4, 1, 5, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(2, 3)
-        return latents
-
-    @staticmethod
-    def _normalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        # Normalize latents across the channel dimension [B, C, F, H, W]
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = (latents - latents_mean) * scaling_factor / latents_std
-        return latents
-
-    @staticmethod
-    def _normalize_audio_latents(latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor):
-        latents_mean = latents_mean.to(latents.device, latents.dtype)
-        latents_std = latents_std.to(latents.device, latents.dtype)
-        return (latents - latents_mean) / latents_std
-
-    @staticmethod
-    def _denormalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = latents * latents_std / scaling_factor + latents_mean
-        return latents
-
-    @staticmethod
-    def _denormalize_audio_latents(latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor):
-        latents_mean = latents_mean.to(latents.device, latents.dtype)
-        latents_std = latents_std.to(latents.device, latents.dtype)
-        return (latents * latents_std) + latents_mean
-
-    @staticmethod
-    def _create_noised_state(
-        latents: torch.Tensor, noise_scale: float | torch.Tensor, generator: torch.Generator | None = None
-    ):
-        noise = randn_tensor(latents.shape, generator=generator, device=latents.device, dtype=latents.dtype)
-        noised_latents = noise_scale * noise + (1 - noise_scale) * latents
-        return noised_latents
-
-    @staticmethod
-    def _pack_audio_latents(
-        latents: torch.Tensor, patch_size: int | None = None, patch_size_t: int | None = None
-    ) -> torch.Tensor:
-        if patch_size is not None and patch_size_t is not None:
-            batch_size, num_channels, latent_length, latent_mel_bins = latents.shape
-            post_patch_latent_length = latent_length / patch_size_t
-            post_patch_mel_bins = latent_mel_bins / patch_size
-            latents = latents.reshape(
-                batch_size, -1, post_patch_latent_length, patch_size_t, post_patch_mel_bins, patch_size
-            )
-            latents = latents.permute(0, 2, 4, 1, 3, 5).flatten(3, 5).flatten(1, 2)
-        else:
-            latents = latents.transpose(1, 2).flatten(2, 3)
-        return latents
-
-    @staticmethod
-    def _unpack_audio_latents(
-        latents: torch.Tensor,
-        latent_length: int,
-        num_mel_bins: int,
-        patch_size: int | None = None,
-        patch_size_t: int | None = None,
-    ) -> torch.Tensor:
-        if patch_size is not None and patch_size_t is not None:
-            batch_size = latents.size(0)
-            latents = latents.reshape(batch_size, latent_length, num_mel_bins, -1, patch_size_t, patch_size)
-            latents = latents.permute(0, 3, 1, 4, 2, 5).flatten(4, 5).flatten(2, 3)
-        else:
-            latents = latents.unflatten(2, (-1, num_mel_bins)).transpose(1, 2)
-        return latents
-
-    @staticmethod
-    def _unpad_audio_latents(latents: torch.Tensor, num_frames: int) -> torch.Tensor:
-        return latents[:, :num_frames]
-
-    def prepare_latents(
-        self,
-        batch_size: int = 1,
-        num_channels_latents: int = 128,
-        height: int = 512,
-        width: int = 768,
-        num_frames: int = 121,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> torch.Tensor:
-        if latents is not None:
-            if latents.ndim == 5:
-                latents = self._normalize_latents(
-                    latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-                )
-                # latents are of shape [B, C, F, H, W], need to be packed
-                latents = self._pack_latents(
-                    latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-                )
-            if latents.ndim != 3:
-                raise ValueError(
-                    f"Provided `latents` tensor has shape {latents.shape}, but the expected shape is [batch_size, num_seq, num_features]."  # noqa
-                )
-            latents = self._create_noised_state(latents, noise_scale, generator)
-            return latents.to(device=device, dtype=dtype)
-
-        height = height // self.vae_spatial_compression_ratio
-        width = width // self.vae_spatial_compression_ratio
-        num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-
-        shape = (batch_size, num_channels_latents, num_frames, height, width)
-
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = self._pack_latents(latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size)
-
-        return latents
-
-    def prepare_audio_latents(
-        self,
-        batch_size: int = 1,
-        num_channels_latents: int = 8,
-        audio_latent_length: int = 1,  # 1 is just a dummy value
-        num_mel_bins: int = 64,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, int, int]:
-        original_latent_length = audio_latent_length
-        padded_latent_length = original_latent_length
-
-        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
-
-        sp_size = getattr(self.od_config.parallel_config, "sequence_parallel_size", 1)
-        if sp_size > 1:
-            padded_latent_length += (sp_size - (original_latent_length % sp_size)) % sp_size
-
-        if latents is not None:
-            if latents.ndim == 4:
-                # latents are of shape [B, C, L, M], need to be packed
-                latents = self._pack_audio_latents(latents)
-            if latents.ndim != 3:
-                raise ValueError(
-                    f"Provided `latents` tensor has shape {latents.shape}, but the expected shape is "
-                    "[batch_size, num_seq, num_features] or [batch_size, num_channels, audio_length, mel_bins]."
-                )
-            latents = self._normalize_audio_latents(latents, self.audio_vae.latents_mean, self.audio_vae.latents_std)
-            latents = self._create_noised_state(latents, noise_scale, generator)
-
-            if latents.shape[1] not in {original_latent_length, padded_latent_length}:
-                raise ValueError(
-                    "Provided `audio_latents` has incompatible audio frame count "
-                    f"{latents.shape[1]}; expected {original_latent_length} or {padded_latent_length}."
-                )
-
-            if latents.shape[1] == original_latent_length and padded_latent_length > original_latent_length:
-                padding = torch.zeros(
-                    latents.shape[0],
-                    padded_latent_length - original_latent_length,
-                    latents.shape[2],
-                    dtype=latents.dtype,
-                    device=latents.device,
-                )
-                latents = torch.cat([latents, padding], dim=1)
-
-            return latents.to(device=device, dtype=dtype), original_latent_length, padded_latent_length
-
-        shape = (batch_size, num_channels_latents, padded_latent_length, latent_mel_bins)
-
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = self._pack_audio_latents(latents)
-        return latents, original_latent_length, padded_latent_length
-
-    @property
-    def guidance_scale(self):
-        return self._guidance_scale
-
-    @property
-    def guidance_rescale(self):
-        return self._guidance_rescale
-
-    @property
-    def do_classifier_free_guidance(self):
-        return self._guidance_scale > 1.0
-
-    @property
-    def num_timesteps(self):
-        return self._num_timesteps
-
-    @property
-    def current_timestep(self):
-        return self._current_timestep
-
-    @property
-    def attention_kwargs(self):
-        return self._attention_kwargs
-
-    @property
-    def interrupt(self):
-        return self._interrupt
-
-    def _transformer_cache_context(self, context_name: str):
-        cache_context = getattr(self.transformer, "cache_context", None)
-        if callable(cache_context):
-            return cache_context(context_name)
-        return nullcontext()
-
-    def predict_noise(self, **kwargs):
-        with self._transformer_cache_context("cond_uncond"):
-            noise_pred_video, noise_pred_audio = self.transformer(**kwargs)
-        return noise_pred_video.float(), noise_pred_audio.float()
-
-    def combine_cfg_noise(self, positive_noise_pred, negative_noise_pred, true_cfg_scale, cfg_normalize=False):
-        """Per-element CFG combine with guidance_rescale support."""
-        (video_pos, audio_pos) = positive_noise_pred
-        (video_neg, audio_neg) = negative_noise_pred
-        video_combined = super().combine_cfg_noise(video_pos, video_neg, true_cfg_scale, cfg_normalize)
-        audio_combined = super().combine_cfg_noise(audio_pos, audio_neg, true_cfg_scale, cfg_normalize)
-        if self._guidance_rescale and self._guidance_rescale > 0:
-            video_combined = rescale_noise_cfg(video_combined, video_pos, guidance_rescale=self._guidance_rescale)
-            audio_combined = rescale_noise_cfg(audio_combined, audio_pos, guidance_rescale=self._guidance_rescale)
-        return (video_combined, audio_combined)
-
-    def _synchronize_cfg_parallel_step_output(
-        self,
-        latents: tuple[torch.Tensor, torch.Tensor],
-        do_true_cfg: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        if not (do_true_cfg and get_classifier_free_guidance_world_size() > 1):
-            return latents
-
-        # Without this sync, CUDA async execution causes non-deterministic
-        # numerical drift across denoising steps in CFG parallel mode,
-        # producing different video outputs across runs.
-        latents = tuple(tensor.contiguous() for tensor in latents)
-        device = next((tensor.device for tensor in latents if tensor.is_cuda), None)
-        if device is not None:
-            torch.cuda.current_stream(device).synchronize()
-        return latents
-
-    @torch.no_grad()
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        sigmas: list[float] | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        guidance_rescale: float = 0.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> DiffusionOutput:
-        # Extract prompt/negative_prompt from request.
-        # Input format: req.prompts is a list of str or dict with "prompt"/"negative_prompt" keys.
-        prompt = [p if isinstance(p, str) else (p.get("prompt") or "") for p in req.prompts] or prompt
-        if all(isinstance(p, str) or p.get("negative_prompt") is None for p in req.prompts):
-            negative_prompt = None
-        elif req.prompts:
-            negative_prompt = ["" if isinstance(p, str) else (p.get("negative_prompt") or "") for p in req.prompts]
-
-        height = req.sampling_params.height or height or 512
-        width = req.sampling_params.width or width or 768
-        num_frames = req.sampling_params.num_frames or num_frames or 121
-        frame_rate = req.sampling_params.resolved_frame_rate or frame_rate or 24.0
-        num_inference_steps = req.sampling_params.num_inference_steps or num_inference_steps or 40
-        if timesteps is None:
-            num_inference_steps = max(int(num_inference_steps), 2)
-        elif len(timesteps) < 2:
-            raise ValueError("`timesteps` must contain at least 2 values for FlowMatchEulerDiscreteScheduler.")
-        num_videos_per_prompt = (
-            req.sampling_params.num_outputs_per_prompt
-            if req.sampling_params.num_outputs_per_prompt > 0
-            else num_videos_per_prompt or 1
-        )
-        max_sequence_length = (
-            req.sampling_params.max_sequence_length or max_sequence_length or self.tokenizer_max_length
-        )
-
-        if req.sampling_params.guidance_scale_provided:
-            guidance_scale = req.sampling_params.guidance_scale
-        if req.sampling_params.guidance_rescale is not None:
-            guidance_rescale = req.sampling_params.guidance_rescale
-
-        if generator is None:
-            generator = req.sampling_params.generator
-        if generator is None and req.sampling_params.seed is not None:
-            generator = torch.Generator(device=self.device).manual_seed(req.sampling_params.seed)
-
-        latents = req.sampling_params.latents if req.sampling_params.latents is not None else latents
-        audio_latents = (
-            req.sampling_params.audio_latents
-            if req.sampling_params.audio_latents is not None
-            else req.sampling_params.extra_args.get("audio_latents", audio_latents)
-        )
-
-        # Override with pre-computed embeddings if provided in request.
-        req_prompt_embeds = [_get_prompt_field(p, "prompt_embeds") for p in req.prompts]
-        if any(p is not None for p in req_prompt_embeds):
-            prompt_embeds = torch.stack(req_prompt_embeds)  # type: ignore[arg-type]
-
-        req_negative_prompt_embeds = [_get_prompt_field(p, "negative_prompt_embeds") for p in req.prompts]
-        if any(p is not None for p in req_negative_prompt_embeds):
-            negative_prompt_embeds = torch.stack(req_negative_prompt_embeds)  # type: ignore[arg-type]
-
-        req_prompt_attention_masks = [
-            _get_prompt_field(p, "prompt_attention_mask") or _get_prompt_field(p, "attention_mask") for p in req.prompts
-        ]
-        if any(m is not None for m in req_prompt_attention_masks):
-            prompt_attention_mask = torch.stack(req_prompt_attention_masks)  # type: ignore[arg-type]
-
-        req_negative_attention_masks = [
-            _get_prompt_field(p, "negative_prompt_attention_mask") or _get_prompt_field(p, "negative_attention_mask")
-            for p in req.prompts
-        ]
-        if any(m is not None for m in req_negative_attention_masks):
-            negative_prompt_attention_mask = torch.stack(req_negative_attention_masks)  # type: ignore[arg-type]
-
-        if req.sampling_params.decode_timestep is not None:
-            decode_timestep = req.sampling_params.decode_timestep
-        if req.sampling_params.decode_noise_scale is not None:
-            decode_noise_scale = req.sampling_params.decode_noise_scale
-        if req.sampling_params.output_type is not None:
-            output_type = req.sampling_params.output_type
-
-        self.check_inputs(
-            prompt=prompt,
-            height=height,
-            width=width,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-        )
-
-        self._guidance_scale = guidance_scale
-        self._guidance_rescale = guidance_rescale
-        self._attention_kwargs = attention_kwargs
-        self._interrupt = False
-        self._current_timestep = None
-
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        device = self.device
-
-        (
-            prompt_embeds,
-            prompt_attention_mask,
-            negative_prompt_embeds,
-            negative_prompt_attention_mask,
-        ) = self.encode_prompt(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            do_classifier_free_guidance=self.do_classifier_free_guidance,
-            num_videos_per_prompt=num_videos_per_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            max_sequence_length=max_sequence_length,
-            device=device,
-        )
-        # Compute positive prompt connectors
-        tokenizer_padding_side = getattr(self.tokenizer, "padding_side", "left")
-        connector_prompt_embeds, connector_audio_prompt_embeds, connector_attention_mask = self.connectors(
-            prompt_embeds, prompt_attention_mask, padding_side=tokenizer_padding_side
-        )
-
-        # Compute negative prompt connectors when CFG is enabled
-        negative_connector_prompt_embeds = None
-        negative_connector_audio_prompt_embeds = None
-        negative_connector_attention_mask = None
-        if self.do_classifier_free_guidance:
-            (
-                negative_connector_prompt_embeds,
-                negative_connector_audio_prompt_embeds,
-                negative_connector_attention_mask,
-            ) = self.connectors(
-                negative_prompt_embeds,
-                negative_prompt_attention_mask,
-                padding_side=tokenizer_padding_side,
-            )
-
-        latent_num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-        latent_height = height // self.vae_spatial_compression_ratio
-        latent_width = width // self.vae_spatial_compression_ratio
-        if latents is not None:
-            if latents.ndim == 5:
-                logger.info(
-                    "Got latents of shape [batch_size, latent_dim, latent_frames, latent_height, latent_width], `latent_num_frames`, `latent_height`, `latent_width` will be inferred."  # noqa
-                )
-                _, _, latent_num_frames, latent_height, latent_width = latents.shape  # [B, C, F, H, W]
-            elif latents.ndim == 3:
-                logger.warning(
-                    f"You have supplied packed `latents` of shape {latents.shape}, so the latent dims cannot be"
-                    f" inferred. Make sure the supplied `height`, `width`, and `num_frames` are correct."
-                )
-            else:
-                raise ValueError(
-                    f"Provided `latents` tensor has shape {latents.shape}, but the expected shape is either [batch_size, seq_len, num_features] or [batch_size, latent_dim, latent_frames, latent_height, latent_width]."  # noqa
-                )
-        video_sequence_length = latent_num_frames * latent_height * latent_width
-
-        num_channels_latents = self.transformer.config.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            num_frames,
-            noise_scale,
-            torch.float32,
-            device,
-            generator,
-            latents,
-        )
-
-        duration_s = num_frames / frame_rate
-        audio_latents_per_second = (
-            self.audio_sampling_rate / self.audio_hop_length / float(self.audio_vae_temporal_compression_ratio)
-        )
-        audio_num_frames = round(duration_s * audio_latents_per_second)
-        if audio_latents is not None:
-            if audio_latents.ndim == 4:
-                logger.info(
-                    "Got audio_latents of shape [batch_size, num_channels, audio_length, mel_bins], `audio_num_frames` will be inferred."  # noqa
-                )
-                _, _, audio_num_frames, _ = audio_latents.shape  # [B, C, L, M]
-            elif audio_latents.ndim == 3:
-                logger.warning(
-                    f"You have supplied packed `audio_latents` of shape {audio_latents.shape}, so the latent dims"
-                    f" cannot be inferred. Make sure the supplied `num_frames` and `frame_rate` are correct."
-                )
-            else:
-                raise ValueError(
-                    f"Provided `audio_latents` tensor has shape {audio_latents.shape}, but the expected shape is either [batch_size, seq_len, num_features] or [batch_size, num_channels, audio_length, mel_bins]."  # noqa
-                )
-
-        num_mel_bins = self.audio_vae.config.mel_bins if getattr(self, "audio_vae", None) is not None else 64
-        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
-
-        num_channels_latents_audio = (
-            self.audio_vae.config.latent_channels if getattr(self, "audio_vae", None) is not None else 8
-        )
-        audio_latents, original_audio_num_frames, padded_audio_num_frames = self.prepare_audio_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents=num_channels_latents_audio,
-            audio_latent_length=audio_num_frames,
-            num_mel_bins=num_mel_bins,
-            noise_scale=noise_scale,
-            dtype=torch.float32,
-            device=device,
-            generator=generator,
-            latents=audio_latents,
-        )
-
-        sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas
-        mu = calculate_shift(
-            video_sequence_length,
-            self.scheduler.config.get("base_image_seq_len", 1024),
-            self.scheduler.config.get("max_image_seq_len", 4096),
-            self.scheduler.config.get("base_shift", 0.95),
-            self.scheduler.config.get("max_shift", 2.05),
-        )
-        audio_scheduler = copy.deepcopy(self.scheduler)
-        video_audio_scheduler = _VideoAudioScheduler(self.scheduler, audio_scheduler)
-        _ = retrieve_timesteps(
-            audio_scheduler,
-            num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        timesteps, num_inference_steps = retrieve_timesteps(
-            self.scheduler,
-            num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        self._num_timesteps = len(timesteps)
-
-        video_coords = self.transformer.rope.prepare_video_coords(
-            latents.shape[0], latent_num_frames, latent_height, latent_width, latents.device, fps=frame_rate
-        )
-        audio_coords = self.transformer.audio_rope.prepare_audio_coords(
-            audio_latents.shape[0], padded_audio_num_frames, audio_latents.device
-        )
-        # No coord duplication needed: mixin handles CFG via separate forward calls,
-        # not batch=2. Each forward gets batch=1 coords directly.
-
-        with self.progress_bar(total=len(timesteps)) as pbar:
-            for i, t in enumerate(timesteps):
-                if self.interrupt:
-                    continue
-
-                self._current_timestep = t
-
-                latent_model_input = latents.to(prompt_embeds.dtype)
-                audio_latent_model_input = audio_latents.to(prompt_embeds.dtype)
-                timestep = t.expand(latent_model_input.shape[0])
-                do_true_cfg = self.do_classifier_free_guidance
-
-                positive_kwargs = {
-                    "hidden_states": latent_model_input,
-                    "audio_hidden_states": audio_latent_model_input,
-                    "encoder_hidden_states": connector_prompt_embeds,
-                    "audio_encoder_hidden_states": connector_audio_prompt_embeds,
-                    "timestep": timestep,
-                    "encoder_attention_mask": connector_attention_mask,
-                    "audio_encoder_attention_mask": connector_attention_mask,
-                    "num_frames": latent_num_frames,
-                    "height": latent_height,
-                    "width": latent_width,
-                    "fps": frame_rate,
-                    "audio_num_frames": padded_audio_num_frames,
-                    "video_coords": video_coords,
-                    "audio_coords": audio_coords,
-                    "attention_kwargs": attention_kwargs,
-                    "return_dict": False,
-                }
-                negative_kwargs = (
-                    {
-                        **positive_kwargs,
-                        "encoder_hidden_states": negative_connector_prompt_embeds,
-                        "audio_encoder_hidden_states": negative_connector_audio_prompt_embeds,
-                        "encoder_attention_mask": negative_connector_attention_mask,
-                        "audio_encoder_attention_mask": negative_connector_attention_mask,
-                    }
-                    if do_true_cfg
-                    else None
-                )
-
-                noise_pred_video, noise_pred_audio = self.predict_noise_maybe_with_cfg(
-                    do_true_cfg=do_true_cfg,
-                    true_cfg_scale=guidance_scale,
-                    positive_kwargs=positive_kwargs,
-                    negative_kwargs=negative_kwargs,
-                    cfg_normalize=False,
-                )
-
-                latents, audio_latents = self.scheduler_step_maybe_with_cfg(
-                    (noise_pred_video, noise_pred_audio),
-                    (t, t),
-                    (latents, audio_latents),
-                    do_true_cfg=do_true_cfg,
-                    per_request_scheduler=video_audio_scheduler,
-                )
-                latents, audio_latents = self._synchronize_cfg_parallel_step_output(
-                    (latents, audio_latents),
-                    do_true_cfg=do_true_cfg,
-                )
-
-                pbar.update()
-
-        latents = self._unpack_latents(
-            latents,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        )
-        latents = self._denormalize_latents(
-            latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-        )
-
-        audio_latents = self._unpad_audio_latents(audio_latents, original_audio_num_frames)
-        audio_latents = self._denormalize_audio_latents(
-            audio_latents, self.audio_vae.latents_mean, self.audio_vae.latents_std
-        )
-        audio_latents = self._unpack_audio_latents(
-            audio_latents,
-            original_audio_num_frames,
-            num_mel_bins=latent_mel_bins,
-        )
-
-        if output_type == "latent":
-            video = latents
-            audio = audio_latents
-        else:
-            latents = latents.to(prompt_embeds.dtype)
-
-            if not self.vae.config.timestep_conditioning:
-                timestep = None
-            else:
-                noise = randn_tensor(latents.shape, generator=generator, device=device, dtype=latents.dtype)
-                if not isinstance(decode_timestep, list):
-                    decode_timestep = [decode_timestep] * batch_size
-                if decode_noise_scale is None:
-                    decode_noise_scale = decode_timestep
-                elif not isinstance(decode_noise_scale, list):
-                    decode_noise_scale = [decode_noise_scale] * batch_size
-
-                timestep = torch.tensor(decode_timestep, device=device, dtype=latents.dtype)
-                decode_noise_scale = torch.tensor(decode_noise_scale, device=device, dtype=latents.dtype)[
-                    :, None, None, None, None
-                ]
-                latents = (1 - decode_noise_scale) * latents + decode_noise_scale * noise
-
-            latents = latents.to(self.vae.dtype)
-            video = self.vae.decode(latents, timestep, return_dict=False)[0]
-            video = self.video_processor.postprocess_video(video, output_type=output_type)
-
-            audio_latents = audio_latents.to(self.audio_vae.dtype)
-            generated_mel_spectrograms = self.audio_vae.decode(audio_latents, return_dict=False)[0]
-            audio = self.vocoder(generated_mel_spectrograms)
-
-        return DiffusionOutput(output=(video, audio))
-
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        loader = AutoWeightsLoader(self)
-        return loader.load_weights(weights)
-
-
-class LTX2TwoStagesPipeline(nn.Module, SupportsComponentDiscovery):
-    """LTX2TwoStagesPipeline is for two stages image to video generation"""
-
-    dummy_run_num_frames = 2
-    supports_request_batch = False
-
-    _dit_modules: ClassVar[list[str]] = ["pipe.transformer"]
-    _encoder_modules: ClassVar[list[str]] = ["pipe.text_encoder"]
-    _vae_modules: ClassVar[list[str]] = ["pipe.vae", "pipe.audio_vae"]
-
-    def __init__(
-        self,
-        *,
-        od_config: OmniDiffusionConfig,
-        prefix: str = "",
-    ):
-        super().__init__()
-
-        self.device = get_local_device()
-        self.dtype = getattr(od_config, "dtype", torch.bfloat16)
-        self.model_path = od_config.model
-        self.distilled = False
-        # User provided model path may contain '/' in the end and basename function
-        # will not return the expected directory name, so we need to remove it by normpath
-        if "distilled" in os.path.basename(os.path.normpath(self.model_path)):
-            self.distilled = True
-        else:
-            raise NotImplementedError(f"{self.model_path} is not supported for {self.__class__.__name__}.")
-
-        self.pipe = LTX2Pipeline(od_config=od_config, prefix=prefix)
-        self.upsample_pipe = LTX2LatentUpsamplePipeline(
-            vae=self.pipe.vae,
-            od_config=od_config,
-        )
-
-        self.lora_manager = DiffusionLoRAManager(
-            pipeline=self.pipe,
-            device=self.device,
-            dtype=self.dtype,
-            max_cached_adapters=od_config.max_cpu_loras,
-        )
-
-        self.weights_sources = [
-            DiffusersPipelineLoader.ComponentSource(
-                model_or_path=od_config.model,
-                subfolder="transformer",
-                revision=None,
-                prefix="pipe.transformer.",
-                fall_back_to_pt=True,
-            ),
-        ]
-
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        guidance_rescale: float = 0.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> DiffusionOutput:
-        stage1_output = self.pipe(
-            req=req,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            frame_rate=frame_rate,
-            num_inference_steps=num_inference_steps,
-            sigmas=DISTILLED_SIGMA_VALUES if self.distilled else None,
-            timesteps=timesteps,
-            guidance_scale=guidance_scale,
-            guidance_rescale=guidance_rescale,
-            noise_scale=noise_scale,
-            num_videos_per_prompt=num_videos_per_prompt,
-            generator=generator,
-            latents=latents,
-            audio_latents=audio_latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            decode_timestep=decode_timestep,
-            decode_noise_scale=decode_noise_scale,
-            output_type="latent",
-            return_dict=return_dict,
-            attention_kwargs=attention_kwargs,
-            max_sequence_length=max_sequence_length,
-        )
-        video_latent, audio_latent = stage1_output.output
-
-        upscaled_video_latent = self.upsample_pipe(
-            latents=video_latent,
-            output_type="latent",
-            return_dict=False,
-        )[0]
-
-        if not self.distilled:
-            # Load Stage 2 distilled LoRA
-            lora_path = f"{self.model_path}/ltx-2-19b-distilled-lora-384.safetensors"
-            lora_request = LoRARequest(
-                lora_name="stage_2_distilled",
-                lora_int_id=1,
-                lora_path=lora_path,
-            )
-            self.lora_manager.set_active_adapter(lora_request, lora_scale=1.0)
-
-            # Change scheduler to use Stage 2 distilled sigmas as is
-            new_scheduler = FlowMatchEulerDiscreteScheduler.from_config(
-                self.pipe.scheduler.config,
-                use_dynamic_shifting=False,
-                shift_terminal=None,
-            )
-            self.pipe.scheduler = new_scheduler
-
-        # We only want to change num_inference_steps here, so no need
-        # to deep copy the whole request. `req` is a DiffusionRequestBatch
-        # whose `sampling_params` is a read-only property, so clone the
-        # underlying request(s) and override their sampling params instead.
-        stage_2_req = copy.copy(req)
-        stage_2_req.requests = [copy.copy(r) for r in req.requests]
-        for stage_2_request in stage_2_req.requests:
-            stage_2_request.sampling_params = stage_2_request.sampling_params.clone()
-            stage_2_request.sampling_params.num_inference_steps = 3
-
-        stage2_output = self.pipe(
-            req=stage_2_req,
-            latents=upscaled_video_latent,
-            audio_latents=audio_latent,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
-            sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
-            guidance_scale=1.0,
-            generator=generator,
-            output_type="np",
-            return_dict=False,
-        )
-        video, audio = stage2_output.output
-
-        return DiffusionOutput(output=(video, audio))
-
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        loader = AutoWeightsLoader(self)
-        return loader.load_weights(weights)
+from .ltx2_components import LTX2_COMPONENT_PROFILE
+from .ltx2_components import (
+    get_ltx2_post_process_func as get_ltx2_post_process_func,  # noqa: F401
+)
+from .ltx2_conditioning import LTXI2VConditioningMixin
+from .ltx2_recipes import (
+    LTX2_ONE_STAGE_RECIPE,
+    LTX_POSITIVE_ONLY_RECIPE,
+)
+from .ltx2_runtime import LTXRuntime
+
+
+class LTX2Pipeline(LTXI2VConditioningMixin, LTXRuntime):
+    """LTX-2 family one-stage entry, configured from checkpoint metadata."""
+
+    pipeline_kind = "one_stage"
+    unified_text_image_entry = True
+    component_profile = LTX2_COMPONENT_PROFILE
+    pipeline_recipe = LTX2_ONE_STAGE_RECIPE
+    _dit_modules: ClassVar[list[str]] = list(component_profile.dit_modules)
+    _encoder_modules: ClassVar[list[str]] = list(component_profile.encoder_modules)
+    _vae_modules: ClassVar[list[str]] = list(component_profile.vae_modules)
+    _resident_modules: ClassVar[list[str]] = list(component_profile.resident_modules)
+    supports_request_batch = True
 
 
 class LTX2T2VDMD2Pipeline(DMD2PipelineMixin, LTX2Pipeline):
-    """LTX-2 T2V pipeline for FastGen DMD2-distilled models."""
+    """LTX2 T2V entry for FastGen DMD2-distilled models."""
+
+    pipeline_kind = "dmd2"
+    support_image_input = False
+    pipeline_recipe = LTX_POSITIVE_ONLY_RECIPE
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
+        super().__init__(od_config=od_config, prefix=prefix)
+        self.__init_dmd2__()
+
+
+class LTX2I2VDMD2Pipeline(DMD2PipelineMixin, LTX2Pipeline):
+    """LTX2 I2V entry for FastGen DMD2-distilled models."""
+
+    pipeline_kind = "dmd2"
+    unified_text_image_entry = False
+    pipeline_recipe = LTX_POSITIVE_ONLY_RECIPE
 
     def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
         super().__init__(od_config=od_config, prefix=prefix)
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3.py
deleted file mode 100644
index 45be23296..000000000
--- a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3.py
+++ /dev/null
@@ -1,1832 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""
-Fully independent LTX-2.3 pipeline for vLLM-Omni.
-
-This pipeline does NOT inherit from LTX2Pipeline because:
-- LTX-2.3 connectors run per_token_rms_norm + per-modality video/audio
-  projection internally (per_modality_projections=True),
-  versus LTX-2's per_layer_masked_mean_norm + shared projection path
-- LTX-2.3 uses a BWE vocoder outputting 48kHz audio (not 16kHz)
-- LTX-2.3 transformer requires the sigma parameter for prompt modulation
-"""
-
-from __future__ import annotations
-
-import copy
-import json
-import os
-from collections.abc import Iterable
-from contextlib import nullcontext
-from dataclasses import dataclass
-from typing import Any, ClassVar
-
-import numpy as np
-import torch
-from diffusers import AutoencoderKLLTX2Audio, FlowMatchEulerDiscreteScheduler
-from diffusers.pipelines.ltx2 import LTX2TextConnectors
-from diffusers.pipelines.ltx2.vocoder import LTX2Vocoder
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import retrieve_timesteps
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from huggingface_hub import hf_hub_download
-from torch import nn
-from transformers import AutoTokenizer, Gemma3ForConditionalGeneration
-from vllm.logger import init_logger
-from vllm.model_executor.models.utils import AutoWeightsLoader
-
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 import DistributedAutoencoderKLLTX2Video
-from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
-from vllm_omni.diffusion.distributed.parallel_state import (
-    get_cfg_group,
-    get_classifier_free_guidance_rank,
-    get_classifier_free_guidance_world_size,
-)
-from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
-from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
-from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
-from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
-from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
-from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
-from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
-
-from .pipeline_ltx2 import (
-    _VideoAudioScheduler,
-    calculate_shift,
-    create_transformer_from_config,
-    load_transformer_config,
-)
-
-logger = init_logger(__name__)
-
-
-def _get_audio_latents_from_sampling(sampling: Any) -> torch.Tensor | None:
-    if sampling.audio_latents is not None:
-        return sampling.audio_latents
-    return sampling.extra_args.get("audio_latents")
-
-
-def _is_output_rank() -> bool:
-    return not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0
-
-
-def _vae_decode_needs_all_ranks(vae: Any) -> bool:
-    if not torch.distributed.is_initialized():
-        return False
-    is_distributed_enabled = getattr(vae, "is_distributed_enabled", None)
-    if not callable(is_distributed_enabled):
-        return False
-    try:
-        return bool(is_distributed_enabled())
-    except Exception:
-        return False
-
-
-def _should_decode_video_on_rank(vae: Any) -> bool:
-    return _is_output_rank() or _vae_decode_needs_all_ranks(vae)
-
-
-# Try to import LTX2VocoderWithBWE (diffusers >= 0.38.0)
-try:
-    from diffusers.pipelines.ltx2.vocoder import LTX2VocoderWithBWE
-except ImportError:
-    LTX2VocoderWithBWE = None
-
-
-@dataclass
-class _LTX23RequestInputs:
-    prompt: str | list[str] | None
-    negative_prompt: str | list[str] | None
-    height: int
-    width: int
-    num_frames: int
-    frame_rate: float
-    num_inference_steps: int
-    guidance_scale: float
-    num_videos_per_prompt: int
-    generator: torch.Generator | list[torch.Generator] | None
-    latents: torch.Tensor | None
-    audio_latents: torch.Tensor | None
-    prompt_embeds: torch.Tensor | None
-    negative_prompt_embeds: torch.Tensor | None
-    prompt_attention_mask: torch.Tensor | None
-    negative_prompt_attention_mask: torch.Tensor | None
-    decode_timestep: float | list[float]
-    decode_noise_scale: float | list[float] | None
-    output_type: str
-    max_sequence_length: int
-
-
-@dataclass
-class _LTX23PromptContext:
-    batch_size: int
-    connector_prompt_embeds: torch.Tensor
-    connector_audio_prompt_embeds: torch.Tensor
-    connector_attention_mask: torch.Tensor
-    positive_connector_prompt_embeds: torch.Tensor
-    positive_connector_audio_prompt_embeds: torch.Tensor
-    positive_connector_attention_mask: torch.Tensor
-    negative_connector_prompt_embeds: torch.Tensor | None
-    negative_connector_audio_prompt_embeds: torch.Tensor | None
-    negative_connector_attention_mask: torch.Tensor | None
-
-
-@dataclass
-class _LTX23ForwardContext:
-    req: DiffusionRequestBatch
-    request_inputs: _LTX23RequestInputs
-    prompt_context: _LTX23PromptContext
-    device: torch.device
-    cfg_parallel_ready: bool
-    attention_kwargs: dict[str, Any] | None
-    latent_num_frames: int
-    latent_height: int
-    latent_width: int
-    latent_mel_bins: int
-    original_audio_num_frames: int
-    padded_audio_num_frames: int
-    timesteps: torch.Tensor
-    audio_scheduler: Any
-    video_audio_scheduler: Any
-
-    @property
-    def batch_size(self) -> int:
-        return self.prompt_context.batch_size
-
-    @property
-    def num_videos_per_prompt(self) -> int:
-        return self.request_inputs.num_videos_per_prompt
-
-
-@dataclass
-class _LTX23DenoiseContext:
-    latents: torch.Tensor
-    audio_latents: torch.Tensor
-    video_coords: torch.Tensor
-    audio_coords: torch.Tensor
-    conditioning_mask: torch.Tensor | None = None
-    conditioning_mask_for_model: torch.Tensor | None = None
-
-
-def _repeat_prompt_tensor_for_outputs(tensor: torch.Tensor, num_videos_per_prompt: int) -> torch.Tensor:
-    if num_videos_per_prompt == 1:
-        return tensor
-    return tensor.repeat_interleave(num_videos_per_prompt, dim=0)
-
-
-def _detect_vocoder_output_sample_rate(model: str) -> int | None:
-    """Detect the vocoder output sample rate from vocoder/config.json.
-
-    This runs at factory time (engine process) so the rate is captured in
-    the post-process closure and doesn't need cross-process communication.
-
-    Returns:
-        Output sample rate (e.g. 48000 for LTX-2.3 BWE vocoder) or None.
-    """
-    vocoder_config_path = os.path.join(model, "vocoder", "config.json")
-    if not os.path.exists(vocoder_config_path):
-        try:
-            vocoder_config_path = hf_hub_download(model, "vocoder/config.json")
-        except Exception:
-            return None
-    try:
-        with open(vocoder_config_path) as f:
-            cfg = json.load(f)
-        return cfg.get("output_sampling_rate")
-    except Exception:
-        return None
-
-
-def get_ltx2_post_process_func(od_config: OmniDiffusionConfig):
-    """Factory for the LTX-2.3 post-process function.
-
-    Detects the vocoder output sample rate at factory time and captures it
-    in the closure so that the audio_sample_rate flows through
-    DiffusionEngine -> OmniRequestOutput -> serving_video.
-    """
-    output_sr = _detect_vocoder_output_sample_rate(od_config.model)
-
-    def post_process_func(output: tuple[torch.Tensor, torch.Tensor] | torch.Tensor):
-        if isinstance(output, tuple) and len(output) == 2:
-            video, audio = output
-            if isinstance(audio, torch.Tensor):
-                audio = audio.detach().cpu()
-            result: dict[str, Any] = {"video": video, "audio": audio}
-            if output_sr is not None:
-                result["audio_sample_rate"] = output_sr
-            return result
-        return output
-
-    return post_process_func
-
-
-def _expand_per_prompt_decode_value(
-    value: float | list[float],
-    *,
-    prompt_batch_size: int,
-    effective_batch_size: int,
-    field_name: str,
-) -> list[float]:
-    if not isinstance(value, list):
-        return [value] * effective_batch_size
-    if len(value) == 1:
-        return value * effective_batch_size
-    if len(value) == effective_batch_size:
-        return value
-    if prompt_batch_size > 0 and len(value) == prompt_batch_size and effective_batch_size % prompt_batch_size == 0:
-        repeats = effective_batch_size // prompt_batch_size
-        return [item for item in value for _ in range(repeats)]
-    raise ValueError(
-        f"`{field_name}` must have length 1, prompt batch size ({prompt_batch_size}), or effective batch size"
-        f" ({effective_batch_size}); got {len(value)}."
-    )
-
-
-def _prepare_decode_timestep_conditioning(
-    *,
-    decode_timestep: float | list[float],
-    decode_noise_scale: float | list[float] | None,
-    prompt_batch_size: int,
-    effective_batch_size: int,
-    device: torch.device,
-    dtype: torch.dtype,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    decode_timestep_values = _expand_per_prompt_decode_value(
-        decode_timestep,
-        prompt_batch_size=prompt_batch_size,
-        effective_batch_size=effective_batch_size,
-        field_name="decode_timestep",
-    )
-    if decode_noise_scale is None:
-        decode_noise_scale_values = decode_timestep_values
-    else:
-        decode_noise_scale_values = _expand_per_prompt_decode_value(
-            decode_noise_scale,
-            prompt_batch_size=prompt_batch_size,
-            effective_batch_size=effective_batch_size,
-            field_name="decode_noise_scale",
-        )
-    return (
-        torch.tensor(decode_timestep_values, device=device, dtype=dtype),
-        torch.tensor(decode_noise_scale_values, device=device, dtype=dtype)[:, None, None, None, None],
-    )
-
-
-class LTX23Pipeline(
-    nn.Module,
-    CFGParallelMixin,
-    ProgressBarMixin,
-    SupportsComponentDiscovery,
-    DiffusionPipelineProfilerMixin,
-):
-    """Fully independent LTX-2.3 pipeline.
-
-    Key differences from LTX2Pipeline:
-    - Text encoding: uses ALL 49 hidden states from Gemma-3-12B, flattened
-    - Connectors: uses padding_side API (not additive_mask)
-    - Vocoder: uses LTX2VocoderWithBWE (48kHz output)
-    - Transformer: passes sigma for prompt_adaln
-    """
-
-    supports_request_batch = True
-    # Audio is diffused jointly with video; warmup must size audio tokens.
-    dummy_run_num_frames = 2
-    _dit_modules: ClassVar[list[str]] = ["transformer"]
-    _encoder_modules: ClassVar[list[str]] = ["text_encoder", "connectors"]
-    _vae_modules: ClassVar[list[str]] = ["vae", "audio_vae"]
-    _resident_modules: ClassVar[list[str]] = ["vocoder"]
-
-    def __init__(
-        self,
-        *,
-        od_config: OmniDiffusionConfig,
-        prefix: str = "",
-    ):
-        super().__init__()
-        self.od_config = od_config
-        self.device = get_local_device()
-        dtype = getattr(od_config, "dtype", torch.bfloat16)
-        model = od_config.model
-        local_files_only = os.path.exists(model)
-
-        # Weight sources for transformer (loaded via AutoWeightsLoader)
-        self.weights_sources = [
-            DiffusersPipelineLoader.ComponentSource(
-                model_or_path=od_config.model,
-                subfolder="transformer",
-                revision=None,
-                prefix="transformer.",
-                fall_back_to_pt=True,
-            ),
-        ]
-
-        # See ``hub_prefetch.py`` for the transformers v5 multi-worker subfolder
-        # race; prefetch the whole component set before any from_pretrained.
-        ltx2_subfolders = [
-            "tokenizer",
-            "text_encoder",
-            "connectors",
-            "vae",
-            "audio_vae",
-            "vocoder",
-            "scheduler",
-        ]
-        prefetch_subfolders(model, ltx2_subfolders, local_files_only=local_files_only)
-
-        # --- Tokenizer (lightweight, stays wherever) ---
-        self.tokenizer = AutoTokenizer.from_pretrained(model, subfolder="tokenizer", local_files_only=local_files_only)
-
-        # --- Text encoder ---
-        with torch.device("cpu"):
-            self.text_encoder = from_pretrained_with_prefetch(
-                Gemma3ForConditionalGeneration.from_pretrained,
-                model,
-                subfolder="text_encoder",
-                prefetch_list=ltx2_subfolders,
-                local_files_only=local_files_only,
-                torch_dtype=dtype,
-            )
-
-        # --- Connectors (LTX-2.3 connectors include caption projection) ---
-        self.connectors = from_pretrained_with_prefetch(
-            LTX2TextConnectors.from_pretrained,
-            model,
-            subfolder="connectors",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        )
-
-        # --- VAE, Audio VAE ---
-        self.vae = from_pretrained_with_prefetch(
-            DistributedAutoencoderKLLTX2Video.from_pretrained,
-            model,
-            subfolder="vae",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        )
-        self.audio_vae = from_pretrained_with_prefetch(
-            AutoencoderKLLTX2Audio.from_pretrained,
-            model,
-            subfolder="audio_vae",
-            prefetch_list=ltx2_subfolders,
-            local_files_only=local_files_only,
-            torch_dtype=dtype,
-        )
-
-        # --- Vocoder: prefer BWE vocoder (48kHz) for LTX-2.3 ---
-        vocoder_cls = LTX2VocoderWithBWE or LTX2Vocoder
-        try:
-            self.vocoder = vocoder_cls.from_pretrained(
-                model, subfolder="vocoder", torch_dtype=dtype, local_files_only=local_files_only
-            )
-        except (TypeError, OSError, ValueError):
-            self.vocoder = LTX2Vocoder.from_pretrained(
-                model, subfolder="vocoder", torch_dtype=dtype, local_files_only=local_files_only
-            )
-
-        # --- Transformer: created empty, weights loaded via AutoWeightsLoader ---
-        transformer_config = load_transformer_config(model, "transformer", local_files_only)
-        quant_config = getattr(self.od_config, "quantization_config", None)
-        self.transformer = create_transformer_from_config(transformer_config, quant_config=quant_config)
-        self._place_aux_components()
-
-        # --- Scheduler ---
-        self.scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
-            model, subfolder="scheduler", local_files_only=local_files_only
-        )
-
-        # --- Derived compression ratios ---
-        self.vae_spatial_compression_ratio = self.vae.spatial_compression_ratio if self.vae is not None else 32
-        self.vae_temporal_compression_ratio = self.vae.temporal_compression_ratio if self.vae is not None else 8
-        self.audio_vae_mel_compression_ratio = self.audio_vae.mel_compression_ratio if self.audio_vae is not None else 4
-        self.audio_vae_temporal_compression_ratio = (
-            self.audio_vae.temporal_compression_ratio if self.audio_vae is not None else 4
-        )
-        self.transformer_spatial_patch_size = self.transformer.config.patch_size if self.transformer is not None else 1
-        self.transformer_temporal_patch_size = (
-            self.transformer.config.patch_size_t if self.transformer is not None else 1
-        )
-        self.audio_sampling_rate = self.audio_vae.config.sample_rate if self.audio_vae is not None else 16000
-        self.audio_hop_length = self.audio_vae.config.mel_hop_length if self.audio_vae is not None else 160
-
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_spatial_compression_ratio)
-
-        # Tokenizer max length
-        tokenizer_max_length = 1024
-        if self.tokenizer is not None:
-            tokenizer_max_length = self.tokenizer.model_max_length
-            if tokenizer_max_length is None or tokenizer_max_length > 100000:
-                encoder_config = getattr(self.text_encoder, "config", None)
-                config_max_len = getattr(encoder_config, "max_position_embeddings", None)
-                if config_max_len is None:
-                    config_max_len = getattr(encoder_config, "max_seq_len", None)
-                tokenizer_max_length = config_max_len or 1024
-        self.tokenizer_max_length = int(tokenizer_max_length)
-
-        # Pipeline state
-        self._guidance_scale = None
-        self._attention_kwargs = None
-        self._interrupt = False
-        self._num_timesteps = None
-        self._current_timestep = None
-
-        self.setup_diffusion_pipeline_profiler(
-            enable_diffusion_pipeline_profiler=self.od_config.enable_diffusion_pipeline_profiler
-        )
-
-    def _place_aux_components(self) -> None:
-        parallel_config = getattr(self.od_config, "parallel_config", None)
-        use_managed_placement = bool(
-            getattr(self.od_config, "enable_cpu_offload", False)
-            or getattr(self.od_config, "enable_layerwise_offload", False)
-            or getattr(parallel_config, "use_hsdp", False)
-        )
-        if use_managed_placement:
-            return
-
-        modules = ModuleDiscovery.discover(self)
-        for module in (*modules.encoders, *modules.vaes, *modules.resident_modules):
-            module.to(self.device)
-
-    # ------------------------------------------------------------------
-    # Text Encoding (LTX-2.3 specific)
-    # ------------------------------------------------------------------
-
-    def _get_gemma_prompt_embeds(
-        self,
-        prompt: str | list[str],
-        num_videos_per_prompt: int = 1,
-        max_sequence_length: int = 1024,
-        device: torch.device | None = None,
-        dtype: torch.dtype | None = None,
-    ):
-        """Encode prompts using Gemma-3-12B, returning ALL 49 hidden states flattened.
-
-        Stacks all 49 hidden states and flattens to [B, seq, hidden * 49]. The
-        connectors unflatten, apply per_token_rms_norm, and project internally
-        (same shape contract as LTX-2 since the `diffusers==0.38` connector
-        migration; the two differ only in the connector's internal norm path).
-        """
-        device = device or self.device
-        dtype = dtype or self.text_encoder.dtype
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        batch_size = len(prompt)
-
-        if self.tokenizer is not None:
-            self.tokenizer.padding_side = "left"
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-
-        prompt = [p.strip() for p in prompt]
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=max_sequence_length,
-            truncation=True,
-            add_special_tokens=True,
-            return_tensors="pt",
-        )
-        text_input_ids = text_inputs.input_ids.to(device)
-        prompt_attention_mask = text_inputs.attention_mask.to(device)
-
-        text_encoder_outputs = self.text_encoder(
-            input_ids=text_input_ids,
-            attention_mask=prompt_attention_mask,
-            output_hidden_states=True,
-        )
-
-        hidden_states = text_encoder_outputs.hidden_states
-
-        # LTX-2.3: Stack ALL 49 hidden states and flatten
-        # [49 x (B, seq, 3840)] -> [B, seq, 3840, 49] -> [B, seq, 188160]
-        prompt_embeds = torch.stack(hidden_states, dim=-1).flatten(2, 3).to(dtype=dtype)
-
-        prompt_attention_mask = prompt_attention_mask.view(batch_size, -1)
-        prompt_embeds = _repeat_prompt_tensor_for_outputs(prompt_embeds, num_videos_per_prompt)
-        prompt_attention_mask = _repeat_prompt_tensor_for_outputs(prompt_attention_mask, num_videos_per_prompt)
-
-        return prompt_embeds, prompt_attention_mask
-
-    def encode_prompt(
-        self,
-        prompt: str | list[str],
-        negative_prompt: str | list[str] | None = None,
-        do_classifier_free_guidance: bool = True,
-        num_videos_per_prompt: int = 1,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        max_sequence_length: int = 1024,
-        device: torch.device | None = None,
-        dtype: torch.dtype | None = None,
-    ):
-        device = device or self.device
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        if prompt is not None:
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        negative_prompt_embeds_provided = negative_prompt_embeds is not None
-
-        if prompt_embeds is None:
-            prompt_embeds, prompt_attention_mask = self._get_gemma_prompt_embeds(
-                prompt=prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                device=device,
-                dtype=dtype,
-            )
-        elif num_videos_per_prompt > 1:
-            prompt_embeds = _repeat_prompt_tensor_for_outputs(prompt_embeds, num_videos_per_prompt)
-            prompt_attention_mask = _repeat_prompt_tensor_for_outputs(prompt_attention_mask, num_videos_per_prompt)
-
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            negative_prompt = negative_prompt or ""
-            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
-
-            if prompt is not None and type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type as `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            if isinstance(negative_prompt, list) and batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-
-            negative_prompt_embeds, negative_prompt_attention_mask = self._get_gemma_prompt_embeds(
-                prompt=negative_prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                device=device,
-                dtype=dtype,
-            )
-        elif do_classifier_free_guidance and negative_prompt_embeds_provided and num_videos_per_prompt > 1:
-            negative_prompt_embeds = _repeat_prompt_tensor_for_outputs(negative_prompt_embeds, num_videos_per_prompt)
-            negative_prompt_attention_mask = _repeat_prompt_tensor_for_outputs(
-                negative_prompt_attention_mask,
-                num_videos_per_prompt,
-            )
-
-        return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask
-
-    # ------------------------------------------------------------------
-    # Latent utilities (shared with LTX2Pipeline)
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _pack_latents(latents: torch.Tensor, patch_size: int = 1, patch_size_t: int = 1) -> torch.Tensor:
-        batch_size, num_channels, num_frames, height, width = latents.shape
-        post_patch_num_frames = num_frames // patch_size_t
-        post_patch_height = height // patch_size
-        post_patch_width = width // patch_size
-        latents = latents.reshape(
-            batch_size,
-            -1,
-            post_patch_num_frames,
-            patch_size_t,
-            post_patch_height,
-            patch_size,
-            post_patch_width,
-            patch_size,
-        )
-        latents = latents.permute(0, 2, 4, 6, 1, 3, 5, 7).flatten(4, 7).flatten(1, 3)
-        return latents
-
-    @staticmethod
-    def _unpack_latents(
-        latents: torch.Tensor,
-        num_frames: int,
-        height: int,
-        width: int,
-        patch_size: int = 1,
-        patch_size_t: int = 1,
-    ) -> torch.Tensor:
-        batch_size = latents.size(0)
-        latents = latents.reshape(batch_size, num_frames, height, width, -1, patch_size_t, patch_size, patch_size)
-        latents = latents.permute(0, 4, 1, 5, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(2, 3)
-        return latents
-
-    @staticmethod
-    def _normalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = (latents - latents_mean) * scaling_factor / latents_std
-        return latents
-
-    @staticmethod
-    def _normalize_audio_latents(latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor):
-        latents_mean = latents_mean.to(latents.device, latents.dtype)
-        latents_std = latents_std.to(latents.device, latents.dtype)
-        return (latents - latents_mean) / latents_std
-
-    @staticmethod
-    def _denormalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = latents * latents_std / scaling_factor + latents_mean
-        return latents
-
-    @staticmethod
-    def _denormalize_audio_latents(latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor):
-        latents_mean = latents_mean.to(latents.device, latents.dtype)
-        latents_std = latents_std.to(latents.device, latents.dtype)
-        return (latents * latents_std) + latents_mean
-
-    @staticmethod
-    def _pack_audio_latents(
-        latents: torch.Tensor, patch_size: int | None = None, patch_size_t: int | None = None
-    ) -> torch.Tensor:
-        if patch_size is not None and patch_size_t is not None:
-            batch_size, num_channels, latent_length, latent_mel_bins = latents.shape
-            post_patch_latent_length = latent_length / patch_size_t
-            post_patch_mel_bins = latent_mel_bins / patch_size
-            latents = latents.reshape(
-                batch_size, -1, post_patch_latent_length, patch_size_t, post_patch_mel_bins, patch_size
-            )
-            latents = latents.permute(0, 2, 4, 1, 3, 5).flatten(3, 5).flatten(1, 2)
-        else:
-            latents = latents.transpose(1, 2).flatten(2, 3)
-        return latents
-
-    @staticmethod
-    def _unpack_audio_latents(
-        latents: torch.Tensor,
-        latent_length: int,
-        num_mel_bins: int,
-        patch_size: int | None = None,
-        patch_size_t: int | None = None,
-    ) -> torch.Tensor:
-        if patch_size is not None and patch_size_t is not None:
-            batch_size = latents.size(0)
-            latents = latents.reshape(batch_size, latent_length, num_mel_bins, -1, patch_size_t, patch_size)
-            latents = latents.permute(0, 3, 1, 4, 2, 5).flatten(4, 5).flatten(2, 3)
-        else:
-            latents = latents.unflatten(2, (-1, num_mel_bins)).transpose(1, 2)
-        return latents
-
-    @staticmethod
-    def _unpad_audio_latents(latents: torch.Tensor, num_frames: int) -> torch.Tensor:
-        return latents[:, :num_frames]
-
-    @staticmethod
-    def _get_sp_padded_audio_latent_length(audio_latent_length: int, sp_size: int) -> int:
-        if sp_size > 1:
-            audio_latent_length += (sp_size - (audio_latent_length % sp_size)) % sp_size
-        return audio_latent_length
-
-    def _resolve_audio_latent_length(self, audio_latent_length: int, audio_latents: torch.Tensor | None) -> int:
-        if audio_latents is None or audio_latents.ndim != 4:
-            return audio_latent_length
-
-        provided_latent_length = audio_latents.shape[2]
-        sp_size = getattr(self.od_config.parallel_config, "sequence_parallel_size", 1) or 1
-        padded_latent_length = self._get_sp_padded_audio_latent_length(audio_latent_length, int(sp_size))
-
-        # Keep requested duration semantics when callers pass 4D latents that
-        # are already padded for SP; other 4D lengths retain shape inference.
-        if provided_latent_length in {audio_latent_length, padded_latent_length}:
-            return audio_latent_length
-        return provided_latent_length
-
-    def _decode_output(
-        self,
-        *,
-        latents: torch.Tensor,
-        audio_latents: torch.Tensor,
-        output_type: str,
-        connector_prompt_embeds: torch.Tensor,
-        generator: torch.Generator | list[torch.Generator] | None,
-        device: torch.device,
-        decode_timestep: float | list[float],
-        decode_noise_scale: float | list[float] | None,
-        prompt_batch_size: int,
-    ) -> DiffusionOutput:
-        if output_type == "latent":
-            return DiffusionOutput(
-                output=(latents, audio_latents),
-                stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
-            )
-
-        latents = latents.to(connector_prompt_embeds.dtype)
-        if not self.vae.config.timestep_conditioning:
-            timestep_decode = None
-        else:
-            noise = randn_tensor(latents.shape, generator=generator, device=device, dtype=latents.dtype)
-            timestep_decode, decode_noise_scale_t = _prepare_decode_timestep_conditioning(
-                decode_timestep=decode_timestep,
-                decode_noise_scale=decode_noise_scale,
-                prompt_batch_size=prompt_batch_size,
-                effective_batch_size=latents.shape[0],
-                device=device,
-                dtype=latents.dtype,
-            )
-            latents = (1 - decode_noise_scale_t) * latents + decode_noise_scale_t * noise
-
-        if _should_decode_video_on_rank(self.vae):
-            latents = latents.to(self.vae.dtype)
-            video = self.vae.decode(latents, timestep_decode, return_dict=False)[0]
-        else:
-            video = torch.empty(0, device=latents.device, dtype=latents.dtype)
-
-        if not _is_output_rank():
-            return DiffusionOutput(
-                output=(
-                    torch.empty(0, device=video.device, dtype=video.dtype),
-                    torch.empty(0, device=audio_latents.device, dtype=audio_latents.dtype),
-                ),
-                stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
-            )
-
-        if video.numel() > 0:
-            video = self.video_processor.postprocess_video(video, output_type=output_type)
-
-        audio_latents = audio_latents.to(self.audio_vae.dtype)
-        generated_mel_spectrograms = self.audio_vae.decode(audio_latents, return_dict=False)[0]
-        audio = self.vocoder(generated_mel_spectrograms)
-
-        return DiffusionOutput(
-            output=(video, audio),
-            stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
-        )
-
-    # ------------------------------------------------------------------
-    # Latent preparation
-    # ------------------------------------------------------------------
-
-    def prepare_latents(
-        self,
-        batch_size: int = 1,
-        num_channels_latents: int = 128,
-        height: int = 512,
-        width: int = 768,
-        num_frames: int = 121,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> torch.Tensor:
-        if latents is not None:
-            if latents.ndim == 5:
-                latents = self._normalize_latents(
-                    latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-                )
-                latents = self._pack_latents(
-                    latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-                )
-            if latents.ndim != 3:
-                raise ValueError(f"Provided `latents` has shape {latents.shape}, expected [batch, seq, features].")
-            noise = randn_tensor(latents.shape, generator=generator, device=latents.device, dtype=latents.dtype)
-            latents = noise_scale * noise + (1 - noise_scale) * latents
-            return latents.to(device=device, dtype=dtype)
-
-        height = height // self.vae_spatial_compression_ratio
-        width = width // self.vae_spatial_compression_ratio
-        num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-        shape = (batch_size, num_channels_latents, num_frames, height, width)
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = self._pack_latents(latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size)
-        return latents
-
-    def prepare_audio_latents(
-        self,
-        batch_size: int = 1,
-        num_channels_latents: int = 8,
-        audio_latent_length: int = 1,
-        num_mel_bins: int = 64,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, int, int]:
-        original_latent_length = audio_latent_length
-        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
-
-        sp_size = getattr(self.od_config.parallel_config, "sequence_parallel_size", 1) or 1
-        padded_latent_length = self._get_sp_padded_audio_latent_length(original_latent_length, int(sp_size))
-
-        if latents is not None:
-            if latents.ndim == 4:
-                latents = self._pack_audio_latents(latents)
-            if latents.ndim != 3:
-                raise ValueError(f"Provided `latents` has shape {latents.shape}, expected [batch, seq, features].")
-            latents = self._normalize_audio_latents(latents, self.audio_vae.latents_mean, self.audio_vae.latents_std)
-            noise = randn_tensor(latents.shape, generator=generator, device=latents.device, dtype=latents.dtype)
-            latents = noise_scale * noise + (1 - noise_scale) * latents
-
-            if latents.shape[1] not in {original_latent_length, padded_latent_length}:
-                raise ValueError(
-                    "Provided `audio_latents` has incompatible audio frame count "
-                    f"{latents.shape[1]}; expected {original_latent_length} or {padded_latent_length}."
-                )
-
-            if latents.shape[1] == original_latent_length and padded_latent_length > original_latent_length:
-                padding = torch.zeros(
-                    latents.shape[0],
-                    padded_latent_length - original_latent_length,
-                    latents.shape[2],
-                    dtype=latents.dtype,
-                    device=latents.device,
-                )
-                latents = torch.cat([latents, padding], dim=1)
-
-            return latents.to(device=device, dtype=dtype), original_latent_length, padded_latent_length
-
-        shape = (batch_size, num_channels_latents, padded_latent_length, latent_mel_bins)
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = self._pack_audio_latents(latents)
-        return latents, original_latent_length, padded_latent_length
-
-    # ------------------------------------------------------------------
-    # Properties
-    # ------------------------------------------------------------------
-
-    @property
-    def guidance_scale(self):
-        return self._guidance_scale
-
-    @property
-    def do_classifier_free_guidance(self):
-        return self._guidance_scale is not None and self._guidance_scale > 1.0
-
-    @property
-    def num_timesteps(self):
-        return self._num_timesteps
-
-    @property
-    def current_timestep(self):
-        return self._current_timestep
-
-    @property
-    def interrupt(self):
-        return self._interrupt
-
-    # ------------------------------------------------------------------
-    # Input validation
-    # ------------------------------------------------------------------
-
-    def check_inputs(
-        self,
-        prompt,
-        height,
-        width,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        if height % 32 != 0 or width % 32 != 0:
-            raise ValueError(f"`height` and `width` must be divisible by 32 but are {height} and {width}.")
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError("Cannot forward both `prompt` and `prompt_embeds`.")
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError("Provide either `prompt` or `prompt_embeds`.")
-        elif prompt is not None and not isinstance(prompt, (str, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if prompt_embeds is not None and prompt_attention_mask is None:
-            raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.")
-
-        if negative_prompt_embeds is not None and negative_prompt_attention_mask is None:
-            raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.")
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
-                raise ValueError(
-                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when "
-                    "passed directly, but got: `prompt_attention_mask` "
-                    f"{prompt_attention_mask.shape} != `negative_prompt_attention_mask` "
-                    f"{negative_prompt_attention_mask.shape}."
-                )
-
-    # ------------------------------------------------------------------
-    # Cache context
-    # ------------------------------------------------------------------
-
-    def _transformer_cache_context(self, context_name: str):
-        cache_context = getattr(self.transformer, "cache_context", None)
-        if callable(cache_context):
-            return cache_context(context_name)
-        return nullcontext()
-
-    # ------------------------------------------------------------------
-    # CFG helpers
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _combine_x0_space_cfg(
-        sample: torch.Tensor,
-        positive_noise_pred: torch.Tensor,
-        negative_noise_pred: torch.Tensor,
-        sigma: torch.Tensor,
-        guidance_scale: float,
-    ) -> torch.Tensor:
-        x0_cond = sample - positive_noise_pred * sigma
-        x0_uncond = sample - negative_noise_pred * sigma
-        x0_guided = x0_cond + (guidance_scale - 1) * (x0_cond - x0_uncond)
-        return (sample - x0_guided) / sigma
-
-    def predict_noise(self, **kwargs):
-        with self._transformer_cache_context("cond_uncond"):
-            noise_pred_video, noise_pred_audio = self.transformer(**kwargs)
-        return noise_pred_video.float(), noise_pred_audio.float()
-
-    def combine_cfg_noise(
-        self,
-        positive_noise_pred,
-        negative_noise_pred,
-        true_cfg_scale,
-        cfg_normalize=False,
-        *,
-        video_latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        video_sigma: torch.Tensor | None = None,
-        audio_sigma: torch.Tensor | None = None,
-    ):
-        if video_latents is None or audio_latents is None or video_sigma is None or audio_sigma is None:
-            raise ValueError("LTX23Pipeline applies CFG in x0-space and requires video/audio latents and sigmas.")
-
-        video_pos, audio_pos = positive_noise_pred
-        video_neg, audio_neg = negative_noise_pred
-        video_combined = self._combine_x0_space_cfg(
-            video_latents,
-            video_pos,
-            video_neg,
-            video_sigma,
-            true_cfg_scale,
-        )
-        audio_combined = self._combine_x0_space_cfg(
-            audio_latents,
-            audio_pos,
-            audio_neg,
-            audio_sigma,
-            true_cfg_scale,
-        )
-        if cfg_normalize:
-            video_combined = self.cfg_normalize_function(video_pos, video_combined)
-            audio_combined = self.cfg_normalize_function(audio_pos, audio_combined)
-        return video_combined, audio_combined
-
-    def predict_noise_with_parallel_cfg(
-        self,
-        true_cfg_scale: float,
-        positive_kwargs: dict[str, Any],
-        negative_kwargs: dict[str, Any],
-        cfg_normalize: bool = True,
-        output_slice: int | None = None,
-        *,
-        video_latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        video_sigma: torch.Tensor | None = None,
-        audio_sigma: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        def maybe_slice(pred: tuple[torch.Tensor, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
-            if output_slice is None:
-                return pred
-            return pred[0][:, :output_slice], pred[1][:, :output_slice]
-
-        cfg_world_size = get_classifier_free_guidance_world_size()
-        if cfg_world_size != 2:
-            raise ValueError(f"LTX23Pipeline parallel CFG requires cfg_parallel_size 2, but got {cfg_world_size}.")
-
-        cfg_group = get_cfg_group()
-        cfg_rank = get_classifier_free_guidance_rank()
-        branch_kwargs = positive_kwargs if cfg_rank == 0 else negative_kwargs
-        local_video_pred, local_audio_pred = maybe_slice(self.predict_noise(**branch_kwargs))
-
-        gathered_video = cfg_group.all_gather(local_video_pred, separate_tensors=True)
-        gathered_audio = cfg_group.all_gather(local_audio_pred, separate_tensors=True)
-        positive_noise_pred = (gathered_video[0], gathered_audio[0])
-        negative_noise_pred = (gathered_video[1], gathered_audio[1])
-
-        return self.combine_cfg_noise(
-            positive_noise_pred,
-            negative_noise_pred,
-            true_cfg_scale,
-            cfg_normalize,
-            video_latents=video_latents,
-            audio_latents=audio_latents,
-            video_sigma=video_sigma,
-            audio_sigma=audio_sigma,
-        )
-
-    def _synchronize_cfg_parallel_step_output(
-        self,
-        latents: tuple[torch.Tensor, torch.Tensor],
-        do_true_cfg: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        if not (do_true_cfg and get_classifier_free_guidance_world_size() > 1):
-            return latents
-
-        latents = tuple(tensor.contiguous() for tensor in latents)
-        device = next((tensor.device for tensor in latents if tensor.is_cuda), None)
-        if device is not None:
-            torch.cuda.current_stream(device).synchronize()
-        return latents
-
-    def _resolve_request_inputs(
-        self,
-        req: DiffusionRequestBatch,
-        *,
-        prompt: str | list[str] | None,
-        negative_prompt: str | list[str] | None,
-        height: int | None,
-        width: int | None,
-        num_frames: int | None,
-        frame_rate: float | None,
-        num_inference_steps: int | None,
-        timesteps: list[int] | None,
-        guidance_scale: float,
-        num_videos_per_prompt: int | None,
-        generator: torch.Generator | list[torch.Generator] | None,
-        latents: torch.Tensor | None,
-        audio_latents: torch.Tensor | None,
-        prompt_embeds: torch.Tensor | None,
-        negative_prompt_embeds: torch.Tensor | None,
-        prompt_attention_mask: torch.Tensor | None,
-        negative_prompt_attention_mask: torch.Tensor | None,
-        decode_timestep: float | list[float],
-        decode_noise_scale: float | list[float] | None,
-        output_type: str,
-        max_sequence_length: int | None,
-    ) -> _LTX23RequestInputs:
-        sampling_params_list = req.sampling_params_list
-        common_sampling_params = sampling_params_list[0]
-        prompt = [p if isinstance(p, str) else (p.get("prompt") or "") for p in req.prompts] or prompt
-        if all(isinstance(p, str) or p.get("negative_prompt") is None for p in req.prompts):
-            negative_prompt = None
-        elif req.prompts:
-            negative_prompt = ["" if isinstance(p, str) else (p.get("negative_prompt") or "") for p in req.prompts]
-
-        height = common_sampling_params.height or height or 512
-        width = common_sampling_params.width or width or 768
-        num_frames = common_sampling_params.num_frames or num_frames or 121
-        frame_rate = common_sampling_params.resolved_frame_rate or frame_rate or 24.0
-        num_inference_steps = common_sampling_params.num_inference_steps or num_inference_steps or 40
-        if timesteps is None:
-            num_inference_steps = max(int(num_inference_steps), 2)
-        elif len(timesteps) < 2:
-            raise ValueError("`timesteps` must contain at least 2 values for FlowMatchEulerDiscreteScheduler.")
-
-        num_videos_per_prompt = (
-            common_sampling_params.num_outputs_per_prompt
-            if common_sampling_params.num_outputs_per_prompt > 0
-            else num_videos_per_prompt or 1
-        )
-        max_sequence_length = (
-            common_sampling_params.max_sequence_length or max_sequence_length or self.tokenizer_max_length
-        )
-
-        if common_sampling_params.guidance_scale_provided:
-            guidance_scale = common_sampling_params.guidance_scale
-
-        if generator is None:
-            generator = req.collate_request_generators(num_videos_per_prompt, generator)
-
-        latents = req.collate_request_tensors("latents", latents)
-        audio_latents = DiffusionRequestBatch.collate_tensors(
-            [_get_audio_latents_from_sampling(sampling) for sampling in sampling_params_list],
-            "audio_latents",
-            audio_latents,
-        )
-
-        prompt_fields = DiffusionRequestBatch.collate_prompt_field_map(
-            req.prompts,
-            {
-                "prompt_embeds": prompt_embeds,
-                "negative_prompt_embeds": negative_prompt_embeds,
-                "prompt_attention_mask": prompt_attention_mask,
-                "negative_prompt_attention_mask": negative_prompt_attention_mask,
-            },
-            field_aliases={
-                "prompt_attention_mask": ("prompt_attention_mask", "attention_mask"),
-                "negative_prompt_attention_mask": (
-                    "negative_prompt_attention_mask",
-                    "negative_attention_mask",
-                ),
-            },
-        )
-        prompt_embeds = prompt_fields["prompt_embeds"]
-        negative_prompt_embeds = prompt_fields["negative_prompt_embeds"]
-        prompt_attention_mask = prompt_fields["prompt_attention_mask"]
-        negative_prompt_attention_mask = prompt_fields["negative_prompt_attention_mask"]
-        if prompt_embeds is not None:
-            prompt = None
-        if negative_prompt_embeds is not None:
-            negative_prompt = None
-
-        if common_sampling_params.decode_timestep is not None:
-            decode_timestep = common_sampling_params.decode_timestep
-        if common_sampling_params.decode_noise_scale is not None:
-            decode_noise_scale = common_sampling_params.decode_noise_scale
-        if common_sampling_params.output_type is not None:
-            output_type = common_sampling_params.output_type
-
-        return _LTX23RequestInputs(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=int(height),
-            width=int(width),
-            num_frames=int(num_frames),
-            frame_rate=float(frame_rate),
-            num_inference_steps=int(num_inference_steps),
-            guidance_scale=guidance_scale,
-            num_videos_per_prompt=int(num_videos_per_prompt),
-            generator=generator,
-            latents=latents,
-            audio_latents=audio_latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            decode_timestep=decode_timestep,
-            decode_noise_scale=decode_noise_scale,
-            output_type=output_type,
-            max_sequence_length=int(max_sequence_length),
-        )
-
-    def _prepare_prompt_context(
-        self,
-        *,
-        prompt: str | list[str] | None,
-        negative_prompt: str | list[str] | None,
-        prompt_embeds: torch.Tensor | None,
-        negative_prompt_embeds: torch.Tensor | None,
-        prompt_attention_mask: torch.Tensor | None,
-        negative_prompt_attention_mask: torch.Tensor | None,
-        num_videos_per_prompt: int,
-        max_sequence_length: int,
-    ) -> _LTX23PromptContext:
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
-            self.encode_prompt(
-                prompt=prompt,
-                negative_prompt=negative_prompt,
-                do_classifier_free_guidance=self.do_classifier_free_guidance,
-                num_videos_per_prompt=num_videos_per_prompt,
-                prompt_embeds=prompt_embeds,
-                negative_prompt_embeds=negative_prompt_embeds,
-                prompt_attention_mask=prompt_attention_mask,
-                negative_prompt_attention_mask=negative_prompt_attention_mask,
-                max_sequence_length=max_sequence_length,
-                device=self.device,
-            )
-        )
-
-        if self.do_classifier_free_guidance:
-            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
-            prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0)
-
-        connector_prompt_embeds, connector_audio_prompt_embeds, connector_attention_mask = self.connectors(
-            prompt_embeds,
-            prompt_attention_mask,
-            padding_side=getattr(self.tokenizer, "padding_side", "left"),
-        )
-
-        positive_connector_prompt_embeds = connector_prompt_embeds
-        positive_connector_audio_prompt_embeds = connector_audio_prompt_embeds
-        positive_connector_attention_mask = connector_attention_mask
-        negative_connector_prompt_embeds = None
-        negative_connector_audio_prompt_embeds = None
-        negative_connector_attention_mask = None
-        if self.do_classifier_free_guidance:
-            split_batch = batch_size * num_videos_per_prompt
-            negative_connector_prompt_embeds = connector_prompt_embeds[:split_batch]
-            positive_connector_prompt_embeds = connector_prompt_embeds[split_batch:]
-            negative_connector_audio_prompt_embeds = connector_audio_prompt_embeds[:split_batch]
-            positive_connector_audio_prompt_embeds = connector_audio_prompt_embeds[split_batch:]
-            negative_connector_attention_mask = connector_attention_mask[:split_batch]
-            positive_connector_attention_mask = connector_attention_mask[split_batch:]
-
-        return _LTX23PromptContext(
-            batch_size=batch_size,
-            connector_prompt_embeds=connector_prompt_embeds,
-            connector_audio_prompt_embeds=connector_audio_prompt_embeds,
-            connector_attention_mask=connector_attention_mask,
-            positive_connector_prompt_embeds=positive_connector_prompt_embeds,
-            positive_connector_audio_prompt_embeds=positive_connector_audio_prompt_embeds,
-            positive_connector_attention_mask=positive_connector_attention_mask,
-            negative_connector_prompt_embeds=negative_connector_prompt_embeds,
-            negative_connector_audio_prompt_embeds=negative_connector_audio_prompt_embeds,
-            negative_connector_attention_mask=negative_connector_attention_mask,
-        )
-
-    def _setup_forward_runtime(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        attention_kwargs: dict[str, Any] | None,
-    ) -> bool:
-        self._guidance_scale = request_inputs.guidance_scale
-        self._attention_kwargs = attention_kwargs
-        self._interrupt = False
-        self._current_timestep = None
-        cfg_world_size = get_classifier_free_guidance_world_size()
-        if self.do_classifier_free_guidance and cfg_world_size not in (1, 2):
-            raise ValueError(
-                f"LTX23Pipeline supports CFG parallelism with cfg_parallel_size 1 or 2, but got {cfg_world_size}."
-            )
-        return self.do_classifier_free_guidance and cfg_world_size > 1
-
-    def _check_forward_inputs(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        image: Any | None = None,
-    ) -> None:
-        self.check_inputs(
-            prompt=request_inputs.prompt,
-            height=request_inputs.height,
-            width=request_inputs.width,
-            prompt_embeds=request_inputs.prompt_embeds,
-            negative_prompt_embeds=request_inputs.negative_prompt_embeds,
-            prompt_attention_mask=request_inputs.prompt_attention_mask,
-            negative_prompt_attention_mask=request_inputs.negative_prompt_attention_mask,
-        )
-
-    def _resolve_video_latent_dimensions(
-        self,
-        request_inputs: _LTX23RequestInputs,
-    ) -> tuple[int, int, int]:
-        latent_num_frames = (request_inputs.num_frames - 1) // self.vae_temporal_compression_ratio + 1
-        latent_height = request_inputs.height // self.vae_spatial_compression_ratio
-        latent_width = request_inputs.width // self.vae_spatial_compression_ratio
-        if request_inputs.latents is not None and request_inputs.latents.ndim == 5:
-            _, _, latent_num_frames, latent_height, latent_width = request_inputs.latents.shape
-        return latent_num_frames, latent_height, latent_width
-
-    def _prepare_video_latents_stage(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        prompt_context: _LTX23PromptContext,
-        *,
-        device: torch.device,
-        noise_scale: float,
-        image: Any | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor | None]:
-        num_channels_latents = self.transformer.config.in_channels
-        latents = self.prepare_latents(
-            prompt_context.batch_size * request_inputs.num_videos_per_prompt,
-            num_channels_latents,
-            request_inputs.height,
-            request_inputs.width,
-            request_inputs.num_frames,
-            noise_scale,
-            torch.float32,
-            device,
-            request_inputs.generator,
-            request_inputs.latents,
-        )
-        return latents, None
-
-    def _prepare_audio_latents_stage(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        prompt_context: _LTX23PromptContext,
-        *,
-        device: torch.device,
-        noise_scale: float,
-    ) -> tuple[torch.Tensor, int, int, int]:
-        duration_s = request_inputs.num_frames / request_inputs.frame_rate
-        audio_latents_per_second = (
-            self.audio_sampling_rate / self.audio_hop_length / float(self.audio_vae_temporal_compression_ratio)
-        )
-        audio_num_frames = round(duration_s * audio_latents_per_second)
-        audio_num_frames = self._resolve_audio_latent_length(audio_num_frames, request_inputs.audio_latents)
-
-        num_mel_bins = self.audio_vae.config.mel_bins if self.audio_vae is not None else 64
-        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
-        num_channels_latents_audio = self.audio_vae.config.latent_channels if self.audio_vae is not None else 8
-        audio_latents, original_audio_num_frames, padded_audio_num_frames = self.prepare_audio_latents(
-            prompt_context.batch_size * request_inputs.num_videos_per_prompt,
-            num_channels_latents=num_channels_latents_audio,
-            audio_latent_length=audio_num_frames,
-            num_mel_bins=num_mel_bins,
-            noise_scale=noise_scale,
-            dtype=torch.float32,
-            device=device,
-            generator=request_inputs.generator,
-            latents=request_inputs.audio_latents,
-        )
-        return audio_latents, original_audio_num_frames, padded_audio_num_frames, latent_mel_bins
-
-    def _make_video_audio_scheduler(
-        self,
-        audio_scheduler: Any,
-        latent_num_frames: int,
-        latent_height: int,
-        latent_width: int,
-    ) -> Any:
-        return _VideoAudioScheduler(self.scheduler, audio_scheduler)
-
-    def _prepare_scheduler_stage(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        *,
-        device: torch.device,
-        sigmas: list[float] | None,
-        timesteps: list[int] | None,
-        latent_num_frames: int,
-        latent_height: int,
-        latent_width: int,
-    ) -> tuple[Any, Any, torch.Tensor]:
-        sigmas = (
-            np.linspace(1.0, 1 / request_inputs.num_inference_steps, request_inputs.num_inference_steps)
-            if sigmas is None
-            else sigmas
-        )
-        # Use max_image_seq_len (not actual video_sequence_length) for mu calculation,
-        # matching diffusers' LTX2Pipeline which hardcodes this value.
-        mu = calculate_shift(
-            self.scheduler.config.get("max_image_seq_len", 4096),
-            self.scheduler.config.get("base_image_seq_len", 1024),
-            self.scheduler.config.get("max_image_seq_len", 4096),
-            self.scheduler.config.get("base_shift", 0.95),
-            self.scheduler.config.get("max_shift", 2.05),
-        )
-        audio_scheduler = copy.deepcopy(self.scheduler)
-        video_audio_scheduler = self._make_video_audio_scheduler(
-            audio_scheduler,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-        )
-        _ = retrieve_timesteps(
-            audio_scheduler,
-            request_inputs.num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        timesteps, _ = retrieve_timesteps(
-            self.scheduler,
-            request_inputs.num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        self._num_timesteps = len(timesteps)
-        return audio_scheduler, video_audio_scheduler, timesteps
-
-    def _prepare_rope_coords_stage(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        latents: torch.Tensor,
-        audio_latents: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        request_inputs = forward_ctx.request_inputs
-        video_coords = self.transformer.rope.prepare_video_coords(
-            latents.shape[0],
-            forward_ctx.latent_num_frames,
-            forward_ctx.latent_height,
-            forward_ctx.latent_width,
-            latents.device,
-            fps=request_inputs.frame_rate,
-        )
-        audio_coords = self.transformer.audio_rope.prepare_audio_coords(
-            audio_latents.shape[0],
-            forward_ctx.padded_audio_num_frames,
-            audio_latents.device,
-        )
-        return video_coords, audio_coords
-
-    def _prepare_denoise_context_for_cfg(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-    ) -> _LTX23DenoiseContext:
-        if self.do_classifier_free_guidance and not forward_ctx.cfg_parallel_ready:
-            denoise_ctx.video_coords = denoise_ctx.video_coords.repeat(
-                (2,) + (1,) * (denoise_ctx.video_coords.ndim - 1)
-            )
-            denoise_ctx.audio_coords = denoise_ctx.audio_coords.repeat(
-                (2,) + (1,) * (denoise_ctx.audio_coords.ndim - 1)
-            )
-        return denoise_ctx
-
-    def _denoise_timestep_kwargs(
-        self,
-        ts: torch.Tensor,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-    ) -> dict[str, torch.Tensor]:
-        return {"timestep": ts, "sigma": ts}
-
-    def _build_transformer_kwargs(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-        *,
-        hidden_states: torch.Tensor,
-        audio_hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        audio_encoder_hidden_states: torch.Tensor,
-        encoder_attention_mask: torch.Tensor,
-        audio_encoder_attention_mask: torch.Tensor,
-        ts: torch.Tensor,
-    ) -> dict[str, Any]:
-        request_inputs = forward_ctx.request_inputs
-        return {
-            "hidden_states": hidden_states,
-            "audio_hidden_states": audio_hidden_states,
-            "encoder_hidden_states": encoder_hidden_states,
-            "audio_encoder_hidden_states": audio_encoder_hidden_states,
-            **self._denoise_timestep_kwargs(ts, forward_ctx, denoise_ctx),
-            "encoder_attention_mask": encoder_attention_mask,
-            "audio_encoder_attention_mask": audio_encoder_attention_mask,
-            "num_frames": forward_ctx.latent_num_frames,
-            "height": forward_ctx.latent_height,
-            "width": forward_ctx.latent_width,
-            "fps": request_inputs.frame_rate,
-            "audio_num_frames": forward_ctx.padded_audio_num_frames,
-            "video_coords": denoise_ctx.video_coords,
-            "audio_coords": denoise_ctx.audio_coords,
-            "attention_kwargs": forward_ctx.attention_kwargs,
-            "return_dict": False,
-        }
-
-    def _step_denoised_latents(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-        noise_pred_video: torch.Tensor,
-        noise_pred_audio: torch.Tensor,
-        t: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        if forward_ctx.cfg_parallel_ready:
-            latents, audio_latents = self.scheduler_step_maybe_with_cfg(
-                (noise_pred_video, noise_pred_audio),
-                (t, t),
-                (denoise_ctx.latents, denoise_ctx.audio_latents),
-                do_true_cfg=self.do_classifier_free_guidance,
-                per_request_scheduler=forward_ctx.video_audio_scheduler,
-            )
-            return self._synchronize_cfg_parallel_step_output(
-                (latents, audio_latents),
-                do_true_cfg=self.do_classifier_free_guidance,
-            )
-
-        latents = self.scheduler.step(noise_pred_video, t, denoise_ctx.latents, return_dict=False)[0]
-        audio_latents = forward_ctx.audio_scheduler.step(
-            noise_pred_audio,
-            t,
-            denoise_ctx.audio_latents,
-            return_dict=False,
-        )[0]
-        return latents, audio_latents
-
-    def _denoise_loop(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        request_inputs = forward_ctx.request_inputs
-        prompt_context = forward_ctx.prompt_context
-        guidance_scale = request_inputs.guidance_scale
-        audio_scheduler = forward_ctx.audio_scheduler
-
-        with self.progress_bar(total=len(forward_ctx.timesteps)) as pbar:
-            for i, t in enumerate(forward_ctx.timesteps):
-                if self.interrupt:
-                    continue
-
-                self._current_timestep = t
-
-                if forward_ctx.cfg_parallel_ready:
-                    latent_model_input = denoise_ctx.latents.to(prompt_context.positive_connector_prompt_embeds.dtype)
-                    audio_latent_model_input = denoise_ctx.audio_latents.to(
-                        prompt_context.positive_connector_prompt_embeds.dtype
-                    )
-                    ts = t.expand(latent_model_input.shape[0])
-                    positive_kwargs = self._build_transformer_kwargs(
-                        forward_ctx,
-                        denoise_ctx,
-                        hidden_states=latent_model_input,
-                        audio_hidden_states=audio_latent_model_input,
-                        encoder_hidden_states=prompt_context.positive_connector_prompt_embeds,
-                        audio_encoder_hidden_states=prompt_context.positive_connector_audio_prompt_embeds,
-                        encoder_attention_mask=prompt_context.positive_connector_attention_mask,
-                        audio_encoder_attention_mask=prompt_context.positive_connector_attention_mask,
-                        ts=ts,
-                    )
-                    negative_kwargs = {
-                        **positive_kwargs,
-                        "encoder_hidden_states": prompt_context.negative_connector_prompt_embeds,
-                        "audio_encoder_hidden_states": prompt_context.negative_connector_audio_prompt_embeds,
-                        "encoder_attention_mask": prompt_context.negative_connector_attention_mask,
-                        "audio_encoder_attention_mask": prompt_context.negative_connector_attention_mask,
-                    }
-                    noise_pred_video, noise_pred_audio = self.predict_noise_with_parallel_cfg(
-                        true_cfg_scale=guidance_scale,
-                        positive_kwargs=positive_kwargs,
-                        negative_kwargs=negative_kwargs,
-                        cfg_normalize=False,
-                        video_latents=denoise_ctx.latents,
-                        audio_latents=denoise_ctx.audio_latents,
-                        video_sigma=self.scheduler.sigmas[i],
-                        audio_sigma=audio_scheduler.sigmas[i],
-                    )
-                else:
-                    latent_model_input = (
-                        torch.cat([denoise_ctx.latents] * 2)
-                        if self.do_classifier_free_guidance
-                        else denoise_ctx.latents
-                    )
-                    latent_model_input = latent_model_input.to(prompt_context.connector_prompt_embeds.dtype)
-                    audio_latent_model_input = (
-                        torch.cat([denoise_ctx.audio_latents] * 2)
-                        if self.do_classifier_free_guidance
-                        else denoise_ctx.audio_latents
-                    )
-                    audio_latent_model_input = audio_latent_model_input.to(prompt_context.connector_prompt_embeds.dtype)
-                    ts = t.expand(latent_model_input.shape[0])
-
-                    transformer_kwargs = self._build_transformer_kwargs(
-                        forward_ctx,
-                        denoise_ctx,
-                        hidden_states=latent_model_input,
-                        audio_hidden_states=audio_latent_model_input,
-                        encoder_hidden_states=prompt_context.connector_prompt_embeds,
-                        audio_encoder_hidden_states=prompt_context.connector_audio_prompt_embeds,
-                        encoder_attention_mask=prompt_context.connector_attention_mask,
-                        audio_encoder_attention_mask=prompt_context.connector_attention_mask,
-                        ts=ts,
-                    )
-                    with self._transformer_cache_context("cond_uncond"):
-                        noise_pred_video, noise_pred_audio = self.transformer(**transformer_kwargs)
-
-                    noise_pred_video = noise_pred_video.float()
-                    noise_pred_audio = noise_pred_audio.float()
-
-                    if self.do_classifier_free_guidance:
-                        noise_pred_video_uncond, noise_pred_video_cond = noise_pred_video.chunk(2)
-                        noise_pred_video = self._combine_x0_space_cfg(
-                            denoise_ctx.latents,
-                            noise_pred_video_cond,
-                            noise_pred_video_uncond,
-                            self.scheduler.sigmas[i],
-                            guidance_scale,
-                        )
-
-                        noise_pred_audio_uncond, noise_pred_audio_cond = noise_pred_audio.chunk(2)
-                        noise_pred_audio = self._combine_x0_space_cfg(
-                            denoise_ctx.audio_latents,
-                            noise_pred_audio_cond,
-                            noise_pred_audio_uncond,
-                            audio_scheduler.sigmas[i],
-                            guidance_scale,
-                        )
-
-                denoise_ctx.latents, denoise_ctx.audio_latents = self._step_denoised_latents(
-                    forward_ctx,
-                    denoise_ctx,
-                    noise_pred_video,
-                    noise_pred_audio,
-                    t,
-                )
-                pbar.update()
-
-        return denoise_ctx.latents, denoise_ctx.audio_latents
-
-    def _unpack_and_denormalize_stage(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        latents: torch.Tensor,
-        audio_latents: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        latents = self._unpack_latents(
-            latents,
-            forward_ctx.latent_num_frames,
-            forward_ctx.latent_height,
-            forward_ctx.latent_width,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        )
-        latents = self._denormalize_latents(
-            latents,
-            self.vae.latents_mean,
-            self.vae.latents_std,
-            self.vae.config.scaling_factor,
-        )
-
-        audio_latents = self._unpad_audio_latents(audio_latents, forward_ctx.original_audio_num_frames)
-        audio_latents = self._denormalize_audio_latents(
-            audio_latents,
-            self.audio_vae.latents_mean,
-            self.audio_vae.latents_std,
-        )
-        audio_latents = self._unpack_audio_latents(
-            audio_latents,
-            forward_ctx.original_audio_num_frames,
-            num_mel_bins=forward_ctx.latent_mel_bins,
-        )
-        return latents, audio_latents
-
-    def _decode_and_split(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        latents: torch.Tensor,
-        audio_latents: torch.Tensor,
-    ) -> list[DiffusionOutput]:
-        request_inputs = forward_ctx.request_inputs
-        return split_diffusion_output_by_request(
-            self._decode_output(
-                latents=latents,
-                audio_latents=audio_latents,
-                output_type=request_inputs.output_type,
-                connector_prompt_embeds=forward_ctx.prompt_context.connector_prompt_embeds,
-                generator=request_inputs.generator,
-                device=forward_ctx.device,
-                decode_timestep=request_inputs.decode_timestep,
-                decode_noise_scale=request_inputs.decode_noise_scale,
-                prompt_batch_size=forward_ctx.batch_size,
-            ),
-            forward_ctx.req,
-            num_outputs_per_prompt=forward_ctx.num_videos_per_prompt,
-        )
-
-    def _forward_impl(
-        self,
-        req: DiffusionRequestBatch,
-        request_inputs: _LTX23RequestInputs,
-        *,
-        noise_scale: float,
-        sigmas: list[float] | None,
-        timesteps: list[int] | None,
-        attention_kwargs: dict[str, Any] | None,
-        image: Any | None = None,
-    ) -> list[DiffusionOutput]:
-        self._check_forward_inputs(request_inputs, image=image)
-        cfg_parallel_ready = self._setup_forward_runtime(request_inputs, attention_kwargs)
-        device = self.device
-        prompt_context = self._prepare_prompt_context(
-            prompt=request_inputs.prompt,
-            negative_prompt=request_inputs.negative_prompt,
-            prompt_embeds=request_inputs.prompt_embeds,
-            negative_prompt_embeds=request_inputs.negative_prompt_embeds,
-            prompt_attention_mask=request_inputs.prompt_attention_mask,
-            negative_prompt_attention_mask=request_inputs.negative_prompt_attention_mask,
-            num_videos_per_prompt=request_inputs.num_videos_per_prompt,
-            max_sequence_length=request_inputs.max_sequence_length,
-        )
-
-        latent_num_frames, latent_height, latent_width = self._resolve_video_latent_dimensions(request_inputs)
-        latents, conditioning_mask = self._prepare_video_latents_stage(
-            request_inputs,
-            prompt_context,
-            device=device,
-            noise_scale=noise_scale,
-            image=image,
-        )
-        audio_latents, original_audio_num_frames, padded_audio_num_frames, latent_mel_bins = (
-            self._prepare_audio_latents_stage(
-                request_inputs,
-                prompt_context,
-                device=device,
-                noise_scale=noise_scale,
-            )
-        )
-        audio_scheduler, video_audio_scheduler, timesteps_tensor = self._prepare_scheduler_stage(
-            request_inputs,
-            device=device,
-            sigmas=sigmas,
-            timesteps=timesteps,
-            latent_num_frames=latent_num_frames,
-            latent_height=latent_height,
-            latent_width=latent_width,
-        )
-        forward_ctx = _LTX23ForwardContext(
-            req=req,
-            request_inputs=request_inputs,
-            prompt_context=prompt_context,
-            device=device,
-            cfg_parallel_ready=cfg_parallel_ready,
-            attention_kwargs=attention_kwargs,
-            latent_num_frames=latent_num_frames,
-            latent_height=latent_height,
-            latent_width=latent_width,
-            latent_mel_bins=latent_mel_bins,
-            original_audio_num_frames=original_audio_num_frames,
-            padded_audio_num_frames=padded_audio_num_frames,
-            timesteps=timesteps_tensor,
-            audio_scheduler=audio_scheduler,
-            video_audio_scheduler=video_audio_scheduler,
-        )
-        video_coords, audio_coords = self._prepare_rope_coords_stage(forward_ctx, latents, audio_latents)
-        denoise_ctx = _LTX23DenoiseContext(
-            latents=latents,
-            audio_latents=audio_latents,
-            video_coords=video_coords,
-            audio_coords=audio_coords,
-            conditioning_mask=conditioning_mask,
-        )
-        denoise_ctx = self._prepare_denoise_context_for_cfg(forward_ctx, denoise_ctx)
-        latents, audio_latents = self._denoise_loop(forward_ctx, denoise_ctx)
-        latents, audio_latents = self._unpack_and_denormalize_stage(forward_ctx, latents, audio_latents)
-        return self._decode_and_split(forward_ctx, latents, audio_latents)
-
-    # ------------------------------------------------------------------
-    # Forward pass
-    # ------------------------------------------------------------------
-
-    @torch.no_grad()
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        sigmas: list[float] | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> list[DiffusionOutput]:
-        request_inputs = self._resolve_request_inputs(
-            req,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            frame_rate=frame_rate,
-            num_inference_steps=num_inference_steps,
-            timesteps=timesteps,
-            guidance_scale=guidance_scale,
-            num_videos_per_prompt=num_videos_per_prompt,
-            generator=generator,
-            latents=latents,
-            audio_latents=audio_latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            decode_timestep=decode_timestep,
-            decode_noise_scale=decode_noise_scale,
-            output_type=output_type,
-            max_sequence_length=max_sequence_length,
-        )
-        return self._forward_impl(
-            req,
-            request_inputs,
-            noise_scale=noise_scale,
-            sigmas=sigmas,
-            timesteps=timesteps,
-            attention_kwargs=attention_kwargs,
-        )
-
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        loader = AutoWeightsLoader(self)
-        return loader.load_weights(weights)
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3_image2video.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3_image2video.py
deleted file mode 100644
index bcccd7596..000000000
--- a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_3_image2video.py
+++ /dev/null
@@ -1,454 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""LTX-2.3 image-to-video pipeline."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import PIL.Image
-import torch
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import retrieve_latents
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-
-from .pipeline_ltx2_3 import (
-    LTX23Pipeline,
-    _LTX23DenoiseContext,
-    _LTX23ForwardContext,
-    _LTX23PromptContext,
-    _LTX23RequestInputs,
-    get_ltx2_post_process_func,
-)
-from .pipeline_ltx2_image2video import LTX2ImageToVideoPipeline, _I2VVideoAudioScheduler
-
-
-class LTX23ImageToVideoPipeline(LTX23Pipeline):
-    """LTX-2.3 image-to-video pipeline.
-
-    This keeps the LTX-2.3 prompt connector, x0-space CFG, sigma prompt
-    modulation, and audio branch semantics from ``LTX23Pipeline`` while
-    reusing the existing LTX image-conditioning contract: the first video
-    latent frame is encoded from the input image and remains fixed during
-    denoising.
-    """
-
-    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
-        super().__init__(od_config=od_config, prefix=prefix)
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_spatial_compression_ratio, resample="bilinear")
-
-    support_image_input = True
-
-    _normalize_latents = staticmethod(LTX2ImageToVideoPipeline._normalize_latents)
-    _create_noised_state = staticmethod(LTX2ImageToVideoPipeline._create_noised_state)
-
-    @staticmethod
-    def _resolve_single_prompt_image(raw_image: Any) -> Any:
-        if isinstance(raw_image, list):
-            if len(raw_image) != 1:
-                raise ValueError(
-                    "LTX-2.3 I2V prompt dictionaries support exactly one image per prompt. "
-                    "Pass one image per prompt for batched I2V requests."
-                )
-            return raw_image[0]
-        return raw_image
-
-    @staticmethod
-    def _resolve_additional_image(additional: dict[str, Any]) -> Any:
-        raw_image = additional.get("preprocessed_image")
-        if raw_image is None:
-            raw_image = additional.get("pixel_values")
-        if raw_image is None:
-            raw_image = additional.get("image")
-        return raw_image
-
-    def prepare_latents(
-        self,
-        image: torch.Tensor | None = None,
-        batch_size: int = 1,
-        num_channels_latents: int = 128,
-        height: int = 512,
-        width: int = 768,
-        num_frames: int = 121,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Prepare I2V latents and the first-frame conditioning mask.
-
-        If caller-provided latents are used without an image, the latents must
-        already represent the full video state including the conditioning first
-        frame. Packed 3D latents are assumed to be in transformer token layout.
-        """
-        height = height // self.vae_spatial_compression_ratio
-        width = width // self.vae_spatial_compression_ratio
-        num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-
-        shape = (batch_size, num_channels_latents, num_frames, height, width)
-        mask_shape = (batch_size, 1, num_frames, height, width)
-
-        if latents is not None:
-            if latents.ndim == 5:
-                batch_size, _, num_frames, height, width = latents.shape
-                mask_shape = (batch_size, 1, num_frames, height, width)
-                conditioning_mask = latents.new_zeros(mask_shape)
-                conditioning_mask[:, :, 0] = 1.0
-
-                latents = self._normalize_latents(
-                    latents,
-                    self.vae.latents_mean,
-                    self.vae.latents_std,
-                    self.vae.config.scaling_factor,
-                )
-                latents = self._create_noised_state(latents, noise_scale * (1 - conditioning_mask), generator)
-                latents = self._pack_latents(
-                    latents,
-                    self.transformer_spatial_patch_size,
-                    self.transformer_temporal_patch_size,
-                )
-            else:
-                conditioning_mask = latents.new_zeros(mask_shape)
-                conditioning_mask[:, :, 0] = 1.0
-
-            conditioning_mask = self._pack_latents(
-                conditioning_mask,
-                self.transformer_spatial_patch_size,
-                self.transformer_temporal_patch_size,
-            ).squeeze(-1)
-            if latents.ndim != 3 or latents.shape[:2] != conditioning_mask.shape:
-                raise ValueError(
-                    "Provided `latents` tensor has shape"
-                    f" {latents.shape}, but the expected shape is {conditioning_mask.shape + (num_channels_latents,)}."
-                )
-            return latents.to(device=device, dtype=dtype), conditioning_mask
-
-        if image is None:
-            raise ValueError("`image` must be provided when `latents` is None.")
-
-        image_batch_size = image.shape[0]
-        if image_batch_size == 0:
-            raise ValueError("`image` batch is empty.")
-        if batch_size % image_batch_size != 0:
-            raise ValueError(
-                f"`batch_size` ({batch_size}) must be divisible by image batch size ({image_batch_size}) "
-                "for image-to-video outputs."
-            )
-        num_videos_per_prompt = batch_size // image_batch_size
-
-        if isinstance(generator, list):
-            if len(generator) != batch_size:
-                raise ValueError(
-                    f"You have passed a list of generators of length {len(generator)}, but requested an effective"
-                    f" batch size of {batch_size}. Make sure the batch size matches the length of the generators."
-                )
-            image_generators = [generator[i * num_videos_per_prompt] for i in range(image_batch_size)]
-            init_latents = [
-                retrieve_latents(self.vae.encode(image[i].unsqueeze(0).unsqueeze(2)), image_generators[i], "argmax")
-                for i in range(image_batch_size)
-            ]
-        else:
-            init_latents = [
-                retrieve_latents(self.vae.encode(img.unsqueeze(0).unsqueeze(2)), generator, "argmax") for img in image
-            ]
-
-        init_latents = torch.cat(init_latents, dim=0).to(dtype)
-        if num_videos_per_prompt > 1:
-            init_latents = init_latents.repeat_interleave(num_videos_per_prompt, dim=0)
-        init_latents = self._normalize_latents(
-            init_latents,
-            self.vae.latents_mean,
-            self.vae.latents_std,
-        )
-        init_latents = init_latents.repeat(1, 1, num_frames, 1, 1)
-
-        conditioning_mask = torch.zeros(mask_shape, device=device, dtype=dtype)
-        conditioning_mask[:, :, 0] = 1.0
-
-        noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = init_latents * conditioning_mask + noise * (1 - conditioning_mask)
-
-        conditioning_mask = self._pack_latents(
-            conditioning_mask,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        ).squeeze(-1)
-        latents = self._pack_latents(latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size)
-
-        return latents, conditioning_mask
-
-    def check_inputs(
-        self,
-        image,
-        height,
-        width,
-        prompt,
-        latents=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        if image is None and latents is None:
-            raise ValueError("Provide either `image` or `latents`. Cannot leave both undefined.")
-        super().check_inputs(
-            prompt=prompt,
-            height=height,
-            width=width,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-        )
-
-    _step_video_latents_i2v = LTX2ImageToVideoPipeline._step_video_latents_i2v
-
-    def _resolve_request_image(
-        self,
-        req: DiffusionRequestBatch,
-        image: PIL.Image.Image | torch.Tensor | list[PIL.Image.Image | torch.Tensor] | None,
-        request_inputs: _LTX23RequestInputs,
-    ) -> PIL.Image.Image | torch.Tensor | list[PIL.Image.Image | torch.Tensor] | None:
-        if image is not None or not req.prompts:
-            return image
-
-        raw_images = []
-        for prompt_item in req.prompts:
-            if isinstance(prompt_item, str):
-                raw_image = None
-            else:
-                multi_modal_data = prompt_item.get("multi_modal_data") or {}
-                raw_image = multi_modal_data.get("image")
-                if raw_image is None:
-                    additional = prompt_item.get("additional_information") or {}
-                    raw_image = self._resolve_additional_image(additional)
-            raw_image = self._resolve_single_prompt_image(raw_image)
-            if isinstance(raw_image, str):
-                raw_image = PIL.Image.open(raw_image).convert("RGB")
-            raw_images.append(raw_image)
-
-        if any(img is None for img in raw_images) and request_inputs.latents is None:
-            raise ValueError("Image is required for LTX-2.3 I2V generation.")
-        if len(raw_images) == 1:
-            return raw_images[0]
-        if raw_images:
-            return raw_images
-        return image
-
-    def _check_forward_inputs(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        image: Any | None = None,
-    ) -> None:
-        self.check_inputs(
-            image=image,
-            height=request_inputs.height,
-            width=request_inputs.width,
-            prompt=request_inputs.prompt,
-            latents=request_inputs.latents,
-            prompt_embeds=request_inputs.prompt_embeds,
-            negative_prompt_embeds=request_inputs.negative_prompt_embeds,
-            prompt_attention_mask=request_inputs.prompt_attention_mask,
-            negative_prompt_attention_mask=request_inputs.negative_prompt_attention_mask,
-        )
-
-    def _resolve_video_latent_dimensions(
-        self,
-        request_inputs: _LTX23RequestInputs,
-    ) -> tuple[int, int, int]:
-        latent_num_frames = (request_inputs.num_frames - 1) // self.vae_temporal_compression_ratio + 1
-        latent_height = request_inputs.height // self.vae_spatial_compression_ratio
-        latent_width = request_inputs.width // self.vae_spatial_compression_ratio
-        if request_inputs.latents is not None:
-            if request_inputs.latents.ndim == 5:
-                _, _, latent_num_frames, latent_height, latent_width = request_inputs.latents.shape
-            elif request_inputs.latents.ndim != 3:
-                raise ValueError(
-                    f"Provided `latents` tensor has shape {request_inputs.latents.shape}, but the expected shape is "
-                    "either [batch_size, seq_len, num_features] or "
-                    "[batch_size, latent_dim, latent_frames, latent_height, latent_width]."
-                )
-        return latent_num_frames, latent_height, latent_width
-
-    def _prepare_video_latents_stage(
-        self,
-        request_inputs: _LTX23RequestInputs,
-        prompt_context: _LTX23PromptContext,
-        *,
-        device: torch.device,
-        noise_scale: float,
-        image: Any | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor | None]:
-        if request_inputs.latents is None:
-            if isinstance(image, torch.Tensor):
-                if image.ndim == 3:
-                    image = image.unsqueeze(0)
-            elif isinstance(image, list) and image and isinstance(image[0], torch.Tensor):
-                image = torch.stack(image, dim=0)
-            else:
-                image = self.video_processor.preprocess(
-                    image,
-                    height=request_inputs.height,
-                    width=request_inputs.width,
-                )
-            image = image.to(device=device, dtype=prompt_context.positive_connector_prompt_embeds.dtype)
-
-        num_channels_latents = self.transformer.config.in_channels
-        return self.prepare_latents(
-            image,
-            prompt_context.batch_size * request_inputs.num_videos_per_prompt,
-            num_channels_latents,
-            request_inputs.height,
-            request_inputs.width,
-            request_inputs.num_frames,
-            noise_scale,
-            torch.float32,
-            device,
-            request_inputs.generator,
-            request_inputs.latents,
-        )
-
-    def _make_video_audio_scheduler(
-        self,
-        audio_scheduler: Any,
-        latent_num_frames: int,
-        latent_height: int,
-        latent_width: int,
-    ) -> Any:
-        return _I2VVideoAudioScheduler(
-            self,
-            audio_scheduler,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-        )
-
-    def _prepare_denoise_context_for_cfg(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-    ) -> _LTX23DenoiseContext:
-        denoise_ctx = super()._prepare_denoise_context_for_cfg(forward_ctx, denoise_ctx)
-        if denoise_ctx.conditioning_mask is None:
-            raise ValueError("I2V denoising requires a conditioning mask.")
-        if self.do_classifier_free_guidance and not forward_ctx.cfg_parallel_ready:
-            denoise_ctx.conditioning_mask_for_model = torch.cat(
-                [denoise_ctx.conditioning_mask, denoise_ctx.conditioning_mask]
-            )
-        else:
-            denoise_ctx.conditioning_mask_for_model = denoise_ctx.conditioning_mask
-        return denoise_ctx
-
-    def _denoise_timestep_kwargs(
-        self,
-        ts: torch.Tensor,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-    ) -> dict[str, torch.Tensor]:
-        conditioning_mask = (
-            denoise_ctx.conditioning_mask if forward_ctx.cfg_parallel_ready else denoise_ctx.conditioning_mask_for_model
-        )
-        if conditioning_mask is None:
-            raise ValueError("I2V denoising requires a conditioning mask.")
-        return {
-            "timestep": ts.unsqueeze(-1) * (1 - conditioning_mask),
-            "audio_timestep": ts,
-            "sigma": ts,
-        }
-
-    def _step_denoised_latents(
-        self,
-        forward_ctx: _LTX23ForwardContext,
-        denoise_ctx: _LTX23DenoiseContext,
-        noise_pred_video: torch.Tensor,
-        noise_pred_audio: torch.Tensor,
-        t: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        latents, audio_latents = self.scheduler_step_maybe_with_cfg(
-            (noise_pred_video, noise_pred_audio),
-            (t, t),
-            (denoise_ctx.latents, denoise_ctx.audio_latents),
-            do_true_cfg=self.do_classifier_free_guidance,
-            per_request_scheduler=forward_ctx.video_audio_scheduler,
-        )
-        return self._synchronize_cfg_parallel_step_output(
-            (latents, audio_latents),
-            do_true_cfg=self.do_classifier_free_guidance,
-        )
-
-    @torch.no_grad()
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        image: PIL.Image.Image | torch.Tensor | list[PIL.Image.Image | torch.Tensor] | None = None,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        sigmas: list[float] | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> list[DiffusionOutput]:
-        request_inputs = self._resolve_request_inputs(
-            req,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            frame_rate=frame_rate,
-            num_inference_steps=num_inference_steps,
-            timesteps=timesteps,
-            guidance_scale=guidance_scale,
-            num_videos_per_prompt=num_videos_per_prompt,
-            generator=generator,
-            latents=latents,
-            audio_latents=audio_latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            decode_timestep=decode_timestep,
-            decode_noise_scale=decode_noise_scale,
-            output_type=output_type,
-            max_sequence_length=max_sequence_length,
-        )
-        image = self._resolve_request_image(req, image, request_inputs)
-        return self._forward_impl(
-            req,
-            request_inputs,
-            noise_scale=noise_scale,
-            sigmas=sigmas,
-            timesteps=timesteps,
-            attention_kwargs=attention_kwargs,
-            image=image,
-        )
-
-
-__all__ = [
-    "LTX23ImageToVideoPipeline",
-    "get_ltx2_post_process_func",
-]
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_image2video.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_image2video.py
deleted file mode 100644
index a1caf6ce8..000000000
--- a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_image2video.py
+++ /dev/null
@@ -1,909 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-from __future__ import annotations
-
-import copy
-import os
-from collections.abc import Iterable
-from typing import Any, ClassVar
-
-import numpy as np
-import PIL.Image
-import torch
-import torch.nn as nn
-from diffusers import FlowMatchEulerDiscreteScheduler
-from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import retrieve_timesteps
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import retrieve_latents
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from vllm.logger import init_logger
-from vllm.model_executor.models.utils import AutoWeightsLoader
-
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.lora.manager import DiffusionLoRAManager
-from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
-from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
-from vllm_omni.diffusion.models.interface import SupportsComponentDiscovery
-from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-from vllm_omni.lora.request import LoRARequest
-
-from .pipeline_ltx2 import (
-    LTX2Pipeline,
-    _get_prompt_field,
-    calculate_shift,
-)
-from .pipeline_ltx2 import (
-    get_ltx2_post_process_func as _get_ltx2_post_process_func,
-)
-from .pipeline_ltx2_latent_upsample import LTX2LatentUpsamplePipeline
-
-logger = init_logger(__name__)
-
-
-def get_ltx2_post_process_func(od_config: OmniDiffusionConfig):
-    return _get_ltx2_post_process_func(od_config)
-
-
-class _I2VVideoAudioScheduler:
-    """Composite scheduler for I2V: uses _step_video_latents_i2v for video, standard step for audio."""
-
-    def __init__(self, pipeline, audio_scheduler, latent_num_frames, latent_height, latent_width):
-        self.video_scheduler = pipeline.scheduler
-        self.audio_scheduler = audio_scheduler
-        self._pipeline = pipeline
-        self._latent_num_frames = latent_num_frames
-        self._latent_height = latent_height
-        self._latent_width = latent_width
-
-    def step(self, noise_pred, t, latents, return_dict=False, generator=None):
-        video_out = self._pipeline._step_video_latents_i2v(
-            noise_pred[0],
-            latents[0],
-            t[0],
-            self._latent_num_frames,
-            self._latent_height,
-            self._latent_width,
-        )
-        audio_out = self.audio_scheduler.step(noise_pred[1], t[1], latents[1], return_dict=False, generator=generator)[
-            0
-        ]
-        return ((video_out, audio_out),)
-
-
-class LTX2ImageToVideoPipeline(LTX2Pipeline):
-    supports_request_batch = False
-    support_image_input = True
-
-    def __init__(
-        self,
-        *,
-        od_config: OmniDiffusionConfig,
-        prefix: str = "",
-    ):
-        super().__init__(od_config=od_config, prefix=prefix)
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_spatial_compression_ratio, resample="bilinear")
-
-    @staticmethod
-    def _normalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = (latents - latents_mean) * scaling_factor / latents_std
-        return latents
-
-    def prepare_latents(
-        self,
-        image: torch.Tensor | None = None,
-        batch_size: int = 1,
-        num_channels_latents: int = 128,
-        height: int = 512,
-        width: int = 768,
-        num_frames: int = 121,
-        noise_scale: float = 0.0,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        height = height // self.vae_spatial_compression_ratio
-        width = width // self.vae_spatial_compression_ratio
-        num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-
-        shape = (batch_size, num_channels_latents, num_frames, height, width)
-        mask_shape = (batch_size, 1, num_frames, height, width)
-
-        if latents is not None:
-            if latents.ndim == 5:
-                # conditioning_mask needs to the same shape as latents in two stages generation.
-                batch_size, _, num_frames, height, width = latents.shape
-                mask_shape = (batch_size, 1, num_frames, height, width)
-                conditioning_mask = latents.new_zeros(mask_shape)
-                conditioning_mask[:, :, 0] = 1.0
-
-                latents = self._normalize_latents(
-                    latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-                )
-                latents = self._create_noised_state(latents, noise_scale * (1 - conditioning_mask), generator)
-                # latents are of shape [B, C, F, H, W], need to be packed
-                latents = self._pack_latents(
-                    latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-                )
-            else:
-                conditioning_mask = latents.new_zeros(mask_shape)
-                conditioning_mask[:, :, 0] = 1.0
-
-            conditioning_mask = self._pack_latents(
-                conditioning_mask, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-            ).squeeze(-1)
-
-            if latents.ndim != 3 or latents.shape[:2] != conditioning_mask.shape:
-                raise ValueError(
-                    "Provided `latents` tensor has shape"
-                    f" {latents.shape}, but the expected shape is {conditioning_mask.shape + (num_channels_latents,)}."
-                )
-            return latents.to(device=device, dtype=dtype), conditioning_mask
-
-        if image is None:
-            raise ValueError("`image` must be provided when `latents` is None.")
-
-        image_batch_size = image.shape[0]
-        if image_batch_size == 0:
-            raise ValueError("`image` batch is empty.")
-        if batch_size % image_batch_size != 0:
-            raise ValueError(
-                f"`batch_size` ({batch_size}) must be divisible by image batch size ({image_batch_size}) "
-                "for image-to-video outputs."
-            )
-        num_videos_per_prompt = batch_size // image_batch_size
-
-        if isinstance(generator, list):
-            if len(generator) != batch_size:
-                raise ValueError(
-                    f"You have passed a list of generators of length {len(generator)}, but requested an effective"
-                    f" batch size of {batch_size}. Make sure the batch size matches the length of the generators."
-                )
-
-            image_generators = [generator[i * num_videos_per_prompt] for i in range(image_batch_size)]
-            init_latents = [
-                retrieve_latents(self.vae.encode(image[i].unsqueeze(0).unsqueeze(2)), image_generators[i], "argmax")
-                for i in range(image_batch_size)
-            ]
-        else:
-            init_latents = [
-                retrieve_latents(self.vae.encode(img.unsqueeze(0).unsqueeze(2)), generator, "argmax") for img in image
-            ]
-
-        init_latents = torch.cat(init_latents, dim=0).to(dtype)
-        if num_videos_per_prompt > 1:
-            init_latents = init_latents.repeat_interleave(num_videos_per_prompt, dim=0)
-        init_latents = self._normalize_latents(init_latents, self.vae.latents_mean, self.vae.latents_std)
-        init_latents = init_latents.repeat(1, 1, num_frames, 1, 1)
-
-        conditioning_mask = torch.zeros(mask_shape, device=device, dtype=dtype)
-        conditioning_mask[:, :, 0] = 1.0
-
-        noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        latents = init_latents * conditioning_mask + noise * (1 - conditioning_mask)
-
-        conditioning_mask = self._pack_latents(
-            conditioning_mask, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-        ).squeeze(-1)
-        latents = self._pack_latents(latents, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size)
-
-        return latents, conditioning_mask
-
-    def check_inputs(
-        self,
-        image,
-        height,
-        width,
-        prompt,
-        latents=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        if height % 32 != 0 or width % 32 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.")
-
-        if image is None and latents is None:
-            raise ValueError("Provide either `image` or `latents`. Cannot leave both undefined.")
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        if prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        if prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if prompt_embeds is not None and prompt_attention_mask is None:
-            raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.")
-
-        if negative_prompt_embeds is not None and negative_prompt_attention_mask is None:
-            raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.")
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
-                raise ValueError(
-                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when"
-                    " passed directly, but"
-                    f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`"
-                    f" {negative_prompt_attention_mask.shape}."
-                )
-
-    def _step_video_latents_i2v(
-        self,
-        noise_pred_video: torch.Tensor,
-        latents: torch.Tensor,
-        t: torch.Tensor,
-        latent_num_frames: int,
-        latent_height: int,
-        latent_width: int,
-    ) -> torch.Tensor:
-        noise_pred_video = self._unpack_latents(
-            noise_pred_video,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        )
-        latents_unpacked = self._unpack_latents(
-            latents,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        )
-
-        noise_pred_video = noise_pred_video[:, :, 1:]
-        noise_latents = latents_unpacked[:, :, 1:]
-        pred_latents = self.scheduler.step(noise_pred_video, t, noise_latents, return_dict=False)[0]
-
-        latents_unpacked = torch.cat([latents_unpacked[:, :, :1], pred_latents], dim=2)
-        latents = self._pack_latents(
-            latents_unpacked, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
-        )
-        return latents
-
-    @torch.no_grad()
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        image: PIL.Image.Image | torch.Tensor | None = None,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        sigmas: list[float] | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        guidance_rescale: float = 0.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> DiffusionOutput:
-        # Extract prompt/negative_prompt from request.
-        # Input format: req.prompts is a list of str or dict with "prompt"/"negative_prompt" keys.
-        prompt = [p if isinstance(p, str) else (p.get("prompt") or "") for p in req.prompts] or prompt
-        if all(isinstance(p, str) or p.get("negative_prompt") is None for p in req.prompts):
-            negative_prompt = None
-        elif req.prompts:
-            negative_prompt = ["" if isinstance(p, str) else (p.get("negative_prompt") or "") for p in req.prompts]
-
-        height = req.sampling_params.height or height or 512
-        width = req.sampling_params.width or width or 768
-        num_frames = req.sampling_params.num_frames or num_frames or 121
-        frame_rate = req.sampling_params.resolved_frame_rate or frame_rate or 24.0
-        num_inference_steps = req.sampling_params.num_inference_steps or num_inference_steps or 40
-        if timesteps is None:
-            num_inference_steps = max(int(num_inference_steps), 2)
-        elif len(timesteps) < 2:
-            raise ValueError("`timesteps` must contain at least 2 values for FlowMatchEulerDiscreteScheduler.")
-        num_videos_per_prompt = (
-            req.sampling_params.num_outputs_per_prompt
-            if req.sampling_params.num_outputs_per_prompt > 0
-            else num_videos_per_prompt or 1
-        )
-        max_sequence_length = (
-            req.sampling_params.max_sequence_length or max_sequence_length or self.tokenizer_max_length
-        )
-
-        if req.sampling_params.guidance_scale_provided:
-            guidance_scale = req.sampling_params.guidance_scale
-        if req.sampling_params.guidance_rescale is not None:
-            guidance_rescale = req.sampling_params.guidance_rescale
-
-        if generator is None:
-            generator = req.sampling_params.generator
-        if generator is None and req.sampling_params.seed is not None:
-            generator = torch.Generator(device=self.device).manual_seed(req.sampling_params.seed)
-
-        latents = req.sampling_params.latents if req.sampling_params.latents is not None else latents
-        audio_latents = (
-            req.sampling_params.audio_latents
-            if req.sampling_params.audio_latents is not None
-            else req.sampling_params.extra_args.get("audio_latents", audio_latents)
-        )
-
-        # Override with pre-computed embeddings if provided in request.
-        req_prompt_embeds = [_get_prompt_field(p, "prompt_embeds") for p in req.prompts]
-        if any(p is not None for p in req_prompt_embeds):
-            prompt_embeds = torch.stack(req_prompt_embeds)  # type: ignore[arg-type]
-
-        req_negative_prompt_embeds = [_get_prompt_field(p, "negative_prompt_embeds") for p in req.prompts]
-        if any(p is not None for p in req_negative_prompt_embeds):
-            negative_prompt_embeds = torch.stack(req_negative_prompt_embeds)  # type: ignore[arg-type]
-
-        req_prompt_attention_masks = [
-            _get_prompt_field(p, "prompt_attention_mask") or _get_prompt_field(p, "attention_mask") for p in req.prompts
-        ]
-        if any(m is not None for m in req_prompt_attention_masks):
-            prompt_attention_mask = torch.stack(req_prompt_attention_masks)  # type: ignore[arg-type]
-
-        req_negative_attention_masks = [
-            _get_prompt_field(p, "negative_prompt_attention_mask") or _get_prompt_field(p, "negative_attention_mask")
-            for p in req.prompts
-        ]
-        if any(m is not None for m in req_negative_attention_masks):
-            negative_prompt_attention_mask = torch.stack(req_negative_attention_masks)  # type: ignore[arg-type]
-
-        if req.sampling_params.decode_timestep is not None:
-            decode_timestep = req.sampling_params.decode_timestep
-        if req.sampling_params.decode_noise_scale is not None:
-            decode_noise_scale = req.sampling_params.decode_noise_scale
-        if req.sampling_params.output_type is not None:
-            output_type = req.sampling_params.output_type
-
-        if image is None and req.prompts:
-            raw_images = []
-            for prompt_item in req.prompts:
-                if isinstance(prompt_item, str):
-                    raw_image = None
-                else:
-                    multi_modal_data = prompt_item.get("multi_modal_data") or {}
-                    raw_image = multi_modal_data.get("image")
-                    if raw_image is None:
-                        additional = prompt_item.get("additional_information") or {}
-                        raw_image = (
-                            additional.get("preprocessed_image")
-                            or additional.get("pixel_values")
-                            or additional.get("image")
-                        )
-                if isinstance(raw_image, list):
-                    raw_image = raw_image[0] if raw_image else None
-                if isinstance(raw_image, str):
-                    raw_image = PIL.Image.open(raw_image).convert("RGB")
-                raw_images.append(raw_image)
-
-            if any(img is None for img in raw_images):
-                if latents is None:
-                    raise ValueError("Image is required for LTX2 I2V generation.")
-            if len(raw_images) == 1:
-                image = raw_images[0]
-            elif raw_images:
-                image = raw_images
-
-        self.check_inputs(
-            image=image,
-            height=height,
-            width=width,
-            prompt=prompt,
-            latents=latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-        )
-
-        self._guidance_scale = guidance_scale
-        self._guidance_rescale = guidance_rescale
-        self._attention_kwargs = attention_kwargs
-        self._interrupt = False
-        self._current_timestep = None
-
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        device = self.device
-
-        (
-            prompt_embeds,
-            prompt_attention_mask,
-            negative_prompt_embeds,
-            negative_prompt_attention_mask,
-        ) = self.encode_prompt(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            do_classifier_free_guidance=self.do_classifier_free_guidance,
-            num_videos_per_prompt=num_videos_per_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            max_sequence_length=max_sequence_length,
-            device=device,
-        )
-        # Compute positive prompt connectors
-        tokenizer_padding_side = getattr(self.tokenizer, "padding_side", "left")
-        connector_prompt_embeds, connector_audio_prompt_embeds, connector_attention_mask = self.connectors(
-            prompt_embeds, prompt_attention_mask, padding_side=tokenizer_padding_side
-        )
-
-        # Compute negative prompt connectors when CFG is enabled
-        negative_connector_prompt_embeds = None
-        negative_connector_audio_prompt_embeds = None
-        negative_connector_attention_mask = None
-        if self.do_classifier_free_guidance:
-            (
-                negative_connector_prompt_embeds,
-                negative_connector_audio_prompt_embeds,
-                negative_connector_attention_mask,
-            ) = self.connectors(
-                negative_prompt_embeds,
-                negative_prompt_attention_mask,
-                padding_side=tokenizer_padding_side,
-            )
-
-        latent_num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-        latent_height = height // self.vae_spatial_compression_ratio
-        latent_width = width // self.vae_spatial_compression_ratio
-        if latents is not None:
-            if latents.ndim == 5:
-                logger.info(
-                    "Got latents of shape [batch_size, latent_dim, latent_frames, latent_height, latent_width], `latent_num_frames`, `latent_height`, `latent_width` will be inferred."  # noqa
-                )
-                _, _, latent_num_frames, latent_height, latent_width = latents.shape  # [B, C, F, H, W]
-            elif latents.ndim == 3:
-                logger.warning(
-                    f"You have supplied packed `latents` of shape {latents.shape}, so the latent dims cannot be"
-                    f" inferred. Make sure the supplied `height`, `width`, and `num_frames` are correct."
-                )
-            else:
-                raise ValueError(
-                    f"Provided `latents` tensor has shape {latents.shape}, but the expected shape is either [batch_size, seq_len, num_features] or [batch_size, latent_dim, latent_frames, latent_height, latent_width]."  # noqa
-                )
-        video_sequence_length = latent_num_frames * latent_height * latent_width
-
-        if latents is None:
-            if isinstance(image, torch.Tensor):
-                if image.ndim == 3:
-                    image = image.unsqueeze(0)
-            elif isinstance(image, list) and image and isinstance(image[0], torch.Tensor):
-                image = torch.stack(image, dim=0)
-            else:
-                image = self.video_processor.preprocess(image, height=height, width=width)
-            image = image.to(device=device, dtype=prompt_embeds.dtype)
-
-        num_channels_latents = self.transformer.config.in_channels
-        latents, conditioning_mask = self.prepare_latents(
-            image,
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            num_frames,
-            noise_scale,
-            torch.float32,
-            device,
-            generator,
-            latents,
-        )
-
-        duration_s = num_frames / frame_rate
-        audio_latents_per_second = (
-            self.audio_sampling_rate / self.audio_hop_length / float(self.audio_vae_temporal_compression_ratio)
-        )
-        audio_num_frames = round(duration_s * audio_latents_per_second)
-        if audio_latents is not None:
-            if audio_latents.ndim == 4:
-                logger.info(
-                    "Got audio_latents of shape [batch_size, num_channels, audio_length, mel_bins], `audio_num_frames` will be inferred."  # noqa
-                )
-                _, _, audio_num_frames, _ = audio_latents.shape  # [B, C, L, M]
-            elif audio_latents.ndim == 3:
-                logger.warning(
-                    f"You have supplied packed `audio_latents` of shape {audio_latents.shape}, so the latent dims"
-                    f" cannot be inferred. Make sure the supplied `num_frames` and `frame_rate` are correct."
-                )
-            else:
-                raise ValueError(
-                    f"Provided `audio_latents` tensor has shape {audio_latents.shape}, but the expected shape is either [batch_size, seq_len, num_features] or [batch_size, num_channels, audio_length, mel_bins]."  # noqa
-                )
-
-        num_mel_bins = self.audio_vae.config.mel_bins if getattr(self, "audio_vae", None) is not None else 64
-        latent_mel_bins = num_mel_bins // self.audio_vae_mel_compression_ratio
-        num_channels_latents_audio = (
-            self.audio_vae.config.latent_channels if getattr(self, "audio_vae", None) is not None else 8
-        )
-        audio_latents, original_audio_num_frames, padded_audio_num_frames = self.prepare_audio_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents=num_channels_latents_audio,
-            audio_latent_length=audio_num_frames,
-            num_mel_bins=num_mel_bins,
-            noise_scale=noise_scale,
-            dtype=torch.float32,
-            device=device,
-            generator=generator,
-            latents=audio_latents,
-        )
-
-        sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas
-        mu = calculate_shift(
-            video_sequence_length,
-            self.scheduler.config.get("base_image_seq_len", 1024),
-            self.scheduler.config.get("max_image_seq_len", 4096),
-            self.scheduler.config.get("base_shift", 0.95),
-            self.scheduler.config.get("max_shift", 2.05),
-        )
-        audio_scheduler = copy.deepcopy(self.scheduler)
-        _ = retrieve_timesteps(
-            audio_scheduler,
-            num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        timesteps, num_inference_steps = retrieve_timesteps(
-            self.scheduler,
-            num_inference_steps,
-            device,
-            timesteps,
-            sigmas=sigmas,
-            mu=mu,
-        )
-        self._num_timesteps = len(timesteps)
-
-        video_coords = self.transformer.rope.prepare_video_coords(
-            latents.shape[0], latent_num_frames, latent_height, latent_width, latents.device, fps=frame_rate
-        )
-        audio_coords = self.transformer.audio_rope.prepare_audio_coords(
-            audio_latents.shape[0], padded_audio_num_frames, audio_latents.device
-        )
-
-        i2v_scheduler = _I2VVideoAudioScheduler(
-            pipeline=self,
-            audio_scheduler=audio_scheduler,
-            latent_num_frames=latent_num_frames,
-            latent_height=latent_height,
-            latent_width=latent_width,
-        )
-        # No coord duplication needed: mixin handles CFG via separate forward calls.
-
-        with self.progress_bar(total=len(timesteps)) as pbar:
-            for i, t in enumerate(timesteps):
-                if self.interrupt:
-                    continue
-
-                self._current_timestep = t
-
-                latent_model_input = latents.to(prompt_embeds.dtype)
-                audio_latent_model_input = audio_latents.to(prompt_embeds.dtype)
-                timestep = t.expand(latent_model_input.shape[0])
-                video_timestep = timestep.unsqueeze(-1) * (1 - conditioning_mask)
-                do_true_cfg = self.do_classifier_free_guidance
-
-                positive_kwargs = {
-                    "hidden_states": latent_model_input,
-                    "audio_hidden_states": audio_latent_model_input,
-                    "encoder_hidden_states": connector_prompt_embeds,
-                    "audio_encoder_hidden_states": connector_audio_prompt_embeds,
-                    "timestep": video_timestep,
-                    "audio_timestep": timestep,
-                    "encoder_attention_mask": connector_attention_mask,
-                    "audio_encoder_attention_mask": connector_attention_mask,
-                    "num_frames": latent_num_frames,
-                    "height": latent_height,
-                    "width": latent_width,
-                    "fps": frame_rate,
-                    "audio_num_frames": padded_audio_num_frames,
-                    "video_coords": video_coords,
-                    "audio_coords": audio_coords,
-                    "attention_kwargs": attention_kwargs,
-                    "return_dict": False,
-                }
-                negative_kwargs = (
-                    {
-                        **positive_kwargs,
-                        "encoder_hidden_states": negative_connector_prompt_embeds,
-                        "audio_encoder_hidden_states": negative_connector_audio_prompt_embeds,
-                        "encoder_attention_mask": negative_connector_attention_mask,
-                        "audio_encoder_attention_mask": negative_connector_attention_mask,
-                    }
-                    if do_true_cfg
-                    else None
-                )
-
-                noise_pred_video, noise_pred_audio = self.predict_noise_maybe_with_cfg(
-                    do_true_cfg=do_true_cfg,
-                    true_cfg_scale=guidance_scale,
-                    positive_kwargs=positive_kwargs,
-                    negative_kwargs=negative_kwargs,
-                    cfg_normalize=False,
-                )
-
-                latents, audio_latents = self.scheduler_step_maybe_with_cfg(
-                    (noise_pred_video, noise_pred_audio),
-                    (t, t),
-                    (latents, audio_latents),
-                    do_true_cfg=do_true_cfg,
-                    per_request_scheduler=i2v_scheduler,
-                )
-                latents, audio_latents = self._synchronize_cfg_parallel_step_output(
-                    (latents, audio_latents),
-                    do_true_cfg=do_true_cfg,
-                )
-
-                pbar.update()
-
-        latents = self._unpack_latents(
-            latents,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            self.transformer_spatial_patch_size,
-            self.transformer_temporal_patch_size,
-        )
-        latents = self._denormalize_latents(
-            latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-        )
-
-        audio_latents = self._unpad_audio_latents(audio_latents, original_audio_num_frames)
-        audio_latents = self._denormalize_audio_latents(
-            audio_latents, self.audio_vae.latents_mean, self.audio_vae.latents_std
-        )
-        audio_latents = self._unpack_audio_latents(
-            audio_latents,
-            original_audio_num_frames,
-            num_mel_bins=latent_mel_bins,
-        )
-
-        if output_type == "latent":
-            video = latents
-            audio = audio_latents
-        else:
-            latents = latents.to(prompt_embeds.dtype)
-
-            if not self.vae.config.timestep_conditioning:
-                timestep = None
-            else:
-                noise = randn_tensor(latents.shape, generator=generator, device=device, dtype=latents.dtype)
-                if not isinstance(decode_timestep, list):
-                    decode_timestep = [decode_timestep] * batch_size
-                if decode_noise_scale is None:
-                    decode_noise_scale = decode_timestep
-                elif not isinstance(decode_noise_scale, list):
-                    decode_noise_scale = [decode_noise_scale] * batch_size
-
-                timestep = torch.tensor(decode_timestep, device=device, dtype=latents.dtype)
-                decode_noise_scale = torch.tensor(decode_noise_scale, device=device, dtype=latents.dtype)[
-                    :, None, None, None, None
-                ]
-                latents = (1 - decode_noise_scale) * latents + decode_noise_scale * noise
-
-            latents = latents.to(self.vae.dtype)
-            video = self.vae.decode(latents, timestep, return_dict=False)[0]
-            video = self.video_processor.postprocess_video(video, output_type=output_type)
-
-            audio_latents = audio_latents.to(self.audio_vae.dtype)
-            generated_mel_spectrograms = self.audio_vae.decode(audio_latents, return_dict=False)[0]
-            audio = self.vocoder(generated_mel_spectrograms)
-
-        return DiffusionOutput(output=(video, audio))
-
-
-class LTX2ImageToVideoTwoStagesPipeline(nn.Module, SupportsComponentDiscovery):
-    """LTXImageToVideoTwoStagesPipeline is for two stages image to video generation"""
-
-    supports_request_batch = False
-    support_image_input = True
-    dummy_run_num_frames = 2
-
-    _dit_modules: ClassVar[list[str]] = ["pipe.transformer"]
-    _encoder_modules: ClassVar[list[str]] = ["pipe.text_encoder"]
-    _vae_modules: ClassVar[list[str]] = ["pipe.vae", "pipe.audio_vae"]
-
-    def __init__(
-        self,
-        *,
-        od_config: OmniDiffusionConfig,
-        prefix: str = "",
-    ):
-        super().__init__()
-
-        self.device = get_local_device()
-        self.dtype = getattr(od_config, "dtype", torch.bfloat16)
-        self.model_path = od_config.model
-        self.distilled = False
-        # User provided model path may contain '/' in the end and basename function
-        # will not return the expected directory name, so we need to remove it by normpath
-        if "distilled" in os.path.basename(os.path.normpath(self.model_path)):
-            self.distilled = True
-        else:
-            raise NotImplementedError(f"{self.model_path} is not supported for {self.__class__.__name__}.")
-
-        self.pipe = LTX2ImageToVideoPipeline(od_config=od_config, prefix=prefix)
-        self.upsample_pipe = LTX2LatentUpsamplePipeline(
-            vae=self.pipe.vae,
-            od_config=od_config,
-        )
-
-        self.lora_manager = DiffusionLoRAManager(
-            pipeline=self.pipe,
-            device=self.device,
-            dtype=self.dtype,
-            max_cached_adapters=od_config.max_cpu_loras,
-        )
-
-        self.weights_sources = [
-            DiffusersPipelineLoader.ComponentSource(
-                model_or_path=od_config.model,
-                subfolder="transformer",
-                revision=None,
-                prefix="pipe.transformer.",
-                fall_back_to_pt=True,
-            ),
-        ]
-
-    @torch.no_grad()
-    def forward(
-        self,
-        req: DiffusionRequestBatch,
-        image: PIL.Image.Image | torch.Tensor | None = None,
-        prompt: str | list[str] | None = None,
-        negative_prompt: str | list[str] | None = None,
-        height: int | None = None,
-        width: int | None = None,
-        num_frames: int | None = None,
-        frame_rate: float | None = None,
-        num_inference_steps: int | None = None,
-        sigmas: list[float] | None = None,
-        timesteps: list[int] | None = None,
-        guidance_scale: float = 4.0,
-        guidance_rescale: float = 0.0,
-        noise_scale: float = 0.0,
-        num_videos_per_prompt: int | None = 1,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        latents: torch.Tensor | None = None,
-        audio_latents: torch.Tensor | None = None,
-        prompt_embeds: torch.Tensor | None = None,
-        negative_prompt_embeds: torch.Tensor | None = None,
-        prompt_attention_mask: torch.Tensor | None = None,
-        negative_prompt_attention_mask: torch.Tensor | None = None,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        output_type: str = "np",
-        return_dict: bool = True,
-        attention_kwargs: dict[str, Any] | None = None,
-        max_sequence_length: int | None = None,
-    ) -> DiffusionOutput:
-        stage1_output = self.pipe(
-            req=req,
-            image=image,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            frame_rate=frame_rate,
-            num_inference_steps=num_inference_steps,
-            sigmas=DISTILLED_SIGMA_VALUES if self.distilled else None,
-            timesteps=timesteps,
-            guidance_scale=guidance_scale,
-            guidance_rescale=guidance_rescale,
-            noise_scale=noise_scale,
-            num_videos_per_prompt=num_videos_per_prompt,
-            generator=generator,
-            latents=latents,
-            audio_latents=audio_latents,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            decode_timestep=decode_timestep,
-            decode_noise_scale=decode_noise_scale,
-            output_type="latent",
-            return_dict=return_dict,
-            attention_kwargs=attention_kwargs,
-            max_sequence_length=max_sequence_length,
-        )
-        video_latent, audio_latent = stage1_output.output
-
-        upscaled_video_latent = self.upsample_pipe(
-            latents=video_latent,
-            output_type="latent",
-            return_dict=False,
-        )[0]
-
-        if not self.distilled:
-            # Load Stage 2 distilled LoRA
-            lora_path = f"{self.model_path}/ltx-2-19b-distilled-lora-384.safetensors"
-            lora_request = LoRARequest(
-                lora_name="stage_2_distilled",
-                lora_int_id=1,
-                lora_path=lora_path,
-            )
-            self.lora_manager.set_active_adapter(lora_request, lora_scale=1.0)
-
-            # Change scheduler to use Stage 2 distilled sigmas as is
-            new_scheduler = FlowMatchEulerDiscreteScheduler.from_config(
-                self.pipe.scheduler.config,
-                use_dynamic_shifting=False,
-                shift_terminal=None,
-            )
-            self.pipe.scheduler = new_scheduler
-
-        # `req` is a DiffusionRequestBatch whose `sampling_params` is a
-        # read-only property; clone the underlying request(s) and override
-        # their sampling params instead of assigning to the batch.
-        stage_2_req = copy.copy(req)
-        stage_2_req.requests = [copy.copy(r) for r in req.requests]
-        for stage_2_request in stage_2_req.requests:
-            stage_2_request.sampling_params = stage_2_request.sampling_params.clone()
-            stage_2_request.sampling_params.num_inference_steps = 3
-
-        stage2_output = self.pipe(
-            req=stage_2_req,
-            latents=upscaled_video_latent,
-            audio_latents=audio_latent,
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
-            sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
-            guidance_scale=1.0,
-            generator=generator,
-            output_type="np",
-            return_dict=False,
-        )
-        video, audio = stage2_output.output
-
-        return DiffusionOutput(output=(video, audio))
-
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        loader = AutoWeightsLoader(self)
-        return loader.load_weights(weights)
-
-
-class LTX2I2VDMD2Pipeline(DMD2PipelineMixin, LTX2ImageToVideoPipeline):
-    """LTX-2 I2V pipeline for FastGen DMD2-distilled models."""
-
-    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
-        super().__init__(od_config=od_config, prefix=prefix)
-        self.__init_dmd2__()
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_latent_upsample.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_latent_upsample.py
deleted file mode 100644
index 0c72a41d5..000000000
--- a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_latent_upsample.py
+++ /dev/null
@@ -1,262 +0,0 @@
-import os
-
-import torch
-import torch.nn as nn
-from diffusers import AutoencoderKLLTX2Video
-from diffusers.image_processor import PipelineImageInput
-from diffusers.pipelines.ltx2.latent_upsampler import LTX2LatentUpsamplerModel
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import retrieve_latents
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from vllm.logger import init_logger
-
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.distributed.utils import get_local_device
-
-logger = init_logger(__name__)
-
-
-class LTX2LatentUpsamplePipeline(nn.Module):
-    def __init__(
-        self,
-        od_config: OmniDiffusionConfig,
-        vae: AutoencoderKLLTX2Video,
-        latent_upsampler: LTX2LatentUpsamplerModel = None,
-    ) -> None:
-        super().__init__()
-
-        if vae is None:
-            raise ValueError("vae must be provided")
-        self.vae = vae
-
-        self.device = get_local_device()
-        model = od_config.model
-        local_files_only = os.path.exists(model)
-
-        if latent_upsampler is None:
-            # Use cpu context to create latent upsampler. The code k[:, None] @ k[None, :] in
-            # diffuser's BlurDownsample is not supported on GPU as k is type of torch.Int64
-            with torch.device("cpu"):
-                latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
-                    model,
-                    subfolder="latent_upsampler",
-                    torch_dtype=torch.bfloat16,
-                    local_files_only=local_files_only,
-                ).to(self.device)
-        self.latent_upsampler = latent_upsampler
-
-        self.vae_spatial_compression_ratio = (
-            self.vae.spatial_compression_ratio if getattr(self, "vae", None) is not None else 32
-        )
-        self.vae_temporal_compression_ratio = (
-            self.vae.temporal_compression_ratio if getattr(self, "vae", None) is not None else 8
-        )
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_spatial_compression_ratio)
-
-    def prepare_latents(
-        self,
-        video: torch.Tensor | None = None,
-        batch_size: int = 1,
-        num_frames: int = 121,
-        height: int = 512,
-        width: int = 768,
-        spatial_patch_size: int = 1,
-        temporal_patch_size: int = 1,
-        dtype: torch.dtype | None = None,
-        device: torch.device | None = None,
-        generator: torch.Generator | None = None,
-        latents: torch.Tensor | None = None,
-    ) -> torch.Tensor:
-        if latents is not None:
-            if latents.ndim == 3:
-                # Convert token seq [B, S, D] to latent video [B, C, F, H, W]
-                latent_num_frames = (num_frames - 1) // self.vae_temporal_compression_ratio + 1
-                latent_height = height // self.vae_spatial_compression_ratio
-                latent_width = width // self.vae_spatial_compression_ratio
-                latents = self._unpack_latents(
-                    latents, latent_num_frames, latent_height, latent_width, spatial_patch_size, temporal_patch_size
-                )
-            return latents.to(device=device, dtype=dtype)
-
-        video = video.to(device=device, dtype=self.vae.dtype)
-        if isinstance(generator, list):
-            if len(generator) != batch_size:
-                raise ValueError(
-                    f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                    f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-                )
-
-            init_latents = [
-                retrieve_latents(self.vae.encode(video[i].unsqueeze(0)), generator[i]) for i in range(batch_size)
-            ]
-        else:
-            init_latents = [retrieve_latents(self.vae.encode(vid.unsqueeze(0)), generator) for vid in video]
-
-        init_latents = torch.cat(init_latents, dim=0).to(dtype)
-        # NOTE: latent upsampler operates on the unnormalized latents, so don't normalize here
-        # init_latents = self._normalize_latents(init_latents, self.vae.latents_mean, self.vae.latents_std)
-        return init_latents
-
-    def adain_filter_latent(self, latents: torch.Tensor, reference_latents: torch.Tensor, factor: float = 1.0):
-        result = latents.clone()
-
-        for i in range(latents.size(0)):
-            for c in range(latents.size(1)):
-                r_sd, r_mean = torch.std_mean(reference_latents[i, c], dim=None)  # index by original dim order
-                i_sd, i_mean = torch.std_mean(result[i, c], dim=None)
-
-                result[i, c] = ((result[i, c] - i_mean) / i_sd) * r_sd + r_mean
-
-        result = torch.lerp(latents, result, factor)
-        return result
-
-    def tone_map_latents(self, latents: torch.Tensor, compression: float) -> torch.Tensor:
-        # Remap [0-1] to [0-0.75] and apply sigmoid compression in one shot
-        scale_factor = compression * 0.75
-        abs_latents = torch.abs(latents)
-
-        # Sigmoid compression: sigmoid shifts large values toward 0.2, small values stay ~1.0
-        # When scale_factor=0, sigmoid term vanishes, when scale_factor=0.75, full effect
-        sigmoid_term = torch.sigmoid(4.0 * scale_factor * (abs_latents - 1.0))
-        scales = 1.0 - 0.8 * scale_factor * sigmoid_term
-
-        filtered = latents * scales
-        return filtered
-
-    @staticmethod
-    # Copied from diffusers.pipelines.ltx2.pipeline_ltx2.LTX2Pipeline._denormalize_latents
-    def _denormalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor, scaling_factor: float = 1.0
-    ) -> torch.Tensor:
-        # Denormalize latents across the channel dimension [B, C, F, H, W]
-        latents_mean = latents_mean.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = latents_std.view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = latents * latents_std / scaling_factor + latents_mean
-        return latents
-
-    @staticmethod
-    # Copied from diffusers.pipelines.ltx2.pipeline_ltx2.LTX2Pipeline._unpack_latents
-    def _unpack_latents(
-        latents: torch.Tensor, num_frames: int, height: int, width: int, patch_size: int = 1, patch_size_t: int = 1
-    ) -> torch.Tensor:
-        # Packed latents of shape [B, S, D] (S is the effective video sequence length, D is the effective feature dimensions) # noqa
-        # are unpacked and reshaped into a video tensor of shape [B, C, F, H, W]. This is the inverse operation of
-        # what happens in the `_pack_latents` method.
-        batch_size = latents.size(0)
-        latents = latents.reshape(batch_size, num_frames, height, width, -1, patch_size_t, patch_size, patch_size)
-        latents = latents.permute(0, 4, 1, 5, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(2, 3)
-        return latents
-
-    def check_inputs(self, video, height, width, latents, tone_map_compression_ratio):
-        if height % self.vae_spatial_compression_ratio != 0 or width % self.vae_spatial_compression_ratio != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.")
-
-        if video is not None and latents is not None:
-            raise ValueError("Only one of `video` or `latents` can be provided.")
-        if video is None and latents is None:
-            raise ValueError("One of `video` or `latents` has to be provided.")
-
-        if not (0 <= tone_map_compression_ratio <= 1):
-            raise ValueError("`tone_map_compression_ratio` must be in the range [0, 1]")
-
-    def forward(
-        self,
-        video: list[PipelineImageInput] | None = None,
-        height: int = 512,
-        width: int = 768,
-        num_frames: int = 121,
-        spatial_patch_size: int = 1,
-        temporal_patch_size: int = 1,
-        latents: torch.Tensor | None = None,
-        latents_normalized: bool = False,
-        decode_timestep: float | list[float] = 0.0,
-        decode_noise_scale: float | list[float] | None = None,
-        adain_factor: float = 0.0,
-        tone_map_compression_ratio: float = 0.0,
-        generator: torch.Generator | list[torch.Generator] | None = None,
-        output_type: str | None = "pil",
-        return_dict: bool = True,
-    ):
-        self.check_inputs(
-            video=video,
-            height=height,
-            width=width,
-            latents=latents,
-            tone_map_compression_ratio=tone_map_compression_ratio,
-        )
-
-        if video is not None:
-            # Batched video input is not yet tested/supported. TODO: take a look later
-            batch_size = 1
-        else:
-            batch_size = latents.shape[0]
-        device = self.device
-
-        if video is not None:
-            num_frames = len(video)
-            if num_frames % self.vae_temporal_compression_ratio != 1:
-                num_frames = num_frames // self.vae_temporal_compression_ratio * self.vae_temporal_compression_ratio + 1
-                video = video[:num_frames]
-                logger.warning(
-                    f"Video length expected to be of the form `k * {self.vae_temporal_compression_ratio} + 1` but is {len(video)}. Truncating to {num_frames} frames."  # noqa
-                )
-            video = self.video_processor.preprocess_video(video, height=height, width=width)
-            video = video.to(device=device, dtype=torch.float32)
-
-        latents_supplied = latents is not None
-        latents = self.prepare_latents(
-            video=video,
-            batch_size=batch_size,
-            num_frames=num_frames,
-            height=height,
-            width=width,
-            spatial_patch_size=spatial_patch_size,
-            temporal_patch_size=temporal_patch_size,
-            dtype=torch.float32,
-            device=device,
-            generator=generator,
-            latents=latents,
-        )
-
-        if latents_supplied and latents_normalized:
-            latents = self._denormalize_latents(
-                latents, self.vae.latents_mean, self.vae.latents_std, self.vae.config.scaling_factor
-            )
-        latents = latents.to(self.latent_upsampler.dtype)
-        latents_upsampled = self.latent_upsampler(latents)
-
-        if adain_factor > 0.0:
-            latents = self.adain_filter_latent(latents_upsampled, latents, adain_factor)
-        else:
-            latents = latents_upsampled
-
-        if tone_map_compression_ratio > 0.0:
-            latents = self.tone_map_latents(latents, tone_map_compression_ratio)
-
-        if output_type == "latent":
-            video = latents
-        else:
-            if not self.vae.config.timestep_conditioning:
-                timestep = None
-            else:
-                noise = randn_tensor(latents.shape, generator=generator, device=device, dtype=latents.dtype)
-                if not isinstance(decode_timestep, list):
-                    decode_timestep = [decode_timestep] * batch_size
-                if decode_noise_scale is None:
-                    decode_noise_scale = decode_timestep
-                elif not isinstance(decode_noise_scale, list):
-                    decode_noise_scale = [decode_noise_scale] * batch_size
-
-                timestep = torch.tensor(decode_timestep, device=device, dtype=latents.dtype)
-                decode_noise_scale = torch.tensor(decode_noise_scale, device=device, dtype=latents.dtype)[
-                    :, None, None, None, None
-                ]
-                latents = (1 - decode_noise_scale) * latents + decode_noise_scale * noise
-
-            video = self.vae.decode(latents, timestep, return_dict=False)[0]
-            video = self.video_processor.postprocess_video(video, output_type=output_type)
-
-        if not return_dict:
-            return (video,)
-
-        return DiffusionOutput(output=(video,))
diff --git a/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_two_stage.py b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_two_stage.py
new file mode 100644
index 000000000..0e5bbc558
--- /dev/null
+++ b/vllm_omni/diffusion/models/ltx2/pipeline_ltx2_two_stage.py
@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Distilled two-stage entry points for the LTX model family."""
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+from .ltx2_components import LTX2_DISTILLED_COMPONENT_PROFILE
+from .ltx2_components import (
+    get_ltx2_post_process_func as get_ltx2_post_process_func,  # noqa: F401
+)
+from .ltx2_recipes import LTX2_DISTILLED_TWO_STAGE_RECIPE
+from .pipeline_ltx2 import LTX2Pipeline
+
+
+class LTX2DistilledPipeline(LTX2Pipeline):
+    """Unified LTX-2 distilled two-stage T2V/I2V entry."""
+
+    pipeline_kind = "distilled_two_stage"
+    component_profile = LTX2_DISTILLED_COMPONENT_PROFILE
+    pipeline_recipe = LTX2_DISTILLED_TWO_STAGE_RECIPE
+    supports_request_batch = False
+    support_image_input = True
+    unified_text_image_entry = True
+
+    def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
+        super().__init__(od_config=od_config, prefix=prefix)
diff --git a/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py b/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
index ed42e24ca..000abe051 100644
--- a/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
+++ b/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
@@ -189,6 +189,7 @@ class SimpleQFormerImageRefiner(nn.Module):
     def __init__(
         self,
         hidden_size: int,
+        output_hidden_size: int | None = None,
         num_queries: int = 128,
         num_layers: int = 2,
         num_heads: int | None = None,
@@ -196,6 +197,8 @@ class SimpleQFormerImageRefiner(nn.Module):
         norm_eps: float = 1e-5,
     ) -> None:
         super().__init__()
+        input_hidden_size = hidden_size
+        hidden_size = output_hidden_size or hidden_size
         self.hidden_size = hidden_size
         self.num_queries = num_queries
         # ensure num_heads divides hidden_size
@@ -203,8 +206,8 @@ class SimpleQFormerImageRefiner(nn.Module):
             num_heads = max(1, hidden_size // 128)
         self.num_heads = self._choose_valid_num_heads(hidden_size, num_heads)
         self.input_proj = nn.Sequential(
-            Qwen2RMSNorm(hidden_size, eps=norm_eps),
-            nn.Linear(hidden_size, hidden_size, bias=True),
+            Qwen2RMSNorm(input_hidden_size, eps=norm_eps),
+            nn.Linear(input_hidden_size, hidden_size, bias=True),
         )
 
         # Learnable query embeddings
@@ -662,11 +665,32 @@ class Transformer2DModel(ModelMixin, ConfigMixin):
         batch_size: int,
         height: int,
         width: int,
+        ar_image_hidden_states: torch.Tensor | None = None,
+        ar_image_attention_mask: torch.Tensor | None = None,
     ):
         device = hidden_states.device
         p = self.config.patch_size
 
         temb, text_hidden_states = self.time_caption_embed(timestep, text_hidden_states, hidden_states.dtype)
+        image_embedder = getattr(self.time_caption_embed, "image_embedder", None)
+        if image_embedder is not None and ar_image_hidden_states is not None:
+            if ar_image_attention_mask is None:
+                ar_image_attention_mask = torch.ones(
+                    ar_image_hidden_states.shape[:2],
+                    dtype=torch.bool,
+                    device=ar_image_hidden_states.device,
+                )
+            image_hidden_states = image_embedder(
+                ar_image_hidden_states,
+                ~ar_image_attention_mask.bool(),
+            )
+            image_attention_mask = torch.ones(
+                image_hidden_states.shape[:2],
+                dtype=torch.bool,
+                device=image_hidden_states.device,
+            )
+            text_hidden_states = torch.cat([text_hidden_states, image_hidden_states], dim=1)
+            text_attention_mask = torch.cat([text_attention_mask, image_attention_mask], dim=1)
 
         img_tokens = rearrange(hidden_states, "b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1=p, p2=p)
         img_tokens = self.x_embedder(img_tokens)
@@ -699,6 +723,7 @@ class Transformer2DModel(ModelMixin, ConfigMixin):
         return (
             temb,
             text_hidden_states,
+            text_attention_mask,
             img_tokens,
             img_mask,
             img_len,
@@ -740,6 +765,8 @@ class Transformer2DModel(ModelMixin, ConfigMixin):
         freqs_cis: torch.Tensor,
         text_attention_mask: torch.Tensor,
         ref_image_hidden_states: list[list[torch.Tensor]] | None = None,
+        ar_image_hidden_states: torch.Tensor | None = None,
+        ar_image_attention_mask: torch.Tensor | None = None,
         return_dict: bool = False,
     ) -> torch.Tensor:
         batch_size, height, width = self._validate_inputs(
@@ -749,6 +776,7 @@ class Transformer2DModel(ModelMixin, ConfigMixin):
         (
             temb,
             text_hidden_states,
+            text_attention_mask,
             img_tokens,
             img_mask,
             img_len,
@@ -766,6 +794,8 @@ class Transformer2DModel(ModelMixin, ConfigMixin):
             batch_size,
             height,
             width,
+            ar_image_hidden_states,
+            ar_image_attention_mask,
         )
 
         text_hidden_states, img_tokens = self._apply_refiners(
diff --git a/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py b/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
index 614c8268c..5298d5514 100644
--- a/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
+++ b/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
@@ -42,6 +42,7 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
     hf_to_vllm_mapper = WeightsMapper(
         orig_to_new_prefix={
             "llm_model.": None,
+            "gen_tokenizer.": None,
         }
     )
 
@@ -77,11 +78,23 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
             )
         self._reinit_caption_embedder(llm_hidden_size)
 
-        # Optional: image condition refiner (Q-Former)
-        if self.config.gen_image_condition_refiner_config is not None:
+        # Optional image condition Q-Former. Preview stores it as a standalone
+        # module; Dev stores it under the DiT timestep/caption embedder.
+        llm_model_type = getattr(self.config.llm_config, "model_type", "")
+        refiner_config = self.config.gen_image_condition_refiner_config
+        if refiner_config is not None and llm_model_type == "mammothmoda2_qwen3_vl":
+            dit_hidden_size = int(self.gen_transformer.hidden_size)
+            self.gen_transformer.time_caption_embed.image_embedder = SimpleQFormerImageRefiner(
+                hidden_size=llm_hidden_size,
+                output_hidden_size=dit_hidden_size,
+                num_heads=max(1, dit_hidden_size // 128),
+                **refiner_config,
+            )
+            self.gen_image_condition_refiner = None
+        elif refiner_config is not None:
             self.gen_image_condition_refiner = SimpleQFormerImageRefiner(
                 hidden_size=llm_hidden_size,
-                **self.config.gen_image_condition_refiner_config,
+                **refiner_config,
             )
         else:
             self.gen_image_condition_refiner = None
@@ -237,6 +250,13 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
 
         text_cond = _ensure_2d(text_cond, "text_prompt_embeds")
         image_cond = _ensure_2d(image_cond, "image_prompt_embeds")
+        if image_cond.shape[0] == 0:
+            answer_token_ids = info.get("full_token_ids", [])[int(info.get("answer_start_index", [0])[0]) :]
+            raise ValueError(
+                "MammothModa2 AR stage produced no visual-token hidden states; "
+                "the DiT stage requires at least one generated visual token. "
+                f"Generated token ids: {answer_token_ids[:32]}"
+            )
         text_cond = text_cond.to(device=model_device, dtype=target_dtype, non_blocking=True).contiguous()
         image_cond = image_cond.to(device=model_device, dtype=target_dtype, non_blocking=True).contiguous()
 
@@ -263,8 +283,17 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
                 device=image_embeds.device,
             )
 
-        prompt_embeds = torch.cat([text_embeds, image_embeds], dim=1)
-        prompt_attention_mask = torch.cat([text_attention_mask, image_attention_mask], dim=1)
+        nested_image_embedder = getattr(self.gen_transformer.time_caption_embed, "image_embedder", None)
+        if nested_image_embedder is None:
+            prompt_embeds = torch.cat([text_embeds, image_embeds], dim=1)
+            prompt_attention_mask = torch.cat([text_attention_mask, image_attention_mask], dim=1)
+            ar_image_embeds = None
+            ar_image_attention_mask = None
+        else:
+            prompt_embeds = text_embeds
+            prompt_attention_mask = text_attention_mask
+            ar_image_embeds = image_embeds
+            ar_image_attention_mask = image_attention_mask
 
         # Prepare negative prompt (for CFG). If none provided, fall back to unconditional.
         negative_prompt_embeds = None
@@ -337,6 +366,8 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
                 text_hidden_states=prompt_embeds,
                 text_attention_mask=prompt_attention_mask,
                 ref_image_hidden_states=None,
+                ar_image_hidden_states=ar_image_embeds,
+                ar_image_attention_mask=ar_image_attention_mask,
                 freqs_cis=self.gen_freqs_cis,
             )
             guidance_scale = text_guidance_scale if cfg_range[0] <= i / total_steps <= cfg_range[1] else 1.0
diff --git a/vllm_omni/diffusion/models/minimax_h3/__init__.py b/vllm_omni/diffusion/models/minimax_h3/__init__.py
new file mode 100644
index 000000000..53052ad42
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/__init__.py
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 audio-video diffusion support."""
+
+from .pipeline_minimax_h3 import (
+    MiniMaxH3Pipeline,
+    get_minimax_h3_post_process_func,
+)
+
+__all__ = [
+    "MiniMaxH3Pipeline",
+    "get_minimax_h3_post_process_func",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/condition_noise.py b/vllm_omni/diffusion/models/minimax_h3/condition_noise.py
new file mode 100644
index 000000000..8ac769792
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/condition_noise.py
@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 visual/audio condition-noise augmentation.
+
+The request's condition timestep is applied to both the tensor value and the
+DiT timestep. Tokenizer artifacts remain clean
+and reusable; this module materializes the fixed noised anchors immediately
+before the denoise loop.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+from .packed_tokens import minimax_h3_patchify_video_latent
+
+# Channel-major packed audio rows always carry a stereo layout.
+MINIMAX_H3_AUDIO_COND_CHANNELS = 2
+
+
+def minimax_h3_imgvid_cond_noise_aug_rows(
+    clean_rows: torch.Tensor,
+    *,
+    condition_shapes: Sequence[Sequence[int]],
+    target_latent_t: int,
+    imgvid_cond_num_frames: int,
+    seed: int,
+    noise_aug: float,
+) -> torch.Tensor:
+    """Apply the imgvid-condition RF noise recipe to packed clean rows.
+
+    ``condition_shapes`` contains ``(latent_t, latent_h, latent_w)`` in packed
+    visual-condition order. A new CPU generator with the same row seed is
+    created for every condition. Under the dependent-noise policy, each draw
+    uses the target temporal length plus the template's imgvid-condition frame
+    count, then slices the prefix matching the current condition.
+    """
+
+    noise_aug = float(noise_aug)
+    if not 0.0 <= noise_aug <= 1.0:
+        raise ValueError(f"noise_aug must be in [0, 1], got {noise_aug}")
+    if noise_aug == 1.0:
+        return clean_rows
+    if clean_rows.ndim != 2 or int(clean_rows.shape[1]) != 96:
+        raise ValueError(f"clean imgvid condition rows must have shape [n, 96], got {list(clean_rows.shape)}")
+
+    target_latent_t = int(target_latent_t)
+    imgvid_cond_num_frames = int(imgvid_cond_num_frames)
+    if target_latent_t <= 0:
+        raise ValueError(f"target_latent_t must be positive, got {target_latent_t}")
+    if imgvid_cond_num_frames <= 0:
+        raise ValueError(
+            f"imgvid_cond_num_frames must be positive when condition rows exist, got {imgvid_cond_num_frames}"
+        )
+
+    parsed_shapes: list[tuple[int, int, int]] = []
+    expected_rows = 0
+    for raw_shape in condition_shapes:
+        if len(raw_shape) != 3:
+            raise ValueError(
+                f"each imgvid condition shape must be (latent_t, latent_h, latent_w), got {list(raw_shape)}"
+            )
+        latent_t, latent_h, latent_w = (int(value) for value in raw_shape)
+        if latent_t <= 0 or latent_h <= 0 or latent_w <= 0:
+            raise ValueError(f"imgvid condition shape must be positive, got {list(raw_shape)}")
+        if latent_h % 2 or latent_w % 2:
+            raise ValueError(
+                f"imgvid condition spatial dimensions must be divisible by 2, got {(latent_t, latent_h, latent_w)}"
+            )
+        parsed_shapes.append((latent_t, latent_h, latent_w))
+        expected_rows += latent_t * (latent_h // 2) * (latent_w // 2)
+    if not parsed_shapes:
+        raise ValueError("condition_shapes must not be empty")
+    if int(clean_rows.shape[0]) != expected_rows:
+        raise ValueError(
+            f"clean imgvid condition rows {int(clean_rows.shape[0])} != shape-derived rows {expected_rows}"
+        )
+
+    output_device = clean_rows.device
+    clean_rows = clean_rows.detach().to(device="cpu", dtype=torch.float32)
+    out: list[torch.Tensor] = []
+    row_offset = 0
+    timestep = torch.tensor(noise_aug, dtype=torch.float32, device="cpu")
+    for latent_t, latent_h, latent_w in parsed_shapes:
+        # Official Ref2VA allows a reference video to be longer than the
+        # generated clip.  The old implementation sized the draw only from
+        # the target clip and consequently rejected valid long references.
+        full_t = max(target_latent_t + imgvid_cond_num_frames, latent_t)
+        generator = torch.Generator(device="cpu").manual_seed(int(seed))
+        noise = torch.randn(
+            1,
+            24,
+            full_t,
+            latent_h,
+            latent_w,
+            generator=generator,
+            dtype=torch.float32,
+            device="cpu",
+        )[:, :, :latent_t]
+        noise_rows = minimax_h3_patchify_video_latent(noise, patch_size=[1, 2, 2]).to(dtype=torch.float32)
+        row_count = int(noise_rows.shape[0])
+        clean_part = clean_rows[row_offset : row_offset + row_count].to(torch.float32)
+        out.append(timestep * clean_part + (1.0 - timestep) * noise_rows)
+        row_offset += row_count
+    return torch.cat(out, dim=0).to(device=output_device, dtype=torch.float32).contiguous()
+
+
+def minimax_h3_audio_cond_noise_aug_rows(
+    clean_rows: torch.Tensor,
+    *,
+    condition_audio_t: Sequence[int],
+    seed: int,
+    noise_aug: float,
+) -> torch.Tensor:
+    """Apply the audio-condition RF noise recipe to packed clean rows.
+
+    ``condition_audio_t`` contains the latent T of each audio-bearing
+    condition in canonical request order. Noise is drawn per condition
+    element, with a fresh CPU generator seeded with ``seed + 1`` for every
+    element.  Consequently each condition restarts the
+    same RNG stream; concatenating the rows and drawing once would be
+    numerically different for ordered multi-reference requests.
+
+    The mix is intentionally evaluated on CPU in fp32 before the packed rows
+    are transferred to the DiT device.
+    """
+
+    noise_aug = float(noise_aug)
+    if not 0.0 <= noise_aug <= 1.0:
+        raise ValueError(f"noise_aug must be in [0, 1], got {noise_aug}")
+    if noise_aug == 1.0:
+        return clean_rows
+    if clean_rows.ndim != 2 or int(clean_rows.shape[1]) != 32:
+        raise ValueError(f"clean audio condition rows must have shape [n, 32], got {list(clean_rows.shape)}")
+
+    audio_channels = MINIMAX_H3_AUDIO_COND_CHANNELS
+    parsed_audio_t = [int(value) for value in condition_audio_t]
+    if not parsed_audio_t:
+        raise ValueError("condition_audio_t must not be empty")
+    if any(value <= 0 for value in parsed_audio_t):
+        raise ValueError(f"condition audio latent lengths must be positive, got {parsed_audio_t}")
+    expected_rows = audio_channels * sum(parsed_audio_t)
+    if int(clean_rows.shape[0]) != expected_rows:
+        raise ValueError(f"clean audio condition rows {int(clean_rows.shape[0])} != shape-derived rows {expected_rows}")
+
+    out: list[torch.Tensor] = []
+    row_offset = 0
+    timestep = torch.tensor(noise_aug, dtype=torch.float32, device="cpu")
+    for audio_t in parsed_audio_t:
+        row_count = audio_channels * audio_t
+        clean_part = clean_rows[row_offset : row_offset + row_count].detach().to(device="cpu", dtype=torch.float32)
+        generator = torch.Generator(device="cpu").manual_seed(int(seed) + 1)
+        noise = torch.randn(
+            clean_part.shape,
+            generator=generator,
+            dtype=torch.float32,
+            device="cpu",
+        )
+        out.append(timestep * clean_part + (1.0 - timestep) * noise)
+        row_offset += row_count
+    return torch.cat(out, dim=0).to(device=clean_rows.device, dtype=torch.float32).contiguous()
+
+
+__all__ = [
+    "minimax_h3_audio_cond_noise_aug_rows",
+    "minimax_h3_imgvid_cond_noise_aug_rows",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py b/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py
new file mode 100644
index 000000000..d22065c3a
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/denoise_loop.py
@@ -0,0 +1,267 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 cfg-distilled full denoise loop.
+
+Per step, the positive presentation is forwarded exactly once. Video and audio
+target rows chain through the Euler-eta0 update while visual and audio condition
+rows stay pinned to their noised step-0 anchors.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from typing import Any
+
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import VideoTokenLayout
+from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
+
+from .scheduling_minimax_h3_euler_ancestral import (
+    minimax_h3_euler_eta0_step,
+    minimax_h3_rf_v_to_x0,
+)
+
+MINIMAX_H3_IMGVID_COND_TIMESTEP = 0.999
+# ref2va audio reference anchor timestep
+MINIMAX_H3_AUDIO_REF_COND_TIMESTEP = 1.0
+# Packed row widths: video rows are [1,2,2]-patchified 24-channel latents
+# (24 * 1 * 2 * 2 = 96); audio rows carry the 32-dim audio latent.
+MINIMAX_H3_VIDEO_ROW_WIDTH = 96
+MINIMAX_H3_AUDIO_ROW_WIDTH = 32
+
+
+class MiniMaxH3DenoiseBranch:
+    """Static per-branch state: packed layout + fixed forward kwargs.
+
+    `packed` is a minimax_h3_packed_sequence(...) result (or equivalent layout
+    dict); `text_embeddings` is the branch's [text_len, 5120] hidden states;
+    `token_tags` must already carry any fl2va vision-span overrides.
+    """
+
+    def __init__(
+        self,
+        *,
+        packed: dict[str, torch.Tensor],
+        text_embeddings: torch.Tensor,
+        token_tags: torch.Tensor,
+        device: torch.device,
+    ) -> None:
+        seq_len = int(packed["seq_len"])
+        self.seq_len = seq_len
+        self.img_pos = packed["img_pos"].view(-1).to(torch.long)
+        self.audio_pos = packed["audio_pos"].view(-1).to(torch.long)
+        self.update_mask = packed["update_mask"].view(-1).to(torch.bool)
+        # ref2va: audio_pos may include reference-audio anchor rows
+        # (audio_update_mask False); absent means all rows are targets.
+        if "audio_update_mask" in packed:
+            self.audio_update_mask = packed["audio_update_mask"].view(-1).to(torch.bool)
+        else:
+            self.audio_update_mask = torch.ones(self.audio_pos.shape[0], dtype=torch.bool)
+        text_len = int(packed["text_pos"].view(-1).shape[0])
+        if list(text_embeddings.shape)[0] != text_len:
+            raise ValueError(f"text_embeddings rows {list(text_embeddings.shape)} != packed text_len {text_len}")
+        if int(token_tags.view(-1).shape[0]) != seq_len:
+            raise ValueError(f"token_tags length {int(token_tags.view(-1).shape[0])} != seq_len {seq_len}")
+        cu = packed["cu_seqlens"].to(torch.int32)
+        self.img_pos_dev = self.img_pos.to(device)
+        self.audio_pos_dev = self.audio_pos.to(device)
+        self.update_mask_dev = self.update_mask.to(device)
+        self.audio_update_mask_dev = self.audio_update_mask.to(device)
+        self.x_base = torch.zeros(1, seq_len, MINIMAX_H3_VIDEO_ROW_WIDTH, dtype=torch.float32, device=device)
+        self.audio_x_base = torch.zeros(1, seq_len, MINIMAX_H3_AUDIO_ROW_WIDTH, dtype=torch.float32, device=device)
+        text_pos_dev = packed["text_pos"].view(-1).to(torch.long).to(device)
+        self.static_kwargs: dict[str, Any] = {
+            "img_position_ids": packed["img_position_ids"][None].to(device),
+            "update_mask": self.update_mask_dev,
+            "token_tags": token_tags.view(-1).to(torch.long).to(device),
+            "skip_mask_out_condition": False,
+            "prompt_embeds": text_embeddings.to(device),
+            "img_pos_info": {"position_ids": self.img_pos_dev},
+            "audio_pos_info": {"position_ids": self.audio_pos_dev},
+            "text_pos_info": {"position_ids": text_pos_dev},
+            "img_pos_for_infer_output_info": {"position_ids": self.img_pos_dev},
+            "packed_seq_params": {
+                "cu_seqlens_q": cu.to(device),
+                "max_seqlen_q": int(cu[1]),
+            },
+            "refiner_packed_seq_params": {
+                "cu_seqlens_q": torch.tensor([0, text_len, text_len], dtype=torch.int32, device=device),
+                "max_seqlen_q": text_len,
+            },
+        }
+        # Where the video segment sits in the packed sequence. Resolved to plain
+        # ints here so the attention layers never sync on it per step.
+        grid = packed["latent_grid"].tolist()
+        self.static_kwargs["video_token_layout"] = VideoTokenLayout(
+            prefix_len=int(packed["video_row_start"]),
+            latent_grid=(int(grid[0]), int(grid[1]), int(grid[2])),
+        )
+
+    def forward_kwargs(
+        self,
+        *,
+        video_rows: torch.Tensor,
+        audio_rows: torch.Tensor,
+        t_video: float,
+        t_audio: float,
+        imgvid_cond_timestep: float,
+        audio_ref_cond_timestep: float,
+    ) -> dict[str, Any]:
+        x = self.x_base.clone()
+        x[0].index_copy_(0, self.img_pos_dev, video_rows)
+        audio_x = self.audio_x_base.clone()
+        audio_x[0].index_copy_(0, self.audio_pos_dev, audio_rows)
+        # Packed-sequence timestep semantics: non-media rows (text and
+        # padding) inherit the current video timestep. Later steps must reuse
+        # the previous step's updated rows; re-initializing from zeros is only
+        # valid at step 0.
+        timesteps = torch.full(
+            (self.seq_len,),
+            float(t_video),
+            dtype=torch.float32,
+            device=x.device,
+        )
+        timesteps[self.img_pos_dev[self.update_mask_dev]] = t_video
+        timesteps[self.img_pos_dev[~self.update_mask_dev]] = imgvid_cond_timestep
+        timesteps[self.audio_pos_dev[self.audio_update_mask_dev]] = t_audio
+        timesteps[self.audio_pos_dev[~self.audio_update_mask_dev]] = audio_ref_cond_timestep
+        unique_timesteps, inverse_indices = torch.unique(timesteps, sorted=True, return_inverse=True)
+        return {
+            **self.static_kwargs,
+            "x": x,
+            "audio_x": audio_x,
+            "unique_timesteps": unique_timesteps,
+            "inverse_indices": inverse_indices,
+        }
+
+
+def minimax_h3_denoise_loop(
+    *,
+    model: Any,
+    positive: MiniMaxH3DenoiseBranch,
+    initial_video_rows: torch.Tensor,
+    initial_audio_rows: torch.Tensor,
+    keyframe_cond_rows: torch.Tensor | None,
+    audio_ref_rows: torch.Tensor | None = None,
+    sigmas_video: list[float],
+    sigmas_audio: list[float],
+    device: torch.device,
+    imgvid_cond_noise_aug_for_inference: float = MINIMAX_H3_IMGVID_COND_TIMESTEP,
+    audio_cond_noise_aug_for_inference: float = MINIMAX_H3_AUDIO_REF_COND_TIMESTEP,
+    on_step_end: Callable[[int, torch.Tensor, torch.Tensor], None] | None = None,
+    on_step_start: Callable[[int, float, float], None] | None = None,
+    step_profiler: Callable[[int], AbstractContextManager] | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Run the full denoise loop; returns final (video_rows, audio_rows).
+
+    ``initial_video_rows`` covers all image rows of the positive layout. For a
+    conditional task, pass ``keyframe_cond_rows`` and/or ``audio_ref_rows`` to
+    pin those rows across every step. The model's raw positive velocity is the
+    update signal; MiniMax H3 only supports cfg-distilled checkpoints.
+    """
+    if len(sigmas_video) != len(sigmas_audio):
+        raise ValueError("video/audio sigma schedules must have equal length")
+    if len(sigmas_video) < 2:
+        raise ValueError("sigma schedules need at least 2 entries")
+    n_cond = int((~positive.update_mask).sum())
+    if keyframe_cond_rows is None:
+        if n_cond != 0:
+            raise ValueError(f"layout has {n_cond} cond rows but keyframe_cond_rows is None")
+    else:
+        if int(keyframe_cond_rows.shape[0]) != n_cond:
+            raise ValueError(f"keyframe_cond_rows {int(keyframe_cond_rows.shape[0])} != layout cond rows {n_cond}")
+    video_rows = initial_video_rows.to(device=device, dtype=torch.float32).clone()
+    audio_rows = initial_audio_rows.to(device=device, dtype=torch.float32).clone()
+    update = positive.update_mask_dev
+    audio_update = positive.audio_update_mask_dev
+    if int(video_rows.shape[0]) != int(positive.img_pos.shape[0]):
+        raise ValueError(
+            f"initial video rows {int(video_rows.shape[0])} != positive layout rows {int(positive.img_pos.shape[0])}"
+        )
+    if int(audio_rows.shape[0]) != int(positive.audio_pos.shape[0]):
+        raise ValueError(
+            f"initial audio rows {int(audio_rows.shape[0])} != positive layout rows {int(positive.audio_pos.shape[0])}"
+        )
+    n_audio_ref = int((~positive.audio_update_mask).sum())
+    if audio_ref_rows is None:
+        if n_audio_ref != 0:
+            raise ValueError(f"layout has {n_audio_ref} audio ref rows but audio_ref_rows is None")
+        audio_anchor = None
+    else:
+        if int(audio_ref_rows.shape[0]) != n_audio_ref:
+            raise ValueError(f"audio_ref_rows {int(audio_ref_rows.shape[0])} != layout audio ref rows {n_audio_ref}")
+        audio_anchor = audio_ref_rows.to(device=device, dtype=torch.float32)
+    cond_anchor = keyframe_cond_rows.to(device=device, dtype=torch.float32) if keyframe_cond_rows is not None else None
+    if cond_anchor is not None:
+        video_rows[~update] = cond_anchor
+    if audio_anchor is not None:
+        audio_rows[~audio_update] = audio_anchor
+
+    num_steps = len(sigmas_video) - 1
+    for step in range(num_steps):
+        step_cm = step_profiler(step) if step_profiler is not None else nullcontext()
+        with step_cm:
+            # Publish the step index so step-gated attention features (e.g. the
+            # dense warmup of RAINFUSION_ATTN) can see where we are.
+            set_forward_context_denoise_step_idx(step)
+            s_v, s_v_next = sigmas_video[step], sigmas_video[step + 1]
+            s_a, s_a_next = sigmas_audio[step], sigmas_audio[step + 1]
+            if on_step_start is not None:
+                # Attention gates use the scheduler-style descending timestep.
+                on_step_start(step, s_v, s_a)
+            t_v, t_a = 1.0 - s_v, 1.0 - s_a
+            imgvid_cond_t = max(t_v, float(imgvid_cond_noise_aug_for_inference))
+            audio_ref_cond_t = max(t_a, float(audio_cond_noise_aug_for_inference))
+
+            fk = positive.forward_kwargs(
+                video_rows=video_rows,
+                audio_rows=audio_rows,
+                t_video=t_v,
+                t_audio=t_a,
+                imgvid_cond_timestep=imgvid_cond_t,
+                audio_ref_cond_timestep=audio_ref_cond_t,
+            )
+            with torch.inference_mode():
+                v_video, v_audio = model(**fk)
+            mv_video_t = v_video.float()[update]
+            mv_audio_t = v_audio.float()[audio_update]
+
+            x0_video = minimax_h3_rf_v_to_x0(
+                video_rows[update],
+                mv_video_t,
+                torch.tensor(t_v, dtype=torch.float32, device=device),
+            )
+            new_target = minimax_h3_euler_eta0_step(video_rows[update], x0_video, sigma_curr=s_v, sigma_next=s_v_next)
+            video_rows = video_rows.clone()
+            video_rows[update] = new_target
+            if cond_anchor is not None:
+                video_rows[~update] = cond_anchor  # per-step imgvid cond reset
+
+            x0_audio = minimax_h3_rf_v_to_x0(
+                audio_rows[audio_update],
+                mv_audio_t,
+                torch.tensor(t_a, dtype=torch.float32, device=device),
+            )
+            new_audio = minimax_h3_euler_eta0_step(
+                audio_rows[audio_update], x0_audio, sigma_curr=s_a, sigma_next=s_a_next
+            )
+            audio_rows = audio_rows.clone()
+            audio_rows[audio_update] = new_audio
+            if audio_anchor is not None:
+                audio_rows[~audio_update] = audio_anchor  # per-step audio ref reset
+            if on_step_end is not None:
+                on_step_end(step, video_rows, audio_rows)
+
+    set_forward_context_denoise_step_idx(None)
+    return video_rows, audio_rows
+
+
+__all__ = [
+    "MINIMAX_H3_AUDIO_REF_COND_TIMESTEP",
+    "MINIMAX_H3_AUDIO_ROW_WIDTH",
+    "MINIMAX_H3_IMGVID_COND_TIMESTEP",
+    "MINIMAX_H3_VIDEO_ROW_WIDTH",
+    "MiniMaxH3DenoiseBranch",
+    "minimax_h3_denoise_loop",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/encoder.py b/vllm_omni/diffusion/models/minimax_h3/encoder.py
new file mode 100644
index 000000000..f811eeecb
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/encoder.py
@@ -0,0 +1,1282 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 Qwen3-VL layer-50 text/vision encoder.
+
+The encoder is reimplemented on top of vLLM-style tensor-parallel building
+blocks (column/row/vocab-parallel linears bound to the MiniMax H3 encoder
+process group) instead of the single-GPU ``transformers`` backbone.  This
+makes the large Qwen3-VL text model TP-shardable across ``text_encoder_tp_size``
+ranks, which removes the rank-0 memory hotspot that dominates no-offload peak
+memory (the retained 50-layer encoder is ~51.5 GB in BF16).
+
+The computation contract is unchanged from the HF reference path:
+
+- plain BF16 weights, only the first ``MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER``
+  decoder layers are kept (the checkpoint consumes the unnormalized hidden
+  state after decoder layer 49);
+- cuDNN SDP is enabled during encode;
+- the multimodal backbone runs with an all-ones attention mask and
+  ``mm_token_type_ids`` derived from the image/video token ids;
+- DeepStack visual features are injected at the first
+  ``len(deepstack_visual_indexes)`` decoder layers;
+- the output is ``hidden_states[50]`` of shape ``[seq, 5120]``.
+
+Tensor parallelism follows vLLM's TP semantics: vocab-parallel embeddings and
+row-parallel projections all-reduce so the hidden state stays fully replicated
+on every encoder rank, while column-parallel projections (QKV / MLP up) keep a
+local shard.  After the final layer every encoder rank therefore holds the
+complete ``[seq, 5120]`` hidden state.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import re
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from vllm.logger import init_logger
+
+MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER = 50
+MINIMAX_H3_QWEN3VL_HIDDEN_DIM = 5120
+
+logger = init_logger(__name__)
+
+
+def _default_weight_loader(
+    param: nn.Parameter,
+    loaded_weight: torch.Tensor,
+    loaded_shard_id: str | None = None,
+) -> None:
+    del loaded_shard_id
+    param.data.copy_(loaded_weight)
+
+
+def _tp_range(group: Any) -> tuple[int, int]:
+    return group.rank_in_group, group.world_size
+
+
+# ---------------------------------------------------------------------------
+# Tensor-parallel primitives bound to the encoder process group.
+#
+# These mirror the math of vLLM's ``VocabParallelEmbedding``,
+# ``ColumnParallelLinear``, ``MergedColumnParallelLinear``, ``QKVParallelLinear``
+# and ``RowParallelLinear`` but route their collectives through the encoder
+# group instead of the (DiT) tensor-model-parallel group, so the text encoder
+# can be sharded independently of the DiT's TP configuration.
+# ---------------------------------------------------------------------------
+
+
+class MiniMaxH3Qwen3VLVocabParallelEmbedding(nn.Module):
+    def __init__(self, group: Any, num_embeddings: int, embedding_dim: int, dtype: torch.dtype) -> None:
+        super().__init__()
+        self.group = group
+        self.num_embeddings = num_embeddings
+        self.embedding_dim = embedding_dim
+        tp_rank, tp_size = _tp_range(group)
+        assert num_embeddings % tp_size == 0, (
+            f"vocab_size {num_embeddings} must be divisible by text_encoder_tp_size {tp_size}"
+        )
+        self.num_embeddings_per_partition = num_embeddings // tp_size
+        self.weight = nn.Parameter(torch.empty(self.num_embeddings_per_partition, embedding_dim, dtype=dtype))
+        self.weight.weight_loader = self.weight_loader  # type: ignore[attr-defined]
+        self._tp_rank = tp_rank
+        self._tp_size = tp_size
+
+    def forward(self, input_: torch.Tensor) -> torch.Tensor:
+        if self._tp_size == 1:
+            return F.embedding(input_, self.weight)
+        # Mirror vLLM's `VocabParallelEmbedding`: token ids that fall outside
+        # this rank's vocab partition are masked to 0 and in-partition ids are
+        # shifted to local indices before the local gather.  The out-of-range
+        # rows are zeroed so the subsequent all-reduce reconstructs the full
+        # embedding for every token.
+        start_idx = self._tp_rank * self.num_embeddings_per_partition
+        end_idx = start_idx + self.num_embeddings_per_partition
+        input_mask = (input_ < start_idx) | (input_ >= end_idx)
+        masked_input = input_.clone() - start_idx
+        masked_input[input_mask] = 0
+        output = F.embedding(masked_input, self.weight)
+        output[input_mask, :] = 0.0
+        self.group.all_reduce(output)
+        return output
+
+    def weight_loader(
+        self, param: nn.Parameter, loaded_weight: torch.Tensor, loaded_shard_id: str | None = None
+    ) -> None:
+        del loaded_shard_id
+        shard_size = self.num_embeddings_per_partition
+        start_idx = self._tp_rank * shard_size
+        param.data.copy_(loaded_weight.narrow(0, start_idx, shard_size))
+
+
+class MiniMaxH3Qwen3VLMergedColumnParallelLinear(nn.Module):
+    """Packed gate/up projection sharded along the output dimension."""
+
+    def __init__(
+        self,
+        group: Any,
+        input_size: int,
+        intermediate_size: int,
+        dtype: torch.dtype,
+    ) -> None:
+        super().__init__()
+        self.group = group
+        self.input_size = input_size
+        self.intermediate_size = intermediate_size
+        tp_rank, tp_size = _tp_range(group)
+        assert intermediate_size % tp_size == 0, (
+            f"intermediate_size {intermediate_size} must be divisible by text_encoder_tp_size {tp_size}"
+        )
+        self.intermediate_size_per_partition = intermediate_size // tp_size
+        self.weight = nn.Parameter(torch.empty(2 * self.intermediate_size_per_partition, input_size, dtype=dtype))
+        self.weight.weight_loader = self.weight_loader  # type: ignore[attr-defined]
+        self._tp_rank = tp_rank
+        self._tp_size = tp_size
+
+    def forward(self, input_: torch.Tensor) -> torch.Tensor:
+        return F.linear(input_, self.weight)
+
+    def weight_loader(
+        self, param: nn.Parameter, loaded_weight: torch.Tensor, loaded_shard_id: str | None = None
+    ) -> None:
+        shard_size = self.intermediate_size_per_partition
+        start_idx = self._tp_rank * shard_size
+        if loaded_shard_id == 1:  # up_proj
+            param.data[shard_size : 2 * shard_size].copy_(loaded_weight.narrow(0, start_idx, shard_size))
+        else:  # gate_proj
+            param.data[0:shard_size].copy_(loaded_weight.narrow(0, start_idx, shard_size))
+
+
+class MiniMaxH3Qwen3VLQKVParallelLinear(nn.Module):
+    """QKV projection with GQA head sharding along the output dimension."""
+
+    def __init__(
+        self,
+        group: Any,
+        hidden_size: int,
+        num_heads: int,
+        num_kv_heads: int,
+        head_dim: int,
+        dtype: torch.dtype,
+    ) -> None:
+        super().__init__()
+        self.group = group
+        self.hidden_size = hidden_size
+        self.num_heads = num_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+        tp_rank, tp_size = _tp_range(group)
+        assert num_heads % tp_size == 0, (
+            f"num_attention_heads {num_heads} must be divisible by text_encoder_tp_size {tp_size}"
+        )
+        assert num_kv_heads % tp_size == 0, (
+            f"num_key_value_heads {num_kv_heads} must be divisible by text_encoder_tp_size {tp_size}"
+        )
+        self.local_num_heads = num_heads // tp_size
+        self.local_num_kv_heads = num_kv_heads // tp_size
+        q_local = self.local_num_heads * head_dim
+        kv_local = self.local_num_kv_heads * head_dim
+        self.weight = nn.Parameter(torch.empty(q_local + 2 * kv_local, hidden_size, dtype=dtype))
+        self.weight.weight_loader = self.weight_loader  # type: ignore[attr-defined]
+        self._tp_rank = tp_rank
+        self._tp_size = tp_size
+
+    def forward(self, input_: torch.Tensor) -> torch.Tensor:
+        return F.linear(input_, self.weight)
+
+    def weight_loader(
+        self, param: nn.Parameter, loaded_weight: torch.Tensor, loaded_shard_id: str | None = None
+    ) -> None:
+        head_dim = self.head_dim
+        q_local = self.local_num_heads * head_dim
+        kv_local = self.local_num_kv_heads * head_dim
+        if loaded_shard_id == "q":
+            start_idx = self._tp_rank * q_local
+            param.data[0:q_local].copy_(loaded_weight.narrow(0, start_idx, q_local))
+        elif loaded_shard_id == "k":
+            start_idx = self._tp_rank * kv_local
+            param.data[q_local : q_local + kv_local].copy_(loaded_weight.narrow(0, start_idx, kv_local))
+        elif loaded_shard_id == "v":
+            start_idx = self._tp_rank * kv_local
+            param.data[q_local + kv_local : q_local + 2 * kv_local].copy_(loaded_weight.narrow(0, start_idx, kv_local))
+        else:
+            raise ValueError(f"unexpected QKV shard id {loaded_shard_id!r}")
+
+
+class MiniMaxH3Qwen3VLRowParallelLinear(nn.Module):
+    def __init__(
+        self,
+        group: Any,
+        input_size: int,
+        output_size: int,
+        dtype: torch.dtype,
+        input_is_parallel: bool = True,
+    ) -> None:
+        super().__init__()
+        self.group = group
+        self.input_size = input_size
+        self.output_size = output_size
+        self.input_is_parallel = input_is_parallel
+        tp_rank, tp_size = _tp_range(group)
+        assert input_size % tp_size == 0, f"input_size {input_size} must be divisible by text_encoder_tp_size {tp_size}"
+        self.input_size_per_partition = input_size // tp_size
+        self.weight = nn.Parameter(torch.empty(output_size, self.input_size_per_partition, dtype=dtype))
+        self.weight.weight_loader = self.weight_loader  # type: ignore[attr-defined]
+        self._tp_rank = tp_rank
+        self._tp_size = tp_size
+
+    def forward(self, input_: torch.Tensor) -> torch.Tensor:
+        if self.input_is_parallel:
+            input_parallel = input_
+        else:
+            split_input = input_.split(self.input_size_per_partition, dim=-1)
+            input_parallel = split_input[self._tp_rank].contiguous()
+        output_parallel = F.linear(input_parallel, self.weight)
+        if self._tp_size > 1:
+            # Reduce in fp32: the reference path accumulates the full (K=8192)
+            # dot product inside a single cuBLAS GEMM before rounding to bf16.
+            # A bf16 all-reduce of the per-rank partial GEMMs would round twice
+            # and amplify error on this model's large-magnitude activations.
+            output_parallel = output_parallel.float()
+            self.group.all_reduce(output_parallel)
+            output_parallel = output_parallel.to(self.weight.dtype)
+        return output_parallel
+
+    def weight_loader(
+        self, param: nn.Parameter, loaded_weight: torch.Tensor, loaded_shard_id: str | None = None
+    ) -> None:
+        del loaded_shard_id
+        shard_size = self.input_size_per_partition
+        start_idx = self._tp_rank * shard_size
+        param.data.copy_(loaded_weight.narrow(1, start_idx, shard_size))
+
+
+# ---------------------------------------------------------------------------
+# Shared math ports (identical to the HF reference path).
+# ---------------------------------------------------------------------------
+
+
+class MiniMaxH3Qwen3VLRMSNorm(nn.Module):
+    def __init__(self, hidden_size: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+
+def _rotate_half(x: torch.Tensor) -> torch.Tensor:
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def _apply_rotary_pos_emb(
+    q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+    cos = cos.unsqueeze(1)
+    sin = sin.unsqueeze(1)
+    q_embed = (q * cos) + (_rotate_half(q) * sin)
+    k_embed = (k * cos) + (_rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+def _apply_interleaved_mrope(freqs: torch.Tensor, mrope_section: list[int]) -> torch.Tensor:
+    """Reorganize chunked [TTT...HHH...WWW] into interleaved [THWTHW...] layout."""
+    freqs_t = freqs[0]
+    for dim, offset in enumerate((1, 2), start=1):
+        length = mrope_section[dim] * 3
+        idx = slice(offset, length, 3)
+        freqs_t[..., idx] = freqs[dim, ..., idx]
+    return freqs_t
+
+
+class MiniMaxH3Qwen3VLTextRotaryEmbedding(nn.Module):
+    """Qwen3-VL text M-RoPE (interleaved sections). Same math as the reference."""
+
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.config = config
+        # ``dim`` and ``base`` are plain attributes so the inverse frequencies
+        # are always recomputed in float32 (module-wide dtype casts must not
+        # degrade the RoPE cache precision).
+        self.dim = int(getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads)
+        self.base = float(config.rope_parameters["rope_theta"])
+        self.mrope_section = config.rope_parameters.get("mrope_section", [24, 20, 20])
+
+    def _get_inv_freq(self, device: torch.device) -> torch.Tensor:
+        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float() / self.dim))
+        return inv_freq.to(device)
+
+    def forward(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        # position_ids: (3, 1, seq)
+        inv_freq = self._get_inv_freq(position_ids.device)
+        inv_freq_expanded = inv_freq[None, None, :, None].float().expand(3, position_ids.shape[1], -1, 1)
+        position_ids_expanded = position_ids[:, :, None, :].float()
+        freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(2, 3)
+        freqs = _apply_interleaved_mrope(freqs, self.mrope_section)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        cos = emb.cos()
+        sin = emb.sin()
+        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+# ---------------------------------------------------------------------------
+# Qwen3-VL vision tower (replicated on every encoder rank; ~1.2 GB BF16).
+# ---------------------------------------------------------------------------
+
+
+class MiniMaxH3Qwen3VLVisionPatchEmbed(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.patch_size = config.patch_size
+        self.temporal_patch_size = config.temporal_patch_size
+        self.in_channels = config.in_channels
+        self.embed_dim = config.hidden_size
+        kernel_size = [self.temporal_patch_size, self.patch_size, self.patch_size]
+        self.proj = nn.Conv3d(self.in_channels, self.embed_dim, kernel_size=kernel_size, stride=kernel_size, bias=True)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        target_dtype = self.proj.weight.dtype
+        hidden_states = hidden_states.view(
+            -1, self.in_channels, self.temporal_patch_size, self.patch_size, self.patch_size
+        )
+        hidden_states = self.proj(hidden_states.to(dtype=target_dtype)).view(-1, self.embed_dim)
+        return hidden_states
+
+
+class MiniMaxH3Qwen3VLVisionRotaryEmbedding(nn.Module):
+    def __init__(self, dim: int, theta: float = 10000.0) -> None:
+        super().__init__()
+        self.dim = dim
+        self.theta = theta
+        # Plain attribute (not a registered buffer): the reference keeps this
+        # table in float32 and module-wide dtype casts must not touch it.
+        self._inv_freq = 1.0 / (theta ** (torch.arange(0, dim, 2, dtype=torch.float) / dim))
+
+    def forward(self, seqlen: int) -> torch.Tensor:
+        inv_freq = self._inv_freq.to(device=self._inv_freq.device)
+        seq = torch.arange(seqlen, device=inv_freq.device, dtype=torch.float)
+        freqs = torch.outer(seq, inv_freq)
+        return freqs
+
+
+class MiniMaxH3Qwen3VLVisionPatchMerger(nn.Module):
+    def __init__(self, config: Any, use_postshuffle_norm: bool = False) -> None:
+        super().__init__()
+        self.hidden_size = config.hidden_size * (config.spatial_merge_size**2)
+        self.use_postshuffle_norm = use_postshuffle_norm
+        self.norm = nn.LayerNorm(self.hidden_size if use_postshuffle_norm else config.hidden_size, eps=1e-6)
+        self.linear_fc1 = nn.Linear(self.hidden_size, self.hidden_size)
+        self.act_fn = nn.GELU()
+        self.linear_fc2 = nn.Linear(self.hidden_size, config.out_hidden_size)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.norm(x.view(-1, self.hidden_size) if self.use_postshuffle_norm else x).view(-1, self.hidden_size)
+        x = self.linear_fc2(self.act_fn(self.linear_fc1(x)))
+        return x
+
+
+class MiniMaxH3Qwen3VLVisionMLP(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.linear_fc1 = nn.Linear(self.hidden_size, self.intermediate_size, bias=True)
+        self.linear_fc2 = nn.Linear(self.intermediate_size, self.hidden_size, bias=True)
+        # The reference vision MLP uses the tanh GELU approximation
+        # (``gelu_pytorch_tanh``), which differs from the exact erf GELU.
+        self.act_fn = nn.GELU(approximate="tanh")
+
+    def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+        return self.linear_fc2(self.act_fn(self.linear_fc1(hidden_state)))
+
+
+def _apply_rotary_pos_emb_vision(
+    q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+    orig_q_dtype = q.dtype
+    orig_k_dtype = k.dtype
+    q, k = q.float(), k.float()
+    cos, sin = cos.unsqueeze(-2).float(), sin.unsqueeze(-2).float()
+    q_embed = (q * cos) + (_rotate_half(q) * sin)
+    k_embed = (k * cos) + (_rotate_half(k) * sin)
+    q_embed = q_embed.to(orig_q_dtype)
+    k_embed = k_embed.to(orig_k_dtype)
+    return q_embed, k_embed
+
+
+class MiniMaxH3Qwen3VLVisionAttention(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.dim = config.hidden_size
+        self.num_heads = config.num_heads
+        self.head_dim = self.dim // self.num_heads
+        self.num_key_value_groups = 1
+        self.qkv = nn.Linear(self.dim, self.dim * 3, bias=True)
+        self.proj = nn.Linear(self.dim, self.dim)
+        self.scaling = self.head_dim**-0.5
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        cu_seqlens: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        seq_length = hidden_states.shape[0]
+        query_states, key_states, value_states = (
+            self.qkv(hidden_states).reshape(seq_length, 3, self.num_heads, -1).permute(1, 0, 2, 3).unbind(0)
+        )
+        cos, sin = position_embeddings
+        query_states, key_states = _apply_rotary_pos_emb_vision(query_states, key_states, cos, sin)
+
+        query_states = query_states.transpose(0, 1).unsqueeze(0)
+        key_states = key_states.transpose(0, 1).unsqueeze(0)
+        value_states = value_states.transpose(0, 1).unsqueeze(0)
+
+        lengths = cu_seqlens[1:] - cu_seqlens[:-1]
+        splits = [torch.split(tensor, lengths.tolist(), dim=2) for tensor in (query_states, key_states, value_states)]
+        attn_outputs = [
+            F.scaled_dot_product_attention(q, k, v, dropout_p=0.0, is_causal=False) for q, k, v in zip(*splits)
+        ]
+        attn_output = torch.cat(attn_outputs, dim=2)
+        # The SDPA kernel may return a non-contiguous (1, num_heads, seq_len, head_dim)
+        # tensor whose memory layout is seq-major; transpose before flattening exactly
+        # like the reference `sdpa_attention_forward` to avoid scrambling heads.
+        attn_output = attn_output.transpose(1, 2).contiguous()
+        attn_output = attn_output.reshape(seq_length, -1).contiguous()
+        attn_output = self.proj(attn_output)
+        return attn_output
+
+
+class MiniMaxH3Qwen3VLVisionBlock(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.norm1 = nn.LayerNorm(config.hidden_size, eps=1e-6)
+        self.norm2 = nn.LayerNorm(config.hidden_size, eps=1e-6)
+        self.attn = MiniMaxH3Qwen3VLVisionAttention(config=config)
+        self.mlp = MiniMaxH3Qwen3VLVisionMLP(config=config)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        cu_seqlens: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+    ) -> torch.Tensor:
+        hidden_states = hidden_states + self.attn(
+            self.norm1(hidden_states),
+            cu_seqlens=cu_seqlens,
+            position_embeddings=position_embeddings,
+        )
+        hidden_states = hidden_states + self.mlp(self.norm2(hidden_states))
+        return hidden_states
+
+
+class MiniMaxH3Qwen3VLVisionModel(nn.Module):
+    """Qwen3-VL vision tower (patch embed + blocks + merger + DeepStack)."""
+
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.config = config
+        self.spatial_merge_size = config.spatial_merge_size
+        self.patch_size = config.patch_size
+        self.spatial_merge_unit = self.spatial_merge_size * self.spatial_merge_size
+
+        self.patch_embed = MiniMaxH3Qwen3VLVisionPatchEmbed(config=config)
+        self.pos_embed = nn.Embedding(config.num_position_embeddings, config.hidden_size)
+        self.num_grid_per_side = int(config.num_position_embeddings**0.5)
+
+        head_dim = config.hidden_size // config.num_heads
+        self.rotary_pos_emb = MiniMaxH3Qwen3VLVisionRotaryEmbedding(head_dim // 2)
+
+        self.blocks = nn.ModuleList([MiniMaxH3Qwen3VLVisionBlock(config=config) for _ in range(config.depth)])
+        self.merger = MiniMaxH3Qwen3VLVisionPatchMerger(config=config, use_postshuffle_norm=False)
+        self.deepstack_visual_indexes = config.deepstack_visual_indexes
+        self.deepstack_merger_list = nn.ModuleList(
+            [
+                MiniMaxH3Qwen3VLVisionPatchMerger(config=config, use_postshuffle_norm=True)
+                for _ in range(len(config.deepstack_visual_indexes))
+            ]
+        )
+
+    def rot_pos_emb(self, grid_thw: torch.Tensor) -> torch.Tensor:
+        merge_size = self.spatial_merge_size
+        grid_thw_list = grid_thw.tolist()
+        max_hw = max(max(h, w) for _, h, w in grid_thw_list)
+        freq_table = self.rotary_pos_emb(max_hw).to(device=grid_thw.device)
+        device = freq_table.device
+        total_tokens = sum(t * h * w for t, h, w in grid_thw_list)
+        pos_ids = torch.empty((total_tokens, 2), dtype=torch.long, device=device)
+        offset = 0
+        for num_frames, height, width in grid_thw_list:
+            merged_h, merged_w = height // merge_size, width // merge_size
+            block_rows = torch.arange(merged_h, device=device)
+            block_cols = torch.arange(merged_w, device=device)
+            intra_row = torch.arange(merge_size, device=device)
+            intra_col = torch.arange(merge_size, device=device)
+            row_idx = block_rows[:, None, None, None] * merge_size + intra_row[None, None, :, None]
+            col_idx = block_cols[None, :, None, None] * merge_size + intra_col[None, None, None, :]
+            row_idx = row_idx.expand(merged_h, merged_w, merge_size, merge_size).reshape(-1)
+            col_idx = col_idx.expand(merged_h, merged_w, merge_size, merge_size).reshape(-1)
+            coords = torch.stack((row_idx, col_idx), dim=-1)
+            if num_frames > 1:
+                coords = coords.repeat(num_frames, 1)
+            num_tokens = coords.shape[0]
+            pos_ids[offset : offset + num_tokens] = coords
+            offset += num_tokens
+        embeddings = freq_table[pos_ids]
+        embeddings = embeddings.flatten(1)
+        return embeddings
+
+    def fast_pos_embed_interpolate(self, grid_thw: torch.Tensor) -> torch.Tensor:
+        grid_thw_list = grid_thw.tolist()
+        grid_ts = [row[0] for row in grid_thw_list]
+        grid_hs = [row[1] for row in grid_thw_list]
+        grid_ws = [row[2] for row in grid_thw_list]
+        device = self.pos_embed.weight.device
+        idx_list = [[] for _ in range(4)]
+        weight_list = [[] for _ in range(4)]
+        for _, h, w in grid_thw_list:
+            h_idxs = torch.linspace(0, self.num_grid_per_side - 1, h)
+            w_idxs = torch.linspace(0, self.num_grid_per_side - 1, w)
+            h_idxs_floor = h_idxs.int()
+            w_idxs_floor = w_idxs.int()
+            h_idxs_ceil = (h_idxs.int() + 1).clip(max=self.num_grid_per_side - 1)
+            w_idxs_ceil = (w_idxs.int() + 1).clip(max=self.num_grid_per_side - 1)
+            dh = h_idxs - h_idxs_floor
+            dw = w_idxs - w_idxs_floor
+            base_h = h_idxs_floor * self.num_grid_per_side
+            base_h_ceil = h_idxs_ceil * self.num_grid_per_side
+            indices = [
+                (base_h[None].T + w_idxs_floor[None]).flatten(),
+                (base_h[None].T + w_idxs_ceil[None]).flatten(),
+                (base_h_ceil[None].T + w_idxs_floor[None]).flatten(),
+                (base_h_ceil[None].T + w_idxs_ceil[None]).flatten(),
+            ]
+            weights = [
+                ((1 - dh)[None].T * (1 - dw)[None]).flatten(),
+                ((1 - dh)[None].T * dw[None]).flatten(),
+                (dh[None].T * (1 - dw)[None]).flatten(),
+                (dh[None].T * dw[None]).flatten(),
+            ]
+            for i in range(4):
+                idx_list[i].extend(indices[i].tolist())
+                weight_list[i].extend(weights[i].tolist())
+        idx_tensor = torch.tensor(idx_list, dtype=torch.long, device=device)
+        weight_tensor = torch.tensor(weight_list, dtype=self.pos_embed.weight.dtype, device=device)
+        pos_embeds = self.pos_embed(idx_tensor).to(device) * weight_tensor[:, :, None]
+        patch_pos_embeds = pos_embeds[0] + pos_embeds[1] + pos_embeds[2] + pos_embeds[3]
+        patch_pos_embeds = patch_pos_embeds.split([h * w for h, w in zip(grid_hs, grid_ws)])
+        patch_pos_embeds_permute = []
+        merge_size = self.spatial_merge_size
+        for pos_embed, t, h, w in zip(patch_pos_embeds, grid_ts, grid_hs, grid_ws):
+            pos_embed = pos_embed.repeat(t, 1)
+            pos_embed = (
+                pos_embed.view(t, h // merge_size, merge_size, w // merge_size, merge_size, -1)
+                .permute(0, 1, 3, 2, 4, 5)
+                .flatten(0, 4)
+            )
+            patch_pos_embeds_permute.append(pos_embed)
+        return torch.cat(patch_pos_embeds_permute)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        grid_thw: torch.Tensor,
+    ) -> tuple[torch.Tensor, list[torch.Tensor]]:
+        hidden_states = self.patch_embed(hidden_states)
+        pos_embeds = self.fast_pos_embed_interpolate(grid_thw)
+        hidden_states = hidden_states + pos_embeds
+        rotary_pos_emb = self.rot_pos_emb(grid_thw)
+        seq_len, _ = hidden_states.size()
+        hidden_states = hidden_states.reshape(seq_len, -1)
+        rotary_pos_emb = rotary_pos_emb.reshape(seq_len, -1)
+        emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
+        position_embeddings = (emb.cos(), emb.sin())
+        cu_seqlens = torch.repeat_interleave(grid_thw[:, 1] * grid_thw[:, 2], grid_thw[:, 0]).cumsum(
+            dim=0, dtype=torch.int32
+        )
+        cu_seqlens = F.pad(cu_seqlens, (1, 0), value=0)
+        deepstack_feature_lists = []
+        for layer_num, blk in enumerate(self.blocks):
+            hidden_states = blk(
+                hidden_states,
+                cu_seqlens=cu_seqlens,
+                position_embeddings=position_embeddings,
+            )
+            if layer_num in self.deepstack_visual_indexes:
+                deepstack_feature = self.deepstack_merger_list[self.deepstack_visual_indexes.index(layer_num)](
+                    hidden_states
+                )
+                deepstack_feature_lists.append(deepstack_feature)
+        merged_hidden_states = self.merger(hidden_states)
+        return merged_hidden_states, deepstack_feature_lists
+
+
+# ---------------------------------------------------------------------------
+# Qwen3-VL text decoder layers (TP-sharded).
+# ---------------------------------------------------------------------------
+
+
+class MiniMaxH3Qwen3VLTextAttention(nn.Module):
+    def __init__(self, group: Any, config: Any, dtype: torch.dtype) -> None:
+        super().__init__()
+        self.group = group
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.num_kv_heads = config.num_key_value_heads
+        self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+        self.scaling = self.head_dim**-0.5
+        self.is_causal = True
+
+        self.qkv_proj = MiniMaxH3Qwen3VLQKVParallelLinear(
+            group,
+            hidden_size=self.hidden_size,
+            num_heads=self.num_heads,
+            num_kv_heads=self.num_kv_heads,
+            head_dim=self.head_dim,
+            dtype=dtype,
+        )
+        self.o_proj = MiniMaxH3Qwen3VLRowParallelLinear(
+            group,
+            input_size=self.num_heads * self.head_dim,
+            output_size=self.hidden_size,
+            dtype=dtype,
+            input_is_parallel=True,
+        )
+        self.q_norm = MiniMaxH3Qwen3VLRMSNorm(self.head_dim, eps=config.rms_norm_eps)
+        self.k_norm = MiniMaxH3Qwen3VLRMSNorm(self.head_dim, eps=config.rms_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+    ) -> torch.Tensor:
+        input_shape = hidden_states.shape[:-1]
+        hidden_shape = (*input_shape, -1, self.head_dim)
+        q_local = self.qkv_proj.local_num_heads * self.head_dim
+        kv_local = self.qkv_proj.local_num_kv_heads * self.head_dim
+        q_weight = self.qkv_proj.weight[0:q_local]
+        k_weight = self.qkv_proj.weight[q_local : q_local + kv_local]
+        v_weight = self.qkv_proj.weight[q_local + kv_local : q_local + 2 * kv_local]
+        # Three separate GEMMs keep the numerics identical to the reference
+        # path (packed QKV changes cuBLAS tiling and shifts bf16 rounding).
+        query_states = self.q_norm(F.linear(hidden_states, q_weight).view(hidden_shape)).transpose(1, 2)
+        key_states = self.k_norm(F.linear(hidden_states, k_weight).view(hidden_shape)).transpose(1, 2)
+        value_states = F.linear(hidden_states, v_weight).view(hidden_shape).transpose(1, 2)
+
+        cos, sin = position_embeddings
+        query_states, key_states = _apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+        # Expand GQA keys/values to the local query-head count so SDPA works
+        # uniformly across backends (mirrors the reference eager path).
+        num_key_value_groups = self.num_heads // self.num_kv_heads
+        key_states = key_states.repeat_interleave(num_key_value_groups, dim=1)
+        value_states = value_states.repeat_interleave(num_key_value_groups, dim=1)
+
+        attn_output = F.scaled_dot_product_attention(
+            query_states,
+            key_states,
+            value_states,
+            dropout_p=0.0,
+            is_causal=True,
+        )
+        attn_output = attn_output.transpose(1, 2).reshape(*input_shape, -1).contiguous()
+        attn_output = self.o_proj(attn_output)
+        return attn_output
+
+
+class MiniMaxH3Qwen3VLTextMLP(nn.Module):
+    def __init__(self, group: Any, config: Any, dtype: torch.dtype) -> None:
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.gate_up_proj = MiniMaxH3Qwen3VLMergedColumnParallelLinear(
+            group,
+            input_size=self.hidden_size,
+            intermediate_size=self.intermediate_size,
+            dtype=dtype,
+        )
+        self.down_proj = MiniMaxH3Qwen3VLRowParallelLinear(
+            group,
+            input_size=self.intermediate_size,
+            output_size=self.hidden_size,
+            dtype=dtype,
+            input_is_parallel=True,
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        ip_local = self.gate_up_proj.intermediate_size_per_partition
+        gate = F.linear(x, self.gate_up_proj.weight[0:ip_local])
+        up = F.linear(x, self.gate_up_proj.weight[ip_local : 2 * ip_local])
+        x = F.silu(gate) * up
+        return self.down_proj(x)
+
+
+class MiniMaxH3Qwen3VLTextDecoderLayer(nn.Module):
+    def __init__(self, group: Any, config: Any, dtype: torch.dtype) -> None:
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.self_attn = MiniMaxH3Qwen3VLTextAttention(group, config, dtype)
+        self.mlp = MiniMaxH3Qwen3VLTextMLP(group, config, dtype)
+        self.input_layernorm = MiniMaxH3Qwen3VLRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = MiniMaxH3Qwen3VLRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        hidden_states = self.self_attn(hidden_states, position_embeddings=position_embeddings)
+        hidden_states = residual + hidden_states
+
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+        return hidden_states
+
+
+class MiniMaxH3Qwen3VLTextModel(nn.Module):
+    """TP-sharded Qwen3-VL text model returning unnormalized layer-50 states."""
+
+    def __init__(self, group: Any, config: Any, selected_layer: int, dtype: torch.dtype) -> None:
+        super().__init__()
+        self.group = group
+        self.config = config
+        self.selected_layer = selected_layer
+        self.vocab_size = config.vocab_size
+        self.hidden_size = config.hidden_size
+        self.num_layers = min(int(getattr(config, "num_hidden_layers", 0)), selected_layer)
+        self.embed_tokens = MiniMaxH3Qwen3VLVocabParallelEmbedding(
+            group, num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, dtype=dtype
+        )
+        self.rotary_emb = MiniMaxH3Qwen3VLTextRotaryEmbedding(config)
+        self.layers = nn.ModuleList(
+            [MiniMaxH3Qwen3VLTextDecoderLayer(group, config, dtype) for _ in range(self.num_layers)]
+        )
+
+    def _deepstack_process(
+        self,
+        hidden_states: torch.Tensor,
+        visual_pos_masks: torch.Tensor,
+        visual_embeds: torch.Tensor,
+    ) -> torch.Tensor:
+        visual_pos_masks = visual_pos_masks.to(hidden_states.device)
+        visual_embeds = visual_embeds.to(hidden_states.device, hidden_states.dtype)
+        hidden_states = hidden_states.clone()
+        hidden_states[visual_pos_masks, :] = hidden_states[visual_pos_masks, :] + visual_embeds
+        return hidden_states
+
+    def forward(
+        self,
+        inputs_embeds: torch.Tensor,
+        positions: torch.Tensor,
+        *,
+        visual_pos_masks: torch.Tensor | None = None,
+        deepstack_visual_embeds: list[torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        hidden_states = inputs_embeds
+        position_embeddings = self.rotary_emb(hidden_states, positions)
+        for layer_idx, decoder_layer in enumerate(self.layers):
+            hidden_states = decoder_layer(hidden_states, position_embeddings=position_embeddings)
+            if deepstack_visual_embeds is not None and layer_idx in range(len(deepstack_visual_embeds)):
+                hidden_states = self._deepstack_process(
+                    hidden_states,
+                    visual_pos_masks,
+                    deepstack_visual_embeds[layer_idx],
+                )
+        return hidden_states
+
+
+# ---------------------------------------------------------------------------
+# Multimodal position / placeholder-mask helpers (ported from the reference).
+# ---------------------------------------------------------------------------
+
+
+def _get_vision_position_ids(
+    start_position: int,
+    grid_thw: list[int] | torch.Tensor,
+    temp_merge_size: int,
+    spatial_merge_size: int,
+    device: str | torch.device,
+) -> torch.Tensor:
+    llm_grid_t, llm_grid_h, llm_grid_w = (
+        grid_thw[0].item() // temp_merge_size,
+        grid_thw[1].item() // spatial_merge_size,
+        grid_thw[2].item() // spatial_merge_size,
+    )
+    position_temporal = torch.arange(llm_grid_t, device=device)
+    position_width = torch.arange(llm_grid_w, device=device) + start_position
+    position_height = torch.arange(llm_grid_h, device=device) + start_position
+    position_width = position_width.repeat(llm_grid_h * llm_grid_t)
+    position_height = position_height.repeat_interleave(llm_grid_w).repeat(llm_grid_t)
+    position_temporal = position_temporal.repeat_interleave(llm_grid_h * llm_grid_w) + start_position
+    return torch.stack([position_temporal, position_height, position_width], dim=0)
+
+
+def _get_rope_index(
+    input_ids: torch.Tensor,
+    mm_token_type_ids: torch.Tensor,
+    image_grid_thw: torch.Tensor | None,
+    video_grid_thw: torch.Tensor | None,
+    attention_mask: torch.Tensor | None,
+    spatial_merge_size: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if video_grid_thw is not None:
+        video_grid_thw = torch.repeat_interleave(video_grid_thw, video_grid_thw[:, 0], dim=0)
+        video_grid_thw[:, 0] = 1
+
+    mrope_position_deltas = []
+    position_ids = torch.zeros(
+        3,
+        input_ids.shape[0],
+        input_ids.shape[1],
+        dtype=input_ids.dtype,
+        device=input_ids.device,
+    )
+    grid_iters = {
+        1: iter(image_grid_thw) if image_grid_thw is not None else None,
+        2: iter(video_grid_thw) if video_grid_thw is not None else None,
+    }
+
+    for batch_idx, current_input_ids in enumerate(input_ids):
+        input_token_type = mm_token_type_ids[batch_idx]
+        if attention_mask is not None:
+            current_input_ids = current_input_ids[attention_mask[batch_idx].bool()]
+            input_token_type = input_token_type[attention_mask[batch_idx].bool()]
+
+        input_type_group = []
+        for key, group in itertools.groupby(enumerate(input_token_type.tolist()), lambda x: x[1]):
+            group = list(group)
+            start_index = group[0][0]
+            end_index = group[-1][0] + 1
+            input_type_group.append((key, start_index, end_index))
+
+        current_pos = 0
+        llm_pos_ids_list = []
+        for modality_type, start_idx, end_idx in input_type_group:
+            if modality_type == 0:
+                text_len = end_idx - start_idx
+                llm_pos_ids_list.append(
+                    torch.arange(text_len, device=input_ids.device).view(1, -1).expand(3, -1) + current_pos
+                )
+                current_pos += text_len
+            else:
+                grid_thw = next(grid_iters[modality_type])
+                vision_position_ids = _get_vision_position_ids(
+                    current_pos, grid_thw, 1, spatial_merge_size, device=input_ids.device
+                )
+                llm_pos_ids_list.append(vision_position_ids)
+                current_pos += max(grid_thw[1], grid_thw[2]) // spatial_merge_size
+        llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)
+        if attention_mask is not None:
+            position_ids[:, batch_idx, attention_mask[batch_idx].bool()] = llm_positions.to(position_ids.device)
+        else:
+            position_ids[:, batch_idx] = llm_positions.to(position_ids.device)
+        mrope_position_deltas.append(llm_positions.max() + 1 - len(current_input_ids))
+    mrope_position_deltas = torch.tensor(mrope_position_deltas, device=input_ids.device).unsqueeze(1)
+    return position_ids, mrope_position_deltas
+
+
+# ---------------------------------------------------------------------------
+# Encoder entry point.
+# ---------------------------------------------------------------------------
+
+
+class MiniMaxH3Qwen3VLEncoder(nn.Module):
+    """Frozen, TP-capable Qwen3-VL backbone returning layer-50 states.
+
+    ``encoder_group`` is a ``GroupCoordinator`` over the encoder tensor-parallel
+    ranks (by default the first ``text_encoder_tp_size`` DiT ranks).  Only
+    ranks inside the group load weights; other ranks construct a parameter-free
+    stub that never runs the forward.
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        *,
+        device: torch.device,
+        load_model: bool,
+        encoder_group: Any | None = None,
+    ) -> None:
+        super().__init__()
+        self.device_target = device
+        self.encoder_group = encoder_group
+        self.image_token_id = 151655
+        self.video_token_id = 151656
+        self._tp_size = 1
+        if not load_model:
+            return
+
+        from transformers import Qwen3VLConfig
+
+        config = Qwen3VLConfig.from_pretrained(model_path, trust_remote_code=False)
+        self.image_token_id = int(config.image_token_id)
+        self.video_token_id = int(config.video_token_id)
+        self._tp_size = int(encoder_group.world_size) if encoder_group is not None else 1
+        dtype = torch.bfloat16
+        self.vision = MiniMaxH3Qwen3VLVisionModel(config.vision_config)
+        self.vision.to(dtype=dtype)
+        self.text_model = MiniMaxH3Qwen3VLTextModel(
+            encoder_group,
+            config.text_config,
+            MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER,
+            dtype,
+        )
+        self.text_model.to(dtype=dtype)
+        self._load_weights(model_path)
+        logger.info(
+            "MiniMax H3 Qwen3-VL encoder: %d retained decoder layers, text_encoder_tp_size=%d, vision replicated",
+            MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER,
+            self._tp_size,
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return hasattr(self, "text_model")
+
+    @property
+    def tp_size(self) -> int:
+        return self._tp_size
+
+    def _map_weight_name(self, name: str) -> tuple[str, str | None] | None:
+        if name == "lm_head.weight" or name == "model.language_model.norm.weight":
+            return None
+        if name.startswith("model.visual."):
+            return ("vision." + name[len("model.visual.") :], None)
+        if name.startswith("model.language_model."):
+            rest = name[len("model.language_model.") :]
+            if rest.startswith("embed_tokens."):
+                return ("text_model." + rest, None)
+            match = re.match(r"layers\.(\d+)\.", rest)
+            if match is not None and int(match.group(1)) >= MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER:
+                return None
+            if ".self_attn.q_proj.weight" in rest:
+                return (
+                    "text_model." + rest.replace(".self_attn.q_proj.weight", ".self_attn.qkv_proj.weight"),
+                    "q",
+                )
+            if ".self_attn.k_proj.weight" in rest:
+                return (
+                    "text_model." + rest.replace(".self_attn.k_proj.weight", ".self_attn.qkv_proj.weight"),
+                    "k",
+                )
+            if ".self_attn.v_proj.weight" in rest:
+                return (
+                    "text_model." + rest.replace(".self_attn.v_proj.weight", ".self_attn.qkv_proj.weight"),
+                    "v",
+                )
+            if ".mlp.gate_proj.weight" in rest:
+                return (
+                    "text_model." + rest.replace(".mlp.gate_proj.weight", ".mlp.gate_up_proj.weight"),
+                    0,
+                )
+            if ".mlp.up_proj.weight" in rest:
+                return (
+                    "text_model." + rest.replace(".mlp.up_proj.weight", ".mlp.gate_up_proj.weight"),
+                    1,
+                )
+            return ("text_model." + rest, None)
+        return None
+
+    def _load_weights(self, model_path: str) -> None:
+        import os
+
+        import safetensors.torch
+
+        index_path = os.path.join(model_path, "model.safetensors.index.json")
+        with open(index_path, encoding="utf-8") as handle:
+            index = json.load(handle)
+        weight_map: dict[str, str] = index["weight_map"]
+        files = sorted(set(weight_map.values()))
+        params = dict(self.named_parameters())
+        loaded: set[str] = set()
+        for shard in files:
+            tensors = safetensors.torch.load_file(os.path.join(model_path, shard), device="cpu")
+            for name, tensor in tensors.items():
+                mapped = self._map_weight_name(name)
+                if mapped is None:
+                    continue
+                param_name, shard_id = mapped
+                param = params.get(param_name)
+                if param is None:
+                    logger.warning("MiniMax H3 text encoder weight %s has no target parameter", name)
+                    continue
+                weight_loader = getattr(param, "weight_loader", _default_weight_loader)
+                weight_loader(param, tensor, shard_id)
+                loaded.add(param_name)
+        missing = sorted(set(params) - loaded)
+        if missing:
+            logger.warning(
+                "MiniMax H3 text encoder weights not loaded (retained-layer subset): %d params, e.g. %s",
+                len(missing),
+                missing[:5],
+            )
+
+    def load_to_device(self) -> None:
+        if not self.is_loaded:
+            return
+        if getattr(self, "_omni_layerwise_enabled", False):
+            for name, child in self.vision.named_children():
+                if name != "blocks":
+                    child.to(self.device_target)
+            for name, child in self.text_model.named_children():
+                if name != "layers":
+                    child.to(self.device_target)
+            return
+        self.vision.to(self.device_target)
+        self.text_model.to(self.device_target)
+
+    def offload_to_cpu(self) -> None:
+        if not self.is_loaded:
+            return
+        if getattr(self, "_omni_layerwise_enabled", False):
+            for hook in self._omni_layerwise_hooks:
+                hook.offload_layer()
+            for name, child in self.vision.named_children():
+                if name != "blocks":
+                    child.to("cpu")
+            for name, child in self.text_model.named_children():
+                if name != "layers":
+                    child.to("cpu")
+            torch.accelerator.empty_cache()
+            return
+        self.vision.to("cpu")
+        self.text_model.to("cpu")
+        torch.accelerator.empty_cache()
+
+    def enable_omni_layerwise_offload(self, *, pin_memory: bool = True) -> None:
+        """Stream the TP-local Qwen vision/text blocks for low-HBM serving.
+
+        The encoder has its own TP process group, so these blocks must remain
+        rank-local.  Reusing the DiT AllGather group would concatenate
+        different TP shards and corrupt the encoder weights.
+        """
+        if not self.is_loaded or getattr(self, "_omni_layerwise_enabled", False):
+            return
+
+        from vllm_omni.diffusion.offloader.layerwise_backend import apply_block_hook
+        from vllm_omni.platforms import current_omni_platform
+
+        self._omni_layerwise_hooks = []
+        self._omni_layerwise_block_groups = []
+        copy_stream = current_omni_platform.Stream()
+        for blocks in (self.vision.blocks, self.text_model.layers):
+            if len(blocks) <= 1:
+                continue
+            last_hook = apply_block_hook(
+                blocks[-1],
+                blocks[0],
+                self.device_target,
+                copy_stream,
+                pin_memory,
+            )
+            hooks = [last_hook]
+            for index, block in enumerate(blocks[:-1]):
+                hooks.append(
+                    apply_block_hook(
+                        block,
+                        blocks[index + 1],
+                        self.device_target,
+                        copy_stream,
+                        pin_memory,
+                    )
+                )
+            for index, hook in enumerate(hooks):
+                hook._prev_hook = hooks[index - 1]
+            self._omni_layerwise_hooks.extend(hooks)
+            self._omni_layerwise_block_groups.append(blocks)
+
+        self._omni_layerwise_enabled = bool(self._omni_layerwise_hooks)
+        logger.info(
+            "MiniMax H3 encoder layerwise offload enabled on %d blocks across %d stacks",
+            sum(len(blocks) for blocks in self._omni_layerwise_block_groups),
+            len(self._omni_layerwise_block_groups),
+        )
+
+    def _encode(
+        self,
+        input_ids: torch.Tensor,
+        *,
+        pixel_values: torch.Tensor | None = None,
+        image_grid_thw: torch.Tensor | None = None,
+        pixel_values_videos: torch.Tensor | None = None,
+        video_grid_thw: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = self.device_target
+        ids = input_ids.to(device, torch.long)[None]
+        attention_mask = torch.ones_like(ids)
+        mm_types = torch.zeros_like(ids, dtype=torch.int32)
+        mm_types[ids == self.image_token_id] = 1
+        mm_types[ids == self.video_token_id] = 2
+
+        inputs_embeds = self.text_model.embed_tokens(ids)
+        image_mask = None
+        video_mask = None
+        deepstack_image_embeds: list[torch.Tensor] | None = None
+        deepstack_video_embeds: list[torch.Tensor] | None = None
+
+        if pixel_values is not None:
+            image_embeds, deepstack_image_embeds = self.vision(
+                pixel_values.to(device, torch.bfloat16),
+                image_grid_thw.to(device, torch.long),
+            )
+            image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+            image_mask, _ = self._get_placeholder_mask(ids, inputs_embeds=inputs_embeds, image_features=image_embeds)
+            inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+        if pixel_values_videos is not None:
+            video_embeds, deepstack_video_embeds = self.vision(
+                pixel_values_videos.to(device, torch.bfloat16),
+                video_grid_thw.to(device, torch.long),
+            )
+            video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+            _, video_mask = self._get_placeholder_mask(ids, inputs_embeds=inputs_embeds, video_features=video_embeds)
+            inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+        visual_pos_masks, deepstack_visual_embeds = self._aggregate_deepstack(
+            image_mask,
+            video_mask,
+            deepstack_image_embeds,
+            deepstack_video_embeds,
+        )
+
+        positions, _ = _get_rope_index(
+            ids,
+            mm_token_type_ids=mm_types,
+            image_grid_thw=image_grid_thw.to(device, torch.long) if image_grid_thw is not None else None,
+            video_grid_thw=video_grid_thw.to(device, torch.long) if video_grid_thw is not None else None,
+            attention_mask=attention_mask,
+            spatial_merge_size=int(self.vision.config.spatial_merge_size),
+        )
+        hidden = self.text_model(
+            inputs_embeds,
+            positions,
+            visual_pos_masks=visual_pos_masks,
+            deepstack_visual_embeds=deepstack_visual_embeds,
+        )[0]
+        expected = (int(ids.shape[1]), MINIMAX_H3_QWEN3VL_HIDDEN_DIM)
+        if tuple(hidden.shape) != expected:
+            raise ValueError(f"unexpected Qwen3-VL hidden shape {tuple(hidden.shape)}, expected {expected}")
+        return hidden.to(torch.bfloat16)
+
+    def _get_placeholder_mask(
+        self,
+        input_ids: torch.Tensor,
+        *,
+        inputs_embeds: torch.Tensor,
+        image_features: torch.Tensor | None = None,
+        video_features: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        special_image_mask = input_ids == self.image_token_id
+        special_video_mask = input_ids == self.video_token_id
+        special_image_mask = special_image_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+        special_video_mask = special_video_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+        if image_features is not None and special_image_mask.sum().item() != image_features.numel():
+            raise ValueError(
+                "Image features and image tokens do not match: "
+                f"tokens: {special_image_mask.sum().item() // inputs_embeds.shape[-1]}, "
+                f"features: {image_features.shape[0]}"
+            )
+        if video_features is not None and special_video_mask.sum().item() != video_features.numel():
+            raise ValueError(
+                "Video features and video tokens do not match: "
+                f"tokens: {special_video_mask.sum().item() // inputs_embeds.shape[-1]}, "
+                f"features: {video_features.shape[0]}"
+            )
+        return special_image_mask, special_video_mask
+
+    def _aggregate_deepstack(
+        self,
+        image_mask: torch.Tensor | None,
+        video_mask: torch.Tensor | None,
+        deepstack_image_embeds: list[torch.Tensor] | None,
+        deepstack_video_embeds: list[torch.Tensor] | None,
+    ) -> tuple[torch.Tensor | None, list[torch.Tensor] | None]:
+        if image_mask is not None and video_mask is not None:
+            image_mask = image_mask[..., 0]
+            video_mask = video_mask[..., 0]
+            visual_pos_masks = image_mask | video_mask
+            deepstack_visual_embeds = []
+            image_mask_joint = image_mask[visual_pos_masks]
+            video_mask_joint = video_mask[visual_pos_masks]
+            for img_embed, vid_embed in zip(deepstack_image_embeds, deepstack_video_embeds):
+                embed_joint = img_embed.new_zeros(visual_pos_masks.sum(), img_embed.shape[-1]).to(img_embed.device)
+                embed_joint[image_mask_joint, :] = img_embed
+                embed_joint[video_mask_joint, :] = vid_embed
+                deepstack_visual_embeds.append(embed_joint)
+            return visual_pos_masks, deepstack_visual_embeds
+        if image_mask is not None:
+            image_mask = image_mask[..., 0]
+            return image_mask, deepstack_image_embeds
+        if video_mask is not None:
+            video_mask = video_mask[..., 0]
+            return video_mask, deepstack_video_embeds
+        return None, None
+
+    @torch.inference_mode()
+    def encode_ids(
+        self,
+        input_ids: torch.Tensor,
+        *,
+        pixel_values: torch.Tensor | None = None,
+        image_grid_thw: torch.Tensor | None = None,
+        pixel_values_videos: torch.Tensor | None = None,
+        video_grid_thw: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if not self.is_loaded:
+            raise RuntimeError("MiniMax H3 text encoder is only loaded on the encoder TP ranks")
+        if input_ids.ndim != 1:
+            raise ValueError(f"input_ids must be 1-D, got {list(input_ids.shape)}")
+        if (pixel_values is None) != (image_grid_thw is None):
+            raise ValueError("pixel_values and image_grid_thw must be provided together")
+        if (pixel_values_videos is None) != (video_grid_thw is None):
+            raise ValueError("pixel_values_videos and video_grid_thw must be provided together")
+        if next(self.parameters()).device.type != self.device_target.type:
+            raise RuntimeError("call load_to_device() before encode_ids()")
+
+        torch.backends.cuda.enable_cudnn_sdp(True)
+        hidden = self._encode(
+            input_ids,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
+            pixel_values_videos=pixel_values_videos,
+            video_grid_thw=video_grid_thw,
+        )
+        return hidden.cpu()
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        *,
+        pixel_values: torch.Tensor | None = None,
+        image_grid_thw: torch.Tensor | None = None,
+        pixel_values_videos: torch.Tensor | None = None,
+        video_grid_thw: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Hook-compatible entry point for model-level CPU offloading."""
+        kwargs = {
+            "pixel_values": pixel_values,
+            "image_grid_thw": image_grid_thw,
+        }
+        if pixel_values_videos is not None or video_grid_thw is not None:
+            kwargs.update(
+                pixel_values_videos=pixel_values_videos,
+                video_grid_thw=video_grid_thw,
+            )
+        return self.encode_ids(input_ids, **kwargs)
+
+
+__all__ = ["MiniMaxH3Qwen3VLEncoder"]
diff --git a/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py b/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
new file mode 100644
index 000000000..610c20d19
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
@@ -0,0 +1,1206 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 packed-token audio/video DiT for vLLM-Omni.
+
+vLLM tensor parallel linears and the unified attention layer provide TP and
+Ulysses/Ring sequence parallel execution without changing the checkpoint
+layout.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import torch
+import torch.nn as nn
+from cache_dit import ForwardPattern
+from vllm.distributed import get_tensor_model_parallel_world_size
+from vllm.logger import init_logger
+from vllm.model_executor.layers.linear import (
+    ColumnParallelLinear,
+    MergedColumnParallelLinear,
+    QKVParallelLinear,
+    RowParallelLinear,
+)
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata, VideoTokenLayout
+from vllm_omni.diffusion.attention.layer import Attention
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
+from vllm_omni.diffusion.distributed.sp_plan import (
+    SequenceParallelInput,
+    SequenceParallelOutput,
+)
+from vllm_omni.diffusion.layers.norm import RMSNorm
+from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+
+if TYPE_CHECKING:
+    from vllm.model_executor.layers.quantization.base_config import (
+        QuantizationConfig,
+    )
+
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+
+logger = init_logger(__name__)
+
+
+@dataclass
+class MiniMaxH3DiTArchConfig:
+    num_layers: int = 50
+    token_refiner_num_layers: int = 2
+    hidden_size: int = 5376
+    num_attention_heads: int = 56
+    attention_head_dim: int = 128
+    ffn_hidden_size: int = 14336
+    latents_dim: int = 24
+    audio_latents_dim: int = 32
+    patch_size: tuple[int, int, int] = (1, 2, 2)
+    text_dim: int = 5120
+    timestep_input_dim: int = 256
+    time_embed_hidden_size: int = 5376
+    time_embed_dim: int = 2688
+    adaln_out_features: int = 18 * 5376
+    final_adaln_out_features: int = 2 * 5376
+    rope_inv_freq_len: int = 16
+    norm_eps: float = 1e-5
+    qk_norm_eps: float = 1e-5
+    final_norm_eps: float = 1e-5
+
+    @classmethod
+    def from_mapping(cls, config: Mapping[str, Any]) -> MiniMaxH3DiTArchConfig:
+        fields = cls.__dataclass_fields__
+        values = {name: config[name] for name in fields if name in config}
+        if "patch_size" in values:
+            values["patch_size"] = tuple(values["patch_size"])
+        arch = cls(**values)
+        if len(arch.patch_size) != 3:
+            raise ValueError(f"patch_size must contain three values, got {arch.patch_size!r}")
+        return arch
+
+
+_ARCH_DEFAULTS = MiniMaxH3DiTArchConfig()
+_BF16_DTYPE = torch.bfloat16
+_FP32_DTYPE = torch.float32
+
+MINIMAX_H3_FP32_PARAM_NAMES = frozenset(
+    {
+        "video_patch_proj.weight",
+        "video_patch_proj.bias",
+        "audio_patch_proj.weight",
+        "audio_patch_proj.bias",
+        "time_embedder.proj_in.weight",
+        "time_embedder.proj_in.bias",
+        "time_embedder.proj_out.weight",
+        "time_embedder.proj_out.bias",
+        "final_layer.video_out.weight",
+        "final_layer.video_out.bias",
+        "final_layer.audio_out.weight",
+        "final_layer.audio_out.bias",
+    }
+)
+MINIMAX_H3_FP32_BUFFER_NAMES = frozenset({"rope.inv_freq"})
+
+# AdaLN modality count: token tags carry -1 for padding and 0/1/2 for
+# video/text/audio tokens (padding is clamped to 0 before the embedding
+# lookup and masked out afterwards).
+MINIMAX_H3_ADALN_MODALITY_NUM = 3
+
+
+def _required_kwarg(kwargs: dict[str, Any], key: str) -> Any:
+    if key not in kwargs or kwargs[key] is None:
+        raise ValueError(f"MiniMaxH3DiTModel.forward requires kwarg {key!r}")
+    return kwargs[key]
+
+
+# The exhaustive keyword contract of MiniMaxH3DiTModel.forward. Anything not
+# listed here is rejected with a TypeError before any tensor work starts.
+_FORWARD_SUPPORTED_KWARGS = frozenset(
+    {
+        "x",
+        "audio_x",
+        "img_position_ids",
+        "unique_timesteps",
+        "inverse_indices",
+        "update_mask",
+        "update_audio_mask",
+        "token_tags",
+        "skip_mask_out_condition",
+        "prompt_embeds",
+        "img_pos_info",
+        "audio_pos_info",
+        "text_pos_info",
+        "img_pos_for_infer_output_info",
+        "packed_seq_params",
+        "refiner_packed_seq_params",
+        "video_token_layout",
+    }
+)
+
+
+def _reorder_grouped_qkv_to_qkv(
+    weight: torch.Tensor,
+    *,
+    num_query_groups: int,
+    heads_per_group: int,
+    head_dim: int,
+) -> torch.Tensor:
+    per_group = (heads_per_group + 2) * head_dim
+    expected_out = num_query_groups * per_group
+    if weight.shape[0] != expected_out:
+        raise ValueError(
+            "qkv weight has incompatible output dim for grouped checkpoint layout: "
+            f"got {tuple(weight.shape)}, expected first dim {expected_out}."
+        )
+
+    rest_shape = weight.shape[1:]
+    grouped = weight.reshape(num_query_groups, per_group, *rest_shape)
+    q, k, v = torch.split(
+        grouped,
+        [heads_per_group * head_dim, head_dim, head_dim],
+        dim=1,
+    )
+    return torch.cat(
+        [
+            q.reshape(num_query_groups * heads_per_group * head_dim, *rest_shape),
+            k.reshape(num_query_groups * head_dim, *rest_shape),
+            v.reshape(num_query_groups * head_dim, *rest_shape),
+        ],
+        dim=0,
+    )
+
+
+def _norm(size: int, *, eps: float, dtype: torch.dtype = _BF16_DTYPE) -> RMSNorm:
+    # RMSNorm uses fp32 accumulation with bf16 inputs and outputs.
+    # torch.nn.RMSNorm upcasts reduced-precision inputs for the variance
+    # reduction, matching that accumulation semantic.
+    return RMSNorm(size, eps=eps, dtype=dtype)
+
+
+def _modulate_scale_shift(
+    x: torch.Tensor,
+    shift: torch.Tensor,
+    scale: torch.Tensor,
+    indices: torch.Tensor,
+    *,
+    dtype: torch.dtype,
+) -> torch.Tensor:
+    # Apply per-index affine modulation: x * (1 + scale[idx]) + shift[idx].
+    return (x * (1.0 + scale.index_select(0, indices)) + shift.index_select(0, indices)).to(dtype)
+
+
+def _modulate_gate(
+    x: torch.Tensor,
+    gate: torch.Tensor,
+    other: torch.Tensor,
+    indices: torch.Tensor,
+    *,
+    dtype: torch.dtype,
+) -> torch.Tensor:
+    # Apply the per-index gated residual: x + gate[idx] * other.
+    return (x + gate.index_select(0, indices) * other).to(dtype)
+
+
+class MiniMaxH3Rope(nn.Module):
+    """3D rope over (t, h, w); rotates 96 of 128 head dims (rotary_percent 0.75).
+
+    Frequency layout concatenates temporal, height, and width embeddings twice,
+    with 16 frequencies per axis (inv_freq = base^-(arange(0,32,2)/32)).
+    """
+
+    def __init__(self, inv_freq_len: int) -> None:
+        super().__init__()
+        self.register_buffer(
+            "inv_freq",
+            torch.empty(inv_freq_len, dtype=_FP32_DTYPE),
+            persistent=True,
+        )
+
+    def forward(self, img_position_ids: torch.Tensor) -> torch.Tensor:
+        """img_position_ids: [1, S, 3] (t, h, w) -> freqs [S, rot_dim=96]."""
+        if img_position_ids.dim() != 3 or img_position_ids.shape[0] != 1:
+            raise ValueError(f"img_position_ids must be [1, S, 3], got {list(img_position_ids.shape)}")
+        pos = img_position_ids[0].to(_FP32_DTYPE)  # [S, 3]
+        per_axis = pos.unsqueeze(-1) * self.inv_freq.view(1, 1, -1)  # [S, 3, 16]
+        t_f, h_f, w_f = per_axis.unbind(dim=1)  # each [S, 16]
+        half = torch.cat((t_f, h_f, w_f), dim=-1)  # [S, 48]
+        return torch.cat((half, half), dim=-1)  # [S, 96]
+
+
+class MiniMaxH3TimeEmbedder(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        self.frequency_embedding_size = arch.timestep_input_dim
+        self.proj_in = ColumnParallelLinear(
+            arch.timestep_input_dim,
+            arch.time_embed_hidden_size,
+            bias=True,
+            gather_output=True,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix=f"{prefix}.proj_in",
+        )
+        self.proj_out = RowParallelLinear(
+            arch.time_embed_hidden_size,
+            arch.time_embed_dim,
+            bias=True,
+            input_is_parallel=False,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix=f"{prefix}.proj_out",
+        )
+
+    def forward(self, t: torch.Tensor) -> torch.Tensor:
+        """t: [M] -> [M, time_embed_dim] fp32.
+
+        The sinusoidal embedding stays fp32 throughout and concatenates cosine
+        values before sine values.
+        """
+        half = self.frequency_embedding_size // 2
+        freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=_FP32_DTYPE, device=t.device) / half)
+        args = t.to(_FP32_DTYPE)[:, None] * freqs[None]
+        t_freq = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        hidden, _ = self.proj_in(t_freq)
+        hidden = nn.functional.silu(hidden)
+        out, _ = self.proj_out(hidden)
+        return out
+
+
+def _sdpa_varlen_attention(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    cu_seqlens: torch.Tensor,
+    softmax_scale: float,
+) -> torch.Tensor:
+    """Segment-wise SDPA equivalent of the non-causal varlen FA call.
+
+    Mirrors the generic attention layer's semantics: FA is the fast path,
+    SDPA is the correctness fallback when the platform resolves another
+    backend. Segments are delimited by ``cu_seqlens`` exactly like the
+    varlen kernel, so attention never crosses packed-document boundaries.
+    """
+    out = torch.empty_like(q)
+    bounds = cu_seqlens.tolist()
+    for start, stop in zip(bounds[:-1], bounds[1:]):
+        if stop == start:
+            continue
+        seg_q = q[start:stop].transpose(0, 1).unsqueeze(0)
+        seg_k = k[start:stop].transpose(0, 1).unsqueeze(0)
+        seg_v = v[start:stop].transpose(0, 1).unsqueeze(0)
+        seg_out = torch.nn.functional.scaled_dot_product_attention(
+            seg_q,
+            seg_k,
+            seg_v,
+            scale=softmax_scale,
+        )
+        out[start:stop] = seg_out.squeeze(0).transpose(0, 1)
+    return out
+
+
+class MiniMaxH3Attention(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+        role: str = "self",
+        role_category: str | None = None,
+        skip_sequence_parallel: bool = False,
+    ) -> None:
+        super().__init__()
+        self.total_num_heads = arch.num_attention_heads
+        self.head_dim = arch.attention_head_dim
+        inner_dim = self.total_num_heads * self.head_dim
+        self.softmax_scale = self.head_dim**-0.5
+        self.qkv_proj = QKVParallelLinear(
+            hidden_size=arch.hidden_size,
+            head_size=self.head_dim,
+            total_num_heads=self.total_num_heads,
+            total_num_kv_heads=self.total_num_heads,
+            bias=False,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix=f"{prefix}.qkv_proj",
+            return_bias=True,
+        )
+        self.num_heads = self.qkv_proj.num_heads
+        self.num_kv_heads = self.qkv_proj.num_kv_heads
+        self.q_norm = _norm(arch.attention_head_dim, eps=arch.qk_norm_eps)
+        self.k_norm = _norm(arch.attention_head_dim, eps=arch.qk_norm_eps)
+        self.rope = RotaryEmbedding(is_neox_style=True, half_head_dim=False)
+        self.out_proj = RowParallelLinear(
+            inner_dim,
+            arch.hidden_size,
+            bias=False,
+            input_is_parallel=True,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix=f"{prefix}.out_proj",
+        )
+        self.attention = Attention(
+            num_heads=self.num_heads,
+            num_kv_heads=self.num_kv_heads,
+            head_size=self.head_dim,
+            softmax_scale=self.softmax_scale,
+            causal=False,
+            # Packed rows reach the impl as [B, S, N, D].
+            qkv_layout="BSND",
+            role=role,
+            role_category=role_category,
+            skip_sequence_parallel=skip_sequence_parallel,
+            prefix=prefix,
+        )
+
+    def _apply_rope(self, x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
+        """Rotate the first rot_dim head dims; pass the rest through.
+
+        x: [T, heads, head_dim]; freqs: [T, rot_dim]. In the unfused path, cos/sin
+        are cast to the activation dtype before the elementwise math.
+        """
+        rot_dim = freqs.shape[-1]
+        x_rot, x_pass = x[..., :rot_dim], x[..., rot_dim:]
+        cos = torch.cos(freqs).to(x.dtype)  # [T, rot_dim]
+        sin = torch.sin(freqs).to(x.dtype)
+        x_rot = self.rope(x_rot, cos, sin)
+        return torch.cat((x_rot, x_pass), dim=-1)
+
+    @torch.compiler.disable
+    def _run_packed_attention(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        *,
+        cu_seqlens: torch.Tensor,
+        max_seqlen: int,
+        packed_total: int,
+        video_layout: VideoTokenLayout | None = None,
+    ) -> torch.Tensor:
+        """Run packed attention as a small eager island.
+
+        The scalar packed-layout metadata and backend-specific attention
+        kernels are intentionally opaque to Dynamo. Keeping this boundary
+        narrow lets regional compile fuse projections, norms, RoPE, and the
+        surrounding DiT block without repeated graph breaks.
+        """
+        # max_seqlen is already the first (real) packed document length. Do
+        # not read the CUDA cu_seqlens scalars here: this function runs once
+        # per layer and .item() would serialize every attention launch.
+        if not 0 < max_seqlen <= packed_total:
+            raise ValueError(
+                f"max_seqlen must be within the packed sequence, got {max_seqlen} for length {packed_total}"
+            )
+        used = min(max_seqlen, packed_total)
+        attn_mask = None
+        # Ring attention can dispatch to a different implementation from the
+        # configured backend, so this no-mask fast path is local-only.
+        prefix_slice = (
+            not getattr(self.attention, "use_ring", False) and self.attention.attn_backend.supports_prefix_kv_slicing
+        )
+        if used < packed_total and not prefix_slice:
+            attn_mask = torch.arange(packed_total, device=q.device)[None] < used
+        metadata = AttentionMetadata(
+            attn_mask=attn_mask,
+            extra={
+                "cu_seqlens_q": cu_seqlens,
+                "cu_seqlens_k": cu_seqlens,
+                "max_seqlen_q": max_seqlen,
+                "max_seqlen_k": max_seqlen,
+                "valid_kv_length": used,
+            },
+            video_layout=video_layout,
+        )
+        return self.attention(
+            q.unsqueeze(0),
+            k.unsqueeze(0),
+            v.unsqueeze(0),
+            metadata,
+        ).squeeze(0)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        *,
+        rope_freqs: torch.Tensor | None,
+        cu_seqlens: torch.Tensor,
+        max_seqlen: int,
+        packed_total: int | None = None,
+        sp_seq_lens: list[int] | None = None,
+        video_layout: VideoTokenLayout | None = None,
+    ) -> torch.Tensor:
+        """x: [T, hidden] packed thd rows -> [T, hidden].
+
+        Operation order: fused qkv projection -> per-head q/k RMSNorm -> RoPE
+        on q/k -> variable-length non-causal flash attention -> output projection.
+
+        With Ulysses sequence parallelism, x holds this rank's row shard;
+        qkv/norm/RoPE run locally, an all-to-all trades sequence for heads.
+        Each rank attends the full sequence with heads/world_size local heads,
+        so cu_seqlens retains global packed-document semantics. The inverse
+        all-to-all restores the row shard before the output projection.
+        """
+        total = x.shape[0]
+        qkv, _ = self.qkv_proj(x)
+        q_size = self.num_heads * self.head_dim
+        kv_size = self.num_kv_heads * self.head_dim
+        q, k, v = qkv.split([q_size, kv_size, kv_size], dim=-1)
+        q = q.view(total, self.num_heads, self.head_dim)
+        k = k.view(total, self.num_kv_heads, self.head_dim)
+        v = v.view(total, self.num_kv_heads, self.head_dim)
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+        if rope_freqs is not None:
+            q = self._apply_rope(q, rope_freqs)
+            k = self._apply_rope(k, rope_freqs)
+
+        # The packed layout uses a second document for alignment padding.
+        # Local/Ulysses backends unpad it, while Ring keeps aligned rows for
+        # fixed-size P2P buffers.
+        out = self._run_packed_attention(
+            q,
+            k,
+            v,
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+            # Before Ulysses, q contains only this rank's row shard. The
+            # backend receives the global sequence after all-to-all, so carry
+            # its Python length explicitly instead of inferring it from q.
+            packed_total=packed_total if packed_total is not None else q.shape[0],
+            video_layout=video_layout,
+        )
+        out = out.reshape(total, self.num_heads * self.head_dim)
+        out, _ = self.out_proj(out)
+        return out
+
+
+class MiniMaxH3MLP(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        self.fc1 = MergedColumnParallelLinear(
+            arch.hidden_size,
+            [arch.ffn_hidden_size, arch.ffn_hidden_size],
+            bias=False,
+            gather_output=False,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix=f"{prefix}.fc1",
+        )
+        # Chunk the fused fc1 output as [gate, up], then compute
+        # silu(gate) * up.
+        self.fc2 = RowParallelLinear(
+            arch.ffn_hidden_size,
+            arch.hidden_size,
+            bias=False,
+            input_is_parallel=True,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix=f"{prefix}.fc2",
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        hidden, _ = self.fc1(x)
+        gate, up = hidden.chunk(2, dim=-1)
+        hidden = nn.functional.silu(gate) * up
+        out, _ = self.fc2(hidden)
+        return out
+
+
+class MiniMaxH3AdalnProj(nn.Module):
+    """SiLU + zero-init linear over unique condition embeddings.
+
+    Per block, three modalities each produce six H-wide vectors:
+    [M, t_dim] -> [M, 3*6H] -> view(M*3, 6H) -> chunk(6).
+    The final layer uses one modality and produces two H-wide vectors:
+    [M, t_dim] -> [M, 2H] -> chunk(2).
+    """
+
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        out_features: int,
+        quant_config: QuantizationConfig | None,
+        *,
+        expand_ratio: int,
+        modality_num: int,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        if out_features != expand_ratio * arch.hidden_size * modality_num:
+            raise ValueError(
+                f"adaln out_features mismatch: {out_features} != {expand_ratio}*{arch.hidden_size}*{modality_num}"
+            )
+        self.expand_ratio = expand_ratio
+        self.modality_num = modality_num
+        self.hidden_size = arch.hidden_size
+        self.linear = ColumnParallelLinear(
+            arch.time_embed_dim,
+            out_features,
+            bias=True,
+            gather_output=True,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix=f"{prefix}.linear",
+        )
+
+    def forward(self, t_emb: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        """t_emb: [M, t_dim] -> expand_ratio tensors of [M*modality_num, H]."""
+        x = nn.functional.silu(t_emb)
+        x, _ = self.linear(x.to(_BF16_DTYPE))
+        m = x.shape[0]
+        x = x.view(m * self.modality_num, self.expand_ratio * self.hidden_size)
+        return tuple(x.chunk(self.expand_ratio, dim=-1))
+
+
+class MiniMaxH3TokenRefinerBlock(nn.Module):
+    """Standard pre-norm transformer block without AdaLN or RoPE."""
+
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        self.norm1 = _norm(arch.hidden_size, eps=arch.norm_eps)
+        self.norm2 = _norm(arch.hidden_size, eps=arch.norm_eps)
+        # Text refinement runs on replicated rows before ``sp_prepare``.
+        # Applying Ulysses here would all-to-all an unsharded sequence while
+        # retaining the original packed ``cu_seqlens`` metadata.
+        self.attn = MiniMaxH3Attention(
+            arch,
+            quant_config,
+            prefix=f"{prefix}.attn",
+            role="minimax_h3.token_refiner",
+            role_category="self",
+            skip_sequence_parallel=True,
+        )
+        self.mlp = MiniMaxH3MLP(
+            arch,
+            quant_config,
+            prefix=f"{prefix}.mlp",
+        )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        *,
+        cu_seqlens: torch.Tensor,
+        max_seqlen: int,
+    ) -> torch.Tensor:
+        x = x + self.attn(
+            self.norm1(x),
+            rope_freqs=None,
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+        )
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+
+class MiniMaxH3TokenRefiner(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        self.blocks = nn.ModuleList(
+            [
+                MiniMaxH3TokenRefinerBlock(
+                    arch,
+                    quant_config,
+                    prefix=f"{prefix}.blocks.{i}",
+                )
+                for i in range(arch.token_refiner_num_layers)
+            ]
+        )
+        self.final_norm = _norm(arch.hidden_size, eps=arch.final_norm_eps)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        *,
+        cu_seqlens: torch.Tensor,
+        max_seqlen: int,
+    ) -> torch.Tensor:
+        for block in self.blocks:
+            x = block(x, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen)
+        return self.final_norm(x)
+
+
+class MiniMaxH3DiTBlock(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        self.norm1 = _norm(arch.hidden_size, eps=arch.norm_eps)
+        self.norm2 = _norm(arch.hidden_size, eps=arch.norm_eps)
+        # The prefix also carries the block index that block-sparse attention
+        # backends match against their skip_layers selector.
+        self.attn = MiniMaxH3Attention(
+            arch,
+            quant_config,
+            prefix=f"{prefix}.attn",
+        )
+        self.mlp = MiniMaxH3MLP(
+            arch,
+            quant_config,
+            prefix=f"{prefix}.mlp",
+        )
+        self.adaln_proj = MiniMaxH3AdalnProj(
+            arch,
+            arch.adaln_out_features,
+            quant_config,
+            expand_ratio=6,
+            modality_num=MINIMAX_H3_ADALN_MODALITY_NUM,
+            prefix=f"{prefix}.adaln_proj",
+        )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        *,
+        t_emb: torch.Tensor,
+        combined_indices: torch.Tensor,
+        rope_freqs: torch.Tensor,
+        cu_seqlens: torch.Tensor,
+        max_seqlen: int,
+        packed_total: int,
+        sp_seq_lens: list[int] | None = None,
+        video_layout: VideoTokenLayout | None = None,
+    ) -> torch.Tensor:
+        """x: [T, H]; t_emb: [M, t_dim]; combined_indices: [T]
+        (= inverse_indices * modality_num + token_tags.clamp(min=0)).
+
+        Each block computes AdaLN parameters once, then applies
+        norm1 -> scale/shift -> attention -> gated residual, followed by
+        norm2 -> scale/shift -> MLP -> gated residual.
+        """
+        (
+            shift_msa,
+            scale_msa,
+            gate_msa,
+            shift_mlp,
+            scale_mlp,
+            gate_mlp,
+        ) = self.adaln_proj(t_emb)
+
+        residual = x
+        h = self.norm1(x)
+        h = _modulate_scale_shift(h, shift_msa, scale_msa, combined_indices, dtype=_BF16_DTYPE)
+        h = self.attn(
+            h,
+            rope_freqs=rope_freqs,
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+            packed_total=packed_total,
+            sp_seq_lens=sp_seq_lens,
+            video_layout=video_layout,
+        )
+        x = _modulate_gate(residual, gate_msa, h, combined_indices, dtype=_BF16_DTYPE)
+
+        residual = x
+        h = self.norm2(x)
+        h = _modulate_scale_shift(h, shift_mlp, scale_mlp, combined_indices, dtype=_BF16_DTYPE)
+        h = self.mlp(h)
+        return _modulate_gate(residual, gate_mlp, h, combined_indices, dtype=_BF16_DTYPE)
+
+
+class MiniMaxH3FinalLayer(nn.Module):
+    def __init__(
+        self,
+        arch: MiniMaxH3DiTArchConfig,
+        quant_config: QuantizationConfig | None,
+        *,
+        prefix: str,
+    ) -> None:
+        super().__init__()
+        video_patch_dim = arch.latents_dim * arch.patch_size[0] * arch.patch_size[1] * arch.patch_size[2]
+        self.norm = _norm(arch.hidden_size, eps=arch.final_norm_eps)
+        self.adaln_proj = MiniMaxH3AdalnProj(
+            arch,
+            arch.final_adaln_out_features,
+            quant_config,
+            expand_ratio=2,
+            modality_num=1,
+            prefix=f"{prefix}.adaln_proj",
+        )
+        self.video_out = ColumnParallelLinear(
+            arch.hidden_size,
+            video_patch_dim,
+            bias=True,
+            gather_output=True,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix=f"{prefix}.video_out",
+        )
+        self.audio_out = ColumnParallelLinear(
+            arch.hidden_size,
+            arch.audio_latents_dim,
+            bias=True,
+            gather_output=True,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix=f"{prefix}.audio_out",
+        )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        *,
+        t_emb: torch.Tensor,
+        inverse_indices: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """x: [T, H] -> (video_logits [T, 96] fp32, audio_logits [T, 32] fp32).
+
+        Apply single-modality shift/scale AdaLN to the final normalized
+        activations, cast to fp32, then apply both output heads to all rows.
+        """
+        shift, scale = self.adaln_proj(t_emb)
+        h = self.norm(x)
+        h = _modulate_scale_shift(h, shift, scale, inverse_indices, dtype=_BF16_DTYPE)
+        # Preserve full precision through both final output projections.
+        h = h.to(_FP32_DTYPE)
+        video, _ = self.video_out(h)
+        audio, _ = self.audio_out(h)
+        return video, audio
+
+
+class MiniMaxH3SPPrepare(nn.Module):
+    """Explicit boundary for sharding packed rows and their metadata together."""
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        rope_freqs: torch.Tensor,
+        combined_indices: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        return hidden_states, rope_freqs, combined_indices
+
+
+class MiniMaxH3SPGather(nn.Module):
+    """Explicit boundary for restoring packed rows after the block stack."""
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return hidden_states
+
+
+class MiniMaxH3DiTModel(nn.Module):
+    _cache_dit_adapter_config = CacheDiTAdapterConfig(
+        block_forward_patterns={"blocks": ForwardPattern.Pattern_3},
+        # H3 is CFG-distilled and performs one transformer forward per step.
+        has_separate_cfg=False,
+        check_forward_pattern=False,
+    )
+    _repeated_blocks = ["MiniMaxH3DiTBlock"]
+    _layerwise_offload_blocks_attrs = ["blocks"]
+
+    @staticmethod
+    def _is_transformer_block(name: str, module: nn.Module) -> bool:
+        del module
+        parts = name.split(".")
+        return len(parts) == 2 and parts[0] == "blocks" and parts[1].isdigit()
+
+    _hsdp_shard_conditions = [_is_transformer_block]
+    _hsdp_ignored_modules = [
+        "video_patch_proj",
+        "audio_patch_proj",
+        "time_embedder",
+        "final_layer",
+    ]
+    _sp_plan = {
+        "sp_prepare": {
+            0: SequenceParallelInput(
+                split_dim=0,
+                expected_dims=2,
+                split_output=True,
+            ),
+            1: SequenceParallelInput(
+                split_dim=0,
+                expected_dims=2,
+                split_output=True,
+            ),
+            2: SequenceParallelInput(
+                split_dim=0,
+                expected_dims=1,
+                split_output=True,
+            ),
+        },
+        "sp_gather": SequenceParallelOutput(gather_dim=0, expected_dims=2),
+    }
+    # The checkpoint already stores qkv and the MLP gate/up as single tensors
+    # (see the reordering in load_weights), so there are no unfused names for
+    # quantization or LoRA to map onto. Address the fused layers directly, e.g.
+    # ignored_layers=["blocks.0.attn.qkv_proj"].
+    packed_modules_mapping = {}
+
+    def _validate_tp_config(self, *, arch: MiniMaxH3DiTArchConfig, tp_size: int) -> None:
+        if tp_size < 1:
+            raise ValueError(f"tensor_parallel_size must be positive, got {tp_size}")
+        if arch.num_attention_heads % tp_size:
+            raise ValueError(
+                "num_attention_heads must be divisible by tensor_parallel_size: "
+                f"{arch.num_attention_heads} % {tp_size} != 0"
+            )
+        if arch.ffn_hidden_size % tp_size:
+            raise ValueError(
+                f"ffn_hidden_size must be divisible by tensor_parallel_size: {arch.ffn_hidden_size} % {tp_size} != 0"
+            )
+        if arch.num_attention_heads <= 0:
+            raise ValueError("num_attention_heads must be positive.")
+        if arch.hidden_size <= 0:
+            raise ValueError("hidden_size must be positive.")
+        if arch.attention_head_dim <= 0:
+            raise ValueError("attention_head_dim must be positive.")
+        if arch.ffn_hidden_size <= 0:
+            raise ValueError("ffn_hidden_size must be positive.")
+
+    def __init__(
+        self,
+        od_config: OmniDiffusionConfig,
+        quant_config: QuantizationConfig | None = None,
+    ) -> None:
+        super().__init__()
+        tf_config = od_config.tf_model_config
+        config_mapping = tf_config.to_dict() if hasattr(tf_config, "to_dict") else dict(tf_config)
+        arch = MiniMaxH3DiTArchConfig.from_mapping(config_mapping)
+        self.arch = arch
+        self.od_config = od_config
+        self.parallel_config = od_config.parallel_config
+        self.hidden_size = arch.hidden_size
+        self.num_attention_heads = arch.num_attention_heads
+        self.num_channels_latents = arch.latents_dim
+        self._validate_tp_config(
+            arch=arch,
+            tp_size=get_tensor_model_parallel_world_size(),
+        )
+        local_heads = arch.num_attention_heads // get_tensor_model_parallel_world_size()
+        ulysses_degree = int(self.parallel_config.ulysses_degree)
+        if local_heads % ulysses_degree:
+            raise ValueError(
+                "MiniMax H3 local attention heads must be divisible by "
+                "ulysses_degree: "
+                f"({arch.num_attention_heads} / "
+                f"{get_tensor_model_parallel_world_size()}) % "
+                f"{ulysses_degree} != 0"
+            )
+
+        self.video_patch_proj = ColumnParallelLinear(
+            arch.latents_dim * arch.patch_size[0] * arch.patch_size[1] * arch.patch_size[2],
+            arch.hidden_size,
+            bias=True,
+            gather_output=True,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix="video_patch_proj",
+        )
+        self.audio_patch_proj = ColumnParallelLinear(
+            arch.audio_latents_dim,
+            arch.hidden_size,
+            bias=True,
+            gather_output=True,
+            params_dtype=_FP32_DTYPE,
+            quant_config=None,
+            prefix="audio_patch_proj",
+        )
+        self.condition_proj = ColumnParallelLinear(
+            arch.text_dim,
+            arch.hidden_size,
+            bias=True,
+            gather_output=True,
+            params_dtype=_BF16_DTYPE,
+            quant_config=quant_config,
+            prefix="condition_proj",
+        )
+        self.time_embedder = MiniMaxH3TimeEmbedder(
+            arch,
+            prefix="time_embedder",
+        )
+        self.rope = MiniMaxH3Rope(arch.rope_inv_freq_len)
+        self.token_refiner = MiniMaxH3TokenRefiner(
+            arch,
+            quant_config,
+            prefix="token_refiner",
+        )
+        self.blocks = nn.ModuleList(
+            [
+                MiniMaxH3DiTBlock(
+                    arch,
+                    quant_config,
+                    prefix=f"blocks.{i}",
+                )
+                for i in range(arch.num_layers)
+            ]
+        )
+        self.sp_prepare = MiniMaxH3SPPrepare()
+        self.sp_gather = MiniMaxH3SPGather()
+        self.final_layer = MiniMaxH3FinalLayer(
+            arch,
+            quant_config,
+            prefix="final_layer",
+        )
+        self._mark_missing_params_required()
+
+    def _mark_missing_params_required(self) -> None:
+        for _, param in self.named_parameters():
+            param.missing_param_init = "error"
+
+    def post_load_weights(self) -> None:
+        for name, param in self.named_parameters():
+            if name in MINIMAX_H3_FP32_PARAM_NAMES and param.dtype != _FP32_DTYPE:
+                raise ValueError(f"{name} must stay fp32 after load, got {param.dtype}.")
+        for name, buffer in self.named_buffers():
+            if name in MINIMAX_H3_FP32_BUFFER_NAMES and buffer.dtype != _FP32_DTYPE:
+                raise ValueError(f"{name} must stay fp32 after load, got {buffer.dtype}.")
+
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]],
+    ) -> set[str]:
+        """Load exact H3 checkpoint names with logical TP-aware loaders."""
+        params = dict(self.named_parameters())
+        params.update(dict(self.named_buffers()))
+        loaded: set[str] = set()
+        for name, loaded_weight in weights:
+            param = params.get(name)
+            if param is None:
+                logger.warning("Skipping MiniMax H3 weight not present in model: %s", name)
+                continue
+            weight_loader = getattr(param, "weight_loader", default_weight_loader)
+            if name.endswith(".attn.qkv_proj.weight"):
+                # Transform checkpoint layout before entering vLLM's loader so
+                # online FP8 can keep ``online_process_loader`` outermost.
+                loaded_weight = _reorder_grouped_qkv_to_qkv(
+                    loaded_weight,
+                    num_query_groups=self.arch.num_attention_heads,
+                    heads_per_group=1,
+                    head_dim=self.arch.attention_head_dim,
+                )
+                weight_loader(param, loaded_weight)
+            elif name.endswith(".mlp.fc1.weight"):
+                if loaded_weight.shape[0] % 2:
+                    raise ValueError(
+                        "MiniMax H3 fc1 checkpoint rows must split evenly into "
+                        f"gate/up matrices, got {tuple(loaded_weight.shape)}"
+                    )
+                gate, up = loaded_weight.chunk(2, dim=0)
+                weight_loader(param, gate, 0)
+                weight_loader(param, up, 1)
+            else:
+                weight_loader(param, loaded_weight)
+            loaded.add(name)
+        return loaded
+
+    @staticmethod
+    def _pos_ids(pos_info: Any, key: str) -> torch.Tensor:
+        if isinstance(pos_info, dict):
+            ids = pos_info.get("position_ids")
+        else:
+            ids = getattr(pos_info, "position_ids", None)
+        if ids is None:
+            raise ValueError(f"{key}.position_ids is required")
+        return ids.view(-1).to(torch.long)
+
+    @staticmethod
+    def _psp_field(psp: Any, key: str, field: str) -> Any:
+        if isinstance(psp, dict):
+            value = psp.get(field)
+        else:
+            value = getattr(psp, field, None)
+        if value is None:
+            raise ValueError(f"{key}.{field} is required")
+        return value
+
+    def _embed(
+        self,
+        *,
+        x: torch.Tensor,
+        audio_x: torch.Tensor,
+        text_embeddings_selected: torch.Tensor,
+        unique_timesteps: torch.Tensor,
+        img_pos: torch.Tensor,
+        audio_pos: torch.Tensor,
+        text_pos: torch.Tensor,
+        refiner_cu_seqlens: torch.Tensor,
+        refiner_max_seqlen: int,
+        seq_len: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Build packed multimodal embeddings for the TP=1/SP=1 inference path.
+
+        Returns (decoder_input [S, H] bf16, t_emb [M, t_dim] fp32).
+        """
+        # Latent embedders stay fp32 in and out; their outputs are cast to the
+        # bf16 sequence dtype only during indexed scattering.
+        x_rows = x.view(-1, x.shape[-1]).index_select(0, img_pos).to(_FP32_DTYPE)
+        video_embed, _ = self.video_patch_proj(x_rows)
+        audio_rows = audio_x.view(-1, audio_x.shape[-1]).index_select(0, audio_pos).to(_FP32_DTYPE)
+        audio_embed, _ = self.audio_patch_proj(audio_rows)
+
+        text_rows = text_embeddings_selected.to(device=device, dtype=_BF16_DTYPE)
+        text_embed, _ = self.condition_proj(text_rows)
+        text_embed = self.token_refiner(
+            text_embed,
+            cu_seqlens=refiner_cu_seqlens,
+            max_seqlen=refiner_max_seqlen,
+        )
+
+        embeddings = torch.zeros((seq_len, self.hidden_size), device=device, dtype=_BF16_DTYPE)
+        embeddings.index_add_(0, text_pos, text_embed.to(_BF16_DTYPE)[: text_pos.shape[0]])
+        embeddings.index_add_(0, img_pos, video_embed.to(_BF16_DTYPE)[: img_pos.shape[0]])
+        embeddings.index_add_(0, audio_pos, audio_embed.to(_BF16_DTYPE)[: audio_pos.shape[0]])
+
+        t_emb = self.time_embedder(unique_timesteps)
+        return embeddings, t_emb
+
+    def forward(self, **kwargs: Any) -> tuple[torch.Tensor, torch.Tensor]:
+        """Packed inference forward.
+
+        Keyword names follow the checkpoint's serving contract.
+        Returns `(video_logits, audio_logits)` from rows selected by
+        `img_pos_for_infer_output_info` and `audio_pos_info`, with condition
+        rows zeroed by update masks.
+        """
+        # Strict keyword contract: refuse any kwarg forward does not consume.
+        unexpected = sorted(set(kwargs) - _FORWARD_SUPPORTED_KWARGS)
+        if unexpected:
+            raise TypeError(
+                "MiniMaxH3DiTModel.forward received unexpected kwargs: "
+                f"{unexpected}; supported kwargs: "
+                f"{sorted(_FORWARD_SUPPORTED_KWARGS)}"
+            )
+
+        x = _required_kwarg(kwargs, "x")
+        audio_x = _required_kwarg(kwargs, "audio_x")
+        img_position_ids = _required_kwarg(kwargs, "img_position_ids")
+        unique_timesteps = _required_kwarg(kwargs, "unique_timesteps")
+        inverse_indices = _required_kwarg(kwargs, "inverse_indices").view(-1).to(torch.long)
+        update_mask = _required_kwarg(kwargs, "update_mask")
+        token_tags = _required_kwarg(kwargs, "token_tags").view(-1).to(torch.long)
+        skip_mask_out_condition = bool(kwargs.get("skip_mask_out_condition", False))
+
+        text_selected = _required_kwarg(kwargs, "prompt_embeds")
+
+        img_pos = self._pos_ids(_required_kwarg(kwargs, "img_pos_info"), "img_pos_info")
+        audio_pos = self._pos_ids(_required_kwarg(kwargs, "audio_pos_info"), "audio_pos_info")
+        text_pos = self._pos_ids(
+            _required_kwarg(kwargs, "text_pos_info"),
+            "text_pos_info",
+        )
+        infer_out_pos = self._pos_ids(
+            _required_kwarg(kwargs, "img_pos_for_infer_output_info"),
+            "img_pos_for_infer_output_info",
+        )
+
+        psp = _required_kwarg(kwargs, "packed_seq_params")
+        cu_seqlens = self._psp_field(psp, "packed_seq_params", "cu_seqlens_q").to(torch.int32)
+        max_seqlen = int(self._psp_field(psp, "packed_seq_params", "max_seqlen_q"))
+        refiner_psp = _required_kwarg(kwargs, "refiner_packed_seq_params")
+        refiner_cu = self._psp_field(refiner_psp, "refiner_packed_seq_params", "cu_seqlens_q").to(torch.int32)
+        refiner_max = int(self._psp_field(refiner_psp, "refiner_packed_seq_params", "max_seqlen_q"))
+        video_layout = kwargs.get("video_token_layout")
+
+        if x.dim() != 3 or x.shape[0] != 1:
+            raise ValueError(f"x must be [1, S, C], got {list(x.shape)}")
+        seq_len = int(x.shape[1])
+        if token_tags.shape[0] != seq_len:
+            raise ValueError(f"token_tags must cover the full packed sequence ({seq_len}), got {token_tags.shape[0]}.")
+        if inverse_indices.shape[0] != seq_len:
+            raise ValueError(f"inverse_indices must be [{seq_len}], got {list(inverse_indices.shape)}")
+        device = x.device
+        # Compute RoPE frequencies over the full packed sequence.
+        rope_freqs = self.rope(img_position_ids).to(device)
+
+        decoder_input, t_emb = self._embed(
+            x=x,
+            audio_x=audio_x,
+            text_embeddings_selected=text_selected,
+            unique_timesteps=unique_timesteps.view(-1).to(device),
+            img_pos=img_pos.to(device),
+            audio_pos=audio_pos.to(device),
+            text_pos=text_pos.to(device),
+            refiner_cu_seqlens=refiner_cu.to(device),
+            refiner_max_seqlen=refiner_max,
+            seq_len=seq_len,
+            device=device,
+        )
+
+        combined_indices = (inverse_indices * MINIMAX_H3_ADALN_MODALITY_NUM + token_tags.clamp(min=0)).to(device)
+        inverse_indices = inverse_indices.to(device)
+
+        hidden = decoder_input
+        cu_seqlens = cu_seqlens.to(device)
+        block_rope = rope_freqs
+        block_combined = combined_indices
+
+        hidden, block_rope, block_combined = self.sp_prepare(
+            hidden,
+            block_rope,
+            block_combined,
+        )
+        for block in self.blocks:
+            hidden = block(
+                hidden,
+                t_emb=t_emb,
+                combined_indices=block_combined,
+                rope_freqs=block_rope,
+                cu_seqlens=cu_seqlens,
+                max_seqlen=max_seqlen,
+                packed_total=seq_len,
+                video_layout=video_layout,
+            )
+        hidden = self.sp_gather(hidden)
+
+        video_logits, audio_logits = self.final_layer(
+            hidden,
+            t_emb=t_emb,
+            inverse_indices=inverse_indices,
+        )
+
+        # Select target and condition rows at inference-output positions, then
+        # zero the condition rows.
+        video_logits = video_logits.index_select(0, infer_out_pos.to(device))
+        audio_logits = audio_logits.index_select(0, audio_pos.to(device))
+        if not skip_mask_out_condition:
+            update_mask = update_mask.view(-1).to(device)
+            if update_mask.shape[0] != video_logits.shape[0]:
+                raise ValueError(f"update_mask length mismatch: {update_mask.shape[0]} != {video_logits.shape[0]}")
+            video_logits = video_logits * update_mask.unsqueeze(-1)
+            # Audio has no condition rows in the supported tasks, so its
+            # derived update mask is all ones. Honor an explicit mask when
+            # provided.
+            update_audio_mask = kwargs.get("update_audio_mask")
+            if update_audio_mask is not None:
+                audio_logits = audio_logits * update_audio_mask.view(-1).unsqueeze(-1)
+        return video_logits, audio_logits
+
+
+EntryClass = MiniMaxH3DiTModel
+
+__all__ = [
+    "MINIMAX_H3_FP32_BUFFER_NAMES",
+    "MINIMAX_H3_FP32_PARAM_NAMES",
+    "MiniMaxH3DiTModel",
+    "_reorder_grouped_qkv_to_qkv",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
new file mode 100644
index 000000000..a57eae700
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
@@ -0,0 +1,578 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 packed-sequence materialization for FL2VA and Ref2VA tasks.
+
+Layout: [text L | imgvid_cond C | audio A(=t*2ch) | video_target V | pad P].
+Builder rules:
+- placeholder ids; block-derived pos infos/masks/cu_seqlens/document_id
+- img_position_ids fp64 grid: text rows (row_idx,0,0); video/cond t counter
+  continues text_len with temporal interp spans (frame_rescale 5/3 x
+  frame_per_token (1,4,4,4,4)); each spatial sqrt_area axis uses evenly spaced
+  coordinates excluding the right endpoint, then scales them by INTERP;
+  audio channel-major blocks pinned to the w-grid extremes.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+import numpy as np
+import torch
+
+MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES: tuple[tuple[int, ...], ...] = (
+    (0,),
+    (-1,),
+    (0, -1),
+)
+
+MINIMAX_H3_TEXT_ID = -5
+MINIMAX_H3_IMGVID_COND_ID = -11
+MINIMAX_H3_AUDIO_REF_COND_ID = -17
+MINIMAX_H3_AUDIO_FIRST_ID = -15
+MINIMAX_H3_AUDIO_ID = -14
+MINIMAX_H3_VIDEO_FIRST_ID = -3
+MINIMAX_H3_VIDEO_ID = -2
+MINIMAX_H3_VIDEO_LAST_ID = -4
+MINIMAX_H3_PAD_ID = -1
+
+_INTERP = 32
+_T_GROUP = 5
+_FRAME_PER_TOKEN = (1, 4, 4, 4, 4)
+_FRAME_RESCALE = 5.0 / 3.0
+_SEQ_ALIGN = 64
+# MiniMax H3 packs video latents with a fixed [1, 2, 2] (t, h, w) patch.
+_PATCH_T = 1
+_PATCH_H = 2
+_PATCH_W = 2
+
+
+def _keyframe_cond_frame_indices(
+    *,
+    include_keyframe_cond: bool,
+    keyframe_frame_indices: list[int] | tuple[int, ...] | None,
+) -> list[int]:
+    if not include_keyframe_cond:
+        if keyframe_frame_indices is not None:
+            raise ValueError("keyframe_frame_indices must be omitted when keyframe cond is not included")
+        return []
+    if keyframe_frame_indices is None:
+        raise ValueError("strict fl2va packed layout requires keyframe_frame_indices")
+    if any(isinstance(value, bool) or not isinstance(value, int) for value in keyframe_frame_indices):
+        raise ValueError("strict fl2va packed layout requires integer keyframe_frame_indices")
+    out = list(keyframe_frame_indices)
+    if tuple(out) not in MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES:
+        raise ValueError(
+            "strict fl2va packed layout requires keyframe_frame_indices in "
+            f"{MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES!r}, got {out!r}"
+        )
+    return out
+
+
+def _resolve_keyframe_frame_indices(
+    frame_indices: Sequence[int],
+    *,
+    frame_count: int | None,
+) -> list[int]:
+    if frame_indices and frame_count is None:
+        raise ValueError("frame_count is required when keyframe_frame_indices are provided")
+    if frame_count is None:
+        return []
+    if frame_count <= 0:
+        raise ValueError("frame_count must be positive")
+    seen: dict[int, int] = {}
+    resolved: list[int] = []
+    for block_index, semantic_index in enumerate(frame_indices):
+        if semantic_index == -1:
+            resolved_index = frame_count - 1
+        elif 0 <= semantic_index < frame_count:
+            resolved_index = semantic_index
+        else:
+            raise ValueError(f"keyframe frame index {semantic_index} must be -1 or in [0, {frame_count})")
+        previous = seen.get(resolved_index)
+        if previous is not None:
+            raise ValueError(
+                f"keyframe frame index at block {block_index} resolves to "
+                f"{resolved_index}, already bound by block {previous}"
+            )
+        seen[resolved_index] = block_index
+        resolved.append(resolved_index)
+    return resolved
+
+
+def _temporal_position_span(temporal_length: int) -> float:
+    """Temporal position span for patch_t=1, in fp64.
+
+    NOTE: intentionally NOT merged with ``_video_t_span``. This variant sums
+    via numpy (pairwise summation), matching the fl2va anchor computation,
+    while ``_video_t_span`` sums sequentially, matching the ref2va
+    t-origin accumulation. The two orders diverge in the last ulp
+    from n=16 onward, so each path must keep its own summation order.
+    """
+    spans = np.ones(int(temporal_length), dtype=np.float64) * _FRAME_RESCALE
+    for token_index in range(_T_GROUP):
+        spans[token_index::_T_GROUP] *= _FRAME_PER_TOKEN[token_index]
+    return float(spans.sum())
+
+
+def minimax_h3_packed_sequence(
+    *,
+    text_len: int,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+    audio_t: int,
+    audio_channel: int = 2,
+    include_keyframe_cond: bool,
+    keyframe_frame_indices: list[int] | tuple[int, ...] | None = None,
+    frame_count: int | None = None,
+) -> dict[str, torch.Tensor]:
+    """Build the packed-sequence structural fields for one CFG branch.
+
+    The used length is padded up to a multiple of 64.
+    """
+    ph, pw = latent_h // _PATCH_H, latent_w // _PATCH_W
+    frame_rows = ph * pw
+    cond_frame_indices = _keyframe_cond_frame_indices(
+        include_keyframe_cond=include_keyframe_cond,
+        keyframe_frame_indices=keyframe_frame_indices,
+    )
+    resolved_cond_frame_indices = _resolve_keyframe_frame_indices(
+        cond_frame_indices,
+        frame_count=frame_count,
+    )
+    cond_rows = len(cond_frame_indices) * frame_rows
+    video_rows = latent_t * frame_rows
+    audio_rows = audio_t * audio_channel
+    used = text_len + cond_rows + audio_rows + video_rows
+    seq_len = ((used + _SEQ_ALIGN - 1) // _SEQ_ALIGN) * _SEQ_ALIGN
+
+    text_sl = slice(0, text_len)
+    cond_sl = slice(text_len, text_len + cond_rows)
+    audio_sl = slice(cond_sl.stop, cond_sl.stop + audio_rows)
+    video_sl = slice(audio_sl.stop, audio_sl.stop + video_rows)
+    pad_sl = slice(video_sl.stop, seq_len)
+
+    input_ids = torch.full((seq_len,), MINIMAX_H3_PAD_ID, dtype=torch.int64)
+    input_ids[text_sl] = MINIMAX_H3_TEXT_ID
+    if cond_rows:
+        input_ids[cond_sl] = MINIMAX_H3_IMGVID_COND_ID
+    input_ids[audio_sl] = MINIMAX_H3_AUDIO_ID
+    input_ids[audio_sl.start] = MINIMAX_H3_AUDIO_FIRST_ID
+    input_ids[video_sl] = MINIMAX_H3_VIDEO_ID
+    input_ids[video_sl.start] = MINIMAX_H3_VIDEO_FIRST_ID
+    input_ids[video_sl.stop - 1] = MINIMAX_H3_VIDEO_LAST_ID
+
+    image_mask = torch.zeros(seq_len, dtype=torch.bool)
+    image_mask[cond_sl] = True
+    image_mask[video_sl] = True
+    audio_mask = torch.zeros(seq_len, dtype=torch.bool)
+    audio_mask[audio_sl] = True
+
+    img_pos = torch.cat(
+        [
+            torch.arange(cond_sl.start, cond_sl.stop),
+            torch.arange(video_sl.start, video_sl.stop),
+        ]
+    )
+    update_mask = torch.zeros(img_pos.shape[0], dtype=torch.bool)
+    update_mask[cond_rows:] = True
+    audio_pos = torch.arange(audio_sl.start, audio_sl.stop)
+    text_pos = torch.arange(0, text_len)
+
+    g = torch.zeros(seq_len, 3, dtype=torch.float64)
+    g[text_sl, 0] = torch.arange(text_len, dtype=torch.float64)
+
+    t_grid = _video_t_grid(latent_t, float(text_len))
+    sqrt_area = np.sqrt(latent_h * latent_w)
+    h_grid = _axis_from_sqrt_area(latent_h, _PATCH_H, sqrt_area)
+    w_grid = _axis_from_sqrt_area(latent_w, _PATCH_W, sqrt_area)
+    hh, ww = torch.meshgrid(h_grid, w_grid, indexing="ij")
+    frame = torch.stack([hh.reshape(-1), ww.reshape(-1)], dim=-1)
+    video_g = torch.empty(latent_t, frame_rows, 3, dtype=torch.float64)
+    video_g[:, :, 0] = t_grid[:, None]
+    video_g[:, :, 1:] = frame[None]
+    for block_index, pixel_index in enumerate(resolved_cond_frame_indices):
+        sl = slice(
+            cond_sl.start + block_index * frame_rows,
+            cond_sl.start + (block_index + 1) * frame_rows,
+        )
+        if pixel_index == 0:
+            cond_t = float(text_len)
+        elif frame_count is not None and pixel_index == frame_count - 1:
+            cond_t = float(text_len) + _temporal_position_span(latent_t) - _FRAME_RESCALE
+        else:
+            raise ValueError(
+                f"fl2va packed layout only supports first/last keyframe anchors, got resolved frame index {pixel_index}"
+            )
+        g[sl, 0] = cond_t
+        g[sl, 1:] = frame
+    g[video_sl] = video_g.reshape(-1, 3)
+    audio_t_grid = float(text_len) + torch.arange(audio_t, dtype=torch.float64)
+    g[audio_sl, 0] = audio_t_grid.repeat(audio_channel)
+    g[audio_sl, 2] = torch.cat(
+        [
+            torch.full((audio_t,), float(w_grid[0]), dtype=torch.float64),
+            torch.full((audio_rows - audio_t,), float(w_grid[-1]), dtype=torch.float64),
+        ]
+    )
+
+    token_tags = torch.full((seq_len,), -1, dtype=torch.long)  # PADDING
+    token_tags[text_sl] = 1  # TEXT (fl2va image-segment override happens upstream)
+    token_tags[audio_sl] = 2  # AUDIO
+    token_tags[img_pos] = 0  # VIDEO
+
+    cu = torch.tensor([0, used, seq_len], dtype=torch.int32)
+    doc = torch.zeros(seq_len, dtype=torch.int32)
+    doc[pad_sl] = 1
+    return {
+        "seq_len": torch.tensor(seq_len),
+        "input_ids": input_ids,
+        "image_mask": image_mask,
+        "audio_mask": audio_mask,
+        "img_pos": img_pos,
+        "audio_pos": audio_pos,
+        "text_pos": text_pos,
+        "update_mask": update_mask,
+        "img_position_ids": g,
+        "token_tags": token_tags,
+        "cu_seqlens": cu,
+        "document_id": doc,
+        # Extent of the video segment within the packed sequence.
+        "latent_grid": torch.tensor([latent_t, ph, pw], dtype=torch.int64),
+        "video_row_start": torch.tensor(video_sl.start, dtype=torch.int64),
+    }
+
+
+def _positive_int(
+    block: Mapping[str, object],
+    key: str,
+    path: str,
+    *,
+    allow_zero: bool = False,
+) -> int:
+    value = block.get(key)
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"{path}.{key} must be an integer")
+    if value < 0 or (value == 0 and not allow_zero):
+        predicate = "non-negative" if allow_zero else "positive"
+        raise ValueError(f"{path}.{key} must be {predicate}")
+    return int(value)
+
+
+def _axis_from_sqrt_area(dim: int, patch: int, sqrt_area: float) -> torch.Tensor:
+    ratio = dim / sqrt_area
+    left = (1.0 - ratio) * 1.0 / 2.0
+    right = left + ratio * 1.0
+    grid = np.linspace(left, right, dim // patch, endpoint=False) * _INTERP
+    return torch.from_numpy(grid).to(torch.float64)
+
+
+def _video_t_grid(n: int, origin: float) -> torch.Tensor:
+    spans = torch.tensor(
+        [_FRAME_RESCALE * _FRAME_PER_TOKEN[k % _T_GROUP] for k in range(n)],
+        dtype=torch.float64,
+    )
+    return origin + torch.cat([torch.zeros(1, dtype=torch.float64), spans[:-1].cumsum(0)])
+
+
+def _video_t_span(n: int) -> float:
+    # Sequential fp64 summation on purpose — see _temporal_position_span for
+    # why the two span implementations must not be unified.
+    return sum(_FRAME_RESCALE * _FRAME_PER_TOKEN[k % _T_GROUP] for k in range(n))
+
+
+def _range_for_slice(sl: slice) -> torch.Tensor:
+    return torch.arange(sl.start, sl.stop, dtype=torch.long)
+
+
+def _cat_ranges(parts: list[torch.Tensor]) -> torch.Tensor:
+    if parts:
+        return torch.cat(parts)
+    return torch.empty(0, dtype=torch.long)
+
+
+def minimax_h3_packed_sequence_ref2va_blocks(
+    *,
+    text_len: int,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+    audio_t: int,
+    ref_blocks: Sequence[Mapping[str, object]],
+    audio_channel: int = 2,
+    seq_len: int | None = None,
+) -> dict[str, torch.Tensor]:
+    """General ref2va-family packed layout.
+
+    ``ref_blocks`` are consumed in request/plan order:
+    - ``{"kind": "image", "latent_h": H, "latent_w": W}``
+    - ``{"kind": "audio", "ref_audio_t": T}``
+    - ``{"kind": "video"|"video_audio", "ref_audio_t": T,
+       "latent_t": RT, "latent_h": RH, "latent_w": RW}``
+
+    Video-bearing blocks pack their audio rows immediately before their video
+    rows; both share the same temporal origin and advance by the longer of the
+    audio and video spans. Standalone audio advances the target origin by its
+    own T, and image blocks advance it by one integer slot.
+    """
+    if not isinstance(ref_blocks, Sequence) or isinstance(ref_blocks, (str, bytes)):
+        raise ValueError("ref_blocks must be a sequence")
+
+    parsed: list[dict[str, object]] = []
+    ref_visual_rows = 0
+    ref_audio_rows = 0
+    for index, raw in enumerate(ref_blocks):
+        path = f"ref_blocks[{index}]"
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"{path} must be an object")
+        kind = raw.get("kind", raw.get("type"))
+        if not isinstance(kind, str) or not kind:
+            raise ValueError(f"{path}.kind must be a non-empty string")
+        if kind == "image":
+            rh = _positive_int(raw, "latent_h", path)
+            rw = _positive_int(raw, "latent_w", path)
+            rows = (rh // _PATCH_H) * (rw // _PATCH_W)
+            item = {"kind": kind, "latent_h": rh, "latent_w": rw, "rows": rows}
+            ref_visual_rows += rows
+        elif kind == "audio":
+            rt = _positive_int(raw, "ref_audio_t", path, allow_zero=True)
+            rows = rt * audio_channel
+            item = {"kind": kind, "ref_audio_t": rt, "audio_rows": rows}
+            ref_audio_rows += rows
+        elif kind in ("video", "video_audio"):
+            rt = _positive_int(raw, "ref_audio_t", path, allow_zero=True)
+            vt = _positive_int(raw, "latent_t", path)
+            vh = _positive_int(raw, "latent_h", path)
+            vw = _positive_int(raw, "latent_w", path)
+            frame_rows = (vh // _PATCH_H) * (vw // _PATCH_W)
+            audio_rows = rt * audio_channel
+            video_rows = vt * frame_rows
+            item = {
+                "kind": kind,
+                "ref_audio_t": rt,
+                "latent_t": vt,
+                "latent_h": vh,
+                "latent_w": vw,
+                "frame_rows": frame_rows,
+                "audio_rows": audio_rows,
+                "video_rows": video_rows,
+            }
+            ref_audio_rows += audio_rows
+            ref_visual_rows += video_rows
+        else:
+            raise ValueError(f"{path}.kind unsupported for ref2va: {kind!r}")
+        parsed.append(item)
+
+    ph, pw = latent_h // _PATCH_H, latent_w // _PATCH_W
+    frame_rows = ph * pw
+    video_rows = latent_t * frame_rows
+    audio_rows = audio_t * audio_channel
+    ref_rows = ref_visual_rows + ref_audio_rows
+    used = text_len + ref_rows + audio_rows + video_rows
+    if seq_len is None:
+        seq_len = ((used + _SEQ_ALIGN - 1) // _SEQ_ALIGN) * _SEQ_ALIGN
+    if seq_len < used:
+        raise ValueError(f"seq_len {seq_len} < used rows {used}")
+
+    text_sl = slice(0, text_len)
+    cursor = text_len
+    block_slices: list[dict[str, object]] = []
+    for item in parsed:
+        kind = str(item["kind"])
+        if kind == "image":
+            rows = int(item["rows"])
+            visual_sl = slice(cursor, cursor + rows)
+            cursor = visual_sl.stop
+            block_slices.append({**item, "visual_sl": visual_sl})
+        elif kind == "audio":
+            rows = int(item["audio_rows"])
+            audio_sl = slice(cursor, cursor + rows)
+            cursor = audio_sl.stop
+            block_slices.append({**item, "audio_sl": audio_sl})
+        else:
+            a_rows = int(item["audio_rows"])
+            v_rows = int(item["video_rows"])
+            audio_sl = slice(cursor, cursor + a_rows)
+            visual_sl = slice(audio_sl.stop, audio_sl.stop + v_rows)
+            cursor = visual_sl.stop
+            block_slices.append({**item, "audio_sl": audio_sl, "visual_sl": visual_sl})
+
+    audio_sl = slice(cursor, cursor + audio_rows)
+    video_sl = slice(audio_sl.stop, audio_sl.stop + video_rows)
+    pad_sl = slice(video_sl.stop, seq_len)
+
+    input_ids = torch.full((seq_len,), MINIMAX_H3_PAD_ID, dtype=torch.int64)
+    input_ids[text_sl] = MINIMAX_H3_TEXT_ID
+    image_mask = torch.zeros(seq_len, dtype=torch.bool)
+    audio_mask = torch.zeros(seq_len, dtype=torch.bool)
+
+    ref_img_pos_parts: list[torch.Tensor] = []
+    ref_audio_pos_parts: list[torch.Tensor] = []
+    g = torch.zeros(seq_len, 3, dtype=torch.float64)
+    g[text_sl, 0] = torch.arange(text_len, dtype=torch.float64)
+
+    target_area = np.sqrt(latent_h * latent_w)
+    h_grid = _axis_from_sqrt_area(latent_h, _PATCH_H, target_area)
+    w_grid = _axis_from_sqrt_area(latent_w, _PATCH_W, target_area)
+    hh, ww = torch.meshgrid(h_grid, w_grid, indexing="ij")
+    target_frame = torch.stack([hh.reshape(-1), ww.reshape(-1)], dim=-1)
+
+    t_cursor = float(text_len)
+    for item in block_slices:
+        kind = str(item["kind"])
+        if kind == "image":
+            visual_sl = item["visual_sl"]
+            assert isinstance(visual_sl, slice)
+            input_ids[visual_sl] = MINIMAX_H3_IMGVID_COND_ID
+            image_mask[visual_sl] = True
+            ref_img_pos_parts.append(_range_for_slice(visual_sl))
+            rh = int(item["latent_h"])
+            rw = int(item["latent_w"])
+            area = np.sqrt(rh * rw)
+            ref_hh, ref_ww = torch.meshgrid(
+                _axis_from_sqrt_area(rh, _PATCH_H, area),
+                _axis_from_sqrt_area(rw, _PATCH_W, area),
+                indexing="ij",
+            )
+            g[visual_sl, 0] = t_cursor
+            g[visual_sl, 1] = ref_hh.reshape(-1)
+            g[visual_sl, 2] = ref_ww.reshape(-1)
+            t_cursor += 1.0
+        elif kind == "audio":
+            audio_ref_sl = item["audio_sl"]
+            assert isinstance(audio_ref_sl, slice)
+            ref_t = int(item["ref_audio_t"])
+            input_ids[audio_ref_sl] = MINIMAX_H3_AUDIO_REF_COND_ID
+            audio_mask[audio_ref_sl] = True
+            ref_audio_pos_parts.append(_range_for_slice(audio_ref_sl))
+            ref_t_grid = t_cursor + torch.arange(ref_t, dtype=torch.float64)
+            g[audio_ref_sl, 0] = ref_t_grid.repeat(audio_channel)
+            if ref_t:
+                g[audio_ref_sl, 2] = torch.cat(
+                    [
+                        torch.full((ref_t,), float(w_grid[0]), dtype=torch.float64),
+                        torch.full(
+                            (int(item["audio_rows"]) - ref_t,),
+                            float(w_grid[-1]),
+                            dtype=torch.float64,
+                        ),
+                    ]
+                )
+            t_cursor += float(ref_t)
+        else:
+            audio_ref_sl = item["audio_sl"]
+            visual_sl = item["visual_sl"]
+            assert isinstance(audio_ref_sl, slice)
+            assert isinstance(visual_sl, slice)
+            ref_t = int(item["ref_audio_t"])
+            vt = int(item["latent_t"])
+            vh = int(item["latent_h"])
+            vw = int(item["latent_w"])
+            input_ids[audio_ref_sl] = MINIMAX_H3_AUDIO_REF_COND_ID
+            input_ids[visual_sl] = MINIMAX_H3_IMGVID_COND_ID
+            audio_mask[audio_ref_sl] = True
+            image_mask[visual_sl] = True
+            ref_audio_pos_parts.append(_range_for_slice(audio_ref_sl))
+            ref_img_pos_parts.append(_range_for_slice(visual_sl))
+
+            ref_area = np.sqrt(vh * vw)
+            rv_h_grid = _axis_from_sqrt_area(vh, _PATCH_H, ref_area)
+            rv_w_grid = _axis_from_sqrt_area(vw, _PATCH_W, ref_area)
+            rv_hh, rv_ww = torch.meshgrid(rv_h_grid, rv_w_grid, indexing="ij")
+
+            ref_t_grid = t_cursor + torch.arange(ref_t, dtype=torch.float64)
+            g[audio_ref_sl, 0] = ref_t_grid.repeat(audio_channel)
+            if ref_t:
+                g[audio_ref_sl, 2] = torch.cat(
+                    [
+                        torch.full((ref_t,), float(rv_w_grid[0]), dtype=torch.float64),
+                        torch.full(
+                            (int(item["audio_rows"]) - ref_t,),
+                            float(rv_w_grid[-1]),
+                            dtype=torch.float64,
+                        ),
+                    ]
+                )
+
+            rv_frame = torch.stack([rv_hh.reshape(-1), rv_ww.reshape(-1)], dim=-1)
+            rv_g = torch.empty(vt, int(item["frame_rows"]), 3, dtype=torch.float64)
+            rv_g[:, :, 0] = _video_t_grid(vt, t_cursor)[:, None]
+            rv_g[:, :, 1:] = rv_frame[None]
+            g[visual_sl] = rv_g.reshape(-1, 3)
+            t_cursor += max(float(ref_t), _video_t_span(vt))
+
+    input_ids[audio_sl] = MINIMAX_H3_AUDIO_ID
+    input_ids[audio_sl.start] = MINIMAX_H3_AUDIO_FIRST_ID
+    input_ids[video_sl] = MINIMAX_H3_VIDEO_ID
+    input_ids[video_sl.start] = MINIMAX_H3_VIDEO_FIRST_ID
+    input_ids[video_sl.stop - 1] = MINIMAX_H3_VIDEO_LAST_ID
+    audio_mask[audio_sl] = True
+    image_mask[video_sl] = True
+
+    audio_t_grid = t_cursor + torch.arange(audio_t, dtype=torch.float64)
+    g[audio_sl, 0] = audio_t_grid.repeat(audio_channel)
+    g[audio_sl, 2] = torch.cat(
+        [
+            torch.full((audio_t,), float(w_grid[0]), dtype=torch.float64),
+            torch.full((audio_rows - audio_t,), float(w_grid[-1]), dtype=torch.float64),
+        ]
+    )
+
+    video_g = torch.empty(latent_t, frame_rows, 3, dtype=torch.float64)
+    video_g[:, :, 0] = _video_t_grid(latent_t, t_cursor)[:, None]
+    video_g[:, :, 1:] = target_frame[None]
+    g[video_sl] = video_g.reshape(-1, 3)
+
+    target_img_pos = _range_for_slice(video_sl)
+    target_audio_pos = _range_for_slice(audio_sl)
+    img_pos = _cat_ranges(ref_img_pos_parts + [target_img_pos])
+    audio_pos = _cat_ranges(ref_audio_pos_parts + [target_audio_pos])
+
+    update_mask = torch.zeros(img_pos.shape[0], dtype=torch.bool)
+    update_mask[ref_visual_rows:] = True
+    audio_update_mask = torch.zeros(audio_pos.shape[0], dtype=torch.bool)
+    audio_update_mask[ref_audio_rows:] = True
+    text_pos = torch.arange(0, text_len)
+
+    token_tags = torch.full((seq_len,), -1, dtype=torch.long)  # PADDING
+    token_tags[text_sl] = 1  # TEXT
+    if ref_audio_rows:
+        token_tags[_cat_ranges(ref_audio_pos_parts)] = 2  # AUDIO (reference)
+    token_tags[audio_sl] = 2  # AUDIO (target)
+    token_tags[img_pos] = 0  # VIDEO (refs + target)
+
+    cu = torch.tensor([0, used, seq_len], dtype=torch.int32)
+    doc = torch.zeros(seq_len, dtype=torch.int32)
+    doc[pad_sl] = 1
+    return {
+        "seq_len": torch.tensor(seq_len),
+        "input_ids": input_ids,
+        "image_mask": image_mask,
+        "audio_mask": audio_mask,
+        "img_pos": img_pos,
+        "audio_pos": audio_pos,
+        "text_pos": text_pos,
+        "update_mask": update_mask,
+        "audio_update_mask": audio_update_mask,
+        "img_position_ids": g,
+        "token_tags": token_tags,
+        "cu_seqlens": cu,
+        "document_id": doc,
+        # Extent of the video segment within the packed sequence.
+        "latent_grid": torch.tensor([latent_t, ph, pw], dtype=torch.int64),
+        "video_row_start": torch.tensor(video_sl.start, dtype=torch.int64),
+    }
+
+
+__all__ = [
+    "MINIMAX_H3_AUDIO_FIRST_ID",
+    "MINIMAX_H3_AUDIO_ID",
+    "MINIMAX_H3_AUDIO_REF_COND_ID",
+    "MINIMAX_H3_IMGVID_COND_ID",
+    "MINIMAX_H3_PAD_ID",
+    "MINIMAX_H3_TEXT_ID",
+    "MINIMAX_H3_VIDEO_FIRST_ID",
+    "MINIMAX_H3_VIDEO_ID",
+    "MINIMAX_H3_VIDEO_LAST_ID",
+    "minimax_h3_packed_sequence",
+    "minimax_h3_packed_sequence_ref2va_blocks",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/packed_tokens.py b/vllm_omni/diffusion/models/minimax_h3/packed_tokens.py
new file mode 100644
index 000000000..e37fe75d8
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/packed_tokens.py
@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+
+def _int_tuple(value: Sequence[int], name: str, length: int) -> tuple[int, ...]:
+    if len(value) != length:
+        raise ValueError(f"{name} must have length {length}, got {list(value)!r}")
+    out = tuple(int(item) for item in value)
+    if any(item <= 0 for item in out):
+        raise ValueError(f"{name} values must be positive, got {list(value)!r}")
+    return out
+
+
+def _rank(tensor: torch.Tensor, name: str, rank: int) -> None:
+    if tensor.ndim != rank:
+        raise ValueError(f"{name} must be rank {rank}, got shape={list(tensor.shape)}")
+
+
+def minimax_h3_patchify_video_latent(
+    latent: torch.Tensor,
+    *,
+    patch_size: Sequence[int],
+) -> torch.Tensor:
+    """Pack video latent [B,C,T,H,W] into DiT token rows."""
+
+    _rank(latent, "video latent", 5)
+    pt, ph, pw = _int_tuple(patch_size, "patch_size", 3)
+    batch, channel, full_t, full_h, full_w = (int(dim) for dim in latent.shape)
+    if full_t % pt or full_h % ph or full_w % pw:
+        raise ValueError(
+            "video latent spatial/time dims must be divisible by patch_size: "
+            f"shape={list(latent.shape)}, patch_size={[pt, ph, pw]}"
+        )
+    t, h, w = full_t // pt, full_h // ph, full_w // pw
+    packed = latent.reshape(batch, channel, t, pt, h, ph, w, pw)
+    packed = torch.einsum("nctrhpwq->nthwcrpq", packed)
+    return packed.reshape(batch * t * h * w, channel * pt * ph * pw).contiguous()
+
+
+def minimax_h3_unpatchify_video_tokens(
+    rows: torch.Tensor,
+    *,
+    latent_shape: Sequence[int],
+    patch_size: Sequence[int],
+) -> torch.Tensor:
+    """Unpack DiT video token rows into latent [B,C,T,H,W]."""
+
+    _rank(rows, "video token rows", 2)
+    t, h, w, channel = _int_tuple(latent_shape, "latent_shape", 4)
+    pt, ph, pw = _int_tuple(patch_size, "patch_size", 3)
+    expected_dim = pt * ph * pw * channel
+    if int(rows.shape[-1]) != expected_dim:
+        raise ValueError(
+            f"video token dim {int(rows.shape[-1])} != patch volume * channel "
+            f"{expected_dim} for latent_shape={list(latent_shape)}, "
+            f"patch_size={[pt, ph, pw]}"
+        )
+    rows_per_sample = t * h * w
+    if int(rows.shape[0]) % rows_per_sample:
+        raise ValueError(
+            f"video rows {int(rows.shape[0])} must be divisible by t*h*w "
+            f"{rows_per_sample} for latent_shape={list(latent_shape)}"
+        )
+    packed = rows.reshape(-1, t, h, w, channel, pt, ph, pw)
+    latent = torch.einsum("nthwcrpq->nctrhpwq", packed)
+    return latent.reshape(-1, channel, t * pt, h * ph, w * pw).contiguous()
+
+
+def minimax_h3_pack_audio_latent(latent: torch.Tensor) -> torch.Tensor:
+    """Pack audio VAE latent [audio_channel, latent_dim, T] into rows."""
+
+    _rank(latent, "audio latent", 3)
+    audio_channel, latent_dim, steps = (int(dim) for dim in latent.shape)
+    return (
+        latent.permute(0, 2, 1)
+        .reshape(
+            audio_channel * steps,
+            latent_dim,
+        )
+        .contiguous()
+    )
+
+
+def minimax_h3_unpack_audio_tokens(
+    rows: torch.Tensor,
+    *,
+    audio_t: int,
+    audio_channel: int,
+) -> torch.Tensor:
+    """Unpack DiT audio token rows into audio VAE latent [C,latent_dim,T]."""
+
+    _rank(rows, "audio token rows", 2)
+    audio_t = int(audio_t)
+    audio_channel = int(audio_channel)
+    if audio_t <= 0 or audio_channel <= 0:
+        raise ValueError(f"audio_t and audio_channel must be positive, got {audio_t=} {audio_channel=}")
+    if int(rows.shape[0]) != audio_t:
+        raise ValueError(f"audio rows {int(rows.shape[0])} != audio_t {audio_t}")
+    if audio_t % audio_channel:
+        raise ValueError(f"audio_t must be divisible by audio_channel, got {audio_t=} {audio_channel=}")
+    native = rows.reshape(audio_channel, audio_t // audio_channel, int(rows.shape[-1]))
+    return native.permute(0, 2, 1).contiguous()
+
+
+__all__ = [
+    "minimax_h3_pack_audio_latent",
+    "minimax_h3_patchify_video_latent",
+    "minimax_h3_unpack_audio_tokens",
+    "minimax_h3_unpatchify_video_tokens",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
new file mode 100644
index 000000000..b11b4e320
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
@@ -0,0 +1,1776 @@
+# SPDX-License-Identifier: Apache-2.0
+"""vLLM-Omni pipeline for MiniMax H3 FL2VA and Ref2VA partitions."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import tempfile
+from collections.abc import Iterable, Mapping, Sequence
+from contextlib import contextmanager
+from itertools import groupby
+from pathlib import Path
+from typing import Any, ClassVar
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from PIL import Image
+from transformers import Qwen2TokenizerFast, Qwen3VLProcessor
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion import envs
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.parallel_state import (
+    get_dit_group,
+    init_world_group,
+)
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
+from vllm_omni.diffusion.model_loader.diffusers_loader import (
+    DiffusersPipelineLoader,
+)
+from vllm_omni.diffusion.models.interface import (
+    SupportAudioInput,
+    SupportAudioOutput,
+    SupportImageInput,
+    SupportsComponentDiscovery,
+)
+from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
+from vllm_omni.diffusion.offloader import OffloadPlan
+from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import (
+    DiffusionPipelineProfilerMixin,
+)
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.errors import OmniClientError
+from vllm_omni.model_executor.model_loader.weight_utils import (
+    download_weights_from_hf_specific,
+)
+from vllm_omni.platforms import current_omni_platform
+
+from .condition_noise import (
+    minimax_h3_audio_cond_noise_aug_rows,
+    minimax_h3_imgvid_cond_noise_aug_rows,
+)
+from .denoise_loop import MiniMaxH3DenoiseBranch, minimax_h3_denoise_loop
+from .encoder import MiniMaxH3Qwen3VLEncoder
+from .minimax_h3_transformer import MiniMaxH3DiTModel
+from .packed_sequence import (
+    minimax_h3_packed_sequence,
+    minimax_h3_packed_sequence_ref2va_blocks,
+)
+from .packed_tokens import (
+    minimax_h3_patchify_video_latent,
+    minimax_h3_unpack_audio_tokens,
+    minimax_h3_unpatchify_video_tokens,
+)
+from .presentation import (
+    minimax_h3_multi_image_presentation_ids,
+    minimax_h3_multi_image_presentation_token_tags,
+    minimax_h3_ref2va_presentation,
+    minimax_h3_ref2va_video_presentation,
+    minimax_h3_text_only_ids,
+)
+from .reference_video import (
+    load_audio_file,
+    load_video_audio,
+    load_video_frames,
+    prepare_reference_videos,
+    sample_reference_video_frames,
+    validate_reference_audio_files,
+    validate_reference_audio_waveforms,
+)
+from .time_request import (
+    MINIMAX_H3_SHAPE_PLANNER,
+    minimax_h3_align_frame_count,
+    minimax_h3_time_shift_sigmas,
+)
+from .vae import MiniMaxH3AudioVAE, MiniMaxH3VideoVAE
+
+logger = init_logger(__name__)
+
+MINIMAX_H3_FPS = 24
+MINIMAX_H3_AUDIO_SAMPLE_RATE = 32000
+MINIMAX_H3_IMGVID_COND_TIMESTEP = 0.999
+MINIMAX_H3_AUDIO_REF_COND_TIMESTEP = 1.0
+MINIMAX_H3_OUTPUT_SHORT_EDGE = 768
+MINIMAX_H3_OUTPUT_MAX_PIXELS = 768 * 1344
+MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE = 2048
+MINIMAX_H3_REFERENCE_IMAGE_MULTIPLE = 32
+MINIMAX_H3_SUPPORTED_ASPECT_RATIOS = {
+    "21:9": 21.0 / 9.0,
+    "16:9": 16.0 / 9.0,
+    "4:3": 4.0 / 3.0,
+    "1:1": 1.0,
+    "3:4": 3.0 / 4.0,
+    "9:16": 9.0 / 16.0,
+}
+MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES = 30 * 1024 * 1024
+MINIMAX_H3_REFERENCE_IMAGE_FORMATS = frozenset({"jpeg", "png", "webp", "heic", "heif"})
+MINIMAX_H3_MIN_OUTPUT_SECONDS = 4.0
+MINIMAX_H3_MAX_OUTPUT_SECONDS = 15.0
+MINIMAX_H3_DOWNLOAD_PATTERNS = [
+    "FL2VA/**",
+    "Ref2VA/model_index.json",
+    "Ref2VA/transformer/**",
+]
+MINIMAX_H3_TASK_DOWNLOAD_PATTERNS = {
+    "fl2va": ["FL2VA/**"],
+    "ref2va": ["Ref2VA/**"],
+}
+
+
+def _minimax_h3_partition_for_task(
+    task_type: str | None,
+    model: str | None = None,
+) -> str:
+    task = str(task_type or "auto").lower()
+    if task == "auto" and model is not None:
+        path = Path(model)
+        if path.is_dir() and path.name in {"FL2VA", "Ref2VA"} and (path / "model_index.json").is_file():
+            return path.name.lower()
+    if task in {"auto", "combined"}:
+        return "combined"
+    if task in {"t2va", "fl2va"}:
+        return "fl2va"
+    if task == "ref2va":
+        return "ref2va"
+    raise ValueError(f"MiniMax-H3 task_type must be one of auto, t2va, fl2va, or ref2va; got {task_type!r}")
+
+
+def _resolve_minimax_h3_model_root(
+    model: str,
+    revision: str | None,
+    partition: str,
+) -> Path:
+    path = Path(model)
+    if path.is_dir():
+        if path.name in {"FL2VA", "Ref2VA"} and (path / "model_index.json").is_file():
+            return path.parent
+        return path
+    allow_patterns = (
+        MINIMAX_H3_DOWNLOAD_PATTERNS if partition == "combined" else MINIMAX_H3_TASK_DOWNLOAD_PATTERNS[partition]
+    )
+    return Path(
+        download_weights_from_hf_specific(
+            model_name_or_path=model,
+            cache_dir=None,
+            allow_patterns=allow_patterns,
+            revision=revision,
+            require_all=True,
+        )
+    )
+
+
+def _resolve_component_quant_config(quant_config, component: str):
+    if hasattr(quant_config, "resolve"):
+        return quant_config.resolve(component)
+    return quant_config
+
+
+def _minimax_h3_post_process(output, output_type: str = "np"):
+    """Convert the joint video/audio output without capturing worker state.
+
+    The callable crosses the multiprocessing result queue, so it must remain a
+    module-level function that the standard pickle module can resolve.
+    """
+    if not isinstance(output, tuple) or len(output) != 2:
+        return output
+    video, audio = output
+    if output_type == "latent":
+        return output
+    if output_type == "np":
+        video = video.detach().float().cpu().permute(0, 2, 3, 4, 1).clamp(0, 1).numpy()
+        audio = audio.detach().float().cpu().numpy()
+        video = [sample for sample in video]
+    return {
+        "video": video,
+        "audio": audio,
+        "audio_sample_rate": MINIMAX_H3_AUDIO_SAMPLE_RATE,
+        "fps": MINIMAX_H3_FPS,
+    }
+
+
+def get_minimax_h3_post_process_func(
+    od_config: OmniDiffusionConfig,
+):
+    del od_config
+    return _minimax_h3_post_process
+
+
+def _align_multiple(value: float, multiple: int = 32) -> int:
+    return max(multiple, int(round(float(value) / multiple)) * multiple)
+
+
+def _load_image(value: Any) -> Image.Image:
+    images = _load_images(value)
+    if len(images) != 1:
+        raise OmniClientError(f"MiniMax H3 expected one image, got {len(images)}")
+    return images[0]
+
+
+def _load_images(value: Any) -> list[Image.Image]:
+    if isinstance(value, (list, tuple)):
+        if not value:
+            raise OmniClientError("MiniMax H3 image input must not be empty")
+        return [_load_image(item) for item in value]
+    if isinstance(value, (str, os.PathLike)):
+        file_size = os.path.getsize(value)
+        if file_size > MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES:
+            raise OmniClientError("MiniMax H3 reference image exceeds the 30 MiB size limit")
+        with Image.open(value) as image:
+            image_format = str(image.format or "").lower()
+            if image_format and image_format not in MINIMAX_H3_REFERENCE_IMAGE_FORMATS:
+                raise OmniClientError(
+                    f"MiniMax H3 reference image must use JPG, JPEG, PNG, WEBP, HEIC, or HEIF, got {image.format}"
+                )
+            return [image.convert("RGB")]
+    if isinstance(value, Image.Image):
+        return [value.convert("RGB")]
+    if isinstance(value, torch.Tensor):
+        tensor = value.detach().float().cpu()
+        if tensor.ndim == 4 and tensor.shape[0] == 1:
+            tensor = tensor[0]
+        if tensor.ndim != 3:
+            raise OmniClientError(f"image tensor must be [C,H,W], got {tuple(tensor.shape)}")
+        if tensor.shape[0] in (1, 3, 4):
+            tensor = tensor.permute(1, 2, 0)
+        array = tensor.numpy()
+        if array.max(initial=0) <= 1.0:
+            array = array * 255.0
+        return [Image.fromarray(array.clip(0, 255).astype(np.uint8)).convert("RGB")]
+    raise OmniClientError(f"unsupported MiniMax H3 image input {type(value)!r}")
+
+
+def _load_audio(value: Any) -> tuple[torch.Tensor, int]:
+    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
+        audios = _load_audios(value)
+        if len(audios) != 1:
+            raise OmniClientError(f"MiniMax H3 expected one audio, got {len(audios)}")
+        return audios[0]
+    if isinstance(value, (str, os.PathLike)):
+        return load_audio_file(str(value))
+    if isinstance(value, tuple) and len(value) == 2:
+        waveform, sample_rate = value
+        waveform = torch.as_tensor(waveform).float()
+        return waveform, int(sample_rate)
+    if isinstance(value, dict):
+        waveform = value.get("waveform", value.get("array"))
+        sample_rate = value.get("sample_rate", value.get("sampling_rate"))
+        if waveform is not None and sample_rate is not None:
+            return torch.as_tensor(waveform).float(), int(sample_rate)
+    raise OmniClientError("MiniMax H3 audio input must be a path, (waveform, sample_rate), or a waveform mapping")
+
+
+def _load_audios(value: Any) -> list[tuple[torch.Tensor, int]]:
+    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
+        if not value:
+            raise OmniClientError("MiniMax H3 audio input must not be empty")
+        return [_load_audio(item) for item in value]
+    return [_load_audio(value)]
+
+
+def _as_int_list(value: Any, *, name: str) -> list[int]:
+    if isinstance(value, bool):
+        raise OmniClientError(f"{name} must be an integer or a list of integers")
+    if isinstance(value, (int, np.integer)):
+        return [int(value)]
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        result = list(value)
+        if not result:
+            raise OmniClientError(f"{name} must not be empty")
+        if any(isinstance(item, bool) or not isinstance(item, (int, np.integer)) for item in result):
+            raise OmniClientError(f"{name} must contain only integers")
+        return [int(item) for item in result]
+    raise OmniClientError(f"{name} must be an integer or a list of integers")
+
+
+def _resolve_fl2va_keyframe_indices(extra: Mapping[str, Any], image_count: int) -> list[int]:
+    target = extra.get("target")
+    target = target if isinstance(target, Mapping) else {}
+    raw = extra.get("frame_indices", extra.get("frame_index"))
+    if raw is None:
+        raw = target.get("frame_indices", target.get("frame_index"))
+    if raw is None:
+        raw_indices = [0] if image_count == 1 else [0, -1]
+    else:
+        raw_indices = _as_int_list(raw, name="frame_indices")
+    if len(raw_indices) != image_count:
+        raise OmniClientError(
+            f"MiniMax H3 FL2VA requires one frame index per image: got {raw_indices!r} for {image_count} image(s)"
+        )
+    if tuple(raw_indices) not in ((0,), (-1,), (0, -1)):
+        raise OmniClientError("MiniMax H3 FL2VA frame_indices must be [0], [-1], or [0, -1]")
+    return raw_indices
+
+
+def _validate_ref2va_reference_counts(
+    image_count: int,
+    video_count: int,
+    audio_count: int,
+) -> None:
+    """Validate the official Ref2VA reference-count contract."""
+    if image_count < 0 or video_count < 0 or audio_count < 0:
+        raise OmniClientError("MiniMax H3 reference counts must be non-negative")
+    if image_count + video_count == 0:
+        raise OmniClientError("ref2va requires at least one image or video reference")
+    if image_count > 9:
+        raise OmniClientError("ref2va accepts at most 9 image references")
+    if video_count > 3:
+        raise OmniClientError("ref2va accepts at most 3 video references")
+    if audio_count > 3:
+        raise OmniClientError("ref2va accepts at most 3 standalone audio references")
+    if image_count + video_count + audio_count > 12:
+        raise OmniClientError("ref2va accepts at most 12 total references")
+
+
+def _resolve_minimax_h3_aspect_ratio(
+    task: str,
+    value: Any,
+    image: Image.Image | None,
+) -> float:
+    """Resolve H3's task-specific ratio policy.
+
+    T2VA must name one of the official ratios.  FL2VA always follows the
+    first input image, even when a generic client sends ``aspect_ratio``.
+    Ref2VA defaults to 16:9; ``adaptive``/``auto`` are retained as aliases
+    for that default for compatibility with existing clients.
+    """
+    if task == "fl2va":
+        if image is None:
+            raise OmniClientError("fl2va requires an input image to resolve its aspect ratio")
+        return float(image.width) / float(image.height)
+
+    if value is None:
+        if task == "t2va":
+            raise OmniClientError("t2va requires an explicit aspect_ratio")
+        return MINIMAX_H3_SUPPORTED_ASPECT_RATIOS["16:9"]
+
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in {"adaptive", "auto"}:
+            if task == "t2va":
+                raise OmniClientError("t2va requires an explicit named aspect_ratio, not adaptive")
+            return MINIMAX_H3_SUPPORTED_ASPECT_RATIOS["16:9"]
+        if normalized in MINIMAX_H3_SUPPORTED_ASPECT_RATIOS:
+            return MINIMAX_H3_SUPPORTED_ASPECT_RATIOS[normalized]
+        try:
+            numeric_value = float(normalized)
+        except (TypeError, ValueError) as exc:
+            supported = ", ".join(MINIMAX_H3_SUPPORTED_ASPECT_RATIOS)
+            raise OmniClientError(f"MiniMax H3 aspect_ratio must be one of {supported}, got {value!r}") from exc
+    elif isinstance(value, (int, float, np.integer, np.floating)) and not isinstance(value, bool):
+        numeric_value = float(value)
+    else:
+        raise OmniClientError(f"MiniMax H3 aspect_ratio must be a string ratio, got {value!r}")
+
+    if not math.isfinite(numeric_value) or not any(
+        math.isclose(numeric_value, ratio, rel_tol=0.0, abs_tol=1e-6)
+        for ratio in MINIMAX_H3_SUPPORTED_ASPECT_RATIOS.values()
+    ):
+        supported = ", ".join(MINIMAX_H3_SUPPORTED_ASPECT_RATIOS)
+        raise OmniClientError(f"MiniMax H3 aspect_ratio must be one of {supported}, got {value!r}")
+    return numeric_value
+
+
+def _resolve_minimax_h3_num_outputs(value: Any) -> int:
+    if value is None:
+        return 1
+    if isinstance(value, bool) or not isinstance(value, (int, np.integer)):
+        raise OmniClientError("MiniMax H3 num_outputs_per_prompt must be an integer in [1, 10]")
+    value = int(value)
+    if not 1 <= value <= 10:
+        raise OmniClientError(f"MiniMax H3 num_outputs_per_prompt must be in [1, 10], got {value}")
+    return value
+
+
+def _minimax_h3_output_seeds(seed: int, num_outputs: int) -> list[int]:
+    return [int(seed) + output_index for output_index in range(int(num_outputs))]
+
+
+def _validate_reference_image(image: Image.Image) -> None:
+    width, height = image.size
+    if min(width, height) < 256 or max(width, height) > 5760:
+        raise OmniClientError(
+            f"MiniMax H3 reference image dimensions must be in [256, 5760] pixels, got {width}x{height}"
+        )
+    ratio = width / height
+    if not 0.4 <= ratio <= 2.5:
+        raise OmniClientError(f"MiniMax H3 reference image aspect ratio must be in [0.4, 2.5], got {width}x{height}")
+
+
+def _dit_rank_world() -> tuple[Any, int, int]:
+    if not dist.is_initialized():
+        return None, 0, 1
+    group = get_dit_group()
+    return group, dist.get_rank(group), dist.get_world_size(group)
+
+
+def _broadcast_tensor(
+    tensor: torch.Tensor | None,
+    *,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> torch.Tensor:
+    group, rank, world_size = _dit_rank_world()
+    if world_size == 1:
+        if tensor is None:
+            raise ValueError("source tensor is required for single-rank execution")
+        return tensor.to(device=device, dtype=dtype)
+
+    shape = torch.zeros(5, dtype=torch.long, device=device)
+    if rank == 0:
+        if tensor is None:
+            raise ValueError("rank 0 must provide a tensor to broadcast")
+        shape[0] = tensor.ndim
+        shape[1 : tensor.ndim + 1] = torch.tensor(
+            tensor.shape,
+            device=device,
+        )
+    dist.broadcast(shape, src=0, group=group)
+    ndim = int(shape[0].item())
+    tensor_shape = tuple(int(v) for v in shape[1 : ndim + 1].tolist())
+    if rank == 0:
+        output = tensor.to(device=device, dtype=dtype).contiguous()
+    else:
+        output = torch.empty(tensor_shape, device=device, dtype=dtype)
+    dist.broadcast(output, src=0, group=group)
+    return output
+
+
+def _reference_image_shape(image: Image.Image) -> tuple[int, int]:
+    width, height = image.size
+    ratio = width / height
+    if not 0.4 <= ratio <= 2.5:
+        raise OmniClientError(f"reference image aspect ratio must be in [0.4, 2.5], got {width}x{height}")
+    if min(width, height) < 256 or max(width, height) > 5760:
+        raise OmniClientError(f"reference image dimensions must be in [256, 5760] pixels, got {width}x{height}")
+    scale = MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE / min(width, height)
+    return (
+        _align_multiple(
+            width * scale,
+            MINIMAX_H3_REFERENCE_IMAGE_MULTIPLE,
+        ),
+        _align_multiple(
+            height * scale,
+            MINIMAX_H3_REFERENCE_IMAGE_MULTIPLE,
+        ),
+    )
+
+
+def _resolve_output_canvas(aspect_ratio: float, short_edge: int) -> tuple[int, int]:
+    """Resolve the official H3 ratio/area policy to a 32-pixel canvas."""
+    if not math.isfinite(float(aspect_ratio)) or float(aspect_ratio) <= 0:
+        raise OmniClientError(f"MiniMax H3 canvas aspect ratio must be positive, got {aspect_ratio!r}")
+    if short_edge != MINIMAX_H3_OUTPUT_SHORT_EDGE:
+        raise OmniClientError(f"MiniMax H3 target.short_edge must be {MINIMAX_H3_OUTPUT_SHORT_EDGE}, got {short_edge}")
+    if aspect_ratio >= 1.0:
+        width = float(short_edge) * aspect_ratio
+        height = float(short_edge)
+    else:
+        width = float(short_edge)
+        height = float(short_edge) / aspect_ratio
+    area = width * height
+    if area > MINIMAX_H3_OUTPUT_MAX_PIXELS:
+        scale = (MINIMAX_H3_OUTPUT_MAX_PIXELS / area) ** 0.5
+        width *= scale
+        height *= scale
+    return (
+        _align_multiple(height, 32),
+        _align_multiple(width, 32),
+    )
+
+
+class _SingleRankEncoderGroup:
+    """Lightweight encoder group for ``text_encoder_tp_size == 1``.
+
+    Avoids creating a distributed ``GroupCoordinator`` with a single-member
+    rank set, which would assert on every other DiT rank that is not part of
+    the group.  The pipeline and encoder only use the attributes below, and
+    all ``world_size == 1`` code paths short-circuit before any collective.
+    """
+
+    world_size: int = 1
+    ranks: list[int] = [0]
+
+    def __init__(self, rank: int) -> None:
+        self.rank_in_group = 0 if rank == 0 else -1
+        self.device_group = None
+
+
+class MiniMaxH3Pipeline(
+    nn.Module,
+    DenoiseProgressMixin,
+    ProgressBarMixin,
+    DiffusionPipelineProfilerMixin,
+    SupportImageInput,
+    SupportAudioInput,
+    SupportAudioOutput,
+    SupportsComponentDiscovery,
+):
+    """CFG-distilled joint video/audio generation for MiniMax H3."""
+
+    _dit_modules: ClassVar[list[str]] = ["transformer", "transformers_ref"]
+    _encoder_modules: ClassVar[list[str]] = ["text_encoder"]
+    _vae_modules: ClassVar[list[str]] = ["video_vae", "audio_vae"]
+    _offload_plan: ClassVar[OffloadPlan] = OffloadPlan(
+        offload_submodules={"token_refiner": "blocks"},
+        resident_dit_paths=frozenset({"transformer"}),
+        encoder_block_attrs={"text_encoder": ("vision.blocks", "text_model.layers")},
+        on_demand_component_paths=frozenset({"text_encoder", "video_vae", "audio_vae"}),
+    )
+    # H3's regular loader performs checkpoint-layout conversions (grouped QKV
+    # and fused MLP). Keep it on that path until mmap can run the same loader
+    # callbacks for every affected parameter.
+    _supports_mmap_loading: ClassVar[bool] = False
+    # TODO(offload): Re-enable after the generic rank-local mmap path can run
+    # this model's grouped-QKV reorder and fused-MLP packing before TP sharding.
+    # Do not bypass the regular loader until that equivalence is tested.
+    _PROFILER_TARGETS: ClassVar[list[str]] = [
+        "_prepare_reference_videos",
+        "encode_prompt",
+        "_encode_video_conditions",
+        "_encode_video_audio_conditions",
+        "diffuse",
+        "decode",
+    ]
+    dummy_run_num_frames: ClassVar[int] = 0
+
+    def __init__(
+        self,
+        *,
+        od_config: OmniDiffusionConfig,
+        prefix: str = "",
+    ) -> None:
+        del prefix
+        super().__init__()
+        self.od_config = od_config
+        self.parallel_config = od_config.parallel_config
+        if int(self.parallel_config.cfg_parallel_size) != 1:
+            raise ValueError("MiniMax-H3 is CFG-distilled and has no negative branch; cfg_parallel_size must be 1")
+        self.device = get_local_device()
+        self.partition = _minimax_h3_partition_for_task(
+            getattr(od_config, "task_type", None),
+            str(od_config.model),
+        )
+        model_root = _resolve_minimax_h3_model_root(
+            str(od_config.model),
+            od_config.revision,
+            self.partition,
+        )
+        model_path = model_root / ("Ref2VA" if self.partition == "ref2va" else "FL2VA")
+        model_index = json.loads((model_path / "model_index.json").read_text(encoding="utf-8"))
+        release = model_index.get("_minimax_h3") or {}
+        partition = str(release.get("partition", "")).lower()
+        expected_partition = "ref2va" if self.partition == "ref2va" else "fl2va"
+        if partition != expected_partition:
+            raise ValueError(f"invalid MiniMax-H3 {expected_partition} partition at {model_path}")
+
+        supported_tasks = {str(task).lower() for task in release.get("tasks", [])}
+        if not supported_tasks:
+            supported_tasks = {"ref2va"} if partition == "ref2va" else {"t2va", "fl2va"}
+        ref2va_model_path = None
+        if self.partition == "combined":
+            ref2va_model_path = model_root / "Ref2VA"
+            ref2va_index_path = ref2va_model_path / "model_index.json"
+            if not ref2va_index_path.is_file():
+                raise ValueError(f"Ref2VA partition not found at {ref2va_model_path}")
+            ref2va_index = json.loads(ref2va_index_path.read_text(encoding="utf-8"))
+            ref2va_release = ref2va_index.get("_minimax_h3") or {}
+            if str(ref2va_release.get("partition", "")).lower() != "ref2va":
+                raise ValueError(f"invalid MiniMax-H3 ref2va partition at {ref2va_model_path}")
+            supported_tasks.update(str(task).lower() for task in ref2va_release.get("tasks", ["ref2va"]))
+
+        self.supported_tasks = frozenset(supported_tasks)
+        shifts = release.get("sigma_shift_scales") or {}
+        self.default_video_shift = float(shifts.get("video", 12.0))
+        self.default_audio_shift = float(shifts.get("audio", 3.0))
+
+        self.weights_sources = [
+            DiffusersPipelineLoader.ComponentSource(
+                model_or_path=str(model_path),
+                subfolder="transformer",
+                revision=od_config.revision,
+                prefix="transformer.",
+                fall_back_to_pt=False,
+            )
+        ]
+        self._dit_modules = ["transformer"]
+        if ref2va_model_path is not None:
+            self.weights_sources.append(
+                DiffusersPipelineLoader.ComponentSource(
+                    model_or_path=str(ref2va_model_path),
+                    subfolder="transformer",
+                    revision=od_config.revision,
+                    prefix="transformers_ref.",
+                    fall_back_to_pt=False,
+                )
+            )
+            self._dit_modules.append("transformers_ref")
+        transformer_quant_config = _resolve_component_quant_config(
+            od_config.quantization_config,
+            "transformer",
+        )
+        self.transformer = MiniMaxH3DiTModel(
+            od_config,
+            quant_config=transformer_quant_config,
+        )
+        if ref2va_model_path is not None:
+            self.transformers_ref = MiniMaxH3DiTModel(
+                od_config,
+                quant_config=transformer_quant_config,
+            )
+
+        self.tokenizer = Qwen2TokenizerFast.from_pretrained(
+            str(model_path),
+            subfolder="tokenizer",
+            local_files_only=os.path.isdir(model_path),
+        )
+        self.processor = Qwen3VLProcessor.from_pretrained(
+            str(model_path),
+            subfolder="processor",
+            local_files_only=os.path.isdir(model_path),
+        )
+
+        _, rank, dit_world = _dit_rank_world()
+        self._dit_rank = rank
+        text_encoder_tp_size = int(getattr(self.parallel_config, "text_encoder_tp_size", 1))
+        if text_encoder_tp_size < 1:
+            raise ValueError(f"text_encoder_tp_size must be >= 1, got {text_encoder_tp_size}")
+        if text_encoder_tp_size > dit_world:
+            raise ValueError(
+                f"text_encoder_tp_size must not exceed the DiT group size ({dit_world}), got {text_encoder_tp_size}"
+            )
+        # The Qwen3-VL text model uses 64 attention heads / 8 KV heads; the
+        # encoder shards them across the encoder TP ranks.
+        if 64 % text_encoder_tp_size or 8 % text_encoder_tp_size:
+            raise ValueError(
+                "text_encoder_tp_size must divide both Qwen3-VL "
+                f"num_attention_heads (64) and num_key_value_heads (8), "
+                f"got {text_encoder_tp_size}"
+            )
+        self.text_encoder_tp_size = text_encoder_tp_size
+        self.text_encoder_group = self._build_text_encoder_group(text_encoder_tp_size)
+        self.text_encoder = MiniMaxH3Qwen3VLEncoder(
+            os.path.join(model_path, "text_encoder"),
+            device=self.device,
+            load_model=rank < text_encoder_tp_size,
+            encoder_group=self.text_encoder_group,
+        )
+        stage_components = bool(
+            od_config.enable_layerwise_offload or getattr(od_config, "enable_distributed_layerwise_offload", False)
+        )
+        component_load_device = torch.device("cpu") if stage_components else self.device
+        self.video_vae = MiniMaxH3VideoVAE(
+            os.path.join(model_path, "video_vae"),
+            device=self.device,
+            load_device=component_load_device,
+        )
+        self.audio_vae = MiniMaxH3AudioVAE(
+            os.path.join(model_path, "audio_vae"),
+            device=self.device,
+            load_device=component_load_device,
+        )
+        # Registry-side VAE patch-parallel discovery uses ``pipeline.vae``.
+        self.vae = self.video_vae
+
+        self.setup_diffusion_pipeline_profiler(
+            enable_diffusion_pipeline_profiler=(od_config.enable_diffusion_pipeline_profiler)
+        )
+
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]],
+    ) -> set[str]:
+        def source_prefix(item: tuple[str, torch.Tensor]) -> str:
+            name, _ = item
+            prefix = name.partition(".")[0] + "."
+            if prefix in {"transformer.", "transformers_ref."}:
+                return prefix
+            raise ValueError(f"unexpected MiniMax-H3 weight {name!r}")
+
+        loaded_with_prefix: set[str] = set()
+        loaded_prefixes: set[str] = set()
+        for prefix, grouped_weights in groupby(weights, key=source_prefix):
+            if prefix in loaded_prefixes:
+                raise ValueError(f"MiniMax-H3 weight source {prefix!r} is not contiguous")
+            loaded_prefixes.add(prefix)
+            transformer = getattr(self, prefix.removesuffix("."))
+            loaded = transformer.load_weights((name[len(prefix) :], tensor) for name, tensor in grouped_weights)
+            transformer.post_load_weights()
+            loaded_with_prefix.update(prefix + name for name in loaded)
+        # The text encoder and both VAEs load eagerly in ``__init__`` rather
+        # than through ``weights_sources``. Record them for the runner's strict
+        # missing-parameter check.
+        for component_name in ("text_encoder", "video_vae", "audio_vae"):
+            component = getattr(self, component_name)
+            loaded_with_prefix.update(f"{component_name}.{name}" for name, _ in component.named_parameters())
+        return loaded_with_prefix
+
+    def _transformer_for_task(self, task: str) -> MiniMaxH3DiTModel:
+        if task == "ref2va" and hasattr(self, "transformers_ref"):
+            return self.transformers_ref
+        return self.transformer
+
+    def _resolve_task(
+        self,
+        requested: str | None,
+        multi_modal_data: dict[str, Any],
+    ) -> str:
+        if requested is None:
+            # A Ref2VA-only startup has no FL2VA transformer; preserve its
+            # historical implicit default even for image-only references.
+            if self.partition == "ref2va":
+                requested = "ref2va"
+            elif multi_modal_data.get("video") is not None or multi_modal_data.get("audio") is not None:
+                requested = "ref2va"
+            elif multi_modal_data.get("image") is not None:
+                requested = "fl2va"
+            else:
+                requested = "t2va"
+        task = str(requested).lower()
+        if task not in self.supported_tasks:
+            raise OmniClientError(
+                f"checkpoint partition {self.partition!r} supports {sorted(self.supported_tasks)}, got task={task!r}"
+            )
+        return task
+
+    def _resolve_shape(
+        self,
+        task: str,
+        sampling: Any,
+        image: Image.Image | None,
+    ) -> tuple[int, int, int, int, int]:
+        fps = int(sampling.fps or MINIMAX_H3_FPS)
+        if fps != MINIMAX_H3_FPS:
+            raise OmniClientError(f"MiniMax H3 output fps is fixed at {MINIMAX_H3_FPS}")
+        extra = sampling.extra_args or {}
+        target = extra.get("target")
+        if target is not None and not isinstance(target, Mapping):
+            raise OmniClientError("MiniMax H3 extra_args['target'] must be an object")
+        target = target if isinstance(target, Mapping) else {}
+        duration = target.get("duration_seconds", extra.get("duration_seconds", extra.get("duration")))
+        if duration is not None:
+            if isinstance(duration, bool):
+                raise OmniClientError(f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration!r}")
+            try:
+                duration = float(duration)
+            except (TypeError, ValueError) as exc:
+                raise OmniClientError(
+                    f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration!r}"
+                ) from exc
+            if (
+                not math.isfinite(duration)
+                or not MINIMAX_H3_MIN_OUTPUT_SECONDS <= duration <= MINIMAX_H3_MAX_OUTPUT_SECONDS
+            ):
+                raise OmniClientError(f"MiniMax H3 output duration must be in [4, 15] seconds, got {duration}")
+            requested_frames = int(round(duration * fps))
+        elif int(sampling.num_frames or 1) > 1:
+            requested_frames = int(sampling.num_frames)
+        else:
+            requested_frames = 124 if task == "ref2va" else 209
+            duration = requested_frames / fps
+        if not MINIMAX_H3_MIN_OUTPUT_SECONDS <= requested_frames / fps <= MINIMAX_H3_MAX_OUTPUT_SECONDS:
+            raise OmniClientError(
+                f"MiniMax H3 output duration must be in [4, 15] seconds, got {requested_frames / fps:.3f}"
+            )
+        num_frames = minimax_h3_align_frame_count(requested_frames)
+
+        height = sampling.height
+        width = sampling.width
+        aspect_ratio = target.get("aspect_ratio", extra.get("aspect_ratio"))
+        raw_short_edge = target.get("short_edge", extra.get("short_edge", MINIMAX_H3_OUTPUT_SHORT_EDGE))
+        if isinstance(raw_short_edge, bool) or not isinstance(raw_short_edge, (int, np.integer)):
+            raise OmniClientError(
+                f"MiniMax H3 target.short_edge must be {MINIMAX_H3_OUTPUT_SHORT_EDGE}, got {raw_short_edge!r}"
+            )
+        short_edge = int(raw_short_edge)
+
+        aspect_ratio = _resolve_minimax_h3_aspect_ratio(
+            task,
+            aspect_ratio,
+            image,
+        )
+        if not 0.25 <= aspect_ratio <= 4.0:
+            raise OmniClientError(f"MiniMax H3 canvas aspect ratio must be in [1:4, 4:1], got {aspect_ratio}")
+
+        if height is None or width is None:
+            height, width = _resolve_output_canvas(aspect_ratio, short_edge)
+        height = int(height) // 32 * 32
+        width = int(width) // 32 * 32
+        if min(height, width) <= 0:
+            raise OmniClientError(f"invalid MiniMax H3 canvas {width}x{height}")
+        if width > 4 * height or height > 4 * width:
+            raise OmniClientError("MiniMax H3 canvas aspect ratio must be in [1:4, 4:1]")
+
+        latent_t = MINIMAX_H3_SHAPE_PLANNER.video_latent_t(num_frames)
+        audio_t = MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(num_frames / fps)
+        return height, width, num_frames, latent_t, audio_t
+
+    def encode_prompt(
+        self,
+        *,
+        task: str,
+        prompt: str,
+        image: Image.Image | None = None,
+        images: list[Image.Image] | None = None,
+        prepared_videos: list[dict[str, Any]] | None = None,
+        condition_labels: list[tuple[str, int]] | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        _, rank, _ = _dit_rank_world()
+        hidden = None
+        tags = None
+        ids = None
+        vision_kwargs: dict[str, torch.Tensor] = {}
+        images = list(images) if images is not None else ([image] if image is not None else [])
+        if rank == 0:
+            if task == "t2va":
+                ids = minimax_h3_text_only_ids(self.tokenizer, prompt)
+                tags = torch.ones(ids.shape[0], dtype=torch.long)
+                vision_kwargs = {}
+            else:
+                image_token_counts: list[int] = []
+                if images:
+                    vision = self.processor.image_processor(
+                        images=images,
+                        return_tensors="pt",
+                    )
+                    image_grid = vision["image_grid_thw"]
+                    merge = int(self.processor.image_processor.merge_size) ** 2
+                    image_token_counts = [int(grid.prod().item()) // merge for grid in image_grid]
+                    vision_kwargs.update(
+                        {
+                            "pixel_values": vision["pixel_values"],
+                            "image_grid_thw": image_grid,
+                        }
+                    )
+
+                video_block_counts: list[list[int]] = []
+                video_block_timestamps: list[list[float]] = []
+                if prepared_videos:
+                    videos = []
+                    sampled_videos = []
+                    for index, item in enumerate(prepared_videos):
+                        sampled = sample_reference_video_frames(
+                            item["prepared_path"],
+                            workdir=str(Path(item["prepared_path"]).parent / f"qwen_frames_{index}"),
+                        )
+                        videos.append(np.stack(sampled["frames"]))
+                        sampled_videos.append(sampled)
+                    vision = self.processor.video_processor(
+                        videos=videos,
+                        do_sample_frames=False,
+                        return_tensors="pt",
+                    )
+                    video_grid = vision["video_grid_thw"]
+                    merge = int(self.processor.image_processor.merge_size) ** 2
+                    for index, sampled in enumerate(sampled_videos):
+                        blocks = int(video_grid[index, 0])
+                        per_block = int(video_grid[index, 1]) * int(video_grid[index, 2]) // merge
+                        timestamps = sampled["block_timestamps"]
+                        if len(timestamps) != blocks:
+                            raise ValueError(
+                                f"video block count mismatch: processor={blocks}, timestamps={len(timestamps)}"
+                            )
+                        video_block_counts.append([per_block] * blocks)
+                        video_block_timestamps.append(timestamps)
+                    vision_kwargs.update(
+                        {
+                            "pixel_values_videos": vision["pixel_values_videos"],
+                            "video_grid_thw": video_grid,
+                        }
+                    )
+
+                if not images and not prepared_videos:
+                    raise OmniClientError(f"{task} requires an image or video condition")
+                if condition_labels is None:
+                    condition_labels = []
+                    for image_index in range(1, len(images) + 1):
+                        condition_labels.append(("image", image_index))
+                    audio_index = 0
+                    for video_index, item in enumerate(prepared_videos or (), start=1):
+                        if item["input_has_audio"]:
+                            audio_index += 1
+                            condition_labels.append(("audio", audio_index))
+                        condition_labels.append(("video", video_index))
+
+                if task == "fl2va":
+                    if prepared_videos:
+                        raise OmniClientError("fl2va does not accept video conditions")
+                    ids = minimax_h3_multi_image_presentation_ids(
+                        self.tokenizer,
+                        prompt=prompt,
+                        image_token_counts=image_token_counts,
+                    )
+                    tags = minimax_h3_multi_image_presentation_token_tags(
+                        self.tokenizer,
+                        prompt=prompt,
+                        image_token_counts=image_token_counts,
+                    )
+                elif prepared_videos:
+                    ids, tags = minimax_h3_ref2va_video_presentation(
+                        self.tokenizer,
+                        prompt=prompt,
+                        condition_labels=condition_labels,
+                        image_token_count=image_token_counts or None,
+                        video_block_token_counts=video_block_counts,
+                        video_block_timestamps=video_block_timestamps,
+                    )
+                else:
+                    ids, tags = minimax_h3_ref2va_presentation(
+                        self.tokenizer,
+                        prompt=prompt,
+                        condition_labels=condition_labels,
+                        image_token_count=image_token_counts or None,
+                    )
+
+            logger.info(
+                "MiniMax H3 %s Qwen presentation: %d tokens%s",
+                task,
+                int(ids.shape[0]),
+                (
+                    f", {len(images)} reference images"
+                    + (f", {len(prepared_videos)} reference videos" if prepared_videos else "")
+                    if images
+                    else (f", {len(prepared_videos)} reference videos" if prepared_videos else "")
+                ),
+            )
+
+        if rank < self.text_encoder_tp_size:
+            # Distribute the encode inputs from the DiT main rank to the other
+            # encoder TP ranks, then run the distributed encode on all of them.
+            ids = self._distribute_encode_inputs(ids, vision_kwargs)
+            hidden = self._encode_text_hidden(ids, vision_kwargs)
+
+        hidden = _broadcast_tensor(
+            hidden,
+            dtype=torch.bfloat16,
+            device=self.device,
+        )
+        tags = _broadcast_tensor(
+            tags,
+            dtype=torch.long,
+            device=self.device,
+        )
+        return hidden, tags
+
+    def _build_text_encoder_group(self, text_encoder_tp_size: int) -> Any:
+        """Create the encoder tensor-parallel process group.
+
+        The encoder group covers the first ``text_encoder_tp_size`` DiT ranks
+        (the DiT group is always global ranks ``[0, dit_world)``).  Every rank
+        participates in ``new_group`` so the collective completes; ranks
+        outside the group never run encoder collectives.  For a single-rank
+        encoder we return a lightweight placeholder so non-encoder ranks do
+        not need to join a ``GroupCoordinator`` that would assert on ranks
+        outside the group.
+        """
+        if text_encoder_tp_size == 1:
+            return _SingleRankEncoderGroup(rank=self._dit_rank)
+        ranks = list(range(text_encoder_tp_size))
+        return init_world_group(
+            ranks=ranks,
+            local_rank=envs.LOCAL_RANK,
+            backend=current_omni_platform.dist_backend,
+        )
+
+    def _encoder_group_broadcast_tensor(
+        self,
+        tensor: torch.Tensor | None,
+        *,
+        dtype: torch.dtype,
+        device: torch.device,
+    ) -> torch.Tensor:
+        """Broadcast a tensor from encoder rank 0 over the encoder TP group."""
+        group = self.text_encoder_group
+        if group.world_size == 1:
+            if tensor is None:
+                raise ValueError("source tensor is required for single-rank execution")
+            return tensor.to(device=device, dtype=dtype)
+
+        shape = torch.zeros(8, dtype=torch.long, device=device)
+        if group.rank_in_group == 0:
+            if tensor is None:
+                raise ValueError("encoder rank 0 must provide a tensor to broadcast")
+            shape[0] = tensor.ndim
+            shape[1 : tensor.ndim + 1] = torch.tensor(tensor.shape, device=device)
+        torch.distributed.broadcast(shape, src=group.ranks[0], group=group.device_group)
+        ndim = int(shape[0].item())
+        tensor_shape = tuple(int(value) for value in shape[1 : ndim + 1].tolist())
+        if group.rank_in_group == 0:
+            output = tensor.to(device=device, dtype=dtype).contiguous()
+        else:
+            output = torch.empty(tensor_shape, device=device, dtype=dtype)
+        torch.distributed.broadcast(output, src=group.ranks[0], group=group.device_group)
+        return output
+
+    def _distribute_encode_inputs(
+        self,
+        ids: torch.Tensor | None,
+        vision_kwargs: dict[str, torch.Tensor],
+    ) -> torch.Tensor:
+        """Fan out encode inputs from encoder rank 0 to the encoder TP ranks.
+
+        Mutates ``vision_kwargs`` in place so every encoder rank ends up with
+        the same vision tensors, and returns the broadcast ``input_ids``.
+        """
+        keys = ("pixel_values", "image_grid_thw", "pixel_values_videos", "video_grid_thw")
+        key_dtypes = {
+            "pixel_values": torch.bfloat16,
+            "pixel_values_videos": torch.bfloat16,
+            "image_grid_thw": torch.long,
+            "video_grid_thw": torch.long,
+        }
+        group = self.text_encoder_group
+        device = self.device
+        if group.world_size == 1:
+            if ids is None:
+                raise ValueError("encoder rank 0 must produce input ids")
+            return ids.to(device=device, dtype=torch.long)
+
+        mask = torch.zeros(len(keys), dtype=torch.long, device=device)
+        if group.rank_in_group == 0:
+            for index, key in enumerate(keys):
+                mask[index] = 1 if key in vision_kwargs else 0
+        torch.distributed.broadcast(mask, src=group.ranks[0], group=group.device_group)
+
+        if group.rank_in_group == 0:
+            ids = self._encoder_group_broadcast_tensor(ids, dtype=torch.long, device=device)
+        else:
+            ids = self._encoder_group_broadcast_tensor(None, dtype=torch.long, device=device)
+        for index, key in enumerate(keys):
+            if mask[index].item() == 0:
+                continue
+            source = vision_kwargs.get(key) if group.rank_in_group == 0 else None
+            vision_kwargs[key] = self._encoder_group_broadcast_tensor(
+                source,
+                dtype=key_dtypes[key],
+                device=device,
+            )
+        return ids
+
+    def _prepare_reference_videos(
+        self,
+        values: Any,
+        *,
+        target_frame_count: int,
+        workdir: str,
+        start_time_seconds: Any = None,
+    ) -> list[dict[str, Any]] | None:
+        _, rank, _ = _dit_rank_world()
+        if rank != 0:
+            return None
+        return prepare_reference_videos(
+            values,
+            target_frame_count=target_frame_count,
+            workdir=workdir,
+            start_time_seconds=start_time_seconds,
+        )
+
+    def _encode_text_hidden(
+        self,
+        input_ids: torch.Tensor,
+        vision_kwargs: dict[str, torch.Tensor],
+    ) -> torch.Tensor:
+        if self.od_config.enable_cpu_offload and not getattr(
+            self.od_config, "enable_distributed_layerwise_offload", False
+        ):
+            # Invoke nn.Module.__call__ so the generic model-level offloader
+            # swaps the resident DiT and encoder.
+            return self.text_encoder(input_ids, **vision_kwargs)
+
+        if self.od_config.enable_layerwise_offload or getattr(
+            self.od_config, "enable_distributed_layerwise_offload", False
+        ):
+            # Layerwise DiT offload already provides the low-residency encoder
+            # phase used by the checkpoint reference.
+            self.text_encoder.load_to_device()
+            try:
+                return self.text_encoder.encode_ids(input_ids, **vision_kwargs)
+            finally:
+                self.text_encoder.offload_to_cpu()
+
+        # Keep both Qwen and DiT resident across requests. Moving either model
+        # here makes encoder latency include a tens-of-gigabytes PCIe transfer,
+        # which defeats the no-offload contract.
+        self.text_encoder.load_to_device()
+        return self.text_encoder.encode_ids(input_ids, **vision_kwargs)
+
+    def _uses_manual_component_offload(self) -> bool:
+        od_config = getattr(self, "od_config", None)
+        return bool(
+            getattr(od_config, "enable_layerwise_offload", False)
+            or getattr(od_config, "enable_distributed_layerwise_offload", False)
+        )
+
+    @contextmanager
+    def _component_on_device(self, component: nn.Module):
+        staged = self._uses_manual_component_offload()
+        if staged:
+            component.load_to_device()
+        try:
+            yield
+        finally:
+            if staged:
+                component.offload_to_cpu()
+
+    def _encode_visual_condition(
+        self,
+        image: Image.Image,
+    ) -> torch.Tensor:
+        _, rank, _ = _dit_rank_world()
+        rows = None
+        if rank == 0:
+            with self._component_on_device(self.video_vae):
+                rows = self.video_vae.encode_image(image)
+        return _broadcast_tensor(
+            rows,
+            dtype=torch.float32,
+            device=self.device,
+        )
+
+    def _encode_visual_conditions(
+        self,
+        images: list[Image.Image],
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        video_count: int,
+    ) -> tuple[torch.Tensor | None, list[tuple[int, int, int]]]:
+        rows: list[torch.Tensor] = []
+        shapes: list[tuple[int, int, int]] = []
+        for image in images:
+            rows.append(self._encode_visual_condition(image))
+            shapes.append((1, image.height // 16, image.width // 16))
+        if video_count:
+            video_rows, video_shapes = self._encode_video_conditions(
+                prepared_videos,
+                count=video_count,
+            )
+            rows.append(video_rows)
+            shapes.extend(video_shapes)
+        return (torch.cat(rows) if rows else None), shapes
+
+    def _encode_audio_condition(
+        self,
+        audio: tuple[torch.Tensor, int],
+    ) -> tuple[torch.Tensor, int]:
+        _, rank, _ = _dit_rank_world()
+        rows = None
+        audio_t = 0
+        if rank == 0:
+            with self._component_on_device(self.audio_vae):
+                rows, audio_t = self.audio_vae.encode_waveform(*audio)
+        audio_t_tensor = torch.tensor(
+            [audio_t],
+            dtype=torch.long,
+            device=self.device,
+        )
+        group, _, world_size = _dit_rank_world()
+        if world_size > 1:
+            dist.broadcast(audio_t_tensor, src=0, group=group)
+        rows = _broadcast_tensor(
+            rows,
+            dtype=torch.float32,
+            device=self.device,
+        )
+        return rows, int(audio_t_tensor.item())
+
+    def _encode_audio_conditions(
+        self,
+        audios: list[tuple[torch.Tensor, int]],
+    ) -> tuple[torch.Tensor | None, list[int]]:
+        if not audios:
+            return None, []
+        _, rank, _ = _dit_rank_world()
+        rows = None
+        lengths = torch.zeros(len(audios), dtype=torch.long, device=self.device)
+        if rank == 0:
+            encoded = [self.audio_vae.encode_waveform(*audio) for audio in audios]
+            rows = torch.cat([item[0] for item in encoded])
+            lengths = torch.tensor(
+                [int(item[1]) for item in encoded],
+                dtype=torch.long,
+                device=self.device,
+            )
+        group, _, world_size = _dit_rank_world()
+        if world_size > 1:
+            dist.broadcast(lengths, src=0, group=group)
+        return (
+            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
+            [int(value) for value in lengths.tolist()],
+        )
+
+    def _encode_video_conditions(
+        self,
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        count: int,
+    ) -> tuple[torch.Tensor, list[tuple[int, int, int]]]:
+        with self._component_on_device(self.video_vae):
+            return self._encode_video_conditions_resident(prepared_videos, count=count)
+
+    def _encode_video_conditions_resident(
+        self,
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        count: int,
+    ) -> tuple[torch.Tensor, list[tuple[int, int, int]]]:
+        group, rank, world_size = _dit_rank_world()
+        distributed_encode = self.video_vae.is_distributed_enabled()
+        if distributed_encode:
+            # Native tiled encode uses collectives, so every VPP rank must
+            # enter each reference encode in the same input order.
+            prepared_videos_list = [prepared_videos]
+            dist.broadcast_object_list(
+                prepared_videos_list,
+                src=0,
+                group=group,
+                device=self.device,
+            )
+            prepared_videos = prepared_videos_list[0]
+
+        rows = None
+        shapes = torch.zeros((count, 3), dtype=torch.long, device=self.device)
+        if rank == 0 or distributed_encode:
+            if prepared_videos is None or len(prepared_videos) != count:
+                raise ValueError("reference-video preparation is incomplete")
+            encoded = [
+                self.video_vae.encode_video(load_video_frames(item["prepared_path"])) for item in prepared_videos
+            ]
+            rows = torch.cat([item[0] for item in encoded])
+            shapes = torch.tensor(
+                [item[1] for item in encoded],
+                dtype=torch.long,
+                device=self.device,
+            )
+        if distributed_encode:
+            return (
+                rows.to(device=self.device, dtype=torch.float32),
+                [tuple(int(value) for value in item) for item in shapes.tolist()],
+            )
+
+        if world_size > 1:
+            dist.broadcast(shapes, src=0, group=group)
+        return (
+            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
+            [tuple(int(value) for value in item) for item in shapes.tolist()],
+        )
+
+    def _encode_video_audio_conditions(
+        self,
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        has_audio: list[bool],
+    ) -> tuple[torch.Tensor | None, list[int]]:
+        with self._component_on_device(self.audio_vae):
+            return self._encode_video_audio_conditions_resident(prepared_videos, has_audio=has_audio)
+
+    def _encode_video_audio_conditions_resident(
+        self,
+        prepared_videos: list[dict[str, Any]] | None,
+        *,
+        has_audio: list[bool],
+    ) -> tuple[torch.Tensor | None, list[int]]:
+        _, rank, _ = _dit_rank_world()
+        count = sum(has_audio)
+        if count == 0:
+            return None, []
+        rows = None
+        lengths = torch.zeros(count, dtype=torch.long, device=self.device)
+        if rank == 0:
+            if prepared_videos is None:
+                raise ValueError("rank 0 reference-video preparation is incomplete")
+            encoded = [
+                self.audio_vae.encode_waveform(
+                    *load_video_audio(
+                        item["original_path"],
+                        start_time_seconds=float(item.get("start_time_seconds", 0.0)),
+                        duration_seconds=item.get("duration_seconds"),
+                    )
+                )
+                for item in prepared_videos
+                if item["input_has_audio"]
+            ]
+            rows = torch.cat([item[0] for item in encoded])
+            lengths = torch.tensor(
+                [item[1] for item in encoded],
+                dtype=torch.long,
+                device=self.device,
+            )
+        group, _, world_size = _dit_rank_world()
+        if world_size > 1:
+            dist.broadcast(lengths, src=0, group=group)
+        return (
+            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
+            [int(value) for value in lengths.tolist()],
+        )
+
+    def _initial_noise(
+        self,
+        *,
+        seed: int,
+        latent_t: int,
+        latent_h: int,
+        latent_w: int,
+        audio_t: int,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        video_generator = torch.Generator(device="cpu").manual_seed(seed)
+        video = torch.randn(
+            1,
+            24,
+            latent_t,
+            latent_h,
+            latent_w,
+            generator=video_generator,
+            dtype=torch.float32,
+        )
+        video_rows = minimax_h3_patchify_video_latent(
+            video,
+            patch_size=(1, 2, 2),
+        )
+        audio_generator = torch.Generator(device="cpu").manual_seed(seed)
+        audio_rows = torch.randn(
+            audio_t * 2,
+            32,
+            generator=audio_generator,
+            dtype=torch.float32,
+        )
+        return video_rows, audio_rows
+
+    @contextmanager
+    def _resident_dit_layers_on_device(self, *, enabled: bool = True):
+        controller = getattr(self, "_dlo_residency_controller", None)
+        if controller is not None and enabled:
+            controller.load_resident_layers()
+        try:
+            yield
+        finally:
+            if controller is not None and enabled:
+                controller.offload_resident_layers()
+
+    def diffuse(
+        self,
+        *,
+        task: str,
+        text_embeddings: torch.Tensor,
+        text_tags: torch.Tensor,
+        seed: int,
+        latent_t: int,
+        latent_h: int,
+        latent_w: int,
+        audio_t: int,
+        num_frames: int,
+        num_steps: int,
+        video_shift: float,
+        audio_shift: float,
+        visual_condition: torch.Tensor | None,
+        visual_condition_shape: tuple[int, int, int] | None,
+        audio_condition: torch.Tensor | None,
+        ref_audio_t: int | None,
+        ref_blocks: list[dict[str, Any]] | None = None,
+        visual_condition_shapes: list[tuple[int, int, int]] | None = None,
+        audio_condition_lengths: list[int] | None = None,
+        keyframe_frame_indices: list[int] | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        initial_video, initial_audio = self._initial_noise(
+            seed=seed,
+            latent_t=latent_t,
+            latent_h=latent_h,
+            latent_w=latent_w,
+            audio_t=audio_t,
+        )
+        if task == "ref2va":
+            if ref_blocks is None:
+                if visual_condition_shape is None or ref_audio_t is None:
+                    raise ValueError("ref2va condition metadata is missing")
+                _, ref_h, ref_w = visual_condition_shape
+                ref_blocks = [
+                    {"kind": "image", "latent_h": ref_h, "latent_w": ref_w},
+                    {"kind": "audio", "ref_audio_t": ref_audio_t},
+                ]
+            packed = minimax_h3_packed_sequence_ref2va_blocks(
+                text_len=int(text_embeddings.shape[0]),
+                latent_t=latent_t,
+                latent_h=latent_h,
+                latent_w=latent_w,
+                audio_t=audio_t,
+                ref_blocks=ref_blocks,
+            )
+        else:
+            packed = minimax_h3_packed_sequence(
+                text_len=int(text_embeddings.shape[0]),
+                latent_t=latent_t,
+                latent_h=latent_h,
+                latent_w=latent_w,
+                audio_t=audio_t,
+                include_keyframe_cond=task == "fl2va",
+                keyframe_frame_indices=keyframe_frame_indices if task == "fl2va" else None,
+                frame_count=num_frames if task == "fl2va" else None,
+            )
+
+        tags = packed["token_tags"].clone()
+        tags[packed["text_pos"]] = text_tags.cpu()
+        branch = MiniMaxH3DenoiseBranch(
+            packed=packed,
+            text_embeddings=text_embeddings,
+            token_tags=tags,
+            device=self.device,
+        )
+
+        visual_anchor = visual_condition
+        if visual_anchor is not None:
+            condition_shapes = visual_condition_shapes
+            if condition_shapes is None and visual_condition_shape is not None:
+                condition_shapes = [visual_condition_shape]
+            if not condition_shapes:
+                raise ValueError("visual condition shape is missing")
+            visual_anchor = minimax_h3_imgvid_cond_noise_aug_rows(
+                visual_anchor,
+                condition_shapes=condition_shapes,
+                target_latent_t=latent_t,
+                imgvid_cond_num_frames=len(condition_shapes),
+                seed=seed,
+                noise_aug=MINIMAX_H3_IMGVID_COND_TIMESTEP,
+            )
+            full_video = torch.zeros(
+                branch.img_pos.shape[0],
+                96,
+                dtype=torch.float32,
+            )
+            full_video[branch.update_mask] = initial_video
+            initial_video = full_video
+
+        audio_anchor = audio_condition
+        if audio_anchor is not None:
+            condition_audio_t = audio_condition_lengths
+            if condition_audio_t is None and ref_audio_t is not None:
+                condition_audio_t = [ref_audio_t]
+            if not condition_audio_t:
+                raise ValueError("reference audio length is missing")
+            audio_anchor = minimax_h3_audio_cond_noise_aug_rows(
+                audio_anchor,
+                condition_audio_t=condition_audio_t,
+                seed=seed,
+                noise_aug=MINIMAX_H3_AUDIO_REF_COND_TIMESTEP,
+            )
+            full_audio = torch.zeros(
+                branch.audio_pos.shape[0],
+                32,
+                dtype=torch.float32,
+            )
+            full_audio[branch.audio_update_mask] = initial_audio
+            initial_audio = full_audio
+
+        video_sigmas = minimax_h3_time_shift_sigmas(
+            num_steps=num_steps,
+            shift_scale=video_shift,
+        )
+        audio_sigmas = minimax_h3_time_shift_sigmas(
+            num_steps=num_steps,
+            shift_scale=audio_shift,
+        )
+        transformer = self._transformer_for_task(task)
+        # The static DLO plan keeps leading blocks resident only for the
+        # primary ``transformer``. In combined mode ``transformers_ref`` is
+        # fully streamed, so a Ref2VA request must not stage the inactive
+        # FL2VA transformer resident blocks.
+        with self._resident_dit_layers_on_device(enabled=transformer is self.transformer):
+            with self.progress_bar(total=len(video_sigmas) - 1) as progress:
+                video_rows, audio_rows = minimax_h3_denoise_loop(
+                    model=transformer,
+                    positive=branch,
+                    initial_video_rows=initial_video,
+                    initial_audio_rows=initial_audio,
+                    keyframe_cond_rows=visual_anchor,
+                    audio_ref_rows=audio_anchor,
+                    sigmas_video=video_sigmas,
+                    sigmas_audio=audio_sigmas,
+                    device=self.device,
+                    imgvid_cond_noise_aug_for_inference=(MINIMAX_H3_IMGVID_COND_TIMESTEP),
+                    audio_cond_noise_aug_for_inference=(MINIMAX_H3_AUDIO_REF_COND_TIMESTEP),
+                    on_step_start=lambda step, video_sigma, audio_sigma: self.record_denoise_step(
+                        step,
+                        normalized_timestep=video_sigma,
+                    ),
+                    on_step_end=lambda step, video, audio: progress.update(),
+                )
+
+        target_video = video_rows[branch.update_mask_dev]
+        video_latent = minimax_h3_unpatchify_video_tokens(
+            target_video,
+            latent_shape=(
+                latent_t,
+                latent_h // 2,
+                latent_w // 2,
+                24,
+            ),
+            patch_size=(1, 2, 2),
+        )
+        target_audio = audio_rows[branch.audio_update_mask_dev]
+        audio_latent = minimax_h3_unpack_audio_tokens(
+            target_audio,
+            audio_t=audio_t * 2,
+            audio_channel=2,
+        )
+        return video_latent, audio_latent
+
+    def decode(
+        self,
+        video_latent: torch.Tensor,
+        audio_latent: torch.Tensor,
+        *,
+        height: int,
+        width: int,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        with self._component_on_device(self.video_vae):
+            with current_omni_platform.create_autocast_context(
+                device_type=self.device.type,
+                dtype=torch.float16,
+                enabled=True,
+            ):
+                video = self.video_vae.decode_latent(video_latent)
+        video = video[..., :height, :width].contiguous()
+        with self._component_on_device(self.audio_vae):
+            audio = self.audio_vae.decode_latent(audio_latent)
+        return video, audio
+
+    @torch.no_grad()
+    def forward(self, request: DiffusionRequestBatch) -> DiffusionOutput:
+        if len(request.prompts) != 1:
+            raise OmniClientError("MiniMax H3 supports one request at a time")
+        raw_prompt = request.prompts[0]
+        if isinstance(raw_prompt, str):
+            prompt = raw_prompt
+            multi_modal_data: dict[str, Any] = {}
+        else:
+            prompt = str(raw_prompt.get("prompt") or "")
+            multi_modal_data = raw_prompt.get("multi_modal_data") or {}
+        if not prompt:
+            raise OmniClientError("MiniMax H3 requires a non-empty prompt")
+
+        sampling = request.sampling_params
+        extra = sampling.extra_args or {}
+        task = self._resolve_task(extra.get("task"), multi_modal_data)
+
+        raw_image = multi_modal_data.get("image")
+        raw_videos = multi_modal_data.get("video")
+        raw_audio = multi_modal_data.get("audio")
+        images = _load_images(raw_image) if raw_image is not None else []
+        video_values = list(raw_videos) if isinstance(raw_videos, (list, tuple)) else raw_videos
+        audio_values = list(raw_audio) if isinstance(raw_audio, (list, tuple)) else raw_audio
+
+        if task == "t2va" and (images or raw_videos is not None or raw_audio is not None):
+            raise OmniClientError("t2va does not accept image, video, or audio conditions")
+        if task == "fl2va":
+            if not images:
+                raise OmniClientError("fl2va requires multi_modal_data.image")
+            if len(images) > 2:
+                raise OmniClientError("fl2va accepts at most first and last images")
+            if raw_videos is not None or raw_audio is not None:
+                raise OmniClientError("fl2va accepts image keyframes only")
+        if task == "ref2va":
+            video_count = (
+                len(video_values) if isinstance(video_values, (list, tuple)) else int(video_values is not None)
+            )
+            audio_is_waveform_pair = (
+                isinstance(raw_audio, (list, tuple))
+                and len(raw_audio) == 2
+                and isinstance(raw_audio[1], (int, np.integer))
+            )
+            audio_count = (
+                len(audio_values)
+                if isinstance(audio_values, (list, tuple)) and not audio_is_waveform_pair
+                else int(raw_audio is not None)
+            )
+            _validate_ref2va_reference_counts(len(images), video_count, audio_count)
+        elif raw_videos is not None:
+            raise OmniClientError(f"{task} does not accept a video condition")
+
+        image = images[0] if images else None
+        height, width, num_frames, latent_t, audio_t = self._resolve_shape(task, sampling, image)
+        if task == "fl2va":
+            for item in images:
+                _validate_reference_image(item)
+            prepared_images = [item.resize((width, height), Image.Resampling.LANCZOS) for item in images]
+            keyframe_frame_indices = _resolve_fl2va_keyframe_indices(extra, len(images))
+        elif task == "ref2va":
+            prepared_images = []
+            for item in images:
+                ref_width, ref_height = _reference_image_shape(item)
+                prepared_images.append(item.resize((ref_width, ref_height), Image.Resampling.LANCZOS))
+            keyframe_frame_indices = None
+        else:
+            prepared_images = []
+            keyframe_frame_indices = None
+
+        visual_condition = None
+        visual_shape = None
+        visual_shapes = None
+        audio_condition = None
+        ref_audio_t = None
+        audio_lengths = None
+        ref_blocks = None
+        with tempfile.TemporaryDirectory(prefix="minimax_h3_ref2va_") as workdir:
+            prepared_videos = None
+            has_audio: list[bool] = []
+            video_count = 0
+            if raw_videos is not None:
+                video_count = len(raw_videos) if isinstance(raw_videos, (list, tuple)) else 1
+                prepared_videos = self._prepare_reference_videos(
+                    raw_videos,
+                    target_frame_count=num_frames,
+                    workdir=workdir,
+                    start_time_seconds=extra.get("start_time_seconds"),
+                )
+                has_audio_tensor = torch.zeros(
+                    video_count,
+                    dtype=torch.long,
+                    device=self.device,
+                )
+                _, rank, world_size = _dit_rank_world()
+                if rank == 0:
+                    has_audio_tensor = torch.tensor(
+                        [int(item["input_has_audio"]) for item in prepared_videos or []],
+                        dtype=torch.long,
+                        device=self.device,
+                    )
+                if world_size > 1:
+                    dist.broadcast(
+                        has_audio_tensor,
+                        src=0,
+                        group=get_dit_group(),
+                    )
+                has_audio = [bool(value) for value in has_audio_tensor.tolist()]
+
+            if raw_audio is not None:
+                validate_reference_audio_files(raw_audio)
+            standalone_audios = _load_audios(raw_audio) if raw_audio is not None else []
+            validate_reference_audio_waveforms(standalone_audios)
+            condition_labels: list[tuple[str, int]] = []
+            for image_index in range(1, len(prepared_images) + 1):
+                condition_labels.append(("image", image_index))
+            audio_index = 0
+            for video_index, item in enumerate(prepared_videos or (), start=1):
+                if item["input_has_audio"]:
+                    audio_index += 1
+                    condition_labels.append(("audio", audio_index))
+                condition_labels.append(("video", video_index))
+            for _ in standalone_audios:
+                audio_index += 1
+                condition_labels.append(("audio", audio_index))
+
+            text_embeddings, text_tags = self.encode_prompt(
+                task=task,
+                prompt=prompt,
+                images=prepared_images,
+                prepared_videos=prepared_videos,
+                condition_labels=condition_labels if task == "ref2va" else None,
+            )
+
+            # ``prepared_videos`` is intentionally ``None`` on non-zero DiT
+            # ranks; the distributed video encoder broadcasts the prepared
+            # metadata inside ``_encode_visual_conditions``.  Use the global
+            # video count here so video + standalone-audio Ref2VA requests do
+            # not look like audio-only requests on those ranks.
+            if video_count or prepared_images:
+                visual_condition, visual_shapes = self._encode_visual_conditions(
+                    prepared_images,
+                    prepared_videos,
+                    video_count=video_count,
+                )
+                embedded_audio_condition, embedded_audio_lengths = self._encode_video_audio_conditions(
+                    prepared_videos,
+                    has_audio=has_audio,
+                )
+                external_audio_condition, external_audio_lengths = self._encode_audio_conditions(standalone_audios)
+                audio_parts = [
+                    item for item in (embedded_audio_condition, external_audio_condition) if item is not None
+                ]
+                audio_condition = torch.cat(audio_parts) if audio_parts else None
+                audio_lengths = embedded_audio_lengths + external_audio_lengths
+                ref_blocks = []
+                image_shapes = visual_shapes[: len(prepared_images)]
+                video_shapes = visual_shapes[len(prepared_images) :]
+                for shape in image_shapes:
+                    ref_blocks.append(
+                        {
+                            "kind": "image",
+                            "latent_h": shape[1],
+                            "latent_w": shape[2],
+                        }
+                    )
+                audio_iterator = iter(embedded_audio_lengths)
+                for shape, contributes_audio in zip(video_shapes, has_audio, strict=True):
+                    ref_audio = next(audio_iterator) if contributes_audio else 0
+                    ref_blocks.append(
+                        {
+                            "kind": "video_audio" if ref_audio else "video",
+                            "ref_audio_t": ref_audio,
+                            "latent_t": shape[0],
+                            "latent_h": shape[1],
+                            "latent_w": shape[2],
+                        }
+                    )
+                for ref_audio_t in external_audio_lengths:
+                    ref_blocks.append({"kind": "audio", "ref_audio_t": ref_audio_t})
+            elif standalone_audios:
+                raise OmniClientError("standalone audio references require a Ref2VA visual reference")
+
+            if visual_shapes and len(visual_shapes) == 1:
+                visual_shape = visual_shapes[0]
+            if audio_lengths:
+                if any(length < 80 or length > 600 for length in audio_lengths):
+                    raise OmniClientError("MiniMax H3 audio references must each be between 2 and 15 seconds")
+                if sum(audio_lengths) > 600:
+                    raise OmniClientError("MiniMax H3 audio references must be at most 15 seconds in total")
+                if len(audio_lengths) == 1:
+                    ref_audio_t = audio_lengths[0]
+
+        seed = int(sampling.seed if sampling.seed is not None else 42)
+        num_steps = int(sampling.num_inference_steps or 50)
+        video_shift = float(extra.get("flow_shift", self.default_video_shift))
+        audio_shift = float(extra.get("audio_flow_shift", self.default_audio_shift))
+        num_outputs = _resolve_minimax_h3_num_outputs(sampling.num_outputs_per_prompt)
+        videos = []
+        audios = []
+        for output_seed in _minimax_h3_output_seeds(seed, num_outputs):
+            video_latent, audio_latent = self.diffuse(
+                task=task,
+                text_embeddings=text_embeddings,
+                text_tags=text_tags,
+                seed=output_seed,
+                latent_t=latent_t,
+                latent_h=height // 16,
+                latent_w=width // 16,
+                audio_t=audio_t,
+                num_frames=num_frames,
+                num_steps=num_steps,
+                video_shift=video_shift,
+                audio_shift=audio_shift,
+                visual_condition=visual_condition,
+                visual_condition_shape=visual_shape,
+                audio_condition=audio_condition,
+                ref_audio_t=ref_audio_t,
+                ref_blocks=ref_blocks,
+                visual_condition_shapes=visual_shapes,
+                audio_condition_lengths=audio_lengths,
+                keyframe_frame_indices=keyframe_frame_indices,
+            )
+            video, audio = self.decode(video_latent, audio_latent, height=height, width=width)
+            videos.append(video)
+            audios.append(audio)
+        video = torch.cat(videos, dim=0)
+        audio = torch.cat(audios, dim=0)
+        return DiffusionOutput(
+            output=(video, audio),
+            post_process_func=get_minimax_h3_post_process_func(self.od_config),
+            stage_durations=(self.stage_durations if hasattr(self, "_stage_durations") else {}),
+        )
+
+
+__all__ = [
+    "MiniMaxH3Pipeline",
+    "get_minimax_h3_post_process_func",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/presentation.py b/vllm_omni/diffusion/models/minimax_h3/presentation.py
new file mode 100644
index 000000000..a8e142189
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/presentation.py
@@ -0,0 +1,297 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 Qwen presentation building.
+
+Builds the positive presentation token stream:
+- fl2va: '<Picture 1>: ' label + vision block (<|vision_start|> +
+  N*<|image_pad|> + <|vision_end|>) + prompt text.
+- t2va: prompt text only (no vision block).
+Prompt text passes through verbatim (no stripping or rewriting).
+
+All presentation variants are emitted through the shared ``_Presentation``
+accumulator so ids and AdaLN token tags cannot drift apart.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import torch
+
+VISION_START = "<|vision_start|>"
+VISION_END = "<|vision_end|>"
+IMAGE_PAD = "<|image_pad|>"
+VIDEO_PAD = "<|video_pad|>"
+
+_TEXT_TAG = 1
+_VIDEO_TAG = 0
+
+
+def _text_ids(tokenizer: Any, text: str) -> list[int]:
+    return list(tokenizer(text, add_special_tokens=False)["input_ids"])
+
+
+def _vision_block_ids(tokenizer: Any, pad_token: str, count: int) -> list[int]:
+    return (
+        [tokenizer.convert_tokens_to_ids(VISION_START)]
+        + [tokenizer.convert_tokens_to_ids(pad_token)] * int(count)
+        + [tokenizer.convert_tokens_to_ids(VISION_END)]
+    )
+
+
+class _Presentation:
+    """Accumulates aligned (ids, token_tags) presentation segments."""
+
+    def __init__(self) -> None:
+        self.ids: list[int] = []
+        self.tags: list[int] = []
+
+    def text(self, token_ids: list[int]) -> None:
+        self.ids += token_ids
+        self.tags += [_TEXT_TAG] * len(token_ids)
+
+    def vision(self, token_ids: list[int]) -> None:
+        self.ids += token_ids
+        self.tags += [_VIDEO_TAG] * len(token_ids)
+
+    def build(self) -> tuple[torch.Tensor, torch.Tensor]:
+        return (
+            torch.tensor(self.ids, dtype=torch.long),
+            torch.tensor(self.tags, dtype=torch.long),
+        )
+
+
+def _timestamped_video_blocks(
+    presentation: _Presentation,
+    tokenizer: Any,
+    *,
+    counts: Sequence[int],
+    timestamps: Sequence[float],
+    context: str,
+) -> None:
+    """Emit per-temporal-block ``<{t:.1f} seconds>`` text + VIDEO vision."""
+
+    counts = [int(value) for value in counts]
+    timestamps = [float(value) for value in timestamps]
+    if not counts or len(counts) != len(timestamps):
+        raise ValueError(f"{context}video block token counts and timestamps must align")
+    for count, timestamp in zip(counts, timestamps):
+        if count <= 0:
+            raise ValueError(f"{context}video block token count must be positive")
+        presentation.text(_text_ids(tokenizer, f"<{timestamp:.1f} seconds>"))
+        presentation.vision(_vision_block_ids(tokenizer, VIDEO_PAD, count))
+
+
+def minimax_h3_text_only_ids(tokenizer: Any, prompt: str) -> torch.Tensor:
+    """t2va presentation: verbatim prompt, no special tokens."""
+    if not prompt:
+        raise ValueError("prompt must be non-empty")
+    return torch.tensor(_text_ids(tokenizer, prompt), dtype=torch.long)
+
+
+def _multi_image_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    image_token_counts: list[int],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if not image_token_counts:
+        raise ValueError("image_token_counts must be non-empty")
+    presentation = _Presentation()
+    for index, count in enumerate(image_token_counts, start=1):
+        if int(count) <= 0:
+            raise ValueError("image_token_count must be positive")
+        presentation.text(_text_ids(tokenizer, f"<Picture {index}>: "))
+        presentation.vision(_vision_block_ids(tokenizer, IMAGE_PAD, count))
+    presentation.text(_text_ids(tokenizer, prompt))
+    return presentation.build()
+
+
+def minimax_h3_multi_image_presentation_ids(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    image_token_counts: list[int],
+) -> torch.Tensor:
+    """Positive fl2va presentation with one or more labeled image slots."""
+    ids, _ = _multi_image_presentation(tokenizer, prompt=prompt, image_token_counts=image_token_counts)
+    return ids
+
+
+def minimax_h3_multi_image_presentation_token_tags(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    image_token_counts: list[int],
+) -> torch.Tensor:
+    """AdaLN token tags aligned with minimax_h3_multi_image_presentation_ids."""
+    _, tags = _multi_image_presentation(tokenizer, prompt=prompt, image_token_counts=image_token_counts)
+    return tags
+
+
+def minimax_h3_ref2va_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    condition_labels: list[tuple[str, int]],
+    image_token_count: int | list[int] | None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """ref2va positive presentation:
+
+    per condition in request order — image i: ``<Picture i>: `` label followed
+    by the vision block; audio j: ``<Audio j>: `` label only (audio content
+    never enters Qwen) — then the verbatim prompt. Returns (ids, token_tags)
+    with the vision block tagged VIDEO(0) and everything else TEXT(1).
+
+    condition_labels: [("image", 1), ("audio", 1), ...] with 1-based ordinals
+    per type.
+    """
+    return minimax_h3_ref2va_video_presentation(
+        tokenizer,
+        prompt=prompt,
+        condition_labels=condition_labels,
+        image_token_count=image_token_count,
+        video_block_token_counts=None,
+        video_block_timestamps=None,
+    )
+
+
+def _as_int_list(value: int | Sequence[int] | None, *, name: str) -> list[int]:
+    if value is None:
+        return []
+    if isinstance(value, int):
+        return [int(value)]
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be an int or a sequence of ints")
+    return [int(item) for item in value]
+
+
+def _as_nested_int_list(
+    value: Sequence[int] | Sequence[Sequence[int]] | None,
+    *,
+    name: str,
+) -> list[list[int]]:
+    if value is None:
+        return []
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be a sequence")
+    if len(value) == 0:
+        return []
+    first = value[0]
+    if isinstance(first, Sequence) and not isinstance(first, (str, bytes)):
+        out: list[list[int]] = []
+        for group in value:
+            if not isinstance(group, Sequence) or isinstance(group, (str, bytes)):
+                raise ValueError(f"{name} must not mix nested and flat entries")
+            out.append([int(item) for item in group])
+        return out
+    return [[int(item) for item in value]]
+
+
+def _as_nested_float_list(
+    value: Sequence[float] | Sequence[Sequence[float]] | None,
+    *,
+    name: str,
+) -> list[list[float]]:
+    if value is None:
+        return []
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be a sequence")
+    if len(value) == 0:
+        return []
+    first = value[0]
+    if isinstance(first, Sequence) and not isinstance(first, (str, bytes)):
+        out: list[list[float]] = []
+        for group in value:
+            if not isinstance(group, Sequence) or isinstance(group, (str, bytes)):
+                raise ValueError(f"{name} must not mix nested and flat entries")
+            out.append([float(item) for item in group])
+        return out
+    return [[float(item) for item in value]]
+
+
+def minimax_h3_ref2va_video_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    condition_labels: list[tuple[str, int]],
+    image_token_count: int | list[int] | None,
+    video_block_token_counts: list[int] | list[list[int]] | None,
+    video_block_timestamps: list[float] | list[list[float]] | None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """ref2va (optionally with video refs) positive presentation:
+
+    per condition in request order —
+    - image i:  ``<Picture i>: `` label + one image vision block;
+    - audio j:  ``<Audio j>: `` label only (audio content never enters Qwen);
+    - video k:  ``<Video k>: `` label, then per temporal block a timestamp
+      text ``<{t:.1f} seconds>`` followed by a VIDEO vision block
+      (<|vision_start|> + <|video_pad|> x n + <|vision_end|>). Timestamps are
+      the mean of each merged frame pair (Qwen3VL temporal merge 2; odd frame
+      counts repeat the last frame), emitting the
+      ``<0.2 seconds>`` ..
+      ``<4.0 seconds>`` sequence — note Python bankers-rounding at .1f.
+    then the verbatim prompt. Vision blocks are tagged VIDEO(0), everything
+    else TEXT(1).
+    """
+    if not prompt:
+        raise ValueError("prompt must be non-empty")
+    presentation = _Presentation()
+    image_token_counts = _as_int_list(image_token_count, name="image_token_count")
+    video_counts_by_ref = _as_nested_int_list(
+        video_block_token_counts,
+        name="video_block_token_counts",
+    )
+    video_timestamps_by_ref = _as_nested_float_list(
+        video_block_timestamps,
+        name="video_block_timestamps",
+    )
+    if len(video_counts_by_ref) != len(video_timestamps_by_ref):
+        raise ValueError("video block token counts and timestamps must align")
+    image_seen = 0
+    video_seen = 0
+    for cond_type, ordinal in condition_labels:
+        if cond_type == "image":
+            image_seen += 1
+            if image_seen > len(image_token_counts):
+                raise ValueError("image_token_count required for an image reference")
+            count = int(image_token_counts[image_seen - 1])
+            if count <= 0:
+                raise ValueError("image_token_count required for an image reference")
+            presentation.text(_text_ids(tokenizer, f"<Picture {ordinal}>: "))
+            presentation.vision(_vision_block_ids(tokenizer, IMAGE_PAD, count))
+        elif cond_type == "audio":
+            presentation.text(_text_ids(tokenizer, f"<Audio {ordinal}>: "))
+        elif cond_type == "video":
+            video_seen += 1
+            if video_seen > len(video_counts_by_ref):
+                raise ValueError("video reference requires block token counts and timestamps")
+            counts = video_counts_by_ref[video_seen - 1]
+            timestamps = video_timestamps_by_ref[video_seen - 1]
+            if not counts or not timestamps:
+                raise ValueError("video reference requires block token counts and timestamps")
+            presentation.text(_text_ids(tokenizer, f"<Video {ordinal}>: "))
+            _timestamped_video_blocks(
+                presentation,
+                tokenizer,
+                counts=counts,
+                timestamps=timestamps,
+                context="",
+            )
+        else:
+            raise ValueError(f"unsupported ref2va condition type {cond_type!r}")
+    if image_seen != len(image_token_counts):
+        raise ValueError("unused image_token_count entries")
+    if video_seen != len(video_counts_by_ref):
+        raise ValueError("unused video block token count entries")
+    presentation.text(_text_ids(tokenizer, prompt))
+    return presentation.build()
+
+
+__all__ = [
+    "minimax_h3_multi_image_presentation_ids",
+    "minimax_h3_multi_image_presentation_token_tags",
+    "minimax_h3_ref2va_presentation",
+    "minimax_h3_ref2va_video_presentation",
+    "minimax_h3_text_only_ids",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/reference_video.py b/vllm_omni/diffusion/models/minimax_h3/reference_video.py
new file mode 100644
index 000000000..0bbb03e87
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/reference_video.py
@@ -0,0 +1,559 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 Ref2VA reference-video preparation."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+from vllm_omni.errors import OmniClientError
+
+MINIMAX_H3_FPS = 24.0
+MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS = 2.0
+MINIMAX_H3_QWEN_TEMPORAL_PATCH = 2
+MINIMAX_H3_BASE_SHORT_EDGE = 768
+MINIMAX_H3_MAX_PIXELS = 768 * 1344
+MINIMAX_H3_CANVAS_MULTIPLE = 32
+MINIMAX_H3_MIN_REFERENCE_DIMENSION = 256
+MINIMAX_H3_MAX_REFERENCE_DIMENSION = 5760
+MINIMAX_H3_MIN_REFERENCE_FPS = 23.976
+MINIMAX_H3_MAX_REFERENCE_FPS = 60.0
+MINIMAX_H3_MIN_REFERENCE_DURATION = 2.0
+MINIMAX_H3_MAX_REFERENCE_DURATION = 15.0
+MINIMAX_H3_MAX_REFERENCE_TOTAL_DURATION = 15.0
+# ffprobe reports container durations at a finer precision than the official
+# example's rounded values. Trim only this small probe-rounding excess.
+MINIMAX_H3_REFERENCE_DURATION_EPSILON = 1e-2
+MINIMAX_H3_MAX_VIDEO_BYTES = 50 * 1024 * 1024
+MINIMAX_H3_MAX_AUDIO_BYTES = 15 * 1024 * 1024
+MINIMAX_H3_VIDEO_FORMATS = frozenset({"mp4", "mov"})
+MINIMAX_H3_VIDEO_CODECS = frozenset({"h264", "h265", "hevc"})
+MINIMAX_H3_AUDIO_FORMATS = frozenset({"wav", "mp3"})
+MINIMAX_H3_AUDIO_CODECS = frozenset({"aac", "mp3"})
+
+
+def _nearest_multiple(value: float, multiple: int) -> int:
+    return max(multiple, int(round(float(value) / multiple)) * multiple)
+
+
+def _probe_video(path: str) -> dict[str, Any]:
+    result = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-count_frames",
+            "-show_entries",
+            (
+                "stream=codec_type,codec_name,width,height,r_frame_rate,nb_read_frames,nb_frames,duration,"
+                "sample_aspect_ratio:format=format_name,size,duration"
+            ),
+            "-of",
+            "json",
+            path,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    probe = json.loads(result.stdout)
+    streams = probe.get("streams") or []
+    video_streams = [stream for stream in streams if stream.get("codec_type") == "video"]
+    if not video_streams:
+        raise OmniClientError(f"media has no video stream: {path}")
+    stream = video_streams[0]
+    try:
+        numerator, denominator = str(stream["r_frame_rate"]).split("/", 1)
+        fps = float(numerator) / float(denominator)
+    except (KeyError, TypeError, ValueError, ZeroDivisionError) as exc:
+        raise OmniClientError(f"cannot determine video FPS: {path}") from exc
+    if not math.isfinite(fps) or fps <= 0:
+        raise OmniClientError(f"cannot determine video FPS: {path}")
+    raw_count = stream.get("nb_read_frames") or stream.get("nb_frames")
+    if raw_count in (None, "", "N/A"):
+        raise OmniClientError(f"cannot determine video frame count: {path}")
+    raw_duration = stream.get("duration")
+    if raw_duration in (None, "", "N/A"):
+        raw_duration = probe.get("format", {}).get("duration")
+    duration = float(raw_duration) if raw_duration not in (None, "", "N/A") else int(raw_count) / fps
+    format_info = probe.get("format") or {}
+    format_names = tuple(
+        name.strip().lower() for name in str(format_info.get("format_name", "")).split(",") if name.strip()
+    )
+    raw_size = format_info.get("size")
+    file_size = int(raw_size) if raw_size not in (None, "", "N/A") else os.path.getsize(path)
+    audio_codecs = tuple(
+        str(stream.get("codec_name", "")).lower()
+        for stream in streams
+        if stream.get("codec_type") == "audio" and stream.get("codec_name")
+    )
+    return {
+        "width": int(stream["width"]),
+        "height": int(stream["height"]),
+        "fps": fps,
+        "frame_count": int(raw_count),
+        "duration": duration,
+        "format_names": format_names,
+        "video_codec": str(stream.get("codec_name", "")).lower(),
+        "audio_codecs": audio_codecs,
+        "file_size": file_size,
+    }
+
+
+def _validate_reference_video_metadata(meta: dict[str, Any], *, index: int, source: str) -> None:
+    width = int(meta["width"])
+    height = int(meta["height"])
+    if (
+        min(width, height) < MINIMAX_H3_MIN_REFERENCE_DIMENSION
+        or max(width, height) > MINIMAX_H3_MAX_REFERENCE_DIMENSION
+    ):
+        raise OmniClientError(f"reference video {index} dimensions must be in [256, 5760] pixels, got {width}x{height}")
+    ratio = width / height
+    if not 0.4 <= ratio <= 2.5:
+        raise OmniClientError(f"reference video {index} aspect ratio must be in [0.4, 2.5], got {width}x{height}")
+
+    fps = float(meta["fps"])
+    if not MINIMAX_H3_MIN_REFERENCE_FPS <= fps <= MINIMAX_H3_MAX_REFERENCE_FPS:
+        raise OmniClientError(f"reference video {index} FPS must be in [23.976, 60], got {fps:.3f}")
+    duration = float(meta["duration"])
+    if (
+        not math.isfinite(duration)
+        or not MINIMAX_H3_MIN_REFERENCE_DURATION <= duration <= MINIMAX_H3_MAX_REFERENCE_DURATION
+    ):
+        raise OmniClientError(f"reference video {index} duration must be in [2, 15] seconds, got {duration:.3f}")
+
+    raw_file_size = meta.get("file_size")
+    file_size = int(raw_file_size) if raw_file_size is not None else os.path.getsize(source)
+    if file_size > MINIMAX_H3_MAX_VIDEO_BYTES:
+        raise OmniClientError(f"reference video {index} exceeds the 50 MiB size limit")
+    format_names = set(meta.get("format_names", ()))
+    if not format_names.intersection(MINIMAX_H3_VIDEO_FORMATS):
+        formats = ", ".join(sorted(format_names)) or "unknown"
+        raise OmniClientError(f"reference video {index} must use an MP4 or MOV container, got {formats}")
+    video_codec = str(meta.get("video_codec", "")).lower()
+    if video_codec not in MINIMAX_H3_VIDEO_CODECS:
+        raise OmniClientError(f"reference video {index} must use H.264 or H.265 video, got {video_codec or 'unknown'}")
+    audio_codecs = tuple(str(codec).lower() for codec in meta.get("audio_codecs", ()))
+    invalid_audio = [codec for codec in audio_codecs if codec not in MINIMAX_H3_AUDIO_CODECS]
+    if invalid_audio:
+        raise OmniClientError(
+            f"reference video {index} must use AAC or MP3 audio when audio is present, got {invalid_audio[0]}"
+        )
+
+
+def _audio_items(values: Any) -> list[Any]:
+    if isinstance(values, (str, os.PathLike)):
+        return [values]
+    if isinstance(values, tuple) and len(values) == 2 and isinstance(values[1], (int, np.integer)):
+        return [values]
+    if isinstance(values, (list, tuple)):
+        return list(values)
+    return [values]
+
+
+def _probe_audio(path: str) -> dict[str, Any]:
+    result = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-show_entries",
+            "stream=codec_type,codec_name,duration:format=format_name,size,duration",
+            "-of",
+            "json",
+            path,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    probe = json.loads(result.stdout)
+    streams = [stream for stream in probe.get("streams", []) if stream.get("codec_type") == "audio"]
+    if not streams:
+        raise OmniClientError(f"media has no audio stream: {path}")
+    stream = streams[0]
+    raw_duration = stream.get("duration")
+    if raw_duration in (None, "", "N/A"):
+        raw_duration = (probe.get("format") or {}).get("duration")
+    if raw_duration in (None, "", "N/A"):
+        raise OmniClientError(f"cannot determine audio duration: {path}")
+    format_info = probe.get("format") or {}
+    format_names = tuple(
+        name.strip().lower() for name in str(format_info.get("format_name", "")).split(",") if name.strip()
+    )
+    raw_size = format_info.get("size")
+    file_size = int(raw_size) if raw_size not in (None, "", "N/A") else os.path.getsize(path)
+    return {
+        "duration": float(raw_duration),
+        "format_names": format_names,
+        "codec": str(stream.get("codec_name", "")).lower(),
+        "file_size": file_size,
+    }
+
+
+def validate_reference_audio_files(values: Any) -> None:
+    """Validate path-backed standalone audio references against the H3 spec."""
+    total_duration = 0.0
+    for index, value in enumerate(_audio_items(values)):
+        if not isinstance(value, (str, os.PathLike)):
+            continue
+        source = str(value)
+        meta = _probe_audio(source)
+        file_size = int(meta["file_size"])
+        if file_size > MINIMAX_H3_MAX_AUDIO_BYTES:
+            raise OmniClientError(f"reference audio {index} exceeds the 15 MiB size limit")
+        if not set(meta["format_names"]).intersection(MINIMAX_H3_AUDIO_FORMATS):
+            formats = ", ".join(meta["format_names"]) or "unknown"
+            raise OmniClientError(f"reference audio {index} must be WAV or MP3, got {formats}")
+        codec = str(meta["codec"]).lower()
+        if codec not in MINIMAX_H3_AUDIO_CODECS and not codec.startswith("pcm_"):
+            raise OmniClientError(f"reference audio {index} must use MP3 or PCM audio, got {codec or 'unknown'}")
+        duration = float(meta["duration"])
+        if (
+            not math.isfinite(duration)
+            or not MINIMAX_H3_MIN_REFERENCE_DURATION <= duration <= MINIMAX_H3_MAX_REFERENCE_DURATION
+        ):
+            raise OmniClientError(f"reference audio {index} duration must be in [2, 15] seconds, got {duration:.3f}")
+        total_duration += duration
+    if total_duration > MINIMAX_H3_MAX_REFERENCE_TOTAL_DURATION:
+        raise OmniClientError("reference audio must be at most 15 seconds in total")
+
+
+def validate_reference_audio_waveforms(values: list[tuple[torch.Tensor, int]]) -> None:
+    """Validate in-memory standalone audio references using sample counts."""
+    total_duration = 0.0
+    for index, (waveform, sample_rate) in enumerate(values):
+        if int(sample_rate) <= 0:
+            raise OmniClientError(f"reference audio {index} has an invalid sample rate")
+        samples = int(waveform.shape[-1])
+        duration = samples / int(sample_rate)
+        if not MINIMAX_H3_MIN_REFERENCE_DURATION <= duration <= MINIMAX_H3_MAX_REFERENCE_DURATION:
+            raise OmniClientError(f"reference audio {index} duration must be in [2, 15] seconds, got {duration:.3f}")
+        total_duration += duration
+    if total_duration > MINIMAX_H3_MAX_REFERENCE_TOTAL_DURATION:
+        raise OmniClientError("reference audio must be at most 15 seconds in total")
+
+
+def _reference_video_shape(width: int, height: int) -> tuple[int, int]:
+    if (
+        min(width, height) < MINIMAX_H3_MIN_REFERENCE_DIMENSION
+        or max(width, height) > MINIMAX_H3_MAX_REFERENCE_DIMENSION
+    ):
+        raise OmniClientError(f"reference video dimensions must be in [256, 5760] pixels, got {width}x{height}")
+    ratio = float(width) / float(height)
+    if not 0.4 <= ratio <= 2.5:
+        raise OmniClientError(f"reference video aspect ratio must be in [0.4, 2.5], got {width}x{height}")
+    if ratio >= 1.0:
+        target_width = MINIMAX_H3_BASE_SHORT_EDGE * ratio
+        target_height = float(MINIMAX_H3_BASE_SHORT_EDGE)
+    else:
+        target_width = float(MINIMAX_H3_BASE_SHORT_EDGE)
+        target_height = MINIMAX_H3_BASE_SHORT_EDGE / ratio
+    area = target_width * target_height
+    if area > MINIMAX_H3_MAX_PIXELS:
+        scale = math.sqrt(MINIMAX_H3_MAX_PIXELS / area)
+        target_width *= scale
+        target_height *= scale
+    return (
+        _nearest_multiple(target_width, MINIMAX_H3_CANVAS_MULTIPLE),
+        _nearest_multiple(target_height, MINIMAX_H3_CANVAS_MULTIPLE),
+    )
+
+
+def _transcode_reference_video(
+    source: str,
+    *,
+    target_width: int,
+    target_height: int,
+    workdir: str,
+    start_time_seconds: float = 0.0,
+    duration_seconds: float | None = None,
+) -> str:
+    output = str(Path(workdir) / "prepared.mp4")
+    duration_args = ["-t", f"{float(duration_seconds):.6f}"] if duration_seconds is not None else []
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-y",
+            "-loglevel",
+            "error",
+            "-ss",
+            f"{float(start_time_seconds):.6f}",
+            "-i",
+            source,
+            "-map",
+            "0:v:0",
+            "-an",
+            "-vf",
+            (f"fps={MINIMAX_H3_FPS:g},scale={target_width}:{target_height}:flags=lanczos,setsar=1"),
+            *duration_args,
+            "-metadata:s:v:0",
+            "rotate=0",
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            output,
+        ],
+        check=True,
+    )
+    return output
+
+
+def prepare_reference_videos(
+    values: Any,
+    *,
+    target_frame_count: int,
+    workdir: str,
+    start_time_seconds: Any = None,
+) -> list[dict[str, Any]]:
+    # Keep this argument for compatibility with existing pipeline callers;
+    # reference inputs are now bounded by their source/segment durations, not
+    # clipped to the generated frame count.
+    del target_frame_count
+    if isinstance(values, (str, os.PathLike)):
+        values = [values]
+    if not isinstance(values, (list, tuple)) or not values:
+        raise OmniClientError("MiniMax H3 Ref2VA video input must be a path or a non-empty list of paths")
+    if isinstance(start_time_seconds, (list, tuple)):
+        start_times = list(start_time_seconds)
+    else:
+        start_times = [start_time_seconds] * len(values)
+    if len(start_times) != len(values):
+        raise OmniClientError("start_time_seconds must contain one value per reference video")
+
+    prepared: list[dict[str, Any]] = []
+    total_duration = 0.0
+    for index, value in enumerate(values):
+        item_start = start_times[index]
+        if isinstance(value, dict):
+            item_start = value.get("start_time_seconds", item_start)
+            value = value.get("path", value.get("video_path", value.get("video_url")))
+        if not isinstance(value, (str, os.PathLike)):
+            raise OmniClientError(
+                f"MiniMax H3 Ref2VA video references require file paths, got item {index}: {type(value)!r}"
+            )
+        source = str(value)
+        meta = _probe_video(source)
+        _validate_reference_video_metadata(meta, index=index, source=source)
+        start = 0.0 if item_start is None else float(item_start)
+        if not math.isfinite(start) or start < 0 or start >= float(meta["duration"]):
+            raise OmniClientError(f"reference video {index} start_time_seconds is outside the source duration")
+        duration = float(meta["duration"]) - start
+        if duration < MINIMAX_H3_MIN_REFERENCE_DURATION:
+            raise OmniClientError(
+                f"reference video {index} must provide at least 2 seconds after start_time_seconds, got {duration:.3f}"
+            )
+        remaining_duration = MINIMAX_H3_MAX_REFERENCE_TOTAL_DURATION - total_duration
+        if duration > remaining_duration:
+            if duration - remaining_duration > MINIMAX_H3_REFERENCE_DURATION_EPSILON:
+                raise OmniClientError("reference videos must be at most 15 seconds in total")
+            duration = remaining_duration
+            if duration < MINIMAX_H3_MIN_REFERENCE_DURATION:
+                raise OmniClientError("reference videos must be at most 15 seconds in total")
+        total_duration += duration
+        width, height = _reference_video_shape(meta["width"], meta["height"])
+        item_workdir = Path(workdir) / f"video_{index}"
+        item_workdir.mkdir(parents=True)
+        prepared_path = _transcode_reference_video(
+            source,
+            target_width=width,
+            target_height=height,
+            workdir=str(item_workdir),
+            start_time_seconds=start,
+            duration_seconds=duration,
+        )
+        prepared.append(
+            {
+                "original_path": source,
+                "prepared_path": prepared_path,
+                "input_has_audio": bool(meta.get("audio_codecs")),
+                "width": width,
+                "height": height,
+                "start_time_seconds": start,
+                "duration_seconds": duration,
+            }
+        )
+    return prepared
+
+
+def load_video_frames(path: str) -> np.ndarray:
+    try:
+        import decord
+    except ImportError:
+        import av
+
+        with av.open(path) as container:
+            frames = [frame.to_ndarray(format="rgb24") for frame in container.decode(video=0)]
+        if not frames:
+            raise OmniClientError(f"video has no frames: {path}")
+        return np.stack(frames)
+
+    reader = decord.VideoReader(path)
+    if len(reader) <= 0:
+        raise OmniClientError(f"video has no frames: {path}")
+    frames = reader.get_batch(list(range(len(reader))))
+    return frames.asnumpy() if hasattr(frames, "asnumpy") else np.asarray(frames)
+
+
+def sample_reference_video_frames(
+    prepared_path: str,
+    *,
+    workdir: str,
+) -> dict[str, Any]:
+    from PIL import Image
+
+    meta = _probe_video(prepared_path)
+    ratio = MINIMAX_H3_FPS / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS
+    indices: list[int] = []
+    cursor = 0.0
+    while True:
+        frame_index = int(round(cursor))
+        if frame_index >= meta["frame_count"]:
+            break
+        if not indices or frame_index > indices[-1]:
+            indices.append(frame_index)
+        cursor += ratio
+    if not indices:
+        raise OmniClientError(f"no frames sampled from {prepared_path}")
+
+    frame_dir = Path(workdir)
+    frame_dir.mkdir(parents=True, exist_ok=True)
+    frames = []
+    for output_index, source_index in enumerate(indices, start=1):
+        output = frame_dir / f"frame_{output_index:06d}.png"
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-loglevel",
+                "error",
+                "-i",
+                prepared_path,
+                "-vf",
+                f"select=eq(n\\,{source_index})",
+                "-vsync",
+                "vfr",
+                "-frames:v",
+                "1",
+                str(output),
+            ],
+            check=True,
+        )
+        frames.append(np.asarray(Image.open(output).convert("RGB")))
+
+    timestamps = [index / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS for index in range(len(indices))]
+    timestamps += [timestamps[-1]] * ((-len(timestamps)) % MINIMAX_H3_QWEN_TEMPORAL_PATCH)
+    block_timestamps = [
+        (timestamps[index] + timestamps[index + MINIMAX_H3_QWEN_TEMPORAL_PATCH - 1]) / 2
+        for index in range(
+            0,
+            len(timestamps),
+            MINIMAX_H3_QWEN_TEMPORAL_PATCH,
+        )
+    ]
+    return {
+        "frames": frames,
+        "block_timestamps": block_timestamps,
+    }
+
+
+def _soundfile_to_waveform(path: str) -> tuple[torch.Tensor, int]:
+    import soundfile as sf
+
+    data, sample_rate = sf.read(path, dtype="float32", always_2d=True)
+    # soundfile is (samples, channels); torchaudio.load is (channels, samples).
+    waveform = torch.from_numpy(data).t().contiguous()
+    return waveform, int(sample_rate)
+
+
+def load_audio_file(path: str) -> tuple[torch.Tensor, int]:
+    """Load an audio file as ``(waveform[C, T] float32, sample_rate)``.
+
+    torchaudio 2.6+ routes ``load`` through TorchCodec, whose wheels do not load
+    on aarch64 with a CPU-only torch (they link CUDA libraries that are absent).
+    Fall back to soundfile; if the container is not libsndfile-readable (e.g.
+    mp3/m4a/mp4), demux to wav with ffmpeg first so any ffmpeg-supported input
+    works at its native sample rate.
+    """
+    try:
+        import torchaudio
+
+        return torchaudio.load(path)
+    except (ImportError, RuntimeError, OSError):
+        pass
+    try:
+        return _soundfile_to_waveform(path)
+    except Exception:
+        import tempfile
+
+        with tempfile.TemporaryDirectory(prefix="minimax_h3_audio_") as tmpdir:
+            wav = str(Path(tmpdir) / "audio.wav")
+            subprocess.run(
+                [
+                    "ffmpeg",
+                    "-y",
+                    "-loglevel",
+                    "error",
+                    "-i",
+                    path,
+                    "-vn",
+                    "-f",
+                    "wav",
+                    wav,
+                ],
+                check=True,
+            )
+            return _soundfile_to_waveform(wav)
+
+
+def load_video_audio(
+    path: str,
+    *,
+    start_time_seconds: float = 0.0,
+    duration_seconds: float | None = None,
+) -> tuple[torch.Tensor, int]:
+    import tempfile
+
+    with tempfile.TemporaryDirectory(prefix="minimax_h3_video_audio_") as tmpdir:
+        output = str(Path(tmpdir) / "audio.wav")
+        command = [
+            "ffmpeg",
+            "-y",
+            "-loglevel",
+            "error",
+            "-ss",
+            f"{float(start_time_seconds):.6f}",
+            "-i",
+            path,
+            "-vn",
+            "-ac",
+            "2",
+            "-ar",
+            "44100",
+            "-f",
+            "wav",
+        ]
+        if duration_seconds is not None:
+            command.extend(["-t", f"{float(duration_seconds):.6f}"])
+        command.append(output)
+        subprocess.run(command, check=True)
+        return load_audio_file(output)
+
+
+__all__ = [
+    "load_audio_file",
+    "load_video_audio",
+    "load_video_frames",
+    "prepare_reference_videos",
+    "sample_reference_video_frames",
+    "validate_reference_audio_files",
+    "validate_reference_audio_waveforms",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/scheduling_minimax_h3_euler_ancestral.py b/vllm_omni/diffusion/models/minimax_h3/scheduling_minimax_h3_euler_ancestral.py
new file mode 100644
index 000000000..9a3a1c9bc
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/scheduling_minimax_h3_euler_ancestral.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import torch
+
+
+def _require_finite_tensor(tensor: torch.Tensor, name: str) -> None:
+    if not bool(torch.isfinite(tensor).all().item()):
+        raise ValueError(f"{name} must be finite")
+
+
+def _validate_unit_timestep(timestep: torch.Tensor, name: str) -> None:
+    if not isinstance(timestep, torch.Tensor):
+        raise ValueError(f"{name} must be a torch.Tensor")
+    if not torch.is_floating_point(timestep):
+        raise ValueError(f"{name} must be a floating point tensor")
+    _require_finite_tensor(timestep, name)
+    out_of_range = (timestep < 0) | (timestep > 1)
+    if bool(out_of_range.any().item()):
+        raise ValueError(f"{name} must be in [0, 1]")
+
+
+def _validate_sigma(value: float, name: str) -> float:
+    sigma = float(value)
+    if not math.isfinite(sigma):
+        raise ValueError(f"{name} must be finite")
+    if sigma < 0.0:
+        raise ValueError(f"{name} must be non-negative")
+    return sigma
+
+
+def _validate_timestep_sigma_pair(
+    timestep: torch.Tensor,
+    sigma_curr: float,
+    name: str,
+) -> float:
+    _validate_unit_timestep(timestep, f"{name}_timestep")
+    sigma = _validate_sigma(sigma_curr, f"{name}_sigma_curr")
+    expected = 1.0 - timestep.detach().to(dtype=torch.float32)
+    actual = torch.full_like(expected, sigma)
+    if not torch.allclose(actual, expected, rtol=1e-5, atol=1e-5):
+        raise ValueError(f"{name}_sigma_curr must equal 1 - {name}_timestep")
+    return sigma
+
+
+def minimax_h3_rf_v_to_x0(
+    xt: torch.Tensor,
+    v: torch.Tensor,
+    timestep: torch.Tensor,
+) -> torch.Tensor:
+    if xt.shape != v.shape:
+        raise ValueError(f"xt and v shapes must match, got {xt.shape} vs {v.shape}")
+    if not torch.is_floating_point(xt):
+        raise ValueError("xt must be a floating point tensor")
+    if not torch.is_floating_point(v):
+        raise ValueError("v must be a floating point tensor")
+    _require_finite_tensor(xt, "xt")
+    _require_finite_tensor(v, "v")
+    _validate_unit_timestep(timestep, "timestep")
+    cond_t = timestep.to(device=xt.device, dtype=xt.dtype)
+    while cond_t.ndim < xt.ndim:
+        cond_t = cond_t.unsqueeze(-1)
+    sigma_t = 1 - cond_t
+    x0 = xt + sigma_t * v
+    _require_finite_tensor(x0, "x0")
+    return x0
+
+
+def minimax_h3_euler_eta0_step(
+    state: torch.Tensor,
+    denoised: torch.Tensor,
+    *,
+    sigma_curr: float,
+    sigma_next: float,
+) -> torch.Tensor:
+    if state.shape != denoised.shape:
+        raise ValueError(f"state and denoised shapes must match, got {state.shape} vs {denoised.shape}")
+    if not torch.is_floating_point(state):
+        raise ValueError("state must be a floating point tensor")
+    if not torch.is_floating_point(denoised):
+        raise ValueError("denoised must be a floating point tensor")
+    _require_finite_tensor(state, "state")
+    _require_finite_tensor(denoised, "denoised")
+    sigma_curr = _validate_sigma(sigma_curr, "sigma_curr")
+    sigma_next = _validate_sigma(sigma_next, "sigma_next")
+    if sigma_curr == 0.0:
+        if sigma_next != 0.0:
+            raise ValueError("sigma_next must be 0 when sigma_curr is 0")
+        return state
+    compute_dtype = torch.float32
+    if state.dtype not in (torch.float16, torch.bfloat16):
+        compute_dtype = state.dtype
+    sigma_curr_t = state.new_tensor(sigma_curr, dtype=compute_dtype)
+    sigma_next_t = state.new_tensor(sigma_next, dtype=compute_dtype)
+    sigma_ratio = sigma_next_t / sigma_curr_t
+    out = sigma_ratio * state.to(dtype=compute_dtype) + (1.0 - sigma_ratio) * denoised.to(dtype=compute_dtype)
+    out = out.to(dtype=state.dtype)
+    _require_finite_tensor(out, "euler_eta0_step output")
+    return out
+
+
+class MiniMaxH3EulerAncestralEta0SchedulerAdapter:
+    def __init__(self, **config: Any) -> None:
+        if config:
+            raise ValueError(f"{type(self).__name__} does not accept config fields: {sorted(config)}")
+
+    def set_shift(self, _flow_shift: float) -> None:
+        """Ignore flow shift, matching the previous loader-specific path."""
+
+    def step_denoising(
+        self,
+        *,
+        input_visual_latent: torch.Tensor,
+        input_audio_latent: torch.Tensor,
+        timestep: torch.Tensor,
+        noise_pred_visual: torch.Tensor,
+        noise_pred_audio: torch.Tensor,
+        sigma_curr: float,
+        sigma_next: float,
+        video_timestep: torch.Tensor | None = None,
+        audio_timestep: torch.Tensor | None = None,
+        video_sigma_curr: float | None = None,
+        video_sigma_next: float | None = None,
+        audio_sigma_curr: float | None = None,
+        audio_sigma_next: float | None = None,
+    ) -> dict[str, torch.Tensor]:
+        visual_timestep = timestep if video_timestep is None else video_timestep
+        audio_timestep = timestep if audio_timestep is None else audio_timestep
+        visual_sigma_curr = sigma_curr if video_sigma_curr is None else video_sigma_curr
+        visual_sigma_next = sigma_next if video_sigma_next is None else video_sigma_next
+        audio_sigma_curr = sigma_curr if audio_sigma_curr is None else audio_sigma_curr
+        audio_sigma_next = sigma_next if audio_sigma_next is None else audio_sigma_next
+        visual_sigma_curr = _validate_timestep_sigma_pair(
+            visual_timestep,
+            visual_sigma_curr,
+            "video",
+        )
+        audio_sigma_curr = _validate_timestep_sigma_pair(
+            audio_timestep,
+            audio_sigma_curr,
+            "audio",
+        )
+
+        denoised_visual = minimax_h3_rf_v_to_x0(
+            input_visual_latent,
+            noise_pred_visual,
+            visual_timestep,
+        )
+        denoised_audio = minimax_h3_rf_v_to_x0(
+            input_audio_latent,
+            noise_pred_audio,
+            audio_timestep,
+        )
+        return {
+            "output_visual_latent": minimax_h3_euler_eta0_step(
+                input_visual_latent,
+                denoised_visual,
+                sigma_curr=visual_sigma_curr,
+                sigma_next=visual_sigma_next,
+            ),
+            "output_audio_latent": minimax_h3_euler_eta0_step(
+                input_audio_latent,
+                denoised_audio,
+                sigma_curr=audio_sigma_curr,
+                sigma_next=audio_sigma_next,
+            ),
+        }
+
+
+EntryClass = MiniMaxH3EulerAncestralEta0SchedulerAdapter
+
+__all__ = [
+    "MiniMaxH3EulerAncestralEta0SchedulerAdapter",
+    "minimax_h3_euler_eta0_step",
+    "minimax_h3_rf_v_to_x0",
+]
diff --git a/vllm_omni/diffusion/models/minimax_h3/time_request.py b/vllm_omni/diffusion/models/minimax_h3/time_request.py
new file mode 100644
index 000000000..08d8fdfcf
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/time_request.py
@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+
+def _align_frame_count(frame_count: int) -> int:
+    """Snap ``frame_count`` up to the MiniMax H3 17n+5 frame boundary."""
+    if frame_count <= 0:
+        return 1
+    current = int(frame_count)
+    while current % 17 != 5:
+        current += 1
+    return current
+
+
+def _video_latent_t(frame_count: int) -> int:
+    if frame_count <= 5:
+        return 2
+    return ((int(frame_count) - 5) // 17) * 5 + 2
+
+
+def _frame_count_from_video_latent_t(out_t: int) -> int:
+    if out_t == 1:
+        return 1
+    if out_t < 2 or (out_t - 2) % 5 != 0:
+        raise ValueError("MiniMax H3 video latent T must be 1 or match 5n+2")
+    return 17 * ((int(out_t) - 2) // 5) + 5
+
+
+def _audio_latent_t(duration_seconds: float) -> int:
+    # Rounding happens at the 40 Hz audio latent boundary.
+    return int(round(float(duration_seconds) * 40.0))
+
+
+def _time_shift_sigmas(
+    *,
+    num_steps: int = 50,
+    shift_scale: float = 6.0,
+) -> list[float]:
+    if shift_scale <= 0:
+        raise ValueError("MiniMax H3 shift_scale must be > 0")
+    if num_steps <= 0:
+        raise ValueError("MiniMax H3 num_steps must be > 0")
+
+    import torch
+
+    # The rectified-flow sigma range is fixed at [1.0, 0.0].
+    base = torch.linspace(
+        1.0,
+        0.0,
+        int(num_steps),
+        device="cpu",
+        dtype=torch.float32,
+    )
+    shifted = float(shift_scale) * base / (1 + (float(shift_scale) - 1) * base)
+    shifted, _ = torch.unique_consecutive(shifted, return_counts=True)
+    # A one-point request is still exactly one point.  Normal serving uses
+    # multiple points, but preserving the requested cardinality keeps
+    # ``num_inference_steps`` the sole schedule-size control.
+    if num_steps > 1 and shifted[-1].item() > 0.0:
+        shifted = torch.cat([shifted, torch.tensor([0.0], dtype=shifted.dtype)])
+    return [float(value) for value in shifted.tolist()]
+
+
+class MiniMaxH3ShapePlanner:
+    """Compute MiniMax H3 frame, latent-shape, and time-shift values."""
+
+    def align_frame_count(self, frame_count: int) -> int:
+        return _align_frame_count(frame_count)
+
+    def video_latent_t(self, frame_count: int) -> int:
+        return _video_latent_t(frame_count)
+
+    def frame_count_from_video_latent_t(self, out_t: int) -> int:
+        return _frame_count_from_video_latent_t(out_t)
+
+    def audio_latent_t(self, duration_seconds: float) -> int:
+        return _audio_latent_t(duration_seconds)
+
+    def time_shift_sigmas(
+        self,
+        *,
+        num_steps: int = 50,
+        shift_scale: float = 6.0,
+    ) -> list[float]:
+        return _time_shift_sigmas(
+            num_steps=num_steps,
+            shift_scale=shift_scale,
+        )
+
+
+MINIMAX_H3_SHAPE_PLANNER = MiniMaxH3ShapePlanner()
+
+
+def minimax_h3_align_frame_count(frame_count: int) -> int:
+    return MINIMAX_H3_SHAPE_PLANNER.align_frame_count(frame_count)
+
+
+def minimax_h3_frame_count_from_video_latent_t(out_t: int) -> int:
+    return MINIMAX_H3_SHAPE_PLANNER.frame_count_from_video_latent_t(out_t)
+
+
+def minimax_h3_time_shift_sigmas(
+    *,
+    num_steps: int = 50,
+    shift_scale: float = 6.0,
+) -> list[float]:
+    return MINIMAX_H3_SHAPE_PLANNER.time_shift_sigmas(
+        num_steps=num_steps,
+        shift_scale=shift_scale,
+    )
diff --git a/vllm_omni/diffusion/models/minimax_h3/vae.py b/vllm_omni/diffusion/models/minimax_h3/vae.py
new file mode 100644
index 000000000..e28450c90
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/vae.py
@@ -0,0 +1,415 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 remote-code VAE adapters and exact latent contracts."""
+
+from __future__ import annotations
+
+import importlib
+import json
+from contextlib import AbstractContextManager
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from PIL import Image
+from transformers.dynamic_module_utils import get_class_from_dynamic_module
+
+from vllm_omni.diffusion.distributed.autoencoders.distributed_vae_executor import (
+    DistributedVaeMixin,
+)
+from vllm_omni.diffusion.distributed.parallel_state import get_dit_group
+from vllm_omni.diffusion.offloader.module_residency import PinnedModuleStager
+
+from .packed_tokens import minimax_h3_patchify_video_latent
+
+MINIMAX_H3_KEYFRAME_ENCODE_SEED = 42
+MINIMAX_H3_AUDIO_SAMPLE_RATE = 32000
+MINIMAX_H3_AUDIO_CHANNELS = 2
+
+
+def _load_component_config(component_path: str) -> dict[str, Any]:
+    config_path = Path(component_path) / "config.json"
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+    channels = int(config["latent_channels"])
+    for key in ("latents_mean", "latents_std"):
+        values = config.get(key)
+        if not isinstance(values, list) or len(values) != channels:
+            raise ValueError(f"{config_path}: {key} must contain {channels} values")
+    return config
+
+
+def _load_remote_component(
+    component_path: str,
+    config: dict[str, Any],
+) -> nn.Module:
+    auto_map = config.get("auto_map") or {}
+    class_reference = auto_map.get("AutoModel")
+    if not isinstance(class_reference, str):
+        raise ValueError(f"{component_path}/config.json must define auto_map.AutoModel")
+    component_cls = get_class_from_dynamic_module(
+        class_reference,
+        component_path,
+    )
+    # Build on the host regardless of the ambient default device. Online
+    # quantization wraps pipeline construction in a `with torch.device(<accel>)`
+    # block for the DiT's quantized linears, and the checkpoint's own VAE code
+    # builds constants with ops that have no accelerator kernel (BigVGAN's
+    # anti-aliasing filters call torch.kaiser_window). Callers place the module
+    # explicitly right after this returns, so nothing depends on the context.
+    with torch.device("cpu"):
+        return component_cls.from_pretrained(component_path)
+
+
+class _AudioVAEDeterminismContext(AbstractContextManager):
+    def __enter__(self):
+        backends = torch.backends
+        self._saved = (
+            backends.cuda.matmul.allow_tf32,
+            backends.cudnn.allow_tf32,
+            backends.cudnn.benchmark,
+            backends.cudnn.deterministic,
+            backends.cudnn.enabled,
+            backends.cuda.flash_sdp_enabled(),
+            backends.cuda.mem_efficient_sdp_enabled(),
+            backends.cuda.math_sdp_enabled(),
+        )
+        backends.cuda.matmul.allow_tf32 = False
+        backends.cudnn.allow_tf32 = False
+        backends.cudnn.benchmark = False
+        backends.cudnn.deterministic = True
+        backends.cudnn.enabled = False
+        backends.cuda.enable_flash_sdp(False)
+        backends.cuda.enable_mem_efficient_sdp(False)
+        backends.cuda.enable_math_sdp(True)
+        return self
+
+    def __exit__(self, exc_type, exc, traceback):
+        backends = torch.backends
+        (
+            backends.cuda.matmul.allow_tf32,
+            backends.cudnn.allow_tf32,
+            backends.cudnn.benchmark,
+            backends.cudnn.deterministic,
+            backends.cudnn.enabled,
+            flash,
+            memory_efficient,
+            math_sdp,
+        ) = self._saved
+        backends.cuda.enable_flash_sdp(flash)
+        backends.cuda.enable_mem_efficient_sdp(memory_efficient)
+        backends.cuda.enable_math_sdp(math_sdp)
+        return False
+
+
+class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
+    """Adapter around the checkpoint's native parallel-tiled video VAE."""
+
+    def __init__(
+        self,
+        component_path: str,
+        *,
+        device: torch.device,
+        load_device: torch.device | None = None,
+    ) -> None:
+        super().__init__()
+        self._device_target = device
+        self.config_dict = _load_component_config(component_path)
+        self.remote = _load_remote_component(
+            component_path,
+            self.config_dict,
+        )
+        # Match the reference loader contract: video VAE weights stay FP32.
+        # Keyframe encoding is numerically sensitive to first casting the
+        # checkpoint through FP16; decode still runs under FP16 autocast.
+        initial_device = load_device or device
+        self.remote.eval().to(device=initial_device, dtype=torch.float32)
+        self._stager = None
+        if initial_device.type == "cpu" and device.type not in ("cpu", "meta"):
+            self._stager = PinnedModuleStager(
+                self.remote,
+                device,
+                pin_memory=True,
+            )
+        self.model = self.remote.model
+        self.use_tiling = True
+        self.use_slicing = False
+        self.parallel_size = 1
+        self.device_module = torch.get_device_module()
+
+    def load_to_device(self) -> None:
+        if self._stager is not None:
+            self._stager.load()
+        else:
+            self.remote.to(self._device_target)
+
+    def offload_to_cpu(self) -> None:
+        if self._stager is not None:
+            self._stager.offload()
+        else:
+            self.remote.to("cpu")
+            torch.accelerator.empty_cache()
+
+    def set_parallel_size(
+        self,
+        parallel_size: int,
+        mode: str = "tile",
+    ) -> None:
+        if mode != "tile":
+            raise ValueError(f"MiniMax H3 VAE supports its native tile parallel mode only, got {mode!r}")
+        group = get_dit_group()
+        world_size = dist.get_world_size(group)
+        rank = dist.get_rank(group)
+        parallel_size = int(parallel_size)
+        if parallel_size not in (1, world_size):
+            raise ValueError(
+                "MiniMax H3 native VAE patch parallelism currently requires "
+                "vae_patch_parallel_size=1 or the full DiT group size "
+                f"({world_size}), got {parallel_size}"
+            )
+        self.parallel_size = parallel_size
+        enabled = parallel_size > 1
+
+        package = self.remote.__class__.__module__.rsplit(".", 1)[0]
+        parallel_module = importlib.import_module(f"{package}.parallel")
+        state = parallel_module.get_parallel_state()
+        state.clear()
+        state.update(
+            group_size=parallel_size,
+            group_rank=rank if enabled else 0,
+            local_process_group=group if enabled else None,
+            sp_size=parallel_size,
+            sp_rank=rank if enabled else 0,
+            sp_enabled=enabled,
+            sp_process_group=group if enabled else None,
+            tp_size=1,
+            tp_rank=0,
+        )
+        self.model.parallel_tiling = enabled
+
+    def is_distributed_enabled(self) -> bool:
+        return self.parallel_size > 1 and dist.is_initialized()
+
+    @torch.inference_mode()
+    def encode_image(self, image: Image.Image) -> torch.Tensor:
+        previous_parallel = self.model.parallel_tiling
+        self.model.parallel_tiling = False
+        parameter = next(self.parameters())
+        previous_dtype = parameter.dtype
+        if previous_dtype != torch.float32:
+            self.to(torch.float32)
+        devices = [parameter.device] if parameter.device.type != "cpu" else []
+        try:
+            with torch.random.fork_rng(devices=devices, device_type=parameter.device.type):
+                torch.default_generator.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
+                for device in devices:
+                    with self.device_module.device(device):
+                        self.device_module.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
+                latent = self.model.encode_images(
+                    image,
+                    use_fp16_latent=True,
+                )[0]
+        finally:
+            self.model.parallel_tiling = previous_parallel
+            if previous_dtype != torch.float32:
+                self.to(previous_dtype)
+
+        # Match the reference contract exactly: normalization and patchify
+        # happen on CPU in FP32 after the sampled encode. The condition noise
+        # path is sensitive enough that doing these elementwise operations on
+        # CUDA can noticeably change the final conditioned video.
+        latent = latent.float().cpu()
+        if latent.ndim == 4:
+            latent = latent[None]
+        channels = int(self.config_dict["latent_channels"])
+        mean = torch.tensor(
+            self.config_dict["latents_mean"],
+        ).view(1, channels, 1, 1, 1)
+        std = torch.tensor(
+            self.config_dict["latents_std"],
+        ).view(1, channels, 1, 1, 1)
+        return minimax_h3_patchify_video_latent(
+            (latent - mean) / std,
+            patch_size=(1, 2, 2),
+        ).float()
+
+    @torch.inference_mode()
+    def encode_video(
+        self,
+        frames: Any,
+    ) -> tuple[torch.Tensor, tuple[int, int, int]]:
+        parameter = next(self.parameters())
+        previous_dtype = parameter.dtype
+        if previous_dtype != torch.float32:
+            self.to(torch.float32)
+        devices = [parameter.device] if parameter.device.type != "cpu" else []
+        try:
+            with torch.random.fork_rng(devices=devices, device_type=parameter.device.type):
+                torch.default_generator.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
+                for device in devices:
+                    with self.device_module.device(device):
+                        self.device_module.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
+                latent = self.model.encode_videos(
+                    frames,
+                    use_fp16_latent=True,
+                )[0]
+        finally:
+            if previous_dtype != torch.float32:
+                self.to(previous_dtype)
+
+        latent = latent.float().cpu()
+        if latent.ndim == 4:
+            latent = latent[None]
+        channels = int(self.config_dict["latent_channels"])
+        if latent.ndim != 5 or int(latent.shape[1]) != channels:
+            raise ValueError(f"unexpected reference video latent shape {tuple(latent.shape)}")
+        shape = (
+            int(latent.shape[2]),
+            int(latent.shape[3]),
+            int(latent.shape[4]),
+        )
+        mean = torch.tensor(
+            self.config_dict["latents_mean"],
+        ).view(1, channels, 1, 1, 1)
+        std = torch.tensor(
+            self.config_dict["latents_std"],
+        ).view(1, channels, 1, 1, 1)
+        rows = minimax_h3_patchify_video_latent(
+            (latent - mean) / std,
+            patch_size=(1, 2, 2),
+        ).float()
+        return rows, shape
+
+    @torch.inference_mode()
+    def decode_latent(self, latent: torch.Tensor) -> torch.Tensor:
+        channels = int(self.config_dict["latent_channels"])
+        mean = torch.tensor(
+            self.config_dict["latents_mean"],
+            device=latent.device,
+            dtype=latent.dtype,
+        ).view(1, channels, 1, 1, 1)
+        std = torch.tensor(
+            self.config_dict["latents_std"],
+            device=latent.device,
+            dtype=latent.dtype,
+        ).view(1, channels, 1, 1, 1)
+        decoded = self.model.decode_base(latent * std + mean)
+        frames = self.model.processor.revert_tensor(decoded)
+        if frames.ndim == 4:
+            frames = frames.unsqueeze(0).transpose(1, 2)
+        if frames.ndim != 5:
+            raise ValueError(f"unexpected decoded video shape {tuple(frames.shape)}")
+        return frames.float()
+
+
+class MiniMaxH3AudioVAE(nn.Module):
+    def __init__(
+        self,
+        component_path: str,
+        *,
+        device: torch.device,
+        load_device: torch.device | None = None,
+    ) -> None:
+        super().__init__()
+        self._device_target = device
+        self.config_dict = _load_component_config(component_path)
+        self.remote = _load_remote_component(
+            component_path,
+            self.config_dict,
+        )
+        # The checkpoint's audio VAE contract is FP32 for both reference
+        # encoding and waveform decoding.
+        initial_device = load_device or device
+        self.remote.eval().to(device=initial_device, dtype=torch.float32)
+        self._stager = None
+        if initial_device.type == "cpu" and device.type not in ("cpu", "meta"):
+            self._stager = PinnedModuleStager(
+                self.remote,
+                device,
+                pin_memory=True,
+            )
+        self.model = self.remote.model
+        self.sample_rate = int(self.config_dict["sample_rate"])
+
+    def load_to_device(self) -> None:
+        if self._stager is not None:
+            self._stager.load()
+        else:
+            self.remote.to(self._device_target)
+
+    def offload_to_cpu(self) -> None:
+        if self._stager is not None:
+            self._stager.offload()
+        else:
+            self.remote.to("cpu")
+            torch.accelerator.empty_cache()
+
+    @torch.inference_mode()
+    def encode_waveform(
+        self,
+        waveform: torch.Tensor,
+        sample_rate: int,
+    ) -> tuple[torch.Tensor, int]:
+        import torchaudio
+
+        waveform = waveform.float()
+        if waveform.ndim == 1:
+            waveform = waveform[None]
+        if int(sample_rate) != MINIMAX_H3_AUDIO_SAMPLE_RATE:
+            waveform = torchaudio.transforms.Resample(
+                int(sample_rate),
+                MINIMAX_H3_AUDIO_SAMPLE_RATE,
+            )(waveform)
+        if waveform.shape[0] < MINIMAX_H3_AUDIO_CHANNELS:
+            waveform = waveform.repeat(
+                MINIMAX_H3_AUDIO_CHANNELS,
+                1,
+            )
+        waveform = waveform[:MINIMAX_H3_AUDIO_CHANNELS]
+        device = next(self.model.parameters()).device
+        waveform = waveform.to(device)
+
+        with _AudioVAEDeterminismContext():
+            audio = self.model.preprocess(
+                waveform.unsqueeze(1),
+                MINIMAX_H3_AUDIO_SAMPLE_RATE,
+            )
+            latent = self.model.encoder(audio)
+            if bool(getattr(self.model, "attn_proj", False)):
+                latent = self.model.pre_block(latent.transpose(1, 2)).transpose(1, 2)
+            latent = self.model.mean_proj(latent).float().cpu()
+
+        channels = int(self.config_dict["latent_channels"])
+        if latent.shape[-1] != channels:
+            if latent.shape[1] != channels:
+                raise ValueError(f"cannot canonicalize audio latent {tuple(latent.shape)}")
+            latent = latent.transpose(1, 2).contiguous()
+        mean = torch.tensor(
+            self.config_dict["latents_mean"],
+        ).view(1, 1, channels)
+        std = torch.tensor(
+            self.config_dict["latents_std"],
+        ).view(1, 1, channels)
+        rows = ((latent - mean) / std).reshape(-1, channels)
+        return rows.float(), int(latent.shape[1])
+
+    @torch.inference_mode()
+    def decode_latent(self, latent: torch.Tensor) -> torch.Tensor:
+        channels = int(self.config_dict["latent_channels"])
+        mean = torch.tensor(
+            self.config_dict["latents_mean"],
+            device=latent.device,
+            dtype=latent.dtype,
+        ).view(1, channels, 1)
+        std = torch.tensor(
+            self.config_dict["latents_std"],
+            device=latent.device,
+            dtype=latent.dtype,
+        ).view(1, channels, 1)
+        waveform = self.remote.decode(latent * std + mean)
+        if waveform.ndim != 3 or waveform.shape[1] != 1:
+            raise ValueError(f"unexpected decoded audio shape {tuple(waveform.shape)}")
+        return waveform.permute(1, 0, 2).contiguous().float()
+
+
+__all__ = ["MiniMaxH3AudioVAE", "MiniMaxH3VideoVAE"]
diff --git a/vllm_omni/diffusion/models/mistral_encoder/mistral_encoder.py b/vllm_omni/diffusion/models/mistral_encoder/mistral_encoder.py
index abeacff2a..518453a17 100644
--- a/vllm_omni/diffusion/models/mistral_encoder/mistral_encoder.py
+++ b/vllm_omni/diffusion/models/mistral_encoder/mistral_encoder.py
@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import logging
 from collections.abc import Iterable
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import torch
 import torch.nn as nn
@@ -37,6 +37,9 @@ from vllm.model_executor.layers.linear import (
 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead, VocabParallelEmbedding
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
+if TYPE_CHECKING:
+    from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -118,6 +121,7 @@ class MistralEncoderAttention(nn.Module):
         num_kv_heads: int,
         head_dim: int,
         prefix: str = "",
+        quant_config: QuantizationConfig | None = None,
     ):
         super().__init__()
         self.hidden_size = hidden_size
@@ -140,6 +144,7 @@ class MistralEncoderAttention(nn.Module):
             total_num_heads=num_heads,
             total_num_kv_heads=num_kv_heads,
             bias=False,
+            quant_config=quant_config,
             prefix=f"{prefix}.qkv_proj",
         )
 
@@ -147,6 +152,7 @@ class MistralEncoderAttention(nn.Module):
             input_size=num_heads * head_dim,
             output_size=hidden_size,
             bias=False,
+            quant_config=quant_config,
             prefix=f"{prefix}.o_proj",
         )
 
@@ -194,18 +200,21 @@ class MistralEncoderMLP(nn.Module):
         hidden_size: int,
         intermediate_size: int,
         prefix: str = "",
+        quant_config: QuantizationConfig | None = None,
     ):
         super().__init__()
         self.gate_up_proj = MergedColumnParallelLinear(
             input_size=hidden_size,
             output_sizes=[intermediate_size, intermediate_size],
             bias=False,
+            quant_config=quant_config,
             prefix=f"{prefix}.gate_up_proj",
         )
         self.down_proj = RowParallelLinear(
             input_size=intermediate_size,
             output_size=hidden_size,
             bias=False,
+            quant_config=quant_config,
             prefix=f"{prefix}.down_proj",
         )
         self.act_fn = SiluAndMul()
@@ -227,6 +236,7 @@ class MistralEncoderLayer(nn.Module):
         intermediate_size: int,
         rms_norm_eps: float,
         prefix: str = "",
+        quant_config: QuantizationConfig | None = None,
     ):
         super().__init__()
         self.self_attn = MistralEncoderAttention(
@@ -235,11 +245,13 @@ class MistralEncoderLayer(nn.Module):
             num_kv_heads=num_kv_heads,
             head_dim=head_dim,
             prefix=f"{prefix}.self_attn",
+            quant_config=quant_config,
         )
         self.mlp = MistralEncoderMLP(
             hidden_size=hidden_size,
             intermediate_size=intermediate_size,
             prefix=f"{prefix}.mlp",
+            quant_config=quant_config,
         )
         self.input_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
         self.post_attention_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps)
@@ -295,7 +307,12 @@ class MistralEncoderModel(nn.Module):
     parallel layers for TP but simple SDPA for attention (no PagedAttention).
     """
 
-    def __init__(self, config: PretrainedConfig, prefix: str = ""):
+    def __init__(
+        self,
+        config: PretrainedConfig,
+        prefix: str = "",
+        quant_config: QuantizationConfig | None = None,
+    ):
         super().__init__()
         self._processor = None
         self._system_message_t2i: str | None = None
@@ -339,6 +356,7 @@ class MistralEncoderModel(nn.Module):
         m = self.language_model.model
 
         m.embed_tokens = VocabParallelEmbedding(self.vocab_size, self.hidden_size)
+        layer_prefix_root = f"{prefix}.language_model.model.layers" if prefix else "language_model.model.layers"
 
         m.layers = nn.ModuleList(
             [
@@ -349,7 +367,8 @@ class MistralEncoderModel(nn.Module):
                     head_dim=self.head_dim,
                     intermediate_size=self.intermediate_size,
                     rms_norm_eps=self.rms_norm_eps,
-                    prefix=f"language_model.model.layers.{i}",
+                    prefix=f"{layer_prefix_root}.{i}",
+                    quant_config=quant_config,
                 )
                 for i in range(self.num_layers)
             ]
diff --git a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
index 986c2ef86..0aeb8b85c 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py
@@ -48,7 +48,7 @@ from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, spli
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.worker.input_batch import InputBatch
-    from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+    from vllm_omni.diffusion.worker.utils import StepRequestState
 
 from vllm_omni.model_executor.model_loader.weight_utils import (
     download_weights_from_hf_specific,
@@ -309,9 +309,8 @@ class QwenImagePipeline(
             model, subfolder="scheduler", local_files_only=local_files_only
         )
         # ``from_pretrained_with_prefetch`` re-prefetches and retries on a
-        # half-written cache (missing-shard ``OSError`` *and* the default
-        # -config size-mismatch ``RuntimeError`` that ``retry_on_missing_shard``
-        # could not recover) instead of crashing the worker.
+        # half-written cache (missing-shard ``OSError`` and the default
+        # -config size-mismatch ``RuntimeError``) instead of crashing the worker.
         self.text_encoder = from_pretrained_with_prefetch(
             Qwen2_5_VLForConditionalGeneration.from_pretrained,
             model,
@@ -771,9 +770,9 @@ class QwenImagePipeline(
 
     def prepare_encode(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         **kwargs: Any,
-    ) -> "DiffusionRequestState":
+    ) -> "StepRequestState":
         """Populate *state* with encoded prompts, latents, timesteps, and CFG config."""
         sampling = state.sampling
         prompt, negative_prompt = self._extract_prompts([state.prompt] if state.prompt is not None else [])
@@ -960,7 +959,7 @@ class QwenImagePipeline(
 
     def step_scheduler(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         noise_pred: torch.Tensor,
         **kwargs: Any,
     ) -> None:
@@ -981,7 +980,7 @@ class QwenImagePipeline(
 
     def post_decode(
         self,
-        state: "DiffusionRequestState",
+        state: "StepRequestState",
         **kwargs: Any,
     ) -> DiffusionOutput:
         """Decode final latents from *state*."""
diff --git a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
index 3d6e937c7..3f0d16002 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
@@ -263,9 +263,8 @@ class QwenImageEditPipeline(
             model, subfolder="scheduler", local_files_only=local_files_only
         )
         # ``from_pretrained_with_prefetch`` re-prefetches and retries on a
-        # half-written cache (missing-shard ``OSError`` *and* the default
-        # -config size-mismatch ``RuntimeError`` that ``retry_on_missing_shard``
-        # could not recover) instead of crashing the worker.
+        # half-written cache (missing-shard ``OSError`` and the default
+        # -config size-mismatch ``RuntimeError``) instead of crashing the worker.
         self.text_encoder = from_pretrained_with_prefetch(
             Qwen2_5_VLForConditionalGeneration.from_pretrained,
             model,
diff --git a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit_plus.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit_plus.py
index a11637163..8b5c4e3b1 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit_plus.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit_plus.py
@@ -230,9 +230,8 @@ class QwenImageEditPlusPipeline(
             model, subfolder="scheduler", local_files_only=local_files_only
         )
         # ``from_pretrained_with_prefetch`` re-prefetches and retries on a
-        # half-written cache (missing-shard ``OSError`` *and* the default
-        # -config size-mismatch ``RuntimeError`` that ``retry_on_missing_shard``
-        # could not recover) instead of crashing the worker.
+        # half-written cache (missing-shard ``OSError`` and the default
+        # -config size-mismatch ``RuntimeError``) instead of crashing the worker.
         self.text_encoder = from_pretrained_with_prefetch(
             Qwen2_5_VLForConditionalGeneration.from_pretrained,
             model,
diff --git a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_layered.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_layered.py
index e2fe67976..830c4d6c1 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_layered.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_layered.py
@@ -237,9 +237,8 @@ class QwenImageLayeredPipeline(
             model, subfolder="scheduler", local_files_only=local_files_only
         )
         # ``from_pretrained_with_prefetch`` re-prefetches and retries on a
-        # half-written cache (missing-shard ``OSError`` *and* the default
-        # -config size-mismatch ``RuntimeError`` that ``retry_on_missing_shard``
-        # could not recover) instead of crashing the worker.
+        # half-written cache (missing-shard ``OSError`` and the default
+        # -config size-mismatch ``RuntimeError``) instead of crashing the worker.
         self.text_encoder = from_pretrained_with_prefetch(
             Qwen2_5_VLForConditionalGeneration.from_pretrained,
             model,
diff --git a/vllm_omni/diffusion/models/schedulers/__init__.py b/vllm_omni/diffusion/models/schedulers/__init__.py
index e683ed272..11aedcb1d 100644
--- a/vllm_omni/diffusion/models/schedulers/__init__.py
+++ b/vllm_omni/diffusion/models/schedulers/__init__.py
@@ -2,11 +2,15 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
 from vllm_omni.diffusion.models.schedulers.scheduling_dmd2_euler import DMD2EulerScheduler
+from vllm_omni.diffusion.models.schedulers.scheduling_flow_match_euler_discrete import (
+    FlowMatchEulerDiscreteScheduler,
+)
 from vllm_omni.diffusion.models.schedulers.scheduling_flow_unipc_multistep import (
     FlowUniPCMultistepScheduler,
 )
 
 __all__ = [
     "DMD2EulerScheduler",
+    "FlowMatchEulerDiscreteScheduler",
     "FlowUniPCMultistepScheduler",
 ]
diff --git a/vllm_omni/diffusion/models/schedulers/scheduling_flow_match_euler_discrete.py b/vllm_omni/diffusion/models/schedulers/scheduling_flow_match_euler_discrete.py
new file mode 100644
index 000000000..8aa7d3a00
--- /dev/null
+++ b/vllm_omni/diffusion/models/schedulers/scheduling_flow_match_euler_discrete.py
@@ -0,0 +1,660 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# Originally from https://github.com/huggingface/diffusers/blob/v0.39.0/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py
+# Copyright 2025 Stability AI, Katherine Crowson and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Flow Match Euler scheduler copied from Diffusers v0.39.0.
+
+Modified by vLLM-Omni contributors for local integration and RNG compatibility.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, is_scipy_available, logging
+from diffusers.utils.torch_utils import randn_tensor
+
+if is_scipy_available():
+    import scipy.stats
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class FlowMatchEulerDiscreteSchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+
+
+class FlowMatchEulerDiscreteScheduler(SchedulerMixin, ConfigMixin):
+    """
+    Euler scheduler.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        shift (`float`, defaults to 1.0):
+            The shift value for the timestep schedule.
+        use_dynamic_shifting (`bool`, defaults to False):
+            Whether to apply timestep shifting on-the-fly based on the image resolution.
+        base_shift (`float`, defaults to 0.5):
+            Value to stabilize image generation. Increasing `base_shift` reduces variation and image is more consistent
+            with desired output.
+        max_shift (`float`, defaults to 1.15):
+            Value change allowed to latent vectors. Increasing `max_shift` encourages more variation and image may be
+            more exaggerated or stylized.
+        base_image_seq_len (`int`, defaults to 256):
+            The base image sequence length.
+        max_image_seq_len (`int`, defaults to 4096):
+            The maximum image sequence length.
+        invert_sigmas (`bool`, defaults to False):
+            Whether to invert the sigmas.
+        shift_terminal (`float`, defaults to None):
+            The end value of the shifted timestep schedule.
+        use_karras_sigmas (`bool`, defaults to False):
+            Whether to use Karras sigmas for step sizes in the noise schedule during sampling.
+        use_exponential_sigmas (`bool`, defaults to False):
+            Whether to use exponential sigmas for step sizes in the noise schedule during sampling.
+        use_beta_sigmas (`bool`, defaults to False):
+            Whether to use beta sigmas for step sizes in the noise schedule during sampling.
+        time_shift_type (`str`, defaults to "exponential"):
+            The type of dynamic resolution-dependent timestep shifting to apply. Either "exponential" or "linear".
+        stochastic_sampling (`bool`, defaults to False):
+            Whether to use stochastic sampling.
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,
+        use_dynamic_shifting: bool = False,
+        base_shift: float | None = 0.5,
+        max_shift: float | None = 1.15,
+        base_image_seq_len: int = 256,
+        max_image_seq_len: int = 4096,
+        invert_sigmas: bool = False,
+        shift_terminal: float = None,
+        use_karras_sigmas: bool = False,
+        use_exponential_sigmas: bool = False,
+        use_beta_sigmas: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "exponential",
+        stochastic_sampling: bool = False,
+    ):
+        if self.config.use_beta_sigmas and not is_scipy_available():
+            raise ImportError("Make sure to install scipy if you want to use beta sigmas.")
+        if (
+            sum(
+                [
+                    self.config.use_beta_sigmas,
+                    self.config.use_exponential_sigmas,
+                    self.config.use_karras_sigmas,
+                ]
+            )
+            > 1
+        ):
+            raise ValueError(
+                "Only one of `config.use_beta_sigmas`, `config.use_exponential_sigmas`, "
+                "`config.use_karras_sigmas` can be used."
+            )
+        if time_shift_type not in {"exponential", "linear"}:
+            raise ValueError("`time_shift_type` must either be 'exponential' or 'linear'.")
+
+        timesteps = np.linspace(1, num_train_timesteps, num_train_timesteps, dtype=np.float32)[::-1].copy()
+        timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32)
+
+        sigmas = timesteps / num_train_timesteps
+        if not use_dynamic_shifting:
+            # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution
+            sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
+
+        self.timesteps = sigmas * num_train_timesteps
+
+        self._step_index = None
+        self._begin_index = None
+
+        self._shift = shift
+
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+
+    @property
+    def shift(self):
+        """
+        The value used for shifting.
+        """
+        return self._shift
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`, defaults to `0`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def set_shift(self, shift: float):
+        """
+        Sets the shift value for the scheduler.
+
+        Args:
+            shift (`float`):
+                The shift value to be set.
+        """
+        self._shift = shift
+
+    def scale_noise(
+        self,
+        sample: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        noise: torch.FloatTensor | None = None,
+    ) -> torch.FloatTensor:
+        """
+        Forward process in flow-matching
+
+        Args:
+            sample (`torch.FloatTensor`):
+                The input sample.
+            timestep (`torch.FloatTensor`):
+                The current timestep in the diffusion chain.
+            noise (`torch.FloatTensor`):
+                The noise tensor.
+
+        Returns:
+            `torch.FloatTensor`:
+                A scaled input sample.
+        """
+        # Make sure sigmas and timesteps have the same device and dtype as original_samples
+        sigmas = self.sigmas.to(device=sample.device, dtype=sample.dtype)
+
+        if sample.device.type == "mps" and torch.is_floating_point(timestep):
+            # mps does not support float64
+            schedule_timesteps = self.timesteps.to(sample.device, dtype=torch.float32)
+            timestep = timestep.to(sample.device, dtype=torch.float32)
+        else:
+            schedule_timesteps = self.timesteps.to(sample.device)
+            timestep = timestep.to(sample.device)
+
+        # self.begin_index is None when scheduler is used for training, or pipeline does not implement set_begin_index
+        if self.begin_index is None:
+            step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timestep]
+        elif self.step_index is not None:
+            # add_noise is called after first denoising step (for inpainting)
+            step_indices = [self.step_index] * timestep.shape[0]
+        else:
+            # add noise is called before first denoising step to create initial latent(img2img)
+            step_indices = [self.begin_index] * timestep.shape[0]
+
+        sigma = sigmas[step_indices].flatten()
+        while len(sigma.shape) < len(sample.shape):
+            sigma = sigma.unsqueeze(-1)
+
+        sample = sigma * noise + (1.0 - sigma) * sample
+
+        return sample
+
+    def _sigma_to_t(self, sigma) -> float:
+        return sigma * self.config.num_train_timesteps
+
+    def time_shift(self, mu: float, sigma: float, t: torch.Tensor) -> torch.Tensor:
+        """
+        Apply time shifting to the sigmas.
+
+        Args:
+            mu (`float`):
+                The mu parameter for the time shift.
+            sigma (`float`):
+                The sigma parameter for the time shift.
+            t (`torch.Tensor`):
+                The input timesteps.
+
+        Returns:
+            `torch.Tensor`:
+                The time-shifted timesteps.
+        """
+        if self.config.time_shift_type == "exponential":
+            return self._time_shift_exponential(mu, sigma, t)
+        elif self.config.time_shift_type == "linear":
+            return self._time_shift_linear(mu, sigma, t)
+
+    def stretch_shift_to_terminal(self, t: torch.Tensor) -> torch.Tensor:
+        r"""
+        Stretches and shifts the timestep schedule to ensure it terminates at the configured `shift_terminal` config
+        value.
+
+        Reference:
+        https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51
+
+        Args:
+            t (`torch.Tensor`):
+                A tensor of timesteps to be stretched and shifted.
+
+        Returns:
+            `torch.Tensor`:
+                A tensor of adjusted timesteps such that the final value equals `self.config.shift_terminal`.
+        """
+        one_minus_z = 1 - t
+        scale_factor = one_minus_z[-1] / (1 - self.config.shift_terminal)
+        stretched_t = 1 - (one_minus_z / scale_factor)
+        return stretched_t
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int | None = None,
+        device: str | torch.device = None,
+        sigmas: list[float] | None = None,
+        mu: float | None = None,
+        timesteps: list[float] | None = None,
+    ):
+        """
+        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
+
+        Args:
+            num_inference_steps (`int`, *optional*):
+                The number of diffusion steps used when generating samples with a pre-trained model.
+            device (`str` or `torch.device`, *optional*):
+                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+            sigmas (`list[float]`, *optional*):
+                Custom values for sigmas to be used for each diffusion step. If `None`, the sigmas are computed
+                automatically.
+            mu (`float`, *optional*):
+                Determines the amount of shifting applied to sigmas when performing resolution-dependent timestep
+                shifting.
+            timesteps (`list[float]`, *optional*):
+                Custom values for timesteps to be used for each diffusion step. If `None`, the timesteps are computed
+                automatically.
+        """
+        if self.config.use_dynamic_shifting and mu is None:
+            raise ValueError("`mu` must be passed when `use_dynamic_shifting` is set to be `True`")
+
+        if sigmas is not None and timesteps is not None:
+            if len(sigmas) != len(timesteps):
+                raise ValueError("`sigmas` and `timesteps` should have the same length")
+
+        if num_inference_steps is not None:
+            if (sigmas is not None and len(sigmas) != num_inference_steps) or (
+                timesteps is not None and len(timesteps) != num_inference_steps
+            ):
+                raise ValueError(
+                    "`sigmas` and `timesteps` should have the same length as num_inference_steps, "
+                    "if `num_inference_steps` is provided"
+                )
+        else:
+            num_inference_steps = len(sigmas) if sigmas is not None else len(timesteps)
+
+        self.num_inference_steps = num_inference_steps
+
+        # 1. Prepare default sigmas
+        is_timesteps_provided = timesteps is not None
+
+        if is_timesteps_provided:
+            timesteps = np.array(timesteps).astype(np.float32)
+
+        if sigmas is None:
+            if timesteps is None:
+                timesteps = np.linspace(
+                    self._sigma_to_t(self.sigma_max),
+                    self._sigma_to_t(self.sigma_min),
+                    num_inference_steps,
+                )
+            sigmas = timesteps / self.config.num_train_timesteps
+        else:
+            sigmas = np.array(sigmas).astype(np.float32)
+            num_inference_steps = len(sigmas)
+
+        # 2. Perform timestep shifting. Either no shifting is applied, or resolution-dependent shifting of
+        #    "exponential" or "linear" type is applied
+        if self.config.use_dynamic_shifting:
+            sigmas = self.time_shift(mu, 1.0, sigmas)
+        else:
+            sigmas = self.shift * sigmas / (1 + (self.shift - 1) * sigmas)
+
+        # 3. If required, stretch the sigmas schedule to terminate at the configured `shift_terminal` value
+        if self.config.shift_terminal:
+            sigmas = self.stretch_shift_to_terminal(sigmas)
+
+        # 4. If required, convert sigmas to one of karras, exponential, or beta sigma schedules
+        if self.config.use_karras_sigmas:
+            sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps)
+        elif self.config.use_exponential_sigmas:
+            sigmas = self._convert_to_exponential(in_sigmas=sigmas, num_inference_steps=num_inference_steps)
+        elif self.config.use_beta_sigmas:
+            sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps)
+
+        # 5. Convert sigmas and timesteps to tensors and move to specified device
+        sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device)
+        if not is_timesteps_provided:
+            timesteps = sigmas * self.config.num_train_timesteps
+        else:
+            timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32, device=device)
+
+        # 6. Append the terminal sigma value.
+        #    If a model requires inverted sigma schedule for denoising but timesteps without inversion, the
+        #    `invert_sigmas` flag can be set to `True`. This case is only required in Mochi
+        if self.config.invert_sigmas:
+            sigmas = 1.0 - sigmas
+            timesteps = sigmas * self.config.num_train_timesteps
+            sigmas = torch.cat([sigmas, torch.ones(1, device=sigmas.device)])
+        else:
+            sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+
+        self.timesteps = timesteps
+        self.sigmas = sigmas
+        self._step_index = None
+        self._begin_index = None
+
+    def index_for_timestep(
+        self,
+        timestep: float | torch.FloatTensor,
+        schedule_timesteps: torch.FloatTensor | None = None,
+    ) -> int:
+        """
+        Get the index for the given timestep.
+
+        Args:
+            timestep (`float` or `torch.FloatTensor`):
+                The timestep to find the index for.
+            schedule_timesteps (`torch.FloatTensor`, *optional*):
+                The schedule timesteps to validate against. If `None`, the scheduler's timesteps are used.
+
+        Returns:
+            `int`:
+                The index of the timestep.
+        """
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep: float | torch.FloatTensor) -> None:
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        sample: torch.FloatTensor,
+        s_churn: float = 0.0,
+        s_tmin: float = 0.0,
+        s_tmax: float = float("inf"),
+        s_noise: float = 1.0,
+        generator: torch.Generator | None = None,
+        per_token_timesteps: torch.Tensor | None = None,
+        return_dict: bool = True,
+    ) -> FlowMatchEulerDiscreteSchedulerOutput | tuple:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            s_churn (`float`):
+            s_tmin  (`float`):
+            s_tmax  (`float`):
+            s_noise (`float`, defaults to 1.0):
+                Scaling factor for noise added to the sample.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            per_token_timesteps (`torch.Tensor`, *optional*):
+                The timesteps for each token in the sample.
+            return_dict (`bool`, defaults to `True`):
+                Whether or not to return a
+                [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or tuple.
+
+        Returns:
+            [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or `tuple`:
+                If return_dict is `True`,
+                [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] is returned,
+                otherwise a tuple is returned where the first element is the sample tensor.
+        """
+
+        if isinstance(timestep, int) or isinstance(timestep, torch.IntTensor) or isinstance(timestep, torch.LongTensor):
+            raise ValueError(
+                (
+                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                    " `FlowMatchEulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                    " one of the `scheduler.timesteps` as a timestep."
+                ),
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        if per_token_timesteps is not None:
+            per_token_sigmas = per_token_timesteps / self.config.num_train_timesteps
+
+            sigmas = self.sigmas[:, None, None]
+            lower_mask = sigmas < per_token_sigmas[None] - 1e-6
+            lower_sigmas = lower_mask * sigmas
+            lower_sigmas, _ = lower_sigmas.max(dim=0)
+
+            current_sigma = per_token_sigmas[..., None]
+            next_sigma = lower_sigmas[..., None]
+            dt = current_sigma - next_sigma
+        else:
+            sigma_idx = self.step_index
+            sigma = self.sigmas[sigma_idx]
+            sigma_next = self.sigmas[sigma_idx + 1]
+
+            current_sigma = sigma
+            next_sigma = sigma_next
+            dt = sigma_next - sigma
+
+        if self.config.stochastic_sampling:
+            x0 = sample - current_sigma * model_output
+            noise = randn_tensor(sample.shape, generator=generator, device=sample.device, dtype=sample.dtype)
+            prev_sample = (1.0 - next_sigma) * x0 + next_sigma * noise
+        else:
+            prev_sample = sample + dt * model_output
+
+        # upon completion increase step index by one
+        self._step_index += 1
+        if per_token_timesteps is None:
+            # Cast sample back to model compatible dtype
+            prev_sample = prev_sample.to(model_output.dtype)
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return FlowMatchEulerDiscreteSchedulerOutput(prev_sample=prev_sample)
+
+    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_karras
+    def _convert_to_karras(self, in_sigmas: torch.Tensor, num_inference_steps: int) -> torch.Tensor:
+        """
+        Construct the noise schedule as proposed in [Elucidating the Design Space of Diffusion-Based Generative
+        Models](https://huggingface.co/papers/2206.00364).
+
+        Args:
+            in_sigmas (`torch.Tensor`):
+                The input sigma values to be converted.
+            num_inference_steps (`int`):
+                The number of inference steps to generate the noise schedule for.
+
+        Returns:
+            `torch.Tensor`:
+                The converted sigma values following the Karras noise schedule.
+        """
+
+        # Hack to make sure that other schedulers which copy this function don't break
+        # TODO: Add this logic to the other schedulers
+        if hasattr(self.config, "sigma_min"):
+            sigma_min = self.config.sigma_min
+        else:
+            sigma_min = None
+
+        if hasattr(self.config, "sigma_max"):
+            sigma_max = self.config.sigma_max
+        else:
+            sigma_max = None
+
+        sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item()
+        sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item()
+
+        rho = 7.0  # 7.0 is the value used in the paper
+        ramp = np.linspace(0, 1, num_inference_steps)
+        min_inv_rho = sigma_min ** (1 / rho)
+        max_inv_rho = sigma_max ** (1 / rho)
+        sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
+        return sigmas
+
+    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_exponential
+    def _convert_to_exponential(self, in_sigmas: torch.Tensor, num_inference_steps: int) -> torch.Tensor:
+        """
+        Construct an exponential noise schedule.
+
+        Args:
+            in_sigmas (`torch.Tensor`):
+                The input sigma values to be converted.
+            num_inference_steps (`int`):
+                The number of inference steps to generate the noise schedule for.
+
+        Returns:
+            `torch.Tensor`:
+                The converted sigma values following an exponential schedule.
+        """
+
+        # Hack to make sure that other schedulers which copy this function don't break
+        # TODO: Add this logic to the other schedulers
+        if hasattr(self.config, "sigma_min"):
+            sigma_min = self.config.sigma_min
+        else:
+            sigma_min = None
+
+        if hasattr(self.config, "sigma_max"):
+            sigma_max = self.config.sigma_max
+        else:
+            sigma_max = None
+
+        sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item()
+        sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item()
+
+        sigmas = np.exp(np.linspace(math.log(sigma_max), math.log(sigma_min), num_inference_steps))
+        return sigmas
+
+    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_beta
+    def _convert_to_beta(
+        self, in_sigmas: torch.Tensor, num_inference_steps: int, alpha: float = 0.6, beta: float = 0.6
+    ) -> torch.Tensor:
+        """
+        Construct a beta noise schedule as proposed in [Beta Sampling is All You
+        Need](https://huggingface.co/papers/2407.12173).
+
+        Args:
+            in_sigmas (`torch.Tensor`):
+                The input sigma values to be converted.
+            num_inference_steps (`int`):
+                The number of inference steps to generate the noise schedule for.
+            alpha (`float`, *optional*, defaults to `0.6`):
+                The alpha parameter for the beta distribution.
+            beta (`float`, *optional*, defaults to `0.6`):
+                The beta parameter for the beta distribution.
+
+        Returns:
+            `torch.Tensor`:
+                The converted sigma values following a beta distribution schedule.
+        """
+
+        # Hack to make sure that other schedulers which copy this function don't break
+        # TODO: Add this logic to the other schedulers
+        if hasattr(self.config, "sigma_min"):
+            sigma_min = self.config.sigma_min
+        else:
+            sigma_min = None
+
+        if hasattr(self.config, "sigma_max"):
+            sigma_max = self.config.sigma_max
+        else:
+            sigma_max = None
+
+        sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item()
+        sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item()
+
+        sigmas = np.array(
+            [
+                sigma_min + (ppf * (sigma_max - sigma_min))
+                for ppf in [
+                    scipy.stats.beta.ppf(timestep, alpha, beta)
+                    for timestep in 1 - np.linspace(0, 1, num_inference_steps)
+                ]
+            ]
+        )
+        return sigmas
+
+    def _time_shift_exponential(self, mu: float, sigma: float, t: torch.Tensor) -> torch.Tensor:
+        return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+    def _time_shift_linear(self, mu: float, sigma: float, t: torch.Tensor) -> torch.Tensor:
+        return mu / (mu + (1 / t - 1) ** sigma)
+
+    def __len__(self) -> int:
+        return self.config.num_train_timesteps
diff --git a/vllm_omni/diffusion/models/schedulers/scheduling_flow_unipc_multistep.py b/vllm_omni/diffusion/models/schedulers/scheduling_flow_unipc_multistep.py
index 3efe564bc..895e12827 100644
--- a/vllm_omni/diffusion/models/schedulers/scheduling_flow_unipc_multistep.py
+++ b/vllm_omni/diffusion/models/schedulers/scheduling_flow_unipc_multistep.py
@@ -23,6 +23,7 @@ from diffusers.schedulers.scheduling_utils import KarrasDiffusionSchedulers, Sch
 from diffusers.utils import deprecate
 
 from vllm_omni.diffusion.models.schedulers.base import BaseScheduler
+from vllm_omni.diffusion.utils.flow_matching import safe_linalg_solve
 
 
 class FlowUniPCMultistepScheduler(SchedulerMixin, ConfigMixin, BaseScheduler):
@@ -431,7 +432,7 @@ class FlowUniPCMultistepScheduler(SchedulerMixin, ConfigMixin, BaseScheduler):
                 rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
             else:
                 assert isinstance(R, torch.Tensor)
-                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
+                rhos_p = safe_linalg_solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
         else:
             D1s = None
 
@@ -565,7 +566,7 @@ class FlowUniPCMultistepScheduler(SchedulerMixin, ConfigMixin, BaseScheduler):
         if order == 1:
             rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
         else:
-            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
+            rhos_c = safe_linalg_solve(R, b).to(device).to(x.dtype)
 
         if self.predict_x0:
             x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
diff --git a/vllm_omni/diffusion/models/sd3/sd3_transformer.py b/vllm_omni/diffusion/models/sd3/sd3_transformer.py
index d8e037051..5e446a496 100644
--- a/vllm_omni/diffusion/models/sd3/sd3_transformer.py
+++ b/vllm_omni/diffusion/models/sd3/sd3_transformer.py
@@ -20,7 +20,7 @@ from vllm.model_executor.layers.linear import (
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 
 logger = init_logger(__name__)
diff --git a/vllm_omni/diffusion/models/sensenova_u1/sensenova_u1_transformer.py b/vllm_omni/diffusion/models/sensenova_u1/sensenova_u1_transformer.py
index 843358a70..d2db1f489 100644
--- a/vllm_omni/diffusion/models/sensenova_u1/sensenova_u1_transformer.py
+++ b/vllm_omni/diffusion/models/sensenova_u1/sensenova_u1_transformer.py
@@ -32,7 +32,7 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (
 
 from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig, SensenovaCachedAdapter
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig, SensenovaCachedAdapter
 
 logger = init_logger(__name__)
 
diff --git a/vllm_omni/diffusion/models/soulx_singer/modules/llama.py b/vllm_omni/diffusion/models/soulx_singer/modules/llama.py
index 23a3377f2..b0b6afce3 100644
--- a/vllm_omni/diffusion/models/soulx_singer/modules/llama.py
+++ b/vllm_omni/diffusion/models/soulx_singer/modules/llama.py
@@ -7,7 +7,7 @@ from transformers import LlamaConfig, LlamaModel
 from transformers.modeling_outputs import BaseModelOutputWithPast
 from transformers.models.llama.modeling_llama import LlamaDecoderLayer
 
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelInput, SequenceParallelOutput
 
 
diff --git a/vllm_omni/diffusion/models/soulx_singer/pipeline_soulx_singer_base.py b/vllm_omni/diffusion/models/soulx_singer/pipeline_soulx_singer_base.py
index a48b5236d..0961e6916 100644
--- a/vllm_omni/diffusion/models/soulx_singer/pipeline_soulx_singer_base.py
+++ b/vllm_omni/diffusion/models/soulx_singer/pipeline_soulx_singer_base.py
@@ -353,7 +353,7 @@ class FlowMatchingAudioPipeline(
             sampling_params.extra_args = extra_args
 
         num_inference_steps = sampling_params.num_inference_steps or 32
-        guidance_scale = sampling_params.guidance_scale or 3.0
+        guidance_scale = sampling_params.guidance_scale if sampling_params.guidance_scale_provided else 3.0
         generator = self._resolve_diffusion_generator(sampling_params)
 
         with self._stage_timer("consume_payload"):
diff --git a/vllm_omni/diffusion/models/stable_audio/stable_audio_transformer.py b/vllm_omni/diffusion/models/stable_audio/stable_audio_transformer.py
index c7bc9b2d4..ad7c27e1b 100644
--- a/vllm_omni/diffusion/models/stable_audio/stable_audio_transformer.py
+++ b/vllm_omni/diffusion/models/stable_audio/stable_audio_transformer.py
@@ -16,7 +16,7 @@ from vllm.model_executor.layers.linear import ReplicatedLinear
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cache_dit_backend import CacheDiTAdapterConfig
+from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.hsdp_utils import is_transformer_block_module
 from vllm_omni.diffusion.layers.fourier import GaussianFourierProjection
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
index d3726e087..0fc9aca65 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
@@ -24,7 +24,7 @@ from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan import Dist
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.pipeline_parallel import AsyncLatents, PipelineParallelMixin
 from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
+from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
 from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
@@ -37,7 +37,7 @@ from vllm_omni.diffusion.postprocess import interpolate_video_tensor
 from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import DiffusionPipelineProfilerMixin
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
-from vllm_omni.inputs.data import OmniTextPrompt
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
 from vllm_omni.platforms import current_omni_platform
 
 logger = logging.getLogger(__name__)
@@ -84,6 +84,24 @@ def resolve_wan_flow_shift(req: OmniDiffusionRequest, od_config: OmniDiffusionCo
         raise ValueError(f"Invalid flow_shift={raw_flow_shift!r}. flow_shift must be a float.") from exc
 
 
+def resolve_wan_guidance_scales(
+    sampling_params: OmniDiffusionSamplingParams,
+    default_guidance_scale: float,
+) -> tuple[float, float]:
+    guidance_scale = (
+        sampling_params.guidance_scale if sampling_params.guidance_scale_provided else default_guidance_scale
+    )
+    guidance_low = guidance_scale if isinstance(guidance_scale, (int, float)) else guidance_scale[0]
+    guidance_high = (
+        sampling_params.guidance_scale_2
+        if sampling_params.guidance_scale_2_provided and sampling_params.guidance_scale_2 is not None
+        else (
+            guidance_scale[1] if isinstance(guidance_scale, (list, tuple)) and len(guidance_scale) > 1 else guidance_low
+        )
+    )
+    return guidance_low, guidance_high
+
+
 def retrieve_latents(
     encoder_output: torch.Tensor,
     generator: torch.Generator | None = None,
@@ -264,6 +282,7 @@ class Wan22Pipeline(
     PipelineParallelMixin,
     CFGParallelMixin,
     ProgressBarMixin,
+    DenoiseProgressMixin,
     DiffusionPipelineProfilerMixin,
     SupportsComponentDiscovery,
 ):
@@ -460,7 +479,7 @@ class Wan22Pipeline(
         with self.progress_bar(total=len(timesteps)) as pbar:
             for step_idx, t in enumerate(timesteps):
                 self._current_timestep = t
-                set_forward_context_denoise_step_idx(step_idx)
+                self.record_denoise_step(step_idx, t)
 
                 # Select model based on timestep and boundary_ratio
                 # High noise stage (t >= boundary_timestep): use transformer
@@ -570,25 +589,10 @@ class Wan22Pipeline(
         width = (width // mod_value) * mod_value
         num_steps = 40 if req.sampling_params.num_inference_steps is None else req.sampling_params.num_inference_steps
 
-        # Respect per-request guidance_scale when explicitly provided.
-        if req.sampling_params.guidance_scale_provided:
-            guidance_scale = req.sampling_params.guidance_scale
-        else:
-            guidance_scale = 4.0
-
         output_type = req.sampling_params.output_type or "np"
         attention_kwargs: dict | None = None
 
-        guidance_low = guidance_scale if isinstance(guidance_scale, (int, float)) else guidance_scale[0]
-        guidance_high = (
-            req.sampling_params.guidance_scale_2
-            if req.sampling_params.guidance_scale_2 is not None
-            else (
-                guidance_scale[1]
-                if isinstance(guidance_scale, (list, tuple)) and len(guidance_scale) > 1
-                else guidance_low
-            )
-        )
+        guidance_low, guidance_high = resolve_wan_guidance_scales(req.sampling_params, default_guidance_scale=4.0)
 
         # record guidance for properties
         self._guidance_scale = guidance_low
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
index 8b042b595..180f8bb7a 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_i2v.py
@@ -24,7 +24,7 @@ from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan import Dist
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.pipeline_parallel import AsyncLatents, PipelineParallelMixin
 from vllm_omni.diffusion.distributed.utils import get_local_device
-from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
+from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.model_loader.hub_prefetch import from_pretrained_with_prefetch, prefetch_subfolders
 from vllm_omni.diffusion.models.dmd2 import DMD2PipelineMixin
@@ -36,6 +36,7 @@ from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
     create_transformer_from_config,
     load_transformer_config,
     resolve_wan_flow_shift,
+    resolve_wan_guidance_scales,
     resolve_wan_sample_solver,
     retrieve_latents,
 )
@@ -144,6 +145,7 @@ class Wan22I2VPipeline(
     CFGParallelMixin,
     ProgressBarMixin,
     DiffusionPipelineProfilerMixin,
+    DenoiseProgressMixin,
     SupportsComponentDiscovery,
 ):
     """
@@ -354,7 +356,7 @@ class Wan22I2VPipeline(
                     current_model = self.transformer_2
                     current_guidance_scale = guidance_high
 
-                set_forward_context_denoise_step_idx(step_idx)
+                self.record_denoise_step(step_idx, t)
 
                 # Prepare latent input
                 if self.expand_timesteps:
@@ -474,26 +476,10 @@ class Wan22I2VPipeline(
         num_frames = req.sampling_params.num_frames or 81
         num_steps = 40 if req.sampling_params.num_inference_steps is None else req.sampling_params.num_inference_steps
 
-        # Respect per-request guidance_scale when explicitly provided.
-        if req.sampling_params.guidance_scale_provided:
-            guidance_scale = req.sampling_params.guidance_scale
-        else:
-            guidance_scale = 5.0
-
         output_type = req.sampling_params.output_type or "np"
         attention_kwargs: dict | None = None
 
-        # Handle guidance scales
-        guidance_low = guidance_scale if isinstance(guidance_scale, (int, float)) else guidance_scale[0]
-        guidance_high = (
-            req.sampling_params.guidance_scale_2
-            if req.sampling_params.guidance_scale_2 is not None
-            else (
-                guidance_scale[1]
-                if isinstance(guidance_scale, (list, tuple)) and len(guidance_scale) > 1
-                else guidance_low
-            )
-        )
+        guidance_low, guidance_high = resolve_wan_guidance_scales(req.sampling_params, default_guidance_scale=5.0)
 
         self._guidance_scale = guidance_low
         self._guidance_scale_2 = guidance_high
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
index 47b8e02d1..52a42cb79 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_s2v.py
@@ -29,6 +29,7 @@ from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_wan import DistributedAutoencoderKLWan
 from vllm_omni.diffusion.distributed.cfg_parallel import CFGParallelMixin
 from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
 from vllm_omni.diffusion.models.interface import SupportAudioInput, SupportImageInput
 from vllm_omni.diffusion.models.progress_bar import ProgressBarMixin
@@ -462,7 +463,13 @@ def _load_wan_t5_as_umt5(
 
 
 class Wan22S2VPipeline(
-    nn.Module, SupportImageInput, SupportAudioInput, CFGParallelMixin, ProgressBarMixin, DiffusionPipelineProfilerMixin
+    nn.Module,
+    SupportImageInput,
+    SupportAudioInput,
+    CFGParallelMixin,
+    DenoiseProgressMixin,
+    ProgressBarMixin,
+    DiffusionPipelineProfilerMixin,
 ):
     """
     Wan2.2 Speech-to-Video Pipeline.
@@ -993,8 +1000,9 @@ class Wan22S2VPipeline(
         do_true_cfg = self.do_classifier_free_guidance and negative_prompt_embeds is not None
 
         with self.progress_bar(total=len(timesteps)) as pbar:
-            for t in timesteps:
+            for step_idx, t in enumerate(timesteps):
                 self._current_timestep = t
+                self.record_denoise_step(step_idx, t)
 
                 latent_model_input = [latents.to(device)]
                 timestep = t.unsqueeze(0).to(device) if t.dim() == 0 else t.to(device)
diff --git a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
index 4173b8601..d0cdb1250 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2_vace.py
@@ -25,7 +25,6 @@ from vllm.model_executor.layers.quantization.base_config import QuantizationConf
 from vllm.model_executor.models.utils import AutoWeightsLoader
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.forward_context import set_forward_context_denoise_step_idx
 from vllm_omni.diffusion.models.interface import SupportImageInput
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
     Wan22Pipeline,
@@ -204,7 +203,7 @@ class Wan22VACEPipeline(Wan22Pipeline, SupportImageInput):
         with self.progress_bar(total=len(timesteps)) as pbar:
             for step_idx, t in enumerate(timesteps):
                 self._current_timestep = t
-                set_forward_context_denoise_step_idx(step_idx)
+                self.record_denoise_step(step_idx, t)
 
                 if boundary_timestep is not None and t < boundary_timestep and self.transformer_2 is not None:
                     current_model = self.transformer_2
diff --git a/vllm_omni/diffusion/offloader/__init__.py b/vllm_omni/diffusion/offloader/__init__.py
index 7987da887..9ff464494 100644
--- a/vllm_omni/diffusion/offloader/__init__.py
+++ b/vllm_omni/diffusion/offloader/__init__.py
@@ -8,24 +8,56 @@ from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.platforms import current_omni_platform
 
 from .base import OffloadBackend, OffloadConfig, OffloadStrategy
+from .block_discovery import get_blocks_attr_names, get_blocks_from_dit, set_blocks_attr_names
+from .distributed_layerwise_backend import (
+    DistributedLayerwiseOffloadBackend,
+    DistributedLayerwiseOffloadHook,
+    apply_distributed_block_hook,
+    remove_distributed_block_hook,
+)
 from .layerwise_backend import LayerWiseOffloadBackend
+from .module_residency import PinnedModuleStager
+from .offload_plan import OffloadPlan, get_offload_plan, supports_mmap_loading
 from .sequential_backend import (
     ModelLevelOffloadBackend,
     apply_sequential_offload,
     remove_sequential_offload,
 )
+from .tensor_utils import (
+    dtype_size,
+    is_dtensor,
+    is_materialized_tensor,
+    make_offload_placeholder,
+    set_tensor_storage,
+)
 
 logger = init_logger(__name__)
 
 __all__ = [
     "OffloadBackend",
     "OffloadConfig",
+    "OffloadPlan",
     "OffloadStrategy",
     "LayerWiseOffloadBackend",
+    "DistributedLayerwiseOffloadBackend",
+    "DistributedLayerwiseOffloadHook",
     "ModelLevelOffloadBackend",
+    "PinnedModuleStager",
     "apply_sequential_offload",
     "remove_sequential_offload",
+    "apply_distributed_block_hook",
+    "remove_distributed_block_hook",
     "get_offload_backend",
+    "get_offload_plan",
+    "supports_mmap_loading",
+    "get_blocks_attr_names",
+    "get_blocks_from_dit",
+    "set_blocks_attr_names",
+    "dtype_size",
+    "is_dtensor",
+    "is_materialized_tensor",
+    "make_offload_placeholder",
+    "set_tensor_storage",
 ]
 
 
@@ -75,6 +107,8 @@ def get_offload_backend(
         return ModelLevelOffloadBackend(config, device)
     elif config.strategy == OffloadStrategy.LAYER_WISE:
         return LayerWiseOffloadBackend(config, device)
+    elif config.strategy == OffloadStrategy.DISTRIBUTED_LAYER_WISE:
+        return DistributedLayerwiseOffloadBackend(config, device)
     else:
         logger.error("Unknown offload strategy: %s", config.strategy)
         return None
diff --git a/vllm_omni/diffusion/offloader/base.py b/vllm_omni/diffusion/offloader/base.py
index e10438765..2db80923d 100644
--- a/vllm_omni/diffusion/offloader/base.py
+++ b/vllm_omni/diffusion/offloader/base.py
@@ -18,6 +18,7 @@ class OffloadStrategy(Enum):
     NONE = "none"
     MODEL_LEVEL = "model_level"  # Sequential offloading between DiT and encoders
     LAYER_WISE = "layer_wise"  # Block-level
+    DISTRIBUTED_LAYER_WISE = "distributed_layer_wise"  # Block-level with DP sharding + H2D/AllGather overlap
 
 
 @dataclass
@@ -25,13 +26,24 @@ class OffloadConfig:
     strategy: OffloadStrategy
     pin_cpu_memory: bool = True
     use_hsdp: bool = False
+    dp_size: int = 1  # derived from parallel_config, not user-configurable
+    # True: add DP sharding + AllGather. False: stream the standard loader's
+    # rank-local tensors (including TP-local shards) with H2D only.
+    dlo_use_allgather: bool = True
+    dlo_resident_layers: int = 0  # leading DiT layers kept on device
+    model_path: str | None = None  # checkpoint path for mmap weight loading
 
     @classmethod
     def from_od_config(cls, od_config: OmniDiffusionConfig) -> "OffloadConfig":
         """Extract and validate offload settings from OmniDiffusionConfig.
 
-        For now, enforces mutual exclusion between model-level and layer-wise offloading.
-        Layer-wise takes priority if both are enabled.
+        Enforces mutual exclusion among the three offload strategies.
+        Distributed layer-wise takes the highest priority, then layer-wise,
+        then model-level.
+
+        The ``dp_size`` is automatically derived from ``parallel_config`` —
+        it is NOT a user-configurable parameter. The distributed layerwise
+        offload works with whatever DP/SP parallelism is already set up.
 
         Args:
             od_config: OmniDiffusionConfig with offload settings
@@ -41,13 +53,39 @@ class OffloadConfig:
         """
         enable_cpu_offload = getattr(od_config, "enable_cpu_offload", False)
         enable_layerwise_offload = getattr(od_config, "enable_layerwise_offload", False)
+        enable_distributed_layerwise_offload = getattr(od_config, "enable_distributed_layerwise_offload", False)
         pin_cpu_memory = getattr(od_config, "pin_cpu_memory", True)
 
         parallel_config = getattr(od_config, "parallel_config", None)
         use_hsdp = getattr(parallel_config, "use_hsdp", False) if parallel_config else False
 
-        # Determine strategy (mutual exclusion, layer-wise takes priority)
-        if enable_layerwise_offload:
+        # Derive dp_size from parallel_config — not user-configurable.
+        # The offload adapts to whatever DP/SP is already configured.
+        dp_size = 1
+        if parallel_config is not None:
+            dp_size = getattr(parallel_config, "data_parallel_size", 1)
+            # HSDP's fully_shard_degree also contributes to effective DP
+            hsdp_shard_size = getattr(parallel_config, "hsdp_shard_size", -1) if use_hsdp else -1
+            hsdp_replicate_size = getattr(parallel_config, "hsdp_replicate_size", 1) if use_hsdp else 1
+            if use_hsdp and hsdp_shard_size > 0:
+                dp_size = hsdp_shard_size * hsdp_replicate_size
+
+            # When there is no DP but SP > 1, shard weights across SP ranks.
+            # AllGather reconstructs full weights per layer; each rank then
+            # computes on its SP portion of the sequence.  This gives N×
+            # compute parallelism with 1/N H2D transfer, reusing the exact
+            # same AllGather code path — only the process group changes.
+            if dp_size <= 1:
+                sp_size = getattr(parallel_config, "sequence_parallel_size", 1)
+                if sp_size and sp_size > 1:
+                    dp_size = sp_size
+
+        # Determine strategy (mutual exclusion, distributed layer-wise takes priority)
+        if enable_distributed_layerwise_offload:
+            strategy = OffloadStrategy.DISTRIBUTED_LAYER_WISE
+            if enable_layerwise_offload or enable_cpu_offload:
+                logger.info("Distributed layer-wise offloading takes priority, disabling other offloading strategies.")
+        elif enable_layerwise_offload:
             strategy = OffloadStrategy.LAYER_WISE
             if enable_cpu_offload:
                 logger.info(
@@ -59,10 +97,47 @@ class OffloadConfig:
         else:
             strategy = OffloadStrategy.NONE
 
+        # With dlo_use_allgather=False, do not add another DP shard. Each rank
+        # streams the tensors produced by the standard loader, which may
+        # already be TP-local shards. This avoids AllGather synchronization
+        # requirements (concurrent requests, dummy run skip).
+        dlo_use_allgather = getattr(od_config, "dlo_use_allgather", True)
+        dlo_resident_layers = int(getattr(od_config, "dlo_resident_layers", 0))
+        if dlo_resident_layers < 0:
+            raise ValueError(f"dlo_resident_layers must be >= 0, got {dlo_resident_layers}")
+        if dlo_resident_layers and dlo_use_allgather:
+            raise ValueError(
+                "dlo_resident_layers currently requires --dlo-no-use-allgather so "
+                "resident blocks use weights prepared by the standard TP-aware loader"
+            )
+
+        # If dlo_use_allgather=False, force dp_size=1 (each rank independent)
+        if enable_distributed_layerwise_offload and not dlo_use_allgather:
+            dp_size = 1
+            logger.info(
+                "Distributed layerwise offload: dlo_use_allgather=False, "
+                "streaming standard-loader rank-local weights (no DP shard or AllGather)"
+            )
+
+        # HSDP already shards parameters into DTensors.  Running distributed
+        # layerwise offload on top would shard each to_local() again, producing
+        # incorrect reconstruction after AllGather.  Reject this combination.
+        if enable_distributed_layerwise_offload and use_hsdp and dlo_use_allgather:
+            raise ValueError(
+                "Distributed layerwise offload with AllGather is incompatible with "
+                "HSDP: HSDP parameters are already sharded DTensors, and the offloader "
+                "would double-shard them. Use --dlo-no-use-allgather (standard-loader "
+                "rank-local weights) or disable HSDP."
+            )
+
         return cls(
             strategy=strategy,
             pin_cpu_memory=pin_cpu_memory,
             use_hsdp=use_hsdp,
+            dp_size=dp_size,
+            dlo_use_allgather=dlo_use_allgather,
+            dlo_resident_layers=dlo_resident_layers,
+            model_path=getattr(od_config, "model", None),
         )
 
 
diff --git a/vllm_omni/diffusion/offloader/block_discovery.py b/vllm_omni/diffusion/offloader/block_discovery.py
new file mode 100644
index 000000000..643485ed6
--- /dev/null
+++ b/vllm_omni/diffusion/offloader/block_discovery.py
@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Block discovery for layerwise offload.
+
+Shared between LayerWiseOffloadBackend and DistributedLayerwiseOffloadBackend.
+"""
+
+from __future__ import annotations
+
+from torch import nn
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+def get_blocks_attr_names(model: nn.Module) -> list[str]:
+    """Get block attribute names from model class."""
+    attrs: list[str] = getattr(model.__class__, "_layerwise_offload_blocks_attrs", [])
+
+    if not attrs:
+        old_attr = getattr(model.__class__, "_layerwise_offload_blocks_attr", None)
+        if old_attr is not None:
+            logger.warning(
+                "'_layerwise_offload_blocks_attr' is deprecated, "
+                "please use '_layerwise_offload_blocks_attrs' instead. "
+                "Example: _layerwise_offload_blocks_attrs = ['blocks']"
+            )
+            attrs = [old_attr] if isinstance(old_attr, str) else list(old_attr)
+
+    return attrs
+
+
+def set_blocks_attr_names(model: nn.Module, names: list[str]) -> None:
+    if not hasattr(model.__class__, "_layerwise_offload_blocks_attrs"):
+        setattr(model.__class__, "_layerwise_offload_blocks_attrs", names)
+
+
+def get_blocks_from_dit(model: nn.Module) -> tuple[list[str], list[nn.Module]]:
+    """Retrieve blocks and attribute names from provided DiT model."""
+    blocks_attr_names = get_blocks_attr_names(model)
+    if not blocks_attr_names:
+        logger.warning(
+            f"No _layerwise_offload_blocks_attrs defined for {model.__class__.__name__}, "
+            "skipping distributed layerwise offloading"
+        )
+        return [], []
+
+    blocks: list[nn.Module] = []
+    for name in blocks_attr_names:
+        attr = getattr(model, name, None)
+        if attr is None:
+            raise AttributeError(
+                f"Attribute '{name}' declared in _layerwise_offload_blocks_attrs "
+                f"does not exist on model {model.__class__.__name__}"
+            )
+        try:
+            attr_iter = iter(attr)
+        except TypeError:
+            if isinstance(attr, nn.Module):
+                logger.warning(
+                    "Attribute '%s' on %s is not iterable; treating it as one block.",
+                    name,
+                    model.__class__.__name__,
+                )
+                blocks.append(attr)
+                continue
+
+            logger.warning(
+                "Attribute '%s' on %s is not iterable (got %s); skipping it.",
+                name,
+                model.__class__.__name__,
+                type(attr).__name__,
+            )
+        else:
+            blocks.extend(attr_iter)
+
+    if not blocks:
+        logger.warning(
+            "No blocks found in %s for %s, skipping distributed layerwise offloading",
+            blocks_attr_names,
+            model.__class__.__name__,
+        )
+        return [], []
+
+    return blocks_attr_names, blocks
diff --git a/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py b/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py
new file mode 100644
index 000000000..7da7c8d37
--- /dev/null
+++ b/vllm_omni/diffusion/offloader/distributed_layerwise_backend.py
@@ -0,0 +1,1764 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Distributed Layerwise Offload backend with H2D + AllGather overlap.
+
+This module implements the RFC-1 "Distributed Layerwise Offload" mechanism that:
+
+* Shards model weights across DP ranks and stores only the local shard
+  (1/DP_size of full model) in host pinned memory per rank.
+* Uses a fixed double-buffer scheme that keeps only two layers' worth of
+  weights on each device at any time.
+* Asynchronously pipelines both H2D transfers and AllGather communications
+  on dedicated streams, fully overlapping them with computation.
+* Is hardware-agnostic, supporting both NVIDIA GPU (CUDA) and Ascend NPU
+  (CANN) platforms via vLLM-Omni's platform abstraction layer.
+"""
+
+from __future__ import annotations
+
+import os
+from itertools import chain
+from typing import Any
+
+import torch
+import torch.distributed
+from torch import nn
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.hooks import HookRegistry, ModelHook
+from vllm_omni.platforms import current_omni_platform
+
+from .base import OffloadBackend, OffloadConfig
+from .block_discovery import get_blocks_from_dit
+from .module_collector import ModuleDiscovery
+from .offload_plan import OffloadPlan, get_offload_plan, supports_mmap_loading
+from .tensor_utils import (
+    dtype_size as _dtype_size,
+)
+from .tensor_utils import (
+    is_materialized_tensor,
+    make_offload_placeholder,
+    set_tensor_storage,
+)
+
+logger = init_logger(__name__)
+
+# Threshold (in MB) for deciding whether a non-block DiT submodule should
+# use layerwise offload (streaming hooks) or be moved to GPU as a resident
+# module.  Submodules larger than this are offloaded to save HBM; smaller
+# ones stay resident for lower latency.
+_ON_DEMAND_THRESHOLD_MB = 1024
+
+
+class DistributedLayerwiseOffloadHook(ModelHook):
+    """Hook for distributed layerwise offloading with fixed double-buffer.
+
+    Each rank stores only a shard of each block's weights on host memory.
+    Two device slots alternate: one holds current weights, one holds next weights.
+    H2D and AllGather run asynchronously on dedicated streams, overlapped
+    with computation.
+
+    Supports both NVIDIA GPU (CUDA) and Ascend NPU (CANN) platforms.
+    """
+
+    _HOOK_NAME = "distributed_layerwise_offload"
+
+    def __init__(
+        self,
+        next_block: nn.Module,
+        device: torch.device,
+        dp_group: torch.distributed.ProcessGroup | None,
+        dp_size: int,
+        rank: int,
+        copy_stream: Any | None = None,
+        comm_stream: Any | None = None,
+        pin_memory: bool = True,
+        shared_buffers: list[dict[torch.dtype, torch.Tensor] | None] | None = None,
+    ):
+        assert isinstance(next_block, nn.Module), "transformer block must be type `torch.nn.Module`"
+
+        self.next_block = next_block
+        self.device = device
+        self.dp_group = dp_group
+        self.dp_size = dp_size
+        self.rank = rank
+        self.pin_memory = pin_memory
+
+        self.copy_stream = copy_stream or current_omni_platform.Stream()
+        self.comm_stream = comm_stream or current_omni_platform.Stream()
+
+        # Double buffers: either shared (from backend) or self-allocated (lazy)
+        if shared_buffers is not None:
+            self.gpu_buffers: list[dict[torch.dtype, torch.Tensor] | None] = shared_buffers
+            self._owns_buffers = False
+        else:
+            self.gpu_buffers = [None, None]
+            self._owns_buffers = True
+        self.ready_events: list[Any | None] = [None, None]
+
+        # Sharded host weights for the next block, keyed by dtype
+        self.cpu_shards: dict[torch.dtype, torch.Tensor] = {}
+        self.metadata: dict[torch.dtype, list[dict[str, Any]]] = {}
+
+        # Current slot index (0 or 1).  Updated dynamically by the previous
+        # hook's prefetch_layer call via _prefetched_slot.  This ensures
+        # correct slot tracking for ALL block counts (including odd N).
+        self.current_slot = 0
+        self._prefetched_slot: int | None = None
+
+        # Backward link to previous hook for fallback (cache-dit skip)
+        self._prev_hook: DistributedLayerwiseOffloadHook | None = None
+
+        # Marks the first hook in a shared-buffer group.  When multiple DiT
+        # groups share the same 2 GPU buffers, another group may have
+        # overwritten this group's slot between forwards.  The first block
+        # must sync-prefetch on entry to ensure it loads the correct
+        # weights, even if is_materialized sees a non-empty tensor left by
+        # the other group.
+        self._is_group_first: bool = False
+
+        # Group ID for per-slot contamination tracking.  Shared across all
+        # hooks in the same group.  When a hook prefetches into a slot, it
+        # stamps the slot with its group ID.  On group entry, the first
+        # hook checks whether the slot was last written by its own group
+        # (tail hook's async prefetch) — if so, skip the sync-prefetch.
+        self._group_id: int = -1
+        self._shared_slot_group: list[int] | None = None  # [-1, -1], shared
+
+        # Parameters/buffers of the current and next blocks
+        self.block_parameters: dict[str, nn.Parameter] = {}
+        self.block_buffers: dict[str, torch.Tensor] = {}
+        self.next_block_parameters: dict[str, nn.Parameter] = {}
+        self.next_block_buffers: dict[str, torch.Tensor] = {}
+
+        # Per-block synchronization primitive: set after H2D copy completes.
+        self._prefetch_done: Any | None = None
+
+        # Shared shard (AllGather input) buffers — assigned by backend.
+        self.gpu_shard_buffers: list[dict[torch.dtype, torch.Tensor] | None] = [None, None]
+
+        # Pending async AllGather work (prevent GC before completion).
+        self._pending_work: Any | None = None
+        self._cached_repoint: list | None = None
+
+    # ------------------------------------------------------------------ #
+    #  DTensor helpers (shared with LayerwiseOffloadHook)                 #
+    # ------------------------------------------------------------------ #
+
+    def initialize_hook(self, module: nn.Module) -> nn.Module:
+        module = super().initialize_hook(module)
+
+        self.block_parameters = dict(module.named_parameters())
+        self.block_buffers = dict(module.named_buffers())
+
+        self.next_block_parameters = dict(self.next_block.named_parameters())
+        self.next_block_buffers = dict(self.next_block.named_buffers())
+
+        # Shard next block's weights and store local shard in pinned CPU memory
+        self.cpu_shards, self.metadata = self._shard_and_pin(
+            self.next_block_parameters,
+            self.next_block_buffers,
+            self.dp_size,
+            self.rank,
+            self.pin_memory,
+        )
+
+        # Allocate device buffers only if not using shared buffers from backend
+        if self._owns_buffers:
+            self._allocate_device_buffers()
+
+        # Cache parameter re-pointing metadata to avoid per-layer dict lookups.
+        self._cached_repoint = []
+        for slot in range(2):
+            repoint = []
+            for dtype, metas in self.metadata.items():
+                for m in metas:
+                    target = (
+                        self.next_block_parameters[m["name"]]
+                        if m["name"] in self.next_block_parameters
+                        else self.next_block_buffers[m["name"]]
+                    )
+                    repoint.append((target, dtype, m["offset"], m["numel"], m["shape"]))
+            self._cached_repoint.append(repoint)
+
+        # Pre-compute AG output sizes (avoid sum() per layer).
+        self._ag_output_sizes: dict[torch.dtype, int] = {}
+        for dtype, metas in self.metadata.items():
+            total_numel = sum(m["numel"] for m in metas)
+            shard_numel = self.cpu_shards[dtype].numel()
+            self._ag_output_sizes[dtype] = shard_numel * self.dp_size if self.dp_size > 1 else total_numel
+
+        return module
+
+    @staticmethod
+    def _shard_and_pin(
+        params: dict[str, nn.Parameter],
+        bufs: dict[str, torch.Tensor],
+        dp_size: int,
+        rank: int,
+        pin_memory: bool,
+    ) -> tuple[dict[torch.dtype, torch.Tensor], dict[torch.dtype, list[dict[str, Any]]]]:
+        """Flatten params+buffers by dtype, split into DP shards, store local shard.
+
+        Each rank stores only ``1/dp_size`` of the total weights. The full
+        tensor is reconstructed at runtime via AllGather.
+        """
+        dtype_grouped: dict[torch.dtype, dict[str, torch.Tensor]] = {}
+        dtype_metadata: dict[torch.dtype, list[dict[str, Any]]] = {}
+
+        for name, param_or_buf in chain(params.items(), bufs.items()):
+            dtype = param_or_buf.dtype
+            if dtype not in dtype_grouped:
+                dtype_grouped[dtype] = {}
+            dtype_grouped[dtype][name] = param_or_buf
+
+        cpu_shards: dict[torch.dtype, torch.Tensor] = {}
+
+        for dtype, name2weights in dtype_grouped.items():
+            # Resolve local tensors (handle DTensor via to_local)
+            weights_with_local = []
+            for name, t in name2weights.items():
+                local_t = t.to_local() if hasattr(t, "to_local") else t
+                mmap_transform = getattr(t, "mmap_weight_transform", None)
+                if callable(mmap_transform) and getattr(t, "mmap_weight_transform_pending", False):
+                    # Some checkpoints use a layout that is converted by the
+                    # regular weight loader (for example MiniMax-H3 grouped
+                    # QKV).  Apply that conversion one block at a time while
+                    # copying the rank-local CPU shard.  Keeping the raw
+                    # parameter as an mmap view avoids a private full-model
+                    # copy in every worker.
+                    local_t = mmap_transform(local_t)
+                weights_with_local.append((name, t, local_t))
+
+            total_numel = sum(local.numel() for _, _, local in weights_with_local)
+
+            # Equal-sized shards (ceil division) for all_gather_into_tensor
+            shard_size = (total_numel + dp_size - 1) // dp_size  # ceil
+            shard_start = rank * shard_size
+            shard_end = min(shard_start + shard_size, total_numel)
+
+            # Allocate ONLY the shard (1/dp_size), zero-padded to ceil.
+            # Avoids materialising the full block on CPU.
+            shard = torch.zeros(shard_size, dtype=dtype, device="cpu")
+
+            current_offset = 0
+            for name, original_tensor, local_tensor in weights_with_local:
+                numel = local_tensor.numel()
+                if dtype not in dtype_metadata:
+                    dtype_metadata[dtype] = []
+                # Offsets remain relative to the FULL flattened buffer
+                # (needed for correct AllGather reconstruction).
+                dtype_metadata[dtype].append(
+                    {
+                        "name": name,
+                        "offset": current_offset,
+                        "numel": numel,
+                        "shape": local_tensor.shape,
+                    }
+                )
+
+                # Copy ONLY the portion within [shard_start, shard_end)
+                overlap_start = max(current_offset, shard_start)
+                overlap_end = min(current_offset + numel, shard_end)
+                if overlap_start < overlap_end:
+                    src_start = overlap_start - current_offset
+                    src_end = overlap_end - current_offset
+                    dst_start = overlap_start - shard_start
+                    dst_end = overlap_end - shard_start
+                    shard[dst_start:dst_end].copy_(local_tensor.flatten()[src_start:src_end])
+
+                # Replace original tensor with placeholder (frees CPU storage)
+                set_tensor_storage(
+                    original_tensor,
+                    make_offload_placeholder(original_tensor),
+                )
+                current_offset += numel
+
+            if pin_memory:
+                shard = shard.pin_memory()
+
+            cpu_shards[dtype] = shard
+
+        return cpu_shards, dtype_metadata
+
+    def _allocate_device_buffers(self) -> None:
+        """Pre-allocate exactly two device buffers (one per slot)."""
+        for slot in range(2):
+            gpu_weights: dict[torch.dtype, torch.Tensor] = {}
+            for dtype, metas in self.metadata.items():
+                total_numel = sum(m["numel"] for m in metas)
+                # AllGather output = dp_size * shard_size (padded)
+                padded = total_numel
+                if self.dp_size > 1:
+                    shard_sz = (total_numel + self.dp_size - 1) // self.dp_size
+                    padded = shard_sz * self.dp_size
+                gpu_weights[dtype] = torch.empty(padded, dtype=dtype, device=self.device)
+            self.gpu_buffers[slot] = gpu_weights
+
+    @property
+    def is_materialized(self) -> bool:
+        """Check whether this block's parameters hold real data on device."""
+        for param in self.block_parameters.values():
+            return is_materialized_tensor(param)
+        return True
+
+    # ------------------------------------------------------------------ #
+    #  Prefetch: H2D + AllGather (overlapped on dedicated streams)      #
+    # ------------------------------------------------------------------ #
+
+    @torch.compiler.disable
+    def prefetch_layer(self, slot: int, non_blocking: bool = True) -> None:
+        """Prepare next block's weights into the shared device buffer for *slot*.
+
+        Uses the pre-allocated ``self.gpu_buffers[slot]`` instead of
+        allocating fresh tensors every layer.  This enforces the fixed
+        double-buffer memory bound (exactly 2 blocks on device).
+        """
+        self.copy_stream.wait_stream(current_omni_platform.current_stream())
+
+        evt = current_omni_platform.Event()
+        gpu_weights = self.gpu_buffers[slot]
+        assert gpu_weights is not None, f"gpu_buffers[{slot}] not allocated"
+
+        if self.dp_size <= 1 or self.dp_group is None:
+            with current_omni_platform.stream(self.copy_stream):
+                for dtype, cpu_shard in self.cpu_shards.items():
+                    gw = gpu_weights[dtype]
+                    gw[: cpu_shard.numel()].copy_(cpu_shard, non_blocking=non_blocking)
+                evt.record(self.copy_stream)
+        else:
+            gpu_shards: dict[torch.dtype, torch.Tensor] = {}
+            shard_bufs = self.gpu_shard_buffers[slot]
+            assert shard_bufs is not None, f"gpu_shard_buffers[{slot}] not allocated"
+            with current_omni_platform.stream(self.copy_stream):
+                for dtype, cpu_shard in self.cpu_shards.items():
+                    gpu_shard = shard_bufs[dtype][: cpu_shard.numel()]
+                    gpu_shard.copy_(cpu_shard, non_blocking=non_blocking)
+                    gpu_shards[dtype] = gpu_shard
+
+            self.comm_stream.wait_stream(self.copy_stream)
+            with current_omni_platform.stream(self.comm_stream):
+                for dtype, local_shard in gpu_shards.items():
+                    # Slice the shared (max-sized) output buffer down to this
+                    # block's actual AllGather output size. The buffers are
+                    # sized to the *largest* block across all groups, so for any
+                    # smaller block the full buffer would violate the
+                    # all_gather_into_tensor contract
+                    # (output.numel() == world_size * input.numel()).
+                    # Repoint offsets are relative to the block's flattened
+                    # buffer, so a prefix slice is safe.
+                    gw = gpu_weights[dtype][: self._ag_output_sizes[dtype]]
+                    torch.distributed.all_gather_into_tensor(
+                        gw,
+                        local_shard,
+                        group=self.dp_group,
+                    )
+                evt.record(self.comm_stream)
+
+        self.ready_events[slot] = evt
+        self._prefetch_done = evt
+        self._prefetched_slot = slot
+
+        # Stamp the slot with this hook's group ID so that group-first
+        # hooks can detect whether another group has overwritten the slot.
+        if self._shared_slot_group is not None:
+            self._shared_slot_group[slot] = self._group_id
+
+        # Re-point using cached metadata (avoids per-layer dict lookups).
+        for target, dtype, offset, numel, shape in self._cached_repoint[slot]:
+            set_tensor_storage(
+                target,
+                gpu_weights[dtype][offset : offset + numel].view(shape),
+            )
+
+    def get_weights(self, slot: int) -> dict[torch.dtype, torch.Tensor] | None:
+        """Wait for AllGather completion and return full weights for the slot.
+
+        The ready event for this slot was set by the *previous* hook's
+        prefetch_layer (which prefetched THIS block's weights into the
+        shared buffer).  This hook's own ready_events[slot] is None because
+        it never prefetched into this slot itself.  Fall back to the
+        previous hook's event to ensure the compute stream waits for the
+        AllGather (or H2D) to complete before reading the buffer.
+        """
+        evt = self.ready_events[slot]
+        if evt is None and self._prev_hook is not None:
+            evt = self._prev_hook.ready_events[slot]
+        if evt is not None:
+            current_omni_platform.current_stream().wait_event(evt)
+        return self.gpu_buffers[slot]
+
+    # ------------------------------------------------------------------ #
+    #  Offload: free device memory for current block                     #
+    # ------------------------------------------------------------------ #
+
+    @torch.compiler.disable
+    def offload_layer(self) -> None:
+        """Free GPU memory for current block by replacing tensors with placeholders."""
+        evt = self._prefetch_done
+        if evt is not None:
+            current_omni_platform.current_stream().wait_event(evt)
+        self._prefetch_done = None
+
+        for _, param in self.block_parameters.items():
+            set_tensor_storage(param, make_offload_placeholder(param))
+        for _, buf in self.block_buffers.items():
+            set_tensor_storage(buf, make_offload_placeholder(buf))
+
+    # ------------------------------------------------------------------ #
+    #  ModelHook interface                                                #
+    # ------------------------------------------------------------------ #
+
+    def pre_forward(self, module: nn.Module, *args: Any, **kwargs: Any) -> tuple[tuple, dict]:
+        # Dynamic slot tracking: read current_slot from the previous hook's
+        # _prefetched_slot (the slot where this block's data was actually
+        # loaded).  This corrects the initial i%2 assignment for odd block
+        # counts, where the circular tail→head prefetch would otherwise
+        # collide with the head's read slot.
+        if self._prev_hook is not None and self._prev_hook._prefetched_slot is not None:
+            self.current_slot = self._prev_hook._prefetched_slot
+
+        # Group-first hook: check whether the shared buffer slot was
+        # overwritten by another group since our last forward.  If the
+        # slot still contains our own data (from the tail hook's async
+        # prefetch), skip the sync-prefetch and just wait for the event.
+        if self._is_group_first and self._prev_hook is not None:
+            slot_contaminated = True
+            if self._shared_slot_group is not None:
+                slot_contaminated = self._shared_slot_group[self.current_slot] != self._group_id
+            if slot_contaminated:
+                # Another group (or no group) wrote to our slot — re-fetch
+                self._prev_hook.prefetch_layer(self.current_slot, non_blocking=False)
+            # Always wait for data to be ready (handles both sync and async paths)
+            self._prev_hook.get_weights(self.current_slot)
+        elif not self.is_materialized and self._prev_hook is not None:
+            # Previous hook was skipped (e.g. by cache-dit), sync-prefetch
+            self._prev_hook.prefetch_layer(self.current_slot, non_blocking=False)
+            self._prev_hook.get_weights(self.current_slot)
+
+        # Prefetch next layer into the other slot (overlapped with compute).
+        # No explicit get_weights() here — offload_layer() in the previous
+        # hook's post_forward already enqueued wait_event for the current
+        # layer's H2D/AllGather, which is sufficient to ensure compute_stream
+        # waits for weights before reading them.  The redundant wait_event
+        # caused cascading NPU stream synchronization stalls (~10ms/layer).
+        next_slot = 1 - self.current_slot
+        self.prefetch_layer(next_slot, non_blocking=True)
+
+        return args, kwargs
+
+    def post_forward(self, module: nn.Module, output: Any) -> Any:
+        self.offload_layer()
+        return output
+
+
+# ---------------------------------------------------------------------- #
+#  Module-level helpers                                                   #
+# ---------------------------------------------------------------------- #
+
+
+def apply_distributed_block_hook(
+    module: nn.Module,
+    next_block: nn.Module,
+    device: torch.device,
+    dp_group: torch.distributed.ProcessGroup | None,
+    dp_size: int,
+    rank: int,
+    copy_stream: Any | None = None,
+    comm_stream: Any | None = None,
+    pin_memory: bool = True,
+    shared_buffers: list[dict[torch.dtype, torch.Tensor] | None] | None = None,
+) -> DistributedLayerwiseOffloadHook:
+    """Register a DistributedLayerwiseOffloadHook on *module*."""
+    registry = HookRegistry.get_or_create(module)
+    hook = DistributedLayerwiseOffloadHook(
+        next_block=next_block,
+        device=device,
+        dp_group=dp_group,
+        dp_size=dp_size,
+        rank=rank,
+        copy_stream=copy_stream,
+        comm_stream=comm_stream,
+        pin_memory=pin_memory,
+        shared_buffers=shared_buffers,
+    )
+    registry.register_hook(DistributedLayerwiseOffloadHook._HOOK_NAME, hook)
+    return hook
+
+
+def remove_distributed_block_hook(module: nn.Module) -> None:
+    """Remove the distributed layerwise offload hook from *module*."""
+    registry: HookRegistry | None = getattr(module, "_hook_registry", None)
+    if registry is not None:
+        registry.remove_hook(DistributedLayerwiseOffloadHook._HOOK_NAME)
+        logger.debug("Removed distributed offload hook from %s", module.__class__.__name__)
+
+
+class PinnedResidentLayerGroup:
+    """Keep selected layers in pinned host memory between requests.
+
+
+    TODO(offload): Extract this alongside PinnedModuleStager after the
+    distributed shard-and-pin operation becomes a shared storage primitive.
+    It currently remains here because it depends on DLO's local-shard layout.
+    Unlike ``module.to(device)``/``module.to("cpu")``, this group retains a
+    pinned CPU master copy and never copies generated device weights back to
+    host.  Entering the denoise stage performs one asynchronous H2D pass;
+    leaving it only restores zero-sized placeholders and releases the device
+    buffers.  This lets the following VAE stage reuse the same HBM.
+
+    The resident path is intentionally local-shard only.  With tensor
+    parallelism, the regular model loader has already produced each rank's TP
+    shard, so no DP AllGather is required or desirable here.
+    """
+
+    def __init__(
+        self,
+        blocks: list[nn.Module],
+        device: torch.device,
+        copy_stream: Any,
+        pin_memory: bool,
+    ) -> None:
+        self.device = device
+        self.copy_stream = copy_stream
+        self.loaded = False
+        self._states: list[dict[str, Any]] = []
+        self._gpu_buffers: list[dict[torch.dtype, torch.Tensor]] = []
+
+        for block in blocks:
+            params = dict(block.named_parameters())
+            bufs = dict(block.named_buffers())
+            targets: dict[str, torch.Tensor] = {**params, **bufs}
+            cpu_shards, metadata = DistributedLayerwiseOffloadHook._shard_and_pin(
+                params,
+                bufs,
+                dp_size=1,
+                rank=0,
+                pin_memory=pin_memory,
+            )
+            self._states.append(
+                {
+                    "targets": targets,
+                    "cpu_shards": cpu_shards,
+                    "metadata": metadata,
+                }
+            )
+
+    def load(self) -> None:
+        if self.loaded:
+            return
+
+        # Allocate on the compute stream so the caching allocator can reuse
+        # blocks released by the encoder stage.  Allocating on the copy stream
+        # would create a separate stream-local pool and inflate peak HBM.
+        gpu_buffers: list[dict[torch.dtype, torch.Tensor]] = []
+        for state in self._states:
+            block_buffers: dict[torch.dtype, torch.Tensor] = {}
+            for dtype, cpu_shard in state["cpu_shards"].items():
+                block_buffers[dtype] = torch.empty(
+                    cpu_shard.shape,
+                    dtype=dtype,
+                    device=self.device,
+                )
+            gpu_buffers.append(block_buffers)
+
+        self.copy_stream.wait_stream(current_omni_platform.current_stream())
+        ready = current_omni_platform.Event()
+        with current_omni_platform.stream(self.copy_stream):
+            for state, block_buffers in zip(self._states, gpu_buffers):
+                for dtype, cpu_shard in state["cpu_shards"].items():
+                    block_buffers[dtype].copy_(cpu_shard, non_blocking=True)
+            ready.record(self.copy_stream)
+
+        for state, block_buffers in zip(self._states, gpu_buffers):
+            targets = state["targets"]
+            for dtype, metas in state["metadata"].items():
+                gpu_buffer = block_buffers[dtype]
+                for meta in metas:
+                    set_tensor_storage(
+                        targets[meta["name"]],
+                        gpu_buffer[meta["offset"] : meta["offset"] + meta["numel"]].view(meta["shape"]),
+                    )
+
+        current_omni_platform.current_stream().wait_event(ready)
+        self._gpu_buffers = gpu_buffers
+        self.loaded = True
+
+    def offload(self) -> None:
+        if not self.loaded:
+            return
+
+        # Denoise kernels consume these buffers on the current compute stream.
+        # Synchronize once at the stage boundary; no D2H copy is necessary
+        # because the pinned CPU master weights were never overwritten.
+        current_omni_platform.synchronize()
+        for state in self._states:
+            for target in state["targets"].values():
+                set_tensor_storage(target, make_offload_placeholder(target))
+        self._gpu_buffers.clear()
+        self.loaded = False
+
+
+# ---------------------------------------------------------------------- #
+#  Backend                                                                #
+# ---------------------------------------------------------------------- #
+
+
+class DistributedLayerwiseOffloadBackend(OffloadBackend):
+    """Distributed layer-wise (block-level) offloading backend.
+
+    Supports both GPU (CUDA) and NPU (CANN) platforms.
+    Device type is determined by the device passed to enable().
+
+    Each rank stores only a shard of each block's weights on host memory.
+    Two device slots alternate: one holds current weights, one holds next
+    weights. H2D and AllGather run asynchronously on dedicated streams,
+    overlapped with computation.
+    """
+
+    _MMAP_PARAM_ATTRS = ("weight_loader", "mmap_weight_transform")
+
+    def __init__(self, config: OffloadConfig, device: torch.device):
+        super().__init__(config, device)
+
+        self.copy_stream = current_omni_platform.Stream()
+        self.comm_stream = current_omni_platform.Stream()
+        self.dp_group: torch.distributed.ProcessGroup | None = None
+        self.dp_size = config.dp_size
+        self.rank = 0
+        self._blocks: list[list[nn.Module]] = []
+        self._all_hook_groups: list[list[DistributedLayerwiseOffloadHook]] = []
+        self._resident_blocks: list[nn.Module] = []
+        self._resident_layer_group: PinnedResidentLayerGroup | None = None
+
+    def load_resident_layers(self) -> None:
+        """Load the model-declared leading blocks for the denoise stage."""
+        if self._resident_layer_group is not None:
+            self._resident_layer_group.load()
+
+    def offload_resident_layers(self) -> None:
+        """Release leading blocks before VAE decode to bound peak HBM."""
+        if self._resident_layer_group is not None:
+            self._resident_layer_group.offload()
+
+    def _remember_mmap_param_attrs(self, pipeline: nn.Module) -> None:
+        """Save loader metadata before ``to_empty`` replaces Parameters."""
+        self._mmap_param_attrs = {
+            name: {attr: value for attr in self._MMAP_PARAM_ATTRS if (value := getattr(param, attr, None)) is not None}
+            for name, param in pipeline.named_parameters()
+        }
+
+    def _attach_mmap_param_attrs(
+        self,
+        name: str,
+        replacement: nn.Parameter,
+        source: nn.Parameter | None = None,
+    ) -> None:
+        attrs = getattr(self, "_mmap_param_attrs", {}).get(name, {})
+        for attr in self._MMAP_PARAM_ATTRS:
+            value = attrs.get(attr)
+            if value is None and source is not None:
+                value = getattr(source, attr, None)
+            if value is not None:
+                setattr(replacement, attr, value)
+                if attr == "mmap_weight_transform":
+                    replacement.mmap_weight_transform_pending = True
+
+    def _load_weights_via_mmap(self, pipeline: nn.Module, modules) -> None:
+        """Load DiT weights from safetensors via mmap views (no RSS).
+
+        When the transformer is created on meta device, this method
+        replaces meta params with mmap views of the checkpoint files.
+        The views point to OS page cache (shared across ranks), so
+        no private copy is created.  _shard_and_pin then copies only
+        the 1/dp_size shard from the mmap view to a private buffer.
+
+        Non-DiT modules (VAE, encoders) are NOT affected — they were
+        created on CPU with real weights via from_pretrained.
+        """
+        import glob
+        import json
+
+        from safetensors import safe_open
+
+        model_path = self.config.model_path
+        if not model_path:
+            logger.warning("No model_path for mmap weight loading, skipping")
+            return
+
+        # Resolve HF repo ID to local snapshot path.
+        # If model_path is a local directory, use it directly; otherwise
+        # download the safetensors index + weight files via HuggingFace Hub.
+        if not os.path.isdir(model_path):
+            from vllm.model_executor.model_loader.weight_utils import (
+                download_weights_from_hf,
+            )
+
+            logger.info("model_path %s is not local, downloading from HF", model_path)
+            model_path = download_weights_from_hf(
+                model_name_or_path=model_path,
+                cache_dir=None,
+                allow_patterns=["*.safetensors", "*.safetensors.index.json"],
+            )
+
+        # Build {checkpoint_key: file_path} from safetensors index
+        weight_map: dict[str, str] = {}
+        for idx_file in glob.glob(os.path.join(model_path, "**", "*.safetensors.index.json"), recursive=True):
+            idx_dir = os.path.dirname(idx_file)
+            with open(idx_file) as f:
+                idx = json.load(f)
+            for key, filename in idx.get("weight_map", {}).items():
+                weight_map[key] = os.path.join(idx_dir, filename)
+
+        if not weight_map:
+            single_files = glob.glob(os.path.join(model_path, "**", "model.safetensors"), recursive=True)
+            for sf in single_files:
+                from safetensors import safe_open as _safe_open
+
+                f = _safe_open(sf, framework="pt", device="cpu")
+                for key in f.keys():
+                    weight_map[key] = sf
+                logger.info("Found single-file safetensors: %s (%d keys)", sf, len(f.keys()))
+
+        if not weight_map:
+            raise RuntimeError(
+                "Distributed layerwise offload could not find safetensors "
+                f"weights at {model_path}. Expected *.safetensors.index.json "
+                "or model.safetensors. Ensure the checkpoint path is correct."
+            )
+
+        logger.info("Loading DiT weights via mmap (meta → page cache, no RSS): %d keys", len(weight_map))
+
+        # --- Convert DiT modules to meta device ---
+        # The transformer was created normally (with random weights and
+        # correct non-persistent buffers from __init__).  We convert it
+        # to meta device to release the random weights (they're useless),
+        # then load real weights via mmap.
+        #
+        # Non-persistent buffers (e.g. RoPE inv_freq, timestep freqs) are
+        # NOT in the checkpoint — they are computed from formulas in
+        # __init__.  Save them before meta conversion and restore after
+        # mmap loading, so we don't need model-specific buffer rebuild code.
+        #
+        # Fail closed for unsupported configurations BEFORE to_empty.
+        # The mmap path bypasses AutoWeightsLoader, which means TP-aware
+        # weight_loader callbacks (fused QKV, row-parallel, etc.) are not
+        # invoked.  When TP > 1, these callbacks shard weights across TP
+        # ranks — skipping them produces incorrect weights.
+        # Check the actual TP world size from parallel_state (initialized
+        # before enable()).  Note: params may have custom weight_loader
+        # attributes even at TP=1 (e.g. QKVParallelLinear), so we cannot
+        # reject based on attribute presence alone.
+        try:
+            from vllm.distributed.parallel_state import (
+                get_tensor_model_parallel_world_size,
+            )
+
+            tp_world = get_tensor_model_parallel_world_size()
+        except Exception:
+            tp_world = 1
+        if tp_world > 1:
+            raise ValueError(
+                "Distributed layerwise offload with mmap loading does not "
+                "support Tensor Parallel (TP > 1). TP-aware weight_loader "
+                "callbacks are bypassed by the mmap path. Use DP or SP "
+                "instead of TP, or disable distributed layerwise offload."
+            )
+
+        # ``Module.to_empty`` creates new Parameter objects and drops custom
+        # attributes installed by vLLM weight loaders.  Preserve them by full
+        # pipeline name so mmap replacements can reproduce checkpoint layout
+        # transforms such as MiniMax-H3 grouped QKV.
+        self._remember_mmap_param_attrs(pipeline)
+
+        #
+        # Important: when DiT modules are nested (e.g. transformer contains
+        # transformer.language_model), to_empty("meta") on the parent
+        # converts the child's buffers too.  So we must save ALL buffers
+        # from ALL DiT modules BEFORE any to_empty call.
+        saved_buffers: dict[int, dict[str, torch.Tensor]] = {}
+        for dit_module in modules.dits:
+            bufs: dict[str, torch.Tensor] = {}
+            for name, buf in dit_module.named_buffers():
+                # Check if this buffer is non-persistent on its OWNING module
+                owner = dit_module
+                parts = name.split(".")
+                for part in parts[:-1]:
+                    owner = getattr(owner, part)
+                buf_name = parts[-1]
+                is_non_persistent = buf_name in owner._non_persistent_buffers_set
+                # Save if non-persistent OR already meta (shouldn't happen
+                # before to_empty, but be safe)
+                if is_non_persistent:
+                    bufs[name] = buf.detach().clone()
+            saved_buffers[id(dit_module)] = bufs
+
+        # Now convert all DiT modules to meta (after saving all buffers).
+        # Skip modules that are already meta (happens when a parent DiT
+        # module contains a child DiT module — to_empty on the parent
+        # already converted the child).
+        for dit_module in modules.dits:
+            if any(p.is_meta for p in dit_module.parameters()):
+                logger.info(
+                    "%s already on meta device (skipping to_empty, %d buffers saved)",
+                    dit_module.__class__.__name__,
+                    len(saved_buffers.get(id(dit_module), {})),
+                )
+                continue
+            dit_module.to_empty(device="meta")
+            logger.info(
+                "Converted %s to meta device (%d non-persistent buffers saved)",
+                dit_module.__class__.__name__,
+                len(saved_buffers.get(id(dit_module), {})),
+            )
+
+        # Build reverse mapping {model_param_name: (ckpt_key, file_path)} using
+        # the pipeline's _remap_ckpt_key (if available).  This handles the
+        # model-specific checkpoint key remapping (e.g., Cosmos3's
+        # layers.0.mlp_moe_gen.gate_proj → transformer.gen_layers.0.mlp.gate_proj).
+        remap_fn = getattr(type(pipeline), "_remap_ckpt_key", None)
+        model_to_ckpt: dict[str, tuple[str, str]] = {}
+        if remap_fn is not None:
+            for ckpt_key, file_path in weight_map.items():
+                model_name = remap_fn(ckpt_key)
+                if model_name is not None:
+                    model_to_ckpt[model_name] = (ckpt_key, file_path)
+            logger.info(
+                "Built reverse remap: %d model params from %d checkpoint keys", len(model_to_ckpt), len(weight_map)
+            )
+        else:
+            # No remap function — use checkpoint keys directly
+            for ckpt_key, file_path in weight_map.items():
+                model_to_ckpt[ckpt_key] = (ckpt_key, file_path)
+
+        # Collect all meta params in DiT modules
+        dit_ids = set()
+        for dit_module in modules.dits:
+            dit_ids.update(id(m) for m in dit_module.modules())
+
+        # Cache open file handles
+        file_cache: dict[str, Any] = {}
+        loaded = 0
+        skipped = 0
+        loaded_names: set[str] = set()
+
+        # Discover blocks first so we can distinguish block params (deferred
+        # to _shard_and_pin) from non-block params (loaded here as mmap views).
+        block_module_ids: set[int] = set()
+        for dit_module in modules.dits:
+            blocks_attr_names, blocks = get_blocks_from_dit(dit_module)
+            for block in blocks:
+                block_module_ids.update(id(m) for m in block.modules())
+
+        for name, param in pipeline.named_parameters():
+            if not (hasattr(param, "is_meta") and param.is_meta):
+                continue
+
+            # Check if this param is inside a block (will be handled by
+            # _shard_and_pin via mmap views in section 2 below).
+            parent = pipeline
+            parts = name.split(".")
+            is_block_param = False
+            for part in parts[:-1]:
+                try:
+                    if part.isdigit():
+                        parent = parent[int(part)]
+                    else:
+                        parent = getattr(parent, part)
+                except (AttributeError, IndexError, TypeError):
+                    break
+                if id(parent) in block_module_ids:
+                    is_block_param = True
+                    break
+
+            if is_block_param:
+                # Block param — will be loaded as mmap view in section 2
+                continue
+
+            # Non-block param (merger, patch_embed, norm, proj_out, etc.)
+            # Look up in reverse remap mapping (handles Cosmos3 key remapping).
+            entry = model_to_ckpt.get(name)
+            if entry is None:
+                skipped += 1
+                continue
+
+            ckpt_key, file_path = entry
+            if file_path not in file_cache:
+                file_cache[file_path] = safe_open(file_path, framework="pt", device="cpu")
+            f = file_cache[file_path]
+            tensor = f.get_tensor(ckpt_key)
+
+            # Replace meta param with mmap view (no copy!)
+            parent = pipeline
+            for part in parts[:-1]:
+                if part.isdigit():
+                    parent = parent[int(part)]
+                else:
+                    parent = getattr(parent, part)
+            replacement = torch.nn.Parameter(tensor, requires_grad=param.requires_grad)
+            self._attach_mmap_param_attrs(name, replacement, param)
+            parent._parameters[parts[-1]] = replacement
+            loaded += 1
+            loaded_names.add(name)
+
+        logger.info("Mmap weight loading: %d non-block params loaded, %d skipped", loaded, skipped)
+
+        # Now load DiT block params from safetensors using mmap views.
+        # Each block param is assigned an mmap view (no RSS).
+        # _shard_and_pin will later copy the shard portion to a private buffer.
+        block_loaded = 0
+        for dit_idx, dit_module in enumerate(modules.dits):
+            dit_name = modules.dit_names[dit_idx]
+            blocks_attr_names, blocks = get_blocks_from_dit(dit_module)
+            if not blocks:
+                continue
+
+            # Determine the blocks_attr for this DiT module (e.g. "layers" or "gen_layers")
+            blocks_attr = None
+            for attr_name in blocks_attr_names:
+                if hasattr(dit_module, attr_name):
+                    candidate = getattr(dit_module, attr_name)
+                    if isinstance(candidate, nn.ModuleList) and len(candidate) > 1:
+                        blocks_attr = attr_name
+                        break
+
+            for block_idx, block in enumerate(blocks):
+                # Build the full model param prefix for this block
+                # e.g. "transformer.language_model.layers.0" or "transformer.gen_layers.0"
+                block_full_prefix = f"{dit_name}.{blocks_attr}.{block_idx}"
+
+                for bname, bparam in block.named_parameters():
+                    if not (hasattr(bparam, "is_meta") and bparam.is_meta):
+                        continue
+
+                    # Use reverse remap to find checkpoint key
+                    full_param_name = f"{block_full_prefix}.{bname}"
+                    entry = model_to_ckpt.get(full_param_name)
+                    if entry is None:
+                        skipped += 1
+                        continue
+
+                    ckpt_key, file_path = entry
+                    if file_path not in file_cache:
+                        file_cache[file_path] = safe_open(file_path, framework="pt", device="cpu")
+                    f = file_cache[file_path]
+                    tensor = f.get_tensor(ckpt_key)
+
+                    # Replace meta param with mmap view
+                    parent = block
+                    bparts = bname.split(".")
+                    for part in bparts[:-1]:
+                        if part.isdigit():
+                            parent = parent[int(part)]
+                        else:
+                            parent = getattr(parent, part)
+                    replacement = torch.nn.Parameter(tensor, requires_grad=bparam.requires_grad)
+                    self._attach_mmap_param_attrs(full_param_name, replacement, bparam)
+                    parent._parameters[bparts[-1]] = replacement
+                    block_loaded += 1
+                    loaded_names.add(full_param_name)
+
+        logger.info("Mmap block loading: %d params loaded, %d skipped", block_loaded, skipped)
+
+        # Strict validation: check that all meta params were loaded.
+        # This replaces the validation that AutoWeightsLoader.load_weights()
+        # performs in the regular load path.
+        remaining_meta = [
+            name for name, param in pipeline.named_parameters() if hasattr(param, "is_meta") and param.is_meta
+        ]
+        if remaining_meta:
+            # Filter out params inside submodules that will be loaded later
+            # by _load_module_weights_from_mmap (non-block submodules)
+            dit_param_names = set()
+            for dit_module in modules.dits:
+                for pname, _ in dit_module.named_parameters():
+                    dit_param_names.add(pname)
+            truly_missing = [n for n in remaining_meta if n in dit_param_names]
+            if truly_missing:
+                logger.warning(
+                    "Mmap loading: %d params still on meta device after "
+                    "loading (first 5: %s). These may be loaded later by "
+                    "_load_module_weights_from_mmap or are expected to be "
+                    "meta (e.g. DTensor placeholders).",
+                    len(truly_missing),
+                    truly_missing[:5],
+                )
+
+        # Keep file handles open — _shard_and_pin will read from the mmap views.
+        # They will be released after _shard_and_pin completes (when params are
+        # replaced with offload placeholders).
+        self._mmap_file_cache = file_cache
+        self._mmap_model_to_ckpt = model_to_ckpt
+
+        # The regular loader runs model-specific post-load transforms after
+        # assigning checkpoint tensors. The mmap path bypasses that loader, so
+        # preserve the same lifecycle for transforms such as Cosmos3's fp32
+        # timestep embedder.
+        for dit_module in modules.dits:
+            post_load_weights = getattr(dit_module, "post_load_weights", None)
+            if callable(post_load_weights):
+                post_load_weights()
+
+            # Call validate_loaded_weights if the model defines it.
+            # This preserves the sound-weight and action-weight validation
+            # that AutoWeightsLoader.load_weights() triggers in the regular
+            # load path (e.g. Cosmos3 checks for missing audio/action weights).
+            validate = getattr(dit_module, "validate_loaded_weights", None)
+            if callable(validate):
+                validate(loaded_names)
+
+            # Restore non-persistent buffers that were saved before meta
+            # conversion.  These buffers (e.g. RoPE inv_freq, timestep
+            # freqs) are computed from formulas in __init__ and are not
+            # present in the checkpoint.  By saving and restoring them
+            # generically, we avoid model-specific buffer rebuild code.
+            bufs = saved_buffers.get(id(dit_module), {})
+            for name, buf in bufs.items():
+                parent = dit_module
+                parts = name.split(".")
+                for part in parts[:-1]:
+                    if part.isdigit():
+                        parent = parent[int(part)]
+                    else:
+                        parent = getattr(parent, part)
+                # Place on the same device as the module's parameters
+                # Place on the offloader's target device (not the module's
+                # current device, which may still be meta at this point).
+                parent._buffers[parts[-1]] = buf.to(self.device)
+
+    def _load_module_weights_from_mmap(self, module: nn.Module, dit_name: str, child_name: str) -> None:
+        """Load a non-block DiT submodule's weights from safetensors via mmap."""
+        from safetensors import safe_open
+
+        if not hasattr(self, "_mmap_file_cache") or not self._mmap_file_cache:
+            return
+
+        file_cache = self._mmap_file_cache
+        model_to_ckpt = getattr(self, "_mmap_model_to_ckpt", {})
+        loaded = 0
+
+        for pname, param in module.named_parameters():
+            if not (hasattr(param, "is_meta") and param.is_meta):
+                continue
+
+            # Build full model param name and look up in reverse remap
+            full_name = f"{dit_name}.{child_name}.{pname}"
+            entry = model_to_ckpt.get(full_name)
+            if entry is None:
+                # Try without dit_name prefix
+                full_name = f"{child_name}.{pname}"
+                entry = model_to_ckpt.get(full_name)
+            if entry is None:
+                continue
+
+            ckpt_key, file_path = entry
+            if file_path not in file_cache:
+                file_cache[file_path] = safe_open(file_path, framework="pt", device="cpu")
+            f = file_cache[file_path]
+            tensor = f.get_tensor(ckpt_key)
+
+            # Replace meta param with mmap view
+            parent = module
+            parts = pname.split(".")
+            for part in parts[:-1]:
+                if part.isdigit():
+                    parent = parent[int(part)]
+                else:
+                    parent = getattr(parent, part)
+            replacement = torch.nn.Parameter(tensor, requires_grad=param.requires_grad)
+            self._attach_mmap_param_attrs(full_name, replacement, param)
+            parent._parameters[parts[-1]] = replacement
+            loaded += 1
+
+        if loaded > 0:
+            logger.info("Loaded %d params for submodule %s.%s via mmap", loaded, dit_name, child_name)
+
+    def _init_dp_group(self) -> None:
+        """Reuse the process group initialized by parallel_state.
+
+        When DP > 1, uses the DP group (handles strided groups with SP/CFG/PP).
+        When DP = 1 but SP > 1 (and dp_size was set to sp_size in OffloadConfig),
+        uses the SP group so weights are sharded across SP ranks.
+        """
+        if self.dp_size <= 1:
+            logger.info("Distributed layerwise offload: dp_size=1, running without AllGather")
+            self.dp_group = None
+            return
+
+        if not torch.distributed.is_initialized():
+            raise RuntimeError(
+                "torch.distributed is not initialized. "
+                "Distributed layerwise offload with dp_size > 1 requires "
+                "an initialized process group."
+            )
+
+        from vllm_omni.diffusion.distributed.parallel_state import (
+            get_data_parallel_world_size,
+            get_dp_group,
+        )
+
+        # Determine which parallel group to use for sharding.
+        # When data_parallel_size > 1, use the DP group.
+        # When data_parallel_size == 1 but dp_size > 1 (set from sp_size in
+        # OffloadConfig), use the SP group for weight sharding.
+        dp_world = get_data_parallel_world_size()
+        if dp_world > 1:
+            coord = get_dp_group()
+        else:
+            from vllm_omni.diffusion.distributed.parallel_state import get_sp_group
+
+            coord = get_sp_group()
+            logger.info(
+                "Distributed layerwise offload: DP=1, using SP group (world_size=%d) for weight sharding",
+                coord.world_size,
+            )
+
+        self.dp_group = coord.device_group
+        self.rank = coord.rank_in_group
+        self.dp_size = coord.world_size
+
+        logger.info(
+            "Distributed layerwise offload: dp_size=%d, rank_in_group=%d, global_rank=%d, group_ranks=%s",
+            self.dp_size,
+            self.rank,
+            coord.rank,
+            coord.ranks,
+        )
+
+    def _register_on_demand_hook(self, module: nn.Module, label: str, *, stage_on_demand: bool = False) -> None:
+        """Prepare a pipeline-managed stage component or keep it resident.
+
+        Components that expose an explicit stage lifecycle are initially
+        offloaded and loaded by their pipeline only around encode/decode.
+        Other models retain the conservative resident behavior because a
+        generic post-forward hook can disrupt the DiT prefetch streams.
+        """
+        offload_to_cpu = getattr(module, "offload_to_cpu", None)
+        if stage_on_demand and callable(offload_to_cpu):
+            offload_to_cpu()
+            logger.info("Prepared %s (%s) for pipeline-managed staged offload", label, module.__class__.__name__)
+            return
+        module.to(self.device)
+        logger.info("Moved %s (%s) to GPU (resident)", label, module.__class__.__name__)
+
+    def _try_layerwise_offload_encoder(self, module: nn.Module, name: str, plan: OffloadPlan | None) -> bool:
+        """Stream plan-declared encoder blocks on each rank without AllGather."""
+        if plan is None or name not in plan.encoder_block_attrs:
+            return False
+        if getattr(module, "_omni_layerwise_enabled", False):
+            return True
+
+        from operator import attrgetter
+
+        from vllm_omni.diffusion.offloader.layerwise_backend import apply_block_hook
+
+        hooks = []
+        block_groups = []
+        copy_stream = current_omni_platform.Stream()
+        for block_path in plan.encoder_block_attrs[name]:
+            try:
+                blocks = attrgetter(block_path)(module)
+            except AttributeError:
+                logger.warning("Encoder offload path %s.%s was not found", name, block_path)
+                continue
+            if not isinstance(blocks, nn.ModuleList) or len(blocks) <= 1:
+                logger.warning("Encoder offload path %s.%s is not a streamable block list", name, block_path)
+                continue
+            group_hooks = [
+                apply_block_hook(blocks[-1], blocks[0], self.device, copy_stream, self.config.pin_cpu_memory)
+            ]
+            group_hooks.extend(
+                apply_block_hook(block, blocks[index + 1], self.device, copy_stream, self.config.pin_cpu_memory)
+                for index, block in enumerate(blocks[:-1])
+            )
+            for index, hook in enumerate(group_hooks):
+                hook._prev_hook = group_hooks[index - 1]
+            hooks.extend(group_hooks)
+            block_groups.append(blocks)
+
+        if not hooks:
+            return False
+        # The component lifecycle uses these generic attributes to keep only
+        # non-block encoder state resident during the encode phase.
+        module._omni_layerwise_hooks = hooks
+        module._omni_layerwise_block_groups = block_groups
+        module._omni_layerwise_enabled = True
+        logger.info(
+            "Enabled rank-local layerwise offload for encoder %s (%d blocks across %d stacks)",
+            name,
+            sum(len(blocks) for blocks in block_groups),
+            len(block_groups),
+        )
+        return True
+
+    def _try_layerwise_offload_submodule(self, module: nn.Module, name: str, plan: OffloadPlan | None = None) -> bool:
+        """Try to apply layerwise offload to a large submodule's blocks.
+        Resolution order:
+        1. OffloadPlan.offload_submodules (declarative, if plan is provided)
+        2. Heuristic search for common block-list attributes
+
+        Returns True if layerwise offload was applied, False otherwise.
+        """
+        from operator import attrgetter
+
+        blocks = None
+        blocks_attr = None
+
+        # 1. Check OffloadPlan first (declarative — no guessing)
+        if plan is not None and name in plan.offload_submodules:
+            attr_name = plan.offload_submodules[name]
+            try:
+                candidate = attrgetter(attr_name)(module)
+                if isinstance(candidate, nn.ModuleList) and len(candidate) > 1:
+                    blocks = candidate
+                    blocks_attr = attr_name
+            except AttributeError:
+                logger.warning(
+                    "OffloadPlan declared block attr '%s' for submodule '%s' "
+                    "but attribute not found — falling back to heuristic",
+                    attr_name,
+                    name,
+                )
+
+        # 2. Fallback: heuristic search
+        if blocks is None:
+            for attr_name in ("layers", "blocks", "h", "model.layers"):
+                try:
+                    candidate = attrgetter(attr_name)(module)
+                except AttributeError:
+                    continue
+                if isinstance(candidate, nn.ModuleList) and len(candidate) > 1:
+                    blocks = candidate
+                    blocks_attr = attr_name
+                    break
+
+        if blocks is None:
+            return False
+
+        num_blocks = len(blocks)
+        logger.info(
+            "Distributed layerwise offload for submodule '%s.%s' (%d blocks, %.0f MB total, dp_size=%d)",
+            name,
+            blocks_attr,
+            num_blocks,
+            sum(p.nelement() * p.element_size() for p in module.parameters()) / 1048576,
+            self.dp_size,
+        )
+
+        # Move non-block parts of the submodule to GPU (small: embeddings, norms)
+        for child_name, child in module.named_children():
+            if child_name != blocks_attr:
+                child.to(self.device)
+
+        # Apply distributed hooks (1/4 sharding + AllGather, same as DiT)
+        # Pass shared_buffers=[None,None] to defer per-hook allocation
+        # (prevents OOM on large models where N hooks × 2 buffers >> HBM)
+        last_block, first_block = blocks[-1], blocks[0]
+        last_hook = apply_distributed_block_hook(
+            last_block,
+            first_block,
+            self.device,
+            self.dp_group,
+            self.dp_size,
+            self.rank,
+            self.copy_stream,
+            self.comm_stream,
+            self.config.pin_cpu_memory,
+            shared_buffers=[None, None],
+        )
+        sub_hooks = [last_hook]
+        for i, block in enumerate(blocks[:-1]):
+            next_block = blocks[(i + 1) % num_blocks]
+            hook = apply_distributed_block_hook(
+                block,
+                next_block,
+                self.device,
+                self.dp_group,
+                self.dp_size,
+                self.rank,
+                self.copy_stream,
+                self.comm_stream,
+                self.config.pin_cpu_memory,
+                shared_buffers=[None, None],
+            )
+            sub_hooks.append(hook)
+
+        # Wire backward references + slot alternation
+        for i in range(len(sub_hooks)):
+            sub_hooks[i]._prev_hook = sub_hooks[i - 1]
+        # Assign slots in list order: sub_hooks = [last_hook, block0, ..., blockN-2]
+        # This ensures last_hook.current_slot != block0_hook.current_slot,
+        # so the circular prefetch (last_hook -> block0) writes to a
+        # different slot than block0 reads from.  Correct for ALL N.
+        for i, hook in enumerate(sub_hooks):
+            hook.current_slot = i % 2
+        # Mark block0_hook (index 1) as group-first — it must sync-prefetch
+        # on entry because another group may have overwritten the shared slot.
+        if len(sub_hooks) > 1:
+            sub_hooks[1]._is_group_first = True
+
+        # Defer buffer allocation and prefetch to enable() unified allocation
+        self._all_hook_groups.append(sub_hooks)
+        self._blocks.append(blocks)
+        return True
+
+    def _prepare_dit_non_block_modules(
+        self,
+        dit_module: nn.Module,
+        dit_name: str,
+        blocks_attr_names: list[str],
+        all_dit_modules: set[int],
+        plan: OffloadPlan | None,
+    ) -> None:
+        """Place or hook the DiT parts that are outside its repeated blocks.
+
+        This must run even when every repeated block is resident.  Otherwise
+        an all-resident stage skips placement for modules such as H3's token
+        refiner and enters the forward pass with CPU or meta tensors.
+        """
+        _ON_DEMAND_THRESHOLD = _ON_DEMAND_THRESHOLD_MB
+        for name, module in dit_module.named_children():
+            if name in blocks_attr_names:
+                logger.debug("Skipped blocks module %s", name)
+                continue
+
+            has_meta = any(getattr(param, "is_meta", False) for param in module.parameters())
+            if has_meta:
+                self._load_module_weights_from_mmap(module, dit_name, name)
+            module_mb = (
+                sum(
+                    param.nelement() * param.element_size() if not getattr(param, "is_meta", False) else 0
+                    for param in module.parameters()
+                )
+                / 1048576
+            )
+            explicitly_planned = plan is not None and name in plan.offload_submodules
+            if explicitly_planned or module_mb > _ON_DEMAND_THRESHOLD:
+                if id(module) in all_dit_modules:
+                    logger.info("Submodule '%s' is already a DiT module, skipping layerwise offload", name)
+                elif self._try_layerwise_offload_submodule(module, name, plan):
+                    pass
+                else:
+                    self._register_on_demand_hook(module, name)
+                continue
+
+            try:
+                module.to(self.device)
+            except (NotImplementedError, RuntimeError):
+                self._load_module_weights_from_mmap(module, dit_name, name)
+                # Non-persistent buffers such as RoPE frequencies do not
+                # exist in the checkpoint and must be reconstructed.
+                has_meta_buffer = any(getattr(buffer, "is_meta", False) for buffer in module.buffers(recurse=True))
+                if has_meta_buffer:
+                    saved_params = {
+                        param_name: param.data.clone()
+                        for param_name, param in module.named_parameters()
+                        if not getattr(param, "is_meta", False)
+                    }
+                    module.to_empty(device=self.device)
+                    for submodule in module.modules():
+                        if hasattr(submodule, "reset_parameters"):
+                            submodule.reset_parameters()
+                    for param_name, param in module.named_parameters():
+                        if param_name in saved_params:
+                            param.data.copy_(saved_params[param_name])
+                try:
+                    module.to(self.device)
+                except Exception:
+                    logger.warning("Module %s still has meta params after mmap load", name)
+
+        for param in dit_module._parameters.values():
+            if param is not None and not getattr(param, "is_meta", False):
+                param.data = param.data.to(self.device, non_blocking=True)
+        for buffer in dit_module._buffers.values():
+            if buffer is not None:
+                buffer.data = buffer.data.to(self.device, non_blocking=True)
+
+    def enable(self, pipeline: nn.Module) -> None:
+        if self.enabled:
+            logger.warning("DistributedLayerwiseOffloadBackend already enabled")
+            return
+
+        self._on_demand_shard_infos: list[dict] = []
+        self._on_demand_handles: list[Any] = []
+
+        # Initialize DP group (if not already done by early init)
+        if self.dp_group is None and self.dp_size > 1:
+            self._init_dp_group()
+
+        modules = ModuleDiscovery.discover(pipeline)
+        if not modules.dits:
+            logger.warning("No DiT/transformer modules found, skipping distributed layer-wise offloading")
+            return
+
+        # Retrieve optional declarative OffloadPlan from the pipeline.
+        # When present, replaces heuristic block discovery.
+        plan = get_offload_plan(pipeline)
+
+        if self.config.dlo_resident_layers and (plan is None or not plan.resident_dit_paths):
+            logger.warning(
+                "dlo_resident_layers=%d was requested, but this model declares no "
+                "resident_dit_paths; all blocks will be streamed.",
+                self.config.dlo_resident_layers,
+            )
+
+        # Load weights via mmap for DLO+AllGather.
+        # TODO(offload): Add a rank-local mmap path for dlo_no_use_allgather.
+        # It must apply declarative checkpoint-to-runtime adapters before the
+        # standard TP loader shards each block, and must cover staged encoders
+        # and VAEs as well as DiT blocks. The current AllGather mmap path is
+        # deliberately not reused because it changes the weight layout.
+        # Gate condition MUST match diffusers_loader.py:
+        #   supports_mmap_loading(pipeline) and not _has_online_quant
+        # When the gate is False, the loader has already loaded weights via
+        # regular load_weights() + _process_weights_after_loading().
+        if self.config.dlo_use_allgather and self.dp_size > 1:
+            _has_online_quant = any(
+                getattr(getattr(module, "quant_method", None), "uses_meta_device", False)
+                for module in pipeline.modules()
+            )
+            if _has_online_quant:
+                raise ValueError(
+                    "Online quantization is incompatible with DLO+AllGather: "
+                    "the sharding + AllGather mechanism flattens weights by "
+                    "dtype, which breaks quantized weight/scale layouts. "
+                    "Please use --dlo-no-use-allgather or disable online "
+                    "quantization."
+                )
+            if supports_mmap_loading(pipeline):
+                self._load_weights_via_mmap(pipeline, modules)
+            else:
+                logger.info("Weights loaded via regular loader — skipping mmap (model does not support mmap)")
+
+        # Keep VAE/encoders on CPU; move to GPU on-demand via hooks.
+        # This saves ~4.3 GB HBM per card (VAE 1.3 + encoder 1.1 + sound 1.9)
+        # during the DiT forward pass.  They are only needed briefly for
+        # text-encoding (before DiT) and VAE-decode (after DiT).
+        for enc, enc_name in zip(modules.encoders, modules.encoder_names):
+            self._try_layerwise_offload_encoder(enc, enc_name, plan)
+            self._register_on_demand_hook(
+                enc, "encoder", stage_on_demand=plan is not None and enc_name in plan.on_demand_component_paths
+            )
+        for vae, vae_name in zip(modules.vaes, modules.vae_names):
+            self._register_on_demand_hook(
+                vae,
+                "vae",
+                stage_on_demand=(plan is not None and vae_name in plan.on_demand_component_paths),
+            )
+
+        # Move resident modules to GPU (small modules needed every forward)
+        for name, module in zip(modules.resident_names, modules.resident_modules):
+            try:
+                module.to(self.device)
+            except Exception as exc:
+                logger.debug("Failed to move resident module %s to GPU: %s", name, exc)
+
+        logger.info("Applying distributed layer-wise offloading on %s", modules.dit_names)
+
+        # Collect all DiT module objects to detect submodules that are
+        # already handled as a separate DiT module (avoids duplicate hooks).
+        all_dit_modules = set(id(m) for m in modules.dits)
+
+        # Apply hooks for each DiT module
+        for i, dit_module in enumerate(modules.dits):
+            dit_name = modules.dit_names[i]
+            logger.info(f"Applying hooks on {dit_name} ({dit_module.__class__.__name__})")
+
+            blocks_attr_names, blocks = get_blocks_from_dit(dit_module)
+
+            if not blocks:
+                logger.warning(
+                    "Target layers (blocks) not found. Skipping offloading on %s (%s)",
+                    dit_name,
+                    dit_module.__class__.__name__,
+                )
+                dit_module.to(self.device)
+                continue
+
+            resident_count = 0
+            if plan is not None and dit_name in plan.resident_dit_paths:
+                resident_count = min(self.config.dlo_resident_layers, len(blocks))
+            if resident_count:
+                resident_blocks = blocks[:resident_count]
+                self._resident_blocks.extend(resident_blocks)
+                blocks = blocks[resident_count:]
+                logger.info(
+                    "Keeping %d leading blocks resident on %s; streaming %d tail blocks",
+                    resident_count,
+                    dit_name,
+                    len(blocks),
+                )
+
+            self._prepare_dit_non_block_modules(
+                dit_module,
+                dit_name,
+                blocks_attr_names,
+                all_dit_modules,
+                plan,
+            )
+
+            num_blocks = len(blocks)
+            if num_blocks == 0:
+                logger.info("All blocks for %s are resident; no streaming hooks required", dit_name)
+                continue
+            if num_blocks <= 1:
+                logger.warning(
+                    "#Streaming target layers (blocks) <= 1. Keeping the final block resident on %s (%s)",
+                    dit_name,
+                    dit_module.__class__.__name__,
+                )
+                self._resident_blocks.extend(blocks)
+                continue
+
+            # Register hooks in a circular sliding window:
+            # last block prefetches first block, block i prefetches block (i+1)
+            # All hooks share 2 global device buffers (RFC: "exactly two layers on device")
+            last_block, first_block = blocks[-1], blocks[0]
+
+            # Pass 1: create hooks with deferred buffer allocation
+            # (shared_buffers=[None,None] prevents per-hook OOM on large models)
+            last_hook = apply_distributed_block_hook(
+                last_block,
+                first_block,
+                self.device,
+                self.dp_group,
+                self.dp_size,
+                self.rank,
+                self.copy_stream,
+                self.comm_stream,
+                self.config.pin_cpu_memory,
+                shared_buffers=[None, None],
+            )
+
+            block_hooks: list[DistributedLayerwiseOffloadHook] = [last_hook]
+            for i, block in enumerate(blocks[:-1]):
+                next_block = blocks[(i + 1) % num_blocks]
+                hook = apply_distributed_block_hook(
+                    block,
+                    next_block,
+                    self.device,
+                    self.dp_group,
+                    self.dp_size,
+                    self.rank,
+                    self.copy_stream,
+                    self.comm_stream,
+                    self.config.pin_cpu_memory,
+                    shared_buffers=[None, None],
+                )
+                block_hooks.append(hook)
+
+            # Wire backward references for cache-dit fallback
+            for i in range(len(block_hooks)):
+                block_hooks[i]._prev_hook = block_hooks[i - 1]
+
+            # Assign slots in list order: block_hooks = [last_hook, block0, ..., blockN-2]
+            # This ensures last_hook.current_slot != block0_hook.current_slot,
+            # so the circular prefetch (last_hook -> block0) writes to a
+            # different slot than block0 reads from.  Correct for ALL N.
+            for i, hook in enumerate(block_hooks):
+                hook.current_slot = i % 2
+
+            # Mark block0_hook (index 1) as group-first
+            if len(block_hooks) > 1:
+                block_hooks[1]._is_group_first = True
+
+            # Defer buffer allocation — collected for unified allocation below
+            self._all_hook_groups.append(block_hooks)
+            self._blocks.append(blocks)
+
+        if self._resident_blocks:
+            self._resident_layer_group = PinnedResidentLayerGroup(
+                self._resident_blocks,
+                self.device,
+                self.copy_stream,
+                self.config.pin_cpu_memory,
+            )
+            pipeline._dlo_residency_controller = self
+
+        if not self._all_hook_groups:
+            self.enabled = bool(self._resident_blocks)
+            return
+
+        # Unified allocation: 2 shared output buffers + 2 shared shard buffers
+        # sized to the max block across ALL module groups (gen_layers +
+        # language_model).  Groups execute sequentially, so 2 buffers suffice.
+        all_hooks: list[DistributedLayerwiseOffloadHook] = []
+        for group in self._all_hook_groups:
+            all_hooks.extend(group)
+
+        unified_buffers = self._allocate_shared_buffers(all_hooks)
+        unified_shard_buffers = None
+        if self.dp_size > 1:
+            unified_shard_buffers = self._allocate_shared_shard_buffers(all_hooks)
+
+        # Shared slot-group tracker: _shared_slot_group[slot] = group_id
+        # that last wrote to that slot.  Group-first hooks use this to
+        # skip sync-prefetch when the slot still contains their own data.
+        shared_slot_group = [-1, -1]
+
+        for group_idx, group in enumerate(self._all_hook_groups):
+            for hook in group:
+                hook.gpu_buffers = unified_buffers
+                hook._owns_buffers = False
+                if unified_shard_buffers is not None:
+                    hook.gpu_shard_buffers = unified_shard_buffers
+                hook._group_id = group_idx
+                hook._shared_slot_group = shared_slot_group
+
+        # Prefetch first block of the FIRST module group only.
+        # Subsequent groups share the same 2 device buffers; prefetching
+        # them now would overwrite the first group's data in the shared
+        # buffer (both groups default to slot 0).  Instead, subsequent
+        # groups' first blocks remain as meta placeholders, and their
+        # pre_forward will sync-prefetch on-demand via the is_materialized
+        # check — by which point the first group's forward has completed
+        # and its buffer slots are free.
+        if self._all_hook_groups:
+            group = self._all_hook_groups[0]
+            first_slot = group[0].current_slot
+            group[-1].prefetch_layer(slot=first_slot, non_blocking=False)
+            group[-1].get_weights(first_slot)
+
+        total_blocks = sum(len(b) for b in self._blocks)
+        logger.info(
+            f"Distributed layer-wise offloading enabled on {total_blocks} blocks "
+            f"across {len(self._all_hook_groups)} group(s), dp_size={self.dp_size}, "
+            f"unified shared_buffers=2"
+        )
+
+        self.enabled = True
+
+        # Release mmap file handles — _shard_and_pin has copied all shards,
+        # params now point to offload placeholders (not mmap views).
+        self._release_mmap_handles()
+
+        # Assign GPU buffers to sharded on-demand modules (VAE/encoders).
+        # Each module gets a dedicated input (shard-sized) and output
+        # (full-sized) buffer.  VAE/encoders run before/after DiT, never
+        # concurrently, so peak HBM = max(DiT, VAE) not sum.
+        for si in self._on_demand_shard_infos:
+            out_bufs: dict[torch.dtype, torch.Tensor] = {}
+            in_bufs: dict[torch.dtype, torch.Tensor] = {}
+            for dtype, shard in si["cpu_shards"].items():
+                # AllGather output = dp_size * shard_size
+                full_size = shard.numel() * self.dp_size if self.dp_size > 1 else shard.numel()
+                out_bufs[dtype] = torch.empty(full_size, dtype=dtype, device=self.device)
+                in_bufs[dtype] = torch.empty(shard.shape, dtype=dtype, device=self.device)
+            si["gpu_output"] = out_bufs
+            si["gpu_input"] = in_bufs
+            _mb = sum(t.nelement() * t.element_size() for t in out_bufs.values()) / 1048576
+            logger.info("Allocated %.0f MB GPU buffer for sharded on-demand module", _mb)
+
+        self._cleanup_after_loading()
+
+    def _release_mmap_handles(self) -> None:
+        """Release safetensors mmap file handles."""
+        if hasattr(self, "_mmap_file_cache"):
+            self._mmap_file_cache.clear()
+            del self._mmap_file_cache
+            if hasattr(self, "_mmap_model_to_ckpt"):
+                del self._mmap_model_to_ckpt
+            logger.info("Released safetensors mmap file handles")
+
+    def _cleanup_after_loading(self) -> None:
+        """Synchronize and release freed device/CPU memory after sharding."""
+        current_omni_platform.synchronize()
+        current_omni_platform.empty_cache()
+        import ctypes as _ctypes
+        import gc as _gc
+
+        _gc.collect()
+        try:
+            _ctypes.CDLL("libc.so.6").malloc_trim(0)
+        except Exception:
+            pass
+
+    def disable(self) -> None:
+        if not self.enabled:
+            return
+
+        for blocks in self._blocks:
+            for block in blocks:
+                remove_distributed_block_hook(block)
+
+        for h in getattr(self, "_on_demand_handles", []):
+            h.remove()
+        self._on_demand_handles = []
+        self._on_demand_shard_infos = []
+
+        self.offload_resident_layers()
+        self._blocks.clear()
+        self._all_hook_groups.clear()
+        self._resident_blocks.clear()
+        self._resident_layer_group = None
+        self.enabled = False
+        logger.info("Distributed layer-wise offloading disabled")
+
+    @staticmethod
+    def _allocate_shared_buffers(
+        hooks: list[DistributedLayerwiseOffloadHook],
+    ) -> list[dict[torch.dtype, torch.Tensor] | None]:
+        """Allocate exactly 2 shared device buffers sized to the largest block.
+
+        All hooks share these 2 buffers. At any time, slot 0 holds the current
+        layer's weights and slot 1 holds the next layer's weights (or vice
+        versa). This ensures only 2 layers' worth of weights reside on device,
+        regardless of the total number of blocks.
+        """
+        max_sizes: dict[torch.dtype, int] = {}
+        for hook in hooks:
+            dp = hook.dp_size
+            for dtype, metas in hook.metadata.items():
+                total = sum(m["numel"] for m in metas)
+                # AllGather output = dp * ceil(total/dp) (padded for equal shards)
+                if dp > 1:
+                    total = ((total + dp - 1) // dp) * dp
+                if dtype not in max_sizes or total > max_sizes[dtype]:
+                    max_sizes[dtype] = total
+
+        device = hooks[0].device
+        shared_buffers: list[dict[torch.dtype, torch.Tensor] | None] = [None, None]
+        for slot in range(2):
+            gpu_weights: dict[torch.dtype, torch.Tensor] = {}
+            for dtype, total_numel in max_sizes.items():
+                gpu_weights[dtype] = torch.empty(total_numel, dtype=dtype, device=device)
+            shared_buffers[slot] = gpu_weights
+
+        logger.info(
+            "Allocated 2 shared device buffers (max block size: %s)",
+            {str(k): f"{v * _dtype_size(k) / 1024 / 1024:.1f}MB" for k, v in max_sizes.items()},
+        )
+        return shared_buffers
+
+    @staticmethod
+    def _allocate_shared_shard_buffers(
+        hooks: list[DistributedLayerwiseOffloadHook],
+    ) -> list[dict[torch.dtype, torch.Tensor] | None]:
+        """Allocate 2 shared shard (AllGather input) buffers sized to the
+        largest per-rank shard.
+
+        All hooks share these 2 input buffers — the same device address is
+        reused for every layer's AllGather so HCCL can reuse its internal
+        communication buffers (preventing rank-dependent HBM imbalance).
+        Cost: 2 × max_shard_size (~184 MB) instead of 2 × N_hooks × shard.
+        """
+        max_shard_sizes: dict[torch.dtype, int] = {}
+        for hook in hooks:
+            for dtype, shard in hook.cpu_shards.items():
+                numel = shard.numel()
+                if dtype not in max_shard_sizes or numel > max_shard_sizes[dtype]:
+                    max_shard_sizes[dtype] = numel
+
+        device = hooks[0].device
+        shared_shard_buffers: list[dict[torch.dtype, torch.Tensor] | None] = [None, None]
+        for slot in range(2):
+            shard_bufs: dict[torch.dtype, torch.Tensor] = {}
+            for dtype, numel in max_shard_sizes.items():
+                shard_bufs[dtype] = torch.empty(numel, dtype=dtype, device=device)
+            shared_shard_buffers[slot] = shard_bufs
+
+        logger.info(
+            "Allocated 2 shared shard buffers (max shard size: %s)",
+            {str(k): f"{v * _dtype_size(k) / 1024 / 1024:.1f}MB" for k, v in max_shard_sizes.items()},
+        )
+        return shared_shard_buffers
diff --git a/vllm_omni/diffusion/offloader/module_collector.py b/vllm_omni/diffusion/offloader/module_collector.py
index 17d4ca2fd..b93c9ed73 100644
--- a/vllm_omni/diffusion/offloader/module_collector.py
+++ b/vllm_omni/diffusion/offloader/module_collector.py
@@ -19,6 +19,7 @@ class PipelineModules:
     encoders: list[nn.Module]
     encoder_names: list[str]
     vaes: list[nn.Module]
+    vae_names: list[str] = field(default_factory=list)
     resident_modules: list[nn.Module] = field(default_factory=list)
     resident_names: list[str] = field(default_factory=list)
 
@@ -80,11 +81,13 @@ class ModuleDiscovery:
         "text_encoder_2",
         "text_encoder_3",
         "image_encoder",
+        "vision_encoder",
         "mllm",
     ]
     _FALLBACK_VAE_ATTRS = [
         "vae",
         "audio_vae",
+        "sound_tokenizer",
     ]
 
     @staticmethod
@@ -151,7 +154,7 @@ class ModuleDiscovery:
 
         dit_modules, dit_names = ModuleDiscovery._collect_modules(pipeline, dit_attrs, warn_missing=declared)
         encoders, encoder_names = ModuleDiscovery._collect_modules(pipeline, enc_attrs, warn_missing=declared)
-        vaes, _ = ModuleDiscovery._collect_modules(pipeline, vae_attrs, warn_missing=declared)
+        vaes, vae_names = ModuleDiscovery._collect_modules(pipeline, vae_attrs, warn_missing=declared)
         residents, resident_names = ModuleDiscovery._collect_modules(pipeline, res_attrs, warn_missing=declared)
 
         return PipelineModules(
@@ -161,5 +164,6 @@ class ModuleDiscovery:
             encoder_names=encoder_names,
             vaes=vaes,
             resident_modules=residents,
+            vae_names=vae_names,
             resident_names=resident_names,
         )
diff --git a/vllm_omni/diffusion/offloader/module_residency.py b/vllm_omni/diffusion/offloader/module_residency.py
new file mode 100644
index 000000000..da32ab520
--- /dev/null
+++ b/vllm_omni/diffusion/offloader/module_residency.py
@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""On-demand module staging backed by an immutable pinned CPU snapshot."""
+
+from __future__ import annotations
+
+from itertools import chain
+from typing import Any
+
+import torch
+from torch import nn
+
+from vllm_omni.platforms import current_omni_platform
+
+from .tensor_utils import set_tensor_storage
+
+
+class PinnedModuleStager:
+    """Stage an immutable module without copying device weights back to CPU.
+
+    ``nn.Module.to("cpu")`` performs a device-to-host copy for every parameter
+    after each forward. In inference the weights are immutable, so retain one
+    pinned CPU master instead. ``load`` materializes fresh device tensors from
+    that master; ``offload`` only rebinds the Parameters/Buffers to it and
+    releases the device allocations.
+    """
+
+    def __init__(
+        self,
+        module: nn.Module,
+        device: torch.device,
+        *,
+        pin_memory: bool = True,
+        copy_stream: Any | None = None,
+    ) -> None:
+        self.device = device
+        self.copy_stream = copy_stream or current_omni_platform.Stream()
+        self.loaded = False
+        self._entries: list[tuple[torch.Tensor, torch.Tensor]] = []
+        self._device_tensors: list[torch.Tensor] = []
+
+        # parameters()/buffers() remove duplicate objects by default, which
+        # preserves tied weights and buffer aliases when their storage moves.
+        for target in chain(module.parameters(), module.buffers()):
+            master = target.detach()
+            if master.device.type != "cpu":
+                master = master.to("cpu")
+            if pin_memory and not master.is_pinned():
+                master = master.pin_memory()
+            set_tensor_storage(target, master)
+            self._entries.append((target, master))
+
+    def load(self) -> None:
+        if self.loaded:
+            return
+
+        # Allocate on the compute stream so the caching allocator can reuse
+        # memory released by the preceding encoder/DiT stage.
+        device_tensors = [torch.empty_like(master, device=self.device) for _, master in self._entries]
+        compute_stream = current_omni_platform.current_stream()
+        self.copy_stream.wait_stream(compute_stream)
+        ready = current_omni_platform.Event()
+        with current_omni_platform.stream(self.copy_stream):
+            for device_tensor, (_, master) in zip(device_tensors, self._entries):
+                device_tensor.copy_(master, non_blocking=master.is_pinned())
+            ready.record(self.copy_stream)
+
+        for device_tensor, (target, _) in zip(device_tensors, self._entries):
+            set_tensor_storage(target, device_tensor)
+        compute_stream.wait_event(ready)
+        self._device_tensors = device_tensors
+        self.loaded = True
+
+    def offload(self) -> None:
+        if not self.loaded:
+            return
+
+        # The module has completed on the compute stream. Synchronize once at
+        # the stage boundary, then release HBM by rebinding to the unchanged
+        # host masters. No device-to-host transfer is necessary.
+        current_omni_platform.synchronize()
+        for target, master in self._entries:
+            set_tensor_storage(target, master)
+        self._device_tensors.clear()
+        self.loaded = False
+        current_omni_platform.empty_cache()
+
+
+__all__ = ["PinnedModuleStager"]
diff --git a/vllm_omni/diffusion/offloader/offload_plan.py b/vllm_omni/diffusion/offloader/offload_plan.py
new file mode 100644
index 000000000..f8943757e
--- /dev/null
+++ b/vllm_omni/diffusion/offloader/offload_plan.py
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Declarative OffloadPlan for distributed layerwise offload.
+
+Models declare this as a class attribute ``_offload_plan`` on the
+pipeline class. When present, the offloader uses it instead of
+heuristic block discovery.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from torch import nn
+
+
+@dataclass(frozen=True)
+class OffloadPlan:
+    """Optional declarative metadata for distributed layerwise offload.
+
+    Models declare this as a class attribute ``_offload_plan`` on the
+    pipeline class.  When present, the offloader uses it instead of
+    heuristic block discovery, making it easier to support new models
+    without offload-specific logic in constructor or forward code.
+
+    If not declared, the offloader falls back to:
+    1. ``_layerwise_offload_blocks_attrs`` on each DiT module class.
+    2. Heuristic search for ``layers`` / ``blocks`` / ``h`` attributes.
+
+    Attributes:
+        block_attrs: Maps DiT path → tuple of block-list attribute names.
+            e.g. ``{"transformer": ("gen_layers",),
+                    "transformer.language_model": ("layers",)}``
+        offload_submodules: Maps child name → block-list attribute name,
+            for large non-DiT submodules within a DiT that should be
+            independently offloaded with their own hooks.
+            e.g. ``{"context_encoder": "layers"}``
+        resident_dit_paths: DiT paths whose leading blocks may be kept on the
+            device when ``dlo_resident_layers`` is nonzero. Keeping this
+            model-declared avoids applying a consumer-GPU tuning knob to
+            auxiliary or dual DiTs unintentionally.
+        encoder_block_attrs: Maps encoder paths to rank-local block-list paths.
+            These blocks are streamed with ordinary layerwise hooks, never
+            with the DiT AllGather group.
+    """
+
+    on_demand_component_paths: frozenset[str] = field(default_factory=frozenset)
+
+    block_attrs: dict[str, tuple[str, ...]] = field(default_factory=dict)
+    offload_submodules: dict[str, str] = field(default_factory=dict)
+    resident_dit_paths: frozenset[str] = field(default_factory=frozenset)
+    encoder_block_attrs: dict[str, tuple[str, ...]] = field(default_factory=dict)
+
+
+def get_offload_plan(pipeline: nn.Module) -> OffloadPlan | None:
+    """Retrieve the OffloadPlan declared by the pipeline, if any."""
+    return getattr(pipeline, "_offload_plan", None)
+
+
+def supports_mmap_loading(pipeline: nn.Module) -> bool:
+    """Whether the pipeline supports mmap weight loading.
+
+    A pipeline supports mmap if any module defines ``_remap_ckpt_key``,
+    which maps checkpoint keys to model parameter names.  Models without
+    this method must use the regular ``load_weights()`` path.
+
+    This check is shared between ``diffusers_loader.py`` (to decide whether
+    to skip ``load_weights``) and ``DistributedLayerwiseOffloadBackend.enable()``
+    (to decide whether to call ``_load_weights_via_mmap``), ensuring both
+    paths use the same gate condition.
+    """
+    return bool(getattr(pipeline, "_supports_mmap_loading", True)) and any(
+        callable(getattr(type(m), "_remap_ckpt_key", None)) for m in pipeline.modules()
+    )
diff --git a/vllm_omni/diffusion/offloader/tensor_utils.py b/vllm_omni/diffusion/offloader/tensor_utils.py
new file mode 100644
index 000000000..ef2d96011
--- /dev/null
+++ b/vllm_omni/diffusion/offloader/tensor_utils.py
@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Shared tensor utilities for distributed layerwise offload.
+
+These helpers are used by both DistributedLayerwiseOffloadHook and
+DistributedLayerwiseOffloadBackend, and can be reused by other
+offload backends.
+"""
+
+from __future__ import annotations
+
+import torch
+from torch.distributed.tensor import DTensor
+
+
+def dtype_size(dtype: torch.dtype) -> int:
+    """Return element size in bytes for a torch.dtype."""
+    return torch.empty(1, dtype=dtype).element_size()
+
+
+def is_dtensor(t: torch.Tensor) -> bool:
+    """Check if tensor is a DTensor."""
+    return isinstance(t, DTensor)
+
+
+def set_tensor_storage(target: torch.Tensor, value: torch.Tensor) -> None:
+    """Replace target's underlying storage with value (zero-copy)."""
+    if is_dtensor(target):
+        target._local_tensor = value
+    else:
+        target.data = value
+
+
+def make_offload_placeholder(tensor: torch.Tensor) -> torch.Tensor:
+    """Create a zero-element placeholder to free GPU memory."""
+    if is_dtensor(tensor):
+        local_shape = tuple(tensor.to_local().shape)
+        return torch.empty(local_shape, device="meta", dtype=tensor.dtype)
+    return torch.empty((0,), device=tensor.device, dtype=tensor.dtype)
+
+
+def is_materialized_tensor(t: torch.Tensor) -> bool:
+    """Check if tensor holds real data (not meta or empty placeholder)."""
+    if is_dtensor(t):
+        local_t = t.to_local()
+        return not local_t.is_meta
+    return not t.is_meta and t.data.numel() > 0
diff --git a/vllm_omni/diffusion/output_formatter.py b/vllm_omni/diffusion/output_formatter.py
index a36305fce..d5b03443c 100644
--- a/vllm_omni/diffusion/output_formatter.py
+++ b/vllm_omni/diffusion/output_formatter.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from typing import TypeGuard
+from typing import TypeGuard, cast
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.io_support import supports_audio_output
@@ -27,14 +27,6 @@ from vllm_omni.outputs.output_metadata import (
 )
 
 
-@dataclass(frozen=True)
-class DiffusionStepTimings:
-    preprocess_time_s: float
-    exec_time_s: float
-    postprocess_time_s: float
-    total_time_ms: float
-
-
 @dataclass(frozen=True)
 class DiffusionPostprocessOutput:
     outputs: DiffusionPayload
@@ -134,25 +126,23 @@ def format_diffusion_outputs(
     diffusion_output: DiffusionOutput,
     output_data: DiffusionPostprocessRawOutput,
     postprocess_output: DiffusionPostprocessOutput,
-    timings: DiffusionStepTimings,
 ) -> list[OmniRequestOutput]:
     """Convert a finished diffusion model output into API-facing outputs."""
 
     primary_payload = _primary_payload(postprocess_output)
     outputs = _ensure_list(primary_payload)
     metrics = {
-        "preprocess_time_ms": timings.preprocess_time_s * 1000,
-        "diffusion_engine_exec_time_ms": timings.exec_time_s * 1000,
-        "diffusion_engine_total_time_ms": timings.total_time_ms,
         "image_num": int(request.sampling_params.num_outputs_per_prompt),
-        "resolution": int(request.sampling_params.resolution),
-        "postprocess_time_ms": timings.postprocess_time_s * 1000,
+        "resolution": (
+            int(request.sampling_params.resolution) if request.sampling_params.resolution is not None else None
+        ),
+        "width": request.sampling_params.width,
+        "height": request.sampling_params.height,
     }
 
-    # Detect text output: when the pipeline returns a string (e.g.,
-    # SenseNova-U1 / BAGEL single-stage img2text / text2text), wrap it
-    # as a text-type response instead of an image.
-    is_text_output = postprocess_output.primary_key == "text" or "text" in postprocess_output.metadata
+    # Only the primary payload determines the response type. Some image models
+    # include reasoning text in metadata, but their final output is still an image.
+    is_text_output = postprocess_output.primary_key == "text"
 
     is_audio_output = supports_audio_output(od_config.model_class_name)
     audio_sample_rate = _metadata_audio_sample_rate(postprocess_output.metadata)
@@ -160,6 +150,13 @@ def format_diffusion_outputs(
         model_cls = DiffusionModelRegistry._try_load_model_cls(od_config.model_class_name)
         audio_sample_rate = getattr(model_cls, "audio_sample_rate", None)
 
+    stream_metadata = _stream_metadata_from_diffusion_output(diffusion_output)
+    if stream_metadata:
+        existing_stream = postprocess_output.metadata.get("stream")
+        merged_stream = dict(existing_stream) if isinstance(existing_stream, Mapping) else {}
+        merged_stream.update(stream_metadata)
+        postprocess_output.metadata["stream"] = merged_stream
+
     return _format_single_prompt_output(
         request=request,
         prompt=request.prompt,
@@ -174,6 +171,27 @@ def format_diffusion_outputs(
     )
 
 
+def _stream_metadata_from_diffusion_output(diffusion_output: DiffusionOutput) -> DiffusionMetadata | None:
+    has_stream_data = (
+        diffusion_output.total_chunks > 1
+        or not diffusion_output.finished
+        or bool(diffusion_output.started_event_ids)
+        or bool(diffusion_output.active_event_ids)
+        or bool(diffusion_output.completed_event_ids)
+    )
+    if not has_stream_data:
+        return None
+    return cast(
+        DiffusionMetadata,
+        {
+            "generation_chunk_index": diffusion_output.chunk_index,
+            "started_event_ids": diffusion_output.started_event_ids,
+            "active_event_ids": diffusion_output.active_event_ids,
+            "completed_event_ids": diffusion_output.completed_event_ids,
+        },
+    )
+
+
 def _ensure_list(outputs: DiffusionPayloadValue) -> list[DiffusionPayloadValue]:
     if isinstance(outputs, list):
         return outputs
diff --git a/vllm_omni/diffusion/output_metadata.py b/vllm_omni/diffusion/output_metadata.py
deleted file mode 100644
index abea8759e..000000000
--- a/vllm_omni/diffusion/output_metadata.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Compatibility imports for diffusion output metadata.
-
-The shared output payload and metadata schema lives in
-``vllm_omni.outputs.output_metadata``.  Keep this module as a stable import
-path for existing diffusion callers.
-"""
-
-from vllm_omni.outputs.output_metadata import *  # noqa: F403
diff --git a/vllm_omni/diffusion/prompt_update.py b/vllm_omni/diffusion/prompt_update.py
new file mode 100644
index 000000000..400838035
--- /dev/null
+++ b/vllm_omni/diffusion/prompt_update.py
@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Midway prompt updates for chunked diffusion step execution.
+
+``PromptUpdateMixin`` exposes
+- a pipeline interface for the external to queue a prompt update,
+- a pipeline internal method to apply prompt transitions at chunk boundaries.
+
+``prompt_update_versions``: a helper for ``InputBatch`` cache invalidation.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from dataclasses import dataclass
+from threading import Lock
+from typing import ClassVar, TypedDict, cast
+
+import torch
+
+from vllm_omni.diffusion.worker.utils import StepRequestState
+
+DEFAULT_TRANSITION_CHUNKS = 3
+
+logger = logging.getLogger(__name__)
+
+
+class PromptUpdateExtra(TypedDict, total=False):
+    """A "protocol" for ``StepRequestState.extra`` keys used by the prompt-update feature."""
+
+    pending_prompt_update: _PendingPromptUpdate
+    prompt_update_state: _PromptUpdateState
+    prompt_update_chunk_metadata: _PromptUpdateChunkMetadata
+    prompt_update_version: int  # Bumped when prompt_embeds change; invalidates InputBatch cache.
+
+    # The lock for storing/updating pending prompt updates.
+    # Saved in state.extra to be naturally cleaned up with the request state.
+    # As PromptUpdateMixin (the pipeline) currently lacks an obvious request-finish hook
+    prompt_update_lock: Lock
+
+
+def prompt_update_versions(states: Sequence[StepRequestState]) -> tuple[int, ...]:
+    """Return per-request prompt-update versions for batch cache comparison.
+
+    To be used by ``InputBatch`` or other external to determine if the cached batch is still valid.
+    """
+    return tuple(int(cast(PromptUpdateExtra, state.extra).get("prompt_update_version", 0)) for state in states)
+
+
+class PromptUpdateMixin:
+    """Mixin for chunked streaming pipelines that support midway prompt updates.
+
+    Implements the behavior expected by :class:`~vllm_omni.diffusion.models.interface.SupportsPromptUpdate`.
+    All per-request transition state lives on ``StepRequestState.extra``; this mixin itself is stateless.
+    """
+
+    supports_prompt_update: ClassVar[bool] = True
+
+    @staticmethod
+    def _prompt_update_lock(extra: PromptUpdateExtra) -> Lock:
+        return extra.setdefault("prompt_update_lock", Lock())
+
+    def prepare_prompt_update(
+        self,
+        state: StepRequestState,
+        prompt: str,
+        event_id: str,
+        transition_chunks: int | None = None,
+    ) -> None:
+        """Encode and queue a prompt update to apply at the next chunk boundary.
+        It does not actually apply the prompt transition.
+
+        This is an extended interface for the pipeline, to be called by the runner.
+        """
+        if not prompt:
+            raise ValueError("prompt must be non-empty")
+        if not event_id:
+            raise ValueError("event_id must be non-empty")
+        if state.prompt_embeds is None:
+            raise ValueError(
+                f"prompt_update is not allowed before initial generation has started (request_id={state.request_id!r})"
+            )
+        duration = DEFAULT_TRANSITION_CHUNKS if transition_chunks is None else transition_chunks
+        if duration < 0:
+            raise ValueError("transition_chunks must be >= 0")
+
+        target_prompt_embeds, _ = self.encode_prompt(
+            prompt=prompt,
+            negative_prompt=None,
+            do_classifier_free_guidance=False,
+            num_videos_per_prompt=state.sampling.num_outputs_per_prompt,
+            max_sequence_length=state.sampling.max_sequence_length,
+            device=self.device,
+            dtype=self.transformer.dtype,
+        )
+        extra = cast(PromptUpdateExtra, state.extra)
+        with self._prompt_update_lock(extra):
+            extra["pending_prompt_update"] = {
+                "event_id": event_id,
+                "prompt": prompt,
+                "target_prompt_embeds": target_prompt_embeds,
+                "transition_chunks": duration,
+            }
+
+    def _apply_prompt_update_at_chunk_boundary(self, state: StepRequestState) -> None:
+        """Advance or start prompt interpolation before the next chunk."""
+        extra = cast(PromptUpdateExtra, state.extra)
+        update_state: _PromptUpdateState | None = extra.get("prompt_update_state")
+        with self._prompt_update_lock(extra):
+            pending = extra.pop("pending_prompt_update", None)
+        embeds_changed = False
+        next_chunk_index = state.chunk_index
+        started_event_ids: list[str] = []
+        active_event_ids: list[str] = []
+        completed_event_ids: list[str] = []
+
+        # If current transition is not complete, advance it.
+        # After completion, leave prompt_update_state in place (so a later pending
+        # update can abort/overwrite), but do not keep bumping the version.
+        if update_state is not None:
+            in_transition = (
+                update_state.transition_chunks > 0
+                and update_state.elapsed_transition_chunks < update_state.transition_chunks
+            )
+            if in_transition:
+                update_state.advance_transition()
+                state.prompt_embeds = update_state.blended_prompt_embeds()
+                embeds_changed = True
+                active_event_ids.append(update_state.event_id)
+                if update_state.elapsed_transition_chunks >= update_state.transition_chunks:
+                    state.prompt_embeds = update_state.target_prompt_embeds
+                    update_state.source_prompt_embeds = update_state.target_prompt_embeds
+                    completed_event_ids.append(update_state.event_id)
+                    if update_state.target_prompt is not None:
+                        logger.debug(
+                            "prompt_update transition complete request_id=%s next_chunk_index=%d prompt=%.20s...",
+                            state.request_id,
+                            next_chunk_index,
+                            update_state.target_prompt,
+                        )
+
+        # If a new prompt update is pending, start a new transition.
+        if pending is not None:
+            if state.prompt_embeds is None:
+                raise RuntimeError(
+                    "internal error: trying to apply a pending prompt update but "
+                    f"current prompt_embeds is None (request_id={state.request_id!r})"
+                )
+            source = state.prompt_embeds.detach().clone()
+            target = pending["target_prompt_embeds"]
+            duration = int(pending["transition_chunks"])
+            prompt = str(pending.get("prompt", ""))
+            event_id = pending.get("event_id")
+            update_state = _PromptUpdateState(
+                source_prompt_embeds=source,
+                target_prompt_embeds=target,
+                transition_chunks=duration,
+                event_id=event_id,
+                target_prompt=prompt,
+            )
+            extra["prompt_update_state"] = update_state
+            started_event_ids.append(event_id)
+            active_event_ids.append(event_id)
+            if duration <= 0:
+                # A hard/immediate transition
+                state.prompt_embeds = target
+                completed_event_ids.append(event_id)
+                logger.debug(
+                    "prompt_update sharp transition request_id=%s next_chunk_index=%d prompt=%.20s...",
+                    state.request_id,
+                    next_chunk_index,
+                    prompt,
+                )
+            else:
+                # A transition that really takes some time
+                update_state.advance_transition()
+                state.prompt_embeds = update_state.blended_prompt_embeds()
+                if update_state.elapsed_transition_chunks >= update_state.transition_chunks:
+                    state.prompt_embeds = update_state.target_prompt_embeds
+                    update_state.source_prompt_embeds = update_state.target_prompt_embeds
+                    completed_event_ids.append(event_id)
+                logger.debug(
+                    "prompt_update transition start request_id=%s next_chunk_index=%d prompt=%.20s...",
+                    state.request_id,
+                    next_chunk_index,
+                    prompt,
+                )
+            embeds_changed = True
+
+        # Indicate that prompt embeddings have changed---clear input batch cache.
+        if embeds_changed:
+            new_version = int(extra.get("prompt_update_version", 0)) + 1
+            extra["prompt_update_version"] = new_version
+
+        extra["prompt_update_chunk_metadata"] = {
+            "started_event_ids": started_event_ids,
+            "active_event_ids": active_event_ids,
+            "completed_event_ids": completed_event_ids,
+        }
+
+
+@dataclass
+class _PromptUpdateState:
+    """Per-request prompt interpolation stored in ``state.extra["prompt_update_state"]``."""
+
+    source_prompt_embeds: torch.Tensor
+    target_prompt_embeds: torch.Tensor
+    transition_chunks: int
+    event_id: str
+    elapsed_transition_chunks: int = 0
+    target_prompt: str | None = None
+
+    def blended_prompt_embeds(self) -> torch.Tensor:
+        alpha = self._current_alpha()
+        if alpha >= 1.0:
+            return self.target_prompt_embeds
+        return (1.0 - alpha) * self.source_prompt_embeds + alpha * self.target_prompt_embeds
+
+    def advance_transition(self) -> None:
+        if self.transition_chunks <= 0:
+            self.source_prompt_embeds = self.target_prompt_embeds
+            return
+        self.elapsed_transition_chunks += 1
+        if self.elapsed_transition_chunks >= self.transition_chunks:
+            self.source_prompt_embeds = self.target_prompt_embeds
+            self.elapsed_transition_chunks = self.transition_chunks
+
+    def _current_alpha(self) -> float:
+        if self.transition_chunks <= 0:
+            return 1.0
+        return min(1.0, self.elapsed_transition_chunks / self.transition_chunks)
+
+
+class _PendingPromptUpdate(TypedDict):
+    event_id: str
+    prompt: str
+    target_prompt_embeds: torch.Tensor
+    transition_chunks: int
+
+
+class _PromptUpdateChunkMetadata(TypedDict):
+    started_event_ids: list[str]
+    active_event_ids: list[str]
+    completed_event_ids: list[str]
diff --git a/vllm_omni/diffusion/registry.py b/vllm_omni/diffusion/registry.py
index 1454a37b1..a45f3bdee 100644
--- a/vllm_omni/diffusion/registry.py
+++ b/vllm_omni/diffusion/registry.py
@@ -71,20 +71,10 @@ _DIFFUSION_MODELS = {
         "pipeline_ltx2",
         "LTX2Pipeline",
     ),
-    "LTX2ImageToVideoPipeline": (
+    "LTX2DistilledPipeline": (
         "ltx2",
-        "pipeline_ltx2_image2video",
-        "LTX2ImageToVideoPipeline",
-    ),
-    "LTX2TwoStagesPipeline": (
-        "ltx2",
-        "pipeline_ltx2",
-        "LTX2TwoStagesPipeline",
-    ),
-    "LTX2ImageToVideoTwoStagesPipeline": (
-        "ltx2",
-        "pipeline_ltx2_image2video",
-        "LTX2ImageToVideoTwoStagesPipeline",
+        "pipeline_ltx2_two_stage",
+        "LTX2DistilledPipeline",
     ),
     "LTX2T2VDMD2Pipeline": (
         "ltx2",
@@ -93,18 +83,18 @@ _DIFFUSION_MODELS = {
     ),
     "LTX2I2VDMD2Pipeline": (
         "ltx2",
-        "pipeline_ltx2_image2video",
+        "pipeline_ltx2",
         "LTX2I2VDMD2Pipeline",
     ),
-    "LTX23Pipeline": (
-        "ltx2",
-        "pipeline_ltx2_3",
-        "LTX23Pipeline",
+    "MiniMaxH3Pipeline": (
+        "minimax_h3",
+        "pipeline_minimax_h3",
+        "MiniMaxH3Pipeline",
     ),
-    "LTX23ImageToVideoPipeline": (
-        "ltx2",
-        "pipeline_ltx2_3_image2video",
-        "LTX23ImageToVideoPipeline",
+    "MiniMaxH3ModularPipeline": (
+        "minimax_h3",
+        "pipeline_minimax_h3",
+        "MiniMaxH3Pipeline",
     ),
     "StableAudioPipeline": (
         "stable_audio",
@@ -141,6 +131,11 @@ _DIFFUSION_MODELS = {
         "pipeline_bagel",
         "BagelPipeline",
     ),
+    "BooguImagePipeline": (
+        "boogu_image",
+        "pipeline_boogu_image",
+        "BooguImagePipeline",
+    ),
     "LancePipeline": (
         "lance",
         "pipeline_lance",
@@ -256,6 +251,11 @@ _DIFFUSION_MODELS = {
         "pipeline_hunyuan_video_1_5_i2v",
         "HunyuanVideo15I2VPipeline",
     ),
+    "LingBotVideoPipeline": (
+        "lingbot_video",
+        "pipeline_lingbot_video",
+        "LingBotVideoPipeline",
+    ),
     "MagiHumanPipeline": (
         "magi_human",
         "pipeline_magi_human",
@@ -276,6 +276,11 @@ _DIFFUSION_MODELS = {
         "pipeline_cosmos3",
         "Cosmos3OmniDiffusersPipeline",
     ),
+    "Cosmos3OmniPipeline": (
+        "cosmos3",
+        "pipeline_cosmos3",
+        "Cosmos3OmniDiffusersPipeline",
+    ),
     "SoulXSingerPipeline": (
         "soulx_singer",
         "pipeline_soulx_singer_svs",
@@ -427,14 +432,16 @@ def _apply_sequence_parallel_if_enabled(model, od_config: OmniDiffusionConfig) -
         if sp_size <= 1:
             return
 
-        # Find transformer model(s) in the pipeline that have _sp_plan
-        # Include transformer_2 for two-stage models (e.g., Wan MoE)
-        transformer_attrs = ["transformer", "transformer_2", "dit", "unet"]
+        # Prefer the pipeline's declared DiT components so custom component
+        # names receive the same SP hooks as conventional transformer names.
+        transformer_attrs = getattr(model, "_dit_modules", None)
+        if not transformer_attrs:
+            transformer_attrs = ("transformer", "transformer_2", "dit", "unet")
         applied_count = 0
 
         for attr in transformer_attrs:
             if not hasattr(model, attr):
-                # Some pipeline like LTX2TwoStagesPipeline have recursive
+                # Some pipelines have recursive
                 # modules that have the transformer
                 module = find_module_with_attr(model, attr)
                 if module is None:
@@ -449,18 +456,25 @@ def _apply_sequence_parallel_if_enabled(model, od_config: OmniDiffusionConfig) -
             if plan is None:
                 continue
 
-            # Create SP config
-            sp_config = SequenceParallelConfig(
-                ulysses_degree=od_config.parallel_config.ulysses_degree,
-                ring_degree=od_config.parallel_config.ring_degree,
-            )
+            # AllGather-KV reuses the Ulysses sequence-sharding hooks.
+            allgather_degree = getattr(od_config.parallel_config, "allgather_degree", 1)
+            if allgather_degree > 1:
+                sp_config = SequenceParallelConfig(
+                    allgather_degree=allgather_degree,
+                )
+                mode = "allgather_kv"
+            else:
+                sp_config = SequenceParallelConfig(
+                    ulysses_degree=od_config.parallel_config.ulysses_degree,
+                    ring_degree=od_config.parallel_config.ring_degree,
+                )
+                # Apply hooks according to the plan
+                mode = (
+                    "hybrid"
+                    if sp_config.ulysses_degree > 1 and sp_config.ring_degree > 1
+                    else ("ulysses" if sp_config.ulysses_degree > 1 else "ring")
+                )
 
-            # Apply hooks according to the plan
-            mode = (
-                "hybrid"
-                if sp_config.ulysses_degree > 1 and sp_config.ring_degree > 1
-                else ("ulysses" if sp_config.ulysses_degree > 1 else "ring")
-            )
             logger.info(
                 f"Applying sequence parallelism to {transformer.__class__.__name__} ({attr}) "
                 f"(sp_size={sp_size}, mode={mode}, ulysses={sp_config.ulysses_degree}, ring={sp_config.ring_degree})"
@@ -493,16 +507,15 @@ _DIFFUSION_POST_PROCESS_FUNCS = {
     "GlmImagePipeline": "get_glm_image_post_process_func",
     "ZImagePipeline": "get_post_process_func",
     "OvisImagePipeline": "get_ovis_image_post_process_func",
+    "BooguImagePipeline": "get_boogu_image_post_process_func",
     "WanPipeline": "get_wan22_post_process_func",
     "WanVACEPipeline": "get_wan22_vace_post_process_func",
     "LTX2Pipeline": "get_ltx2_post_process_func",
-    "LTX2TwoStagesPipeline": "get_ltx2_post_process_func",
-    "LTX2ImageToVideoPipeline": "get_ltx2_post_process_func",
-    "LTX2ImageToVideoTwoStagesPipeline": "get_ltx2_post_process_func",
+    "LTX2DistilledPipeline": "get_ltx2_post_process_func",
     "LTX2T2VDMD2Pipeline": "get_ltx2_post_process_func",
     "LTX2I2VDMD2Pipeline": "get_ltx2_post_process_func",
-    "LTX23Pipeline": "get_ltx2_post_process_func",
-    "LTX23ImageToVideoPipeline": "get_ltx2_post_process_func",
+    "MiniMaxH3Pipeline": "get_minimax_h3_post_process_func",
+    "MiniMaxH3ModularPipeline": "get_minimax_h3_post_process_func",
     "StableAudioPipeline": "get_stable_audio_post_process_func",
     "SoulXSingerPipeline": "get_soulxsinger_post_process_func",
     "SoulXSingerSVCPipeline": "get_soulxsinger_post_process_func",
@@ -531,14 +544,18 @@ _DIFFUSION_POST_PROCESS_FUNCS = {
     "Flux2Pipeline": "get_flux2_post_process_func",
     "HunyuanVideo15Pipeline": "get_hunyuan_video_15_post_process_func",
     "HunyuanVideo15ImageToVideoPipeline": "get_hunyuan_video_15_i2v_post_process_func",
+    "HunyuanImage3Pipeline": "get_hunyuan_image3_post_process_func",
+    "LingBotVideoPipeline": "get_lingbot_video_post_process_func",
     "MagiHumanPipeline": "get_magi_human_post_process_func",
     "OmniVoicePipeline": "get_omnivoice_post_process_func",
     "DreamIDOmniPipeline": "get_dreamid_omni_post_process_func",
     "SenseNovaU1Pipeline": "get_sensenova_u1_post_process_func",
     "Cosmos3OmniDiffusersPipeline": "get_cosmos3_post_process_func",
+    "Cosmos3OmniPipeline": "get_cosmos3_post_process_func",
     "HiDreamImagePipeline": "get_hidream_image_post_process_func",
     "StableDiffusionXLPipeline": "get_sdxl_image_post_process_func",
     "Krea2Pipeline": "get_krea2_post_process_func",
+    "HunyuanImage3ForCausalMM": "get_hunyuan_image3_post_process_func",
 }
 
 _DIFFUSION_IR_OP_PRIORITY_FUNCS = {
@@ -546,6 +563,7 @@ _DIFFUSION_IR_OP_PRIORITY_FUNCS = {
     # `ir_op_priority_func` function must be placed in {mod_folder}/{mod_relname}.py,
     # where mod_folder and mod_relname are defined and mapped using `_DIFFUSION_MODELS` via the `arch` key.
     "Cosmos3OmniDiffusersPipeline": "get_cosmos3_ir_op_priority_func",
+    "Cosmos3OmniPipeline": "get_cosmos3_ir_op_priority_func",
 }
 
 _DIFFUSION_PRE_PROCESS_FUNCS = {
@@ -553,6 +571,7 @@ _DIFFUSION_PRE_PROCESS_FUNCS = {
     # `pre_process_func` function must be placed in {mod_folder}/{mod_relname}.py,
     # where mod_folder and mod_relname are  defined and mapped using `_DIFFUSION_MODELS` via the `arch` key
     "GlmImagePipeline": "get_glm_image_pre_process_func",
+    "BooguImagePipeline": "get_boogu_image_pre_process_func",
     "QwenImageEditPipeline": "get_qwen_image_edit_pre_process_func",
     "QwenImageEditPlusPipeline": "get_qwen_image_edit_plus_pre_process_func",
     "LongCatImageEditPipeline": "get_longcat_image_edit_pre_process_func",
@@ -570,6 +589,7 @@ _DIFFUSION_PRE_PROCESS_FUNCS = {
     "HunyuanImage3ForCausalMM": "get_hunyuan_image_3_pre_process_func",
     "MagiHumanPipeline": "get_magi_human_pre_process_func",
     "Cosmos3OmniDiffusersPipeline": "get_cosmos3_pre_process_func",
+    "Cosmos3OmniPipeline": "get_cosmos3_pre_process_func",
     "SoulXSingerPipeline": "get_soulxsinger_pre_process_func",
     "SoulXSingerSVCPipeline": "get_soulxsinger_svc_pre_process_func",
 }
diff --git a/vllm_omni/diffusion/request.py b/vllm_omni/diffusion/request.py
index 42181419c..e1147c3d6 100644
--- a/vllm_omni/diffusion/request.py
+++ b/vllm_omni/diffusion/request.py
@@ -4,6 +4,7 @@
 
 import random
 from dataclasses import dataclass
+from typing import Any
 
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniPromptType
 
@@ -28,7 +29,7 @@ class OmniDiffusionRequest:
     prompt: OmniPromptType
     sampling_params: OmniDiffusionSamplingParams
     request_id: str
-    kv_sender_info: dict | None = None
+    kv_sender_info: dict[str, Any] | None = None
 
     def __post_init__(self):
         """Initialize dependent fields after dataclass initialization."""
@@ -40,12 +41,11 @@ class OmniDiffusionRequest:
         if self.sampling_params.generator is None and self.sampling_params.seed is None:
             self.sampling_params.seed = random.randint(0, 2**31 - 1)
 
-        # Detect whether user explicitly provided guidance_scale.
-        # The sentinel default is 0.0 (false-like); any truthy value means
-        # the caller set it intentionally.  We must resolve this BEFORE
-        # auto-filling guidance_scale_2, otherwise the sentinel leaks into
-        # guidance_scale_2.
-        if self.sampling_params.guidance_scale:
+        # Detect whether the caller explicitly provided guidance_scale before
+        # resolving the omitted value.  ``0.0`` is API-valid and must not be
+        # treated as omission because that would unexpectedly enable CFG in
+        # pipelines with a model-specific default above zero.
+        if self.sampling_params.guidance_scale is not None:
             self.sampling_params.guidance_scale_provided = True
         else:
             self.sampling_params.guidance_scale = 1.0
@@ -56,6 +56,13 @@ class OmniDiffusionRequest:
         ):
             self.sampling_params.do_classifier_free_guidance = True
 
+        # Detect whether the caller explicitly provided guidance_scale_2
+        # BEFORE auto-filling it. Pipelines with a model-specific second
+        # guidance default (e.g. Boogu image_guidance_scale=1.0) must be able
+        # to tell an explicit value apart from the guidance_scale fallback.
+        if self.sampling_params.guidance_scale_2 is not None:
+            self.sampling_params.guidance_scale_2_provided = True
+
         # Auto-fill guidance_scale_2 from the (now-resolved) guidance_scale
         # so downstream code always has a valid value.
         if self.sampling_params.guidance_scale_2 is None:
diff --git a/vllm_omni/diffusion/sched/__init__.py b/vllm_omni/diffusion/sched/__init__.py
index e02637338..29b9cc667 100644
--- a/vllm_omni/diffusion/sched/__init__.py
+++ b/vllm_omni/diffusion/sched/__init__.py
@@ -1,13 +1,15 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+from vllm_omni.diffusion.sched.base_scheduler import BaseScheduler, SchedulerInterface
 from vllm_omni.diffusion.sched.interface import (
     CachedRequestData,
-    DiffusionRequestState,
     DiffusionRequestStatus,
     DiffusionSchedulerOutput,
+    KVPrefetchJob,
     NewRequestData,
-    SchedulerInterface,
+    SchedulerRequestState,
+    StepBatchSamplingParamsKey,
 )
 from vllm_omni.diffusion.sched.request_scheduler import RequestScheduler
 from vllm_omni.diffusion.sched.step_scheduler import StepScheduler
@@ -17,10 +19,13 @@ Scheduler = RequestScheduler
 __all__ = [
     "DiffusionRequestStatus",
     "CachedRequestData",
-    "DiffusionRequestState",
     "DiffusionSchedulerOutput",
+    "KVPrefetchJob",
     "NewRequestData",
+    "SchedulerRequestState",
+    "BaseScheduler",
     "SchedulerInterface",
+    "StepBatchSamplingParamsKey",
     "RequestScheduler",
     "StepScheduler",
     "Scheduler",
diff --git a/vllm_omni/diffusion/sched/base_scheduler.py b/vllm_omni/diffusion/sched/base_scheduler.py
index 9e4b6af5b..5ea91b167 100644
--- a/vllm_omni/diffusion/sched/base_scheduler.py
+++ b/vllm_omni/diffusion/sched/base_scheduler.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from collections import deque
 from dataclasses import fields
 
@@ -12,54 +13,37 @@ from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched.interface import (
     CachedRequestData,
-    DiffusionRequestState,
     DiffusionRequestStatus,
     DiffusionSchedulerOutput,
+    KVPrefetchJob,
     NewRequestData,
     RequestBatchSamplingParamsKey,
-    SamplingParamsKey,
-    SchedulerInterface,
+    SchedulerRequestState,
+    StepBatchSamplingParamsKey,
 )
+from vllm_omni.diffusion.worker.utils import RunnerOutput
 
 logger = init_logger(__name__)
 
+BatchSamplingParamsKey = StepBatchSamplingParamsKey | RequestBatchSamplingParamsKey
+
 # LoRA identity is derived from `sampling.lora_request`, not a same-named field
 # on sampling params, so it must be resolved separately from the bulk lookup.
-_SAMPLING_PARAMS_KEY_FIELD_NAMES = frozenset(f.name for f in fields(SamplingParamsKey)) - {"lora_int_id"}
-_REQUEST_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES = frozenset(f.name for f in fields(RequestBatchSamplingParamsKey)) - {
+_STEP_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES = frozenset(field.name for field in fields(StepBatchSamplingParamsKey)) - {
     "lora_int_id"
 }
 
 
-def get_sampling_params_key(request: OmniDiffusionRequest) -> SamplingParamsKey:
-    """Build a batch-compatibility key from the request's sampling params."""
-    sampling = request.sampling_params
-    lora_request = getattr(sampling, "lora_request", None)
-    return SamplingParamsKey(
-        lora_int_id=lora_request.lora_int_id if lora_request is not None else None,
-        **{name: getattr(sampling, name) for name in _SAMPLING_PARAMS_KEY_FIELD_NAMES},
-    )
-
-
-def get_request_batch_sampling_params_key(request: OmniDiffusionRequest) -> RequestBatchSamplingParamsKey:
-    """Build a request-batch compatibility key from the request's sampling params."""
-    sampling = request.sampling_params
-    lora_request = getattr(sampling, "lora_request", None)
-    key_kwargs = {name: getattr(sampling, name) for name in _REQUEST_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES}
-    key_kwargs["lora_int_id"] = lora_request.lora_int_id if lora_request is not None else None
-    return RequestBatchSamplingParamsKey(**key_kwargs)
-
-
-class _BaseScheduler(SchedulerInterface):
+class BaseScheduler(ABC):
     """Shared queue/state bookkeeping for diffusion schedulers."""
 
     def __init__(self) -> None:
         self.od_config: OmniDiffusionConfig | None = None
-        self._request_states: dict[str, DiffusionRequestState] = {}
+        self._request_states: dict[str, SchedulerRequestState] = {}
         self._step_id: int = 0
         self._waiting: deque[str] = deque()
         self._running: list[str] = []
-        self._running_sampling_params_key: SamplingParamsKey | RequestBatchSamplingParamsKey | None = None
+        self._running_sampling_params_key: BatchSamplingParamsKey | None = None
         self._finished_req_ids: set[str] = set()
         self.max_num_running_reqs: int = 1
         self._prefetch_enabled: bool = False
@@ -129,13 +113,13 @@ class _BaseScheduler(SchedulerInterface):
         # kv_sender_info (would target the wrong sender under multi-replica) or
         # one already finished/aborted (would consume its sender buffer for
         # nothing).
-        kv_prefetch_jobs: dict | None = None
+        kv_prefetch_job: KVPrefetchJob | None = None
         if self._prefetch_enabled and self._waiting:
             nxt = self._request_states.get(self._waiting[0])
             if nxt is not None and not nxt.is_finished():
                 sender_info = getattr(nxt.req, "kv_sender_info", None)
                 if sender_info:
-                    kv_prefetch_jobs = {
+                    kv_prefetch_job = {
                         "request_id": nxt.request_id,
                         "kv_sender_info": sender_info,
                     }
@@ -147,7 +131,7 @@ class _BaseScheduler(SchedulerInterface):
             finished_req_ids=set(self._finished_req_ids),
             num_running_reqs=len(self._running),
             num_waiting_reqs=len(self._waiting),
-            kv_prefetch_jobs=kv_prefetch_jobs,
+            kv_prefetch_job=kv_prefetch_job,
         )
 
         # update after schedule
@@ -155,6 +139,10 @@ class _BaseScheduler(SchedulerInterface):
         self._finished_req_ids.clear()
         return scheduler_output
 
+    @abstractmethod
+    def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
+        pass
+
     def has_requests(self) -> bool:
         return bool(self._waiting or self._running)
 
@@ -164,10 +152,10 @@ class _BaseScheduler(SchedulerInterface):
     def num_running_requests(self) -> int:
         return len(self._running)
 
-    def get_request_state(self, request_id: str) -> DiffusionRequestState | None:
+    def get_request_state(self, request_id: str) -> SchedulerRequestState | None:
         return self._request_states.get(request_id)
 
-    def pop_request_state(self, request_id: str) -> DiffusionRequestState | None:
+    def pop_request_state(self, request_id: str) -> SchedulerRequestState | None:
         self._pop_extra_request_state(request_id)
         return self._request_states.pop(request_id, None)
 
@@ -262,21 +250,21 @@ class _BaseScheduler(SchedulerInterface):
     def _pop_extra_request_state(self, request_id: str) -> None:
         """Remove subclass-owned per-request state before popping request state."""
 
-    def _make_request_state(self, request_id: str, request: OmniDiffusionRequest) -> DiffusionRequestState:
-        return DiffusionRequestState(
+    def _make_request_state(self, request_id: str, request: OmniDiffusionRequest) -> SchedulerRequestState:
+        return SchedulerRequestState(
             request_id=request_id,
             req=request,
             sampling_params_key=self._build_sampling_params_key(request),
         )
 
-    def _can_schedule_waiting(self, state: DiffusionRequestState) -> bool:
+    def _can_schedule_waiting(self, state: SchedulerRequestState) -> bool:
         if not self._running:
             return True
 
         current_key = self._current_sampling_params_key()
         return current_key is not None and current_key == state.sampling_params_key
 
-    def _current_sampling_params_key(self) -> SamplingParamsKey | RequestBatchSamplingParamsKey | None:
+    def _current_sampling_params_key(self) -> BatchSamplingParamsKey | None:
         if self._running_sampling_params_key is not None or not self._running:
             return self._running_sampling_params_key
         state = self._request_states.get(self._running[0])
@@ -285,5 +273,30 @@ class _BaseScheduler(SchedulerInterface):
 
     def _build_sampling_params_key(
         self, request: OmniDiffusionRequest
-    ) -> SamplingParamsKey | RequestBatchSamplingParamsKey | None:
-        return get_sampling_params_key(request)
+    ) -> StepBatchSamplingParamsKey | RequestBatchSamplingParamsKey:  # return type loosened for subclassing
+        """Build a step-batch compatibility key from sampling parameters."""
+        sampling = request.sampling_params
+        # LoRA identity is optional on sampling params (and on test stubs).
+        lora_request = getattr(sampling, "lora_request", None)
+        return StepBatchSamplingParamsKey(
+            lora_int_id=lora_request.lora_int_id if lora_request is not None else None,
+            **{name: getattr(sampling, name) for name in _STEP_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES},
+        )
+
+
+class SchedulerInterface(BaseScheduler):
+    """Deprecated compatibility base for custom scheduler injection.
+
+    Prefer subclassing :class:`BaseScheduler` directly. Subclassing this name
+    still works but emits a :class:`DeprecationWarning`.
+    """
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        import warnings
+
+        warnings.warn(
+            "SchedulerInterface is deprecated; subclass BaseScheduler instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init_subclass__(**kwargs)
diff --git a/vllm_omni/diffusion/sched/interface.py b/vllm_omni/diffusion/sched/interface.py
index 695641b5d..25ec722d5 100644
--- a/vllm_omni/diffusion/sched/interface.py
+++ b/vllm_omni/diffusion/sched/interface.py
@@ -4,17 +4,12 @@
 from __future__ import annotations
 
 import enum
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import Any, TypedDict
 
-from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 
-if TYPE_CHECKING:
-    from vllm_omni.diffusion.worker.utils import RunnerOutput
-
 
 class DiffusionRequestStatus(enum.IntEnum):
     """Request status tracked by diffusion scheduler."""
@@ -34,7 +29,7 @@ class DiffusionRequestStatus(enum.IntEnum):
 
 
 @dataclass(frozen=True, eq=True)
-class SamplingParamsKey:
+class StepBatchSamplingParamsKey:
     """Denoise step level Batch-compatibility key derived from ``OmniDiffusionSamplingParams``.
 
     Only requests with the same key can be batched together.
@@ -81,33 +76,33 @@ class RequestBatchSamplingParamsKey:
     """
 
     # Spatial / temporal shape.
-    height: object = None
-    width: object = None
+    height: int | None = None
+    width: int | None = None
     num_frames: int = 1
-    resolution: object = 640
-    fps: object = None
-    frame_rate: object = None
-    boundary_ratio: object = None
+    resolution: int = 640
+    fps: int | None = None
+    frame_rate: float | None = None
+    boundary_ratio: float | None = None
 
     # CFG / guidance.
     do_classifier_free_guidance: bool = False
     guidance_scale: float = 0.0
     guidance_scale_provided: bool = False
-    guidance_scale_2: object = None
+    guidance_scale_2: float | None = None
     guidance_rescale: float = 0.0
-    true_cfg_scale: object = None
+    true_cfg_scale: float | None = None
     cfg_normalize: bool = False
-    strength: object = None
+    strength: float | None = None
 
     # Scheduling / output shape.
-    num_inference_steps: object = None
-    sigmas: object = None
-    max_sequence_length: object = None
+    num_inference_steps: int | None = None
+    sigmas: list[float] | None = None
+    max_sequence_length: int | None = None
     num_outputs_per_prompt: int = 1
     eta: float = 0.0
-    decode_timestep: object = None
-    decode_noise_scale: object = None
-    output_type: object = None
+    decode_timestep: float | list[float] | None = None
+    decode_noise_scale: float | list[float] | None = None
+    output_type: str | None = None
 
     # Model-specific batch defaults used by request-mode pipelines.
     layers: int = 4
@@ -119,12 +114,12 @@ class RequestBatchSamplingParamsKey:
 
 
 @dataclass
-class DiffusionRequestState:
+class SchedulerRequestState:
     """Scheduler-owned state for one queued OmniDiffusionRequest."""
 
     request_id: str
     req: OmniDiffusionRequest
-    sampling_params_key: SamplingParamsKey | RequestBatchSamplingParamsKey | None = None
+    sampling_params_key: StepBatchSamplingParamsKey | RequestBatchSamplingParamsKey | None = None
     status: DiffusionRequestStatus = DiffusionRequestStatus.WAITING
     error: str | None = None
 
@@ -145,7 +140,7 @@ class NewRequestData:
     req: OmniDiffusionRequest
 
     @classmethod
-    def from_state(cls, state: DiffusionRequestState) -> NewRequestData:
+    def from_state(cls, state: SchedulerRequestState) -> NewRequestData:
         return cls(request_id=state.request_id, req=state.req)
 
 
@@ -160,10 +155,20 @@ class CachedRequestData:
         return cls(request_ids=[])
 
 
+class KVPrefetchJob(TypedDict):
+    """Descriptor for prefetching the next request's received KV cache."""
+
+    request_id: str
+    kv_sender_info: dict[str, Any]
+
+
 @dataclass
 class DiffusionSchedulerOutput:
     """Output of a single scheduling cycle."""
 
+    # Stable scheduler-cycle diagnostics for engines, injected schedulers, and
+    # instrumentation; they are intentionally retained even without a direct
+    # production consumer for every field.
     step_id: int  # global step index
     scheduled_new_reqs: list[NewRequestData]
     scheduled_cached_reqs: CachedRequestData
@@ -171,7 +176,7 @@ class DiffusionSchedulerOutput:
     num_running_reqs: int
     num_waiting_reqs: int
     # next request to background-prefetch KV
-    kv_prefetch_jobs: dict | None = None
+    kv_prefetch_job: KVPrefetchJob | None = None
 
     @cached_property
     def scheduled_request_ids(self) -> list[str]:
@@ -190,55 +195,3 @@ class DiffusionSchedulerOutput:
     @property
     def is_empty(self) -> bool:
         return self.num_scheduled_reqs == 0
-
-
-class SchedulerInterface(ABC):
-    """Abstract lifecycle contract for diffusion schedulers."""
-
-    @abstractmethod
-    def initialize(self, od_config: OmniDiffusionConfig) -> None:
-        """Initialize or reset scheduler state."""
-
-    @abstractmethod
-    def add_request(self, request: OmniDiffusionRequest) -> str:
-        """Add a request and return the scheduler-owned request id."""
-
-    @abstractmethod
-    def schedule(self) -> DiffusionSchedulerOutput:
-        """Run one scheduling cycle."""
-
-    @abstractmethod
-    def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
-        """Update scheduler state from executor output."""
-
-    @abstractmethod
-    def get_request_state(self, request_id: str) -> DiffusionRequestState | None:
-        """Return request state if present."""
-
-    @abstractmethod
-    def has_requests(self) -> bool:
-        """Return whether the scheduler still owns runnable requests."""
-
-    @abstractmethod
-    def num_waiting_requests(self) -> int:
-        """Return the number of requests waiting to be scheduled."""
-
-    @abstractmethod
-    def num_running_requests(self) -> int:
-        """Return the number of requests currently running."""
-
-    @abstractmethod
-    def pop_request_state(self, request_id: str) -> DiffusionRequestState | None:
-        """Remove and return request state if present."""
-
-    @abstractmethod
-    def preempt_request(self, request_id: str) -> bool:
-        """Preempt a running request back to waiting."""
-
-    @abstractmethod
-    def finish_requests(self, request_ids: str | list[str], status: DiffusionRequestStatus) -> None:
-        """Mark one or more requests finished."""
-
-    @abstractmethod
-    def close(self) -> None:
-        """Release scheduler-owned state."""
diff --git a/vllm_omni/diffusion/sched/request_scheduler.py b/vllm_omni/diffusion/sched/request_scheduler.py
index 9a02eb8f3..ec6b2aa8e 100644
--- a/vllm_omni/diffusion/sched/request_scheduler.py
+++ b/vllm_omni/diffusion/sched/request_scheduler.py
@@ -3,30 +3,38 @@
 
 from __future__ import annotations
 
+from dataclasses import fields
 from typing import TYPE_CHECKING
 
 from vllm_omni.diffusion.request import OmniDiffusionRequest
-from vllm_omni.diffusion.sched.base_scheduler import _BaseScheduler, get_request_batch_sampling_params_key
+from vllm_omni.diffusion.sched.base_scheduler import BaseScheduler
 from vllm_omni.diffusion.sched.interface import (
     DiffusionRequestStatus,
     DiffusionSchedulerOutput,
+    RequestBatchSamplingParamsKey,
 )
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.worker.utils import RunnerOutput
 
+# LoRA identity is derived from `sampling.lora_request`, not a same-named field
+# on sampling params, so it must be resolved separately from the bulk lookup.
+_REQUEST_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES = frozenset(
+    field.name for field in fields(RequestBatchSamplingParamsKey)
+) - {"lora_int_id"}
 
-class RequestScheduler(_BaseScheduler):
+
+class RequestScheduler(BaseScheduler):
     """Diffusion scheduler with vLLM-style waiting/running queues."""
 
-    def _build_sampling_params_key(self, request: OmniDiffusionRequest):
-        return get_request_batch_sampling_params_key(request)
-
-    def add_request(self, request: OmniDiffusionRequest) -> str:
-        return super().add_request(request)
-
-    def schedule(self) -> DiffusionSchedulerOutput:
-        return super().schedule()
+    def _build_sampling_params_key(self, request: OmniDiffusionRequest) -> RequestBatchSamplingParamsKey:
+        """Build a request-batch compatibility key from sampling parameters."""
+        sampling = request.sampling_params
+        # LoRA identity is optional on sampling params (and on test stubs).
+        lora_request = getattr(sampling, "lora_request", None)
+        key_kwargs = {name: getattr(sampling, name) for name in _REQUEST_BATCH_SAMPLING_PARAMS_KEY_FIELD_NAMES}
+        key_kwargs["lora_int_id"] = lora_request.lora_int_id if lora_request is not None else None
+        return RequestBatchSamplingParamsKey(**key_kwargs)
 
     def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
         scheduled_request_ids = sched_output.scheduled_request_ids
@@ -42,8 +50,14 @@ class RequestScheduler(_BaseScheduler):
             req_output = output.get_request_output(request_id)
             result = req_output.result if req_output is not None else None
             if result is None:
-                terminal_statuses[request_id] = DiffusionRequestStatus.FINISHED_ERROR
-                terminal_errors[request_id] = "No output result"
+                # Async mode: result=None with async_output_id means compute done,
+                # final output will arrive later via wait_output_ready.
+                if req_output is not None and req_output.async_output_id is not None:
+                    terminal_statuses[request_id] = DiffusionRequestStatus.FINISHED_COMPLETED
+                    terminal_errors[request_id] = None
+                else:
+                    terminal_statuses[request_id] = DiffusionRequestStatus.FINISHED_ERROR
+                    terminal_errors[request_id] = "No output result"
             elif result.aborted:
                 terminal_statuses[request_id] = DiffusionRequestStatus.FINISHED_ABORTED
                 terminal_errors[request_id] = None
diff --git a/vllm_omni/diffusion/sched/step_scheduler.py b/vllm_omni/diffusion/sched/step_scheduler.py
index 6cb6a9a28..a5a7a04ae 100644
--- a/vllm_omni/diffusion/sched/step_scheduler.py
+++ b/vllm_omni/diffusion/sched/step_scheduler.py
@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any
 from vllm.logger import init_logger
 
 from vllm_omni.diffusion.request import OmniDiffusionRequest
-from vllm_omni.diffusion.sched.base_scheduler import _BaseScheduler
+from vllm_omni.diffusion.sched.base_scheduler import BaseScheduler
 from vllm_omni.diffusion.sched.interface import (
     DiffusionRequestStatus,
     DiffusionSchedulerOutput,
@@ -27,8 +27,8 @@ class _StepProgress:
     total_steps: int
 
 
-class StepScheduler(_BaseScheduler):
-    """Placeholder scheduler that advances a request one denoise step per update."""
+class StepScheduler(BaseScheduler):
+    """Scheduler that advances each request by one denoise step per update."""
 
     def __init__(self) -> None:
         super().__init__()
@@ -62,9 +62,6 @@ class StepScheduler(_BaseScheduler):
         )
         return request_id
 
-    def schedule(self) -> DiffusionSchedulerOutput:
-        return super().schedule()
-
     def update_from_output(self, sched_output: DiffusionSchedulerOutput, output: RunnerOutput) -> set[str]:
         scheduled_request_ids = sched_output.scheduled_request_ids
         if not scheduled_request_ids:
diff --git a/vllm_omni/diffusion/stage_diffusion_client.py b/vllm_omni/diffusion/stage_diffusion_client.py
index 2b13ddc9d..a8733b8d0 100644
--- a/vllm_omni/diffusion/stage_diffusion_client.py
+++ b/vllm_omni/diffusion/stage_diffusion_client.py
@@ -34,7 +34,7 @@ from vllm_omni.outputs import OmniRequestOutput
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.data import OmniDiffusionConfig
-    from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniPromptType
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniInteractionPrompt, OmniPromptType
 
 logger = init_logger(__name__)
 _MISSING_RPC_RESULT = object()
@@ -395,6 +395,19 @@ class StageDiffusionClient(StageClientBase):
             )
         )
 
+    async def submit_interaction_async(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+        timeout: float | None = None,
+    ) -> Any:
+        """Apply a midway interaction to an active streaming request."""
+        return await self.collective_rpc_async(
+            "submit_interaction",
+            timeout=timeout,
+            args=(request_id, interaction),
+        )
+
     async def collective_rpc_async(
         self,
         method: str,
diff --git a/vllm_omni/diffusion/stage_diffusion_proc.py b/vllm_omni/diffusion/stage_diffusion_proc.py
index e74a34b59..f01348c74 100644
--- a/vllm_omni/diffusion/stage_diffusion_proc.py
+++ b/vllm_omni/diffusion/stage_diffusion_proc.py
@@ -40,6 +40,7 @@ from vllm_omni.outputs import OmniRequestOutput
 
 if TYPE_CHECKING:
     from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.executor.abstract import DiffusionExecutor
 
 logger = init_logger(__name__)
 
@@ -92,20 +93,19 @@ class StageDiffusionProc:
     def _is_executor_dead(self) -> bool:
         """True iff the multiproc executor has been closed or marked failed.
 
-        Detects the "workers died but the diffusion proc is still pulling
-        requests" case: ``MultiprocDiffusionExecutor`` sets ``_closed = True``
-        and ``is_failed = True`` from its worker-monitor thread the moment any
-        worker process exits; every subsequent ``execute_request`` /
-        ``collective_rpc`` then raises ``RuntimeError("DiffusionExecutor is
-        closed.")`` inside the engine. Callers in ``run_loop`` use this to
-        decide whether a per-request failure is recoverable or fatal.
+        requests" case: ``MultiprocDiffusionExecutor`` sets ``is_dead`` from its
+        worker-monitor thread the moment any worker process exits; every
+        subsequent ``execute_request`` / ``collective_rpc`` then raises
+        ``RuntimeError("DiffusionExecutor is closed.")`` inside the engine.
+        Callers in ``run_loop`` use this to decide whether a per-request
+        failure is recoverable or fatal.
         """
         if self._engine is None:
             return False
-        executor = getattr(self._engine, "executor", None)
+        executor: DiffusionExecutor | None = getattr(self._engine, "executor", None)
         if executor is None:
             return False
-        return bool(getattr(executor, "_closed", False) or getattr(executor, "is_failed", False))
+        return executor.is_dead
 
     def _signal_fatal_engine_failure(self, reason: str) -> None:
         """Idempotently signal ``run_loop`` to tear down on a fatal engine error."""
@@ -155,7 +155,7 @@ class StageDiffusionProc:
         sampling_params_dict: dict,
         kv_sender_info: dict[str, Any] | None = None,
     ) -> OmniRequestOutput:
-        """Build a diffusion request and run DiffusionEngine.step()."""
+        """Build a diffusion request and consume DiffusionEngine.step_streaming() to completion."""
         sampling_params = self._reconstruct_sampling_params(sampling_params_dict)
 
         request = OmniDiffusionRequest(
@@ -165,8 +165,13 @@ class StageDiffusionProc:
             kv_sender_info=kv_sender_info,
         )
 
-        results = await self._engine.step(request)
-        result = results[0]
+        # Non-streaming callers share the streaming engine path but only
+        # return the final output.
+        result = None
+        async for results in self._engine.step_streaming(request):
+            result = results[0]
+        if result is None:
+            raise RuntimeError("Diffusion execution finished without output.")
         if not result.request_id:
             result.request_id = request_id
         return result
diff --git a/vllm_omni/diffusion/utils/flow_matching.py b/vllm_omni/diffusion/utils/flow_matching.py
index e81d405ec..ec643644b 100644
--- a/vllm_omni/diffusion/utils/flow_matching.py
+++ b/vllm_omni/diffusion/utils/flow_matching.py
@@ -3,10 +3,22 @@
 
 import math
 
+import numpy as np
 import torch
 from torch import nn
 
 
+def safe_linalg_solve(matrix: torch.Tensor, rhs: torch.Tensor) -> torch.Tensor:
+    try:
+        return torch.linalg.solve(matrix, rhs)
+    except RuntimeError as exc:
+        if matrix.device.type != "cpu" or "requires compiling PyTorch with LAPACK" not in str(exc):
+            raise
+        # Some ROCm wheels still fail here at runtime even when the LAPACK probe reports support.
+        solved = np.linalg.solve(matrix.detach().cpu().numpy(), rhs.detach().cpu().numpy())
+        return torch.from_numpy(solved).to(device=matrix.device, dtype=matrix.dtype)
+
+
 def swish(x: torch.Tensor) -> torch.Tensor:
     return x * torch.sigmoid(x)
 
diff --git a/vllm_omni/diffusion/utils/hf_utils.py b/vllm_omni/diffusion/utils/hf_utils.py
index dad02583f..78d8c6536 100644
--- a/vllm_omni/diffusion/utils/hf_utils.py
+++ b/vllm_omni/diffusion/utils/hf_utils.py
@@ -7,6 +7,24 @@ from vllm.transformers_utils.config import get_hf_file_to_dict
 
 logger = init_logger(__name__)
 
+DIFFUSION_MODEL_INDEX_FILES = (
+    "model_index.json",
+    "modular_model_index.json",
+)
+
+
+def get_diffusion_model_index(
+    model_name: str,
+    *,
+    revision: str | None = None,
+) -> dict | None:
+    """Read the first standard Diffusers pipeline index available."""
+    for filename in DIFFUSION_MODEL_INDEX_FILES:
+        config = get_hf_file_to_dict(filename, model_name, revision=revision)
+        if isinstance(config, Mapping):
+            return dict(config)
+    return None
+
 
 def load_diffusers_config(model_name) -> dict:
     from diffusers.pipelines.pipeline_utils import DiffusionPipeline
@@ -58,33 +76,32 @@ def is_diffusion_model(model_name: str) -> bool:
     """Check if a model is a diffusion model.
 
     Uses multiple fallback strategies to detect diffusion models:
-    1. Check local file system for model_index.json (fastest, no imports)
+    1. Check the local file system for a standard Diffusers index
     2. Check using vllm's get_hf_file_to_dict utility
     3. Try the standard diffusers approach (may fail due to import issues)
     """
     # Strategy 1: Check local file system first (fastest, avoids import issues)
     if os.path.isdir(model_name):
-        model_index_path = os.path.join(model_name, "model_index.json")
-        if os.path.exists(model_index_path):
+        for filename in DIFFUSION_MODEL_INDEX_FILES:
+            model_index_path = os.path.join(model_name, filename)
+            if not os.path.exists(model_index_path):
+                continue
             try:
                 import json
 
                 with open(model_index_path) as f:
                     config_dict = json.load(f)
                 if config_dict.get("_class_name") and config_dict.get("_diffusers_version"):
-                    logger.debug("Detected diffusion model via local model_index.json")
+                    logger.debug("Detected diffusion model via local %s", filename)
                     return True
             except Exception as e:
-                logger.debug("Failed to read local model_index.json: %s", e)
+                logger.debug("Failed to read local %s: %s", filename, e)
 
     # Strategy 2: Check using vllm's utility (works for both local and remote models)
-    try:
-        config_dict = get_hf_file_to_dict("model_index.json", model_name)
-        if config_dict is not None and config_dict.get("_class_name") and config_dict.get("_diffusers_version"):
-            logger.debug("Detected diffusion model via model_index.json")
-            return True
-    except Exception as e:
-        logger.debug("Failed to check model_index.json via get_hf_file_to_dict: %s", e)
+    config_dict = get_diffusion_model_index(model_name)
+    if config_dict is not None and config_dict.get("_class_name") and config_dict.get("_diffusers_version"):
+        logger.debug("Detected diffusion model via a standard Diffusers index")
+        return True
 
     # Strategy 3: Try the standard diffusers approach (may fail due to import issues)
     # This is last because it requires importing diffusers/xformers/flash_attn
diff --git a/vllm_omni/diffusion/utils/image_output.py b/vllm_omni/diffusion/utils/image_output.py
new file mode 100644
index 000000000..5f8c9903a
--- /dev/null
+++ b/vllm_omni/diffusion/utils/image_output.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any
+
+import torch
+from PIL import Image
+from vllm.outputs import RequestOutput
+
+from vllm_omni.outputs import OmniRequestOutput
+
+ImageOutput = OmniRequestOutput | RequestOutput
+ImageOutputs = ImageOutput | Sequence[ImageOutput] | None
+
+
+def extract_images_from_outputs(outputs: ImageOutputs) -> list[Image.Image]:
+    """Extract PIL images from known Omni output types.
+
+    Supported inputs:
+    - OmniRequestOutput / list[OmniRequestOutput]
+    - RequestOutput / list[RequestOutput] (compatibility fallback)
+    """
+    for output in _iter_known_outputs(outputs):
+        if isinstance(output, OmniRequestOutput):
+            images = _coerce_images(output.images)
+            if images:
+                return images
+
+        for payload in _iter_multimodal_image_payloads(output):
+            images = _coerce_images(payload)
+            if images:
+                return images
+
+    return []
+
+
+def _iter_known_outputs(value: ImageOutputs) -> Iterable[ImageOutput]:
+    if value is None:
+        return
+    if isinstance(value, OmniRequestOutput | RequestOutput):
+        yield value
+        return
+    if isinstance(value, Sequence):
+        for item in value:
+            if isinstance(item, OmniRequestOutput | RequestOutput):
+                yield item
+
+
+def _iter_multimodal_image_payloads(output: OmniRequestOutput | RequestOutput) -> Iterable[Any]:
+    if isinstance(output, OmniRequestOutput):
+        if output.multimodal_output is not None:
+            yield from _image_values_from_mapping_like(output.multimodal_output)
+        if output.request_output is not None:
+            yield from _iter_request_output_payloads(output.request_output)
+    else:
+        yield from _iter_request_output_payloads(output)
+
+
+def _iter_request_output_payloads(request_output: RequestOutput) -> Iterable[Any]:
+    mm = getattr(request_output, "multimodal_output", None)
+    if mm is not None:
+        yield from _image_values_from_mapping_like(mm)
+    for completion in getattr(request_output, "outputs", []):
+        mm = getattr(completion, "multimodal_output", None)
+        if mm is not None:
+            yield from _image_values_from_mapping_like(mm)
+
+
+def _image_values_from_mapping_like(value: Any) -> Iterable[Any]:
+    if hasattr(value, "to_dict") and callable(value.to_dict):
+        value = value.to_dict()
+    if not isinstance(value, Mapping):
+        return
+    for key in ("image", "images", "model_outputs"):
+        if key in value:
+            yield value[key]
+
+
+def _coerce_images(payload: Any) -> list[Image.Image]:
+    if payload is None:
+        return []
+    if isinstance(payload, Image.Image):
+        return [payload]
+    if isinstance(payload, torch.Tensor):
+        return _tensor_to_images(payload)
+    if isinstance(payload, list | tuple):
+        images: list[Image.Image] = []
+        for item in payload:
+            images.extend(_coerce_images(item))
+        return images
+    return []
+
+
+def _tensor_to_images(tensor: torch.Tensor) -> list[Image.Image]:
+    img = tensor.detach().to("cpu", dtype=torch.float32)
+    if img.ndim == 4:
+        images: list[Image.Image] = []
+        for single in img:
+            images.extend(_tensor_to_images(single))
+        return images
+    if img.ndim != 3:
+        return []
+
+    if img.shape[0] in (1, 3, 4):
+        img = img.permute(1, 2, 0)
+
+    # Some diffusion models emit image tensors normalized in [-1, 1].
+    if img.min().item() < 0.0:
+        img = img / 2 + 0.5
+    img = img.clamp(0, 1).mul(255).to(torch.uint8).contiguous().numpy()
+    return [Image.fromarray(img)]
diff --git a/vllm_omni/diffusion/utils/kv_utils.py b/vllm_omni/diffusion/utils/kv_utils.py
index 9ba231386..fc6ec6cc1 100644
--- a/vllm_omni/diffusion/utils/kv_utils.py
+++ b/vllm_omni/diffusion/utils/kv_utils.py
@@ -3,6 +3,19 @@
 import torch
 
 
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """Expand GQA KV from num_kv_heads to num_heads.
+
+    Input:  (batch, seqlen, num_key_value_heads, head_dim)
+    Output: (batch, seqlen, num_key_value_heads * n_rep, head_dim)
+    """
+    if n_rep == 1:
+        return hidden_states
+    batch, slen, num_key_value_heads, head_dim = hidden_states.shape
+    hidden_states = hidden_states[:, :, :, None, :].expand(batch, slen, num_key_value_heads, n_rep, head_dim)
+    return hidden_states.reshape(batch, slen, num_key_value_heads * n_rep, head_dim)
+
+
 def left_pad_stack(
     tensors: list[torch.Tensor],
 ) -> tuple[torch.Tensor, torch.Tensor | None]:
diff --git a/vllm_omni/diffusion/worker/diffusion_model_runner.py b/vllm_omni/diffusion/worker/diffusion_model_runner.py
index cb16bdeac..2e8111a31 100644
--- a/vllm_omni/diffusion/worker/diffusion_model_runner.py
+++ b/vllm_omni/diffusion/worker/diffusion_model_runner.py
@@ -12,17 +12,17 @@ from __future__ import annotations
 
 import copy
 import time
-from collections.abc import Iterable
-from contextlib import nullcontext
-from typing import Any
+from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from typing import TYPE_CHECKING, Any, cast
 
 import torch
 from torch.profiler import record_function
-from vllm.config import LoadConfig
+from vllm.config import LoadConfig, VllmConfig
 from vllm.logger import init_logger
 from vllm.utils.mem_utils import DeviceMemoryProfiler, GiB_bytes
 
-from vllm_omni.diffusion.cache.cache_dit_backend import cache_summary
+from vllm_omni.diffusion.cache.cachedit import cache_summary
 from vllm_omni.diffusion.cache.prompt_embed_cache import (
     install_prompt_embed_cache,
     resolve_prompt_embed_cache_config,
@@ -32,26 +32,30 @@ from vllm_omni.diffusion.compile import regionally_compile
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.forward_context import set_forward_context
 from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
-from vllm_omni.diffusion.models.interface import supports_step_execution
+from vllm_omni.diffusion.models.interface import SupportsPromptUpdate, supports_prompt_update, supports_step_execution
 from vllm_omni.diffusion.offloader import get_offload_backend
 from vllm_omni.diffusion.registry import _NO_CACHE_ACCELERATION
 from vllm_omni.diffusion.request import OmniDiffusionRequest
-from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput
+from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput, KVPrefetchJob
 from vllm_omni.diffusion.worker.input_batch import InputBatch, scatter_latents
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 from vllm_omni.diffusion.worker.utils import (
     BatchRunnerOutput,
-    DiffusionRequestState,
     RunnerOutput,
+    StepRequestState,
     attach_stage_durations,
     clear_pipeline_stage_durations,
     consume_pipeline_stage_durations,
     merge_stage_durations,
 )
 from vllm_omni.distributed.omni_connectors.kv_transfer_manager import OmniKVTransferManager
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.platforms import current_omni_platform
 from vllm_omni.worker.omni_connector_model_runner_mixin import OmniConnectorModelRunnerMixin
 
+if TYPE_CHECKING:
+    from vllm_omni.inputs.data import OmniInteractionPrompt
+
 logger = init_logger(__name__)
 
 
@@ -103,7 +107,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
     def __init__(
         self,
-        vllm_config,
+        vllm_config: VllmConfig,
         od_config: OmniDiffusionConfig,
         device: torch.device,
     ):
@@ -118,13 +122,14 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         self.vllm_config = vllm_config
         self.od_config = od_config
         self.device = device
-        self.pipeline = None
-        self.cache_backend = None
-        self.offload_backend = None
-        self.prompt_embed_cache = None
+        self.pipeline: Any | None = None
+        self.cache_backend: Any | None = None
+        self.offload_backend: Any | None = None
+        self.prompt_embed_cache: Any | None = None
+        self.input_batch: InputBatch | None = None
 
         # Cache for per-request stepwise state.
-        self.state_cache: dict[str, DiffusionRequestState] = {}
+        self.state_cache: dict[str, StepRequestState] = {}
 
         # Initialize KV cache manager for connector management.
         self.kv_transfer_manager = OmniKVTransferManager.from_od_config(od_config)
@@ -140,7 +145,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         )
 
     @property
-    def target_device(self) -> torch.device | None:
+    def _target_device(self) -> torch.device | None:
         return getattr(self.pipeline, "device", None)
 
     def _compile_transformer(self, attr_name: str) -> None:
@@ -149,24 +154,42 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         if model is None:
             return
 
+        compile_granularity = self.od_config.diffusion_compile_granularity
+        compile_dynamic = self.od_config.diffusion_compile_dynamic
         try:
-            setattr(self.pipeline, attr_name, regionally_compile(model, dynamic=True))
-            logger.info("Model runner: %s compiled with torch.compile.", attr_name)
+            if compile_granularity == "full":
+                model.compile(dynamic=compile_dynamic)
+                compiled_model = model
+            else:
+                compiled_model = regionally_compile(model, dynamic=compile_dynamic)
+            setattr(self.pipeline, attr_name, compiled_model)
         except Exception as e:
             logger.warning(
-                "Model runner: torch.compile for %s failed: %s. Using eager mode.",
+                "Model runner: %s torch.compile setup for %s failed before activation: %s. "
+                "Continuing with the uncompiled model; lazy compilation errors can still "
+                "surface on the first request.",
+                compile_granularity,
                 attr_name,
                 e,
             )
+            return
+
+        logger.info(
+            "Model runner: %s configured for lazy %s torch.compile with dynamic=%s; "
+            "compilation errors may surface on the first request.",
+            attr_name,
+            compile_granularity,
+            compile_dynamic,
+        )
 
     def load_model(
         self,
-        memory_pool_context_fn: callable | None = None,
+        memory_pool_context_fn: Callable[[str], AbstractContextManager[Any]] | None = None,
         load_format: str = "default",
         custom_pipeline_name: str | None = None,
     ) -> None:
         """
-        Load the diffusion model, apply compilation and offloading.
+        Launch the diffusion pipeline, applying compilation, offloading, and caching.
 
         Args:
             memory_pool_context_fn: Optional function that returns a context manager
@@ -182,13 +205,23 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         if load_format == "dummy":
             return
 
-        load_device = (
-            "cpu" if self.od_config.enable_cpu_offload or self.od_config.enable_layerwise_offload else str(self.device)
+        current_omni_platform.init_diffusion_model_runner_runtime(
+            vllm_config=self.vllm_config,
+            od_config=self.od_config,
+            device=self.device,
         )
 
-        def get_memory_context():
+        load_device = (
+            "cpu"
+            if self.od_config.enable_cpu_offload
+            or self.od_config.enable_layerwise_offload
+            or getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+            else str(self.device)
+        )
+
+        def get_memory_context() -> AbstractContextManager[Any]:
             if memory_pool_context_fn is not None:
-                return memory_pool_context_fn(tag="weights")
+                return memory_pool_context_fn("weights")
             return nullcontext()
 
         # Load model within forward context
@@ -217,13 +250,13 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             logger.warning("streaming_output=True requires step_execution=True; enabling step execution.")
             self.od_config.step_execution = True
 
-        if getattr(self.od_config, "step_execution", False) and not self.supports_step_mode():
+        if getattr(self.od_config, "step_execution", False) and not self._supports_step_mode():
             raise ValueError(
                 "step_execution=True requires a pipeline implementing "
                 "prepare_encode(), denoise_step(), step_scheduler(), and post_decode(); "
                 f"{self.od_config.model_class_name} does not support that contract."
             )
-        if self.od_config.streaming_output and not self.supports_step_mode():
+        if self.od_config.streaming_output and not self._supports_step_mode():
             raise ValueError(
                 "streaming_output=True requires step execution support; "
                 f"{self.od_config.model_class_name} does not support that contract."
@@ -247,8 +280,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                             exc,
                         )
                 else:
-                    self._compile_transformer("transformer")
-                    self._compile_transformer("transformer_2")
+                    transformer_attrs = getattr(self.pipeline, "_dit_modules", None)
+                    if not transformer_attrs:
+                        transformer_attrs = ("transformer", "transformer_2")
+                    for attr_name in transformer_attrs:
+                        self._compile_transformer(attr_name)
             else:
                 logger.warning(
                     "Model runner: Platform %s does not support torch inductor, skipping torch.compile.",
@@ -287,17 +323,19 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
         logger.info("Model runner: Initialization complete.")
 
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        """Load weights into the pipeline."""
-        return self.pipeline.load_weights(weights)
-
     def clear_prompt_embed_cache(self) -> None:
-        """Evict all cached text-encoder outputs (e.g. between training epochs)."""
+        """Evict all cached text-encoder outputs (e.g. between training epochs).
+
+        Kept primarily for extension purposes.
+        """
         if self.prompt_embed_cache is not None:
             self.prompt_embed_cache.clear()
 
     def get_prompt_embed_cache_stats(self) -> dict | None:
-        """Return hit/miss statistics for the prompt-embedding cache, if enabled."""
+        """Return hit/miss statistics for the prompt-embedding cache, if enabled.
+
+        Kept primarily for extension purposes.
+        """
         if self.prompt_embed_cache is None:
             return None
         return self.prompt_embed_cache.stats()
@@ -336,7 +374,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         req: OmniDiffusionRequest,
         *,
         od_config: OmniDiffusionConfig,
-        kv_prefetch_jobs: dict | None = None,
+        kv_prefetch_job: KVPrefetchJob | None = None,
         use_prefetch: bool = False,
     ) -> None:
         # Receive AR KV. Single-request execution can use the prefetch path:
@@ -346,29 +384,32 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         if use_prefetch and self._kv_prefetch_enabled:
             self.kv_transfer_manager.consume_and_distribute_kv_cache(
                 req,
-                target_device=self.target_device,
+                target_device=self._target_device,
             )
         else:
             self.kv_transfer_manager.receive_multi_kv_cache_distributed(
                 req,
                 cfg_kv_collect_func=getattr(od_config, "cfg_kv_collect_func", None),
-                target_device=self.target_device if use_prefetch else getattr(self.pipeline, "device", None),
+                target_device=self._target_device if use_prefetch else getattr(self.pipeline, "device", None),
             )
         kv_recv_ms = (time.perf_counter() - kv_recv_t0) * 1000
         logger.debug("KV recv for %s %.1fms", req.request_id, kv_recv_ms)
 
         # Kick off the next request's prefetch (+ H2D) to overlap this forward.
-        if use_prefetch and self._kv_prefetch_enabled and kv_prefetch_jobs is not None:
-            self.kv_transfer_manager.start_prefetch(kv_prefetch_jobs, self.target_device)
+        if use_prefetch and self._kv_prefetch_enabled and kv_prefetch_job is not None:
+            self.kv_transfer_manager.start_prefetch(kv_prefetch_job, self._target_device)
 
-        if req.sampling_params.generator is None and req.sampling_params.seed is not None:
-            if req.sampling_params.generator_device is not None:
-                gen_device = req.sampling_params.generator_device
+        self._initialize_generator(req.sampling_params)
+
+    def _initialize_generator(self, sampling_params: OmniDiffusionSamplingParams) -> None:
+        if sampling_params.generator is None and sampling_params.seed is not None:
+            if sampling_params.generator_device is not None:
+                gen_device = sampling_params.generator_device
             elif self.device.type == "cpu":
                 gen_device = "cpu"
             else:
                 gen_device = self.device
-            req.sampling_params.generator = torch.Generator(device=gen_device).manual_seed(req.sampling_params.seed)
+            sampling_params.generator = torch.Generator(device=gen_device).manual_seed(sampling_params.seed)
 
     def _refresh_cache_for_requests(
         self,
@@ -377,15 +418,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         od_config: OmniDiffusionConfig,
     ) -> None:
         first_req = reqs[0]
-        if (
-            getattr(first_req, "skip_cache_refresh", False)
-            or self.cache_backend is None
-            or not self.cache_backend.is_enabled()
-        ):
+        if self.cache_backend is None or not self.cache_backend.is_enabled():
             return
 
         # Refresh cache context if needed. Batch admission groups requests by
-        # SamplingParamsKey, so the first request's num_inference_steps applies
+        # RequestBatchSamplingParamsKey, so the first request's num_inference_steps applies
         # to the whole runner batch.
         num_inference_steps = first_req.sampling_params.num_inference_steps
         if num_inference_steps is None and od_config.cache_backend in (
@@ -432,7 +469,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         od_config: OmniDiffusionConfig,
         allow_single_output: bool,
         require_request_batch_support: bool,
-        kv_prefetch_jobs: dict | None = None,
+        kv_prefetch_job: KVPrefetchJob | None = None,
         record_name: str,
     ) -> BatchRunnerOutput:
         assert self.pipeline is not None, "Model not loaded. Call load_model() first."
@@ -448,13 +485,14 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         # better perf. HSDP2's fully_shard pre-forward hooks need tensor version
         # counters, which inference tensors do not track.
         use_hsdp = od_config.parallel_config.use_hsdp
-        grad_context = torch.no_grad() if use_hsdp else torch.inference_mode()
+        use_distributed_offload = getattr(self.od_config, "enable_distributed_layerwise_offload", False)
+        grad_context = torch.no_grad() if (use_hsdp or use_distributed_offload) else torch.inference_mode()
         with grad_context:
             for req in reqs:
                 self._prepare_request_for_forward(
                     req,
                     od_config=od_config,
-                    kv_prefetch_jobs=kv_prefetch_jobs,
+                    kv_prefetch_job=kv_prefetch_job,
                     use_prefetch=allow_single_output,
                 )
 
@@ -497,10 +535,8 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
     def _attach_stepwise_metrics(
         self,
-        state: DiffusionRequestState,
+        state: StepRequestState,
         output: DiffusionOutput,
-        *,
-        is_primary: bool,
     ) -> None:
         merge_stage_durations(
             state,
@@ -508,7 +544,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         )
         attach_stage_durations(state, output)
 
-    def execute_model(self, req: OmniDiffusionRequest, kv_prefetch_jobs: dict | None = None) -> DiffusionOutput:
+    def execute_model(
+        self,
+        req: OmniDiffusionRequest,
+        kv_prefetch_job: KVPrefetchJob | None = None,
+    ) -> DiffusionOutput:
         """
         Execute a forward pass for the given requests.
 
@@ -529,7 +569,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             od_config=self.od_config,
             allow_single_output=True,
             require_request_batch_support=False,
-            kv_prefetch_jobs=kv_prefetch_jobs,
+            kv_prefetch_job=kv_prefetch_job,
             record_name="pipeline_forward",
         )
         output = runner_output.runner_outputs[0].result
@@ -560,18 +600,16 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
     # Step-wise execution
     # ------------------------------------------------------------------
 
-    def supports_step_mode(self) -> bool:
+    def _supports_step_mode(self) -> bool:
         """Return whether current pipeline supports step execution."""
         return self.pipeline is not None and supports_step_execution(self.pipeline)
 
-    def _update_states(
-        self, scheduler_output: DiffusionSchedulerOutput
-    ) -> tuple[list[DiffusionRequestState], list[str]]:
+    def _update_states(self, scheduler_output: DiffusionSchedulerOutput) -> tuple[list[StepRequestState], list[str]]:
         """Step-before update: cleanup finished requests and get/create one running state."""
         for request_id in scheduler_output.finished_req_ids:
             self.state_cache.pop(request_id, None)
 
-        resolved: list[DiffusionRequestState] = []
+        resolved: list[StepRequestState] = []
         new_request_ids: list[str] = []
         try:
             # process new requests
@@ -580,7 +618,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 new_request_ids.append(request_id)
                 if request_id in self.state_cache:
                     raise ValueError(f"Received duplicate new-request payload for cached request {request_id}.")
-                new_state = DiffusionRequestState(
+                new_state = StepRequestState(
                     request_id=request_id,
                     sampling=copy.deepcopy(sched_new_req.req.sampling_params),
                     prompt=sched_new_req.req.prompt,
@@ -591,7 +629,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 self.kv_transfer_manager.receive_multi_kv_cache_distributed(
                     state_req,
                     cfg_kv_collect_func=getattr(self.od_config, "cfg_kv_collect_func", None),
-                    target_device=self.target_device,
+                    target_device=self._target_device,
                 )
                 self.state_cache[request_id] = new_state
                 resolved.append(new_state)
@@ -609,19 +647,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
         return resolved, new_request_ids
 
-    def _prepare_batch_inputs(self, states: list[DiffusionRequestState], new_request_ids: list[str]) -> InputBatch:
+    def _prepare_batch_inputs(self, states: list[StepRequestState], new_request_ids: list[str]) -> InputBatch:
         # process new reqs
         for state in states:
             if state.request_id in new_request_ids:
-                # set generator
-                if state.sampling.generator is None and state.sampling.seed is not None:
-                    if state.sampling.generator_device is not None:
-                        gen_device = state.sampling.generator_device
-                    elif self.device.type == "cpu":
-                        gen_device = "cpu"
-                    else:
-                        gen_device = self.device
-                    state.sampling.generator = torch.Generator(device=gen_device).manual_seed(state.sampling.seed)
+                self._initialize_generator(state.sampling)
                 clear_pipeline_stage_durations(self.pipeline)
                 # encode
                 self.pipeline.prepare_encode(state)
@@ -639,10 +669,10 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
 
     def _update_states_after(
         self,
-        states: list[DiffusionRequestState],
+        states: list[StepRequestState],
         input_batch: InputBatch,
         interrupted: bool = False,
-    ):
+    ) -> None:
         """Step-after update: clear cached state for completed request."""
         gathered_latents = torch.cat([state.latents for state in states], dim=0)
         if (
@@ -661,19 +691,10 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             if interrupted or state.request_denoise_completed:
                 self.state_cache.pop(state.request_id, None)
 
-    def _prepare_attn_metadata(self, input_batch: InputBatch) -> Any:
-        model_state = getattr(self, "model_state", None)
-        if model_state is None:
-            return {}
-        prepare_attn = getattr(model_state, "prepare_attn", None)
-        if not callable(prepare_attn):
-            return {}
-        return prepare_attn(input_batch)
-
     def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> BatchRunnerOutput:
         """Execute one step for one scheduled request and return runner output."""
         assert self.pipeline is not None, "Model not loaded. Call load_model() first."
-        if not self.supports_step_mode():
+        if not self._supports_step_mode():
             raise ValueError("Current pipeline does not support step execution.")
         # Stepwise mode only supports the basic state-driven denoise path for now.
         # Request-mode extras such as cache backends, editing inputs, and
@@ -690,7 +711,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             if new_request_ids and not had_active_states and is_primary and current_omni_platform.is_available():
                 current_omni_platform.reset_peak_memory_stats()
             input_batch = self._prepare_batch_inputs(states, new_request_ids)
-            attn_metadata = self._prepare_attn_metadata(input_batch)
+            attn_metadata = {}
 
             with set_forward_context(
                 vllm_config=self.vllm_config,
@@ -728,7 +749,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                                 req, noise_pred[offset : offset + row_num] if noise_pred is not None else None
                             )
                             if self.od_config.streaming_output:
-                                should_decode = req.chunk_denoise_completed
+                                should_decode = req.chunk_denoise_completed or req.request_denoise_completed
                             else:
                                 should_decode = req.denoise_completed
 
@@ -739,7 +760,6 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                                     self._attach_stepwise_metrics(
                                         req,
                                         result,
-                                        is_primary=is_primary,
                                     )
                             else:
                                 result = None
@@ -800,3 +820,48 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 self._update_states_after(states, input_batch, pipeline_interrupted)
 
                 return BatchRunnerOutput.from_list(runner_output_list)
+
+    def submit_interaction(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Route a midway interaction to the matching active stepwise request feature."""
+        assert self.pipeline is not None, "Model not loaded. Call load_model() first."
+        if not self.od_config.streaming_output:
+            raise ValueError("submit_interaction requires streaming_output=True")
+        if not self._supports_step_mode():
+            raise ValueError("submit_interaction requires step execution support")
+
+        event = interaction.get("event")
+        if isinstance(event, dict) and "prompt" in event and "multi_modal_data" not in event:
+            # Is a prompt update interaction.
+            self._submit_prompt_update_interaction(request_id, interaction)
+            return
+
+        raise NotImplementedError(
+            "Only text-only prompt update interactions with 'event.prompt' and optional "
+            "'transition_chunks' are supported in this release"
+        )
+
+    def _submit_prompt_update_interaction(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Queue a prompt-update interaction for an active stepwise request."""
+        if not supports_prompt_update(self.pipeline):
+            raise ValueError(f"prompt_update is not supported by pipeline {self.od_config.model_class_name!r}")
+
+        state = self.state_cache.get(request_id)
+        if state is None:
+            raise ValueError(f"No active request state for prompt_update: {request_id!r}")
+
+        event = cast(dict[str, Any], interaction.get("event"))
+        prompt = event["prompt"]
+        transition_chunks = interaction.get("transition_chunks")
+        event_id = interaction.get("event_id")
+        if not isinstance(event_id, str) or not event_id:
+            raise ValueError("event_id must be non-empty")
+        pipeline = cast(SupportsPromptUpdate, self.pipeline)
+        pipeline.prepare_prompt_update(state, prompt, event_id, transition_chunks)
diff --git a/vllm_omni/diffusion/worker/diffusion_worker.py b/vllm_omni/diffusion/worker/diffusion_worker.py
index 8cce47897..9a2958fcf 100644
--- a/vllm_omni/diffusion/worker/diffusion_worker.py
+++ b/vllm_omni/diffusion/worker/diffusion_worker.py
@@ -11,9 +11,12 @@ to DiffusionModelRunner.
 import gc
 import multiprocessing as mp
 import os
+import queue
 import signal
+import threading
 import traceback
-from collections.abc import Iterable, Iterator
+import uuid
+from collections.abc import Iterator
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from typing import Any
@@ -30,6 +33,8 @@ from vllm.utils.mem_utils import GiB_bytes
 from vllm.v1.worker.workspace import init_workspace_manager
 
 from vllm_omni.diffusion.data import (
+    AsyncDiffusionOutput,
+    AsyncOutputKind,
     DiffusionOutput,
     OmniACK,
     OmniDiffusionConfig,
@@ -46,10 +51,11 @@ from vllm_omni.diffusion.ipc import DIFFUSION_RPC_RESULT_ENVELOPE, pack_diffusio
 from vllm_omni.diffusion.lora.manager import DiffusionLoRAManager
 from vllm_omni.diffusion.registry import get_diffusion_ir_op_priority_func
 from vllm_omni.diffusion.request import OmniDiffusionRequest
-from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput
+from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput, KVPrefetchJob
 from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
 from vllm_omni.diffusion.worker.utils import BaseRunnerOutput, BatchRunnerOutput
 from vllm_omni.engine.stage_init_utils import set_death_signal
+from vllm_omni.inputs.data import OmniInteractionPrompt
 from vllm_omni.lora.request import LoRARequest
 from vllm_omni.platforms import current_omni_platform
 from vllm_omni.profiler import OmniTorchProfilerWrapper, create_omni_profiler
@@ -288,6 +294,12 @@ class DiffusionWorker:
         # Since vLLM v0.20.0, IR wraps GPU ops. Set IR op priority preference to enforce GPU op fusion during wrapping.
         # Also need to log, because vLLM internally logs another line in VllmConfig.__post_init__. Avoid confusion.
         vllm_config.kernel_config.ir_op_priority = _resolve_ir_op_priority(self.od_config, vllm_config)
+        if self.od_config.moe_backend != "auto":
+            logger.warning(
+                "Overriding MoE backend from default 'auto' to '%s' per deploy config.",
+                self.od_config.moe_backend,
+            )
+            vllm_config.kernel_config.moe_backend = self.od_config.moe_backend
         logger.info(
             "Final IR op priority after setting vLLM-Omni overrides: %s", vllm_config.kernel_config.ir_op_priority
         )
@@ -309,6 +321,7 @@ class DiffusionWorker:
                 sequence_parallel_size=parallel_config.sequence_parallel_size,
                 ulysses_degree=parallel_config.ulysses_degree,
                 ring_degree=parallel_config.ring_degree,
+                allgather_degree=parallel_config.allgather_degree,
                 tensor_parallel_size=parallel_config.tensor_parallel_size,
                 pipeline_parallel_size=parallel_config.pipeline_parallel_size,
                 fully_shard_degree=parallel_config.hsdp_shard_size if parallel_config.use_hsdp else 1,
@@ -381,10 +394,6 @@ class DiffusionWorker:
             lora_scale=self.od_config.lora_scale,
         )
 
-    def generate(self, request: OmniDiffusionRequest) -> DiffusionOutput:
-        """Generate output for the given requests."""
-        return self.execute_model(request, self.od_config)
-
     def profile(self, is_start: bool = True, profile_prefix: str | None = None) -> None:
         """Start or stop profiling for this GPU worker.
 
@@ -408,12 +417,34 @@ class DiffusionWorker:
 
     def execute_model(
         self,
-        req: OmniDiffusionRequest,
+        req: OmniDiffusionRequest | list[OmniDiffusionRequest],
         od_config: OmniDiffusionConfig,
-        kv_prefetch_jobs: dict | None = None,
+        kv_prefetch_job: KVPrefetchJob | None = None,
     ) -> DiffusionOutput:
-        """Execute a forward pass by delegating to the model runner."""
+        """Execute a forward pass by delegating to the model runner.
+
+        If *req* is a list (DP multi-concurrency), each rank picks one
+        request based on its distributed rank.  AllGather in the layerwise
+        offload only gathers weight shards (request-independent), so all
+        ranks stay synchronised at each AllGather call while computing
+        different activations.
+
+        Each rank returns its OWN DiffusionOutput (no gather).  The executor
+        collects N responses via result_mq (all ranks share one queue).
+        """
         assert self.model_runner is not None, "Model runner not initialized"
+
+        # DP multi-concurrency: pick one request per DP rank.
+        # Use rank_in_group (DP rank) not global rank, so that SP/TP/CFG
+        # ranks within the same DP replica select the same request.
+        is_batch = isinstance(req, list)
+        if is_batch:
+            from vllm_omni.diffusion.distributed.parallel_state import get_data_parallel_rank
+
+            dp_rank = get_data_parallel_rank()
+            idx = dp_rank % len(req)
+            req = req[idx]
+
         if self.lora_manager is not None:
             try:
                 self.lora_manager.set_active_adapter(req.sampling_params.lora_request, req.sampling_params.lora_scale)
@@ -424,9 +455,17 @@ class DiffusionWorker:
         profiler = self._get_profiler()
         ctx = profiler.annotate_context_manager("diffusion_forward") if profiler else nullcontext()
         with ctx:
-            output = self.model_runner.execute_model(req, kv_prefetch_jobs=kv_prefetch_jobs)
+            output = self.model_runner.execute_model(req, kv_prefetch_job=kv_prefetch_job)
         if profiler:
             profiler.step()
+
+        # Each primary rank returns its own output tagged with its DP rank
+        # so the executor can match results to requests by dp_rank.
+        # Non-primary ranks (SP/TP > 0) do not reply.
+        if is_batch:
+            from vllm_omni.diffusion.distributed.parallel_state import get_data_parallel_rank
+
+            return {"dp_rank": get_data_parallel_rank(), "output": output}
         return output
 
     def execute_model_batch(
@@ -434,7 +473,7 @@ class DiffusionWorker:
     ) -> BatchRunnerOutput:
         """Batch forward: LoRA activate once, delegate to model runner."""
         assert self.model_runner is not None, "Model runner not initialized"
-        # LoRA: same adapter/scale within batch guaranteed by SamplingParamsKey
+        # LoRA: same adapter/scale within batch guaranteed by RequestBatchSamplingParamsKey.
         if self.lora_manager is not None and scheduler_output.scheduled_new_reqs:
             sp = scheduler_output.scheduled_new_reqs[0].req.sampling_params
             try:
@@ -469,7 +508,7 @@ class DiffusionWorker:
         Newly scheduled requests register their (lora_request, lora_scale)
         in ``_step_lora_state`` so cached requests can resolve to the same
         adapter on later ticks. Finished requests are evicted. Batch
-        homogeneity is enforced by the scheduler via ``SamplingParamsKey``,
+        homogeneity is enforced by the scheduler via ``StepBatchSamplingParamsKey``,
         so any scheduled request id resolves to the active LoRA identity.
         """
         for request_id in scheduler_output.finished_req_ids:
@@ -500,11 +539,6 @@ class DiffusionWorker:
                 raise
             logger.warning("LoRA activation skipped: %s", exc)
 
-    def load_weights(self, weights) -> set[str]:
-        """Load weights by delegating to the model runner."""
-        assert self.model_runner is not None, "Model runner not initialized"
-        return self.model_runner.load_weights(weights)
-
     def remove_lora(self, adapter_id: int) -> bool:
         return self.lora_manager.remove_adapter(adapter_id)
 
@@ -513,13 +547,22 @@ class DiffusionWorker:
         # for the frontend server yet.
         return self.lora_manager.add_adapter(lora_request)
 
+    def submit_interaction(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Apply a midway interaction to an active stepwise request."""
+        assert self.model_runner is not None, "Model runner not initialized"
+        self.model_runner.submit_interaction(request_id, interaction)
+
     def list_loras(self) -> list[int]:
         return self.lora_manager.list_adapters()
 
     def pin_lora(self, adapter_id: int) -> bool:
         return self.lora_manager.pin_adapter(adapter_id)
 
-    def sleep(self, level: int = 1) -> bool:
+    def sleep(self, level: int = 1) -> int:
         """
         Put the worker to sleep, offloading model weights.
 
@@ -592,7 +635,7 @@ class DiffusionWorker:
         logger.info(f"[Worker {self.rank}] Wake-up complete.")
         return True
 
-    def handle_sleep_task(self, task: OmniSleepTask) -> OmniACK:
+    def handle_sleep_task(self, task: OmniSleepTask | dict) -> OmniACK | None:
         from vllm_omni.platforms import current_omni_platform
 
         try:
@@ -649,7 +692,7 @@ class DiffusionWorker:
                     pass
             return OmniACK(task_id=task.task_id, status="ERROR", error_msg=str(e))
 
-    def handle_wake_task(self, task: OmniWakeTask) -> OmniACK:
+    def handle_wake_task(self, task: OmniWakeTask | dict) -> OmniACK | None:
         from vllm_omni.platforms import current_omni_platform
 
         try:
@@ -768,17 +811,12 @@ class WorkerProc:
         self.result_mq = None
         self.result_mq_handle = None
 
-        # Setup result sender (only for rank 0)
-        if gpu_id == 0:
-            self.result_mq = MessageQueue(n_reader=1, n_local_reader=1, local_reader_ranks=[0])
-            self.result_mq_handle = self.result_mq.export_handle()
-            WorkerProc._shared_result_handle = self.result_mq_handle
-            logger.info(f"Worker {gpu_id} created result MessageQueue")
-        else:
-            handle = getattr(WorkerProc, "_shared_result_handle", None)
-            if handle:
-                self.result_mq = MessageQueue.create_from_handle(handle, gpu_id)
-                logger.info(f"Worker {gpu_id} attached to shared result MessageQueue")
+        # Each worker creates its own result MessageQueue (as writer).
+        # The executor creates one reader per worker to collect responses.
+        # This supports DP multi-concurrency where all ranks reply independently.
+        self.result_mq = MessageQueue(n_reader=1, n_local_reader=1, local_reader_ranks=[0])
+        self.result_mq_handle = self.result_mq.export_handle()
+        logger.info(f"Worker {gpu_id} created result MessageQueue")
 
         assert od_config.master_port is not None
 
@@ -786,13 +824,28 @@ class WorkerProc:
         self.worker = self._create_worker(gpu_id, od_config, worker_extension_cls, custom_pipeline_args)
         self._running = True
 
+        self._async_output_queue: queue.Queue | None = None
+        self._async_output_thread: threading.Thread | None = None
+        if not self.od_config.step_execution:
+            self._async_output_queue = queue.Queue()
+            self._async_output_thread = threading.Thread(
+                target=self._async_output_loop,
+                daemon=True,
+                name="DiffusionAsyncOutput",
+            )
+            self._async_output_thread.start()
+
+    @staticmethod
+    def _generate_async_output_id() -> str:
+        return uuid.uuid4().hex
+
     def _create_worker(
         self,
         gpu_id: int,
         od_config: OmniDiffusionConfig,
         worker_extension_cls: str | None,
         custom_pipeline_args: dict[str, Any] | None = None,
-    ) -> DiffusionWorker:
+    ) -> "WorkerWrapperBase":
         """Create a worker instance. Override in subclasses for different worker types."""
         worker_cls_path = current_omni_platform.get_diffusion_worker_cls()
         base_worker_class = resolve_obj_by_qualname(worker_cls_path)
@@ -805,22 +858,72 @@ class WorkerProc:
         )
         return wrapper
 
-    def return_result(self, output: Any):
+    def _return_result(self, output: Any, rpc_id: str | None = None) -> None:
         """Reply to client, only on rank 0."""
-        if self.result_mq is not None:
-            if isinstance(output, OmniACK):
-                self.result_mq.enqueue(output)
-                return
-            try:
-                pack_diffusion_output_shm(output)
-            except Exception as e:
-                if hasattr(output, "output"):
-                    logger.warning("SHM pack failed for model output: %s", e)
+        if self.result_mq is None:
+            return
+        if isinstance(output, OmniACK):
             self.result_mq.enqueue(output)
+            return
 
-    def recv_message(self):
-        """Receive messages from broadcast queue."""
-        return self.mq.dequeue(indefinite=True)
+        # Async path: enqueue compute_done immediately, bg thread does D2H+SHM.
+        if not self.od_config.step_execution and isinstance(output, (DiffusionOutput, BatchRunnerOutput)):
+            async_output_id = WorkerProc._generate_async_output_id()
+            gpu_event = current_omni_platform.record_device_event()
+            self._async_output_queue.put((output, async_output_id, gpu_event))
+            msg = AsyncDiffusionOutput(
+                kind=AsyncOutputKind.COMPUTE_DONE,
+                rpc_id=rpc_id,
+                async_output_id=async_output_id,
+            )
+            self.result_mq.enqueue(msg)
+            return
+
+        # Sync path (original, or async fallback).
+        try:
+            pack_diffusion_output_shm(output)
+        except Exception as e:
+            if hasattr(output, "output"):
+                logger.warning("SHM pack failed for model output: %s", e)
+        self.result_mq.enqueue(output)
+
+    def _async_output_loop(self):
+        """Background thread: D2H + SHM packing for async diffusion output.
+
+        Uses a side stream so the D2H transfer does not block the default
+        stream where the next forward runs.
+        """
+        device = torch.device(torch.accelerator.current_accelerator().type, self.gpu_id)
+        d2h_stream = torch.Stream(device=device)
+        while self._running:
+            output, async_output_id, gpu_event = self._async_output_queue.get()
+            try:
+                # Cross-stream ordering: wait for default stream to finish
+                # writing the output tensors before the side stream reads.
+                if gpu_event is not None:
+                    d2h_stream.wait_event(gpu_event)
+                pack_diffusion_output_shm(output, d2h_stream=d2h_stream)
+                d2h_stream.synchronize()
+
+                self.result_mq.enqueue(
+                    AsyncDiffusionOutput(
+                        kind=AsyncOutputKind.OUTPUT_READY,
+                        async_output_id=async_output_id,
+                        output=output,
+                    )
+                )
+            except Exception:
+                logger.exception(
+                    "Async output packing failed for id '%s'; sending error",
+                    async_output_id,
+                )
+                self.result_mq.enqueue(
+                    AsyncDiffusionOutput(
+                        kind=AsyncOutputKind.OUTPUT_READY,
+                        async_output_id=async_output_id,
+                        error="Background D2H/SHM packing failed",
+                    )
+                )
 
     def _gather_rpc_rank_statuses(self, status: dict[str, Any]) -> list[dict[str, Any]]:
         if not torch.distributed.is_initialized():
@@ -834,7 +937,7 @@ class WorkerProc:
             logger.warning("RPC rank status gather returned missing entries for ranks: %s", missing_ranks)
         return [s for s in statuses if s is not None]
 
-    def execute_rpc(self, rpc_request: dict) -> tuple[object | None, bool]:
+    def _execute_rpc(self, rpc_request: dict) -> tuple[object | None, bool]:
         """Execute an RPC request and indicate whether to reply."""
         method = rpc_request["method"]
         args = rpc_request.get("args", ())
@@ -842,12 +945,33 @@ class WorkerProc:
         output_rank = rpc_request.get("output_rank")
         exec_all_ranks = rpc_request.get("exec_all_ranks", False)
         collect_rank_status = rpc_request.get("collect_rank_status", False)
+        wave_id = rpc_request.get("wave_id")
 
         if collect_rank_status and not exec_all_ranks:
             raise ValueError("collect_rank_status requires exec_all_ranks=True so all ranks enter the status gather")
 
         should_execute = exec_all_ranks or output_rank is None or output_rank == self.gpu_id
-        should_reply = (output_rank is None or output_rank == self.gpu_id) and self.result_mq is not None
+        # For DP multi-concurrency (output_rank=None), only the primary rank
+        # within each DP replica should reply.  This prevents SP/TP/CFG/PP
+        # ranks from enqueuing extra replies that the executor doesn't drain.
+        if output_rank is None and exec_all_ranks:
+            from vllm.distributed.parallel_state import get_tensor_model_parallel_rank
+
+            from vllm_omni.diffusion.distributed.parallel_state import (
+                get_classifier_free_guidance_rank,
+                get_pipeline_parallel_rank,
+                get_sequence_parallel_rank,
+            )
+
+            is_primary_in_replica = (
+                get_sequence_parallel_rank() == 0
+                and get_classifier_free_guidance_rank() == 0
+                and get_tensor_model_parallel_rank() == 0
+                and get_pipeline_parallel_rank() == 0
+            )
+            should_reply = is_primary_in_replica and self.result_mq is not None
+        else:
+            should_reply = (output_rank is None or output_rank == self.gpu_id) and self.result_mq is not None
 
         if not should_execute:
             return None, False
@@ -890,6 +1014,7 @@ class WorkerProc:
                         "method": method,
                         "result": result,
                         "rank_statuses": rank_statuses,
+                        "wave_id": wave_id,
                     },
                     True,
                 )
@@ -897,9 +1022,11 @@ class WorkerProc:
 
         if rpc_exception is not None:
             raise rpc_exception
+        if isinstance(result, dict) and wave_id is not None:
+            result["wave_id"] = wave_id
         return result, should_reply
 
-    def worker_busy_loop(self) -> None:
+    def _worker_busy_loop(self) -> None:
         """Main busy loop for Multiprocessing Workers."""
         logger.info(f"Worker {self.gpu_id} ready to receive requests via shared memory")
 
@@ -924,21 +1051,67 @@ class WorkerProc:
             if isinstance(msg, dict) and msg.get("type") == "sleep":
                 task = OmniSleepTask(level=msg.get("level", 2), task_id=msg.get("task_id", "local"))
                 ack = self.worker.handle_sleep_task(task)
-                self.return_result(ack)
+                self._return_result(ack)
             elif isinstance(msg, dict) and msg.get("type") == "wake_up":
                 task = OmniWakeTask(tags=msg.get("tags"), task_id=msg.get("task_id", "local"))
                 ack = self.worker.handle_wake_task(task)
-                self.return_result(ack)
+                self._return_result(ack)
             # Route message based on type
             elif isinstance(msg, dict) and msg.get("type") == "rpc":
                 try:
-                    result, should_reply = self.execute_rpc(msg)
+                    rpc_id = msg.get("rpc_id")
+                    result, should_reply = self._execute_rpc(msg)
                     if should_reply:
-                        self.return_result(result)
+                        self._return_result(result, rpc_id=rpc_id)
                 except Exception as e:
                     logger.error(f"Error processing RPC: {e}", exc_info=True)
+                    # Apply the same reply gate as the success path so
+                    # non-output ranks don't enqueue stale error replies
+                    # that compete with the expected responder's message.
+                    output_rank = msg.get("output_rank")
+                    exec_all_ranks = msg.get("exec_all_ranks", False)
+                    wave_id = msg.get("wave_id")
                     if self.result_mq is not None:
-                        self.return_result({"status": "error", "error": str(e)})
+                        if rpc_id is not None:
+                            # Async RPC: must complete the executor's pending
+                            # future so collective_rpc() doesn't hang.
+                            self.result_mq.enqueue(
+                                AsyncDiffusionOutput(
+                                    kind=AsyncOutputKind.RPC_RESULT,
+                                    rpc_id=rpc_id,
+                                    error=str(e),
+                                )
+                            )
+                        elif output_rank is None and exec_all_ranks:
+                            # DP multi-concurrency: primary ranks reply, tagged
+                            from vllm.distributed.parallel_state import (
+                                get_tensor_model_parallel_rank,
+                            )
+
+                            from vllm_omni.diffusion.distributed.parallel_state import (
+                                get_classifier_free_guidance_rank,
+                                get_data_parallel_rank,
+                                get_pipeline_parallel_rank,
+                                get_sequence_parallel_rank,
+                            )
+
+                            is_primary = (
+                                get_sequence_parallel_rank() == 0
+                                and get_classifier_free_guidance_rank() == 0
+                                and get_tensor_model_parallel_rank() == 0
+                                and get_pipeline_parallel_rank() == 0
+                            )
+                            if is_primary:
+                                try:
+                                    dp_rank = get_data_parallel_rank()
+                                except Exception:
+                                    dp_rank = self.gpu_id
+                                self._return_result(
+                                    {"status": "error", "error": str(e), "dp_rank": dp_rank, "wave_id": wave_id}
+                                )
+                        elif output_rank is None or output_rank == self.gpu_id:
+                            # Normal RPC: only the expected rank replies
+                            self._return_result({"status": "error", "error": str(e), "wave_id": wave_id})
 
             elif isinstance(msg, dict) and msg.get("type") == "shutdown":
                 logger.info("Worker %s: Received shutdown message", self.gpu_id)
@@ -957,7 +1130,7 @@ class WorkerProc:
                     output = DiffusionOutput.from_exception(e)
 
                 try:
-                    self.return_result(output)
+                    self._return_result(output)
                 except zmq.ZMQError as e:
                     logger.error(f"ZMQ error sending reply: {e}")
                     continue
@@ -1013,10 +1186,10 @@ class WorkerProc:
             pipe_writer.send(
                 {
                     "status": "ready",
-                    "result_handle": worker_proc.result_mq_handle if rank == 0 else None,
+                    "result_handle": worker_proc.result_mq_handle,
                 }
             )
-            worker_proc.worker_busy_loop()
+            worker_proc._worker_busy_loop()
         except SystemExit:
             logger.info("Worker %d: Shutdown signal received, starting cleanup.", rank)
             raise
@@ -1133,54 +1306,30 @@ class WorkerWrapperBase:
 
         return worker_class
 
-    def generate(self, requests: list[OmniDiffusionRequest]) -> DiffusionOutput:
-        """
-        Generate output for the given requests.
-
-        Args:
-            requests: List of diffusion requests
-
-        Returns:
-            DiffusionOutput with generated results
-        """
-        return self.worker.generate(requests)
-
     def execute_model(
         self,
-        reqs: list[OmniDiffusionRequest],
+        req: OmniDiffusionRequest,
         od_config: OmniDiffusionConfig,
-        kv_prefetch_jobs: dict | None = None,
+        kv_prefetch_job: KVPrefetchJob | None = None,
     ) -> DiffusionOutput:
         """
         Execute a forward pass.
 
         Args:
-            reqs: List of diffusion requests
+            req: Diffusion request.
             od_config: OmniDiffusionConfig configuration
-            kv_prefetch_jobs: Optional next-request KV prefetch descriptor.
+            kv_prefetch_job: Optional next-request KV prefetch descriptor.
 
         Returns:
             DiffusionOutput with generated results
         """
-        return self.worker.execute_model(reqs, od_config, kv_prefetch_jobs=kv_prefetch_jobs)
+        return self.worker.execute_model(req, od_config, kv_prefetch_job=kv_prefetch_job)
 
     def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> BaseRunnerOutput:
         """Execute one diffusion step."""
         return self.worker.execute_stepwise(scheduler_output)
 
-    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        """
-        Load model weights.
-
-        Args:
-            weights: Iterable of (name, tensor) tuples
-
-        Returns:
-            Set of loaded weight names
-        """
-        return self.worker.load_weights(weights)
-
-    def sleep(self, level: int = 1) -> bool:
+    def sleep(self, level: int = 1) -> int:
         """
         Put the worker to sleep. The worker should not process any requests.
         The caller should guarantee that no requests are being processed
@@ -1188,11 +1337,11 @@ class WorkerWrapperBase:
 
         Args:
             level: The sleep level. Level 1 sleep will offload the model
-                weights and discard the kv cache.
-                Currently only support level 1.
+                weights and discard the kv cache. Level 2 also saves buffers.
+                Currently only support level 1 and level 2.
 
         Returns:
-            True on success
+            Bytes held by the allocator before sleeping.
         """
         return self.worker.sleep(level)
 
@@ -1213,10 +1362,10 @@ class WorkerWrapperBase:
         """
         return self.worker.wake_up(tags)
 
-    def handle_sleep_task(self, task):
+    def handle_sleep_task(self, task: OmniSleepTask | dict) -> OmniACK | None:
         return self.worker.handle_sleep_task(task)
 
-    def handle_wake_task(self, task):
+    def handle_wake_task(self, task: OmniWakeTask | dict) -> OmniACK | None:
         return self.worker.handle_wake_task(task)
 
     def shutdown(self) -> None:
diff --git a/vllm_omni/diffusion/worker/input_batch.py b/vllm_omni/diffusion/worker/input_batch.py
index 511f2dd69..d21e73287 100644
--- a/vllm_omni/diffusion/worker/input_batch.py
+++ b/vllm_omni/diffusion/worker/input_batch.py
@@ -17,7 +17,8 @@ from dataclasses import dataclass, field
 import numpy as np
 import torch
 
-from vllm_omni.diffusion.worker.utils import DiffusionRequestState
+from vllm_omni.diffusion.prompt_update import prompt_update_versions
+from vllm_omni.diffusion.worker.utils import StepRequestState
 
 
 def _normalize_prompt_embeds(x: torch.Tensor) -> torch.Tensor:
@@ -59,9 +60,9 @@ def _pad_mask(x: torch.Tensor, target_seq_len: int) -> torch.Tensor:
 
 
 def _select_states(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     idx_mapping: torch.Tensor | None,
-) -> tuple[list[DiffusionRequestState], torch.Tensor, np.ndarray]:
+) -> tuple[list[StepRequestState], torch.Tensor, np.ndarray]:
     if not states:
         raise ValueError("Cannot build InputBatch from empty states.")
 
@@ -73,7 +74,7 @@ def _select_states(
             raise ValueError("idx_mapping must be a 1D tensor.")
         idx_mapping = idx_mapping.to(dtype=torch.int32)
 
-    selected_states: list[DiffusionRequestState] = []
+    selected_states: list[StepRequestState] = []
     for batch_idx, state_idx in enumerate(idx_mapping.tolist()):
         if state_idx < 0 or state_idx >= len(states):
             raise ValueError(f"idx_mapping[{batch_idx}]={state_idx} is out of range for states.")
@@ -81,12 +82,12 @@ def _select_states(
     return selected_states, idx_mapping, idx_mapping.detach().cpu().numpy()
 
 
-def _prepare_request_ids(states: Sequence[DiffusionRequestState]) -> list[str]:
+def _prepare_request_ids(states: Sequence[StepRequestState]) -> list[str]:
     return [state.request_id for state in states]
 
 
 def _prepare_prompt_field_on_state(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     *,
     embeds_attr: str,
     mask_attr: str,
@@ -180,7 +181,7 @@ def _get_seq_lens_from_mask(mask: torch.Tensor) -> list[int]:
 
 
 def _get_request_prompt_seq_lens(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     *,
     embeds_attr: str,
     mask_attr: str,
@@ -209,7 +210,7 @@ def _get_request_prompt_seq_lens(
 
 
 def _prepare_request_prompt_field(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     *,
     embeds_attr: str,
     mask_attr: str,
@@ -266,7 +267,7 @@ def _prepare_request_prompt_field(
 
 
 def _prepare_padded_prompt_fields(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     embeds_attr: str,
     mask_attr: str,
@@ -337,7 +338,7 @@ def _prepare_padded_prompt_fields(
 
 
 def _prepare_latents(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     out: torch.Tensor | None = None,
 ) -> torch.Tensor:
@@ -352,7 +353,7 @@ def _prepare_latents(
 
 
 def _require_state_latents(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     *,
     for_field: str,
 ) -> torch.Tensor:
@@ -382,7 +383,7 @@ def _expand_scalar_or_vector(
 
 
 def _prepare_timesteps(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     out: torch.Tensor | None = None,
 ) -> torch.Tensor:
@@ -410,9 +411,9 @@ def _prepare_timesteps(
 
 
 def _prepare_cfg_scalars(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
 ) -> tuple[bool, float, bool]:
-    def _cfg_scalars(state: DiffusionRequestState) -> tuple[bool, float, bool]:
+    def _cfg_scalars(state: StepRequestState) -> tuple[bool, float, bool]:
         true_cfg_scale = getattr(state.sampling, "true_cfg_scale", None) or 4.0
         cfg_normalize = bool(getattr(state.sampling, "cfg_normalize", False))
         return state.do_true_cfg, true_cfg_scale, cfg_normalize
@@ -425,7 +426,7 @@ def _prepare_cfg_scalars(
 
 
 def _prepare_guidance(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     out: torch.Tensor | None = None,
 ) -> torch.Tensor | None:
@@ -461,7 +462,7 @@ def _prepare_guidance(
 
 
 def _prepare_image_latents(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     out: torch.Tensor | None = None,
 ) -> torch.Tensor | None:
@@ -478,7 +479,7 @@ def _prepare_image_latents(
 
 
 def _prepare_seq_lens(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     attr_name: str,
 ) -> list[int] | None:
     values = [getattr(state, attr_name) for state in states]
@@ -489,7 +490,7 @@ def _prepare_seq_lens(
     return [int(value[0]) for value in values if value is not None]
 
 
-def _prepare_img_shapes(states: Sequence[DiffusionRequestState]) -> list | None:
+def _prepare_img_shapes(states: Sequence[StepRequestState]) -> list | None:
     values = [state.img_shapes for state in states]
     if all(value is None for value in values):
         return None
@@ -499,7 +500,7 @@ def _prepare_img_shapes(states: Sequence[DiffusionRequestState]) -> list | None:
 
 
 def _prepare_prompt_embeds(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     embeds_out: torch.Tensor | None = None,
     mask_out: torch.Tensor | None = None,
@@ -516,7 +517,7 @@ def _prepare_prompt_embeds(
 
 
 def _prepare_negative_prompt_embeds(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     *,
     embeds_out: torch.Tensor | None = None,
     mask_out: torch.Tensor | None = None,
@@ -535,16 +536,21 @@ def _same_composition(
     cached_batch: InputBatch | None,
     request_ids: list[str],
     idx_mapping_np: np.ndarray,
+    states: Sequence[StepRequestState],
 ) -> bool:
     if cached_batch is None:
         return False
     if cached_batch.request_ids != request_ids:
         return False
-    return np.array_equal(cached_batch.idx_mapping_np, idx_mapping_np)
+    if not np.array_equal(cached_batch.idx_mapping_np, idx_mapping_np):
+        return False
+    # Midway prompt updates (typically for video generation) can change prompt_embeds without changing ids/mapping.
+    # In this case, each request state manages the embedding's "version". Use it to determine if cache is still valid.
+    return cached_batch._prompt_update_versions == prompt_update_versions(states)
 
 
 def _scatter_batch_tensor_by_mapping(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     idx_mapping_np: np.ndarray,
     *,
     attr_name: str,
@@ -582,7 +588,7 @@ class InputBatch:
     """Ephemeral step-level batch view.
 
     Static request-local tensors are normalized and padded onto
-    ``DiffusionRequestState`` itself, making the request state the persistent
+    ``StepRequestState`` itself, making the request state the persistent
     source of truth. ``InputBatch`` only assembles a contiguous view for the
     current step and refreshes dynamic fields in-place when composition is
     unchanged.
@@ -613,7 +619,11 @@ class InputBatch:
     img_shapes: list | None = None
     txt_seq_lens: list[int] | None = None
     negative_txt_seq_lens: list[int] | None = None
-    states: Sequence[DiffusionRequestState] = field(default_factory=tuple)
+    states: Sequence[StepRequestState] = field(default_factory=tuple)
+
+    # For midway prompt updates (typically for video generation) that changes embeddings without changing ids,
+    # Keep a snapshot of the current per-request versions of prompt embeddings for later runtime comparison
+    _prompt_update_versions: tuple[int, ...] = ()
 
     def __post_init__(self) -> None:
         if len(self.request_ids) != int(self.idx_mapping.numel()):
@@ -625,14 +635,14 @@ class InputBatch:
 
     def _refresh_dynamic_fields(
         self,
-        selected_states: Sequence[DiffusionRequestState],
+        selected_states: Sequence[StepRequestState],
     ) -> None:
         self.latents = _prepare_latents(selected_states, out=self.latents)
         self.timesteps = _prepare_timesteps(selected_states, out=self.timesteps)
 
     def _refresh_static_fields(
         self,
-        states: Sequence[DiffusionRequestState],
+        states: Sequence[StepRequestState],
     ) -> None:
         self.do_true_cfg, self.true_cfg_scale, self.cfg_normalize = _prepare_cfg_scalars(states)
         self.guidance = _prepare_guidance(states, out=self.guidance)
@@ -653,10 +663,11 @@ class InputBatch:
         self.img_shapes = _prepare_img_shapes(states)
         self.txt_seq_lens = _prepare_seq_lens(states, "txt_seq_lens")
         self.negative_txt_seq_lens = _prepare_seq_lens(states, "negative_txt_seq_lens")
+        self._prompt_update_versions = prompt_update_versions(states)
 
     def _repack_dynamic_fields(
         self,
-        selected_states: Sequence[DiffusionRequestState],
+        selected_states: Sequence[StepRequestState],
     ) -> None:
         # Same-composition cache hits reuse static prompt fields; request ids
         # must keep the same encoded prompt metadata for the batch lifetime.
@@ -665,7 +676,7 @@ class InputBatch:
 
     def _rebuild(
         self,
-        selected_states: Sequence[DiffusionRequestState],
+        selected_states: Sequence[StepRequestState],
         idx_mapping: torch.Tensor,
         idx_mapping_np: np.ndarray,
         request_ids: list[str],
@@ -685,7 +696,7 @@ class InputBatch:
     @classmethod
     def make_batch(
         cls,
-        states: Sequence[DiffusionRequestState],
+        states: Sequence[StepRequestState],
         idx_mapping: torch.Tensor | None = None,
         cached_batch: InputBatch | None = None,
     ) -> InputBatch:
@@ -693,7 +704,7 @@ class InputBatch:
         selected_states, idx_mapping, idx_mapping_np = _select_states(states, idx_mapping)
         request_ids = _prepare_request_ids(selected_states)
 
-        if _same_composition(cached_batch, request_ids, idx_mapping_np):
+        if _same_composition(cached_batch, request_ids, idx_mapping_np, selected_states):
             assert cached_batch is not None
             cached_batch._repack_dynamic_fields(selected_states)
             return cached_batch
@@ -733,11 +744,12 @@ class InputBatch:
                 "negative_txt_seq_lens",
             ),
             states=tuple(selected_states),
+            _prompt_update_versions=prompt_update_versions(selected_states),
         )
 
 
 def scatter_latents(
-    states: Sequence[DiffusionRequestState],
+    states: Sequence[StepRequestState],
     input_batch: InputBatch,
 ) -> None:
     """Scatter the step-updated latents back into persistent request states.
diff --git a/vllm_omni/diffusion/worker/request_batch.py b/vllm_omni/diffusion/worker/request_batch.py
index 1f7c2acaa..079a213db 100644
--- a/vllm_omni/diffusion/worker/request_batch.py
+++ b/vllm_omni/diffusion/worker/request_batch.py
@@ -8,6 +8,7 @@ from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any
 
+import numpy as np
 import torch
 
 from vllm_omni.diffusion.data import DiffusionOutput
@@ -20,7 +21,7 @@ def _slice_request_output(value: Any, start: int, stop: int) -> Any:
         return tuple(_slice_request_output(item, start, stop) for item in value)
     if isinstance(value, list):
         return value[start:stop]
-    if isinstance(value, torch.Tensor):
+    if isinstance(value, (np.ndarray, torch.Tensor)):
         return value[start:stop]
     return value
 
@@ -48,6 +49,9 @@ def split_diffusion_output_by_request(
             peak_memory_mb=result.peak_memory_mb,
             chunk_index=result.chunk_index,
             total_chunks=result.total_chunks,
+            started_event_ids=result.started_event_ids,
+            active_event_ids=result.active_event_ids,
+            completed_event_ids=result.completed_event_ids,
         )
         for idx in range(req.num_reqs)
     ]
diff --git a/vllm_omni/diffusion/worker/utils.py b/vllm_omni/diffusion/worker/utils.py
index ba6165a9d..40ed550d0 100644
--- a/vllm_omni/diffusion/worker/utils.py
+++ b/vllm_omni/diffusion/worker/utils.py
@@ -33,7 +33,7 @@ def consume_pipeline_stage_durations(pipeline: Any) -> dict[str, float]:
 
 
 def merge_stage_durations(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     stage_durations: dict[str, float],
 ) -> None:
     if not stage_durations:
@@ -43,7 +43,7 @@ def merge_stage_durations(
 
 
 def attach_stage_durations(
-    state: DiffusionRequestState,
+    state: StepRequestState,
     output: DiffusionOutput,
 ) -> None:
     if state.stage_durations:
@@ -51,7 +51,7 @@ def attach_stage_durations(
 
 
 @dataclass
-class DiffusionRequestState:
+class StepRequestState:
     """Per-request mutable state across all pipeline stages.
 
     Owned by Runner and passed through all step-execution stages:
@@ -163,12 +163,6 @@ class DiffusionRequestState:
             return self.denoise_completed
         return self.chunk_index >= self.total_chunks
 
-    @property
-    def new_request(self) -> bool:
-        # TODO: this is only an approximation for current stepwise mode.
-        # A real "new request" signal should eventually come from scheduler/runner state transitions.
-        return self.step_index == 0 or self.timesteps is None
-
 
 class BaseRunnerOutput(ABC):
     @abstractmethod
@@ -189,6 +183,7 @@ class RunnerOutput(BaseRunnerOutput):
     step_index: int | None = None
     finished: bool = False
     result: DiffusionOutput | None = None
+    async_output_id: str | None = None
 
     def get_request_output(self, request_id: str) -> RunnerOutput | None:
         return self if self.request_id == request_id else None
diff --git a/vllm_omni/distributed/omni_connectors/adapter.py b/vllm_omni/distributed/omni_connectors/adapter.py
index db253ebad..f1e224b15 100644
--- a/vllm_omni/distributed/omni_connectors/adapter.py
+++ b/vllm_omni/distributed/omni_connectors/adapter.py
@@ -229,6 +229,22 @@ def construct_next_stage_streaming_input_prompt(payload_data: dict[str, Any], re
       extended prompt without discarding prior computed state.
     """
     ids = payload_data.get("ids", {})
+    meta = payload_data.get("meta", {})
+    replace_prompt = isinstance(meta, dict) and meta.get("replace_streaming_prompt") is True
+    next_stage_prompt_len = meta.get("next_stage_prompt_len") if isinstance(meta, dict) else None
+    if replace_prompt and isinstance(next_stage_prompt_len, int) and next_stage_prompt_len > 0:
+        # Some downstream stages consume complete, independently conditioned
+        # segments instead of extending an existing KV prefix. The producer
+        # declares that transport behavior explicitly in payload metadata.
+        new_prompt = [0] * next_stage_prompt_len
+        request._output_token_ids.clear()
+        request._all_token_ids.clear()
+        request._all_token_ids.extend(new_prompt)
+        request.prompt_token_ids = new_prompt
+        request.num_computed_tokens = 0
+        request.num_prompt_tokens = next_stage_prompt_len
+        request.update_block_hashes()
+        return
     prompt_token_ids = ids.get("prompt", None)
     if not prompt_token_ids:
         return
@@ -239,7 +255,10 @@ def construct_next_stage_streaming_input_prompt(payload_data: dict[str, Any], re
     assert request.prompt_token_ids is not None
     # Extend prompt with kept output tokens.
     request.prompt_token_ids.extend(kept_output_tokens)
-    next_prompt_len = max(1, compute_talker_prompt_ids_length(prompt_token_ids))
+    if isinstance(next_stage_prompt_len, int) and next_stage_prompt_len > 0:
+        next_prompt_len = next_stage_prompt_len
+    else:
+        next_prompt_len = max(1, compute_talker_prompt_ids_length(prompt_token_ids))
     new_prompt = [0] * next_prompt_len
     request._all_token_ids.extend(new_prompt or ())
     request.prompt_token_ids.extend(new_prompt or ())
diff --git a/vllm_omni/distributed/omni_connectors/connectors/mooncake_transfer_engine_connector.py b/vllm_omni/distributed/omni_connectors/connectors/mooncake_transfer_engine_connector.py
index 34d19062a..2d0c1f11a 100644
--- a/vllm_omni/distributed/omni_connectors/connectors/mooncake_transfer_engine_connector.py
+++ b/vllm_omni/distributed/omni_connectors/connectors/mooncake_transfer_engine_connector.py
@@ -30,6 +30,9 @@ except ImportError:
 # Stale buffer TTL: buffers older than this are automatically reclaimed
 # to prevent memory leaks when receiver crashes or gives up.
 _BUFFER_TTL_SECONDS = 300  # 5 minutes
+_BASE_TRANSFER_TIMEOUT_MS = 30_000
+_TRANSFER_TIMEOUT_STEP_BYTES = 100 * 1024 * 1024
+_TRANSFER_TIMEOUT_PER_STEP_MS = 5_000
 
 # ZMQ Message constants
 TRANS_DONE = b"trans_done"
@@ -119,6 +122,7 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
         self._worker_local = threading.local()
         self._last_ttl_check: float = _time_mod.monotonic()
         self._sender_endpoints: dict[int, tuple[str, int]] = {}
+        self._in_flight_buffers: set[str] = set()
 
         self._metrics = {
             "puts": 0,
@@ -155,6 +159,7 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
         # --- Memory Pool Configuration ---
         self.pool_size = config.get("memory_pool_size", 1024**3)  # Default 1GB
         self.pool_device = config.get("memory_pool_device", "cpu")
+        self.buffer_ttl_seconds = float(config.get("buffer_ttl_seconds", _BUFFER_TTL_SECONDS))
 
         # --- Sender Configuration (for receiver to query without metadata) ---
         # When receiver doesn't have metadata, it uses these to connect to sender
@@ -175,7 +180,12 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
 
         self.engine_id = str(uuid.uuid4())
 
-        # --- Mooncake Engine Init ---
+        self._init_engine()
+        self._init_pool()
+        self._init_listener(config)
+
+    def _init_engine(self) -> None:
+        """Initialize the Mooncake engine and discover the local RPC port."""
         self.engine = TransferEngine()
         # Note: For P2P handshake mode, local_hostname should be just the IP address.
         # Mooncake will auto-assign an RPC port, retrievable via get_rpc_port().
@@ -186,7 +196,8 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
         self.rpc_port = self.engine.get_rpc_port()
         logger.info(f"MooncakeTransferEngineConnector initialized at {self.host}:{self.rpc_port}")
 
-        # --- Pool Allocation & Registration ---
+    def _init_pool(self) -> None:
+        """Allocate and register the memory pool used by TransferEngine."""
         logger.info(f"Allocating RDMA Memory Pool: {self.pool_size / 1024**2:.2f} MB on {self.pool_device}")
         try:
             if self.pool_device == "cpu":
@@ -207,9 +218,8 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
 
         self.allocator = BufferAllocator(self.pool_size, alignment=4096)  # 4KB alignment for safety
 
-        # --- State Management & Background Threads ---
-        # Most fields already initialized at the top of __init__ for teardown
-        # safety.  Only create the real ZMQ context and thread pool here.
+    def _init_listener(self, config: dict[str, Any]) -> None:
+        """Initialize control-plane sockets and start the sender listener."""
         self.zmq_ctx = zmq.Context()
         self._sender_executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="mooncake-sender")
 
@@ -642,44 +652,18 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
             raise RuntimeError("Cannot get data: MooncakeTransferEngineConnector is closed")
 
         get_key = self._make_key(get_key, from_stage, to_stage)
-
         _t0 = _time_mod.perf_counter()
-
+        metadata = self._resolve_metadata(get_key, metadata)
         if not metadata:
-            # Path 3: no metadata at all — query default sender
-            if not self.sender_host or not self.sender_zmq_port or str(self.sender_host).lower() == "auto":
-                raise RuntimeError(
-                    f"get(metadata=None) requires sender info to be resolved, "
-                    f"but sender_host={self.sender_host!r}, sender_zmq_port={self.sender_zmq_port!r}. "
-                    f"Call update_sender_info(host, port) before using get() without metadata."
-                )
-            metadata = self._query_metadata_from_sender(get_key)
-            if not metadata:
-                return None
-        elif "data_size" not in metadata:
-            # Path 2: partial metadata (host/port only) — query that sender
-            partial_host = metadata.get("source_host")
-            partial_port = metadata.get("source_port")
-            if not partial_host or not partial_port:
-                logger.warning(
-                    "get(%s): partial metadata missing source_host/source_port, cannot resolve data_size. metadata=%s",
-                    get_key,
-                    metadata,
-                )
-                return None
-            queried = self._query_metadata_at(get_key, str(partial_host), int(partial_port))
-            if not queried:
-                return None
-            metadata = queried
+            return None
 
         _t1 = _time_mod.perf_counter()
-        _query_ms = (_t1 - _t0) * 1000
+        query_ms = (_t1 - _t0) * 1000
 
         src_host = metadata.get("source_host")
         src_port = metadata.get("source_port")
-        data_size = metadata.get("data_size", 0)
-        is_fast_path = metadata.get("is_fast_path", False)
-
+        data_size = int(metadata.get("data_size", 0) or 0)
+        is_fast_path = bool(metadata.get("is_fast_path", False))
         if not src_host or not src_port or str(src_host).lower() == "auto":
             logger.error(
                 f"Invalid metadata for {get_key}: source_host={src_host!r}, "
@@ -691,27 +675,116 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
             logger.warning(f"Skipping get for {get_key}: data_size is 0 (metadata={metadata})")
             return None
 
-        # 1. Allocate Destination Buffer from Pool
-        # For non-fast-path (serialized objects), allocate a few extra bytes
-        # as padding.  Mooncake's TCP/memcpy transport may prepend a leading
-        # protocol byte (0x01) before the payload.  The extra padding allows
-        # the receiver to detect and skip this byte without truncating the
-        # actual payload.  The padding is harmless for fast-path (ManagedBuffer)
-        # because the caller reads exact-size slices.
-        _MOONCAKE_TCP_PADDING = 4 if not is_fast_path else 0
-        alloc_size = data_size + _MOONCAKE_TCP_PADDING
         try:
-            offset = self.allocator.alloc(alloc_size)
-            recv_buffer = ManagedBuffer(self.allocator, offset, alloc_size, self.pool)
-            dst_ptr = self.base_ptr + offset
+            recv_buffer, dst_ptr = self._alloc_recv_buffer(data_size, is_fast_path)
         except MemoryError:
-            logger.error(f"Failed to allocate {alloc_size} bytes in receive pool")
             return None
 
         _t2 = _time_mod.perf_counter()
-        _alloc_ms = (_t2 - _t1) * 1000
+        alloc_ms = (_t2 - _t1) * 1000
+        try:
+            resp = self._request_transfer(
+                get_key=get_key,
+                source_host=str(src_host),
+                source_port=int(src_port),
+                dst_ptr=dst_ptr,
+                data_size=data_size,
+            )
+        except zmq.Again as e:
+            self._metrics["timeouts"] += 1
+            logger.error(f"RDMA Get timed out: {e}", exc_info=True)
+            recv_buffer.release()
+            return None
+        except Exception as e:
+            self._metrics["errors"] += 1
+            logger.error(f"RDMA transfer request failed: {e}", exc_info=True)
+            recv_buffer.release()
+            return None
 
-        # 2. Prepare Handshake
+        _t3 = _time_mod.perf_counter()
+        rdma_ms = (_t3 - _t2) * 1000
+        if resp != TRANS_DONE:
+            self._metrics["errors"] += 1
+            logger.error(f"RDMA Get failed: received {resp} instead of TRANS_DONE")
+            recv_buffer.release()
+            return None
+
+        try:
+            sync_ms = self._sync_receive_buffer_if_needed()
+        except Exception as e:
+            self._metrics["errors"] += 1
+            logger.error(f"Failed to synchronize Mooncake receive buffer: {e}", exc_info=True)
+            recv_buffer.release()
+            return None
+
+        try:
+            return self._decode_result(
+                get_key=get_key,
+                recv_buffer=recv_buffer,
+                data_size=data_size,
+                is_fast_path=is_fast_path,
+                query_ms=query_ms,
+                alloc_ms=alloc_ms,
+                rdma_ms=rdma_ms,
+                sync_ms=sync_ms,
+                start_time=_t0,
+            )
+        except Exception as e:
+            self._metrics["errors"] += 1
+            logger.error(f"RDMA result decode failed for {get_key}: {e}", exc_info=True)
+            return None
+
+    def _resolve_metadata(self, get_key: str, metadata: dict[str, Any] | None) -> dict[str, Any] | None:
+        """Resolve full transfer metadata for a receive request."""
+        if not metadata:
+            # Path 3: no metadata at all — query default sender
+            if not self.sender_host or not self.sender_zmq_port or str(self.sender_host).lower() == "auto":
+                raise RuntimeError(
+                    f"get(metadata=None) requires sender info to be resolved, "
+                    f"but sender_host={self.sender_host!r}, sender_zmq_port={self.sender_zmq_port!r}. "
+                    f"Call update_sender_info(host, port) before using get() without metadata."
+                )
+            return self._query_metadata_from_sender(get_key)
+
+        if "data_size" in metadata:
+            # Path 1: metadata is complete
+            return metadata
+
+        # Path 2: partial metadata (host/port only) — query that sender
+        partial_host = metadata.get("source_host")
+        partial_port = metadata.get("source_port")
+        if not partial_host or not partial_port:
+            logger.warning(
+                "get(%s): partial metadata missing source_host/source_port, cannot resolve data_size. metadata=%s",
+                get_key,
+                metadata,
+            )
+            return None
+        return self._query_metadata_at(get_key, str(partial_host), int(partial_port))
+
+    def _alloc_recv_buffer(self, data_size: int, is_fast_path: bool) -> tuple[ManagedBuffer, int]:
+        """Allocate the receive-side buffer and return ``(buffer, dst_ptr)``."""
+        # For non-fast-path serialized objects, allocate a few extra bytes as
+        # padding. Mooncake's TCP/memcpy transport may prepend a protocol byte.
+        padding = 4 if not is_fast_path else 0
+        alloc_size = data_size + padding
+        try:
+            offset = self.allocator.alloc(alloc_size)
+        except MemoryError:
+            logger.error(f"Failed to allocate {alloc_size} bytes in receive pool")
+            raise
+        recv_buffer = ManagedBuffer(self.allocator, offset, alloc_size, self.pool)
+        return recv_buffer, self.base_ptr + offset
+
+    def _request_transfer(
+        self,
+        get_key: str,
+        source_host: str,
+        source_port: int,
+        dst_ptr: int,
+        data_size: int,
+    ) -> bytes:
+        """Ask the sender to write this key into the local receive buffer."""
         agent_meta = MooncakeAgentMetadata(
             remote_hostname=self.host,
             remote_port=self.rpc_port,
@@ -720,109 +793,82 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
             lengths=[data_size],
         )
 
-        # 3. ZMQ Transaction (uses cached socket to avoid TCP reconnection)
         # Timeout scales with data size: base 30s + 5s per 100MB.
-        # Large RDMA transfers (esp. loopback or cross-NIC) can take tens of
-        # seconds; if we time out too early the receiver closes and deregisters
-        # its memory, causing the sender's in-flight write to fail with ret=-1.
-        _base_timeout_ms = 30000
-        _size_timeout_ms = max(0, (data_size // (100 * 1024 * 1024))) * 5000
-        _total_timeout_ms = _base_timeout_ms + _size_timeout_ms
-        zmq_addr = f"tcp://{src_host}:{src_port}"
-        req_socket = self._get_req_socket(zmq_addr, timeout_ms=_total_timeout_ms)
-
+        size_timeout_ms = (data_size // _TRANSFER_TIMEOUT_STEP_BYTES) * _TRANSFER_TIMEOUT_PER_STEP_MS
+        total_timeout_ms = _BASE_TRANSFER_TIMEOUT_MS + size_timeout_ms
+        zmq_addr = f"tcp://{source_host}:{source_port}"
+        req_socket = self._get_req_socket(zmq_addr, timeout_ms=total_timeout_ms)
         try:
             req_socket.send(msgspec.msgpack.encode(agent_meta))
-            resp = req_socket.recv()
-
-            _t3 = _time_mod.perf_counter()
-            _rdma_ms = (_t3 - _t2) * 1000
-
-            if resp == TRANS_DONE:
-                # Success
-                # Ensure data is visible on GPU
-                # Note: RDMA write visibility on GPU usually requires some form of fence/sync.
-                # torch.accelerator.synchronize() is a heavy hammer but safe.
-                # Ideally Mooncake engine provides a way to poll for completion that guarantees visibility.
-                # TODO(wzliu): Replace synchronize with cuda event in the future for better performance.
-                if self.pool.is_cuda:
-                    with torch.cuda.device(self.pool.device):
-                        torch.cuda.current_stream().synchronize()
-
-                _t4 = _time_mod.perf_counter()
-                _sync_ms = (_t4 - _t3) * 1000
-
-                if is_fast_path:
-                    # Return ManagedBuffer directly for ALL fast_path data
-                    # (both bytes and tensor payloads).  Caller is responsible
-                    # for consuming the data and calling release() afterwards.
-                    # This avoids the expensive to_bytes() copy (~54ms for 115MB).
-                    #
-                    # Usage patterns for callers:
-                    #   - Zero-copy read: mv = memoryview(buf.tensor.numpy())
-                    #   - Copy to GPU:    buf.tensor.to(device); buf.release()
-                    #   - Fallback:       data = buf.to_bytes(); buf.release()
-                    _t5 = _time_mod.perf_counter()
-                    _total_ms = (_t5 - _t0) * 1000
-                    _mbps = (data_size / 1024 / 1024) / (_total_ms / 1000) if _total_ms > 0 else 0
-                    logger.info(
-                        f"[RDMA GET] {get_key}: query={_query_ms:.1f}ms, alloc={_alloc_ms:.1f}ms, "
-                        f"rdma={_rdma_ms:.1f}ms, sync={_sync_ms:.1f}ms, "
-                        f"total={_total_ms:.1f}ms, {_mbps:.1f} MB/s (fast_path, zero-copy)"
-                    )
-                    self._metrics["gets"] += 1
-                    self._metrics["bytes_transferred"] += data_size
-                    return recv_buffer, data_size
-                else:
-                    # If it was a serialized object or generic bytes, we assume standard Omni behavior:
-                    # Deserialize and return object. This requires a copy (to_bytes).
-                    # We MUST release the buffer after deserialization.
-                    try:
-                        _t_copy_start = _time_mod.perf_counter()
-                        raw_bytes = recv_buffer.to_bytes()
-                        _t_copy_end = _time_mod.perf_counter()
-                        _copy_ms = (_t_copy_end - _t_copy_start) * 1000
-
-                        # Try deserializing the first data_size bytes.  Mooncake's
-                        # TCP/memcpy transport may prepend a leading protocol byte
-                        # (0x01) before the payload — handle this by retrying from
-                        # offset 1 if the first attempt raises DecodeError.
-                        _t_deser_start = _time_mod.perf_counter()
-                        payload = raw_bytes[:data_size]
-                        try:
-                            val = OmniSerializer.deserialize(payload)
-                        except msgspec.DecodeError:
-                            # Likely a leading Mooncake TCP protocol byte — retry
-                            # from offset 1, using the extra padding bytes if needed.
-                            payload = raw_bytes[1 : data_size + 1]
-                            val = OmniSerializer.deserialize(payload)
-                        _t_deser_end = _time_mod.perf_counter()
-                        _deser_ms = (_t_deser_end - _t_deser_start) * 1000
-
-                        _total_ms = (_t_deser_end - _t0) * 1000
-                        _mbps = (data_size / 1024 / 1024) / (_total_ms / 1000) if _total_ms > 0 else 0
-                        logger.info(
-                            f"[RDMA GET] {get_key}: query={_query_ms:.1f}ms, alloc={_alloc_ms:.1f}ms, "
-                            f"rdma={_rdma_ms:.1f}ms, sync={_sync_ms:.1f}ms, copy={_copy_ms:.1f}ms, "
-                            f"deser={_deser_ms:.1f}ms, total={_total_ms:.1f}ms, {_mbps:.1f} MB/s"
-                        )
-                        self._metrics["gets"] += 1
-                        self._metrics["bytes_transferred"] += data_size
-                        return val, data_size
-                    finally:
-                        recv_buffer.release()
-            else:
-                self._metrics["errors"] += 1
-                logger.error(f"RDMA Get failed: received {resp} instead of TRANS_DONE")
-                recv_buffer.release()
-                return None
-        except Exception as e:
-            # Socket may be stuck after timeout; discard it
+            return req_socket.recv()
+        except Exception:
+            # Socket may be stuck after timeout; discard it.
             self._invalidate_req_socket(zmq_addr)
-            self._metrics["timeouts"] += 1
-            logger.error(f"RDMA Get error: {e}", exc_info=True)
+            raise
+
+    def _sync_receive_buffer_if_needed(self) -> float:
+        """Synchronize GPU-visible receive memory until Mooncake exposes a finer fence."""
+        t0 = _time_mod.perf_counter()
+        if self.pool.is_cuda:
+            with torch.cuda.device(self.pool.device):
+                torch.cuda.current_stream().synchronize()
+        return (_time_mod.perf_counter() - t0) * 1000
+
+    def _decode_result(
+        self,
+        get_key: str,
+        recv_buffer: ManagedBuffer,
+        data_size: int,
+        is_fast_path: bool,
+        query_ms: float,
+        alloc_ms: float,
+        rdma_ms: float,
+        sync_ms: float,
+        start_time: float,
+    ) -> tuple[Any, int]:
+        """Decode a completed transfer result."""
+        if is_fast_path:
+            try:
+                total_ms = (_time_mod.perf_counter() - start_time) * 1000
+                mbps = (data_size / 1024 / 1024) / (total_ms / 1000) if total_ms > 0 else 0
+                logger.info(
+                    f"[RDMA GET] {get_key}: query={query_ms:.1f}ms, alloc={alloc_ms:.1f}ms, "
+                    f"rdma={rdma_ms:.1f}ms, sync={sync_ms:.1f}ms, "
+                    f"total={total_ms:.1f}ms, {mbps:.1f} MB/s (fast_path, zero-copy)"
+                )
+                self._metrics["gets"] += 1
+                self._metrics["bytes_transferred"] += data_size
+                return recv_buffer, data_size
+            except Exception:
+                recv_buffer.release()
+                raise
+
+        try:
+            copy_start = _time_mod.perf_counter()
+            raw_bytes = recv_buffer.to_bytes()
+            copy_ms = (_time_mod.perf_counter() - copy_start) * 1000
+
+            deser_start = _time_mod.perf_counter()
+            payload = raw_bytes[:data_size]
+            try:
+                value = OmniSerializer.deserialize(payload)
+            except msgspec.DecodeError:
+                payload = raw_bytes[1 : data_size + 1]
+                value = OmniSerializer.deserialize(payload)
+            deser_ms = (_time_mod.perf_counter() - deser_start) * 1000
+
+            total_ms = (_time_mod.perf_counter() - start_time) * 1000
+            mbps = (data_size / 1024 / 1024) / (total_ms / 1000) if total_ms > 0 else 0
+            logger.info(
+                f"[RDMA GET] {get_key}: query={query_ms:.1f}ms, alloc={alloc_ms:.1f}ms, "
+                f"rdma={rdma_ms:.1f}ms, sync={sync_ms:.1f}ms, copy={copy_ms:.1f}ms, "
+                f"deser={deser_ms:.1f}ms, total={total_ms:.1f}ms, {mbps:.1f} MB/s"
+            )
+            self._metrics["gets"] += 1
+            self._metrics["bytes_transferred"] += data_size
+            return value, data_size
+        finally:
             recv_buffer.release()
-            return None
 
     def cleanup(self, request_id: str, from_stage: str | None = None, to_stage: str | None = None) -> None:
         """Release the producer-side buffer associated with the request.
@@ -847,6 +893,7 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
         with self._local_buffers_lock:
             item = self._local_buffers.pop(request_id, None)
             if item:
+                self._in_flight_buffers.discard(request_id)
                 # item is (src_addrs, lengths, holder, should_release, is_fast_path, created_at)
                 _, _, holder, should_release, _, _ = item
                 if should_release and isinstance(holder, ManagedBuffer):
@@ -904,6 +951,7 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
                 if should_release and isinstance(holder, ManagedBuffer):
                     holder.release()
             self._local_buffers.clear()
+            self._in_flight_buffers.clear()
 
         # 5. Close thread-local cached REQ sockets (for the calling thread).
         #    Sockets cached in *other* threads are not directly accessible here
@@ -945,21 +993,26 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
     # -------------------------------------------------------
 
     def _cleanup_stale_buffers(self) -> None:
-        """Reclaim buffers older than ``_BUFFER_TTL_SECONDS``.
+        """Reclaim stale buffers not currently used by a transfer.
+
         Prevents permanent memory leaks when a receiver crashes or times out
         without ever pulling the data.
-        TODO(wzliu): In extreme rare case, long transfer time, there might exist
-        TTL cleanup vs in-flight transfer conflict, which will be handled in the next PR.
         """
+        if self.buffer_ttl_seconds <= 0:
+            return
         now = _time_mod.monotonic()
         with self._local_buffers_lock:
-            stale_keys = [k for k, v in self._local_buffers.items() if now - v[5] > _BUFFER_TTL_SECONDS]
+            stale_keys = [
+                k
+                for k, v in self._local_buffers.items()
+                if k not in self._in_flight_buffers and now - v[5] > self.buffer_ttl_seconds
+            ]
             for k in stale_keys:
                 item = self._local_buffers.pop(k)
                 _, _, holder, should_release, _, _ = item
                 if should_release and isinstance(holder, ManagedBuffer):
                     holder.release()
-                logger.warning(f"TTL expired ({_BUFFER_TTL_SECONDS}s): cleaned up stale buffer for {k}")
+                logger.warning(f"TTL expired ({self.buffer_ttl_seconds}s): cleaned up stale buffer for {k}")
 
     def _zmq_listener_loop(self):
         socket = self.zmq_ctx.socket(zmq.ROUTER)
@@ -1058,30 +1111,36 @@ class MooncakeTransferEngineConnector(OmniConnectorBase):
 
             with self._local_buffers_lock:
                 item = self._local_buffers.get(meta.request_id)
+                if item:
+                    self._in_flight_buffers.add(meta.request_id)
 
             if not item:
                 response_queue.put((identity, TRANS_ERROR))
                 self._notify_listener(notify_addr)
                 return
 
-            src_addrs, src_lengths, _, _, _, _ = item
-            remote_session = f"{meta.remote_hostname}:{meta.remote_port}"
+            try:
+                src_addrs, src_lengths, _, _, _, _ = item
+                remote_session = f"{meta.remote_hostname}:{meta.remote_port}"
 
-            # RDMA Write
-            ret = self.engine.batch_transfer_sync_write(remote_session, src_addrs, meta.dst_addrs, src_lengths)
+                # RDMA Write
+                ret = self.engine.batch_transfer_sync_write(remote_session, src_addrs, meta.dst_addrs, src_lengths)
 
-            if ret == 0:
-                self.cleanup(meta.request_id)
-                response_queue.put((identity, TRANS_DONE))
-            else:
-                # Keep buffer in _local_buffers so receiver can retry on transient failures.
-                # Buffer will be cleaned up when: (a) a retry succeeds, (b) close() is called,
-                # or (c) a future TTL mechanism reclaims stale entries.
-                logger.warning(
-                    f"RDMA write failed for {meta.request_id} to {remote_session} "
-                    f"(ret={ret}). Buffer retained for retry."
-                )
-                response_queue.put((identity, TRANS_ERROR))
+                if ret == 0:
+                    self.cleanup(meta.request_id)
+                    response_queue.put((identity, TRANS_DONE))
+                else:
+                    # Keep buffer in _local_buffers so receiver can retry on transient failures.
+                    # Buffer will be cleaned up when: (a) a retry succeeds, (b) close() is called,
+                    # or (c) TTL reclaims it after it is no longer in-flight.
+                    logger.warning(
+                        f"RDMA write failed for {meta.request_id} to {remote_session} "
+                        f"(ret={ret}). Buffer retained for retry."
+                    )
+                    response_queue.put((identity, TRANS_ERROR))
+            finally:
+                with self._local_buffers_lock:
+                    self._in_flight_buffers.discard(meta.request_id)
 
         except Exception as e:
             logger.error(f"Push failed: {e}")
diff --git a/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py b/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
index 5de0d54db..3a51795c4 100644
--- a/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
+++ b/vllm_omni/distributed/omni_connectors/connectors/shm_connector.py
@@ -27,16 +27,11 @@ class SharedMemoryConnector(OmniConnectorBase):
     def __init__(self, config: dict[str, Any]):
         self.config = config
         self.stage_id = config.get("stage_id", -1)
-        self.device = config.get("device", "cuda:0")
-        self.threshold = int(config.get("shm_threshold_bytes", 65536))
-        self.inline_small_payloads = bool(config.get("inline_small_payloads", False))
         self._pending_keys: set[str] = set()
         self._metrics = {
             "puts": 0,
             "gets": 0,
             "bytes_transferred": 0,
-            "shm_writes": 0,
-            "inline_writes": 0,
         }
 
     def put(
@@ -47,33 +42,18 @@ class SharedMemoryConnector(OmniConnectorBase):
         data: Any,
     ) -> tuple[bool, int, dict[str, Any] | None]:
         try:
-            # Always serialize first to check size (and for SHM writing)
-            # Note: For extremely large objects in "inline" mode (e.g. Ray),
-            # we might double-serialize if we're not careful, but here we assume
-            # if it's huge we use SHM, or if Ray, threshold is maxsize.
             payload = self.serialize_obj(data)
             size = len(payload)
 
-            # The legacy async-chunk adapter transfers only the connector key
-            # across stages; it cannot deliver inline metadata to the receiver.
-            # Keep key-addressed SHM as the default and only inline payloads
-            # when the caller explicitly enables the metadata-aware path.
-            if size >= self.threshold or not self.inline_small_payloads:
-                lock_file = f"/dev/shm/shm_{put_key}_lockfile.lock"
-                with open(lock_file, "wb+") as lockf:
-                    fcntl.flock(lockf, fcntl.LOCK_EX)
-                    meta = shm_write_bytes(payload, name=put_key)
-                    fcntl.flock(lockf, fcntl.LOCK_UN)
+            lock_file = f"/dev/shm/shm_{put_key}_lockfile.lock"
+            with open(lock_file, "wb+") as lockf:
+                fcntl.flock(lockf, fcntl.LOCK_EX)
+                meta = shm_write_bytes(payload, name=put_key)
+                fcntl.flock(lockf, fcntl.LOCK_UN)
 
-                # meta contains {'name': ..., 'size': ...}
-                metadata = {"shm": meta, "size": size}
-                self._pending_keys.add(put_key)
-                self._metrics["shm_writes"] += 1
-            else:
-                # Inline small payloads to avoid the mmap + file-lock overhead
-                # that dominates codec chunk transfers.
-                metadata = {"inline_bytes": payload, "size": size}
-                self._metrics["inline_writes"] += 1
+            # meta contains {'name': ..., 'size': ...}
+            metadata = {"shm": meta, "size": size}
+            self._pending_keys.add(put_key)
 
             self._metrics["puts"] += 1
             self._metrics["bytes_transferred"] += size
@@ -84,22 +64,26 @@ class SharedMemoryConnector(OmniConnectorBase):
             logger.error(f"SharedMemoryConnector put failed for req {put_key}: {e}")
             return False, 0, None
 
-    def _get_data_with_lock(self, lock_file: str, shm_handle: dict):
-        obj = None
+    def _get_data_with_lock(self, lock_file: str, shm_handle: dict[str, Any]) -> tuple[Any, int] | None:
+        deserialized = False
         try:
             with open(lock_file, "rb+") as lockf:
                 fcntl.flock(lockf, fcntl.LOCK_EX)
                 data_bytes = shm_read_bytes(shm_handle)
                 fcntl.flock(lockf, fcntl.LOCK_UN)
             obj = self.deserialize_obj(data_bytes)
-            return obj, int(shm_handle.get("size", 0))
+            result = (obj, int(shm_handle.get("size", 0)))
+            deserialized = True
+            return result
         except Exception as e:
             logger.error(f"SharedMemoryConnector shm get failed for req : {e}")
             return None
         finally:
-            # If data has been received, delete lock_file.
-            if obj and os.path.exists(lock_file):
-                os.remove(lock_file)
+            if deserialized:
+                try:
+                    os.remove(lock_file)
+                except FileNotFoundError:
+                    pass
 
     def _get_by_key(self, get_key: str) -> tuple[Any, int] | None:
         """Read a SHM segment addressed purely by *get_key*."""
@@ -142,31 +126,21 @@ class SharedMemoryConnector(OmniConnectorBase):
             if isinstance(metadata, dict) and get_key in metadata:
                 metadata = metadata.get(get_key)
 
-            if not isinstance(metadata, dict):
-                return self._get_by_key(get_key)
-
-            if "inline_bytes" in metadata:
-                try:
-                    obj = self.deserialize_obj(metadata["inline_bytes"])
-                    self._pending_keys.discard(get_key)
-                    return obj, int(metadata.get("size", 0))
-                except Exception as e:
-                    logger.error(f"SharedMemoryConnector inline get failed for req {get_key}: {e}")
-                    return None
-
-            if "shm" in metadata:
+            if isinstance(metadata, dict) and "shm" in metadata:
                 shm_handle = metadata["shm"]
                 lock_file = f"/dev/shm/shm_{shm_handle['name']}_lockfile.lock"
                 result = self._get_data_with_lock(lock_file, shm_handle)
                 if result is not None:
                     self._pending_keys.discard(get_key)
-                return result
+            else:
+                # Missing or non-SHM metadata falls back to key-based lookup.
+                result = self._get_by_key(get_key)
+        else:
+            result = self._get_by_key(get_key)
 
-            # Metadata is a dict but has no SHM-specific handle (e.g. RDMA-
-            # style source_host/source_port).  Fall back to key-based read.
-            return self._get_by_key(get_key)
-
-        return self._get_by_key(get_key)
+        if result is not None:
+            self._metrics["gets"] += 1
+        return result
 
     def cleanup(self, request_id: str) -> None:
         """Best-effort cleanup of unconsumed SHM segments for *request_id*.
@@ -217,4 +191,4 @@ class SharedMemoryConnector(OmniConnectorBase):
         self._pending_keys.clear()
 
     def health(self) -> dict[str, Any]:
-        return {"status": "healthy", "threshold": self.threshold, **self._metrics}
+        return {"status": "healthy", **self._metrics}
diff --git a/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py b/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
index 51e604336..6b83349f2 100644
--- a/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
+++ b/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
@@ -15,6 +15,7 @@ import torch
 from vllm.logger import init_logger
 
 from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.sched.interface import KVPrefetchJob
 from vllm_omni.platforms import current_omni_platform
 
 from .factory import OmniConnectorFactory
@@ -68,6 +69,12 @@ class _TransferTopoConfig:
     sp_rank: int
     sp_group: Any
     world: Any
+    # The stage's tensor-model-parallel group (vLLM parallel state). Only the
+    # ranks in this group execute the same request in lockstep — DP replicas
+    # and PP stages in ``world`` do not — so per-request consensus exchanges
+    # must use this group, never ``world``.
+    tp_group: Any = None
+    tp_size: int = 1
 
     @property
     def is_leader(self) -> bool:
@@ -402,6 +409,7 @@ class OmniKVTransferManager:
         self._prefetch_executor: ThreadPoolExecutor | None = (
             ThreadPoolExecutor(max_workers=1, thread_name_prefix="kv-prefetch") if async_prefetch else None
         )
+
         self._prefetch_futures: dict[str, Any] = {}
         self._bg_copy_stream: current_omni_platform.Stream | None = None
 
@@ -414,6 +422,11 @@ class OmniKVTransferManager:
             except Exception as e:
                 logger.warning("Failed to eagerly initialize sender connector: %s", e)
 
+    @property
+    def tp_topology(self) -> KVTPTopology:
+        """Return the effective topology after config and runtime detection."""
+        return self._tp_topo
+
     @property
     def topo_config(self) -> _TransferTopoConfig:
         """Lazily build the parallel topology snapshot on first access."""
@@ -635,6 +648,16 @@ class OmniKVTransferManager:
         else:
             role = ReceiveRole.LEADER if world_rank == 0 else ReceiveRole.FOLLOWER
 
+        # The stage's TP group comes from vLLM parallel state (the TP-sharded
+        # LM path); it may legitimately be uninitialized on non-TP stages.
+        try:
+            from vllm.distributed.parallel_state import get_tp_group
+
+            tp_group = get_tp_group()
+            tp_size = tp_group.world_size
+        except Exception:
+            tp_group, tp_size = None, 1  # vLLM TP not initialized
+
         return _TransferTopoConfig(
             role=role,
             tp_active=tp_active,
@@ -645,6 +668,8 @@ class OmniKVTransferManager:
             sp_rank=sp_rank,
             sp_group=sp_group,
             world=world,
+            tp_group=tp_group,
+            tp_size=tp_size,
         )
 
     def _resolve_sender_info(
@@ -757,6 +782,20 @@ class OmniKVTransferManager:
 
         return kv_payload
 
+    @staticmethod
+    def _clear_request_kv_payload(req: Any) -> None:
+        """Drop every request-side KV field a receive may have applied.
+
+        Enumerates fields via ``_collect_request_kv_payload`` so clearing stays
+        symmetric with what apply/broadcast set — the pipeline then takes the
+        same no-KV path as a rank that never received.
+        """
+        for key in OmniKVTransferManager._collect_request_kv_payload(req):
+            if key.startswith("sp."):
+                setattr(req.sampling_params, key[3:], None)
+            else:
+                setattr(req, key, None)
+
     @staticmethod
     def _apply_request_kv_payload(
         req: Any,
@@ -1022,7 +1061,7 @@ class OmniKVTransferManager:
         value_cache: list[torch.Tensor | None] = [None] * num_layers
 
         for layer_idx, layer_kv in enumerate(kv_caches):
-            kv_pair = normalize_layer_kv(layer_kv, req_id=req_id, layer_idx=layer_idx)
+            kv_pair = normalize_layer_kv(layer_kv, req_id=req_id, layer_idx=layer_idx, block_size=block_size)
             if kv_pair is None:
                 continue
             key_blocks, value_blocks = kv_pair
@@ -1205,16 +1244,14 @@ class OmniKVTransferManager:
                 logger.exception("Failed to release KV pool buffer")
         buffers.clear()
 
-    def start_prefetch(
-        self, kv_prefetch_jobs: dict[str, Any] | None, target_device: torch.device | None = None
-    ) -> None:
+    def start_prefetch(self, kv_prefetch_job: KVPrefetchJob | None, target_device: torch.device | None = None) -> None:
         """Kick off a background KV load (non-blocking). No-op unless prefetch enabled."""
-        if not (self._async_prefetch and self.config.need_recv_cache) or not kv_prefetch_jobs:
+        if not (self._async_prefetch and self.config.need_recv_cache) or not kv_prefetch_job:
             return
         # Followers receive via collective distribute; bg pull would consume the owner's payload.
         if self.topo_config.is_follower:
             return
-        rid = kv_prefetch_jobs.get("request_id")
+        rid = kv_prefetch_job.get("request_id")
         if not rid:
             return
         # Memory pressure → skip prefetch; sync receive handles it.
@@ -1228,7 +1265,7 @@ class OmniKVTransferManager:
             self._discard_future(stale_rid)
         if rid in self._prefetch_futures:
             return
-        sender_info = kv_prefetch_jobs.get("kv_sender_info")
+        sender_info = kv_prefetch_job.get("kv_sender_info")
         if not sender_info:
             # No explicit endpoint → bg receive would target wrong sender under multi-replica.
             logger.debug("Skip KV prefetch for %s: stub has no kv_sender_info", rid)
@@ -1748,6 +1785,64 @@ class OmniKVTransferManager:
         combined = combined.to(device)
         return self._unpack_kv_payload(combined)
 
+    def _tp_local_receive_consensus(self, req: Any, received: bool) -> bool:
+        """Identical-KV-state verdict across pure-TP ranks (LOCAL role).
+
+        In pure TP every rank fetches its own KV shard with an independent
+        timeout and ``distribute_kv_cache`` is a no-op, so a single rank's
+        silent miss sends only that rank into the pipeline's no-KV prefill —
+        it then enters TP collectives its peers never join, and the NCCL
+        watchdog kills the worker (#5627). Each rank reports a signature of
+        its applied KV state — the primary-receive flag plus the set of
+        applied payload roles, so partially-received CFG companion KV
+        (``cfg_text``/``cfg_img``) diverging between ranks is caught too. If
+        the signatures differ, every rank drops its KV so all take the same
+        fallback path together; identical-but-partial state is kept, since
+        symmetric absence is consistent (e.g. Bagel's empty unconditional
+        branch).
+
+        The exchange runs over the stage's tensor-parallel group only: those
+        are the ranks executing this request in lockstep. ``world`` would
+        also contain DP replicas / PP stages working on different requests —
+        mixing their flags corrupts the verdict, and a replica skipping the
+        exchange (dummy request) while another enters it would deadlock.
+        Within the TP group the skip guards below depend only on topology,
+        config, and the request id — identical on every TP rank — so ranks
+        always agree on whether the exchange happens.
+        """
+        pt = self.topo_config
+        group = pt.tp_group
+        if not (pt.is_local and pt.tp_active) or group is None or pt.tp_size <= 1:
+            return received
+        if not self.config.need_recv_cache:
+            return received
+        request_id = self._resolve_request_id(req)
+        if request_id is None or OmniDiffusionRequest.is_dummy_run_request_id(request_id):
+            return received
+
+        signature = (bool(received), tuple(sorted(self._collect_request_kv_payload(req))))
+        if group.rank_in_group == 0:
+            signatures = [signature]
+            signatures.extend(group.recv_object(src=src) for src in range(1, pt.tp_size))
+            consistent = all(sig == signature for sig in signatures)
+            group.broadcast_object(consistent, src=0)
+        else:
+            group.send_object(signature, dst=0)
+            consistent = bool(group.broadcast_object(None, src=0))
+
+        if not consistent:
+            logger.warning(
+                "KV state for %s diverged across TP ranks (this rank: received=%s, roles=%s); "
+                "dropping KV on every rank so all take the no-KV fallback together "
+                "instead of desyncing TP collectives",
+                request_id,
+                signature[0],
+                list(signature[1]),
+            )
+            self._clear_request_kv_payload(req)
+            return False
+        return received
+
     def receive_multi_kv_cache_distributed(
         self,
         req: Any,
@@ -1758,6 +1853,7 @@ class OmniKVTransferManager:
         received = False
         if not self.topo_config.is_follower:
             received = self.receive_multi_kv_cache(req, cfg_kv_collect_func, target_device)
+        received = self._tp_local_receive_consensus(req, received)
         kv_payload = self.distribute_kv_cache(req, target_device, received=received)
         if kv_payload is not None:
             self._apply_request_kv_payload(req, kv_payload, target_device)
@@ -1786,6 +1882,7 @@ class OmniKVTransferManager:
         if not received and not self.topo_config.is_follower and not payload_consumed:
             logger.debug("KV prefetch miss for %s; falling back to sync receive", self._resolve_request_id(req))
             received = self.receive_multi_kv_cache(req, None, target_device)
+        received = self._tp_local_receive_consensus(req, received)
         kv_payload = self.distribute_kv_cache(req, target_device, received=received)
         if kv_payload is not None:
             self._apply_request_kv_payload(req, kv_payload, target_device)
diff --git a/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py b/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
index 04368842c..d722adad2 100644
--- a/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
+++ b/vllm_omni/distributed/omni_connectors/transfer_adapter/chunk_transfer_adapter.py
@@ -7,13 +7,14 @@ from collections.abc import Callable, Mapping
 from typing import Any
 
 import torch
+from vllm.v1.metrics.stats import PrefillStats
 from vllm.v1.request import Request, RequestStatus
 
 from vllm_omni.data_entry_keys import MetaStruct, OmniPayloadStruct, unflatten_payload
 
 from ..adapter import construct_next_stage_streaming_input_prompt
 from ..factory import OmniConnectorFactory
-from ..utils.config import ConnectorSpec
+from ..utils.config import ConnectorSpec, stage_receives_chunks
 from ..utils.logging import get_connector_logger
 from .base import OmniTransferAdapterBase
 
@@ -56,6 +57,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 self._active_window,
             )
         self.connector = self.create_connector(model_config)
+        self.receives_chunks = stage_receives_chunks(model_config)
         super().__init__(model_config)
         self.model_mode = getattr(model_config, "worker_type", None) or "ar"
         # State specific to Chunk management
@@ -68,7 +70,11 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         # mapping for request id and chunk id
         self.put_req_chunk: dict[str, int] = defaultdict(int)
         self.get_req_chunk: dict[str, int] = defaultdict(int)
-        self.finished_requests: set[str] = set()
+        # Segment-local chunk counter: incremented alongside put_req_chunk
+        # but popped at segment boundaries (unlike put_req_chunk which is
+        # request-global for connector key continuity).
+        self.ramp_chunk_count: dict[str, int] = defaultdict(int)
+        self.upstream_exhausted_requests: set[str] = set()
         self.segment_finished_requests: set[str] = set()
         self.request_payload = {}
         self.code_prompt_token_ids: dict[str, list[torch.Tensor]] = defaultdict(list)
@@ -104,6 +110,12 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         num_placeholders = int(getattr(request, "num_output_placeholders", 0) or 0)
         return max(0, num_computed - num_placeholders)
 
+    @staticmethod
+    def _refresh_generation_chunk_prefill_state(request: Request) -> None:
+        request.num_prompt_tokens = len(request.prompt_token_ids)
+        if getattr(request, "prefill_stats", None) is None:
+            request.prefill_stats = PrefillStats()
+
     @classmethod
     def create_connector(cls, model_config: Any):
         connector_config = getattr(model_config, "stage_connector_config", None)
@@ -135,7 +147,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         """
         stage_id = self.connector.stage_id
 
-        if stage_id == 0:
+        if stage_id == 0 or not self.receives_chunks:
             return
         if not hasattr(request, "additional_information"):
             request.additional_information = None
@@ -224,18 +236,19 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
             payload_segment_finished = self._is_truthy_scalar(meta.get("is_segment_finished"))
             if self.model_mode == "ar":
                 request.additional_information = payload_data
-                if chunk_id > 0 and request.resumable:
+                replace_prompt = meta.get("replace_streaming_prompt") is True
+                if getattr(request, "resumable", False) and (chunk_id > 0 or replace_prompt):
                     # For new streaming input segment, we should update prompt from payload
                     construct_next_stage_streaming_input_prompt(payload_data, request)
 
                 if payload_finished:
-                    self.finished_requests.add(req_id)
+                    self.upstream_exhausted_requests.add(req_id)
                     request.resumable = False
                 if payload_segment_finished:
                     self.segment_finished_requests.add(req_id)
             else:
                 if payload_finished:
-                    self.finished_requests.add(req_id)
+                    self.upstream_exhausted_requests.add(req_id)
                     request.resumable = False
                 if payload_segment_finished:
                     self.segment_finished_requests.add(req_id)
@@ -243,15 +256,18 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 new_ids = payload_data.get("codes", {}).get("audio")
                 has_tensor_codes = isinstance(new_ids, torch.Tensor)
                 use_tensor_codes = has_tensor_codes and new_ids.ndim >= 2
+                prompt_token_ids: list[int]
                 if use_tensor_codes:
-                    request.prompt_token_ids = [0] if new_ids.numel() > 0 else []
+                    prompt_token_ids = [0] if new_ids.numel() > 0 else []
                 elif has_tensor_codes:
                     new_ids = new_ids.tolist()
+                    prompt_token_ids = new_ids
                 elif new_ids is None:
                     new_ids = []
-                    request.prompt_token_ids = new_ids
-                if not use_tensor_codes:
-                    request.prompt_token_ids = new_ids
+                    prompt_token_ids = new_ids
+                else:
+                    prompt_token_ids = new_ids
+                request.prompt_token_ids = prompt_token_ids
                 prev_info = getattr(request, "additional_information", None)
                 info = dict(prev_info) if isinstance(prev_info, dict) else {}
                 for key, value in payload_data.items():
@@ -277,12 +293,17 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
 
                 # Empty chunk with more data expected: keep polling.
                 has_new_ids = bool(new_ids.numel()) if use_tensor_codes else bool(new_ids)
-                if not has_new_ids and not payload_finished:
+                if not has_new_ids and payload_segment_finished:
+                    # Preserve an explicit scheduler boundary even when it
+                    # contains no new codec frames.
+                    request.prompt_token_ids = [0]
+                if not has_new_ids and not payload_finished and not payload_segment_finished:
                     # The base recv loop treats False as "not ready yet" and
                     # requeues the request. Do not mark an empty non-terminal
                     # chunk as ready, otherwise Stage1 can consume before the
                     # first DAC frame arrives.
                     return False
+                self._refresh_generation_chunk_prefill_state(request)
 
             # Mark as finished for consumption
             self._finished_load_reqs.add(req_id)
@@ -311,7 +332,13 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                     multimodal_output=multimodal_output,
                     request=request,
                     # Existing processors use is_finished as a flush signal.
-                    is_finished=is_segment_finished,
+                    # Terminal stops no longer count as segment boundaries
+                    # (is_segment_finished is False when the request finishes,
+                    # see #5383), but the processor must still flush its
+                    # accumulated tail on the terminal chunk — otherwise the
+                    # downstream stage receives the finished marker without
+                    # the final payload (#5413).
+                    is_finished=is_segment_finished or is_finished,
                 )
 
             except Exception as e:
@@ -326,7 +353,8 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         if payload_data.meta is None:
             payload_data.meta = MetaStruct()
         payload_data.meta.finished = torch.tensor(is_finished, dtype=torch.bool)
-        payload_data.meta.is_segment_finished = torch.tensor(is_segment_finished, dtype=torch.bool)
+        if payload_data.meta.is_segment_finished is None:
+            payload_data.meta.is_segment_finished = torch.tensor(is_segment_finished, dtype=torch.bool)
 
         success, size, metadata = self.connector.put(
             from_stage=str(stage_id),
@@ -337,6 +365,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
 
         if success:
             self.put_req_chunk[external_req_id] += 1
+            self.ramp_chunk_count[external_req_id] += 1
             logger.debug(f"[Stage-{stage_id}] Sent {connector_put_key}")
             # Sender uses struct attr access here; the receive path in
             # `_load_one_request` / `_update_request_payload` reads dict keys.
@@ -358,6 +387,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         if is_segment_finished:
             self.code_prompt_token_ids.pop(external_req_id, None)
             self.requests_num_chunks_sent.pop(external_req_id, None)
+            self.ramp_chunk_count.pop(external_req_id, None)
             cached_ic = getattr(self, "_cached_ic", None)
             if cached_ic is not None:
                 cached_ic.pop(external_req_id, None)
@@ -365,11 +395,12 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
     def is_done_receiving_chunks(self, request_id: str) -> bool:
         """Return True if the request should stop polling upstream chunks.
 
-        Covers both the whole-request finish marker (``finished_requests``) and
-        the per-segment finish marker (``segment_finished_requests``) used while
-        waiting for the next streaming input slice.
+        Covers both the whole-request marker (``upstream_exhausted_requests``)
+        and the per-segment marker (``segment_finished_requests``) used while
+        waiting for the next streaming input slice. Neither means this
+        stage's own generation is done -- see vllm-project/vllm-omni#5349.
         """
-        return request_id in self.finished_requests or request_id in self.segment_finished_requests
+        return request_id in self.upstream_exhausted_requests or request_id in self.segment_finished_requests
 
     ########################################################################
     # Cleanup
@@ -382,22 +413,41 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         enqueued work that the background thread has not yet processed,
         because it only touches receiver-side dictionaries.
 
+        Must also purge the request from the chunk-parking deques
+        (``waiting_for_chunk_waiting_requests`` / ``_running_requests`` /
+        ``_held_non_active``): otherwise a caller that calls
+        ``restore_queues()`` without ``scheduler_requests`` (e.g. a unit
+        test, or any future caller not synced with the scheduler's own
+        request-removal timing) would re-admit an already-finished
+        request into the visible queue, which ``_promote_active_streams``
+        would then FIFO-promote ahead of genuinely-waiting requests. See
+        vllm-project/vllm-omni#5349's active-stream-window tests.
+
         Idempotent: calling with an already-cleaned or unknown id is safe.
         """
-        if request_id in self.finished_requests:
-            self._evict_finished_active_streams({request_id})
-        else:
-            self._active_streams.pop(request_id, None)
-        self.finished_requests.discard(request_id)
+        self._active_streams.pop(request_id, None)
+        self.upstream_exhausted_requests.discard(request_id)
         self.segment_finished_requests.discard(request_id)
         self.get_req_chunk.pop(request_id, None)
         self.requests_with_ready_chunks.discard(request_id)
         self.request_ids_mapping.pop(request_id, None)
         self.requests_origin_status.pop(request_id, None)
+        self._discard_from_chunk_deque(self.waiting_for_chunk_waiting_requests, request_id)
+        self._discard_from_chunk_deque(self.waiting_for_chunk_running_requests, request_id)
+        self._discard_from_chunk_deque(self._held_non_active, request_id)
 
         self._cancelled_load_reqs.add(request_id)
         self._finished_load_reqs.discard(request_id)
 
+    @staticmethod
+    def _discard_from_chunk_deque(deque_list: deque[Any], request_id: str) -> None:
+        if not deque_list:
+            return
+        for _ in range(len(deque_list)):
+            request = deque_list.popleft()
+            if request.request_id != request_id:
+                deque_list.append(request)
+
     def cleanup_sender(self, external_req_id: str) -> None:
         """Reclaim sender-side per-request state (keyed by external id).
 
@@ -410,6 +460,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         self.request_payload.pop(external_req_id, None)
         self.code_prompt_token_ids.pop(external_req_id, None)
         self.requests_num_chunks_sent.pop(external_req_id, None)
+        self.ramp_chunk_count.pop(external_req_id, None)
         self._pending_streaming_prefills.pop(external_req_id, None)
 
         cached_ic = getattr(self, "_cached_ic", None)
@@ -464,6 +515,8 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         callers that don't track aborts may omit it to keep the prior
         (unguarded) behaviour.
         """
+        if not self.receives_chunks:
+            return
         if self.connector.stage_id == 0:
             return
 
@@ -502,13 +555,6 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         self._promote_active_streams(waiting_queue)
         self._preempt_non_active_running(waiting_queue, running_queue)
 
-    def _evict_finished_active_streams(self, request_ids: set[str] | None = None) -> None:
-        for request_id in list(self._active_streams):
-            if request_ids is not None and request_id not in request_ids:
-                continue
-            if request_id in self.finished_requests:
-                self._active_streams.pop(request_id, None)
-
     def _promote_active_streams(self, queue: Any) -> None:
         if len(self._active_streams) >= self._active_window:
             return
@@ -516,7 +562,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
             if len(self._active_streams) >= self._active_window:
                 return
             request_id = request.request_id
-            if request_id in self._active_streams or request_id in self.finished_requests:
+            if request_id in self._active_streams:
                 continue
             # Iterating the existing queue preserves FIFO admission.
             self._active_streams[request_id] = request
@@ -528,11 +574,16 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         if request_id in self._active_streams:
             self._active_streams[request_id] = request
             return True
-        if request_id in self.finished_requests or len(self._active_streams) >= self._active_window:
+        if len(self._active_streams) >= self._active_window:
             return False
         self._active_streams[request_id] = request
         return True
 
+    @property
+    def num_running_waiting_for_chunk(self) -> int:
+        """Count running requests temporarily removed while awaiting a chunk."""
+        return len(self.waiting_for_chunk_running_requests)
+
     def _preempt_non_active_running(self, waiting_queue: Any, running_queue: list[Request]) -> None:
         # Hold non-active running requests in a private deque rather than
         # routing them back through waiting_queue. Routing through the
@@ -628,6 +679,8 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         every parked request is restored unconditionally (the
         pre-purge behavior).
         """
+        if not self.receives_chunks:
+            return
         if scheduler_requests is not None:
             self._purge_untracked_chunk_requests(self.waiting_for_chunk_waiting_requests, scheduler_requests)
             self._purge_untracked_chunk_requests(self.waiting_for_chunk_running_requests, scheduler_requests)
@@ -659,6 +712,8 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         Add additional info for cached requests and
         clean up ready chunks from scheduler output.
         """
+        if not self.receives_chunks:
+            return
         stage_id = self.connector.stage_id
 
         if stage_id == 0:
@@ -666,25 +721,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
 
         if requests is not None:
             self.attach_cached_additional_information(scheduler_output, requests)
-        scheduled_req_ids = self._scheduled_request_ids(scheduler_output)
         self._clear_chunk_ready(scheduler_output)
-        if scheduled_req_ids:
-            # Terminal chunks must stay active until they are scheduled once.
-            self._evict_finished_active_streams(scheduled_req_ids)
-
-    @staticmethod
-    def _scheduled_request_ids(scheduler_output: Any) -> set[str]:
-        req_ids: set[str] = set()
-        if scheduler_output.scheduled_new_reqs:
-            for req_data in scheduler_output.scheduled_new_reqs:
-                req_id = getattr(req_data, "req_id", None)
-                if req_id:
-                    req_ids.add(req_id)
-        if scheduler_output.scheduled_cached_reqs:
-            for req_id in scheduler_output.scheduled_cached_reqs.req_ids:
-                if req_id:
-                    req_ids.add(req_id)
-        return req_ids
 
     @staticmethod
     def attach_cached_additional_information(scheduler_output: Any, requests: dict[str, Request]) -> None:
@@ -710,6 +747,14 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         queue_snapshot = list(queue)
         for request in queue_snapshot:
             if not self._ensure_active_stream(request):
+                if target_status == RequestStatus.WAITING:
+                    # A non-active placeholder must not remain visible to the
+                    # scheduler: it has no connector payload yet, so running
+                    # it would execute the downstream model with empty
+                    # additional_information. Park it until restore_queues()
+                    # and retry admission on the next scheduler tick.
+                    queue.remove(request)
+                    waiting_for_chunk_list.append(request)
                 continue
             if request.status != RequestStatus.WAITING_FOR_CHUNK:
                 if request.request_id in self.requests_with_ready_chunks:
@@ -771,10 +816,14 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         self.waiting_for_chunk_running_requests = deque(
             request for request in self.waiting_for_chunk_running_requests if request.request_id not in request_ids
         )
+        self._held_non_active = deque(
+            request for request in self._held_non_active if request.request_id not in request_ids
+        )
 
         for req_id in request_ids:
+            self._active_streams.pop(req_id, None)
             self.requests_with_ready_chunks.discard(req_id)
-            self.finished_requests.discard(req_id)
+            self.upstream_exhausted_requests.discard(req_id)
             self._finished_load_reqs.discard(req_id)
             self._cancelled_load_reqs.add(req_id)
 
diff --git a/vllm_omni/distributed/omni_connectors/utils/config.py b/vllm_omni/distributed/omni_connectors/utils/config.py
index ee049904f..1a6d395c2 100644
--- a/vllm_omni/distributed/omni_connectors/utils/config.py
+++ b/vllm_omni/distributed/omni_connectors/utils/config.py
@@ -17,6 +17,34 @@ TRANSFER_ENGINE_CONNECTOR_NAMES = frozenset(
 )
 
 
+def get_stage_connector_role(model_config: Any) -> str | None:
+    """Return the configured stage connector direction, if explicit."""
+    connector_config = getattr(model_config, "stage_connector_config", None)
+    if isinstance(connector_config, dict):
+        extra = connector_config.get("extra")
+    else:
+        extra = getattr(connector_config, "extra", None)
+    if isinstance(extra, dict):
+        role = extra.get("role")
+        return role if isinstance(role, str) else None
+    return None
+
+
+def stage_receives_chunks(model_config: Any) -> bool:
+    """Whether connector chunks, rather than the orchestrator, feed a stage."""
+    return get_stage_connector_role(model_config) != "sender"
+
+
+def stage_sends_async_output(model_config: Any) -> bool:
+    """Whether async output should be partitioned for connector transport."""
+    role = get_stage_connector_role(model_config)
+    if role is not None:
+        return role == "sender"
+    # Preserve legacy partitioning while keeping stage-0 orchestrator bridges
+    # on the normal RequestOutput path.
+    return getattr(model_config, "stage_id", None) != 0
+
+
 @dataclass
 class ConnectorSpec:
     """Specification for a connector instance."""
diff --git a/vllm_omni/distributed/omni_connectors/utils/initialization.py b/vllm_omni/distributed/omni_connectors/utils/initialization.py
index f7a464809..bbbda44e3 100644
--- a/vllm_omni/distributed/omni_connectors/utils/initialization.py
+++ b/vllm_omni/distributed/omni_connectors/utils/initialization.py
@@ -4,7 +4,6 @@
 """Utilities for OmniConnector configuration and validation."""
 
 import json
-import sys
 import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -42,7 +41,6 @@ KV_REPLICA_PORT_STRIDE = 1024
 
 def initialize_connectors_from_config(
     config_path: str | Path | None = None,
-    default_shm_threshold: int = 65536,
     purpose: str = "request_forwarding",
     caller_stage_id: int | str | None = None,
     is_sender: bool | None = None,
@@ -53,7 +51,7 @@ def initialize_connectors_from_config(
     Returns:
         tuple: (OmniTransferConfig, dict of {(from, to): connector_instance})
     """
-    transfer_config = load_omni_transfer_config(config_path, default_shm_threshold=default_shm_threshold)
+    transfer_config = load_omni_transfer_config(config_path)
 
     if not transfer_config:
         logger.info("No OmniTransferConfig provided")
@@ -190,7 +188,6 @@ def get_connectors_config_for_stage(transfer_config: OmniTransferConfig | None,
 def load_omni_transfer_config(
     config_path: str | Path | None = None,
     config_dict: dict[str, Any] | None = None,
-    default_shm_threshold: int = 65536,
 ) -> OmniTransferConfig | None:
     """Load OmniTransferConfig from file or dict."""
     if config_path is None and config_dict is None:
@@ -325,10 +322,7 @@ def load_omni_transfer_config(
                     expected_edges.add(edge_key)
                     if edge_key not in connectors:
                         logger.info(f"Auto-configuring SharedMemoryConnector for edge {edge_key}")
-                        connectors[edge_key] = ConnectorSpec(
-                            name="SharedMemoryConnector",
-                            extra={"shm_threshold_bytes": default_shm_threshold},
-                        )
+                        connectors[edge_key] = ConnectorSpec(name="SharedMemoryConnector")
 
             # Fallback: infer edges from engine_input_source for each stage
             for stage_config in stage_args:
@@ -343,9 +337,7 @@ def load_omni_transfer_config(
 
                     if edge_key not in connectors:
                         logger.info(f"Auto-configuring SharedMemoryConnector for edge {edge_key}")
-                        connectors[edge_key] = ConnectorSpec(
-                            name="SharedMemoryConnector", extra={"shm_threshold_bytes": default_shm_threshold}
-                        )
+                        connectors[edge_key] = ConnectorSpec(name="SharedMemoryConnector")
 
         except Exception as e:
             logger.warning(f"Failed to auto-configure SHM connectors: {e}")
@@ -369,22 +361,16 @@ def load_omni_transfer_config(
 
 
 def initialize_orchestrator_connectors(
-    config_path: str | None, worker_backend: str | None = "multi_process", shm_threshold_bytes: int = 65536
+    config_path: str | None,
 ) -> tuple[OmniTransferConfig | None, dict[tuple[str, str], OmniConnectorBase]]:
     """Initialize connectors shared at orchestrator level.
     Args:
         config_path: The path to the configuration file.
-        worker_backend: The backend to use for the worker.
     Returns:
         A tuple containing the OmniTransferConfig and a dictionary of connectors.
     """
-    if worker_backend == "ray":
-        default_shm_threshold = sys.maxsize
-    else:
-        default_shm_threshold = max(0, shm_threshold_bytes)
     transfer_config, connectors = initialize_connectors_from_config(
         config_path,
-        default_shm_threshold=default_shm_threshold,
         purpose="request_forwarding",
         caller_stage_id="orchestrator",
         is_sender=True,
diff --git a/vllm_omni/distributed/omni_connectors/utils/kv_utils.py b/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
index fe0df21f2..b7f51460c 100644
--- a/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
+++ b/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
@@ -402,6 +402,7 @@ def normalize_layer_kv(
     *,
     req_id: str = "",
     layer_idx: int = -1,
+    block_size: int | None = None,
 ) -> tuple[torch.Tensor, torch.Tensor] | None:
     """Normalize one layer KV cache to a ``(key_blocks, value_blocks)`` tuple.
 
@@ -424,6 +425,10 @@ def normalize_layer_kv(
       dim-0 selects key / value.
     * **Stacked tensor** ``[num_blocks, 2, block_size, n_heads, head_dim]`` –
       dim-1 selects key / value.
+    * **Packed tensor** ``[num_blocks, n_heads, block_size, 2 * head_dim]`` –
+      vLLM >= 0.23 FlashAttention packs K and V into the last (content)
+      dimension.  Only recognized when *block_size* is provided and matches
+      dim 2, to avoid misreading other 4-D layouts.
     * **Tuple** ``(key_tensor, value_tensor)`` – returned as-is after
       validation.
 
@@ -431,13 +436,29 @@ def normalize_layer_kv(
         layer_kv: The raw KV cache (tensor or tuple) for the layer.
         req_id: Request ID used only for diagnostic log messages.
         layer_idx: Layer index used only for diagnostic log messages.
+        block_size: The paged-attention block size, required to recognize
+            the packed 4-D layout.
 
     Returns:
         ``(key_blocks, value_blocks)`` if *layer_kv* is valid, ``None``
         otherwise.
     """
     if isinstance(layer_kv, torch.Tensor):
-        if layer_kv.ndim >= 3 and layer_kv.shape[0] == 2:
+        if (
+            layer_kv.ndim == 4
+            and block_size is not None
+            and layer_kv.shape[2] == block_size
+            and layer_kv.shape[-1] % 2 == 0
+        ):
+            # vLLM >= 0.23 FlashAttention layout: (num_blocks, n_heads,
+            # block_size, 2 * head_dim).  Unpack the same way
+            # FlashAttentionImpl does: move block_size before heads, then
+            # split the content dim into the K and V halves.  Checked before
+            # the stacked layouts (which are 5-D in practice) so that a
+            # 2-KV-head packed tensor is not misread as a dim-1 stack.
+            head_dim = layer_kv.shape[-1] // 2
+            key_blocks, value_blocks = layer_kv.transpose(1, 2).split(head_dim, dim=-1)
+        elif layer_kv.ndim >= 3 and layer_kv.shape[0] == 2:
             key_blocks = layer_kv[0]
             value_blocks = layer_kv[1]
         elif layer_kv.ndim >= 3 and layer_kv.shape[1] == 2:
@@ -446,7 +467,8 @@ def normalize_layer_kv(
         else:
             logger.warning(
                 f"Layer {layer_idx} for request {req_id} has invalid stacked KV shape: "
-                f"expected [2, ...] or [..., 2, ...] at dim 0/1, got {tuple(layer_kv.shape)}"
+                f"expected [2, ...], [..., 2, ...] at dim 0/1, or packed "
+                f"[num_blocks, n_heads, block_size, 2*head_dim], got {tuple(layer_kv.shape)}"
             )
             return None
     elif isinstance(layer_kv, tuple):
diff --git a/vllm_omni/engine/__init__.py b/vllm_omni/engine/__init__.py
index 89bb41908..e72ce9fed 100644
--- a/vllm_omni/engine/__init__.py
+++ b/vllm_omni/engine/__init__.py
@@ -75,6 +75,10 @@ class OmniEngineCoreRequest(EngineCoreRequest):
 
     # Optional additional information dictionary (serialized)
     additional_information: AdditionalInformationPayload | None = None
+    # Runner-owned runtime payload. This is materialized directly into
+    # GPUModelRunner.model_intermediate_buffer instead of using the deprecated
+    # additional_information request transport.
+    model_intermediate_buffer: dict[str, Any] | None = None
 
     @classmethod
     def from_request(
@@ -83,6 +87,7 @@ class OmniEngineCoreRequest(EngineCoreRequest):
         *,
         prompt_embeds: torch.Tensor | None = None,
         additional_information: AdditionalInformationPayload | None = None,
+        model_intermediate_buffer: dict[str, Any] | None = None,
     ) -> "OmniEngineCoreRequest":
         """Clone an EngineCoreRequest into an OmniEngineCoreRequest with optional payload overrides."""
 
@@ -90,6 +95,8 @@ class OmniEngineCoreRequest(EngineCoreRequest):
             prompt_embeds = request.prompt_embeds
         if additional_information is None:
             additional_information = getattr(request, "additional_information", None)
+        if model_intermediate_buffer is None:
+            model_intermediate_buffer = getattr(request, "model_intermediate_buffer", None)
 
         return cls(
             request_id=request.request_id,
@@ -113,6 +120,7 @@ class OmniEngineCoreRequest(EngineCoreRequest):
             reasoning_parser_kwargs=request.reasoning_parser_kwargs,
             abort_immediately=request.abort_immediately,
             additional_information=additional_information,
+            model_intermediate_buffer=model_intermediate_buffer,
         )
 
 
diff --git a/vllm_omni/engine/arg_utils.py b/vllm_omni/engine/arg_utils.py
index bdf43711c..633eec436 100644
--- a/vllm_omni/engine/arg_utils.py
+++ b/vllm_omni/engine/arg_utils.py
@@ -23,6 +23,11 @@ _ARCH_TO_MODEL_TYPE: dict[str, str] = {
     "IndexTTS2S2MelDecoder": "indextts2",
     "IndexTTS2TalkerForConditionalGeneration": "indextts2",
     "OmniVoiceModel": "omnivoice",
+    # PersonaPlex ships an empty config.json, so create_model_config() must patch
+    # model_type=personaplex from the arch name or the staged pipeline can't load
+    # the HF config without manual overrides.
+    "PersonaPlexTalkerForConditionalGeneration": "personaplex",
+    "PersonaPlexCode2Wav": "personaplex",
     "VoxCPM2TalkerForConditionalGeneration": "voxcpm2",
 }
 
@@ -48,6 +53,9 @@ def _register_omni_hf_configs() -> None:
             MossTTSLocalConfig,
             MossTTSRealtimeConfig,
         )
+        from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+            PersonaPlexConfig,
+        )
         from vllm_omni.model_executor.models.qwen3_tts.configuration_qwen3_tts import (
             Qwen3TTSConfig,
         )
@@ -74,6 +82,7 @@ def _register_omni_hf_configs() -> None:
         ("moss_tts_local", MossTTSLocalConfig),
         ("moss_tts_realtime", MossTTSRealtimeConfig),
         ("qwen3_tts", Qwen3TTSConfig),
+        ("personaplex", PersonaPlexConfig),
         ("cosyvoice3", CosyVoice3Config),
         ("glm_tts", GLMTTSConfig),
         ("omnivoice", OmniVoiceConfig),
@@ -131,8 +140,9 @@ class OmniEngineArgs(EngineArgs):
         stage_connector_spec: Extra configuration for stage connector
         async_chunk: If set to True, perform async chunk
         worker_type: Model Type, e.g., "ar" or "generation"
-        task_type: Default task type for TTS models (CustomVoice, VoiceDesign, or Base).
-            If not specified, will be inferred from model path.
+        task_type: Model-defined startup task type. Consumers validate the
+            supported values and decide whether it selects request behavior,
+            task-specific weights, or both.
         omni_master_address: TCP address that the OmniMasterServer (running
             inside AsyncOmniEngine) listens on for engine core registrations.
             Required when single-stage mode is active.
@@ -159,10 +169,14 @@ class OmniEngineArgs(EngineArgs):
     stage_connector_spec: dict[str, Any] = field(default_factory=dict)
     subtalker_sampling_params: dict[str, Any] | None = None
     async_chunk: bool = False
+    retains_state_across_chunks: bool = False
     # WS-A: Stage-1 active stream slots. 0 = legacy preempt-everything.
     # Must be declared here so engine_args dict propagation does not silently
     # drop the value when constructing OmniEngineArgs from kwargs.
     active_stream_window: int = 0
+    # Engine admission is the single source of truth for per-stage pools of
+    # model-owned streaming state (codec, decoder, and similar resources).
+    duplex_max_sessions: int = 1
     omni_kv_config: dict | None = None
     quantization_config: Any | None = None
     force_cutlass_fp8: bool | None = None
@@ -341,7 +355,9 @@ class OmniEngineArgs(EngineArgs):
             # All kwargs below are Omni specific
             stage_id=self.stage_id,
             async_chunk=self.async_chunk,
+            retains_state_across_chunks=self.retains_state_across_chunks,
             active_stream_window=self.active_stream_window,
+            duplex_max_sessions=self.duplex_max_sessions,
             model_stage=self.model_stage,
             model_arch=self.model_arch,
             worker_type=self.worker_type,
@@ -393,7 +409,7 @@ class OmniAsyncEngineArgs(AsyncEngineArgs, OmniEngineArgs):
 # Fields in ``SHARED_FIELDS`` (e.g. ``model``, ``log_stats``) flow to BOTH
 # orchestrator and engine by design.
 #
-# Invariants enforced by ``tests/test_arg_utils.py``:
+# Invariants enforced by ``tests/engine/test_arg_utils_shared_fields.py``:
 #
 #   1. ``OrchestratorArgs`` ∩ ``OmniEngineArgs`` ⊆ ``SHARED_FIELDS``
 #   2. Every CLI flag is classifiable into one of the three buckets
@@ -423,7 +439,6 @@ class OrchestratorArgs:
     init_timeout: int = 600
 
     # === Cross-stage Communication ===
-    shm_threshold_bytes: int = 65536
     batch_timeout: int = 10
 
     # === Cluster / Backend ===
@@ -460,12 +475,15 @@ class OrchestratorArgs:
     ulysses_degree: int | None = None
     ulysses_mode: str = "strict"
     ring_degree: int | None = None
+    allgather_degree: int | None = None
     diffusion_quantization_config: str | None = None
     use_hsdp: bool = False
     hsdp_shard_size: int = -1
     hsdp_replicate_size: int = 1
     diffusion_attention_backend: str | None = None
     diffusion_attention_config: str | None = None
+    diffusion_compile_granularity: str | None = None
+    diffusion_compile_dynamic: bool | None = None
     cache_backend: str = "none"
     cache_config: str | None = None
     enable_cache_dit_summary: bool = False
@@ -476,6 +494,9 @@ class OrchestratorArgs:
     num_weight_load_threads: int = 4
     enable_cpu_offload: bool = False
     enable_layerwise_offload: bool = False
+    enable_distributed_layerwise_offload: bool = False
+    dlo_use_allgather: bool = True
+    dlo_resident_layers: int = 0
     boundary_ratio: float | None = None
     flow_shift: float | None = None
     diffusion_kv_cache_dtype: str | None = None
@@ -484,6 +505,7 @@ class OrchestratorArgs:
     cfg_parallel_size: int = 1
     vae_patch_parallel_size: int = 1
     vae_parallel_mode: str = "tile"
+    text_encoder_tp_size: int = 1
     default_sampling_params: str | None = None
     max_generated_image_size: int | None = None
     tts_max_instructions_length: int | None = None
diff --git a/vllm_omni/engine/async_engine_utils.py b/vllm_omni/engine/async_engine_utils.py
new file mode 100644
index 000000000..6f544239b
--- /dev/null
+++ b/vllm_omni/engine/async_engine_utils.py
@@ -0,0 +1,165 @@
+"""Stateless request and shutdown helpers for :mod:`async_omni_engine`."""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+import janus
+import torch
+from vllm.logger import init_logger
+from vllm.v1.engine import EngineCoreRequest
+
+from vllm_omni.engine import OmniEngineCoreRequest
+from vllm_omni.engine.messages import EngineQueueMessage, ShutdownRequestMessage
+from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
+from vllm_omni.engine.serialization import (
+    deserialize_additional_information,
+    serialize_additional_information,
+)
+from vllm_omni.engine.stage_runtime import StageRuntime
+
+logger = init_logger(__name__)
+
+SHUTDOWN_ENQUEUE_TIMEOUT_S = 1.0
+SHUTDOWN_JOIN_TIMEOUT_S = 30.0
+_WEAK_SHUTDOWN_JOIN_TIMEOUT_S = 1.0
+
+
+def inject_global_id(target: Any, request_id: str) -> None:
+    """Inject ``global_request_id`` into a prompt's additional information."""
+    if isinstance(target, dict):
+        if "additional_information" not in target:
+            target["additional_information"] = {}
+        if target["additional_information"] is None:
+            target["additional_information"] = {}
+        if isinstance(target["additional_information"], dict):
+            target["additional_information"]["global_request_id"] = [str(request_id)]
+
+
+def upgrade_to_omni_request(
+    request: EngineCoreRequest,
+    raw_prompt: Any,
+) -> EngineCoreRequest:
+    """Restore omni-only fields omitted by the upstream input processor."""
+    prompt_embeds = request.prompt_embeds
+    additional_information = None
+    wire_payload = None
+    model_intermediate_buffer = None
+
+    if isinstance(raw_prompt, dict):
+        if prompt_embeds is None:
+            raw_prompt_embeds = raw_prompt.get("prompt_embeds")
+            if isinstance(raw_prompt_embeds, torch.Tensor):
+                prompt_embeds = raw_prompt_embeds
+        raw_info = raw_prompt.get("additional_information")
+        raw_buffer = raw_prompt.get("model_intermediate_buffer")
+        if isinstance(raw_info, dict):
+            wire_payload = dict(raw_info)
+        if isinstance(raw_buffer, dict):
+            model_intermediate_buffer = raw_buffer
+        additional_information = serialize_additional_information(
+            wire_payload,
+            log_prefix="AsyncOmniEngine",
+        )
+
+    if prompt_embeds is None and additional_information is None and model_intermediate_buffer is None:
+        return request
+
+    return OmniEngineCoreRequest.from_request(
+        request,
+        prompt_embeds=prompt_embeds,
+        additional_information=additional_information,
+        model_intermediate_buffer=model_intermediate_buffer,
+    )
+
+
+def apply_omni_final_stage_metadata(
+    request: EngineCoreRequest,
+    final_stage_id: int,
+    *,
+    force_kv_transfer: bool = False,
+) -> EngineCoreRequest:
+    """Tag a request with its final stage and optional KV-transfer override."""
+    merged: dict[str, Any] = {}
+    if isinstance(request, OmniEngineCoreRequest) and request.additional_information is not None:
+        merged = deserialize_additional_information(request.additional_information)
+    merged["omni_final_stage_id"] = final_stage_id
+    merged.pop("omni_force_kv_transfer", None)
+    if force_kv_transfer:
+        merged["omni_force_kv_transfer"] = True
+    payload = serialize_additional_information(merged)
+    return OmniEngineCoreRequest.from_request(
+        request,
+        additional_information=payload,
+    )
+
+
+def weak_shutdown_async_omni_engine(
+    orchestrator_thread: threading.Thread | None,
+    request_queue: janus.Queue[EngineQueueMessage] | None,
+    output_queue: janus.Queue[EngineQueueMessage] | None,
+    rpc_output_queue: janus.Queue[EngineQueueMessage] | None,
+    rpc_client: CorrelatedRpcClient | None,
+) -> None:
+    """Best-effort orchestrator cleanup for garbage-collection finalization."""
+    request_queue_closed = False
+    shutdown_enqueued = enqueue_orchestrator_shutdown(
+        request_queue,
+        timeout=SHUTDOWN_ENQUEUE_TIMEOUT_S,
+    )
+    if request_queue is not None and not shutdown_enqueued:
+        try:
+            request_queue.close()
+            request_queue_closed = True
+        except Exception:
+            pass
+
+    if rpc_client is not None:
+        rpc_client.close()
+
+    try:
+        if orchestrator_thread is not None and orchestrator_thread.is_alive():
+            orchestrator_thread.join(timeout=_WEAK_SHUTDOWN_JOIN_TIMEOUT_S)
+    except Exception:
+        pass
+
+    for q in (request_queue, output_queue, rpc_output_queue):
+        try:
+            if q is not None and not (q is request_queue and request_queue_closed):
+                q.close()
+        except Exception:
+            pass
+
+
+def enqueue_orchestrator_shutdown(
+    request_queue: janus.Queue[EngineQueueMessage] | None,
+    *,
+    timeout: float,
+) -> bool:
+    """Deliver shutdown without waiting forever behind a full request queue."""
+    if request_queue is None:
+        return False
+    try:
+        request_queue.sync_q.put(ShutdownRequestMessage(), timeout=timeout)
+    except Exception:
+        return False
+    return True
+
+
+def shutdown_runtime_after_orchestrator(
+    orchestrator_thread: threading.Thread,
+    runtime: StageRuntime,
+) -> None:
+    """Release a stage runtime once its orchestrator can no longer use it."""
+    try:
+        orchestrator_thread.join()
+    except Exception:
+        logger.exception("[AsyncOmniEngine] Failed while awaiting deferred Orchestrator shutdown")
+    if orchestrator_thread.is_alive():
+        logger.error("[AsyncOmniEngine] Orchestrator is still alive; StageRuntime cleanup remains deferred")
+        return
+    try:
+        runtime.shutdown()
+    except Exception:
+        logger.exception("[AsyncOmniEngine] Failed to shutdown deferred StageRuntime")
diff --git a/vllm_omni/engine/async_omni_engine.py b/vllm_omni/engine/async_omni_engine.py
index ce9662884..c938d0757 100644
--- a/vllm_omni/engine/async_omni_engine.py
+++ b/vllm_omni/engine/async_omni_engine.py
@@ -18,7 +18,7 @@ import uuid
 import weakref
 from collections.abc import Mapping, Sequence
 from dataclasses import asdict
-from typing import Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal, cast
 
 import janus
 import torch
@@ -30,11 +30,24 @@ from vllm.logger import init_logger
 from vllm.v1.engine import EngineCoreRequest
 from vllm.v1.engine.input_processor import InputProcessor
 
-from vllm_omni.config.config_factory import StageConfigFactory
-from vllm_omni.config.stage_config import strip_parent_engine_args
+from vllm_omni.config.config_factory import StageConfigFactory, with_trust_remote_code_override
+from vllm_omni.config.stage_config import (
+    DuplexSessionRuntimeConfig,
+    load_deploy_config,
+    strip_parent_engine_args,
+)
 from vllm_omni.diffusion.data import DiffusionParallelConfig, parse_attention_config
 from vllm_omni.diffusion.diffusion_engine import supports_audio_output
-from vllm_omni.engine import OmniEngineCoreRequest
+from vllm_omni.engine.async_engine_utils import (
+    SHUTDOWN_ENQUEUE_TIMEOUT_S,
+    SHUTDOWN_JOIN_TIMEOUT_S,
+    apply_omni_final_stage_metadata,
+    enqueue_orchestrator_shutdown,
+    inject_global_id,
+    shutdown_runtime_after_orchestrator,
+    upgrade_to_omni_request,
+    weak_shutdown_async_omni_engine,
+)
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
     AddCompanionRequestMessage,
@@ -42,14 +55,11 @@ from vllm_omni.engine.messages import (
     CollectiveRPCResultMessage,
     EngineQueueMessage,
     ErrorMessage,
-    ShutdownRequestMessage,
+    InteractionMessage,
     StageSubmissionMessage,
 )
 from vllm_omni.engine.orchestrator import Orchestrator
-from vllm_omni.engine.serialization import (
-    deserialize_additional_information,
-    serialize_additional_information,
-)
+from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
 from vllm_omni.engine.stage_client import StageClient
 from vllm_omni.engine.stage_init_utils import build_stage0_input_processor
 from vllm_omni.engine.stage_pool import StagePool
@@ -62,15 +72,18 @@ from vllm_omni.entrypoints.utils import (
     load_and_resolve_stage_configs,
     parse_stage_overrides,
 )
-from vllm_omni.inputs.data import OmniSamplingParams
+from vllm_omni.inputs.data import OmniInteractionPrompt, OmniSamplingParams
 from vllm_omni.metrics.prometheus import OmniRequestCounter
 
 logger = init_logger(__name__)
 
+if TYPE_CHECKING:
+    from vllm_omni.experimental.fullduplex.engine.duplex_control_client import DuplexControlClient
+    from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+    from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
 _STARTUP_POLL_INTERVAL_S = 1.0
 _REQUEST_QUEUE_MAXSIZE = 256
-
-
 # ============================================================================
 # Parent-EngineArgs field-routing contracts (consumed by
 # AsyncOmniEngine._strip_parent_engine_args when ``stage_configs_path`` is set).
@@ -106,88 +119,6 @@ _PARENT_ARGS_STRIP: frozenset[str] = frozenset({"stage_configs_path"})
 _PARENT_ARGS_NO_WARN: frozenset[str] = frozenset({"model"})
 
 
-def _inject_global_id(target: Any, request_id: str) -> None:
-    """Inject global_request_id into a prompt dict's additional_information."""
-    if isinstance(target, dict):
-        if "additional_information" not in target:
-            target["additional_information"] = {}
-        if target["additional_information"] is None:
-            target["additional_information"] = {}
-        if isinstance(target["additional_information"], dict):
-            target["additional_information"]["global_request_id"] = [str(request_id)]
-
-
-def _upgrade_to_omni_request(
-    request: EngineCoreRequest,
-    raw_prompt: Any,
-) -> EngineCoreRequest:
-    """Restore omni-only fields omitted by upstream InputProcessor."""
-    prompt_embeds = request.prompt_embeds
-    additional_information = None
-
-    if isinstance(raw_prompt, dict):
-        if prompt_embeds is None:
-            raw_prompt_embeds = raw_prompt.get("prompt_embeds")
-            if isinstance(raw_prompt_embeds, torch.Tensor):
-                prompt_embeds = raw_prompt_embeds
-        additional_information = serialize_additional_information(
-            raw_prompt.get("additional_information"),
-            log_prefix="AsyncOmniEngine",
-        )
-
-    if prompt_embeds is None and additional_information is None:
-        return request
-
-    return OmniEngineCoreRequest.from_request(
-        request,
-        prompt_embeds=prompt_embeds,
-        additional_information=additional_information,
-    )
-
-
-def _apply_omni_final_stage_metadata(
-    request: EngineCoreRequest,
-    final_stage_id: int,
-) -> EngineCoreRequest:
-    """Tag EngineCoreRequest so OmniARScheduler can skip DiT KV when final_stage_id is 0."""
-    merged: dict[str, Any] = {}
-    if isinstance(request, OmniEngineCoreRequest) and request.additional_information is not None:
-        merged = deserialize_additional_information(request.additional_information)
-    merged["omni_final_stage_id"] = final_stage_id
-    payload = serialize_additional_information(merged)
-    return OmniEngineCoreRequest.from_request(
-        request,
-        additional_information=payload,
-    )
-
-
-def _weak_shutdown_async_omni_engine(
-    orchestrator_thread: threading.Thread | None,
-    request_queue: janus.Queue[EngineQueueMessage] | None,
-    output_queue: janus.Queue[EngineQueueMessage] | None,
-    rpc_output_queue: janus.Queue[EngineQueueMessage] | None,
-) -> None:
-    """Best-effort orchestrator cleanup for GC finalization."""
-    try:
-        if request_queue is not None:
-            request_queue.sync_q.put_nowait(ShutdownRequestMessage())
-    except Exception:
-        pass
-
-    try:
-        if orchestrator_thread is not None and orchestrator_thread.is_alive():
-            orchestrator_thread.join()
-    except Exception:
-        pass
-
-    for q in (request_queue, output_queue, rpc_output_queue):
-        try:
-            if q is not None:
-                q.close()
-        except Exception:
-            pass
-
-
 class AsyncOmniEngine:
     """Thin proxy that launches an Orchestrator in a background thread.
 
@@ -220,7 +151,7 @@ class AsyncOmniEngine:
         transfer_emitter: Any = None,
         log_stats: bool = False,
         tokenizer: str | None = None,
-        trust_remote_code: bool = False,
+        trust_remote_code: bool | None = None,
         **kwargs: Any,
     ) -> None:
         self.model = model
@@ -278,18 +209,43 @@ class AsyncOmniEngine:
                 self._omni_master_port,
             )
 
-        # Stage resolution pops deploy_config, so get the pipeline endpoint
-        # restriction beforehand. TODO (Alex) make this cleaner and refactor
-        # stage config resolution to remove kwargs hacks.
-        deploy_config_path = kwargs.get("deploy_config")
-        self.endpoint_restrictions = StageConfigFactory.get_pipeline_endpoint_restrictions(
+        # Stage resolution pops deploy_config, so get pipeline-wide settings
+        # beforehand. The stage CLI exposes the same deploy YAML through
+        # stage_configs_path.
+        deploy_config_path = kwargs.get("deploy_config") or kwargs.get("stage_configs_path")
+        # ``trust_remote_code`` is tri-state (bool | None): ``None`` means "not
+        # specified" so stage-config resolution can defer to the deploy yaml's
+        # per-stage value (see ``with_trust_remote_code_override``). The
+        # restriction path below loads the top-level HF config via vLLM's
+        # ``get_config``, which needs a real bool, so collapse ``None`` to the
+        # default ``False`` here (#5495).
+        pipeline_config = StageConfigFactory.get_pipeline_config(
             model=model,
-            trust_remote_code=trust_remote_code,
+            trust_remote_code=bool(trust_remote_code),
             deploy_config_path=deploy_config_path,
         )
+        self.endpoint_restrictions = pipeline_config.endpoint_restrictions if pipeline_config is not None else ()
+        self._duplex_runtime_extension_path = (
+            pipeline_config.duplex_runtime_extension if pipeline_config is not None else None
+        )
+        self.duplex_serving_adapter_path = (
+            pipeline_config.duplex_serving_adapter if pipeline_config is not None else None
+        )
+        self._duplex_control_enabled = bool(pipeline_config and pipeline_config.duplex_control_enabled)
+        self.duplex_session_config = DuplexSessionRuntimeConfig()
+        if deploy_config_path is not None:
+            self.duplex_session_config = load_deploy_config(deploy_config_path).duplex_session
 
-        kwargs["trust_remote_code"] = trust_remote_code
-        self.config_path, self.stage_configs = self._resolve_stage_configs(model, kwargs)
+        # Tri-state: None means "not specified" — the deploy yaml's per-stage
+        # trust_remote_code stays in effect. An explicit True/False here is a
+        # global override (precedence: caller > deploy yaml > default False);
+        # the merge rule lives in with_trust_remote_code_override.
+        kwargs = with_trust_remote_code_override(kwargs, trust_remote_code)
+        self.config_path, self.stage_configs = self._resolve_stage_configs(
+            model,
+            kwargs,
+            trust_remote_code=trust_remote_code,
+        )
 
         self.num_stages = len(self.stage_configs)
         stage0_args = getattr(self.stage_configs[0], "engine_args", None) if self.num_stages > 0 else None
@@ -311,7 +267,8 @@ class AsyncOmniEngine:
         self.rpc_output_queue: janus.Queue[EngineQueueMessage] = janus.Queue()
         self._shutdown_called = False
         self._weak_finalizer: weakref.finalize | None = None
-        self._rpc_lock = threading.Lock()
+        self._correlated_rpc_client: CorrelatedRpcClient | None = None
+        self._duplex_control_client: DuplexControlClient | None = None
         self._running_counter = OmniRequestCounter()
 
         logger.info(f"[AsyncOmniEngine] Launching Orchestrator thread with {self.num_stages} stages")
@@ -330,15 +287,20 @@ class AsyncOmniEngine:
         )
         self.orchestrator_thread.start()
         self._wait_for_orchestrator_init(startup_future, startup_timeout)
+        self._correlated_rpc_client = CorrelatedRpcClient(
+            self.request_queue.sync_q,
+            self.rpc_output_queue.sync_q,
+        )
 
         # Stage runtime fields are assigned directly on self by the bootstrap thread.
         self._weak_finalizer = weakref.finalize(
             self,
-            _weak_shutdown_async_omni_engine,
+            weak_shutdown_async_omni_engine,
             self.orchestrator_thread,
             self.request_queue,
             self.output_queue,
             self.rpc_output_queue,
+            self._correlated_rpc_client,
         )
 
         logger.info(f"[AsyncOmniEngine] Orchestrator ready with {self.num_stages} stages")
@@ -353,8 +315,16 @@ class AsyncOmniEngine:
             from types import SimpleNamespace
 
             from vllm_omni.diffusion.data import resolve_model_class_name
+            from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 
-            self._diffusion_od_config_view = SimpleNamespace(model_class_name=resolve_model_class_name(self.model))
+            model_class_name = resolve_model_class_name(self.model)
+            metadata = get_diffusion_model_metadata(model_class_name)
+            self._diffusion_od_config_view = SimpleNamespace(
+                model_class_name=model_class_name,
+                supports_multimodal_inputs=metadata.supports_multimodal_inputs,
+                max_multimodal_image_inputs=metadata.max_multimodal_image_inputs,
+                supports_mixed_reference_inputs=metadata.supports_mixed_reference_inputs,
+            )
         return self._diffusion_od_config_view
 
     def _initialize_stages(self, stage_init_timeout: int) -> None:
@@ -375,6 +345,7 @@ class AsyncOmniEngine:
             omni_heartbeat_timeout=self._omni_heartbeat_timeout,
             omni_lb_policy=self._omni_lb_policy,
             request_queue=self.request_queue,
+            log_stats=self._log_stats,
         )
         self._runtime.initialize()
 
@@ -431,6 +402,21 @@ class AsyncOmniEngine:
             pd_config = self._detect_pd_config()
 
             membership_controller = self._runtime.create_membership_controller()
+            duplex_runtime_extension = None
+            if self._duplex_control_enabled:
+                from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+                    load_duplex_runtime_extension,
+                    validate_duplex_runtime_extension,
+                )
+
+                duplex_runtime_extension = load_duplex_runtime_extension(
+                    getattr(self, "_duplex_runtime_extension_path", None)
+                )
+                if duplex_runtime_extension is not None:
+                    validate_duplex_runtime_extension(
+                        duplex_runtime_extension,
+                        sampling_defaults=tuple(pool.stage_client.default_sampling_params for pool in self.stage_pools),
+                    )
 
             orchestrator = Orchestrator(
                 request_async_queue=self.request_queue.async_q,
@@ -444,6 +430,9 @@ class AsyncOmniEngine:
                 transfer_emitter=self._transfer_emitter,
                 log_stats=self._log_stats,
                 enable_orch_monitor=self._enable_orch_monitor,
+                duplex_runtime_extension=duplex_runtime_extension,
+                enable_duplex_control=self._duplex_control_enabled,
+                duplex_session_config=self.duplex_session_config,
             )
             if not startup_future.done():
                 startup_future.set_result(asyncio.get_running_loop())
@@ -491,6 +480,13 @@ class AsyncOmniEngine:
         while True:
             remaining = deadline - time.monotonic()
             if remaining <= 0:
+                logger.warning(
+                    "[AsyncOmniEngine] Orchestrator startup timed out after %ss. "
+                    "Multi-stage deployments that initialize stages sequentially on one device "
+                    "or load checkpoints from slow storage may need larger --init-timeout and "
+                    "--stage-init-timeout values.",
+                    startup_timeout,
+                )
                 self._try_shutdown("[AsyncOmniEngine] Failed to cleanup after orchestrator startup timeout")
                 raise TimeoutError(f"Orchestrator did not become ready within {startup_timeout}s")
             try:
@@ -714,10 +710,10 @@ class AsyncOmniEngine:
         if stage_type != "diffusion" and not isinstance(prompt, EngineCoreRequest):
             # Inject global_request_id into the raw prompt.
             if isinstance(prompt, dict):
-                _inject_global_id(prompt, request_id)
+                inject_global_id(prompt, request_id)
             elif isinstance(prompt, list):
                 for item in prompt:
-                    _inject_global_id(item, request_id)
+                    inject_global_id(item, request_id)
 
             preselected_stage0_replica = self._scope_stage0_multimodal_cache_to_replica(
                 request_id,
@@ -747,7 +743,7 @@ class AsyncOmniEngine:
             _preprocess_ms = (time.perf_counter() - _t_preprocess) * 1000.0
             # TODO (Peiqi): add this for Qwen3-TTS only. Other models don't have
             # additional_information field in the prompt.
-            request = _upgrade_to_omni_request(request, prompt)
+            request = upgrade_to_omni_request(request, prompt)
 
             if reasoning_ended is not None:
                 request.reasoning_ended = reasoning_ended
@@ -759,7 +755,7 @@ class AsyncOmniEngine:
             # to match the key used in Orchestrator.request_states so that
             # output routing (output.request_id lookup) can find the req_state.
             request.external_req_id = request_id
-            request = _apply_omni_final_stage_metadata(request, final_stage_id)
+            request = apply_omni_final_stage_metadata(request, final_stage_id)
 
             # Registration with stage 0's output processor is deferred to the
             # orchestrator thread (see Orchestrator._handle_add_request), which
@@ -807,7 +803,7 @@ class AsyncOmniEngine:
             companion_params, companion_spl = ep.apply_overrides(stage0_params, sampling_params_list)
 
             if isinstance(companion_prompt, dict):
-                _inject_global_id(companion_prompt, cid)
+                inject_global_id(companion_prompt, cid)
 
             request = self.input_processor.process_inputs(
                 request_id=cid,
@@ -816,6 +812,9 @@ class AsyncOmniEngine:
                 supported_tasks=self.supported_tasks,
             )
             request.external_req_id = cid
+            # Companions are stage-0-final for ordinary downstream payloads,
+            # but diffusion still needs their CFG KV caches.
+            request = apply_omni_final_stage_metadata(request, 0, force_kv_transfer=True)
 
             # Registration of this companion on stage-0's output processor is
             # deferred to Orchestrator._handle_add_companion, which routes
@@ -964,6 +963,7 @@ class AsyncOmniEngine:
         if parallel_config is None:
             ulysses_degree = normalized_kwargs.get("ulysses_degree") or 1
             ring_degree = normalized_kwargs.get("ring_degree") or 1
+            allgather_degree = normalized_kwargs.get("allgather_degree") or 1
             ulysses_mode = normalized_kwargs.get("ulysses_mode") or "strict"
             sequence_parallel_size = normalized_kwargs.get("sequence_parallel_size")
             pipeline_parallel_size = normalized_kwargs.get("pipeline_parallel_size") or 1
@@ -973,12 +973,13 @@ class AsyncOmniEngine:
             pipeline_parallel_size = normalized_kwargs.get("pipeline_parallel_size") or 1
             vae_patch_parallel_size = normalized_kwargs.get("vae_patch_parallel_size") or 1
             vae_parallel_mode = normalized_kwargs.get("vae_parallel_mode") or "tile"
+            text_encoder_tp_size = normalized_kwargs.get("text_encoder_tp_size") or 1
             enable_expert_parallel = normalized_kwargs.get("enable_expert_parallel") or False
             use_hsdp = normalized_kwargs.get("use_hsdp", False)
             hsdp_shard_size = normalized_kwargs.get("hsdp_shard_size", -1)
             hsdp_replicate_size = normalized_kwargs.get("hsdp_replicate_size", 1)
             if sequence_parallel_size is None:
-                sequence_parallel_size = ulysses_degree * ring_degree
+                sequence_parallel_size = allgather_degree if allgather_degree > 1 else ulysses_degree * ring_degree
 
             parallel_config = DiffusionParallelConfig(
                 pipeline_parallel_size=pipeline_parallel_size,
@@ -988,10 +989,12 @@ class AsyncOmniEngine:
                 sequence_parallel_size=sequence_parallel_size,
                 ulysses_degree=ulysses_degree,
                 ring_degree=ring_degree,
+                allgather_degree=allgather_degree,
                 ulysses_mode=ulysses_mode,
                 cfg_parallel_size=cfg_parallel_size,
                 vae_patch_parallel_size=vae_patch_parallel_size,
                 vae_parallel_mode=vae_parallel_mode,
+                text_encoder_tp_size=text_encoder_tp_size,
                 use_hsdp=use_hsdp,
                 hsdp_shard_size=hsdp_shard_size,
                 hsdp_replicate_size=hsdp_replicate_size,
@@ -1016,6 +1019,7 @@ class AsyncOmniEngine:
             "max_num_seqs": kwargs.get("max_num_seqs") or 1,
             "parallel_config": parallel_config,
             "model_class_name": kwargs.get("model_class_name", None),
+            "task_type": kwargs.get("task_type", None),
             "model_config": kwargs.get("model_config", None),
             "additional_config": kwargs.get("additional_config", None),
             "step_execution": kwargs.get("step_execution", False),
@@ -1027,7 +1031,18 @@ class AsyncOmniEngine:
             "enable_cache_dit_summary": kwargs.get("enable_cache_dit_summary", False),
             "enable_cpu_offload": kwargs.get("enable_cpu_offload", False),
             "enable_layerwise_offload": kwargs.get("enable_layerwise_offload", False),
+            "enable_distributed_layerwise_offload": kwargs.get("enable_distributed_layerwise_offload", False),
+            "dlo_use_allgather": kwargs.get("dlo_use_allgather", True),
+            "dlo_resident_layers": kwargs.get("dlo_resident_layers", 0),
             "enforce_eager": False if kwargs.get("enforce_eager") is None else kwargs.get("enforce_eager"),
+            "diffusion_compile_granularity": (
+                "regional"
+                if kwargs.get("diffusion_compile_granularity") is None
+                else kwargs["diffusion_compile_granularity"]
+            ),
+            "diffusion_compile_dynamic": (
+                True if kwargs.get("diffusion_compile_dynamic") is None else kwargs["diffusion_compile_dynamic"]
+            ),
             "boundary_ratio": kwargs.get("boundary_ratio", None),
             "flow_shift": kwargs.get("flow_shift", None),
             "diffusion_load_format": kwargs.get("diffusion_load_format", "default"),
@@ -1085,6 +1100,7 @@ class AsyncOmniEngine:
                     "devices": devices,
                 },
                 "engine_args": stage_engine_args,
+                "engine_input_source": [],
                 "default_sampling_params": stage_default_sampling_params,
                 "final_output": True,
                 "final_output_type": final_output_type,
@@ -1156,7 +1172,13 @@ class AsyncOmniEngine:
             )
             self._omni_lb_policy = str(derived)
 
-    def _resolve_stage_configs(self, model: str, kwargs: dict[str, Any]) -> tuple[str, list[Any]]:
+    def _resolve_stage_configs(
+        self,
+        model: str,
+        kwargs: dict[str, Any],
+        *,
+        trust_remote_code: bool | None,
+    ) -> tuple[str, list[Any]]:
         """Resolve stage configs and inject defaults shared by orchestrator/headless."""
 
         stage_configs_path = kwargs.get("stage_configs_path", None)
@@ -1182,6 +1204,7 @@ class AsyncOmniEngine:
             model,
             stage_configs_path,
             base_kwargs,
+            trust_remote_code=trust_remote_code,
             default_stage_cfg_factory=lambda: self._create_default_diffusion_stage_cfg(kwargs),
             deploy_config_path=deploy_config_path,
             stage_overrides=stage_overrides,
@@ -1422,6 +1445,268 @@ class AsyncOmniEngine:
             resumable=resumable,
         )
 
+    def open_duplex_session(
+        self,
+        session_id: str,
+        *,
+        session_mode: str = "duplex",
+        capabilities: dict[str, object] | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Open an engine-level duplex session."""
+        return self._get_duplex_control_client().open(
+            session_id,
+            session_mode=session_mode,
+            capabilities=capabilities,
+            session_config=session_config,
+            runtime_config=runtime_config,
+            fence=fence,
+            timeout=timeout,
+        )
+
+    async def open_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        session_mode: str = "duplex",
+        capabilities: dict[str, object] | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Async wrapper for opening an engine-level duplex session."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.open_duplex_session(
+                session_id,
+                session_mode=session_mode,
+                capabilities=capabilities,
+                session_config=session_config,
+                runtime_config=runtime_config,
+                fence=fence,
+                timeout=timeout,
+            ),
+        )
+
+    def append_duplex_input(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None = None,
+        final: bool = False,
+        expected_epoch: int | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Append input to an engine-level duplex session."""
+        return self._get_duplex_control_client().append(
+            session_id,
+            mode=mode,
+            payload=payload,
+            operation_id=operation_id,
+            final=final,
+            expected_epoch=expected_epoch,
+            fence=fence,
+            timeout=timeout,
+        )
+
+    async def append_duplex_input_async(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None = None,
+        final: bool = False,
+        expected_epoch: int | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Async wrapper for appending duplex input."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.append_duplex_input(
+                session_id,
+                mode=mode,
+                payload=payload,
+                operation_id=operation_id,
+                final=final,
+                expected_epoch=expected_epoch,
+                fence=fence,
+                timeout=timeout,
+            ),
+        )
+
+    def signal_duplex_turn(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        fence: DuplexFence,
+        next_fence: DuplexFence | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Signal an engine-level duplex turn."""
+        return self._get_duplex_control_client().signal(
+            session_id,
+            event=event,
+            fence=fence,
+            next_fence=next_fence,
+            session_config=session_config,
+            runtime_config=runtime_config,
+            timeout=timeout,
+        )
+
+    async def signal_duplex_turn_async(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        fence: DuplexFence,
+        next_fence: DuplexFence | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Async wrapper for signaling a duplex turn."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.signal_duplex_turn(
+                session_id,
+                event=event,
+                fence=fence,
+                next_fence=next_fence,
+                session_config=session_config,
+                runtime_config=runtime_config,
+                timeout=timeout,
+            ),
+        )
+
+    def close_duplex_session(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Close an engine-level duplex session."""
+        return self._get_duplex_control_client().close(
+            session_id,
+            reason=reason,
+            fence=fence,
+            timeout=timeout,
+        )
+
+    def touch_duplex_session(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        return self._get_duplex_control_client().touch(
+            session_id,
+            fence=fence,
+            activity=activity,
+            timeout=timeout,
+        )
+
+    async def touch_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.touch_duplex_session(
+                session_id,
+                fence=fence,
+                activity=activity,
+                timeout=timeout,
+            ),
+        )
+
+    def resume_duplex_session(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        return self._get_duplex_control_client().resume(
+            session_id,
+            fence=fence,
+            expected_lease_generation=expected_lease_generation,
+            timeout=timeout,
+        )
+
+    async def resume_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.resume_duplex_session(
+                session_id,
+                fence=fence,
+                expected_lease_generation=expected_lease_generation,
+                timeout=timeout,
+            ),
+        )
+
+    def _get_duplex_control_client(self) -> DuplexControlClient:
+        from vllm_omni.experimental.fullduplex.engine.duplex_control_client import DuplexControlClient
+
+        client = getattr(self, "_duplex_control_client", None)
+        if client is None:
+            transport = getattr(self, "_correlated_rpc_client", None)
+            if transport is None:
+                raise RuntimeError("correlated RPC client is not initialized")
+            client = DuplexControlClient(
+                transport,
+                control_id_factory=lambda: uuid.uuid4().hex,
+            )
+            self._duplex_control_client = client
+        return client
+
+    async def close_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Async wrapper for closing an engine-level duplex session."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.close_duplex_session(session_id, reason=reason, fence=fence, timeout=timeout),
+        )
+
     def try_get_output(self, timeout: float = 0.001) -> EngineQueueMessage | None:
         """Read one output message from the Orchestrator output queue."""
         try:
@@ -1454,6 +1739,30 @@ class AsyncOmniEngine:
         """Async abort API."""
         self.abort(request_ids)
 
+    def submit_interaction(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Send an interaction control message to the Orchestrator."""
+        if self.request_queue is None:
+            raise RuntimeError("request_queue is not initialized")
+
+        self.request_queue.sync_q.put_nowait(
+            InteractionMessage(
+                request_id=request_id,
+                interaction=interaction,
+            )
+        )
+
+    async def submit_interaction_async(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Async interaction API."""
+        self.submit_interaction(request_id, interaction)
+
     def collective_rpc(
         self,
         method: str,
@@ -1477,36 +1786,19 @@ class AsyncOmniEngine:
             stage_ids=stage_ids,
         )
 
-        with self._rpc_lock:
-            self.request_queue.sync_q.put(msg)
-            deadline = None if timeout is None else time.monotonic() + timeout
-
-            while True:
-                remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
-                try:
-                    result_msg = self.rpc_output_queue.sync_q.get(timeout=remaining)
-                except queue.Empty as exc:
-                    raise TimeoutError(f"collective_rpc timed out after {timeout} seconds") from exc
-
-                if isinstance(result_msg, ErrorMessage):
-                    raise RuntimeError(result_msg.error)
-
-                if not isinstance(result_msg, CollectiveRPCResultMessage):
-                    logger.warning(
-                        "[AsyncOmniEngine] Dropping unexpected rpc queue message type=%s",
-                        getattr(result_msg, "type", type(result_msg).__name__),
-                    )
-                    continue
-
-                if result_msg.rpc_id != rpc_id:
-                    logger.warning(
-                        "[AsyncOmniEngine] Dropping mismatched rpc result rpc_id=%s expected=%s",
-                        result_msg.rpc_id,
-                        rpc_id,
-                    )
-                    continue
-
-                return list(result_msg.results)
+        transport = self._correlated_rpc_client
+        if transport is None:
+            raise RuntimeError("correlated RPC client is not initialized")
+        result_msg = transport.execute(
+            ("collective", rpc_id),
+            msg,
+            timeout=timeout,
+            timeout_message=f"collective_rpc timed out after {timeout} seconds",
+            block_on_submit=True,
+        )
+        if not isinstance(result_msg, CollectiveRPCResultMessage):
+            raise RuntimeError(f"unexpected collective RPC result type: {type(result_msg).__name__}")
+        return list(result_msg.results)
 
     async def collective_rpc_async(
         self,
@@ -1543,22 +1835,61 @@ class AsyncOmniEngine:
             finalizer.detach()
 
         logger.info("[AsyncOmniEngine] Shutting down Orchestrator")
-        if self.request_queue is not None:
-            self.request_queue.sync_q.put_nowait(ShutdownRequestMessage())
-        if self.is_alive():
-            self.orchestrator_thread.join()
+        request_queue_closed = False
+        shutdown_enqueued = enqueue_orchestrator_shutdown(
+            self.request_queue,
+            timeout=SHUTDOWN_ENQUEUE_TIMEOUT_S,
+        )
+        if self.request_queue is not None and not shutdown_enqueued:
+            logger.error(
+                "[AsyncOmniEngine] Failed to enqueue orchestrator shutdown; "
+                "closing the request queue to wake the request handler"
+            )
+            try:
+                self.request_queue.close()
+                request_queue_closed = True
+            except Exception:
+                logger.exception("[AsyncOmniEngine] Failed to close the request queue")
+
+        if self._correlated_rpc_client is not None:
+            try:
+                self._correlated_rpc_client.close()
+            except Exception:
+                logger.exception("[AsyncOmniEngine] Failed to close correlated RPC client")
+
+        orchestrator_stopped = False
+        try:
+            if self.is_alive():
+                self.orchestrator_thread.join(timeout=SHUTDOWN_JOIN_TIMEOUT_S)
+            orchestrator_stopped = not self.is_alive()
+            if not orchestrator_stopped:
+                logger.error(
+                    "[AsyncOmniEngine] Orchestrator did not stop within %.1f seconds; continuing cleanup",
+                    SHUTDOWN_JOIN_TIMEOUT_S,
+                )
+        except Exception:
+            logger.exception("[AsyncOmniEngine] Failed to join Orchestrator thread")
 
         for q in (self.request_queue, self.output_queue, self.rpc_output_queue):
             try:
-                q.close()
+                if not (q is self.request_queue and request_queue_closed):
+                    q.close()
             except Exception:
                 pass
 
-        if hasattr(self, "_runtime") and self._runtime is not None:
+        if hasattr(self, "_runtime") and self._runtime is not None and orchestrator_stopped:
             try:
                 self._runtime.shutdown()
             except Exception:
                 logger.exception("[AsyncOmniEngine] Failed to shutdown StageRuntime")
+        elif hasattr(self, "_runtime") and self._runtime is not None:
+            logger.warning("[AsyncOmniEngine] Deferring StageRuntime shutdown until the Orchestrator exits")
+            threading.Thread(
+                target=shutdown_runtime_after_orchestrator,
+                args=(self.orchestrator_thread, self._runtime),
+                daemon=True,
+                name="omni-stage-runtime-shutdown",
+            ).start()
 
         # ── Release CuMem allocator memory pool ──────────────────────────────
         # When enable_sleep_mode is in use, the CuMem (CUDA Virtual Memory
diff --git a/vllm_omni/engine/cfg_companion_tracker.py b/vllm_omni/engine/cfg_companion_tracker.py
index aeec9e848..904a608fb 100644
--- a/vllm_omni/engine/cfg_companion_tracker.py
+++ b/vllm_omni/engine/cfg_companion_tracker.py
@@ -57,16 +57,28 @@ class CfgCompanionTracker:
         """Stash companion engine output for the parent to bundle at forward time."""
         self._companion_outputs[companion_id] = output
 
-    def pop_companion_outputs(self, parent_id: str) -> list[Any]:
-        """Pop companion outputs (role-registration order) for bundling into set_engine_outputs."""
+    def get_companion_outputs(self, parent_id: str) -> list[Any]:
+        """Return companion outputs (role-registration order) for bundling.
+
+        Non-destructive: outputs stay stashed until ``cleanup_parent`` so a
+        re-submission of the same parent (e.g. a streaming terminal update)
+        bundles the complete set again instead of an empty one.
+        """
         role_map = self._companion_map.get(parent_id, {})
         outputs = []
         for cid in role_map.values():
-            out = self._companion_outputs.pop(cid, None)
+            out = self._companion_outputs.get(cid)
             if out is not None:
                 outputs.append(out)
         return outputs
 
+    def is_companion_done(self, companion_id: str) -> bool:
+        """True once this companion's processed output was stashed and marked done."""
+        parent_id = self._companion_to_parent.get(companion_id)
+        if parent_id is None:
+            return False
+        return companion_id in self._done.get(parent_id, set())
+
     def on_companion_completed(self, companion_id: str) -> str | None:
         """Mark done. Returns parent_id only if parent is pending and all companions finished."""
         parent_id = self._companion_to_parent.get(companion_id)
@@ -83,10 +95,14 @@ class CfgCompanionTracker:
         return None
 
     def defer_parent(self, parent_id: str, engine_outputs: Any, stage_id: int) -> None:
-        """Hold parent result while waiting for companions to finish."""
-        # TODO: Add timeout/error recovery when the orchestrator grows a
-        # companion-failure path. Today deferred parents are released only when
-        # companions finish or the external layer aborts the request.
+        """Hold parent result while waiting for companions to finish.
+
+        Deferred parents are released when their companions' processed outputs
+        arrive, and failed by the orchestrator when a companion errors or is
+        aborted. TODO: a deadline for deferred parents and detection of a
+        companion replica dying silently (no error output, no abort) still
+        need a liveness owner in the orchestrator loop.
+        """
         self._pending_parents[parent_id] = {
             "engine_outputs": engine_outputs,
             "stage_id": stage_id,
diff --git a/vllm_omni/engine/membership_controller.py b/vllm_omni/engine/membership_controller.py
index 48b6fe559..a7676de54 100644
--- a/vllm_omni/engine/membership_controller.py
+++ b/vllm_omni/engine/membership_controller.py
@@ -157,7 +157,7 @@ class MembershipController:
         input_addr = StagePool._client_input_addr(client)
         if input_addr is None:
             raise RuntimeError(f"remote replica factory for stage {stage_id} produced a client without input address")
-        pool.add_client(input_addr, client)
+        pool.add_client(input_addr, client, replica_id=replica_id)
         logger.info(
             "[MembershipController] attached remote replica stage=%d replica=%d addr=%s",
             stage_id,
diff --git a/vllm_omni/engine/messages.py b/vllm_omni/engine/messages.py
index bb73f74a3..80bf42b0e 100644
--- a/vllm_omni/engine/messages.py
+++ b/vllm_omni/engine/messages.py
@@ -6,7 +6,7 @@ import msgspec
 from vllm.inputs import PromptType
 from vllm.v1.engine import EngineCoreRequest
 
-from vllm_omni.inputs.data import OmniSamplingParams
+from vllm_omni.inputs.data import OmniInteractionPrompt, OmniSamplingParams
 from vllm_omni.metrics.stats import StageRequestStats as StageRequestMetrics
 from vllm_omni.outputs import OmniRequestOutput
 
@@ -44,6 +44,12 @@ class AbortRequestMessage(EngineQueueMessage, kw_only=True):
     request_ids: list[str]
 
 
+class InteractionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["interaction"] = "interaction"
+    request_id: str
+    interaction: OmniInteractionPrompt
+
+
 class CollectiveRPCRequestMessage(EngineQueueMessage, kw_only=True):
     type: Literal["collective_rpc"] = "collective_rpc"
     rpc_id: str
@@ -78,6 +84,7 @@ class ErrorMessage(EngineQueueMessage, kw_only=True):
     fatal: bool = False
     request_id: str | None = None
     stage_id: int | None = None
+    event_id: str | None = None  # for interactions on diffusion generation requests
 
 
 class OutputMessage(EngineQueueMessage, kw_only=True):
@@ -106,3 +113,7 @@ class CollectiveRPCResultMessage(EngineQueueMessage, kw_only=True):
     method: str
     stage_ids: list[int]
     results: list[object]
+
+    @property
+    def rpc_correlation_key(self) -> tuple[str, str]:
+        return ("collective", self.rpc_id)
diff --git a/vllm_omni/engine/orchestrator.py b/vllm_omni/engine/orchestrator.py
index bdd678f27..0b4f17aae 100644
--- a/vllm_omni/engine/orchestrator.py
+++ b/vllm_omni/engine/orchestrator.py
@@ -13,8 +13,9 @@ from __future__ import annotations
 
 import asyncio
 import time as _time
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import janus
 import torch
@@ -22,11 +23,13 @@ from vllm.config import ModelConfig
 from vllm.logger import init_logger
 from vllm.outputs import CompletionOutput, RequestOutput
 from vllm.pooling_params import PoolingParams
-from vllm.sampling_params import SamplingParams
+from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.v1.engine import EngineCoreOutputs
 from vllm.v1.engine.exceptions import EngineDeadError
 from vllm.v1.metrics.stats import IterationStats
 
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.distributed.omni_connectors.utils.config import stage_receives_chunks
 from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
 from vllm_omni.engine.membership_controller import MembershipController
@@ -37,6 +40,7 @@ from vllm_omni.engine.messages import (
     CollectiveRPCResultMessage,
     EngineQueueMessage,
     ErrorMessage,
+    InteractionMessage,
     OutputMessage,
     RegisterRemoteReplicaMessage,
     ShutdownRequestMessage,
@@ -53,6 +57,23 @@ from vllm_omni.outputs import OmniRequestOutput
 
 logger = init_logger(__name__)
 
+if TYPE_CHECKING:
+    from vllm_omni.experimental.fullduplex.engine.contracts import (
+        DuplexControlPlanePort,
+        DuplexOutputContext,
+        DuplexOutputDecision,
+        DuplexRequestIdentity,
+        DuplexRuntimeExtension,
+        DuplexStageRequestContext,
+        DuplexStageSubmission,
+        DuplexStageSubmissionResult,
+    )
+    from vllm_omni.experimental.fullduplex.engine.duplex_session import (
+        DuplexSessionRuntimeManager,
+        DuplexSessionRuntimeState,
+    )
+    from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
 
 def _build_terminal_empty_output(
     request_id: str,
@@ -85,37 +106,6 @@ def _build_terminal_empty_output(
     )
 
 
-def _coerce_int_scalar(value: Any) -> int:
-    if value is None:
-        return 0
-    if isinstance(value, (list, tuple)):
-        for item in value:
-            coerced = _coerce_int_scalar(item)
-            if coerced > 0:
-                return coerced
-        return 0
-    if hasattr(value, "item"):
-        value = value.item()
-    try:
-        coerced = int(value)
-    except (TypeError, ValueError):
-        return 0
-    return coerced if coerced > 0 else 0
-
-
-def _infer_stage_audio_sample_rate(stage_pool: StagePool, default: int = 24000) -> int:
-    """Infer the final audio stage sample rate from stage metadata when possible."""
-    sample_rate_attrs = ("audio_sample_rate", "sample_rate", "sampling_rate", "output_sample_rate", "sr")
-    stage_client = getattr(stage_pool, "stage_client", None)
-    stage_config = getattr(stage_pool, "_stage_vllm_config", None)
-    for source in (stage_client, stage_config):
-        for attr in sample_rate_attrs:
-            sample_rate = _coerce_int_scalar(getattr(source, attr, None))
-            if sample_rate > 0:
-                return sample_rate
-    return default
-
-
 def build_engine_core_request_from_tokens(
     request_id: str,
     prompt: dict[str, Any],
@@ -141,8 +131,13 @@ def build_engine_core_request_from_tokens(
         pooling_params = params.clone()
 
     prompt_embeds: torch.Tensor | None = prompt.get("prompt_embeds")
+    raw_additional_information = prompt.get("additional_information")
+    model_intermediate_buffer = prompt.get("model_intermediate_buffer")
+    wire_payload: dict[str, Any] | None = None
+    if isinstance(raw_additional_information, dict):
+        wire_payload = dict(raw_additional_information)
     additional_info_payload = serialize_additional_information(
-        prompt.get("additional_information"),
+        wire_payload,
         log_prefix=f"build_engine_core_request_from_tokens req={request_id}",
     )
 
@@ -159,6 +154,7 @@ def build_engine_core_request_from_tokens(
         prompt_embeds=prompt_embeds,
         resumable=resumable,
         additional_information=additional_info_payload,
+        model_intermediate_buffer=model_intermediate_buffer if isinstance(model_intermediate_buffer, dict) else None,
     )
 
 
@@ -186,6 +182,10 @@ class OrchestratorRequestState:
 
     # Per-request pipeline timing accumulator (milliseconds)
     pipeline_timings: dict[str, float] = field(default_factory=dict)
+    duplex_identity: DuplexRequestIdentity | None = None
+    duplex_stage_fences: dict[int, DuplexFence] = field(default_factory=dict)
+    duplex_config_generation: int = -1
+    running_counter_registered: bool = False
 
 
 @dataclass
@@ -194,10 +194,137 @@ class StreamingInputState:
     enabled: bool = False
     # Flag of segment of streaming input finished
     segment_finished: bool = False
+    # Tokens from the current raw segment boundary. The vLLM output processor
+    # does not guarantee that EngineCoreOutput.new_token_ids survives on the
+    # processed RequestOutput used by the routing layer.
+    segment_token_ids: list[int] = field(default_factory=list)
+    segment_output_metadata: dict[str, Any] = field(default_factory=dict)
     # Streaming update prompt length
     new_prompt_len_snapshot: int | None = None
     # Model/bridge-specific runtime states (e.g., thinker->talker)
     bridge_states: dict[str, Any] = field(default_factory=dict)
+    # Synchronous stage-transition capability installed by the orchestrator
+    # while the downstream input processor consumes upstream token output.
+    source_token_decoder: Callable[..., str] | None = None
+
+
+class _OrchestratorDuplexStagePort:
+    """Adapts generic stage pools to the model-neutral duplex control plane."""
+
+    def __init__(
+        self,
+        *,
+        stage_pools: list[StagePool],
+        request_states: dict[str, OrchestratorRequestState],
+        running_counter: OmniRequestCounter | None,
+        cleanup_request_ids: Callable[..., Any],
+        async_chunk: bool,
+        prewarm_async_chunk_stages: Callable[
+            [str, Any, OrchestratorRequestState],
+            Awaitable[None],
+        ],
+    ) -> None:
+        self._stage_pools = stage_pools
+        self._request_states = request_states
+        self._running_counter = running_counter
+        self._cleanup_request_ids = cleanup_request_ids
+        self._async_chunk = async_chunk
+        self._prewarm_async_chunk_stages = prewarm_async_chunk_stages
+
+    @property
+    def stage_count(self) -> int:
+        return len(self._stage_pools)
+
+    def sampling_defaults(self) -> tuple[object, ...]:
+        return tuple(pool.stage_client.default_sampling_params for pool in self._stage_pools)
+
+    @staticmethod
+    def _sync_bridge_state(
+        request_state: OrchestratorRequestState,
+        context: DuplexStageRequestContext,
+    ) -> None:
+        duplex_state = request_state.streaming.bridge_states.setdefault("duplex", {})
+        if not isinstance(duplex_state, dict):
+            duplex_state = {}
+            request_state.streaming.bridge_states["duplex"] = duplex_state
+        previous_epoch = duplex_state.get("epoch")
+        if not isinstance(duplex_state.get("model_turn_id"), int) or previous_epoch != context.fence.epoch:
+            duplex_state["model_turn_id"] = context.fence.turn_id
+        duplex_state.update(
+            {
+                "session_id": context.session_id,
+                "fence": context.fence,
+                "incarnation": context.fence.incarnation,
+                "epoch": context.fence.epoch,
+                "turn_id": context.fence.turn_id,
+                "response_seq": context.fence.response_seq,
+                "session_config": dict(context.session_config),
+                "runtime_config": dict(context.runtime_config),
+            }
+        )
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None:
+        from vllm_omni.experimental.fullduplex.engine.contracts import DuplexRequestIdentity
+
+        request_state = self._request_states.get(context.request_id)
+        if request_state is None:
+            request_state = OrchestratorRequestState(
+                request_id=context.request_id,
+                prompt=None,
+                sampling_params_list=list(context.sampling_params),
+                final_stage_id=context.final_stage_id,
+                duplex_config_generation=context.config_generation,
+            )
+            request_state.streaming.enabled = True
+            self._request_states[context.request_id] = request_state
+        elif request_state.duplex_config_generation != context.config_generation:
+            request_state.sampling_params_list = list(context.sampling_params)
+            request_state.duplex_config_generation = context.config_generation
+        request_state.duplex_identity = DuplexRequestIdentity(
+            session_id=context.session_id,
+            fence=context.fence,
+        )
+        self._sync_bridge_state(request_state, context)
+
+    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
+        from vllm_omni.experimental.fullduplex.engine.contracts import DuplexStageSubmissionResult
+
+        context = submission.context
+        request_state = self._request_states.get(context.request_id)
+        if request_state is None:
+            raise RuntimeError(f"duplex request was not preregistered: {context.request_id}")
+        request = build_engine_core_request_from_tokens(
+            request_id=context.request_id,
+            prompt=dict(submission.prompt),
+            params=context.stage_sampling_params,
+            model_config=self._stage_pools[context.stage_id].stage_vllm_config.model_config,
+            resumable=True,
+        )
+        request.external_req_id = request.request_id
+        pool = self._stage_pools[context.stage_id]
+        if submission.already_submitted:
+            replica_id = await pool.submit_update(context.request_id, request_state, request)
+        else:
+            replica_id = await pool.submit_initial(context.request_id, request_state, request, prompt_text=None)
+            if self._async_chunk and context.stage_id == 0:
+                await self._prewarm_async_chunk_stages(
+                    context.request_id,
+                    request,
+                    request_state,
+                )
+        request_state.duplex_stage_fences[context.stage_id] = context.fence
+        request_state.stage_submit_ts[context.stage_id] = _time.time()
+        if not request_state.running_counter_registered and self._running_counter is not None:
+            self._running_counter.increment()
+            request_state.running_counter_registered = True
+        return DuplexStageSubmissionResult(
+            request_id=context.request_id,
+            stage_id=context.stage_id,
+            replica_id=replica_id,
+        )
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+        await self._cleanup_request_ids(request_ids, abort=abort)
 
 
 class Orchestrator:
@@ -208,6 +335,7 @@ class Orchestrator:
     _running_counter: OmniRequestCounter | None = None
     _transfer_emitter: Any = None
     _stat_logger: OmniPrometheusStatLogger | None = None
+    duplex_control_plane: DuplexControlPlanePort | None = None
 
     def __init__(
         self,
@@ -223,6 +351,9 @@ class Orchestrator:
         transfer_emitter: Any = None,
         log_stats: bool = False,
         enable_orch_monitor: bool = False,
+        duplex_runtime_extension: DuplexRuntimeExtension | None = None,
+        enable_duplex_control: bool = False,
+        duplex_session_config: DuplexSessionRuntimeConfig | None = None,
     ) -> None:
         self.request_async_queue = request_async_queue
         self.output_async_queue = output_async_queue
@@ -231,12 +362,13 @@ class Orchestrator:
         self.async_chunk = bool(async_chunk)
         self.num_stages = len(stage_pools)
         self.stage_pools: list[StagePool] = stage_pools
+        self.log_stats = log_stats
         self._orch_monitor = create_orch_monitor(
             enabled=enable_orch_monitor,
             replica_sampler=self._sample_replica_metrics,
         )
         for stage_id, pool in enumerate(self.stage_pools):
-            for replica_id in pool.live_replica_ids():
+            for replica_id in pool.available_replica_ids():
                 self._orch_monitor.register_replica(stage_id, replica_id)
 
         # PD disaggregation state
@@ -254,6 +386,35 @@ class Orchestrator:
         self._cfg_tracker = CfgCompanionTracker()
         self._stage_input_processors: dict[int, Any] = {}
 
+        self.duplex_control_plane: DuplexControlPlanePort | None = None
+        self._duplex_reaper_interval_s = 1.0
+        if enable_duplex_control:
+            from vllm_omni.experimental.fullduplex.engine.duplex_control_plane import DuplexControlPlane
+            from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseConfig
+
+            runtime_session_config = duplex_session_config or DuplexSessionRuntimeConfig()
+            self._duplex_reaper_interval_s = runtime_session_config.reaper_interval_s
+
+            self.duplex_control_plane = DuplexControlPlane(
+                extension=duplex_runtime_extension,
+                stage_port=_OrchestratorDuplexStagePort(
+                    stage_pools=self.stage_pools,
+                    request_states=self.request_states,
+                    running_counter=self._running_counter,
+                    cleanup_request_ids=self._cleanup_request_ids,
+                    async_chunk=self.async_chunk,
+                    prewarm_async_chunk_stages=self._prewarm_async_chunk_stages,
+                ),
+                result_sink=self.rpc_async_queue,
+                lifecycle_sink=self.output_async_queue,
+                lease_config=DuplexLeaseConfig(
+                    idle_ttl_s=runtime_session_config.idle_ttl_s,
+                    disconnect_grace_s=runtime_session_config.disconnect_grace_s,
+                ),
+                max_sessions=runtime_session_config.max_sessions,
+                completed_append_limit=runtime_session_config.completed_append_cache_size,
+            )
+
         self._shutdown_event = asyncio.Event()
         self._stages_shutdown = False
         self._fatal_error: str | None = None
@@ -286,7 +447,10 @@ class Orchestrator:
         already no-ops on ``scheduler_stats is None`` (which is what
         the upstream scheduler returns when its own log_stats is False),
         so this gate is mainly to keep the ``/metrics`` surface clean
-        when the user did not request stats.
+        when the user did not request stats. When stats are enabled, record()
+        must still receive IterationStats even on ticks where scheduler_stats
+        is None; upstream PrometheusStatLogger records token/request metrics
+        from iteration_stats independently of scheduler gauges.
         """
         self._running_counter = running_counter
         self._transfer_emitter = transfer_emitter
@@ -327,6 +491,17 @@ class Orchestrator:
             logger.exception("[Orchestrator] OmniPrometheusStatLogger init failed; metrics wrap disabled")
             self._stat_logger = None
 
+    @property
+    def duplex_sessions(self) -> DuplexSessionRuntimeManager:
+        if self.duplex_control_plane is None:
+            raise RuntimeError("duplex control plane is disabled")
+        return self.duplex_control_plane.sessions
+
+    def _require_duplex_control_plane(self) -> DuplexControlPlanePort:
+        if self.duplex_control_plane is None:
+            raise RuntimeError("duplex control plane is disabled")
+        return self.duplex_control_plane
+
     async def run(self) -> None:
         """Main entry point for the Orchestrator event loop."""
         logger.info("[Orchestrator] Starting event loop")
@@ -347,6 +522,8 @@ class Orchestrator:
             membership_watcher = self._membership.start()
 
         tasks = [request_task, output_task]
+        if self.duplex_control_plane is not None:
+            tasks.append(asyncio.create_task(self._duplex_reaper_loop(), name="orchestrator-duplex-reaper"))
         if membership_watcher is not None:
             tasks.append(membership_watcher)
 
@@ -361,6 +538,15 @@ class Orchestrator:
             # During teardown this is expected; the finally block handles
             # proper cleanup.  Do not re-raise.
             logger.info("[Orchestrator] Engine dead during shutdown: %s", e)
+            if self._fatal_error is None:
+                self._fatal_error = str(e) or "Stage engine died"
+            await self.rpc_async_queue.put(
+                ErrorMessage(
+                    error=self._fatal_error or str(e),
+                    fatal=True,
+                    stage_id=self._fatal_error_stage_id,
+                )
+            )
         except Exception:
             logger.exception("[Orchestrator] Fatal error in orchestrator tasks")
             raise
@@ -373,6 +559,8 @@ class Orchestrator:
                 await asyncio.gather(*tasks, return_exceptions=True)
             except Exception:
                 pass
+            if self.duplex_control_plane is not None:
+                await self.duplex_control_plane.shutdown()
 
             if self._fatal_error is not None:
                 await self._drain_pending_requests_on_fatal()
@@ -405,8 +593,12 @@ class Orchestrator:
                 await self._handle_streaming_update(msg)
             elif msg_type == "add_companion_request":
                 await self._handle_add_companion(msg)
+            elif self.duplex_control_plane is not None and self.duplex_control_plane.accepts(msg):
+                self.duplex_control_plane.dispatch(msg)
             elif msg_type == "abort":
                 await self._handle_abort(msg)
+            elif msg_type == "interaction":
+                await self._handle_interaction(msg)
             elif msg_type == "collective_rpc":
                 await self._handle_collective_rpc(msg)
             elif isinstance(msg, RegisterRemoteReplicaMessage):
@@ -432,6 +624,21 @@ class Orchestrator:
             else:
                 logger.warning("[Orchestrator] Unknown message type: %s", msg_type)
 
+    async def _duplex_reaper_loop(self) -> None:
+        while not self._shutdown_event.is_set():
+            try:
+                await asyncio.wait_for(
+                    self._shutdown_event.wait(),
+                    timeout=self._duplex_reaper_interval_s,
+                )
+            except TimeoutError:
+                plane = self.duplex_control_plane
+                if plane is not None:
+                    try:
+                        await plane.reap_expired()
+                    except Exception:
+                        logger.exception("[Orchestrator] Duplex expiry cleanup failed; retrying on next tick")
+
     async def _handle_add_request(self, msg: StageSubmissionMessage) -> None:
         """Handle an add_request message from the main thread."""
         stage_id = 0
@@ -466,8 +673,7 @@ class Orchestrator:
             mm_features=getattr(prompt, "mm_features", None),
         )
         self.request_states[request_id] = req_state
-        if self._running_counter is not None:
-            self._running_counter.increment()
+        self._register_running_request(req_state)
         req_state.streaming.enabled = bool(getattr(prompt, "resumable", False))
         req_state.stage_submit_ts[stage_id] = _time.time()
         enqueue_ts = msg.enqueue_ts
@@ -494,24 +700,16 @@ class Orchestrator:
         final_stage_id = msg.final_stage_id
         req_state = self.request_states.get(request_id)
         if req_state is None:
+            # Streaming updates always follow the first-chunk add_request
+            # through the same ordered submission queue, so an unknown id
+            # here can only mean the request already finished or was
+            # aborted (e.g. the client disconnected). Re-adding it would
+            # resurrect a headless session that keeps cycling through the
+            # stages with nobody consuming its outputs (issue #4271).
             logger.warning(
-                "[Orchestrator] streaming_update for unknown req=%s, falling back to add_request",
+                "[Orchestrator] streaming_update for unknown req=%s; dropping (request finished or aborted)",
                 request_id,
             )
-            fallback_msg = StageSubmissionMessage(
-                type="add_request",
-                request_id=msg.request_id,
-                prompt=msg.prompt,
-                original_prompt=msg.original_prompt,
-                output_prompt_text=msg.output_prompt_text,
-                sampling_params_list=msg.sampling_params_list,
-                final_stage_id=msg.final_stage_id,
-                final_output_stage_ids=msg.final_output_stage_ids,
-                preprocess_ms=msg.preprocess_ms,
-                request_timestamp=msg.request_timestamp,
-                enqueue_ts=msg.enqueue_ts,
-            )
-            await self._handle_add_request(fallback_msg)
             return
 
         if msg.sampling_params_list:
@@ -578,18 +776,57 @@ class Orchestrator:
     async def _handle_abort(self, msg: AbortRequestMessage) -> None:
         """Handle an abort message from the main thread."""
         request_ids = msg.request_ids
-        await self._cleanup_request_ids(
-            self._cfg_tracker.abort_parents(request_ids),
-            abort=True,
-        )
+        # _cleanup_request_ids is CFG-aware: it expands aborted parents to
+        # their companions and fails a deferred parent whose companion is
+        # aborted before its output arrived.
+        await self._cleanup_request_ids(list(request_ids), abort=True)
         logger.info("[Orchestrator] Aborted request(s) %s", request_ids)
 
+    async def _handle_interaction(self, msg: InteractionMessage) -> None:
+        """Handle a midway interaction for an active streaming diffusion request."""
+        stage_id = 0
+        request_id = msg.request_id
+        event_id = msg.interaction.get("event_id")
+        req_state = self.request_states.get(request_id)
+        if req_state is None:
+            logger.info("[Orchestrator] Dropping interaction for inactive req %s", request_id)
+            await self.output_async_queue.put(
+                ErrorMessage(
+                    error=f"No active request for interaction: {request_id}",
+                    fatal=False,
+                    request_id=request_id,
+                    event_id=event_id,
+                    stage_id=stage_id,
+                )
+            )
+            return
+
+        try:
+            await self.stage_pools[stage_id].submit_interaction(request_id, msg.interaction)
+        except Exception as exc:
+            logger.info(
+                "[Orchestrator] Failed interaction for req %s: %s",
+                request_id,
+                exc,
+                exc_info=True,
+            )
+            await self.output_async_queue.put(
+                ErrorMessage(
+                    error=f"Failed interaction for request {request_id}: {exc}",
+                    fatal=False,
+                    request_id=request_id,
+                    event_id=event_id,
+                    stage_id=stage_id,
+                )
+            )
+
     async def _abort_request_ids(self, request_ids: list[str]) -> None:
         """Forward abort requests to all stage pools."""
         if not request_ids:
             return
         for pool in self.stage_pools:
             await pool.abort_requests(request_ids)
+            pool.release_bindings(request_ids)
 
     def _release_request_bindings(self, request_ids: list[str]) -> None:
         """Release all stage-local route bindings for the given request ids."""
@@ -662,7 +899,7 @@ class Orchestrator:
             idle = True
             for stage_id in range(self.num_stages):
                 pool = self.stage_pools[stage_id]
-                for replica_id in pool.live_replica_ids():
+                for replica_id in pool.available_replica_ids():
                     if self._shutdown_event.is_set():
                         return
 
@@ -686,6 +923,17 @@ class Orchestrator:
                                 if req_state is None or not req_state.streaming.enabled:
                                     continue
                                 req_state.streaming.segment_finished = bool(getattr(eco, "is_segment_finished", False))
+                                req_state.streaming.segment_token_ids = (
+                                    self._coerce_int_list(getattr(eco, "new_token_ids", None))
+                                    if req_state.streaming.segment_finished
+                                    else []
+                                )
+                                raw_mm = self._completion_multimodal_output(eco, None)
+                                req_state.streaming.segment_output_metadata = (
+                                    dict(raw_mm)
+                                    if req_state.streaming.segment_finished and isinstance(raw_mm, dict)
+                                    else {}
+                                )
                                 req_state.streaming.new_prompt_len_snapshot = getattr(
                                     eco,
                                     "new_prompt_len_snapshot",
@@ -693,19 +941,17 @@ class Orchestrator:
                                 )
                                 if req_state.streaming.enabled:
                                     await self._apply_raw_terminal_stage_finish(stage_id, eco, req_state)
-                            # OmniSchedulerMixin.make_stats() already throttles
-                            # per-scheduler at 1 Hz, so raw_outputs.scheduler_stats
-                            # being non-None means this replica passed its own gate.
-                            # A second global throttle here would drop stats for
-                            # other (stage, replica) pairs in the same 1s window.
-                            record_stats = self._stat_logger is not None and raw_outputs.scheduler_stats is not None
-                            iteration_stats = IterationStats() if record_stats else None
+                            iteration_stats = (
+                                IterationStats() if (self._stat_logger is not None and raw_outputs.outputs) else None
+                            )
                             raw_output = await pool.process_llm_raw_outputs(
                                 replica_id,
                                 raw_outputs,
                                 iteration_stats=iteration_stats,
                             )
-                            if record_stats:
+                            if self._stat_logger is not None and (
+                                raw_outputs.scheduler_stats is not None or iteration_stats is not None
+                            ):
                                 self._stat_logger.record(
                                     raw_outputs.scheduler_stats,
                                     iteration_stats,
@@ -715,32 +961,62 @@ class Orchestrator:
                             raise
                         except EngineDeadError as e:
                             logger.error(
-                                "[Orchestrator] Stage-%s is dead: %s",
+                                "[Orchestrator] Stage-%s replica-%s is dead: %s",
                                 stage_id,
+                                replica_id,
                                 e,
                             )
-                            # TODO: Fault handling is intentionally fail-stop at
-                            # the orchestrator level today. If one replica in a
-                            # logical stage dies, we promote it to `_fatal_error`,
-                            # notify requests already admitted to that stage, and
-                            # re-raise so `run()` shuts down all stages. This is
-                            # conservative but means a single unhealthy replica in
-                            # a multi-replica deployment can take down otherwise
-                            # healthy replicas in other stages. Revisit this when
-                            # adding per-replica fault isolation / eviction.
-                            self._fatal_error = str(e)
-                            self._fatal_error_stage_id = stage_id
-                            for req_id, req_state in list(self.request_states.items()):
-                                if stage_id in req_state.stage_submit_ts:
+                            affected_request_ids = pool.mark_replica_unavailable(replica_id)
+                            closed_sessions = (
+                                self.duplex_control_plane.close_sessions_for_request_ids(
+                                    affected_request_ids,
+                                    abort=False,
+                                )
+                                if self.duplex_control_plane is not None
+                                else {}
+                            )
+                            for session_id, stale_request_ids in closed_sessions.items():
+                                affected_request_ids.extend(stale_request_ids)
+                                logger.warning(
+                                    "[Orchestrator] closed duplex session %s after stage-%s replica-%s died; "
+                                    "stale_request_ids=%s",
+                                    session_id,
+                                    stage_id,
+                                    replica_id,
+                                    stale_request_ids,
+                                )
+                            affected_request_ids = list(dict.fromkeys(affected_request_ids))
+                            if pool.available_replica_ids():
+                                for req_id in affected_request_ids:
                                     await self.output_async_queue.put(
                                         ErrorMessage(
                                             error=str(e),
-                                            fatal=True,
+                                            fatal=False,
                                             request_id=req_id,
                                             stage_id=stage_id,
                                         )
                                     )
-                                    self.request_states.pop(req_id, None)
+                                await self._cleanup_request_ids(
+                                    affected_request_ids,
+                                    close_duplex_sessions=True,
+                                )
+                                continue
+
+                            self._fatal_error = str(e)
+                            self._fatal_error_stage_id = stage_id
+                            for req_id in affected_request_ids:
+                                await self.output_async_queue.put(
+                                    ErrorMessage(
+                                        error=str(e),
+                                        fatal=True,
+                                        request_id=req_id,
+                                        stage_id=stage_id,
+                                    )
+                                )
+                            await self._cleanup_request_ids(
+                                affected_request_ids,
+                                close_duplex_sessions=True,
+                            )
                             self._shutdown_event.set()
                             raise
                         except Exception:
@@ -781,7 +1057,8 @@ class Orchestrator:
                 continue
 
             stage_metrics = None
-            if output.finished:
+            segment_finished = req_state.streaming.enabled and req_state.streaming.segment_finished
+            if output.finished or segment_finished:
                 stage_metrics = pool.build_stage_metrics(
                     [output],
                     submit_ts=req_state.stage_submit_ts.get(stage_id, _time.time()),
@@ -811,22 +1088,86 @@ class Orchestrator:
         await self._cleanup_request_ids(
             [parent_id, *self._cfg_tracker.cleanup_parent(parent_id)],
             abort=True,
+            close_duplex_sessions=True,
         )
 
     # ---- Shared helpers ----
 
-    async def _cleanup_request_ids(self, request_ids: list[str], *, abort: bool = False) -> None:
-        """Release pool bindings and logical request state for the given ids."""
+    async def _cleanup_request_ids(
+        self,
+        request_ids: list[str],
+        *,
+        abort: bool = False,
+        close_duplex_sessions: bool = False,
+    ) -> None:
+        """Release pool bindings and logical request state for the given ids.
+
+        CFG-aware: cleaning a parent releases its tracker state and pulls its
+        companions into the batch; cleaning a companion whose parent is NOT in
+        the batch and whose output never arrived fails that parent (its bundle
+        can never complete). Every teardown path (stage error, abort, replica
+        loss, membership unregister) funnels through here, so tracker state
+        cannot outlive its requests.
+        """
         if not request_ids:
             return
 
-        if abort:
-            await self._abort_request_ids(request_ids)
-        self._release_request_bindings(request_ids)
-        for request_id in request_ids:
-            self._pd_kv_params.pop(request_id, None)
-            if self.request_states.pop(request_id, None) is not None and self._running_counter is not None:
-                self._running_counter.decrement()
+        cleanup_ids = list(dict.fromkeys(request_ids))
+        batch = set(cleanup_ids)
+        orphaned_parents: dict[str, str] = {}
+        for rid in cleanup_ids:
+            pid = self._cfg_tracker.get_parent_id(rid)
+            if pid is not None and pid not in batch and not self._cfg_tracker.is_companion_done(rid):
+                orphaned_parents.setdefault(pid, rid)
+        for pid, cid in orphaned_parents.items():
+            deferred = self._cfg_tracker.pop_pending_parent(pid)
+            await self.output_async_queue.put(
+                ErrorMessage(
+                    request_id=pid,
+                    stage_id=deferred["stage_id"] if deferred is not None else None,
+                    error=f"CFG companion {cid} was aborted or lost before its outputs arrived",
+                )
+            )
+            batch.add(pid)
+            cleanup_ids.append(pid)
+        for rid in list(cleanup_ids):
+            for cid in self._cfg_tracker.cleanup_parent(rid):
+                if cid not in batch:
+                    batch.add(cid)
+                    cleanup_ids.append(cid)
+        closing_session_ids: list[str] = []
+        if close_duplex_sessions and self.duplex_control_plane is not None:
+            closed_sessions = self.duplex_control_plane.close_sessions_for_request_ids(
+                cleanup_ids,
+                abort=abort,
+                cleanup_in_progress=True,
+            )
+            closing_session_ids.extend(closed_sessions)
+            for session_id, stale_request_ids in closed_sessions.items():
+                logger.info(
+                    "[Orchestrator] closed duplex session %s while cleaning failed request ids %s",
+                    session_id,
+                    stale_request_ids,
+                )
+                cleanup_ids.extend(stale_request_ids)
+            cleanup_ids = list(dict.fromkeys(cleanup_ids))
+
+        try:
+            if abort:
+                await self._abort_request_ids(cleanup_ids)
+            self._release_request_bindings(cleanup_ids)
+            for request_id in cleanup_ids:
+                self._pd_kv_params.pop(request_id, None)
+                req_state = self.request_states.pop(request_id, None)
+                if req_state is not None and req_state.running_counter_registered and self._running_counter is not None:
+                    self._running_counter.decrement()
+                    req_state.running_counter_registered = False
+        except BaseException:
+            if closing_session_ids and self.duplex_control_plane is not None:
+                self.duplex_control_plane.defer_request_cleanups(closing_session_ids)
+            raise
+        if closing_session_ids and self.duplex_control_plane is not None:
+            self.duplex_control_plane.finalize_closed_sessions(closing_session_ids)
 
     async def _apply_raw_terminal_stage_finish(
         self,
@@ -873,6 +1214,34 @@ class Orchestrator:
         params.cfg_kv_request_ids = companion_request_ids
         return params
 
+    def _duplex_session_for_req_state(self, req_state: OrchestratorRequestState) -> DuplexSessionRuntimeState | None:
+        if self.duplex_control_plane is None:
+            return None
+        return self.duplex_control_plane.session_for_identity(req_state.duplex_identity)
+
+    def _record_duplex_stage_submission(
+        self,
+        stage_id: int,
+        request_id: str,
+        replica_id: int,
+        req_state: OrchestratorRequestState,
+    ) -> None:
+        del replica_id
+        identity = req_state.duplex_identity
+        session = self._duplex_session_for_req_state(req_state)
+        if identity is None or session is None:
+            return
+        req_state.duplex_stage_fences[stage_id] = identity.fence
+        session.bind_stage_request(stage_id, request_id, fence=identity.fence)
+        req_state.stage_submit_ts[stage_id] = _time.time()
+        self._register_running_request(req_state)
+
+    def _register_running_request(self, req_state: OrchestratorRequestState) -> None:
+        if req_state.running_counter_registered or self._running_counter is None:
+            return
+        self._running_counter.increment()
+        req_state.running_counter_registered = True
+
     async def _route_output(
         self,
         stage_id: int,
@@ -885,7 +1254,6 @@ class Orchestrator:
         req_id = output.request_id
         finished = output.finished
         submit_ts = req_state.stage_submit_ts.get(stage_id)
-
         # CFG companion: stash output so parent can bundle [parent, *companions]
         # into source_outputs for the bridge (e.g. thinker2imagegen).
         if finished and self._cfg_tracker.is_companion(req_id):
@@ -895,11 +1263,25 @@ class Orchestrator:
             return
 
         request_finished = False
-        if finished and self.stage_pools[stage_id].final_output:
+        if (
+            finished
+            and self.stage_pools[stage_id].final_output
+            and not (req_state.streaming.enabled and req_state.streaming.segment_finished)
+        ):
             req_state.finished_final_output_stage_ids.add(stage_id)
             final_output_stage_ids = req_state.final_output_stage_ids or {req_state.final_stage_id}
             request_finished = final_output_stage_ids.issubset(req_state.finished_final_output_stage_ids)
-        if self.stage_pools[stage_id].final_output:
+        # Duplex stage-0 segment boundaries are not client-visible outputs:
+        # direct decisions are emitted by the model runtime extension below,
+        # while spoken content flows through the next stage. Forwarding
+        # the raw stage-0 output as well injects one cumulative-text,
+        # no-audio message per unit that every downstream consumer must
+        # filter out again (the official implementation returns exactly one
+        # result per audio chunk).
+        is_duplex_stage0_segment = (
+            stage_id == 0 and self._is_duplex_session_request(req_state) and req_state.streaming.segment_finished
+        )
+        if self.stage_pools[stage_id].final_output and not is_duplex_stage0_segment:
             await self.output_async_queue.put(
                 OutputMessage(
                     request_id=req_id,
@@ -907,7 +1289,10 @@ class Orchestrator:
                     replica_id=replica_id,
                     engine_outputs=output,
                     metrics=stage_metrics,
-                    finished=request_finished,
+                    finished=(
+                        request_finished
+                        or (self._is_duplex_session_request(req_state) and req_state.streaming.segment_finished)
+                    ),
                     stage_submit_ts=submit_ts,
                 )
             )
@@ -928,10 +1313,22 @@ class Orchestrator:
                 self._pd_kv_params[req_id] = kv_params if isinstance(kv_params, dict) else dict(kv_params)
             req_state.pd_prefill_multimodal_output = getattr(output, "multimodal_output", None)
 
+        duplex_output_decision = self._duplex_output_decision(stage_id, output, req_state)
+        if duplex_output_decision is not None:
+            await self._emit_duplex_direct_output(
+                stage_id,
+                req_id,
+                output,
+                duplex_output_decision,
+                stage_metrics,
+                submit_ts,
+            )
+            return
+
         if (
             (finished or (req_state.streaming.enabled and req_state.streaming.segment_finished))
             and stage_id < req_state.final_stage_id
-            and not self.async_chunk
+            and (not self.async_chunk or not self._stage_receives_async_chunks(stage_id + 1))
             and (not self._next_stage_already_submitted(stage_id, req_state) or req_state.streaming.enabled)
         ):
             if (
@@ -941,6 +1338,12 @@ class Orchestrator:
             ):
                 self._cfg_tracker.defer_parent(req_id, output, stage_id)
             else:
+                stage_params = req_state.sampling_params_list[stage_id]
+                final_only_finished = (
+                    req_state.streaming.enabled
+                    and finished
+                    and getattr(stage_params, "output_kind", None) == RequestOutputKind.FINAL_ONLY
+                )
                 await self._forward_to_next_stage(
                     req_id,
                     stage_id,
@@ -948,9 +1351,14 @@ class Orchestrator:
                     req_state,
                     src_replica_id=replica_id,
                     is_streaming_session=req_state.streaming.enabled,
-                    is_final_update=False,
+                    is_final_update=final_only_finished,
                 )
-                if req_state.streaming.enabled and finished:
+                if (
+                    req_state.streaming.enabled
+                    and finished
+                    and not final_only_finished
+                    and not self._is_duplex_session_request(req_state)
+                ):
                     # For streaming sessions, send the terminal (resumable=False) update only on a finish
                     await self._forward_to_next_stage(
                         req_id,
@@ -962,12 +1370,18 @@ class Orchestrator:
                         is_final_update=True,
                     )
 
-        if request_finished:
+        if request_finished and not self._is_duplex_session_request(req_state):
             await self._cleanup_request_ids([req_id, *self._cfg_tracker.cleanup_parent(req_id)])
 
     def _next_stage_already_submitted(self, stage_id: int, req_state: OrchestratorRequestState) -> bool:
         return (stage_id + 1) in req_state.stage_submit_ts
 
+    def _stage_receives_async_chunks(self, stage_id: int) -> bool:
+        """Whether a stage's connector supplies its runtime inputs."""
+        pool = self.stage_pools[stage_id]
+        model_config = getattr(pool.stage_vllm_config, "model_config", None)
+        return stage_receives_chunks(model_config)
+
     def _get_stage_input_processor(self, stage_id: int) -> Any:
         processor = self._stage_input_processors.get(stage_id)
         if processor is None:
@@ -1039,6 +1453,137 @@ class Orchestrator:
         request.external_req_id = req_id
         return request
 
+    @staticmethod
+    def _duplex_output_context(
+        req_state: OrchestratorRequestState,
+        *,
+        stage_id: int | None = None,
+    ) -> DuplexOutputContext | None:
+        identity = req_state.duplex_identity
+        if identity is None:
+            return None
+        from vllm_omni.experimental.fullduplex.engine.contracts import (
+            DuplexOutputContext,
+            DuplexRequestIdentity,
+        )
+
+        fence = req_state.duplex_stage_fences.get(stage_id, identity.fence) if stage_id is not None else identity.fence
+        return DuplexOutputContext(
+            identity=DuplexRequestIdentity(
+                session_id=identity.session_id,
+                fence=fence,
+            ),
+            final_stage_id=req_state.final_stage_id,
+            segment_finished=req_state.streaming.enabled and req_state.streaming.segment_finished,
+            segment_token_ids=tuple(req_state.streaming.segment_token_ids),
+            segment_output_metadata=req_state.streaming.segment_output_metadata,
+        )
+
+    @staticmethod
+    def _is_duplex_session_request(req_state: OrchestratorRequestState) -> bool:
+        return req_state.duplex_identity is not None
+
+    @staticmethod
+    def _duplex_fence_for_req_state(
+        req_state: OrchestratorRequestState,
+        *,
+        stage_id: int | None = None,
+    ) -> DuplexFence | None:
+        context = Orchestrator._duplex_output_context(req_state, stage_id=stage_id)
+        return context.identity.fence if context is not None else None
+
+    def _duplex_output_decision(
+        self,
+        stage_id: int,
+        output: Any,
+        req_state: OrchestratorRequestState,
+    ) -> DuplexOutputDecision | None:
+        if self.duplex_control_plane is None:
+            return None
+        context = self._duplex_output_context(req_state, stage_id=stage_id)
+        decision = self.duplex_control_plane.decide_output(
+            stage_id,
+            output,
+            context,
+        )
+        return decision
+
+    async def _emit_duplex_direct_output(
+        self,
+        stage_id: int,
+        req_id: str,
+        output: Any,
+        decision: DuplexOutputDecision,
+        stage_metrics: Any,
+        submit_ts: float | None,
+    ) -> None:
+        action = getattr(decision.action, "value", decision.action)
+        if action != "direct_response":
+            raise ValueError(f"Unsupported duplex output action: {action}")
+        from vllm_omni.experimental.fullduplex.output import attach_duplex_output_decision
+
+        engine_output = attach_duplex_output_decision(
+            OmniRequestOutput(
+                request_id=req_id,
+                finished=True,
+                stage_id=stage_id,
+                final_output_type=decision.final_output_type,
+                request_output=output,
+            ),
+            decision,
+        )
+        await self.output_async_queue.put(
+            OutputMessage(
+                request_id=req_id,
+                stage_id=stage_id,
+                engine_outputs=engine_output,
+                metrics=stage_metrics,
+                finished=True,
+                stage_submit_ts=submit_ts,
+            )
+        )
+
+    @staticmethod
+    def _completion_multimodal_output(output: Any, completion: Any) -> dict[str, Any]:
+        mm_output = getattr(output, "multimodal_output", None)
+        if isinstance(mm_output, dict):
+            return mm_output
+        mm_output = getattr(completion, "multimodal_output", None) if completion is not None else None
+        return mm_output if isinstance(mm_output, dict) else {}
+
+    @classmethod
+    def _coerce_int_list(cls, value: Any) -> list[int]:
+        if value is None:
+            return []
+        if hasattr(value, "detach"):
+            try:
+                value = value.detach().cpu().reshape(-1).tolist()
+            except Exception:
+                return []
+        if not isinstance(value, (list, tuple)):
+            return []
+        out: list[int] = []
+        for item in value:
+            token_id = cls._coerce_int(item)
+            if token_id is not None:
+                out.append(token_id)
+        return out
+
+    @staticmethod
+    def _coerce_int(value: Any) -> int | None:
+        if hasattr(value, "detach"):
+            try:
+                value = value.detach().cpu().reshape(-1)
+                if value.numel() == 0:
+                    return None
+                value = value[0].item()
+            except Exception:
+                return None
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
     async def _handle_cfg_companion_ready(self, req_id: str) -> None:
         """Mark a CFG companion as done; if all companions are done, flush deferred parent."""
         parent_id = self._cfg_tracker.on_companion_completed(req_id)
@@ -1083,7 +1628,12 @@ class Orchestrator:
             if req_state is None:
                 continue
             if self._cfg_tracker.is_companion(req_id):
-                await self._handle_cfg_companion_ready(req_id)
+                # kv_ready only says the companion's KV hit the connector; its
+                # processed output has not been stashed yet. Counting it as
+                # done here let the parent pass the all_companions_done gate
+                # and dispatch with 0/N companion outputs (degraded CFG).
+                # Done-marking now happens solely on the processed-output path
+                # in _route_output, after set_companion_output.
                 continue
             if stage_id >= req_state.final_stage_id:
                 continue
@@ -1198,16 +1748,48 @@ class Orchestrator:
         _t_submit_start = _time.perf_counter()
 
         if next_pool.stage_type == "diffusion":
-            companion_outputs = self._cfg_tracker.pop_companion_outputs(req_id)
+            # Gate: never dispatch with an incomplete CFG bundle. Checked
+            # non-destructively BEFORE popping — a pop-then-redefer would lose
+            # the partial outputs. all_companions_done is trustworthy here
+            # because done-marking happens only after set_companion_output.
+            if self._cfg_tracker.has_companions(req_id) and not self._cfg_tracker.all_companions_done(req_id):
+                self._cfg_tracker.defer_parent(req_id, output, src_stage_id)
+                logger.info(
+                    "[Orchestrator] req=%s: CFG companion outputs not all stashed yet; re-deferring parent",
+                    req_id,
+                )
+                return
+            # Peek, don't pop: outputs stay stashed until cleanup_parent so a
+            # streaming re-submission bundles the complete set again rather
+            # than an empty one.
+            companion_outputs = self._cfg_tracker.get_companion_outputs(req_id)
             expected = len(self._cfg_tracker.get_companion_request_ids(req_id))
             if expected > len(companion_outputs):
-                logger.warning(
-                    "[Orchestrator] req=%s: only %d/%d CFG companion outputs arrived; "
-                    "downstream CFG conditioning may degrade",
+                # Companions are done but outputs are missing — inconsistent
+                # tracker state (should be unreachable with peek semantics).
+                # Fail the request rather than degrade CFG conditioning.
+                logger.error(
+                    "[Orchestrator] req=%s: only %d/%d CFG companion outputs available; "
+                    "failing the request instead of dispatching degraded CFG",
                     req_id,
                     len(companion_outputs),
                     expected,
                 )
+                await self.output_async_queue.put(
+                    ErrorMessage(
+                        request_id=req_id,
+                        stage_id=src_stage_id,
+                        error=(
+                            f"CFG companion outputs incomplete ({len(companion_outputs)}/{expected}); "
+                            "request aborted to avoid degraded CFG conditioning"
+                        ),
+                    )
+                )
+                await self._cleanup_request_ids(
+                    [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
+                    abort=True,
+                )
+                return
             diffusion_source_outputs = [output, *companion_outputs]
             if next_client.custom_process_input_func is not None:
                 _t_ar2d = _time.perf_counter()
@@ -1293,9 +1875,9 @@ class Orchestrator:
                 diffusion_prompt = req_state.prompt
 
             if already_submitted:
-                await next_pool.submit_update(req_id, req_state, diffusion_prompt)
+                replica_id = await next_pool.submit_update(req_id, req_state, diffusion_prompt)
             else:
-                await next_pool.submit_initial(
+                replica_id = await next_pool.submit_initial(
                     req_id,
                     req_state,
                     diffusion_prompt,
@@ -1307,6 +1889,12 @@ class Orchestrator:
                     },
                     params_override=self._maybe_clone_diffusion_params_for_cfg(req_id, params),
                 )
+            self._record_duplex_stage_submission(
+                next_logical,
+                req_id,
+                replica_id,
+                req_state,
+            )
             req_state.stage_submit_ts[next_logical] = _time.time()
             _tx_ms = (_time.perf_counter() - _t_submit_start) * 1000.0
             self._emit_tx_edge(
@@ -1351,9 +1939,15 @@ class Orchestrator:
                 )
                 request.external_req_id = request.request_id
                 if already_submitted:
-                    await next_pool.submit_update(req_id, req_state, request)
+                    replica_id = await next_pool.submit_update(req_id, req_state, request)
                 else:
-                    await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
+                    replica_id = await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
+                self._record_duplex_stage_submission(
+                    next_logical,
+                    req_id,
+                    replica_id,
+                    req_state,
+                )
 
             req_state.stage_submit_ts[next_logical] = _time.time()
             _tx_ms = (_time.perf_counter() - _t_submit_start) * 1000.0
@@ -1373,6 +1967,13 @@ class Orchestrator:
                 {},
             )[req_id] = req_state.pd_prefill_multimodal_output
 
+        previous_decoder = req_state.streaming.source_token_decoder
+        source_processor = self.stage_pools[src_stage_id].output_processor
+        tokenizer = getattr(source_processor, "tokenizer", None)
+        decode = getattr(tokenizer, "decode", None)
+        if callable(decode):
+            req_state.streaming.source_token_decoder = decode
+
         try:
             next_inputs = next_client.process_engine_inputs(
                 source_outputs,
@@ -1386,6 +1987,8 @@ class Orchestrator:
                 next_logical,
             )
             raise
+        finally:
+            req_state.streaming.source_token_decoder = previous_decoder
 
         if not next_inputs:
             if not getattr(output, "finished", False):
@@ -1403,7 +2006,7 @@ class Orchestrator:
             terminal_output = _build_terminal_empty_output(
                 req_id,
                 final_output_type=final_output_type,
-                audio_sample_rate=_infer_stage_audio_sample_rate(final_pool),
+                audio_sample_rate=final_pool._infer_audio_sample_rate(),
             )
             submit_ts = _time.time()
             req_state.stage_submit_ts[final_stage_id] = submit_ts
@@ -1446,9 +2049,15 @@ class Orchestrator:
             )
 
             if already_submitted:
-                await next_pool.submit_update(req_id, req_state, request)
+                replica_id = await next_pool.submit_update(req_id, req_state, request)
             else:
-                await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
+                replica_id = await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
+            self._record_duplex_stage_submission(
+                next_logical,
+                req_id,
+                replica_id,
+                req_state,
+            )
 
         req_state.stage_submit_ts[next_logical] = _time.time()
         _tx_ms = (_time.perf_counter() - _t_submit_start) * 1000.0
@@ -1482,12 +2091,17 @@ class Orchestrator:
         for next_stage_id in range(1, req_state.final_stage_id + 1):
             next_pool = self.stage_pools[next_stage_id]
             params = req_state.sampling_params_list[next_stage_id]
+            if not self._stage_receives_async_chunks(next_stage_id):
+                # Outgoing-only stages receive their first real input from the
+                # orchestrator. Pre-submitting a placeholder lets it race and
+                # execute before that conditioning payload arrives.
+                continue
 
             req_state.stage_submit_ts[next_stage_id] = _time.time()
             _t_submit_start = _time.perf_counter()
 
             if next_pool.stage_type == "diffusion":
-                await next_pool.submit_initial(
+                replica_id = await next_pool.submit_initial(
                     request_id,
                     req_state,
                     req_state.prompt,
@@ -1526,12 +2140,18 @@ class Orchestrator:
                     resumable=downstream_resumable,
                 )
                 request.external_req_id = request.request_id
-                await next_pool.submit_initial(
+                replica_id = await next_pool.submit_initial(
                     request_id,
                     req_state,
                     request,
                     prompt_text=None,
                 )
+            self._record_duplex_stage_submission(
+                next_stage_id,
+                request_id,
+                replica_id,
+                req_state,
+            )
 
             # async_chunk pre-submit fires per stage edge (N-1 -> N). Source
             # replica is stage 0's bound replica (single-replica thinker in
diff --git a/vllm_omni/engine/rpc_result_router.py b/vllm_omni/engine/rpc_result_router.py
new file mode 100644
index 000000000..516b36f16
--- /dev/null
+++ b/vllm_omni/engine/rpc_result_router.py
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import queue
+import threading
+from typing import TypeAlias
+
+from vllm.logger import init_logger
+
+from vllm_omni.engine.messages import (
+    EngineQueueMessage,
+    ErrorMessage,
+)
+
+logger = init_logger(__name__)
+
+RpcCorrelationKey: TypeAlias = tuple[str, str]
+RpcWaiter: TypeAlias = queue.Queue[EngineQueueMessage]
+
+
+class RpcResultRouter:
+    """Single consumer that dispatches shared RPC results by correlation ID."""
+
+    def __init__(self, source_queue) -> None:
+        self._source_queue = source_queue
+        self._pending: dict[RpcCorrelationKey, RpcWaiter] = {}
+        self._lock = threading.Lock()
+        self._stopped = threading.Event()
+        self._terminal_error: ErrorMessage | None = None
+        self._thread = threading.Thread(
+            target=self._run,
+            daemon=True,
+            name="omni-rpc-result-router",
+        )
+        self._thread.start()
+
+    def register(self, key: RpcCorrelationKey) -> RpcWaiter:
+        waiter: RpcWaiter = queue.Queue(maxsize=1)
+        with self._lock:
+            if self._stopped.is_set():
+                raise RuntimeError("RPC result router is closed")
+            if self._terminal_error is not None:
+                raise RuntimeError(self._terminal_error.error)
+            if key in self._pending:
+                raise RuntimeError(f"duplicate pending RPC correlation key: {key!r}")
+            self._pending[key] = waiter
+        return waiter
+
+    def unregister(self, key: RpcCorrelationKey, waiter: RpcWaiter) -> None:
+        with self._lock:
+            if self._pending.get(key) is waiter:
+                self._pending.pop(key, None)
+
+    def close(self) -> None:
+        if self._stopped.is_set():
+            return
+        self._stopped.set()
+        self._broadcast_error(ErrorMessage(error="RPC result router closed", fatal=True))
+        self._thread.join(timeout=1.0)
+
+    def _run(self) -> None:
+        while not self._stopped.is_set():
+            try:
+                message = self._source_queue.get(timeout=0.1)
+            except queue.Empty:
+                continue
+            except Exception as exc:
+                if not self._stopped.is_set():
+                    logger.exception("RPC result router source queue failed")
+                    self._broadcast_error(ErrorMessage(error=str(exc), fatal=True))
+                return
+
+            if isinstance(message, ErrorMessage):
+                if message.fatal:
+                    self._broadcast_error(message)
+                else:
+                    logger.warning(
+                        "Dropping uncorrelated non-fatal RPC error request_id=%s stage_id=%s: %s",
+                        message.request_id,
+                        message.stage_id,
+                        message.error,
+                    )
+                continue
+            key = self._correlation_key(message)
+            if key is None:
+                logger.warning(
+                    "Dropping unexpected RPC result message type=%s",
+                    getattr(message, "type", type(message).__name__),
+                )
+                continue
+            with self._lock:
+                waiter = self._pending.pop(key, None)
+            if waiter is None:
+                logger.warning("Dropping late or unknown RPC result correlation_key=%s", key)
+                continue
+            waiter.put_nowait(message)
+
+    def _broadcast_error(self, message: ErrorMessage) -> None:
+        with self._lock:
+            if message.fatal:
+                self._terminal_error = message
+            waiters = list(self._pending.values())
+            self._pending.clear()
+        for waiter in waiters:
+            try:
+                waiter.put_nowait(message)
+            except queue.Full:
+                pass
+
+    @staticmethod
+    def _correlation_key(message: EngineQueueMessage) -> RpcCorrelationKey | None:
+        key = getattr(message, "rpc_correlation_key", None)
+        if not isinstance(key, tuple) or len(key) != 2 or not all(isinstance(part, str) and part for part in key):
+            return None
+        return key
+
+
+class CorrelatedRpcClient:
+    """Own request submission and correlated result waiting as one lifecycle."""
+
+    def __init__(self, request_queue, result_queue) -> None:
+        self._request_queue = request_queue
+        self._router = RpcResultRouter(result_queue)
+
+    def execute(
+        self,
+        key: RpcCorrelationKey,
+        message: EngineQueueMessage,
+        *,
+        timeout: float | None,
+        timeout_message: str,
+        block_on_submit: bool = False,
+    ) -> EngineQueueMessage:
+        waiter = self._router.register(key)
+        try:
+            if block_on_submit:
+                self._request_queue.put(message)
+            else:
+                self._request_queue.put_nowait(message)
+            try:
+                result = waiter.get(timeout=timeout)
+            except queue.Empty as exc:
+                raise TimeoutError(timeout_message) from exc
+            if isinstance(result, ErrorMessage):
+                raise RuntimeError(result.error)
+            return result
+        finally:
+            self._router.unregister(key, waiter)
+
+    def close(self) -> None:
+        self._router.close()
+
+
+__all__ = [
+    "CorrelatedRpcClient",
+    "RpcCorrelationKey",
+    "RpcResultRouter",
+    "RpcWaiter",
+]
diff --git a/vllm_omni/engine/stage_client.py b/vllm_omni/engine/stage_client.py
index 6db090955..74f65d8c2 100644
--- a/vllm_omni/engine/stage_client.py
+++ b/vllm_omni/engine/stage_client.py
@@ -8,7 +8,12 @@ from typing import TYPE_CHECKING, Any, Protocol
 if TYPE_CHECKING:
     from vllm.v1.engine import EngineCoreOutput, EngineCoreOutputs, EngineCoreRequest
 
-    from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniPromptType, OmniTokensPrompt
+    from vllm_omni.inputs.data import (
+        OmniDiffusionSamplingParams,
+        OmniInteractionPrompt,
+        OmniPromptType,
+        OmniTokensPrompt,
+    )
     from vllm_omni.outputs import OmniRequestOutput
 
 from vllm_omni.inputs.data import OmniSamplingParams
@@ -101,3 +106,10 @@ class StagePoolDiffusionClient(StagePoolClient, Protocol):
     ) -> None: ...
 
     def get_diffusion_output_nowait(self) -> OmniRequestOutput | None: ...
+
+    async def submit_interaction_async(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+        timeout: float | None = None,
+    ) -> Any: ...
diff --git a/vllm_omni/engine/stage_engine_core_proc.py b/vllm_omni/engine/stage_engine_core_proc.py
index e3f75d9e3..3ac719a6b 100644
--- a/vllm_omni/engine/stage_engine_core_proc.py
+++ b/vllm_omni/engine/stage_engine_core_proc.py
@@ -30,7 +30,10 @@ from vllm.v1.engine.utils import (
 
 from vllm_omni.distributed.omni_coordinator import create_stage_coord_client
 from vllm_omni.engine import OmniEngineCoreRequest
-from vllm_omni.engine.stage_init_utils import set_death_signal
+from vllm_omni.engine.stage_init_utils import (
+    maybe_apply_audex_cfg_patches,
+    set_death_signal,
+)
 
 logger = init_logger(__name__)
 
@@ -51,6 +54,13 @@ class StageEngineCoreProc(EngineCoreProc):
     ``EngineCoreProc.run_engine_core()``.
     """
 
+    def preprocess_add_request(self, request: OmniEngineCoreRequest) -> tuple[Any, int]:
+        """Preserve omni payloads when vLLM builds its scheduler request."""
+        scheduler_request, current_wave = super().preprocess_add_request(request)
+        scheduler_request.additional_information = request.additional_information
+        scheduler_request.external_req_id = getattr(request, "external_req_id", request.request_id)
+        return scheduler_request, current_wave
+
     @staticmethod
     def run_stage_core(
         *args: Any,
@@ -124,6 +134,10 @@ class StageEngineCoreProc(EngineCoreProc):
                 _vllm_engine_core_module.EngineCoreRequest,
             )
 
+            # Audex CFG scheduler patches must land before EngineCore builds
+            # its Scheduler; gated on the stage's logits_processors config.
+            maybe_apply_audex_cfg_patches(kwargs.get("vllm_config"))
+
             engine_core = StageEngineCoreProc(
                 *args,
                 engine_index=dp_rank,
diff --git a/vllm_omni/engine/stage_engine_startup.py b/vllm_omni/engine/stage_engine_startup.py
index 7a55bb93f..cb80c82ac 100644
--- a/vllm_omni/engine/stage_engine_startup.py
+++ b/vllm_omni/engine/stage_engine_startup.py
@@ -183,6 +183,10 @@ class OmniMasterServer:
         # seeded with the registration port (and coordinator ROUTER port) that
         # are already bound on the same host.
         self._allocated_ports: set[int] = set()
+        # Keep route ports bound until their ZMQ owners are ready to bind them.
+        # Recording only the integer leaves a race with unrelated startup
+        # consumers (notably NCCL's own ephemeral-port selection).
+        self._port_reservations: dict[int, socket.socket] = {}
         if master_port:
             self._allocated_ports.add(int(master_port))
         # Coordinator ROUTER address echoed back in every registration reply
@@ -283,9 +287,11 @@ class OmniMasterServer:
         ``get_open_ports_list`` dedups only within its own call, so we redraw any
         port that collides with one already recorded in ``self._allocated_ports``
         (registration/coordinator ports plus every previously-allocated route
-        port) and register the winners before returning. Callers already hold the
-        relevant allocation context (``__init__`` is single-threaded;
-        registration holds ``self._alloc_lock``).
+        port). Each winner remains OS-bound until its ZMQ owner is ready, so
+        another startup subsystem cannot claim it in the allocation-to-bind
+        window. Callers already hold the relevant allocation context
+        (``__init__`` is single-threaded; registration holds
+        ``self._alloc_lock``).
         """
         picked: list[int] = []
         # Bounded retry budget so a pathological host (near port exhaustion)
@@ -294,7 +300,17 @@ class OmniMasterServer:
             for port in get_open_ports_list(count=count - len(picked)):
                 if port in self._allocated_ports:
                     continue
+                reservation = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                try:
+                    # Reserve on every local interface. The advertised address
+                    # can be a routable interface IP, but wildcard binding also
+                    # protects the route from local NCCL/socket allocations.
+                    reservation.bind(("", port))
+                except OSError:
+                    reservation.close()
+                    continue
                 self._allocated_ports.add(port)
+                self._port_reservations[port] = reservation
                 picked.append(port)
                 if len(picked) == count:
                     return picked
@@ -303,6 +319,33 @@ class OmniMasterServer:
             f"(host={self._address}); {len(self._allocated_ports)} already in use."
         )
 
+    def release_route_port_reservations(
+        self,
+        stage_id: int,
+        replica_id: int = 0,
+        *,
+        handshake: bool = True,
+        data: bool = True,
+    ) -> None:
+        """Release reserved route ports immediately before their ZMQ binds."""
+        alloc = self.get_allocation(stage_id, replica_id)
+        ports: list[int] = []
+        if handshake:
+            handshake_port = _port_from_zmq_address(alloc.handshake_bind_address)
+            if handshake_port is not None:
+                ports.append(handshake_port)
+        if data:
+            for address in (alloc.input_bind_address, alloc.output_bind_address):
+                port = _port_from_zmq_address(address)
+                if port is not None:
+                    ports.append(port)
+
+        with self._alloc_lock:
+            for port in ports:
+                reservation = self._port_reservations.pop(port, None)
+                if reservation is not None:
+                    reservation.close()
+
     def _next_free_replica_id(self, stage_id: int) -> int:
         """Return the next replica id to assign for an auto-assign registration.
 
@@ -437,6 +480,11 @@ class OmniMasterServer:
         self._stop_event.set()
         if self._thread is not None:
             self._thread.join(timeout=10)
+        with self._alloc_lock:
+            reservations = list(self._port_reservations.values())
+            self._port_reservations.clear()
+        for reservation in reservations:
+            reservation.close()
 
     # ------------------------------------------------------------------
     # Internal server logic
@@ -771,20 +819,34 @@ def connect_remote_engine_cores(
 
     handshake_bind_address = omni_master_server.get_allocation(stage_id, replica_id=replica_id).handshake_bind_address
 
-    with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
-        yield StageReplicaResources(
-            coordinator=coordinator,
-            addresses=addresses,
-        )
-        wait_for_engine_startup(
-            handshake_socket,
-            addresses,
-            engines_to_handshake,
-            vllm_config.parallel_config,
-            False,  # coordinated_dp
-            vllm_config.cache_config,
-            None,  # proc_manager (remote — no local procs)
-            None,  # coord_process
+    omni_master_server.release_route_port_reservations(
+        stage_id,
+        replica_id,
+        handshake=True,
+        data=False,
+    )
+    try:
+        with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
+            yield StageReplicaResources(
+                coordinator=coordinator,
+                addresses=addresses,
+            )
+            wait_for_engine_startup(
+                handshake_socket,
+                addresses,
+                engines_to_handshake,
+                vllm_config.parallel_config,
+                False,  # coordinated_dp
+                vllm_config.cache_config,
+                None,  # proc_manager (remote — no local procs)
+                None,  # coord_process
+            )
+    finally:
+        omni_master_server.release_route_port_reservations(
+            stage_id,
+            replica_id,
+            handshake=False,
+            data=True,
         )
 
 
@@ -802,17 +864,31 @@ def connect_remote_diffusion_proc(
     ).handshake_bind_address
 
     logger.info("Waiting for remote diffusion proc for stage %d replica %d", stage_id, replica_id)
-    with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
-        yield StageReplicaResources(addresses=addresses)
-        wait_for_engine_startup(
-            handshake_socket,
-            addresses,
-            [CoreEngine(index=0, local=False)],
-            _single_diffusion_parallel_config(local_client=False),
-            False,
-            None,
-            None,
-            None,
+    omni_master_server.release_route_port_reservations(
+        stage_id,
+        replica_id,
+        handshake=True,
+        data=False,
+    )
+    try:
+        with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
+            yield StageReplicaResources(addresses=addresses)
+            wait_for_engine_startup(
+                handshake_socket,
+                addresses,
+                [CoreEngine(index=0, local=False)],
+                _single_diffusion_parallel_config(local_client=False),
+                False,
+                None,
+                None,
+                None,
+            )
+    finally:
+        omni_master_server.release_route_port_reservations(
+            stage_id,
+            replica_id,
+            handshake=False,
+            data=True,
         )
 
 
@@ -918,49 +994,63 @@ def _launch_omni_core_engines(
     # Bind the pre-allocated handshake socket for this stage.
     handshake_bind_address = omni_master_server.get_allocation(stage_id, replica_id=replica_id).handshake_bind_address
 
-    with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
-        if omni_coordinator_address is not None:
-            # Use the omni subclass so each spawned subprocess instantiates
-            # an OmniCoordClientForStage and heartbeats to the coordinator.
-            from vllm_omni.engine.stage_engine_core_proc_manager import StageEngineCoreProcManager
+    omni_master_server.release_route_port_reservations(
+        stage_id,
+        replica_id,
+        handshake=True,
+        data=False,
+    )
+    try:
+        with zmq_socket_ctx(handshake_bind_address, zmq.ROUTER, bind=True) as handshake_socket:
+            if omni_coordinator_address is not None:
+                # Use the omni subclass so each spawned subprocess instantiates
+                # an OmniCoordClientForStage and heartbeats to the coordinator.
+                from vllm_omni.engine.stage_engine_core_proc_manager import StageEngineCoreProcManager
 
-            with scoped_spawn_device_env(stage_visible_devices, spawn_device_lock):
-                local_engine_manager: CoreEngineProcManager = StageEngineCoreProcManager(
-                    local_engine_count=local_engine_count,
-                    start_index=start_index,
-                    local_start_index=local_start_index,
-                    vllm_config=vllm_config,
-                    local_client=True,
-                    handshake_address=handshake_address,
-                    executor_class=executor_class,
-                    log_stats=log_stats,
-                    omni_stage_id=stage_id,
-                    omni_coordinator_address=omni_coordinator_address,
-                    omni_replica_base_id=replica_id,
-                )
-        else:
-            with scoped_spawn_device_env(stage_visible_devices, spawn_device_lock):
-                local_engine_manager = CoreEngineProcManager(
-                    local_engine_count=local_engine_count,
-                    start_index=start_index,
-                    local_start_index=local_start_index,
-                    vllm_config=vllm_config,
-                    local_client=True,
-                    handshake_address=handshake_address,
-                    executor_class=executor_class,
-                    log_stats=log_stats,
-                )
+                with scoped_spawn_device_env(stage_visible_devices, spawn_device_lock):
+                    local_engine_manager: CoreEngineProcManager = StageEngineCoreProcManager(
+                        local_engine_count=local_engine_count,
+                        start_index=start_index,
+                        local_start_index=local_start_index,
+                        vllm_config=vllm_config,
+                        local_client=True,
+                        handshake_address=handshake_address,
+                        executor_class=executor_class,
+                        log_stats=log_stats,
+                        omni_stage_id=stage_id,
+                        omni_coordinator_address=omni_coordinator_address,
+                        omni_replica_base_id=replica_id,
+                    )
+            else:
+                with scoped_spawn_device_env(stage_visible_devices, spawn_device_lock):
+                    local_engine_manager = CoreEngineProcManager(
+                        local_engine_count=local_engine_count,
+                        start_index=start_index,
+                        local_start_index=local_start_index,
+                        vllm_config=vllm_config,
+                        local_client=True,
+                        handshake_address=handshake_address,
+                        executor_class=executor_class,
+                        log_stats=log_stats,
+                    )
 
-        yield local_engine_manager, coordinator, addresses
-        wait_for_engine_startup(
-            handshake_socket,
-            addresses,
-            engines_to_handshake,
-            parallel_config,
-            parallel_config.data_parallel_size > 1 and vllm_config.model_config.is_moe,
-            vllm_config.cache_config,
-            local_engine_manager,
-            coordinator.proc if coordinator else None,
+            yield local_engine_manager, coordinator, addresses
+            wait_for_engine_startup(
+                handshake_socket,
+                addresses,
+                engines_to_handshake,
+                parallel_config,
+                parallel_config.data_parallel_size > 1 and vllm_config.model_config.is_moe,
+                vllm_config.cache_config,
+                local_engine_manager,
+                coordinator.proc if coordinator else None,
+            )
+    finally:
+        omni_master_server.release_route_port_reservations(
+            stage_id,
+            replica_id,
+            handshake=False,
+            data=True,
         )
 
 
@@ -1347,7 +1437,10 @@ def launch_headless_diffusion_replicas(
         stage_id,
     )
 
-    metadata = stage_init_utils.extract_stage_metadata(stage_cfg)
+    # Headless diffusion startup and its downstream helpers still consume the
+    # legacy StageConfig shape; switch this with the coordinated RFC #4021
+    # stage-init cutover.
+    metadata = stage_init_utils.extract_legacy_stage_metadata(stage_cfg)
     if omni_conn_cfg:
         inject_omni_kv_config(stage_cfg, omni_conn_cfg, omni_from, omni_to)
     # Headless single-stage launch must still infer cross-stage TP topology
@@ -1445,6 +1538,12 @@ def launch_diffusion_stage_replica(
             omni_stage_config=stage_config,
             replica_id=replica_id,
         )
+        omni_master_server.release_route_port_reservations(
+            metadata.stage_id,
+            replica_id,
+            handshake=True,
+            data=False,
+        )
         proc_manager = stage_diffusion_proc.StageDiffusionProcManager(
             model=model,
             od_config=od_config,
@@ -1458,6 +1557,12 @@ def launch_diffusion_stage_replica(
             omni_stage_id=metadata.stage_id,
             omni_replica_id=replica_id,
         )
+        omni_master_server.release_route_port_reservations(
+            metadata.stage_id,
+            replica_id,
+            handshake=False,
+            data=True,
+        )
         client = StageDiffusionClient.from_addresses(
             metadata,
             request_address=proc_manager.addresses.inputs[0],
@@ -1471,6 +1576,10 @@ def launch_diffusion_stage_replica(
             lock_fds=lock_fds,
         )
     except Exception:
+        omni_master_server.release_route_port_reservations(
+            metadata.stage_id,
+            replica_id,
+        )
         if proc_manager is not None:
             proc_manager.shutdown()
         if lock_fds:
diff --git a/vllm_omni/engine/stage_init_utils.py b/vllm_omni/engine/stage_init_utils.py
index d43160895..e8284ba68 100644
--- a/vllm_omni/engine/stage_init_utils.py
+++ b/vllm_omni/engine/stage_init_utils.py
@@ -8,6 +8,7 @@ out of StageEngineCoreClient into reusable functions.
 
 from __future__ import annotations
 
+import copy
 import fcntl
 import importlib
 import multiprocessing as mp
@@ -15,7 +16,7 @@ import os
 import time
 from collections.abc import Callable, Generator, Sequence
 from contextlib import contextmanager
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, fields, replace
 from typing import Any, Literal, cast
 
 from vllm.logger import init_logger
@@ -25,6 +26,11 @@ from vllm.usage.usage_lib import UsageContext
 from vllm.v1.engine.input_processor import InputProcessor
 from vllm.v1.executor import Executor
 
+from vllm_omni.config.omni_config import (
+    BaseVllmOmniStageConfig,
+    VllmOmniDiffusionStageConfig,
+)
+from vllm_omni.config.stage_config import StageType
 from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.entrypoints.stage_utils import _to_dict, set_stage_devices
@@ -346,53 +352,70 @@ class StageMetadata:
     replica_id: int = 0
 
 
-def extract_stage_metadata(stage_config: Any) -> StageMetadata:
-    """Pure data extraction from a stage_config object."""
+def _apply_rocm_attention_backend(
+    engine_args: dict[str, Any],
+    stage_type: str | StageType,
+) -> None:
+    """Preserve Omni's ROCm attention-backend compatibility default."""
+    if (
+        not current_omni_platform.is_rocm()
+        or stage_type == StageType.DIFFUSION
+        or engine_args.get("attention_backend") is not None
+    ):
+        return
+
+    from vllm._aiter_ops import rocm_aiter_ops
+
+    if rocm_aiter_ops.is_enabled():
+        engine_args["attention_backend"] = "ROCM_AITER_FA"
+    # Before vLLM v0.19.0, the default attention backend is TRITON_ATTN for ROCm.
+    # Since vLLM v0.19.0, the default attention backend is ROCM_ATTN for ROCm.
+    # However, the compatibility of ROCM_ATTN with Omni is not guaranteed.
+    # Therefore, we still use TRITON_ATTN as the default attention backend,
+    # when the selected_backend is not specified.
+    engine_args["attention_backend"] = "TRITON_ATTN"
+
+
+def extract_legacy_stage_metadata(stage_config: Any) -> StageMetadata:
+    """Extract metadata through the active production legacy path.
+
+    Keep production callers on this path until RFC #4021 migrates the
+    engine-argument and stage-init consumers together.
+    """
     stage_id: int = stage_config.stage_id
-    stage_type: Literal["llm", "diffusion"] = getattr(stage_config, "stage_type", "llm")
+    stage_type: Literal["llm", "diffusion"] = _get_attr_or_item(stage_config, "stage_type", "llm")
     engine_args = stage_config.engine_args
 
-    if current_omni_platform.is_rocm():
-        if stage_type != "diffusion" and engine_args.get("attention_backend") is None:
-            from vllm._aiter_ops import rocm_aiter_ops
+    _apply_rocm_attention_backend(engine_args, stage_type)
 
-            if rocm_aiter_ops.is_enabled():
-                engine_args["attention_backend"] = "ROCM_AITER_FA"
-            # Before vLLM v0.19.0, the default attention backend is TRITON_ATTN for ROCm.
-            # Since vLLM v0.19.0, the default attention backend is ROCM_ATTN for ROCm.
-            # However, the compatibility of ROCM_ATTN with Omni is not guaranteed.
-            # Therefore, we still use TRITON_ATTN as the default attention backend,
-            # when the selected_backend is not specified.
-            engine_args["attention_backend"] = "TRITON_ATTN"
+    runtime_cfg = stage_config.runtime
+    engine_input_source: list[int] = _get_attr_or_item(stage_config, "engine_input_source", [])
+    final_output: bool = stage_config.final_output
+    final_output_type: str | None = stage_config.final_output_type
 
-    runtime_cfg = getattr(stage_config, "runtime", {})
-    engine_input_source: list[int] = getattr(stage_config, "engine_input_source", [])
-    final_output: bool = getattr(stage_config, "final_output", False)
-    final_output_type: str | None = getattr(stage_config, "final_output_type", None)
-
-    default_sp = _to_dict(getattr(stage_config, "default_sampling_params", {}))
+    default_sp = _to_dict(_get_attr_or_item(stage_config, "default_sampling_params", {}))
     SPClass = SamplingParams if stage_type == "llm" else OmniDiffusionSamplingParams
     default_sampling_params: OmniSamplingParams = SPClass(**default_sp)
 
     custom_process_input_func: Callable | None = None
-    _cpif_path = getattr(stage_config, "custom_process_input_func", None)
+    _cpif_path = _get_attr_or_item(stage_config, "custom_process_input_func")
     if _cpif_path:
         mod_path, fn_name = _cpif_path.rsplit(".", 1)
         custom_process_input_func = getattr(importlib.import_module(mod_path), fn_name)
 
     prompt_expand_func: Callable | None = None
-    _pef_path = getattr(stage_config, "prompt_expand_func", None)
+    _pef_path = _get_attr_or_item(stage_config, "prompt_expand_func")
     if _pef_path:
         _mod, _fn = _pef_path.rsplit(".", 1)
         prompt_expand_func = getattr(importlib.import_module(_mod), _fn)
 
     cfg_kv_collect_func: Callable | None = None
-    _ckf_path = getattr(stage_config, "cfg_kv_collect_func", None)
+    _ckf_path = _get_attr_or_item(stage_config, "cfg_kv_collect_func")
     if _ckf_path:
         _mod, _fn = _ckf_path.rsplit(".", 1)
         cfg_kv_collect_func = getattr(importlib.import_module(_mod), _fn)
 
-    model_stage = getattr(engine_args, "model_stage", None)
+    model_stage = engine_args.get("model_stage")
 
     if stage_type == "diffusion":
         return StageMetadata(
@@ -411,8 +434,8 @@ def extract_stage_metadata(stage_config: Any) -> StageMetadata:
             cfg_kv_collect_func=cfg_kv_collect_func,
         )
 
-    engine_output_type = getattr(engine_args, "engine_output_type", None)
-    is_comprehension = getattr(stage_config, "is_comprehension", False)
+    engine_output_type = engine_args.get("engine_output_type")
+    is_comprehension = stage_config.is_comprehension
     requires_multimodal_data = getattr(runtime_cfg, "requires_multimodal_data", False)
 
     return StageMetadata(
@@ -432,6 +455,68 @@ def extract_stage_metadata(stage_config: Any) -> StageMetadata:
     )
 
 
+def extract_stage_metadata(stage_config: Any) -> StageMetadata:
+    """Preserve the legacy one-argument API for external callers."""
+    return extract_legacy_stage_metadata(stage_config)
+
+
+def _resolve_omni_metadata_hook(path: str | None) -> Callable | None:
+    if not path:
+        return None
+    module_path, function_name = path.rsplit(".", 1)
+    return getattr(importlib.import_module(module_path), function_name)
+
+
+def extract_stage_metadata_from_omni_stage_config(
+    stage_config: BaseVllmOmniStageConfig,
+) -> StageMetadata:
+    """Project one typed stage config into metadata for a future cutover.
+
+    This projection is not used by production startup yet. Current replica
+    layout, engine-argument, remote-diffusion, and platform setup paths still
+    require the legacy StageConfig/OmegaConf shape.
+    """
+    stage_type: Literal["llm", "diffusion"] = "diffusion" if stage_config.stage_type == StageType.DIFFUSION else "llm"
+    sampling_params_cls = SamplingParams if stage_type == "llm" else OmniDiffusionSamplingParams
+    sampling_params: OmniSamplingParams = sampling_params_cls(
+        **(stage_config.model_config.default_sampling_params or {})
+    )
+    custom_process_input_func = _resolve_omni_metadata_hook(stage_config.custom_process_input_func)
+
+    if stage_type == "diffusion":
+        return StageMetadata(
+            stage_id=stage_config.stage_id,
+            stage_type="diffusion",
+            engine_output_type=None,
+            is_comprehension=False,
+            requires_multimodal_data=False,
+            engine_input_source=stage_config.input_sources,
+            final_output=stage_config.final_output,
+            final_output_type=stage_config.final_output_type,
+            default_sampling_params=sampling_params,
+            custom_process_input_func=custom_process_input_func,
+            model_stage=stage_config.model_stage,
+            runtime_cfg=stage_config.runtime_config,
+            cfg_kv_collect_func=_resolve_omni_metadata_hook(stage_config.cfg_kv_collect_func),
+        )
+
+    return StageMetadata(
+        stage_id=stage_config.stage_id,
+        stage_type="llm",
+        engine_output_type=stage_config.engine_output_type,
+        is_comprehension=stage_config.is_comprehension,
+        requires_multimodal_data=stage_config.requires_multimodal_data,
+        engine_input_source=stage_config.input_sources,
+        final_output=stage_config.final_output,
+        final_output_type=stage_config.final_output_type,
+        default_sampling_params=sampling_params,
+        custom_process_input_func=custom_process_input_func,
+        model_stage=stage_config.model_stage,
+        runtime_cfg=stage_config.runtime_config,
+        prompt_expand_func=_resolve_omni_metadata_hook(stage_config.prompt_expand_func),
+    )
+
+
 def prepare_engine_environment() -> None:
     """One-time global setup: load plugins, set multiprocessing spawn method."""
     from vllm_omni.plugins import load_omni_general_plugins
@@ -680,30 +765,157 @@ def stage_runtime_env(stage_id: int, runtime_cfg: Any) -> Generator[None, None,
                 os.environ[key] = old_value
 
 
-def build_engine_args_dict(
-    stage_config: Any,
-    model: str,
-    stage_connector_spec: dict[str, Any] | None = None,
-    cli_tokenizer: str | None = None,
+def _project_omni_config_fields(
+    config: Any,
+    *,
+    exclude: frozenset[str] = frozenset(),
 ) -> dict[str, Any]:
-    """Build the normalized engine args dict for one stage."""
-    engine_args = stage_config.engine_args
-    # HACK (Alex) Tensor parallel size should not be passed as None;
-    # remove it if this is the case so that we fall back to default
-    # creation from vLLM's engine args.
-    # NOTE: This will be fixed more generically in ongoing work for engine arg filtering.
-    if "tensor_parallel_size" in engine_args and engine_args["tensor_parallel_size"] is None:
-        del engine_args["tensor_parallel_size"]
+    """Copy defined typed config fields into backend adapter kwargs."""
+    projected: dict[str, Any] = {}
+    for config_field in fields(config):
+        name = config_field.name
+        if name in exclude:
+            continue
+        value = getattr(config, name)
+        if value is not None:
+            projected[name] = copy.deepcopy(value)
+    return projected
 
-    stage_type = getattr(stage_config, "stage_type", "llm")
-    stage_id = stage_config.stage_id
 
-    engine_args_dict = _to_dict(engine_args)
+def _project_omni_stage_engine_args(
+    stage_config: BaseVllmOmniStageConfig,
+) -> dict[str, Any]:
+    """Read backend inputs from one structured stage config."""
+    engine_args: dict[str, Any] = {}
+    is_diffusion = isinstance(stage_config, VllmOmniDiffusionStageConfig)
+
+    if is_diffusion:
+        engine_args.update(_project_omni_config_fields(stage_config.diffusion_config))
+
+    for config, excluded_fields in (
+        (
+            stage_config.model_config,
+            frozenset({"default_sampling_params", "has_sampling_extra_args"}),
+        ),
+        (stage_config.load_config, frozenset()),
+        (stage_config.cache_config, frozenset()),
+        (stage_config.scheduler_config, frozenset()),
+        (
+            stage_config.runtime_config,
+            frozenset({"devices", "num_replicas", "env", "num_gpus"}),
+        ),
+    ):
+        engine_args.update(
+            _project_omni_config_fields(
+                config,
+                exclude=excluded_fields,
+            )
+        )
+
+    # The legacy builder always emits this key, including for pipelines such
+    # as Audex that intentionally defer architecture discovery to HF config.
+    engine_args["model_arch"] = copy.deepcopy(stage_config.model_config.model_arch)
+
+    topology = stage_config.stage_pipeline_config
+    topology_engine_args = {
+        "model_stage": stage_config.model_stage,
+        "worker_type": stage_config.worker_type,
+        "scheduler_cls": stage_config.scheduler_cls,
+        "hf_config_name": stage_config.hf_config_name,
+        "engine_output_type": stage_config.engine_output_type,
+        "custom_process_next_stage_input_func": stage_config.custom_process_next_stage_input_func,
+        "retains_state_across_chunks": topology.retains_state_across_chunks,
+    }
+    engine_args.update(
+        {name: copy.deepcopy(value) for name, value in topology_engine_args.items() if value is not None}
+    )
+
+    connector_config = stage_config.connector_config
+    engine_args["async_chunk"] = connector_config.async_chunk
+    if connector_config.omni_kv_config is not None:
+        engine_args["omni_kv_config"] = copy.deepcopy(connector_config.omni_kv_config)
+
+    if is_diffusion:
+        engine_args["parallel_config"] = _project_omni_config_fields(
+            stage_config.parallel_config,
+            exclude=frozenset({"world_size"}),
+        )
+    else:
+        engine_args.update(
+            _project_omni_config_fields(
+                stage_config.parallel_config,
+                exclude=frozenset({"world_size"}),
+            )
+        )
+
+    quantization_config = stage_config.quantization_config
+    if quantization_config is not None:
+        quantization_key = (
+            "quantization" if isinstance(quantization_config, str) and not is_diffusion else "quantization_config"
+        )
+        engine_args[quantization_key] = copy.deepcopy(quantization_config)
+
+    return engine_args
+
+
+def _finalize_engine_args_dict(
+    engine_args_dict: dict[str, Any],
+    *,
+    stage_type: str | StageType,
+    stage_id: int,
+    model: str,
+    stage_connector_spec: dict[str, Any] | None,
+    cli_tokenizer: str | None,
+    has_sampling_extra_args: bool,
+) -> dict[str, Any]:
+    """Apply representation-independent engine adapter behavior."""
+    pipeline_model_root = model
     model = engine_args_dict.pop("model", None) or model
     stage_defines_tokenizer = (
         engine_args_dict.get("tokenizer") is not None or engine_args_dict.get("tokenizer_subdir") is not None
     )
+    audex_stage = str(engine_args_dict.get("model_stage") or "")
+    if audex_stage == "audex_xcodec":
+        # TTA stage 1 decodes with the external XCodec1 checkpoint, not a
+        # subfolder of the Audex repo: the source comes from XCODEC1_PATH,
+        # the stage yaml's own ``model`` entry, or the default HF repo — the
+        # pipeline-level model (the Audex root) is never a valid source.
+        from vllm_omni.model_executor.models.audex.checkpoint import (
+            ensure_audex_snapshot,
+            ensure_xcodec1_snapshot,
+        )
+
+        stage_model = None if model == pipeline_model_root else model
+        model = ensure_xcodec1_snapshot(os.environ.get("XCODEC1_PATH") or stage_model)
+        if not stage_defines_tokenizer:
+            # XCodec1 ships no tokenizer files; borrow the thinker's (same
+            # workaround as the TTS decoder stage).
+            audex_root = ensure_audex_snapshot(pipeline_model_root, profile="tta")
+            engine_args_dict["tokenizer"] = os.path.join(audex_root, "checkpoint_folder_audiogen")
+            stage_defines_tokenizer = True
+    elif audex_stage.startswith("audex"):
+        # Audex users pass the HF repo ROOT; make sure the required snapshot
+        # subset exists locally BEFORE subdir resolution, otherwise the
+        # subdirs get joined onto the raw repo id on a fresh cache. The
+        # profile keeps TTS-only deployments from pulling the full-checkpoint
+        # extras.
+        from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
+
+        if audex_stage == "audex_omni":
+            audex_profile = "full"
+        elif audex_stage == "audex_tta_thinker":
+            audex_profile = "tta"
+        else:
+            audex_profile = "tts"
+        model = ensure_audex_snapshot(model, profile=audex_profile)
     model = _resolve_model_tokenizer_paths(model, engine_args_dict)
+    if engine_args_dict.get("model_stage") in ("audex_thinker", "audex_tta_thinker"):
+        # Audex ships its thinker weights deduplicated into a sibling folder;
+        # replicate the official prepare-script symlink on first use. The TTA
+        # thinker loads the same checkpoint_folder_audiogen checkpoint.
+        from vllm_omni.model_executor.models.audex.checkpoint import ensure_audiogen_weights
+
+        ensure_audiogen_weights(model)
     apply_cli_tokenizer(
         engine_args_dict,
         cli_tokenizer=cli_tokenizer,
@@ -713,18 +925,18 @@ def build_engine_args_dict(
     # Stage id must come from stage config instead of inherited CLI kwargs
     # (e.g. `--stage-id` defaulting to None).
     engine_args_dict["stage_id"] = stage_id
-    if engine_args_dict.get("async_chunk", False):
+    if stage_connector_spec:
         engine_args_dict["stage_connector_spec"] = dict(stage_connector_spec or {})
 
-    if stage_type == "diffusion":
+    is_diffusion = stage_type == StageType.DIFFUSION
+    if is_diffusion:
         from vllm_omni.diffusion.data import parse_attention_config
 
         if engine_args_dict.get("diffusion_attention_config") is not None:
             engine_args_dict["diffusion_attention_config"] = parse_attention_config(
-                engine_args_dict.get("diffusion_attention_config"),
+                engine_args_dict["diffusion_attention_config"],
             )
-
-    if stage_type != "diffusion":
+    else:
         resolve_worker_cls(engine_args_dict)
 
     if engine_args_dict.get("worker_type") == "generation":
@@ -734,17 +946,86 @@ def build_engine_args_dict(
         engine_args_dict.setdefault("disable_hybrid_kv_cache_manager", True)
         engine_args_dict.setdefault("enable_prefix_caching", False)
 
-    # Check whether the stage's default_sampling_params defines extra_args.
-    default_sp = _to_dict(getattr(stage_config, "default_sampling_params", {}))
-    engine_args_dict["has_sampling_extra_args"] = bool(default_sp.get("extra_args"))
+    engine_args_dict["has_sampling_extra_args"] = has_sampling_extra_args
 
     # TODO: Remove this after the performance regression is fixed
     # Set VLLM_USE_FLASHINFER_MOE_FP16=0 for Qwen3-Omni to avoid performance regression
     _maybe_set_qwen3_omni_moe_env(engine_args_dict)
-
     return engine_args_dict
 
 
+def build_legacy_engine_args_dict(
+    stage_config: Any,
+    model: str,
+    stage_connector_spec: dict[str, Any] | None = None,
+    cli_tokenizer: str | None = None,
+) -> dict[str, Any]:
+    """Implement engine-argument building for the legacy stage representation."""
+    engine_args_dict = _to_dict(stage_config.engine_args)
+    # Legacy configs can materialize an omitted optional TP size as None.
+    # Remove it from the detached adapter dict so the backend default applies
+    # without mutating stage_config.engine_args.
+    if engine_args_dict.get("tensor_parallel_size") is None:
+        engine_args_dict.pop("tensor_parallel_size", None)
+
+    default_sp = _to_dict(_get_attr_or_item(stage_config, "default_sampling_params", {}))
+    return _finalize_engine_args_dict(
+        engine_args_dict,
+        stage_type=_get_attr_or_item(stage_config, "stage_type", "llm"),
+        stage_id=stage_config.stage_id,
+        model=model,
+        stage_connector_spec=stage_connector_spec,
+        cli_tokenizer=cli_tokenizer,
+        has_sampling_extra_args=bool(default_sp.get("extra_args")),
+    )
+
+
+def build_engine_args_dict(
+    stage_config: Any,
+    model: str,
+    stage_connector_spec: dict[str, Any] | None = None,
+    cli_tokenizer: str | None = None,
+) -> dict[str, Any]:
+    """Build engine arguments through the stable production entry point.
+
+    Production inputs still use the legacy stage representation. Keep that
+    compatibility choice behind this function so callers do not bind directly
+    to a representation-specific implementation.
+    """
+    return build_legacy_engine_args_dict(
+        stage_config,
+        model,
+        stage_connector_spec=stage_connector_spec,
+        cli_tokenizer=cli_tokenizer,
+    )
+
+
+def build_engine_args_dict_from_omni_stage_config(
+    stage_config: BaseVllmOmniStageConfig,
+    model: str,
+    stage_connector_spec: dict[str, Any] | None = None,
+    cli_tokenizer: str | None = None,
+) -> dict[str, Any]:
+    """Project one typed stage config into backend engine arguments.
+
+    This projection is prepared for the RFC #4021 stage-init cutover. Current
+    production startup reaches the legacy implementation through
+    ``build_engine_args_dict`` while strategy and startup-plan inputs still
+    use the legacy representation.
+    """
+    engine_args_dict = _project_omni_stage_engine_args(stage_config)
+    _apply_rocm_attention_backend(engine_args_dict, stage_config.stage_type)
+    return _finalize_engine_args_dict(
+        engine_args_dict,
+        stage_type=stage_config.stage_type,
+        stage_id=stage_config.stage_id,
+        model=model,
+        stage_connector_spec=stage_connector_spec,
+        cli_tokenizer=cli_tokenizer,
+        has_sampling_extra_args=stage_config.model_config.has_sampling_extra_args,
+    )
+
+
 def build_vllm_config(
     stage_config: Any,
     model: str,
@@ -1054,15 +1335,23 @@ def get_stage_connector_spec(
     stage_id: int,
     async_chunk: bool,
 ) -> dict[str, Any]:
-    """Return the first connector spec for the stage when async chunking is enabled."""
+    """Return the first connector spec for a stage data-plane edge."""
     from vllm_omni.distributed.omni_connectors import get_stage_connector_config
 
-    if not async_chunk:
-        return {}
-
     stage_connectors_cfg = get_stage_connector_config(omni_transfer_config, stage_id)
     for cfg in stage_connectors_cfg.values():
         return dict(cfg.get("spec", {}))
+
+    # A producer does not consume connector data itself. Keep its connector
+    # for both async-chunk and terminal full-payload sends, but mark it
+    # sender-only so the scheduler does not park orchestrator-provided inputs
+    # waiting for an upstream payload.
+    target_stage = str(stage_id)
+    for (from_stage, _to_stage), spec in getattr(omni_transfer_config, "connectors", {}).items():
+        if from_stage == target_stage:
+            extra = dict(spec.extra or {})
+            extra.setdefault("role", "sender")
+            return {"name": spec.name, "extra": extra}
     return {}
 
 
@@ -1121,3 +1410,26 @@ def initialize_diffusion_stage(
 
     od_config = build_diffusion_config(model, stage_cfg, metadata)
     return create_diffusion_client(model, od_config, metadata, stage_init_timeout, batch_size, use_inline)
+
+
+def maybe_apply_audex_cfg_patches(vllm_config: Any) -> None:
+    """Install the Audex CFG scheduler patches for CFG-configured engines.
+
+    Must run in the engine-core process BEFORE ``Scheduler`` is constructed:
+    the patch wraps ``Scheduler.__init__`` to add the pair registry, so a
+    scheduler built earlier would never become pair-aware. Gated on the
+    engine's ``logits_processors`` so non-CFG stages stay untouched.
+    """
+    model_config = getattr(vllm_config, "model_config", None)
+    processors = getattr(model_config, "logits_processors", None) or []
+    if not any("AudexCFGLogitsProcessor" in getattr(proc, "__name__", str(proc)) for proc in processors):
+        return
+
+    from vllm_omni.model_executor.models.audex.cfg import apply_cfg_patches
+
+    apply_cfg_patches()
+
+    from vllm.v1.core.sched.scheduler import Scheduler
+
+    if not getattr(Scheduler.schedule, "_audex_cfg_patched", False):
+        raise RuntimeError("Audex CFG scheduler patches failed to install before Scheduler construction")
diff --git a/vllm_omni/engine/stage_pool.py b/vllm_omni/engine/stage_pool.py
index 34af459ab..354032a7d 100644
--- a/vllm_omni/engine/stage_pool.py
+++ b/vllm_omni/engine/stage_pool.py
@@ -24,11 +24,19 @@ from vllm_omni.engine.stage_client import (
     StagePoolDiffusionClient,
     StagePoolLLMClient,
 )
-from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniInteractionPrompt
+from vllm_omni.metrics import (
+    count_audio_frames,
+    count_image_pixels,
+    count_tokens_from_outputs,
+)
 from vllm_omni.metrics import definitions as defs
 from vllm_omni.metrics.stats import StageRequestStats as StageRequestMetrics
 from vllm_omni.metrics.stats import StageStats
-from vllm_omni.metrics.utils import count_tokens_from_outputs
+from vllm_omni.metrics.utils import (
+    coerce_positive_int_scalar,
+    iter_mm_outputs,
+)
 
 if TYPE_CHECKING:
     from vllm_omni.engine.orchestrator import OrchestratorRequestState
@@ -97,6 +105,7 @@ class StagePool:
         self._stage_vllm_config = stage_vllm_config
         self._next_replica_id = 0
         self._request_bindings: dict[str, int] = {}
+        self._unavailable_replicas: set[int] = set()
         self._replica_metrics: list[_ReplicaMetrics] = [_ReplicaMetrics() for _ in self.clients]
         self._output_timestamps_by_request: dict[str, list[float]] = {}
         self._non_empty_first_output_timestamps_by_request: dict[str, float] = {}
@@ -206,27 +215,41 @@ class StagePool:
                 return addr
         return None
 
-    def add_client(self, input_addr: str, client: Any) -> int:
+    def add_client(self, input_addr: str, client: Any, *, replica_id: int | None = None) -> int:
         """Register a head-side client for ``input_addr``.
 
         Returns the assigned ``replica_id`` (index into :attr:`clients`).
-        If the address is already known, replaces the existing client and
-        returns its existing id (this should not happen in practice — the
-        master server assigns unique slots — but the contract is idempotent
-        to keep the dispatch layer robust).
+        A coordinator-provided ``replica_id`` restores that exact slot after
+        unregister/re-register. Without one, a known address keeps its slot
+        and a new address takes the first vacant slot.
         """
         if not input_addr:
             raise ValueError("input_addr must be a non-empty string")
+        if replica_id is not None and replica_id < 0:
+            raise ValueError("replica_id must be non-negative")
 
         existing = self._addr_to_replica_id.get(input_addr)
-        if existing is not None:
-            self.clients[existing] = client
-            return existing
+        if replica_id is not None and existing is not None and existing != replica_id:
+            raise ValueError(
+                f"input address {input_addr!r} is already assigned to replica {existing}, not {replica_id}"
+            )
+        if replica_id is None:
+            replica_id = existing
+        if replica_id is None:
+            replica_id = next(
+                (index for index, existing_client in enumerate(self.clients) if existing_client is None),
+                len(self.clients),
+            )
 
-        replica_id = len(self.clients)
-        self.clients.append(client)
+        while len(self.clients) <= replica_id:
+            self.clients.append(None)
+            self._replica_metrics.append(_ReplicaMetrics())
+        for known_addr, known_replica_id in list(self._addr_to_replica_id.items()):
+            if known_replica_id == replica_id and known_addr != input_addr:
+                self._addr_to_replica_id.pop(known_addr, None)
+        self.clients[replica_id] = client
         self._addr_to_replica_id[input_addr] = replica_id
-        self._replica_metrics.append(_ReplicaMetrics())
+        self._unavailable_replicas.discard(replica_id)
         return replica_id
 
     def remove_client(self, input_addr: str) -> Any | None:
@@ -234,7 +257,7 @@ class StagePool:
 
         Slot is marked ``None`` to preserve indices for outstanding bindings.
         """
-        replica_id = self._addr_to_replica_id.pop(input_addr, None)
+        replica_id = self._addr_to_replica_id.get(input_addr)
         if replica_id is None:
             return None
         client = self.clients[replica_id]
@@ -475,6 +498,39 @@ class StagePool:
         for request_id in request_ids:
             self.release_binding(request_id)
 
+    def release_replica_bindings(self, replica_id: int) -> list[str]:
+        """Drop all route/session bindings owned by one physical replica."""
+        released_request_ids = [
+            request_id
+            for request_id, bound_replica_id in list(self._request_bindings.items())
+            if bound_replica_id == replica_id
+        ]
+        released_request_ids.extend(
+            request_id
+            for request_id, input_addr in list(self._affinity.items())
+            if self._addr_to_replica_id.get(input_addr) == replica_id
+        )
+        released_request_ids = list(dict.fromkeys(released_request_ids))
+        for request_id in released_request_ids:
+            self.release_binding(request_id)
+        return released_request_ids
+
+    def mark_replica_unavailable(self, replica_id: int) -> list[str]:
+        """Evict a failed replica from admission and release its bindings."""
+        if 0 <= replica_id < self.num_replicas:
+            self._unavailable_replicas.add(replica_id)
+        return self.release_replica_bindings(replica_id)
+
+    def is_replica_available(self, replica_id: int) -> bool:
+        return (
+            0 <= replica_id < self.num_replicas
+            and self.clients[replica_id] is not None
+            and replica_id not in self._unavailable_replicas
+        )
+
+    def available_replica_ids(self) -> list[int]:
+        return [replica_id for replica_id in range(self.num_replicas) if self.is_replica_available(replica_id)]
+
     def select_replica_id(
         self,
         request_id: str,
@@ -483,23 +539,27 @@ class StagePool:
     ) -> int:
         """Pick a replica id for *request_id* and cache the choice (legacy path)."""
         cached = self.get_bound_replica_id(request_id)
-        if cached is not None and self.clients[cached] is not None:
+        if cached is not None and self.clients[cached] is not None and self.is_replica_available(cached):
             return cached
+        if cached is not None:
+            # Cached replica is dead/unavailable: drop the stale binding.
+            self.release_binding(request_id)
 
         chosen: int | None = None
         if affinity_request_id is not None:
             parent = self.get_bound_replica_id(affinity_request_id)
-            if parent is not None and self.clients[parent] is not None:
+            if parent is not None and self.clients[parent] is not None and self.is_replica_available(parent):
                 chosen = parent
 
         if chosen is None:
-            live = self.live_replica_ids()
+            # Prefer replicas that are both live (client up) and available.
+            live = [r for r in self.live_replica_ids() if self.is_replica_available(r)]
             if not live:
                 raise RuntimeError(f"stage {self.stage_id} has no live replicas")
             if len(live) == 1:
                 chosen = live[0]
             else:
-                # Round-robin over live replicas only.
+                # Round-robin over live, available replicas only.
                 start = self._next_replica_id % len(live)
                 chosen = live[start]
                 self._next_replica_id = (self._next_replica_id + 1) % len(live)
@@ -539,18 +599,23 @@ class StagePool:
         non_empty_first_output_ts = (
             self._non_empty_first_output_timestamps_by_request.pop(request_id, None) if request_id else None
         )
-        num_tokens_out = count_tokens_from_outputs(request_outputs)
+        native_text_metrics = {}
+        if request_id:
+            pop_native_text_metrics = getattr(self.output_processor, "pop_native_text_metrics", None)
+            if callable(pop_native_text_metrics):
+                native_text_metrics = pop_native_text_metrics(request_id)
+        native_generation_tokens = native_text_metrics.get("num_generation_tokens")
+        num_tokens_out = (
+            max(int(native_generation_tokens), 0)
+            if isinstance(native_generation_tokens, int) and not isinstance(native_generation_tokens, bool)
+            else count_tokens_from_outputs(request_outputs)
+        )
         output_unit_type = self._infer_output_unit_type(request_outputs, token_count=num_tokens_out)
         output_unit_count = self._count_output_units(
             request_outputs,
             unit_type=output_unit_type,
             fallback_token_count=num_tokens_out,
         )
-        native_text_metrics = {}
-        if request_id:
-            pop_native_text_metrics = getattr(self.output_processor, "pop_native_text_metrics", None)
-            if callable(pop_native_text_metrics):
-                native_text_metrics = pop_native_text_metrics(request_id)
         current_audio_frames, current_audio_sample_rate, _ = self._collect_audio_metrics(request_outputs)
         accumulated_audio_frames = self._audio_frames_by_request.pop(request_id, 0) if request_id else 0
         accumulated_audio_sample_rate = self._audio_sample_rate_by_request.pop(request_id, 0) if request_id else 0
@@ -562,7 +627,7 @@ class StagePool:
             else 0.0
         )
         image_pixels = self._count_image_pixels(request_outputs) if output_unit_type == "image" else 0
-        num_inference_steps = self._coerce_int_scalar(getattr(sampling_params, "num_inference_steps", None))
+        num_inference_steps = coerce_positive_int_scalar(getattr(sampling_params, "num_inference_steps", None)) or 0
         denoise_step_latency_ms = (
             defs.compute_denoise_step_latency(stage_gen_time_ms, num_inference_steps)
             if output_unit_type == "image"
@@ -604,6 +669,8 @@ class StagePool:
             num_tokens_out=num_tokens_out,
             stage_gen_time_ms=stage_gen_time_ms,
             batch_id=batch_id,
+            # This event summarizes one completed request. Execution batching
+            # happens inside the model runner and is not observable here.
             batch_size=1,
             replica_id=replica_id,
             rx_decode_time_ms=0.0,
@@ -684,78 +751,40 @@ class StagePool:
 
     def _has_audio_output(self, request_outputs: list[Any]) -> bool:
         for ro in request_outputs:
-            for mm_output in self._iter_multimodal_outputs(ro):
+            for mm_output in iter_mm_outputs(ro):
                 if isinstance(mm_output, Mapping) and mm_output.get("audio") is not None:
                     return True
         return False
 
-    def _collect_audio_metrics(self, request_outputs: list[Any]) -> tuple[int, int, float]:
+    def _collect_audio_metrics(
+        self,
+        request_outputs: list[Any],
+        *,
+        use_default_sample_rate: bool = False,
+    ) -> tuple[int, int, float]:
         total_frames = 0
         sample_rate = 0
         for ro in request_outputs:
-            for mm_output in self._iter_multimodal_outputs(ro):
-                if not isinstance(mm_output, Mapping):
-                    continue
+            for mm_output in iter_mm_outputs(ro):
                 if sample_rate <= 0:
-                    sample_rate = self._infer_audio_sample_rate(mm_output)
-                audio_output = mm_output.get("audio")
-                if audio_output is None:
-                    continue
-                items = audio_output if isinstance(audio_output, list) else [audio_output]
-                for item in items:
-                    total_frames += self._count_audio_frames(item)
+                    sample_rate = self._infer_audio_sample_rate(mm_output, use_default=use_default_sample_rate)
+                total_frames += count_audio_frames(mm_output)
         duration_s = (float(total_frames) / float(sample_rate)) if total_frames > 0 and sample_rate > 0 else 0.0
         return int(total_frames), int(sample_rate), duration_s
 
-    @staticmethod
-    def _count_audio_frames(audio_output: Any) -> int:
-        shape = getattr(audio_output, "shape", None)
-        if shape is not None and len(shape) > 0:
-            # Audio chunks are concatenated on dim=-1 in the output processor,
-            # so the frame/sample axis is the last dim (e.g. [channels, frames]).
-            # Keep this aligned with serving_chat.py: audio tensors are consumed
-            # as (T,), (C, T), or (B, C, T). Flattening would corrupt
-            # multi-channel audio.
-            return int(shape[-1])
-        try:
-            return len(audio_output)
-        except TypeError:
-            return 1
-
-    def _infer_audio_sample_rate(self, mm_output: dict[str, Any]) -> int:
-        for key in ("audio_sample_rate", "sample_rate", "sampling_rate", "sr"):
-            rate = self._coerce_int_scalar(mm_output.get(key))
-            if rate > 0:
-                return rate
-        for attr in ("audio_sample_rate", "sample_rate", "sampling_rate", "output_sample_rate"):
-            rate = self._coerce_int_scalar(getattr(self.stage_client, attr, None))
-            if rate > 0:
-                return rate
-            rate = self._coerce_int_scalar(getattr(self._stage_vllm_config, attr, None))
-            if rate > 0:
-                return rate
-        return 0
-
-    @classmethod
-    def _coerce_int_scalar(cls, value: Any) -> int:
-        if value is None:
-            return 0
-        if isinstance(value, (list, tuple)):
-            for item in value:
-                coerced = cls._coerce_int_scalar(item)
-                if coerced > 0:
-                    return coerced
-            return 0
-        item = getattr(value, "item", None)
-        if callable(item):
-            try:
-                return int(item())
-            except Exception:
-                return 0
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            return 0
+    def _infer_audio_sample_rate(
+        self,
+        mm_output: dict[str, Any] | None = None,
+        *,
+        use_default: bool = True,
+    ) -> int:
+        sources: list[Any] = []
+        if mm_output is not None:
+            sources.append(mm_output)
+        sources.extend([self.stage_client, self._stage_vllm_config])
+        if use_default:
+            return defs.resolve_audio_sample_rate(sources)
+        return defs.resolve_audio_sample_rate_or_none(sources) or 0
 
     def _has_image_output(self, request_outputs: list[Any]) -> bool:
         for ro in request_outputs:
@@ -777,7 +806,7 @@ class StagePool:
 
     def _count_images(self, request_output: Any) -> int:
         total_images = self._count_value_units(getattr(request_output, "images", None))
-        for mm_output in self._iter_multimodal_outputs(request_output):
+        for mm_output in iter_mm_outputs(request_output):
             if isinstance(mm_output, Mapping):
                 total_images += self._count_value_units(mm_output.get("image"))
                 total_images += self._count_value_units(mm_output.get("images"))
@@ -786,43 +815,17 @@ class StagePool:
     def _count_image_pixels(self, request_outputs: list[Any]) -> int:
         total_pixels = 0
         for ro in request_outputs:
-            total_pixels += self._count_image_value_pixels(getattr(ro, "images", None))
-            for mm_output in self._iter_multimodal_outputs(ro):
+            total_pixels += count_image_pixels(getattr(ro, "images", None))
+            for mm_output in iter_mm_outputs(ro):
                 if isinstance(mm_output, Mapping):
-                    total_pixels += self._count_image_value_pixels(mm_output.get("image"))
-                    total_pixels += self._count_image_value_pixels(mm_output.get("images"))
+                    total_pixels += count_image_pixels(mm_output.get("image"))
+                    total_pixels += count_image_pixels(mm_output.get("images"))
         return total_pixels
 
-    @classmethod
-    def _count_image_value_pixels(cls, value: Any) -> int:
-        if value is None:
-            return 0
-        if isinstance(value, (list, tuple)):
-            return sum(cls._count_image_value_pixels(item) for item in value)
-
-        size = getattr(value, "size", None)
-        if isinstance(size, tuple) and len(size) >= 2:
-            try:
-                return int(size[0]) * int(size[1])
-            except (TypeError, ValueError):
-                return 0
-
-        shape = getattr(value, "shape", None)
-        if shape is None or len(shape) < 2:
-            return 0
-        dims = [int(dim) for dim in shape]
-        if len(dims) >= 4:
-            return dims[0] * dims[-2] * dims[-1]
-        if len(dims) == 3 and dims[0] in (1, 3, 4):
-            return dims[1] * dims[2]
-        if len(dims) == 3 and dims[-1] in (1, 3, 4):
-            return dims[0] * dims[1]
-        return dims[-2] * dims[-1]
-
     def _count_videos(self, request_output: Any) -> int:
         total_videos = self._count_video_units(getattr(request_output, "video", None))
         total_videos += self._count_video_units(getattr(request_output, "videos", None))
-        for mm_output in self._iter_multimodal_outputs(request_output):
+        for mm_output in iter_mm_outputs(request_output):
             if isinstance(mm_output, Mapping):
                 total_videos += self._count_video_units(mm_output.get("video"))
                 total_videos += self._count_video_units(mm_output.get("videos"))
@@ -847,7 +850,7 @@ class StagePool:
         custom_output = getattr(request_output, "_custom_output", None)
         if isinstance(custom_output, dict) and custom_output:
             return True
-        for mm_output in self._iter_multimodal_outputs(request_output):
+        for mm_output in iter_mm_outputs(request_output):
             if isinstance(mm_output, Mapping) and any(self._is_non_empty_value(value) for value in mm_output.values()):
                 return True
         for output in getattr(request_output, "outputs", None) or []:
@@ -910,23 +913,15 @@ class StagePool:
             self._output_timestamps_by_request.setdefault(rid, []).append(output_ts)
             if self._has_non_empty_output(request_output):
                 self._non_empty_first_output_timestamps_by_request.setdefault(rid, output_ts)
-            audio_frames, audio_sample_rate, _ = self._collect_audio_metrics([request_output])
+            audio_frames, audio_sample_rate, _ = self._collect_audio_metrics(
+                [request_output],
+                use_default_sample_rate=False,
+            )
             if audio_frames > 0:
                 self._audio_frames_by_request[rid] = self._audio_frames_by_request.get(rid, 0) + audio_frames
             if self._audio_sample_rate_by_request.get(rid, 0) <= 0 and audio_sample_rate > 0:
                 self._audio_sample_rate_by_request[rid] = audio_sample_rate
 
-    def _iter_multimodal_outputs(self, request_output: object) -> list[Mapping[str, Any]]:
-        multimodal_outputs: list[Mapping[str, Any]] = []
-        outer_mm = getattr(request_output, "multimodal_output", None)
-        if isinstance(outer_mm, Mapping) and outer_mm:
-            multimodal_outputs.append(outer_mm)
-        for output in getattr(request_output, "outputs", None) or []:
-            inner_mm = getattr(output, "multimodal_output", None)
-            if isinstance(inner_mm, Mapping) and inner_mm:
-                multimodal_outputs.append(inner_mm)
-        return multimodal_outputs
-
     # ---- Stage-local admission ----
 
     async def submit_initial(
@@ -942,10 +937,9 @@ class StagePool:
     ) -> int:
         """Submit a stage-entry request into this pool."""
         params = params_override if params_override is not None else req_state.sampling_params_list[self.stage_id]
-        # Convert plain vllm SamplingParams for single-stage diffusion models
-        # that receive sampling params from the user/caller directly.
-        if self.stage_type == "diffusion" and not isinstance(params, OmniDiffusionSamplingParams):
-            params = OmniDiffusionSamplingParams()
+        # Direct engine callers may provide plain vLLM SamplingParams.
+        if self.stage_type == "diffusion":
+            params = OmniDiffusionSamplingParams.from_params(params)
         submit_kwargs = dict(submit_kwargs or {})
         if self.stage_type == "diffusion":
             if isinstance(request, list):
@@ -1008,8 +1002,8 @@ class StagePool:
     ) -> int:
         """Submit a streaming update to an already admitted request."""
         params = req_state.sampling_params_list[self.stage_id]
-        if self.stage_type == "diffusion" and not isinstance(params, OmniDiffusionSamplingParams):
-            params = OmniDiffusionSamplingParams()
+        if self.stage_type == "diffusion":
+            params = OmniDiffusionSamplingParams.from_params(params)
         replica_id = self.get_bound_replica_id(request_id)
         if replica_id is None or self.clients[replica_id] is None:
             replica_id = await self._pick_or_select(request_id)
@@ -1029,14 +1023,46 @@ class StagePool:
             # Refresh the shared output-processor state before yielding to the
             # stage client so streaming segments are merged against the latest
             # prompt/token metadata.
-            self.output_processor.add_request(
-                request=request,
-                prompt=prompt_text,
-                parent_req=None,
-                request_index=0,
-                queue=None,
-            )
-            await self._llm_client(replica_id).add_request_async(request)
+            try:
+                self.output_processor.add_request(
+                    request=request,
+                    prompt=prompt_text,
+                    parent_req=None,
+                    request_index=0,
+                    queue=None,
+                )
+                await self._llm_client(replica_id).add_request_async(request)
+            except Exception:
+                rollback = getattr(self.output_processor, "remove_request", None)
+                if callable(rollback):
+                    try:
+                        rollback(request_id)
+                    except Exception as rollback_error:
+                        logger.warning(
+                            "[StagePool] Failed to rollback output processor update for req=%s stage-%s: %s",
+                            request_id,
+                            self.stage_id,
+                            rollback_error,
+                        )
+                raise
+        return replica_id
+
+    async def submit_interaction(
+        self,
+        request_id: str,
+        interaction: OmniInteractionPrompt,
+    ) -> int:
+        """Submit a midway interaction to an active diffusion (typically video generation) request."""
+        replica_id = self.get_bound_replica_id(request_id)
+        if replica_id is None or self.clients[replica_id] is None:
+            replica_id = await self._pick_or_select(request_id)
+
+        client = self._diffusion_client(replica_id)
+        result = await client.submit_interaction_async(request_id, interaction)
+        # Interaction may raise error if underlying check against ODConfig fails.
+        if isinstance(result, dict) and result.get("error"):
+            reason = result.get("reason") or "Unknown interaction RPC error"
+            raise ValueError(str(reason))
         return replica_id
 
     async def _pick_or_select(
@@ -1055,7 +1081,11 @@ class StagePool:
     async def _poll_stage_raw(self, client: StagePoolLLMClient) -> EngineCoreOutputs | None:
         """Pull raw EngineCoreOutputs from a stage replica without processing."""
         outputs = await client.get_output_async()
-        if not outputs.outputs:
+        # Keep scheduler-only / finished-only batches. Omni schedulers mirror
+        # upstream by emitting SchedulerStats on throttled ticks even when no
+        # request output is produced, and dropping those batches loses KV/queue
+        # gauges for that interval.
+        if not outputs.outputs and outputs.scheduler_stats is None and not outputs.finished_requests:
             return None
         return outputs
 
@@ -1071,7 +1101,6 @@ class StagePool:
             return []
         client = cast(StagePoolLLMClient, raw_client)
         processor = self.output_processor
-        iteration_stats = IterationStats()
         processed = processor.process_outputs(
             raw_outputs.outputs,
             raw_outputs.timestamp,
@@ -1097,6 +1126,8 @@ class StagePool:
         timeout_s: float = 0.001,
     ) -> EngineCoreOutputs | None:
         """Poll raw EngineCore outputs from one LLM replica once."""
+        if not self.is_replica_available(replica_id):
+            return None
         raw_client = self.clients[replica_id]
         if raw_client is None:
             return None
@@ -1120,6 +1151,8 @@ class StagePool:
 
     def poll_diffusion_output(self, replica_id: int) -> Any | None:
         """Drain one ready diffusion output from the given replica if present."""
+        if not self.is_replica_available(replica_id):
+            return None
         raw_client = self.clients[replica_id]
         if raw_client is None:
             return None
diff --git a/vllm_omni/engine/stage_runtime.py b/vllm_omni/engine/stage_runtime.py
index 8897043ca..bf84f7793 100644
--- a/vllm_omni/engine/stage_runtime.py
+++ b/vllm_omni/engine/stage_runtime.py
@@ -51,7 +51,7 @@ from vllm_omni.engine.stage_init_utils import (
     build_llm_stage_output_processor,
     build_vllm_config,
     compute_replica_layout,
-    extract_stage_metadata,
+    extract_legacy_stage_metadata,
     get_stage_connector_spec,
     inject_kv_stage_info,
     inject_omni_kv_connector_config,
@@ -126,6 +126,7 @@ class StageRuntime:
         diffusion_batch_size: int,
         async_chunk: bool,
         tokenizer: str | None = None,
+        log_stats: bool = False,
     ) -> None:
         self._stage_configs = stage_configs
         self._model = model
@@ -134,6 +135,7 @@ class StageRuntime:
         self._diffusion_batch_size = diffusion_batch_size
         self._async_chunk = async_chunk
         self._tokenizer = tokenizer
+        self._log_stats = log_stats
         self._num_stages = len(stage_configs)
 
         # Populated by initialize()
@@ -339,8 +341,12 @@ class StageRuntime:
         """Build startup plans for every logical stage and replica."""
         stage_plans: list[LogicalStageInitPlan] = []
 
+        # RFC #4021 transition boundary: stage planning still relies on legacy
+        # StageConfig.runtime and StageConfig.engine_args for replica and engine
+        # setup. Keep metadata extraction on the legacy path until the
+        # coordinated stage-init cutover.
         for stage_idx, stage_cfg in enumerate(self._stage_configs):
-            base_metadata = extract_stage_metadata(stage_cfg)
+            base_metadata = extract_legacy_stage_metadata(stage_cfg)
             stage_id = int(base_metadata.stage_id)
             if stage_id != stage_idx:
                 raise ValueError(
@@ -364,6 +370,9 @@ class StageRuntime:
             executor_class = None
             engine_args_dict = None
             if base_metadata.stage_type != "diffusion":
+                # The stable adapter entry point still receives the same
+                # legacy stage object as replica planning. Its implementation
+                # switches only at the coordinated RFC #4021 cutover.
                 engine_args_dict = build_engine_args_dict(
                     stage_cfg,
                     self._model,
@@ -392,11 +401,10 @@ class StageRuntime:
                 if stage_idx in replica_devices_map:
                     replica_cfg.runtime.devices = replica_devices_map[stage_idx][replica_id]
 
-                replica_metadata = extract_stage_metadata(replica_cfg)
+                replica_metadata = extract_legacy_stage_metadata(replica_cfg)
                 replica_metadata.replica_id = replica_id
                 if launch_mode == "remote" and replica_metadata.stage_type != "diffusion":
                     replica_metadata.runtime_cfg = None
-
                 replicas.append(
                     ReplicaInitPlan(
                         replica_id=replica_id,
@@ -572,7 +580,7 @@ class StageRuntime:
                 with launch_stage_replica(
                     vllm_config=vllm_config,
                     executor_class=executor_class,
-                    log_stats=False,
+                    log_stats=self._log_stats,
                     stage_id=plan.metadata.stage_id,
                     replica_id=plan.replica_id,
                     stage_config=plan.stage_cfg,
@@ -591,6 +599,7 @@ class StageRuntime:
             stage_client = StageEngineCoreClientBase.make_async_mp_client(
                 vllm_config=vllm_config,
                 executor_class=executor_class,
+                log_stats=self._log_stats,
                 metadata=plan.metadata,
                 client_addresses=self._client_addresses_from_zmq(resources.addresses),
                 engine_manager=resources.manager,
@@ -701,7 +710,11 @@ class StageRuntime:
                 stage_vllm_config = plan.replicas[0].stage_vllm_config
                 if stage_vllm_config is None:
                     raise RuntimeError(f"Stage {plan.stage_id} is missing vllm_config")
-                output_processor = build_llm_stage_output_processor(plan, stage_vllm_config)
+                output_processor = build_llm_stage_output_processor(
+                    plan,
+                    stage_vllm_config,
+                    log_stats=self._log_stats,
+                )
 
             stage_pools.append(
                 StagePool(
@@ -739,10 +752,11 @@ class DistStageRuntime(StageRuntime):
         stage_init_timeout: int,
         diffusion_batch_size: int,
         async_chunk: bool,
-        tokenizer: str | None = None,
         single_stage_id_filter: int | None,
         omni_master_address: str,
         omni_master_port: int,
+        tokenizer: str | None = None,
+        log_stats: bool = False,
         omni_dp_size_local: int = 1,
         omni_heartbeat_timeout: float = 30.0,
         omni_lb_policy: str = "random",
@@ -756,6 +770,7 @@ class DistStageRuntime(StageRuntime):
             diffusion_batch_size=diffusion_batch_size,
             async_chunk=async_chunk,
             tokenizer=tokenizer,
+            log_stats=log_stats,
         )
         self._single_stage_id_filter = single_stage_id_filter
         self._omni_master_address = omni_master_address
@@ -866,8 +881,10 @@ class DistStageRuntime(StageRuntime):
         if registered_stage_cfg is None:
             raise ValueError(f"Remote stage {plan.metadata.stage_id} registered without stage config")
 
+        # Remote diffusion registration still transports the legacy mapping
+        # shape. Reconstruct and project that shape until its RFC #4021 cutover.
         metadata = (
-            extract_stage_metadata(OmegaConf.create(registered_stage_cfg))
+            extract_legacy_stage_metadata(OmegaConf.create(registered_stage_cfg))
             if plan.metadata.stage_type == "diffusion"
             else copy.deepcopy(plan.metadata)
         )
@@ -1046,6 +1063,7 @@ class DistStageRuntime(StageRuntime):
             client = StageEngineCoreClientBase.make_async_mp_client(
                 vllm_config=vllm_config,
                 executor_class=ctx.executor_class,
+                log_stats=self._log_stats,
                 metadata=metadata,
                 client_addresses=client_addresses,
                 engine_manager=resources.manager,
@@ -1084,6 +1102,7 @@ def create_stage_runtime(
     omni_heartbeat_timeout: float = 30.0,
     omni_lb_policy: str = "random",
     request_queue: janus.Queue[EngineQueueMessage] | None = None,
+    log_stats: bool = False,
 ) -> StageRuntime:
     """Factory: select StageRuntime or DistStageRuntime."""
     if single_stage_mode:
@@ -1097,6 +1116,7 @@ def create_stage_runtime(
             diffusion_batch_size=diffusion_batch_size,
             async_chunk=async_chunk,
             tokenizer=tokenizer,
+            log_stats=log_stats,
             single_stage_id_filter=single_stage_id_filter,
             omni_master_address=omni_master_address,
             omni_master_port=omni_master_port,
@@ -1113,4 +1133,5 @@ def create_stage_runtime(
         diffusion_batch_size=diffusion_batch_size,
         async_chunk=async_chunk,
         tokenizer=tokenizer,
+        log_stats=log_stats,
     )
diff --git a/vllm_omni/entrypoints/async_omni.py b/vllm_omni/entrypoints/async_omni.py
index 74911af9e..1437cc680 100644
--- a/vllm_omni/entrypoints/async_omni.py
+++ b/vllm_omni/entrypoints/async_omni.py
@@ -44,7 +44,13 @@ if TYPE_CHECKING:
     from vllm.tokenizers import TokenizerLike
     from vllm.v1.engine import PauseMode
 
-    from vllm_omni.inputs.data import OmniPromptType
+    from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+    from vllm_omni.experimental.fullduplex.engine.messages import (
+        DuplexFence,
+        DuplexSessionLifecycleMessage,
+    )
+    from vllm_omni.experimental.fullduplex.request_client import DuplexRequestClient
+    from vllm_omni.inputs.data import OmniInteractionPrompt, OmniPromptType
 
 logger = init_logger(__name__)
 _FINAL_OUTPUT_IDLE_SLEEP_S = 0.001
@@ -143,12 +149,16 @@ class AsyncOmni(EngineClient, OmniBase):
         self._paused: bool = False
         self._sleeping_tags: set[str] = set()
         self._level2_sleeping: bool = False
+        self._duplex_request_client: DuplexRequestClient | None = None
+        self.duplex_lifecycle_events: asyncio.Queue[DuplexSessionLifecycleMessage] = asyncio.Queue()
         self.final_output_task: asyncio.Task | None = None
         self.event_resolver = AsyncEventResolver(orchestrator=self)
         self.config_path = self.engine.config_path
         self.tts_max_instructions_length = kwargs.get("tts_max_instructions_length", None)
         self.input_processor = self.engine.input_processor
         self.endpoint_restrictions = self.engine.endpoint_restrictions
+        self.duplex_session_config = self.engine.duplex_session_config
+        self.duplex_serving_adapter_path = self.engine.duplex_serving_adapter_path
 
         stage_index = self._get_comprehension_stage_index()
         if stage_index is None:
@@ -254,6 +264,191 @@ class AsyncOmni(EngineClient, OmniBase):
         prefix = "" if not external_request_id else f"{external_request_id}-"
         return f"{prefix}{uuid:.8}"
 
+    async def open_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        session_mode: str = "duplex",
+        capabilities: dict[str, object] | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Open an engine-level duplex session when the backend supports it."""
+        return await self._get_duplex_request_client().open(
+            session_id,
+            session_mode=session_mode,
+            capabilities=capabilities,
+            session_config=session_config,
+            runtime_config=runtime_config,
+            fence=fence,
+            timeout=timeout,
+        )
+
+    async def append_duplex_input_async(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None = None,
+        final: bool = False,
+        expected_epoch: int | None = None,
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+        collect_outputs: bool = True,
+    ) -> dict[str, object]:
+        """Append input to an engine-level duplex session."""
+        return await self._get_duplex_request_client().append(
+            session_id,
+            mode=mode,
+            payload=payload,
+            operation_id=operation_id,
+            final=final,
+            expected_epoch=expected_epoch,
+            fence=fence,
+            timeout=timeout,
+            collect_outputs=collect_outputs,
+        )
+
+    async def collect_duplex_data_plane_outputs_async(
+        self,
+        request_id: str,
+        *,
+        response_stage_id: int | None = None,
+        timeout: float | None = 10.0,
+    ) -> list[OmniRequestOutput]:
+        """Collect the next duplex data-plane output batch for a live request."""
+        return await self._get_duplex_request_client().collect_registered_outputs(
+            request_id,
+            response_stage_id=response_stage_id,
+            timeout=timeout,
+        )
+
+    async def signal_duplex_turn_async(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        fence: DuplexFence,
+        next_fence: DuplexFence | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Send a turn/control signal to an engine-level duplex session."""
+        return await self._get_duplex_request_client().signal(
+            session_id,
+            event=event,
+            fence=fence,
+            next_fence=next_fence,
+            session_config=session_config,
+            runtime_config=runtime_config,
+            timeout=timeout,
+        )
+
+    async def close_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        fence: DuplexFence,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        """Close an engine-level duplex session."""
+        return await self._get_duplex_request_client().close(
+            session_id,
+            reason=reason,
+            fence=fence,
+            timeout=timeout,
+        )
+
+    async def touch_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        return await self._get_duplex_request_client().touch(
+            session_id,
+            fence=fence,
+            activity=activity,
+            timeout=timeout,
+        )
+
+    async def resume_duplex_session_async(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None = 10.0,
+    ) -> dict[str, object]:
+        return await self._get_duplex_request_client().resume(
+            session_id,
+            fence=fence,
+            expected_lease_generation=expected_lease_generation,
+            timeout=timeout,
+        )
+
+    def _get_duplex_request_client(self) -> DuplexRequestClient:
+        from vllm_omni.experimental.fullduplex.request_client import (
+            DuplexRequestClient,
+            DuplexRequestOutputPort,
+        )
+
+        client = getattr(self, "_duplex_request_client", None)
+        if client is None:
+            engine = getattr(self, "engine", None)
+            client = DuplexRequestClient(
+                engine,
+                DuplexRequestOutputPort(
+                    request_states=getattr(self, "request_states", {}),
+                    num_stages=getattr(engine, "num_stages", 1),
+                    log_stats=getattr(self, "log_stats", False),
+                    start_output_handler=self._final_output_handler,
+                    process_single_result=self._process_single_result,
+                ),
+            )
+            self._duplex_request_client = client
+        return client
+
+    @staticmethod
+    def _duplex_data_plane_request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
+        from vllm_omni.experimental.fullduplex.request_client import DuplexRequestClient
+
+        return DuplexRequestClient.request_info(result)
+
+    async def _collect_duplex_data_plane_outputs(
+        self,
+        request_id: str,
+        req_state: ClientRequestState,
+        *,
+        response_stage_id: int | None,
+        timeout: float | None,
+    ) -> list[OmniRequestOutput]:
+        return await self._get_duplex_request_client().collect_outputs(
+            request_id,
+            req_state,
+            response_stage_id=response_stage_id,
+            timeout=timeout,
+        )
+
+    @classmethod
+    def _is_direct_duplex_data_plane_response(cls, output: object) -> bool:
+        from vllm_omni.experimental.fullduplex.request_client import DuplexRequestClient
+
+        return DuplexRequestClient.is_direct_response(output)
+
+    @classmethod
+    def _duplex_multimodal_output(cls, output: object) -> dict[str, object]:
+        from vllm_omni.experimental.fullduplex.request_client import DuplexRequestClient
+
+        return DuplexRequestClient.multimodal_output(output)
+
     # ==================== Generate Method ====================
 
     async def generate(
@@ -433,6 +628,13 @@ class AsyncOmni(EngineClient, OmniBase):
 
             logger.debug(f"[AsyncOmni] Request {request_id} completed")
 
+            # The input pump can outlive a normally-completed generation
+            # (e.g. a realtime client that keeps streaming after the final
+            # output); a live pump keeps issuing streaming updates for a
+            # request the orchestrator no longer tracks.
+            if input_stream_task is not None and not input_stream_task.done():
+                input_stream_task.cancel()
+
             self._log_summary_and_cleanup(request_id)
 
         except (asyncio.CancelledError, GeneratorExit):
@@ -693,6 +895,10 @@ class AsyncOmni(EngineClient, OmniBase):
                         await self.event_resolver.resolve(msg)
                         continue
 
+                    if getattr(msg, "type", None) == "duplex_session_lifecycle":
+                        await self.duplex_lifecycle_events.put(msg)
+                        continue
+
                     if isinstance(msg, ErrorMessage) and not msg.fatal:
                         req_state = self.request_states.get(msg.request_id)
                         if req_state is not None:
@@ -807,6 +1013,46 @@ class AsyncOmni(EngineClient, OmniBase):
         internal_ids = [s.request_id for s in self.request_states.values() if s.external_request_id in request_ids]
         await self._abort(internal_ids)
 
+    async def submit_interaction_async(
+        self,
+        request_id: str,
+        *,
+        interaction: OmniInteractionPrompt,
+    ) -> None:
+        """Apply a midway interaction to an active streaming diffusion request.
+
+        ``request_id`` is the external id created by the server-side session,
+        matching the value passed to :meth:`generate`.
+        """
+        event = interaction.get("event")
+        prompt = event.get("prompt") if isinstance(event, dict) else None
+        if isinstance(event, dict) and "prompt" in event and (not isinstance(prompt, str) or not prompt):
+            raise ValueError("prompt must be non-empty")
+        transition_chunks = interaction.get("transition_chunks")
+        if transition_chunks is not None and transition_chunks < 0:
+            raise ValueError("transition_chunks must be >= 0")
+
+        if self.num_stages != 1:
+            raise ValueError("interaction requires single-stage diffusion")
+        stage_meta = self.engine.get_stage_metadata(0)
+        if stage_meta.stage_type != "diffusion":
+            raise ValueError("interaction requires a diffusion stage")
+
+        internal_ids = [s.request_id for s in self.request_states.values() if s.external_request_id == request_id]
+        if not internal_ids:
+            raise ValueError(f"No active request for interaction: {request_id!r}")
+        if len(internal_ids) > 1:
+            raise ValueError(
+                f"interaction requires exactly one active request for {request_id!r}, found {len(internal_ids)}"
+            )
+
+        await self.engine.submit_interaction_async(
+            internal_ids[0],
+            interaction=interaction,
+        )
+        if self.log_stats:
+            logger.info("[AsyncOmni] Queued interaction for request %s", request_id)
+
     async def _abort_internal_requests(self, request_id: str | Iterable[str]):
         """Abort request(s) via the Orchestrator given internal request IDs,
         which take the format <external_request_id>-<UUID>.
@@ -820,7 +1066,10 @@ class AsyncOmni(EngineClient, OmniBase):
         """Submit request IDs to be aborted to the engine."""
         await self.engine.abort_async(request_ids)
         for rid in request_ids:
-            self.request_states.pop(rid, None)
+            state = self.request_states.pop(rid, None)
+            input_stream_task = getattr(state, "input_stream_task", None)
+            if input_stream_task is not None and not input_stream_task.done():
+                input_stream_task.cancel()
         if self.log_stats:
             logger.info("[AsyncOmni] Aborted request(s) %s", ",".join(request_ids))
 
diff --git a/vllm_omni/entrypoints/cli/benchmark/base.py b/vllm_omni/entrypoints/cli/benchmark/base.py
index 6a6f97eb1..d35c98787 100644
--- a/vllm_omni/entrypoints/cli/benchmark/base.py
+++ b/vllm_omni/entrypoints/cli/benchmark/base.py
@@ -1,3 +1,11 @@
+"""Shared interface for vLLM-Omni benchmark CLI subcommands.
+
+``OmniBenchmarkSubcommandBase`` defines the argument-registration and command
+execution hooks required by benchmark implementations. The ``bench`` command
+discovers its concrete subclasses and uses these hooks to build and dispatch
+nested benchmark subcommands.
+"""
+
 import argparse
 
 from vllm.entrypoints.cli.types import CLISubcommand
diff --git a/vllm_omni/entrypoints/cli/benchmark/cli_args.py b/vllm_omni/entrypoints/cli/benchmark/cli_args.py
new file mode 100644
index 000000000..97b549fe1
--- /dev/null
+++ b/vllm_omni/entrypoints/cli/benchmark/cli_args.py
@@ -0,0 +1,261 @@
+"""vLLM-Omni extensions for the ``vllm bench serve`` CLI.
+
+Core functions:
+    add_omni_args: Register all Omni-specific argument groups by calling the
+        feature-specific ``add_*_cli_args`` helpers in this module.
+    extend_omni_choices: Add Omni datasets and backends to choices defined by
+        the upstream vLLM parser, including its shadow parser.
+    update_omni_help: Extend upstream help text with Omni-specific behavior.
+    preprocess_serve_args: Apply transformations that require parsed values
+        before the serving benchmark starts.
+
+``OmniBenchmarkServingSubcommand.add_cli_args`` invokes the first three after
+upstream vLLM registers its arguments. New feature arguments should normally be
+added to the corresponding ``add_*_cli_args`` helper, or to a new helper called
+by ``add_omni_args``.
+"""
+
+import argparse
+
+
+def add_multi_stage_cli_args(parser: argparse.ArgumentParser) -> None:
+    """Add CLI arguments for vLLM-Omni multi-stage benchmarks."""
+    group = parser.add_argument_group("vLLM-Omni Multi-stage Benchmark Options")
+    group.add_argument(
+        "--print-stage",
+        action="store_true",
+        default=False,
+        help=(
+            "Print per-stage benchmark metrics for --omni serving when stage metrics are returned by the server. "
+            "Disabled by default. The latency sections follow --percentile-metrics by modality: "
+            "ttft/tpot/itl control text stages, ttfc/tpoc/icl control internal stream stages, "
+            "and tpop controls both text TPOP and internal stream TPOP."
+        ),
+    )
+
+
+def add_diffusion_cli_args(parser: argparse.ArgumentParser) -> None:
+    """Add CLI arguments for diffusion model benchmarks."""
+    group = parser.add_argument_group("Diffusion Models Options")
+    group.add_argument(
+        "--image-edits-bot-task",
+        dest="bot_task",
+        type=str,
+        default="think",
+        help=(
+            "Default bot_task form field for --backend openai-image-edits-omni "
+            "(/v1/images/edits). "
+            'Use --extra-body \'{"bot_task":"..."}\' to override per run.'
+        ),
+    )
+
+
+def add_daily_omni_cli_args(parser: argparse.ArgumentParser) -> None:
+    """Add CLI arguments specific to the Daily-Omni dataset."""
+    group = parser.add_argument_group("Daily-Omni Dataset Options")
+    group.add_argument(
+        "--daily-omni-qa-json",
+        type=str,
+        default=None,
+        help="Path to local upstream qa.json. When set, QA rows are read from this file and "
+        "the HuggingFace dataset is not loaded (no network). Use with --daily-omni-video-dir "
+        "for fully offline runs. --dataset-path / Hub split flags are then ignored for QA loading.",
+    )
+    group.add_argument(
+        "--daily-omni-video-dir",
+        type=str,
+        default=None,
+        help="Root directory of extracted Daily-Omni videos (contents of Videos.tar: "
+        "each video_id in its own subdir with {video_id}_video.mp4). "
+        "If omitted, Videos.tar is downloaded from the Hugging Face dataset repo on first multimodal "
+        "request. "
+        "When using file URLs, you MUST start the vLLM server with "
+        "--allowed-local-media-path set to this same directory (or a parent), "
+        "otherwise requests fail with 'Cannot load local files without "
+        "--allowed-local-media-path'.",
+    )
+    group.add_argument(
+        "--daily-omni-inline-local-video",
+        action="store_true",
+        default=False,
+        help="For local videos only: embed MP4 as base64 data URLs in benchmark "
+        "requests so the server does not need --allowed-local-media-path. "
+        "Increases request size and client memory; use for small --num-prompts. "
+        "When using --daily-omni-input-mode audio or all, local WAV files are "
+        "embedded the same way.",
+    )
+    group.add_argument(
+        "--daily-omni-input-mode",
+        type=str,
+        choices=["all", "visual", "audio"],
+        default="all",
+        help="Daily-Omni input protocol (mirrors upstream Lliar-liar/Daily-Omni "
+        "--input_mode). 'visual': video only (default). 'audio': WAV only, "
+        "requires {video_id}/{video_id}_audio.wav under --daily-omni-video-dir. "
+        "'all': video + WAV together. Sets mm_processor_kwargs.use_audio_in_video=false "
+        "and matches official separate video/audio streams.",
+    )
+    group.add_argument(
+        "--daily-omni-pack-mode",
+        type=str,
+        choices=["qwen", "minicpm-interleave"],
+        default="qwen",
+        help="How to pack multimodal parts into OpenAI chat messages. "
+        "'qwen' (default): one video_url + one audio_url (Daily-Omni/Qwen protocol). "
+        "'minicpm-interleave': MiniCPM-o official recipe — 1fps frames interleaved with "
+        "matching 1s audio segments as image_url/audio_url pairs (needed to approach "
+        "OpenBMB ~80%% Daily-Omni; requires local Videos extract). By default this mode "
+        "writes JPEG/WAV segments under "
+        "<daily-omni-video-dir>/.minicpm_daily_omni_interleave and sends file:// URLs, "
+        "so start the server with --allowed-local-media-path <daily-omni-video-dir> "
+        "(or a parent). Alternatively pass --daily-omni-inline-local-video to embed "
+        "segments as data URLs. For MiniCPM-o 4.5 string chat templates also start the "
+        "server with --interleave-mm-strings.",
+    )
+    group.add_argument(
+        "--daily-omni-save-eval-items",
+        action="store_true",
+        default=False,
+        help="Include per-request Daily-Omni accuracy rows (gold/predicted/correct) "
+        "in the saved JSON under key daily_omni_eval_items. "
+        "Alternatively set env DAILY_OMNI_SAVE_EVAL_ITEMS=1.",
+    )
+
+
+def add_seed_tts_cli_args(parser: argparse.ArgumentParser) -> None:
+    """Add CLI arguments for Seed-TTS benchmarks."""
+    group = parser.add_argument_group("Seed-TTS Dataset Options")
+    group.add_argument(
+        "--seed-tts-locale",
+        type=str,
+        choices=["en", "zh"],
+        default="en",
+        help="Which Seed-TTS split to load: en/meta.lst or zh/meta.lst under the dataset root.",
+    )
+    group.add_argument(
+        "--seed-tts-root",
+        type=str,
+        default=None,
+        help="Override root directory that contains en/ and zh/ (meta.lst + prompt-wavs). "
+        "If set, --dataset-path can still name the HF repo for logging; this path is used for files.",
+    )
+    group.add_argument(
+        "--seed-tts-file-ref-audio",
+        action="store_true",
+        default=False,
+        help="Send ref_audio as file:// URIs (smaller HTTP bodies). Requires the API server "
+        "to be started with --allowed-local-media-path covering the Seed-TTS dataset root. "
+        "Default is inline data:audio/wav;base64 so Qwen3-TTS works without that flag.",
+    )
+    group.add_argument(
+        "--seed-tts-inline-ref-audio",
+        action="store_true",
+        default=False,
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--seed-tts-system-prompt",
+        type=str,
+        default=None,
+        help="Override chat system message for --backend openai-chat-omni (Qwen3-Omni TTS). "
+        "Default follows official Qwen3-Omni identity + zero-shot voice-clone instructions.",
+    )
+    group.add_argument(
+        "--seed-tts-wer-eval",
+        action="store_true",
+        default=False,
+        help="Keep synthesized audio as 24 kHz mono PCM for WER (works with "
+        "--backend openai-audio-speech or openai-chat-omni). Scoring follows "
+        "zhaochenyang20/seed-tts-eval (Whisper-large-v3 / Paraformer-zh + jiwer). "
+        "Sets SEED_TTS_WER_EVAL=1. Install: pip install 'vllm-omni[dev]'. "
+        "Optional: SEED_TTS_EVAL_DEVICE, SEED_TTS_HF_WHISPER_MODEL.",
+    )
+    group.add_argument(
+        "--seed-tts-wer-save-items",
+        action="store_true",
+        default=False,
+        help="Include per-utterance ASR rows in the saved JSON under key seed_tts_wer_eval_items. "
+        "Or set SEED_TTS_WER_SAVE_ITEMS=1.",
+    )
+
+
+_OMNI_BENCH_DATASET_CHOICES = (
+    "daily-omni",
+    "seed-tts",
+    "seed-tts-text",
+    "seed-tts-design",
+    "ttsd",
+    "sound-effect",
+)
+
+
+def extend_omni_choices(parser: argparse.ArgumentParser) -> None:
+    """Extend upstream argument choices with Omni-specific values."""
+    parsers = [parser]
+    shadow = getattr(parser, "_shadow", None)
+    if shadow is not None:
+        parsers.append(shadow)
+
+    for current_parser in parsers:
+        for action in current_parser._actions:
+            if action.dest == "dataset_name" and action.choices is not None:
+                extra = [choice for choice in _OMNI_BENCH_DATASET_CHOICES if choice not in action.choices]
+                if extra:
+                    action.choices = list(action.choices) + extra
+            if action.dest == "backend" and action.choices is not None:
+                extra = [choice for choice in ("openai-image-edits-omni",) if choice not in action.choices]
+                if extra:
+                    action.choices = list(action.choices) + extra
+
+
+def update_omni_help(parser: argparse.ArgumentParser) -> None:
+    """Update upstream argument help text to describe Omni-specific behavior."""
+    for action in parser._actions:
+        if action.dest == "percentile_metrics":
+            action.help = (
+                "Comma-separated list of selected metrics to report percentiles. "
+                'For text metrics, "ttft", "tpot", and "itl" affect the global benchmark and text '
+                'stage metrics. "tpop" also requests text TPOT/TPOP globally and per stage, and internal '
+                'stream TPOP. "ttfc", "tpoc", and "icl" only affect internal stream stage metrics. '
+                'Audio metrics include "audio_ttfp", "audio_rtf", "audio_duration", and "audio_underrun".'
+            )
+        if action.dest == "random_mm_limit_mm_per_prompt":
+            action.help = (
+                "Per-modality hard caps for items attached per request, e.g. "
+                '\'{"image": 3, "video": 0, "audio": 1}\'. The sampled per-request item '
+                "count is clamped to the sum of these limits. When a modality "
+                "reaches its cap, its buckets are excluded and probabilities are "
+                "renormalized."
+            )
+        if action.dest == "random_mm_bucket_config":
+            action.help = (
+                "The bucket config is a dictionary mapping a multimodal item"
+                "sampling configuration to a probability."
+                "Currently allows for 3 modalities: audio, images and videos. "
+                "A bucket key is a tuple of (height, width, num_frames)"
+                "The value is the probability of sampling that specific item. "
+                "Example: "
+                "--random-mm-bucket-config "
+                "{(256, 256, 1): 0.5, (720, 1280, 16): 0.4, (0, 1, 5): 0.10} "
+                "First item: images with resolution 256x256 w.p. 0.5"
+                "Second item: videos with resolution 720x1280 and 16 frames "
+                "Third item: audios with 1s duration and 5 channels w.p. 0.1"
+                "OBS.: If the probabilities do not sum to 1, they are normalized."
+            )
+
+
+def add_omni_args(parser: argparse.ArgumentParser) -> None:
+    """Register all vLLM-Omni serving benchmark arguments."""
+    add_daily_omni_cli_args(parser)
+    add_seed_tts_cli_args(parser)
+    add_multi_stage_cli_args(parser)
+    add_diffusion_cli_args(parser)
+
+
+def preprocess_serve_args(args: argparse.Namespace) -> None:
+    """Apply serving benchmark CLI transformations after parsing."""
+    extra_body = dict(getattr(args, "extra_body", None) or {})
+    bot_task = getattr(args, "bot_task", None)
+    if getattr(args, "backend", None) == "openai-image-edits-omni" and bot_task is not None:
+        extra_body.setdefault("bot_task", bot_task)
+    args.extra_body = extra_body
diff --git a/vllm_omni/entrypoints/cli/benchmark/main.py b/vllm_omni/entrypoints/cli/benchmark/main.py
index 391def31f..342b4fb4f 100644
--- a/vllm_omni/entrypoints/cli/benchmark/main.py
+++ b/vllm_omni/entrypoints/cli/benchmark/main.py
@@ -1,3 +1,11 @@
+"""Top-level ``vllm bench`` command integration for vLLM-Omni.
+
+``OmniBenchmarkSubcommand`` creates the benchmark command group, discovers
+``OmniBenchmarkSubcommandBase`` implementations, builds their nested parsers,
+and dispatches parsed commands to the selected implementation. ``cmd_init``
+exposes the command to the surrounding vLLM-Omni CLI registration mechanism.
+"""
+
 from __future__ import annotations
 
 import argparse
diff --git a/vllm_omni/entrypoints/cli/benchmark/serve.py b/vllm_omni/entrypoints/cli/benchmark/serve.py
index 70e7342c0..5e46aecd2 100644
--- a/vllm_omni/entrypoints/cli/benchmark/serve.py
+++ b/vllm_omni/entrypoints/cli/benchmark/serve.py
@@ -1,190 +1,25 @@
+"""Online serving benchmark subcommand for vLLM-Omni.
+
+``OmniBenchmarkServingSubcommand`` starts from vLLM's serving benchmark
+arguments, adds Omni-specific options and adaptations, then preprocesses the
+parsed namespace and delegates execution to ``vllm_omni.benchmarks.serve``.
+This keeps CLI integration separate from the multimodal benchmark runtime.
+"""
+
 import argparse
-import os
 
 from vllm.benchmarks.serve import add_cli_args
 
 from vllm_omni.benchmarks.serve import main
 from vllm_omni.entrypoints.cli.benchmark.base import OmniBenchmarkSubcommandBase
-
-
-def add_daily_omni_cli_args(parser: argparse.ArgumentParser) -> None:
-    """Add CLI arguments specific to Daily-Omni dataset.
-
-    This function should be called by the CLI entrypoint to add additional
-    arguments for daily-omni benchmark support.
-
-    Args:
-        parser: The ArgumentParser instance to extend
-    """
-    # Daily-Omni specific arguments
-    daily_omni_group = parser.add_argument_group("Daily-Omni Dataset Options")
-
-    daily_omni_group.add_argument(
-        "--daily-omni-qa-json",
-        type=str,
-        default=None,
-        help="Path to local upstream qa.json. When set, QA rows are read from this file and "
-        "the HuggingFace dataset is not loaded (no network). Use with --daily-omni-video-dir "
-        "for fully offline runs. --dataset-path / Hub split flags are then ignored for QA loading.",
-    )
-    daily_omni_group.add_argument(
-        "--daily-omni-video-dir",
-        type=str,
-        default=None,
-        help="Root directory of extracted Daily-Omni videos (contents of Videos.tar: "
-        "each video_id in its own subdir with {video_id}_video.mp4). "
-        "If omitted, Videos.tar is downloaded from the Hugging Face dataset repo on first multimodal "
-        "request. "
-        "When using file URLs, you MUST start the vLLM server with "
-        "--allowed-local-media-path set to this same directory (or a parent), "
-        "otherwise requests fail with 'Cannot load local files without "
-        "--allowed-local-media-path'.",
-    )
-    daily_omni_group.add_argument(
-        "--daily-omni-inline-local-video",
-        action="store_true",
-        default=False,
-        help="For local videos only: embed MP4 as base64 data URLs in benchmark "
-        "requests so the server does not need --allowed-local-media-path. "
-        "Increases request size and client memory; use for small --num-prompts. "
-        "When using --daily-omni-input-mode audio or all, local WAV files are "
-        "embedded the same way.",
-    )
-    daily_omni_group.add_argument(
-        "--daily-omni-input-mode",
-        type=str,
-        choices=["all", "visual", "audio"],
-        default="all",
-        help="Daily-Omni input protocol (mirrors upstream Lliar-liar/Daily-Omni "
-        "--input_mode). 'visual': video only (default). 'audio': WAV only, "
-        "requires {video_id}/{video_id}_audio.wav under --daily-omni-video-dir. "
-        "'all': video + WAV together. Sets mm_processor_kwargs.use_audio_in_video=false "
-        "and matches official separate video/audio streams.",
-    )
-    daily_omni_group.add_argument(
-        "--daily-omni-save-eval-items",
-        action="store_true",
-        default=False,
-        help="Include per-request Daily-Omni accuracy rows (gold/predicted/correct) "
-        "in the saved JSON under key daily_omni_eval_items. "
-        "Alternatively set env DAILY_OMNI_SAVE_EVAL_ITEMS=1.",
-    )
-
-    # Note: --dataset-name daily-omni via get_samples patch; use either Hub (--dataset-path
-    # liarliar/Daily-Omni) or local --daily-omni-qa-json (offline).
-
-
-def add_seed_tts_cli_args(parser: argparse.ArgumentParser) -> None:
-    """CLI for Seed-TTS zero-shot TTS benchmark (``--dataset-name seed-tts``)."""
-    g = parser.add_argument_group("Seed-TTS Dataset Options")
-    g.add_argument(
-        "--seed-tts-locale",
-        type=str,
-        choices=["en", "zh"],
-        default="en",
-        help="Which Seed-TTS split to load: en/meta.lst or zh/meta.lst under the dataset root.",
-    )
-    g.add_argument(
-        "--seed-tts-root",
-        type=str,
-        default=None,
-        help="Override root directory that contains en/ and zh/ (meta.lst + prompt-wavs). "
-        "If set, --dataset-path can still name the HF repo for logging; this path is used for files.",
-    )
-    g.add_argument(
-        "--seed-tts-file-ref-audio",
-        action="store_true",
-        default=False,
-        help="Send ref_audio as file:// URIs (smaller HTTP bodies). Requires the API server "
-        "to be started with --allowed-local-media-path covering the Seed-TTS dataset root. "
-        "Default is inline data:audio/wav;base64 so Qwen3-TTS works without that flag.",
-    )
-    g.add_argument(
-        "--seed-tts-inline-ref-audio",
-        action="store_true",
-        default=False,
-        help=argparse.SUPPRESS,
-    )
-    g.add_argument(
-        "--seed-tts-system-prompt",
-        type=str,
-        default=None,
-        help="Override chat system message for --backend openai-chat-omni (Qwen3-Omni TTS). "
-        "Default follows official Qwen3-Omni identity + zero-shot voice-clone instructions.",
-    )
-    g.add_argument(
-        "--seed-tts-wer-eval",
-        action="store_true",
-        default=False,
-        help="Keep synthesized audio as 24 kHz mono PCM for WER (works with "
-        "--backend openai-audio-speech or openai-chat-omni). Scoring follows "
-        "zhaochenyang20/seed-tts-eval (Whisper-large-v3 / Paraformer-zh + jiwer). "
-        "Sets SEED_TTS_WER_EVAL=1. Install: pip install 'vllm-omni[dev]'. "
-        "Optional: SEED_TTS_EVAL_DEVICE, SEED_TTS_HF_WHISPER_MODEL.",
-    )
-    g.add_argument(
-        "--seed-tts-wer-save-items",
-        action="store_true",
-        default=False,
-        help="Include per-utterance ASR rows in the saved JSON under key seed_tts_wer_eval_items. "
-        "Or set SEED_TTS_WER_SAVE_ITEMS=1.",
-    )
-
-
-def add_omni_benchmark_cli_args(parser: argparse.ArgumentParser) -> None:
-    """Add vLLM-Omni specific serving benchmark options."""
-    group = parser.add_argument_group("vLLM-Omni Multi-stage Benchmark Options")
-    group.add_argument(
-        "--print-stage",
-        action="store_true",
-        default=False,
-        help=(
-            "Print per-stage benchmark metrics for --omni serving when stage metrics are returned by the server. "
-            "Disabled by default. The latency sections follow --percentile-metrics by modality: "
-            "ttft/tpot/itl control text stages, ttfc/tpoc/icl control internal stream stages, "
-            "and tpop controls both text TPOP and internal stream TPOP."
-        ),
-    )
-    group.add_argument(
-        "--image-edits-bot-task",
-        type=str,
-        default="think",
-        help=(
-            "Default bot_task form field for --backend openai-image-edits-omni "
-            '(/v1/images/edits). Use --extra-body \'{"bot_task":"..."}\' to override per run.'
-        ),
-    )
-
-
-_OMNI_BENCH_DATASET_CHOICES = (
-    "daily-omni",
-    "seed-tts",
-    "seed-tts-text",
-    "seed-tts-design",
-    "ttsd",
-    "sound-effect",
+from vllm_omni.entrypoints.cli.benchmark.cli_args import (
+    add_omni_args,
+    extend_omni_choices,
+    preprocess_serve_args,
+    update_omni_help,
 )
 
 
-def _extend_omni_dataset_name_choices(parser: argparse.ArgumentParser) -> None:
-    """Append omni benchmark dataset names to --dataset-name choices.
-
-    TrackingArgumentParser keeps a shadow parser for explicit-arg tracking; both
-    parsers must list the same choices or parse_args rejects valid omni values.
-    """
-    parsers = [parser]
-    shadow = getattr(parser, "_shadow", None)
-    if shadow is not None:
-        parsers.append(shadow)
-
-    for p in parsers:
-        for action in p._actions:
-            if action.dest == "dataset_name" and action.choices is not None:
-                extra = [c for c in _OMNI_BENCH_DATASET_CHOICES if c not in action.choices]
-                if extra:
-                    action.choices = list(action.choices) + extra
-
-
 class OmniBenchmarkServingSubcommand(OmniBenchmarkSubcommandBase):
     """The `serve` subcommand for vllm bench."""
 
@@ -194,79 +29,11 @@ class OmniBenchmarkServingSubcommand(OmniBenchmarkSubcommandBase):
     @classmethod
     def add_cli_args(cls, parser: argparse.ArgumentParser) -> None:
         add_cli_args(parser)
-
-        # Add Daily-Omni specific arguments
-        add_daily_omni_cli_args(parser)
-        add_seed_tts_cli_args(parser)
-        add_omni_benchmark_cli_args(parser)
-
-        for action in parser._actions:
-            if action.dest == "dataset_name" and action.choices is not None:
-                extra = [
-                    c
-                    for c in (
-                        "daily-omni",
-                        "seed-tts",
-                        "seed-tts-text",
-                        "seed-tts-design",
-                        "ttsd",
-                        "sound-effect",
-                    )
-                    if c not in action.choices
-                ]
-                if extra:
-                    action.choices = list(action.choices) + extra
-            if action.dest == "backend" and action.choices is not None:
-                extra = [c for c in ("openai-image-edits-omni",) if c not in action.choices]
-                if extra:
-                    action.choices = list(action.choices) + extra
-        _extend_omni_dataset_name_choices(parser)
-
-        # Update help messages for omni-specific features
-        for action in parser._actions:
-            if action.dest == "percentile_metrics":
-                action.help = (
-                    "Comma-separated list of selected metrics to report percentiles. "
-                    'For text metrics, "ttft", "tpot", and "itl" affect the global benchmark and text '
-                    'stage metrics. "tpop" also requests text TPOT/TPOP globally and per stage, and internal '
-                    'stream TPOP. "ttfc", "tpoc", and "icl" only affect internal stream stage metrics. '
-                    'Audio metrics include "audio_ttfp", "audio_rtf", "audio_duration", and "audio_underrun".'
-                )
-            if action.dest == "random_mm_limit_mm_per_prompt":
-                action.help = (
-                    "Per-modality hard caps for items attached per request, e.g. "
-                    '\'{"image": 3, "video": 0, "audio": 1}\'. The sampled per-request item '
-                    "count is clamped to the sum of these limits. When a modality "
-                    "reaches its cap, its buckets are excluded and probabilities are "
-                    "renormalized."
-                )
-            if action.dest == "random_mm_bucket_config":
-                action.help = (
-                    "The bucket config is a dictionary mapping a multimodal item"
-                    "sampling configuration to a probability."
-                    "Currently allows for 3 modalities: audio, images and videos. "
-                    "A bucket key is a tuple of (height, width, num_frames)"
-                    "The value is the probability of sampling that specific item. "
-                    "Example: "
-                    "--random-mm-bucket-config "
-                    "{(256, 256, 1): 0.5, (720, 1280, 16): 0.4, (0, 1, 5): 0.10} "
-                    "First item: images with resolution 256x256 w.p. 0.5"
-                    "Second item: videos with resolution 720x1280 and 16 frames "
-                    "Third item: audios with 1s duration and 5 channels w.p. 0.1"
-                    "OBS.: If the probabilities do not sum to 1, they are normalized."
-                )
+        add_omni_args(parser)
+        extend_omni_choices(parser)
+        update_omni_help(parser)
 
     @staticmethod
     def cmd(args: argparse.Namespace) -> None:
-        if getattr(args, "daily_omni_save_eval_items", False):
-            os.environ["DAILY_OMNI_SAVE_EVAL_ITEMS"] = "1"
-        if getattr(args, "seed_tts_wer_eval", False):
-            os.environ["SEED_TTS_WER_EVAL"] = "1"
-        if getattr(args, "seed_tts_wer_save_items", False):
-            os.environ["SEED_TTS_WER_SAVE_ITEMS"] = "1"
-        image_edits_bot_task = getattr(args, "image_edits_bot_task", None)
-        if image_edits_bot_task is not None:
-            extra_body = dict(getattr(args, "extra_body", None) or {})
-            extra_body.setdefault("bot_task", image_edits_bot_task)
-            args.extra_body = extra_body
+        preprocess_serve_args(args)
         main(args)
diff --git a/vllm_omni/entrypoints/cli/serve.py b/vllm_omni/entrypoints/cli/serve.py
index 5d435bc2f..8256d084a 100644
--- a/vllm_omni/entrypoints/cli/serve.py
+++ b/vllm_omni/entrypoints/cli/serve.py
@@ -147,8 +147,9 @@ class OmniServeCommand(CLISubcommand):
                 raise ValueError(
                     "The following CLI args are not supported under --omni: "
                     f"{', '.join(offenders)}. Configure parallelism through the "
-                    "per-stage YAML (`--deploy-config` / `--stage-configs-path`) "
-                    "and replica count via `--omni-dp-size-local`."
+                    "per-stage YAML (`--deploy-config`) "
+                    "and replica count via the per-stage `num_replicas` config field "
+                    "(single-runtime) or `--omni-dp-size-local` (headless / multi-runtime)."
                 )
 
         # --omni-lb-policy is validated against the LoadBalancingPolicy enum.
@@ -212,9 +213,10 @@ class OmniServeCommand(CLISubcommand):
             "--task-type",
             type=str,
             default=None,
-            choices=["CustomVoice", "VoiceDesign", "Base"],
-            help="Default task type for TTS models (CustomVoice, VoiceDesign, or Base). "
-            "If not specified, will be inferred from model path.",
+            help="Model-defined startup task type. The selected model validates "
+            "supported values; for example, TTS models accept CustomVoice, "
+            "VoiceDesign, or Base, while diffusion models may use it to select "
+            "task-specific weights. If omitted, the model default is used.",
         )
         # Forced aligner / word timestamps. --forced-aligner is the opt-in
         # toggle; heavier knobs (gpu_memory_utilization, dtype, max_model_len)
@@ -239,20 +241,11 @@ class OmniServeCommand(CLISubcommand):
                 "flag, when set, overrides the YAML model field."
             ),
         )
-        # TODO(@lishunyang12): deprecate once all models migrate to --deploy-config
-        omni_config_group.add_argument(
-            "--stage-configs-path",
-            type=str,
-            default=None,
-            help="[Deprecated — will be removed in a future release] Path to a legacy "
-            "stage configs YAML (stage_args format). Prefer --deploy-config for new-format deploy YAMLs.",
-        )
         omni_config_group.add_argument(
             "--deploy-config",
             type=str,
             default=None,
-            help="Path to a deploy config YAML (new format with stages/engine_args). "
-            "Mutually exclusive with --stage-configs-path.",
+            help="Path to a deploy config YAML (new format with stages/engine_args).",
         )
         omni_config_group.add_argument(
             "--strategy-config",
@@ -409,7 +402,7 @@ class OmniServeCommand(CLISubcommand):
             dest="model_class_name",
             type=str,
             default=None,
-            help="Override the diffusion pipeline class name (e.g. LTX2ImageToVideoPipeline).",
+            help="Override the diffusion pipeline class name (e.g. LTX2Pipeline).",
         )
         omni_config_group.add_argument(
             "--diffusion-load-format",
@@ -422,6 +415,25 @@ class OmniServeCommand(CLISubcommand):
                 "custom_pipeline, dummy, or diffusers for the HF diffusers adapter."
             ),
         )
+        omni_config_group.add_argument(
+            "--diffusion-compile-granularity",
+            choices=["regional", "full"],
+            default=None,
+            help=(
+                "Compilation scope for the generic diffusion model runner. "
+                "'regional' compiles repeated blocks (default); 'full' compiles the whole transformer and is "
+                "incompatible with HSDP, sequence parallelism, CPU offload, and layerwise offload."
+            ),
+        )
+        omni_config_group.add_argument(
+            "--diffusion-compile-dynamic",
+            action=argparse.BooleanOptionalAction,
+            default=None,
+            help=(
+                "Use dynamic shapes for the selected generic diffusion compile scope. "
+                "Disable for fixed-shape workloads with --no-diffusion-compile-dynamic."
+            ),
+        )
         omni_config_group.add_argument(
             "--diffusers-load-kwargs",
             dest="diffusers_load_kwargs",
@@ -472,6 +484,14 @@ class OmniServeCommand(CLISubcommand):
             help="Ring Sequence Parallelism degree for diffusion models. "
             "Equivalent to setting DiffusionParallelConfig.ring_degree.",
         )
+        omni_config_group.add_argument(
+            "--allgather-degree",
+            dest="allgather_degree",
+            type=int,
+            default=None,
+            help="AllGather-KV Sequence Parallelism degree for non-causal diffusion attention. "
+            "Equivalent to setting DiffusionParallelConfig.allgather_degree.",
+        )
         omni_config_group.add_argument(
             "--diffusion-quantization-config",
             type=json.loads,
@@ -533,7 +553,8 @@ class OmniServeCommand(CLISubcommand):
             help="Diffusion attention config. Accepts JSON or vLLM-style dotted flags. "
             "Examples: "
             "--diffusion-attention-config.default.backend FLASH_ATTN, "
-            "--diffusion-attention-config.per_role.self.backend SPARSE_BLOCK, "
+            "--diffusion-attention-config.default.backend TRTLLM_ATTN "
+            "--diffusion-attention-config.default.skip_softmax.target_sparsity 0.5, "
             "--diffusion-attention-config.per_role.cross.backend SAGE_ATTN, "
             '--diffusion-attention-config \'{"default": {"backend": "FLASH_ATTN"}, '
             '"per_role": {"cross": {"backend": "SAGE_ATTN"}}}\'.',
@@ -612,6 +633,40 @@ class OmniServeCommand(CLISubcommand):
             action="store_true",
             help="Enable layerwise (blockwise) offloading on DiT modules.",
         )
+        omni_config_group.add_argument(
+            "--enable-distributed-layerwise-offload",
+            action="store_true",
+            help="Enable distributed layerwise offloading with H2D + AllGather overlap. "
+            "Shards weights across DP ranks, stores only 1/DP_size on each host, "
+            "and overlaps H2D transfers and AllGather with computation. "
+            "DP size is automatically derived from the parallel configuration.",
+        )
+        omni_config_group.add_argument(
+            "--dlo-use-allgather",
+            dest="dlo_use_allgather",
+            action="store_true",
+            default=True,
+            help="Use shard + AllGather for weight reconstruction (default: True). "
+            "When disabled (--dlo-no-use-allgather), each rank streams the "
+            "standard loader's rank-local tensors via H2D only — no additional "
+            "DP sharding, no AllGather, and no concurrent-request requirement.",
+        )
+        omni_config_group.add_argument(
+            "--dlo-no-use-allgather",
+            dest="dlo_use_allgather",
+            action="store_false",
+            help=(
+                "Disable AllGather and stream standard-loader rank-local weights "
+                "independently (including existing TP shards)."
+            ),
+        )
+        omni_config_group.add_argument(
+            "--dlo-resident-layers",
+            type=int,
+            default=0,
+            help="Keep this many leading main-DiT blocks resident on the device "
+            "while distributed layerwise offload streams the remaining blocks.",
+        )
         # Video model parameters (e.g., Wan2.2) - engine-level
         omni_config_group.add_argument(
             "--boundary-ratio",
@@ -649,8 +704,7 @@ class OmniServeCommand(CLISubcommand):
             "--cfg-parallel-size",
             type=int,
             default=1,
-            choices=[1, 2],
-            help="Number of devices for CFG parallel computation for diffusion models. "
+            help="Number of devices used to execute diffusion guidance passes in parallel. "
             "Equivalent to setting DiffusionParallelConfig.cfg_parallel_size.",
         )
         omni_config_group.add_argument(
@@ -661,6 +715,15 @@ class OmniServeCommand(CLISubcommand):
             "Distributes VAE decode workload across multiple ranks by splitting the latent spatially. "
             "Equivalent to setting DiffusionParallelConfig.vae_patch_parallel_size.",
         )
+        omni_config_group.add_argument(
+            "--text-encoder-tp-size",
+            type=int,
+            default=1,
+            help="Tensor-parallel degree for the diffusion text encoder. "
+            "Shards the Qwen3-VL encoder across the first N DiT ranks, "
+            "removing the rank-0 encoder memory hotspot in no-offload runs. "
+            "Equivalent to setting DiffusionParallelConfig.text_encoder_tp_size.",
+        )
         omni_config_group.add_argument(
             "--vae-parallel-mode",
             type=str,
@@ -785,7 +848,6 @@ def run_headless(args: TrackingNamespace) -> None:
     omni_master_address: str | None = args.omni_master_address
     omni_master_port: int | None = args.omni_master_port
     worker_backend: str | None = args.worker_backend
-    stage_configs_path: str | None = args.stage_configs_path
     omni_replica_address: str | None = getattr(args, "omni_replica_address", None)
     omni_dp_size_local: int = max(1, int(getattr(args, "omni_dp_size_local", 1) or 1))
 
@@ -821,8 +883,12 @@ def run_headless(args: TrackingNamespace) -> None:
 
     config_path, stage_configs, _ = load_and_resolve_stage_configs(
         model,
-        stage_configs_path,
+        # The serve CLI no longer accepts legacy stage_args YAMLs.
+        None,
         args_dict,
+        # store_true cannot express an explicit False: absent maps to None
+        # ("not specified") so the deploy yaml's per-stage value applies.
+        trust_remote_code=getattr(args, "trust_remote_code", None) or None,
         deploy_config_path=args_dict.get("deploy_config"),
         stage_overrides=stage_overrides,
         strategy_config_path=args_dict.get("strategy_config"),
@@ -862,13 +928,16 @@ def run_headless(args: TrackingNamespace) -> None:
     stage_connector_spec = get_stage_connector_spec(
         omni_transfer_config=omni_transfer_config,
         stage_id=stage_id,
-        async_chunk=False,
+        async_chunk=bool(stage_cfg.engine_args.get("async_chunk", False)),
     )
 
     # ``runtime_cfg`` is mostly inherited from the parent's
     # CUDA_VISIBLE_DEVICES; when ``--omni-dp-size-local > 1`` we additionally
     # bracket each replica's spawn below with setup_stage_devices so they
     # don't all stack on cuda:0 (see ``per_replica_devices`` above).
+    # Headless startup still supplies the legacy OmegaConf stage shape through
+    # the stable adapter entry point. The implementation switches only when
+    # RFC #4021 threads structured stage configs through the launch plan.
     engine_args_dict = build_engine_args_dict(
         stage_cfg,
         model,
diff --git a/vllm_omni/entrypoints/client_request_state.py b/vllm_omni/entrypoints/client_request_state.py
index 316d4c2aa..9526df36a 100644
--- a/vllm_omni/entrypoints/client_request_state.py
+++ b/vllm_omni/entrypoints/client_request_state.py
@@ -4,7 +4,7 @@ from vllm_omni.metrics import OrchestratorAggregator
 
 
 class ClientRequestState:
-    """Tracks the state of an individual request in the orchestrator."""
+    """Tracks one entrypoint request and its output queue."""
 
     def __init__(
         self,
diff --git a/vllm_omni/entrypoints/omni_base.py b/vllm_omni/entrypoints/omni_base.py
index 304070dfa..3cae33661 100644
--- a/vllm_omni/entrypoints/omni_base.py
+++ b/vllm_omni/entrypoints/omni_base.py
@@ -7,7 +7,9 @@ from collections.abc import Sequence
 from typing import Any, Literal
 
 import huggingface_hub
+import vllm.envs as envs
 from vllm.logger import init_logger
+from vllm.transformers_utils.repo_utils import file_or_path_exists
 from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
@@ -63,11 +65,25 @@ def omni_snapshot_download(model_id: str) -> str:
 
     # TODO: this is just a workaround for quickly use modelscope, we should support
     # modelscope in weight loading feature instead of using `snapshot_download`
-    if os.environ.get("VLLM_USE_MODELSCOPE", False):
+    # Read through ``vllm.envs`` so the flag keeps vLLM's semantics (only
+    # "true", case-insensitive, enables ModelScope). Reading the raw variable
+    # here made every non-empty value truthy, so ``VLLM_USE_MODELSCOPE=0``
+    # took the ModelScope path while the rest of the stack stayed on HF.
+    if envs.VLLM_USE_MODELSCOPE:
         from modelscope.hub.snapshot_download import snapshot_download
 
         return snapshot_download(model_id)
 
+    # Modular Diffusers repositories describe independently loadable
+    # components. Let the selected pipeline download only its component
+    # sources instead of eagerly materializing the entire repository.
+    try:
+        if file_or_path_exists(model_id, "modular_model_index.json", revision=None):
+            return model_id
+    except (huggingface_hub.errors.GatedRepoError, huggingface_hub.errors.RepositoryNotFoundError):
+        # Preserve the more helpful errors raised by the full-download path.
+        pass
+
     try:
         download_weights_from_hf_specific(
             model_name_or_path=model_id,
@@ -144,7 +160,7 @@ class OmniBase(PDDisaggregationMixin):
         log_stats = kwargs.pop("log_stats", False)
         self._enable_ar_profiler = kwargs.pop("enable_ar_profiler", False)
         # NOTE: read-only lookup — must NOT pop. Popping here drops the key
-        # before it reaches ``StageConfigFactory._create_from_registry``, so
+        # before it reaches ``StageConfigFactory._create_legacy_from_registry``, so
         # ``--no-async-chunk`` (``async_chunk=False``) silently fails to
         # override the deploy YAML's ``async_chunk: true`` default.
         async_chunk = kwargs.get("async_chunk")
@@ -473,6 +489,7 @@ class OmniBase(PDDisaggregationMixin):
         req_start_ts: dict[str, float],
         wall_start_ts: float,
         final_stage_id_for_e2e: int,
+        stage_event_cursor: int = 0,
     ) -> OmniRequestOutput | None:
         req_id = result.request_id
         engine_outputs = result.engine_outputs
@@ -481,7 +498,7 @@ class OmniBase(PDDisaggregationMixin):
 
         # Merge AR stage timing from OrchestratorAggregator.stage_events
         if self._enable_ar_profiler:
-            ar_events = metrics.stage_events.get(str(req_id), [])
+            ar_events = metrics.stage_events.get(str(req_id), [])[stage_event_cursor:]
             for evt in ar_events:
                 if evt.stage_id != stage_id:
                     stage_durations[f"ar_stage_{evt.stage_id}"] = evt.stage_gen_time_ms / 1000.0
@@ -494,7 +511,7 @@ class OmniBase(PDDisaggregationMixin):
                     stage_durations[key] = value
 
         # Merge per-stage gen times into stage_durations
-        for evt in metrics.stage_events.get(str(req_id), []):
+        for evt in metrics.stage_events.get(str(req_id), [])[stage_event_cursor:]:
             key = f"stage_{evt.stage_id}_gen_ms"
             if key not in stage_durations:
                 stage_durations[key] = evt.stage_gen_time_ms
@@ -546,7 +563,7 @@ class OmniBase(PDDisaggregationMixin):
                 # Token counters — aggregate across all stages for this request.
                 _prompt_tok = 0
                 _gen_tok = 0
-                for evt in metrics.stage_events.get(rid_key, []):
+                for evt in metrics.stage_events.get(rid_key, [])[stage_event_cursor:]:
                     if evt.stage_id == 0:
                         _prompt_tok += int(evt.num_tokens_in)
                     _gen_tok += int(evt.num_tokens_out)
@@ -581,7 +598,7 @@ class OmniBase(PDDisaggregationMixin):
         response_metrics: dict[str, Any] = {}
         stage_metrics: dict[str, dict[str, Any]] = {}
         rid_key = str(req_id)
-        for evt in metrics.stage_events.get(rid_key, []):
+        for evt in metrics.stage_events.get(rid_key, [])[stage_event_cursor:]:
             if evt.stage_id is None:
                 continue
             sid = int(evt.stage_id)
@@ -604,7 +621,9 @@ class OmniBase(PDDisaggregationMixin):
                 response_metrics["num_tokens_out"] = current_stage_metrics["num_tokens_out"]
         return OmniRequestOutput(
             request_id=req_id or "",
+            finished=finished,
             stage_id=stage_id,
+            replica_id=result.replica_id,
             final_output_type=output_type,
             request_output=engine_outputs,
             images=images,
@@ -616,7 +635,6 @@ class OmniBase(PDDisaggregationMixin):
             metrics=response_metrics,
             stage_durations=stage_durations,
             peak_memory_mb=peak_memory_mb,
-            finished=finished,
         )
 
     def shutdown(self, timeout: float | None = None) -> None:
diff --git a/vllm_omni/entrypoints/openai/api_server.py b/vllm_omni/entrypoints/openai/api_server.py
index a9251a8d8..d59a7699f 100755
--- a/vllm_omni/entrypoints/openai/api_server.py
+++ b/vllm_omni/entrypoints/openai/api_server.py
@@ -11,6 +11,7 @@ import os
 
 # Image generation API imports
 import random
+import tempfile
 import time
 from argparse import Namespace
 from collections.abc import AsyncIterator
@@ -94,10 +95,10 @@ from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 from vllm_omni.config.endpoint_policy import shutdown_unsupported_routes
 from vllm_omni.diffusion.models.interface import ReferenceVideoDecodeSpec
 from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.openai.duplex_capability import should_enable_duplex_endpoint
 from vllm_omni.entrypoints.openai.errors import InvalidInputReferenceError
 from vllm_omni.entrypoints.openai.image_api_utils import (
     SUPPORTED_LAYERED_RESOLUTIONS,
-    encode_image_base64,
     encode_image_base64_with_compression,
     parse_size,
     validate_layered_layers,
@@ -143,7 +144,11 @@ from vllm_omni.entrypoints.openai.stage_params import (
 from vllm_omni.entrypoints.openai.storage import STORAGE_MANAGER, FileStorageHandle
 from vllm_omni.entrypoints.openai.stores import VIDEO_STORE, VIDEO_TASKS
 from vllm_omni.entrypoints.openai.utils import get_stage_type, parse_lora_request
-from vllm_omni.entrypoints.openai.video_api_utils import decode_audio_url, decode_input_reference
+from vllm_omni.entrypoints.openai.video_api_utils import (
+    VideoFrames,
+    decode_audio_url,
+    decode_input_reference,
+)
 from vllm_omni.entrypoints.openpi.serving import ServingRealtimeRobotOpenPI
 from vllm_omni.errors import OmniClientError
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
@@ -154,6 +159,13 @@ logger = init_logger(__name__)
 router = APIRouter()
 
 MAX_UINT32_SEED = 2**32 - 1
+MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES = 30 * 1024 * 1024
+MINIMAX_H3_MAX_REFERENCE_VIDEO_BYTES = 50 * 1024 * 1024
+MINIMAX_H3_MAX_REFERENCE_AUDIO_BYTES = 15 * 1024 * 1024
+MINIMAX_H3_MAX_REFERENCE_COUNT = 12
+MINIMAX_H3_REFERENCE_IMAGE_FORMATS = frozenset({"jpeg", "png", "webp", "heic", "heif"})
+MINIMAX_H3_REFERENCE_VIDEO_SUFFIXES = frozenset({".mp4", ".mov"})
+MINIMAX_H3_REFERENCE_AUDIO_SUFFIXES = frozenset({".wav", ".mp3"})
 profiler_router = APIRouter()
 
 
@@ -793,6 +805,7 @@ async def omni_init_app_state(
             model_name=model_name,
             stage_configs=diffusion_stage_configs,
         )
+        state.openai_serving_duplex = None
         state.openai_streaming_speech = None
         state.openai_streaming_video = None
         state.openai_serving_realtime_robot = ServingRealtimeRobotOpenPI.create_policy_server(
@@ -1112,6 +1125,18 @@ async def omni_init_app_state(
         if state.openai_serving_chat is not None
         else None
     )
+    state.openai_serving_duplex = None
+    if state.openai_serving_chat is not None and should_enable_duplex_endpoint(
+        state.stage_configs,
+        config_path=getattr(args, "stage_configs_path", None) or getattr(args, "deploy_config", None),
+    ):
+        from vllm_omni.experimental.fullduplex.openai.serving import OmniDuplexSessionHandler
+
+        state.openai_serving_duplex = OmniDuplexSessionHandler(
+            chat_service=state.openai_serving_chat,
+            duplex_session_config=getattr(engine_client, "duplex_session_config", None),
+            serving_runtime_adapter_path=getattr(engine_client, "duplex_serving_adapter_path", None),
+        )
     state.openai_serving_realtime = OpenAIServingRealtime(
         engine_client=engine_client,
         models=state.openai_serving_models,
@@ -1558,8 +1583,9 @@ async def delete_voice(name: str, raw_request: Request):
 async def streaming_speech(websocket: WebSocket):
     """WebSocket endpoint for streaming text input TTS.
 
-    Accepts text incrementally, splits at sentence boundaries, and
-    returns audio per sentence. See serving_speech_stream.py for protocol.
+    Accepts text incrementally and returns audio for the buffered text on
+    input.done, which flushes without closing the connection. See
+    serving_speech_stream.py for protocol.
     """
     handler = getattr(websocket.app.state, "openai_streaming_speech", None)
     if handler is None:
@@ -1612,6 +1638,15 @@ async def streaming_video_output(websocket: WebSocket):
 @router.websocket("/v1/realtime")
 async def realtime_websocket(websocket: WebSocket):
     """WebSocket endpoint for OpenAI-style realtime interactions."""
+    duplex_handler = getattr(websocket.app.state, "openai_serving_duplex", None)
+    duplex_query = websocket.query_params.get("duplex")
+    use_duplex_realtime = (
+        duplex_handler is not None and isinstance(duplex_query, str) and duplex_query.lower() in {"1", "true", "on"}
+    )
+    if use_duplex_realtime and duplex_handler is not None:
+        await duplex_handler.handle_realtime_session(websocket)
+        return
+
     serving = getattr(websocket.app.state, "openai_serving_realtime", None)
     if serving is None:
         await websocket.accept()
@@ -1639,6 +1674,18 @@ async def realtime_robot_openpi(websocket: WebSocket):
     await connection.handle_connection()
 
 
+@router.websocket("/v1/duplex")
+async def duplex_websocket(websocket: WebSocket):
+    """WebSocket endpoint for vLLM-Omni duplex session control."""
+    handler = getattr(websocket.app.state, "openai_serving_duplex", None)
+    if handler is None:
+        await websocket.accept()
+        await websocket.send_json({"type": "error", "error": "Duplex API is not available", "code": "unsupported"})
+        await websocket.close()
+        return
+    await handler.handle_session(websocket)
+
+
 # Health and Model endpoints for diffusion mode
 
 
@@ -1695,6 +1742,39 @@ async def show_available_models(raw_request: Request) -> JSONResponse:
 # Image generation API endpoints
 
 
+def _build_image_generation_response(
+    *,
+    images: list[Image.Image],
+    request: ImageGenerationRequest,
+    stage_durations: Any,
+    peak_memory_mb: Any,
+) -> ImageGenerationResponse | StreamingResponse:
+    """Encode generated images and apply the requested response format."""
+    output_format = _choose_output_format(request.output_format or "png", None)
+    image_data = [
+        ImageData(
+            b64_json=encode_image_base64_with_compression(image, format=output_format),
+            revised_prompt=None,
+        )
+        for image in images
+    ]
+    response_kwargs: dict[str, Any] = {
+        "created": int(time.time()),
+        "data": image_data,
+        "output_format": output_format,
+        "metrics": {
+            "stage_durations": stage_durations or None,
+            "peak_memory_mb": float(peak_memory_mb) if peak_memory_mb else None,
+        },
+    }
+    if request.size is not None:
+        response_kwargs["size"] = request.size
+    response = ImageGenerationResponse(**response_kwargs)
+    if request.response_format == ResponseFormat.FILE:
+        return response.stream_response()
+    return response
+
+
 @router.post(
     "/v1/images/generations",
     dependencies=[Depends(validate_json_request)],
@@ -1795,10 +1875,13 @@ async def generate_images(
                     status_code=generation_result.error.code if generation_result.error else 400,
                     content=generation_result.model_dump(),
                 )
-            flat_images, _, _, _ = generation_result
-            image_data = [ImageData(b64_json=encode_image_base64(img), revised_prompt=None) for img in flat_images]
-
-            return ImageGenerationResponse(created=int(time.time()), data=image_data)
+            flat_images, stage_durations, peak_memory_mb, _ = generation_result
+            return _build_image_generation_response(
+                images=flat_images,
+                request=request,
+                stage_durations=stage_durations,
+                peak_memory_mb=peak_memory_mb,
+            )
 
         # Build params - pass through user values directly
         prompt: OmniTextPrompt = {"prompt": request.prompt, "modalities": ["image"]}
@@ -1864,7 +1947,7 @@ async def generate_images(
 
         logger.debug(f"Generating {request.n} image(s) {size_str}")
 
-        # Generate images using AsyncOmni (multi-stage mode)
+        # Generate images using AsyncOmni.
         result = await _generate_with_async_omni(
             engine_client=engine_client,
             gen_params=gen_params,
@@ -1885,26 +1968,14 @@ async def generate_images(
 
         logger.debug(f"Successfully generated {len(images)} image(s)")
 
-        # Determine output format (default to png)
-        output_format = _choose_output_format(request.output_format or "png", None)
-
-        # Encode images to base64 with the specified format
-        image_data = [
-            ImageData(b64_json=encode_image_base64_with_compression(img, format=output_format), revised_prompt=None)
-            for img in images
-        ]
-
-        response_kwargs = {
-            "created": int(time.time()),
-            "data": image_data,
-            "output_format": output_format,
-        }
-        if request.size:
-            response_kwargs["size"] = size_str
-        response = ImageGenerationResponse(**response_kwargs)
-        if request.response_format != ResponseFormat.FILE:
-            return response
-        return response.stream_response()
+        stage_durations = getattr(result, "stage_durations", None)
+        peak_memory_mb = getattr(result, "peak_memory_mb", None)
+        return _build_image_generation_response(
+            images=images,
+            request=request,
+            stage_durations=stage_durations,
+            peak_memory_mb=peak_memory_mb,
+        )
 
     except (EngineGenerateError, EngineDeadError) as exc:
         return _create_engine_error_json_response(raw_request, exc)
@@ -1955,6 +2026,7 @@ async def edit_images(
     negative_prompt: str | None = Form(None),
     num_inference_steps: int | None = Form(None),
     guidance_scale: float | None = Form(None),
+    guidance_scale_2: float | None = Form(None),
     strength: float | None = Form(None),
     true_cfg_scale: float | None = Form(None),
     seed: int | None = Form(None),
@@ -2120,6 +2192,7 @@ async def edit_images(
         # 3.4 Add optional parameters ONLY if provided
         _update_if_not_none(gen_params, "num_inference_steps", num_inference_steps)
         _update_if_not_none(gen_params, "guidance_scale", guidance_scale)
+        _update_if_not_none(gen_params, "guidance_scale_2", guidance_scale_2)
         _update_if_not_none(gen_params, "strength", strength)
         _update_if_not_none(gen_params, "true_cfg_scale", true_cfg_scale)
         # If seed is not provided, generate a random one to ensure
@@ -2185,6 +2258,8 @@ async def edit_images(
                 extra_body["num_inference_steps"] = num_inference_steps
             if guidance_scale is not None:
                 extra_body["guidance_scale"] = guidance_scale
+            if guidance_scale_2 is not None:
+                extra_body["guidance_scale_2"] = guidance_scale_2
             if strength is not None:
                 extra_body["strength"] = strength
             if true_cfg_scale is not None:
@@ -2793,6 +2868,21 @@ async def _cleanup_video(video_id: str):
         logger.warning("Failed to cleanup partial video file '%s'", video_id)
 
 
+def _cleanup_video_references(
+    reference_video: ReferenceVideo | None,
+    reference_audio: ReferenceAudio | None,
+) -> None:
+    if reference_video is not None:
+        for path in reference_video.cleanup_paths:
+            if os.path.exists(path):
+                os.unlink(path)
+    if reference_audio is not None:
+        cleanup_paths = reference_audio.cleanup_paths or tuple(_reference_list(reference_audio.path))
+        for path in cleanup_paths:
+            if os.path.exists(path):
+                os.unlink(path)
+
+
 async def _run_video_generation_job(
     handler: OmniOpenAIServingVideo,
     request: VideoGenerationRequest,
@@ -2873,17 +2963,178 @@ async def _run_video_generation_job(
         await VIDEO_STORE.pop(video_id)
         raise
     finally:
-        if reference_audio is not None and os.path.exists(reference_audio.path):
-            os.unlink(reference_audio.path)
+        _cleanup_video_references(reference_video, reference_audio)
 
 
 VIDEO_SYNC_TIMEOUT_S = float(os.environ.get("VLLM_OMNI_VIDEO_SYNC_TIMEOUT", 600.0))
 
 
+async def _persist_uploaded_video_references(uploads: list[UploadFile]) -> list[str]:
+    paths: list[str] = []
+    try:
+        for upload in uploads:
+            suffix = Path(upload.filename or "").suffix.lower()
+            if suffix not in {".mkv", ".mov", ".mp4", ".webm"}:
+                suffix = ".mp4"
+            fd, path = tempfile.mkstemp(prefix="vllm_omni_video_reference_", suffix=suffix)
+            paths.append(path)
+            with os.fdopen(fd, "wb") as output:
+                while chunk := await upload.read(1024 * 1024):
+                    output.write(chunk)
+    except Exception:
+        for path in paths:
+            if os.path.exists(path):
+                os.unlink(path)
+        raise
+    return paths
+
+
+def _reference_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    return list(value) if isinstance(value, list) else [value]
+
+
+def _uploaded_media_kind(upload: UploadFile) -> str:
+    content_type = (upload.content_type or "").lower()
+    if content_type.startswith("image/"):
+        return "image"
+    if content_type.startswith("audio/"):
+        return "audio"
+    suffix = Path(upload.filename or "").suffix.lower()
+    if suffix in {".png", ".jpg", ".jpeg", ".webp", ".heic", ".heif"}:
+        return "image"
+    if suffix in {".wav", ".mp3", ".m4a", ".aac", ".flac", ".ogg"}:
+        return "audio"
+    return "video"
+
+
+def _minimax_h3_upload_limit(upload: UploadFile) -> int:
+    kind = _uploaded_media_kind(upload)
+    if kind == "image":
+        return MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES
+    if kind == "audio":
+        return MINIMAX_H3_MAX_REFERENCE_AUDIO_BYTES
+    return MINIMAX_H3_MAX_REFERENCE_VIDEO_BYTES
+
+
+async def _read_upload_limited(upload: UploadFile, *, max_bytes: int | None = None) -> bytes:
+    """Read an upload with an optional hard byte limit."""
+    if max_bytes is None:
+        return await upload.read()
+
+    declared_size = getattr(upload, "size", None)
+    if isinstance(declared_size, Integral) and int(declared_size) > max_bytes:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=f"Uploaded reference exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
+        )
+
+    chunks: list[bytes] = []
+    total = 0
+    while True:
+        chunk = await upload.read(min(1024 * 1024, max_bytes - total + 1))
+        if not chunk:
+            break
+        total += len(chunk)
+        if total > max_bytes:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST.value,
+                detail=f"Uploaded reference exceeds the {max_bytes // (1024 * 1024)} MiB size limit.",
+            )
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def _validate_minimax_h3_image_payload(
+    payload: bytes,
+    *,
+    filename: str | None,
+    allow_non_image: bool = False,
+) -> None:
+    """Validate a H3 image before converting it to a format-less PIL image."""
+    try:
+        with Image.open(io.BytesIO(payload)) as image:
+            image_format = str(image.format or "").lower()
+    except (OSError, ValueError) as exc:
+        if allow_non_image:
+            return
+        raise HTTPException(400, detail=f"Invalid uploaded image reference: {filename}") from exc
+
+    if image_format not in MINIMAX_H3_REFERENCE_IMAGE_FORMATS:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=(
+                "MiniMax H3 reference images must use JPG, JPEG, PNG, WEBP, HEIC, or HEIF; "
+                f"got {image_format or 'unknown'}."
+            ),
+        )
+
+
+async def _persist_uploaded_media_references(
+    uploads: list[UploadFile],
+) -> tuple[list[Image.Image], list[str], list[str]]:
+    """Persist a mixed MiniMax H3 multipart reference list.
+
+    Images are decoded in memory; videos and audio remain files because H3's
+    reference encoders need the original container streams (including video
+    soundtracks).
+    """
+    images: list[Image.Image] = []
+    videos: list[str] = []
+    audios: list[str] = []
+    paths: list[str] = []
+    if len(uploads) > MINIMAX_H3_MAX_REFERENCE_COUNT:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=f"MiniMax H3 accepts at most {MINIMAX_H3_MAX_REFERENCE_COUNT} total references.",
+        )
+    try:
+        for upload in uploads:
+            kind = _uploaded_media_kind(upload)
+            payload = await _read_upload_limited(upload, max_bytes=_minimax_h3_upload_limit(upload))
+            if kind == "image":
+                try:
+                    _validate_minimax_h3_image_payload(payload, filename=upload.filename)
+                    with Image.open(io.BytesIO(payload)) as image:
+                        images.append(image.convert("RGB"))
+                except (OSError, ValueError) as exc:
+                    raise HTTPException(400, detail=f"Invalid uploaded image reference: {upload.filename}") from exc
+                continue
+            suffix = Path(upload.filename or "").suffix.lower()
+            if kind == "video" and suffix and suffix not in MINIMAX_H3_REFERENCE_VIDEO_SUFFIXES:
+                raise HTTPException(
+                    status_code=HTTPStatus.BAD_REQUEST.value,
+                    detail="MiniMax H3 reference videos must use an MP4 or MOV file.",
+                )
+            if kind == "audio" and suffix and suffix not in MINIMAX_H3_REFERENCE_AUDIO_SUFFIXES:
+                raise HTTPException(
+                    status_code=HTTPStatus.BAD_REQUEST.value,
+                    detail="MiniMax H3 reference audio must use a WAV or MP3 file.",
+                )
+            if not suffix or len(suffix) > 8:
+                suffix = ".mp3" if kind == "audio" else ".mp4"
+            fd, path = tempfile.mkstemp(prefix="vllm_omni_reference_", suffix=suffix)
+            paths.append(path)
+            with os.fdopen(fd, "wb") as output:
+                output.write(payload)
+            if kind == "audio":
+                audios.append(path)
+            else:
+                videos.append(path)
+    except Exception:
+        for path in paths:
+            if os.path.exists(path):
+                os.unlink(path)
+        raise
+    return images, videos, audios
+
+
 async def _parse_video_form(
     raw_request: Request,
     prompt: str = Form(...),
     input_reference: UploadFile | None = File(default=None),
+    input_references: list[UploadFile] | None = File(default=None),
     image_reference: str | None = Form(default=None),
     video_reference: str | None = Form(default=None),
     audio_reference: str | None = Form(default=None),
@@ -2895,6 +3146,10 @@ async def _parse_video_form(
     height: int | None = Form(default=None),
     num_frames: int | None = Form(default=None),
     fps: int | None = Form(default=None),
+    aspect_ratio: str | None = Form(default=None),
+    short_edge: int | None = Form(default=None, ge=1),
+    num_outputs_per_prompt: int = Form(default=1, ge=1, le=10),
+    start_time_seconds: float | None = Form(default=None, ge=0.0),
     num_inference_steps: int | None = Form(default=None),
     guidance_scale: float | None = Form(default=None),
     guidance_scale_2: float | None = Form(default=None),
@@ -2924,18 +3179,26 @@ async def _parse_video_form(
 
     Used by both ``POST /v1/videos`` (async) and ``POST /v1/videos/sync``.
     """
-    input_reference_bytes = await input_reference.read() if input_reference is not None else None
+    input_references = input_references or []
+    input_reference_bytes: bytes | None = None
     parsed_image_reference = _parse_form_json(image_reference)
     parsed_video_reference = _parse_form_json(video_reference)
     parsed_audio_reference = _parse_form_json(audio_reference)
 
-    provided_references = sum(
-        item is not None for item in (parsed_image_reference, parsed_video_reference, input_reference_bytes)
-    )
-    if provided_references > 1:
+    if input_references and any(
+        item is not None for item in (parsed_image_reference, parsed_video_reference, input_reference)
+    ):
         raise HTTPException(
             status_code=HTTPStatus.BAD_REQUEST.value,
-            detail="Provide only one of input_reference, image_reference, or video_reference.",
+            detail="Provide input_references alone, without input_reference, image_reference, or video_reference.",
+        )
+    if input_reference is not None and (parsed_image_reference is not None or parsed_video_reference is not None):
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST.value,
+            detail=(
+                "Provide only one of input_reference, image_reference, or video_reference when using "
+                "input_reference; image_reference and video_reference may be combined."
+            ),
         )
 
     request_data: dict[str, Any] = {
@@ -2951,6 +3214,10 @@ async def _parse_video_form(
         "height": height,
         "num_frames": num_frames,
         "fps": fps,
+        "aspect_ratio": aspect_ratio,
+        "short_edge": short_edge,
+        "num_outputs_per_prompt": num_outputs_per_prompt,
+        "start_time_seconds": start_time_seconds,
         "num_inference_steps": num_inference_steps,
         "guidance_scale": guidance_scale,
         "guidance_scale_2": guidance_scale_2,
@@ -2999,35 +3266,127 @@ async def _parse_video_form(
             detail=f"Video generation setup failed: {str(e)}",
         )
 
+    supports_mixed_reference_inputs = bool(getattr(handler, "supports_mixed_reference_inputs", False))
+    if input_reference is not None:
+        input_reference_bytes = await _read_upload_limited(
+            input_reference,
+            max_bytes=_minimax_h3_upload_limit(input_reference) if supports_mixed_reference_inputs else None,
+        )
+        if supports_mixed_reference_inputs:
+            input_reference_kind = _uploaded_media_kind(input_reference)
+            _validate_minimax_h3_image_payload(
+                input_reference_bytes,
+                filename=input_reference.filename,
+                allow_non_image=input_reference_kind != "image",
+            )
+
     decode_spec = ReferenceVideoDecodeSpec()
-    if parsed_video_reference is not None or input_reference_bytes is not None:
+    if not input_references and (parsed_video_reference is not None or input_reference_bytes is not None):
         stage_configs = (
             handler.stage_configs
             or app_stage_configs
             or getattr(getattr(handler, "_engine_client", None), "stage_configs", None)
         )
         decode_spec = _reference_video_decode_spec(request, stage_configs)
-    try:
-        media_data = await decode_input_reference(
-            request.image_reference,
-            request.video_reference,
-            input_reference_bytes,
-            max_video_frames=decode_spec.max_frames,
-            video_keep=decode_spec.keep,
-        )
-    except InvalidInputReferenceError as exc:
-        raise HTTPException(400, detail=str(exc) or "Invalid input reference.") from exc
-
-    reference_image = ReferenceImage(data=media_data) if isinstance(media_data, Image.Image) else None
-    reference_video = ReferenceVideo(data=media_data) if isinstance(media_data, list) else None
-
+    reference_image = None
+    reference_video = None
     reference_audio: ReferenceAudio | None = None
+    if input_references:
+        if not supports_mixed_reference_inputs:
+            video_paths = await _persist_uploaded_video_references(input_references)
+            reference_video = ReferenceVideo(data=video_paths, cleanup_paths=tuple(video_paths))
+            images, audio_paths = [], []
+        else:
+            images, video_paths, audio_paths = await _persist_uploaded_media_references(input_references)
+        if images:
+            reference_image = ReferenceImage(data=images if len(images) > 1 else images[0])
+        if video_paths:
+            reference_video = ReferenceVideo(data=video_paths, cleanup_paths=tuple(video_paths))
+        if audio_paths:
+            reference_audio = ReferenceAudio(path=audio_paths, cleanup_paths=tuple(audio_paths))
+    else:
+        video_paths: list[str] = []
+        try:
+            image_items = _reference_list(request.image_reference)
+            video_items = _reference_list(request.video_reference)
+            image_data = []
+            for item in image_items:
+                media_data = await decode_input_reference(item, None, None)
+                if not isinstance(media_data, Image.Image):
+                    raise InvalidInputReferenceError("image_reference did not decode to an image")
+                image_data.append(media_data)
+
+            video_frames: list[Image.Image] | None = None
+            for item in video_items:
+                media_data = await decode_input_reference(
+                    None,
+                    item,
+                    None,
+                    max_video_frames=decode_spec.max_frames,
+                    video_keep=decode_spec.keep,
+                )
+                if not isinstance(media_data, VideoFrames):
+                    raise InvalidInputReferenceError("video_reference did not decode to a video")
+                if media_data.source_path is not None:
+                    video_paths.append(media_data.source_path)
+                else:
+                    if len(video_items) != 1:
+                        raise InvalidInputReferenceError(
+                            "multiple video URL references must be downloadable source videos"
+                        )
+                    video_frames = list(media_data)
+
+            if input_reference_bytes is not None:
+                media_data = await decode_input_reference(
+                    None,
+                    None,
+                    input_reference_bytes,
+                    max_video_frames=decode_spec.max_frames,
+                    video_keep=decode_spec.keep,
+                )
+                if isinstance(media_data, Image.Image):
+                    image_data.append(media_data)
+                elif isinstance(media_data, VideoFrames):
+                    if media_data.source_path is not None:
+                        video_paths.append(media_data.source_path)
+                    else:
+                        video_frames = list(media_data)
+
+            if image_data:
+                reference_image = ReferenceImage(data=image_data if len(image_data) > 1 else image_data[0])
+            if video_paths:
+                reference_video = ReferenceVideo(data=video_paths, cleanup_paths=tuple(video_paths))
+            elif video_frames is not None:
+                reference_video = ReferenceVideo(data=video_frames)
+        except InvalidInputReferenceError as exc:
+            for path in video_paths:
+                if os.path.exists(path):
+                    os.unlink(path)
+            raise HTTPException(400, detail=str(exc) or "Invalid input reference.") from exc
+
+    audio_paths = [] if reference_audio is None else list(_reference_list(reference_audio.path))
     if request.audio_reference is not None:
         try:
-            audio_path = await decode_audio_url(request.audio_reference.audio_url)
+            for audio_reference in _reference_list(request.audio_reference):
+                audio_paths.append(await decode_audio_url(audio_reference.audio_url))
         except InvalidInputReferenceError as exc:
+            _cleanup_video_references(reference_video, reference_audio)
+            cleanup_paths = set(() if reference_audio is None else reference_audio.cleanup_paths)
+            for path in audio_paths:
+                if path not in cleanup_paths and os.path.exists(path):
+                    os.unlink(path)
             raise HTTPException(400, detail=str(exc)) from exc
-        reference_audio = ReferenceAudio(path=audio_path)
+    if audio_paths:
+        cleanup_paths = (
+            tuple(audio_paths)
+            if reference_audio is None
+            else reference_audio.cleanup_paths
+            + tuple(path for path in audio_paths if path not in reference_audio.cleanup_paths)
+        )
+        reference_audio = ReferenceAudio(
+            path=audio_paths if len(audio_paths) > 1 else audio_paths[0],
+            cleanup_paths=cleanup_paths,
+        )
 
     return request, handler, effective_model_name, reference_image, reference_video, reference_audio
 
@@ -3138,8 +3497,7 @@ async def create_video_sync(
             detail=f"Video generation failed: {str(exc)}",
         ) from exc
     finally:
-        if reference_audio is not None and os.path.exists(reference_audio.path):
-            os.unlink(reference_audio.path)
+        _cleanup_video_references(reference_video, reference_audio)
     inference_time_s = time.perf_counter() - started_at
 
     return Response(
diff --git a/vllm_omni/entrypoints/openai/audio_utils_mixin.py b/vllm_omni/entrypoints/openai/audio_utils_mixin.py
index 12024013d..6c7043201 100644
--- a/vllm_omni/entrypoints/openai/audio_utils_mixin.py
+++ b/vllm_omni/entrypoints/openai/audio_utils_mixin.py
@@ -5,7 +5,7 @@ import torch
 import torchaudio
 from vllm.logger import init_logger
 
-from vllm_omni.entrypoints.openai.protocol.audio import AudioResponse, CreateAudio
+from vllm_omni.entrypoints.openai.protocol.audio import DEFAULT_AUDIO_FORMAT, AudioResponse, CreateAudio
 
 try:
     import soundfile
@@ -49,13 +49,12 @@ class AudioMixin:
             "pcm": ("RAW", "audio/pcm", {"subtype": "PCM_16"}),
             "flac": ("FLAC", "audio/flac", {}),
             "mp3": ("MP3", "audio/mpeg", {}),
-            "aac": ("AAC", "audio/aac", {}),
             "opus": ("OGG", "audio/ogg", {"subtype": "OPUS"}),
         }
 
         if response_format not in supported_formats:
-            logger.warning(f"Unsupported response format '{response_format}', defaulting to 'wav'.")
-            response_format = "wav"
+            logger.warning(f"Unsupported response format '{response_format}', defaulting to '{DEFAULT_AUDIO_FORMAT}'.")
+            response_format = DEFAULT_AUDIO_FORMAT
 
         soundfile_format, media_type, kwargs = supported_formats[response_format]
 
diff --git a/vllm_omni/entrypoints/openai/diffusion_request_utils.py b/vllm_omni/entrypoints/openai/diffusion_request_utils.py
new file mode 100644
index 000000000..84fec8a3a
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/diffusion_request_utils.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from collections.abc import Collection, Mapping
+
+from vllm.logger import init_logger
+
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+logger = init_logger(__name__)
+
+
+def _request_mapping(name: str, value: object | None) -> dict[str, object]:
+    if value is None:
+        return {}
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{name} must be a JSON object.")
+    if any(not isinstance(key, str) for key in value):
+        raise ValueError(f"{name} must be a JSON object with string keys.")
+    return dict(value)
+
+
+def normalize_diffusion_request_args(
+    *,
+    root: object | None = None,
+    nested: object | None = None,
+    explicit_root_args: object | None = None,
+    serving_root_fields: Collection[str] = (),
+    registered_extra_fields: Collection[str] = (),
+    root_field_aliases: Mapping[str, str] | None = None,
+) -> tuple[dict[str, object], dict[str, object]]:
+    """Validate request sources and project diffusion consumer arguments."""
+    root_args = _request_mapping("request", root)
+    root_args.update(_request_mapping("explicit_root_args", explicit_root_args))
+    nested_args = _request_mapping("request.extra_body", nested)
+
+    registered = set(registered_extra_fields)
+    aliases = {alias: canonical for alias, canonical in (root_field_aliases or {}).items() if alias not in registered}
+    serving_fields = set(serving_root_fields) | aliases.keys()
+    declared_fields = registered - serving_fields
+    consumer_fields = serving_fields | declared_fields
+
+    root_declared = {key: root_args[key] for key in declared_fields if key in root_args}
+    nested_declared = {key: nested_args[key] for key in declared_fields if key in nested_args}
+    canonical = _request_mapping("extra_args", root_args.get("extra_args"))
+    legacy = _request_mapping("extra_params", root_args.get("extra_params"))
+    nested_canonical = _request_mapping("extra_body.extra_args", nested_args.get("extra_args"))
+    nested_legacy = _request_mapping("extra_body.extra_params", nested_args.get("extra_params"))
+
+    sources_by_key: dict[str, list[str]] = {}
+    sources = (
+        ((root_args.keys() & serving_fields) | root_declared.keys(), "request"),
+        ((nested_args.keys() & serving_fields) | nested_declared.keys(), "request.extra_body"),
+        (canonical, "request.extra_args"),
+        (legacy, "request.extra_params"),
+        (nested_canonical, "request.extra_body.extra_args"),
+        (nested_legacy, "request.extra_body.extra_params"),
+    )
+    for keys, prefix in sources:
+        for key in sorted(keys):
+            sources_by_key.setdefault(aliases.get(key, key), []).append(f"{prefix}.{key}")
+
+    conflicts = {key: list(dict.fromkeys(paths)) for key, paths in sources_by_key.items() if len(set(paths)) > 1}
+    if conflicts:
+        details = "; ".join(f'"{key}": {", ".join(conflicts[key])}' for key in sorted(conflicts))
+        raise ValueError(f"Diffusion request parameters were provided more than once: {details}.")
+
+    if root_args.get("extra_params") is not None or nested_args.get("extra_params") is not None:
+        logger.warning_once(
+            "extra_params is deprecated; use extra_args for model-specific diffusion request parameters."
+        )
+
+    # Duplicate request keys were rejected above, so ordering is not precedence.
+    normalized_extra_args = {
+        **nested_declared,
+        **root_declared,
+        **legacy,
+        **nested_legacy,
+        **canonical,
+        **nested_canonical,
+    }
+    normalized_extra_args = {key: value for key, value in normalized_extra_args.items() if value is not None}
+
+    request_args = {
+        **{key: nested_args[key] for key in consumer_fields if key in nested_args},
+        **{key: root_args[key] for key in consumer_fields if key in root_args},
+    }
+    for alias, canonical_name in aliases.items():
+        if alias in request_args:
+            request_args[canonical_name] = request_args.pop(alias)
+    return normalized_extra_args, request_args
+
+
+def apply_normalized_diffusion_request_extra_args(
+    sampling_params: OmniDiffusionSamplingParams,
+    normalized_extra_args: Mapping[str, object],
+) -> None:
+    """Overlay request extras without discarding stage defaults."""
+    if normalized_extra_args:
+        sampling_params.extra_args = {
+            **(sampling_params.extra_args or {}),
+            **normalized_extra_args,
+        }
diff --git a/vllm_omni/entrypoints/openai/duplex_capability.py b/vllm_omni/entrypoints/openai/duplex_capability.py
new file mode 100644
index 000000000..c3e4e3e38
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/duplex_capability.py
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+def should_enable_duplex_endpoint(
+    stage_configs: list | None,
+    *,
+    config_path: str | None = None,
+) -> bool:
+    """Enable duplex routes only for deployments that explicitly opt in."""
+    if stage_configs:
+        for stage in stage_configs:
+            session_mode = (
+                stage.get("session_mode") if isinstance(stage, dict) else getattr(stage, "session_mode", None)
+            )
+            if session_mode == "duplex":
+                return True
+    if config_path:
+        try:
+            from omegaconf import OmegaConf
+
+            raw_config = OmegaConf.load(config_path)
+            session_mode = raw_config.get("session_mode") if hasattr(raw_config, "get") else None
+            if session_mode == "duplex":
+                return True
+        except Exception as exc:
+            logger.warning("Failed to inspect duplex session_mode from %s: %s", config_path, exc)
+    return False
+
+
+__all__ = ["should_enable_duplex_endpoint"]
diff --git a/vllm_omni/entrypoints/openai/image_api_utils.py b/vllm_omni/entrypoints/openai/image_api_utils.py
index 5bd79e936..ed759a080 100644
--- a/vllm_omni/entrypoints/openai/image_api_utils.py
+++ b/vllm_omni/entrypoints/openai/image_api_utils.py
@@ -101,13 +101,14 @@ def encode_image_base64_with_compression(
     """
     buffer = io.BytesIO()
     image = prepare_image_for_output_format(image, format)
+    pil_format = "jpeg" if format == "jpg" else format
     save_kwargs = {}
     if format in ("jpg", "jpeg", "webp"):
         save_kwargs["quality"] = output_compression
     elif format == "png":
         save_kwargs["compress_level"] = max(0, min(9, 9 - output_compression // 11))
 
-    image.save(buffer, format=format, **save_kwargs)
+    image.save(buffer, format=pil_format, **save_kwargs)
     buffer.seek(0)
     return base64.b64encode(buffer.read()).decode("utf-8")
 
diff --git a/vllm_omni/entrypoints/openai/protocol/audio.py b/vllm_omni/entrypoints/openai/protocol/audio.py
index ad7bf8fae..92b2efd14 100644
--- a/vllm_omni/entrypoints/openai/protocol/audio.py
+++ b/vllm_omni/entrypoints/openai/protocol/audio.py
@@ -6,6 +6,10 @@ from pydantic import AliasChoices, BaseModel, Field, field_validator, model_vali
 
 _MAX_EMBEDDING_DIM = 8192
 
+SUPPORTED_AUDIO_FORMATS: frozenset[str] = frozenset({"wav", "pcm", "flac", "mp3", "opus"})
+SUPPORTED_CHAT_AUDIO_FORMATS: frozenset[str] = SUPPORTED_AUDIO_FORMATS | {"pcm16"}
+DEFAULT_AUDIO_FORMAT: str = "wav"
+
 
 def _normalize_ref_audio_value(value):
     if value is None:
@@ -59,7 +63,7 @@ class OpenAICreateSpeechRequest(BaseModel):
         default=None,
         description="Instructions for voice style/emotion (maps to 'instruct' for Qwen3-TTS)",
     )
-    response_format: Literal["wav", "pcm", "flac", "mp3", "aac", "opus"] = "wav"
+    response_format: Literal["wav", "pcm", "flac", "mp3", "opus"] = DEFAULT_AUDIO_FORMAT
     speed: float | None = Field(
         default=1.0,
         ge=0.25,
@@ -325,7 +329,7 @@ class OpenAICreateAudioGenerateRequest(BaseModel):
         description="Text prompt describing the audio to generate",
     )
     model: str | None = None
-    response_format: Literal["wav", "pcm", "flac", "mp3", "aac", "opus"] = "wav"
+    response_format: Literal["wav", "pcm", "flac", "mp3", "opus"] = DEFAULT_AUDIO_FORMAT
     speed: float | None = Field(
         default=1.0,
         ge=0.25,
@@ -391,7 +395,7 @@ class SpeechBatchItem(BaseModel):
     input: str
     voice: str | None = Field(default=None, validation_alias=AliasChoices("voice", "speaker"))
     instructions: str | None = None
-    response_format: Literal["wav", "pcm", "flac", "mp3", "aac", "opus"] | None = None
+    response_format: Literal["wav", "pcm", "flac", "mp3", "opus"] | None = None
     speed: float | None = Field(default=None, ge=0.25, le=4.0)
     task_type: Literal["CustomVoice", "VoiceDesign", "Base"] | None = None
     language: str | None = None
@@ -411,7 +415,7 @@ class BatchSpeechRequest(BaseModel):
     items: list[SpeechBatchItem] = Field(..., min_length=1)
     voice: str | None = Field(default=None, validation_alias=AliasChoices("voice", "speaker"))
     instructions: str | None = None
-    response_format: Literal["wav", "pcm", "flac", "mp3", "aac", "opus"] = "wav"
+    response_format: Literal["wav", "pcm", "flac", "mp3", "opus"] = DEFAULT_AUDIO_FORMAT
     speed: float | None = Field(default=1.0, ge=0.25, le=4.0)
     task_type: Literal["CustomVoice", "VoiceDesign", "Base"] | None = None
     language: str | None = None
@@ -500,7 +504,7 @@ class StreamingSpeechSessionConfig(BaseModel):
     task_type: Literal["CustomVoice", "VoiceDesign", "Base"] | None = None
     language: str | None = None
     instructions: str | None = None
-    response_format: Literal["wav", "pcm", "flac", "mp3", "aac", "opus"] = "wav"
+    response_format: Literal["wav", "pcm", "flac", "mp3", "opus"] = DEFAULT_AUDIO_FORMAT
     speed: float | None = Field(default=1.0, ge=0.25, le=4.0)
     max_new_tokens: int | None = Field(default=None, ge=1)
     initial_codec_chunk_frames: int | None = Field(
diff --git a/vllm_omni/entrypoints/openai/protocol/images.py b/vllm_omni/entrypoints/openai/protocol/images.py
index b7247962c..0a20ba1c8 100644
--- a/vllm_omni/entrypoints/openai/protocol/images.py
+++ b/vllm_omni/entrypoints/openai/protocol/images.py
@@ -21,6 +21,13 @@ from pydantic import BaseModel, Field, field_validator
 
 from vllm_omni.entrypoints.openai.image_api_utils import validate_layered_layers
 
+_IMAGE_FILE_METADATA = {
+    "jpg": ("jpg", "image/jpeg"),
+    "jpeg": ("jpeg", "image/jpeg"),
+    "png": ("png", "image/png"),
+    "webp": ("webp", "image/webp"),
+}
+
 
 class ResponseFormat(str, Enum):
     """Image response format"""
@@ -183,13 +190,17 @@ class ImageGenerationResponse(BaseModel):
 
     created: int = Field(..., description="Unix timestamp of when the generation completed")
     data: list[ImageData] = Field(..., description="Array of generated images")
-    output_format: str = Field(None, description="The output format of the image generation")
+    output_format: str | None = Field(None, description="The output format of the image generation")
     size: str = Field(None, description="The size of the image generated")
     cot_output: str | None = Field(
         None,
         description="Chain-of-thought text output from the AR stage. "
         "Only present for image editing (IT2I) with CoT-enabled models.",
     )
+    metrics: dict[str, Any] | None = Field(
+        default=None,
+        description="Per-request generation metrics.",
+    )
 
     def stream_response(self) -> StreamingResponse:
         if not self.data or not self.data[0].b64_json:
@@ -197,12 +208,16 @@ class ImageGenerationResponse(BaseModel):
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR.value,
                 detail="No image data available for file response.",
             )
+        extension, media_type = _IMAGE_FILE_METADATA.get(
+            (self.output_format or "png").lower(),
+            _IMAGE_FILE_METADATA["png"],
+        )
         if len(self.data) == 1:
             image_bytes = base64.b64decode(self.data[0].b64_json)
-            filename = f"image_{uuid.uuid4().hex[:8]}.png"
+            filename = f"image_{uuid.uuid4().hex[:8]}.{extension}"
             return StreamingResponse(
                 io.BytesIO(image_bytes),
-                media_type="image/png",
+                media_type=media_type,
                 headers={
                     "Content-Disposition": f'attachment; filename="{filename}"',
                     "Content-Length": str(len(image_bytes)),
@@ -213,7 +228,7 @@ class ImageGenerationResponse(BaseModel):
             with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
                 for idx, item in enumerate(self.data):
                     if item.b64_json:
-                        zf.writestr(f"image_{idx}.png", base64.b64decode(item.b64_json))
+                        zf.writestr(f"image_{idx}.{extension}", base64.b64decode(item.b64_json))
             zip_bytes = zip_buffer.getvalue()
             filename = f"images_{uuid.uuid4().hex[:8]}.zip"
             return StreamingResponse(
diff --git a/vllm_omni/entrypoints/openai/protocol/videos.py b/vllm_omni/entrypoints/openai/protocol/videos.py
index 8773dd2d8..92ff836b8 100644
--- a/vllm_omni/entrypoints/openai/protocol/videos.py
+++ b/vllm_omni/entrypoints/openai/protocol/videos.py
@@ -116,17 +116,20 @@ class VideoGenerationRequest(BaseModel):
         description="Video dimensions in WIDTHxHEIGHT format (e.g., '1280x720')",
     )
 
-    image_reference: ImageReference | None = Field(
+    image_reference: ImageReference | list[ImageReference] | None = Field(
         default=None,
-        description="Optional JSON-safe image reference that guides generation. Provide either image_url or file_id.",
+        description=(
+            "Optional image reference or ordered list of references. MiniMax H3 uses the list order for "
+            "FL2VA first/last frames and Ref2VA image labels."
+        ),
     )
-    video_reference: VideoReference | None = Field(
+    video_reference: VideoReference | list[VideoReference] | None = Field(
         default=None,
-        description="Optional JSON-safe video reference that guides generation. Provide either video_url or file_id.",
+        description="Optional video reference or ordered list of Ref2VA video references.",
     )
-    audio_reference: AudioReference | None = Field(
+    audio_reference: AudioReference | list[AudioReference] | None = Field(
         default=None,
-        description="Optional audio reference for speech-to-video. Provide audio_url (http(s) or data URL).",
+        description="Optional audio reference or ordered list of Ref2VA audio references.",
     )
 
     # Video params block for extensibility
@@ -140,6 +143,25 @@ class VideoGenerationRequest(BaseModel):
     height: int | None = Field(default=None, ge=1, description="Video height in pixels")
     fps: int | None = Field(default=None, ge=1, description="Frames per second for output video")
     num_frames: int | None = Field(default=None, ge=1, description="Number of frames to generate")
+    aspect_ratio: str | None = Field(
+        default=None,
+        description=(
+            "MiniMax H3 output ratio. T2VA requires 21:9, 16:9, 4:3, 1:1, 3:4, or 9:16; "
+            "FL2VA follows the input image; Ref2VA defaults to 16:9."
+        ),
+    )
+    short_edge: int | None = Field(default=None, ge=1, description="MiniMax H3 output short edge in pixels")
+    num_outputs_per_prompt: int = Field(
+        default=1,
+        ge=1,
+        le=10,
+        description="Number of videos to generate. MiniMax H3 supports 1 through 10.",
+    )
+    start_time_seconds: float | None = Field(
+        default=None,
+        ge=0.0,
+        description="Start offset for a single MiniMax H3 reference video.",
+    )
 
     # vllm-omni extensions for diffusion control
     negative_prompt: str | None = Field(default=None, description="Text describing what to avoid in the video")
diff --git a/vllm_omni/entrypoints/openai/realtime_connection.py b/vllm_omni/entrypoints/openai/realtime_connection.py
index 0f0efbef8..aad7ea658 100644
--- a/vllm_omni/entrypoints/openai/realtime_connection.py
+++ b/vllm_omni/entrypoints/openai/realtime_connection.py
@@ -138,6 +138,7 @@ class RealtimeConnection(VllmRealtimeConnection):
             is_streaming=True,
         )
 
+        result_gen = None
         try:
             result_gen = self.engine.generate(
                 prompt=streaming_input_gen,
@@ -196,6 +197,16 @@ class RealtimeConnection(VllmRealtimeConnection):
             logger.exception("Error in generation: %s", e)
             await self.send_error(str(e), "processing_error")
         finally:
+            # Close the generator explicitly so AsyncOmni.generate's cleanup
+            # (input-pump cancellation and engine-side abort) runs now rather
+            # than whenever the event loop garbage-collects the async
+            # generator; the delay window is where a disconnected session
+            # keeps cycling through the stages (issue #4271).
+            if result_gen is not None:
+                try:
+                    await result_gen.aclose()
+                except Exception:
+                    logger.exception("Failed to close realtime result generator")
             # Always send terminal event so clients don't hang forever.
             if self._is_connected and not audio_done_sent:
                 try:
@@ -206,4 +217,10 @@ class RealtimeConnection(VllmRealtimeConnection):
                 self.audio_queue.get_nowait()
 
     async def send_json(self, payload: dict):
-        await self.websocket.send_text(json.dumps(payload))
+        try:
+            await self.websocket.send_text(json.dumps(payload))
+        except Exception:
+            # A failed send means the client is gone; flag it so the
+            # generation loop stops instead of retrying into a dead socket.
+            self._is_connected = False
+            raise
diff --git a/vllm_omni/entrypoints/openai/serving_chat.py b/vllm_omni/entrypoints/openai/serving_chat.py
index a1a51c303..5dc3002ca 100755
--- a/vllm_omni/entrypoints/openai/serving_chat.py
+++ b/vllm_omni/entrypoints/openai/serving_chat.py
@@ -25,6 +25,10 @@ from vllm.entrypoints.chat_utils import (
 
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.openai.diffusion_request_utils import (
+    apply_normalized_diffusion_request_extra_args,
+    normalize_diffusion_request_args,
+)
 from vllm_omni.entrypoints.openai.protocol.chat_completion import OmniChatCompletionResponse
 from vllm_omni.entrypoints.utils import coerce_param_message_types
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
@@ -33,7 +37,10 @@ from vllm_omni.metrics.modality import (
     observe_audio_first_packet,
     observe_audio_streaming_finalize,
 )
-from vllm_omni.model_extras import get_extra_body_params, get_extra_output_params
+from vllm_omni.model_extras import (
+    get_extra_body_params,
+    get_extra_output_params,
+)
 
 try:
     import soundfile
@@ -79,7 +86,7 @@ from vllm.outputs import RequestOutput
 from vllm.reasoning import ReasoningParser
 from vllm.renderers import BaseRenderer, merge_kwargs
 from vllm.renderers.inputs import TokPrompt
-from vllm.sampling_params import SamplingParams
+from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.tokenizers import TokenizerLike
 from vllm.tokenizers import TokenizerLike as AnyTokenizer
 from vllm.tokenizers.mistral import (
@@ -95,9 +102,17 @@ from vllm.utils.collection_utils import as_list
 from vllm.v1.engine.exceptions import EngineDeadError
 
 from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin
-from vllm_omni.entrypoints.openai.image_api_utils import encode_image_base64_with_compression, validate_layered_layers
+from vllm_omni.entrypoints.openai.image_api_utils import (
+    encode_image_base64_with_compression,
+    validate_layered_layers,
+)
 from vllm_omni.entrypoints.openai.protocol import OmniChatCompletionStreamResponse
-from vllm_omni.entrypoints.openai.protocol.audio import AudioResponse, CreateAudio
+from vllm_omni.entrypoints.openai.protocol.audio import (
+    DEFAULT_AUDIO_FORMAT,
+    SUPPORTED_CHAT_AUDIO_FORMATS,
+    AudioResponse,
+    CreateAudio,
+)
 from vllm_omni.entrypoints.openai.protocol.images import (
     ImageData,
     ImageEditARDeltaChunk,
@@ -147,6 +162,33 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
     _supported_speakers: set[str] | None = None
     _diffusion_extra_body_params: frozenset[str] | None = None
     _diffusion_extra_output_params: frozenset[str] | None = None
+    # Common fields stay at the request root, but still participate in
+    # conflicts with model-specific compatibility forms.
+    _diffusion_common_root_fields = frozenset(
+        {
+            "height",
+            "width",
+            "num_outputs_per_prompt",
+            "seed",
+            "num_inference_steps",
+            "guidance_scale",
+            "true_cfg_scale",
+            "num_frames",
+            "guidance_scale_2",
+            "layers",
+            "resolution",
+        }
+    )
+    _diffusion_existing_control_fields = frozenset(
+        {
+            "size",
+            "negative_prompt",
+            "lora",
+            "modalities",
+        }
+    )
+    _diffusion_root_field_aliases = {"cfg_scale": "true_cfg_scale"}
+    _diffusion_serving_root_fields = _diffusion_common_root_fields | _diffusion_existing_control_fields
 
     # Harmony flag (always False for vllm-omni models)
     use_harmony: bool = False
@@ -182,6 +224,63 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         tp_cls = self.parser_cls.tool_parser_cls if self.parser_cls is not None else None
         return request.tools and tp_cls is not None and self.enable_auto_tools and request.tool_choice in ["auto", None]
 
+    @staticmethod
+    def _stage_get(obj: Any, key: str, default: Any = None) -> Any:
+        if obj is None:
+            return default
+        if hasattr(obj, "get"):
+            return obj.get(key, default)
+        return getattr(obj, key, default)
+
+    def _has_minicpmo45_stage(self) -> bool:
+        for stage in getattr(self.engine_client, "stage_configs", []) or []:
+            engine_args = self._stage_get(stage, "engine_args")
+            model_arch = self._stage_get(engine_args, "model_arch")
+            if model_arch == "MiniCPMO45OmniForConditionalGeneration":
+                return True
+        return False
+
+    def _fix_minicpmo45_audio_stream_output_kinds(
+        self,
+        sampling_params_list: list[Any],
+        output_modalities: list[str] | tuple[str, ...] | None,
+    ) -> list[Any]:
+        """Keep MiniCPM-o 4.5's thinker final-only during audio streaming.
+
+        Chat ``stream=true`` normally coerces every AR stage to DELTA output.
+        That is correct for token-level text streaming, but MiniCPM-o 4.5's
+        Talker consumes the completed TTS span plus aligned thinker hidden
+        states. If Stage0 is DELTA, llm2tts receives one generated token at a
+        time and repeatedly starts tiny, independent TTS streams. The API then
+        never represents one coherent audio response.
+
+        For this model, stream the audio stage, not the thinker-to-talker
+        boundary.
+        """
+        if not output_modalities or "audio" not in output_modalities:
+            return sampling_params_list
+        if not self._has_minicpmo45_stage():
+            return sampling_params_list
+
+        stage_configs = getattr(self.engine_client, "stage_configs", []) or []
+        for idx, stage in enumerate(stage_configs):
+            if idx >= len(sampling_params_list):
+                break
+            sp = sampling_params_list[idx]
+            if not hasattr(sp, "output_kind"):
+                continue
+
+            engine_args = self._stage_get(stage, "engine_args")
+            if self._stage_get(engine_args, "model_arch") != "MiniCPMO45OmniForConditionalGeneration":
+                continue
+
+            model_stage = self._stage_get(engine_args, "model_stage")
+            if model_stage == "llm":
+                sp.output_kind = RequestOutputKind.FINAL_ONLY
+            elif model_stage == "tts":
+                sp.output_kind = RequestOutputKind.DELTA
+        return sampling_params_list
+
     @classmethod
     def for_diffusion(
         cls,
@@ -229,6 +328,30 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         self._diffusion_extra_body_params = params
         return params
 
+    def _normalize_diffusion_request_args(
+        self,
+        request: ChatCompletionRequest,
+    ) -> tuple[dict[str, object], dict[str, Any]]:
+        """Normalize extras and preserve validated common root fields."""
+        root = dict(request.model_extra or {})
+        nested = root.pop("extra_body", None)
+        if nested is None:
+            nested = getattr(request, "extra_body", None)
+        explicit = getattr(request, "model_fields_set", None)
+        if explicit is None:
+            explicit = getattr(request, "__fields_set__", ())
+        explicit_root_args = {
+            key: getattr(request, key) for key in explicit if key != "extra_body" and hasattr(request, key)
+        }
+        return normalize_diffusion_request_args(
+            root=root,
+            nested=nested,
+            explicit_root_args=explicit_root_args,
+            serving_root_fields=self._diffusion_serving_root_fields,
+            registered_extra_fields=self._get_diffusion_extra_body_params(),
+            root_field_aliases=self._diffusion_root_field_aliases,
+        )
+
     def _get_diffusion_extra_output_params(
         self,
         output: object,
@@ -324,9 +447,26 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         request: ChatCompletionRequest,
         raw_request: Request | None = None,
     ) -> AsyncGenerator[str, None] | ChatCompletionResponse | ErrorResponse:
+        stage_configs = getattr(self.engine_client, "stage_configs", ()) or ()
+        serves_diffusion = self._diffusion_mode or any(
+            get_stage_type(stage_config) == "diffusion" for stage_config in stage_configs
+        )
+        normalized_extra_args: dict[str, object] = {}
+        diffusion_request_args: dict[str, Any] = {}
+        if serves_diffusion:
+            try:
+                normalized_extra_args, diffusion_request_args = self._normalize_diffusion_request_args(request)
+            except ValueError as exc:
+                return self._create_error_response(str(exc), status_code=400)
+
         # Handle diffusion mode
         if self._diffusion_mode:
-            return await self._create_diffusion_chat_completion(request, raw_request)
+            return await self._create_diffusion_chat_completion(
+                request,
+                normalized_extra_args,
+                diffusion_request_args,
+                raw_request,
+            )
 
         request_timestamp = time.time()
         if raw_request is not None:
@@ -450,8 +590,25 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         output_modalities = getattr(request, "modalities", engine_output_modalities)
         request.modalities = output_modalities if output_modalities is not None else engine_output_modalities
 
+        if not isinstance(request.modalities, list) or not all(isinstance(m, str) for m in request.modalities):
+            return self.create_error_response("'modalities' must be a list of strings.")
+        allowed_modalities = set(engine_output_modalities)
+        if is_single_stage_diffusion(self.engine_client):
+            allowed_modalities.add("text")
+        unsupported = set(request.modalities) - allowed_modalities
+        if unsupported:
+            return self.create_error_response(
+                f"Unsupported output modalities {', '.join(sorted(unsupported))} for this model. "
+                f"Supported modalities: {', '.join(sorted(allowed_modalities))}",
+            )
+
+        if request.modalities and "audio" in request.modalities:
+            audio_format_check = self._resolve_audio_format(request)
+            if isinstance(audio_format_check, ErrorResponse):
+                return audio_format_check
+
         num_inference_steps = None
-        extra_body: dict[str, Any] = {}
+        extra_body = diffusion_request_args
         # Omni multistage image generation: Stage-0 (AR) should receive a clean
         # text prompt (and optional conditioning image/size) so the model's own
         # processor can construct the correct inputs.
@@ -465,12 +622,6 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                 if not extracted_prompt:
                     return self.create_error_response("No text prompt found in messages")
 
-                # [NOTE] When sending request via openai client Python library,
-                #   `extra_body` is flattented and merged into the payload's root.
-                #   These extra fields are accessible via `model_extra` property (from Pydantic base class).
-                #   When sending raw request with curl, no flattening happens. Directly read the `extra_body` dict.
-                extra_body = getattr(request, "extra_body", None) or request.model_extra or {}
-
                 height, width = self._resolve_height_width_from_extra_body(extra_body)
 
                 num_inference_steps = extra_body.get("num_inference_steps")
@@ -583,16 +734,38 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                 # to delta to ensure emitted outputs are correctly drained. Otherwise
                 # convert cumulative to Final Only to ensure the output is correct.
                 sampling_params_list = coerce_param_message_types(sampling_params_list, request.stream)
+                if request.stream:
+                    sampling_params_list = self._fix_minicpmo45_audio_stream_output_kinds(
+                        sampling_params_list,
+                        output_modalities,
+                    )
 
+                comprehension_idx = (
+                    self._get_comprehension_stage_index()
+                    if _image_gen_height is not None and _image_gen_width is not None
+                    else None
+                )
                 # Apply user-specified overrides to diffusion stage(s) for image generation
                 for idx, sp in enumerate(sampling_params_list):
+                    if idx == comprehension_idx:
+                        extra_args = dict(getattr(sp, "extra_args", {}) or {})
+                        extra_args["target_h"] = int(_image_gen_height)
+                        extra_args["target_w"] = int(_image_gen_width)
+                        sp.extra_args = extra_args
                     if hasattr(sp, "height") and _image_gen_height is not None:
                         sp.height = _image_gen_height
                     if hasattr(sp, "width") and _image_gen_width is not None:
                         sp.width = _image_gen_width
                     if hasattr(sp, "num_inference_steps") and num_inference_steps is not None:
                         sp.num_inference_steps = num_inference_steps
-                    apply_declared_extra_args(sp, self._get_diffusion_extra_body_params(), extra_body)
+                    if isinstance(sp, OmniDiffusionSamplingParams):
+                        apply_normalized_diffusion_request_extra_args(sp, normalized_extra_args)
+                    else:
+                        apply_declared_extra_args(
+                            sp,
+                            self._get_diffusion_extra_body_params(),
+                            extra_body,
+                        )
 
                 self._log_inputs(
                     request_id,
@@ -1082,8 +1255,6 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         Starts with YAML defaults and only overrides fields that the user
         explicitly provided (non-None values) in the request.
 
-        For models needing spatial metadata (e.g. GLM-Image), target_h/w is
-        injected into extra_args so the runner can build M-RoPE position grids.
         max_tokens is NOT computed dynamically — it uses the deploy YAML default.
 
         Args:
@@ -1109,19 +1280,6 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             if (value is not None and not isinstance(value, list)) or (isinstance(value, list) and len(value) > 0):
                 setattr(params, field_name, value)
 
-        # For GLM-Image: compute max_tokens from height/width with mode-aware
-        # budgeting (t2i vs i2i).
-        extra_body = getattr(request, "extra_body", {}) or {}
-        height, width = self._resolve_height_width_from_extra_body(extra_body)
-
-        if height is not None and width is not None:
-            # Keep target size in stage-0 sampling params so runner/model can
-            # build deterministic M-RoPE grids for t2i (no MM features).
-            extra_args = dict(getattr(params, "extra_args", {}) or {})
-            extra_args["target_h"] = int(height)
-            extra_args["target_w"] = int(width)
-            params.extra_args = extra_args
-
         return params
 
     @staticmethod
@@ -1904,15 +2062,19 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                     now_ts = time.time()
                     if req_state is not None and req_state.first_audio_ts is None:
                         req_state.first_audio_ts = now_ts
-                        stage_pools = getattr(self.engine_client.engine, "stage_pools", None)
-                        # The orchestrator binds requests by their internal id,
-                        # not the user-visible external id, so look up the
-                        # replica with req_state.request_id (internal).
-                        replica_id = (
-                            stage_pools[omni_res.stage_id].get_bound_replica_id(req_state.request_id)
-                            if stage_pools is not None and 0 <= omni_res.stage_id < len(stage_pools)
-                            else None
-                        )
+                        replica_id = getattr(omni_res, "replica_id", None)
+                        if replica_id is None:
+                            stage_pools = getattr(self.engine_client.engine, "stage_pools", None)
+                            # Fallback for older outputs. The orchestrator binds
+                            # requests by internal id, but can release that
+                            # binding before the API sees the final audio chunk,
+                            # so prefer the OutputMessage replica copied onto
+                            # OmniRequestOutput above.
+                            replica_id = (
+                                stage_pools[omni_res.stage_id].get_bound_replica_id(req_state.request_id)
+                                if stage_pools is not None and 0 <= omni_res.stage_id < len(stage_pools)
+                                else None
+                            )
                         req_state.audio_emit_stage_id = omni_res.stage_id
                         req_state.audio_emit_replica_id = replica_id
                         observe_audio_first_packet(
@@ -1925,6 +2087,13 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
 
                     role = self.get_chat_request_role(request)
                     choices_data = self._create_audio_choice(omni_res, role, request, stream=True)
+                    if isinstance(choices_data, ErrorResponse):
+                        logger.error(
+                            "Skipping audio chunk for request %s: %s",
+                            request_id,
+                            choices_data.error.message,
+                        )
+                        continue
                     # Only emit finish_reason on the last modality to
                     # comply with OpenAI streaming spec.
                     for choice in choices_data:
@@ -2197,6 +2366,8 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                     ]
             elif omni_outputs.final_output_type == "audio":
                 choices_data = self._create_audio_choice(omni_outputs, role, request, stream=False)
+                if isinstance(choices_data, ErrorResponse):
+                    return choices_data
             elif omni_outputs.final_output_type == "image":
                 choices_data = self._create_image_choice(omni_outputs, role, request, stream=False)
             else:
@@ -2524,12 +2695,15 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
 
     def _create_audio_choice(
         self, omni_outputs: OmniRequestOutput, role: str, request: ChatCompletionRequest, stream: bool = False
-    ):
+    ) -> list[ChatCompletionResponseChoice] | list[ChatCompletionResponseStreamChoice] | ErrorResponse:
         choices: list[ChatCompletionResponseChoice] = []
         final_res = omni_outputs.request_output
         # OMNI: Access multimodal_output from CompletionOutput (outputs[0]), not from RequestOutput
         # Reference: examples/offline_inference/qwen3_omni/end2end.py line 421
-        mm_output = final_res.outputs[0].multimodal_output
+        # The attribute is attached dynamically when stage audio arrives; fall
+        # back to the no-audio error response instead of an AttributeError 500
+        # when the pipeline produced no audio for this request.
+        mm_output = getattr(final_res.outputs[0], "multimodal_output", None) or {}
         audio_data = mm_output.get("audio")
         if isinstance(audio_data, list):
             if not audio_data:
@@ -2541,7 +2715,24 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         else:
             audio_tensor = audio_data
         if audio_tensor is None:
-            return self._create_error_response("Audio generation completed but no audio was produced.")
+            if not stream:
+                return self._create_error_response("Audio generation completed but no audio was produced.")
+            # A streamed message can legitimately carry no waveform: the talker
+            # may emit an empty speech segment, and Stage 2 then reports the
+            # chunk with metadata only. Emit an empty audio delta so the
+            # caller's finish_reason bookkeeping still runs and the stream
+            # terminates normally instead of raising mid-generation.
+            return [
+                ChatCompletionResponseStreamChoice(
+                    index=output.index,
+                    delta=DeltaMessage(role=role, content=""),
+                    logprobs=None,
+                    finish_reason=output.finish_reason,
+                    stop_reason=output.stop_reason,
+                    token_ids=(as_list(output.token_ids) if request.return_token_ids else None),
+                )
+                for output in final_res.outputs
+            ]
         audio_tensor = audio_tensor.detach().cpu().float().numpy()
 
         # Ensure audio is 1D (flatten if needed)
@@ -2561,10 +2752,14 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
         else:
             sample_rate = int(sr_raw)
 
+        audio_format = self._resolve_audio_format(request)
+        if isinstance(audio_format, ErrorResponse):
+            return audio_format
+
         audio_obj = CreateAudio(
             audio_tensor=audio_tensor,
             sample_rate=sample_rate,
-            response_format="wav",
+            response_format=audio_format,
             speed=1.0,
             base64_encode=True,
         )
@@ -3249,12 +3444,16 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
     async def _create_diffusion_chat_completion(
         self,
         request: ChatCompletionRequest,
+        normalized_extra_args: dict[str, object],
+        diffusion_request_args: dict[str, Any],
         raw_request: Request | None = None,
     ) -> ChatCompletionResponse | ErrorResponse:
         """Generate images via chat completion interface for diffusion models.
 
         Args:
             request: Chat completion request
+            normalized_extra_args: Validated model-specific request arguments
+            diffusion_request_args: Compatibility arguments plus validated common root fields
             raw_request: Raw FastAPI request object
 
         Returns:
@@ -3279,15 +3478,8 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                 messages
             )
 
-            # Extract generation parameters from extra_body (preferred)
             # Reference: text_to_image.py and text_to_video.py for supported parameters
-            # [NOTE] When sending request via openai client Python library,
-            #   `extra_body` is flattented and merged into the payload's root.
-            #   These extra fields are accessible via `model_extra` property (from Pydantic base class).
-            #   When sending raw request with curl, no flattening happens. Directly read the `extra_body` dict.
-            extra_body = getattr(request, "extra_body", None)
-            if not extra_body:
-                extra_body = request.model_extra or {}
+            extra_body = diffusion_request_args
 
             # Parse size if provided (supports "1024x1024" format)
             height, width = self._resolve_height_width_from_extra_body(extra_body)
@@ -3298,7 +3490,7 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             # not provide a value.
             num_inference_steps = extra_body.get("num_inference_steps")
             guidance_scale = extra_body.get("guidance_scale")
-            true_cfg_scale = extra_body.get("true_cfg_scale") or extra_body.get("cfg_scale")
+            true_cfg_scale = extra_body.get("true_cfg_scale")
             seed = extra_body.get("seed")
             if seed is None:
                 seed = getattr(request, "seed", None)
@@ -3313,18 +3505,17 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             # Qwen-Image-Layered parameters
             layers = extra_body.get("layers")
             resolution = extra_body.get("resolution")
-
             try:
                 layers = validate_layered_layers(layers)
-            except ValueError as e:
-                return self._create_error_response(str(e), status_code=400)
+            except ValueError as exc:
+                return self._create_error_response(str(exc), status_code=400)
 
             logger.info(
                 "Diffusion chat request %s: prompt=%r, ref_images=%d, params=%s",
                 request_id,
                 prompt[:50] + "..." if len(prompt) > 50 else prompt,
                 len(reference_images),
-                {k: v for k, v in extra_body.items() if v is not None},
+                {key: value for key, value in extra_body.items() if value is not None},
             )
 
             # Decode reference images if provided
@@ -3356,7 +3547,7 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                 gen_params.guidance_scale = guidance_scale
             if true_cfg_scale is not None:
                 gen_params.true_cfg_scale = true_cfg_scale
-            apply_declared_extra_args(gen_params, self._get_diffusion_extra_body_params(), extra_body)
+            apply_normalized_diffusion_request_extra_args(gen_params, normalized_extra_args)
             if num_frames is not None:
                 gen_params.num_frames = num_frames
             if guidance_scale_2 is not None:
@@ -3366,14 +3557,6 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             if resolution is not None:
                 gen_params.resolution = resolution
 
-            # Pipeline-agnostic escape hatch (mirrors ``extra_params`` on the /v1/videos
-            # endpoint in ``serving_video.py``): a single reserved ``extra_args`` dict in
-            # ``extra_body`` flows straight into ``gen_params.extra_args``, with no keys
-            # hardcoded here.
-            extra_args_body = extra_body.get("extra_args")
-            if isinstance(extra_args_body, dict):
-                gen_params.extra_args.update(extra_args_body)
-
             # Parse per-request LoRA.
             if lora_body and isinstance(lora_body, dict):
                 try:
@@ -3382,8 +3565,8 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                         gen_params.lora_request = lora_req
                         if lora_scale is not None:
                             gen_params.lora_scale = lora_scale
-                except Exception as e:  # pragma: no cover - safeguard
-                    logger.warning("Failed to parse LoRA request: %s", e)
+                except Exception as exc:  # pragma: no cover - safeguard
+                    logger.warning("Failed to parse LoRA request: %s", exc)
 
             # Route text modality for single-stage diffusion (img2text / text2text)
             requested_modalities = extra_body.get("modalities") or []
@@ -3422,13 +3605,22 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             # Generate image or audio (e.g. AudioX) via AsyncOmni
             diffusion_engine = cast(AsyncOmni, self._diffusion_engine)
             stage_configs = list(getattr(diffusion_engine, "stage_configs", []) or [])
+            default_sampling_params_list = get_default_sampling_params_list(diffusion_engine)
             sampling_params_list = build_stage_sampling_params_list(
                 stage_configs,
-                get_default_sampling_params_list(diffusion_engine),
+                default_sampling_params_list,
                 diffusion_params=gen_params,
                 replace_diffusion_params=True,
             )
-
+            for index, (stage_config, sampling_params) in enumerate(zip(stage_configs, sampling_params_list)):
+                if get_stage_type(stage_config) != "diffusion" or index >= len(default_sampling_params_list):
+                    continue
+                default_extra_args = getattr(default_sampling_params_list[index], "extra_args", None)
+                if default_extra_args:
+                    sampling_params.extra_args = {
+                        **default_extra_args,
+                        **(getattr(sampling_params, "extra_args", None) or {}),
+                    }
             if not sampling_params_list:
                 sampling_params_list = [gen_params]
 
@@ -3515,10 +3707,14 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
                     raise ValueError(f"Unexpected audio tensor rank {audio_tensor.ndim}; expected 1-3 dims.")
                 audio_array = audio_tensor.numpy()
 
+                audio_format = self._resolve_audio_format(request)
+                if isinstance(audio_format, ErrorResponse):
+                    return audio_format
+
                 audio_obj = CreateAudio(
                     audio_tensor=audio_array,
                     sample_rate=sample_rate,
-                    response_format="wav",
+                    response_format=audio_format,
                     speed=1.0,
                     base64_encode=True,
                 )
@@ -3734,6 +3930,21 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
 
         return height, width
 
+    def _resolve_audio_format(self, request: ChatCompletionRequest) -> str | ErrorResponse:
+        """Extract and validate the audio output format from a chat completion request."""
+        audio_params = getattr(request, "audio", None)
+        if isinstance(audio_params, dict):
+            audio_format = audio_params.get("format", DEFAULT_AUDIO_FORMAT)
+        else:
+            audio_format = DEFAULT_AUDIO_FORMAT
+        if audio_format not in SUPPORTED_CHAT_AUDIO_FORMATS:
+            return self._create_error_response(
+                f"Invalid audio format '{audio_format}'. Supported formats: {sorted(SUPPORTED_CHAT_AUDIO_FORMATS)}",
+            )
+        if audio_format == "pcm16":
+            audio_format = "pcm"
+        return audio_format
+
     def _create_error_response(
         self,
         message: str,
diff --git a/vllm_omni/entrypoints/openai/serving_speech.py b/vllm_omni/entrypoints/openai/serving_speech.py
index 3db6b63a6..6cec05db8 100644
--- a/vllm_omni/entrypoints/openai/serving_speech.py
+++ b/vllm_omni/entrypoints/openai/serving_speech.py
@@ -67,6 +67,7 @@ from vllm_omni.model_executor.models.ming_flash_omni.prompt_utils import (
 from vllm_omni.model_executor.models.ming_flash_omni.prompt_utils import (
     create_instruction as ming_create_instruction,
 )
+from vllm_omni.model_executor.models.ming_tts.constants import SPEAKER_EMBEDDING_DIM
 from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.utils.speaker_cache import (
     get_speaker_cache,
@@ -99,6 +100,10 @@ _HIGGS_V3_TTS_MODEL_STAGES = {"higgs_audio_v3"}
 _GLM_TTS_MODEL_STAGES = {"glm_tts"}
 _STEP_AUDIO2_TTS_MODEL_STAGES = {"step_audio2_thinker"}
 _INDEXTTS2_TTS_MODEL_STAGES = {"indextts2_talker"}
+# audex_omni covers the audex_s2s S2S deployment, whose
+# TTS pass uses the same /v1/audio/speech surface.
+_AUDEX_TTS_MODEL_STAGES = {"audex_thinker", "audex_omni"}
+_AUDEX_TTA_MODEL_STAGES = {"audex_tta_thinker"}
 _TTS_MODEL_STAGES: set[str] = (
     _VOXTRAL_TTS_MODEL_STAGES
     | _QWEN3_TTS_MODEL_STAGES
@@ -116,6 +121,8 @@ _TTS_MODEL_STAGES: set[str] = (
     | _GLM_TTS_MODEL_STAGES
     | _STEP_AUDIO2_TTS_MODEL_STAGES
     | _INDEXTTS2_TTS_MODEL_STAGES
+    | _AUDEX_TTS_MODEL_STAGES
+    | _AUDEX_TTA_MODEL_STAGES
 )
 _SAMPLING_MAX_TOKENS_TTS_MODEL_TYPES = {
     "fish_tts",
@@ -126,7 +133,13 @@ _SAMPLING_MAX_TOKENS_TTS_MODEL_TYPES = {
     "higgs_audio_v2",
     "higgs_audio_v3",
     "indextts2",
+    "audex",
+    "audex_tta",
 }
+# Audex contract: zero-codec / invalid generations arrive as empty terminal
+# payloads and must fail the request, never serialize as a successful empty
+# WAV. Covers both the TTS ("audex") and TTA ("audex_tta") pipelines.
+_AUDEX_NO_AUDIO_GUARD_MODEL_TYPES = frozenset({"audex", "audex_tta"})
 _TTS_LANGUAGES = frozenset(
     {
         "Auto",
@@ -150,7 +163,6 @@ _HIGGS_V3_REF_CODE_CACHE_MAX_ENTRIES = 256
 _HIGGS_V3_REF_CODE_CACHE_MAX_BYTES = 64 * 1024 * 1024
 _QWEN3_TTS_REF_AUDIO_CACHE_KEY = "_qwen3_tts_ref_audio_cache_key"
 _TTS_MAX_INSTRUCTIONS_LENGTH = 500
-_TTS_MAX_NEW_TOKENS_MIN = 1
 _TTS_MAX_NEW_TOKENS_MAX = 4096
 _MING_DEFAULT_PROMPT = MING_DEFAULT_PROMPT
 
@@ -323,8 +335,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         self._ref_audio_resolve_cache_bytes = 0
         self._ref_audio_resolve_cache_max_entries = _REF_AUDIO_RESOLVE_CACHE_MAX_ENTRIES
         self._ref_audio_resolve_cache_max_bytes = _REF_AUDIO_RESOLVE_CACHE_MAX_BYTES
-        self._ref_audio_model_artifact_ready: set[str] = set()
-        self._request_ref_audio_artifact_keys: dict[str, str] = {}
+        # Readiness is keyed by (artifact_key, x_vector_only). An x-vector-only
+        # request caches a speaker embedding but no ref_code, so its artifact
+        # must not satisfy a later ICL request that needs ref_code (#5049).
+        self._ref_audio_model_artifact_ready: set[tuple[str, bool]] = set()
+        self._request_ref_audio_artifact_keys: dict[str, tuple[str, bool]] = {}
         self._higgs_audio_v3_ref_code_cache: OrderedDict[str, tuple[torch.Tensor, int]] = OrderedDict()
         self._higgs_audio_v3_ref_code_cache_bytes = 0
         self._higgs_audio_v3_ref_code_inflight: dict[str, asyncio.Task[torch.Tensor]] = {}
@@ -490,6 +505,8 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
         self._tts_tokenizer = None
         self._voxcpm2_tokenizer = None
+        self._audex_tokenizer = None
+        self._audex_tta_rvq = None
         self._voxcpm2_split_map: dict[int, list[int]] = {}
 
         logger.info("Loaded %d supported speakers: %s", len(self.supported_speakers), sorted(self.supported_speakers))
@@ -670,12 +687,19 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
     def _find_tts_stage(self):
         """Find and return the TTS stage config, or None if not found."""
+        all_stages = {getattr(stage.engine_args, "model_stage", None) for stage in self.engine_client.stage_configs}
         for stage in self.engine_client.stage_configs:
             engine_args = stage.engine_args
             model_stage = engine_args.model_stage
             model_arch = getattr(engine_args, "model_arch", None)
             worker_type = getattr(engine_args, "worker_type", None)
             if model_stage in _TTS_MODEL_STAGES:
+                # The audio-capable Audex thinker is only speech-capable when
+                # deployed WITH the speech decoder (audex_s2s);
+                # the thinker-only deployment is text-final and must not
+                # accept /v1/audio/speech requests.
+                if model_stage == "audex_omni" and "audex_code2wav" not in all_stages:
+                    continue
                 return stage
             # Ming dense identifies its AR entry stage by architecture because
             # it does not use a dedicated TTS model_stage value.
@@ -726,6 +750,10 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             return "step_audio2"
         if model_stage in _INDEXTTS2_TTS_MODEL_STAGES:
             return "indextts2"
+        if model_stage in _AUDEX_TTS_MODEL_STAGES:
+            return "audex"
+        if model_stage in _AUDEX_TTA_MODEL_STAGES:
+            return "audex_tta"
         return None
 
     def _get_custom_voice_dir(self) -> str | None:
@@ -804,7 +832,9 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 config = self.engine_client.model_config.hf_config.audio_config
             else:
                 # Default is qwen3_tts path
-                config = self.engine_client.model_config.hf_config.talker_config
+                config = getattr(self.engine_client.model_config.hf_config, "talker_config", None)
+                if config is None:
+                    return set()
 
             # Check for speakers in either spk_id or speaker_id
             for attr_name in ["spk_id", "speaker_id"]:
@@ -1394,8 +1424,8 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
         emb_dim = len(embedding)
         if self._tts_model_type == "ming_tts":
-            if emb_dim != 192:
-                raise ValueError(f"Ming speaker embedding must have 192 dims, got {emb_dim}")
+            if emb_dim != SPEAKER_EMBEDDING_DIM:
+                raise ValueError(f"Ming speaker embedding must have {SPEAKER_EMBEDDING_DIM} dims, got {emb_dim}")
         else:
             dim_err = self._validate_qwen_tts_speaker_embedding_dim(emb_dim)
             if dim_err is not None:
@@ -1490,48 +1520,22 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
     def _validate_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
         """Validate TTS request parameters. Returns error message or None."""
-        if self._tts_model_type == "step_audio2":
-            # StepAudio2 only requires non-empty input text
-            if not request.input or not request.input.strip():
-                return "Input text cannot be empty"
-            return None
-        if self._tts_model_type == "voxtral_tts":
-            return self._validate_voxtral_tts_request(request)
-        if self._tts_model_type == "fish_tts":
-            return self._validate_fish_tts_request(request)
-        if self._tts_model_type == "cosyvoice3":
-            return self._validate_cosyvoice3_request(request)
-        if self._tts_model_type == "voxcpm2":
-            return self._validate_voxcpm2_request(request)
         if self._tts_model_type == "ming_flash_omni_tts":
             return self._validate_ming_flash_omni_tts_request(request)
-        if self._tts_model_type == "ming_tts":
-            return self._validate_ming_tts_request(request)
-        if self._tts_model_type in ("moss_tts_nano", "moss_tts"):
-            return self._validate_moss_tts_request(request)
-        if self._tts_model_type == "glm_tts":
-            return self._validate_glm_tts_request(request)
-        return self._validate_qwen_tts_request(request)
 
-    def _validate_voxcpm2_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate VoxCPM2 request parameters. Returns error message or None."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
+        adapter = self._get_tts_adapter()
+        if adapter is not None:
+            return adapter.validate(request)
 
-        if request.voice is not None:
-            request.voice = request.voice.lower()
-            available_voices = set(self.uploaded_speakers) | set(self.precomputed_speakers) | {"default"}
-            if request.voice not in available_voices:
-                supported = ", ".join(sorted(available_voices)) or "none"
-                return f"Invalid voice '{request.voice}'. Supported: {supported}"
+        adapter_cls = resolve_adapter("qwen3_tts")
+        if adapter_cls is None:
+            raise ValueError("Qwen3-TTS adapter is not registered")
 
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
+        ctx = SpeechServingContext(
+            server=self,
+            engine_client=self.engine_client,
+        )
+        return adapter_cls(ctx).validate(request)
 
     def _voxcpm2_encode(self, text: str) -> list[int]:
         """Tokenize text for VoxCPM2, splitting multichar Chinese tokens."""
@@ -1599,158 +1603,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             return "ref_audio must be a URL (http/https), base64 data URL (data:...), or file URI (file://...)"
         return None
 
-    def _validate_voxtral_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate Voxtral TTS request parameters. Returns error message or None."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        # Voxtral TTS requires either a preset voice or ref_audio for voice cloning.
-        if request.voice is None and request.ref_audio is None:
-            return "Either 'voice' (preset speaker) or 'ref_audio' (voice cloning) must be provided"
-
-        if request.ref_audio is not None:
-            fmt_err = self._validate_ref_audio_format(request.ref_audio)
-            if fmt_err:
-                return fmt_err
-
-        if request.voice is not None:
-            request.voice = request.voice.lower()
-            if self.supported_speakers and request.voice not in self.supported_speakers:
-                return f"Invalid speaker '{request.voice}'. Supported: {', '.join(sorted(self.supported_speakers))}"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
-    def _validate_qwen_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate Qwen TTS request parameters. Returns error message or None."""
-        # Infer Base task when ref_audio or ref_text is provided without explicit task_type.
-        if request.task_type is None and (request.ref_audio is not None or request.ref_text is not None):
-            request.task_type = "Base"
-
-        # Normalize voice to lowercase for case-insensitive matching
-        if request.voice is not None:
-            request.voice = request.voice.lower()
-            if request.task_type is None and request.voice in self.precomputed_speakers:
-                request.task_type = "Base"
-        task_type = request.task_type or "CustomVoice"
-
-        # Validate input is not empty
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        # Validate language (case-insensitive; normalized to the title-cased config form)
-        if request.language is not None:
-            request.language = request.language.title()
-            if request.language not in self.supported_languages:
-                return (
-                    f"Invalid language '{request.language}'. Supported: {', '.join(sorted(self.supported_languages))}"
-                )
-
-        # Validate speaker for CustomVoice task
-        if task_type == "CustomVoice":
-            if not self.supported_speakers:
-                return (
-                    "This model does not support CustomVoice task (no speakers configured). "
-                    "Use task_type='Base' with ref_audio/ref_text for voice cloning, "
-                    "or use a CustomVoice model."
-                )
-            if request.voice is not None and request.voice not in self.supported_speakers:
-                return f"Invalid voice '{request.voice}'. Supported: {', '.join(sorted(self.supported_speakers))}"
-
-        # Validate speaker_embedding constraints
-        if request.speaker_embedding is not None:
-            if task_type != "Base":
-                return "'speaker_embedding' is only valid for Base task"
-            if not request.speaker_embedding:
-                return "'speaker_embedding' must be a non-empty list of floats"
-            # speaker_embedding implies x_vector_only_mode — set it before
-            # Base task validation so callers don't need to pass it explicitly.
-            request.x_vector_only_mode = True
-            emb_len = len(request.speaker_embedding)
-            dim_err = self._validate_qwen_tts_speaker_embedding_dim(emb_len)
-            if dim_err is not None:
-                return dim_err
-        # Validate Base task requirements
-        if task_type == "Base":
-            if request.voice is None:
-                # 1. Ensure a voice source is provided
-                if request.ref_audio is None and getattr(request, "speaker_embedding", None) is None:
-                    return "Base task requires 'ref_audio' or 'speaker_embedding' for voice cloning"
-                # 2. Validate ref_audio format if it exists (using the helper from main)
-                if request.ref_audio is not None:
-                    fmt_err = self._validate_ref_audio_format(request.ref_audio)
-                    if fmt_err:
-                        return fmt_err
-                # 3. Validate text requirements based on the mode
-                if not getattr(request, "x_vector_only_mode", False):
-                    if not request.ref_text or not request.ref_text.strip():
-                        return (
-                            "Base task requires non-empty 'ref_text' (transcript of "
-                            "the reference audio) unless 'x_vector_only_mode' is enabled"
-                        )
-            else:
-                voice_lower = request.voice.lower()
-                if voice_lower in self.uploaded_speakers:
-                    # Check if data file exists for uploaded speaker
-                    speaker_info = self.uploaded_speakers[voice_lower]
-                    file_path = Path(speaker_info["file_path"])
-                    if not file_path.exists():
-                        return f"Data file for uploaded speaker '{request.voice}' not found on disk"
-                elif voice_lower in self.precomputed_speakers:
-                    profile = self.precomputed_speakers[voice_lower]
-                    mode = str(profile.get("mode") or "xvec").lower()
-                    ref_text = request.ref_text or profile.get("ref_text")
-                    if mode == "icl" and (not isinstance(ref_text, str) or not ref_text.strip()):
-                        return (
-                            f"Precomputed voice '{request.voice}' uses ICL mode but has no ref_text in "
-                            "the request or custom voice manifest"
-                        )
-                else:
-                    # need ref_audio for built-in speaker
-                    if request.ref_audio is None:
-                        return (
-                            f"Base task with built-in speaker '{request.voice}' requires 'ref_audio' for voice cloning"
-                        )
-                    fmt_err = self._validate_ref_audio_format(request.ref_audio)
-                    if fmt_err:
-                        return fmt_err
-                    if not getattr(request, "x_vector_only_mode", False) and (
-                        not request.ref_text or not request.ref_text.strip()
-                    ):
-                        return (
-                            "Base task requires non-empty 'ref_text' (transcript of "
-                            "the reference audio) unless 'x_vector_only_mode' is enabled"
-                        )
-
-        # Validate cross-parameter dependencies
-        if task_type != "Base":
-            if request.ref_text is not None:
-                return "'ref_text' is only valid for Base task"
-            if request.x_vector_only_mode is not None:
-                return "'x_vector_only_mode' is only valid for Base task"
-
-        # Validate VoiceDesign task requirements
-        if task_type == "VoiceDesign" and not request.instructions:
-            return "VoiceDesign task requires 'instructions' to describe the voice"
-
-        # Validate instructions length (using cached value from initialization)
-        if request.instructions and len(request.instructions) > self._max_instructions_length:
-            return f"Instructions too long (max {self._max_instructions_length} characters)"
-
-        # Validate max_new_tokens range
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
     def _detect_moss_variant(self) -> str:
         """Sub-classify a ``moss_tts``-stage server into the actual MOSS-TTS
         variant family (tts, ttsd, sound_effect, voice_generator, realtime).
@@ -1776,66 +1628,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             return "voice_generator"
         return "tts"
 
-    def _validate_moss_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate any MOSS-TTS-family request (nano + 5 full variants).
-
-        Dispatches by ``self._moss_variant``:
-          - ``tts``/``realtime``: require ``ref_audio`` (voice cloning).
-          - ``ttsd``: require ``ref_audio`` (speaker 1); ``ref_audio_2``
-            optional (defaults to the same ref for both speakers).
-          - ``sound_effect``: require ``ambient_sound`` (no ref_audio).
-          - ``voice_generator``: require ``instructions`` (no ref_audio).
-          - For the legacy moss_tts_nano model_type the variant is None and
-            we fall through to the original nano contract (ref_audio only).
-        """
-        if not request.input or not request.input.strip():
-            # SoundEffect can legitimately have empty input (just ambient_sound).
-            if self._moss_variant != "sound_effect":
-                return "Input text cannot be empty"
-
-        v = self._moss_variant
-        if v in (None, "tts", "realtime", "local"):
-            if request.ref_audio is None:
-                label = (
-                    "MOSS-TTS-Nano"
-                    if v is None
-                    else (
-                        "MOSS-TTS-Realtime"
-                        if v == "realtime"
-                        else ("MOSS-TTS-Local-Transformer" if v == "local" else "MOSS-TTS")
-                    )
-                )
-                return f"{label} requires 'ref_audio' (reference audio for voice cloning)."
-            return self._validate_ref_audio_format(request.ref_audio)
-
-        if v == "ttsd":
-            if request.ref_audio is None:
-                return "MOSS-TTSD requires 'ref_audio' (speaker 1 reference)."
-            fmt_err = self._validate_ref_audio_format(request.ref_audio)
-            if fmt_err:
-                return fmt_err
-            if request.ref_audio_2 is not None:
-                return self._validate_ref_audio_format(request.ref_audio_2)
-            return None
-
-        if v == "sound_effect":
-            if not request.ambient_sound or not request.ambient_sound.strip():
-                return (
-                    "MOSS-SoundEffect requires 'ambient_sound' (natural language "
-                    "description of the sound effect to synthesise)."
-                )
-            return None
-
-        if v == "voice_generator":
-            if not request.instructions or not request.instructions.strip():
-                return (
-                    "MOSS-VoiceGenerator requires 'instructions' (natural language "
-                    "voice description, e.g. 'a warm female voice with an American accent')."
-                )
-            return None
-
-        return None  # unreachable
-
     def _get_moss_processor(self):
         """Lazily load the upstream MOSS-TTS processor once per server.
 
@@ -1974,7 +1766,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         # headline improvement is multilingual synthesis when the language is
         # given (build_user_message(..., language=...)); 1.0 ignores it
         # gracefully. Sound-effect output is non-verbal, so skip it there.
-        if v in ("tts", "ttsd", "voice_generator") and getattr(request, "language", None):
+        if v in ("tts", "local", "ttsd", "voice_generator") and getattr(request, "language", None):
             user_kwargs["language"] = request.language
 
         # Build the unified-codes prompt: (L, 1+n_vq) where col 0 is text/special
@@ -1994,93 +1786,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             params["max_new_frames"] = [request.max_new_tokens]
         return params
 
-    def _validate_higgs_audio_v2_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate higgs_audio_v2 request parameters. Returns error message or None.
-
-        Accepted: plain text -> speech, or shallow voice clone via ``ref_audio``
-        + ``ref_text`` (both required together). Still out of scope: preset
-        ``voice``/``speaker`` selection, ``x_vector_only_mode`` /
-        ``speaker_embedding`` helpers, ``task_type``/``language``/
-        ``instructions``/``speed`` overrides, and multi-speaker ``[SPEAKERn]``
-        tags inside the input body.
-        """
-        from vllm_omni.model_executor.models.higgs_audio_v2.higgs_audio_v2_tokenizer import (
-            MULTI_SPEAKER_TAG_PATTERN,
-        )
-
-        if not request.input or not request.input.strip():
-            return "higgs_audio_v2: input text cannot be empty"
-
-        # Voice clone: ref_audio and ref_text must come together.
-        if request.ref_audio is not None and not request.ref_text:
-            return (
-                "higgs_audio_v2 voice clone requires both 'ref_audio' and "
-                "'ref_text'; received ref_audio without ref_text"
-            )
-        if request.ref_text and request.ref_audio is None:
-            return (
-                "higgs_audio_v2 voice clone requires both 'ref_audio' and "
-                "'ref_text'; received ref_text without ref_audio"
-            )
-
-        if request.x_vector_only_mode is not None:
-            return "higgs_audio_v2 v1 does not support 'x_vector_only_mode' (voice-cloning helper field)"
-        if request.speaker_embedding is not None:
-            return "higgs_audio_v2 v1 does not support 'speaker_embedding' (voice-cloning helper field)"
-        if request.voice and request.ref_audio is None:
-            # _apply_uploaded_speaker runs before this validator; if voice was
-            # an uploaded speaker, ref_audio is now populated and ref_text is
-            # backfilled from the speaker entry. A bare voice= with no
-            # ref_audio means the name didn't resolve to an uploaded speaker
-            # (and higgs has no built-in preset voices).
-            return (
-                "higgs_audio_v2 v1 does not support 'voice'/'speaker' selection for built-in voices; "
-                f"upload a voice first via POST /v1/audio/voices, or use ref_audio + ref_text. "
-                f"Got voice={request.voice!r}"
-            )
-        if request.instructions:
-            return (
-                "higgs_audio_v2 v1 does not support 'instructions' (voice "
-                "style/emotion control); supply plain text instead"
-            )
-        if request.task_type is not None:
-            return "higgs_audio_v2 v1 does not support 'task_type'; the model is single-mode plain text -> speech"
-        if request.language is not None:
-            return (
-                "higgs_audio_v2 v1 does not accept 'language' overrides; the model infers language from the input text"
-            )
-        if request.speed is not None and request.speed != 1.0:
-            return (
-                "higgs_audio_v2 v1 does not support 'speed' adjustments; the audio is rendered at native rate (24 kHz)"
-            )
-
-        if MULTI_SPEAKER_TAG_PATTERN.search(request.input):
-            return "higgs_audio_v2 v1 does not support multi-speaker [SPEAKERn] tags; remove the tag from the input"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-
-    def _validate_glm_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate GLM-TTS request — requires ref_audio for voice cloning."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        if request.ref_audio is None:
-            return "GLM-TTS requires 'ref_audio' for zero-shot voice cloning"
-        fmt_err = self._validate_ref_audio_format(request.ref_audio)
-        if fmt_err:
-            return fmt_err
-        if not request.ref_text or not request.ref_text.strip():
-            return "GLM-TTS voice cloning requires 'ref_text' (transcript of the reference audio)"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be >= {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-        return None
-
     async def _build_higgs_audio_v2_params(self, request: OpenAICreateSpeechRequest):
         """Build prompt_token_ids for higgs_audio_v2 via the upstream processor.
 
@@ -2157,18 +1862,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
     # ---- higgs-audio v3 ----
 
-    def _validate_higgs_audio_v3_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate higgs_audio_v3 request parameters."""
-        if not request.input or not request.input.strip():
-            return "higgs_audio_v3: input text cannot be empty"
-        if request.ref_audio is not None and not request.ref_text:
-            # Voice clone ref_text is optional for v3 (improves fidelity but not required)
-            pass
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-        return None
-
     async def _build_higgs_audio_v3_params(self, request: OpenAICreateSpeechRequest):
         """Build prompt_token_ids for higgs_audio_v3.
 
@@ -2302,143 +1995,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         self._higgs_audio_v3_adapter = adapter
         return adapter
 
-    def _validate_fish_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate Fish Speech request parameters. Returns error message or None."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        if request.ref_audio is not None:
-            fmt_err = self._validate_ref_audio_format(request.ref_audio)
-            if fmt_err:
-                return fmt_err
-            if not request.ref_text or not request.ref_text.strip():
-                return "Voice cloning requires 'ref_text' (transcript of the reference audio)"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
-    def _validate_cosyvoice3_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate CosyVoice3 request parameters. Returns error message or None."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        # CosyVoice3 requires reference audio for voice cloning
-        if request.ref_audio is None:
-            return "CosyVoice3 requires 'ref_audio' (reference audio for voice cloning)"
-
-        fmt_err = self._validate_ref_audio_format(request.ref_audio)
-        if fmt_err:
-            return fmt_err
-
-        if not request.ref_text or not request.ref_text.strip():
-            return "CosyVoice3 requires 'ref_text' (transcript of the reference audio)"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
-    def _validate_ming_tts_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        """Validate Ming TTS request parameters. Returns error message or None."""
-        if not request.input or not request.input.strip():
-            return "Input text cannot be empty"
-
-        if isinstance(request.ref_audio, list):
-            return self._validate_ming_tts_podcast_request(request)
-        return self._validate_ming_tts_single_speaker_request(request)
-
-    def _validate_ming_tts_single_speaker_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        if request.ref_audio is not None:
-            fmt_err = self._validate_ref_audio_format(request.ref_audio)
-            if fmt_err:
-                return fmt_err
-
-        if request.speaker_embedding is not None:
-            if not request.speaker_embedding:
-                return "'speaker_embedding' must be a non-empty list of floats"
-            emb_len = len(request.speaker_embedding)
-            if emb_len != 192:
-                logger.warning(
-                    "speaker_embedding has %d dimensions; Ming dense expects 192. "
-                    "Wrong dimensions will likely fail or degrade output.",
-                    emb_len,
-                )
-
-        voice_lower = request.voice.lower() if isinstance(request.voice, str) else None
-        uploaded_voice = bool(voice_lower and voice_lower in self.uploaded_speakers)
-        clone_source_present = request.ref_audio is not None or request.speaker_embedding is not None or uploaded_voice
-
-        if request.task_type == "Base" and not clone_source_present:
-            return "Base task requires 'ref_audio', 'speaker_embedding', or an uploaded voice sample"
-
-        if request.ref_audio is not None and request.ref_text is not None and not request.ref_text.strip():
-            return "'ref_text' must be non-empty when provided with 'ref_audio'"
-
-        # Ming offline ref-audio cases use prompt_waveform without prompt_text;
-        # keep the transcript requirement for other TTS models.
-        if request.ref_audio is not None and request.speaker_embedding is None and not self._is_ming_tts_model():
-            uploaded_ref_text = self.uploaded_speakers[voice_lower].get("ref_text") if uploaded_voice else None
-            if not (request.ref_text and request.ref_text.strip()) and not uploaded_ref_text:
-                return "Reference-audio cloning requires non-empty 'ref_text'"
-
-        if request.ref_text is not None and request.ref_audio is None and not uploaded_voice:
-            return "'ref_text' requires 'ref_audio' or an uploaded voice sample"
-
-        if request.instructions and len(request.instructions) > self._max_instructions_length:
-            return f"Instructions too long (max {self._max_instructions_length} characters)"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
-    def _validate_ming_tts_podcast_request(self, request: OpenAICreateSpeechRequest) -> str | None:
-        if len(request.ref_audio) < 2:
-            return "Podcast-style Ming requests require at least two 'ref_audio' clips"
-
-        for ref_audio in request.ref_audio:
-            fmt_err = self._validate_ref_audio_format(ref_audio)
-            if fmt_err:
-                return fmt_err
-
-        if not request.ref_text or not request.ref_text.strip():
-            return "Podcast-style Ming requests require non-empty 'ref_text'"
-
-        if request.speaker_embedding is not None:
-            embeddings = request.speaker_embedding
-            embedding_count = len(embeddings) if embeddings and isinstance(embeddings[0], list) else 1
-            if embedding_count != len(request.ref_audio):
-                return (
-                    "Podcast-style Ming requests require one speaker embedding per ref_audio clip; "
-                    f"got {embedding_count} embeddings for {len(request.ref_audio)} clips"
-                )
-            if embeddings and isinstance(embeddings[0], list):
-                for item in embeddings:
-                    if len(item) != 192:
-                        return "Podcast-style Ming speaker embeddings must each have 192 dimensions"
-
-        if request.instructions and len(request.instructions) > self._max_instructions_length:
-            return f"Instructions too long (max {self._max_instructions_length} characters)"
-
-        if request.max_new_tokens is not None:
-            if request.max_new_tokens < _TTS_MAX_NEW_TOKENS_MIN:
-                return f"max_new_tokens must be at least {_TTS_MAX_NEW_TOKENS_MIN}"
-            if request.max_new_tokens > _TTS_MAX_NEW_TOKENS_MAX:
-                return f"max_new_tokens cannot exceed {_TTS_MAX_NEW_TOKENS_MAX}"
-
-        return None
-
     async def _resolve_ref_audio(self, ref_audio_str: str) -> tuple[list[float], int]:
         """Resolve ref_audio to (wav_samples, sample_rate).
 
@@ -2544,23 +2100,35 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
     def _discard_ref_audio_artifact_ready_if_unreferenced(self, artifact_key: str) -> None:
         if artifact_key and all(entry[3] != artifact_key for entry in self._ref_audio_resolve_cache.values()):
-            self._ref_audio_model_artifact_ready.discard(artifact_key)
+            self._ref_audio_model_artifact_ready = {
+                (key, mode) for (key, mode) in self._ref_audio_model_artifact_ready if key != artifact_key
+            }
+
+    @staticmethod
+    def _tts_x_vector_only(tts_params: dict[str, Any]) -> bool:
+        return bool((tts_params.get("x_vector_only_mode") or [False])[0])
 
     def _qwen3_tts_can_use_ref_audio_artifact_only(self, tts_params: dict[str, Any], artifact_key: str | None) -> bool:
         if self._tts_model_type != "qwen3_tts":
             return False
-        if not artifact_key or artifact_key not in self._ref_audio_model_artifact_ready:
+        x_vector_only = self._tts_x_vector_only(tts_params)
+        if not artifact_key or (artifact_key, x_vector_only) not in self._ref_audio_model_artifact_ready:
             return False
         return (tts_params.get("task_type") or ["CustomVoice"])[0] == "Base"
 
-    def _track_ref_audio_artifact_warmup(self, request_id: str, artifact_key: str | None) -> None:
+    def _track_ref_audio_artifact_warmup(
+        self, request_id: str, artifact_key: str | None, x_vector_only: bool = False
+    ) -> None:
         if artifact_key:
-            self._request_ref_audio_artifact_keys[request_id] = artifact_key
+            self._request_ref_audio_artifact_keys[request_id] = (artifact_key, bool(x_vector_only))
 
     def _mark_ref_audio_artifact_ready_for_request(self, request_id: str) -> None:
-        artifact_key = self._request_ref_audio_artifact_keys.pop(request_id, None)
+        tracked = self._request_ref_audio_artifact_keys.pop(request_id, None)
+        if tracked is None:
+            return
+        artifact_key, x_vector_only = tracked
         if artifact_key and any(entry[3] == artifact_key for entry in self._ref_audio_resolve_cache.values()):
-            self._ref_audio_model_artifact_ready.add(artifact_key)
+            self._ref_audio_model_artifact_ready.add((artifact_key, x_vector_only))
 
     def _discard_ref_audio_artifact_warmup(self, request_id: str) -> None:
         self._request_ref_audio_artifact_keys.pop(request_id, None)
@@ -2573,9 +2141,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
     # ---- Ming TTS helpers ----
 
-    def _is_ming_tts_model(self) -> bool:
-        return self._tts_model_type == "ming_tts"
-
     def _coerce_ming_prompt_waveform(self, wav_samples, sample_rate):
         from torchaudio.functional import resample as resample_audio
 
@@ -2586,35 +2151,18 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             waveform = resample_audio(waveform, int(sample_rate), SAMPLE_RATE)
         return waveform
 
-    def _build_ming_prompt_waveform(
+    def _build_ming_reference_waveforms(
         self,
         ref_audio_data: tuple[list[float], int] | list[tuple[list[float], int]] | None,
-    ):
-        if isinstance(ref_audio_data, list):
-            return torch.cat(
-                [self._coerce_ming_prompt_waveform(item[0], item[1]) for item in ref_audio_data],
-                dim=-1,
-            )
-        if ref_audio_data is not None:
-            return self._coerce_ming_prompt_waveform(ref_audio_data[0], ref_audio_data[1])
-        return None
-
-    def _extract_ming_speaker_embeddings_from_ref_audio(
-        self,
-        ref_audio_data_list: list[tuple[list[float], int]],
-    ) -> list[list[float]]:
-        from vllm_omni.model_executor.models.ming_tts.speaker_extractor import MingSpeakerEmbeddingExtractor
-
-        extractor = MingSpeakerEmbeddingExtractor(self.engine_client.model_config.model, target_sr=16000)
-        embeddings = []
-        for wav_samples, sr in ref_audio_data_list:
-            waveform = torch.as_tensor(wav_samples, dtype=torch.float32).reshape(1, -1)
-            embedding = extractor.extract_from_waveform(waveform, int(sr))
-            flat = embedding.detach().reshape(-1).to(torch.float32).cpu()
-            if int(flat.numel()) != 192:
-                raise ValueError(f"Ming speaker extractor returned {int(flat.numel())} dims; expected 192")
-            embeddings.append(flat.tolist())
-        return embeddings
+    ) -> tuple[list[torch.Tensor], list[int]]:
+        if ref_audio_data is None:
+            return [], []
+        items = ref_audio_data if isinstance(ref_audio_data, list) else [ref_audio_data]
+        waveforms = [torch.as_tensor(samples, dtype=torch.float32).reshape(1, -1) for samples, _ in items]
+        sample_rates = [int(sample_rate) for _, sample_rate in items]
+        if any(sample_rate <= 0 for sample_rate in sample_rates):
+            raise ValueError(f"Ming reference audio sample rates must be positive, got {sample_rates}")
+        return waveforms, sample_rates
 
     def _parse_ming_instruction_fields(
         self,
@@ -2657,11 +2205,18 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         request: OpenAICreateSpeechRequest,
         *,
         ref_audio_data: tuple[list[float], int] | list[tuple[list[float], int]] | None = None,
+        voice_name: str | None = None,
+        voice_created_at: int = 0,
     ) -> dict[str, Any]:
         """Build a Ming dense prompt directly from the OpenAI speech request."""
         from transformers import AutoTokenizer
 
-        from vllm_omni.model_executor.models.ming_tts.config_ming_tts import KEY_MAX_DECODE_STEPS
+        from vllm_omni.model_executor.models.ming_tts.config_ming_tts import (
+            KEY_MAX_DECODE_STEPS,
+            KEY_SPEAKER_SAMPLE_RATES,
+            KEY_SPEAKER_WAVEFORM,
+            KEY_SPEAKER_WAVEFORM_LENGTHS,
+        )
         from vllm_omni.model_executor.models.ming_tts.prompt_assembly import build_ming_dense_prompt
 
         if self._tts_tokenizer is None:
@@ -2670,9 +2225,20 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             self._tts_tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=trust_remote_code)
 
         ref_text = request.ref_text
-        prompt_waveform = self._build_ming_prompt_waveform(ref_audio_data) if ref_text is not None else None
+        reference_waveforms, reference_sample_rates = self._build_ming_reference_waveforms(ref_audio_data)
+        reference_waveform = torch.cat(reference_waveforms, dim=-1) if reference_waveforms else None
+        prompt_waveforms = (
+            [
+                self._coerce_ming_prompt_waveform(waveform, sample_rate)
+                for waveform, sample_rate in zip(reference_waveforms, reference_sample_rates, strict=True)
+            ]
+            if ref_text is not None
+            else []
+        )
+        prompt_waveform = torch.cat(prompt_waveforms, dim=-1) if prompt_waveforms else None
         speaker_embedding = request.speaker_embedding
-        use_zero_spk_emb = prompt_waveform is None and speaker_embedding is None
+        pending_speaker_extraction = speaker_embedding is None and reference_waveform is not None
+        use_zero_spk_emb = not pending_speaker_extraction and prompt_waveform is None and speaker_embedding is None
 
         runtime_controls = {}
         if request.max_new_tokens is not None:
@@ -2689,8 +2255,23 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             prompt_text=ref_text,
             prompt_waveform=prompt_waveform,
             speaker_embedding=speaker_embedding,
+            speaker_count=len(reference_waveforms) if pending_speaker_extraction else None,
             use_zero_spk_emb=use_zero_spk_emb,
         )
+        additional_information = prompt_dict["additional_information"]
+        if pending_speaker_extraction:
+            additional_information[KEY_SPEAKER_WAVEFORM] = reference_waveform
+            additional_information[KEY_SPEAKER_WAVEFORM_LENGTHS] = torch.tensor(
+                [int(waveform.shape[-1]) for waveform in reference_waveforms],
+                dtype=torch.int32,
+            )
+            additional_information[KEY_SPEAKER_SAMPLE_RATES] = torch.tensor(
+                reference_sample_rates,
+                dtype=torch.int32,
+            )
+            if voice_name:
+                additional_information["voice_name"] = voice_name
+                additional_information["voice_created_at"] = int(voice_created_at)
         prompt = tokens_input(prompt_token_ids=prompt_dict["prompt_token_ids"])
         prompt["prompt"] = prompt_dict["prompt"]
         prompt["text"] = prompt_dict["text"]
@@ -2764,6 +2345,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     )
                     if chunk_np.ndim > 1:
                         chunk_np = chunk_np.squeeze()
+                    if self._tts_model_type in _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES and int(np.size(chunk_np)) == 0:
+                        # Zero-size chunks must not emit a WAV header or count
+                        # as first audio; the post-loop guard below needs to
+                        # see an audio-less stream to fail the request.
+                        continue
                     # For WAV format, emit header before first audio chunk
                     if response_format == "wav" and first_chunk:
                         # Assert that sample rate has been set from chunk metadata (not just default)
@@ -2795,6 +2381,10 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                         yield audio_bytes, sample_rate_val
                     else:
                         yield audio_bytes
+            if self._tts_model_type in _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES and first_audio_chunk_s is None:
+                # Audex contract: zero codec tokens must abort the stream, not
+                # complete it cleanly with zero audio bytes.
+                raise ValueError("Audex produced no audio (the thinker emitted zero or invalid codec tokens)")
             self._mark_ref_audio_artifact_ready_for_request(request_id)
             artifact_ready = True
             total_ms = (time.perf_counter() - stream_start_s) * 1000.0
@@ -3268,6 +2858,140 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         )
         return {"prompt_token_ids": prompt_ids}
 
+    def _get_audex_tokenizer(self):
+        """Load (once per process) the Audex thinker tokenizer for CFG/TTA prompts.
+
+        The folder follows the serving stage: the full-pipeline thinker
+        (``audex_omni``) tokenizes with ``checkpoint_folder_full``; the TTS
+        and TTA thinkers use ``checkpoint_folder_audiogen``.
+        """
+        if self._audex_tokenizer is None:
+            from transformers import AutoTokenizer
+
+            from vllm_omni.model_executor.models.audex.checkpoint import ensure_audex_snapshot
+
+            stage = getattr(getattr(self._tts_stage, "engine_args", None), "model_stage", None)
+            if stage == "audex_omni":
+                profile, folder = "full", "checkpoint_folder_full"
+            elif stage == "audex_tta_thinker":
+                profile, folder = "tta", "checkpoint_folder_audiogen"
+            else:
+                profile, folder = "tts", "checkpoint_folder_audiogen"
+            # The serving model_config may already hold the RESOLVED per-stage
+            # checkpoint folder (stage init joins model_subdir onto the
+            # snapshot root); joining again would produce a non-existent path
+            # that transformers then mistakes for a repo id.
+            model_path = os.path.normpath(self.engine_client.model_config.model)
+            if os.path.basename(model_path).startswith("checkpoint_folder"):
+                root = os.path.dirname(model_path)
+            else:
+                root = ensure_audex_snapshot(model_path, profile=profile)
+            self._audex_tokenizer = AutoTokenizer.from_pretrained(os.path.join(root, folder))
+        return self._audex_tokenizer
+
+    def _inject_audex_tta_args(self, request_id: str, prompt: Any, stage0_params: Any) -> Any:
+        """Complete the Audex TTA contract on a CLONE of the stage-0 params.
+
+        Always attaches the RVQ phase-mask contract (required for token
+        validity) and the CFG pair contract at the official default scale
+        3.0 unless the caller passed ``cfg_scale`` (1.0 disables guidance).
+
+        Returns the cloned params; the input is never mutated. On the
+        no-extra_params online path the input is an element of the engine's
+        SHARED ``default_sampling_params_list`` — writing per-request pair
+        state (``cfg_pair_id``/``cfg_null_prompt``) into it would race
+        concurrent requests and leak stale CFG metadata into later ones.
+        """
+        import copy
+
+        from vllm_omni.model_executor.models.audex.prompt import build_tta_null_prompt
+        from vllm_omni.model_executor.models.audex.tta import build_tta_phase_token_ids
+
+        cond_prompt = prompt.get("prompt") if isinstance(prompt, dict) else prompt
+        if not isinstance(cond_prompt, str) or not cond_prompt:
+            raise ValueError("Audex TTA requires the adapter-built caption prompt")
+
+        stage0_params = copy.deepcopy(stage0_params)
+        tokenizer = self._get_audex_tokenizer()
+        if self._audex_tta_rvq is None:
+            phase_token_ids, start_tid, end_tid = build_tta_phase_token_ids(tokenizer)
+            self._audex_tta_rvq = {
+                "phase_token_ids": phase_token_ids,
+                "start_tid": start_tid,
+                "end_tid": end_tid,
+                # Official generation cap (decode truncates at 500 frames).
+                "codec_cap": 4000,
+                # The TTA prompt ends with <audiogen_start>.
+                "start_in_prompt": True,
+            }
+
+        extra_args = getattr(stage0_params, "extra_args", None)
+        if extra_args is None:
+            extra_args = {}
+            stage0_params.extra_args = extra_args
+        extra_args["tta_rvq"] = self._audex_tta_rvq
+
+        cfg_scale = extra_args.get("cfg_scale")
+        cfg_scale = 3.0 if cfg_scale is None else float(cfg_scale)
+        if cfg_scale <= 1.0:
+            extra_args.pop("cfg_scale", None)
+            return stage0_params
+        extra_args.update(
+            {
+                "cfg_scale": cfg_scale,
+                "cfg_role": "cond",
+                "cfg_pair_id": request_id,
+                "cfg_null_prompt": build_tta_null_prompt(cond_prompt, tokenizer),
+            }
+        )
+        return stage0_params
+
+    def _inject_audex_cfg_pair_args(self, request_id: str, prompt: Any, stage0_params: Any) -> Any:
+        """Complete the Audex CFG contract on a CLONE of the stage-0 params.
+
+        The adapter validated ``cfg_scale``; here (where the final request id
+        exists) the cond role, pair id, and the length-matched null prompt are
+        attached. ``cfg_scale`` absent/1.0 returns a clone value-identical to
+        the non-CFG flow (the key is dropped rather than forwarded).
+
+        Returns the cloned params; the input is never mutated (it may be an
+        element of the engine's shared ``default_sampling_params_list`` —
+        see ``_inject_audex_tta_args``).
+        """
+        import copy
+
+        stage0_params = copy.deepcopy(stage0_params)
+        extra_args = getattr(stage0_params, "extra_args", None)
+        if not extra_args or extra_args.get("cfg_scale") is None:
+            if extra_args:
+                extra_args.pop("cfg_scale", None)
+            return stage0_params
+        cfg_scale = float(extra_args["cfg_scale"])
+        if cfg_scale <= 1.0:
+            extra_args.pop("cfg_scale", None)
+            return stage0_params
+
+        from vllm_omni.model_executor.models.audex.prompt import build_null_prompt
+
+        cond_prompt = prompt.get("prompt") if isinstance(prompt, dict) else prompt
+        if not isinstance(cond_prompt, str) or not cond_prompt:
+            raise ValueError("Audex CFG requires the adapter-built text prompt")
+        null_prompt = build_null_prompt(cond_prompt, self._get_audex_tokenizer())
+        extra_args.update(
+            {
+                "cfg_scale": cfg_scale,
+                "cfg_role": "cond",
+                "cfg_pair_id": request_id,
+                "cfg_null_prompt": null_prompt,
+            }
+        )
+        # Guided decoding sharpens the distribution; the unguided default
+        # temperature (0.1) adds excess sampling noise under CFG. Measured
+        # on the en-24 gate corpus at cfg 1.5: temp 0.1 -> CER 7.31%,
+        # temp 0.05 -> CER 6.87% (unguided baseline 7.24%).
+        stage0_params.temperature = 0.05
+        return stage0_params
+
     def _apply_cosyvoice3_dynamic_tokens(
         self,
         sampling_params_list: list,
@@ -3488,6 +3212,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         self,
         request: OpenAICreateSpeechRequest,
         request_id: str | None = None,
+        has_inline_ref_audio: bool | None = None,
     ) -> tuple[str, Any, dict[str, Any]]:
         if self.engine_client.errored:
             raise self.engine_client.dead_error
@@ -3520,7 +3245,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         # in place. The builders need to know whether the caller supplied audio
         # inline vs. via an uploaded voice.
         model_type: str | None = None
-        has_inline_ref_audio = request.ref_audio is not None
+        has_inline_ref_audio = (request.ref_audio is not None) if has_inline_ref_audio is None else has_inline_ref_audio
         if self._tts_model_type == "ming_flash_omni_tts":
             # ming_flash_omni is intentionally NOT migrated onto the adapter
             # framework in this PR (it has no registered adapter); keep it on the
@@ -3642,11 +3367,25 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             import copy
 
             sampling_params_list = copy.deepcopy(sampling_params_list)
+            for name in ("temperature", "top_p", "top_k"):
+                if (value := request.extra_params.get(name)) is not None:
+                    setattr(sampling_params_list[0], name, value)
             if sampling_params_list[0].extra_args is None:
                 sampling_params_list[0].extra_args = {}
             sampling_params_list[0].extra_args.update(request.extra_params)
             logger.info("Applied extra_params: %s", request.extra_params)
 
+        # Audex CFG: turn an adapter-validated cfg_scale into the engine-side
+        # pair contract. This must run here (not in the adapter) because the
+        # pair id is the final request_id, which the adapter never sees.
+        # The injectors return a CLONE: without extra_params above,
+        # sampling_params_list still holds the engine's shared default params,
+        # which must never carry per-request CFG state.
+        if self._tts_model_type == "audex" and sampling_params_list:
+            sampling_params_list[0] = self._inject_audex_cfg_pair_args(request_id, prompt, sampling_params_list[0])
+        elif self._tts_model_type == "audex_tta" and sampling_params_list:
+            sampling_params_list[0] = self._inject_audex_tta_args(request_id, prompt, sampling_params_list[0])
+
         # Some TTS model defaults come from deploy YAML. Their AR
         # generation length is controlled by SamplingParams.max_tokens, so only
         # override it when the caller explicitly requests max_new_tokens.
@@ -3711,7 +3450,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             sampling_params_list=sampling_params_list,
             output_modalities=["audio"],
         )
-        self._track_ref_audio_artifact_warmup(request_id, qwen3_ref_audio_warmup_artifact_key)
+        self._track_ref_audio_artifact_warmup(
+            request_id,
+            qwen3_ref_audio_warmup_artifact_key,
+            x_vector_only=self._tts_x_vector_only(tts_params),
+        )
         return request_id, generator, tts_params
 
     async def _generate_pcm_chunks(self, generator, request_id: str, *, include_sample_rate: bool = False):
@@ -3743,12 +3486,15 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         base64_encode: bool = False,
         request_id: str | None = None,
         usage_out: list[SpeechTokenUsage] | None = None,
+        has_inline_ref_audio: bool | None = None,
     ) -> tuple[bytes | str, str]:
         # ``usage_out`` is an opt-in output channel: when a list is passed, the
         # computed SpeechTokenUsage is appended to it. The return stays a
         # 2-tuple so existing callers (and their test mocks) are unaffected;
         # only the batch path, which surfaces per-item usage, opts in.
-        request_id, generator, bytes_tts_params = await self._prepare_speech_generation(request, request_id=request_id)
+        request_id, generator, bytes_tts_params = await self._prepare_speech_generation(
+            request, request_id=request_id, has_inline_ref_audio=has_inline_ref_audio
+        )
         artifact_ready = False
 
         try:
@@ -3840,6 +3586,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             if audio_tensor.ndim > 1:
                 audio_tensor = audio_tensor.squeeze()
 
+            if self._tts_model_type in _AUDEX_NO_AUDIO_GUARD_MODEL_TYPES and int(np.size(audio_tensor)) == 0:
+                # Audex contract: zero codec tokens must fail the request, not
+                # serialize as an empty-but-successful WAV.
+                raise ValueError("Audex produced no audio (the thinker emitted zero or invalid codec tokens)")
+
             audio_obj = CreateAudio(
                 audio_tensor=audio_tensor,
                 sample_rate=sample_rate,
@@ -4205,17 +3956,15 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         merged_requests = [self._merge_batch_item(batch_request, item) for item in batch_request.items]
 
         async def _run_item(idx: int, req: OpenAICreateSpeechRequest) -> SpeechBatchItemResult:
-            # Batch validation still goes through _validate_tts_request directly
-            # (not the adapter). The single-request path validates via the
-            # adapter; both ultimately call the same per-model validators, so the
-            # surfaces stay in sync. Routing batch through the adapter (and its
-            # uploaded-speaker handling) is a follow-up (RFC #4327).
+            has_inline_ref_audio = req.ref_audio is not None
             validation_error = self._validate_tts_request(req)
             if validation_error is not None:
                 return SpeechBatchItemResult(index=idx, status="error", error=validation_error)
             usage_box: list[SpeechTokenUsage] = []
             try:
-                audio_data, media_type = await self._generate_audio_bytes(req, base64_encode=True, usage_out=usage_box)
+                audio_data, media_type = await self._generate_audio_bytes(
+                    req, base64_encode=True, usage_out=usage_box, has_inline_ref_audio=has_inline_ref_audio
+                )
             except Exception as e:
                 logger.exception("Batch item %d failed: %s", idx, e)
                 return SpeechBatchItemResult(index=idx, status="error", error=str(e))
diff --git a/vllm_omni/entrypoints/openai/serving_speech_stream.py b/vllm_omni/entrypoints/openai/serving_speech_stream.py
index 28acf8679..102cfda45 100644
--- a/vllm_omni/entrypoints/openai/serving_speech_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_speech_stream.py
@@ -3,26 +3,46 @@
 Accepts text incrementally via WebSocket, buffers it until input.done, and
 generates audio once for the buffered input using the existing TTS pipeline.
 
+input.done is a flush, not a close: it ends the current utterance and the
+connection stays open, so the next utterance reuses the same connection
+instead of paying another WebSocket handshake. A connection ends on
+session.close, on the idle timeout, or when the client closes the socket.
+The session config is sticky across flushes and can be replaced by sending
+another session.config between utterances.
+
+"Utterance" here names the flush unit rather than any linguistic unit: it is
+whatever text the client had buffered when it sent input.done, from a word to
+several paragraphs, synthesized as a single request.
+
 Protocol:
     Client -> Server:
-        {"type": "session.config", ...}   # Session config (sent once first)
+        {"type": "session.config", ...}   # Session config (first message; repeatable)
         {"type": "input.text", "text": "..."} # Text chunks
-        {"type": "input.done"}            # End of input
+        {"type": "input.done"}            # End of utterance, flush and keep connection open
+        {"type": "session.close"}         # End of connection
 
     Server -> Client (default, word_timestamps=false):
-        {"type": "audio.start", "sentence_index": 0, "sentence_text": "...", "format": "wav"}
+        {"type": "audio.start", "utterance_index": 0, "sentence_index": 0,
+         "sentence_text": "...", "format": "wav"}
         <binary frame: audio bytes>
         ...
-        {"type": "audio.done", "sentence_index": 0}
-        {"type": "session.done", "total_sentences": N}
+        {"type": "audio.done", "utterance_index": 0, "sentence_index": 0}
+        {"type": "session.done", "utterance_index": 0, "total_sentences": N}
         {"type": "error", "message": "..."}
+        # session.done ends the flushed utterance, not the connection. An
+        # utterance is just the flush unit: whatever text was buffered when
+        # input.done arrived, of any length. utterance_index counts those
+        # flushes across the connection, while sentence_index counts within
+        # one of them and so pairs with total_sentences.
 
     Server -> Client (when word_timestamps=true):
-        {"type": "audio.start", "sentence_index": 0, "sentence_text": "...", "format": "pcm"}
-        {"type": "audio.chunk", "sentence_index": 0, "chunk_id": 0, "audio_b64": "<base64 PCM>", "timestamps": null}
+        {"type": "audio.start", "utterance_index": 0, "sentence_index": 0,
+         "sentence_text": "...", "format": "pcm"}
+        {"type": "audio.chunk", "utterance_index": 0, "sentence_index": 0, "chunk_id": 0,
+         "audio_b64": "<base64 PCM>", "timestamps": null}
         ...
         {"type": "audio.chunk", "audio_b64": "", "timestamps": [{"word", "start_ms", "end_ms"}, ...]}
-        {"type": "audio.done", "sentence_index": 0}
+        {"type": "audio.done", "utterance_index": 0, "sentence_index": 0}
         # Audio is JSON base64 PCM (not binary). A trailing empty-audio chunk carries the
         # full sentence-relative alignment. timestamps: list = aligned, [] = silence, null = failed.
 """
@@ -57,9 +77,11 @@ _MAX_INPUT_TEXT_MESSAGE_SIZE = 128 * 1024
 class OmniStreamingSpeechHandler:
     """Handles WebSocket sessions for streaming text-input TTS.
 
-    Each WebSocket connection is an independent session. Text arrives
-    incrementally, is buffered until input.done, and audio is generated once
-    for the buffered input using the existing OmniOpenAIServingSpeech pipeline.
+    A connection carries one or more utterances. Text arrives incrementally,
+    is buffered until input.done, and audio is generated once for the
+    buffered input using the existing OmniOpenAIServingSpeech pipeline. The
+    connection outlives each utterance so a client can keep synthesizing on
+    it without reconnecting.
 
     Args:
         speech_service: The existing TTS serving instance (reused for
@@ -79,54 +101,64 @@ class OmniStreamingSpeechHandler:
         self._config_timeout = config_timeout
 
     async def handle_session(self, websocket: WebSocket) -> None:
-        """Main session loop for a single WebSocket connection."""
+        """Main loop for a single WebSocket connection.
+
+        Serves any number of utterances: text is buffered until input.done,
+        which flushes it as one TTS request and then leaves the connection
+        open for the next one. Rejecting a message is only fatal before the
+        first valid session.config; afterwards the error is reported and the
+        connection survives.
+        """
         await websocket.accept()
 
+        config: StreamingSpeechSessionConfig | None = None
+        text_parts: list[str] = []
+        utterance_index = 0
+
         try:
-            # 1. Wait for session.config
-            config = await self._receive_config(websocket)
-            if config is None:
-                return  # Error already sent, connection closing
-
-            # Validate model if specified
-            if config.model and hasattr(self._speech_service, "_check_model"):
-                error = await self._speech_service._check_model(
-                    OpenAICreateSpeechRequest(input="ping", model=config.model)
-                )
-                if error is not None:
-                    await self._send_error(websocket, str(error))
-                    return
-
-            text_parts: list[str] = []
-
-            # 2. Receive text chunks until input.done
             while True:
                 try:
                     raw = await asyncio.wait_for(
                         websocket.receive_text(),
-                        timeout=self._idle_timeout,
+                        timeout=self._config_timeout if config is None else self._idle_timeout,
                     )
                 except asyncio.TimeoutError:
-                    await self._send_error(websocket, "Idle timeout: no message received")
+                    if config is None:
+                        await self._send_error(websocket, "Timeout waiting for session.config")
+                    else:
+                        await self._send_error(websocket, "Idle timeout: no message received")
                     return
 
-                if len(raw) > _MAX_INPUT_TEXT_MESSAGE_SIZE:
-                    await self._send_error(websocket, "input.text message too large")
-                    continue
-
-                try:
-                    msg = json.loads(raw)
-                except json.JSONDecodeError:
-                    await self._send_error(websocket, "Invalid JSON message")
-                    continue
-
-                if not isinstance(msg, dict):
-                    await self._send_error(websocket, "WebSocket messages must be JSON objects")
+                msg = await self._parse_message(websocket, raw)
+                if msg is None:
+                    if config is None:
+                        return  # Malformed handshake, connection closing
                     continue
 
                 msg_type = msg.get("type")
 
-                if msg_type == "input.text":
+                if msg_type == "session.config":
+                    if text_parts:
+                        await self._send_error(
+                            websocket,
+                            "session.config cannot be applied while input is buffered; send input.done first",
+                        )
+                        continue
+                    new_config = await self._build_config(websocket, msg)
+                    if new_config is None:
+                        if config is None:
+                            return  # Error already sent, connection closing
+                        continue  # Keep serving with the previous config
+                    config = new_config
+
+                elif config is None:
+                    await self._send_error(
+                        websocket,
+                        f"Expected session.config, got: {msg_type}",
+                    )
+                    return
+
+                elif msg_type == "input.text":
                     text = msg.get("text", "")
                     if not isinstance(text, str):
                         await self._send_error(websocket, "input.text requires a string value")
@@ -135,17 +167,31 @@ class OmniStreamingSpeechHandler:
 
                 elif msg_type == "input.done":
                     full_text = "".join(text_parts).strip()
+                    text_parts.clear()
                     total_sentences = 0
                     if full_text:
-                        await self._generate_and_send(websocket, config, full_text, 0)
+                        # However long the buffered text is, the pipeline takes
+                        # it as one request, so every flush is sentence 0 of 1.
+                        await self._generate_and_send(
+                            websocket,
+                            config,
+                            full_text,
+                            utterance_index=utterance_index,
+                            sentence_index=0,
+                        )
                         total_sentences = 1
 
                     await websocket.send_json(
                         {
                             "type": "session.done",
+                            "utterance_index": utterance_index,
                             "total_sentences": total_sentences,
                         }
                     )
+                    utterance_index += 1
+
+                elif msg_type == "session.close":
+                    await websocket.close()
                     return
 
                 else:
@@ -163,44 +209,50 @@ class OmniStreamingSpeechHandler:
             except Exception:
                 logger.debug("Failed to send error to streaming speech client", exc_info=True)
 
-    async def _receive_config(self, websocket: WebSocket) -> StreamingSpeechSessionConfig | None:
-        """Wait for and validate the session.config message."""
-        try:
-            raw = await asyncio.wait_for(
-                websocket.receive_text(),
-                timeout=self._config_timeout,
-            )
-        except asyncio.TimeoutError:
-            await self._send_error(websocket, "Timeout waiting for session.config")
-            return None
+    async def _parse_message(self, websocket: WebSocket, raw: str) -> dict | None:
+        """Decode one client message, or report why it was rejected.
 
-        if len(raw) > _MAX_CONFIG_MESSAGE_SIZE:
-            await self._send_error(websocket, "session.config message too large")
+        Size limits are per message type: session.config carries ref_audio
+        payloads and gets the larger budget.
+        """
+        if len(raw) > max(_MAX_CONFIG_MESSAGE_SIZE, _MAX_INPUT_TEXT_MESSAGE_SIZE):
+            await self._send_error(websocket, "WebSocket message too large")
             return None
 
         try:
             msg = json.loads(raw)
         except json.JSONDecodeError:
-            await self._send_error(websocket, "Invalid JSON in session.config")
+            await self._send_error(websocket, "Invalid JSON message")
             return None
 
         if not isinstance(msg, dict):
-            await self._send_error(websocket, "session.config must be a JSON object")
+            await self._send_error(websocket, "WebSocket messages must be JSON objects")
             return None
 
-        if msg.get("type") != "session.config":
-            await self._send_error(
-                websocket,
-                f"Expected session.config, got: {msg.get('type')}",
-            )
+        if msg.get("type") == "session.config":
+            if len(raw) > _MAX_CONFIG_MESSAGE_SIZE:
+                await self._send_error(websocket, "session.config message too large")
+                return None
+        elif len(raw) > _MAX_INPUT_TEXT_MESSAGE_SIZE:
+            await self._send_error(websocket, "input.text message too large")
             return None
 
+        return msg
+
+    async def _build_config(self, websocket: WebSocket, msg: dict) -> StreamingSpeechSessionConfig | None:
+        """Validate a session.config message and its model."""
         try:
             config = StreamingSpeechSessionConfig(**{k: v for k, v in msg.items() if k != "type"})
         except ValidationError as e:
             await self._send_error(websocket, f"Invalid session config: {e}")
             return None
 
+        if config.model and hasattr(self._speech_service, "_check_model"):
+            error = await self._speech_service._check_model(OpenAICreateSpeechRequest(input="ping", model=config.model))
+            if error is not None:
+                await self._send_error(websocket, str(error))
+                return None
+
         return config
 
     async def _generate_and_send(
@@ -208,9 +260,15 @@ class OmniStreamingSpeechHandler:
         websocket: WebSocket,
         config: StreamingSpeechSessionConfig,
         sentence_text: str,
+        *,
+        utterance_index: int,
         sentence_index: int,
     ) -> None:
-        """Generate audio for a single sentence and send it over WebSocket."""
+        """Generate audio for a single sentence and send it over WebSocket.
+
+        ``utterance_index`` identifies the flush this sentence belongs to and
+        ``sentence_index`` its position inside that flush.
+        """
         response_format = config.response_format or "wav"
 
         # Reject unmet word-timestamps preconditions early with a clear reason.
@@ -253,6 +311,7 @@ class OmniStreamingSpeechHandler:
 
         start_payload = {
             "type": "audio.start",
+            "utterance_index": utterance_index,
             "sentence_index": sentence_index,
             "sentence_text": sentence_text,
             "format": response_format,
@@ -277,6 +336,7 @@ class OmniStreamingSpeechHandler:
                         request_id=request_id,
                         generator=generator,
                         sentence_text=sentence_text,
+                        utterance_index=utterance_index,
                         sentence_index=sentence_index,
                         language=config.language,
                     )
@@ -298,13 +358,22 @@ class OmniStreamingSpeechHandler:
             raise
         except Exception as e:
             generation_failed = True
-            logger.error("Generation failed for sentence %d: %s", sentence_index, e)
-            await self._send_error(websocket, f"Generation failed for sentence {sentence_index}: {e}")
+            logger.error(
+                "Generation failed for utterance %d, sentence %d: %s",
+                utterance_index,
+                sentence_index,
+                e,
+            )
+            await self._send_error(
+                websocket,
+                f"Generation failed for utterance {utterance_index}, sentence {sentence_index}: {e}",
+            )
         finally:
             try:
                 await websocket.send_json(
                     {
                         "type": "audio.done",
+                        "utterance_index": utterance_index,
                         "sentence_index": sentence_index,
                         "total_bytes": total_bytes,
                         "error": generation_failed,
@@ -320,6 +389,7 @@ class OmniStreamingSpeechHandler:
         request_id: str,
         generator,
         sentence_text: str,
+        utterance_index: int,
         sentence_index: int,
         language: str | None = None,
     ) -> int:
@@ -350,6 +420,7 @@ class OmniStreamingSpeechHandler:
             await websocket.send_json(
                 {
                     "type": "audio.chunk",
+                    "utterance_index": utterance_index,
                     "sentence_index": sentence_index,
                     "chunk_id": chunk_id,
                     "chunk_start_ms": chunk_start_ms,
diff --git a/vllm_omni/entrypoints/openai/serving_video.py b/vllm_omni/entrypoints/openai/serving_video.py
index ed846e7e8..c5536c876 100644
--- a/vllm_omni/entrypoints/openai/serving_video.py
+++ b/vllm_omni/entrypoints/openai/serving_video.py
@@ -15,6 +15,7 @@ from PIL import Image
 from vllm.engine.protocol import EngineClient
 from vllm.logger import init_logger
 
+from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.entrypoints.openai.protocol.videos import (
     VideoAction,
@@ -42,21 +43,23 @@ logger = init_logger(__name__)
 class ReferenceImage:
     """Reference class for tracking additional metadata if needed"""
 
-    data: Image.Image
+    data: Image.Image | list[Image.Image]
 
 
 @dataclass
 class ReferenceVideo:
     """Reference video frames for video-conditioned generation."""
 
-    data: list[Image.Image]
+    data: list[Image.Image] | list[str]
+    cleanup_paths: tuple[str, ...] = ()
 
 
 @dataclass
 class ReferenceAudio:
     """Reference audio file path for speech-to-video generation."""
 
-    path: str
+    path: str | list[str]
+    cleanup_paths: tuple[str, ...] = ()
 
 
 @dataclass
@@ -97,6 +100,21 @@ class OmniOpenAIServingVideo:
         if self._stage_configs is None and stage_configs is not None:
             self._stage_configs = stage_configs
 
+    @property
+    def supports_mixed_reference_inputs(self) -> bool:
+        """Return whether the configured diffusion model accepts mixed refs."""
+        get_od_config = getattr(self._engine_client, "get_diffusion_od_config", None)
+        od_config = get_od_config() if callable(get_od_config) else getattr(self._engine_client, "od_config", None)
+        if od_config is None:
+            return False
+
+        capability = getattr(od_config, "supports_mixed_reference_inputs", None)
+        if isinstance(capability, bool):
+            return capability
+
+        model_class_name = getattr(od_config, "model_class_name", None)
+        return get_diffusion_model_metadata(model_class_name).supports_mixed_reference_inputs
+
     @classmethod
     def for_diffusion(
         cls,
@@ -128,22 +146,26 @@ class OmniOpenAIServingVideo:
 
         input_image = None if reference_image is None else reference_image.data
         input_video = None if reference_video is None else reference_video.data
-        if input_image is not None and input_video is not None:
+        if input_image is not None and input_video is not None and not self.supports_mixed_reference_inputs:
             raise HTTPException(
                 status_code=HTTPStatus.BAD_REQUEST.value,
-                detail="Provide either an image reference or a video reference, not both.",
+                detail="This diffusion model does not support mixed image and video references.",
             )
         provided_fields = request.model_fields_set
         fps_provided = self._request_fps_provided(request)
         vp = request.resolve_video_params()
         if input_image is not None and vp.width is not None and vp.height is not None:
             target_size = (vp.width, vp.height)
-            if input_image.size != target_size:
-                input_image = input_image.resize(target_size, Image.Resampling.LANCZOS)
+            image_items = input_image if isinstance(input_image, list) else [input_image]
+            resized_images = [
+                image.resize(target_size, Image.Resampling.LANCZOS) if image.size != target_size else image
+                for image in image_items
+            ]
+            input_image = resized_images if isinstance(input_image, list) else resized_images[0]
         multi_modal_data: dict[str, Any] = {}
         if input_image is not None:
             multi_modal_data["image"] = input_image
-        elif input_video is not None:
+        if input_video is not None:
             multi_modal_data["video"] = input_video
         if reference_audio is not None:
             multi_modal_data["audio"] = reference_audio.path
@@ -154,6 +176,15 @@ class OmniOpenAIServingVideo:
             gen_params.height = vp.height
         if vp.num_frames is not None:
             gen_params.num_frames = vp.num_frames
+        gen_params.num_outputs_per_prompt = request.num_outputs_per_prompt
+        if request.seconds is not None:
+            gen_params.extra_args.setdefault("duration", float(request.seconds))
+        if request.aspect_ratio is not None:
+            gen_params.extra_args["aspect_ratio"] = request.aspect_ratio
+        if request.short_edge is not None:
+            gen_params.extra_args["short_edge"] = request.short_edge
+        if request.start_time_seconds is not None:
+            gen_params.extra_args["start_time_seconds"] = request.start_time_seconds
         # Leave fps/frame_rate as None when the user did not provide fps.
         if fps_provided and vp.fps is not None:
             gen_params.fps = vp.fps
diff --git a/vllm_omni/entrypoints/openai/serving_video_output_stream.py b/vllm_omni/entrypoints/openai/serving_video_output_stream.py
index f713df07c..64327420c 100644
--- a/vllm_omni/entrypoints/openai/serving_video_output_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_video_output_stream.py
@@ -5,13 +5,22 @@
 Protocol:
     Client -> Server:
         {"type": "session.start", "model": "...", "prompt": "...", "format": "m4s", ...}
-        {"type": "session.prompt_update", "prompt": "..."}  # currently unsupported
+        {
+            "type": "session.interaction",
+            "interaction": {
+                "event_id": "...",
+                "event": {"prompt": "..."},
+                "transition_chunks": (optional, integer),
+            },
+        }
         {"type": "session.stop"}
         {"type": "session.ping"}  # optional; refreshes stall clock
 
     Server -> Client:
         {"type": "video.start", "request_id": "...", "config": {...}, "format": "m4s"}
+        {"type": "video.chunk_metadata", ...}
         <binary frame: fragmented MP4 bytes>
+        {"type": "session.interaction.queued", "request_id": "...", "event_id": "..."}
         {"type": "session.done", ...}
         {"type": "session.pong"}  # reply to session.ping
         {"type": "error", "message": "..."}
@@ -21,7 +30,6 @@ from __future__ import annotations
 
 import asyncio
 import copy
-import inspect
 import json
 import time
 import uuid
@@ -29,19 +37,34 @@ from collections.abc import AsyncGenerator
 from http import HTTPStatus
 from typing import Any, cast
 
+import numpy as np
+import torch
 from fastapi import HTTPException, WebSocket, WebSocketDisconnect
+from PIL import Image
 from pydantic import ValidationError
-from vllm.engine.protocol import EngineClient
 from vllm.logger import init_logger
 
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.openai.errors import InvalidInputReferenceError
 from vllm_omni.entrypoints.openai.protocol.videos import VideoGenerationRequest, VideoParams
 from vllm_omni.entrypoints.openai.stage_params import (
     build_stage_sampling_params_list,
     get_default_sampling_params_list,
 )
 from vllm_omni.entrypoints.openai.utils import get_stage_type, parse_lora_request
-from vllm_omni.entrypoints.openai.video_api_utils import StreamingVideoFormat, create_streaming_video_encoder
-from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
+from vllm_omni.entrypoints.openai.video_api_utils import (
+    StreamingVideoFormat,
+    create_streaming_video_encoder,
+    decode_input_reference,
+)
+from vllm_omni.inputs.data import (
+    OmniDiffusionSamplingParams,
+    OmniInteractionEvent,
+    OmniInteractionPrompt,
+    OmniTextPrompt,
+)
+from vllm_omni.outputs import OmniRequestOutput
+from vllm_omni.outputs.output_metadata import DiffusionPayloadValue
 
 logger = init_logger(__name__)
 
@@ -70,7 +93,7 @@ class OmniStreamingVideoOutputHandler:
 
     def __init__(
         self,
-        engine_client: EngineClient,
+        engine_client: AsyncOmni,
         model_name: str | None = None,
         stage_configs: list[Any] | None = None,
         stall_timeout: float = _DEFAULT_STALL_TIMEOUT,
@@ -91,6 +114,7 @@ class OmniStreamingVideoOutputHandler:
         control_task: asyncio.Task[None] | None = None
         stopped = False
         chunks_sent = 0
+        interaction_payloads_by_id: dict[str, OmniInteractionPrompt] = {}
 
         try:
             start = await self._receive_start(websocket)
@@ -112,13 +136,22 @@ class OmniStreamingVideoOutputHandler:
             progress.touch()
 
             control_task = asyncio.create_task(
-                self._control_loop(websocket, request_id, stop_event, send_lock, progress)
+                self._control_loop(
+                    websocket,
+                    request_id,
+                    stop_event,
+                    send_lock,
+                    progress,
+                    interaction_payloads_by_id,
+                )
             )
-            async for chunk in self._stream_video_bytes(request, request_id, output_format, progress):
+            async for chunk, metadata in self._stream_video_bytes(request, request_id, output_format, progress):
                 if stop_event.is_set():
                     stopped = True
                     break
                 async with send_lock:
+                    metadata["transport_chunk_index"] = chunks_sent
+                    await websocket.send_json(metadata)
                     await websocket.send_bytes(chunk)
                 chunks_sent += 1
                 progress.touch()
@@ -234,6 +267,7 @@ class OmniStreamingVideoOutputHandler:
         stop_event: asyncio.Event,
         send_lock: asyncio.Lock,
         progress: _SessionProgress,
+        interaction_payloads_by_id: dict[str, OmniInteractionPrompt],
     ) -> None:
         while not stop_event.is_set():
             if progress.stalled_for(self._stall_timeout):
@@ -282,34 +316,151 @@ class OmniStreamingVideoOutputHandler:
                 except Exception:
                     pass
                 continue
-            if msg_type == "session.prompt_update":
-                await self._send_error(
+            if msg_type == "session.interaction":
+                await self._handle_interaction(
                     websocket,
-                    "session.prompt_update is not supported by this backend yet",
+                    msg,
+                    request_id=request_id,
                     send_lock=send_lock,
+                    interaction_payloads_by_id=interaction_payloads_by_id,
                 )
                 continue
             await self._send_error(websocket, f"Unknown message type: {msg_type}", send_lock=send_lock)
 
     async def _abort_request(self, request_id: str) -> None:
         try:
-            abort = getattr(self._engine_client, "abort", None)
-            if callable(abort):
-                result = abort(request_id)
-                if inspect.isawaitable(result):
-                    await result
+            await self._engine_client.abort(request_id)
         except Exception:
             logger.debug("Failed to abort streaming video request %s", request_id, exc_info=True)
 
+    async def _handle_interaction(
+        self,
+        websocket: WebSocket,
+        msg: dict[str, Any],
+        *,
+        request_id: str,
+        send_lock: asyncio.Lock,
+        interaction_payloads_by_id: dict[str, OmniInteractionPrompt],
+    ) -> None:
+        interaction = msg.get("interaction")
+        if not isinstance(interaction, dict):
+            await self._send_error(websocket, "session.interaction requires an interaction object", send_lock=send_lock)
+            return
+
+        event_id = interaction.get("event_id")
+        if event_id is None:
+            event_id = uuid.uuid4().hex
+        elif not isinstance(event_id, str) or not event_id:
+            await self._send_error(
+                websocket,
+                "session.interaction event_id must be a non-empty string",
+                send_lock=send_lock,
+            )
+            return
+
+        event = interaction.get("event")
+        if not isinstance(event, dict):
+            await self._send_error(websocket, "session.interaction requires event object", send_lock=send_lock)
+            return
+
+        prompt = event.get("prompt")
+        if not isinstance(prompt, str) or not prompt.strip():
+            await self._send_error(
+                websocket,
+                "session.interaction requires a non-empty event.prompt",
+                send_lock=send_lock,
+            )
+            return
+
+        if "negative_prompt" in event and event["negative_prompt"] is not None:
+            await self._send_error(
+                websocket,
+                "session.interaction negative_prompt is not supported in this release",
+                send_lock=send_lock,
+            )
+            return
+
+        normalized: OmniInteractionPrompt = {
+            "event_id": event_id,
+            "event": cast(OmniInteractionEvent, event),
+        }
+        transition_chunks = interaction.get("transition_chunks")
+        if transition_chunks is not None:
+            try:
+                if (
+                    isinstance(transition_chunks, bool)
+                    or not isinstance(transition_chunks, (int, float))
+                    or (isinstance(transition_chunks, float) and not transition_chunks.is_integer())
+                ):
+                    raise ValueError
+                normalized["transition_chunks"] = int(transition_chunks)
+            except (TypeError, ValueError):
+                await self._send_error(
+                    websocket,
+                    "session.interaction transition_chunks must be an integer",
+                    send_lock=send_lock,
+                )
+                return
+            if normalized["transition_chunks"] < 0:
+                await self._send_error(
+                    websocket,
+                    "session.interaction transition_chunks must be >= 0",
+                    send_lock=send_lock,
+                )
+                return
+
+        if event_id in interaction_payloads_by_id:
+            await self._send_error(
+                websocket,
+                "event_id_conflict",
+                code="event_id_conflict",
+                request_id=request_id,
+                event_id=event_id,
+                send_lock=send_lock,
+            )
+            return
+
+        interaction_payloads_by_id[event_id] = normalized
+
+        try:
+            await self._engine_client.submit_interaction_async(
+                request_id,
+                interaction=normalized,
+            )
+        except Exception:
+            logger.exception("Failed to apply interaction for request %s", request_id, exc_info=True)
+            interaction_payloads_by_id.pop(event_id, None)
+            await self._send_error(
+                websocket,
+                "Failed to apply interaction",
+                code="interaction_failed",
+                request_id=request_id,
+                event_id=event_id,
+                send_lock=send_lock,
+            )
+            return
+
+        try:
+            async with send_lock:
+                await websocket.send_json(
+                    {
+                        "type": "session.interaction.queued",
+                        "request_id": request_id,
+                        "event_id": event_id,
+                    }
+                )
+        except Exception:
+            logger.debug("Failed to send interaction acknowledgement for %s", request_id, exc_info=True)
+
     async def _stream_video_bytes(
         self,
         request: VideoGenerationRequest,
         request_id: str,
         output_format: StreamingVideoFormat,
         progress: _SessionProgress,
-    ) -> AsyncGenerator[bytes, None]:
+    ) -> AsyncGenerator[tuple[bytes, dict[str, Any]], None]:
         """Yield encoded video bytes from diffusion streaming outputs."""
-        prompt, gen_params, vp = self._build_prompt_and_sampling_params(request)
+        prompt, gen_params, vp = await self._build_prompt_and_sampling_params(request)
         video_codec_options = {"preset": "ultrafast", "threads": "0", "tune": "zerolatency"}
         if isinstance(request.extra_params, dict) and "video_codec_options" in request.extra_params:
             video_codec_options = request.extra_params["video_codec_options"]
@@ -323,23 +474,41 @@ class OmniStreamingVideoOutputHandler:
         completed = False
         try:
             async for result in self._iter_generation_outputs(prompt, gen_params, request_id, progress):
-                if error := getattr(result, "error", None):
-                    raise RuntimeError(str(error))
+                if result.error:
+                    raise RuntimeError(str(result.error))
                 videos = self._extract_video_outputs(result)
                 for video in videos:
                     chunk = encoder.encode(video)
                     if chunk:
-                        yield chunk
+                        yield (
+                            chunk,
+                            self._build_chunk_metadata(
+                                request_id=request_id,
+                                kind="media",
+                                byte_length=len(chunk),
+                                num_frames=self._num_video_frames(video),
+                                stream_metadata=self._extract_stream_metadata(result),
+                            ),
+                        )
 
             completed = True
             final_chunk = encoder.close()
             if final_chunk:
-                yield final_chunk
+                yield (
+                    final_chunk,
+                    self._build_chunk_metadata(
+                        request_id=request_id,
+                        kind="trailer",
+                        byte_length=len(final_chunk),
+                        num_frames=0,
+                        stream_metadata={},
+                    ),
+                )
         finally:
             if not completed:
                 encoder.close()
 
-    def _build_prompt_and_sampling_params(
+    async def _build_prompt_and_sampling_params(
         self,
         request: VideoGenerationRequest,
     ) -> tuple[OmniTextPrompt, OmniDiffusionSamplingParams, VideoParams]:
@@ -350,6 +519,10 @@ class OmniStreamingVideoOutputHandler:
 
         gen_params = self._resolve_default_sampling_params()
         vp = request.resolve_video_params()
+        input_image = await self._decode_image_reference(request)
+        if input_image is not None:
+            prompt["multi_modal_data"] = {"image": input_image}
+
         if vp.width is not None and vp.height is not None:
             gen_params.width = vp.width
             gen_params.height = vp.height
@@ -386,12 +559,28 @@ class OmniStreamingVideoOutputHandler:
         self._apply_lora(request.lora, gen_params)
         return prompt, gen_params, vp
 
+    @staticmethod
+    async def _decode_image_reference(request: VideoGenerationRequest) -> Image.Image | None:
+        try:
+            media_data = await decode_input_reference(
+                request.image_reference,
+                None,
+                None,
+            )
+        except InvalidInputReferenceError as exc:
+            raise HTTPException(HTTPStatus.BAD_REQUEST.value, detail=str(exc)) from exc
+        if media_data is not None and not isinstance(media_data, Image.Image):
+            raise HTTPException(
+                HTTPStatus.BAD_REQUEST.value,
+                detail="image_reference must resolve to an image.",
+            )
+        return media_data
+
     def _resolve_default_sampling_params(self) -> OmniDiffusionSamplingParams:
-        default_sampling_params_list = getattr(self._engine_client, "default_sampling_params_list", None)
-        if default_sampling_params_list:
-            for params in default_sampling_params_list:
-                if isinstance(params, OmniDiffusionSamplingParams):
-                    return copy.deepcopy(params)
+        default_sampling_params_list = self._engine_client.default_sampling_params_list
+        for params in default_sampling_params_list:
+            if isinstance(params, OmniDiffusionSamplingParams):
+                return copy.deepcopy(params)
         return OmniDiffusionSamplingParams()
 
     @staticmethod
@@ -417,8 +606,8 @@ class OmniStreamingVideoOutputHandler:
         gen_params: OmniDiffusionSamplingParams,
         request_id: str,
         progress: _SessionProgress,
-    ) -> AsyncGenerator[Any, None]:
-        stage_configs = self._stage_configs or getattr(self._engine_client, "stage_configs", None)
+    ) -> AsyncGenerator[OmniRequestOutput, None]:
+        stage_configs = self._stage_configs or self._engine_client.stage_configs
         if not stage_configs:
             raise HTTPException(
                 status_code=HTTPStatus.SERVICE_UNAVAILABLE.value,
@@ -433,15 +622,14 @@ class OmniStreamingVideoOutputHandler:
                     detail=f"Video generation only supports diffusion stages, found '{stage_type}' stage.",
                 )
 
-        engine_client = cast(Any, self._engine_client)
         sampling_params_list = build_stage_sampling_params_list(
             list(stage_configs),
-            get_default_sampling_params_list(engine_client),
+            get_default_sampling_params_list(self._engine_client),
             diffusion_params=gen_params,
             replace_diffusion_params=True,
         )
 
-        async for output in engine_client.generate(
+        async for output in self._engine_client.generate(
             prompt=prompt,
             request_id=request_id,
             sampling_params_list=sampling_params_list,
@@ -450,44 +638,49 @@ class OmniStreamingVideoOutputHandler:
             yield output
 
     @staticmethod
-    def _normalize_video_outputs(videos: Any) -> list[Any]:
+    def _normalize_video_outputs(videos: DiffusionPayloadValue | None) -> list[DiffusionPayloadValue]:
         if videos is None:
             return []
-        if hasattr(videos, "ndim") and videos.ndim == 5:
+        if isinstance(videos, (torch.Tensor, np.ndarray)) and videos.ndim == 5:
             return [videos[i] for i in range(videos.shape[0])]
         if isinstance(videos, list):
             if not videos:
                 return []
             first = videos[0]
-            if hasattr(first, "ndim") and first.ndim == 5:
-                flattened: list[Any] = []
+            if isinstance(first, (torch.Tensor, np.ndarray)) and first.ndim == 5:
+                flattened: list[DiffusionPayloadValue] = []
                 for item in videos:
-                    if hasattr(item, "ndim") and item.ndim == 5:
+                    if isinstance(item, (torch.Tensor, np.ndarray)) and item.ndim == 5:
                         flattened.extend([item[i] for i in range(item.shape[0])])
                     else:
                         flattened.append(item)
                 return flattened
             if isinstance(first, list):
                 return videos
-            if hasattr(first, "ndim") and first.ndim == 3:
+            if isinstance(first, (torch.Tensor, np.ndarray)) and first.ndim == 3:
+                return [videos]
+            if isinstance(first, Image.Image):
                 return [videos]
             return videos
         return [videos]
 
-    def _extract_video_outputs(self, result: Any) -> list[Any]:
-        videos = None
-        if hasattr(result, "images") and result.images:
-            videos = result.images
-        elif hasattr(result, "request_output"):
+    def _extract_video_outputs(self, result: OmniRequestOutput) -> list[DiffusionPayloadValue]:
+        videos: DiffusionPayloadValue | None = None
+        if result.images:
+            # Video frames may be list[list[Image.Image]] despite images: list[Image.Image].
+            videos = result.images  # type: ignore[assignment]
+        elif result.request_output is not None:
             request_output = result.request_output
             if isinstance(request_output, dict) and request_output.get("images"):
                 videos = request_output["images"]
-            elif not isinstance(request_output, dict):
-                if hasattr(request_output, "images") and request_output.images:
-                    videos = request_output.images
-                elif hasattr(request_output, "multimodal_output") and request_output.multimodal_output:
-                    videos = request_output.multimodal_output.get("video")
-        if videos is None and hasattr(result, "multimodal_output") and result.multimodal_output:
+            elif isinstance(request_output, OmniRequestOutput):
+                if request_output.images:
+                    # Same nested-frames mismatch as result.images above.
+                    videos = request_output.images  # type: ignore[assignment]
+                else:
+                    request_multimodal_output = request_output.multimodal_output
+                    videos = request_multimodal_output.get("video")
+        if videos is None:
             videos = result.multimodal_output.get("video")
 
         normalized = self._normalize_video_outputs(videos)
@@ -498,18 +691,64 @@ class OmniStreamingVideoOutputHandler:
             )
         return normalized
 
+    @staticmethod
+    def _extract_stream_metadata(result: OmniRequestOutput) -> dict[str, Any]:
+        multimodal_output = result.multimodal_output
+        if not isinstance(multimodal_output, dict):
+            return {}
+        metadata = multimodal_output.get("metadata")
+        if not isinstance(metadata, dict):
+            return {}
+        stream = metadata.get("stream")
+        return dict(stream) if isinstance(stream, dict) else {}
+
+    @staticmethod
+    def _num_video_frames(video: DiffusionPayloadValue) -> int:
+        if isinstance(video, (torch.Tensor, np.ndarray)) and len(video.shape) > 0:
+            return int(video.shape[0])
+        if isinstance(video, list):
+            return len(video)
+        return 0
+
+    @staticmethod
+    def _build_chunk_metadata(
+        *,
+        request_id: str,
+        kind: str,
+        byte_length: int,
+        num_frames: int,
+        stream_metadata: dict[str, Any],
+    ) -> dict[str, Any]:
+        return {
+            "type": "video.chunk_metadata",
+            "request_id": request_id,
+            "kind": kind,
+            "num_frames": num_frames,
+            "byte_length": byte_length,
+            "generation_chunk_index": (stream_metadata.get("generation_chunk_index") if kind == "media" else None),
+            "started_event_ids": stream_metadata.get("started_event_ids", []),
+            "active_event_ids": stream_metadata.get("active_event_ids", []),
+            "completed_event_ids": stream_metadata.get("completed_event_ids", []),
+        }
+
     @staticmethod
     async def _send_error(
         websocket: WebSocket,
         message: str,
-        code: int | None = None,
+        code: int | str | None = None,
         *,
+        request_id: str | None = None,
+        event_id: str | None = None,
         send_lock: asyncio.Lock | None = None,
     ) -> None:
         try:
             payload: dict[str, Any] = {"type": "error", "message": message}
             if code is not None:
                 payload["code"] = code
+            if request_id is not None:
+                payload["request_id"] = request_id
+            if event_id is not None:
+                payload["event_id"] = event_id
             if send_lock is None:
                 await websocket.send_json(payload)
             else:
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
index a2b9cce09..c1317c3af 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
@@ -51,6 +51,8 @@ def resolve_adapter(model_type: str | None) -> type[TTSModelAdapter] | None:
 # Import adapter modules for their registration side effects. Keep at the bottom
 # so the registry helpers above are defined first.
 from vllm_omni.entrypoints.openai.tts_adapters import (  # noqa: E402,F401
+    audex,
+    audex_tta,
     cosyvoice3,
     covo_audio,
     fish_speech,
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/audex.py b/vllm_omni/entrypoints/openai/tts_adapters/audex.py
new file mode 100644
index 000000000..890e132de
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/tts_adapters/audex.py
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Audex (Nemotron-Labs-Audex-2B) TTS serving adapter."""
+
+from typing import TYPE_CHECKING
+
+from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
+from vllm_omni.entrypoints.openai.tts_adapters.base import ARTTSAdapter, PreparedRequest
+from vllm_omni.model_executor.models.audex.prompt import build_cond_prompt
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+
+
+# Classifier-free guidance strength accepted on /v1/audio/speech via
+# extra_params. 1.0 disables guidance (identical to omitting it); the
+# official TTS quality setting is 1.5.
+AUDEX_CFG_SCALE_MIN = 1.0
+AUDEX_CFG_SCALE_MAX = 10.0
+
+# Internal CFG pair-plumbing keys; injected by the serving layer once the
+# request id exists, never accepted from callers.
+_AUDEX_INTERNAL_CFG_KEYS = ("cfg_role", "cfg_pair_id", "cfg_null_prompt")
+
+
+@register_tts_adapter
+class AudexAdapter(ARTTSAdapter):
+    """Plain English TTS: single built-in voice, no reference audio, optional CFG."""
+
+    stage_keys = frozenset({"audex_thinker", "audex_omni"})
+    name = "audex"
+
+    def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        if not request.input or not request.input.strip():
+            return "Audex TTS requires non-empty input text"
+        voice = (request.voice or "").strip().lower()
+        if voice not in ("", "default"):
+            return (
+                f"Audex has a single built-in voice and no voice cloning; got voice={request.voice!r}. "
+                "Omit 'voice' or pass 'default'."
+            )
+        if request.ref_audio is not None:
+            return "Audex does not support reference audio (no voice cloning)."
+        extra = request.extra_params or {}
+        for key in _AUDEX_INTERNAL_CFG_KEYS:
+            if key in extra:
+                return f"extra_params.{key} is managed internally by the server; only cfg_scale may be set."
+        cfg_scale = extra.get("cfg_scale")
+        if cfg_scale is not None:
+            try:
+                cfg_value = float(cfg_scale)
+            except (TypeError, ValueError):
+                return (
+                    f"extra_params.cfg_scale must be a number in "
+                    f"[{AUDEX_CFG_SCALE_MIN}, {AUDEX_CFG_SCALE_MAX}]; got {cfg_scale!r}."
+                )
+            if not (AUDEX_CFG_SCALE_MIN <= cfg_value <= AUDEX_CFG_SCALE_MAX):
+                return (
+                    f"extra_params.cfg_scale must be within [{AUDEX_CFG_SCALE_MIN}, {AUDEX_CFG_SCALE_MAX}]; "
+                    f"got {cfg_scale!r}. 1.0 disables guidance; 1.5 is the recommended quality setting."
+                )
+        return None
+
+    async def build(
+        self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
+    ) -> PreparedRequest:
+        prompt = {"prompt": build_cond_prompt(request.input)}
+        return PreparedRequest(prompt=prompt, tts_params={}, model_type="audex")
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/audex_tta.py b/vllm_omni/entrypoints/openai/tts_adapters/audex_tta.py
new file mode 100644
index 000000000..f754f0158
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/tts_adapters/audex_tta.py
@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Audex (Nemotron-Labs-Audex-2B) text-to-audio serving adapter.
+
+Caption → general audio through the ``audex_tta`` pipeline.
+The adapter builds the TTA prompt; the serving layer completes the request
+after the final request id exists: the RVQ phase-mask contract
+(``extra_args["tta_rvq"]``) and the CFG pair contract (official default
+scale 3.0 — guidance is effectively mandatory for TTA quality).
+"""
+
+from typing import TYPE_CHECKING
+
+from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
+from vllm_omni.entrypoints.openai.tts_adapters.base import ARTTSAdapter, PreparedRequest
+from vllm_omni.model_executor.models.audex.prompt import build_tta_cond_prompt
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+
+AUDEX_TTA_DEFAULT_CFG_SCALE = 3.0
+AUDEX_TTA_CFG_SCALE_MIN = 1.0
+AUDEX_TTA_CFG_SCALE_MAX = 10.0
+
+# Internal plumbing keys; injected by the serving layer, never accepted
+# from callers.
+_INTERNAL_KEYS = ("cfg_role", "cfg_pair_id", "cfg_null_prompt", "tta_rvq")
+
+
+@register_tts_adapter
+class AudexTTAAdapter(ARTTSAdapter):
+    """Caption-conditioned general audio: no voices, no reference audio."""
+
+    stage_keys = frozenset({"audex_tta_thinker"})
+    name = "audex_tta"
+
+    def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        if not request.input or not request.input.strip():
+            return "Audex TTA requires a non-empty caption"
+        voice = (request.voice or "").strip().lower()
+        if voice not in ("", "default"):
+            return f"Audex TTA generates general audio and has no voices; got voice={request.voice!r}."
+        if request.ref_audio is not None:
+            return "Audex TTA does not support reference audio."
+        extra = request.extra_params or {}
+        for key in _INTERNAL_KEYS:
+            if key in extra:
+                return f"extra_params.{key} is managed internally by the server; only cfg_scale may be set."
+        cfg_scale = extra.get("cfg_scale")
+        if cfg_scale is not None:
+            try:
+                cfg_value = float(cfg_scale)
+            except (TypeError, ValueError):
+                return (
+                    f"extra_params.cfg_scale must be a number in "
+                    f"[{AUDEX_TTA_CFG_SCALE_MIN}, {AUDEX_TTA_CFG_SCALE_MAX}]; got {cfg_scale!r}."
+                )
+            if not (AUDEX_TTA_CFG_SCALE_MIN <= cfg_value <= AUDEX_TTA_CFG_SCALE_MAX):
+                return (
+                    f"extra_params.cfg_scale must be within "
+                    f"[{AUDEX_TTA_CFG_SCALE_MIN}, {AUDEX_TTA_CFG_SCALE_MAX}]; got {cfg_scale!r}. "
+                    f"The official TTA setting is {AUDEX_TTA_DEFAULT_CFG_SCALE}; 1.0 disables guidance."
+                )
+        return None
+
+    async def build(
+        self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
+    ) -> PreparedRequest:
+        prompt = {"prompt": build_tta_cond_prompt(request.input)}
+        return PreparedRequest(prompt=prompt, tts_params={}, model_type="audex_tta")
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/base.py b/vllm_omni/entrypoints/openai/tts_adapters/base.py
index ad753a91e..58c135044 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/base.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/base.py
@@ -104,6 +104,10 @@ class TTSModelAdapter(ABC):
     #: Serving backend: ``"ar"`` (engine_client) or ``"diffusion"``.
     backend: ClassVar[str] = "ar"
 
+    max_new_tokens_min = 1
+
+    max_new_tokens_max = 4096
+
     def __init__(self, ctx: SpeechServingContext) -> None:
         self.ctx = ctx
 
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/cosyvoice3.py b/vllm_omni/entrypoints/openai/tts_adapters/cosyvoice3.py
index 6a7a89702..85648442f 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/cosyvoice3.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/cosyvoice3.py
@@ -16,10 +16,32 @@ class CosyVoice3Adapter(ARTTSAdapter):
     name = "cosyvoice3"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate CosyVoice3 request parameters. Returns error message or None."""
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_cosyvoice3_request(request)
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        # CosyVoice3 requires reference audio for voice cloning
+        if request.ref_audio is None:
+            return "CosyVoice3 requires 'ref_audio' (reference audio for voice cloning)"
+
+        fmt_err = server._validate_ref_audio_format(request.ref_audio)
+        if fmt_err:
+            return fmt_err
+
+        if not request.ref_text or not request.ref_text.strip():
+            return "CosyVoice3 requires 'ref_text' (transcript of the reference audio)"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/covo_audio.py b/vllm_omni/entrypoints/openai/tts_adapters/covo_audio.py
index f98f89619..70673ac54 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/covo_audio.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/covo_audio.py
@@ -15,6 +15,11 @@ class CovoAudioAdapter(ARTTSAdapter):
     stage_keys = frozenset({"fused_thinker_talker"})
     name = "covo_audio"
 
+    def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+        return None
+
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
     ) -> PreparedRequest:
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/fish_speech.py b/vllm_omni/entrypoints/openai/tts_adapters/fish_speech.py
index d216117b7..e8080a427 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/fish_speech.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/fish_speech.py
@@ -16,10 +16,28 @@ class FishSpeechAdapter(ARTTSAdapter):
     name = "fish_tts"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate Fish Speech request parameters. Returns error message or None."""
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_fish_tts_request(request)
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        if request.ref_audio is not None:
+            fmt_err = server._validate_ref_audio_format(request.ref_audio)
+            if fmt_err:
+                return fmt_err
+            if not request.ref_text or not request.ref_text.strip():
+                return "Voice cloning requires 'ref_text' (transcript of the reference audio)"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/glm_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/glm_tts.py
index e9e8700e6..ddfd194e2 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/glm_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/glm_tts.py
@@ -16,10 +16,28 @@ class GlmTTSAdapter(ARTTSAdapter):
     name = "glm_tts"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate GLM-TTS request — requires ref_audio for voice cloning."""
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_glm_tts_request(request)
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        if request.ref_audio is None:
+            return "GLM-TTS requires 'ref_audio' for zero-shot voice cloning"
+        fmt_err = server._validate_ref_audio_format(request.ref_audio)
+        if fmt_err:
+            return fmt_err
+        if not request.ref_text or not request.ref_text.strip():
+            return "GLM-TTS voice cloning requires 'ref_text' (transcript of the reference audio)"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be >= {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
index 606b4bca1..99949d8b3 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v2.py
@@ -16,10 +16,76 @@ class HiggsAudioV2Adapter(ARTTSAdapter):
     name = "higgs_audio_v2"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate higgs_audio_v2 request parameters. Returns error message or None.
+
+        Accepted: plain text -> speech, or shallow voice clone via ``ref_audio``
+        + ``ref_text`` (both required together). Still out of scope: preset
+        ``voice``/``speaker`` selection, ``x_vector_only_mode`` /
+        ``speaker_embedding`` helpers, ``task_type``/``language``/
+        ``instructions``/``speed`` overrides, and multi-speaker ``[SPEAKERn]``
+        tags inside the input body.
+        """
+        from vllm_omni.model_executor.models.higgs_audio_v2.higgs_audio_v2_tokenizer import (
+            MULTI_SPEAKER_TAG_PATTERN,
+        )
+
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_higgs_audio_v2_request(request)
+
+        if not request.input or not request.input.strip():
+            return "higgs_audio_v2: input text cannot be empty"
+
+        # Voice clone: ref_audio and ref_text must come together.
+        if request.ref_audio is not None and not request.ref_text:
+            return (
+                "higgs_audio_v2 voice clone requires both 'ref_audio' and "
+                "'ref_text'; received ref_audio without ref_text"
+            )
+        if request.ref_text and request.ref_audio is None:
+            return (
+                "higgs_audio_v2 voice clone requires both 'ref_audio' and "
+                "'ref_text'; received ref_text without ref_audio"
+            )
+
+        if request.x_vector_only_mode is not None:
+            return "higgs_audio_v2 v1 does not support 'x_vector_only_mode' (voice-cloning helper field)"
+        if request.speaker_embedding is not None:
+            return "higgs_audio_v2 v1 does not support 'speaker_embedding' (voice-cloning helper field)"
+        if request.voice and request.ref_audio is None:
+            # _apply_uploaded_speaker runs before this validator; if voice was
+            # an uploaded speaker, ref_audio is now populated and ref_text is
+            # backfilled from the speaker entry. A bare voice= with no
+            # ref_audio means the name didn't resolve to an uploaded speaker
+            # (and higgs has no built-in preset voices).
+            return (
+                "higgs_audio_v2 v1 does not support 'voice'/'speaker' selection for built-in voices; "
+                f"upload a voice first via POST /v1/audio/voices, or use ref_audio + ref_text. "
+                f"Got voice={request.voice!r}"
+            )
+        if request.instructions:
+            return (
+                "higgs_audio_v2 v1 does not support 'instructions' (voice "
+                "style/emotion control); supply plain text instead"
+            )
+        if request.task_type is not None:
+            return "higgs_audio_v2 v1 does not support 'task_type'; the model is single-mode plain text -> speech"
+        if request.language is not None:
+            return (
+                "higgs_audio_v2 v1 does not accept 'language' overrides; the model infers language from the input text"
+            )
+        if request.speed is not None and request.speed != 1.0:
+            return (
+                "higgs_audio_v2 v1 does not support 'speed' adjustments; the audio is rendered at native rate (24 kHz)"
+            )
+
+        if MULTI_SPEAKER_TAG_PATTERN.search(request.input):
+            return "higgs_audio_v2 v1 does not support multi-speaker [SPEAKERn] tags; remove the tag from the input"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
index dde5e0815..9cae9aa2d 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/higgs_audio_v3.py
@@ -16,10 +16,20 @@ class HiggsAudioV3Adapter(ARTTSAdapter):
     name = "higgs_audio_v3"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate higgs_audio_v3 request parameters."""
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_higgs_audio_v3_request(request)
+        if not request.input or not request.input.strip():
+            return "higgs_audio_v3: input text cannot be empty"
+        if request.ref_audio is not None and not request.ref_text:
+            # Voice clone ref_text is optional for v3 (improves fidelity but not required)
+            pass
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/ming_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/ming_tts.py
index 7e1a8e66b..adce42867 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/ming_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/ming_tts.py
@@ -3,12 +3,17 @@
 
 from typing import TYPE_CHECKING
 
+from vllm.logger import init_logger
+
 from vllm_omni.entrypoints.openai.tts_adapters import register_tts_adapter
 from vllm_omni.entrypoints.openai.tts_adapters.base import ARTTSAdapter, PreparedRequest
+from vllm_omni.model_executor.models.ming_tts.constants import SPEAKER_EMBEDDING_DIM
 
 if TYPE_CHECKING:
     from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
 
+logger = init_logger(__name__)
+
 
 @register_tts_adapter
 class MingTTSAdapter(ARTTSAdapter):
@@ -16,13 +21,21 @@ class MingTTSAdapter(ARTTSAdapter):
     name = "ming_tts"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        return self.ctx.server._validate_ming_tts_request(request)
+        """Validate Ming TTS request parameters. Returns error message or None."""
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        if isinstance(request.ref_audio, list):
+            return self._validate_ming_tts_podcast_request(request)
+        return self._validate_ming_tts_single_speaker_request(request)
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
     ) -> PreparedRequest:
         server = self.ctx.server
         ref_audio_source = request.ref_audio
+        uploaded_audio_voice = None
+        uploaded_audio_created_at = 0
         voice_lower = request.voice.lower() if isinstance(request.voice, str) else None
         if ref_audio_source is None and voice_lower in server.uploaded_speakers:
             speaker_info = server.uploaded_speakers[voice_lower]
@@ -37,17 +50,102 @@ class MingTTSAdapter(ARTTSAdapter):
                     raise ValueError(f"Audio file for uploaded voice '{request.voice}' is missing")
                 if request.ref_text is None:
                     request.ref_text = speaker_info.get("ref_text")
+                uploaded_audio_voice = voice_lower
+                uploaded_audio_created_at = server._voice_created_at(voice_lower)
         ref_audio_data = None
         if isinstance(ref_audio_source, list):
             ref_audio_data = await server._resolve_ref_audio_many(ref_audio_source)
-            if request.speaker_embedding is None:
-                request.speaker_embedding = server._extract_ming_speaker_embeddings_from_ref_audio(ref_audio_data)
         elif ref_audio_source is not None and isinstance(ref_audio_source, str):
             wav_list, sr = await server._resolve_ref_audio(ref_audio_source)
             ref_audio_data = (wav_list, sr)
-            if request.speaker_embedding is None:
-                request.speaker_embedding = server._extract_ming_speaker_embeddings_from_ref_audio([ref_audio_data])[0]
-        prompt = server._build_ming_dense_prompt(request, ref_audio_data=ref_audio_data)
+        prompt = server._build_ming_dense_prompt(
+            request,
+            ref_audio_data=ref_audio_data,
+            voice_name=uploaded_audio_voice,
+            voice_created_at=uploaded_audio_created_at,
+        )
         tts_params = prompt.get("additional_information", {})
         # Ming stop-token / max_tokens sampling stays in the orchestrator tail.
         return PreparedRequest(prompt=prompt, tts_params=tts_params, model_type="ming_tts")
+
+    def _validate_ming_tts_single_speaker_request(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        server = self.ctx.server
+        if request.ref_audio is not None:
+            fmt_err = server._validate_ref_audio_format(request.ref_audio)
+            if fmt_err:
+                return fmt_err
+
+        if request.speaker_embedding is not None:
+            if not request.speaker_embedding:
+                return "'speaker_embedding' must be a non-empty list of floats"
+            emb_len = len(request.speaker_embedding)
+            if emb_len != SPEAKER_EMBEDDING_DIM:
+                logger.warning(
+                    "speaker_embedding has %d dimensions; Ming dense expects %d. "
+                    "Wrong dimensions will likely fail or degrade output.",
+                    emb_len,
+                    SPEAKER_EMBEDDING_DIM,
+                )
+
+        voice_lower = request.voice.lower() if isinstance(request.voice, str) else None
+        uploaded_voice = bool(voice_lower and voice_lower in server.uploaded_speakers)
+        clone_source_present = request.ref_audio is not None or request.speaker_embedding is not None or uploaded_voice
+
+        if request.task_type == "Base" and not clone_source_present:
+            return "Base task requires 'ref_audio', 'speaker_embedding', or an uploaded voice sample"
+
+        if request.ref_audio is not None and request.ref_text is not None and not request.ref_text.strip():
+            return "'ref_text' must be non-empty when provided with 'ref_audio'"
+
+        if request.ref_text is not None and request.ref_audio is None and not uploaded_voice:
+            return "'ref_text' requires 'ref_audio' or an uploaded voice sample"
+
+        if request.instructions and len(request.instructions) > server._max_instructions_length:
+            return f"Instructions too long (max {server._max_instructions_length} characters)"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
+
+    def _validate_ming_tts_podcast_request(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        server = self.ctx.server
+        if len(request.ref_audio) < 2:
+            return "Podcast-style Ming requests require at least two 'ref_audio' clips"
+
+        for ref_audio in request.ref_audio:
+            fmt_err = server._validate_ref_audio_format(ref_audio)
+            if fmt_err:
+                return fmt_err
+
+        if not request.ref_text or not request.ref_text.strip():
+            return "Podcast-style Ming requests require non-empty 'ref_text'"
+
+        if request.speaker_embedding is not None:
+            embeddings = request.speaker_embedding
+            embedding_count = len(embeddings) if embeddings and isinstance(embeddings[0], list) else 1
+            if embedding_count != len(request.ref_audio):
+                return (
+                    "Podcast-style Ming requests require one speaker embedding per ref_audio clip; "
+                    f"got {embedding_count} embeddings for {len(request.ref_audio)} clips"
+                )
+            if embeddings and isinstance(embeddings[0], list):
+                for item in embeddings:
+                    if len(item) != SPEAKER_EMBEDDING_DIM:
+                        return (
+                            f"Podcast-style Ming speaker embeddings must each have {SPEAKER_EMBEDDING_DIM} dimensions"
+                        )
+
+        if request.instructions and len(request.instructions) > server._max_instructions_length:
+            return f"Instructions too long (max {server._max_instructions_length} characters)"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
index 36d98c2d9..ad43a1c01 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
@@ -18,10 +18,69 @@ if TYPE_CHECKING:
 
 class _MossTTSAdapterBase(ARTTSAdapter):
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        err = self.ctx.server._apply_uploaded_speaker(request)
+        """Validate any MOSS-TTS-family request (nano + 5 full variants).
+
+        Dispatches by ``self._moss_variant``:
+          - ``tts``/``realtime``: require ``ref_audio`` (voice cloning).
+          - ``ttsd``: require ``ref_audio`` (speaker 1); ``ref_audio_2``
+            optional (defaults to the same ref for both speakers).
+          - ``sound_effect``: require ``ambient_sound`` (no ref_audio).
+          - ``voice_generator``: require ``instructions`` (no ref_audio).
+          - For the legacy moss_tts_nano model_type the variant is None and
+            we fall through to the original nano contract (ref_audio only).
+        """
+        server = self.ctx.server
+        err = server._apply_uploaded_speaker(request)
         if err:
             return err
-        return self.ctx.server._validate_moss_tts_request(request)
+
+        if not request.input or not request.input.strip():
+            # SoundEffect can legitimately have empty input (just ambient_sound).
+            if server._moss_variant != "sound_effect":
+                return "Input text cannot be empty"
+
+        v = server._moss_variant
+        if v in (None, "tts", "realtime", "local"):
+            if request.ref_audio is None:
+                label = (
+                    "MOSS-TTS-Nano"
+                    if v is None
+                    else (
+                        "MOSS-TTS-Realtime"
+                        if v == "realtime"
+                        else ("MOSS-TTS-Local-Transformer" if v == "local" else "MOSS-TTS")
+                    )
+                )
+                return f"{label} requires 'ref_audio' (reference audio for voice cloning)."
+            return server._validate_ref_audio_format(request.ref_audio)
+
+        if v == "ttsd":
+            if request.ref_audio is None:
+                return "MOSS-TTSD requires 'ref_audio' (speaker 1 reference)."
+            fmt_err = server._validate_ref_audio_format(request.ref_audio)
+            if fmt_err:
+                return fmt_err
+            if request.ref_audio_2 is not None:
+                return server._validate_ref_audio_format(request.ref_audio_2)
+            return None
+
+        if v == "sound_effect":
+            if not request.ambient_sound or not request.ambient_sound.strip():
+                return (
+                    "MOSS-SoundEffect requires 'ambient_sound' (natural language "
+                    "description of the sound effect to synthesise)."
+                )
+            return None
+
+        if v == "voice_generator":
+            if not request.instructions or not request.instructions.strip():
+                return (
+                    "MOSS-VoiceGenerator requires 'instructions' (natural language "
+                    "voice description, e.g. 'a warm female voice with an American accent')."
+                )
+            return None
+
+        return None  # unreachable
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
index 0f62a169c..c0be8c685 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
@@ -1,18 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Qwen3-TTS serving adapter.
-
-First model migrated onto the adapter framework (RFC #4327). It is the dispatch
-surface for Qwen3-TTS: the serving orchestrator routes prompt/param building
-through ``build()`` instead of the inline ``else`` branch in
-``_prepare_speech_generation``.
-
-To stay behaviour-identical and avoid divergence from the batch path (which
-shares ``_validate_qwen_tts_request`` and ``_build_tts_params``), the adapter
-reuses the single-source helper implementations on the serving instance through
-``ctx.server`` rather than copying them. Subsequent PRs relocate those bodies as
-more models migrate and the batch path also routes through adapters.
-"""
+"""Qwen3-TTS serving adapter."""
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from vllm.logger import init_logger
@@ -36,13 +25,133 @@ class Qwen3TTSAdapter(ARTTSAdapter):
     def normalize(self, request: "OpenAICreateSpeechRequest") -> None:
         """Qwen3-TTS normalization (Base-task inference, voice lowercasing) is
         performed inside ``validate`` today; kept fused for a strict behaviour
-        match. See ``_validate_qwen_tts_request``."""
+        match."""
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        # Go through the shared dispatcher (which routes to
-        # _validate_qwen_tts_request for this model-type) rather than the leaf
-        # validator directly, matching the pre-adapter qwen3 path.
-        return self.ctx.server._validate_tts_request(request)
+        """Validate Qwen TTS request parameters. Returns error message or None."""
+        # Infer Base task when ref_audio or ref_text is provided without explicit task_type.
+        server = self.ctx.server
+        if request.task_type is None and (request.ref_audio is not None or request.ref_text is not None):
+            request.task_type = "Base"
+
+        # Normalize voice to lowercase for case-insensitive matching
+        if request.voice is not None:
+            request.voice = request.voice.lower()
+            if request.task_type is None and request.voice in server.precomputed_speakers:
+                request.task_type = "Base"
+        task_type = request.task_type or "CustomVoice"
+
+        # Validate input is not empty
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        # Validate language (case-insensitive; normalized to the title-cased config form)
+        if request.language is not None:
+            request.language = request.language.title()
+            if request.language not in server.supported_languages:
+                return (
+                    f"Invalid language '{request.language}'. Supported: {', '.join(sorted(server.supported_languages))}"
+                )
+
+        # Validate speaker for CustomVoice task
+        if task_type == "CustomVoice":
+            if not server.supported_speakers:
+                return (
+                    "This model does not support CustomVoice task (no speakers configured). "
+                    "Use task_type='Base' with ref_audio/ref_text for voice cloning, "
+                    "or use a CustomVoice model."
+                )
+            if request.voice is not None and request.voice not in server.supported_speakers:
+                return f"Invalid voice '{request.voice}'. Supported: {', '.join(sorted(server.supported_speakers))}"
+
+        # Validate speaker_embedding constraints
+        if request.speaker_embedding is not None:
+            if task_type != "Base":
+                return "'speaker_embedding' is only valid for Base task"
+            if not request.speaker_embedding:
+                return "'speaker_embedding' must be a non-empty list of floats"
+            # speaker_embedding implies x_vector_only_mode — set it before
+            # Base task validation so callers don't need to pass it explicitly.
+            request.x_vector_only_mode = True
+            emb_len = len(request.speaker_embedding)
+            dim_err = server._validate_qwen_tts_speaker_embedding_dim(emb_len)
+            if dim_err is not None:
+                return dim_err
+        # Validate Base task requirements
+        if task_type == "Base":
+            if request.voice is None:
+                # 1. Ensure a voice source is provided
+                if request.ref_audio is None and getattr(request, "speaker_embedding", None) is None:
+                    return "Base task requires 'ref_audio' or 'speaker_embedding' for voice cloning"
+                # 2. Validate ref_audio format if it exists (using the helper from main)
+                if request.ref_audio is not None:
+                    fmt_err = server._validate_ref_audio_format(request.ref_audio)
+                    if fmt_err:
+                        return fmt_err
+                # 3. Validate text requirements based on the mode
+                if not getattr(request, "x_vector_only_mode", False):
+                    if not request.ref_text or not request.ref_text.strip():
+                        return (
+                            "Base task requires non-empty 'ref_text' (transcript of "
+                            "the reference audio) unless 'x_vector_only_mode' is enabled"
+                        )
+            else:
+                voice_lower = request.voice.lower()
+                if voice_lower in server.uploaded_speakers:
+                    # Check if data file exists for uploaded speaker
+                    speaker_info = server.uploaded_speakers[voice_lower]
+                    file_path = Path(speaker_info["file_path"])
+                    if not file_path.exists():
+                        return f"Data file for uploaded speaker '{request.voice}' not found on disk"
+                elif voice_lower in server.precomputed_speakers:
+                    profile = server.precomputed_speakers[voice_lower]
+                    mode = str(profile.get("mode") or "xvec").lower()
+                    ref_text = request.ref_text or profile.get("ref_text")
+                    if mode == "icl" and (not isinstance(ref_text, str) or not ref_text.strip()):
+                        return (
+                            f"Precomputed voice '{request.voice}' uses ICL mode but has no ref_text in "
+                            "the request or custom voice manifest"
+                        )
+                else:
+                    # need ref_audio for built-in speaker
+                    if request.ref_audio is None:
+                        return (
+                            f"Base task with built-in speaker '{request.voice}' requires 'ref_audio' for voice cloning"
+                        )
+                    fmt_err = server._validate_ref_audio_format(request.ref_audio)
+                    if fmt_err:
+                        return fmt_err
+                    if not getattr(request, "x_vector_only_mode", False) and (
+                        not request.ref_text or not request.ref_text.strip()
+                    ):
+                        return (
+                            "Base task requires non-empty 'ref_text' (transcript of "
+                            "the reference audio) unless 'x_vector_only_mode' is enabled"
+                        )
+
+        # Validate cross-parameter dependencies
+        if task_type != "Base":
+            if request.ref_text is not None:
+                return "'ref_text' is only valid for Base task"
+            if request.x_vector_only_mode is not None:
+                return "'x_vector_only_mode' is only valid for Base task"
+
+        # Validate VoiceDesign task requirements
+        if task_type == "VoiceDesign" and not request.instructions:
+            return "VoiceDesign task requires 'instructions' to describe the voice"
+
+        # Validate instructions length (using cached value from initialization)
+        if request.instructions and len(request.instructions) > server._max_instructions_length:
+            return f"Instructions too long (max {server._max_instructions_length} characters)"
+
+        # Validate max_new_tokens range
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/step_audio2.py b/vllm_omni/entrypoints/openai/tts_adapters/step_audio2.py
index dd1365204..2c720d8e1 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/step_audio2.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/step_audio2.py
@@ -23,8 +23,9 @@ class StepAudio2Adapter(ARTTSAdapter):
     name = "step_audio2"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        # Dispatcher routes to the step_audio2 case (non-empty input check).
-        return self.ctx.server._validate_tts_request(request)
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/voxcpm2.py b/vllm_omni/entrypoints/openai/tts_adapters/voxcpm2.py
index 221e2f64b..361aa2522 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/voxcpm2.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/voxcpm2.py
@@ -19,7 +19,25 @@ class VoxCPM2Adapter(ARTTSAdapter):
     name = "voxcpm2"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        return self.ctx.server._validate_voxcpm2_request(request)
+        """Validate VoxCPM2 request parameters. Returns error message or None."""
+        server = self.ctx.server
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        if request.voice is not None:
+            request.voice = request.voice.lower()
+            available_voices = set(server.uploaded_speakers) | set(server.precomputed_speakers) | {"default"}
+            if request.voice not in available_voices:
+                supported = ", ".join(sorted(available_voices)) or "none"
+                return f"Invalid voice '{request.voice}'. Supported: {supported}"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
index 72e18dc84..0b2d400b1 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
@@ -16,7 +16,32 @@ class VoxtralTTSAdapter(ARTTSAdapter):
     name = "voxtral_tts"
 
     def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
-        return self.ctx.server._validate_voxtral_tts_request(request)
+        """Validate Voxtral TTS request parameters. Returns error message or None."""
+        server = self.ctx.server
+        if not request.input or not request.input.strip():
+            return "Input text cannot be empty"
+
+        # Voxtral TTS requires either a preset voice or ref_audio for voice cloning.
+        if request.voice is None and request.ref_audio is None:
+            return "Either 'voice' (preset speaker) or 'ref_audio' (voice cloning) must be provided"
+
+        if request.ref_audio is not None:
+            fmt_err = server._validate_ref_audio_format(request.ref_audio)
+            if fmt_err:
+                return fmt_err
+
+        if request.voice is not None:
+            request.voice = request.voice.lower()
+            if server.supported_speakers and request.voice not in server.supported_speakers:
+                return f"Invalid speaker '{request.voice}'. Supported: {', '.join(sorted(server.supported_speakers))}"
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min:
+                return f"max_new_tokens must be at least {self.max_new_tokens_min}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+
+        return None
 
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
diff --git a/vllm_omni/entrypoints/openai/video_api_utils.py b/vllm_omni/entrypoints/openai/video_api_utils.py
index aa6479189..5a4f9f826 100644
--- a/vllm_omni/entrypoints/openai/video_api_utils.py
+++ b/vllm_omni/entrypoints/openai/video_api_utils.py
@@ -8,7 +8,8 @@ from __future__ import annotations
 
 import base64
 import binascii
-from collections import deque
+import os
+import tempfile
 from io import BytesIO
 from typing import Any, Literal
 
@@ -16,6 +17,12 @@ import httpx
 import numpy as np
 import torch
 from PIL import Image, UnidentifiedImageError
+from vllm.multimodal.video import (
+    VIDEO_LOADER_REGISTRY,
+    VideoBackend,
+    VideoSourceMetadata,
+    VideoTargetMetadata,
+)
 
 from vllm_omni.entrypoints.openai.errors import InvalidInputReferenceError
 from vllm_omni.entrypoints.openai.protocol.videos import (
@@ -31,10 +38,17 @@ from vllm_omni.entrypoints.openai.protocol.videos import (
 class VideoFrames(list[Image.Image]):
     """Decoded video frames plus source metadata."""
 
-    def __init__(self, frames: list[Image.Image] | None = None, *, fps: float | None = None) -> None:
+    def __init__(
+        self,
+        frames: list[Image.Image] | None = None,
+        *,
+        fps: float | None = None,
+        source_path: str | None = None,
+    ) -> None:
         super().__init__(frames or [])
         self.fps = fps
         self.frame_rate = fps
+        self.source_path = source_path
 
 
 def positive_float(value: Any) -> float | None:
@@ -58,53 +72,61 @@ def _decode_image_bytes(image_bytes: bytes, *, source: str) -> Image.Image:
         raise InvalidInputReferenceError(f"Invalid {source}: provided content is not a valid image.") from exc
 
 
+@VIDEO_LOADER_REGISTRY.register("omni")
+class OmniVideoBackend(VideoBackend):
+    """Video backend that selects sequential first-N or last-N frames."""
+
+    @classmethod
+    def compute_frames_index_to_sample(
+        cls,
+        source: VideoSourceMetadata,
+        target: VideoTargetMetadata,
+        *,
+        keep: Literal["first", "last"] = "first",
+        **kwargs,
+    ) -> list[int]:
+        num_frames_to_sample = source.total_frames_num
+        if target.num_frames > 0:
+            num_frames_to_sample = min(num_frames_to_sample, target.num_frames)
+        num_frames_to_sample = max(1, num_frames_to_sample)
+        if num_frames_to_sample >= source.total_frames_num:
+            return list(range(source.total_frames_num))
+        if keep == "last":
+            return list(range(source.total_frames_num - num_frames_to_sample, source.total_frames_num))
+        return list(range(num_frames_to_sample))
+
+
 def _decode_video_bytes(
     video_bytes: bytes,
     *,
     source: str,
     max_frames: int | None = None,
     keep: Literal["first", "last"] = "first",
+    source_path: str | None = None,
 ) -> VideoFrames:
-    try:
-        import av
-    except ImportError as exc:  # pragma: no cover - av is a serving dependency via media_utils
-        raise InvalidInputReferenceError(f"Invalid {source}: video decoding requires PyAV.") from exc
-
     if keep not in {"first", "last"}:
         raise InvalidInputReferenceError(f"Invalid {source}: video frame selection must be 'first' or 'last'.")
     if max_frames is not None and max_frames <= 0:
         raise InvalidInputReferenceError(f"Invalid {source}: max video frames must be positive.")
 
-    frames: list[Image.Image] = []
-    tail_frames: deque[Image.Image] | None = (
-        deque(maxlen=max_frames) if keep == "last" and max_frames is not None else None
-    )
-    fps: float | None = None
+    loader = VIDEO_LOADER_REGISTRY.load("omni")
+    num_frames = max_frames if max_frames is not None else -1
     try:
-        with av.open(BytesIO(video_bytes)) as container:
-            video_stream = container.streams.video[0] if container.streams.video else None
-            if video_stream is not None:
-                fps = (
-                    positive_float(getattr(video_stream, "average_rate", None))
-                    or positive_float(getattr(video_stream, "base_rate", None))
-                    or positive_float(getattr(video_stream, "guessed_rate", None))
-                )
-            for frame in container.decode(video=0):
-                image = frame.to_image().convert("RGB")
-                if tail_frames is not None:
-                    tail_frames.append(image)
-                else:
-                    frames.append(image)
-                if keep == "first" and max_frames is not None and len(frames) >= max_frames:
-                    break
+        frames_array, metadata = loader.load_bytes(
+            video_bytes,
+            num_frames=num_frames,
+            backend="pyav",
+            keep=keep,
+        )
     except Exception as exc:
         raise InvalidInputReferenceError(f"Invalid {source}: provided content is not a valid video.") from exc
 
-    if tail_frames is not None:
-        frames = list(tail_frames)
+    fps: float | None = positive_float(metadata.get("fps"))
+
+    frames = [Image.fromarray(f, "RGB") for f in frames_array]
     if not frames:
         raise InvalidInputReferenceError(f"Invalid {source}: provided content is not a valid video.")
-    return VideoFrames(frames, fps=fps)
+    return VideoFrames(frames, fps=fps, source_path=source_path)
 
 
 def _decode_media_bytes(
@@ -169,6 +191,7 @@ def _decode_base64_video(
     source: str,
     max_frames: int | None = None,
     keep: Literal["first", "last"] = "first",
+    source_path: str | None = None,
 ) -> VideoFrames:
     if video_reference:
         if video_reference.startswith("data:video"):
@@ -180,7 +203,16 @@ def _decode_base64_video(
             video_bytes = base64.b64decode(b64_data)
         except (binascii.Error, ValueError) as exc:  # pragma: no cover - malformed base64
             raise InvalidInputReferenceError(f"Invalid {source}: video data is not valid base64.") from exc
-        return _decode_video_bytes(video_bytes, source=source, max_frames=max_frames, keep=keep)
+        if source_path is not None:
+            with open(source_path, "wb") as output:
+                output.write(video_bytes)
+        return _decode_video_bytes(
+            video_bytes,
+            source=source,
+            max_frames=max_frames,
+            keep=keep,
+            source_path=source_path,
+        )
     raise InvalidInputReferenceError(f"Invalid {source}: video data is empty.")
 
 
@@ -191,12 +223,19 @@ async def decode_video_url(
     keep: Literal["first", "last"] = "first",
 ) -> VideoFrames:
     if video_url.startswith("data:video"):
-        return _decode_base64_video(
-            video_url,
-            source="video_reference.video_url",
-            max_frames=max_frames,
-            keep=keep,
-        )
+        path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+        try:
+            return _decode_base64_video(
+                video_url,
+                source="video_reference.video_url",
+                max_frames=max_frames,
+                keep=keep,
+                source_path=path,
+            )
+        except Exception:
+            if os.path.exists(path):
+                os.unlink(path)
+            raise
 
     if video_url.startswith(("http://", "https://")):
         async with httpx.AsyncClient(timeout=60) as client:
@@ -207,12 +246,26 @@ async def decode_video_url(
                 raise InvalidInputReferenceError(
                     "Invalid video_reference.video_url: failed to download video."
                 ) from exc
-        return _decode_video_bytes(
-            response.content,
-            source="video_reference.video_url",
-            max_frames=max_frames,
-            keep=keep,
-        )
+        path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+        try:
+            with open(path, "wb") as output:
+                output.write(response.content)
+        except Exception:
+            if os.path.exists(path):
+                os.unlink(path)
+            raise
+        try:
+            return _decode_video_bytes(
+                response.content,
+                source="video_reference.video_url",
+                max_frames=max_frames,
+                keep=keep,
+                source_path=path,
+            )
+        except Exception:
+            if os.path.exists(path):
+                os.unlink(path)
+            raise
 
     raise InvalidInputReferenceError("Invalid video_reference.video_url: must be an http(s) URL or data URL.")
 
@@ -308,9 +361,6 @@ def _normalize_video_tensor(video_tensor: torch.Tensor) -> np.ndarray:
     video_tensor = video_tensor.detach().cpu()
     if video_tensor.dim() == 5:
         raise ValueError("Batched video tensors are not supported for single-video encoding.")
-    elif video_tensor.dim() == 4 and video_tensor.shape[0] in (3, 4):
-        # [C, F, H, W] -> [F, H, W, C]
-        video_tensor = video_tensor.permute(1, 2, 3, 0)
 
     if video_tensor.is_floating_point():
         # Cast to float32 first: bf16 (e.g. SANA-WM's refiner output) has no
@@ -329,6 +379,8 @@ def _normalize_single_video_array(video_array: np.ndarray) -> np.ndarray:
 
     if video_array.ndim == 4:
         # Convert channel-first layouts to channel-last
+        # Prefer an explicit channel-last dimension for ambiguous 3/4-frame
+        # videos before interpreting a leading dimension as channels.
         if video_array.shape[0] in (3, 4) and video_array.shape[-1] not in (3, 4):
             video_array = np.transpose(video_array, (1, 2, 3, 0))
         elif video_array.shape[1] in (3, 4) and video_array.shape[-1] not in (3, 4):
@@ -429,18 +481,32 @@ def _coerce_video_to_uint8_frames(video: Any) -> np.ndarray:
     if not frames:
         raise ValueError("No frames found to encode.")
 
-    frames_np = np.stack(frames, axis=0)
-    if frames_np.ndim == 4 and frames_np.shape[-1] == 4:
-        frames_np = frames_np[..., :3]
+    frame_shape = frames[0].shape
+    has_alpha = len(frame_shape) == 3 and frame_shape[-1] == 4
+    output_shape = (*frame_shape[:-1], 3) if has_alpha else frame_shape
+    frames_u8 = np.empty((len(frames), *output_shape), dtype=np.uint8)
+    common_dtype = np.result_type(*(frame.dtype for frame in frames))
 
-    if frames_np.dtype == np.uint8:
-        frames_u8 = frames_np
-    else:
-        frames_np = np.clip(frames_np, 0.0, 1.0)
-        frames_np *= 255.0
-        frames_u8 = np.round(frames_np).astype(np.uint8)
+    # Convert one frame at a time instead of stacking the normalized float
+    # payload first. Long videos can otherwise require another full-size
+    # float array plus conversion temporaries before encoding.
+    for index, frame in enumerate(frames):
+        if frame.shape != frame_shape:
+            raise ValueError("All video frames must have the same shape.")
+        frame = frame[..., :3] if has_alpha else frame
+        if frame.dtype == np.uint8:
+            frames_u8[index] = frame
+            continue
 
-    return np.ascontiguousarray(frames_u8)
+        # np.stack(), used by the previous implementation, promoted mixed
+        # frame dtypes before scaling. Preserve those rounding semantics
+        # without allocating a full-video float buffer.
+        scaled = np.clip(frame.astype(common_dtype, copy=False), 0.0, 1.0)
+        scaled *= 255.0
+        np.rint(scaled, out=scaled)
+        frames_u8[index] = scaled
+
+    return frames_u8
 
 
 def _encode_video_bytes(
diff --git a/vllm_omni/entrypoints/openai/video_stream_base.py b/vllm_omni/entrypoints/openai/video_stream_base.py
index 460a66d7c..1694704f3 100644
--- a/vllm_omni/entrypoints/openai/video_stream_base.py
+++ b/vllm_omni/entrypoints/openai/video_stream_base.py
@@ -10,12 +10,14 @@ via :class:`VideoStreamPipelineHooks`.
 Protocol:
     Client -> Server:
         {"type": "session.config", ...}         # Session config (sent once)
-        {"type": "video.frame", "data": "..."}  # base64 JPEG/PNG frame
+        {"type": "video.frame", "data": "...", "frame_id": "...", "pts_ms": 0}
         {"type": "audio.chunk", "data": "..."}  # base64 PCM16 16kHz mono
         {"type": "video.query", "text": "..."}  # Submit query about buffered frames
         {"type": "video.done"}                  # End of session
 
     Server -> Client:
+        {"type": "video.frame.ack", ...}          # when frame_id is provided
+        {"type": "video.frames.consumed", ...}    # after first engine output
         {"type": "response.start"}
         {"type": "response.text.delta", "delta": "..."}
         {"type": "response.text.done", "text": "..."}
@@ -215,6 +217,7 @@ class OmniStreamingVideoHandler:
                 return
 
             frame_buffer: list[str] = []  # base64-encoded JPEG frames
+            frame_metadata: list[dict[str, Any]] = []
             # Per-frame PIL cache + uuid for mm_hash reuse. Aligned with frame_buffer by index.
             frame_pil_cache: dict[str, tuple[Any, str] | object] = {}  # b64 -> (PIL.Image, uuid) or _BAD_FRAME
             frame_filter = (
@@ -259,6 +262,8 @@ class OmniStreamingVideoHandler:
                         if msg_type.startswith("_internal."):
                             await self._send_error(websocket, f"Unknown type: {msg_type}")
                             continue
+                        if msg_type == "video.frame":
+                            msg["_receiver_received_ts_ms"] = _time.monotonic() * 1000
 
                         await msg_queue.put(msg)
                         if msg.get("type") == "video.done":
@@ -308,6 +313,7 @@ class OmniStreamingVideoHandler:
                 active_request_id = request_id
                 interrupt_event.clear()
                 query_frames = list(frame_buffer)
+                query_frame_metadata = list(frame_metadata)
                 query_audio_buffer = bytearray(audio_buffer)
                 audio_buffer.clear()
                 query_prewarmed_frames = dict(frame_pil_cache)
@@ -315,6 +321,9 @@ class OmniStreamingVideoHandler:
                 async def _run_query() -> None:
                     nonlocal active_request_id, prev_request_id
                     try:
+                        process_kwargs: dict[str, Any] = {}
+                        if any(metadata.get("frame_id") for metadata in query_frame_metadata):
+                            process_kwargs["frame_metadata"] = query_frame_metadata
                         await self._process_query(
                             websocket,
                             config,
@@ -325,6 +334,7 @@ class OmniStreamingVideoHandler:
                             request_id,
                             interrupt_event,
                             query_prewarmed_frames,
+                            **process_kwargs,
                         )
                     finally:
                         if active_request_id == request_id:
@@ -349,7 +359,11 @@ class OmniStreamingVideoHandler:
                         frame_data = msg.get("b64", "")
                         removed = frame_data in frame_buffer
                         if removed:
-                            frame_buffer[:] = [f for f in frame_buffer if f != frame_data]
+                            retained_indices = [
+                                index for index, frame in enumerate(frame_buffer) if frame != frame_data
+                            ]
+                            frame_buffer[:] = [frame_buffer[index] for index in retained_indices]
+                            frame_metadata[:] = [frame_metadata[index] for index in retained_indices]
                         if frame_pil_cache.get(frame_data) is _BAD_FRAME:
                             frame_pil_cache.pop(frame_data, None)
                         if removed:
@@ -370,16 +384,43 @@ class OmniStreamingVideoHandler:
                         if frame_filter is not None:
                             try:
                                 if not frame_filter.should_retain(raw_bytes):
+                                    await self._send_frame_ack(
+                                        websocket,
+                                        msg,
+                                        accepted=False,
+                                        buffered_frames=len(frame_buffer),
+                                        reason="filtered",
+                                    )
                                     continue
                             except Exception:
                                 await self._send_error(websocket, "Invalid image data")
                                 continue
                         max_buf = config.max_frames
+                        dropped_frame_id: str | None = None
                         if len(frame_buffer) >= max_buf:
                             dropped = frame_buffer.pop(0)
+                            dropped_metadata = frame_metadata.pop(0)
+                            dropped_frame_id = dropped_metadata.get("frame_id")
                             frame_pil_cache.pop(dropped, None)
                         frame_buffer.append(frame_data)
+                        frame_metadata.append(
+                            {
+                                "frame_id": msg.get("frame_id"),
+                                "pts_ms": msg.get("pts_ms"),
+                                "source_pts_ms": msg.get("source_pts_ms"),
+                                "quality_profile": msg.get("quality_profile"),
+                                "capture_ts_ms": msg.get("capture_ts_ms"),
+                                "receiver_received_ts_ms": msg.get("_receiver_received_ts_ms"),
+                            }
+                        )
                         self.on_frame_buffered(raw_bytes, frame_data, message_history, config)
+                        await self._send_frame_ack(
+                            websocket,
+                            msg,
+                            accepted=True,
+                            buffered_frames=len(frame_buffer),
+                            dropped_frame_id=dropped_frame_id,
+                        )
                         # Prewarm: decode PIL off the event loop so query-time chat_template
                         # can skip base64+Image.open. uuid=md5 lets mm_cache dedupe identical frames.
                         if frame_data not in frame_pil_cache:
@@ -537,6 +578,7 @@ class OmniStreamingVideoHandler:
         request_id: str,
         interrupt_event: asyncio.Event,
         prewarmed_frames: dict[str, tuple[Any, str]],
+        frame_metadata: list[dict[str, Any]] | None = None,
     ) -> None:
         """Build prompt, run inference, stream text + audio response."""
 
@@ -544,6 +586,9 @@ class OmniStreamingVideoHandler:
             await self._send_error(websocket, "Streaming video requires an engine client")
             return
 
+        engine_kwargs: dict[str, Any] = {}
+        if frame_metadata:
+            engine_kwargs["frame_metadata"] = frame_metadata
         await self._process_query_engine(
             websocket,
             config,
@@ -554,6 +599,7 @@ class OmniStreamingVideoHandler:
             request_id,
             interrupt_event,
             prewarmed_frames,
+            **engine_kwargs,
         )
 
     # ------------------------------------------------------------------
@@ -571,6 +617,7 @@ class OmniStreamingVideoHandler:
         request_id: str,
         interrupt_event: asyncio.Event,
         prewarmed_frames: dict[str, tuple[Any, str]],
+        frame_metadata: list[dict[str, Any]] | None = None,
     ) -> None:
         """Direct engine_client.generate() path for async_chunk audio."""
         from vllm.entrypoints.openai.chat_completion.protocol import (
@@ -613,6 +660,9 @@ class OmniStreamingVideoHandler:
         except Exception as e:
             await self._send_error(websocket, f"Preprocess failed: {e}")
             return
+        decoded_ready_ts_ms = _time.monotonic() * 1000
+        selected_metadata = self._sample_frame_metadata(frame_metadata or [], config.num_frames)
+        model_selected_ts_ms = _time.monotonic() * 1000
 
         await websocket.send_json({"type": "response.start"})
         text_parts: list[str] = []
@@ -623,6 +673,7 @@ class OmniStreamingVideoHandler:
         audio_chunks_drained = 0
         previous_text = ""
         interrupted = False
+        frames_consumed_sent = False
         t_start = _time.monotonic()
         t_first_text = None
         t_first_audio = None
@@ -652,6 +703,33 @@ class OmniStreamingVideoHandler:
                 if not isinstance(output, OmniRequestOutput):
                     continue
 
+                if not frames_consumed_sent and frame_metadata:
+                    await websocket.send_json(
+                        {
+                            "type": "video.frames.consumed",
+                            "request_id": request_id,
+                            "model_selected_ts_ms": model_selected_ts_ms,
+                            "frame_ids": [
+                                metadata["frame_id"]
+                                for metadata in selected_metadata
+                                if isinstance(metadata.get("frame_id"), str)
+                            ],
+                            "frames": [
+                                {
+                                    "frame_id": metadata.get("frame_id"),
+                                    "pts_ms": metadata.get("pts_ms"),
+                                    "source_pts_ms": metadata.get("source_pts_ms"),
+                                    "quality_profile": metadata.get("quality_profile"),
+                                    "receiver_received_ts_ms": metadata.get("receiver_received_ts_ms"),
+                                    "decoded_ready_ts_ms": decoded_ready_ts_ms,
+                                }
+                                for metadata in selected_metadata
+                            ],
+                            "latest_pts_ms": selected_metadata[-1].get("pts_ms") if selected_metadata else None,
+                        }
+                    )
+                    frames_consumed_sent = True
+
                 out_type = getattr(output, "final_output_type", "text")
 
                 if out_type == "audio":
@@ -971,3 +1049,42 @@ class OmniStreamingVideoHandler:
             await websocket.send_json({"type": "error", "message": message})
         except Exception:
             pass
+
+    @staticmethod
+    def _sample_frame_metadata(
+        frame_metadata: list[dict[str, Any]],
+        num_frames: int,
+    ) -> list[dict[str, Any]]:
+        if len(frame_metadata) <= num_frames:
+            return list(frame_metadata)
+        stride = max(1, len(frame_metadata) // num_frames)
+        indices = [index * stride for index in range(num_frames - 1)] + [len(frame_metadata) - 1]
+        return [frame_metadata[index] for index in indices]
+
+    @staticmethod
+    async def _send_frame_ack(
+        websocket: WebSocket,
+        message: Mapping[str, Any],
+        *,
+        accepted: bool,
+        buffered_frames: int,
+        reason: str | None = None,
+        dropped_frame_id: str | None = None,
+    ) -> None:
+        frame_id = message.get("frame_id")
+        if not isinstance(frame_id, str) or not frame_id:
+            return
+        ack: dict[str, Any] = {
+            "type": "video.frame.ack",
+            "frame_id": frame_id,
+            "pts_ms": message.get("pts_ms"),
+            "capture_ts_ms": message.get("capture_ts_ms"),
+            "accepted": accepted,
+            "buffered_frames": buffered_frames,
+            "server_receive_ts_ms": message.get("_receiver_received_ts_ms", _time.monotonic() * 1000),
+        }
+        if reason is not None:
+            ack["reason"] = reason
+        if dropped_frame_id is not None:
+            ack["dropped_frame_id"] = dropped_frame_id
+        await websocket.send_json(ack)
diff --git a/vllm_omni/entrypoints/utils.py b/vllm_omni/entrypoints/utils.py
index a2c598b31..8a8f34c15 100644
--- a/vllm_omni/entrypoints/utils.py
+++ b/vllm_omni/entrypoints/utils.py
@@ -12,9 +12,14 @@ from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.transformers_utils.config import get_config, get_hf_file_to_dict
 from vllm.transformers_utils.repo_utils import file_or_path_exists
 
-from vllm_omni.config.config_factory import StageConfigFactory
+from vllm_omni.config.config_factory import StageConfigFactory, with_trust_remote_code_override
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
+from vllm_omni.config.stage_config import _DEPLOY_DIR
 from vllm_omni.config.yaml_util import create_config, load_yaml_config, merge_configs
-from vllm_omni.diffusion.utils.hf_utils import _looks_like_dreamzero
+from vllm_omni.diffusion.utils.hf_utils import (
+    _looks_like_dreamzero,
+    get_diffusion_model_index,
+)
 from vllm_omni.entrypoints.stage_utils import _to_dict
 from vllm_omni.inputs.data import OmniSamplingParams
 from vllm_omni.platforms import current_omni_platform
@@ -72,9 +77,9 @@ def _try_get_class_name_from_diffusers_config(model: str) -> str | None:
     Returns:
         Model type string if found, None otherwise
     """
-    model_index = get_hf_file_to_dict("model_index.json", model, revision=None)
+    model_index = get_diffusion_model_index(model)
     if model_index and isinstance(model_index, dict) and "_class_name" in model_index:
-        logger.debug(f"Found model_type '{model_index['_class_name']}' in model_index.json")
+        logger.debug(f"Found Diffusers model type '{model_index['_class_name']}'")
         return model_index["_class_name"]
 
     return None
@@ -103,12 +108,7 @@ def _filter_dict_like_object(obj: dict | Any) -> dict:
             return True
         return isinstance(
             value,
-            (
-                types.FunctionType,
-                types.MethodType,
-                types.BuiltinFunctionType,
-                types.BuiltinMethodType,
-            ),
+            types.FunctionType | types.MethodType | types.BuiltinFunctionType | types.BuiltinMethodType,
         )
 
     result = {}
@@ -193,10 +193,10 @@ def _convert_dataclasses_to_dict(obj: Any) -> Any:
     if callable(obj):
         return None
     # Handle lists and tuples (recurse into items)
-    if isinstance(obj, (list, tuple)):
+    if isinstance(obj, list | tuple):
         return type(obj)(_convert_dataclasses_to_dict(item) for item in obj if not callable(item))
     # Try to convert any dict-like object (has keys/values methods) to dict
-    if hasattr(obj, "keys") and hasattr(obj, "values") and not isinstance(obj, (str, bytes)):
+    if hasattr(obj, "keys") and hasattr(obj, "values") and not isinstance(obj, str | bytes):
         try:
             return _filter_dict_like_object(obj)
         except (TypeError, ValueError, AttributeError):
@@ -231,22 +231,49 @@ def _try_resolve_omni_model_type(model: str) -> str | None:
     return best_match
 
 
-def resolve_model_config_path(model: str) -> str:
-    """Resolve the stage config file path from the model name.
+def _registry_default_deploy_path(model: str) -> str | None:
+    """Return the registered pipeline's default deploy YAML path, if any.
 
-    Resolves stage configuration path based on the model type and device type.
-    First tries to find a device-specific YAML file from stage_configs/{device_type}/
-    directory. If not found, falls back to the default config file.
+    A checkpoint's HF ``model_type`` is not always the registered Omni pipeline
+    key. MiniCPM-o 4.5, for example, reports ``minicpmo`` while its
+    predicate-selected pipeline is ``minicpmo_4_5``. Stage construction already
+    loads that pipeline's default deploy config, so connector discovery must
+    resolve the same path.
+    """
+    pipeline_config = StageConfigFactory.get_pipeline_config(
+        model=model,
+        trust_remote_code=True,
+    )
+    if pipeline_config is None or pipeline_config.default_deploy_config_name is None:
+        return None
+    default_deploy_path = _DEPLOY_DIR / pipeline_config.default_deploy_config_name
+    if default_deploy_path.is_file():
+        return str(default_deploy_path)
+    return None
+
+
+def resolve_model_config_path(model: str) -> str | None:
+    """Resolve the stage/deploy config file path from the model name.
+
+    Resolves configuration path based on the model type and device type.
+    Order:
+    1. Device-specific stage config under ``stage_configs/{device_type}/``
+    2. If HF ``model_type`` is not an ``OMNI_PIPELINES`` key, the registered
+       pipeline's ``default_deploy_config_name`` (keeps connectors aligned with
+       stage construction when HF type and pipeline key differ)
+    3. ``deploy/{model_type}.yaml``
+    4. Legacy ``stage_configs/{model_type}.yaml``
+    5. Registered pipeline default deploy config (final fallthrough)
 
     Args:
         model: Model name or path (used to determine model_type)
 
     Returns:
-        String path to the stage configuration file
+        String path to the stage/deploy configuration file, or ``None`` if no
+        matching config file exists.
 
     Raises:
         ValueError: If model_type cannot be determined
-        FileNotFoundError: If no stage config file exists for the model type
     """
     # Try to get config from standard transformers format first
     try:
@@ -254,12 +281,12 @@ def resolve_model_config_path(model: str) -> str:
         model_type = hf_config.model_type
     except (ValueError, Exception):
         # If standard transformers format fails, try diffusers format
-        if file_or_path_exists(model, "model_index.json", revision=None):
+        if get_diffusion_model_index(model) is not None:
             model_type = _try_get_class_name_from_diffusers_config(model)
             if model_type is None:
                 raise ValueError(
                     f"Could not determine model_type for diffusers model: {model}. "
-                    f"Please ensure the model has 'model_type' in transformer/config.json or model_index.json"
+                    "Please ensure its Diffusers pipeline index contains '_class_name'"
                 )
         elif file_or_path_exists(model, "config.json", revision=None):
             # Try to read config.json manually for custom models like Bagel that fail get_config
@@ -284,7 +311,7 @@ def resolve_model_config_path(model: str) -> str:
             if model_type is None:
                 raise ValueError(
                     f"Could not determine model_type for model: {model}. "
-                    f"Model is not in standard transformers format and does not have model_index.json. "
+                    "Model is not in standard transformers or Diffusers format. "
                     f"Please ensure the model has proper configuration files with 'model_type' field"
                 )
 
@@ -301,19 +328,30 @@ def resolve_model_config_path(model: str) -> str:
     if os.path.exists(complete_config_path):
         return str(complete_config_path)
 
-    deploy_config_path = PROJECT_ROOT / "vllm_omni" / "deploy" / model_type_str
+    # Prefer the registry default before deploy/<hf_model_type>.yaml when the
+    # HF type is not itself a pipeline key. Otherwise a future
+    # deploy/minicpmo.yaml would desync connectors from stages for MiniCPM-o 4.5.
+    if normalized_model_type not in OMNI_PIPELINES:
+        registry_path = _registry_default_deploy_path(model)
+        if registry_path is not None:
+            return registry_path
+
+    deploy_config_path = _DEPLOY_DIR / model_type_str
     if os.path.exists(deploy_config_path):
         return str(deploy_config_path)
 
     stage_config_file = f"vllm_omni/model_executor/stage_configs/{normalized_model_type}.yaml"
     stage_config_path = PROJECT_ROOT / stage_config_file
-    if not os.path.exists(stage_config_path):
-        return None
-    return str(stage_config_path)
+    if os.path.exists(stage_config_path):
+        return str(stage_config_path)
+
+    return _registry_default_deploy_path(model)
 
 
 def load_stage_configs_from_model(
     model: str,
+    *,
+    trust_remote_code: bool | None,
     base_engine_args: dict | None = None,
     deploy_config_path: str | None = None,
     stage_overrides: dict[str, dict[str, Any]] | None = None,
@@ -322,13 +360,14 @@ def load_stage_configs_from_model(
     """Load stage configurations from model's default config file.
 
     For models registered in the pipeline registry (new path), uses
-    ``StageConfigFactory.create_from_model()`` which merges
+    ``StageConfigFactory.create_legacy_stage_configs_from_model()`` which merges
     PipelineConfig + DeployConfig + CLI overrides.
 
     For other models (legacy path), loads stage configs from YAML.
 
     Args:
         model: Model name or path (used to determine model_type)
+        trust_remote_code: Whether to trust remote code while resolving the model config.
         base_engine_args: Base engine args to merge as CLI overrides.
         deploy_config_path: Optional explicit deploy config path.
         stage_overrides: Per-stage overrides from --stage-overrides.
@@ -346,20 +385,30 @@ def load_stage_configs_from_model(
         base_engine_args = {}
 
     cli_overrides = _convert_dataclasses_to_dict(dict(base_engine_args))
+    # A False inherited from the engine-args dump is the store_true flag's
+    # default, not an explicit choice — drop it so only the tri-state
+    # parameter below decides (see with_trust_remote_code_override).
+    if not cli_overrides.get("trust_remote_code"):
+        cli_overrides.pop("trust_remote_code", None)
+    cli_overrides = with_trust_remote_code_override(cli_overrides, trust_remote_code)
     if stage_overrides:
         for stage_id_str, overrides in stage_overrides.items():
             for key, val in overrides.items():
                 cli_overrides[f"stage_{stage_id_str}_{key}"] = val
 
+    # Current runtime initialization still consumes legacy OmegaConf stage
+    # configs. ``StageConfigFactory.create_from_model`` now produces the
+    # structured ``VllmOmniConfig`` object; future RFC #4021 changes will
+    # migrate the engine/runtime consumers and replace this legacy resolver.
     strategy_specs = None
     if strategy_config_path is not None:
         from vllm_omni.config.composable_parallel.strategy_loader import load_strategy_specs
 
         strategy_specs = load_strategy_specs(strategy_config_path)
 
-    stages, omni_lb_policy = StageConfigFactory.create_from_model(
+    stages, omni_lb_policy = StageConfigFactory.create_legacy_stage_configs_from_model(
         model,
-        trust_remote_code=cli_overrides.get("trust_remote_code", False),
+        trust_remote_code=trust_remote_code,
         cli_overrides=cli_overrides,
         deploy_config_path=deploy_config_path,
         strategy_specs=strategy_specs,
@@ -550,6 +599,8 @@ def load_and_resolve_stage_configs(
     model: str,
     stage_configs_path: str | None,
     kwargs: dict | None,
+    *,
+    trust_remote_code: bool | None,
     default_stage_cfg_factory: Any = None,
     deploy_config_path: str | None = None,
     stage_overrides: dict[str, dict[str, Any]] | None = None,
@@ -561,6 +612,7 @@ def load_and_resolve_stage_configs(
         model: Model name or path
         stage_configs_path: Optional path to legacy YAML (stage_args format)
         kwargs: Engine arguments to merge with stage configs
+        trust_remote_code: Whether to trust remote code while resolving the model config.
         default_stage_cfg_factory: Optional callable that takes no args and returns
             default stage config list when no configs are found
         deploy_config_path: Optional path to deploy YAML (new format).
@@ -606,6 +658,7 @@ def load_and_resolve_stage_configs(
         config_path = deploy_config_path
         stage_configs, omni_lb_policy = load_stage_configs_from_model(
             model,
+            trust_remote_code=trust_remote_code,
             base_engine_args=kwargs,
             deploy_config_path=deploy_config_path,
             stage_overrides=stage_overrides,
@@ -621,6 +674,7 @@ def load_and_resolve_stage_configs(
         config_path = resolve_model_config_path(model)
         stage_configs, omni_lb_policy = load_stage_configs_from_model(
             model,
+            trust_remote_code=trust_remote_code,
             base_engine_args=kwargs,
             stage_overrides=stage_overrides,
             strategy_config_path=strategy_config_path,
@@ -715,7 +769,7 @@ def filter_dataclass_kwargs(cls: Any, kwargs: dict) -> dict:
         if origin in (list, tuple, set):
             args = get_args(annotation)
             inner = args[0] if args else None
-            if isinstance(value, (list, tuple, set)):
+            if isinstance(value, list | tuple | set):
                 return type(value)(_filter_value(v, inner) for v in value)
             return value
 
diff --git a/vllm_omni/experimental/ar_diffusion/__init__.py b/vllm_omni/experimental/ar_diffusion/__init__.py
index b312660ec..b87ac1ccc 100644
--- a/vllm_omni/experimental/ar_diffusion/__init__.py
+++ b/vllm_omni/experimental/ar_diffusion/__init__.py
@@ -2,11 +2,24 @@
 """AR-Diffusion Engine (AR-Diffusion).
 
 The AR-Diffusion engine: a ``DiffusionEngine`` subclass that adds engine-level KV
-cache management for autoregressive / chunked "world-model" diffusion models
-(DreamZero and the AR-DiT family). Selected via
+cache management for autoregressive / chunked diffusion models. Selected via
 ``OmniDiffusionConfig.engine_backend = "ar_diffusion"``.
 """
 
+from vllm_omni.experimental.ar_diffusion.capability import (
+    ARDiffusionCrossAttentionKVSpec,
+    ARDiffusionKVBranchSpec,
+    ARDiffusionKVCacheSpec,
+    SupportsARDiffusionPipeline,
+    SupportsARDiffusionWarmup,
+)
 from vllm_omni.experimental.ar_diffusion.engine import ARDiffusionEngine
 
-__all__ = ["ARDiffusionEngine"]
+__all__ = [
+    "ARDiffusionKVBranchSpec",
+    "ARDiffusionCrossAttentionKVSpec",
+    "ARDiffusionEngine",
+    "ARDiffusionKVCacheSpec",
+    "SupportsARDiffusionPipeline",
+    "SupportsARDiffusionWarmup",
+]
diff --git a/vllm_omni/experimental/ar_diffusion/capability.py b/vllm_omni/experimental/ar_diffusion/capability.py
new file mode 100644
index 000000000..b30d10c1e
--- /dev/null
+++ b/vllm_omni/experimental/ar_diffusion/capability.py
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Typed pipeline contract for the model-neutral AR-Diffusion runtime."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
+
+
+@dataclass(frozen=True)
+class ARDiffusionKVBranchSpec:
+    """One logical model KV branch and its worker-local storage slot.
+
+    Distinct KV branches may share ``local_index`` when distributed execution
+    guarantees that at most one of them runs on a worker. For example, two CFG
+    branches use indices ``0, 1`` without CFG parallelism and may both use index
+    ``0`` when each worker executes only one branch.
+    """
+
+    name: str
+    local_index: int
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("AR-Diffusion KV branch names must be non-empty")
+        if self.local_index < 0:
+            raise ValueError(f"AR-Diffusion KV branch local_index must be non-negative, got {self.local_index}")
+
+
+@dataclass(frozen=True)
+class ARDiffusionCrossAttentionKVSpec:
+    """A fixed-length, per-layer cross-attention KV allocation."""
+
+    name: str
+    num_tokens: int
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("AR-Diffusion cross-attention cache names must be non-empty")
+        if self.num_tokens <= 0:
+            raise ValueError(f"AR-Diffusion cross-attention num_tokens must be positive, got {self.num_tokens}")
+
+
+@dataclass(frozen=True)
+class ARDiffusionKVCacheSpec:
+    """KV geometry and session policy supplied by an AR-Diffusion pipeline.
+
+    ``tokens_per_frame`` is also the paged KV block size. A model forward may
+    commit ``frames_per_block`` such blocks at once. ``window_frames`` is the
+    recent sliding tail and ``sink_frames`` is the separately retained prefix;
+    both are expressed in the same frame/block unit.
+
+    ``max_scratch_tokens_per_branch`` is the maximum non-video KV (for example,
+    action/state registers) that must coexist with an uncommitted video block.
+    ``session_capacity`` is the pipeline's upper bound; a runner may retain
+    fewer sessions when its current memory and execution policy is stricter.
+
+    The runner owns all pool allocations and session lifetime. The pipeline
+    owns its non-KV model state and receives reset/close notifications through
+    :class:`SupportsARDiffusionPipeline`.
+    """
+
+    num_layers: int
+    num_kv_heads: int
+    head_size: int
+    tokens_per_frame: int
+    frames_per_block: int
+    window_frames: int
+    kv_branches: tuple[ARDiffusionKVBranchSpec, ...]
+    session_capacity: int
+    sink_frames: int = 0
+    reset_at_boundary: bool = False
+    cross_attention: tuple[ARDiffusionCrossAttentionKVSpec, ...] = ()
+    max_model_len: int = 1 << 20
+    max_scratch_tokens_per_branch: int = 0
+
+    def __post_init__(self) -> None:
+        positive_fields = {
+            "num_layers": self.num_layers,
+            "num_kv_heads": self.num_kv_heads,
+            "head_size": self.head_size,
+            "tokens_per_frame": self.tokens_per_frame,
+            "frames_per_block": self.frames_per_block,
+            "window_frames": self.window_frames,
+            "session_capacity": self.session_capacity,
+            "max_model_len": self.max_model_len,
+        }
+        for name, value in positive_fields.items():
+            if value <= 0:
+                raise ValueError(f"AR-Diffusion {name} must be positive, got {value}")
+        if self.sink_frames < 0:
+            raise ValueError(f"AR-Diffusion sink_frames must be non-negative, got {self.sink_frames}")
+        if self.max_scratch_tokens_per_branch < 0:
+            raise ValueError(
+                "AR-Diffusion max_scratch_tokens_per_branch must be non-negative, "
+                f"got {self.max_scratch_tokens_per_branch}"
+            )
+        if not self.kv_branches:
+            raise ValueError("AR-Diffusion requires at least one KV branch")
+        kv_branch_names = [kv_branch.name for kv_branch in self.kv_branches]
+        if len(kv_branch_names) != len(set(kv_branch_names)):
+            raise ValueError(f"AR-Diffusion KV branch names must be unique, got {kv_branch_names}")
+        local_indices = {kv_branch.local_index for kv_branch in self.kv_branches}
+        if local_indices != set(range(max(local_indices) + 1)):
+            raise ValueError(
+                f"AR-Diffusion KV branch local_index values must be contiguous from zero, got {sorted(local_indices)}"
+            )
+        cross_names = [cache.name for cache in self.cross_attention]
+        if len(cross_names) != len(set(cross_names)):
+            raise ValueError(f"AR-Diffusion cross-attention cache names must be unique, got {cross_names}")
+
+    @property
+    def num_local_kv_branches(self) -> int:
+        """Number of KV branch storage slots allocated on this worker."""
+        return max(kv_branch.local_index for kv_branch in self.kv_branches) + 1
+
+    @property
+    def cross_attention_lengths(self) -> dict[str, int]:
+        return {cache.name: cache.num_tokens for cache in self.cross_attention}
+
+
+@runtime_checkable
+class SupportsARDiffusionPipeline(Protocol):
+    """Required pipeline capability for :class:`ARDiffusionModelRunner`.
+
+    A session begins when the runner first sees its ``session_id`` and persists
+    across requests until reset, explicit close, LRU eviction, or a failed
+    forward. ``bind_ar_diffusion_state`` exposes the runner-owned KV state only
+    for the duration of one request. The pipeline must not retain the state
+    after the context exits.
+    """
+
+    def ar_diffusion_kv_cache_spec(self) -> ARDiffusionKVCacheSpec:
+        """Return immutable KV geometry and session policy for this worker."""
+        ...
+
+    def bind_ar_diffusion_state(
+        self,
+        session_id: str,
+        state: ARDiffusionKVState,
+    ) -> AbstractContextManager[None]:
+        """Bind ``state`` to model execution for one request."""
+        ...
+
+    def reset_ar_diffusion_session(self, session_id: str) -> None:
+        """Reset model-owned state for ``session_id`` after KV release."""
+        ...
+
+    def close_ar_diffusion_session(self, session_id: str) -> None:
+        """Drop model-owned state after close, eviction, or failed forward."""
+        ...
+
+
+@runtime_checkable
+class SupportsARDiffusionWarmup(Protocol):
+    """Optional provider of model-valid warmup requests.
+
+    Pipelines without this capability are loaded without an AR rollout warmup.
+    """
+
+    def ar_diffusion_warmup_requests(self, session_id: str) -> Iterable[OmniDiffusionRequest]:
+        """Yield requests for compiled shapes, each carrying ``session_id``."""
+        ...
diff --git a/vllm_omni/experimental/ar_diffusion/engine.py b/vllm_omni/experimental/ar_diffusion/engine.py
index 6fb6ee7c9..52ef6c9d0 100644
--- a/vllm_omni/experimental/ar_diffusion/engine.py
+++ b/vllm_omni/experimental/ar_diffusion/engine.py
@@ -20,8 +20,7 @@ class ARDiffusionEngine(DiffusionEngine):
     (world models, AR-DiT) that materialize persistent attention KV. It reuses
     vLLM's paged KV stack (``KVCacheManager`` / ``BlockPool`` / ``BlockTables``)
     as a library, driven from the engine rather than hand-rolled inside each
-    model. See ``BDE_doc/diffusion_kv_cache_management.md`` for the design and
-    ``BDE_doc/dreamzero_kv_phase1_plan.md`` for the rollout.
+    model.
 
     It is selected per model via ``OmniDiffusionConfig.engine_backend = "ar_diffusion"``
     (resolved by :meth:`DiffusionEngine.make_engine`), so models that do not opt
@@ -32,7 +31,7 @@ class ARDiffusionEngine(DiffusionEngine):
     actual KV *body* is :class:`~vllm_omni.experimental.ar_diffusion.kv_cache.manager.ARDiffusionKVCache`, owned
     by :class:`~vllm_omni.experimental.ar_diffusion.runner.ARDiffusionModelRunner`. ``ARDiffusionEngine`` itself is the
     thin selection / injection seam; it wires the AR-Diffusion executor → worker → runner
-    so DreamZero's rollout runs against the runner-owned KV cache.
+    so capable pipelines run against runner-owned KV session state.
     """
 
     #: Workers of this engine build the AR-Diffusion runner (unless the config
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/__init__.py b/vllm_omni/experimental/ar_diffusion/kv_cache/__init__.py
index ab29f6093..b407d24a3 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/__init__.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/__init__.py
@@ -3,7 +3,7 @@
 
 Thin glue over vLLM's paged KV stack (``KVCacheManager`` / ``BlockPool`` /
 ``SlidingWindowManager``), used by the AR-Diffusion Engine to manage KV for
-AR-diffusion models. See ``BDE_doc/dreamzero_kv_phase1_plan.md``.
+AR-diffusion models.
 
 Layout: ``config`` (public knob) · ``paged`` (engine-generic paging mechanics +
 chunk-window eviction spec) · ``manager`` (the ARDiffusionKVCache orchestrator + its
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/config.py b/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
index 4b3c73775..07be2546e 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/config.py
@@ -15,14 +15,13 @@ class ARDiffusionKVConfig:
     """
 
     enable: bool = False
-    # Persistent KV tokens materialized per AR chunk. For DreamZero this is
-    # ``num_frame_per_block * frame_seqlen``.
+    # Persistent KV tokens materialized per paged cache block.
     chunk_size: int = 0
     # Resident window in chunks. ``None`` means full attention (no eviction).
     window_chunks: int | None = None
     # Protected leading chunks (attention sink); never evicted.
     sink_chunks: int = 0
-    # DreamZero-style window reset vs. VGGT-style sliding replace.
+    # Boundary reset vs. sliding replacement.
     reset_at_boundary: bool = False
     # Fraction of free device memory budgeted for the AR-Diffusion KV pool.
     gpu_memory_fraction: float = 0.1
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py b/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
index 4b3b5d788..9ef3cca0c 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/manager.py
@@ -1,20 +1,19 @@
 # SPDX-License-Identifier: Apache-2.0
-"""ARDiffusionKVCache — the engine-level KV cache orchestrator for one AR-Diffusion model.
+"""Engine-level KV cache orchestration for AR-Diffusion models.
 
 This is the *body* of AR-Diffusion's KV management: it owns a vLLM ``KVCacheManager`` (a
 single chunk-window group) and the per-request adapter lifecycle, and exposes the
 per-chunk operations a rollout needs — allocate, slot mapping, commit, window
 lookup, free. It lives in the model runner (worker / GPU side), co-located with
-the model and the KV tensors; the DreamZero pipeline calls these methods during a
-rollout. The main-process ``ARDiffusionEngine`` only selects the engine and is otherwise
-thin.
+the model and the KV tensors. The main-process ``ARDiffusionEngine`` only
+selects the engine and is otherwise thin.
 """
 
 from __future__ import annotations
 
 import inspect
 import os
-from collections.abc import Sequence
+from collections.abc import Collection, Iterable, Sequence
 
 import torch
 from vllm.logger import init_logger
@@ -27,6 +26,7 @@ from vllm.v1.kv_cache_interface import (
 )
 from vllm.v1.request import RequestStatus
 
+from vllm_omni.experimental.ar_diffusion.capability import ARDiffusionKVBranchSpec
 from vllm_omni.experimental.ar_diffusion.kv_cache.config import ARDiffusionKVConfig
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged import (
     ChunkWindowSpec,
@@ -48,7 +48,7 @@ class ARDiffusionRequestAdapter:
     real ``KVCacheManager`` against this adapter so the surface cannot silently
     drift across vLLM versions.
 
-    A AR-Diffusion request advances one *chunk* at a time: ``allocate_slots`` is called
+    An AR-Diffusion request advances one *chunk* at a time: ``allocate_slots`` is called
     once per chunk and ``num_computed_tokens`` advances only when a chunk is
     committed (:meth:`on_chunk_committed`), so the ``T`` denoise steps of a chunk
     reuse the same slots.
@@ -71,6 +71,11 @@ class ARDiffusionRequestAdapter:
         self.num_preemptions = 0
         # vLLM watermark gate reads this; map the request lifecycle onto it.
         self.status = RequestStatus.WAITING
+        # vLLM 0.26 KVCacheManager.allocate_slots reads this when computing
+        # remove_skipped_blocks. Always 0 here: an AR-Diffusion request only
+        # advances num_computed_tokens on on_chunk_committed(), so there are
+        # never optimistically-counted in-flight tokens to subtract.
+        self.num_in_flight_tokens = 0
 
     @property
     def num_computed_tokens(self) -> int:
@@ -145,7 +150,7 @@ def build_kv_manager(
 
 
 class ARDiffusionKVCache:
-    """Owns the paged KV pool + per-request lifecycle for a AR-Diffusion model.
+    """Own the paged KV pool and KV-branch-local storage for one model.
 
     Build once per loaded model (dimensions known); then per request:
     ``begin_request`` → per chunk (``allocate_chunk`` → ``chunk_write_slots`` →
@@ -163,11 +168,12 @@ class ARDiffusionKVCache:
         block_size: int,
         max_model_len: int,
         available_bytes: int,
-        cross_attn_length: int = 0,
-        cross_attn_img_length: int = 0,
+        kv_branches: tuple[ARDiffusionKVBranchSpec, ...],
+        session_capacity: int,
+        cross_attention_lengths: dict[str, int] | None = None,
         device: torch.device | None = None,
-        local_branches: int = 2,
-        num_frame_per_block: int = 1,
+        frames_per_block: int = 1,
+        max_scratch_tokens_per_branch: int = 0,
     ) -> None:
         if not config.enable:
             raise ValueError("ARDiffusionKVCache built with a disabled ARDiffusionKVConfig")
@@ -175,77 +181,63 @@ class ARDiffusionKVCache:
             raise ValueError("Phase 1 requires a bounded window (window_chunks)")
         if config.chunk_size <= 0:
             raise ValueError("ARDiffusionKVConfig.chunk_size must be set (> 0)")
-        if local_branches not in (1, 2):
-            raise ValueError(f"local_branches must be 1 or 2, got {local_branches}")
+        if not kv_branches:
+            raise ValueError("ARDiffusionKVCache requires at least one KV branch")
+        if session_capacity <= 0:
+            raise ValueError(f"session_capacity must be positive, got {session_capacity}")
+        kv_branch_names = [kv_branch.name for kv_branch in kv_branches]
+        if len(kv_branch_names) != len(set(kv_branch_names)):
+            raise ValueError(f"ARDiffusionKVCache KV branch names must be unique, got {kv_branch_names}")
+        local_indices = {kv_branch.local_index for kv_branch in kv_branches}
+        if local_indices != set(range(max(local_indices) + 1)):
+            raise ValueError(
+                "ARDiffusionKVCache KV branch local_index values must be contiguous from zero, "
+                f"got {sorted(local_indices)}"
+            )
 
         self.config = config
-        # How many CFG branches allocate from THIS rank's pool. Under
-        # CFG-parallel x2 each rank executes exactly one branch (rank0 pos,
-        # rank1 neg) and the other branch's lazy contexts never allocate, so
-        # sizing for both would leave ~half the pool as idle capacity. A
-        # single-process run (TP1 / offline) executes both branches -> 2.
-        self.local_branches = local_branches
-        self.num_frame_per_block = max(1, int(num_frame_per_block))
+        self.kv_branches = kv_branches
+        self.session_capacity = session_capacity
+        self._kv_branch_local_indices = {kv_branch.name: kv_branch.local_index for kv_branch in kv_branches}
+        self.num_local_kv_branches = max(local_indices) + 1
+        if frames_per_block <= 0:
+            raise ValueError(f"frames_per_block must be positive, got {frames_per_block}")
+        if max_scratch_tokens_per_branch < 0:
+            raise ValueError(f"max_scratch_tokens_per_branch must be non-negative, got {max_scratch_tokens_per_branch}")
+        self.frames_per_block = int(frames_per_block)
         self.block_size = block_size
         self.num_layers = num_layers
         self.num_kv_heads = num_kv_heads
         self.head_size = head_size
         self.dtype = dtype
-        self.cross_attn_length = cross_attn_length
+        self.cross_attention_lengths = dict(cross_attention_lengths or {})
+        invalid_cross = {name: length for name, length in self.cross_attention_lengths.items() if length <= 0}
+        if invalid_cross:
+            raise ValueError(f"cross_attention_lengths must be positive, got {invalid_cross}")
         self.device = device or torch.device("cpu")
+        self._allocate_tensors = device is not None
         self._adapters: dict[str, ARDiffusionRequestAdapter] = {}
 
-        # -- cross-attention pool (static, one-time-fill) -----------------------
-        # Cross-attn KV is computed once from the text encoder and never changes.
-        # Allocate a per-layer contiguous tensor for each branch: (2, text_len,
-        # kv_heads, head_dim) where dim-0 = [pos, neg].  Allocated separately
-        # from the self-attn block pool (static, small — ~400 MiB for
-        # DreamZero I2V).  Both pools draw from the same GPU free memory but
-        # the cross-attn pool is sized directly rather than via the block pool
-        # budget (no eviction/chunk lifecycle needed).
-        self.cross_attn_img_length = cross_attn_img_length
-        self._cross_k: list[torch.Tensor] = []
-        self._cross_v: list[torch.Tensor] = []
-        # I2V image-token cross-attn pool. Like the text k/v, the image-token
-        # k_img/v_img are session-invariant (the conditioning image doesn't change),
-        # so they are cached once and read every denoise step — see
-        # WanI2VCrossAttention (#4154 caches these model-side too). Empty for T2V.
-        self._cross_k_img: list[torch.Tensor] = []
-        self._cross_v_img: list[torch.Tensor] = []
+        # Named cross-attention K/V is allocated lazily per session and released
+        # with that session. Reserve its worst-case capacity when sizing the
+        # paged self-attention pool so the two stores share one memory budget.
+        self._cross_sessions: dict[
+            str,
+            dict[str, dict[str, tuple[list[torch.Tensor], list[torch.Tensor]]]],
+        ] = {}
 
-        # Bytes the cross-attn pools consume directly (K+V, pos+neg, all layers).
-        # Deducted from the self-attn paged-pool budget below so the two
-        # allocations together stay within the GPU free-memory budget.
         def _cross_pool_bytes(length: int) -> int:
-            return 2 * 2 * length * num_kv_heads * head_size * dtype.itemsize * num_layers
+            return int(2 * len(self.kv_branches) * length * num_kv_heads * head_size * dtype.itemsize * num_layers)
 
-        cross_total_bytes = 0
-        if device is not None and cross_attn_length > 0:
-            cross_shape = (2, cross_attn_length, num_kv_heads, head_size)
-            cross_bytes = _cross_pool_bytes(cross_attn_length)
-            cross_total_bytes += cross_bytes
-            for _ in range(num_layers):
-                self._cross_k.append(torch.empty(cross_shape, dtype=dtype, device=device))
-                self._cross_v.append(torch.empty(cross_shape, dtype=dtype, device=device))
+        cross_bytes_per_session = sum(_cross_pool_bytes(length) for length in self.cross_attention_lengths.values())
+        cross_total_bytes = cross_bytes_per_session * session_capacity
+        if cross_total_bytes:
             _log.info(
-                "AR-Diffusion cross-attn pool: %d layers × (%d tok × %d heads × %d) = %.1f MiB",
-                num_layers,
-                cross_attn_length,
-                num_kv_heads,
-                head_size,
-                cross_bytes / (1024 * 1024),
+                "AR-Diffusion cross-attn reservation: %.1f MiB/session × %d sessions = %.1f MiB",
+                cross_bytes_per_session / (1024 * 1024),
+                session_capacity,
+                cross_total_bytes / (1024 * 1024),
             )
-            if cross_attn_img_length > 0:
-                img_shape = (2, cross_attn_img_length, num_kv_heads, head_size)
-                cross_total_bytes += _cross_pool_bytes(cross_attn_img_length)
-                for _ in range(num_layers):
-                    self._cross_k_img.append(torch.empty(img_shape, dtype=dtype, device=device))
-                    self._cross_v_img.append(torch.empty(img_shape, dtype=dtype, device=device))
-                _log.info(
-                    "AR-Diffusion cross-attn IMG pool: %d layers × %d img-tok (I2V)",
-                    num_layers,
-                    cross_attn_img_length,
-                )
 
         self.spec = ChunkWindowSpec(
             block_size=block_size,
@@ -260,46 +252,51 @@ class ARDiffusionKVCache:
         )
         # Each pool block spans all layers' K/V, so size against the per-layer
         # page size times the layer count.
-        # Size the self-attn pool against the memory left after the cross-attn
-        # pools (allocated above), so cross + self-attn stays within the budget.
+        # Size the self-attn pool against memory reserved for the maximum number
+        # of lazily allocated cross-attention sessions.
         num_blocks = compute_num_blocks(
             max(0, available_bytes - cross_total_bytes),
             config.gpu_memory_fraction,
             self.spec.page_size_bytes * num_layers,
         )
         # Floor: one forward needs the resident window plus the in-flight chunk
-        # (num_frame_per_block frame-blocks) for every branch THIS rank runs,
+        # (frames_per_block frame-blocks) for every KV branch THIS rank runs,
         # with a little eviction-transient headroom. The memory-fraction
         # heuristic can under-size this once block_size grows — e.g. frame-granular
         # paging at the true frame_seqlen makes each block larger and the pool
         # fewer-blocks — so guarantee the minimum the rollout cannot run without,
         # otherwise allocate_chunk hits an exhausted pool mid-forward.
-        min_blocks = self.local_branches * (config.window_chunks + self.num_frame_per_block) + 2
+        resident_blocks = config.sink_chunks + config.window_chunks
+        min_blocks = self.num_local_kv_branches * (resident_blocks + self.frames_per_block) + 2
         if num_blocks < min_blocks:
             _log.warning(
                 "AR-Diffusion KV pool: memory-fraction sizing gave %d blocks; raising to the %d-block "
-                "floor (%d local CFG branch(es) x (window_chunks=%d + num_frame_per_block=%d) + 2 headroom)",
+                "floor (%d local KV branch(es) x (sink_chunks=%d + window_chunks=%d "
+                "+ frames_per_block=%d) + 2 headroom)",
                 num_blocks,
                 min_blocks,
-                self.local_branches,
+                self.num_local_kv_branches,
+                config.sink_chunks,
                 config.window_chunks,
-                self.num_frame_per_block,
+                self.frames_per_block,
             )
             num_blocks = min_blocks
         layer_names = [f"ar_diffusion.layer.{i}" for i in range(num_layers)]
         self.manager = build_kv_manager(self.spec, layer_names, num_blocks, max_model_len)
         self.managed_num_blocks = num_blocks
         self.num_blocks = num_blocks
-        # Scratch blocks are outside KVCacheManager ownership. They hold current
-        # denoise-step video KV when update_kv_cache=False and action/state KV in
-        # both modes; they are reused every forward and never committed.
-        # Default 4: measured high-water is num_frame_per_block video blocks (2)
-        # + 1 action block per branch per forward, +1 margin.
-        scratch_per_branch = int(os.environ.get("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH", "4"))
-        if scratch_per_branch <= 0:
-            raise ValueError("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH must be positive")
-        self.scratch_blocks_per_branch = scratch_per_branch
-        self.scratch_num_blocks = self.local_branches * scratch_per_branch
+        # Scratch blocks are outside KVCacheManager ownership. A non-committing
+        # forward needs one block per current frame plus space for any
+        # model-declared action/state tokens that coexist with video KV.
+        declared_scratch_blocks = (max_scratch_tokens_per_branch + block_size - 1) // block_size
+        minimum_scratch_blocks = self.frames_per_block + declared_scratch_blocks
+        override = os.environ.get("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH")
+        override_blocks = int(override) if override is not None else 0
+        if override_blocks < 0:
+            raise ValueError("AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH must be non-negative")
+        scratch_per_kv_branch = max(minimum_scratch_blocks, override_blocks)
+        self.scratch_blocks_per_kv_branch = scratch_per_kv_branch
+        self.scratch_num_blocks = self.num_local_kv_branches * scratch_per_kv_branch
         self.num_blocks_total = self.managed_num_blocks + self.scratch_num_blocks
         self.null_block_id = self.manager.block_pool.null_block.block_id
 
@@ -322,49 +319,147 @@ class ARDiffusionKVCache:
     # Cross-attn KV is static once populated — write once (from text encoder),
     # read many (every denoising step). Not managed through the paged block pool.
 
-    def write_cross_kv(
+    def _kv_branch_index(self, kv_branch: str) -> int:
+        try:
+            return self._kv_branch_local_indices[kv_branch]
+        except KeyError as exc:
+            expected = tuple(self._kv_branch_local_indices)
+            raise KeyError(f"Unknown AR-Diffusion KV branch {kv_branch!r}; expected {expected}") from exc
+
+    def _cross_attention_pool(
         self,
-        layer_idx: int,
-        is_negative: bool,
-        k: torch.Tensor | None,
-        v: torch.Tensor | None,
-        k_img: torch.Tensor | None = None,
-        v_img: torch.Tensor | None = None,
+        session_id: str,
+        cache_name: str,
+        kv_branch: str,
+    ) -> tuple[list[torch.Tensor], list[torch.Tensor]]:
+        if cache_name not in self.cross_attention_lengths:
+            raise KeyError(
+                f"Unknown AR-Diffusion cross-attention cache {cache_name!r}; "
+                f"expected {tuple(self.cross_attention_lengths)}"
+            )
+        self._kv_branch_index(kv_branch)
+        session = self._cross_sessions.get(session_id)
+        if session is None:
+            raise RuntimeError(
+                f"AR-Diffusion cross-attention cache {cache_name!r} for session {session_id!r} "
+                "was read before it was populated"
+            )
+        pool = session.get(cache_name, {}).get(kv_branch)
+        if pool is None:
+            raise RuntimeError(
+                f"AR-Diffusion cross-attention cache {cache_name!r} for session {session_id!r} "
+                f"and KV branch {kv_branch!r} was read before it was populated"
+            )
+        return pool
+
+    def is_cross_attention_populated(self, session_id: str, cache_name: str, kv_branch: str) -> bool:
+        """Whether a complete logical-branch cache has been published."""
+        if cache_name not in self.cross_attention_lengths:
+            raise KeyError(
+                f"Unknown AR-Diffusion cross-attention cache {cache_name!r}; "
+                f"expected {tuple(self.cross_attention_lengths)}"
+            )
+        self._kv_branch_index(kv_branch)
+        session = self._cross_sessions.get(session_id)
+        return session is not None and kv_branch in session.get(cache_name, {})
+
+    def populate_cross_attention(
+        self,
+        session_id: str,
+        cache_name: str,
+        kv_branch: str,
+        layer_kv: Iterable[tuple[torch.Tensor, torch.Tensor]],
     ) -> None:
-        """Write one layer's cross-attn K/V into the pool.
+        """Atomically populate one logical branch of a named cross-attention cache.
 
-        ``k`` / ``v``: ``(B, text_len, tp_num_heads, head_dim)``; only batch-0
-        is copied (B=1 for inference). ``None`` skips the text half (window
-        restarts keep the still-valid text K/V and rewrite only the image half).
-        The ``is_negative`` flag selects the correct CFG branch slot. ``k_img`` /
-        ``v_img`` (I2V image tokens, ``(B, 257, ...)``) are written when the
-        image pool is allocated.
+        ``layer_kv`` must yield exactly one ``(k, v)`` pair per model layer.
+        Inputs have shape ``(B, length, local_kv_heads, head_size)``; batch zero
+        is copied because AR-Diffusion currently supports one sequence per
+        forward. The new cache is published only after every layer is copied,
+        so failed projection/copy work cannot expose partially initialized KV.
         """
-        branch = 1 if is_negative else 0
-        if k is not None:
-            self._cross_k[layer_idx][branch].copy_(k[0])
-            self._cross_v[layer_idx][branch].copy_(v[0])
-        if k_img is not None and self._cross_k_img:
-            self._cross_k_img[layer_idx][branch].copy_(k_img[0])
-            self._cross_v_img[layer_idx][branch].copy_(v_img[0])
+        try:
+            length = self.cross_attention_lengths[cache_name]
+        except KeyError as exc:
+            raise KeyError(
+                f"Unknown AR-Diffusion cross-attention cache {cache_name!r}; "
+                f"expected {tuple(self.cross_attention_lengths)}"
+            ) from exc
+        self._kv_branch_index(kv_branch)
+        session = self._cross_sessions.get(session_id)
+        if session is None and len(self._cross_sessions) >= self.session_capacity:
+            raise RuntimeError(
+                "AR-Diffusion cross-attention session capacity exhausted; "
+                "the runner must evict a session before allocating another"
+            )
+        if not self._allocate_tensors:
+            raise RuntimeError("AR-Diffusion cross-attention tensors require a configured pool device")
 
-    def read_cross_kv(self, layer_idx: int, is_negative: bool) -> dict:
-        """Return a pool-backed cross-attn cache dict for one layer.
+        shape = (length, self.num_kv_heads, self.head_size)
+        expected_input_shape = (1, *shape)
+        k_pool = [torch.empty(shape, dtype=self.dtype, device=self.device) for _ in range(self.num_layers)]
+        v_pool = [torch.empty(shape, dtype=self.dtype, device=self.device) for _ in range(self.num_layers)]
+        populated_layers = 0
+        for layer_idx, (k, v) in enumerate(layer_kv):
+            if layer_idx >= self.num_layers:
+                raise ValueError(
+                    f"AR-Diffusion cross-attention cache {cache_name!r} expected {self.num_layers} layers, "
+                    f"got more than {self.num_layers}"
+                )
+            if not isinstance(k, torch.Tensor) or not isinstance(v, torch.Tensor):
+                raise ValueError(
+                    f"AR-Diffusion cross-attention cache {cache_name!r} layer {layer_idx} "
+                    f"must yield torch.Tensor k/v, got {type(k).__name__} and {type(v).__name__}"
+                )
+            if tuple(k.shape) != expected_input_shape or tuple(v.shape) != expected_input_shape:
+                raise ValueError(
+                    f"AR-Diffusion cross-attention cache {cache_name!r} layer {layer_idx} expected "
+                    f"k/v shape {expected_input_shape}, got {tuple(k.shape)} and {tuple(v.shape)}"
+                )
+            k_pool[layer_idx].copy_(k[0])
+            v_pool[layer_idx].copy_(v[0])
+            populated_layers += 1
+        if populated_layers != self.num_layers:
+            raise ValueError(
+                f"AR-Diffusion cross-attention cache {cache_name!r} expected {self.num_layers} layers, "
+                f"got {populated_layers}"
+            )
 
-        The dict matches the ``{"is_init": True, "k": Tensor, "v": Tensor}``
-        convention the cross-attention module expects — it reads from the pool
-        slice rather than from the lazy-initialised model-local dict. For I2V,
-        ``k_img`` / ``v_img`` are added so the image-token cache (added by #4154)
-        reads from the pool too.
-        """
-        branch = 1 if is_negative else 0
-        k = self._cross_k[layer_idx][branch].unsqueeze(0)  # (1, L, heads, dim)
-        v = self._cross_v[layer_idx][branch].unsqueeze(0)
-        cache = {"is_init": True, "k": k, "v": v}
-        if self._cross_k_img:
-            cache["k_img"] = self._cross_k_img[layer_idx][branch].unsqueeze(0)
-            cache["v_img"] = self._cross_v_img[layer_idx][branch].unsqueeze(0)
-        return cache
+        if session is None:
+            session = {}
+            self._cross_sessions[session_id] = session
+        session.setdefault(cache_name, {})[kv_branch] = (k_pool, v_pool)
+
+    def read_cross_attention_kv(
+        self,
+        session_id: str,
+        cache_name: str,
+        layer_idx: int,
+        kv_branch: str,
+    ) -> dict[str, torch.Tensor | bool]:
+        """Return a model-facing K/V dict for one named cross-attention pool."""
+        k_pool, v_pool = self._cross_attention_pool(session_id, cache_name, kv_branch)
+        return {
+            "is_init": True,
+            "k": k_pool[layer_idx].unsqueeze(0),
+            "v": v_pool[layer_idx].unsqueeze(0),
+        }
+
+    def retain_cross_attention(self, session_id: str, cache_names: Collection[str]) -> None:
+        """Release named cross-attention caches not retained by an internal reset."""
+        session = self._cross_sessions.get(session_id)
+        if session is None:
+            return
+        keep = set(cache_names)
+        for cache_name in tuple(session):
+            if cache_name not in keep:
+                del session[cache_name]
+        if not session:
+            self._cross_sessions.pop(session_id, None)
+
+    def release_cross_attention(self, session_id: str) -> None:
+        """Release every named cross-attention allocation for one session."""
+        self._cross_sessions.pop(session_id, None)
 
     # -- request lifecycle ---------------------------------------------------
 
@@ -431,20 +526,19 @@ class ARDiffusionKVCache:
             self.block_size,
         )
 
-    def scratch_block_ids(self, is_negative: bool, start: int, count: int) -> list[int]:
-        """Return branch-local scratch block ids outside manager ownership."""
+    def scratch_block_ids(self, kv_branch: str, start: int, count: int) -> list[int]:
+        """Return KV-branch-local scratch block ids outside manager ownership."""
         if count < 0 or start < 0:
             raise ValueError(f"scratch start/count must be non-negative, got start={start}, count={count}")
-        if start + count > self.scratch_blocks_per_branch:
+        if start + count > self.scratch_blocks_per_kv_branch:
             raise RuntimeError(
                 "AR-Diffusion paged attention scratch blocks exhausted: "
-                f"need [{start}, {start + count}) of {self.scratch_blocks_per_branch}. "
-                "Increase AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH."
+                f"need [{start}, {start + count}) of {self.scratch_blocks_per_kv_branch}. "
+                "Declare max_scratch_tokens_per_branch in the pipeline capability "
+                "or increase AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH."
             )
-        # With one local branch (CFG-parallel x2) the rank's only branch maps to
-        # slot 0 whichever CFG side it is; the other branch never allocates here.
-        branch_offset = self.scratch_blocks_per_branch if (is_negative and self.local_branches == 2) else 0
-        base = self.managed_num_blocks + branch_offset + start
+        kv_branch_offset = self.scratch_blocks_per_kv_branch * self._kv_branch_index(kv_branch)
+        base = self.managed_num_blocks + kv_branch_offset + start
         return list(range(base, base + count))
 
     def key_cache(self, layer_idx: int) -> torch.Tensor:
@@ -455,13 +549,13 @@ class ARDiffusionKVCache:
 
     def window_block_ids(self, adapter: ARDiffusionRequestAdapter) -> list[int]:
         """Resident (non-null) managed blocks visible to paged attention."""
-        return resident_block_ids(self.block_table(adapter), self.null_block_id)
+        return [int(block_id) for block_id in resident_block_ids(self.block_table(adapter), self.null_block_id)]
 
     def commit_chunk(self, adapter: ARDiffusionRequestAdapter) -> None:
         """Advance the adapter by one chunk after its K/V is written.
 
-        This standalone primitive is used by low-level manager tests. In the
-        DreamZero paged-attention path, :meth:`ARDiffusionKVState.commit_paged_context`
+        This standalone primitive is used by low-level manager tests. The
+        paged-attention path uses :meth:`ARDiffusionKVState.commit_paged_context`,
         advances the adapter only after the forward succeeds. Call once per
         committed chunk, not per denoise step.
         """
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py b/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
index a39a66b91..6b7d7ffe5 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/paged.py
@@ -153,7 +153,7 @@ def chunk_window_skipped_tokens(
     Pure function so the eviction policy is unit-testable without constructing a
     manager. Two strategies:
 
-    - ``reset_at_boundary`` (DreamZero): at each chunk boundary everything past
+    - ``reset_at_boundary``: at each chunk boundary everything past
       the sink is dropped.
     - otherwise (VGGT-style sliding replace): keep the last ``window`` tokens
       (plus the sink); the skip count snaps down to a chunk boundary so a chunk
@@ -184,6 +184,25 @@ class ChunkWindowManager(SlidingWindowManager):
             reset_at_boundary=spec.reset_at_boundary,
         )
 
+    def remove_skipped_blocks(
+        self,
+        request_id: str,
+        total_computed_tokens: int,
+        num_prompt_tokens: int | None = None,
+    ) -> None:
+        """Free the middle gap while preserving the leading attention sink."""
+        del num_prompt_tokens
+        num_skipped_tokens = self.get_num_skipped_tokens(total_computed_tokens)
+        if num_skipped_tokens <= 0:
+            return
+        sink_blocks = self.kv_cache_spec.sink_chunks
+        num_skipped_blocks = num_skipped_tokens // self.block_size
+        self._remove_blocks_in_range(
+            request_id,
+            sink_blocks,
+            sink_blocks + num_skipped_blocks,
+        )
+
 
 # Register so KVCacheManager resolves ChunkWindowSpec to ChunkWindowManager.
 # Dispatch walks the spec's MRO, so without explicit registration the subclass
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py b/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
index 2038e496d..bcd06b63a 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/paged_attention.py
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Paged self-attention helpers for AR-Diffusion DreamZero KV reuse."""
+"""Paged self-attention helpers for AR-Diffusion KV reuse."""
 
 from __future__ import annotations
 
@@ -10,7 +10,7 @@ import torch
 
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged import compute_slot_mapping
 
-# Set by ARDiffusionPagedForwardContext.prepare() before each branch forward and
+# Set by ARDiffusionPagedForwardContext.prepare() before each KV branch forward and
 # read by the fused write+attend custom op below. The pools are process-lifetime
 # allocations owned by one ARDiffusionKVCache per worker process (CFG-parallel /
 # TP ranks are separate processes), mirroring vLLM's forward-context pattern for
@@ -39,7 +39,7 @@ class ARDiffusionPagedLayerInputs(NamedTuple):
 
     A NamedTuple of plain tensors + ints so ``torch.compile`` treats every field
     as a pytree graph input (no object-attribute guards, no recompiles when only
-    tensor *values* change). All layers of one branch forward share the same
+    tensor *values* change). All layers of one KV branch forward share the same
     metadata tensor objects, built once by ``prepare()``.
 
     ``layer_idx`` is a 0-dim CPU tensor, NOT a python int: all 40 DiT blocks
@@ -62,11 +62,11 @@ class ARDiffusionPagedLayerInputs(NamedTuple):
 
 @dataclass
 class ARDiffusionPagedForwardContext:
-    """Mutable branch-level state shared by all layer contexts in one forward."""
+    """Mutable KV-branch state shared by all layer contexts in one forward."""
 
     kv_cache: Any
     adapter: Any
-    is_negative: bool
+    kv_branch: str
     history_block_ids: list[int]
     seq_len: int
     commit_current: bool
@@ -80,7 +80,7 @@ class ARDiffusionPagedForwardContext:
     _allocated_video: bool = False
     _committed: bool = False
     _action_len: int = 0
-    # Set once by prepare(); shared by all layers of the branch forward.
+    # Set once by prepare(); shared by all layers of the KV branch forward.
     block_table: torch.Tensor | None = None
     query_start_loc: torch.Tensor | None = None
     seq_lens: torch.Tensor | None = None
@@ -102,7 +102,7 @@ class ARDiffusionPagedForwardContext:
         return self.seq_len // self.block_size
 
     def ensure_video_slots(self, device: torch.device) -> None:
-        """Allocate/write targets for the current video tokens, once per branch."""
+        """Allocate/write targets for the current video tokens, once per KV branch."""
         if self._allocated_video:
             return
 
@@ -116,7 +116,7 @@ class ARDiffusionPagedForwardContext:
             positions = torch.arange(start, start + self.seq_len, dtype=torch.long)
             self.current_video_slot_mapping = compute_slot_mapping(table, positions, self.block_size).to(device=device)
         else:
-            self.current_video_block_ids = self.kv_cache.scratch_block_ids(self.is_negative, 0, n_blocks)
+            self.current_video_block_ids = self.kv_cache.scratch_block_ids(self.kv_branch, 0, n_blocks)
             positions = torch.arange(self.seq_len, dtype=torch.long)
             self.current_video_slot_mapping = compute_slot_mapping(
                 self.current_video_block_ids,
@@ -140,7 +140,7 @@ class ARDiffusionPagedForwardContext:
         action_blocks = (action_len + self.block_size - 1) // self.block_size
         scratch_offset = 0 if self.commit_current else len(self.current_video_block_ids)
         self.action_scratch_block_ids = self.kv_cache.scratch_block_ids(
-            self.is_negative,
+            self.kv_branch,
             scratch_offset,
             action_blocks,
         )
@@ -161,8 +161,15 @@ class ARDiffusionPagedForwardContext:
             )
         all_video_blocks = self.history_block_ids + self.current_video_block_ids
         max_video_blocks = self.max_video_tokens // self.block_size
-        visible_video_blocks = all_video_blocks[-max_video_blocks:] if max_video_blocks else []
-        video_len = min(len(all_video_blocks) * self.block_size, self.max_video_tokens)
+        sink_blocks = int(self.kv_cache.spec.sink_chunks)
+        if len(all_video_blocks) <= max_video_blocks:
+            visible_video_blocks = all_video_blocks
+        else:
+            tail_blocks = max_video_blocks - sink_blocks
+            visible_video_blocks = all_video_blocks[:sink_blocks]
+            if tail_blocks:
+                visible_video_blocks += all_video_blocks[-tail_blocks:]
+        video_len = len(visible_video_blocks) * self.block_size
         return visible_video_blocks, video_len
 
     def build_block_table(
@@ -201,9 +208,9 @@ class ARDiffusionPagedForwardContext:
         return block_table, query_start_loc, seq_lens, self.query_len, max_seq_len
 
     def prepare(self, device: torch.device, action_len: int, query_len: int) -> None:
-        """Host-side, once-per-branch-forward setup (called OUTSIDE torch.compile).
+        """Host-side, once-per-KV-branch setup (called OUTSIDE torch.compile).
 
-        Allocates the current video/action slots (still lazy: only the branch a
+        Allocates the current video/action slots (still lazy: only the KV branch a
         CFG-parallel rank actually runs reaches its ``_forward_blocks``), builds
         the padded block-table metadata ONCE for all layers, and publishes the
         pool registry for the fused custom op. The compiled per-layer code then
@@ -245,7 +252,7 @@ class ARDiffusionPagedForwardContext:
 
 @dataclass
 class ARDiffusionPagedLayerContext:
-    """Layer-specific handle passed through DreamZero's existing ``kv_cache`` slot."""
+    """Layer-specific handle passed through a model's ``kv_cache`` slot."""
 
     is_ar_diffusion_paged_context: ClassVar[bool] = True
     layer_idx: int
@@ -260,8 +267,8 @@ class ARDiffusionPagedLayerContext:
         return self.forward_ctx.adapter
 
     @property
-    def is_negative(self) -> bool:
-        return self.forward_ctx.is_negative
+    def kv_branch(self) -> str:
+        return self.forward_ctx.kv_branch
 
     @property
     def history_block_ids(self) -> list[int]:
diff --git a/vllm_omni/experimental/ar_diffusion/kv_cache/state.py b/vllm_omni/experimental/ar_diffusion/kv_cache/state.py
index 510bbe043..d114212bb 100644
--- a/vllm_omni/experimental/ar_diffusion/kv_cache/state.py
+++ b/vllm_omni/experimental/ar_diffusion/kv_cache/state.py
@@ -1,8 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
-"""DreamZero-facing AR-Diffusion KV bridge backed by paged self-attention."""
+"""Model-facing session state backed by paged AR-Diffusion KV storage."""
 
 from __future__ import annotations
 
+from collections.abc import Collection, Iterable, Mapping
+from typing import TYPE_CHECKING
+
+import torch
 from vllm.logger import init_logger
 
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged_attention import (
@@ -10,67 +14,79 @@ from vllm_omni.experimental.ar_diffusion.kv_cache.paged_attention import (
     ARDiffusionPagedLayerContext,
 )
 
+if TYPE_CHECKING:
+    from vllm_omni.experimental.ar_diffusion.kv_cache.manager import (
+        ARDiffusionKVCache,
+        ARDiffusionRequestAdapter,
+    )
+
 _log = init_logger(__name__)
 
 
 class ARDiffusionKVState:
-    """Per-request bridge between a DreamZero rollout and the AR-Diffusion KV pool.
+    """Runner-owned KV state for one session and any number of KV branches.
 
-    The self-attention path is paged-only: ``get_kv_caches`` returns lightweight
-    per-layer contexts, and each attention layer writes current K/V into the
-    pool before calling the FlashAttention block-table kernel.  No resident
-    window is gathered into a contiguous tensor.
+    KV branches are addressed by the names in ``ARDiffusionKVCacheSpec``. Each
+    branch owns an independent request adapter and therefore independent
+    resident self-attention blocks. Named cross-attention allocations are also
+    session-scoped and are released by :meth:`close`.
     """
 
-    def __init__(self, kv_cache, pos_adapter, neg_adapter, num_layers: int) -> None:
-        """One state per DreamZero session, holding BOTH CFG branches' adapters.
-
-        ``pos``/``neg`` are the classifier-free-guidance branches: ``pos`` is
-        the conditional pass (real prompt), ``neg`` the unconditional pass
-        (negative prompt). Each owns an independent request adapter — and
-        therefore independent pool blocks — because the two branches produce
-        different K/V for the same frames. Every ``is_negative`` flag in this
-        module selects between them (``False`` -> ``pos``, ``True`` -> ``neg``).
-        """
+    def __init__(
+        self,
+        kv_cache: ARDiffusionKVCache,
+        session_id: str,
+        adapters: Mapping[str, ARDiffusionRequestAdapter],
+        *,
+        num_layers: int,
+    ) -> None:
+        expected = tuple(kv_branch.name for kv_branch in kv_cache.kv_branches)
+        if set(adapters) != set(expected):
+            raise ValueError(
+                "AR-Diffusion session adapters must match the configured KV branches; "
+                f"expected {expected}, got {tuple(adapters)}"
+            )
         self.kv_cache = kv_cache
-        self.pos = pos_adapter
-        self.neg = neg_adapter
+        self.session_id = session_id
+        self.adapters = dict(adapters)
         self.num_layers = num_layers
-        self._committed: dict[bool, int] = {False: 0, True: 0}
-        self._paged_pending: dict[bool, ARDiffusionPagedForwardContext | None] = {False: None, True: None}
-        # Cross-attn KV is populated once after text encoding (eager), then
-        # read every denoising step. Tracked per half: the text K/V depend only
-        # on the session prompt (survive window-boundary resets), while the I2V
-        # image-token K/V come from the current observation's CLIP features and
-        # must be re-projected on every window restart.
-        self._cross_text_populated: dict[bool, bool] = {False: False, True: False}
-        self._cross_img_populated: dict[bool, bool] = {False: False, True: False}
+        self._committed: dict[str, int] = dict.fromkeys(expected, 0)
+        self._paged_pending: dict[str, ARDiffusionPagedForwardContext | None] = dict.fromkeys(expected)
+        self._closed = False
 
-    def _adapter(self, is_negative: bool):
-        return self.neg if is_negative else self.pos
+    @property
+    def kv_branch_names(self) -> tuple[str, ...]:
+        return tuple(self.adapters)
+
+    def adapter(self, kv_branch: str) -> ARDiffusionRequestAdapter:
+        """Return the request adapter for one logical KV branch."""
+        if self._closed:
+            raise RuntimeError(f"AR-Diffusion session {self.session_id!r} is closed")
+        try:
+            return self.adapters[kv_branch]
+        except KeyError as exc:
+            raise KeyError(f"Unknown AR-Diffusion KV branch {kv_branch!r}; expected {self.kv_branch_names}") from exc
 
     def get_kv_caches(
         self,
-        is_negative: bool,
+        kv_branch: str,
         seq_len: int | None = None,
         commit_current: bool = False,
     ) -> list[ARDiffusionPagedLayerContext]:
         if seq_len is None:
             raise ValueError("AR-Diffusion paged self-attention requires seq_len in get_kv_caches()")
-        return self.prepare_paged_context(is_negative, seq_len, commit_current)
+        return self.prepare_paged_context(kv_branch, seq_len, commit_current)
 
     def prepare_paged_context(
         self,
-        is_negative: bool,
+        kv_branch: str,
         seq_len: int,
         commit_current: bool,
     ) -> list[ARDiffusionPagedLayerContext]:
-        """Return per-layer paged attention contexts for one branch forward.
+        """Return per-layer paged attention contexts for one KV branch forward.
 
-        Allocation is lazy: constructing both CFG branches' kwargs must not
-        allocate manager blocks for a branch that a CFG-parallel rank will not run.
-        The first self-attn layer that consumes the context allocates the current
-        video slots, then all layers share that branch-level state.
+        Allocation is lazy so distributed workers allocate only for KV branches
+        they actually execute.
         """
         cs = self.kv_cache.spec.chunk_size
         if int(seq_len) % cs != 0:
@@ -78,25 +94,26 @@ class ARDiffusionKVState:
                 f"AR-Diffusion expects frame-aligned seq_len (multiple of chunk_size={cs}), got {seq_len}"
             )
 
-        pending = self._paged_pending.get(is_negative)
+        pending = self._paged_pending.get(kv_branch)
         if pending is not None and pending.commit_current and pending._allocated_video and not pending._committed:
             raise RuntimeError("AR-Diffusion paged context replaced before its managed current chunk was committed")
 
-        adapter = self._adapter(is_negative)
-        branch = "neg" if is_negative else "pos"
+        adapter = self.adapter(kv_branch)
         forward_ctx = ARDiffusionPagedForwardContext(
             kv_cache=self.kv_cache,
             adapter=adapter,
-            is_negative=is_negative,
+            kv_branch=kv_branch,
             history_block_ids=self.kv_cache.window_block_ids(adapter),
             seq_len=int(seq_len),
             commit_current=bool(commit_current),
-            max_video_tokens=int(self.kv_cache.spec.sliding_window),
+            max_video_tokens=int(
+                self.kv_cache.spec.sliding_window + self.kv_cache.spec.sink_chunks * self.kv_cache.spec.chunk_size
+            ),
         )
-        self._paged_pending[is_negative] = forward_ctx
+        self._paged_pending[kv_branch] = forward_ctx
         _log.debug(
-            "AR-Diffusion GET   [%s] source=paged-attn layers=%d history_blocks=%d seq_len=%d commit_current=%s",
-            branch,
+            "AR-Diffusion GET [%s] source=paged-attn layers=%d history_blocks=%d seq_len=%d commit_current=%s",
+            kv_branch,
             self.num_layers,
             len(forward_ctx.history_block_ids),
             int(seq_len),
@@ -104,80 +121,94 @@ class ARDiffusionKVState:
         )
         return [ARDiffusionPagedLayerContext(layer_idx=i, forward_ctx=forward_ctx) for i in range(self.num_layers)]
 
-    def commit_paged_context(self, is_negative: bool) -> None:
-        """Commit the managed current video blocks after a successful forward."""
-        ctx = self._paged_pending.get(is_negative)
+    def commit_paged_context(self, kv_branch: str) -> None:
+        """Commit managed current blocks after one successful KV branch forward."""
+        self.adapter(kv_branch)
+        ctx = self._paged_pending.get(kv_branch)
         if ctx is None:
             return
-        branch = "neg" if is_negative else "pos"
         if ctx.commit_current and ctx._allocated_video:
             n_chunks = ctx.seq_len // self.kv_cache.spec.chunk_size
             for _ in range(n_chunks):
                 ctx.adapter.on_chunk_committed()
-            self._committed[is_negative] += ctx.seq_len
+            self._committed[kv_branch] += ctx.seq_len
             _log.debug(
-                "AR-Diffusion COMMIT [%s] paged-attn new_tokens=%d chunks=%d resident=%d/%d",
-                branch,
+                "AR-Diffusion COMMIT [%s] new_tokens=%d chunks=%d resident=%d/%d",
+                kv_branch,
                 ctx.seq_len,
                 n_chunks,
                 len(self.kv_cache.window_block_ids(ctx.adapter)),
                 self.kv_cache.spec.window_chunks,
             )
         ctx.mark_committed()
-        self._paged_pending[is_negative] = None
+        self._paged_pending[kv_branch] = None
 
-    def get_cross_kv_caches(self, is_negative: bool) -> list[dict]:
-        """Return pool-backed cross-attn cache dicts.
+    def is_cross_attention_populated(self, kv_branch: str, cache_name: str) -> bool:
+        self.adapter(kv_branch)
+        return self.kv_cache.is_cross_attention_populated(self.session_id, cache_name, kv_branch)
 
-        Under AR-Diffusion the cross-attn pool is always populated by ``_kv_populate_cross``
-        before the first read, so this must never be reached unpopulated — if it
-        were, the model would lazily project and write cross KV itself, violating
-        engine ownership. Fail loud rather than fall back to the model.
+    def populate_cross_attention(
+        self,
+        kv_branch: str,
+        cache_name: str,
+        layer_kv: Iterable[tuple[torch.Tensor, torch.Tensor]],
+    ) -> None:
+        """Publish one named logical-branch cache after all layers are written.
+
+        The iterable is consumed once in layer order. If projection, validation,
+        or copying fails, the previous complete cache (if any) remains visible.
         """
-        img_ok = not self.kv_cache._cross_k_img or self._cross_img_populated[is_negative]
-        if not (self._cross_text_populated[is_negative] and img_ok and self.kv_cache.cross_attn_length > 0):
+        self.adapter(kv_branch)
+        self.kv_cache.populate_cross_attention(self.session_id, cache_name, kv_branch, layer_kv)
+
+    def get_cross_attention_kv(self, kv_branch: str, cache_name: str) -> list[dict[str, torch.Tensor | bool]]:
+        """Return all layers for one populated named cross-attention cache."""
+        if not self.is_cross_attention_populated(kv_branch, cache_name):
             raise RuntimeError(
-                f"AR-Diffusion cross-attn read before _kv_populate_cross (neg={is_negative}, "
-                f"cross_attn_length={self.kv_cache.cross_attn_length}, "
-                f"text={self._cross_text_populated[is_negative]} "
-                f"img={self._cross_img_populated[is_negative]}) — the engine must own all cross KV"
+                f"AR-Diffusion cross-attention cache {cache_name!r} for KV branch {kv_branch!r} "
+                "was read before it was populated"
             )
-        return [self.kv_cache.read_cross_kv(i, is_negative) for i in range(self.num_layers)]
+        return [
+            self.kv_cache.read_cross_attention_kv(self.session_id, cache_name, i, kv_branch)
+            for i in range(self.num_layers)
+        ]
 
     def close(self) -> None:
-        """Final teardown: free both branches' resident pool blocks."""
-        self.kv_cache.end_request(self.pos)
-        self.kv_cache.end_request(self.neg)
-        self._paged_pending = {False: None, True: None}
+        """Release all self- and cross-attention storage owned by this session."""
+        if self._closed:
+            return
+        for adapter in self.adapters.values():
+            self.kv_cache.end_request(adapter)
+        self.kv_cache.release_cross_attention(self.session_id)
+        self._paged_pending = dict.fromkeys(self.adapters)
+        self._closed = True
 
-    def reset(self, *, keep_cross_text: bool = False) -> None:
-        """Drop this session's KV — mirrors the model-local ``state.reset()``.
+    def reset(self, *, keep_cross_attention: Collection[str] = ()) -> None:
+        """Release resident blocks and reopen this session with fresh adapters.
 
-        DreamZero resets at the attention-window boundary (``should_reset``); the
-        model starts a fresh sliding window, so AR-Diffusion must free the resident pool
-        blocks and start a fresh adapter for each branch. The ``ARDiffusionKVState``
-        object (and thus ``pipeline._ar_diffusion_kv_state``) is preserved across the reset
-        so the runner's session mapping stays valid — only the pool-backed state
-        is recycled.
-
-        Args:
-            keep_cross_text: On window ("inference") resets the session prompt is
-                unchanged, so the text cross-attn K/V in the static pool buffers are
-                still valid — keep them and only force the image half to repopulate.
-                Session resets (prompt change / explicit reset) pass ``False``.
+        ``keep_cross_attention`` names allocations whose conditioning remains
+        valid across a model-internal window reset. Ordinary session reset
+        should leave it empty.
         """
-        pos_id, neg_id = self.pos.request_id, self.neg.request_id
-        self.close()
-        self.pos = self.kv_cache.begin_request(pos_id)
-        self.neg = self.kv_cache.begin_request(neg_id)
-        self._committed = {False: 0, True: 0}
-        self._paged_pending = {False: None, True: None}
-        if not keep_cross_text:
-            self._cross_text_populated = {False: False, True: False}
-        self._cross_img_populated = {False: False, True: False}
+        unknown = set(keep_cross_attention) - set(self.kv_cache.cross_attention_lengths)
+        if unknown:
+            raise KeyError(f"Unknown AR-Diffusion cross-attention caches to keep: {sorted(unknown)}")
+        request_ids = {kv_branch: adapter.request_id for kv_branch, adapter in self.adapters.items()}
+        if keep_cross_attention:
+            for adapter in self.adapters.values():
+                self.kv_cache.end_request(adapter)
+            self.kv_cache.retain_cross_attention(self.session_id, keep_cross_attention)
+        else:
+            self.close()
+        self.adapters = {
+            kv_branch: self.kv_cache.begin_request(request_id) for kv_branch, request_id in request_ids.items()
+        }
+        self._committed = dict.fromkeys(self.adapters, 0)
+        self._paged_pending = dict.fromkeys(self.adapters)
+        self._closed = False
         _log.info(
-            "AR-Diffusion RESET [%s/%s] session KV cleared (window boundary; cross text %s)",
-            pos_id,
-            neg_id,
-            "kept" if keep_cross_text else "cleared",
+            "AR-Diffusion RESET session=%s KV branches=%s kept_cross=%s",
+            self.session_id,
+            self.kv_branch_names,
+            sorted(keep_cross_attention),
         )
diff --git a/vllm_omni/experimental/ar_diffusion/runner.py b/vllm_omni/experimental/ar_diffusion/runner.py
index 862b3d9e8..31a23eaf7 100644
--- a/vllm_omni/experimental/ar_diffusion/runner.py
+++ b/vllm_omni/experimental/ar_diffusion/runner.py
@@ -1,31 +1,23 @@
 # SPDX-License-Identifier: Apache-2.0
-"""ARDiffusionModelRunner — the diffusion model runner for the AR-Diffusion engine.
-
-Subclasses ``DiffusionModelRunner`` and owns the engine-level KV cache
-(:class:`ARDiffusionKVCache`). It brackets a request's rollout with the KV lifecycle
-(``begin_request`` / ``end_request``) and exposes the live ``ARDiffusionKVCache`` so the
-model pipeline (DreamZero) can drive the per-chunk allocate / slot-mapping /
-gather / commit operations during ``pipeline.forward``.
-
-Selecting the AR-Diffusion engine enables KV management (no env gate); optional KV
-parameters come from the deploy yaml's ``model_config["ar_diffusion_kv_config"]``.
-"""
-
 from __future__ import annotations
 
 import dataclasses
-import math
 import time
 from collections import OrderedDict
 
-import numpy as np
 import torch
 from vllm.logger import init_logger
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.models.dreamzero.pipeline_dreamzero import MAX_DREAMZERO_SESSIONS
 from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput, KVPrefetchJob
 from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
+from vllm_omni.diffusion.worker.utils import BatchRunnerOutput
+from vllm_omni.experimental.ar_diffusion.capability import (
+    ARDiffusionKVCacheSpec,
+    SupportsARDiffusionPipeline,
+    SupportsARDiffusionWarmup,
+)
 from vllm_omni.experimental.ar_diffusion.kv_cache.config import ARDiffusionKVConfig
 from vllm_omni.experimental.ar_diffusion.kv_cache.manager import ARDiffusionKVCache
 from vllm_omni.experimental.ar_diffusion.kv_cache.state import ARDiffusionKVState
@@ -34,14 +26,7 @@ logger = init_logger(__name__)
 
 
 def resolve_ar_diffusion_kv_config(od_config: OmniDiffusionConfig) -> ARDiffusionKVConfig:
-    """Resolve the AR-Diffusion KV config from the deploy/command arg.
-
-    Selecting the AR-Diffusion engine implies KV management, so the result is always
-    enabled. Optional overrides (``window_chunks`` / ``gpu_memory_fraction`` /
-    ``sink_chunks`` / ``reset_at_boundary``) may be supplied via the deploy yaml as
-    ``model_config["ar_diffusion_kv_config"]``. ``chunk_size`` / ``window_chunks`` are
-    finalized from the model geometry at load (see ``_preallocate_kv_cache``).
-    """
+    """Resolve optional deployment overrides and enable AR-Diffusion KV."""
     raw = getattr(od_config, "ar_diffusion_kv_config", None)
     if raw is None:
         model_config = getattr(od_config, "model_config", None)
@@ -55,355 +40,280 @@ def resolve_ar_diffusion_kv_config(od_config: OmniDiffusionConfig) -> ARDiffusio
 
 
 class ARDiffusionModelRunner(DiffusionModelRunner):
-    def __init__(self, vllm_config, od_config: OmniDiffusionConfig, device) -> None:
+    """Own AR KV pools and session lifetime for a capable diffusion pipeline.
+
+    The runner never inspects model internals. At load time it consumes an
+    :class:`ARDiffusionKVCacheSpec`; during execution it binds a runner-owned
+    :class:`ARDiffusionKVState` through the pipeline's context manager. Sessions
+    persist across requests and end on explicit close, LRU eviction, or failed
+    forward. A request with ``extra_args["reset"]`` releases the old session
+    before executing with a fresh one.
+    """
+
+    _WARMUP_SID = "__ardiffusion_warmup__"
+    _MAX_RESIDENT_SESSIONS = 1
+
+    def __init__(self, vllm_config: object, od_config: OmniDiffusionConfig, device: torch.device) -> None:
         super().__init__(vllm_config, od_config, device)
         self.ar_diffusion_kv_config = resolve_ar_diffusion_kv_config(od_config)
-        # Built after the model is loaded (dimensions known); stays None while KV
-        # management is disabled.
         self.kv_cache: ARDiffusionKVCache | None = None
-        # DreamZero KV is session-scoped (persists across a session's forwards),
-        # so AR-Diffusion KV state is keyed by session_id and reused, not created per request.
-        # Bounded by the same LRU cap as DreamZeroPipeline._states: an evicted
-        # session's ARDiffusionKVState owns pool blocks (two CFG adapters), so without a
-        # bound, session-id churn in a long-running server would leak pool ownership
-        # until the KV pool is exhausted. Evicting frees those blocks (state.close()).
-        self._ar_diffusion_states: OrderedDict[str, ARDiffusionKVState] = OrderedDict()
-        self._max_ar_diffusion_states = MAX_DREAMZERO_SESSIONS
-        # Per-request server-side forward E2E times (seconds), recorded in
-        # execute_model. This is the worker-side compute time — the analog of the
-        # upstream server's per-request E2E — and excludes the engine<->worker IPC
-        # that the client's omni.generate wall time includes. Read (and cleared)
-        # by the ar_diffusion_perf_stats worker RPC for the perf-compare summary.
+        self._ar_diffusion_capability: SupportsARDiffusionPipeline | None = None
+        self._ar_diffusion_kv_cache_spec: ARDiffusionKVCacheSpec | None = None
+        self._sessions: OrderedDict[str, ARDiffusionKVState] = OrderedDict()
+        self._session_capacity = 0
         self._perf_e2e_times: list[float] = []
 
-    def build_kv_cache(
-        self,
-        *,
-        num_layers: int,
-        num_kv_heads: int,
-        head_size: int,
-        dtype,
-        block_size: int,
-        max_model_len: int,
-        available_bytes: int,
-        cross_attn_length: int = 0,
-        cross_attn_img_length: int = 0,
-        local_branches: int = 2,
-        num_frame_per_block: int = 1,
-    ) -> None:
-        """Construct the ARDiffusionKVCache (preallocating GPU pools on ``self.device``).
+    @staticmethod
+    def _require_capability(pipeline: object) -> SupportsARDiffusionPipeline:
+        if not isinstance(pipeline, SupportsARDiffusionPipeline):
+            raise TypeError(
+                "ARDiffusionEngine requires the loaded pipeline to implement "
+                "SupportsARDiffusionPipeline: ar_diffusion_kv_cache_spec(), "
+                "bind_ar_diffusion_state(), reset_ar_diffusion_session(), and "
+                "close_ar_diffusion_session(). Select the default DiffusionEngine "
+                "or add an explicit AR-Diffusion capability adapter to the model."
+            )
+        return pipeline
 
-        No-op when KV management is disabled.
-        """
-        if not self.ar_diffusion_kv_config.enable:
-            return
-        self.kv_cache = ARDiffusionKVCache(
-            self.ar_diffusion_kv_config,
-            num_layers=num_layers,
-            num_kv_heads=num_kv_heads,
-            head_size=head_size,
-            dtype=dtype,
-            block_size=block_size,
-            max_model_len=max_model_len,
-            available_bytes=available_bytes,
-            cross_attn_length=cross_attn_length,
-            cross_attn_img_length=cross_attn_img_length,
-            local_branches=local_branches,
-            num_frame_per_block=num_frame_per_block,
-            device=self.device,
-        )
-        logger.info(
-            "AR-Diffusion KV cache enabled: %d blocks, chunk_size=%d, window_chunks=%s, "
-            "layers=%d kv_heads=%d head_dim=%d block_size=%d cross_attn_len=%d device=%s",
-            self.kv_cache.num_blocks,
-            self.ar_diffusion_kv_config.chunk_size,
-            self.ar_diffusion_kv_config.window_chunks,
-            num_layers,
-            num_kv_heads,
-            head_size,
-            block_size,
-            cross_attn_length,
-            self.device,
-        )
-
-    # -- preallocation at load -------------------------------------------------
-
-    def load_model(self, *args, **kwargs):
+    def load_model(self, *args: object, **kwargs: object) -> None:
         super().load_model(*args, **kwargs)
-        if self.ar_diffusion_kv_config.enable and self.pipeline is not None:
-            self._preallocate_kv_cache()
-            # Pre-capture the CUDA graphs for every window-fill shape at load time
-            # (only when compiling/cuda-graph is on) so serving is fast from chunk 0.
-            if not self.od_config.enforce_eager and self.ar_diffusion_kv_config.warmup_cudagraph:
-                self._warmup_ar_rollout()
+        if self.pipeline is None:
+            return
+        self._preallocate_kv_cache()
+        if not self.od_config.enforce_eager and self.ar_diffusion_kv_config.warmup_cudagraph:
+            self._warmup_ar_rollout()
 
-    def _infer_frame_seqlen(self) -> int:
-        """frame_seqlen = (H//8)*(W//8)//4 from the configured image_resolution."""
-        mc = getattr(self.od_config, "model_config", None) or {}
-        psc = (mc.get("policy_server_config") if isinstance(mc, dict) else None) or {}
-        res = psc.get("image_resolution", [180, 320])
-        h, w = int(res[0]), int(res[1])
-        return (h // 8) * (w // 8) // 4
+    def _available_memory_bytes(self) -> int:
+        if self.device is None or torch.device(self.device).type != "cuda":
+            raise RuntimeError("AR-Diffusion KV preallocation currently requires a CUDA device")
+        return int(torch.cuda.mem_get_info(self.device)[0])
 
-    def _preallocate_kv_cache(self) -> None:
-        """Build the KV pool once, from the loaded DreamZero transformer geometry."""
-        # The paged self-attention path carries one rollout per request: slot
-        # mappings/adapters are single-sequence and K/V writes address batch
-        # index 0 only. Reject a multi-sequence config at init instead of
-        # failing (or silently dropping sequences) mid-forward.
+    def _preallocate_kv_cache(self, *, available_bytes: int | None = None) -> None:
+        """Build pools solely from the pipeline capability and runner config."""
+        if bool(getattr(self.od_config, "step_execution", False)):
+            raise ValueError(
+                "ARDiffusionModelRunner currently supports request-mode execution only; "
+                "step_execution=True would bypass per-request AR session binding."
+            )
         max_num_seqs = int(getattr(self.od_config, "max_num_seqs", 1) or 1)
         if max_num_seqs > 1:
             raise ValueError(
                 "AR-Diffusion paged KV supports max_num_seqs=1 (single-sequence "
-                f"rollouts); got max_num_seqs={max_num_seqs}. Per-sequence "
-                "adapters/slot maps are not implemented."
+                f"rollouts); got max_num_seqs={max_num_seqs}."
             )
-        t = self.pipeline.transformer
-        num_layers = int(t.num_layers)
-        num_kv_heads = int(getattr(t.blocks[0].self_attn, "tp_num_heads", t.num_heads))
-        head_size = int(t.dim // t.num_heads)
-        num_frame_per_block = int(t.num_frame_per_block)
-        local_attn_size = int(t.local_attn_size)
-        # The loaded transformer is the source of truth for frame_seqlen (it derives
-        # max_attention_size from it). The deploy-config inference is only a
-        # cross-check — warn on drift rather than silently sizing chunks wrong.
-        frame_seqlen = int(getattr(t, "frame_seqlen", 0)) or self._infer_frame_seqlen()
-        inferred = self._infer_frame_seqlen()
-        if frame_seqlen != inferred:
-            logger.warning(
-                "AR-Diffusion frame_seqlen mismatch: transformer=%d deploy-config=%d; using transformer",
-                frame_seqlen,
-                inferred,
+        capability = self._require_capability(self.pipeline)
+        if bool(getattr(self.pipeline, "supports_request_batch", False)):
+            raise ValueError(
+                "ARDiffusionModelRunner currently supports one request at a time; "
+                "request-batch execution would bypass per-request AR session binding."
+            )
+        spec = capability.ar_diffusion_kv_cache_spec()
+        if not isinstance(spec, ARDiffusionKVCacheSpec):
+            raise TypeError(
+                f"ar_diffusion_kv_cache_spec() must return ARDiffusionKVCacheSpec, got {type(spec).__name__}"
             )
-        # The model's own attention window, in tokens (= the [-max_attention_size:]
-        # slice it applies). Read it directly rather than recomputing.
-        max_attention_size = int(t.blocks[0].self_attn.max_attention_size)
-        # Cross-attn text length — static pool for the text-encoder output.
-        # The cached k/v spans the full text sequence (the image tokens
-        # prepended in _forward_blocks are stripped inside the cross-attn
-        # forward but are not part of the cached k/v).
-        cross_attn_length = int(getattr(t, "text_len", 0))
-        # I2V image-token cross-attn length: the model splits context[:, :257] as the
-        # image tokens (the img_emb(clip_feature) output), caching k_img/v_img. T2V: 0.
-        cross_attn_img_length = 257 if getattr(t, "model_type", "t2v") == "i2v" else 0
 
-        # Frame-granular paging: 1 block = 1 frame = frame_seqlen tokens, so the
-        # resident window matches max_attention_size exactly (it need not be a whole
-        # number of num_frame_per_block causal blocks).
-        chunk_size = frame_seqlen
-        window_chunks = self.ar_diffusion_kv_config.window_chunks or (max_attention_size // frame_seqlen)
-
-        self.ar_diffusion_kv_config = dataclasses.replace(
-            self.ar_diffusion_kv_config, chunk_size=chunk_size, window_chunks=window_chunks
+        config = dataclasses.replace(
+            self.ar_diffusion_kv_config,
+            chunk_size=spec.tokens_per_frame,
+            window_chunks=self.ar_diffusion_kv_config.window_chunks or spec.window_frames,
+            sink_chunks=self.ar_diffusion_kv_config.sink_chunks or spec.sink_frames,
+            reset_at_boundary=self.ar_diffusion_kv_config.reset_at_boundary or spec.reset_at_boundary,
         )
-        free_bytes = torch.cuda.mem_get_info(self.device)[0]
-        # Under CFG-parallel each rank executes exactly ONE branch (rank0 pos,
-        # rank1 neg; the other branch's lazy contexts never allocate on this
-        # rank), so its pool only needs one branch's capacity. A single-process
-        # run (cfg world 1) executes both branches from one pool.
-        try:
-            from vllm_omni.diffusion.distributed.parallel_state import (
-                get_classifier_free_guidance_world_size,
-            )
-
-            cfg_world = int(get_classifier_free_guidance_world_size())
-        except Exception:
-            cfg_world = 1
-        local_branches = 1 if cfg_world >= 2 else 2
-        logger.info(
-            "AR-Diffusion preallocating (paged): frame_seqlen=%d num_frame_per_block=%d "
-            "local_attn_size=%d -> chunk_size=%d window_chunks=%d (window=%d tokens)",
-            frame_seqlen,
-            num_frame_per_block,
-            local_attn_size,
-            chunk_size,
-            window_chunks,
-            window_chunks * chunk_size,
-        )
-        self.build_kv_cache(
-            num_layers=num_layers,
-            num_kv_heads=num_kv_heads,
-            head_size=head_size,
+        self.ar_diffusion_kv_config = config
+        self._ar_diffusion_capability = capability
+        self._ar_diffusion_kv_cache_spec = spec
+        self._session_capacity = min(spec.session_capacity, self._MAX_RESIDENT_SESSIONS)
+        self.kv_cache = ARDiffusionKVCache(
+            config,
+            num_layers=spec.num_layers,
+            num_kv_heads=spec.num_kv_heads,
+            head_size=spec.head_size,
             dtype=self.od_config.dtype,
-            block_size=chunk_size,  # one pool block per chunk
-            max_model_len=1 << 20,
-            available_bytes=free_bytes,
-            cross_attn_length=cross_attn_length,
-            cross_attn_img_length=cross_attn_img_length,
-            local_branches=local_branches,
-            num_frame_per_block=num_frame_per_block,
+            block_size=spec.tokens_per_frame,
+            max_model_len=spec.max_model_len,
+            available_bytes=self._available_memory_bytes() if available_bytes is None else available_bytes,
+            kv_branches=spec.kv_branches,
+            session_capacity=self._session_capacity,
+            cross_attention_lengths=spec.cross_attention_lengths,
+            frames_per_block=spec.frames_per_block,
+            max_scratch_tokens_per_branch=spec.max_scratch_tokens_per_branch,
+            device=self.device,
+        )
+        logger.info(
+            "AR-Diffusion KV cache: blocks=%d layers=%d local_kv_heads=%d head_size=%d "
+            "tokens/frame=%d frames/block=%d window=%d sink=%d kv_branches=%s cross=%s "
+            "resident_capacity=%d requested_capacity=%d",
+            self.kv_cache.num_blocks,
+            spec.num_layers,
+            spec.num_kv_heads,
+            spec.head_size,
+            spec.tokens_per_frame,
+            spec.frames_per_block,
+            config.window_chunks,
+            config.sink_chunks,
+            [(kv_branch.name, kv_branch.local_index) for kv_branch in spec.kv_branches],
+            spec.cross_attention_lengths,
+            self._session_capacity,
+            spec.session_capacity,
         )
 
-    def execute_model(self, req: OmniDiffusionRequest, kv_prefetch_jobs: dict | None = None) -> DiffusionOutput:
-        # KV disabled -> base behavior, unchanged.
-        if self.kv_cache is None:
-            return super().execute_model(req, kv_prefetch_jobs=kv_prefetch_jobs)
-
-        kv = self.kv_cache
-        # DreamZero KV is session-scoped (the model state persists across a
-        # session's forwards), so the AR-Diffusion KV state is keyed by session_id and
-        # reused — matching how pipeline.forward resolves the model-local state.
-        extra_args = req.sampling_params.extra_args or {}
-        session_id = str(extra_args.get("session_id") or "default")
-        state = self._ar_diffusion_states.get(session_id)
-        if state is None:
-            pos = kv.begin_request(f"bde__{session_id}")
-            neg = kv.begin_request(f"bde__{session_id}__neg")
-            state = ARDiffusionKVState(kv, pos, neg, num_layers=kv.num_layers)
-            self._ar_diffusion_states[session_id] = state
-            # Evict the least-recently-used session(s) past the cap, freeing their
-            # pool blocks — mirrors DreamZeroPipeline._states so the AR-Diffusion pool can't
-            # outlive the model-local state map it shadows.
-            while len(self._ar_diffusion_states) > self._max_ar_diffusion_states:
-                old_id, old_state = self._ar_diffusion_states.popitem(last=False)
-                old_state.close()
-                logger.debug("AR-Diffusion evicted session=%s (LRU); freed pool blocks", old_id)
-        # Track recency on every access (hit or miss) so the LRU order is correct.
-        self._ar_diffusion_states.move_to_end(session_id)
-        logger.debug(
-            "AR-Diffusion execute_model: req=%s session=%s chunk_size=%d window_chunks=%s num_blocks=%d",
-            req.request_id,
+    def _new_session_state(self, session_id: str) -> ARDiffusionKVState:
+        if self.kv_cache is None or self._ar_diffusion_kv_cache_spec is None:
+            raise RuntimeError("AR-Diffusion session requested before KV cache initialization")
+        adapters = {
+            kv_branch.name: self.kv_cache.begin_request(f"ar::{session_id}::{kv_branch.name}")
+            for kv_branch in self._ar_diffusion_kv_cache_spec.kv_branches
+        }
+        return ARDiffusionKVState(
+            self.kv_cache,
             session_id,
-            kv.spec.chunk_size,
-            kv.config.window_chunks,
-            kv.num_blocks,
+            adapters,
+            num_layers=self._ar_diffusion_kv_cache_spec.num_layers,
         )
-        self.pipeline._ar_diffusion_kv_state = state
-        # Time the worker-side forward (true per-request compute E2E). The CUDA
-        # sync below makes the stop reflect completed GPU work, not just dispatch.
-        _e2e_t0 = time.perf_counter()
+
+    def _release_session(
+        self,
+        session_id: str,
+        *,
+        reset_model: bool,
+        reason: str,
+        suppress_errors: bool = False,
+    ) -> None:
+        """One release path for reset, close, eviction, and failed forwards."""
+        state = self._sessions.pop(session_id, None)
+        errors: list[Exception] = []
+        if state is not None:
+            try:
+                state.close()
+            except Exception as exc:  # noqa: BLE001 - notify the pipeline even if pool cleanup fails
+                errors.append(exc)
+        capability = self._ar_diffusion_capability
+        if capability is not None:
+            try:
+                if reset_model:
+                    capability.reset_ar_diffusion_session(session_id)
+                else:
+                    capability.close_ar_diffusion_session(session_id)
+            except Exception as exc:  # noqa: BLE001 - preserve all lifecycle cleanup attempts
+                errors.append(exc)
+        logger.debug("AR-Diffusion released session=%s reason=%s", session_id, reason)
+        if errors:
+            if suppress_errors:
+                logger.warning(
+                    "AR-Diffusion session=%s cleanup after %s had %d error(s): %s",
+                    session_id,
+                    reason,
+                    len(errors),
+                    errors,
+                )
+            else:
+                raise errors[0]
+
+    def reset_session(self, session_id: str) -> None:
+        """Release KV and notify the pipeline to reset model-owned state."""
+        self._release_session(session_id, reset_model=True, reason="reset")
+
+    def close_session(self, session_id: str) -> None:
+        """Release KV and notify the pipeline to drop model-owned state."""
+        self._release_session(session_id, reset_model=False, reason="close")
+
+    def _get_or_create_session(self, session_id: str) -> ARDiffusionKVState:
+        state = self._sessions.get(session_id)
+        if state is None:
+            while len(self._sessions) >= self._session_capacity:
+                oldest = next(iter(self._sessions))
+                self._release_session(oldest, reset_model=False, reason="lru_eviction")
+            state = self._new_session_state(session_id)
+            self._sessions[session_id] = state
+        self._sessions.move_to_end(session_id)
+        return state
+
+    @staticmethod
+    def _request_session(req: OmniDiffusionRequest) -> tuple[str, dict]:
+        extra_args = req.sampling_params.extra_args or {}
+        return str(extra_args.get("session_id") or "default"), extra_args
+
+    def execute_model(
+        self,
+        req: OmniDiffusionRequest,
+        kv_prefetch_job: KVPrefetchJob | None = None,
+    ) -> DiffusionOutput:
+        if self.kv_cache is None:
+            return super().execute_model(req, kv_prefetch_job=kv_prefetch_job)
+        capability = self._ar_diffusion_capability
+        if capability is None:
+            raise RuntimeError("AR-Diffusion capability missing after KV cache initialization")
+
+        session_id, extra_args = self._request_session(req)
+        if extra_args.get("reset", False):
+            self.reset_session(session_id)
+        state = self._get_or_create_session(session_id)
+        started = time.perf_counter()
         try:
-            out = super().execute_model(req, kv_prefetch_jobs=kv_prefetch_jobs)
+            with capability.bind_ar_diffusion_state(session_id, state):
+                output = super().execute_model(req, kv_prefetch_job=kv_prefetch_job)
+            if self.device is not None and torch.device(self.device).type == "cuda":
+                torch.accelerator.synchronize(self.device)
         except Exception:
-            # Transactional containment: a forward that died partway may have
-            # written some layers' K/V into allocated-but-uncommitted blocks
-            # and advanced model-local state. Tear the whole session down
-            # (engine pool blocks freed via close(); model-local state dropped)
-            # so the next request with this session id starts clean instead of
-            # tripping the pending-commit guard or reading half-written KV.
-            broken = self._ar_diffusion_states.pop(session_id, None)
-            if broken is not None:
-                broken.close()
-            states = getattr(self.pipeline, "_states", None)
-            if states is not None:
-                states.pop(session_id, None)
+            self._release_session(
+                session_id,
+                reset_model=False,
+                reason="forward_exception",
+                suppress_errors=True,
+            )
             logger.warning(
-                "AR-Diffusion execute_model failed for session=%s; session state torn down "
-                "(pool blocks freed) — the next request starts a fresh session",
+                "AR-Diffusion forward failed for session=%s; KV and model state were released",
                 session_id,
             )
             raise
-        finally:
-            self.pipeline._ar_diffusion_kv_state = None
-        if self.device is not None and torch.cuda.is_available():
-            torch.accelerator.synchronize(self.device)
-        self._perf_e2e_times.append(time.perf_counter() - _e2e_t0)
-        return out
+        self._perf_e2e_times.append(time.perf_counter() - started)
+        if extra_args.get("close_session", False):
+            self.close_session(session_id)
+        return output
 
-    # -- cuda-graph warm-up ----------------------------------------------------
+    def execute_model_batch(
+        self,
+        scheduler_output: DiffusionSchedulerOutput,
+        od_config: OmniDiffusionConfig,
+    ) -> BatchRunnerOutput:
+        """Reject request batching until batch-aware AR state binding exists."""
+        raise RuntimeError(
+            "ARDiffusionModelRunner does not support request-batch execution; use request mode with max_num_seqs=1."
+        )
 
-    #: Dedicated session id for the warm-up rollout; cleaned from both state maps.
-    _WARMUP_SID = "__ardiffusion_warmup__"
-
-    def _synth_robot_obs(self, h: int, w: int, n_frames: int) -> dict:
-        """Zero-filled roboarena observation matching the client's obs layout.
-
-        Mirrors ``examples/.../client_schedule.make_obs_from_video`` (2 ext + wrist
-        cameras, 7/6/1 state vectors) so it survives ``_transform_robot_obs`` exactly
-        like a real request. One frame -> ``(H,W,3)``; chunk -> ``(n_frames,H,W,3)``.
-        """
-        img = np.zeros((h, w, 3), dtype=np.uint8) if n_frames == 1 else np.zeros((n_frames, h, w, 3), dtype=np.uint8)
-        return {
-            "observation/exterior_image_0_left": img,
-            "observation/exterior_image_1_left": img,
-            "observation/wrist_image_left": img,
-            "observation/joint_position": np.zeros(7, dtype=np.float32),
-            "observation/cartesian_position": np.zeros(6, dtype=np.float32),
-            "observation/gripper_position": np.zeros(1, dtype=np.float32),
-            "prompt": "warmup",
-            "session_id": self._WARMUP_SID,
-        }
+    def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> BatchRunnerOutput:
+        """Reject step execution until step-aware AR state binding exists."""
+        raise RuntimeError(
+            "ARDiffusionModelRunner does not support step execution; use request mode with step_execution=False."
+        )
 
     def _warmup_ar_rollout(self) -> None:
-        """Drive a synthetic rollout through one window-fill so every DiT graph is
-        captured at load (off the serving hot path). Frees the synthetic session and
-        leaves the KV pool exactly as found. Never raises — falls back to lazy capture.
-        """
-        from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-        kv = self.kv_cache
-        if kv is None:
+        """Run model-provided warmup requests, or safely skip when absent."""
+        if self.kv_cache is None or self.pipeline is None:
+            return
+        if not isinstance(self.pipeline, SupportsARDiffusionWarmup):
+            logger.info("AR-Diffusion pipeline provides no warmup requests; skipping rollout warmup")
             return
         sid = self._WARMUP_SID
-        t = self.pipeline.transformer
-        nfpb = int(t.num_frame_per_block)
-        window_chunks = int(kv.config.window_chunks or 0)
-        if window_chunks <= 0:
-            return
-        # Distinct DiT window shapes are walked by one fill: prefill + ceil((W-1)/nfpb)
-        # chunk forwards. +1 optionally to also capture the reset-cycle forward.
-        n_forwards = 1 + math.ceil(max(0, window_chunks - 1) / nfpb)
-        if self.ar_diffusion_kv_config.warmup_capture_reset:
-            n_forwards += 1
-        res = self._image_resolution()
-        h, w = int(res[0]), int(res[1])
-
-        free_before = kv.manager.block_pool.get_num_free_blocks()
-        # The step cache is left active: the DiT input shape is per-chunk (the resident
-        # window length), and the first denoise step of every chunk always computes, so
-        # every window shape is captured regardless of how many later steps are skipped.
-        logger.info(
-            "AR-Diffusion cudagraph warm-up: up to %d synthetic forwards (window_chunks=%d, nfpb=%d)",
-            n_forwards,
-            window_chunks,
-            nfpb,
-        )
+        free_before = self.kv_cache.manager.block_pool.get_num_free_blocks()
         try:
-            for i in range(n_forwards):
-                n_frames = 1 if i == 0 else 4  # client convention: 1-frame prefill, 4-frame chunks
-                obs = self._synth_robot_obs(h, w, n_frames)
-                sp = OmniDiffusionSamplingParams(extra_args={"reset": i == 0, "session_id": sid, "robot_obs": obs})
-                req = OmniDiffusionRequest(prompts=["warmup"], sampling_params=sp, request_id=f"ardiffusion-warmup-{i}")
-                self.execute_model(req)
-                # Stop once the resident window is full — the remaining shapes are
-                # already captured (the window caps/resets through the same set).
-                ar_state = self._ar_diffusion_states.get(sid)
-                if (
-                    not self.ar_diffusion_kv_config.warmup_capture_reset
-                    and ar_state is not None
-                    and len(kv.window_block_ids(ar_state.pos)) >= window_chunks
-                ):
-                    break
-        except Exception as e:  # noqa: BLE001 — warm-up must never break model load
-            logger.warning("AR-Diffusion cudagraph warm-up failed (%s); using lazy capture.", e)
+            for request in self.pipeline.ar_diffusion_warmup_requests(sid):
+                self.execute_model(request)
+        except Exception as exc:  # noqa: BLE001 - warmup must not make model load fail
+            logger.warning("AR-Diffusion rollout warmup failed (%s); using lazy capture", exc)
         finally:
-            # Free the synthetic session from BOTH maps (KV pool + pipeline state).
-            ar_state = self._ar_diffusion_states.pop(sid, None)
-            if ar_state is not None:
-                try:
-                    ar_state.close()  # return KV blocks to the BlockPool
-                except Exception as e:  # noqa: BLE001
-                    logger.warning("AR-Diffusion warm-up: state.close() failed (%s)", e)
-            try:
-                self.pipeline._states.pop(sid, None)
-            except Exception:  # noqa: BLE001
-                pass
-            # Drop any per-forward timings the warm-up recorded so serving stats start clean.
+            self._release_session(
+                sid,
+                reset_model=False,
+                reason="warmup_complete",
+                suppress_errors=True,
+            )
             self._perf_e2e_times.clear()
-            free_after = kv.manager.block_pool.get_num_free_blocks()
+            free_after = self.kv_cache.manager.block_pool.get_num_free_blocks()
             if free_after != free_before:
                 logger.warning(
-                    "AR-Diffusion warm-up: KV pool not restored (free %d -> %d) — possible leak",
+                    "AR-Diffusion warmup did not restore the KV pool (free %d -> %d)",
                     free_before,
                     free_after,
                 )
-            else:
-                logger.info(
-                    "AR-Diffusion cudagraph warm-up complete; KV pool restored (%d free blocks)",
-                    free_after,
-                )
-
-    def _image_resolution(self) -> list[int]:
-        mc = getattr(self.od_config, "model_config", None) or {}
-        psc = (mc.get("policy_server_config") if isinstance(mc, dict) else None) or {}
-        return psc.get("image_resolution", [180, 320])
diff --git a/vllm_omni/experimental/fullduplex/DESIGN.md b/vllm_omni/experimental/fullduplex/DESIGN.md
new file mode 100644
index 000000000..256214299
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/DESIGN.md
@@ -0,0 +1,1029 @@
+# MiniCPM-o 4.5 Full-Duplex Runtime Architecture
+
+## Purpose
+
+This document records the runtime architecture implemented by PR #3907, the
+cleanup applied after published commit `e011d936`, and the remaining work that
+must not be advertised as complete. Implemented contracts and future
+architecture work are called out separately below.
+
+The checkpoint preserves the active runtime path already exercised on H20. It does
+not introduce another reducer, controller, worker provider, or shadow runtime.
+
+## Review Snapshot
+
+- PR: `vllm-project/vllm-omni#3907`
+- Published head before this refactor: `e011d936`
+- Published base snapshot: `62589203`
+- Published diff: 93 files, approximately `+29.2k/-0.6k`
+- Local runtime and pytest validation: intentionally not used
+- Required validation environment: an NVIDIA H20 CUDA host
+- PR head reviewed for the current cleanup:
+  `f4f78fa555af4d65e46b003022d352ca2ea9d703`
+- Validated tree: the uncommitted refactor synchronized file-for-file to the
+  isolated H20 worktree on 2026-07-20
+
+The current tree has received fresh H20 focused and E2E validation against vLLM
+0.25.0. The final affected matrix includes the pre-response continuation and
+Stage1 CUDA Graph padding regressions. The checked-in MiniCPM profile admits
+two concurrent sessions through an engine-owned limit; a third
+session was rejected and capacity returned after one session closed. The two
+accepted sessions independently completed their audio, transcript, response,
+playback, and close lifecycles. This is isolation and admission evidence for the
+tested two-session deployment, not a production fairness, arbitrary-capacity,
+or failure-recovery claim. The validated paths include the experimental runtime
+extension, typed resumable policy, extracted control plane and clients, request
+preregistration, typed direct-output decision, engine-managed two-session
+capacity in the checked-in deploy profile, separate public/runtime configuration
+channels, private Session ledgers, ordered `session.update`, the MiniCPM runner
+fast path, continuous
+browser input, and the final Realtime input-lifecycle fixes. Exact evidence and
+scope limits are recorded below.
+
+## Scope
+
+The checkpoint keeps these verified contracts:
+
+- MiniCPM Stage0 conversation KV continuity;
+- Stage1 TTS and Token2Wav continuity;
+- model-owned listen/speak decisions on the normal auto-response path;
+- continuous browser PCM upload during assistant playback, without browser VAD
+  or browser-generated input commits;
+- segment EOS and turn EOS as different boundaries;
+- transcript/audio cursors scoped to a response and turn;
+- playback acknowledgement and history commit;
+- Stage0 request metadata routed per batch row rather than inherited from the
+  first request in the batch;
+- Stage0 token timing snapshots and client-observed audio chunk cadence;
+- scheduler data-plane append over a resumable request;
+- stale epoch/turn/response fencing;
+- `/v1/duplex` and OpenAI Realtime projection;
+- existing JoyVL behavior.
+
+The checkpoint does not claim:
+
+- scheduler-native KV append;
+- deterministic VAD-triggered interruption (the browser intentionally does not
+  run VAD; MiniCPM owns listen/speak decisions at model-unit boundaries);
+- production multi-session admission, fairness, capacity, or failure recovery;
+- bounded long-session KV;
+- video input or audio/video synchronization.
+
+## Active Runtime Path
+
+The actual path is:
+
+```text
+WebSocket
+  -> OmniDuplexSessionHandler
+  -> DuplexSession + MiniCPMO45ServingSessionState
+  -> DuplexRequestClient
+  -> AsyncOmni thin open/append/signal/close proxies
+  -> DuplexControlClient over the engine-owned correlated RPC transport
+  -> DuplexControlPlane + DuplexSessionRuntimeManager
+  -> experimental DuplexRuntimeExtension + engine session/stage bindings
+  -> StagePool
+  -> resumable scheduler request
+  -> MiniCPM Stage0
+  -> Stage1 TTS / Token2Wav
+  -> output processor
+  -> Realtime protocol projection
+  -> WebSocket writer
+```
+
+The removed typed reducer/facade and worker-provider runtimes were not in this
+path. This refactor continues to modify only the path above.
+
+## State Ownership
+
+The architecture allows several state objects only when their facts are
+orthogonal.
+
+| Owner | Authoritative facts |
+| --- | --- |
+| `DuplexSession` | session state, epoch, turn, active/last response, pending input, overlap duration, playback cursor, history |
+| `MiniCPMO45ServingSessionState` | MiniCPM PCM buffer, deferred overlap payload, data-plane task, continuation effect counter |
+| `DuplexWebSocketActor` | inbound mailbox, outbound queue, writer, transport close state, effect task handles |
+| `NativeRealtimeSessionProtocol` | wire-only response/item projection and input-buffer projection |
+| `DuplexSessionRuntimeManager` | fence snapshot, append reservation, completed-operation cache, resource reservations, stage bindings |
+| `DuplexControlPlane` | control-message validation, transactional open/append/update/close, extension invocation, typed segment/output decisions |
+
+Important distinctions:
+
+- Realtime response IDs are projection caches, not domain decision sources.
+- Engine fences duplicate identity across a process boundary by design; they
+  are immutable validation snapshots.
+- Stage bindings are engine resources, not serving response state.
+- `continuation_owner_id` scopes an effect counter either to a visible response
+  or, before `response.created`, to an explicit model turn. A pre-response
+  continuation also revalidates request, epoch, turn state, and model-turn
+  identity immediately before append; it cannot survive turn completion.
+- runtime open/close acknowledgements are handler-local effect bookkeeping,
+  not Session lifecycle.
+
+## Implemented Concurrency Contracts
+
+### Single inbound mailbox
+
+The Actor now uses one:
+
+```python
+asyncio.Queue[event]
+```
+
+This replaces competing control/input/event `Queue.get()` tasks and the
+deferred-event list while preserving WebSocket arrival order. A later close,
+cancel, or clear must not overtake earlier append, playback ACK, or
+session-update events. Slow runtime appends remain background tasks. Cancelling
+their asyncio task does not stop a synchronous callable already running in the
+default executor, so cancellation correctness is provided by the engine fence,
+not by `Task.cancel()`.
+
+Properties covered by focused tests:
+
+- every enqueued event is delivered exactly once;
+- terminal control preserves wire order while cancelling background work;
+- clear and cancel never scan or delete later mailbox events;
+- one writer owns all WebSocket sends.
+
+### Correlated RPC result router
+
+`AsyncOmniEngine` now has one consumer for `rpc_output_queue`. Results route by:
+
+```text
+("duplex", control_id)
+("collective", rpc_id)
+```
+
+The router replaces the global RPC lock. It supports out-of-order replies,
+timeout unregister, late-result rejection, fatal-error broadcast, and close
+unblocking.
+
+Additional lifecycle rules:
+
+- uncorrelated non-fatal errors are not broadcast to unrelated waiters;
+- a latched fatal rejects new calls before they enter the request queue;
+- `EngineDeadError` is broadcast directly to the RPC queue even though the
+  orchestrator consumes that exception during teardown;
+- shutdown closes the router before joining the orchestrator;
+- failure to enqueue shutdown closes the request queue and still attempts a
+  bounded orchestrator join;
+- `StageRuntime` cleanup runs only after the orchestrator has stopped, avoiding
+  concurrent client teardown.
+
+The router removes wait-side head-of-line blocking. The orchestrator request
+handler remains ordered, but executor submission order is not itself a session
+ordering guarantee.
+
+### Extracted control ownership
+
+The generic engine mechanism and the experimental duplex plugin are split by
+responsibility:
+
+| Module | Responsibility |
+| --- | --- |
+| `engine.messages` | ordinary engine queue messages and collective RPC envelopes |
+| `engine.rpc_result_router` | generic correlation routing through each result message's `rpc_correlation_key` |
+| `experimental.fullduplex.engine.contracts` | immutable duplex DTOs, extension/stage protocols, typed decisions, request-ID codec |
+| `experimental.fullduplex.engine.lease` | duplex lease activity, TTL/grace configuration, and expiry records |
+| `experimental.fullduplex.engine.messages` | identity fence and duplex control message/result envelopes |
+| `experimental.fullduplex.engine.duplex_runtime` | extension loading, validation, and compatibility exports |
+| `experimental.fullduplex.engine.duplex_session` | session resources, fences, append reservations, idempotency cache, binding cleanup |
+| `experimental.fullduplex.engine.duplex_control_plane` | control algorithms and the narrow `DuplexStagePort` used to submit and clean up stage requests |
+| `experimental.fullduplex.engine.duplex_control_client` | typed control-message construction and calls through the engine-owned correlated RPC transport |
+| `experimental.fullduplex.request_client` | deterministic request identity, client-state preregistration, acknowledgement validation, data-plane collection, rollback |
+
+`Orchestrator`, `AsyncOmniEngine`, and `AsyncOmni` retain explicit wiring and
+compatibility proxies. They no longer own the corresponding duplex algorithms.
+The ControlClient does not own waiters or consume the result queue;
+`RpcResultRouter` remains the single correlation owner for both duplex and
+collective RPC. The ControlPlane receives a narrow stage port rather than the
+Orchestrator object.
+
+Control-plane enablement is independent from extension presence.
+`PipelineConfig.duplex_control_enabled` determines whether an Orchestrator
+constructs a ControlPlane. This preserves extension-free
+`TURN_COMMIT_ONLY` deployments while allowing ordinary deployments to use a
+single `None` fast-path check. The MiniCPM pipeline explicitly enables control
+and separately selects its runtime extension.
+
+### Transactional open and append
+
+Opening a native session registers its engine state and reserves the Stage0
+request resource as one externally atomic operation. If capability, sampling,
+extension, or request-state initialization fails, the ControlPlane removes the
+session, reserved request resources, and any preregistered request state before
+returning the error. Cleanup distinguishes a reserved resource from a submitted
+request, so it does not decrement the running counter for unrelated work.
+Closing a session that never appended also removes the preregistered resource.
+
+Expiry and request-triggered cleanup use a two-step close. The runtime manager
+first marks the session closing but retains it in the admission set. Only a
+successful stage cleanup finalizes and removes the session. A blocked or failed
+cleanup therefore continues to consume its server-owned slot and is retried;
+replacement admission cannot overlap request or KV resources that are still
+owned by the closing session.
+
+Append uses prepare/submit/commit ordering. `prepare_append()` computes the
+next sequence values without mutating the session. Prompt planning and stage
+submission use that reservation, and only a successful submit commits
+`input_seq`, `input_turn_seq`, and the accepted fence. Serving uses a matching
+PCM reservation and consumes bytes only after the append acknowledgement;
+failure or a closed predecessor rolls the bytes back. An `operation_id` caches
+completed append results so a retry cannot submit the same physical append
+twice.
+
+### Ordered append and configuration effects
+
+Native append effects form a per-session tail. Each append awaits its
+predecessor before entering the engine, and `session.update` awaits that same
+tail before changing either the serving aggregate or engine configuration.
+Consequently, an append received before an update uses the old immutable
+sampling snapshot, while the first accepted append after the update uses
+the new generation.
+
+The engine increments `config_generation` when it accepts the replacement
+configuration. At the next append boundary, the control plane rebuilds sampling
+parameters from stage defaults through the model extension. It never mutates
+the snapshot of a segment already in progress.
+
+### Irreversible cancellation fence
+
+Every cancel control carries the cancelled fence and the next session fence.
+The `AsyncOmni` facade preserves both values across the serving,
+entrypoint, engine-message, and orchestrator boundaries. The orchestrator then
+atomically:
+
+1. advances the runtime state to the next fence;
+2. releases and aborts bindings owned by the cancelled fence;
+3. permanently rejects an append that arrives later with the old fence.
+
+Missing `next_fence` is rejected without releasing bindings; the engine never
+advances independently from serving. A late cancel cannot move a session
+backward when the runtime is already on a newer fence. Idle playback clear does
+not send an engine cancel because no runtime resource is being cancelled.
+
+`model_native_duplex` also validates its engine-client contract before opening
+the session. The open, append, signal, and close methods must exist and declare
+the required `fence` arguments; signal must additionally accept `next_fence`.
+An older or custom client that cannot preserve this boundary fails with
+`runtime_contract_invalid` instead of silently running an unfenced native
+session. The generic serving-session adapter retains its compatibility behavior.
+
+`DuplexFence` also carries a server-side session incarnation. Reusing a public
+session ID after close increments that incarnation, and resource request IDs
+include it after the first incarnation. A synchronous append from a closed
+session therefore cannot be accepted by a newly opened session with the same
+public ID. Stale close validates the full fence before removing the runtime
+registry entry or releasing bindings.
+
+## Implemented Serving Ownership
+
+### Session-owned response and overlap state
+
+The Actor no longer stores:
+
+- a Session reference;
+- lifecycle mirror state;
+- active or last response ID;
+- overlap duration;
+- response-in-progress or playback business predicates;
+- runtime open/close acknowledgements.
+
+`DuplexSession.begin_response()` owns both active and last response identity.
+The Session owns overlap accumulation/reset and playback state.
+
+One `native_response_in_progress()` predicate now covers:
+
+- active response ID;
+- active engine request ID;
+- uncommitted ACK-only playback;
+- active generic response task;
+- response-bound append tasks;
+- MiniCPM data-plane task;
+- assistant-generating turn state.
+
+The write-only `MiniCPMO45ServingSessionState.response_emitted` field and a dead
+data-plane task mirror were removed.
+
+### Response-scoped options
+
+`response.create` is represented by an immutable `ResponseCreateOptions` value.
+The Session reserves it for one response, applies it to a response-local copy
+when that response begins, and restores the base session configuration on
+completion, listen, cancellation, or failure. Instructions, voice, modalities,
+temperature, token limit, format, tools, and conversation metadata therefore do
+not mutate the permanent session configuration or leak into a later response.
+
+### Explicit event effects and pure writer
+
+Business paths call `emit_event()`. It serializes domain effects and outbound
+queue insertion with one session-local lock. Deferred append starts outside the
+lock so recursive event emission cannot deadlock.
+
+The writer only:
+
+1. dequeues an event;
+2. applies late stale filtering to streaming model output;
+3. projects the event to the selected wire protocol;
+4. sends JSON.
+
+The writer does not promote overlap, clear input, advance Session state, call
+the engine, or commit history.
+
+### Single terminal acceptance point
+
+Terminal events are accepted or rejected before domain effects run:
+
+```text
+response.done
+response.listen
+audio.cancelled
+input.cancelled
+session.closed
+```
+
+For a terminal carrying an epoch, that epoch must match the current Session.
+Stale cancellation therefore cannot reset overlap belonging to a later turn.
+Once a terminal is accepted and its effect is applied, the writer cannot revoke
+it because close or epoch state changed while it waited in the output queue.
+
+Streaming audio/text deltas still receive late stale filtering at send time,
+which prevents queued old audio from leaking after a cancel or epoch bump.
+
+## Runtime Type Boundary
+
+The stable kernel is deliberately limited to generic engine and scheduler
+mechanisms:
+
+```text
+vllm_omni.engine.messages                  # ordinary queue and collective RPC envelopes
+vllm_omni.engine.rpc_result_router         # generic correlation routing
+vllm_omni.engine.async_engine_utils        # ordinary engine lifecycle helpers
+```
+
+The full-duplex implementation remains experimental:
+
+```text
+vllm_omni.experimental.fullduplex.engine.duplex_runtime
+                                           # extension loading and validation
+vllm_omni.experimental.fullduplex.engine.contracts
+                                           # immutable DTOs and narrow protocols
+vllm_omni.experimental.fullduplex.engine.lease
+                                           # duplex lease primitives
+vllm_omni.experimental.fullduplex.engine.messages
+                                           # duplex identity and queue envelopes
+vllm_omni.experimental.fullduplex.engine.duplex_session
+                                           # session transaction implementation
+vllm_omni.experimental.fullduplex.engine.duplex_control_plane
+                                           # engine-side control algorithms
+vllm_omni.experimental.fullduplex.engine.duplex_control_client
+                                           # correlated control client
+vllm_omni.experimental.fullduplex.request_client
+                                           # entrypoint request/output lifecycle
+```
+
+Stable engine and entrypoint modules import only the kernel at module load.
+They load the experimental ControlPlane, ControlClient, request client, and
+runtime extension inside duplex-only construction or call paths. Importing
+`Orchestrator`, `AsyncOmniEngine`, or `AsyncOmni` for an ordinary deployment
+therefore does not import `vllm_omni.experimental.fullduplex`. Compatibility
+exports remain lazy and are not part of ordinary startup.
+
+`PipelineConfig.duplex_control_enabled` enables the generic mechanism, while
+`PipelineConfig.duplex_runtime_extension` separately selects the model adapter.
+The MiniCPM pipeline opts into both and installs
+`MiniCPMO45DuplexRuntimeExtension`; ordinary pipelines construct neither a
+ControlPlane nor a ControlClient. The model-neutral protocol exposes
+sampling-parameter configuration, append planning, and a typed stage-output
+decision. MiniCPM owns
+stage-specific overrides, PCM-to-token budgeting, force-listen payload policy,
+special-token interpretation, and `listen` response metadata. The generic
+Orchestrator does not parse MiniCPM session keys, `listen_token_id`, or construct
+MiniCPM metadata, and it does not import the adapter.
+
+Extension loading is fail-fast. Startup validates every required callable and
+the number and type of returned stage sampling parameters. Invalid custom
+extensions fail before a session can open.
+
+Direct listen/speak outcomes use `DuplexOutputDecision` on
+`OmniRequestOutput`. That typed envelope is authoritative over inner completion
+metadata for native projection, so a processed output cannot hide a listen
+decision merely because it retains unrelated multimodal metadata.
+
+Generic multimodal chunk accumulation lives in
+`vllm_omni.outputs.multimodal_accumulation`. It owns snapshot replacement,
+DELTA draining, and audio-finality interpretation; `OmniRequestState` only
+invokes that policy while assembling request output. Model output processors no
+longer need to add chunk-retention rules to the main output orchestration file.
+
+The strict chunk-transfer schema still contains `hidden_states.tts` as the
+generic AR-stage-to-TTS handoff and several MiniCPM streaming token IDs as
+compatibility wire fields. The latter are not a preferred generic model
+contract. Moving them behind a model-namespaced metadata envelope requires a
+versioned producer/consumer migration because unknown msgspec fields are
+rejected; silently deleting or renaming them in this checkpoint would break
+existing Stage0-to-Stage1 transfer.
+
+### Public and runtime configuration channels
+
+Control messages carry two independent snapshots:
+
+- `session_config` contains the public Realtime/session values used by serving
+  and model prompt policy;
+- `runtime_config` contains server-derived MiniCPM sampling, scheduler, context
+  reserve, prefix-budget, and resolved reference-audio values.
+
+The MiniCPM serving adapter derives `runtime_config` from deploy/model defaults
+and validated public options. Clients cannot provide private runtime keys in
+`session.create` or `session.update`; response-scoped `extra_body` drops those
+keys rather than turning them into engine policy. The ControlPlane constructs
+sampling parameters only from `runtime_config`,
+while append planning receives both snapshots explicitly. Raw Realtime
+`extra_body` is not used as the engine's sampling-policy channel.
+
+`session.update` prepares both candidates, validates the runtime candidate in
+the engine, and replaces the serving snapshots only after the engine ACK. A
+rejected candidate therefore leaves both the public configuration and runtime
+sampling generation unchanged.
+
+`DeployConfig.duplex_session` is an immutable, server-owned
+`DuplexSessionRuntimeConfig`. These limits are not read from client
+`extra_body` or session payloads:
+
+| Field | Default | Owner | Lifecycle or resource effect |
+|---|---:|---|---|
+| `idle_ttl_s` | `300.0` | Engine lease manager | Expires an attached or detached session after inactivity; `null` disables only idle expiry. |
+| `disconnect_grace_s` | `30.0` | Engine lease manager and API attachment registry | Bounds how long a detached session may retain engine resources before cleanup. |
+| `reaper_interval_s` | `5.0` | Orchestrator | Sets the cadence for lease expiry and pending cleanup retries. |
+| `resume_replay_ttl_s` | `60.0` | API attachment registry | Expires replay events retained for resume or takeover. |
+| `resume_replay_max_bytes_per_session` | `8388608` | API attachment registry | Bounds each session's replay buffer. |
+| `max_pending_input_bytes_per_session` | `16777216` | API session input ledger | Applies per-session byte backpressure before input is admitted. |
+| `max_pending_turns_per_session` | `4` | API session input ledger | Bounds queued turns that have not completed runtime processing. |
+| `max_sessions` | `1` | Engine session manager | Atomically enforces admission; closing sessions retain capacity until cleanup finalizes. |
+| `completed_append_cache_size` | `256` | Engine session manager | Bounds completed append idempotency records per session. |
+
+Deploy profiles may lower or raise these values to match scheduler capacity,
+but clients cannot override them. The engine remains authoritative for
+admission and cleanup ownership even when the API performs an early check.
+
+## Generic-Path Cleanup
+
+Model-specific `MINICPMO45_PROFILE_LOGS` probes were removed from:
+
+- the generic AR scheduler;
+- orchestrator;
+- AsyncOmni;
+- the generic GPU AR runner.
+
+The cleanup removes the temporary serving and generic-runtime probes. The
+generic AR runner builds `DuplexSamplingRow` values only when the model exposes
+the optional `prepare_duplex_sampling()` hook, then invokes that hook exactly
+once before the normal sampler. Ordinary models do not scan request rows.
+MiniCPM owns force-listen logits, turn-ended state, and its row-local sampling
+policy behind that hook; the runner no longer reads `_minicpmo45_*` attributes
+or retries sampling after matching `TypeError` text.
+
+The scheduler no longer parses serving `session_config`, `extra_body`, or
+`duplex_stage_sampling_params`. Stage-specific overrides are materialized as
+ordinary `SamplingParams` by the model runtime extension before scheduler
+admission. Existing vLLM stop-token, EOS, and max-token handling defines each
+segment boundary; `resumable=True` parks the request for the next streaming
+update. The scheduler does not inspect a duplex dictionary, Realtime
+configuration, or MiniCPM sampling fields.
+
+The generic runner's unused `_duplex_force_listen_applied_segments` cleanup and
+the obsolete `streaming_accumulated_keys` accumulation hook were removed. The
+latter had no model producer after its upstream Qwen removal; streaming input
+still performs the ordinary replacement merge needed by active models.
+
+Local `turn.signal` transitions such as `user_started` and
+`assistant_started` no longer perform an engine RPC. Only cancellation and
+`session.update` cross the engine boundary because those operations change
+runtime resource identity or runtime configuration.
+
+During a stage transition, `StreamingInputState.source_token_decoder` exposes a
+short-lived, model-neutral decoder sourced from the upstream output processor.
+The MiniCPM Stage1 input processor consumes that capability for token-faithful
+delta transcripts. The generic orchestrator no longer installs or names a
+MiniCPM-specific bridge-state key.
+
+The stable API server inspects the deployment `session_mode` before importing or
+constructing the experimental duplex handler. Ordinary deployments do not load
+the full-duplex serving package or create its registries and background state.
+For an enabled deployment, the client still selects the Realtime duplex route
+with `?duplex=1` (or an equivalent explicit true value). Model-name matching is
+not used for routing or native-runtime activation. MiniCPM clients explicitly
+set `extra_body.minicpmo45_native_duplex=true`; repository demos do so in their
+session payloads.
+
+`DuplexRequestClient` derives the data-plane request identity from the accepted
+fence and preregisters a resumable `ClientRequestState` before the append crosses
+the engine boundary. The acknowledgement must return the same identity or the
+operation fails. Unregistered outputs, including names that merely use the old
+`duplex-` prefix, are dropped. Timeout, cancel, and close remove the
+preregistered state.
+
+## Why Scheduler Changes Remain
+
+Serving cannot preserve model KV after a segment ends. The scheduler must keep
+one resumable request in a waiting state and accept a later update:
+
+```text
+RUNNING
+  -> segment stop
+WAITING_FOR_STREAMING_REQ  (KV retained)
+  -> next append
+RUNNING
+  -> session close
+FINISHED                   (KV released)
+```
+
+Scheduler responsibilities are limited to resumable request state, runtime
+context update, stop/boundary handling, and final release. Scheduler must not
+own response IDs, playback, overlap, Realtime events, or model policy.
+
+## Serving and Compatibility Boundaries
+
+### Normative Realtime event contract
+
+The public contract in this section applies to `/v1/realtime?duplex=1`. Internal
+duplex event names such as `response.output_audio.delta` are projection inputs,
+not additional public aliases. Events for one attachment preserve mailbox
+order; replay after resume preserves the original event order and `event_id`.
+
+Accepted compatibility aliases are normalized before mailbox admission:
+
+| Canonical input event | Accepted aliases | Contract |
+| --- | --- | --- |
+| `input.text.append` | `input_text.append`, `push_text` | Appends text to the open input item. |
+| `input_audio_buffer.append` | `input.audio.append`, `push_chunk` | Appends audio; legacy aliases default to WAV when no format is supplied. |
+| `turn.signal` | `signal_turn` | Sends an explicit turn signal; it does not imply response creation. |
+| `playback.ack` | `audio.playback_ack` | Advances playback/history only for the identified response and attachment. |
+| `session.close` | `close_session`, `close` | Closes the session after previously admitted mailbox events. |
+
+The Realtime projector emits the following response lifecycle. Cardinality is
+scoped to one `response_id` unless stated otherwise.
+
+| Public event | Trigger and ordering | Cardinality |
+| --- | --- | --- |
+| `response.created` | First event for a visible assistant response; precedes its output-item, content-part, speak, text, and audio events. | Exactly once for every visible response. |
+| `response.speak` | The model selected speak; emitted after `response.created` and no later than the first `response.audio.delta`. It carries decision metadata, not transcript text. | At most once. |
+| `response.audio.delta` | Carries one ordered audio chunk. Every emitted audio delta is followed by a `response.audio_transcript.delta` for the same chunk. | Zero or more. |
+| `response.audio_transcript.delta` | Append-only transcript contribution paired with an audio delta; it may be empty for a text-less audio unit and must not repeat or overlap earlier text. | One per audio delta. |
+| `response.audio.done` | Closes the audio stream after its final delta and before response terminal events. It is omitted for a response with no audio or transcript. | At most once. |
+| `response.audio_transcript.done` | Contains the exact concatenation of all non-overlapping transcript deltas for the response. | At most once, and only for a non-empty transcript. |
+| `response.output_item.done` / `conversation.item.done` | Finalize the assistant item after content-part terminal events and before `response.done`. | At most once each. |
+| `response.done` | Terminal event for a created response; follows audio, transcript, content-part, and item terminal events. | Exactly once for every created response that reaches a terminal state. |
+| `rate_limits.updated` | Compatibility event emitted immediately after `response.done`; the current payload has an empty rate-limit list. | Once per emitted `response.done`. |
+| `response.listen` | The model selected listen at a model-unit boundary. It may be emitted without `response.created`; clients must not infer a missing or pending response from it. | Zero or more per session, at most once per model-unit decision. |
+
+Session lifecycle events (`session.created`, `session.updated`,
+`session.resumed`, `session.replaced`, `session.expired`, and
+`session.resync_required`) are session-scoped rather than response-scoped.
+`session.created` is emitted before held response output on a new attachment.
+Cancellation and truncation use terminal status/details on the affected
+response and never reuse that response ID for later model turns.
+
+Compatibility changes must update this table and its protocol contract tests in
+the same change. The golden transcript test requires joined
+`response.audio_transcript.delta` values to equal
+`response.audio_transcript.done.transcript`; response tests separately enforce
+at-most-once `response.speak` and terminal event cardinality.
+
+### Session internal ledgers
+
+`DuplexSession` remains the serving aggregate root and now composes
+`InputBufferState`, `ResponseState`, `PlaybackLedger`, and
+`ConversationHistory`. The ledgers are private. Read-only properties return
+tuples, snapshots, or mapping proxies, and serving modules mutate them through
+Session transition methods for request, response-turn, lifecycle, playback,
+capability replacement, and history. The Realtime session-update parser still
+normalizes individual fields before atomically retaining or rolling back the
+aggregate configuration. Further work may narrow the read-only compatibility
+surface, but it must not introduce another reducer or a second session state
+machine.
+
+### Realtime input ownership
+
+The browser is a continuous PCM producer. While the session is open and the
+microphone is unmuted, it sends `input_audio_buffer.append` every 200 ms,
+including while assistant audio is being generated or played. It does not run
+VAD and does not send `input_audio_buffer.commit`. Native Stage0 consumes the
+stream in approximately one-second model units; MiniCPM listen, speak, and turn
+EOS decisions advance the model conversation.
+
+Explicit Realtime clients may still use `input_audio_buffer.commit` to create a
+conversation item. The translator validates that wire input before producing a
+commit carrying `realtime_item_id`. Native auto-response may already have
+streamed those PCM samples into the runtime, so the runner accepts a validated
+commit even when no runtime-side chunk remains. A truly empty explicit buffer
+continues to return `input_audio_buffer_empty`.
+
+The commit-to-response contract is:
+
+| Session state at `input_audio_buffer.commit` | Runtime action | Required event outcome |
+|---|---|---|
+| Auto-response disabled, valid idle input | Commit and retain the input item. | Emit `input_audio_buffer.committed`; emit no response until an explicit `response.create`. |
+| Auto-response enabled, valid idle speech | Submit the final native append for the current model turn. | Emit `input_audio_buffer.committed` before model output. Create a response only on the first visible text/audio output; a model listen decision may end with `response.listen` and no response. |
+| Auto-response enabled, short overlap during an active response | Discard the short overlap as an acknowledgement. | Emit the committed/no-response acknowledgement; do not create or defer a response. |
+| Auto-response enabled, meaningful overlap during an active response | Retain one deferred payload and promote it after the active response terminates. | Emit `input_audio_buffer.committed` with deferred metadata. A later response follows the same visible-output rule and never reuses the prior response ID. |
+| Explicit silence/noise (`is_speech=false`) | Clear the physical input without a runtime append. | Emit the committed/no-response acknowledgement followed by `response.listen`. |
+| Empty or invalid input | Reject without changing response ownership. | Emit one typed `error`; do not emit `response.created`. |
+| Previous response cancelled or truncated and cleanup complete | Apply the corresponding idle rule above. | The prior response remains terminal; any later visible output receives a new response ID. |
+
+Append tasks, explicit commits, cancellation, and deferred promotion are
+serialized by the session actor. Tests cover post-response commits, active
+playback deferral, truncated-response ownership, and two-turn
+response-required execution; the H20 validation record below is the golden
+multi-turn runtime evidence.
+
+During auto-response overlap, `preserve_realtime_input` distinguishes "do not
+append this silent chunk to the native buffer" from "clear the open Realtime
+item". Silent overlap no longer discards earlier user PCM. This is an input
+ownership correction. It does not add a VAD policy: overlap is admitted to
+Stage0 and the model decides whether to listen or speak.
+
+The first chunk of one overlapping input item also reserves its target model
+turn. A later Realtime commit uses that reserved identity even if response EOS
+has already advanced the Session turn; clear, cancel, close, and successful
+promotion release the reservation.
+
+### Physical input and model-turn identity
+
+A Realtime input item, an optional `input_audio_buffer.commit`, and a MiniCPM
+model turn are intentionally different identities. The browser normally keeps
+one input stream open without commits. Native Stage0 evaluates that stream in
+approximately one-second model units. A sampled `<|turn_eos|>` closes the
+current model turn and allows a later streamed unit to start another turn.
+Explicitly committed input may also produce only model-listen decisions and no
+spoken response.
+
+Therefore neither `model_turn_id` nor response cardinality is derived from the
+number of physical inputs. `model_turn_id` advances at model EOS. The
+`response-required` fixture may require exactly one response per requested
+turn, but `model-policy` validation must accept additional model-owned responses
+and cannot assert cross-turn transcript independence through physical-input
+attribution.
+Before closing, the model-policy demo drains every created response through
+`response.done`, acknowledges every completed audio playback, and requires a
+bounded quiet interval with no newly created response. This validates lifecycle
+completion without suppressing or overriding the model's listen/speak policy.
+
+### Non-cancel signal semantics
+
+`turn.signal` remains a public compatibility surface for local Session and
+Realtime transitions. Serving forwards only cancellation and `session.update`
+to the engine. The engine rejects arbitrary non-cancel signal names instead of
+returning a misleading supported acknowledgement. `session.update` remains a
+real engine operation because it replaces the configuration consumed by later
+append plans.
+
+## Remaining Architecture Work
+
+The following work is deliberately not hidden inside this checkpoint.
+
+### Serving composition
+
+The generic runner and runtime bridge now depend on the model-neutral
+`ServingRuntimeAdapter` protocol and no longer import MiniCPM modules. The
+`MiniCPMO45ServingRuntimeAdapter` owns MiniCPM serving state, PCM preparation,
+data-plane projection, client/runtime configuration validation, prefix policy,
+and capability projection. `PipelineConfig.duplex_serving_adapter` explicitly
+selects its import path; `AsyncOmniEngine` and `AsyncOmni` carry that path to the
+API server, which passes it into the generic handler. The handler has no model
+default and fails startup when the duplex endpoint is enabled without an
+adapter. Tests may inject an adapter instance directly. Import-boundary tests
+verify that loading the generic runner, bridge, or handler does not load MiniCPM
+modules.
+
+Behavior is still assembled through `DuplexSessionRunnerMixin`,
+`NativeRuntimeBridgeMixin`, and `ChatFallbackProjectorMixin`, so explicit
+adapter composition is only the model-policy boundary, not a completed removal
+of host-method coupling. A later refactor may replace the remaining mixins with
+explicit protocol and effect-runner dependencies while preserving one actor
+mailbox and one `DuplexSession` transition owner. Splitting those components
+must not create a second reducer or concurrent state machine.
+
+The four private Session ledgers are data partitions, not independent owners.
+`DuplexSession` intentionally remains the aggregate root. Further encapsulation
+may narrow compatibility properties, but serving code must continue to perform
+state changes through Session transitions.
+
+### Plugin descriptor and typed payloads
+
+The pipeline currently selects the MiniCPM engine extension and Serving adapter
+through two explicit fields, but there is not yet one versioned plugin descriptor
+that binds those identities in an open handshake. Realtime client payloads do
+not select either implementation. Adding a second native model should first
+introduce that descriptor and reject serving/engine plugin mismatches explicitly.
+
+The stable boundary has typed fences, plans, policies, decisions, and control
+messages, but `session_config`, `runtime_config`, and append payloads still use
+generic mappings or objects at the extension boundary. Model-neutral typed
+session and input-chunk contracts remain follow-up work, especially before
+adding video.
+
+### Output modality policy
+
+The current Realtime duplex contract supports text and audio output. Unknown
+output modalities fail closed with `unsupported_response_modality`; they are
+never silently projected as text. This checkpoint deliberately does not add a
+modality registry because there is only one native text/audio projection path
+to register.
+
+A registry becomes justified when a second non-audio/non-text implementation
+uses the same validation, encoding, lifecycle, and projection contract. At that
+point the abstraction must be extracted from two working adapters and retain
+the same fail-closed behavior. A speculative registry before that condition
+would add selection state without removing any existing branch.
+
+### Performance measurement contract
+
+Stage0 token timing comes only from the engine's per-segment metric snapshot:
+`vllm_ttft_ms`, `vllm_tpot_ms`, and `vllm_itls_ms`. A resumable Stage0 request
+exports its segment-local `num_generation_tokens`; ordinary requests retain the
+existing output-token fallback. Realtime response state clears its metric
+accumulator at `response.created`, combines only model units owned by that
+response, and ignores session-level events with no matching `response_id`.
+Realtime projection carries the result under
+`metadata.vllm_omni.stage_metrics`; clients do not estimate TPOT from transcript
+deltas or subtract cumulative snapshots.
+
+Audio timing uses the client's monotonic receive clock and is partitioned by
+`response_id`. `response_created_to_first_audio_ms` measures projection startup
+after `response.created`; `commit_to_first_audio_ms` measures end-to-end output
+from an explicit input commit. Neither field is called TTFP without naming its
+origin. Reports also include inter-chunk and chunk-duration
+count/mean/p50/p95/max plus maximum chunk gap. Engine and client measurements
+have different clock origins and must not be merged into one timeline.
+
+### Stage1 CUDA Graph boundary
+
+Native Stage1 streaming advances Python-owned request generators and turn
+state on every scheduler step. A full-model CUDA Graph would execute that
+Python control flow only while capturing and then replay stale chunk and turn
+metadata, even if its host-to-device tensor construction were made
+capture-safe. The duplex deploy profile therefore keeps `enforce_eager=false`
+but selects `cudagraph_mode=PIECEWISE` for Stage1. Python orchestration runs on
+every step while fixed-topology compiled regions remain eligible for CUDA
+Graph capture. This is a model execution constraint, not an E2E-only override.
+
+### Resource capabilities
+
+The checked-in MiniCPM duplex deploy profile sets Stage0 and Stage1
+`max_num_seqs` to two and configures the engine runtime manager with
+`max_sessions=2`. The Realtime capability response therefore advertises
+multi-session and same-replica multi-session support with
+`session_admission_mode="engine_managed"`. Client session fields cannot raise
+this server-owned limit. Fresh E2E evidence covers two concurrent sessions in
+both model-policy and response-required modes, rejection of a third session,
+and admission of a replacement after one accepted session closes. It does not
+establish behavior beyond that configured limit.
+
+Session leases, lease TTL, resumable attachment, orphan reaping, and bounded
+Serving input/backpressure are implemented. A production admission controller,
+KV-aware capacity budgeting, fairness, starvation metrics, and multi-session
+worker-failure recovery remain follow-up work. Capability claims must stay
+limited to the mechanisms and two-session execution shape validated here.
+
+## Validation Evidence
+
+All pytest and runtime evidence for this branch must run on the remote H20.
+
+### Current synchronized tree
+
+The current dirty tree was synchronized to the isolated H20 worktree at
+`/home/admin/workspace/aop_lab/model_runner_v2/vllm-omni-worktrees/pr3907-boundary-cg-0721`.
+
+- Final affected matrix: 661 passed, one network-dependent config test
+  deselected, 20 warnings. It includes the complete MiniCPM native-duplex hook
+  file and all control/session/handler/Orchestrator/import-boundary suites. The
+  run is task `be221f67` (`/tmp/remote_gpu_logs/be221f67.log`). The deselected
+  `test_resolve_when_autodetect_resolves_none` attempted a Hugging Face model
+  lookup and hung in the isolated environment; the duplex deploy-config test
+  passed independently.
+- Stage1 PIECEWISE CUDA Graph validation: the deploy-config assertion first
+  failed with no Stage1 compilation config, then passed in task `3ed6091d`.
+  Server task `95827027` started with `enforce_eager=False`, logged
+  `cudagraph_mode=PIECEWISE`, and captured batch sizes 1, 2, and 4 without the
+  CPU-to-CUDA capture error. The first concurrent E2E exposed graph padding as
+  `request_token_spans` covering three valid rows in a four-row capture. A
+  focused RED/GREEN now verifies both single-request and batched-request
+  padding, and the full MiniCPM hook file passed 47 tests in task `e89dba88`.
+  After the fix, two concurrent response-required sessions each completed two
+  spoken responses, playback acknowledgements, and history lifecycles with no
+  error or stale event. Artifacts are under
+  `/tmp/pr3907_piecewise_response_required_2x2_fixed_20260721`.
+- An exploratory two-session, two-turn model-policy run still left one session
+  waiting after its second input commit while the other session completed both
+  turns. The same liveness symptom was reproduced with Stage1 eager mode before
+  the padding fix, and no Stage1 fatal occurred after the fix. This run is not
+  counted as PIECEWISE acceptance evidence; the remaining Stage0 resumable
+  reactivation path requires separate diagnosis. Artifacts are under
+  `/tmp/pr3907_piecewise_model_policy_2x2_fixed_20260721`.
+- Latest broad affected matrix before the final pre-response continuation fix:
+  608 passed, 19 warnings. This includes the
+  Stage0 row-routing regression, cleanup-held admission regressions,
+  segment-local token accounting, response-owned metric filtering, the generic
+  output-processor suite, direct E2E script execution, and continuous-response
+  overlap ownership. The run is task `e2146318`
+  (`/tmp/remote_gpu_logs/e2146318.log`).
+- The pre-response continuation regression group passed 5 focused tests. The
+  response-required two-turn scenario then passed 5/5 repeated runs in task
+  two-session semantic isolation plus resume, takeover, and
+  admission passed in task `49225794`; model-unit overlap passed in task
+  `3888387d`. The final affected matrix above supersedes the earlier pending
+  rerun requirement.
+- Serving plugin selection was first reproduced as three RED tests: the generic
+  handler silently selected MiniCPM and the pipeline had no explicit Serving
+  adapter field. The final pipeline/import/fail-fast group passed 9 tests in task
+  `4db6d959` (`/tmp/remote_gpu_logs/4db6d959.log`). The token-metric and client
+  audio-cadence producer-to-consumer group passed 8 tests in task `cf80f6b2`
+  (`/tmp/remote_gpu_logs/cf80f6b2.log`).
+- Stable-import isolation was first reproduced as a RED that loaded twelve
+  `experimental.fullduplex` modules. After extracting the kernel and making
+  implementation loading conditional, the isolated import regression passed.
+  The focused ControlPlane/ControlClient/session/runtime/Orchestrator/AsyncOmni
+  suite then passed 139 tests in task `fad613ea`
+  (`/tmp/remote_gpu_logs/fad613ea.log`).
+  After the final contract-import cleanup, the import-boundary, runtime, and
+  lease suites passed 45 tests in task `bc138887`
+  (`/tmp/remote_gpu_logs/bc138887.log`).
+- Concurrency and failure-path hardening now has direct regressions for
+  single-flight cancel/close cleanup, cleanup retry without dropping request
+  resources, failed-replica affinity cleanup and same-address reattachment,
+  append ordering across resume, takeover ownership of pending-turn
+  reservations, and a closed-transport send immediately after resumable
+  credentials are delivered. The final focused resume/takeover group passed 5
+  tests in task `dc2ac96e` (`/tmp/remote_gpu_logs/dc2ac96e.log`).
+- Stage1 batching regression: the focused test first failed because only the
+  first request in `runtime_additional_information` reached the talker. After
+  routing every request by `request_token_spans`, preserving per-row terminal
+  flags, and emitting request-keyed sparse audio, the complete MiniCPM duplex
+  hook file passed 42 tests.
+- Stage0 batching regression: two requests in one batch now retain different
+  `duplex_prompt_token_ids` and `special_token_ids`. The model emits row-aligned
+  payload elements, so Stage0 no longer copies request zero's duplex metadata to
+  later sessions.
+- Admission finalization regressions cover `max_sessions=1` with blocked and
+  failed expiry cleanup plus request-triggered cleanup. Every replacement is
+  rejected with `resource_exhausted` until stage resources are cleaned and the
+  old session is explicitly finalized.
+- Resumable token accounting exports each model unit's native generation-token
+  count instead of recounting the request's cumulative token IDs. Realtime
+  response state resets and accumulates those segment snapshots, and the client
+  ignores unowned session-level metrics while summarizing a response.
+- Engine-owned admission and two-session model-policy E2E: two random session
+  IDs were admitted and remained isolated, a third was rejected with
+  `resource_exhausted`, closing one accepted session returned capacity, and a
+  random replacement session was admitted. The capability projection reported
+  `configured_limit=2`, `advertised_multi_session=true`, and
+  `session_admission_mode=engine_managed`. In the same run one session selected
+  speak and the other selected listen without identity leakage. Detach/resume
+  advanced attachment generation from one to two and rotated its token; active
+  takeover rejected all four writes from the replaced connection. The run is
+  task `1d9dd1ed` (`/tmp/remote_gpu_logs/1d9dd1ed.log`), with artifacts under
+  `/tmp/pr3907_resume_takeover_native_metrics`.
+- Concurrent two-session, two-turn response-required E2E: both sessions produced
+  two complete spoken responses, committed two playback acknowledgements and
+  history records, and emitted no error, cancel, truncate, or stale events. The
+  semantically distinct inputs produced isolated transcripts containing
+  "当时" and "一加一" respectively. Per-response Stage0 output counts were 20,
+  38, 32, and 33 tokens rather than cumulative request totals. The run is task
+  `a16f1467` (`/tmp/remote_gpu_logs/a16f1467.log`), with artifacts under
+  `/tmp/pr3907_semantic_2turn_native_metrics`.
+- Disconnect-grace E2E: a detached session expired after the configured
+  30-second engine grace, and a later resume was rejected with
+  `session_resume_expired`. The run is task `9872d50c`, with artifacts under
+  `/tmp/pr3907_0719_disconnect_grace_expiry`.
+- A separate black-box takeover client exercised the current backend with two
+  semantically distinct concurrent inputs. Active resume replayed 17 events
+  including five audio deltas and committed playback history; takeover rejected
+  all four stale-attachment sends, emitted `session.replaced`, and preserved
+  attachment/session isolation. Both transcripts contained only their expected
+  semantic token. The client task is `6773bd34`
+  (`/tmp/remote_gpu_logs/6773bd34.log`), with artifacts under
+  `/tmp/pr3907_gaohan_final_takeover`. The backend task was `5abcd1ee`.
+- Across the final response-required, overlap, and resume/takeover runs, engine
+  Stage0 TTFT ranged from 31.17 to 310.18 ms, TPOT from 15.18 to 21.18 ms, and
+  reported ITL p95 from 16.35 to 32.83 ms. Explicit
+  `commit_to_first_audio_ms` ranged from 386.80 to 1033.25 ms, while the
+  client-monotonic maximum audio chunk gap ranged from 388.30 to 1316.37 ms.
+  These are response-scoped observations from a small, warm-state-sensitive
+  sample, not an SLO claim. The slowest response still does not satisfy a 200 ms
+  end-to-end first-output target.
+- Post-merge focused handler/demo/Web/Stage0/runner/video suite: 324 passed,
+  19 warnings. The run is task `f78cb7a8`
+  (`/tmp/remote_gpu_logs/f78cb7a8.log`). The Web contract explicitly rejects
+  browser VAD markers and browser-generated input commits while the merged
+  video path retains camera-frame admission.
+- No-response listen and residual accounting: the focused handler regressions
+  passed after first reproducing both failures. A model-listen unit without a
+  Realtime response no longer defers the next committed input, and three
+  consecutive 1.2-second `pcm_f32le` inputs each returned pending input bytes
+  to zero.
+- Model-unit overlap E2E: the second physical input streamed while the first
+  response remained active. Seven overlap decisions had
+  `defer_runtime_append=false`; the one-second model-unit boundary occurred
+  before the first `response.done`, and no barge-in, cancel, truncate, stale, or
+  error event occurred. The model-policy contract accepts a later unit ending
+  the continuous response instead of requiring a second physical-input-owned
+  response. The two response-owned Stage0 snapshots independently reported 20
+  tokens / 152.8 ms TTFT and 19 tokens / 43.3 ms TTFT. The run is task
+  `a4977622` (`/tmp/remote_gpu_logs/a4977622.log`), with artifacts under
+  `/tmp/pr3907_overlap_native_metrics_scoped`.
+- The split multi-session E2E runner is directly executable from the repository
+  even when another installed package owns the top-level `tests` name. Its
+  script-import and continuous-terminal regressions passed in task `f11b106c`.
+- Pinned response-required E2E: the first 1400 ms of the pinned fixture produced
+  one complete spoken response, five audio/transcript deltas, and one playback
+  history commit, with symmetric created/audio-done/done lifecycle and no
+  duplicate `response.speak`. The client task is `a76dec52`
+  (`/tmp/remote_gpu_logs/a76dec52.log`).
+- Continuous-input model-policy E2E: 36 browser-like 200 ms chunks produced
+  seven model-listen decisions with zero input commits and no
+  error/cancel/truncate/stale events. The client task is `fb256595`; artifacts
+  are in `/tmp/minicpmo_pr3907_continuous_model_policy_20260718`.
+- Three-response continuous-input E2E: three consecutive 9469 ms streams,
+  composed of the original fixture plus four seconds of silence, produced three
+  spoken responses in one session. All three completed `response.done`, audio
+  transcript, playback ACK, and history commit; the run had 22 audio/transcript
+  deltas, zero input commits, and no error/cancel/truncate/stale events. This is
+  lifecycle evidence, not semantic cross-input independence, because the same
+  fixture was repeated. The client task is `2a5f29f0`; artifacts are in
+  `/tmp/minicpmo_pr3907_continuous_three_response_20260718`.
+- The fresh validation backend was stopped after the E2E runs and GPU0/1 returned
+  to baseline. Audio-quality and ASR evaluation were not rerun for these
+  lifecycle-only changes. Other GPU workloads were not modified.
+
+### Regression lineage
+
+Earlier synchronized checkpoints passed broader affected matrices before the
+extension, policy, and ledger consolidation. Those runs were useful while
+developing the refactor but are superseded by the current file-identical H20
+matrix and E2E evidence above; they are intentionally omitted to avoid mixing
+different trees in the acceptance argument.
+
+### Focused suites
+
+- RPC router and AsyncOmni shutdown/error routing;
+- orchestrator fatal and duplex control paths;
+- WebSocket Actor mailbox and writer;
+- duplex protocol and Session ownership;
+- Realtime handler, terminal ordering, overlap, playback ACK;
+- scheduler resumable boundary;
+- MiniCPM runner and Stage0/Stage1 lifecycle.
+
+### E2E contract
+
+Run two deliberately separate fixture contracts:
+
+- model-policy uses three distinct inputs, no transcript hints, 200 ms
+  real-time pacing, and continuous input with no browser commit. It allows
+  natural listen or speak decisions and assumes no 1:1 mapping between
+  physical inputs, model turns, and responses;
+- response-required uses `minicpmo_pr3907_jiayan_16k.wav` pinned to SHA-256
+  `2e5fd4eb3ee434ce107ee3a0591fa624a33f7683c7462f45fe651c443c9af941`,
+  sends its first 1400 ms, and requires one complete spoken response.
+  It is an output-lifecycle fixture, not evidence that arbitrary no-hint,
+  real-time input must select speak;
+- late and old-response playback ACK handling in the affected test matrix;
+- final model-policy response drain before `session.close`;
+- close/disconnect with no post-terminal audio;
+- transcript delta/final consistency;
+- generated WAV validity and external ASR sanity.
+
+Distinct-input fixtures must also be semantically distinct. Different files or
+waveform hashes containing the same greeting can legitimately produce the same
+reply and are not sufficient evidence for cross-turn transcript independence.
+
+For each run record the exact SHA/worktree, command, server log, client log,
+WAV path, and cleanup result.
+
+## Acceptance Criteria
+
+This checkpoint is ready to publish only when:
+
+- one mailbox passes exactly-once and wire-order tests;
+- cancel advances the engine fence even when the old append continues in an
+  executor, and the next-epoch append remains accepted;
+- request completion removes MiniCPM helper and model-owned force-listen state;
+- RPC fatal/close wakes every waiter and no new work enters after terminal;
+- Session is the only serving response/overlap authority;
+- stale terminal events cannot mutate a newer epoch;
+- an accepted terminal cannot be dropped by the writer;
+- no duplicate `response.speak` or transcript delta appears;
+- Stage0 KV continuity and Stage1 turn reset pass;
+- the real H20 multi-turn audio E2E passes;
+- ordinary non-duplex paths in the affected matrix still pass;
+- no local path, proxy token, temporary profiling probe, or test-only switch is present.
+
+Passing this checkpoint supports the statement:
+
+> Single-session, model-owned MiniCPM-o 4.5 native duplex is reviewable on the
+> validated H20 configuration.
+
+It does not support claims for deterministic VAD-triggered interruption,
+multi-session production concurrency, bounded long-session KV,
+scheduler-native append, or video input.
diff --git a/vllm_omni/experimental/fullduplex/README.md b/vllm_omni/experimental/fullduplex/README.md
index 7f9e22fa6..e08c5ee1c 100644
--- a/vllm_omni/experimental/fullduplex/README.md
+++ b/vllm_omni/experimental/fullduplex/README.md
@@ -1,80 +1,55 @@
-# Full-duplex interaction framework
+# Experimental Full-Duplex Runtime
 
-A model-agnostic framework for real-time, full-duplex (streaming-in / streaming-out)
-model interaction, plus the JoyVL implementation built on it.
+This package contains three experimental integrations:
 
-To **run the JoyVL model**, see the recipe:
+- the existing JoyVL framework and example integration;
+- the MiniCPM-o 4.5 native audio path used by `/v1/duplex` and
+  `/v1/realtime?duplex=1`;
+- the PersonaPlex lockstep speech-to-speech path (browser demo + batched
+  serving, see `recipes/NVIDIA/PersonaPlex.md`).
+
+For the MiniCPM active runtime path, lifecycle invariants, capability boundary,
+Realtime response contract, and validation scope, see [`DESIGN.md`](DESIGN.md).
+
+To run JoyVL, see
 [`recipes/JD/JoyAI-VL-Interaction.md`](../../../recipes/JD/JoyAI-VL-Interaction.md).
-This README covers the framework itself and how to add a new model.
 
-## Layout
+## Package boundaries
 
-```
-vllm_omni/experimental/fullduplex/
-  core/      generic full-duplex framework (model-agnostic): DuplexRuntime (event
-             loop + epoch barge-in), DuplexSession, DuplexAdapter (ABC), protocol
-  joyvl/     JoyVL implementation (model-specific):
-             adapter.py            JoyVLDuplexAdapter (implements core.DuplexAdapter)
-             decision/             policy + output_parser + prompts (speak/silence/delegate)
-             memory/               InteractionBrain — 3-tier summary memory (async)
-             serving/              OpenAI-compatible HTTP orchestrator
-             bridges/              model backend + delegation
+```text
+core/        model-agnostic duplex contracts (adapter, session, turn runtime)
+engine/      AsyncOmni/orchestrator scheduler data-plane adapter
+openai/      WebSocket transport, Realtime projection, and audio codecs
+minicpmo45/  MiniCPM input framing, policy, compatibility, and Stage0 state
+joyvl/       JoyVL model-specific integration
+personaplex/ PersonaPlex lockstep engine, model-owned runtime, and serving
 ```
 
-`core/` is the only part shared across models; data planes differ by model and are
-intentionally not shared.
+MiniCPM does not run through the experimental `core.DuplexRuntime`
+facade. Its active path uses the `openai` session controller, the experimental
+engine contracts, the standard scheduler/model runners, and an injected
+MiniCPM-specific runtime extension from `minicpmo45/runtime.py`.
 
-## Scope
+`personaplex/` is a Moshi-class, pure-lockstep speech-to-speech model on the
+`core/` contracts. It keeps `core/` untouched: the lockstep lifecycle (ONE
+eternal, frame-clocked response that drains on close, instead of the turn-style
+start/cancel-per-trigger one) is model policy and lives in the model package as
+`PersonaPlexDuplexRuntime`, mirroring the model-owned runtime shape of the
+MiniCPM-o duplex work. Its runnable serving path is `personaplex/serving/`
+(single-session lease or `--batch-size` elastic slots) over
+`personaplex/session.py` (lockstep driver).
 
-The runnable serving path is `joyvl/serving/` driving `decision/` + `memory/` directly.
-`joyvl/adapter.py` + `core/` are a **demonstration** of how a model plugs into the
-generic full-duplex framework (exercised by `tests/fullduplex/`), not the serving path
-the HTTP orchestrator currently uses — a fused-audio model (e.g. MiniCPM-o) is the case
-`core/` is built for.
+## Adding a full-duplex model on the core contracts
 
-## Adding a full-duplex model
+The seam is `core.DuplexAdapter`. `core/` owns the session lifecycle,
+epoch-based barge-in, playback cursor, and the event protocol; you implement
+only model policy.
 
-The seam is `core.DuplexAdapter`. `core/` owns the session lifecycle, epoch-based
-barge-in, playback cursor, and the event protocol — you implement only model policy.
-
-1. Create a sibling package `vllm_omni/experimental/fullduplex/<model>/` next to `joyvl/`; keep
+1. Create a sibling package `vllm_omni/experimental/fullduplex/<model>/`; keep
    model-specific code there and do not touch `core/`.
-2. Implement one `DuplexAdapter` (three required methods; the rest have defaults):
-
-   ```python
-   from collections.abc import AsyncIterator
-   from vllm_omni.experimental.fullduplex.core.adapter import DuplexAdapter, DuplexCapability, OutputChunk
-   from vllm_omni.experimental.fullduplex.core.session import DuplexSession
-
-   class MyModelAdapter(DuplexAdapter):
-       def capabilities(self) -> DuplexCapability:
-           return DuplexCapability(
-               input_modalities=frozenset({"audio", "text"}),
-               output_modalities=frozenset({"audio", "text"}),
-               proactive=True,            # speak without being asked?
-           )
-
-       async def on_input(self, session: DuplexSession, modality: str, data) -> None:
-           ...                            # buffer/route an incoming chunk
-
-       async def respond(self, session: DuplexSession) -> AsyncIterator[OutputChunk]:
-           async for piece in self._model_stream(session):
-               yield OutputChunk(modality="audio", data=piece)   # runtime drops stale
-               #                                                   chunks after a barge-in
-
-       # optional: should_respond / on_barge_in / on_playback_ack
-   ```
-
-3. Run it through the shared runtime — no new control-plane code:
-
-   ```python
-   from vllm_omni.experimental.fullduplex.core.runtime import DuplexRuntime
-   from vllm_omni.experimental.fullduplex.core.session import DuplexSession, DuplexSessionConfig
-
-   rt = DuplexRuntime(DuplexSession("sid", DuplexSessionConfig()), MyModelAdapter())
-   await rt.run(input_events, emit)
-   ```
-
-`joyvl/adapter.py` is the worked demonstration (currently exercised by tests, not the
-HTTP serving path). Promote a helper from a model package up into `core/` only once a
-second model actually needs it.
+2. Implement one `DuplexAdapter` (`capabilities` / `on_input` / `respond`; the
+   rest have defaults). Turn-based models run through `core.DuplexRuntime`
+   unchanged; a model needing a different lifecycle carries its own runtime in
+   its package (see `personaplex/adapter.py::PersonaPlexDuplexRuntime`).
+3. Promote a helper from a model package up into `core/` only once a second
+   model actually needs it.
diff --git a/vllm_omni/experimental/fullduplex/client.py b/vllm_omni/experimental/fullduplex/client.py
new file mode 100644
index 000000000..57cc2f700
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/client.py
@@ -0,0 +1,417 @@
+"""Reusable Realtime WebSocket, PCM, and event helpers for MiniCPM-o demos."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import math
+import time
+import wave
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+try:
+    import websockets
+    from websockets.exceptions import ConnectionClosed
+except ImportError as exc:  # pragma: no cover - example dependency
+    raise SystemExit("Install websockets first: pip install websockets") from exc
+
+PCM16_SAMPLE_RATE = 16_000
+PCM16_BYTES_PER_SAMPLE = 2
+
+
+def _rounded_ms(value: float) -> float:
+    return round(float(value), 3)
+
+
+def _interval_summary(values: list[float]) -> dict[str, float | int]:
+    clean = sorted(_rounded_ms(value) for value in values if math.isfinite(value) and value >= 0)
+    if not clean:
+        return {"count": 0, "mean": 0.0, "p50": 0.0, "p95": 0.0, "max": 0.0}
+
+    def nearest_rank(percentile: float) -> float:
+        index = max(0, math.ceil(percentile * len(clean)) - 1)
+        return clean[min(index, len(clean) - 1)]
+
+    return {
+        "count": len(clean),
+        "mean": _rounded_ms(sum(clean) / len(clean)),
+        "p50": nearest_rank(0.50),
+        "p95": nearest_rank(0.95),
+        "max": clean[-1],
+    }
+
+
+def _event_stage_metrics(event: dict[str, object]) -> dict[str, object] | None:
+    candidates: list[object] = [event.get("vllm_omni")]
+    metadata = event.get("metadata")
+    if isinstance(metadata, dict):
+        candidates.extend((metadata, metadata.get("vllm_omni")))
+    response = event.get("response")
+    if isinstance(response, dict):
+        response_metadata = response.get("metadata")
+        if isinstance(response_metadata, dict):
+            candidates.extend((response_metadata, response_metadata.get("vllm_omni")))
+    for candidate in candidates:
+        if not isinstance(candidate, dict):
+            continue
+        stage_metrics = candidate.get("stage_metrics")
+        if isinstance(stage_metrics, dict):
+            return stage_metrics
+    return None
+
+
+def build_realtime_url(
+    url: str,
+    model: str,
+    *,
+    autostart: bool | None = None,
+    session_id: str | None = None,
+) -> str:
+    """Add the explicit native-duplex query parameters to a Realtime URL."""
+    parts = urlsplit(url)
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query.setdefault("duplex", "1")
+    query.setdefault("model", model)
+    query.setdefault("minicpmo45_native_duplex", "1")
+    if autostart is not None:
+        query.setdefault("autostart", "1" if autostart else "0")
+    if session_id:
+        query.setdefault("session_id", session_id)
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+
+
+def read_pcm16_wav(path: Path) -> bytes:
+    """Read a mono, uncompressed, 16 kHz PCM16 WAV file."""
+    with wave.open(str(path), "rb") as wav_file:
+        if wav_file.getnchannels() != 1:
+            raise ValueError("input WAV must be mono")
+        if wav_file.getsampwidth() != PCM16_BYTES_PER_SAMPLE:
+            raise ValueError("input WAV must be 16-bit PCM")
+        if wav_file.getframerate() != PCM16_SAMPLE_RATE:
+            raise ValueError("input WAV must be 16 kHz")
+        if wav_file.getcomptype() != "NONE":
+            raise ValueError("input WAV must be uncompressed PCM")
+        return wav_file.readframes(wav_file.getnframes())
+
+
+def write_pcm16_wav(path: Path, pcm16: bytes, *, sample_rate_hz: int) -> None:
+    """Write mono PCM16 bytes as a WAV artifact."""
+    with wave.open(str(path), "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(PCM16_BYTES_PER_SAMPLE)
+        wav_file.setframerate(sample_rate_hz)
+        wav_file.writeframes(pcm16)
+
+
+async def wait_for(
+    predicate: Callable[[], bool],
+    *,
+    timeout_s: float,
+    label: str,
+) -> None:
+    """Wait for a collector predicate without coupling to a scenario runner."""
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if predicate():
+            return
+        await asyncio.sleep(0.02)
+    raise TimeoutError(f"Timed out waiting for {label}")
+
+
+@dataclass
+class RealtimeEventCollector:
+    """Collect server events and decode response audio by response identity."""
+
+    events: list[dict[str, object]] = field(default_factory=list)
+    event_received_at_s: list[float] = field(default_factory=list)
+    response_audio: dict[str, list[bytes]] = field(default_factory=dict)
+    response_ids: list[str] = field(default_factory=list)
+    output_sample_rate_hz: int = 24_000
+
+    @staticmethod
+    def response_id(event: dict[str, object]) -> str | None:
+        response_id = event.get("response_id")
+        if isinstance(response_id, str):
+            return response_id
+        response = event.get("response")
+        if isinstance(response, dict):
+            response_id = response.get("id")
+            if isinstance(response_id, str):
+                return response_id
+        return None
+
+    def add(self, event: dict[str, object], *, received_at_s: float | None = None) -> None:
+        received_at = time.monotonic() if received_at_s is None else float(received_at_s)
+        stored_event = dict(event)
+        stored_event.setdefault("_client_received_at_s", received_at)
+        self.events.append(stored_event)
+        self.event_received_at_s.append(received_at)
+        response_id = self.response_id(stored_event)
+        event_type = stored_event.get("type")
+        if event_type == "response.created" and response_id and response_id not in self.response_ids:
+            self.response_ids.append(response_id)
+        if event_type == "response.audio.delta":
+            delta = stored_event.get("delta") or stored_event.get("audio")
+            if isinstance(delta, str) and response_id:
+                try:
+                    self.response_audio.setdefault(response_id, []).append(base64.b64decode(delta))
+                except ValueError:
+                    pass
+            sample_rate_hz = stored_event.get("sample_rate_hz")
+            if isinstance(sample_rate_hz, int) and sample_rate_hz > 0:
+                self.output_sample_rate_hz = sample_rate_hz
+
+    def count(self, event_type: str) -> int:
+        return sum(event.get("type") == event_type for event in self.events)
+
+    def audio_bytes(self, response_id: str | None = None) -> bytes:
+        if response_id is not None:
+            return b"".join(self.response_audio.get(response_id, ()))
+        return b"".join(
+            chunk for response_id in self.response_ids for chunk in self.response_audio.get(response_id, ())
+        )
+
+    def errors(self) -> list[dict[str, object]]:
+        return [event for event in self.events if event.get("type") == "error"]
+
+    def first_received_at(
+        self,
+        *event_types: str,
+        after_s: float = 0.0,
+    ) -> float | None:
+        for event, received_at_s in zip(self.events, self.event_received_at_s, strict=True):
+            if received_at_s >= after_s and event.get("type") in event_types:
+                return received_at_s
+        return None
+
+    def last_received_at(self, event_type: str) -> float | None:
+        for event, received_at_s in zip(
+            reversed(self.events),
+            reversed(self.event_received_at_s),
+            strict=True,
+        ):
+            if event.get("type") == event_type:
+                return received_at_s
+        return None
+
+    def timing_summary(
+        self,
+        *,
+        after_s: float,
+        input_committed_at_s: float | None = None,
+        response_id: str | None = None,
+    ) -> dict[str, object]:
+        """Summarize engine token metrics and client-observed audio cadence."""
+        stage0_metrics: dict[str, object] | None = None
+        response_created_at_s: float | None = None
+        audio_received_at_s: list[float] = []
+        cumulative_audio_ms: list[float] = []
+        for event, received_at_s in zip(self.events, self.event_received_at_s, strict=True):
+            if received_at_s < after_s:
+                continue
+            event_response_id = self.response_id(event)
+            if response_id is not None and event_response_id != response_id:
+                continue
+            if event.get("type") == "response.created" and response_created_at_s is None:
+                response_created_at_s = received_at_s
+
+            stage_metrics = _event_stage_metrics(event)
+            stage0 = stage_metrics.get("0") if isinstance(stage_metrics, dict) else None
+            if isinstance(stage0, dict):
+                stage0_metrics = stage0
+
+            if event.get("type") != "response.audio.delta" or (
+                response_id is not None and event_response_id != response_id
+            ):
+                continue
+            delta = event.get("delta") or event.get("audio")
+            if not isinstance(delta, str) or not delta:
+                continue
+            audio_received_at_s.append(received_at_s)
+            metadata = event.get("metadata")
+            duration_ms = metadata.get("audio_duration_ms") if isinstance(metadata, dict) else None
+            if isinstance(duration_ms, int | float) and math.isfinite(float(duration_ms)):
+                cumulative_audio_ms.append(max(0.0, float(duration_ms)))
+
+        result: dict[str, object] = {}
+        if stage0_metrics is not None:
+            raw_itls = stage0_metrics.get("vllm_itls_ms")
+            itls = (
+                [float(value) for value in raw_itls if isinstance(value, int | float)]
+                if isinstance(raw_itls, list)
+                else []
+            )
+            result["stage0_tokens"] = {
+                "source": "engine_stage_metrics",
+                "output_token_count": int(stage0_metrics.get("num_tokens_out") or 0),
+                "ttft_ms": float(stage0_metrics.get("vllm_ttft_ms") or 0.0),
+                "tpot_ms": float(stage0_metrics.get("vllm_tpot_ms") or 0.0),
+                "inter_token_interval_ms": _interval_summary(itls),
+            }
+
+        if audio_received_at_s:
+            intervals_ms = [
+                (current - previous) * 1000.0 for previous, current in zip(audio_received_at_s, audio_received_at_s[1:])
+            ]
+            chunk_durations_ms: list[float] = []
+            previous_duration_ms = 0.0
+            for duration_ms in cumulative_audio_ms:
+                chunk_durations_ms.append(
+                    duration_ms - previous_duration_ms if duration_ms >= previous_duration_ms else duration_ms
+                )
+                previous_duration_ms = duration_ms
+            interval_summary = _interval_summary(intervals_ms)
+            result["audio_output"] = {
+                "source": "client_monotonic_receive",
+                "chunk_count": len(audio_received_at_s),
+                "response_created_to_first_audio_ms": (
+                    _rounded_ms((audio_received_at_s[0] - response_created_at_s) * 1000.0)
+                    if response_created_at_s is not None
+                    else None
+                ),
+                "commit_to_first_audio_ms": (
+                    _rounded_ms((audio_received_at_s[0] - input_committed_at_s) * 1000.0)
+                    if input_committed_at_s is not None
+                    else None
+                ),
+                "inter_chunk_interval_ms": interval_summary,
+                "chunk_duration_ms": _interval_summary(chunk_durations_ms),
+                "max_chunk_gap_ms": interval_summary["max"],
+            }
+        return result
+
+
+class RealtimeDuplexClient:
+    """Small async client used by the user demo and reusable smoke probes."""
+
+    def __init__(self, url: str, *, max_size: int = 64 * 1024 * 1024) -> None:
+        self.url = url
+        self.max_size = max_size
+        self.events = RealtimeEventCollector()
+        self._ws: Any = None
+        self._reader_task: asyncio.Task[None] | None = None
+
+    async def __aenter__(self) -> RealtimeDuplexClient:
+        self._ws = await websockets.connect(self.url, max_size=self.max_size)
+        self._reader_task = asyncio.create_task(self._read_events())
+        return self
+
+    async def __aexit__(self, exc_type, exc, traceback) -> None:
+        if self._ws is not None:
+            await self._ws.close()
+        if self._reader_task is not None:
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except asyncio.CancelledError:
+                pass
+
+    async def _read_events(self) -> None:
+        try:
+            while True:
+                raw = await self._ws.recv()
+                if not isinstance(raw, str):
+                    continue
+                event = json.loads(raw)
+                if isinstance(event, dict):
+                    self.events.add(event)
+        except ConnectionClosed:
+            return
+
+    async def send(self, event: dict[str, object]) -> None:
+        await self._ws.send(json.dumps(event))
+
+    async def configure(
+        self,
+        model: str,
+        *,
+        output_audio_format: str = "pcm16",
+        ref_audio: str | None = None,
+        session_id: str | None = None,
+        timeout_s: float = 20.0,
+    ) -> None:
+        session: dict[str, object] = {
+            "model": model,
+            "modalities": ["audio", "text"],
+            "input_audio_format": "pcm16",
+            "output_audio_format": output_audio_format,
+            "turn_detection": None,
+            "overlap_policy": "listen_only",
+            "playback_commit_policy": "ack_only",
+            "extra_body": {
+                "auto_response": True,
+                "minicpmo45_native_duplex": True,
+                "force_listen_count": 0,
+            },
+        }
+        if ref_audio is not None:
+            session["ref_audio"] = ref_audio
+        if session_id:
+            session["session_id"] = session_id
+        await self.send({"type": "session.update", "session": session})
+        await wait_for(
+            lambda: self.events.count("session.created") > 0,
+            timeout_s=timeout_s,
+            label="session.created",
+        )
+
+    async def stream_pcm16(
+        self,
+        pcm16: bytes,
+        *,
+        chunk_ms: int = 200,
+        realtime: bool = True,
+    ) -> None:
+        chunk_bytes = max(
+            PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * chunk_ms // 1000,
+            PCM16_BYTES_PER_SAMPLE,
+        )
+        audio_end_ms = 0
+        for offset in range(0, len(pcm16), chunk_bytes):
+            chunk = pcm16[offset : offset + chunk_bytes]
+            duration_ms = len(chunk) * 1000 // (PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE)
+            audio_end_ms += duration_ms
+            await self.send(
+                {
+                    "type": "input_audio_buffer.append",
+                    "audio": base64.b64encode(chunk).decode("ascii"),
+                    "input_audio_format": "pcm16",
+                    "sample_rate_hz": PCM16_SAMPLE_RATE,
+                    "duration_ms": duration_ms,
+                    "audio_end_ms": audio_end_ms,
+                }
+            )
+            if realtime:
+                await asyncio.sleep(duration_ms / 1000)
+
+    async def commit(self) -> None:
+        await self.send({"type": "input_audio_buffer.commit", "final": True})
+
+    async def acknowledge_playback(self) -> None:
+        for response_id in self.events.response_ids:
+            pcm16 = self.events.audio_bytes(response_id)
+            if not pcm16:
+                continue
+            played_ms = len(pcm16) * 1000 // (self.events.output_sample_rate_hz * PCM16_BYTES_PER_SAMPLE)
+            await self.send(
+                {
+                    "type": "playback.ack",
+                    "response_id": response_id,
+                    "item_id": f"item_{response_id}",
+                    "played_ms": played_ms,
+                    "committed_ms": played_ms,
+                }
+            )
+
+    async def close_session(self, *, timeout_s: float = 20.0) -> None:
+        await self.send({"type": "session.close"})
+        await wait_for(
+            lambda: self.events.count("session.closed") > 0,
+            timeout_s=timeout_s,
+            label="session.closed",
+        )
diff --git a/vllm_omni/experimental/fullduplex/engine/__init__.py b/vllm_omni/experimental/fullduplex/engine/__init__.py
new file mode 100644
index 000000000..c8e20437f
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/__init__.py
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Engine-side helpers for the experimental full-duplex runtime."""
diff --git a/vllm_omni/experimental/fullduplex/engine/contracts.py b/vllm_omni/experimental/fullduplex/engine/contracts.py
new file mode 100644
index 000000000..ae449e82f
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/contracts.py
@@ -0,0 +1,276 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Model-neutral contracts for the experimental duplex engine plugin.
+
+This module contains only immutable data transfer objects and narrow protocols.
+Duplex control algorithms, session implementations, model policy, and Realtime
+serving remain in sibling experimental modules.
+"""
+
+from __future__ import annotations
+
+import base64
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from types import MappingProxyType
+from typing import Any, Protocol
+
+from vllm_omni.engine.messages import EngineQueueMessage
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+
+class SessionMode(str, Enum):
+    TURN = "turn"
+    DUPLEX = "duplex"
+
+
+class DuplexInputMode(str, Enum):
+    APPEND_TOKENS = "append_tokens"
+    APPEND_AUDIO_CHUNK = "append_audio_chunk"
+    REPLACE_LATEST_CHUNK = "replace_latest_chunk"
+    REENCODE_CONTEXT = "reencode_context"
+    ROLLBACK_TO_CHECKPOINT = "rollback_to_checkpoint"
+    TURN_COMMIT_ONLY = "turn_commit_only"
+
+
+class DuplexOutputAction(str, Enum):
+    DIRECT_RESPONSE = "direct_response"
+
+
+@dataclass
+class DuplexRuntimeCapabilities:
+    input_modes: set[DuplexInputMode] = field(default_factory=lambda: {DuplexInputMode.TURN_COMMIT_ONLY})
+    implementation_level: str = "serving_session_adapter"
+
+
+@dataclass(frozen=True)
+class DuplexAppendPlan:
+    prompt: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class DuplexOutputDecision:
+    action: DuplexOutputAction
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+    final_output_type: str = "text"
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
+
+
+class DuplexRuntimeExtension(Protocol):
+    """Pure model policy invoked by the experimental duplex control plane."""
+
+    def configure_sampling_params(
+        self,
+        *,
+        runtime_config: dict[str, Any],
+        defaults: tuple[object, ...],
+    ) -> tuple[object, ...]: ...
+
+    def plan_append(
+        self,
+        *,
+        request_id: str,
+        fence: DuplexFence,
+        session_config: dict[str, Any],
+        runtime_config: dict[str, Any],
+        seq: int,
+        turn_seq: int,
+        mode: DuplexInputMode,
+        payload: object,
+        final: bool,
+        sampling_params: object,
+    ) -> DuplexAppendPlan: ...
+
+    def decide_output(
+        self,
+        *,
+        stage_id: int,
+        final_stage_id: int,
+        segment_finished: bool,
+        segment_token_ids: tuple[int, ...],
+        segment_output_metadata: dict[str, Any],
+        output: object,
+    ) -> DuplexOutputDecision | None: ...
+
+
+@dataclass(frozen=True)
+class DuplexRequestIdentity:
+    session_id: str
+    fence: DuplexFence
+
+
+@dataclass(frozen=True)
+class DuplexStageRequestContext:
+    request_id: str
+    session_id: str
+    fence: DuplexFence
+    stage_id: int
+    final_stage_id: int
+    config_generation: int
+    sampling_params: tuple[object, ...]
+    session_config: Mapping[str, Any] = field(default_factory=dict)
+    runtime_config: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "sampling_params", tuple(self.sampling_params))
+        object.__setattr__(self, "session_config", MappingProxyType(dict(self.session_config)))
+        object.__setattr__(self, "runtime_config", MappingProxyType(dict(self.runtime_config)))
+
+    @property
+    def stage_sampling_params(self) -> object:
+        return self.sampling_params[self.stage_id]
+
+
+@dataclass(frozen=True)
+class DuplexStageSubmission:
+    context: DuplexStageRequestContext
+    prompt: Mapping[str, Any]
+    already_submitted: bool
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "prompt", MappingProxyType(dict(self.prompt)))
+
+
+@dataclass(frozen=True)
+class DuplexStageSubmissionResult:
+    request_id: str
+    stage_id: int
+    replica_id: int
+
+
+@dataclass(frozen=True)
+class DuplexOutputContext:
+    identity: DuplexRequestIdentity
+    final_stage_id: int
+    segment_finished: bool
+    segment_token_ids: tuple[int, ...] = ()
+    segment_output_metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "segment_token_ids", tuple(self.segment_token_ids))
+        object.__setattr__(
+            self,
+            "segment_output_metadata",
+            MappingProxyType(dict(self.segment_output_metadata)),
+        )
+
+
+class DuplexStagePort(Protocol):
+    @property
+    def stage_count(self) -> int: ...
+
+    def sampling_defaults(self) -> tuple[object, ...]: ...
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None: ...
+
+    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult: ...
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None: ...
+
+
+class DuplexControlPlanePort(Protocol):
+    @property
+    def sessions(self) -> object: ...
+
+    def accepts(self, message: object) -> bool: ...
+
+    def dispatch(self, message: object) -> None: ...
+
+    async def shutdown(self) -> None: ...
+
+    def close_sessions_for_request_ids(self, request_ids: list[str]) -> dict[str, list[str]]: ...
+
+    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None: ...
+
+    def session_for_identity(self, identity: DuplexRequestIdentity | None) -> object | None: ...
+
+    def decide_output(
+        self,
+        stage_id: int,
+        output: object,
+        context: DuplexOutputContext | None,
+    ) -> DuplexOutputDecision | None: ...
+
+
+class CorrelatedRpcTransport(Protocol):
+    def execute(
+        self,
+        key: tuple[str, str],
+        message: EngineQueueMessage,
+        *,
+        timeout: float | None,
+        timeout_message: str,
+        block_on_submit: bool = False,
+    ) -> EngineQueueMessage: ...
+
+
+def duplex_data_plane_request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
+    stage_results = result.get("stage_results")
+    if not isinstance(stage_results, list):
+        return None, None
+    for item in stage_results:
+        if not isinstance(item, dict):
+            continue
+        inner = item.get("result")
+        if not isinstance(inner, dict) or inner.get("data_plane_append") is not True:
+            continue
+        request_id = inner.get("request_id")
+        if not isinstance(request_id, str) or not request_id:
+            continue
+        response_stage_id = inner.get("response_stage_id")
+        return request_id, response_stage_id if isinstance(response_stage_id, int) else None
+    return None, None
+
+
+def duplex_resource_request_id(fence: DuplexFence, role: str) -> str:
+    if not role or any(
+        character not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-" for character in role
+    ):
+        raise ValueError(f"invalid duplex resource role: {role!r}")
+    encoded_session_id = base64.urlsafe_b64encode(fence.session_id.encode("utf-8")).decode("ascii").rstrip("=")
+    return f"duplex-s.{encoded_session_id}.i.{fence.incarnation}.e.{fence.epoch}.r.{role}"
+
+
+def duplex_resource_request_belongs_to_session(request_id: str, session_id: str) -> bool:
+    """Return whether a current-format resource request belongs to a session."""
+    parts = request_id.split(".")
+    if len(parts) != 8 or parts[0] != "duplex-s" or parts[2] != "i" or parts[4] != "e" or parts[6] != "r":
+        return False
+    try:
+        int(parts[3])
+        int(parts[5])
+    except ValueError:
+        return False
+    role = parts[7]
+    if not role or any(
+        character not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-" for character in role
+    ):
+        return False
+    encoded_session_id = base64.urlsafe_b64encode(session_id.encode("utf-8")).decode("ascii").rstrip("=")
+    return parts[1] == encoded_session_id
+
+
+__all__ = [
+    "CorrelatedRpcTransport",
+    "DuplexAppendPlan",
+    "DuplexControlPlanePort",
+    "DuplexInputMode",
+    "DuplexOutputAction",
+    "DuplexOutputContext",
+    "DuplexOutputDecision",
+    "DuplexRequestIdentity",
+    "DuplexRuntimeCapabilities",
+    "DuplexRuntimeExtension",
+    "DuplexStagePort",
+    "DuplexStageRequestContext",
+    "DuplexStageSubmission",
+    "DuplexStageSubmissionResult",
+    "SessionMode",
+    "duplex_data_plane_request_info",
+    "duplex_resource_request_belongs_to_session",
+    "duplex_resource_request_id",
+]
diff --git a/vllm_omni/experimental/fullduplex/engine/duplex_control_client.py b/vllm_omni/experimental/fullduplex/engine/duplex_control_client.py
new file mode 100644
index 000000000..b37effe32
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/duplex_control_client.py
@@ -0,0 +1,228 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Callable
+
+from vllm_omni.experimental.fullduplex.engine.contracts import CorrelatedRpcTransport
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    AppendDuplexInputMessage,
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexFence,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    SignalDuplexTurnMessage,
+    TouchDuplexSessionMessage,
+)
+
+DuplexControlMessage = (
+    OpenDuplexSessionMessage
+    | AppendDuplexInputMessage
+    | SignalDuplexTurnMessage
+    | CloseDuplexSessionMessage
+    | TouchDuplexSessionMessage
+    | ResumeDuplexSessionMessage
+)
+
+
+class DuplexControlRequestError(RuntimeError):
+    """Typed client-side failure returned by the duplex control plane."""
+
+    def __init__(self, result: dict[str, object]) -> None:
+        error = result.get("error")
+        error_data = error if isinstance(error, dict) else {}
+        self.result = result
+        self.code = str(error_data.get("code") or "internal_error")
+        self.retryable = bool(error_data.get("retryable", False))
+        accepted_fence = result.get("accepted_fence")
+        self.accepted_fence = accepted_fence if isinstance(accepted_fence, DuplexFence) else None
+        lease_generation = result.get("lease_generation")
+        self.lease_generation = lease_generation if isinstance(lease_generation, int) else None
+        super().__init__(f"duplex {result.get('operation')} failed: {result}")
+
+
+class DuplexControlClient:
+    """Builds duplex commands on top of an engine-owned RPC transport."""
+
+    def __init__(
+        self,
+        transport: CorrelatedRpcTransport,
+        *,
+        control_id_factory: Callable[[], str] | None = None,
+    ) -> None:
+        self._transport = transport
+        self._control_id_factory = control_id_factory or (lambda: uuid.uuid4().hex)
+
+    def execute(self, message: DuplexControlMessage, *, timeout: float | None) -> dict[str, object]:
+        result_message = self._transport.execute(
+            ("duplex", message.control_id),
+            message,
+            timeout=timeout,
+            timeout_message=f"duplex control timed out after {timeout} seconds",
+        )
+        if not isinstance(result_message, DuplexControlResultMessage):
+            raise RuntimeError(f"unexpected duplex control result type: {type(result_message).__name__}")
+        if result_message.fence != message.fence:
+            raise RuntimeError(
+                f"duplex control fence mismatch: expected {message.fence!r}, got {result_message.fence!r}"
+            )
+        result = {
+            "fence": result_message.fence,
+            "operation": result_message.operation,
+            "session_id": result_message.session_id,
+            "ok": result_message.ok,
+            "stage_results": list(result_message.stage_results),
+            "unsupported_count": result_message.unsupported_count,
+            "error_count": result_message.error_count,
+            "accepted_fence": result_message.accepted_fence,
+            "lease_generation": result_message.lease_generation,
+            "error": (
+                {
+                    "code": result_message.error.code,
+                    "message": result_message.error.message,
+                    "retryable": result_message.error.retryable,
+                }
+                if result_message.error is not None
+                else None
+            ),
+        }
+        if not result_message.ok:
+            raise DuplexControlRequestError(result)
+        return result
+
+    def open(
+        self,
+        session_id: str,
+        *,
+        session_mode: str,
+        capabilities: dict[str, object] | None,
+        session_config: dict[str, object] | None,
+        runtime_config: dict[str, object] | None,
+        fence: DuplexFence,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return self.execute(
+            OpenDuplexSessionMessage(
+                control_id=self._control_id_factory(),
+                fence=fence,
+                session_id=session_id,
+                session_mode=session_mode,
+                capabilities=dict(capabilities or {}),
+                session_config=dict(session_config or {}),
+                runtime_config=dict(runtime_config or {}),
+            ),
+            timeout=timeout,
+        )
+
+    def append(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None,
+        final: bool,
+        expected_epoch: int | None,
+        fence: DuplexFence,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        if expected_epoch is not None and expected_epoch != fence.epoch:
+            raise ValueError("expected_epoch must match fence.epoch")
+        return self.execute(
+            AppendDuplexInputMessage(
+                control_id=self._control_id_factory(),
+                operation_id=operation_id,
+                fence=fence,
+                session_id=session_id,
+                expected_epoch=expected_epoch,
+                mode=mode,
+                payload=payload,
+                final=final,
+            ),
+            timeout=timeout,
+        )
+
+    def signal(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        fence: DuplexFence,
+        next_fence: DuplexFence | None,
+        session_config: dict[str, object] | None,
+        runtime_config: dict[str, object] | None,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return self.execute(
+            SignalDuplexTurnMessage(
+                control_id=self._control_id_factory(),
+                fence=fence,
+                session_id=session_id,
+                event=event,
+                next_fence=next_fence,
+                session_config=dict(session_config) if session_config is not None else None,
+                runtime_config=dict(runtime_config) if runtime_config is not None else None,
+            ),
+            timeout=timeout,
+        )
+
+    def close(
+        self,
+        session_id: str,
+        *,
+        reason: str,
+        fence: DuplexFence,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return self.execute(
+            CloseDuplexSessionMessage(
+                control_id=self._control_id_factory(),
+                fence=fence,
+                session_id=session_id,
+                reason=reason,
+            ),
+            timeout=timeout,
+        )
+
+    def touch(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return self.execute(
+            TouchDuplexSessionMessage(
+                control_id=self._control_id_factory(),
+                fence=fence,
+                session_id=session_id,
+                activity=activity.value,
+            ),
+            timeout=timeout,
+        )
+
+    def resume(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return self.execute(
+            ResumeDuplexSessionMessage(
+                control_id=self._control_id_factory(),
+                fence=fence,
+                session_id=session_id,
+                expected_lease_generation=expected_lease_generation,
+            ),
+            timeout=timeout,
+        )
+
+
+__all__ = ["CorrelatedRpcTransport", "DuplexControlClient", "DuplexControlMessage"]
diff --git a/vllm_omni/experimental/fullduplex/engine/duplex_control_plane.py b/vllm_omni/experimental/fullduplex/engine/duplex_control_plane.py
new file mode 100644
index 000000000..a1d3dac00
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/duplex_control_plane.py
@@ -0,0 +1,1063 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Orchestrator-side control plane for experimental duplex sessions.
+
+``Orchestrator`` creates this component only when duplex control is enabled
+and supplies a narrow :class:`DuplexStagePort` implementation. Queue messages
+are routed through :meth:`DuplexControlPlane.handle`; stage outputs are passed
+to :meth:`DuplexControlPlane.decide_output`; request cleanup is reported back
+through the control plane so session leases and stage bindings stay coherent.
+
+The module owns duplex session/control algorithms. It deliberately does not
+own stage pools, request queues, or OpenAI Realtime protocol state.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from vllm.logger import init_logger
+
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    DuplexAppendPlan,
+    DuplexInputMode,
+    DuplexOutputContext,
+    DuplexOutputDecision,
+    DuplexRequestIdentity,
+    DuplexRuntimeCapabilities,
+    DuplexRuntimeExtension,
+    DuplexStagePort,
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+    DuplexStageSubmissionResult,
+    SessionMode,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_session import (
+    DuplexAppendReservation,
+    DuplexFenceMismatchError,
+    DuplexSessionExpiry,
+    DuplexSessionRuntimeManager,
+    DuplexSessionRuntimeState,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity, DuplexLeaseConfig
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    AppendDuplexInputMessage,
+    CloseDuplexSessionMessage,
+    DuplexControlError,
+    DuplexControlResultMessage,
+    DuplexFence,
+    DuplexSessionLifecycleMessage,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    SignalDuplexTurnMessage,
+    TouchDuplexSessionMessage,
+)
+
+logger = init_logger(__name__)
+
+
+@dataclass(frozen=True)
+class _PendingControlCleanup:
+    kind: str
+    session_id: str
+    fence: DuplexFence
+    submitted_request_ids: tuple[str, ...]
+    reserved_request_ids: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class _PendingSubmissionCleanup:
+    session_id: str
+    request_ids: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class _PendingRequestCleanup:
+    session_id: str
+    fence: DuplexFence
+    lease_generation: int
+    request_ids: tuple[str, ...]
+    abort: bool
+
+
+class DuplexResultSink(Protocol):
+    async def put(self, message: DuplexControlResultMessage) -> None: ...
+
+
+class DuplexLifecycleSink(Protocol):
+    async def put(self, message: DuplexSessionLifecycleMessage) -> None: ...
+
+
+class DuplexControlPlane:
+    _MESSAGE_TYPES = (
+        OpenDuplexSessionMessage,
+        AppendDuplexInputMessage,
+        SignalDuplexTurnMessage,
+        CloseDuplexSessionMessage,
+        TouchDuplexSessionMessage,
+        ResumeDuplexSessionMessage,
+    )
+
+    def __init__(
+        self,
+        *,
+        extension: DuplexRuntimeExtension | None,
+        stage_port: DuplexStagePort,
+        result_sink: DuplexResultSink,
+        lifecycle_sink: DuplexLifecycleSink | None = None,
+        lease_config: DuplexLeaseConfig | None = None,
+        clock: Callable[[], float] | None = None,
+        max_sessions: int | None = None,
+        completed_append_limit: int = 256,
+    ) -> None:
+        self._extension = extension
+        self._stage_port = stage_port
+        self._result_sink = result_sink
+        self._lifecycle_sink = lifecycle_sink
+        self._lease_config = lease_config or DuplexLeaseConfig()
+        self._sessions = DuplexSessionRuntimeManager(
+            clock=clock,
+            max_sessions=max_sessions,
+            completed_append_limit=completed_append_limit,
+        )
+        self._pending_expirations: dict[tuple[str, int], DuplexSessionExpiry] = {}
+        self._pending_control_cleanups: dict[tuple[str, str, int, int, int, int], _PendingControlCleanup] = {}
+        self._control_cleanup_tasks: dict[
+            tuple[str, str, int, int, int, int],
+            asyncio.Task[None],
+        ] = {}
+        self._pending_submission_cleanups: dict[str, _PendingSubmissionCleanup] = {}
+        self._submission_cleanup_tasks: dict[str, asyncio.Task[None]] = {}
+        self._pending_request_cleanups: dict[tuple[str, int, int], _PendingRequestCleanup] = {}
+        self._request_cleanup_tasks: dict[tuple[str, int, int], asyncio.Task[None]] = {}
+        self._request_cleanups_in_progress: set[tuple[str, int, int]] = set()
+        self._session_control_tails: dict[str, asyncio.Task[None]] = {}
+        self._dispatched_control_tasks: set[asyncio.Task[None]] = set()
+
+    @property
+    def sessions(self) -> DuplexSessionRuntimeManager:
+        return self._sessions
+
+    @property
+    def pending_submission_cleanup_count(self) -> int:
+        return len(self._pending_submission_cleanups)
+
+    def accepts(self, message: object) -> bool:
+        return isinstance(message, self._MESSAGE_TYPES)
+
+    async def handle(self, message: object) -> None:
+        if isinstance(message, OpenDuplexSessionMessage):
+            await self.handle_open(message)
+        elif isinstance(message, AppendDuplexInputMessage):
+            await self.handle_append(message)
+        elif isinstance(message, SignalDuplexTurnMessage):
+            await self.handle_signal(message)
+        elif isinstance(message, CloseDuplexSessionMessage):
+            await self.handle_close(message)
+        elif isinstance(message, TouchDuplexSessionMessage):
+            await self.handle_touch(message)
+        elif isinstance(message, ResumeDuplexSessionMessage):
+            await self.handle_resume(message)
+        else:
+            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
+
+    def dispatch(self, message: object) -> None:
+        """Schedule one control command without blocking unrelated sessions."""
+        if not self.accepts(message):
+            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
+        session_id = message.session_id
+        predecessor = self._session_control_tails.get(session_id)
+
+        async def run_ordered() -> None:
+            if predecessor is not None:
+                await predecessor
+            await self.handle(message)
+
+        task = asyncio.create_task(
+            run_ordered(),
+            name=f"duplex-control-{session_id}-{message.control_id}",
+        )
+        self._session_control_tails[session_id] = task
+        self._dispatched_control_tasks.add(task)
+
+        def discard(completed: asyncio.Task[None]) -> None:
+            self._dispatched_control_tasks.discard(completed)
+            if self._session_control_tails.get(session_id) is completed:
+                self._session_control_tails.pop(session_id, None)
+            if not completed.cancelled():
+                completed.exception()
+
+        task.add_done_callback(discard)
+
+    async def drain(self) -> None:
+        while self._dispatched_control_tasks:
+            await asyncio.gather(*tuple(self._dispatched_control_tasks))
+
+    async def shutdown(self) -> None:
+        tasks = tuple(
+            self._dispatched_control_tasks
+            | set(self._control_cleanup_tasks.values())
+            | set(self._submission_cleanup_tasks.values())
+            | set(self._request_cleanup_tasks.values())
+        )
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    @staticmethod
+    def coerce_capabilities(raw: dict[str, object]) -> DuplexRuntimeCapabilities:
+        input_modes: set[DuplexInputMode] = set()
+        values = raw.get("input_modes")
+        if values is not None and not isinstance(values, list):
+            raise TypeError("duplex input_modes capability must be a list")
+        if isinstance(values, list):
+            for value in values:
+                try:
+                    input_modes.add(DuplexInputMode(value))
+                except (TypeError, ValueError) as exc:
+                    raise ValueError(f"unknown duplex input mode: {value!r}") from exc
+        return DuplexRuntimeCapabilities(
+            input_modes=input_modes or {DuplexInputMode.TURN_COMMIT_ONLY},
+            implementation_level=str(raw.get("implementation_level") or "serving_session_adapter"),
+        )
+
+    def sampling_params_for_config(self, runtime_config: dict[str, Any]) -> list[object]:
+        defaults = self._stage_port.sampling_defaults()
+        if self._extension is None:
+            return list(defaults)
+        configured = self._extension.configure_sampling_params(
+            runtime_config=runtime_config,
+            defaults=defaults,
+        )
+        if not isinstance(configured, tuple):
+            raise TypeError("duplex runtime extension must return sampling parameters as a tuple")
+        if len(configured) != len(defaults):
+            raise ValueError("duplex runtime extension must return one sampling parameter per stage")
+        return list(configured)
+
+    @staticmethod
+    def stage_request_id(fence: DuplexFence, *, stage_id: int) -> str:
+        return duplex_resource_request_id(fence, f"stage{stage_id}")
+
+    def ensure_stage_request(
+        self,
+        session: DuplexSessionRuntimeState,
+        *,
+        stage_id: int,
+        fence: DuplexFence | None = None,
+    ) -> DuplexStageRequestContext | None:
+        if stage_id >= self._stage_port.stage_count:
+            return None
+        effective_fence = fence or session.fence
+        request_id = self.stage_request_id(effective_fence, stage_id=stage_id)
+        session.reserve_stage_request(stage_id, request_id, fence=effective_fence)
+        context = DuplexStageRequestContext(
+            request_id=request_id,
+            session_id=session.session_id,
+            fence=effective_fence,
+            stage_id=stage_id,
+            final_stage_id=self._stage_port.stage_count - 1,
+            config_generation=session.config_generation,
+            sampling_params=tuple(self.sampling_params_for_config(session.runtime_config)),
+            session_config=session.session_config,
+            runtime_config=session.runtime_config,
+        )
+        self._stage_port.ensure_request(context)
+        return context
+
+    async def handle_open(self, message: OpenDuplexSessionMessage) -> None:
+        session: DuplexSessionRuntimeState | None = None
+        try:
+            session_mode = SessionMode(message.session_mode)
+            capabilities = self.coerce_capabilities(message.capabilities)
+            native_append_modes = capabilities.input_modes - {DuplexInputMode.TURN_COMMIT_ONLY}
+            if native_append_modes and self._extension is None:
+                raise RuntimeError("duplex_runtime_extension_not_configured")
+            session = self.sessions.open_session(
+                message.fence,
+                capabilities=capabilities,
+                session_config=message.session_config,
+                runtime_config=message.runtime_config,
+                lease_config=self._lease_config,
+            )
+            request_context = self.ensure_stage_request(session, stage_id=0) if self._extension is not None else None
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="open",
+                session_id=message.session_id,
+                stage_results=[
+                    {
+                        "stage_id": -1,
+                        "replica_id": -1,
+                        "result": {
+                            "supported": True,
+                            "implementation_level": capabilities.implementation_level,
+                            "data_plane_session": True,
+                            "session_mode": session_mode.value,
+                            "scheduler_request_context": request_context is not None,
+                            "request_id": request_context.request_id if request_context is not None else None,
+                        },
+                    }
+                ],
+            )
+        except Exception as exc:
+            if self._control_error(exc).code == "resource_exhausted":
+                logger.info("open_duplex_session rejected: %s", exc)
+            else:
+                logger.exception("open_duplex_session failed: %s", exc)
+            if session is not None and self.sessions.get(message.session_id) is session:
+                reserved_request_ids = tuple(session.resource_request_ids())
+                self.sessions.begin_close_session(session.fence, reason="open_rollback")
+                cleanup_key = self._cleanup_key("open_rollback", session.fence)
+                pending = _PendingControlCleanup(
+                    kind="open_rollback",
+                    session_id=session.session_id,
+                    fence=session.fence,
+                    reserved_request_ids=reserved_request_ids,
+                    submitted_request_ids=(),
+                )
+                self._pending_control_cleanups[cleanup_key] = pending
+                try:
+                    await self._complete_control_cleanup(cleanup_key, pending)
+                except Exception as cleanup_exc:
+                    logger.warning(
+                        "duplex open rollback remains pending for session %s: %s",
+                        session.session_id,
+                        cleanup_exc,
+                    )
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="open",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+
+    async def handle_append(self, message: AppendDuplexInputMessage) -> None:
+        session: DuplexSessionRuntimeState | None = None
+        lease_operation_id = f"append:{message.control_id}"
+        operation_started = False
+        try:
+            session = self.sessions.require(message.session_id)
+            await self._complete_pending_submission_cleanup(message.session_id)
+            if message.expected_epoch is not None and message.expected_epoch != message.fence.epoch:
+                raise ValueError("expected_epoch must match fence.epoch")
+            mode = DuplexInputMode(message.mode)
+            if message.operation_id is not None:
+                completed = session.completed_append(
+                    message.operation_id,
+                    fence=message.fence,
+                    mode=mode,
+                    final=message.final,
+                )
+                if completed is not None:
+                    session.touch(message.fence, DuplexLeaseActivity.APPEND)
+                    await self.put_result(
+                        message.control_id,
+                        fence=message.fence,
+                        operation="append",
+                        session_id=message.session_id,
+                        stage_results=completed,
+                    )
+                    return
+            session.begin_operation(message.fence, lease_operation_id)
+            operation_started = True
+            reservation = session.prepare_append(mode=mode, fence=message.fence)
+            stage_results = await self.append_via_data_plane(
+                message,
+                session=session,
+                reservation=reservation,
+                mode=mode,
+            )
+            if message.operation_id is not None:
+                session.record_completed_append(
+                    message.operation_id,
+                    fence=message.fence,
+                    mode=mode,
+                    final=message.final,
+                    stage_results=stage_results,
+                )
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="append",
+                session_id=message.session_id,
+                stage_results=stage_results,
+            )
+        except Exception as exc:
+            logger.exception("append_duplex_input failed: %s", exc)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="append",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+        finally:
+            if session is not None and operation_started and lease_operation_id in session.lease.active_operations:
+                session.end_operation(session.fence, lease_operation_id)
+
+    async def append_via_data_plane(
+        self,
+        message: AppendDuplexInputMessage,
+        *,
+        session: DuplexSessionRuntimeState,
+        reservation: DuplexAppendReservation,
+        mode: DuplexInputMode,
+    ) -> list[dict[str, object]]:
+        if self._extension is None and mode is DuplexInputMode.TURN_COMMIT_ONLY:
+            update = session.commit_append(reservation)
+            return [
+                {
+                    "stage_id": -1,
+                    "replica_id": -1,
+                    "result": {
+                        "supported": True,
+                        "data_plane_append": False,
+                        "seq": update.seq,
+                        "turn_id": update.turn_id,
+                        "turn_seq": update.turn_seq,
+                        "mode": mode.value,
+                    },
+                }
+            ]
+        if self._stage_port.stage_count == 0:
+            return [
+                {
+                    "stage_id": -1,
+                    "replica_id": -1,
+                    "result": {"supported": False, "error": "duplex_data_plane_has_no_stage"},
+                }
+            ]
+        if self._extension is None:
+            raise RuntimeError("duplex_runtime_extension_not_configured")
+
+        stage_id = 0
+        request_id = self.stage_request_id(message.fence, stage_id=stage_id)
+        existing_binding = session.stage_bindings.get(stage_id)
+        already_submitted = existing_binding is not None and existing_binding.request_id == request_id
+        request_context = self.ensure_stage_request(
+            session,
+            stage_id=stage_id,
+            fence=message.fence,
+        )
+        if request_context is None:
+            raise RuntimeError("duplex_data_plane_has_no_stage")
+        append_plan = self._extension.plan_append(
+            request_id=request_id,
+            fence=message.fence,
+            session_config=dict(request_context.session_config),
+            runtime_config=dict(request_context.runtime_config),
+            seq=reservation.update.seq,
+            turn_seq=reservation.update.turn_seq,
+            mode=mode,
+            payload=message.payload,
+            final=message.final,
+            sampling_params=request_context.stage_sampling_params,
+        )
+        if not isinstance(append_plan, DuplexAppendPlan):
+            raise TypeError("duplex runtime extension plan_append() must return DuplexAppendPlan")
+        submission = DuplexStageSubmission(
+            context=request_context,
+            prompt=append_plan.prompt,
+            already_submitted=already_submitted,
+        )
+        submission_result = await self._stage_port.submit(submission)
+        try:
+            if submission_result.request_id != request_id or submission_result.stage_id != stage_id:
+                raise RuntimeError("duplex stage adapter returned a mismatched submission result")
+            update = session.commit_append(reservation)
+            session.bind_stage_request(stage_id, request_id, fence=message.fence)
+        except BaseException:
+            self._pending_submission_cleanups[session.session_id] = _PendingSubmissionCleanup(
+                session_id=session.session_id,
+                request_ids=(request_id,),
+            )
+            try:
+                await self._complete_pending_submission_cleanup(session.session_id)
+            except Exception as cleanup_exc:
+                logger.warning(
+                    "duplex append compensation remains pending for session %s: %s",
+                    session.session_id,
+                    cleanup_exc,
+                )
+            raise
+        return [
+            {
+                "stage_id": stage_id,
+                "replica_id": submission_result.replica_id,
+                "result": {
+                    "supported": True,
+                    "implementation_level": session.capabilities.implementation_level,
+                    "data_plane_append": True,
+                    "request_id": request_id,
+                    "response_stage_id": request_context.final_stage_id,
+                    "seq": update.seq,
+                    "turn_id": update.turn_id,
+                    "response_seq": message.fence.response_seq,
+                    "turn_seq": update.turn_seq,
+                    "mode": mode.value,
+                    "resumable": True,
+                },
+            }
+        ]
+
+    async def handle_signal(self, message: SignalDuplexTurnMessage) -> None:
+        try:
+            cancel_events = {"barge_in", "input.cancel", "response.cancel"}
+            if message.event not in {*cancel_events, "session.update"}:
+                raise ValueError(f"unsupported duplex runtime signal: {message.event}")
+            session = self.sessions.require(message.session_id)
+            await self._complete_pending_submission_cleanup(message.session_id)
+            effective_next_fence = message.next_fence
+            if message.event in cancel_events:
+                if effective_next_fence is None:
+                    raise ValueError(f"{message.event} requires next_fence")
+                cleanup_key = self._cleanup_key("cancel", message.fence)
+                pending = self._pending_control_cleanups.get(cleanup_key)
+                if pending is None:
+                    stale_request_ids = session.prepare_cancel_fence(message.fence, effective_next_fence)
+                    pending = _PendingControlCleanup(
+                        kind="cancel",
+                        session_id=message.session_id,
+                        fence=message.fence,
+                        submitted_request_ids=tuple(stale_request_ids),
+                    )
+                    self._pending_control_cleanups[cleanup_key] = pending
+                await self._complete_control_cleanup(cleanup_key, pending)
+            else:
+                session.accept_fence(message.fence)
+            if message.runtime_config is not None:
+                self.sampling_params_for_config(message.runtime_config)
+            session.replace_configs(
+                session_config=message.session_config,
+                runtime_config=message.runtime_config,
+            )
+            session.touch(session.fence, DuplexLeaseActivity.SIGNAL)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="signal",
+                session_id=message.session_id,
+                stage_results=[
+                    {
+                        "stage_id": -1,
+                        "replica_id": -1,
+                        "result": {
+                            "supported": True,
+                            "data_plane_signal": True,
+                            "event": message.event,
+                            "fence": message.fence,
+                            "next_fence": effective_next_fence,
+                        },
+                    }
+                ],
+            )
+        except Exception as exc:
+            logger.exception("signal_duplex_turn failed: %s", exc)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="signal",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+
+    async def handle_close(self, message: CloseDuplexSessionMessage) -> None:
+        try:
+            await self._complete_pending_submission_cleanup(message.session_id)
+            session = self.sessions.get(message.session_id)
+            if session is None:
+                await self.put_result(
+                    message.control_id,
+                    fence=message.fence,
+                    operation="close",
+                    session_id=message.session_id,
+                    stage_results=[],
+                )
+                return
+            cleanup_key = self._cleanup_key("close", message.fence)
+            pending = self._pending_control_cleanups.get(cleanup_key)
+            if pending is None:
+                submitted = tuple(session.resource_request_ids(submitted=True))
+                reserved = tuple(session.resource_request_ids(submitted=False))
+                self.sessions.begin_close_session(message.fence, reason=message.reason)
+                pending = _PendingControlCleanup(
+                    kind="close",
+                    session_id=message.session_id,
+                    fence=message.fence,
+                    submitted_request_ids=submitted,
+                    reserved_request_ids=reserved,
+                )
+                self._pending_control_cleanups[cleanup_key] = pending
+            await self._complete_control_cleanup(cleanup_key, pending)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="close",
+                session_id=message.session_id,
+                stage_results=[
+                    {
+                        "stage_id": -1,
+                        "replica_id": -1,
+                        "result": {
+                            "supported": True,
+                            "data_plane_close": True,
+                            "reason": message.reason,
+                        },
+                    }
+                ],
+            )
+        except Exception as exc:
+            logger.exception("close_duplex_session failed: %s", exc)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="close",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+
+    async def handle_touch(self, message: TouchDuplexSessionMessage) -> None:
+        try:
+            session = self.sessions.require(message.session_id)
+            activity = DuplexLeaseActivity(message.activity)
+            if activity is DuplexLeaseActivity.DETACH:
+                session.detach(message.fence)
+            else:
+                session.touch(message.fence, activity)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="touch",
+                session_id=message.session_id,
+                stage_results=[
+                    {
+                        "stage_id": -1,
+                        "replica_id": -1,
+                        "result": {
+                            "supported": True,
+                            "activity": activity.value,
+                            "lease_generation": session.lease.generation,
+                        },
+                    }
+                ],
+            )
+        except Exception as exc:
+            logger.exception("touch_duplex_session failed: %s", exc)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="touch",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+
+    async def handle_resume(self, message: ResumeDuplexSessionMessage) -> None:
+        try:
+            session = self.sessions.require(message.session_id)
+            generation = session.resume(
+                message.fence,
+                expected_lease_generation=message.expected_lease_generation,
+            )
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="resume",
+                session_id=message.session_id,
+                stage_results=[
+                    {
+                        "stage_id": -1,
+                        "replica_id": -1,
+                        "result": {
+                            "supported": True,
+                            "lease_generation": generation,
+                        },
+                    }
+                ],
+            )
+        except Exception as exc:
+            logger.exception("resume_duplex_session failed: %s", exc)
+            await self.put_result(
+                message.control_id,
+                fence=message.fence,
+                operation="resume",
+                session_id=message.session_id,
+                stage_results=[],
+                error=exc,
+            )
+
+    async def reap_expired(self, now: float | None = None) -> int:
+        completed = 0
+        for session_id in list(self._pending_submission_cleanups):
+            try:
+                await self._complete_pending_submission_cleanup(session_id)
+            except Exception as exc:
+                logger.warning(
+                    "duplex append compensation remains pending for session %s: %s",
+                    session_id,
+                    exc,
+                )
+        for key, pending in list(self._pending_control_cleanups.items()):
+            try:
+                await self._complete_control_cleanup(key, pending)
+            except Exception as exc:
+                logger.warning(
+                    "duplex %s cleanup remains pending for session %s: %s",
+                    pending.kind,
+                    pending.session_id,
+                    exc,
+                )
+        for key, pending in list(self._pending_request_cleanups.items()):
+            if key in self._request_cleanups_in_progress:
+                continue
+            try:
+                await self._complete_request_cleanup(key, pending)
+            except Exception as exc:
+                logger.warning(
+                    "duplex request cleanup remains pending for session %s: %s",
+                    pending.session_id,
+                    exc,
+                )
+                continue
+            completed += 1
+        for item in self.sessions.collect_expired(
+            now,
+            excluded_session_ids=set(self._pending_submission_cleanups),
+        ):
+            self._pending_expirations.setdefault(
+                (item.session_id, item.lease_generation),
+                item,
+            )
+        for key, item in list(self._pending_expirations.items()):
+            try:
+                if item.submitted_request_ids:
+                    await self._stage_port.cleanup(list(item.submitted_request_ids), abort=True)
+                if item.reserved_request_ids:
+                    await self._stage_port.cleanup(list(item.reserved_request_ids))
+                if self._lifecycle_sink is not None:
+                    await self._lifecycle_sink.put(
+                        DuplexSessionLifecycleMessage(
+                            fence=item.fence,
+                            session_id=item.session_id,
+                            event="expired",
+                            reason=item.reason,
+                            lease_generation=item.lease_generation,
+                            submitted_request_ids=list(item.submitted_request_ids),
+                            reserved_request_ids=list(item.reserved_request_ids),
+                        )
+                    )
+            except Exception as exc:
+                logger.warning(
+                    "duplex expiry cleanup remains pending for session %s: %s",
+                    item.session_id,
+                    exc,
+                )
+                continue
+            session = self.sessions.get(item.session_id)
+            if session is not None and session.lease.generation == item.lease_generation:
+                self.sessions.finalize_close_session(session)
+            self._pending_expirations.pop(key, None)
+            completed += 1
+        return completed
+
+    async def _complete_pending_submission_cleanup(self, session_id: str) -> None:
+        pending = self._pending_submission_cleanups.get(session_id)
+        if pending is None:
+            return
+        task = self._submission_cleanup_tasks.get(session_id)
+        if task is not None and task.done():
+            self._submission_cleanup_tasks.pop(session_id, None)
+            task = None
+        if task is None:
+            task = asyncio.create_task(
+                self._run_submission_cleanup(pending),
+                name=f"duplex-append-compensation-{session_id}",
+            )
+            self._submission_cleanup_tasks[session_id] = task
+
+            def discard(completed: asyncio.Task[None]) -> None:
+                if self._submission_cleanup_tasks.get(session_id) is completed:
+                    self._submission_cleanup_tasks.pop(session_id, None)
+
+            task.add_done_callback(discard)
+        await asyncio.shield(task)
+
+    async def _run_submission_cleanup(self, pending: _PendingSubmissionCleanup) -> None:
+        await self._stage_port.cleanup(list(pending.request_ids), abort=True)
+        session = self.sessions.get(pending.session_id)
+        if session is not None:
+            session.release_request_ids(list(pending.request_ids))
+        if self._pending_submission_cleanups.get(pending.session_id) is pending:
+            self._pending_submission_cleanups.pop(pending.session_id, None)
+
+    async def _complete_request_cleanup(
+        self,
+        key: tuple[str, int, int],
+        pending: _PendingRequestCleanup,
+    ) -> None:
+        task = self._request_cleanup_tasks.get(key)
+        if task is not None and task.done():
+            self._request_cleanup_tasks.pop(key, None)
+            task = None
+        if task is None:
+            task = asyncio.create_task(
+                self._run_request_cleanup(key, pending),
+                name=f"duplex-request-cleanup-{pending.session_id}",
+            )
+            self._request_cleanup_tasks[key] = task
+
+            def discard(completed: asyncio.Task[None]) -> None:
+                if self._request_cleanup_tasks.get(key) is completed:
+                    self._request_cleanup_tasks.pop(key, None)
+
+            task.add_done_callback(discard)
+        await asyncio.shield(task)
+
+    async def _run_request_cleanup(
+        self,
+        key: tuple[str, int, int],
+        pending: _PendingRequestCleanup,
+    ) -> None:
+        await self._stage_port.cleanup(list(pending.request_ids), abort=pending.abort)
+        session = self.sessions.get(pending.session_id)
+        if (
+            session is not None
+            and session.fence.incarnation == pending.fence.incarnation
+            and session.lease.generation == pending.lease_generation
+        ):
+            self.sessions.finalize_close_session(session)
+        if self._pending_request_cleanups.get(key) is pending:
+            self._pending_request_cleanups.pop(key, None)
+            self._request_cleanups_in_progress.discard(key)
+
+    @staticmethod
+    def _cleanup_key(kind: str, fence: DuplexFence) -> tuple[str, str, int, int, int, int]:
+        return (kind, fence.session_id, fence.incarnation, fence.epoch, fence.turn_id, fence.response_seq)
+
+    async def _complete_control_cleanup(
+        self,
+        key: tuple[str, str, int, int, int, int],
+        pending: _PendingControlCleanup,
+    ) -> None:
+        task = self._control_cleanup_tasks.get(key)
+        if task is not None and task.done():
+            self._control_cleanup_tasks.pop(key, None)
+            task = None
+        if task is None:
+            task = asyncio.create_task(
+                self._run_control_cleanup(key, pending),
+                name=f"duplex-{pending.kind}-cleanup-{pending.session_id}",
+            )
+            self._control_cleanup_tasks[key] = task
+
+            def discard(completed: asyncio.Task[None]) -> None:
+                if self._control_cleanup_tasks.get(key) is completed:
+                    self._control_cleanup_tasks.pop(key, None)
+
+            task.add_done_callback(discard)
+        await asyncio.shield(task)
+
+    async def _run_control_cleanup(
+        self,
+        key: tuple[str, str, int, int, int, int],
+        pending: _PendingControlCleanup,
+    ) -> None:
+        if pending.submitted_request_ids:
+            await self._stage_port.cleanup(list(pending.submitted_request_ids), abort=True)
+        if pending.reserved_request_ids:
+            await self._stage_port.cleanup(list(pending.reserved_request_ids))
+        session = self.sessions.get(pending.session_id)
+        if session is not None:
+            if pending.kind == "cancel":
+                session.release_fence(pending.fence)
+            elif pending.kind in {"close", "open_rollback"}:
+                self.sessions.finalize_close_session(session)
+        self._pending_control_cleanups.pop(key, None)
+
+    @classmethod
+    def _iter_result_dicts(cls, result: object):
+        if isinstance(result, dict):
+            yield result
+        elif isinstance(result, list | tuple):
+            for item in result:
+                yield from cls._iter_result_dicts(item)
+
+    @classmethod
+    def _result_counts(cls, stage_results: list[dict[str, object]]) -> tuple[int, int]:
+        unsupported_count = 0
+        error_count = 0
+        for item in stage_results:
+            for result in cls._iter_result_dicts(item.get("result")):
+                if result.get("supported") is False:
+                    unsupported_count += 1
+                if result.get("error"):
+                    error_count += 1
+        return unsupported_count, error_count
+
+    async def put_result(
+        self,
+        control_id: str,
+        *,
+        fence: DuplexFence,
+        operation: str,
+        session_id: str,
+        stage_results: list[dict[str, object]],
+        error: BaseException | str | None = None,
+    ) -> None:
+        control_error = self._control_error(error) if error is not None else None
+        if error is not None:
+            stage_results = [
+                {
+                    "stage_id": -1,
+                    "replica_id": -1,
+                    "result": {"supported": False, "error": control_error.message},
+                }
+            ]
+        unsupported_count, error_count = self._result_counts(stage_results)
+        session = self.sessions.get(session_id)
+        await self._result_sink.put(
+            DuplexControlResultMessage(
+                control_id=control_id,
+                fence=fence,
+                operation=operation,
+                session_id=session_id,
+                ok=error_count == 0 and unsupported_count == 0,
+                stage_results=stage_results,
+                unsupported_count=unsupported_count,
+                error_count=error_count,
+                error=control_error,
+                accepted_fence=session.fence if session is not None else None,
+                lease_generation=session.lease.generation if session is not None else None,
+            )
+        )
+
+    @staticmethod
+    def _control_error(error: BaseException | str) -> DuplexControlError:
+        message = str(error)
+        if isinstance(error, DuplexFenceMismatchError):
+            code = "stale_fence"
+            retryable = False
+        elif "unknown duplex input mode" in message:
+            code = "invalid_capability"
+            retryable = False
+        elif "duplex_session_capacity_exhausted" in message:
+            code = "resource_exhausted"
+            retryable = True
+        elif isinstance(error, KeyError):
+            code = "not_found"
+            retryable = False
+        elif isinstance(error, (TypeError, ValueError)):
+            code = "invalid_argument"
+            retryable = False
+        elif isinstance(error, TimeoutError):
+            code = "timeout"
+            retryable = True
+        else:
+            code = "failed_precondition"
+            retryable = False
+        return DuplexControlError(code=code, message=message, retryable=retryable)
+
+    def decide_output(
+        self,
+        stage_id: int,
+        output: object,
+        context: DuplexOutputContext | None,
+    ) -> DuplexOutputDecision | None:
+        if context is None or self._extension is None:
+            return None
+        session = self._sessions.get(context.identity.session_id)
+        if session is None:
+            return None
+        try:
+            session.touch(context.identity.fence, DuplexLeaseActivity.MODEL_OUTPUT)
+        except RuntimeError:
+            return None
+        decision = self._extension.decide_output(
+            stage_id=stage_id,
+            final_stage_id=context.final_stage_id,
+            segment_finished=context.segment_finished,
+            segment_token_ids=context.segment_token_ids,
+            segment_output_metadata=dict(context.segment_output_metadata),
+            output=output,
+        )
+        if decision is not None and not isinstance(decision, DuplexOutputDecision):
+            raise TypeError("duplex runtime extension decide_output() must return DuplexOutputDecision or None")
+        return decision
+
+    def session_for_identity(self, identity: DuplexRequestIdentity | None) -> DuplexSessionRuntimeState | None:
+        if identity is None:
+            return None
+        return self._sessions.get(identity.session_id)
+
+    def close_sessions_for_request_ids(
+        self,
+        request_ids: list[str],
+        *,
+        abort: bool = False,
+        cleanup_in_progress: bool = False,
+    ) -> dict[str, list[str]]:
+        closed = self._sessions.close_sessions_for_request_ids(request_ids)
+        for session_id, stale_request_ids in closed.items():
+            session = self._sessions.get(session_id)
+            if session is None:
+                continue
+            key = (session_id, session.fence.incarnation, session.lease.generation)
+            existing = self._pending_request_cleanups.get(key)
+            merged_request_ids = tuple(
+                dict.fromkeys(
+                    [
+                        *(existing.request_ids if existing is not None else ()),
+                        *stale_request_ids,
+                    ]
+                )
+            )
+            self._pending_request_cleanups[key] = _PendingRequestCleanup(
+                session_id=session_id,
+                fence=session.fence,
+                lease_generation=session.lease.generation,
+                request_ids=merged_request_ids,
+                abort=abort or (existing.abort if existing is not None else False),
+            )
+            if cleanup_in_progress:
+                self._request_cleanups_in_progress.add(key)
+        return closed
+
+    def defer_request_cleanups(self, session_ids: Iterable[str]) -> None:
+        session_id_set = set(session_ids)
+        active_keys = {key for key in self._request_cleanups_in_progress if key[0] in session_id_set}
+        self._request_cleanups_in_progress.difference_update(active_keys)
+
+    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None:
+        session_id_set = set(session_ids)
+        for key in list(self._pending_request_cleanups):
+            if key[0] not in session_id_set:
+                continue
+            self._pending_request_cleanups.pop(key, None)
+            self._request_cleanups_in_progress.discard(key)
+        self._sessions.finalize_closed_sessions(session_ids)
+
+
+__all__ = [
+    "DuplexControlPlane",
+    "DuplexOutputContext",
+    "DuplexRequestIdentity",
+    "DuplexResultSink",
+    "DuplexLifecycleSink",
+    "DuplexStagePort",
+    "DuplexStageRequestContext",
+    "DuplexStageSubmission",
+    "DuplexStageSubmissionResult",
+]
diff --git a/vllm_omni/experimental/fullduplex/engine/duplex_runtime.py b/vllm_omni/experimental/fullduplex/engine/duplex_runtime.py
new file mode 100644
index 000000000..acd977448
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/duplex_runtime.py
@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Experimental duplex runtime loading and compatibility exports."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    DuplexAppendPlan,
+    DuplexInputMode,
+    DuplexOutputAction,
+    DuplexOutputDecision,
+    DuplexRuntimeCapabilities,
+    DuplexRuntimeExtension,
+    SessionMode,
+    duplex_data_plane_request_info,
+    duplex_resource_request_belongs_to_session,
+    duplex_resource_request_id,
+)
+
+
+def load_duplex_runtime_extension(path: str | None) -> DuplexRuntimeExtension | None:
+    if not path:
+        return None
+    module_name, separator, attribute_name = path.rpartition(".")
+    if not separator:
+        raise ValueError(f"Invalid duplex runtime extension path: {path!r}")
+    extension_type = getattr(import_module(module_name), attribute_name)
+    return validate_duplex_runtime_extension(extension_type())
+
+
+def validate_duplex_runtime_extension(
+    extension: object,
+    *,
+    sampling_defaults: tuple[object, ...] | None = None,
+) -> DuplexRuntimeExtension:
+    required_methods = (
+        "configure_sampling_params",
+        "plan_append",
+        "decide_output",
+    )
+    missing = [name for name in required_methods if not callable(getattr(extension, name, None))]
+    if missing:
+        raise TypeError(f"Duplex runtime extension is missing callable method(s): {', '.join(missing)}")
+    typed_extension = extension  # type: ignore[assignment]
+    if sampling_defaults is not None:
+        configured = typed_extension.configure_sampling_params(
+            runtime_config={},
+            defaults=sampling_defaults,
+        )
+        if not isinstance(configured, tuple):
+            raise TypeError("Duplex runtime extension must return sampling parameters as a tuple")
+        if len(configured) != len(sampling_defaults):
+            raise ValueError("Duplex runtime extension must return one sampling parameter per stage")
+        for stage_id, (value, default) in enumerate(zip(configured, sampling_defaults, strict=True)):
+            if default is not None and not isinstance(value, type(default)):
+                raise TypeError(
+                    "Duplex runtime extension sampling parameter type mismatch "
+                    f"for stage {stage_id}: expected {type(default).__name__}, got {type(value).__name__}"
+                )
+    return typed_extension
+
+
+from vllm_omni.experimental.fullduplex.engine.duplex_session import (  # noqa: E402, F401
+    DuplexAppendReservation,
+    DuplexCompletedAppend,
+    DuplexFenceMismatchError,
+    DuplexInputAppend,
+    DuplexRequestResource,
+    DuplexSessionRuntimeManager,
+    DuplexSessionRuntimeState,
+    DuplexStageBinding,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import (  # noqa: E402, F401
+    DuplexLeaseActivity,
+    DuplexLeaseConfig,
+    DuplexLeaseState,
+    DuplexSessionExpiry,
+)
+
+__all__ = [
+    "DuplexAppendPlan",
+    "DuplexAppendReservation",
+    "DuplexCompletedAppend",
+    "DuplexFenceMismatchError",
+    "DuplexInputAppend",
+    "DuplexInputMode",
+    "DuplexLeaseActivity",
+    "DuplexLeaseConfig",
+    "DuplexLeaseState",
+    "DuplexOutputAction",
+    "DuplexOutputDecision",
+    "DuplexRequestResource",
+    "DuplexRuntimeCapabilities",
+    "DuplexRuntimeExtension",
+    "DuplexSessionExpiry",
+    "DuplexSessionRuntimeManager",
+    "DuplexSessionRuntimeState",
+    "DuplexStageBinding",
+    "SessionMode",
+    "duplex_data_plane_request_info",
+    "duplex_resource_request_belongs_to_session",
+    "duplex_resource_request_id",
+    "load_duplex_runtime_extension",
+    "validate_duplex_runtime_extension",
+]
diff --git a/vllm_omni/experimental/fullduplex/engine/duplex_session.py b/vllm_omni/experimental/fullduplex/engine/duplex_session.py
new file mode 100644
index 000000000..244005f06
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/duplex_session.py
@@ -0,0 +1,534 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import time
+from collections import OrderedDict
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from typing import Any
+
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    DuplexInputMode,
+    DuplexRuntimeCapabilities,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import (
+    DuplexLeaseActivity,
+    DuplexLeaseConfig,
+    DuplexLeaseState,
+    DuplexSessionExpiry,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+
+def _default_capabilities() -> DuplexRuntimeCapabilities:
+    return DuplexRuntimeCapabilities()
+
+
+class DuplexFenceMismatchError(RuntimeError):
+    def __init__(self, expected: DuplexFence, actual: DuplexFence) -> None:
+        super().__init__(f"duplex fence mismatch: expected {expected!r}, got {actual!r}")
+        self.expected = expected
+        self.actual = actual
+
+
+@dataclass
+class DuplexStageBinding:
+    request_id: str
+    fence: DuplexFence
+
+
+@dataclass
+class DuplexRequestResource:
+    stage_id: int
+    request_id: str
+    fence: DuplexFence
+    submitted: bool = False
+
+
+@dataclass
+class DuplexInputAppend:
+    seq: int
+    turn_seq: int
+    turn_id: int
+
+
+@dataclass(frozen=True)
+class DuplexAppendReservation:
+    fence: DuplexFence
+    mode: DuplexInputMode
+    base_fence: DuplexFence
+    base_input_seq: int
+    base_input_turn_seq: int
+    base_append_turn_key: tuple[int, int, int] | None
+    update: DuplexInputAppend
+
+
+@dataclass(frozen=True)
+class DuplexCompletedAppend:
+    fence: DuplexFence
+    mode: DuplexInputMode
+    final: bool
+    stage_results: tuple[dict[str, object], ...]
+
+
+@dataclass
+class DuplexSessionRuntimeState:
+    """Engine resource handles associated with a core-owned identity fence."""
+
+    fence: DuplexFence
+    lease: DuplexLeaseState
+    _clock: Callable[[], float] = field(repr=False)
+    capabilities: DuplexRuntimeCapabilities = field(default_factory=_default_capabilities)
+    session_config: dict[str, Any] = field(default_factory=dict)
+    runtime_config: dict[str, Any] = field(default_factory=dict)
+    config_generation: int = 0
+    stage_bindings: dict[int, DuplexStageBinding] = field(default_factory=dict)
+    request_resources: dict[tuple[int, str], DuplexRequestResource] = field(default_factory=dict)
+    input_seq: int = 0
+    input_turn_seq: int = 0
+    _append_turn_key: tuple[int, int, int] | None = None
+    completed_append_limit: int = 256
+    completed_appends: OrderedDict[str, DuplexCompletedAppend] = field(default_factory=OrderedDict)
+
+    def __post_init__(self) -> None:
+        if self.completed_append_limit <= 0:
+            raise ValueError("completed_append_limit must be positive")
+
+    @property
+    def session_id(self) -> str:
+        return self.fence.session_id
+
+    @property
+    def epoch(self) -> int:
+        return self.fence.epoch
+
+    @property
+    def turn_id(self) -> int:
+        return self.fence.turn_id
+
+    def _validate_fence(self, fence: DuplexFence) -> None:
+        if fence.session_id != self.session_id or fence.incarnation != self.fence.incarnation:
+            raise DuplexFenceMismatchError(self.fence, fence)
+        current = self.fence
+        if fence.epoch < current.epoch or (
+            fence.epoch == current.epoch
+            and (fence.turn_id < current.turn_id or fence.response_seq < current.response_seq)
+        ):
+            raise DuplexFenceMismatchError(current, fence)
+
+    def accept_fence(self, fence: DuplexFence) -> None:
+        self._validate_fence(fence)
+        if fence.epoch != self.fence.epoch:
+            self.input_seq = 0
+            self.input_turn_seq = 0
+            self._append_turn_key = None
+            self.completed_appends.clear()
+        self.fence = fence
+
+    def touch(self, fence: DuplexFence, activity: DuplexLeaseActivity) -> None:
+        self._validate_fence(fence)
+        self.lease.touch(self._clock(), activity)
+
+    def detach(self, fence: DuplexFence) -> None:
+        self._validate_fence(fence)
+        self.lease.detach(self._clock())
+
+    def resume(self, fence: DuplexFence, *, expected_lease_generation: int) -> int:
+        self._validate_fence(fence)
+        return self.lease.resume(
+            self._clock(),
+            expected_generation=expected_lease_generation,
+        )
+
+    def begin_operation(self, fence: DuplexFence, operation_id: str) -> None:
+        self._validate_fence(fence)
+        self.lease.begin_operation(self._clock(), operation_id)
+
+    def end_operation(self, fence: DuplexFence, operation_id: str) -> None:
+        self._validate_fence(fence)
+        self.lease.end_operation(self._clock(), operation_id)
+
+    def replace_session_config(self, session_config: dict[str, Any]) -> None:
+        self.session_config = dict(session_config)
+        self.config_generation += 1
+
+    def replace_runtime_config(self, runtime_config: dict[str, Any]) -> None:
+        self.runtime_config = dict(runtime_config)
+        self.config_generation += 1
+
+    def replace_configs(
+        self,
+        *,
+        session_config: dict[str, Any] | None = None,
+        runtime_config: dict[str, Any] | None = None,
+    ) -> None:
+        """Atomically publish one validated configuration generation."""
+        if session_config is None and runtime_config is None:
+            return
+        next_session_config = self.session_config if session_config is None else dict(session_config)
+        next_runtime_config = self.runtime_config if runtime_config is None else dict(runtime_config)
+        self.session_config = next_session_config
+        self.runtime_config = next_runtime_config
+        self.config_generation += 1
+
+    def reserve_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
+        self._validate_fence(fence)
+        resource_key = (stage_id, request_id)
+        existing = self.request_resources.get(resource_key)
+        if existing is not None:
+            if (
+                existing.fence.session_id != fence.session_id
+                or existing.fence.incarnation != fence.incarnation
+                or existing.fence.epoch != fence.epoch
+            ):
+                raise ValueError(f"Duplex request resource already reserved with different identity: {request_id}")
+            return
+        self.request_resources[resource_key] = DuplexRequestResource(
+            stage_id=stage_id,
+            request_id=request_id,
+            fence=fence,
+        )
+
+    def bind_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
+        self.reserve_stage_request(stage_id, request_id, fence=fence)
+        self.accept_fence(fence)
+        resource = self.request_resources[(stage_id, request_id)]
+        resource.fence = fence
+        resource.submitted = True
+        self.stage_bindings[stage_id] = DuplexStageBinding(request_id=request_id, fence=fence)
+
+    def stage_request_ids(self, fence: DuplexFence | None = None) -> list[str]:
+        return [
+            binding.request_id for binding in self.stage_bindings.values() if fence is None or binding.fence == fence
+        ]
+
+    def resource_request_ids(
+        self,
+        fence: DuplexFence | None = None,
+        *,
+        submitted: bool | None = None,
+    ) -> list[str]:
+        return list(
+            dict.fromkeys(
+                resource.request_id
+                for resource in self.request_resources.values()
+                if (fence is None or resource.fence == fence) and (submitted is None or resource.submitted is submitted)
+            )
+        )
+
+    def release_request_ids(self, request_ids: list[str]) -> None:
+        released = set(request_ids)
+        if not released:
+            return
+        self.stage_bindings = {
+            stage_id: binding for stage_id, binding in self.stage_bindings.items() if binding.request_id not in released
+        }
+        self.request_resources = {
+            resource_key: resource
+            for resource_key, resource in self.request_resources.items()
+            if resource.request_id not in released
+        }
+
+    def prepare_append(self, *, mode: DuplexInputMode, fence: DuplexFence) -> DuplexAppendReservation:
+        if mode not in self.capabilities.input_modes:
+            raise ValueError(f"Duplex input mode {mode.value!r} is not supported by session {self.session_id}")
+        self._validate_fence(fence)
+        input_seq = 0 if fence.epoch != self.fence.epoch else self.input_seq
+        input_turn_seq = 0 if fence.epoch != self.fence.epoch else self.input_turn_seq
+        append_turn_key = None if fence.epoch != self.fence.epoch else self._append_turn_key
+        turn_key = (fence.epoch, fence.turn_id, fence.response_seq)
+        turn_seq = input_turn_seq + 1 if turn_key == append_turn_key else 1
+        return DuplexAppendReservation(
+            fence=fence,
+            mode=mode,
+            base_fence=self.fence,
+            base_input_seq=self.input_seq,
+            base_input_turn_seq=self.input_turn_seq,
+            base_append_turn_key=self._append_turn_key,
+            update=DuplexInputAppend(
+                seq=input_seq + 1,
+                turn_seq=turn_seq,
+                turn_id=fence.turn_id,
+            ),
+        )
+
+    def commit_append(self, reservation: DuplexAppendReservation) -> DuplexInputAppend:
+        if (
+            self.fence != reservation.base_fence
+            or self.input_seq != reservation.base_input_seq
+            or self.input_turn_seq != reservation.base_input_turn_seq
+            or self._append_turn_key != reservation.base_append_turn_key
+        ):
+            raise RuntimeError("duplex append reservation is stale")
+        self.accept_fence(reservation.fence)
+        self.input_seq = reservation.update.seq
+        self.input_turn_seq = reservation.update.turn_seq
+        self._append_turn_key = (
+            reservation.fence.epoch,
+            reservation.fence.turn_id,
+            reservation.fence.response_seq,
+        )
+        return reservation.update
+
+    def completed_append(
+        self,
+        operation_id: str,
+        *,
+        fence: DuplexFence,
+        mode: DuplexInputMode,
+        final: bool,
+    ) -> list[dict[str, object]] | None:
+        self._validate_fence(fence)
+        completed = self.completed_appends.get(operation_id)
+        if completed is None:
+            return None
+        if completed.fence != fence or completed.mode != mode or completed.final != final:
+            raise ValueError(f"duplex append operation {operation_id!r} was reused with different metadata")
+        return [dict(result) for result in completed.stage_results]
+
+    def record_completed_append(
+        self,
+        operation_id: str,
+        *,
+        fence: DuplexFence,
+        mode: DuplexInputMode,
+        final: bool,
+        stage_results: list[dict[str, object]],
+    ) -> None:
+        self.completed_appends[operation_id] = DuplexCompletedAppend(
+            fence=fence,
+            mode=mode,
+            final=final,
+            stage_results=tuple(dict(result) for result in stage_results),
+        )
+        self.completed_appends.move_to_end(operation_id)
+        while len(self.completed_appends) > self.completed_append_limit:
+            self.completed_appends.popitem(last=False)
+
+    def append_input(self, *, mode: DuplexInputMode, fence: DuplexFence) -> DuplexInputAppend:
+        return self.commit_append(self.prepare_append(mode=mode, fence=fence))
+
+    def release_fence(self, fence: DuplexFence) -> list[str]:
+        stale = self.resource_request_ids(fence)
+        self.stage_bindings = {
+            stage_id: binding for stage_id, binding in self.stage_bindings.items() if binding.fence != fence
+        }
+        self.request_resources = {
+            resource_key: resource
+            for resource_key, resource in self.request_resources.items()
+            if resource.fence != fence
+        }
+        return stale
+
+    def cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
+        stale = self.prepare_cancel_fence(cancelled_fence, next_fence)
+        self.release_fence(cancelled_fence)
+        return stale
+
+    def prepare_cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
+        """Advance the cancellation fence without dropping cleanup records."""
+        if cancelled_fence.session_id != self.session_id or cancelled_fence.incarnation != self.fence.incarnation:
+            raise DuplexFenceMismatchError(self.fence, cancelled_fence)
+        if (
+            next_fence.session_id != self.session_id
+            or next_fence.incarnation != self.fence.incarnation
+            or next_fence.epoch <= cancelled_fence.epoch
+        ):
+            raise DuplexFenceMismatchError(cancelled_fence, next_fence)
+        current_key = (self.fence.epoch, self.fence.turn_id, self.fence.response_seq)
+        cancelled_key = (cancelled_fence.epoch, cancelled_fence.turn_id, cancelled_fence.response_seq)
+        next_key = (next_fence.epoch, next_fence.turn_id, next_fence.response_seq)
+        if cancelled_key > current_key:
+            raise DuplexFenceMismatchError(self.fence, cancelled_fence)
+        if next_key > current_key:
+            self.accept_fence(next_fence)
+        return self.resource_request_ids(cancelled_fence)
+
+    def begin_close(self, fence: DuplexFence, *, reason: str) -> bool:
+        """Make close irreversible while retaining resources for cleanup retry."""
+        self.accept_fence(fence)
+        if self.lease.terminal_reason is not None:
+            return True
+        return self.lease.mark_terminal(reason)
+
+    def finalize_close(self) -> list[str]:
+        return self.close()
+
+    def close(self, fence: DuplexFence | None = None) -> list[str]:
+        if fence is not None:
+            self.accept_fence(fence)
+        stale = self.resource_request_ids()
+        self.stage_bindings.clear()
+        self.request_resources.clear()
+        return stale
+
+    def terminate(self, fence: DuplexFence, *, reason: str) -> bool:
+        if not self.begin_close(fence, reason=reason):
+            return False
+        self.finalize_close()
+        return True
+
+
+class DuplexSessionRuntimeManager:
+    def __init__(
+        self,
+        *,
+        clock: Callable[[], float] | None = None,
+        max_sessions: int | None = None,
+        completed_append_limit: int = 256,
+    ) -> None:
+        if max_sessions is not None and max_sessions <= 0:
+            raise ValueError("max_sessions must be positive or null")
+        if completed_append_limit <= 0:
+            raise ValueError("completed_append_limit must be positive")
+        self._sessions: dict[str, DuplexSessionRuntimeState] = {}
+        self._clock = clock or time.monotonic
+        self._max_sessions = max_sessions
+        self._completed_append_limit = completed_append_limit
+
+    def open_session(
+        self,
+        fence: DuplexFence,
+        *,
+        capabilities: DuplexRuntimeCapabilities | None = None,
+        session_config: dict[str, Any] | None = None,
+        runtime_config: dict[str, Any] | None = None,
+        lease_config: DuplexLeaseConfig | None = None,
+    ) -> DuplexSessionRuntimeState:
+        if not isinstance(fence, DuplexFence):
+            raise TypeError("open_session requires DuplexFence")
+        if fence.session_id in self._sessions:
+            raise ValueError(f"Duplex session already exists: {fence.session_id}")
+        if self._max_sessions is not None and len(self._sessions) >= self._max_sessions:
+            raise RuntimeError(f"duplex_session_capacity_exhausted: limit={self._max_sessions}")
+        session = DuplexSessionRuntimeState(
+            fence=fence,
+            lease=DuplexLeaseState(
+                config=lease_config or DuplexLeaseConfig(),
+                generation=0,
+                last_activity=self._clock(),
+            ),
+            _clock=self._clock,
+            capabilities=capabilities or _default_capabilities(),
+            session_config=dict(session_config or {}),
+            runtime_config=dict(runtime_config or {}),
+            completed_append_limit=self._completed_append_limit,
+        )
+        self._sessions[fence.session_id] = session
+        return session
+
+    def get(self, session_id: str) -> DuplexSessionRuntimeState | None:
+        return self._sessions.get(session_id)
+
+    def require(self, session_id: str) -> DuplexSessionRuntimeState:
+        session = self.get(session_id)
+        if session is None:
+            raise KeyError(f"Unknown duplex session: {session_id}")
+        return session
+
+    def close_session(
+        self,
+        fence: DuplexFence,
+        *,
+        reason: str = "explicit_close",
+    ) -> DuplexSessionRuntimeState | None:
+        if not isinstance(fence, DuplexFence):
+            raise TypeError("close_session requires DuplexFence")
+        session = self._sessions.get(fence.session_id)
+        if session is not None:
+            if session.lease.terminal_reason is not None:
+                return None
+            if not session.terminate(fence, reason=reason):
+                return None
+            if self._sessions.get(fence.session_id) is session:
+                self._sessions.pop(fence.session_id)
+        return session
+
+    def begin_close_session(
+        self,
+        fence: DuplexFence,
+        *,
+        reason: str = "explicit_close",
+    ) -> DuplexSessionRuntimeState | None:
+        if not isinstance(fence, DuplexFence):
+            raise TypeError("begin_close_session requires DuplexFence")
+        session = self._sessions.get(fence.session_id)
+        if session is not None:
+            session.begin_close(fence, reason=reason)
+        return session
+
+    def finalize_close_session(self, session: DuplexSessionRuntimeState) -> None:
+        session.finalize_close()
+        if self._sessions.get(session.session_id) is session:
+            self._sessions.pop(session.session_id, None)
+
+    def collect_expired(
+        self,
+        now: float | None = None,
+        *,
+        excluded_session_ids: set[str] | None = None,
+    ) -> list[DuplexSessionExpiry]:
+        effective_now = self._clock() if now is None else now
+        excluded = excluded_session_ids or set()
+        expired: list[DuplexSessionExpiry] = []
+        for session_id, session in list(self._sessions.items()):
+            if session_id in excluded:
+                continue
+            if session.lease.disconnect_grace_expired(effective_now):
+                reason = "disconnect_grace_expired"
+            elif session.lease.idle_expired(effective_now):
+                reason = "idle_ttl_expired"
+            else:
+                continue
+            submitted = tuple(session.resource_request_ids(submitted=True))
+            reserved = tuple(session.resource_request_ids(submitted=False))
+            if not session.begin_close(session.fence, reason=reason):
+                continue
+            expired.append(
+                DuplexSessionExpiry(
+                    session_id=session_id,
+                    fence=session.fence,
+                    lease_generation=session.lease.generation,
+                    reason=reason,
+                    submitted_request_ids=submitted,
+                    reserved_request_ids=reserved,
+                )
+            )
+        return expired
+
+    def close_sessions_for_request_ids(self, request_ids: list[str]) -> dict[str, list[str]]:
+        request_id_set = set(request_ids)
+        closed: dict[str, list[str]] = {}
+        for session_id, session in list(self._sessions.items()):
+            stale = session.resource_request_ids()
+            if request_id_set.isdisjoint(stale):
+                continue
+            if not session.begin_close(session.fence, reason="request_cleanup"):
+                continue
+            closed[session_id] = stale
+        return closed
+
+    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None:
+        for session_id in session_ids:
+            session = self._sessions.get(session_id)
+            if session is None or session.lease.terminal_reason is None:
+                continue
+            self.finalize_close_session(session)
+
+
+__all__ = [
+    "DuplexAppendReservation",
+    "DuplexCompletedAppend",
+    "DuplexFenceMismatchError",
+    "DuplexInputAppend",
+    "DuplexLeaseActivity",
+    "DuplexLeaseConfig",
+    "DuplexLeaseState",
+    "DuplexRequestResource",
+    "DuplexSessionExpiry",
+    "DuplexSessionRuntimeManager",
+    "DuplexSessionRuntimeState",
+    "DuplexStageBinding",
+]
diff --git a/vllm_omni/experimental/fullduplex/engine/intermediate.py b/vllm_omni/experimental/fullduplex/engine/intermediate.py
new file mode 100644
index 000000000..d85d8f712
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/intermediate.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class DuplexIntermediateBuffer(TypedDict, total=False):
+    """Structured keys carried through ``model_intermediate_buffer``.
+
+    The buffer remains a dict for scheduler and msgspec compatibility, but
+    duplex-specific producers and consumers should use the helpers in this
+    module instead of scattering nested string keys across serving, runner, and
+    model code.
+    """
+
+    request_id: str
+    global_request_id: list[str]
+    prompt_token_ids: list[int]
+    llm_output_token_ids: list[int]
+    llm_output_text: list[str]
+    stream_output: bool
+    native_duplex: bool
+    ids: dict[str, object]
+    hidden_states: dict[str, object]
+    codes: dict[str, object]
+    meta: dict[str, object]
+    duplex: dict[str, object]
+    omni_payload: object
+    waveform: object
+    mel_spec: object
+
+
+def build_duplex_intermediate_buffer(
+    *,
+    request_id: str,
+    prompt_token_ids: list[int] | None = None,
+    output_token_ids: list[int] | None = None,
+    output_text: str | None = None,
+    stream_output: bool = False,
+    native_duplex: bool = False,
+) -> DuplexIntermediateBuffer:
+    buffer: DuplexIntermediateBuffer = {
+        "global_request_id": [str(request_id)],
+        "ids": {},
+    }
+    if prompt_token_ids is not None:
+        prompt_ids = [int(token_id) for token_id in prompt_token_ids]
+        buffer["prompt_token_ids"] = prompt_ids
+        buffer["ids"]["prompt"] = prompt_ids
+    if output_token_ids is not None:
+        output_ids = [int(token_id) for token_id in output_token_ids]
+        buffer["llm_output_token_ids"] = output_ids
+        buffer["ids"]["output"] = output_ids
+    if output_text is not None:
+        buffer["llm_output_text"] = [output_text]
+    if stream_output:
+        buffer["stream_output"] = True
+    if native_duplex:
+        buffer["native_duplex"] = True
+    return buffer
+
+
+def set_ref_audio(buffer: dict[str, object], waveform: object, sample_rate_hz: int) -> None:
+    buffer.setdefault("codes", {})["ref"] = waveform
+    buffer.setdefault("meta", {})["ref_audio_sr"] = int(sample_rate_hz)
+
+
+def set_tts_handoff(buffer: dict[str, object], token_ids: object | None, hidden_states: object | None) -> None:
+    """Store the AR-to-TTS handoff used by the full-duplex stage bridge."""
+    if token_ids is not None:
+        buffer.setdefault("ids", {})["tts"] = token_ids
+    if hidden_states is not None:
+        buffer.setdefault("hidden_states", {})["tts"] = hidden_states
+
+
+def get_tts_handoff(info: dict[str, object]) -> tuple[object | None, object | None]:
+    """Read the canonical handoff, including the legacy flat aliases."""
+    ids_info = info.get("ids")
+    hidden_info = info.get("hidden_states")
+    token_ids = ids_info.get("tts") if isinstance(ids_info, dict) else None
+    hidden_states = hidden_info.get("tts") if isinstance(hidden_info, dict) else None
+    return (
+        info.get("tts_token_ids") if token_ids is None else token_ids,
+        info.get("tts_hidden_states") if hidden_states is None else hidden_states,
+    )
+
+
+def get_stream_request_key(info: dict[str, object]) -> str:
+    key = info.get("global_request_id") or info.get("request_id") or info.get("_omni_req_id")
+    if isinstance(key, (list, tuple)):
+        key = key[0] if key else None
+    if isinstance(key, bytes):
+        key = key.decode("utf-8", errors="replace")
+    if key is None:
+        raise ValueError(
+            "Duplex streaming handoff requires a stable request id; "
+            "expected global_request_id, request_id, or _omni_req_id."
+        )
+    return str(key)
diff --git a/vllm_omni/experimental/fullduplex/engine/lease.py b/vllm_omni/experimental/fullduplex/engine/lease.py
new file mode 100644
index 000000000..09430a7bb
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/lease.py
@@ -0,0 +1,129 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Generic engine lease primitives shared by optional session runtimes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+
+class DuplexLeaseActivity(str, Enum):
+    APPEND = "append"
+    SIGNAL = "signal"
+    PLAYBACK_ACK = "playback_ack"
+    HEARTBEAT = "heartbeat"
+    ATTACH = "attach"
+    DETACH = "detach"
+    RESUME = "resume"
+    MODEL_OUTPUT = "model_output"
+
+
+@dataclass(frozen=True)
+class DuplexLeaseConfig:
+    idle_ttl_s: float | None = 300.0
+    disconnect_grace_s: float = 30.0
+
+    def __post_init__(self) -> None:
+        if self.idle_ttl_s is not None and self.idle_ttl_s <= 0:
+            raise ValueError("idle_ttl_s must be positive or null")
+        if self.disconnect_grace_s <= 0:
+            raise ValueError("disconnect_grace_s must be positive")
+
+
+@dataclass
+class DuplexLeaseState:
+    config: DuplexLeaseConfig
+    generation: int
+    last_activity: float
+    detached_at: float | None = None
+    active_operations: set[str] = field(default_factory=set)
+    terminal_reason: str | None = None
+
+    @property
+    def expires_at(self) -> float | None:
+        if self.config.idle_ttl_s is None:
+            return None
+        return self.last_activity + self.config.idle_ttl_s
+
+    def _require_open(self) -> None:
+        if self.terminal_reason is not None:
+            raise RuntimeError(f"duplex lease is terminal: {self.terminal_reason}")
+
+    def touch(self, now: float, activity: DuplexLeaseActivity) -> None:
+        self._require_open()
+        if not isinstance(activity, DuplexLeaseActivity):
+            raise TypeError("lease activity must be DuplexLeaseActivity")
+        self.last_activity = now
+
+    def detach(self, now: float) -> None:
+        self.touch(now, DuplexLeaseActivity.DETACH)
+        self.detached_at = now
+
+    def resume(self, now: float, *, expected_generation: int) -> int:
+        self._require_open()
+        if expected_generation != self.generation:
+            raise ValueError(f"duplex lease generation mismatch: expected {self.generation}, got {expected_generation}")
+        self.generation += 1
+        self.detached_at = None
+        self.last_activity = now
+        return self.generation
+
+    def begin_operation(self, now: float, operation_id: str) -> None:
+        self._require_open()
+        if not operation_id:
+            raise ValueError("duplex lease operation_id must not be empty")
+        if operation_id in self.active_operations:
+            raise ValueError(f"duplex lease operation already active: {operation_id}")
+        self.active_operations.add(operation_id)
+        self.last_activity = now
+
+    def end_operation(self, now: float, operation_id: str) -> None:
+        self._require_open()
+        if operation_id not in self.active_operations:
+            raise KeyError(f"duplex lease operation is not active: {operation_id}")
+        self.active_operations.remove(operation_id)
+        self.last_activity = now
+
+    def disconnect_grace_expired(self, now: float) -> bool:
+        return (
+            self.terminal_reason is None
+            and self.detached_at is not None
+            and now >= self.detached_at + self.config.disconnect_grace_s
+        )
+
+    def idle_expired(self, now: float) -> bool:
+        expires_at = self.expires_at
+        return (
+            self.terminal_reason is None and not self.active_operations and expires_at is not None and now >= expires_at
+        )
+
+    def mark_terminal(self, reason: str) -> bool:
+        if self.terminal_reason is not None:
+            return False
+        self.terminal_reason = reason
+        self.generation += 1
+        self.detached_at = None
+        self.active_operations.clear()
+        return True
+
+
+@dataclass(frozen=True)
+class DuplexSessionExpiry:
+    session_id: str
+    fence: DuplexFence
+    lease_generation: int
+    reason: str
+    submitted_request_ids: tuple[str, ...]
+    reserved_request_ids: tuple[str, ...]
+
+
+__all__ = [
+    "DuplexLeaseActivity",
+    "DuplexLeaseConfig",
+    "DuplexLeaseState",
+    "DuplexSessionExpiry",
+]
diff --git a/vllm_omni/experimental/fullduplex/engine/messages.py b/vllm_omni/experimental/fullduplex/engine/messages.py
new file mode 100644
index 000000000..94f154a8a
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/engine/messages.py
@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Queue contracts owned by the experimental duplex control plane."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from vllm_omni.engine.messages import EngineQueueMessage
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexFence:
+    """Identity fence carried by experimental duplex control messages."""
+
+    session_id: str
+    epoch: int = 0
+    turn_id: int = 0
+    response_seq: int = 0
+    incarnation: int = 0
+
+
+class OpenDuplexSessionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["open_duplex_session"] = "open_duplex_session"
+    control_id: str
+    fence: DuplexFence
+    session_id: str
+    session_mode: str = "duplex"
+    capabilities: dict[str, object]
+    session_config: dict[str, object] | None = None
+    runtime_config: dict[str, object] | None = None
+
+
+class AppendDuplexInputMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["append_duplex_input"] = "append_duplex_input"
+    control_id: str
+    operation_id: str | None = None
+    fence: DuplexFence
+    session_id: str
+    expected_epoch: int | None = None
+    mode: str
+    payload: object
+    final: bool = False
+
+
+class SignalDuplexTurnMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["signal_duplex_turn"] = "signal_duplex_turn"
+    control_id: str
+    fence: DuplexFence
+    session_id: str
+    event: str
+    next_fence: DuplexFence | None = None
+    session_config: dict[str, object] | None = None
+    runtime_config: dict[str, object] | None = None
+
+
+class CloseDuplexSessionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["close_duplex_session"] = "close_duplex_session"
+    control_id: str
+    fence: DuplexFence
+    session_id: str
+    reason: str = "client_close"
+
+
+class TouchDuplexSessionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["touch_duplex_session"] = "touch_duplex_session"
+    control_id: str
+    fence: DuplexFence
+    session_id: str
+    activity: str
+
+
+class ResumeDuplexSessionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["resume_duplex_session"] = "resume_duplex_session"
+    control_id: str
+    fence: DuplexFence
+    session_id: str
+    expected_lease_generation: int
+
+
+class DuplexSessionLifecycleMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["duplex_session_lifecycle"] = "duplex_session_lifecycle"
+    fence: DuplexFence
+    session_id: str
+    event: str
+    reason: str
+    lease_generation: int
+    submitted_request_ids: list[str]
+    reserved_request_ids: list[str]
+
+
+class DuplexControlError(EngineQueueMessage, kw_only=True):
+    code: str
+    message: str
+    retryable: bool = False
+
+
+class DuplexControlResultMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["duplex_control_result"] = "duplex_control_result"
+    control_id: str
+    fence: DuplexFence
+    operation: str
+    session_id: str
+    ok: bool
+    stage_results: list[dict[str, object]]
+    unsupported_count: int = 0
+    error_count: int = 0
+    error: DuplexControlError | None = None
+    accepted_fence: DuplexFence | None = None
+    lease_generation: int | None = None
+
+    @property
+    def rpc_correlation_key(self) -> tuple[str, str]:
+        return ("duplex", self.control_id)
+
+
+__all__ = [
+    "AppendDuplexInputMessage",
+    "CloseDuplexSessionMessage",
+    "DuplexControlError",
+    "DuplexControlResultMessage",
+    "DuplexFence",
+    "DuplexSessionLifecycleMessage",
+    "OpenDuplexSessionMessage",
+    "ResumeDuplexSessionMessage",
+    "SignalDuplexTurnMessage",
+    "TouchDuplexSessionMessage",
+]
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/__init__.py b/vllm_omni/experimental/fullduplex/minicpmo45/__init__.py
new file mode 100644
index 000000000..6df010470
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/__init__.py
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from .adapter import MiniCPMO45ClientRuntimeConfigError, MiniCPMO45NativeDuplexServingAdapter
+from .input import MiniCPMO45PcmAppendBuffer
+from .policy import MiniCPMO45DuplexPolicy
+from .stage0 import MiniCPMO45Stage0DuplexRuntime
+
+__all__ = [
+    "MiniCPMO45DuplexPolicy",
+    "MiniCPMO45NativeDuplexServingAdapter",
+    "MiniCPMO45ClientRuntimeConfigError",
+    "MiniCPMO45PcmAppendBuffer",
+    "MiniCPMO45Stage0DuplexRuntime",
+]
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/adapter.py b/vllm_omni/experimental/fullduplex/minicpmo45/adapter.py
new file mode 100644
index 000000000..10d75320d
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/adapter.py
@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import base64
+from copy import deepcopy
+from typing import Any
+
+import numpy as np
+from vllm.multimodal.media import MediaConnector
+
+from vllm_omni.experimental.fullduplex.minicpmo45.policy import MiniCPMO45DuplexPolicy
+from vllm_omni.experimental.fullduplex.openai.protocol import DuplexSessionConfig
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    ServingRuntimeConfigError,
+)
+
+
+class MiniCPMO45ClientRuntimeConfigError(ServingRuntimeConfigError):
+    pass
+
+
+class MiniCPMO45NativeDuplexServingAdapter:
+    """Serving-side MiniCPM-o 4.5 native duplex session preparation.
+
+    The generic duplex WebSocket handler should not let client-supplied local
+    paths reach workers.  This adapter follows the existing media connector
+    boundary: serving resolves client media URIs, then workers receive only
+    normalized PCM payloads.  Server-owned model assets remain local paths here.
+    """
+
+    PRIVATE_RUNTIME_CONFIG_KEYS = frozenset(
+        {
+            "duplex_stage_sampling_params",
+            "duplex_stage_max_tokens",
+            "duplex_stage0_max_tokens",
+            "duplex_scheduler_token_id",
+            "duplex_first_append_context_tokens",
+            "ref_audio_data",
+            "ref_audio_format",
+            "ref_audio_sample_rate_hz",
+        }
+    )
+
+    @classmethod
+    def is_enabled(cls, config: DuplexSessionConfig) -> bool:
+        return config.extra_body.get("minicpmo45_native_duplex") is True
+
+    @classmethod
+    def validate_client_config(cls, config: DuplexSessionConfig) -> None:
+        cls.validate_client_extra_body(config.extra_body)
+
+    @classmethod
+    def validate_client_extra_body(cls, extra_body: object) -> None:
+        if not isinstance(extra_body, dict):
+            return
+        private_keys = sorted(cls.PRIVATE_RUNTIME_CONFIG_KEYS.intersection(extra_body))
+        if private_keys:
+            raise MiniCPMO45ClientRuntimeConfigError(
+                "native duplex runtime configuration is server-owned: " + ", ".join(private_keys)
+            )
+
+    @classmethod
+    def runtime_config_for_update(
+        cls,
+        config: DuplexSessionConfig,
+        current: object,
+    ) -> dict[str, object]:
+        runtime_config = deepcopy(dict(current)) if isinstance(current, dict) else {}
+        runtime_config["instructions"] = config.instructions
+        stage_max_tokens = runtime_config.get("duplex_stage_max_tokens")
+        stage_max_tokens = deepcopy(stage_max_tokens) if isinstance(stage_max_tokens, dict) else {}
+        stage_max_tokens["0"] = (
+            config.max_tokens if isinstance(config.max_tokens, int) and config.max_tokens > 0 else 20
+        )
+        stage_max_tokens.setdefault("1", 8192)
+        runtime_config["duplex_stage_max_tokens"] = stage_max_tokens
+
+        stage_sampling = runtime_config.get("duplex_stage_sampling_params")
+        stage_sampling = deepcopy(stage_sampling) if isinstance(stage_sampling, dict) else {}
+        stage0 = stage_sampling.get("0")
+        stage0 = deepcopy(stage0) if isinstance(stage0, dict) else {}
+        stage0["temperature"] = config.temperature if config.temperature is not None else 0.7
+        stage_sampling["0"] = stage0
+        runtime_config["duplex_stage_sampling_params"] = stage_sampling
+        return runtime_config
+
+    @classmethod
+    async def prepare_runtime_config(cls, config: DuplexSessionConfig, *, model_config: Any) -> dict[str, object]:
+        extra_body = dict(config.extra_body)
+        if any(key in extra_body for key in ("ref_audio_path", "tts_ref_audio_path")):
+            raise ValueError("ref_audio_path is not accepted by native duplex; use ref_audio URI instead")
+        cls.validate_client_config(config)
+        runtime_config: dict[str, object] = {"instructions": config.instructions}
+        cls._apply_default_scheduler_policy(runtime_config, config=config, model_config=model_config)
+
+        ref_audio = config.ref_audio
+        if ref_audio is None and isinstance(extra_body.get("ref_audio"), str):
+            ref_audio = extra_body.pop("ref_audio")
+        if ref_audio is None and isinstance(extra_body.get("tts_ref_audio"), str):
+            ref_audio = extra_body.pop("tts_ref_audio")
+
+        if ref_audio is None:
+            if any(str(modality).lower() == "audio" for modality in config.modalities):
+                raise MiniCPMO45ClientRuntimeConfigError(
+                    "MiniCPM-o native duplex audio output requires ref_audio",
+                    code="ref_audio_required",
+                )
+            cls._apply_first_append_context_tokens(
+                runtime_config,
+                model_config=model_config,
+                instructions=config.instructions,
+                ref_sample_count=None,
+            )
+            config.extra_body = extra_body
+            return runtime_config
+        else:
+            wav_np, sr = await cls.resolve_ref_audio(ref_audio, model_config=model_config)
+
+        wav_np = cls.normalize_ref_audio(wav_np, int(sr), target_sr=16000)
+        # Trim to a whole number of pooled audio embeddings (100 ms frames) so
+        # the first-append scheduler reserve can count them exactly.
+        usable = (len(wav_np) // MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN) * (
+            MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN
+        )
+        wav_np = wav_np[:usable]
+        ref_audio_bytes = np.ascontiguousarray(wav_np, dtype=np.float32).tobytes()
+        runtime_config["ref_audio_data"] = base64.b64encode(ref_audio_bytes).decode("ascii")
+        runtime_config["ref_audio_format"] = "pcm_f32le"
+        runtime_config["ref_audio_sample_rate_hz"] = 16000
+        cls._apply_first_append_context_tokens(
+            runtime_config,
+            model_config=model_config,
+            instructions=config.instructions,
+            ref_sample_count=len(wav_np),
+        )
+        config.extra_body = extra_body
+        config.ref_audio = None
+        return runtime_config
+
+    @classmethod
+    def _apply_default_scheduler_policy(
+        cls,
+        runtime_config: dict[str, object],
+        *,
+        config: DuplexSessionConfig,
+        model_config: Any,
+    ) -> None:
+        stage0_max_tokens = config.max_tokens if isinstance(config.max_tokens, int) and config.max_tokens > 0 else 20
+        runtime_config["duplex_stage_max_tokens"] = {"0": stage0_max_tokens, "1": 8192}
+        stage0_params: dict[str, object] = {
+            "temperature": config.temperature if config.temperature is not None else 0.7,
+            "top_p": 0.8,
+            "top_k": 20,
+            "repetition_penalty": 1.05,
+        }
+        stop_token_ids = cls._native_stage0_stop_token_ids(model_config)
+        if stop_token_ids:
+            stage0_params["stop_token_ids"] = stop_token_ids
+        runtime_config["duplex_stage_sampling_params"] = {"0": stage0_params}
+        scheduler_token_id = cls._native_scheduler_token_id(model_config)
+        if scheduler_token_id is not None:
+            runtime_config["duplex_scheduler_token_id"] = scheduler_token_id
+
+    @classmethod
+    def _apply_first_append_context_tokens(
+        cls,
+        runtime_config: dict[str, object],
+        *,
+        model_config: Any,
+        instructions: object,
+        ref_sample_count: int | None,
+    ) -> None:
+        """Precompute the exact session-context token count for the engine.
+
+        The first data-plane append carries the system template and optional
+        reference-audio embeddings ahead of the first unit. The engine
+        reserves scheduler slots from this count; an inexact count turns into
+        pad embeddings inside the model KV (surplus) or truncated context
+        (deficit), so it is computed with the same template and pooling math
+        the worker uses.
+        """
+        if "duplex_first_append_context_tokens" in runtime_config:
+            return
+        tokenizer = cls._load_native_tokenizer(model_config)
+        if tokenizer is None:
+            return
+        prefix, suffix = MiniCPMO45DuplexPolicy.session_context_texts(
+            instructions,
+            ref_sample_count is not None,
+        )
+        try:
+            prefix_ids = tokenizer.encode(prefix, add_special_tokens=False)
+            suffix_ids = tokenizer.encode(suffix, add_special_tokens=False)
+        except Exception:
+            return
+        ref_tokens = MiniCPMO45DuplexPolicy.audio_token_count(ref_sample_count or 0)
+        runtime_config["duplex_first_append_context_tokens"] = len(prefix_ids) + ref_tokens + len(suffix_ids)
+
+    @staticmethod
+    def _native_stage0_stop_token_ids(model_config: Any) -> list[int]:
+        tokenizer = MiniCPMO45NativeDuplexServingAdapter._load_native_tokenizer(model_config)
+        if tokenizer is None:
+            return []
+        out: list[int] = []
+        stop_token_fields = (
+            "chunk_eos_token_id",
+            "chunk_tts_eos_token_id",
+            "listen_token_id",
+            "turn_eos_token_id",
+        )
+        for field in stop_token_fields:
+            token = MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS[field]
+            token_id = MiniCPMO45NativeDuplexServingAdapter._convert_token_to_id(tokenizer, token)
+            if token_id is not None and token_id not in out:
+                out.append(token_id)
+        return out
+
+    @staticmethod
+    def _native_scheduler_token_id(model_config: Any) -> int | None:
+        tokenizer = MiniCPMO45NativeDuplexServingAdapter._load_native_tokenizer(model_config)
+        if tokenizer is None:
+            return None
+        scheduler_tokens = (
+            MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS["unit_token_id"],
+            MiniCPMO45DuplexPolicy.OPTIONAL_TOKEN_FIELDS["audio_placeholder_token_id"],
+        )
+        for token in scheduler_tokens:
+            token_id = MiniCPMO45NativeDuplexServingAdapter._convert_token_to_id(tokenizer, token)
+            if token_id is not None:
+                return token_id
+        eos_id = getattr(tokenizer, "eos_token_id", None)
+        try:
+            return int(eos_id)
+        except (TypeError, ValueError):
+            return None
+
+    @staticmethod
+    def _load_native_tokenizer(model_config: Any) -> Any | None:
+        model_path = getattr(model_config, "model", None)
+        if not isinstance(model_path, str) or not model_path:
+            return None
+        try:
+            from transformers import AutoTokenizer
+
+            return AutoTokenizer.from_pretrained(
+                model_path,
+                trust_remote_code=True,
+                local_files_only=True,
+            )
+        except Exception:
+            return None
+
+    @staticmethod
+    def _convert_token_to_id(tokenizer: Any, token: str) -> int | None:
+        convert = getattr(tokenizer, "convert_tokens_to_ids", None)
+        value = None
+        if callable(convert):
+            value = convert(token)
+            if isinstance(value, list):
+                value = value[0] if len(value) == 1 else None
+        try:
+            token_id = int(value)
+        except (TypeError, ValueError):
+            token_id = -1
+        unk_token_id = getattr(tokenizer, "unk_token_id", None)
+        if token_id >= 0 and token_id != unk_token_id:
+            return token_id
+        encode = getattr(tokenizer, "encode", None)
+        if callable(encode):
+            try:
+                ids = list(encode(token, add_special_tokens=False))
+            except TypeError:
+                ids = list(encode(token))
+            if len(ids) == 1:
+                try:
+                    token_id = int(ids[0])
+                except (TypeError, ValueError):
+                    token_id = -1
+                if token_id >= 0 and token_id != unk_token_id:
+                    return token_id
+        return None
+
+    @staticmethod
+    async def resolve_ref_audio(ref_audio: str, *, model_config: Any) -> tuple[np.ndarray, int]:
+        connector = MediaConnector(
+            allowed_local_media_path=getattr(model_config, "allowed_local_media_path", None),
+            allowed_media_domains=getattr(model_config, "allowed_media_domains", None),
+        )
+        wav_np, sr = await connector.fetch_audio_async(ref_audio)
+        return np.asarray(wav_np, dtype=np.float32), int(sr)
+
+    @staticmethod
+    def normalize_ref_audio(wav_np: np.ndarray, sample_rate: int, *, target_sr: int) -> np.ndarray:
+        wav_np = np.asarray(wav_np, dtype=np.float32)
+        if wav_np.ndim > 1:
+            wav_np = wav_np.mean(axis=-1)
+        wav_np = wav_np.reshape(-1)
+        if sample_rate <= 0 or sample_rate == target_sr or wav_np.size == 0:
+            return wav_np.astype(np.float32, copy=False)
+        import torch
+        import torchaudio
+
+        audio = torch.from_numpy(wav_np).to(dtype=torch.float32).unsqueeze(0)
+        resampled = torchaudio.functional.resample(audio, int(sample_rate), int(target_sr))
+        return resampled.squeeze(0).cpu().numpy().astype(np.float32, copy=False)
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/compat.py b/vllm_omni/experimental/fullduplex/minicpmo45/compat.py
new file mode 100644
index 000000000..9b44bed4c
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/compat.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def patch_minicpmo_remote_config(config: Any) -> None:
+    """Fill config fields expected by the vLLM MiniCPM implementation."""
+    seen: set[int] = set()
+
+    def patch_cfg(cfg: Any) -> None:
+        if cfg is None or id(cfg) in seen:
+            return
+        seen.add(id(cfg))
+        if getattr(cfg, "base_model_tp_plan", None) is None:
+            setattr(cfg, "base_model_tp_plan", {})
+        for value in getattr(cfg, "__dict__", {}).values():
+            if value is cfg:
+                continue
+            if hasattr(value, "__dict__") and (
+                value.__class__.__name__.endswith("Config")
+                or hasattr(value, "model_type")
+                or hasattr(value, "base_model_tp_plan")
+            ):
+                patch_cfg(value)
+
+    patch_cfg(config)
+    tts_config = getattr(config, "tts_config", None)
+    if tts_config is None:
+        return
+    defaults = {
+        "top_p": 0.8,
+        "top_k": 100,
+        "temperature": 0.8,
+        "repetition_penalty": 1.05,
+    }
+    for name, value in defaults.items():
+        if isinstance(tts_config, dict):
+            tts_config.setdefault(name, value)
+        elif not hasattr(tts_config, name):
+            setattr(tts_config, name, value)
+
+
+__all__ = ["patch_minicpmo_remote_config"]
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/data_plane.py b/vllm_omni/experimental/fullduplex/minicpmo45/data_plane.py
new file mode 100644
index 000000000..d18c0f4a9
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/data_plane.py
@@ -0,0 +1,837 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass, field
+
+import numpy as np
+from vllm.logger import init_logger
+
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    duplex_resource_request_belongs_to_session,
+)
+from vllm_omni.experimental.fullduplex.output import get_duplex_output_decision
+
+logger = init_logger(__name__)
+
+EncodeAudio = Callable[[object, int, str, float | None], str | None]
+
+
+@dataclass(frozen=True, slots=True)
+class MiniCPMO45DataPlaneContext:
+    """Serving state needed to project one MiniCPM data-plane output."""
+
+    epoch: int = 0
+    turn_id: int = 0
+    active_response_turn_id: int | None = None
+    active_response_id: str | None = None
+    auto_responds: bool = False
+    response_format: str = "wav"
+    speed: float | None = None
+    modalities: tuple[str, ...] = ()
+
+
+@dataclass(slots=True)
+class _TurnState:
+    sent_segment_text: str = ""
+    has_text: bool = False
+    tts_eos_done: bool = False
+    turn_eos_done: bool = False
+
+
+@dataclass(slots=True)
+class _RequestState:
+    audio_offset: int = 0
+    uses_segment_text_metadata: bool = False
+    pending_audio_without_text: list[dict[str, object]] = field(default_factory=list)
+    terminal: bool = False
+    turns: dict[int | None, _TurnState] = field(default_factory=dict)
+
+    def turn(self, turn_id: int | None) -> _TurnState:
+        return self.turns.setdefault(turn_id, _TurnState())
+
+
+class MiniCPMO45DataPlaneSession:
+    """MiniCPM output projector and request/turn cursor owner.
+
+    The scheduler request owns cumulative Stage1 audio, while model turns own
+    transcript and terminal cursors. Keeping both levels in one object avoids
+    leaking MiniCPM-specific state into the generic Realtime handler.
+    """
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        self._encode_audio = encode_audio
+        self._requests: dict[str, _RequestState] = {}
+
+    def begin_request(self, request_id: str) -> None:
+        state = self._requests.setdefault(request_id, _RequestState())
+        state.terminal = False
+        # A resumable append starts a new Talker segment, even when it
+        # continues the same model turn. Re-arm only the segment boundary;
+        # turn EOS remains deduplicated until the model advances the turn.
+        for turn_state in state.turns.values():
+            turn_state.tts_eos_done = False
+
+    def is_terminal(self, request_id: str | None) -> bool:
+        if request_id is None:
+            return False
+        state = self._requests.get(request_id)
+        return state is not None and state.terminal
+
+    def mark_terminal(self, request_id: str) -> None:
+        self._requests.setdefault(request_id, _RequestState()).terminal = True
+
+    def close_stream(self, request_id: str) -> None:
+        """Release non-resumable request cursors after its drain finishes."""
+        state = self._requests.get(request_id)
+        if state is None:
+            return
+        state.audio_offset = 0
+        state.turns.pop(None, None)
+
+    def close_request(self, request_id: str) -> None:
+        self._requests.pop(request_id, None)
+
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None:
+        if active_request_id is not None:
+            self.close_request(active_request_id)
+        for request_id in list(self._requests):
+            if self.request_belongs_to_session(request_id, session_id):
+                self.close_request(request_id)
+
+    def has_request(self, request_id: str) -> bool:
+        return request_id in self._requests
+
+    def has_pending_audio(self, request_id: str) -> bool:
+        state = self._requests.get(request_id)
+        return bool(state and state.pending_audio_without_text)
+
+    def audio_offset(self, request_id: str | None) -> int | None:
+        if request_id is None:
+            return None
+        state = self._requests.get(request_id)
+        return state.audio_offset if state is not None and state.audio_offset > 0 else None
+
+    def project(
+        self,
+        result: object,
+        *,
+        context: MiniCPMO45DataPlaneContext | None = None,
+    ) -> Iterator[dict[str, object]]:
+        if not isinstance(result, dict):
+            return
+        outputs = result.get("data_plane_outputs")
+        if not isinstance(outputs, list):
+            return
+        for output in outputs:
+            yield from self.project_output(output, context=context)
+
+    def project_output(
+        self,
+        output: object,
+        *,
+        context: MiniCPMO45DataPlaneContext | None = None,
+    ) -> Iterator[dict[str, object]]:
+        context = context or MiniCPMO45DataPlaneContext()
+        stage_metrics = _output_stage_metrics(output)
+
+        def runtime_result(**values: object) -> dict[str, object]:
+            result = _runtime_result(**values)
+            if stage_metrics is not None:
+                result["stage_metrics"] = stage_metrics
+            return result
+
+        request_id = getattr(output, "request_id", None)
+        if not isinstance(request_id, str) or not request_id:
+            request_id = None
+        request_state = self._requests.setdefault(request_id, _RequestState()) if request_id is not None else None
+
+        outputs = getattr(output, "outputs", None)
+        completion = outputs[0] if isinstance(outputs, list) and outputs else None
+        text = getattr(completion, "text", "") if completion is not None else ""
+        direct_decision = get_duplex_output_decision(output)
+        direct_metadata = getattr(direct_decision, "metadata", None)
+        if isinstance(direct_metadata, Mapping):
+            mm_output = direct_metadata
+        else:
+            mm_output = getattr(output, "multimodal_output", None)
+        if not isinstance(mm_output, Mapping):
+            mm_output = getattr(completion, "multimodal_output", {}) if completion is not None else {}
+        if not mm_output:
+            inner_output = getattr(output, "request_output", None)
+            if inner_output is not None and inner_output is not output:
+                inner_mm_output = getattr(inner_output, "multimodal_output", None)
+                if isinstance(inner_mm_output, Mapping) and inner_mm_output:
+                    mm_output = inner_mm_output
+                else:
+                    inner_outputs = getattr(inner_output, "outputs", None)
+                    inner_completion = inner_outputs[0] if isinstance(inner_outputs, list) and inner_outputs else None
+                    inner_mm_output = (
+                        getattr(inner_completion, "multimodal_output", None) if inner_completion is not None else None
+                    )
+                    if completion is None and inner_completion is not None:
+                        completion = inner_completion
+                        text = getattr(inner_completion, "text", "") or text
+                    if isinstance(inner_mm_output, Mapping):
+                        mm_output = inner_mm_output
+        mm_output = dict(mm_output) if isinstance(mm_output, Mapping) else {}
+
+        output_turn_id = output_turn_id_from_metadata(mm_output)
+        output_epoch = output_epoch_from_metadata(mm_output)
+        expected_turn_id = context.active_response_turn_id
+        stale_turn = expected_turn_id is not None and output_turn_id is not None and output_turn_id < expected_turn_id
+        if expected_turn_id is None and output_turn_id is not None:
+            stale_turn = output_turn_id < context.turn_id
+        stale_epoch = output_epoch is not None and output_epoch != context.epoch
+        if context.auto_responds and (stale_turn or stale_epoch):
+            return
+
+        mm_text = _llm_output_text(mm_output)
+        if mm_text:
+            text = mm_text
+            if request_state is not None:
+                request_state.uses_segment_text_metadata = True
+        elif request_state is not None and request_state.uses_segment_text_metadata:
+            text = ""
+
+        finished = bool(getattr(output, "finished", False))
+        tts_is_last_chunk = _bool_metadata(mm_output, ("tts_is_last_chunk",), default=False)
+        token_ids = _completion_token_ids(completion)
+        native_decision = _native_decision(completion, mm_output, token_ids=token_ids, finished=finished)
+        if native_decision == "listen":
+            listen_result = runtime_result(
+                stage_role="llm",
+                is_listen=True,
+                model_listen=True,
+                listen_source="model_listen",
+                data_plane_request_id=request_id,
+                end_of_turn=False,
+            )
+            if output_turn_id is not None:
+                listen_result["model_turn_id"] = output_turn_id
+            yield listen_result
+            return
+
+        raw_audio = next((mm_output[key] for key in ("audio", "model_outputs", "latent") if key in mm_output), None)
+        raw_audio_samples = _audio_num_samples(raw_audio)
+        offset_before = self.audio_offset(request_id)
+        audio_chunks = list(
+            self._encode_audio_chunks_with_duration(
+                mm_output,
+                request_id=request_id,
+                response_format=context.response_format,
+                speed=context.speed,
+            )
+        )
+        stage_turn_end = _bool_metadata(mm_output, ("turn_end", "end_of_turn"), default=False)
+        terminal_turn_state = request_state.turn(output_turn_id) if request_state is not None else None
+        stage_tts_eos = (
+            context.auto_responds
+            and 151645 in token_ids
+            and not audio_chunks
+            and raw_audio_samples is not None
+            and (raw_audio_samples == 0 or raw_audio_samples == offset_before)
+            and (terminal_turn_state is None or not terminal_turn_state.tts_eos_done)
+        )
+        tts_segment_end = bool(tts_is_last_chunk or stage_tts_eos) and (
+            terminal_turn_state is None or not terminal_turn_state.tts_eos_done
+        )
+        if tts_segment_end and terminal_turn_state is not None:
+            terminal_turn_state.tts_eos_done = True
+        stage_turn_end_new = bool(stage_turn_end) and (
+            terminal_turn_state is None or not terminal_turn_state.turn_eos_done
+        )
+        if stage_turn_end_new and terminal_turn_state is not None:
+            terminal_turn_state.turn_eos_done = True
+        unit_end_of_turn = stage_turn_end_new or (finished and not context.auto_responds)
+
+        text_turn_id = output_turn_id if output_turn_id is not None else context.turn_id
+        text_turn_state = request_state.turn(text_turn_id) if request_state is not None else None
+        if audio_chunks:
+            delta_text = self.segment_text_delta(request_id, text, turn_id=text_turn_id)
+            last_idx = len(audio_chunks) - 1
+            sample_rate_hz = _sample_rate_hz(mm_output)
+            audio_text_marks = _audio_text_marks(mm_output)
+            fallback_marks = _fallback_audio_text_marks(audio_chunks, delta_text)
+            audio_results: list[dict[str, object]] = []
+            for idx, (audio, duration_ms) in enumerate(audio_chunks):
+                native_result = runtime_result(
+                    stage_role="tts",
+                    is_listen=False,
+                    data_plane_request_id=request_id,
+                    text=delta_text if idx == 0 else "",
+                    audio_data=audio,
+                    audio_format=context.response_format,
+                    audio_duration_ms=duration_ms,
+                    audio_text_mark=idx == last_idx,
+                    sample_rate_hz=sample_rate_hz,
+                    end_of_turn=unit_end_of_turn and idx == last_idx,
+                    abort_data_plane_request=tts_segment_end and idx == last_idx,
+                )
+                if output_turn_id is not None:
+                    native_result["model_turn_id"] = output_turn_id
+                if audio_text_marks and idx == last_idx:
+                    native_result["audio_text_marks"] = audio_text_marks
+                    native_result["audio_text_marks_are_cumulative"] = True
+                elif idx < len(fallback_marks) and fallback_marks[idx]:
+                    native_result["audio_text_marks"] = fallback_marks[idx]
+                    native_result["audio_text_marks_are_cumulative"] = True
+                audio_results.append(native_result)
+
+            if context.auto_responds:
+                if delta_text and text_turn_state is not None:
+                    text_turn_state.has_text = True
+                future_model_turn = (
+                    context.active_response_turn_id is not None
+                    and output_turn_id is not None
+                    and output_turn_id > context.active_response_turn_id
+                )
+                response_turn_bound = context.active_response_id is not None and (
+                    output_turn_id is None
+                    or context.active_response_turn_id is None
+                    or context.active_response_turn_id == output_turn_id
+                )
+                turn_has_text = text_turn_state is not None and text_turn_state.has_text
+                if not future_model_turn and not response_turn_bound and not turn_has_text:
+                    if request_state is not None:
+                        if tts_segment_end:
+                            request_state.pending_audio_without_text.clear()
+                        else:
+                            request_state.pending_audio_without_text.extend(audio_results)
+                    if tts_segment_end:
+                        terminal_result = dict(audio_results[-1])
+                        terminal_result.update(
+                            audio_data="",
+                            audio_duration_ms=0,
+                            audio_text_mark=False,
+                            end_of_turn=True,
+                        )
+                        yield terminal_result
+                    return
+                if request_state is not None and request_state.pending_audio_without_text:
+                    pending = request_state.pending_audio_without_text
+                    request_state.pending_audio_without_text = []
+                    yield from pending
+            yield from audio_results
+            return
+
+        if context.auto_responds and request_state is not None and isinstance(text, str) and text:
+            pending_audio = request_state.pending_audio_without_text
+            request_state.pending_audio_without_text = []
+            if pending_audio:
+                delta_text = self.segment_text_delta(request_id, text, turn_id=text_turn_id)
+                if delta_text:
+                    pending_audio[0]["text"] = delta_text
+                    if text_turn_state is not None:
+                        text_turn_state.has_text = True
+                    total_duration_ms = sum(
+                        max(0, int(result.get("audio_duration_ms", 0) or 0)) for result in pending_audio
+                    )
+                    if total_duration_ms > 0 and not pending_audio[-1].get("audio_text_marks"):
+                        pending_audio[-1]["audio_text_marks"] = [
+                            {"text_chars": len(delta_text), "audio_end_ms": total_duration_ms}
+                        ]
+                        pending_audio[-1]["audio_text_marks_are_cumulative"] = True
+                    if unit_end_of_turn:
+                        pending_audio[-1]["end_of_turn"] = True
+                    if tts_segment_end:
+                        pending_audio[-1]["abort_data_plane_request"] = True
+                    yield from pending_audio
+                    return
+                request_state.pending_audio_without_text = pending_audio
+
+        if tts_segment_end:
+            if unit_end_of_turn and request_state is not None and request_state.pending_audio_without_text:
+                request_state.pending_audio_without_text[-1]["end_of_turn"] = True
+                request_state.pending_audio_without_text[-1]["abort_data_plane_request"] = True
+            terminal_result = runtime_result(
+                stage_role="tts",
+                is_listen=False,
+                data_plane_request_id=request_id,
+                text="",
+                audio_data="",
+                audio_format=context.response_format,
+                audio_text_mark=False,
+                end_of_turn=unit_end_of_turn,
+                abort_data_plane_request=True,
+            )
+            if output_turn_id is not None:
+                terminal_result["model_turn_id"] = output_turn_id
+            yield terminal_result
+            return
+
+        if context.active_response_id is not None and unit_end_of_turn:
+            terminal_result = runtime_result(
+                stage_role="tts",
+                is_listen=False,
+                data_plane_request_id=request_id,
+                text="",
+                audio_data="",
+                audio_format=context.response_format,
+                audio_text_mark=False,
+                end_of_turn=True,
+            )
+            if output_turn_id is not None:
+                terminal_result["model_turn_id"] = output_turn_id
+            yield terminal_result
+            return
+
+        if request_id is not None and context.auto_responds and unit_end_of_turn and context.active_response_id is None:
+            # The legacy projector only removed the request-scoped pending
+            # buffer here when no explicit model-turn key was present.
+            if request_state is not None and output_turn_id is None:
+                request_state.pending_audio_without_text.clear()
+            terminal_result = runtime_result(
+                stage_role="tts",
+                is_listen=False,
+                data_plane_request_id=request_id,
+                text="",
+                audio_data="",
+                audio_format=context.response_format,
+                audio_text_mark=False,
+                end_of_turn=True,
+                abort_data_plane_request=True,
+            )
+            if output_turn_id is not None:
+                terminal_result["model_turn_id"] = output_turn_id
+            yield terminal_result
+            return
+
+        if (
+            finished
+            and context.auto_responds
+            and context.active_response_id is not None
+            and request_id is not None
+            and not unit_end_of_turn
+        ):
+            listen_result = runtime_result(
+                stage_role="llm",
+                is_listen=True,
+                model_listen=False,
+                listen_source="auto_response_segment_complete",
+                reason="auto_response_segment_complete",
+                data_plane_request_id=request_id,
+                end_of_turn=False,
+            )
+            if output_turn_id is not None:
+                listen_result["model_turn_id"] = output_turn_id
+            yield listen_result
+            return
+
+        if not text:
+            if context.auto_responds:
+                return
+            if finished:
+                listen_result = runtime_result(
+                    stage_role="llm",
+                    is_listen=True,
+                    model_listen=False,
+                    listen_source="data_plane_finished_without_output",
+                    reason="data_plane_finished_without_output",
+                    data_plane_request_id=request_id,
+                    end_of_turn=False,
+                )
+                if output_turn_id is not None:
+                    listen_result["model_turn_id"] = output_turn_id
+                yield listen_result
+            return
+        if context.auto_responds:
+            return
+        if "audio" in context.modalities:
+            yield runtime_result(
+                stage_role="tts",
+                error_code="runtime_data_plane_text_without_audio",
+                error="MiniCPM-o native duplex data-plane produced text without audio.",
+                data_plane_request_id=request_id,
+            )
+            return
+        yield runtime_result(
+            stage_role="llm",
+            is_listen=False,
+            data_plane_request_id=request_id,
+            text=text if isinstance(text, str) else "",
+            audio_data="",
+            end_of_turn=unit_end_of_turn,
+        )
+
+    def segment_text_delta(self, request_id: str | None, text: object, *, turn_id: int | None = None) -> str:
+        if not isinstance(text, str) or not text:
+            return ""
+        if request_id is None:
+            return text
+        turn_state = self._requests.setdefault(request_id, _RequestState()).turn(turn_id)
+        sent_text = turn_state.sent_segment_text
+        if not sent_text:
+            delta_text = text
+        elif text == sent_text:
+            delta_text = ""
+        elif text.startswith(sent_text):
+            delta_text = text[len(sent_text) :]
+        else:
+            # The producer sends text for the current thinker segment, not a
+            # cumulative turn snapshot. Distinct adjacent segments need not
+            # have a prefix relationship and must both remain visible.
+            delta_text = text
+        turn_state.sent_segment_text = text
+        return delta_text
+
+    def slice_cumulative_audio(self, request_id: str | None, audio_data: object) -> object:
+        if request_id is None:
+            return audio_data
+        num_samples = _audio_num_samples(audio_data)
+        if num_samples is None or num_samples <= 0:
+            return audio_data
+        state = self._requests.setdefault(request_id, _RequestState())
+        prev_samples = state.audio_offset
+        if prev_samples <= 0:
+            state.audio_offset = num_samples
+            return audio_data
+        if num_samples == prev_samples:
+            return None
+        if num_samples < prev_samples:
+            state.audio_offset = num_samples
+            return audio_data
+        state.audio_offset = num_samples
+        try:
+            import torch
+
+            if isinstance(audio_data, torch.Tensor):
+                return audio_data.reshape(-1)[prev_samples:].contiguous()
+            return np.asarray(audio_data, dtype=np.float32).reshape(-1)[prev_samples:]
+        except Exception:
+            logger.exception("Failed to slice cumulative duplex audio output")
+            return audio_data
+
+    def _encode_audio_chunks_with_duration(
+        self,
+        mm_output: dict[str, object],
+        *,
+        request_id: str | None,
+        response_format: str,
+        speed: float | None,
+    ) -> Iterator[tuple[str, int]]:
+        sample_rate_hz = _sample_rate_hz(mm_output)
+        audio_data = next((mm_output[key] for key in ("audio", "model_outputs", "latent") if key in mm_output), None)
+        if isinstance(audio_data, list):
+            for value in audio_data:
+                encoded = self._encode_audio(value, sample_rate_hz, response_format, speed)
+                if encoded:
+                    duration_ms = int((_audio_num_samples(value) or 0) * 1000 / max(1, sample_rate_hz))
+                    yield encoded, duration_ms
+            return
+        sliced = self.slice_cumulative_audio(request_id, audio_data)
+        encoded = self._encode_audio(sliced, sample_rate_hz, response_format, speed)
+        if encoded:
+            duration_ms = int((_audio_num_samples(sliced) or 0) * 1000 / max(1, sample_rate_hz))
+            yield encoded, duration_ms
+
+    @staticmethod
+    def request_belongs_to_session(request_id: str, session_id: str) -> bool:
+        return (
+            duplex_resource_request_belongs_to_session(request_id, session_id)
+            or request_id.startswith(f"duplex-{session_id}-")
+            or request_id.startswith(f"chatcmpl-duplex-{session_id}-")
+        )
+
+
+def coerce_int(value: object) -> int | None:
+    if hasattr(value, "detach"):
+        try:
+            value = value.detach().cpu().reshape(-1)
+            if value.numel() == 0:
+                return None
+            value = value[0].item()
+        except Exception:
+            return None
+    elif hasattr(value, "reshape") and hasattr(value, "size"):
+        try:
+            value = value.reshape(-1)
+            if int(value.size) == 0:
+                return None
+            item = value[0]
+            value = item.item() if hasattr(item, "item") else item
+        except Exception:
+            return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def payload_turn_id(payload: object) -> int | None:
+    if not isinstance(payload, Mapping):
+        return None
+    return coerce_int(payload.get("duplex_turn_id"))
+
+
+def output_turn_id_from_metadata(mm_output: dict[str, object]) -> int | None:
+    return _first_metadata_int(mm_output, "duplex_turn_id", "turn_id")
+
+
+def output_epoch_from_metadata(mm_output: dict[str, object]) -> int | None:
+    return _first_metadata_int(mm_output, "duplex_epoch", "epoch")
+
+
+def _first_metadata_int(mm_output: dict[str, object], *names: str) -> int | None:
+    candidates: list[object] = []
+    meta = mm_output.get("meta")
+    for name in names:
+        candidates.extend((mm_output.get(name), mm_output.get(f"meta.{name}")))
+        if isinstance(meta, dict):
+            candidates.append(meta.get(name))
+    for value in candidates:
+        result = coerce_int(value)
+        if result is not None:
+            return result
+    return None
+
+
+def _runtime_result(**values: object) -> dict[str, object]:
+    return {
+        "supported": True,
+        **values,
+        "uses_model_runner_scheduler": True,
+        "runner_kv_backed": True,
+        "runtime_impl": "scheduler_data_plane",
+        "owned_runtime": False,
+    }
+
+
+def _output_stage_metrics(output: object) -> dict[str, dict[str, object]] | None:
+    metrics = getattr(output, "metrics", None)
+    if not isinstance(metrics, Mapping):
+        return None
+    stage_metrics = metrics.get("stage_metrics")
+    if not isinstance(stage_metrics, Mapping):
+        return None
+    snapshot = {
+        str(stage_id): dict(values) for stage_id, values in stage_metrics.items() if isinstance(values, Mapping)
+    }
+    return snapshot or None
+
+
+def _native_decision(
+    completion: object,
+    mm_output: dict[str, object],
+    *,
+    token_ids: list[int],
+    finished: bool,
+) -> str | None:
+    if not finished:
+        return None
+    if mm_output.get("duplex_native_decision") == "listen" or mm_output.get("model_listen") is True:
+        return "listen"
+    listen_id = _special_token_ids(mm_output).get("listen_token_id")
+    if listen_id is None:
+        return None
+    stop_reason = getattr(completion, "stop_reason", None) if completion is not None else None
+    if coerce_int(stop_reason) == listen_id:
+        return "listen"
+    return "listen" if token_ids and token_ids[-1] == listen_id else None
+
+
+def _special_token_ids(mm_output: dict[str, object]) -> dict[str, int]:
+    sources: list[object] = []
+    raw_special = mm_output.get("special_token_ids")
+    if isinstance(raw_special, dict):
+        sources.append(raw_special)
+    raw_meta = mm_output.get("meta")
+    if isinstance(raw_meta, dict):
+        sources.append(raw_meta)
+    sources.append(
+        {
+            key.removeprefix("meta."): value
+            for key, value in mm_output.items()
+            if isinstance(key, str) and key.startswith("meta.")
+        }
+    )
+    out: dict[str, int] = {}
+    for source in sources:
+        if not isinstance(source, dict):
+            continue
+        for key, value in source.items():
+            if not isinstance(key, str):
+                continue
+            token_id = coerce_int(value)
+            if token_id is not None and token_id >= 0:
+                out[key] = token_id
+    return out
+
+
+def _completion_token_ids(completion: object) -> list[int]:
+    if completion is None:
+        return []
+    for candidate in (
+        getattr(completion, "token_ids", None),
+        getattr(completion, "cumulative_token_ids", None),
+    ):
+        token_ids = _coerce_int_list(candidate)
+        if token_ids:
+            return token_ids
+    return []
+
+
+def _coerce_int_list(value: object) -> list[int]:
+    if value is None:
+        return []
+    if hasattr(value, "detach"):
+        try:
+            value = value.detach().cpu().reshape(-1).tolist()
+        except Exception:
+            return []
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [item for raw in value if (item := coerce_int(raw)) is not None]
+
+
+def _audio_num_samples(audio_data: object) -> int | None:
+    try:
+        import torch
+
+        if isinstance(audio_data, torch.Tensor):
+            return int(audio_data.numel())
+        return int(np.asarray(audio_data, dtype=np.float32).size)
+    except Exception:
+        return None
+
+
+def _bool_metadata(
+    mm_output: dict[str, object],
+    names: tuple[str, ...],
+    *,
+    default: bool,
+) -> bool:
+    def coerce(value: object) -> bool | None:
+        if value is None:
+            return None
+        if isinstance(value, bool):
+            return value
+        try:
+            import torch
+
+            if isinstance(value, torch.Tensor):
+                return bool(value.reshape(-1)[-1].item()) if value.numel() else None
+        except Exception:
+            pass
+        if isinstance(value, np.ndarray):
+            return bool(value.reshape(-1)[-1].item()) if value.size else None
+        if isinstance(value, np.generic):
+            return bool(value.item())
+        if isinstance(value, (list, tuple)):
+            return coerce(value[-1]) if value else None
+        if isinstance(value, (int, float)):
+            return bool(value)
+        return None
+
+    meta = mm_output.get("meta")
+    for name in names:
+        for key in (name, f"meta.{name}"):
+            result = coerce(mm_output.get(key))
+            if result is not None:
+                return result
+        if isinstance(meta, dict):
+            result = coerce(meta.get(name))
+            if result is not None:
+                return result
+    return default
+
+
+def _sample_rate_hz(mm_output: dict[str, object]) -> int:
+    sr_raw = mm_output.get("sr")
+    if sr_raw is None:
+        sr_raw = mm_output.get("sample_rate_hz", mm_output.get("sample_rate"))
+    meta = mm_output.get("meta")
+    if sr_raw is None and isinstance(meta, dict):
+        sr_raw = meta.get("sr") or meta.get("sample_rate_hz") or meta.get("sample_rate")
+    if sr_raw is None:
+        sr_raw = mm_output.get("meta.sr") or mm_output.get("meta.sample_rate_hz") or mm_output.get("meta.sample_rate")
+    if hasattr(sr_raw, "item"):
+        try:
+            return int(sr_raw.item())
+        except Exception:
+            return 24000
+    return int(sr_raw) if isinstance(sr_raw, (int, float)) else 24000
+
+
+def _audio_text_marks(mm_output: dict[str, object]) -> list[dict[str, object]]:
+    names = ("audio_text_marks", "text_audio_marks", "audio_text_alignment", "alignment_marks")
+    candidates = [mm_output.get(name) for name in names]
+    meta = mm_output.get("meta")
+    if isinstance(meta, dict):
+        candidates.extend(meta.get(name) for name in names)
+    candidates.extend(
+        value
+        for key, value in mm_output.items()
+        if isinstance(key, str) and key.startswith("meta.") and key.rsplit(".", 1)[-1] in names
+    )
+    for raw in candidates:
+        if not isinstance(raw, list):
+            continue
+        marks: list[dict[str, object]] = []
+        for item in raw:
+            if not isinstance(item, dict):
+                continue
+            text_chars = item.get("text_chars")
+            audio_end_ms = item.get("audio_end_ms", item.get("audio_ms"))
+            if isinstance(text_chars, (int, float)) and isinstance(audio_end_ms, (int, float)):
+                marks.append({"text_chars": max(0, int(text_chars)), "audio_end_ms": max(0, int(audio_end_ms))})
+        if marks:
+            return marks
+    return []
+
+
+def _llm_output_text(mm_output: dict[str, object]) -> str:
+    candidates: list[object] = [
+        mm_output.get("llm_output_text"),
+        mm_output.get("text"),
+        mm_output.get("llm_output_text_utf8"),
+        mm_output.get("meta.llm_output_text_utf8"),
+    ]
+    meta = mm_output.get("meta")
+    if isinstance(meta, dict):
+        candidates.extend((meta.get("llm_output_text"), meta.get("text"), meta.get("llm_output_text_utf8")))
+    candidates.extend(mm_output.get(key) for key in ("meta.llm_output_text", "meta.text"))
+    for value in candidates:
+        if isinstance(value, str) and value:
+            return value
+        decoded = _decode_text_tensor(value)
+        if decoded:
+            return decoded
+        if isinstance(value, list):
+            text_chunks = [item for item in value if isinstance(item, str)]
+            if text_chunks:
+                return "".join(text_chunks)
+    return ""
+
+
+def _decode_text_tensor(value: object) -> str:
+    if value is None:
+        return ""
+    try:
+        if isinstance(value, np.ndarray):
+            raw = value.astype(np.uint8, copy=False).reshape(-1).tobytes()
+        elif hasattr(value, "detach"):
+            raw = value.detach().cpu().numpy().astype(np.uint8, copy=False).reshape(-1).tobytes()
+        else:
+            return ""
+        return raw.decode("utf-8", errors="ignore")
+    except Exception:
+        return ""
+
+
+def _fallback_audio_text_marks(
+    audio_chunks: list[tuple[str, int]],
+    delta_text: str,
+) -> list[list[dict[str, int]] | None]:
+    if not delta_text:
+        return []
+    total_duration_ms = sum(max(0, int(duration_ms)) for _, duration_ms in audio_chunks)
+    cumulative_duration_ms = 0
+    marks: list[list[dict[str, int]] | None] = []
+    for _, duration_ms in audio_chunks:
+        cumulative_duration_ms += max(0, int(duration_ms))
+        if total_duration_ms <= 0:
+            marks.append(None)
+            continue
+        text_chars = int(len(delta_text) * min(1.0, cumulative_duration_ms / float(total_duration_ms)))
+        marks.append([{"text_chars": max(0, text_chars), "audio_end_ms": max(0, cumulative_duration_ms)}])
+    return marks
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/input.py b/vllm_omni/experimental/fullduplex/minicpmo45/input.py
new file mode 100644
index 000000000..248e857e8
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/input.py
@@ -0,0 +1,444 @@
+from __future__ import annotations
+
+import base64
+import binascii
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True, slots=True)
+class _PcmSpan:
+    byte_count: int
+    force_listen: bool
+    is_speech: bool
+
+
+class MiniCPMO45PcmAppendReservation:
+    __slots__ = (
+        "_active",
+        "_force_listen",
+        "_is_speech",
+        "_owner",
+        "_raw",
+        "_sample_rate_hz",
+        "_spans",
+        "_turn_had_speech",
+        "_video_frames",
+        "operation_id",
+        "payload",
+    )
+
+    def __init__(
+        self,
+        *,
+        owner: MiniCPMO45PcmAppendBuffer,
+        operation_id: str,
+        payload: dict[str, object] | None,
+        raw: bytes,
+        sample_rate_hz: int,
+        force_listen: bool,
+        is_speech: bool,
+        spans: list[_PcmSpan] | None = None,
+        turn_had_speech: bool = False,
+        video_frames: list[str] | None = None,
+    ) -> None:
+        self._owner = owner
+        self.operation_id = operation_id
+        self.payload = payload
+        self._raw = raw
+        self._sample_rate_hz = sample_rate_hz
+        self._force_listen = force_listen
+        self._is_speech = is_speech
+        self._spans = list(spans or [])
+        self._turn_had_speech = turn_had_speech
+        self._video_frames = list(video_frames or [])
+        self._active = True
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @property
+    def byte_count(self) -> int:
+        return len(self._raw)
+
+    def commit(self) -> None:
+        self._owner._commit_reservation(self)
+
+    def rollback(self) -> None:
+        self._owner._rollback_reservation(self)
+
+
+def validate_native_ref_audio_config(session_config: dict[str, Any]) -> None:
+    extra_body = session_config.get("extra_body")
+    if not isinstance(extra_body, dict):
+        extra_body = {}
+    if any(key in session_config for key in ("ref_audio_path", "tts_ref_audio_path")) or any(
+        key in extra_body for key in ("ref_audio_path", "tts_ref_audio_path")
+    ):
+        raise ValueError("native duplex ref_audio_path is not accepted; resolve ref_audio in serving first")
+
+
+def decode_native_ref_audio_from_config(session_config: dict[str, Any]) -> np.ndarray | None:
+    validate_native_ref_audio_config(session_config)
+    extra_body = session_config.get("extra_body")
+    if not isinstance(extra_body, dict):
+        extra_body = {}
+    audio_data = extra_body.get("ref_audio_data")
+    if audio_data is None:
+        return None
+    if not isinstance(audio_data, str):
+        raise TypeError("native duplex ref_audio_data must be base64 pcm_f32le")
+    fmt = extra_body.get("ref_audio_format") or "pcm_f32le"
+    if fmt != "pcm_f32le":
+        raise ValueError(f"unsupported native duplex ref_audio_format: {fmt!r}")
+    try:
+        raw = base64.b64decode(audio_data, validate=True)
+    except (ValueError, binascii.Error) as exc:
+        raise ValueError("invalid native duplex ref_audio_data") from exc
+    if len(raw) % 4:
+        raise ValueError("invalid native duplex ref_audio_data length")
+    return np.frombuffer(raw, dtype="<f4").astype(np.float32, copy=True)
+
+
+class MiniCPMO45PcmAppendBuffer:
+    """Accumulates short native-duplex PCM chunks into model-sized appends."""
+
+    def __init__(self) -> None:
+        self._buffer = bytearray()
+        self._spans: list[_PcmSpan] = []
+        self._sample_rate_hz: int | None = None
+        self._turn_had_speech = False
+        self._reservation_seq = 0
+        self._reservations: list[MiniCPMO45PcmAppendReservation] = []
+        # Omni duplex: queued camera frames (base64 JPEG), consumed FIFO at
+        # one frame per emitted model unit alongside the unit's audio.
+        self._frame_queue: list[str] = []
+
+    def clear(self) -> None:
+        for reservation in self._reservations:
+            reservation._active = False
+        self._reservations.clear()
+        self._buffer.clear()
+        self._spans.clear()
+        self._frame_queue.clear()
+        self._sample_rate_hz = None
+        self._turn_had_speech = False
+
+    def clear_force_listen(self) -> None:
+        self._spans = [_PcmSpan(span.byte_count, False, span.is_speech) for span in self._spans]
+
+    def has_pending(self) -> bool:
+        return bool(self._buffer)
+
+    def has_reserved(self) -> bool:
+        return bool(self._reservations)
+
+    @property
+    def pending_byte_count(self) -> int:
+        return len(self._buffer)
+
+    def _append_span(self, span: _PcmSpan) -> None:
+        if span.byte_count <= 0:
+            return
+        if (
+            self._spans
+            and self._spans[-1].force_listen == span.force_listen
+            and self._spans[-1].is_speech == span.is_speech
+        ):
+            previous = self._spans[-1]
+            self._spans[-1] = _PcmSpan(
+                previous.byte_count + span.byte_count,
+                span.force_listen,
+                span.is_speech,
+            )
+            return
+        self._spans.append(span)
+
+    def _consume_spans(self, byte_count: int) -> list[_PcmSpan]:
+        consumed: list[_PcmSpan] = []
+        remaining = byte_count
+        while remaining:
+            if not self._spans:
+                raise RuntimeError("MiniCPM-o PCM metadata is shorter than buffered audio")
+            span = self._spans.pop(0)
+            take = min(remaining, span.byte_count)
+            consumed.append(_PcmSpan(take, span.force_listen, span.is_speech))
+            if take < span.byte_count:
+                self._spans.insert(
+                    0,
+                    _PcmSpan(
+                        span.byte_count - take,
+                        span.force_listen,
+                        span.is_speech,
+                    ),
+                )
+            remaining -= take
+        return consumed
+
+    def _prepend_spans(self, spans: list[_PcmSpan]) -> None:
+        current = self._spans
+        self._spans = []
+        for span in [*spans, *current]:
+            self._append_span(span)
+
+    def _buffer_force_listen(self) -> bool:
+        return any(span.force_listen for span in self._spans)
+
+    def _buffer_is_speech(self) -> bool:
+        return any(span.is_speech for span in self._spans)
+
+    def _reserve_passthrough(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str,
+    ) -> MiniCPMO45PcmAppendReservation:
+        sample_rate_hz = payload.get("sample_rate_hz")
+        if isinstance(payload, dict) and "video_frames" in payload:
+            # Frames align to whole audio units; a passthrough payload has no
+            # unit framing for Stage0 to interleave against.
+            payload = {key: value for key, value in payload.items() if key != "video_frames"}
+        reservation = MiniCPMO45PcmAppendReservation(
+            owner=self,
+            operation_id=operation_id,
+            payload=payload,
+            raw=b"",
+            sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int) else 0,
+            force_listen=bool(payload.get("force_listen", False)),
+            is_speech=bool(payload.get("is_speech", False)),
+            turn_had_speech=bool(payload.get("is_speech", False)),
+        )
+        self._reservations.append(reservation)
+        return reservation
+
+    def prepare_append(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+        flush: bool = False,
+        allow_emit: bool = True,
+    ) -> MiniCPMO45PcmAppendReservation | None:
+        fmt = payload.get("format")
+        sample_rate_hz = payload.get("sample_rate_hz")
+        audio = payload.get("audio")
+        if fmt != "pcm_f32le" or not isinstance(sample_rate_hz, int) or not isinstance(audio, str):
+            return self._reserve_passthrough(payload, operation_id=operation_id)
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError):
+            return self._reserve_passthrough(payload, operation_id=operation_id)
+        if len(raw) % 4 != 0:
+            return self._reserve_passthrough(payload, operation_id=operation_id)
+
+        if self._sample_rate_hz is not None and self._sample_rate_hz != sample_rate_hz:
+            raise ValueError("MiniCPM-o native duplex audio append sample_rate_hz changed within a session")
+        self._sample_rate_hz = sample_rate_hz
+        self._buffer.extend(raw)
+        self._append_span(
+            _PcmSpan(
+                len(raw),
+                bool(payload.get("force_listen", False)),
+                bool(payload.get("is_speech", False)),
+            )
+        )
+        frames_in = payload.get("video_frames")
+        if isinstance(frames_in, list):
+            self._frame_queue.extend(frame for frame in frames_in if isinstance(frame, str) and frame)
+        self._turn_had_speech = self._turn_had_speech or bool(payload.get("is_speech", False))
+        if not allow_emit:
+            return None
+
+        min_samples = max(1, int(sample_rate_hz * max(1, int(chunk_period_ms)) / 1000))
+        buffered_samples = len(self._buffer) // 4
+        if not flush and buffered_samples < min_samples:
+            return None
+
+        # Emit whole model chunks only: the engine reserves scheduler slots
+        # from the payload size and the worker consumes whole chunks per
+        # append, so partial chunks would turn into pad embeddings inside the
+        # model KV. On flush, the tail is zero-padded (silence) up to the
+        # chunk boundary instead.
+        if flush:
+            emit_samples = buffered_samples
+            remainder = emit_samples % min_samples
+            pad_samples = (min_samples - remainder) if remainder else 0
+        else:
+            emit_samples = min_samples
+            pad_samples = 0
+        emit_bytes = emit_samples * 4
+        reserved_raw = bytes(self._buffer[:emit_bytes])
+        reserved_spans = self._consume_spans(emit_bytes)
+        emit_raw = reserved_raw + b"\x00" * (pad_samples * 4)
+        del self._buffer[:emit_bytes]
+
+        out = dict(payload)
+        out.pop("force_speak", None)
+        out.pop("video_frames", None)
+        out["audio"] = base64.b64encode(emit_raw).decode("ascii")
+        out["sample_rate_hz"] = sample_rate_hz
+        # Omni duplex: attach at most one queued camera frame per emitted
+        # model unit (official cadence: one frame per 1 s chunk). The engine
+        # budgets 66 scheduler slots per attached frame from this payload.
+        # Official omni cadence is one frame per ~1 s chunk, and the first
+        # append consumes extra samples (1035 ms first window), so per-unit
+        # attachment could outrun the units Stage0 actually builds. Attach at
+        # most ONE frame per emitted payload; the rest stay queued.
+        attached_frames: list[str] = []
+        if emit_samples + pad_samples >= min_samples and self._frame_queue:
+            attached_frames = [self._frame_queue.pop(0)]
+            out["video_frames"] = attached_frames
+        out["force_listen"] = any(span.force_listen for span in reserved_spans)
+        out["is_speech"] = any(span.is_speech for span in reserved_spans)
+        reservation = MiniCPMO45PcmAppendReservation(
+            owner=self,
+            operation_id=operation_id,
+            payload=out,
+            raw=reserved_raw,
+            sample_rate_hz=sample_rate_hz,
+            force_listen=bool(out.get("force_listen", False)),
+            is_speech=bool(out.get("is_speech", False)),
+            spans=reserved_spans,
+            turn_had_speech=self._turn_had_speech,
+            video_frames=attached_frames,
+        )
+        self._reservations.append(reservation)
+        return reservation
+
+    def prepare_commit(
+        self,
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+    ) -> MiniCPMO45PcmAppendReservation:
+        """Reserve the terminal payload without invalidating prior appends."""
+        had_speech = self._turn_had_speech
+        reservation: MiniCPMO45PcmAppendReservation | None = None
+        if had_speech and self._buffer:
+            payload: dict[str, object] = {
+                "type": "audio",
+                "audio": "",
+                "format": "pcm_f32le",
+                "sample_rate_hz": self._sample_rate_hz or 16000,
+                "force_listen": self._buffer_force_listen(),
+                "is_speech": self._buffer_is_speech(),
+            }
+            reservation = self.prepare_append(
+                payload,
+                operation_id=operation_id,
+                chunk_period_ms=chunk_period_ms,
+                flush=True,
+            )
+            assert reservation is not None
+            assert reservation.payload is not None
+            reservation.payload["final"] = True
+        if reservation is None:
+            reservation = MiniCPMO45PcmAppendReservation(
+                owner=self,
+                operation_id=operation_id,
+                payload=None,
+                raw=b"",
+                sample_rate_hz=self._sample_rate_hz or 0,
+                force_listen=self._buffer_force_listen(),
+                is_speech=self._buffer_is_speech(),
+                turn_had_speech=had_speech,
+            )
+            self._reservations.append(reservation)
+
+        # Open the next physical input generation without touching already
+        # reserved appends. A rollback restores this generation's metadata.
+        self._sample_rate_hz = None
+        self._turn_had_speech = False
+        return reservation
+
+    def append(
+        self,
+        payload: dict[str, object],
+        *,
+        chunk_period_ms: int,
+        flush: bool = False,
+        allow_emit: bool = True,
+    ) -> dict[str, object] | None:
+        self._reservation_seq += 1
+        reservation = self.prepare_append(
+            payload,
+            operation_id=f"immediate-{self._reservation_seq}",
+            chunk_period_ms=chunk_period_ms,
+            flush=flush,
+            allow_emit=allow_emit,
+        )
+        if reservation is None:
+            return None
+        reservation.commit()
+        assert reservation.payload is not None
+        return reservation.payload
+
+    def _commit_reservation(self, reservation: MiniCPMO45PcmAppendReservation) -> None:
+        if not reservation._active:
+            return
+        if not self._reservations or self._reservations[0] is not reservation:
+            raise RuntimeError("PCM append reservations must commit in wire order")
+        self._reservations.pop(0)
+        reservation._active = False
+
+    def _rollback_reservation(self, reservation: MiniCPMO45PcmAppendReservation) -> None:
+        if not reservation._active:
+            return
+        try:
+            index = self._reservations.index(reservation)
+        except ValueError:
+            reservation._active = False
+            return
+        rolled_back = self._reservations[index:]
+        restored = b"".join(item._raw for item in rolled_back)
+        self._buffer[:0] = restored
+        self._prepend_spans([span for item in rolled_back for span in item._spans])
+        restored_frames = [frame for item in rolled_back for frame in item._video_frames]
+        if restored_frames:
+            self._frame_queue[:0] = restored_frames
+        self._sample_rate_hz = self._sample_rate_hz or reservation._sample_rate_hz
+        self._turn_had_speech = self._turn_had_speech or any(item._turn_had_speech for item in rolled_back)
+        for item in rolled_back:
+            item._active = False
+        del self._reservations[index:]
+
+    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None:
+        if not self._buffer:
+            return None
+        payload: dict[str, object] = {
+            "type": "audio",
+            "audio": "",
+            "format": "pcm_f32le",
+            "sample_rate_hz": self._sample_rate_hz or 16000,
+            "force_listen": self._buffer_force_listen(),
+            "is_speech": self._buffer_is_speech(),
+        }
+        return self.append(payload, chunk_period_ms=chunk_period_ms, flush=True)
+
+    def commit(self, *, chunk_period_ms: int) -> dict[str, object] | None:
+        """Commit the real residual PCM and reset per-client-input state.
+
+        Complete model units are emitted by :meth:`append` as soon as they are
+        available.  A commit at that exact boundary therefore has no payload;
+        synthesizing another unit would add a model decision that does not
+        exist in the official continuous streaming loop.
+        """
+        self._reservation_seq += 1
+        reservation = self.prepare_commit(
+            operation_id=f"immediate-commit-{self._reservation_seq}",
+            chunk_period_ms=chunk_period_ms,
+        )
+        reservation.commit()
+        return reservation.payload
+
+
+__all__ = [
+    "MiniCPMO45PcmAppendReservation",
+    "MiniCPMO45PcmAppendBuffer",
+    "decode_native_ref_audio_from_config",
+    "validate_native_ref_audio_config",
+]
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/policy.py b/vllm_omni/experimental/fullduplex/minicpmo45/policy.py
new file mode 100644
index 000000000..c55b25360
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/policy.py
@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class MiniCPMO45DuplexPolicy:
+    """MiniCPM-o 4.5 native duplex model policy.
+
+    Keep model-specific token names, input modes, and handoff type strings out
+    of the generic scheduler/orchestrator path. These names are part of the
+    MiniCPM-o 4.5 remote-code contract, not a general vLLM-Omni duplex schema.
+    """
+
+    # Audio framing contract shared by serving, orchestrator, and worker.
+    # MiniCPM-o consumes 1 s units at 16 kHz and pools audio to one embedding
+    # per 100 ms, so a unit contributes exactly 10 audio embeddings plus the
+    # <unit> open (and a </unit> closure for every unit after the first).
+    # Scheduler token budgets must match the worker-built embeddings exactly:
+    # surplus slots become pad embeddings inside the KV and measurably corrupt
+    # the model's listen/speak behavior.
+    SAMPLE_RATE_HZ = 16000
+    CHUNK_SAMPLES = 16000
+    SAMPLES_PER_AUDIO_TOKEN = 1600
+    # Vision framing contract (omni duplex). Official streaming_prefill feeds
+    # each frame as <image> + 64 resampler embeddings + </image> inside the
+    # unit, ahead of the unit's audio embeddings (max_slice_nums=1 in
+    # streaming, so exactly one 64-token block per frame).
+    VISION_EMBEDS_PER_FRAME = 64
+    VISION_TOKENS_PER_FRAME = VISION_EMBEDS_PER_FRAME + 2  # <image> + embeds + </image>
+    DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK = 20
+    DEFAULT_MAX_SPEAK_CHARS_PER_CHUNK = 28
+    DEFAULT_MIN_NEW_SPEAK_TOKENS_BEFORE_CHUNK_BOUNDARY = 8
+    REPETITION_HISTORY_SIZE = 512
+
+    @classmethod
+    def audio_token_count(cls, sample_count: int) -> int:
+        """Audio embedding count for a clip of ``sample_count`` samples.
+
+        Matches the whole-clip encoder math (hop 160 mel frames -> CNN stride 2
+        -> avg-pool 5) for any multiple of ``SAMPLES_PER_AUDIO_TOKEN``; serving
+        normalizes clips to that boundary before this is used for budgets.
+        """
+        return max(0, int(sample_count) // cls.SAMPLES_PER_AUDIO_TOKEN)
+
+    @staticmethod
+    def session_context_texts(instructions: object, has_ref_audio: bool) -> tuple[str, str]:
+        """System-context prefix/suffix, matching MiniCPMODuplex.prepare()."""
+        system_prompt = (
+            instructions if isinstance(instructions, str) and instructions else "Streaming Omni Conversation."
+        )
+        prefix = f"<|im_start|>system\n{system_prompt}"
+        suffix = "<|im_end|>"
+        if has_ref_audio:
+            prefix += "\n<|audio_start|>"
+            suffix = "<|audio_end|>" + suffix
+        return prefix, suffix
+
+    SPECIAL_TOKEN_FIELDS: dict[str, str] = {
+        "unit_token_id": "<unit>",
+        "unit_end_token_id": "</unit>",
+        "listen_token_id": "<|listen|>",
+        "speak_token_id": "<|speak|>",
+        "tts_bos_token_id": "<|tts_bos|>",
+        "tts_eos_token_id": "<|tts_eos|>",
+        "tts_pad_token_id": "<|tts_pad|>",
+        "chunk_eos_token_id": "<|chunk_eos|>",
+        "chunk_tts_eos_token_id": "<|chunk_tts_eos|>",
+        "turn_eos_token_id": "<|turn_eos|>",
+    }
+    OPTIONAL_TOKEN_FIELDS: dict[str, str] = {
+        "audio_placeholder_token_id": "<|audio|>",
+        "image_start_token_id": "<image>",
+        "image_end_token_id": "</image>",
+    }
+
+    @classmethod
+    def token_ids_from_tokenizer(cls, tokenizer: Any) -> dict[str, int]:
+        convert = getattr(tokenizer, "convert_tokens_to_ids", None)
+
+        def token_id(token: str) -> int:
+            if not callable(convert):
+                value = None
+            else:
+                value = convert(token)
+                if isinstance(value, list):
+                    value = value[0] if len(value) == 1 else None
+            unk_token_id = getattr(tokenizer, "unk_token_id", None)
+            try:
+                candidate = int(value)
+            except (TypeError, ValueError):
+                candidate = -1
+            if candidate >= 0 and candidate != unk_token_id:
+                return candidate
+
+            encode = getattr(tokenizer, "encode", None)
+            if callable(encode):
+                try:
+                    ids = list(encode(token, add_special_tokens=False))
+                except TypeError:
+                    ids = list(encode(token))
+                if len(ids) == 1:
+                    try:
+                        candidate = int(ids[0])
+                    except (TypeError, ValueError):
+                        candidate = -1
+                    if candidate >= 0 and candidate != unk_token_id:
+                        return candidate
+            return -1
+
+        resolved = {field: token_id(token) for field, token in cls.SPECIAL_TOKEN_FIELDS.items()}
+        resolved.update({field: token_id(token) for field, token in cls.OPTIONAL_TOKEN_FIELDS.items()})
+        if resolved.get("listen_token_id", -1) < 0:
+            eos_id = getattr(tokenizer, "eos_token_id", None)
+            try:
+                resolved["listen_token_id"] = int(eos_id)
+            except (TypeError, ValueError):
+                pass
+        return resolved
+
+    @staticmethod
+    def native_forbidden_token_ids(
+        token_ids: dict[str, int],
+        *,
+        bad_token_ids: list[int] | tuple[int, ...] = (),
+    ) -> list[int]:
+        return [
+            token_ids.get("tts_pad_token_id", -1),
+            *list(bad_token_ids),
+            token_ids.get("chunk_eos_token_id", -1),
+        ]
+
+    @staticmethod
+    def native_special_token_ids(
+        token_ids: dict[str, int],
+        *,
+        tokenizer_special_ids: list[int] | tuple[int, ...] = (),
+    ) -> set[int]:
+        special = set(tokenizer_special_ids or [])
+        special.update(value for value in token_ids.values() if isinstance(value, int) and value >= 0)
+        return special
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/runtime.py b/vllm_omni/experimental/fullduplex/minicpmo45/runtime.py
new file mode 100644
index 000000000..b5fbd37a5
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/runtime.py
@@ -0,0 +1,354 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from base64 import b64decode
+from binascii import Error as BinasciiError
+from typing import Any
+
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexAppendPlan,
+    DuplexInputMode,
+    DuplexOutputAction,
+    DuplexOutputDecision,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+_DUPLEX_CHUNK_SAMPLES = 16000
+_DUPLEX_SAMPLES_PER_AUDIO_TOKEN = 1600
+# <image> + 64 resampler embeddings + </image> per frame (max_slice_nums=1),
+# matching MiniCPMO45DuplexPolicy.VISION_TOKENS_PER_FRAME.
+_DUPLEX_VISION_TOKENS_PER_FRAME = 66
+
+
+def _duplex_frame_count(payload: object) -> int:
+    if not isinstance(payload, dict):
+        return 0
+    frames = payload.get("video_frames")
+    if not isinstance(frames, list):
+        return 0
+    return sum(1 for frame in frames if isinstance(frame, str) and frame)
+
+
+def _duplex_pcm_sample_count(payload: object) -> int | None:
+    if not isinstance(payload, dict):
+        return None
+    audio = payload.get("audio") or payload.get("data")
+    if payload.get("format") != "pcm_f32le" or not isinstance(audio, str):
+        return None
+    try:
+        raw = b64decode(audio, validate=True)
+    except (BinasciiError, ValueError):
+        return None
+    return len(raw) // 4
+
+
+def duplex_payload_is_exact_chunks(payload: object) -> bool:
+    sample_count = _duplex_pcm_sample_count(payload)
+    return bool(sample_count) and sample_count % _DUPLEX_CHUNK_SAMPLES == 0
+
+
+def duplex_first_append_unit_count(payload: object) -> int | None:
+    sample_count = _duplex_pcm_sample_count(payload)
+    if not sample_count or sample_count % _DUPLEX_CHUNK_SAMPLES != 0:
+        return None
+    return max(1, sample_count // _DUPLEX_CHUNK_SAMPLES - 1)
+
+
+def duplex_scheduler_token_budget(payload: object, *, default: int = 64) -> int:
+    vision_tokens = _duplex_frame_count(payload) * _DUPLEX_VISION_TOKENS_PER_FRAME
+    sample_count = _duplex_pcm_sample_count(payload)
+    if sample_count is None:
+        return max(1, int(default)) + vision_tokens
+    sample_count = max(1, sample_count)
+    if sample_count % _DUPLEX_CHUNK_SAMPLES == 0:
+        units = sample_count // _DUPLEX_CHUNK_SAMPLES
+        return units * (2 + _DUPLEX_CHUNK_SAMPLES // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN) + vision_tokens
+    return max(16, min(768, sample_count // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)) + vision_tokens
+
+
+def duplex_first_append_context_reserve(runtime_config: object) -> int:
+    if not isinstance(runtime_config, dict):
+        return 48
+    exact = runtime_config.get("duplex_first_append_context_tokens")
+    if isinstance(exact, int) and exact >= 0:
+        return exact
+    reserve = 48
+    ref = runtime_config.get("ref_audio_data")
+    if isinstance(ref, str) and ref:
+        try:
+            raw = b64decode(ref, validate=True)
+        except (BinasciiError, ValueError):
+            raw = b""
+        if raw:
+            reserve += max(0, (len(raw) // 4) // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)
+    return reserve
+
+
+def _duplex_force_listen_count(extra_body: object) -> int:
+    raw = extra_body.get("force_listen_count") if isinstance(extra_body, dict) else None
+    try:
+        return 0 if raw is None else max(0, int(raw))
+    except (TypeError, ValueError):
+        return 0
+
+
+def build_duplex_data_plane_prompt(
+    *,
+    request_id: str,
+    fence: DuplexFence,
+    session_config: dict[str, Any],
+    runtime_config: dict[str, Any],
+    seq: int,
+    turn_seq: int,
+    mode: DuplexInputMode,
+    payload: object,
+    final: bool,
+) -> dict[str, Any]:
+    token_budget = duplex_scheduler_token_budget(payload)
+    if seq <= 1:
+        context_reserve = duplex_first_append_context_reserve(runtime_config)
+        token_budget += context_reserve
+        first_units = duplex_first_append_unit_count(payload)
+        if first_units is not None:
+            token_budget = (
+                context_reserve + first_units * 12 - 1 + _duplex_frame_count(payload) * _DUPLEX_VISION_TOKENS_PER_FRAME
+            )
+    if seq > 1 and duplex_payload_is_exact_chunks(payload):
+        token_budget += 1
+    if final and duplex_payload_is_exact_chunks(payload):
+        token_budget += 12
+    extra_body = session_config.get("extra_body")
+    raw_token_id = runtime_config.get("duplex_scheduler_token_id")
+    try:
+        token_id = max(0, int(raw_token_id))
+    except (TypeError, ValueError):
+        token_id = 0
+    force_listen_count = _duplex_force_listen_count(extra_body)
+    if (
+        force_listen_count > 0
+        and turn_seq <= force_listen_count
+        and isinstance(payload, dict)
+        and payload.get("force_listen") is not True
+    ):
+        payload = {**payload, "force_listen": True}
+    return {
+        "prompt_token_ids": [token_id] * token_budget,
+        "model_intermediate_buffer": {
+            "request_id": request_id,
+            "global_request_id": [fence.session_id],
+            "duplex": {
+                "fence": fence,
+                "session_id": fence.session_id,
+                "incarnation": fence.incarnation,
+                "epoch": fence.epoch,
+                "seq": seq,
+                "turn_id": fence.turn_id,
+                "response_seq": fence.response_seq,
+                "turn_seq": turn_seq,
+                "mode": mode.value,
+                "payload": payload,
+                "final": final,
+                "data_plane": True,
+                "session_config": dict(session_config),
+                "runtime_config": dict(runtime_config),
+                "scheduler_token_budget": token_budget,
+                "scheduler_token_id": token_id,
+            },
+        },
+    }
+
+
+def _coerce_int(value: object) -> int | None:
+    if hasattr(value, "detach"):
+        try:
+            value = value.detach().cpu().reshape(-1)
+            if value.numel() == 0:
+                return None
+            value = value[0].item()
+        except Exception:
+            return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _coerce_int_list(value: object) -> list[int]:
+    if value is None:
+        return []
+    if hasattr(value, "detach"):
+        try:
+            value = value.detach().cpu().reshape(-1).tolist()
+        except Exception:
+            return []
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [token_id for item in value if (token_id := _coerce_int(item)) is not None]
+
+
+def _first_completion(output: object) -> object | None:
+    outputs = getattr(output, "outputs", None)
+    return outputs[0] if isinstance(outputs, list) and outputs else None
+
+
+def _multimodal_output(output: object, completion: object | None) -> dict[str, Any]:
+    metadata = getattr(output, "multimodal_output", None)
+    if isinstance(metadata, dict):
+        return metadata
+    metadata = getattr(completion, "multimodal_output", None) if completion is not None else None
+    return metadata if isinstance(metadata, dict) else {}
+
+
+def _special_token_ids(metadata: dict[str, Any]) -> dict[str, int]:
+    sources: list[object] = [metadata.get("special_token_ids"), metadata.get("meta")]
+    sources.append(
+        {
+            key.removeprefix("meta."): value
+            for key, value in metadata.items()
+            if isinstance(key, str) and key.startswith("meta.")
+        }
+    )
+    token_ids: dict[str, int] = {}
+    for source in sources:
+        if not isinstance(source, dict):
+            continue
+        for key, value in source.items():
+            token_id = _coerce_int(value)
+            if isinstance(key, str) and token_id is not None and token_id >= 0:
+                token_ids[key] = token_id
+    return token_ids
+
+
+def _completion_token_ids(completion: object | None) -> list[int]:
+    if completion is None:
+        return []
+    for attribute in ("token_ids", "cumulative_token_ids"):
+        token_ids = _coerce_int_list(getattr(completion, attribute, None))
+        if token_ids:
+            return token_ids
+    return []
+
+
+def _stage_config_value(runtime_config: dict[str, Any], key: str, stage_id: int) -> object | None:
+    raw = runtime_config.get(key)
+    if isinstance(raw, dict):
+        value = raw.get(stage_id)
+        return raw.get(str(stage_id)) if value is None else value
+    if isinstance(raw, (list, tuple)) and stage_id < len(raw):
+        return raw[stage_id]
+    return None
+
+
+class MiniCPMO45DuplexRuntimeExtension:
+    def configure_sampling_params(
+        self,
+        *,
+        runtime_config: dict[str, Any],
+        defaults: tuple[object, ...],
+    ) -> tuple[object, ...]:
+        configured: list[object] = []
+        for stage_id, default in enumerate(defaults):
+            max_tokens = _coerce_int(_stage_config_value(runtime_config, "duplex_stage_max_tokens", stage_id))
+            raw_overrides = _stage_config_value(runtime_config, "duplex_stage_sampling_params", stage_id)
+            overrides = dict(raw_overrides) if isinstance(raw_overrides, dict) else {}
+            if not isinstance(default, SamplingParams) or (not overrides and (max_tokens is None or max_tokens <= 0)):
+                configured.append(default)
+                continue
+            params = default.clone()
+            if max_tokens is not None and max_tokens > 0:
+                params.max_tokens = max_tokens
+            for name, value in overrides.items():
+                if not hasattr(params, name):
+                    continue
+                setattr(params, name, value)
+                if name == "stop_token_ids":
+                    all_stop_token_ids = getattr(params, "_all_stop_token_ids", None)
+                    if isinstance(all_stop_token_ids, set):
+                        all_stop_token_ids.update(int(token_id) for token_id in value)
+            configured.append(params)
+        return tuple(configured)
+
+    def plan_append(
+        self,
+        *,
+        request_id: str,
+        fence: DuplexFence,
+        session_config: dict[str, Any],
+        runtime_config: dict[str, Any],
+        seq: int,
+        turn_seq: int,
+        mode: DuplexInputMode,
+        payload: object,
+        final: bool,
+        sampling_params: object,
+    ) -> DuplexAppendPlan:
+        del sampling_params
+        return DuplexAppendPlan(
+            prompt=build_duplex_data_plane_prompt(
+                request_id=request_id,
+                fence=fence,
+                session_config=session_config,
+                runtime_config=runtime_config,
+                seq=seq,
+                turn_seq=turn_seq,
+                mode=mode,
+                payload=payload,
+                final=final,
+            )
+        )
+
+    def decide_output(
+        self,
+        *,
+        stage_id: int,
+        final_stage_id: int,
+        segment_finished: bool,
+        segment_token_ids: tuple[int, ...],
+        segment_output_metadata: dict[str, Any],
+        output: object,
+    ) -> DuplexOutputDecision | None:
+        if stage_id >= final_stage_id or not segment_finished:
+            return None
+
+        completion = _first_completion(output)
+        output_metadata = _multimodal_output(output, completion)
+        special_token_ids = _special_token_ids(segment_output_metadata)
+        special_token_ids.update(_special_token_ids(output_metadata))
+        listen_id = special_token_ids.get("listen_token_id")
+        if listen_id is None:
+            return None
+
+        stop_reason = getattr(completion, "stop_reason", None) if completion is not None else None
+        token_ids = _completion_token_ids(completion) or list(segment_token_ids)
+        if _coerce_int(stop_reason) != listen_id and (not token_ids or token_ids[-1] != listen_id):
+            return None
+
+        metadata = dict(output_metadata)
+        for key, value in special_token_ids.items():
+            metadata.setdefault(f"meta.{key}", value)
+        metadata.update(
+            {
+                "duplex_direct_response": True,
+                "duplex_native_decision": "listen",
+                "model_listen": True,
+                "listen_source": "model_listen",
+            }
+        )
+        return DuplexOutputDecision(
+            action=DuplexOutputAction.DIRECT_RESPONSE,
+            metadata=metadata,
+        )
+
+
+__all__ = [
+    "MiniCPMO45DuplexRuntimeExtension",
+    "build_duplex_data_plane_prompt",
+    "duplex_first_append_context_reserve",
+    "duplex_first_append_unit_count",
+    "duplex_payload_is_exact_chunks",
+    "duplex_scheduler_token_budget",
+]
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/serving_adapter.py b/vllm_omni/experimental/fullduplex/minicpmo45/serving_adapter.py
new file mode 100644
index 000000000..e811d73e5
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/serving_adapter.py
@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from vllm_omni.experimental.fullduplex.minicpmo45.adapter import (
+    MiniCPMO45NativeDuplexServingAdapter,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.data_plane import (
+    MiniCPMO45DataPlaneContext,
+    MiniCPMO45DataPlaneSession,
+)
+from vllm_omni.experimental.fullduplex.minicpmo45.session import (
+    MiniCPMO45ServingSessionState,
+)
+from vllm_omni.experimental.fullduplex.openai.protocol import DuplexCapabilities
+
+EncodeAudio = Callable[[object, int, str, float | None], str | None]
+
+
+class MiniCPMO45ServingRuntimeAdapter:
+    """MiniCPM-owned serving state, input packing, and output projection."""
+
+    adapter_id = "minicpmo45"
+    clean_response_done_prefix = ""
+    interrupted_tts_prefix = ""
+    private_runtime_config_keys = MiniCPMO45NativeDuplexServingAdapter.PRIVATE_RUNTIME_CONFIG_KEYS
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        self.session_states: dict[str, MiniCPMO45ServingSessionState] = {}
+        self.data_plane = MiniCPMO45DataPlaneSession(encode_audio)
+
+    def create_session_state(self) -> MiniCPMO45ServingSessionState:
+        return MiniCPMO45ServingSessionState()
+
+    def session_state(self, session_id: str) -> MiniCPMO45ServingSessionState:
+        state = self.session_states.get(session_id)
+        if state is None:
+            state = self.create_session_state()
+            self.session_states[session_id] = state
+        return state
+
+    def remove_session_state(self, session_id: str) -> None:
+        self.session_states.pop(session_id, None)
+
+    @staticmethod
+    def is_enabled(config: object) -> bool:
+        return MiniCPMO45NativeDuplexServingAdapter.is_enabled(config)  # type: ignore[arg-type]
+
+    @staticmethod
+    def capabilities(*, max_sessions: int) -> DuplexCapabilities:
+        return DuplexCapabilities.minicpmo45_native(max_sessions=max_sessions)
+
+    @staticmethod
+    def validate_client_extra_body(extra_body: object) -> None:
+        MiniCPMO45NativeDuplexServingAdapter.validate_client_extra_body(extra_body)
+
+    @staticmethod
+    async def prepare_runtime_config(config: object, *, model_config: Any) -> dict[str, object]:
+        return await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
+            config,  # type: ignore[arg-type]
+            model_config=model_config,
+        )
+
+    @staticmethod
+    def runtime_config_for_update(
+        config: object,
+        current: Mapping[str, object],
+    ) -> dict[str, object]:
+        return MiniCPMO45NativeDuplexServingAdapter.runtime_config_for_update(
+            config,  # type: ignore[arg-type]
+            dict(current),
+        )
+
+    @staticmethod
+    def data_plane_context(
+        *,
+        epoch: int,
+        turn_id: int,
+        active_response_turn_id: int | None,
+        active_response_id: str | None,
+        auto_responds: bool,
+        response_format: str,
+        speed: float | None,
+        modalities: tuple[str, ...],
+    ) -> MiniCPMO45DataPlaneContext:
+        return MiniCPMO45DataPlaneContext(
+            epoch=epoch,
+            turn_id=turn_id,
+            active_response_turn_id=active_response_turn_id,
+            active_response_id=active_response_id,
+            auto_responds=auto_responds,
+            response_format=response_format,
+            speed=speed,
+            modalities=modalities,
+        )
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/session.py b/vllm_omni/experimental/fullduplex/minicpmo45/session.py
new file mode 100644
index 000000000..763bcf8b3
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/session.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+
+from vllm_omni.experimental.fullduplex.minicpmo45.input import (
+    MiniCPMO45PcmAppendBuffer,
+)
+
+
+@dataclass(slots=True)
+class MiniCPMO45ServingSessionState:
+    """Mutable serving state owned by one MiniCPM duplex session."""
+
+    audio_buffer: MiniCPMO45PcmAppendBuffer = field(default_factory=MiniCPMO45PcmAppendBuffer)
+    input_since_commit: bool = False
+    speech_since_commit: bool = False
+    committed_audio_payload: dict[str, object] | None = None
+    committed_audio_operation_id: str | None = None
+    committed_audio_reserved_bytes: int = 0
+    deferred_response_create: bool = False
+    deferred_precreate_response: bool = False
+    data_plane_task: asyncio.Task[None] | None = None
+    data_plane_restart_requested: bool = False
+    continuation_owner_id: str | None = None
+    continuation_units: int = 0
+    pending_silence_task: asyncio.Task[bool] | None = None
+    pending_silence_owner_id: str | None = None
+    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | None = None
+
+    def retain_committed_audio(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str | None,
+        reserved_bytes: int = 0,
+    ) -> None:
+        self.committed_audio_payload = payload
+        self.committed_audio_operation_id = operation_id
+        self.committed_audio_reserved_bytes += max(0, int(reserved_bytes))
+
+    def clear_committed_audio(self) -> int:
+        reserved_bytes = self.committed_audio_reserved_bytes
+        self.committed_audio_payload = None
+        self.committed_audio_operation_id = None
+        self.committed_audio_reserved_bytes = 0
+        self.deferred_response_create = False
+        self.deferred_precreate_response = False
+        return reserved_bytes
+
+    def clear_continuation(self) -> None:
+        self.continuation_owner_id = None
+        self.continuation_units = 0
+        self.pending_silence_task = None
+        self.pending_silence_owner_id = None
diff --git a/vllm_omni/experimental/fullduplex/minicpmo45/stage0.py b/vllm_omni/experimental/fullduplex/minicpmo45/stage0.py
new file mode 100644
index 000000000..8a304d101
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/minicpmo45/stage0.py
@@ -0,0 +1,816 @@
+from __future__ import annotations
+
+import base64
+import copy
+import time
+from contextlib import suppress
+from dataclasses import dataclass, field
+from threading import Lock
+from typing import Any
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.minicpmo45.policy import MiniCPMO45DuplexPolicy
+
+_MINICPMO45_SPECIAL_TOKEN_FIELDS = MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS
+_MINICPMO45_OPTIONAL_TOKEN_FIELDS = MiniCPMO45DuplexPolicy.OPTIONAL_TOKEN_FIELDS
+_MINICPMO45_PROCESSOR_LOAD_LOCK = Lock()
+
+
+@dataclass
+class _MiniCPMO45Stage0SessionState:
+    session_id: str
+    streaming_processor: Any | None = None
+    audio_buffer: np.ndarray = field(default_factory=lambda: np.array([], dtype=np.float32))
+    audio_chunk_idx: int = 0
+    context_embeds: list[Any] = field(default_factory=list)
+    context_token_ids: list[int] = field(default_factory=list)
+    current_turn_ended: bool = True
+    prepared_append_identity: tuple[int | None, int] | None = None
+    prepared_inputs_embeds: Any | None = None
+    prepared_input_token_ids: list[int] = field(default_factory=list)
+    prepared_result: dict[str, Any] = field(default_factory=dict)
+    audio_past_key_values: Any | None = None
+    pending_terminator_token: int | None = None
+    last_terminator_token: int | None = None
+    pending_speech_context: bool = False
+    pending_speech_append_identity: tuple[int | None, int] | None = None
+    pending_speech_response_open: bool = False
+    generated_tokens: list[int] = field(default_factory=list)
+
+
+class MiniCPMO45Stage0DuplexRuntime:
+    """Build scheduler-owned MiniCPM-o 4.5 Stage0 duplex inputs."""
+
+    def __init__(self, stage_model: Any, *, model_path: str | None = None, device: str = "cuda") -> None:
+        self.stage_model = stage_model
+        self.model_path = model_path
+        self.device = device
+        self.sessions: dict[tuple[str, int], _MiniCPMO45Stage0SessionState] = {}
+        self.thinker = getattr(stage_model, "thinker", None) or getattr(stage_model, "model", None) or stage_model
+        self.processor = (
+            getattr(stage_model, "processor", None)
+            or getattr(self.thinker, "processor", None)
+            or self._load_processor_from_path(model_path)
+        )
+        self.tokenizer = (
+            getattr(self.processor, "tokenizer", None)
+            if self.processor is not None
+            else getattr(stage_model, "tokenizer", None)
+        )
+        self._init_token_ids()
+        if self.tokenizer is not None:
+            self._require_special_token_ids()
+
+    def _stage_runtime_ready(self) -> bool:
+        return self.processor is not None and self.tokenizer is not None and self.thinker is not None
+
+    def _configure_streaming_processor(
+        self,
+        state: _MiniCPMO45Stage0SessionState | None = None,
+    ) -> Any | None:
+        processor = self.processor
+        if processor is None:
+            return None
+        if state is not None:
+            if state.streaming_processor is not None:
+                return state.streaming_processor
+            processor = copy.copy(processor)
+            shared_mel = getattr(self.processor, "_streaming_mel_processor", None)
+            if shared_mel is not None:
+                processor._streaming_mel_processor = copy.deepcopy(shared_mel)
+            state.streaming_processor = processor
+        if processor is None:
+            return
+        set_streaming_mode = getattr(processor, "set_streaming_mode", None)
+        if callable(set_streaming_mode):
+            set_streaming_mode(
+                mode="exact",
+                chunk_ms=int(self._stage_param("chunk_ms", 1000)),
+                first_chunk_ms=int(self._stage_param("first_chunk_ms", 1035)),
+                cnn_redundancy_ms=int(self._stage_param("cnn_redundancy_ms", 20)),
+                enable_sliding_window=True,
+                slide_trigger_seconds=30.0,
+                slide_stride_seconds=10.0,
+            )
+            # Match official init_streaming_processor: reset the streaming mel-processor
+            # buffers at session init (modeling_minicpmo_unified.py:207).
+            reset_streaming = getattr(processor, "reset_streaming", None)
+            if callable(reset_streaming):
+                reset_streaming()
+            return processor
+        configure_streaming = getattr(processor, "configure_streaming", None)
+        if callable(configure_streaming):
+            configure_streaming(
+                chunk_ms=int(self._stage_param("chunk_ms", 1000)),
+                enable_sliding_window=True,
+                slide_trigger_seconds=30.0,
+                slide_stride_seconds=10.0,
+            )
+        return processor
+
+    def _prepare_session_context(
+        self,
+        state: _MiniCPMO45Stage0SessionState,
+        session_config: dict[str, Any],
+        *,
+        runtime_config: dict[str, Any] | None = None,
+    ) -> None:
+        if not self._stage_runtime_ready():
+            return
+        self._require_special_token_ids()
+        ref_audio = self._decode_ref_audio_from_session_config(runtime_config or {})
+        # Matches MiniCPMODuplex.prepare() in the released checkpoint's
+        # modeling_minicpmo.py: the <|audio_start|>/<|audio_end|> markers are
+        # only present when reference audio is embedded between them. The
+        # template is shared with the serving adapter so the first-append
+        # scheduler reserve can count these tokens exactly.
+        prefix, suffix = MiniCPMO45DuplexPolicy.session_context_texts(
+            session_config.get("instructions"),
+            ref_audio is not None,
+        )
+        for token_id in self._encode_text(prefix):
+            state.context_embeds.append(self._embed_token(token_id))
+            state.context_token_ids.append(token_id)
+        if ref_audio is not None:
+            ref_audio_embeds = self._stage_ref_audio_embeddings(ref_audio, state=state)
+            if ref_audio_embeds is not None:
+                ref_audio_embeds = self._as_2d_tensor(ref_audio_embeds)
+                state.context_embeds.append(ref_audio_embeds)
+                state.context_token_ids.extend([self.unit_token_id] * int(ref_audio_embeds.shape[0]))
+        for token_id in self._encode_text(suffix):
+            state.context_embeds.append(self._embed_token(token_id))
+            state.context_token_ids.append(token_id)
+
+    def _stage_prefill_embeddings_only(
+        self,
+        state: _MiniCPMO45Stage0SessionState,
+        audio_waveform: Any,
+        *,
+        video_frames: list[Any] | None = None,
+        epoch: int | None = None,
+        seq: int | None = None,
+        is_speech: bool = False,
+        final: bool = False,
+    ) -> dict[str, Any]:
+        """Build scheduler-owned Stage0 input embeddings for one audio append.
+
+        Unlike the legacy worker-control path, this method never calls an eager
+        model forward. The normal vLLM runner consumes the returned embeddings
+        and owns attention metadata, block tables, KV cache, and sampling.
+        """
+        start_time = time.time()
+        processor = self._configure_streaming_processor(state)
+        append_identity = (epoch, seq) if seq is not None else None
+        if (
+            append_identity is not None
+            and state.prepared_append_identity == append_identity
+            and state.prepared_inputs_embeds is not None
+        ):
+            result = dict(state.prepared_result)
+            result["inputs_embeds"] = state.prepared_inputs_embeds
+            result["input_token_ids"] = list(state.prepared_input_token_ids)
+            return result
+        self._require_special_token_ids()
+        if audio_waveform is None or len(audio_waveform) == 0:
+            return self._stage_prefill_result(False, start_time, "empty audio")
+        # Omni duplex: encode this append's camera frames up front so the unit
+        # loop can interleave one <image> block per unit, mirroring official
+        # streaming_prefill (feed <unit>, then image embeds, then audio).
+        frame_blocks: list[Any] = []
+        if video_frames:
+            self._require_vision_token_ids()
+            frame_blocks = self._stage_vision_embeddings(video_frames)
+            if frame_blocks is None or len(frame_blocks) != len(video_frames):
+                return self._stage_prefill_result(False, start_time, "streaming vision embedding failed")
+        state.audio_buffer = np.concatenate([state.audio_buffer, np.asarray(audio_waveform, dtype=np.float32)])
+        chunk_size = self._streaming_chunk_size(processor)
+        self._pad_first_audio_chunk_if_needed(state, processor)
+        if len(state.audio_buffer) < chunk_size:
+            return self._stage_prefill_result(
+                False,
+                start_time,
+                f"audio not enough: need {chunk_size} samples, only {len(state.audio_buffer)}",
+            )
+
+        embed_parts: list[Any] = []
+        token_ids: list[int] = []
+        if state.audio_chunk_idx == 0 and state.context_embeds:
+            embed_parts.extend(state.context_embeds)
+            token_ids.extend(state.context_token_ids)
+
+        # Consume every complete processor chunk in the buffer so the appended
+        # span and the scheduler's slot reservation agree exactly. The serving
+        # PCM buffer pads a final real residual before it reaches Stage0. Do not
+        # pad again here: the first processor chunk is hop-aligned below 1035ms
+        # and intentionally leaves a small carry that is not another model unit.
+        units_built = 0
+        while True:
+            if len(state.audio_buffer) < chunk_size:
+                break
+            audio_chunk = state.audio_buffer[:chunk_size]
+            batch_feature = self._process_streaming_audio(audio_chunk, state.audio_chunk_idx, processor=processor)
+            for name, value in (
+                ("chunk_idx", state.audio_chunk_idx),
+                ("use_extra_context", True),
+                ("prefix_extra_frames", 0 if state.audio_chunk_idx == 0 else 2),
+                ("suffix_extra_frames", 2),
+            ):
+                with suppress(Exception):
+                    setattr(batch_feature, name, value)
+            audio_embeds = self._stage_audio_embeddings(batch_feature, state=state)
+            if audio_embeds is None:
+                if units_built == 0:
+                    return self._stage_prefill_result(False, start_time, "streaming audio embedding returned empty")
+                break
+            consumed_samples = self._consumed_audio_samples(
+                state.audio_chunk_idx,
+                chunk_size,
+                processor=processor,
+            )
+            if state.audio_chunk_idx > 0:
+                # Official duplex closes every unit (finalize_unit feeds the
+                # sampled terminator + </unit>) before the next <unit> opens.
+                # The scheduler session update discards the previous segment's
+                # sampled terminator token, so it is re-injected here ahead of
+                # the closure; the model's listen/speak policy depends on
+                # seeing its own past decisions in context.
+                pending_terminator = state.pending_terminator_token
+                if pending_terminator is not None and units_built == 0:
+                    state.pending_terminator_token = None
+                    embed_parts.append(self._embed_token(pending_terminator))
+                    token_ids.append(int(pending_terminator))
+                embed_parts.append(self._embed_token(self.unit_end_token_id))
+                token_ids.append(self.unit_end_token_id)
+            embed_parts.append(self._embed_token(self.unit_token_id))
+            token_ids.append(self.unit_token_id)
+            if frame_blocks:
+                # Official order inside a unit: <image> + 64 resampler
+                # embeddings + </image> ahead of the unit's audio embeddings
+                # (max_slice_nums=1 in streaming, one frame per unit).
+                vision_block = self._as_2d_tensor(frame_blocks.pop(0))
+                embed_parts.append(self._embed_token(self.image_start_token_id))
+                token_ids.append(int(self.image_start_token_id))
+                embed_parts.append(vision_block)
+                token_ids.extend([self._vision_embedding_placeholder_token_id()] * int(vision_block.shape[0]))
+                embed_parts.append(self._embed_token(self.image_end_token_id))
+                token_ids.append(int(self.image_end_token_id))
+            embed_parts.append(audio_embeds)
+            token_ids.extend(
+                [self._audio_embedding_placeholder_token_id()] * int(self._as_2d_tensor(audio_embeds).shape[0])
+            )
+            state.audio_buffer = state.audio_buffer[consumed_samples:]
+            state.audio_chunk_idx += 1
+            units_built += 1
+            chunk_size = self._streaming_chunk_size(processor)
+        if frame_blocks:
+            # Each frame reserves one image block in the append plan. A frame
+            # without a matching audio unit would desynchronize that plan.
+            return self._stage_prefill_result(
+                False,
+                start_time,
+                f"{len(frame_blocks)} video frame(s) left without a matching audio unit",
+            )
+        # Match official streaming_prefill: per chunk feed ONLY <unit>+audio. The assistant
+        # turn is opened once at session init; re-emitting the turn-open prefix per chunk
+        # re-opened the turn each chunk -> degenerate repetition. tts_bos/listen/turn_eos are
+        # model-generated and tracked via current_turn_ended (mirrors streaming_generate).
+        prompt_suffix_len = 0
+
+        import torch
+
+        inputs_embeds = torch.cat([self._as_2d_tensor(embed) for embed in embed_parts], dim=0)
+        result = self._stage_prefill_result(True, start_time)
+        result.update(
+            {
+                "inputs_embeds": inputs_embeds,
+                "input_token_ids": token_ids,
+                "special_token_ids": self._special_token_ids(),
+                "num_input_tokens": int(inputs_embeds.shape[0]),
+                "prompt_suffix_len": prompt_suffix_len,
+                "uses_model_runner_scheduler": True,
+                "runner_kv_backed": True,
+                "runtime_impl": "scheduler_data_plane",
+            }
+        )
+        if is_speech and (append_identity is None or state.pending_speech_append_identity != append_identity):
+            state.pending_speech_context = True
+            state.pending_speech_append_identity = append_identity
+        if append_identity is not None:
+            state.prepared_append_identity = append_identity
+            state.prepared_inputs_embeds = inputs_embeds
+            state.prepared_input_token_ids = list(token_ids)
+            state.prepared_result = {k: v for k, v in result.items() if k not in {"inputs_embeds", "input_token_ids"}}
+        return result
+
+    @staticmethod
+    def _stage_prefill_result(success: bool, start_time: float, reason: str = "") -> dict[str, Any]:
+        return {
+            "success": success,
+            "prefill_success": success,
+            "is_buffering": not success,
+            "reason": reason,
+            "cost_all": time.time() - start_time,
+            "stage_runtime_ready": True,
+        }
+
+    @staticmethod
+    def _as_2d_tensor(value: Any) -> Any:
+        if value.ndim == 1:
+            return value.unsqueeze(0)
+        if value.ndim == 3 and value.shape[0] == 1:
+            return value.squeeze(0)
+        return value
+
+    def _embed_token(self, token_id: int) -> Any:
+        import torch
+
+        token = torch.tensor([int(token_id)], dtype=torch.long, device=self._model_device())
+        embedder = self._token_embedder()
+        embeds = embedder(token)
+        return self._as_2d_tensor(embeds)
+
+    def _token_embedder(self) -> Any:
+        nested_embed = getattr(getattr(getattr(self.thinker, "llm", None), "model", None), "embed_tokens", None)
+        if callable(nested_embed):
+            return nested_embed
+        for target in (self.thinker, self.stage_model):
+            embedder = getattr(target, "get_input_embeddings", None)
+            if callable(embedder):
+                try:
+                    embeddings = embedder()
+                    if callable(embeddings):
+                        return embeddings
+                except TypeError:
+                    return embedder
+        raise AttributeError("MiniCPM-o stage0 model does not expose token embeddings")
+
+    def _model_device(self) -> Any:
+        try:
+            return next(self.thinker.parameters()).device
+        except Exception:
+            pass
+        try:
+            return next(self.stage_model.parameters()).device
+        except Exception:
+            pass
+        return self.device
+
+    def _streaming_chunk_size(self, processor: Any | None = None) -> int:
+        processor = processor or self.processor
+        get_chunk = getattr(processor, "get_streaming_chunk_size", None)
+        if callable(get_chunk):
+            return int(get_chunk())
+        return 16000
+
+    def _sample_rate(self, processor: Any | None = None) -> int:
+        processor = processor or self.processor
+        return int(
+            self._stage_param(
+                "sample_rate",
+                getattr(getattr(processor, "_streaming_mel_processor", None), "sample_rate", 16000),
+            )
+        )
+
+    def _first_chunk_samples(self, default_chunk_size: int, processor: Any | None = None) -> int:
+        processor = processor or self.processor
+        if getattr(processor, "_streaming_mel_processor", None) is None:
+            return default_chunk_size
+        return int(self._stage_param("first_chunk_ms", 1035) * self._sample_rate(processor) / 1000)
+
+    def _pad_first_audio_chunk_if_needed(
+        self,
+        state: _MiniCPMO45Stage0SessionState,
+        processor: Any | None = None,
+    ) -> None:
+        if state.audio_chunk_idx != 0 or len(state.audio_buffer) == 0:
+            return
+        first_chunk_samples = self._first_chunk_samples(
+            self._streaming_chunk_size(processor),
+            processor,
+        )
+        if len(state.audio_buffer) >= first_chunk_samples:
+            return
+        padding = np.zeros(first_chunk_samples - len(state.audio_buffer), dtype=np.float32)
+        state.audio_buffer = np.concatenate([padding, state.audio_buffer])
+
+    def _stage_param(self, name: str, default: Any) -> Any:
+        for target in (self.stage_model, self.thinker, getattr(self.thinker, "llm", None)):
+            value = getattr(target, name, None)
+            if value is not None:
+                return value
+            value = getattr(target, name.upper(), None)
+            if value is not None:
+                return value
+        return default
+
+    def _consumed_audio_samples(
+        self,
+        chunk_idx: int,
+        default_chunk_size: int,
+        *,
+        processor: Any | None = None,
+    ) -> int:
+        processor = processor or self.processor
+        if chunk_idx != 0:
+            chunk_ms = int(self._stage_param("chunk_ms", 1000))
+            return int(chunk_ms * self._sample_rate(processor) / 1000)
+        mel_processor = getattr(processor, "_streaming_mel_processor", None)
+        get_config = getattr(mel_processor, "get_config", None)
+        if callable(get_config):
+            cfg = get_config()
+            if isinstance(cfg, dict):
+                consumed_ms = int(cfg.get("effective_first_chunk_ms", self._stage_param("first_chunk_ms", 1035)))
+                return int(consumed_ms * self._sample_rate(processor) / 1000)
+        return default_chunk_size
+
+    def _process_streaming_audio(
+        self,
+        audio_chunk: Any,
+        chunk_idx: int,
+        *,
+        processor: Any | None = None,
+    ) -> Any:
+        processor = processor or self.processor
+        process = getattr(processor, "process_audio_streaming", None)
+        if callable(process):
+            try:
+                return process(audio_chunk, reset=False, return_batch_feature=True)
+            except TypeError:
+                return process(audio_chunk, chunk_idx=chunk_idx)
+        return {"audio_features": audio_chunk, "audio_feature_lens": [[len(audio_chunk)]]}
+
+    def _stage_audio_embeddings(
+        self,
+        batch_feature: Any,
+        *,
+        state: _MiniCPMO45Stage0SessionState | None = None,
+    ) -> Any | None:
+        if hasattr(batch_feature, "to"):
+            batch_feature = batch_feature.to(self.device)
+        self._ensure_dynamic_cache_compat()
+        has_audio_cache = state is not None and hasattr(self.thinker, "audio_past_key_values")
+        previous_audio_past_key_values = (
+            getattr(self.thinker, "audio_past_key_values", None) if has_audio_cache else None
+        )
+        if has_audio_cache:
+            self.thinker.audio_past_key_values = state.audio_past_key_values
+        try:
+            for target in (self.stage_model, self.thinker):
+                get_streaming = getattr(target, "get_audio_embedding_streaming", None)
+                if callable(get_streaming):
+                    try:
+                        result = self._cat_nested_tensors(
+                            get_streaming(
+                                batch_feature,
+                                use_extra_context=True,
+                                prefix_extra_frames=0 if int(getattr(batch_feature, "chunk_idx", 0)) == 0 else 2,
+                                suffix_extra_frames=2,
+                            )
+                        )
+                        if has_audio_cache:
+                            state.audio_past_key_values = getattr(self.thinker, "audio_past_key_values", None)
+                        return result
+                    except TypeError:
+                        result = self._cat_nested_tensors(get_streaming(batch_feature))
+                        if has_audio_cache:
+                            state.audio_past_key_values = getattr(self.thinker, "audio_past_key_values", None)
+                        return result
+                get_hidden = getattr(target, "get_audio_hidden_states", None)
+                if callable(get_hidden):
+                    result = self._cat_nested_tensors(get_hidden(batch_feature))
+                    if has_audio_cache:
+                        state.audio_past_key_values = getattr(self.thinker, "audio_past_key_values", None)
+                    return result
+            return None
+        finally:
+            if has_audio_cache:
+                self.thinker.audio_past_key_values = previous_audio_past_key_values
+
+    @staticmethod
+    def _decode_ref_audio_from_session_config(session_config: dict[str, Any]) -> Any | None:
+        from vllm_omni.experimental.fullduplex.minicpmo45.input import decode_native_ref_audio_from_config
+
+        return decode_native_ref_audio_from_config({"extra_body": session_config})
+
+    def _stage_ref_audio_embeddings(
+        self,
+        ref_audio: Any,
+        *,
+        state: _MiniCPMO45Stage0SessionState | None = None,
+    ) -> Any | None:
+        process_audio = getattr(self.processor, "process_audio", None)
+        if callable(process_audio):
+            batch_feature = process_audio([ref_audio])
+            if hasattr(batch_feature, "to"):
+                batch_feature = batch_feature.to(self.device)
+            self._ensure_dynamic_cache_compat()
+            for target in (self.stage_model, self.thinker):
+                get_audio_embedding = getattr(target, "get_audio_embedding", None)
+                if callable(get_audio_embedding):
+                    try:
+                        chunk_length = getattr(getattr(target, "config", None), "audio_chunk_length", None)
+                        if chunk_length is not None:
+                            return self._cat_nested_tensors(
+                                get_audio_embedding(batch_feature, chunk_length=chunk_length)
+                            )
+                    except TypeError:
+                        pass
+                    return self._cat_nested_tensors(get_audio_embedding(batch_feature))
+                # The split vLLM stage0 wrapper ports official
+                # get_audio_embedding(chunk_length=...) as
+                # get_audio_hidden_states (chunk_length comes from config).
+                get_hidden = getattr(target, "get_audio_hidden_states", None)
+                if callable(get_hidden):
+                    return self._cat_nested_tensors(get_hidden(batch_feature))
+        # The split vLLM stage0 wrapper may only expose the streaming encoder
+        # path.  Use it as a fallback so the server-resolved reference audio is
+        # still represented in the same system context location as official
+        # MiniCPM-o prepare().
+        processor = state.streaming_processor if state is not None else self.processor
+        batch_feature = self._process_streaming_audio(ref_audio, 0, processor=processor)
+        for name, value in (
+            ("chunk_idx", 0),
+            ("use_extra_context", True),
+            ("prefix_extra_frames", 0),
+            ("suffix_extra_frames", 2),
+        ):
+            with suppress(Exception):
+                setattr(batch_feature, name, value)
+        return self._stage_audio_embeddings(batch_feature, state=state)
+
+    @staticmethod
+    def _ensure_dynamic_cache_compat() -> None:
+        try:
+            from transformers.cache_utils import DynamicCache
+        except Exception:
+            return
+        if hasattr(DynamicCache, "get_usable_length"):
+            return
+
+        def get_usable_length(self, new_seq_length: int | None = None, layer_idx: int = 0) -> int:
+            get_seq_length = getattr(self, "get_seq_length", None)
+            if not callable(get_seq_length):
+                return 0
+            try:
+                return int(get_seq_length(layer_idx))
+            except TypeError:
+                return int(get_seq_length())
+
+        DynamicCache.get_usable_length = get_usable_length  # type: ignore[attr-defined]
+
+    @staticmethod
+    def _cat_nested_tensors(value: Any) -> Any | None:
+        import torch
+
+        tensors = []
+
+        def collect(item: Any) -> None:
+            if item is None:
+                return
+            if hasattr(item, "detach"):
+                tensors.append(item)
+                return
+            if isinstance(item, dict):
+                for child in item.values():
+                    collect(child)
+                return
+            if isinstance(item, (list, tuple)):
+                for child in item:
+                    collect(child)
+
+        collect(value)
+        if not tensors:
+            return None
+        return torch.cat([tensor.reshape(-1, tensor.shape[-1]) for tensor in tensors], dim=0)
+
+    def _encode_text(self, text: str) -> list[int]:
+        encode = getattr(self.tokenizer, "encode", None)
+        if callable(encode):
+            return list(encode(text, add_special_tokens=False))
+        return []
+
+    def _special_token_ids(self) -> dict[str, int]:
+        return {
+            name: value
+            for name, value in {
+                "unit_token_id": self.unit_token_id,
+                "unit_end_token_id": self.unit_end_token_id,
+                "listen_token_id": self.listen_token_id,
+                "speak_token_id": self.speak_token_id,
+                "tts_bos_token_id": self.tts_bos_token_id,
+                "tts_eos_token_id": self.tts_eos_token_id,
+                "tts_pad_token_id": self.tts_pad_token_id,
+                "chunk_eos_token_id": self.chunk_eos_token_id,
+                "chunk_tts_eos_token_id": self.chunk_tts_eos_token_id,
+                "turn_eos_token_id": self.turn_eos_token_id,
+            }.items()
+            if isinstance(value, int) and value >= 0
+        }
+
+    @staticmethod
+    def _load_processor_from_path(model_path: str | None) -> Any | None:
+        if not model_path:
+            return None
+        try:
+            from transformers import AutoImageProcessor, AutoProcessor
+
+            original_register = AutoImageProcessor.register
+
+            def register_image_processor(config_class, *args, **kwargs):
+                # The checkpoint's auto_map already loads this class. Its
+                # legacy string registration is incompatible with some
+                # Transformers versions and is otherwise redundant.
+                if config_class == "MiniCPMVImageProcessor":
+                    return None
+                return original_register(config_class, *args, **kwargs)
+
+            with _MINICPMO45_PROCESSOR_LOAD_LOCK:
+                AutoImageProcessor.register = staticmethod(register_image_processor)
+                try:
+                    processor = AutoProcessor.from_pretrained(
+                        model_path,
+                        trust_remote_code=True,
+                    )
+                finally:
+                    AutoImageProcessor.register = staticmethod(original_register)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to load MiniCPM-o duplex processor from {model_path!r}") from exc
+        if getattr(processor, "tokenizer", None) is None:
+            raise RuntimeError(f"MiniCPM-o duplex processor loaded from {model_path!r} does not expose a tokenizer")
+        return processor
+
+    def _init_token_ids(self) -> None:
+        if self.tokenizer is None:
+            for field_name in _MINICPMO45_SPECIAL_TOKEN_FIELDS:
+                setattr(self, field_name, -1)
+            for field_name in _MINICPMO45_OPTIONAL_TOKEN_FIELDS:
+                setattr(self, field_name, -1)
+        else:
+            for field_name, token in _MINICPMO45_SPECIAL_TOKEN_FIELDS.items():
+                setattr(self, field_name, self._resolve_special_token_id(token))
+            for field_name, token in _MINICPMO45_OPTIONAL_TOKEN_FIELDS.items():
+                setattr(self, field_name, self._resolve_special_token_id(token))
+
+    def _resolve_special_token_id(self, token: str) -> int:
+        if self.tokenizer is None:
+            return -1
+
+        unk_token_id = getattr(self.tokenizer, "unk_token_id", None)
+        candidate = None
+        convert = getattr(self.tokenizer, "convert_tokens_to_ids", None)
+        if callable(convert):
+            value = convert(token)
+            if isinstance(value, list):
+                value = value[0] if len(value) == 1 else None
+            with suppress(TypeError, ValueError):
+                candidate = int(value)
+        if candidate is not None and candidate >= 0 and candidate != unk_token_id:
+            return candidate
+
+        encode = getattr(self.tokenizer, "encode", None)
+        if callable(encode):
+            ids = list(encode(token, add_special_tokens=False))
+            if len(ids) == 1:
+                value = int(ids[0])
+                if value >= 0 and value != unk_token_id:
+                    return value
+        return -1
+
+    def _require_special_token_ids(self) -> None:
+        missing = [
+            token
+            for field_name, token in _MINICPMO45_SPECIAL_TOKEN_FIELDS.items()
+            if not isinstance(getattr(self, field_name, None), int) or getattr(self, field_name) < 0
+        ]
+        if missing:
+            raise ValueError(
+                "MiniCPM-o 4.5 native duplex requires tokenizer-defined special "
+                f"tokens, missing or unknown: {', '.join(missing)}"
+            )
+
+    def _required_token_id(self, field_name: str) -> int:
+        token_id = getattr(self, field_name, None)
+        if not isinstance(token_id, int) or token_id < 0:
+            token = _MINICPMO45_SPECIAL_TOKEN_FIELDS.get(field_name, field_name)
+            raise ValueError(f"MiniCPM-o 4.5 missing required special token id for {token}")
+        return token_id
+
+    def stage_padding_token_id(self) -> int:
+        return self._required_token_id("unit_end_token_id")
+
+    def _audio_embedding_placeholder_token_id(self) -> int:
+        token_id = getattr(self, "audio_placeholder_token_id", -1)
+        if isinstance(token_id, int) and token_id >= 0:
+            return token_id
+        return self.stage_padding_token_id()
+
+    @staticmethod
+    def _decode_audio_payload(payload: dict[str, Any]) -> Any:
+        audio = payload.get("audio") or payload.get("data")
+        if not isinstance(audio, str):
+            raise ValueError("audio append payload requires base64 audio")
+        fmt = payload.get("format") or "pcm_f32le"
+        if fmt != "pcm_f32le":
+            raise ValueError(f"MiniCPM-o stage0 expects pcm_f32le audio, got {fmt!r}")
+        return np.frombuffer(base64.b64decode(audio), dtype=np.float32)
+
+    @staticmethod
+    def _decode_video_frames_payload(payload: dict[str, Any]) -> list[Any]:
+        """Decode omni-duplex camera frames (base64 JPEG/PNG) to PIL images."""
+        frames = payload.get("video_frames")
+        if not isinstance(frames, list) or not frames:
+            return []
+        from io import BytesIO
+
+        from PIL import Image
+
+        decoded: list[Any] = []
+        for frame_b64 in frames:
+            if not isinstance(frame_b64, str) or not frame_b64:
+                continue
+            try:
+                raw = base64.b64decode(frame_b64, validate=True)
+                image = Image.open(BytesIO(raw))
+                image.load()
+            except Exception as exc:  # noqa: BLE001 - normalized below
+                raise ValueError("invalid omni duplex video frame payload") from exc
+            decoded.append(image.convert("RGB"))
+        return decoded
+
+    def _vision_embedding_placeholder_token_id(self) -> int:
+        unk_token_id = getattr(self.tokenizer, "unk_token_id", None)
+        if isinstance(unk_token_id, int) and unk_token_id >= 0:
+            return unk_token_id
+        return self._required_optional_token_id("image_start_token_id")
+
+    def _required_optional_token_id(self, field_name: str) -> int:
+        token_id = getattr(self, field_name, None)
+        if not isinstance(token_id, int) or token_id < 0:
+            token = _MINICPMO45_OPTIONAL_TOKEN_FIELDS.get(field_name, field_name)
+            raise ValueError(f"MiniCPM-o 4.5 missing required special token id for {token}")
+        return token_id
+
+    def _require_vision_token_ids(self) -> None:
+        missing = [
+            _MINICPMO45_OPTIONAL_TOKEN_FIELDS[field_name]
+            for field_name in ("image_start_token_id", "image_end_token_id")
+            if not isinstance(getattr(self, field_name, None), int) or getattr(self, field_name) < 0
+        ]
+        if missing:
+            raise ValueError(
+                "MiniCPM-o 4.5 omni duplex requires tokenizer-defined image tokens, "
+                f"missing or unknown: {', '.join(missing)}"
+            )
+
+    def _stage_vision_embeddings(self, frames: list[Any]) -> list[Any] | None:
+        """Encode camera frames for omni duplex via the loaded vision tower.
+
+        Semantics mirror ``MiniCPMODuplex.streaming_prefill`` (one 64-embedding
+        block per frame at ``max_slice_nums=1``), executed through the vLLM
+        wrapper's ``get_vision_hidden_states`` (vpm + resampler) since the
+        stage model does not expose the remote-code ``get_vision_embedding``.
+        """
+        process_image = getattr(self.processor, "process_image", None)
+        if not callable(process_image):
+            return None
+        try:
+            processed = process_image(frames, max_slice_nums=1)
+        except Exception:  # noqa: BLE001 - prefill fails with a reason
+            return None
+        targets = (self.stage_model, self.thinker, getattr(self.stage_model, "model", None))
+        for target in targets:
+            if target is None:
+                continue
+            get_hidden = getattr(target, "get_vision_hidden_states", None)
+            vpm = getattr(target, "vpm", None)
+            if not callable(get_hidden) or vpm is None:
+                continue
+            try:
+                import torch
+
+                vpm_param = next(vpm.parameters())
+                device, dtype = vpm_param.device, vpm_param.dtype
+                pixel_nested = processed["pixel_values"]
+                tgt_nested = processed["tgt_sizes"]
+                flat_pixels: list[Any] = []
+                flat_tgt: list[Any] = []
+                for image_slices, image_tgt in zip(pixel_nested, tgt_nested):
+                    for slice_pixels in image_slices:
+                        flat_pixels.append(slice_pixels.to(device=device, dtype=dtype))
+                    tgt_tensor = image_tgt if hasattr(image_tgt, "reshape") else torch.tensor(image_tgt)
+                    flat_tgt.append(tgt_tensor.reshape(-1, 2))
+                tgt_sizes = torch.cat(flat_tgt, dim=0).to(device=device, dtype=torch.int64)
+                with torch.no_grad():
+                    hidden = get_hidden({"pixel_values": flat_pixels, "tgt_sizes": tgt_sizes})
+            except Exception:  # noqa: BLE001 - prefill fails with a reason
+                return None
+            expected = MiniCPMO45DuplexPolicy.VISION_EMBEDS_PER_FRAME
+            out: list[Any] = []
+            for block in hidden:
+                block_2d = self._as_2d_tensor(block)
+                if int(block_2d.shape[0]) != expected:
+                    return None
+                out.append(block_2d)
+            return out
+        return None
diff --git a/vllm_omni/experimental/fullduplex/model_executor.py b/vllm_omni/experimental/fullduplex/model_executor.py
new file mode 100644
index 000000000..eebe01876
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/model_executor.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexSamplingRow:
+    """Request-local context for the experimental duplex sampling hook."""
+
+    row_idx: int
+    request_id: str
+    session_id: str | None
+    incarnation: int
+    seq: int | None
+    payload: dict[str, object] | None
+    max_tokens: int | None
+
+
+class DuplexSamplingHelper:
+    """Tracks duplex sampling rows outside the generic AR model runner."""
+
+    def __init__(self) -> None:
+        self.active_request_ids: set[str] = set()
+        self.hook_active = False
+
+    @staticmethod
+    def _is_duplex_data_plane_info(info: object) -> bool:
+        duplex = info.get("duplex") if isinstance(info, dict) else None
+        return isinstance(duplex, dict) and duplex.get("data_plane") is True
+
+    @staticmethod
+    def _request_intermediate_info(runner: object, req_id: str) -> dict[str, Any] | None:
+        model_intermediate_buffer = getattr(runner, "model_intermediate_buffer", {})
+        info = model_intermediate_buffer.get(req_id) if isinstance(model_intermediate_buffer, dict) else None
+        if isinstance(info, dict):
+            return info
+        requests = getattr(runner, "requests", {})
+        req_state = requests.get(req_id) if isinstance(requests, dict) else None
+        info = getattr(req_state, "additional_information_cpu", None)
+        return info if isinstance(info, dict) else None
+
+    def refresh_active_request(self, runner: object, req_id: str) -> None:
+        if self._is_duplex_data_plane_info(self._request_intermediate_info(runner, req_id)):
+            self.active_request_ids.add(req_id)
+        else:
+            self.active_request_ids.discard(req_id)
+
+    def update_states(self, runner: object, scheduler_output: object) -> None:
+        self.active_request_ids.difference_update(str(req_id) for req_id in scheduler_output.finished_req_ids)
+        for request in scheduler_output.scheduled_new_reqs:
+            self.refresh_active_request(runner, str(request.req_id))
+
+    def rows(self, runner: object) -> tuple[DuplexSamplingRow, ...]:
+        rows: list[DuplexSamplingRow] = []
+        req_ids = [str(req_id) for req_id in getattr(runner.input_batch, "req_ids", [])]
+        requests = getattr(runner, "requests", {})
+        for row_idx, req_id in enumerate(req_ids):
+            if req_id not in self.active_request_ids:
+                continue
+            info = self._request_intermediate_info(runner, req_id)
+            duplex = info.get("duplex") if isinstance(info, dict) else None
+            if not isinstance(duplex, dict) or duplex.get("data_plane") is not True:
+                continue
+            session_id = duplex.get("session_id")
+            if not isinstance(session_id, str) or not session_id:
+                session_id = None
+            try:
+                incarnation = int(duplex.get("incarnation", 0))
+            except (TypeError, ValueError):
+                incarnation = 0
+            try:
+                seq = int(duplex.get("seq"))
+            except (TypeError, ValueError):
+                seq = None
+            payload = duplex.get("payload")
+            if not isinstance(payload, dict):
+                payload = None
+            request = requests.get(req_id) if isinstance(requests, dict) else None
+            sampling_params = getattr(request, "sampling_params", None)
+            try:
+                max_tokens = int(getattr(sampling_params, "max_tokens", 0) or 0)
+            except (TypeError, ValueError):
+                max_tokens = 0
+            rows.append(
+                DuplexSamplingRow(
+                    row_idx=row_idx,
+                    request_id=req_id,
+                    session_id=session_id,
+                    incarnation=incarnation,
+                    seq=seq,
+                    payload=payload,
+                    max_tokens=max_tokens if max_tokens > 0 else None,
+                )
+            )
+        return tuple(rows)
+
+    def clear(self) -> None:
+        self.active_request_ids.clear()
+        self.hook_active = False
+
+
+__all__ = ["DuplexSamplingHelper", "DuplexSamplingRow"]
diff --git a/vllm_omni/experimental/fullduplex/openai/__init__.py b/vllm_omni/experimental/fullduplex/openai/__init__.py
new file mode 100644
index 000000000..1bb45f8d4
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from .websocket import DuplexWebSocketActor
+
+__all__ = ["DuplexWebSocketActor"]
diff --git a/vllm_omni/experimental/fullduplex/openai/audio.py b/vllm_omni/experimental/fullduplex/openai/audio.py
new file mode 100644
index 000000000..023bfdd9e
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/audio.py
@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import math
+import wave
+
+import numpy as np
+
+try:
+    from audioop import alaw2lin, lin2alaw, lin2ulaw, ulaw2lin
+except ImportError:  # pragma: no cover - audioop is removed in newer Python.
+    alaw2lin = lin2alaw = lin2ulaw = ulaw2lin = None
+
+
+MIN_INPUT_SAMPLE_RATE_HZ = 8_000
+MAX_INPUT_SAMPLE_RATE_HZ = 192_000
+
+
+def validate_input_sample_rate_hz(sample_rate_hz: int | float) -> int:
+    if isinstance(sample_rate_hz, bool) or (isinstance(sample_rate_hz, float) and not math.isfinite(sample_rate_hz)):
+        raise ValueError("sample_rate_hz must be a finite integer")
+    rate = int(sample_rate_hz)
+    if rate != sample_rate_hz:
+        raise ValueError("sample_rate_hz must be an integer")
+    if not MIN_INPUT_SAMPLE_RATE_HZ <= rate <= MAX_INPUT_SAMPLE_RATE_HZ:
+        raise ValueError(f"sample_rate_hz must be between {MIN_INPUT_SAMPLE_RATE_HZ} and {MAX_INPUT_SAMPLE_RATE_HZ}")
+    return rate
+
+
+def resample_pcm16_mono(raw: bytes, *, source_rate_hz: int, target_rate_hz: int) -> bytes:
+    if source_rate_hz <= 0 or target_rate_hz <= 0 or source_rate_hz == target_rate_hz:
+        return raw
+    samples = np.frombuffer(raw, dtype="<i2").astype(np.float32)
+    if samples.size <= 1:
+        return raw
+    target_size = max(1, int(round(samples.size * target_rate_hz / source_rate_hz)))
+    source_x = np.linspace(0.0, 1.0, num=samples.size, endpoint=True)
+    target_x = np.linspace(0.0, 1.0, num=target_size, endpoint=True)
+    resampled = np.interp(target_x, source_x, samples)
+    return np.clip(resampled, -32768, 32767).astype("<i2").tobytes()
+
+
+def decode_g711_ulaw(raw: bytes) -> bytes:
+    if ulaw2lin is not None:
+        return ulaw2lin(raw, 2)
+    data = np.frombuffer(raw, dtype=np.uint8)
+    value = np.bitwise_not(data).astype(np.int16)
+    sign = value & 0x80
+    exponent = (value >> 4) & 0x07
+    mantissa = value & 0x0F
+    sample = ((mantissa << 3) + 0x84) << exponent
+    return np.where(sign != 0, -(sample - 0x84), sample - 0x84).astype("<i2").tobytes()
+
+
+def decode_g711_alaw(raw: bytes) -> bytes:
+    if alaw2lin is not None:
+        return alaw2lin(raw, 2)
+    data = np.bitwise_xor(np.frombuffer(raw, dtype=np.uint8), 0x55).astype(np.int16)
+    sign = data & 0x80
+    exponent = (data >> 4) & 0x07
+    mantissa = data & 0x0F
+    sample = np.where(exponent == 0, (mantissa << 4) + 8, ((mantissa << 4) + 0x108) << (exponent - 1))
+    return np.where(sign != 0, sample, -sample).astype("<i2").tobytes()
+
+
+def encode_g711_ulaw(raw: bytes) -> bytes:
+    if lin2ulaw is not None:
+        return lin2ulaw(raw, 2)
+    pcm = np.clip(np.frombuffer(raw, dtype="<i2").astype(np.int32), -32635, 32635)
+    sign = np.where(pcm < 0, 0x80, 0)
+    magnitude = np.abs(pcm) + 0x84
+    exponent = np.zeros_like(magnitude)
+    for exp in range(7):
+        exponent = np.where(magnitude > (0xFF << exp), exp + 1, exponent)
+    mantissa = (magnitude >> (exponent + 3)) & 0x0F
+    return (np.bitwise_not(sign | (exponent << 4) | mantissa) & 0xFF).astype(np.uint8).tobytes()
+
+
+def encode_g711_alaw(raw: bytes) -> bytes:
+    if lin2alaw is not None:
+        return lin2alaw(raw, 2)
+    pcm = np.frombuffer(raw, dtype="<i2").astype(np.int32)
+    sign = np.where(pcm >= 0, 0x80, 0x00)
+    magnitude = np.abs(pcm)
+    exponent = np.zeros_like(magnitude)
+    for exp in range(1, 8):
+        exponent = np.where(magnitude >= (1 << (exp + 7)), exp, exponent)
+    mantissa = np.where(
+        exponent == 0,
+        (magnitude >> 4) & 0x0F,
+        (magnitude >> (exponent + 3)) & 0x0F,
+    )
+    return ((sign | (exponent << 4) | mantissa) ^ 0x55).astype(np.uint8).tobytes()
+
+
+def wav_payload_to_pcm16(raw: bytes) -> tuple[bytes | None, int | None]:
+    try:
+        with wave.open(io.BytesIO(raw), "rb") as wav_file:
+            channels = wav_file.getnchannels()
+            sample_width = wav_file.getsampwidth()
+            sample_rate_hz = wav_file.getframerate()
+            frames = wav_file.readframes(wav_file.getnframes())
+        if sample_width != 2:
+            return None, sample_rate_hz
+        if channels <= 1:
+            return frames, sample_rate_hz
+        pcm = np.frombuffer(frames, dtype="<i2").reshape(-1, channels)
+        mono = np.mean(pcm.astype(np.float32), axis=1)
+        return np.clip(mono, -32768, 32767).astype("<i2").tobytes(), sample_rate_hz
+    except (EOFError, ValueError, wave.Error):
+        return None, None
+
+
+def convert_input_audio_with_rate(
+    audio: object,
+    fmt: object,
+    *,
+    sample_rate_hz: int | float | None = None,
+    target_sample_rate_hz: int = 16_000,
+) -> tuple[object, object, int | float | None]:
+    if not isinstance(audio, str) or not isinstance(fmt, str):
+        return audio, fmt, sample_rate_hz
+    normalized = fmt.lower()
+    if normalized not in {"pcm16", "pcm_s16le", "s16le", "g711_ulaw", "g711_alaw"}:
+        return audio, fmt, sample_rate_hz
+    if isinstance(sample_rate_hz, int | float):
+        sample_rate_hz = validate_input_sample_rate_hz(sample_rate_hz)
+    try:
+        raw = base64.b64decode(audio.strip(), validate=False)
+    except (binascii.Error, ValueError):
+        return audio, fmt, sample_rate_hz
+    if normalized == "g711_ulaw":
+        raw = decode_g711_ulaw(raw)
+        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
+    elif normalized == "g711_alaw":
+        raw = decode_g711_alaw(raw)
+        sample_rate_hz = sample_rate_hz if isinstance(sample_rate_hz, int | float) else 8_000
+    elif len(raw) % 2:
+        return audio, fmt, sample_rate_hz
+    if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) != target_sample_rate_hz:
+        raw = resample_pcm16_mono(
+            raw,
+            source_rate_hz=int(sample_rate_hz),
+            target_rate_hz=target_sample_rate_hz,
+        )
+        sample_rate_hz = target_sample_rate_hz
+    pcm = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    encoded = base64.b64encode(np.ascontiguousarray(pcm, dtype="<f4").tobytes()).decode("ascii")
+    return encoded, "pcm_f32le", sample_rate_hz
+
+
+def convert_output_audio(
+    audio: str,
+    *,
+    source_fmt: str,
+    target_fmt: str,
+    source_sample_rate_hz: int | None = None,
+    target_sample_rate_hz: int | None = None,
+) -> tuple[str, str, int | None]:
+    target = target_fmt.lower()
+    if target not in {"g711_ulaw", "g711_alaw"}:
+        return audio, source_fmt, source_sample_rate_hz
+    try:
+        raw = base64.b64decode(audio, validate=False)
+    except (binascii.Error, ValueError):
+        return audio, source_fmt, source_sample_rate_hz
+    source = source_fmt.lower()
+    if source == "wav":
+        pcm_raw, wav_rate = wav_payload_to_pcm16(raw)
+        if pcm_raw is None:
+            return audio, source_fmt, source_sample_rate_hz
+        raw = pcm_raw
+        source_sample_rate_hz = source_sample_rate_hz or wav_rate
+    elif source not in {"pcm", "pcm16", "pcm_s16le", "s16le"} or len(raw) % 2:
+        return audio, source_fmt, source_sample_rate_hz
+    target_rate = target_sample_rate_hz or 8_000
+    if source_sample_rate_hz is not None:
+        raw = resample_pcm16_mono(raw, source_rate_hz=source_sample_rate_hz, target_rate_hz=target_rate)
+    encoded = encode_g711_ulaw(raw) if target == "g711_ulaw" else encode_g711_alaw(raw)
+    return base64.b64encode(encoded).decode("ascii"), target, target_rate
diff --git a/vllm_omni/experimental/fullduplex/openai/chat_fallback.py b/vllm_omni/experimental/fullduplex/openai/chat_fallback.py
new file mode 100644
index 000000000..65d3b32fd
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/chat_fallback.py
@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
+from vllm.entrypoints.openai.engine.protocol import ErrorResponse
+from vllm.logger import init_logger
+
+from vllm_omni.experimental.fullduplex.openai.protocol import DuplexSession
+
+logger = init_logger(__name__)
+
+
+class ChatFallbackProjectorMixin:
+    """Project generic chat completion output into duplex response events."""
+
+    async def _run_response(self, session: DuplexSession, send_json) -> None:
+        response_id = session.begin_response()
+        epoch = session.epoch
+        request_id = f"duplex-{session.session_id}-{epoch}-{session.input_commit_seq}"
+        session.bind_request(f"chatcmpl-{request_id}")
+        await send_json(
+            self._response_created_payload(
+                session,
+                response_id,
+                epoch=epoch,
+                request_id=session.active_request_id,
+            )
+        )
+
+        try:
+            request = self._build_chat_request(session, request_id)
+            result = await self._chat_service.create_chat_completion(request, raw_request=None)
+            if isinstance(result, ErrorResponse):
+                await send_json({"type": "error", "error": result.message, "code": result.type or "chat_error"})
+                session.end_response(commit_text=False)
+                return
+            if hasattr(result, "__aiter__"):
+                await self._drain_streaming_response(session, result, epoch, response_id, send_json)
+            else:
+                await self._emit_full_response(session, result, epoch, response_id, send_json)
+            if session.epoch == epoch:
+                should_commit = self._should_commit_response_to_history(session, response_id)
+                committed_message = session.end_response(commit_text=should_commit)
+                if should_commit:
+                    session.register_history_item(f"item_{response_id}", committed_message)
+                await send_json(
+                    {
+                        "type": "response.done",
+                        "session_id": session.session_id,
+                        "response_id": response_id,
+                        "epoch": epoch,
+                        "committed": committed_message is not None,
+                        "playback": session.playback.as_dict(),
+                    }
+                )
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Duplex response failed: %s", exc)
+            session.end_response(commit_text=False)
+            await send_json(
+                {
+                    "type": "error",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "error": str(exc),
+                    "code": "response_error",
+                }
+            )
+
+    def _build_chat_request(self, session: DuplexSession, request_id: str) -> ChatCompletionRequest:
+        response_config = session.response_config
+        messages: list[dict[str, object]] = []
+        if response_config.instructions:
+            messages.append({"role": "system", "content": response_config.instructions})
+        messages.extend(session.history)
+
+        kwargs: dict[str, Any] = {
+            "model": response_config.model or self._chat_service.model_config.model,
+            "messages": messages,
+            "stream": True,
+        }
+        if response_config.temperature is not None:
+            kwargs["temperature"] = response_config.temperature
+        if response_config.max_tokens is not None:
+            kwargs["max_tokens"] = response_config.max_tokens
+        model_extra = dict(response_config.extra_body)
+        tools = model_extra.pop("realtime_response_tools", model_extra.pop("realtime_tools", None))
+        tool_choice = model_extra.pop(
+            "realtime_response_tool_choice",
+            model_extra.pop("realtime_tool_choice", None),
+        )
+        for protocol_key in (
+            "realtime_response_conversation",
+            "realtime_response_metadata",
+            "realtime_response_prompt",
+        ):
+            model_extra.pop(protocol_key, None)
+        kwargs.update(model_extra)
+        if isinstance(tools, list):
+            kwargs["tools"] = tools
+        if isinstance(tool_choice, str | dict):
+            kwargs["tool_choice"] = tool_choice
+
+        request = ChatCompletionRequest(**kwargs)
+        object.__setattr__(request, "modalities", response_config.modalities)
+        object.__setattr__(request, "request_id", request_id)
+        object.__setattr__(
+            request,
+            "chat_template_kwargs",
+            {"use_tts_template": response_config.use_tts_template},
+        )
+        return request
+
+    async def _drain_streaming_response(
+        self,
+        session: DuplexSession,
+        result: AsyncGenerator[str, None],
+        epoch: int,
+        response_id: str,
+        send_json,
+    ) -> None:
+        async for raw_chunk in result:
+            if session.epoch != epoch:
+                return
+            for payload in self._parse_sse_payloads(raw_chunk):
+                if payload == "[DONE]":
+                    continue
+                if isinstance(payload, dict):
+                    await self._emit_chat_payload(session, payload, epoch, response_id, send_json)
+
+    async def _emit_full_response(
+        self,
+        session: DuplexSession,
+        result: Any,
+        epoch: int,
+        response_id: str,
+        send_json,
+    ) -> None:
+        if hasattr(result, "model_dump"):
+            payload = result.model_dump(mode="json", exclude_unset=True)
+        else:
+            payload = {"response": str(result)}
+        await self._emit_chat_payload(session, payload, epoch, response_id, send_json)
+
+    def _parse_sse_payloads(self, raw_chunk: str) -> list[dict[str, object] | str]:
+        payloads: list[dict[str, object] | str] = []
+        for line in raw_chunk.splitlines():
+            line = line.strip()
+            if not line.startswith("data:"):
+                continue
+            data = line[5:].strip()
+            if not data:
+                continue
+            if data == "[DONE]":
+                payloads.append(data)
+                continue
+            try:
+                parsed = json.loads(data)
+            except json.JSONDecodeError:
+                logger.debug("Skipping non-JSON duplex stream payload: %s", data)
+                continue
+            if isinstance(parsed, dict):
+                payloads.append(parsed)
+        return payloads
+
+    async def _emit_chat_payload(
+        self,
+        session: DuplexSession,
+        payload: dict[str, object],
+        epoch: int,
+        response_id: str,
+        send_json,
+    ) -> None:
+        modality = payload.get("modality")
+        if modality not in {None, "text", "audio"}:
+            await send_json(
+                {
+                    "type": "error",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": epoch,
+                    "code": "unsupported_response_modality",
+                    "error": f"Unsupported chat response modality: {modality}",
+                }
+            )
+            return
+        choices = payload.get("choices")
+        if not isinstance(choices, list):
+            await send_json(
+                {
+                    "type": "response.message",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": epoch,
+                    "payload": payload,
+                }
+            )
+            return
+
+        for choice in choices:
+            if not isinstance(choice, dict):
+                continue
+            delta = choice.get("delta")
+            message = choice.get("message")
+            content = None
+            if isinstance(delta, dict):
+                content = delta.get("content")
+            elif isinstance(message, dict):
+                content = message.get("content")
+
+            if isinstance(content, str) and content:
+                if modality == "audio":
+                    session.mark_audio_sent()
+                    await send_json(
+                        {
+                            "type": "response.output_audio.delta",
+                            "session_id": session.session_id,
+                            "response_id": response_id,
+                            "epoch": epoch,
+                            "audio": content,
+                            "format": session.response_config.response_format,
+                        }
+                    )
+                else:
+                    session.append_assistant_text(content)
+                    await send_json(
+                        {
+                            "type": "response.text.delta",
+                            "session_id": session.session_id,
+                            "response_id": response_id,
+                            "epoch": epoch,
+                            "delta": content,
+                        }
+                    )
+
+            finish_reason = choice.get("finish_reason")
+            if finish_reason is not None and modality != "audio":
+                await send_json(
+                    {
+                        "type": "response.output_item.done",
+                        "session_id": session.session_id,
+                        "response_id": response_id,
+                        "epoch": epoch,
+                        "finish_reason": finish_reason,
+                        "modality": modality,
+                    }
+                )
diff --git a/vllm_omni/experimental/fullduplex/openai/commit_policy.py b/vllm_omni/experimental/fullduplex/openai/commit_policy.py
new file mode 100644
index 000000000..940509ec3
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/commit_policy.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class CommitAction(str, Enum):
+    """How one native audio commit participates in response scheduling."""
+
+    START_AUTO_RESPONSE = "start_auto_response"
+    DEFER_ACTIVE_RESPONSE = "defer_active_response"
+    COMMIT_ONLY = "commit_only"
+
+
+@dataclass(frozen=True, slots=True)
+class CommitSnapshot:
+    auto_responds: bool
+    speech_since_commit: bool
+    active_response_id: str | None
+    overlap_speech_ms: int
+    native_response_in_progress: bool
+    playback_active: bool
+
+
+def decide_commit_action(snapshot: CommitSnapshot) -> CommitAction:
+    """Choose response scheduling from an immutable session snapshot."""
+    if snapshot.auto_responds:
+        if snapshot.speech_since_commit:
+            return CommitAction.START_AUTO_RESPONSE
+        return CommitAction.COMMIT_ONLY
+    if snapshot.native_response_in_progress and snapshot.overlap_speech_ms > 0:
+        return CommitAction.DEFER_ACTIVE_RESPONSE
+    if snapshot.playback_active and snapshot.overlap_speech_ms > 0:
+        return CommitAction.DEFER_ACTIVE_RESPONSE
+    return CommitAction.COMMIT_ONLY
+
+
+__all__ = ["CommitAction", "CommitSnapshot", "decide_commit_action"]
diff --git a/vllm_omni/experimental/fullduplex/openai/protocol.py b/vllm_omni/experimental/fullduplex/openai/protocol.py
new file mode 100644
index 000000000..0a87d55b4
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/protocol.py
@@ -0,0 +1,1336 @@
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from types import MappingProxyType
+from uuid import uuid4
+
+
+class DuplexOverlapPolicy(str, Enum):
+    AUTO = "auto"
+    LISTEN_ONLY = "listen_only"
+    BARGE_IN_ON_SPEECH = "barge_in_on_speech"
+
+
+class DuplexPlaybackCommitPolicy(str, Enum):
+    COMMIT_ALL_ON_DONE = "commit_all_on_done"
+    ACK_ONLY = "ack_only"
+
+
+class DuplexSessionState(str, Enum):
+    OPEN = "open"
+    CLOSING = "closing"
+    CLOSED = "closed"
+
+
+class DuplexTurnState(str, Enum):
+    IDLE = "idle"
+    USER_SPEAKING = "user_speaking"
+    USER_COMMITTED = "user_committed"
+    ASSISTANT_GENERATING = "assistant_generating"
+    ASSISTANT_PLAYING = "assistant_playing"
+    BARGE_IN = "barge_in"
+
+
+class DuplexTurnEventType(str, Enum):
+    USER_STARTED = "user_started"
+    USER_COMMITTED = "user_committed"
+    ASSISTANT_STARTED = "assistant_started"
+    ASSISTANT_DONE = "assistant_done"
+    BARGE_IN = "barge_in"
+    PLAYBACK_ACK = "playback_ack"
+    TIMEOUT = "timeout"
+    CLOSE = "close"
+
+
+@dataclass
+class DuplexCapabilities:
+    """Runtime/model capabilities exposed by the duplex serving protocol.
+
+    These are intentionally explicit so the serving layer does not assume all
+    duplex models support the same input append, rollback, or turn policy.
+    ``supports_core_kv_lease`` is reserved for scheduler-owned KV lifecycle;
+    model-owned decoder/TTS state must use ``supports_model_internal_state``.
+    ``supports_core_resumable_request`` means the scheduler can resume the
+    same request id across streaming updates, but it is not a KV lease by
+    itself. Realtime support means this endpoint can speak the native Realtime
+    event schema for the supported audio duplex paths while keeping model- or
+    scheduler-specific limits explicit in the capability payload.
+    """
+
+    supports_session_adapter: bool = True
+    supports_model_native_turn_policy: bool = False
+    supports_external_turn_signal: bool = True
+    supports_client_commit: bool = True
+    supports_barge_in: bool = True
+    supports_playback_ack: bool = True
+    supports_input_append: bool = False
+    supports_replace_latest_chunk: bool = True
+    supports_reencode_context: bool = True
+    supports_rollback_to_checkpoint: bool = False
+    supports_turn_commit_only: bool = True
+    supports_kv_lease: bool = False
+    supports_core_kv_lease: bool = False
+    supports_model_internal_state: bool = False
+    supports_stage_resumption: bool = False
+    supports_scheduler_native_append: bool = False
+    supports_core_resumable_request: bool = False
+    supports_stage_connector_handoff: bool = False
+    supports_independent_io_streams: bool = False
+    supports_realtime_endpoint: bool = False
+    supports_multi_session: bool = False
+    supports_multi_session_same_replica: bool = False
+    supports_session_lease: bool = False
+    supports_session_resume: bool = False
+    session_admission_mode: str = "serving_managed"
+    supports_audio_truncate: bool = False
+    requires_model_runner_kv: bool = False
+    requires_native_stage_role: bool = False
+    implementation_level: str = "serving_session_adapter"
+    adapter_patterns: list[str] = field(default_factory=lambda: ["chunk_group_append"])
+    input_modes: list[str] = field(default_factory=lambda: ["turn_commit_only", "reencode_context"])
+    signal_sources: list[str] = field(default_factory=lambda: ["client_event", "server_policy", "model_native"])
+    stage_handoff_transport: str | None = None
+    chunk_period_ms: int | None = 1000
+    target_barge_in_latency_ms: int | None = 1000
+
+    @classmethod
+    def minicpmo45_native(cls, *, max_sessions: int = 1) -> DuplexCapabilities:
+        supports_multi_session = max_sessions > 1
+        return cls(
+            supports_model_native_turn_policy=True,
+            supports_barge_in=False,
+            supports_input_append=True,
+            supports_replace_latest_chunk=False,
+            supports_reencode_context=False,
+            supports_turn_commit_only=False,
+            supports_kv_lease=False,
+            supports_core_kv_lease=False,
+            supports_model_internal_state=True,
+            supports_stage_resumption=True,
+            supports_scheduler_native_append=False,
+            supports_core_resumable_request=True,
+            supports_stage_connector_handoff=True,
+            supports_independent_io_streams=True,
+            supports_realtime_endpoint=True,
+            supports_multi_session=supports_multi_session,
+            supports_multi_session_same_replica=supports_multi_session,
+            supports_session_lease=True,
+            supports_session_resume=True,
+            session_admission_mode="engine_managed",
+            supports_audio_truncate=True,
+            requires_model_runner_kv=True,
+            requires_native_stage_role=True,
+            implementation_level="model_native_duplex",
+            adapter_patterns=["scheduler_data_plane"],
+            input_modes=["append_audio_chunk"],
+            signal_sources=["model_native", "client_event", "server_policy"],
+            stage_handoff_transport="scheduler_data_plane",
+            chunk_period_ms=1000,
+            target_barge_in_latency_ms=None,
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "supports_session_adapter": self.supports_session_adapter,
+            "supports_model_native_turn_policy": self.supports_model_native_turn_policy,
+            "supports_external_turn_signal": self.supports_external_turn_signal,
+            "supports_client_commit": self.supports_client_commit,
+            "supports_barge_in": self.supports_barge_in,
+            "supports_playback_ack": self.supports_playback_ack,
+            "supports_input_append": self.supports_input_append,
+            "supports_replace_latest_chunk": self.supports_replace_latest_chunk,
+            "supports_reencode_context": self.supports_reencode_context,
+            "supports_rollback_to_checkpoint": self.supports_rollback_to_checkpoint,
+            "supports_turn_commit_only": self.supports_turn_commit_only,
+            "supports_kv_lease": self.supports_kv_lease,
+            "supports_core_kv_lease": self.supports_core_kv_lease,
+            "supports_model_internal_state": self.supports_model_internal_state,
+            "supports_stage_resumption": self.supports_stage_resumption,
+            "supports_scheduler_native_append": self.supports_scheduler_native_append,
+            "supports_core_resumable_request": self.supports_core_resumable_request,
+            "supports_stage_connector_handoff": self.supports_stage_connector_handoff,
+            "supports_independent_io_streams": self.supports_independent_io_streams,
+            "supports_realtime_endpoint": self.supports_realtime_endpoint,
+            "supports_multi_session": self.supports_multi_session,
+            "supports_multi_session_same_replica": self.supports_multi_session_same_replica,
+            "supports_session_lease": self.supports_session_lease,
+            "supports_session_resume": self.supports_session_resume,
+            "session_admission_mode": self.session_admission_mode,
+            "supports_audio_truncate": self.supports_audio_truncate,
+            "requires_model_runner_kv": self.requires_model_runner_kv,
+            "requires_native_stage_role": self.requires_native_stage_role,
+            "implementation_level": self.implementation_level,
+            "adapter_patterns": self.adapter_patterns,
+            "input_modes": self.input_modes,
+            "signal_sources": self.signal_sources,
+            "stage_handoff_transport": self.stage_handoff_transport,
+            "chunk_period_ms": self.chunk_period_ms,
+            "target_barge_in_latency_ms": self.target_barge_in_latency_ms,
+        }
+
+
+@dataclass
+class DuplexPlaybackCursor:
+    generated_ms: int = 0
+    sent_ms: int = 0
+    played_ms: int = 0
+    committed_ms: int = 0
+
+    def acknowledge(self, played_ms: int, committed_ms: int | None = None) -> None:
+        self.played_ms = max(self.played_ms, max(0, int(played_ms)))
+        if committed_ms is None:
+            committed_ms = self.played_ms
+        self.committed_ms = max(self.committed_ms, max(0, int(committed_ms)))
+
+    def truncate_committed(self, committed_ms: int) -> None:
+        self.committed_ms = max(0, min(max(self.sent_ms, self.generated_ms), int(committed_ms)))
+
+    def as_dict(self) -> dict[str, int]:
+        return {
+            "generated_ms": self.generated_ms,
+            "sent_ms": self.sent_ms,
+            "played_ms": self.played_ms,
+            "committed_ms": self.committed_ms,
+        }
+
+    def snapshot(self) -> DuplexPlaybackView:
+        return DuplexPlaybackView(**self.as_dict())
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexPlaybackView:
+    generated_ms: int = 0
+    sent_ms: int = 0
+    played_ms: int = 0
+    committed_ms: int = 0
+
+    def as_dict(self) -> dict[str, int]:
+        return {
+            "generated_ms": self.generated_ms,
+            "sent_ms": self.sent_ms,
+            "played_ms": self.played_ms,
+            "committed_ms": self.committed_ms,
+        }
+
+
+@dataclass
+class DuplexAudioChunk:
+    data: str
+    format: str = "wav"
+    sample_rate_hz: int | None = None
+
+
+@dataclass
+class DuplexSessionConfig:
+    model: str | None = None
+    modalities: list[str] = field(default_factory=lambda: ["text", "audio"])
+    instructions: str | None = None
+    voice: str | None = None
+    ref_audio: str | None = None
+    response_format: str = "wav"
+    temperature: float | None = None
+    max_tokens: int | None = None
+    speed: float | None = None
+    use_tts_template: bool = True
+    idle_timeout_s: float = 300.0
+    overlap_policy: str = DuplexOverlapPolicy.LISTEN_ONLY.value
+    overlap_short_ack_ms: int = 700
+    overlap_barge_in_ms: int = 1200
+    overlap_silence_rms: float = 0.003
+    playback_commit_policy: str = DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
+    extra_body: dict[str, object] = field(default_factory=dict)
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "model": self.model,
+            "modalities": list(self.modalities),
+            "instructions": self.instructions,
+            "voice": self.voice,
+            "ref_audio": self.ref_audio,
+            "response_format": self.response_format,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "speed": self.speed,
+            "use_tts_template": self.use_tts_template,
+            "idle_timeout_s": self.idle_timeout_s,
+            "overlap_policy": self.overlap_policy,
+            "overlap_short_ack_ms": self.overlap_short_ack_ms,
+            "overlap_barge_in_ms": self.overlap_barge_in_ms,
+            "overlap_silence_rms": self.overlap_silence_rms,
+            "playback_commit_policy": self.playback_commit_policy,
+            "extra_body": dict(self.extra_body),
+        }
+
+    @classmethod
+    def from_event(cls, event: dict[str, object]) -> DuplexSessionConfig:
+        payload = event.get("session")
+        if isinstance(payload, dict):
+            source = payload
+        else:
+            source = event
+
+        config = cls()
+        if isinstance(source.get("model"), str):
+            config.model = source["model"]
+        if isinstance(source.get("instructions"), str):
+            config.instructions = source["instructions"]
+        if isinstance(source.get("voice"), str):
+            config.voice = source["voice"]
+        if isinstance(source.get("ref_audio"), str):
+            config.ref_audio = source["ref_audio"]
+        if isinstance(source.get("response_format"), str):
+            config.response_format = source["response_format"]
+        if isinstance(source.get("use_tts_template"), bool):
+            config.use_tts_template = bool(source["use_tts_template"])
+        if isinstance(source.get("temperature"), int | float):
+            config.temperature = float(source["temperature"])
+        if isinstance(source.get("max_tokens"), int):
+            config.max_tokens = int(source["max_tokens"])
+        if isinstance(source.get("speed"), int | float):
+            config.speed = float(source["speed"])
+        if isinstance(source.get("idle_timeout_s"), int | float):
+            config.idle_timeout_s = float(source["idle_timeout_s"])
+        if isinstance(source.get("overlap_policy"), str):
+            config.overlap_policy = cls._normalize_overlap_policy(source["overlap_policy"])
+        if isinstance(source.get("overlap_short_ack_ms"), int | float):
+            config.overlap_short_ack_ms = max(0, int(source["overlap_short_ack_ms"]))
+        if isinstance(source.get("overlap_barge_in_ms"), int | float):
+            config.overlap_barge_in_ms = max(0, int(source["overlap_barge_in_ms"]))
+        if isinstance(source.get("overlap_silence_rms"), int | float):
+            config.overlap_silence_rms = max(0.0, float(source["overlap_silence_rms"]))
+        if isinstance(source.get("playback_commit_policy"), str):
+            config.playback_commit_policy = cls._normalize_playback_commit_policy(source["playback_commit_policy"])
+        if isinstance(source.get("modalities"), list) and all(isinstance(x, str) for x in source["modalities"]):
+            config.modalities = list(source["modalities"])
+        if isinstance(source.get("extra_body"), dict):
+            config.extra_body = dict(source["extra_body"])
+            extra = config.extra_body
+            if isinstance(extra.get("overlap_policy"), str):
+                config.overlap_policy = cls._normalize_overlap_policy(extra["overlap_policy"])
+            if isinstance(extra.get("overlap_short_ack_ms"), int | float):
+                config.overlap_short_ack_ms = max(0, int(extra["overlap_short_ack_ms"]))
+            if isinstance(extra.get("overlap_barge_in_ms"), int | float):
+                config.overlap_barge_in_ms = max(0, int(extra["overlap_barge_in_ms"]))
+            if isinstance(extra.get("overlap_silence_rms"), int | float):
+                config.overlap_silence_rms = max(0.0, float(extra["overlap_silence_rms"]))
+            if isinstance(extra.get("playback_commit_policy"), str):
+                config.playback_commit_policy = cls._normalize_playback_commit_policy(extra["playback_commit_policy"])
+        return config
+
+    @staticmethod
+    def _normalize_overlap_policy(value: str) -> str:
+        normalized = value.strip().lower()
+        if normalized in {policy.value for policy in DuplexOverlapPolicy}:
+            return normalized
+        return DuplexOverlapPolicy.LISTEN_ONLY.value
+
+    @staticmethod
+    def _normalize_playback_commit_policy(value: str) -> str:
+        normalized = value.strip().lower()
+        if normalized in {policy.value for policy in DuplexPlaybackCommitPolicy}:
+            return normalized
+        return DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
+
+
+@dataclass(frozen=True)
+class ResponseCreateOptions:
+    instructions: str | None = None
+    voice: str | None = None
+    response_format: str | None = None
+    temperature: float | None = None
+    max_tokens: int | None = None
+    speed: float | None = None
+    modalities: tuple[str, ...] | None = None
+    extra_body: Mapping[str, object] = field(default_factory=dict)
+
+    def apply_to(self, config: DuplexSessionConfig) -> None:
+        for field_name in ("instructions", "voice", "response_format", "temperature", "max_tokens", "speed"):
+            value = getattr(self, field_name)
+            if value is not None:
+                setattr(config, field_name, value)
+        if self.modalities is not None:
+            config.modalities = list(self.modalities)
+        config.extra_body.update(self.extra_body)
+
+
+@dataclass
+class DuplexCommittedInput:
+    message: dict[str, object]
+    turn_id: int
+    epoch: int
+    input_commit_seq: int
+
+
+@dataclass
+class DuplexAssistantAudioTextMark:
+    text_chars: int
+    audio_end_ms: int
+
+
+@dataclass
+class InputBufferState:
+    commit_seq: int = 0
+    pending_text: list[str] = field(default_factory=list)
+    pending_audio: list[DuplexAudioChunk] = field(default_factory=list)
+    overlap_speech_ms: int = 0
+    reserved_input_bytes: int = 0
+    pending_turns: int = 0
+
+
+@dataclass
+class ResponseState:
+    active_request_id: str | None = None
+    active_response_id: str | None = None
+    active_response_turn_id: int | None = None
+    last_response_id: str | None = None
+    assistant_text_buffer: list[str] = field(default_factory=list)
+    assistant_audio_text_marks: list[DuplexAssistantAudioTextMark] = field(default_factory=list)
+    pending_options: ResponseCreateOptions | None = None
+    active_options: ResponseCreateOptions | None = None
+    active_config: DuplexSessionConfig | None = None
+    stage_metrics: dict[str, dict[str, object]] = field(default_factory=dict)
+    stage_metric_tpot_weighted_ms: dict[str, float] = field(default_factory=dict)
+    stage_metric_tpot_weight: dict[str, int] = field(default_factory=dict)
+
+
+@dataclass
+class PlaybackLedger:
+    current: DuplexPlaybackCursor = field(default_factory=DuplexPlaybackCursor)
+    by_response: dict[str, DuplexPlaybackCursor] = field(default_factory=dict)
+
+
+@dataclass
+class ConversationHistory:
+    messages: list[dict[str, object]] = field(default_factory=list)
+    item_ids: dict[str, dict[str, object]] = field(default_factory=dict)
+    item_audio_text_marks: dict[str, list[DuplexAssistantAudioTextMark]] = field(default_factory=dict)
+    pending_item_ids: dict[str, dict[str, object]] = field(default_factory=dict)
+    pending_item_audio_text_marks: dict[str, list[DuplexAssistantAudioTextMark]] = field(default_factory=dict)
+    pending_truncations_ms: dict[str, int] = field(default_factory=dict)
+    last_assistant_full_message: dict[str, object] | None = None
+    last_assistant_audio_text_marks: list[DuplexAssistantAudioTextMark] = field(default_factory=list)
+
+
+@dataclass
+class DuplexSession:
+    session_id: str
+    config: DuplexSessionConfig
+    capabilities: DuplexCapabilities = field(default_factory=DuplexCapabilities)
+    incarnation: int = 0
+    state: DuplexSessionState = DuplexSessionState.OPEN
+    turn_state: DuplexTurnState = DuplexTurnState.IDLE
+    epoch: int = 0
+    turn_id: int = 0
+    _input: InputBufferState = field(default_factory=InputBufferState, repr=False)
+    _response: ResponseState = field(default_factory=ResponseState, repr=False)
+    _playback: PlaybackLedger = field(default_factory=PlaybackLedger, repr=False)
+    _conversation: ConversationHistory = field(default_factory=ConversationHistory, repr=False)
+    _runtime_config: dict[str, object] = field(default_factory=dict, repr=False)
+
+    @property
+    def response_config(self) -> DuplexSessionConfig:
+        """Return the immutable-for-this-lifecycle response configuration.
+
+        ``config`` remains the session defaults.  A response takes a deep
+        snapshot when it begins so response.create overrides and concurrent
+        session updates cannot mutate each other's ownership domains.
+        """
+        return self._response.active_config or self.config
+
+    @property
+    def runtime_config(self) -> Mapping[str, object]:
+        return MappingProxyType(dict(self._runtime_config))
+
+    def replace_runtime_config(self, runtime_config: Mapping[str, object]) -> None:
+        self._runtime_config = dict(runtime_config)
+
+    @property
+    def input_commit_seq(self) -> int:
+        return self._input.commit_seq
+
+    @property
+    def pending_text(self) -> tuple[str, ...]:
+        return tuple(self._input.pending_text)
+
+    @property
+    def pending_audio(self) -> tuple[DuplexAudioChunk, ...]:
+        return tuple(self._input.pending_audio)
+
+    @property
+    def history(self) -> tuple[dict[str, object], ...]:
+        return tuple(dict(message) for message in self._conversation.messages)
+
+    @property
+    def active_request_id(self) -> str | None:
+        return self._response.active_request_id
+
+    @property
+    def active_response_id(self) -> str | None:
+        return self._response.active_response_id
+
+    @property
+    def active_response_turn_id(self) -> int | None:
+        return self._response.active_response_turn_id
+
+    @property
+    def last_response_id(self) -> str | None:
+        return self._response.last_response_id
+
+    @property
+    def overlap_speech_ms(self) -> int:
+        return self._input.overlap_speech_ms
+
+    @property
+    def assistant_text_buffer(self) -> tuple[str, ...]:
+        return tuple(self._response.assistant_text_buffer)
+
+    @property
+    def assistant_audio_text_marks(self) -> tuple[DuplexAssistantAudioTextMark, ...]:
+        return tuple(self._response.assistant_audio_text_marks)
+
+    @property
+    def last_assistant_full_message(self) -> dict[str, object] | None:
+        message = self._conversation.last_assistant_full_message
+        return dict(message) if message is not None else None
+
+    @property
+    def last_assistant_audio_text_marks(self) -> tuple[DuplexAssistantAudioTextMark, ...]:
+        return tuple(self._conversation.last_assistant_audio_text_marks)
+
+    @property
+    def playback(self) -> DuplexPlaybackView:
+        return self._playback.current.snapshot()
+
+    @property
+    def response_playbacks(self) -> Mapping[str, DuplexPlaybackView]:
+        return MappingProxyType({key: value.snapshot() for key, value in self._playback.by_response.items()})
+
+    @property
+    def history_item_ids(self) -> Mapping[str, dict[str, object]]:
+        return MappingProxyType({key: dict(value) for key, value in self._conversation.item_ids.items()})
+
+    @property
+    def pending_history_item_ids(self) -> Mapping[str, dict[str, object]]:
+        return MappingProxyType({key: dict(value) for key, value in self._conversation.pending_item_ids.items()})
+
+    @property
+    def pending_history_truncations_ms(self) -> Mapping[str, int]:
+        return MappingProxyType(dict(self._conversation.pending_truncations_ms))
+
+    def replace_config(self, config: DuplexSessionConfig) -> None:
+        self.config = config
+
+    def replace_capabilities(self, capabilities: DuplexCapabilities) -> None:
+        self.capabilities = capabilities
+
+    def transition_turn(self, state: DuplexTurnState) -> None:
+        self.turn_state = state
+
+    def transition_session(self, state: DuplexSessionState) -> None:
+        self.state = state
+
+    def bind_request(self, request_id: str | None) -> None:
+        self._response.active_request_id = request_id
+
+    def clear_request(self, expected_request_id: str | None = None) -> bool:
+        if expected_request_id is not None and self._response.active_request_id != expected_request_id:
+            return False
+        self._response.active_request_id = None
+        return True
+
+    def bind_response_turn(self, turn_id: int | None) -> None:
+        self._response.active_response_turn_id = turn_id
+
+    def active_response_accepts_model_turn(self, turn_id: int | None) -> bool:
+        if self._response.active_response_id is None:
+            return False
+        if turn_id is None:
+            return True
+        active_turn_id = self._response.active_response_turn_id
+        return active_turn_id is None or int(turn_id) == active_turn_id
+
+    def append_history_message(self, message: dict[str, object]) -> None:
+        self._conversation.messages.append(message)
+
+    def stage_pending_history_item(self, item_id: str, message: dict[str, object]) -> None:
+        self._conversation.pending_item_ids[item_id] = dict(message)
+
+    def append_text(self, text: str) -> None:
+        if not text:
+            return
+        self._input.pending_text.append(text)
+        self.turn_state = DuplexTurnState.USER_SPEAKING
+
+    @property
+    def pending_input_bytes(self) -> int:
+        return self._input.reserved_input_bytes
+
+    @property
+    def pending_input_turns(self) -> int:
+        return self._input.pending_turns
+
+    def reserve_input_bytes(self, size: int, *, limit: int) -> bool:
+        size = max(0, int(size))
+        if self._input.reserved_input_bytes + size > int(limit):
+            return False
+        self._input.reserved_input_bytes += size
+        return True
+
+    def release_input_bytes(self, size: int) -> None:
+        self._input.reserved_input_bytes = max(0, self._input.reserved_input_bytes - max(0, int(size)))
+
+    def release_all_input_bytes(self) -> None:
+        self._input.reserved_input_bytes = 0
+
+    def reserve_pending_turn(self, *, limit: int) -> bool:
+        if self._input.pending_turns >= int(limit):
+            return False
+        self._input.pending_turns += 1
+        return True
+
+    def release_pending_turn(self) -> None:
+        self._input.pending_turns = max(0, self._input.pending_turns - 1)
+
+    def clear_pending_turn_reservations(self) -> None:
+        self._input.pending_turns = 0
+
+    def append_audio(self, data: str, *, fmt: str = "wav", sample_rate_hz: int | None = None) -> None:
+        if not data:
+            return
+        self._input.pending_audio.append(DuplexAudioChunk(data=data, format=fmt, sample_rate_hz=sample_rate_hz))
+        self.turn_state = DuplexTurnState.USER_SPEAKING
+
+    def mark_user_input_activity(self) -> None:
+        self.turn_state = DuplexTurnState.USER_SPEAKING
+
+    def mark_assistant_generating(self) -> None:
+        self.turn_state = DuplexTurnState.ASSISTANT_GENERATING
+
+    def cancel_pending_input(self) -> dict[str, int]:
+        cancelled = {
+            "text_chunks": len(self._input.pending_text),
+            "audio_chunks": len(self._input.pending_audio),
+        }
+        self._input.pending_text.clear()
+        self._input.pending_audio.clear()
+        self._input.reserved_input_bytes = 0
+        self._input.pending_turns = 0
+        self.turn_state = DuplexTurnState.IDLE
+        return cancelled
+
+    def commit_user_input(self) -> DuplexCommittedInput | None:
+        text = "".join(self._input.pending_text).strip()
+        audio_chunks = list(self._input.pending_audio)
+        if not text and not audio_chunks:
+            return None
+
+        content: str | list[dict[str, object]]
+        if audio_chunks:
+            content_items: list[dict[str, object]] = []
+            if text:
+                content_items.append({"type": "text", "text": text})
+            for chunk in audio_chunks:
+                content_items.append(
+                    {
+                        "type": "audio_url",
+                        "audio_url": {
+                            "url": f"data:audio/{chunk.format};base64,{chunk.data}",
+                        },
+                    }
+                )
+            content = content_items
+        else:
+            content = text
+
+        self._input.commit_seq += 1
+        message = {"role": "user", "content": content}
+        self._conversation.messages.append(message)
+        self._input.pending_text.clear()
+        self._input.pending_audio.clear()
+        self._input.reserved_input_bytes = 0
+        self.turn_state = DuplexTurnState.USER_COMMITTED
+        return DuplexCommittedInput(
+            message=message,
+            turn_id=self.turn_id,
+            epoch=self.epoch,
+            input_commit_seq=self._input.commit_seq,
+        )
+
+    def commit_native_audio_input(
+        self,
+        *,
+        transcript: str | None = None,
+        turn_id: int | None = None,
+    ) -> DuplexCommittedInput:
+        input_audio_part: dict[str, object] = {
+            "type": "audio_url",
+            "audio_url": {"url": "native-duplex:input-audio"},
+        }
+        if transcript:
+            input_audio_part["transcript"] = transcript
+        self._input.commit_seq += 1
+        message = {"role": "user", "content": [input_audio_part]}
+        if transcript:
+            message["transcript"] = transcript
+        self._conversation.messages.append(message)
+        self._input.pending_text.clear()
+        self._input.pending_audio.clear()
+        self.turn_state = DuplexTurnState.USER_COMMITTED
+        return DuplexCommittedInput(
+            message=message,
+            turn_id=self.turn_id if turn_id is None else int(turn_id),
+            epoch=self.epoch,
+            input_commit_seq=self._input.commit_seq,
+        )
+
+    def complete_model_turn(self, turn_id: int) -> None:
+        """Advance the model-owned output identity after its terminal signal."""
+        completed_turn_id = int(turn_id)
+        if completed_turn_id >= self.turn_id:
+            self.turn_id = completed_turn_id + 1
+
+    def reserve_response_options(self, options: ResponseCreateOptions) -> None:
+        if self._response.active_response_id is not None:
+            raise RuntimeError("response options cannot be reserved while a response is active")
+        if self._response.pending_options is not None:
+            raise RuntimeError("response options are already reserved")
+        self._response.pending_options = options
+
+    def discard_response_options(self) -> None:
+        self._response.pending_options = None
+
+    def _activate_response_options(self) -> None:
+        options = self._response.pending_options
+        self._response.active_config = copy.deepcopy(self.config)
+        self._response.active_options = options
+        self._response.pending_options = None
+        if options is not None:
+            options.apply_to(self._response.active_config)
+
+    def _restore_response_config(self) -> None:
+        self._response.active_config = None
+        self._response.active_options = None
+        self._response.pending_options = None
+
+    def begin_response(self, *, turn_id: int | None = None) -> str:
+        self._activate_response_options()
+        response_id = f"resp-{self.session_id}-{self.epoch}-{uuid4().hex[:8]}"
+        self._response.active_response_id = response_id
+        self._response.active_response_turn_id = self.turn_id if turn_id is None else int(turn_id)
+        self._response.last_response_id = response_id
+        self._response.assistant_text_buffer.clear()
+        self._response.assistant_audio_text_marks.clear()
+        self._clear_response_metrics()
+        self._conversation.last_assistant_full_message = None
+        self._conversation.last_assistant_audio_text_marks.clear()
+        self._playback.current = DuplexPlaybackCursor()
+        self._playback.by_response[response_id] = self._playback.current
+        self.turn_state = DuplexTurnState.ASSISTANT_GENERATING
+        return response_id
+
+    def _clear_response_metrics(self) -> None:
+        self._response.stage_metrics.clear()
+        self._response.stage_metric_tpot_weighted_ms.clear()
+        self._response.stage_metric_tpot_weight.clear()
+
+    def accumulate_response_stage_metrics(
+        self,
+        stage_metrics: Mapping[object, object] | None,
+    ) -> dict[str, dict[str, object]]:
+        if self.active_response_id is None or not isinstance(stage_metrics, Mapping):
+            return copy.deepcopy(self._response.stage_metrics)
+
+        additive_fields = (
+            "num_tokens_in",
+            "num_tokens_out",
+            "stage_gen_time_ms",
+            "postprocess_time_ms",
+            "audio_generated_frames",
+            "audio_duration_s",
+            "image_pixels",
+            "output_unit_count",
+        )
+        first_positive_fields = (
+            "serving_time_to_first_output_ms",
+            "vllm_ttft_ms",
+        )
+        interval_fields = (
+            ("inter_output_latencies_ms", "inter_output_latency_ms"),
+            ("vllm_itls_ms", "vllm_itl_ms"),
+        )
+        handled_fields = {
+            *additive_fields,
+            *first_positive_fields,
+            "vllm_tpot_ms",
+            *(name for pair in interval_fields for name in pair),
+        }
+
+        for raw_stage_id, raw_values in stage_metrics.items():
+            if not isinstance(raw_values, Mapping):
+                continue
+            stage_id = str(raw_stage_id)
+            current = self._response.stage_metrics.setdefault(stage_id, {})
+            for name in additive_fields:
+                value = raw_values.get(name)
+                if isinstance(value, int | float) and not isinstance(value, bool):
+                    current[name] = current.get(name, 0) + value
+            for name in first_positive_fields:
+                value = raw_values.get(name)
+                current_value = current.get(name)
+                if (
+                    isinstance(value, int | float)
+                    and not isinstance(value, bool)
+                    and value > 0
+                    and not (isinstance(current_value, int | float) and current_value > 0)
+                ):
+                    current[name] = value
+            for list_name, mean_name in interval_fields:
+                values = raw_values.get(list_name)
+                if isinstance(values, list):
+                    combined = list(current.get(list_name, []))
+                    combined.extend(
+                        value for value in values if isinstance(value, int | float) and not isinstance(value, bool)
+                    )
+                    current[list_name] = combined
+                    current[mean_name] = sum(combined) / len(combined) if combined else 0.0
+
+            tpot_ms = raw_values.get("vllm_tpot_ms")
+            token_count = raw_values.get("num_tokens_out")
+            if isinstance(tpot_ms, int | float) and tpot_ms > 0:
+                weight = max(int(token_count) - 1, 1) if isinstance(token_count, int | float) else 1
+                self._response.stage_metric_tpot_weighted_ms[stage_id] = (
+                    self._response.stage_metric_tpot_weighted_ms.get(stage_id, 0.0) + float(tpot_ms) * weight
+                )
+                self._response.stage_metric_tpot_weight[stage_id] = (
+                    self._response.stage_metric_tpot_weight.get(stage_id, 0) + weight
+                )
+                current["vllm_tpot_ms"] = self._response.stage_metric_tpot_weighted_ms[stage_id] / float(
+                    self._response.stage_metric_tpot_weight[stage_id]
+                )
+
+            for name, value in raw_values.items():
+                if name not in handled_fields:
+                    current[str(name)] = copy.deepcopy(value)
+
+        return copy.deepcopy(self._response.stage_metrics)
+
+    def accumulate_overlap_speech(self, duration_ms: int) -> int:
+        self._input.overlap_speech_ms += max(0, int(duration_ms))
+        return self._input.overlap_speech_ms
+
+    def reset_overlap_speech(self) -> int:
+        previous = self._input.overlap_speech_ms
+        self._input.overlap_speech_ms = 0
+        return previous
+
+    def append_assistant_text(self, text: str) -> None:
+        if text:
+            self._response.assistant_text_buffer.append(text)
+
+    def mark_audio_sent(
+        self,
+        duration_ms: int | None = None,
+        *,
+        text_chars: int | None = None,
+        audio_text_marks: list[dict[str, object]] | None = None,
+    ) -> None:
+        playback = self._playback.current
+        if duration_ms is not None:
+            playback.generated_ms = max(playback.generated_ms, duration_ms)
+            playback.sent_ms = max(playback.sent_ms, duration_ms)
+            if text_chars is not None and text_chars >= 0:
+                self._response.assistant_audio_text_marks.append(
+                    DuplexAssistantAudioTextMark(
+                        text_chars=int(text_chars),
+                        audio_end_ms=max(0, int(duration_ms)),
+                    )
+                )
+        if audio_text_marks:
+            for raw_mark in audio_text_marks:
+                if not isinstance(raw_mark, dict):
+                    continue
+                raw_text_chars = raw_mark.get("text_chars")
+                raw_audio_end_ms = raw_mark.get("audio_end_ms", raw_mark.get("audio_ms"))
+                if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
+                    continue
+                self._response.assistant_audio_text_marks.append(
+                    DuplexAssistantAudioTextMark(
+                        text_chars=max(0, int(raw_text_chars)),
+                        audio_end_ms=max(0, int(raw_audio_end_ms)),
+                    )
+                )
+        self.turn_state = DuplexTurnState.ASSISTANT_PLAYING
+
+    def _playback_cursor_for_response(self, response_id: str | None = None) -> DuplexPlaybackCursor:
+        if response_id is None:
+            return self._playback.current
+        playback = self._playback.by_response.get(response_id)
+        if playback is None:
+            # A restored or legacy session may not have response-scoped state.
+            # Keep its acknowledgement isolated from the active response.
+            playback = DuplexPlaybackCursor()
+            self._playback.by_response[response_id] = playback
+        return playback
+
+    def playback_for_response(self, response_id: str | None = None) -> DuplexPlaybackView:
+        return self._playback_cursor_for_response(response_id).snapshot()
+
+    def acknowledge_playback(
+        self,
+        played_ms: int,
+        committed_ms: int | None = None,
+        *,
+        response_id: str | None = None,
+    ) -> DuplexPlaybackView:
+        playback = self._playback_cursor_for_response(response_id)
+        playback.acknowledge(played_ms, committed_ms)
+        return playback.snapshot()
+
+    def truncate_playback_commit(
+        self,
+        committed_ms: int,
+        *,
+        response_id: str | None = None,
+    ) -> DuplexPlaybackView:
+        playback = self._playback_cursor_for_response(response_id)
+        playback.truncate_committed(committed_ms)
+        return playback.snapshot()
+
+    def release_response_playback(self, response_id: str | None) -> None:
+        if response_id is None or response_id == self.active_response_id:
+            return
+        self._playback.by_response.pop(response_id, None)
+
+    def clear_playback_cursor(self) -> None:
+        self._playback.current = DuplexPlaybackCursor()
+        if self.active_response_id is not None:
+            self._playback.by_response[self.active_response_id] = self._playback.current
+
+    def end_response(
+        self,
+        *,
+        commit_text: bool = True,
+        playback_commit_policy: str | None = None,
+        preserve_request: bool = False,
+    ) -> dict[str, object] | None:
+        assistant_text = "".join(self._response.assistant_text_buffer).strip()
+        message = None
+        if assistant_text:
+            self._conversation.last_assistant_full_message = {"role": "assistant", "content": assistant_text}
+            self._conversation.last_assistant_audio_text_marks = list(self._response.assistant_audio_text_marks)
+        if commit_text and assistant_text:
+            committed_text = self._playback_committed_text(
+                assistant_text,
+                playback_commit_policy=playback_commit_policy,
+            )
+        else:
+            committed_text = ""
+        if commit_text and committed_text:
+            message = {"role": "assistant", "content": committed_text}
+            self._conversation.messages.append(message)
+        self._response.assistant_text_buffer.clear()
+        if not preserve_request:
+            self._response.active_request_id = None
+        self._response.active_response_id = None
+        self._response.active_response_turn_id = None
+        self._clear_response_metrics()
+        self.turn_state = DuplexTurnState.IDLE
+        self._restore_response_config()
+        return message
+
+    def register_history_item(self, item_id: str | None, message: dict[str, object] | None) -> None:
+        if not item_id:
+            return
+        if message is None:
+            last_message = self._conversation.last_assistant_full_message
+            if last_message is None:
+                return
+            self._conversation.pending_item_ids[item_id] = dict(last_message)
+            if self._conversation.last_assistant_audio_text_marks:
+                self._conversation.pending_item_audio_text_marks[item_id] = list(
+                    self._conversation.last_assistant_audio_text_marks
+                )
+            pending_audio_ms = self._conversation.pending_truncations_ms.pop(item_id, None)
+            if pending_audio_ms is not None:
+                self.truncate_history_item(
+                    item_id,
+                    audio_end_ms=pending_audio_ms,
+                    playback=self._playback_cursor_for_item_id(item_id),
+                )
+            return
+        pending_audio_ms = self._conversation.pending_truncations_ms.pop(item_id, None)
+        if pending_audio_ms is not None:
+            self._truncate_message_to_audio_ms(
+                message,
+                audio_end_ms=pending_audio_ms,
+                marks=self._response.assistant_audio_text_marks or self._conversation.last_assistant_audio_text_marks,
+                playback=self._playback_cursor_for_item_id(item_id),
+            )
+            if self._message_text_len(message) <= 0:
+                try:
+                    self._conversation.messages.remove(message)
+                except ValueError:
+                    pass
+                return
+        self._conversation.item_ids[item_id] = message
+        self._conversation.pending_item_ids.pop(item_id, None)
+        self._conversation.pending_item_audio_text_marks.pop(item_id, None)
+        if message.get("role") == "assistant":
+            marks = self._response.assistant_audio_text_marks or self._conversation.last_assistant_audio_text_marks
+            if marks:
+                self._conversation.item_audio_text_marks[item_id] = list(marks)
+
+    def delete_history_item(self, item_id: str) -> bool:
+        message = self._conversation.item_ids.pop(item_id, None)
+        self._conversation.item_audio_text_marks.pop(item_id, None)
+        pending = self._conversation.pending_item_ids.pop(item_id, None)
+        self._conversation.pending_item_audio_text_marks.pop(item_id, None)
+        self._conversation.pending_truncations_ms.pop(item_id, None)
+        if message is None:
+            return pending is not None
+        try:
+            self._conversation.messages.remove(message)
+        except ValueError:
+            pass
+        return True
+
+    def truncate_history_item(
+        self,
+        item_id: str,
+        *,
+        audio_end_ms: int,
+        playback: DuplexPlaybackCursor | DuplexPlaybackView | None = None,
+    ) -> bool:
+        playback = playback or self._playback_cursor_for_item_id(item_id)
+        message = self._conversation.item_ids.get(item_id)
+        if message is None:
+            pending = self._conversation.pending_item_ids.get(item_id)
+            if pending is None:
+                self._conversation.pending_truncations_ms[item_id] = max(0, int(audio_end_ms))
+                return False
+            message = dict(pending)
+            changed = self._truncate_message_to_audio_ms(
+                message,
+                audio_end_ms=audio_end_ms,
+                marks=self._conversation.pending_item_audio_text_marks.get(item_id),
+                playback=playback,
+            )
+            if not changed or self._message_text_len(message) <= 0:
+                if changed:
+                    self._conversation.pending_item_ids.pop(item_id, None)
+                    self._conversation.pending_item_audio_text_marks.pop(item_id, None)
+                    self._conversation.pending_truncations_ms.pop(item_id, None)
+                return changed
+            self._conversation.messages.append(message)
+            self._conversation.item_ids[item_id] = message
+            if item_id in self._conversation.pending_item_audio_text_marks:
+                self._conversation.item_audio_text_marks[item_id] = list(
+                    self._conversation.pending_item_audio_text_marks[item_id]
+                )
+            self._conversation.pending_item_ids.pop(item_id, None)
+            self._conversation.pending_item_audio_text_marks.pop(item_id, None)
+            self._conversation.pending_truncations_ms.pop(item_id, None)
+            return True
+        changed = self._truncate_message_to_audio_ms(
+            message,
+            audio_end_ms=audio_end_ms,
+            marks=self._conversation.item_audio_text_marks.get(item_id),
+            playback=playback,
+        )
+        if changed and self._message_text_len(message) <= 0:
+            self._conversation.item_ids.pop(item_id, None)
+            self._conversation.item_audio_text_marks.pop(item_id, None)
+            try:
+                self._conversation.messages.remove(message)
+            except ValueError:
+                pass
+        return changed
+
+    def _truncate_message_to_audio_ms(
+        self,
+        message: dict[str, object],
+        *,
+        audio_end_ms: int,
+        marks: list[DuplexAssistantAudioTextMark] | None = None,
+        playback: DuplexPlaybackCursor | DuplexPlaybackView | None = None,
+    ) -> bool:
+        content = message.get("content")
+        if isinstance(content, str):
+            keep_chars = self._text_chars_for_audio_ms(
+                audio_end_ms,
+                len(content),
+                marks=marks,
+                playback=playback,
+            )
+            message["content"] = content[:keep_chars].rstrip()
+            return True
+        if not isinstance(content, list):
+            return False
+        changed = False
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            part_type = part.get("type")
+            if part_type in {"output_audio", "audio", "audio_transcript"}:
+                transcript = part.get("transcript")
+                if isinstance(transcript, str):
+                    keep_chars = self._text_chars_for_audio_ms(
+                        audio_end_ms,
+                        len(transcript),
+                        marks=marks,
+                        playback=playback,
+                    )
+                    part["transcript"] = transcript[:keep_chars].rstrip()
+                    changed = True
+            if part_type in {"output_text", "text"}:
+                text = part.get("text")
+                if isinstance(text, str):
+                    keep_chars = self._text_chars_for_audio_ms(
+                        audio_end_ms,
+                        len(text),
+                        marks=marks,
+                        playback=playback,
+                    )
+                    part["text"] = text[:keep_chars].rstrip()
+                    changed = True
+        if not changed:
+            return False
+        return True
+
+    @staticmethod
+    def _message_text_len(message: dict[str, object]) -> int:
+        content = message.get("content")
+        if isinstance(content, str):
+            return len(content)
+        if not isinstance(content, list):
+            return 0
+        total = 0
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            for key in ("text", "transcript"):
+                value = part.get(key)
+                if isinstance(value, str):
+                    total += len(value)
+        return total
+
+    def _playback_committed_text(
+        self,
+        assistant_text: str,
+        *,
+        playback_commit_policy: str | None = None,
+    ) -> str:
+        sent_ms = max(self.playback.sent_ms, self.playback.generated_ms)
+        committed_ms = self.playback.committed_ms
+        policy = playback_commit_policy or self.config.playback_commit_policy
+        if sent_ms <= 0 or committed_ms >= sent_ms:
+            return assistant_text
+        if committed_ms <= 0:
+            if policy == DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value:
+                return assistant_text
+            return ""
+        keep_chars = self._text_chars_for_audio_ms(committed_ms, len(assistant_text))
+        if keep_chars <= 0:
+            return ""
+        return assistant_text[:keep_chars].rstrip()
+
+    def _text_chars_for_audio_ms(
+        self,
+        audio_end_ms: int,
+        text_len: int,
+        *,
+        marks: list[DuplexAssistantAudioTextMark] | None = None,
+        playback: DuplexPlaybackCursor | DuplexPlaybackView | None = None,
+    ) -> int:
+        if text_len <= 0:
+            return 0
+        audio_end_ms = max(0, int(audio_end_ms))
+        marks = marks if marks is not None else self._response.assistant_audio_text_marks
+        playback = playback or self._playback.current
+        if not marks:
+            sent_ms = max(1, playback.sent_ms, playback.generated_ms)
+            return int(text_len * max(0.0, min(1.0, audio_end_ms / sent_ms)))
+        marks = sorted(
+            (mark for mark in marks if mark.audio_end_ms >= 0 and mark.text_chars >= 0),
+            key=lambda mark: mark.audio_end_ms,
+        )
+        if not marks:
+            return 0
+        if audio_end_ms <= 0:
+            return 0
+        previous_ms = 0
+        previous_chars = 0
+        for mark in marks:
+            mark_ms = max(previous_ms, mark.audio_end_ms)
+            mark_chars = min(text_len, max(previous_chars, mark.text_chars))
+            if audio_end_ms <= mark_ms:
+                if mark_ms <= previous_ms:
+                    return mark_chars
+                ratio = (audio_end_ms - previous_ms) / max(1, mark_ms - previous_ms)
+                return int(previous_chars + (mark_chars - previous_chars) * max(0.0, min(1.0, ratio)))
+            previous_ms = mark_ms
+            previous_chars = mark_chars
+        final_ms = max(playback.sent_ms, playback.generated_ms, previous_ms)
+        if audio_end_ms >= final_ms:
+            return text_len
+        ratio = (audio_end_ms - previous_ms) / max(1, final_ms - previous_ms)
+        return int(previous_chars + (text_len - previous_chars) * max(0.0, min(1.0, ratio)))
+
+    def _playback_cursor_for_item_id(self, item_id: str) -> DuplexPlaybackCursor | None:
+        if not item_id.startswith("item_"):
+            return None
+        return self._playback.by_response.get(item_id.removeprefix("item_"))
+
+    def barge_in(self) -> int:
+        self.epoch += 1
+        self._input.pending_text.clear()
+        self._input.pending_audio.clear()
+        self._response.assistant_text_buffer.clear()
+        self._response.assistant_audio_text_marks.clear()
+        self._response.active_request_id = None
+        self._response.active_response_id = None
+        self._response.active_response_turn_id = None
+        self._clear_response_metrics()
+        self._restore_response_config()
+        self.turn_state = DuplexTurnState.BARGE_IN
+        return self.epoch
+
+    def mark_closing(self) -> None:
+        if self.state != DuplexSessionState.CLOSED:
+            self.state = DuplexSessionState.CLOSING
+
+    def close(self) -> None:
+        self.state = DuplexSessionState.CLOSED
+        self.turn_state = DuplexTurnState.IDLE
+        self._response.active_response_turn_id = None
+        self._clear_response_metrics()
+        self._restore_response_config()
+
+    def as_public_dict(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "id": self.session_id,
+            "state": self.state.value,
+            "turn_state": self.turn_state.value,
+            "epoch": self.epoch,
+            "turn_id": self.turn_id,
+            "active_request_id": self.active_request_id,
+            "active_response_id": self.active_response_id,
+            "active_response_turn_id": self.active_response_turn_id,
+            "model": self.config.model,
+            "modalities": list(self.config.modalities),
+            "instructions": self.config.instructions,
+            "voice": self.config.voice,
+            "response_format": self.config.response_format,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "speed": self.config.speed,
+            "idle_timeout_s": self.config.idle_timeout_s,
+            "overlap_policy": self.config.overlap_policy,
+            "overlap_short_ack_ms": self.config.overlap_short_ack_ms,
+            "overlap_barge_in_ms": self.config.overlap_barge_in_ms,
+            "overlap_silence_rms": self.config.overlap_silence_rms,
+            "playback_commit_policy": self.config.playback_commit_policy,
+            "playback": self.playback.as_dict(),
+            "capabilities": self.capabilities.as_dict(),
+        }
+        if isinstance(self.config.extra_body.get("realtime_tools"), list):
+            payload["tools"] = self.config.extra_body["realtime_tools"]
+        if isinstance(self.config.extra_body.get("realtime_tool_choice"), str | dict):
+            payload["tool_choice"] = self.config.extra_body["realtime_tool_choice"]
+        if isinstance(self.config.extra_body.get("realtime_metadata"), dict):
+            payload["metadata"] = dict(self.config.extra_body["realtime_metadata"])
+        if isinstance(self.config.extra_body.get("realtime_include"), list):
+            payload["include"] = list(self.config.extra_body["realtime_include"])
+        if isinstance(self.config.extra_body.get("realtime_prompt"), dict):
+            payload["prompt"] = dict(self.config.extra_body["realtime_prompt"])
+        if isinstance(self.config.extra_body.get("realtime_input_audio_transcription"), dict):
+            payload["input_audio_transcription"] = dict(self.config.extra_body["realtime_input_audio_transcription"])
+        if isinstance(self.config.extra_body.get("realtime_input_audio_noise_reduction"), dict):
+            payload["input_audio_noise_reduction"] = dict(
+                self.config.extra_body["realtime_input_audio_noise_reduction"]
+            )
+        if isinstance(self.config.extra_body.get("realtime_audio"), dict):
+            payload["audio"] = dict(self.config.extra_body["realtime_audio"])
+        if isinstance(self.config.extra_body.get("realtime_tracing"), str | dict):
+            payload["tracing"] = self.config.extra_body["realtime_tracing"]
+        raw_realtime_session = self.config.extra_body.get("realtime_session_payload")
+        if isinstance(raw_realtime_session, dict):
+            for key, value in raw_realtime_session.items():
+                if key not in payload and key != "extra_body":
+                    payload[key] = value
+        return payload
+
+
+class DuplexTurnController:
+    """Interaction controller that accepts signals from multiple sources."""
+
+    def signal(
+        self,
+        session: DuplexSession,
+        event_type: str,
+        payload: dict[str, object] | None = None,
+    ) -> dict[str, object]:
+        payload = payload or {}
+        if event_type == DuplexTurnEventType.USER_STARTED.value:
+            session.transition_turn(DuplexTurnState.USER_SPEAKING)
+        elif event_type == DuplexTurnEventType.USER_COMMITTED.value:
+            session.transition_turn(DuplexTurnState.USER_COMMITTED)
+        elif event_type == DuplexTurnEventType.ASSISTANT_STARTED.value:
+            session.transition_turn(DuplexTurnState.ASSISTANT_GENERATING)
+        elif event_type == DuplexTurnEventType.ASSISTANT_DONE.value:
+            session.transition_turn(DuplexTurnState.IDLE)
+        elif event_type == DuplexTurnEventType.PLAYBACK_ACK.value:
+            played_ms = int(payload.get("played_ms", 0) or 0)
+            committed_ms = payload.get("committed_ms")
+            session.acknowledge_playback(
+                played_ms,
+                int(committed_ms) if isinstance(committed_ms, int | float) else None,
+            )
+        elif event_type == DuplexTurnEventType.BARGE_IN.value:
+            session.transition_turn(DuplexTurnState.BARGE_IN)
+        elif event_type in {DuplexTurnEventType.CLOSE.value, DuplexTurnEventType.TIMEOUT.value}:
+            session.transition_session(DuplexSessionState.CLOSING)
+        return {
+            "type": "turn.event",
+            "session_id": session.session_id,
+            "event": event_type,
+            "turn_state": session.turn_state.value,
+            "epoch": session.epoch,
+        }
+
+
+class DuplexSessionRegistry:
+    def __init__(self, capabilities: DuplexCapabilities | None = None) -> None:
+        self._capabilities = capabilities or DuplexCapabilities()
+        self._sessions: dict[str, DuplexSession] = {}
+        self._next_incarnation_by_session_id: dict[str, int] = {}
+
+    def create(self, config: DuplexSessionConfig | None = None, session_id: str | None = None) -> DuplexSession:
+        sid = session_id or f"duplex-{uuid4().hex}"
+        if sid in self._sessions:
+            raise ValueError(f"Duplex session already exists: {sid}")
+        incarnation = self._next_incarnation_by_session_id.get(sid, 0)
+        self._next_incarnation_by_session_id[sid] = incarnation + 1
+        session = DuplexSession(
+            session_id=sid,
+            config=config or DuplexSessionConfig(),
+            capabilities=self._capabilities,
+            incarnation=incarnation,
+        )
+        self._sessions[sid] = session
+        return session
+
+    def active_count(self) -> int:
+        return len(self._sessions)
+
+    def get(self, session_id: str) -> DuplexSession | None:
+        return self._sessions.get(session_id)
+
+    def close(self, session_id: str) -> DuplexSession | None:
+        session = self._sessions.pop(session_id, None)
+        if session is not None:
+            session.close()
+        return session
diff --git a/vllm_omni/experimental/fullduplex/openai/realtime_input.py b/vllm_omni/experimental/fullduplex/openai/realtime_input.py
new file mode 100644
index 000000000..e3fe7f3ec
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/realtime_input.py
@@ -0,0 +1,1233 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import binascii
+from typing import Any
+from uuid import uuid4
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.openai.audio import (
+    convert_input_audio_with_rate,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_state import (
+    REALTIME_INPUT_AUDIO_FORMATS,
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+)
+
+
+class RealtimeInputTranslator:
+    """Translate and validate client Realtime events for the duplex core."""
+
+    async def discard_pending_input_audio(
+        self,
+        *,
+        audio_end_ms: int | None = None,
+    ) -> None:
+        """Drop Realtime input-buffer state that was consumed as overlap.
+
+        The serving overlap policy may classify a short acknowledgement such
+        as "continue" as a side-channel signal instead of user turn input. The
+        Realtime protocol has already observed the append and may have emitted
+        ``speech_started``; reset that transient buffer so a later commit does
+        not accidentally attach the acknowledgement transcript/audio to the
+        next real user turn.
+        """
+        if self._input_speech_started and self._active_input_item_id is not None:
+            await self._send_realtime_payload(
+                {
+                    "type": "input_audio_buffer.speech_stopped",
+                    "audio_end_ms": max(0, int(audio_end_ms or 0)),
+                    "item_id": self._active_input_item_id,
+                }
+            )
+        self._input_speech_started = False
+        self._active_input_item_id = None
+        self._input_audio_buffer_has_audio = False
+        self._input_audio_buffer_had_non_speech = False
+        self._input_audio_buffer_transcript_parts.clear()
+
+    async def _send_realtime_input_ack(self, event: dict[str, object]) -> None:
+        if event.get("type") != "conversation.item.create":
+            return
+        item = event.get("item")
+        if not isinstance(item, dict):
+            return
+        item = self._normalize_conversation_item(item)
+        previous_item_id = event.get("previous_item_id")
+        if isinstance(previous_item_id, str):
+            item["_previous_item_id"] = previous_item_id
+        if item.get("role") != "user":
+            return
+        self._conversation_items[str(item["id"])] = item
+        for payload in self._conversation_item_added_events(item):
+            await self._send_realtime_payload(payload)
+
+    async def _to_duplex_event(self, event: dict[str, object]) -> dict[str, object] | None:
+        event_type = event.get("type")
+        if event_type == "session.update":
+            session_payload = event.get("session") if isinstance(event.get("session"), dict) else event
+            format_error = self._validate_realtime_session_audio_formats(session_payload)
+            if format_error is not None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "unsupported_audio_format",
+                        format_error,
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            turn_detection_error = self._validate_realtime_turn_detection(session_payload)
+            if turn_detection_error is not None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "unsupported_turn_detection",
+                        turn_detection_error,
+                        event_id=event.get("event_id"),
+                        param="turn_detection",
+                    )
+                )
+                return None
+            self._apply_realtime_session_defaults(session_payload)
+            session_payload.update(self._realtime_overlap_fields(session_payload))
+            if not self._opened:
+                self._opened = True
+                self._initial_session_update = True
+                return self._session_create_from_realtime(session_payload)
+            return {
+                "type": "turn.signal",
+                "event": "session.update",
+                "payload": session_payload,
+            }
+        if event_type == "conversation.item.create":
+            item = event.get("item")
+            format_error = self._validate_conversation_item_audio_formats(item)
+            if format_error is not None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "unsupported_audio_format",
+                        format_error,
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            return await self._conversation_item_to_duplex(event)
+        if event_type == "conversation.item.delete":
+            item_id = event.get("item_id")
+            if not isinstance(item_id, str) or not item_id:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "missing_item_id",
+                        "conversation.item.delete requires item_id",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            if item_id not in self._conversation_items:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "item_not_found",
+                        f"Conversation item not found: {item_id}",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            self._remove_conversation_item(item_id)
+            await self._pending_outbound.put(
+                {
+                    "type": "turn.signal",
+                    "event": "conversation.item.delete",
+                    "payload": {"item_id": item_id},
+                }
+            )
+            return None
+        if event_type == "conversation.item.retrieve":
+            item_id = event.get("item_id")
+            if not isinstance(item_id, str) or not item_id:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "missing_item_id",
+                        "conversation.item.retrieve requires item_id",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            item = self._conversation_items.get(item_id)
+            if item is None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "item_not_found",
+                        f"Conversation item not found: {item_id}",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            await self._send_realtime_payload({"type": "conversation.item.retrieved", "item": item})
+            return None
+        if event_type == "conversation.item.truncate":
+            item_id = event.get("item_id")
+            audio_end_ms = event.get("audio_end_ms")
+            content_index = event.get("content_index", 0)
+            if not isinstance(item_id, str) or not item_id:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "missing_item_id",
+                        "conversation.item.truncate requires item_id",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            if not isinstance(audio_end_ms, int | float):
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "bad_event",
+                        "conversation.item.truncate requires numeric audio_end_ms",
+                        event_id=event.get("event_id"),
+                        param="audio_end_ms",
+                    )
+                )
+                return None
+            item = self._conversation_items.get(item_id)
+            if item is None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "item_not_found",
+                        f"Conversation item not found: {item_id}",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            truncate_error = self._validate_realtime_item_truncate(
+                item,
+                content_index=int(content_index) if isinstance(content_index, int | float) else 0,
+                audio_end_ms=int(audio_end_ms),
+            )
+            if truncate_error is not None:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "bad_event",
+                        truncate_error,
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            self._item_truncation_cursors[item_id] = (
+                int(content_index) if isinstance(content_index, int | float) else 0,
+                int(audio_end_ms),
+            )
+            self._truncate_realtime_item_content(
+                item,
+                content_index=int(content_index) if isinstance(content_index, int | float) else 0,
+                audio_end_ms=int(audio_end_ms),
+            )
+            await self._pending_outbound.put(
+                {
+                    "type": "turn.signal",
+                    "event": "conversation.item.truncate",
+                    "payload": {
+                        "item_id": item_id,
+                        "content_index": content_index,
+                        "audio_end_ms": audio_end_ms,
+                    },
+                }
+            )
+            await self._pending_outbound.put(
+                {
+                    "type": "playback.ack",
+                    "item_id": item_id,
+                    "committed_ms": int(audio_end_ms),
+                    "played_ms": int(audio_end_ms),
+                    "truncate": True,
+                }
+            )
+            return None
+        if event_type == "input_audio_buffer.append":
+            audio = event.get("audio") or event.get("delta")
+            fmt, format_rate = self._parse_realtime_audio_format(
+                event.get("format") or event.get("input_audio_format") or self._input_audio_format
+            )
+            sample_rate_hz = (
+                event.get("sample_rate_hz") or event.get("sample_rate") or format_rate or self._input_sample_rate_hz
+            )
+            if not self._is_supported_realtime_input_format(fmt):
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "unsupported_audio_format",
+                        f"Unsupported input_audio_format: {fmt}",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            try:
+                audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
+                    audio,
+                    fmt,
+                    sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int | float) else None,
+                )
+            except ValueError as exc:
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "bad_event",
+                        str(exc),
+                        event_id=event.get("event_id"),
+                        param="sample_rate_hz",
+                    )
+                )
+                return None
+            looks_like_speech = self._input_looks_like_speech(event, audio=audio, fmt=fmt)
+            self._input_audio_buffer_has_audio = self._input_audio_buffer_has_audio or (
+                looks_like_speech and isinstance(audio, str) and bool(audio)
+            )
+            self._input_audio_buffer_had_non_speech = self._input_audio_buffer_had_non_speech or (
+                not looks_like_speech and isinstance(audio, str) and bool(audio)
+            )
+            if looks_like_speech:
+                await self._emit_input_speech_started(event)
+                self._remember_input_transcript_hint(event)
+            payload = {
+                "type": "input_audio_buffer.append",
+                "audio": audio,
+                "format": fmt,
+                "sample_rate_hz": sample_rate_hz,
+            }
+            video_frames = event.get("video_frames")
+            if video_frames is not None:
+                frames_error = self._validate_realtime_video_frames(video_frames, event.get("max_slice_nums"))
+                if frames_error is not None:
+                    await self._send_realtime_payload(
+                        self._realtime_error_payload(
+                            "invalid_video_frames",
+                            frames_error,
+                            event_id=event.get("event_id"),
+                            param="video_frames",
+                        )
+                    )
+                    return None
+                payload["video_frames"] = [frame for frame in video_frames if isinstance(frame, str) and frame]
+            self._copy_realtime_input_hints(event, payload)
+            if not looks_like_speech:
+                payload["is_speech"] = False
+            return payload
+        if event_type == "input_audio_buffer.commit":
+            if not self._input_audio_buffer_has_audio:
+                if self._input_audio_buffer_had_non_speech:
+                    self._input_audio_buffer_had_non_speech = False
+                    self._active_input_item_id = None
+                    return {
+                        "type": "input_audio_buffer.commit",
+                        "final": event.get("final", True),
+                        "response_create": False,
+                        "is_speech": False,
+                    }
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "input_audio_buffer_empty",
+                        "input_audio_buffer.commit requires a non-empty input audio buffer",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            item_id = self._active_input_item_id or f"item_{uuid4().hex}"
+            await self._pending_commit_item_ids.put(item_id)
+            await self._emit_input_speech_stopped(event, item_id=item_id)
+            transcript = self._consume_input_transcript_hint()
+            self._active_input_item_id = None
+            self._input_audio_buffer_has_audio = False
+            self._input_audio_buffer_had_non_speech = False
+            payload = {
+                "type": "input_audio_buffer.commit",
+                "final": event.get("final", True),
+                "realtime_item_id": item_id,
+                "response_create": bool(event.get("response_create", False)),
+            }
+            if transcript:
+                payload["transcript"] = transcript
+            return payload
+        if event_type == "input_audio_buffer.clear":
+            self._input_speech_started = False
+            self._active_input_item_id = None
+            self._input_audio_buffer_has_audio = False
+            self._input_audio_buffer_had_non_speech = False
+            self._input_audio_buffer_transcript_parts.clear()
+            return {"type": "input_audio_buffer.clear", "reason": event_type}
+        if event_type == "output_audio_buffer.clear":
+            payload = {"type": "output_audio_buffer.clear", "reason": event_type}
+            response_id = event.get("response_id")
+            if not isinstance(response_id, str) or not response_id:
+                response_id = self._active_response_id or self._last_response_id
+            if self._response_is_done(response_id):
+                await self._send_realtime_payload(
+                    {
+                        "type": "output_audio_buffer.cleared",
+                        "response_id": response_id,
+                    }
+                )
+                return None
+            if isinstance(response_id, str) and response_id:
+                payload["response_id"] = response_id
+            return payload
+        if event_type == "response.cancel":
+            payload = {"type": "response.cancel", "reason": event_type}
+            response_id = event.get("response_id")
+            if not isinstance(response_id, str) or not response_id:
+                response_id = self._active_response_id or self._last_response_id
+            if self._response_is_done(response_id):
+                await self._send_realtime_payload(
+                    self._realtime_error_payload(
+                        "response_not_active",
+                        f"Response is already complete: {response_id}",
+                        event_id=event.get("event_id"),
+                    )
+                )
+                return None
+            if isinstance(response_id, str) and response_id:
+                payload["response_id"] = response_id
+            return payload
+        if event_type == "response.create":
+            response_payload = event.get("response")
+            if isinstance(response_payload, dict):
+                format_error = self._validate_realtime_response_audio_formats(response_payload)
+                if format_error is not None:
+                    await self._send_realtime_payload(
+                        self._realtime_error_payload(
+                            "unsupported_audio_format",
+                            format_error,
+                            event_id=event.get("event_id"),
+                        )
+                    )
+                    return None
+            return {
+                "type": "response.create",
+                "response": response_payload if isinstance(response_payload, dict) else {},
+            }
+        if event_type in {"session.close", "close"}:
+            return {"type": "session.close"}
+        return event
+
+    @staticmethod
+    def _normalize_conversation_item(item: dict[str, object]) -> dict[str, object]:
+        normalized = dict(item)
+        normalized.setdefault("id", f"item_{uuid4().hex}")
+        normalized.setdefault("object", "realtime.item")
+        normalized.setdefault("type", "message")
+        normalized.setdefault("status", "completed")
+        if "role" not in normalized and normalized.get("type") == "message":
+            normalized["role"] = "user"
+        if not isinstance(normalized.get("content"), list):
+            normalized["content"] = []
+        return normalized
+
+    @staticmethod
+    def _truncate_realtime_item_content(
+        item: dict[str, object],
+        *,
+        content_index: int,
+        audio_end_ms: int,
+    ) -> None:
+        content = item.get("content")
+        if not isinstance(content, list) or not content:
+            return
+        index = max(0, int(content_index))
+        if index >= len(content):
+            return
+        part = content[index]
+        if not isinstance(part, dict):
+            return
+        transcript = part.get("transcript")
+        if not isinstance(transcript, str) or not transcript:
+            return
+        marks = part.get("audio_text_marks")
+        if isinstance(marks, list):
+            keep_chars = RealtimeInputTranslator._text_chars_for_audio_ms_from_marks(
+                audio_end_ms,
+                len(transcript),
+                marks,
+                final_ms=part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms"),
+            )
+            part["transcript"] = transcript[:keep_chars].rstrip()
+            return
+        duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
+        if isinstance(duration_ms, int | float) and duration_ms > 0:
+            keep_chars = int(len(transcript) * max(0.0, min(1.0, int(audio_end_ms) / float(duration_ms))))
+            part["transcript"] = transcript[:keep_chars].rstrip()
+        elif audio_end_ms <= 0:
+            part["transcript"] = ""
+
+    @staticmethod
+    def _validate_realtime_item_truncate(
+        item: dict[str, object],
+        *,
+        content_index: int,
+        audio_end_ms: int,
+    ) -> str | None:
+        if item.get("type") != "message" or item.get("role") != "assistant":
+            return "conversation.item.truncate only supports assistant message items"
+        if audio_end_ms < 0:
+            return "conversation.item.truncate requires non-negative audio_end_ms"
+        content = item.get("content")
+        if not isinstance(content, list) or not content:
+            return None
+        index = max(0, int(content_index))
+        if index >= len(content):
+            return f"conversation.item.truncate content_index out of range: {content_index}"
+        part = content[index]
+        if not isinstance(part, dict):
+            return "conversation.item.truncate target content part is invalid"
+        if part.get("type") not in {"audio", "output_audio"}:
+            return "conversation.item.truncate target content part must be audio"
+        duration_ms = part.get("audio_duration_ms") or part.get("duration_ms") or part.get("audio_ms")
+        if isinstance(duration_ms, int | float) and int(duration_ms) >= 0 and audio_end_ms > int(duration_ms):
+            return "conversation.item.truncate audio_end_ms exceeds item audio duration"
+        return None
+
+    @staticmethod
+    def _text_chars_for_audio_ms_from_marks(
+        audio_end_ms: int,
+        text_len: int,
+        marks: list[object],
+        *,
+        final_ms: object | None = None,
+    ) -> int:
+        if text_len <= 0:
+            return 0
+        clean_marks: list[tuple[int, int]] = []
+        for mark in marks:
+            if not isinstance(mark, dict):
+                continue
+            raw_text_chars = mark.get("text_chars")
+            raw_audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
+            if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
+                continue
+            clean_marks.append((max(0, int(raw_audio_end_ms)), min(text_len, max(0, int(raw_text_chars)))))
+        if not clean_marks:
+            return 0 if audio_end_ms <= 0 else text_len
+        clean_marks.sort(key=lambda item: item[0])
+        audio_end_ms = max(0, int(audio_end_ms))
+        if audio_end_ms <= 0:
+            return 0
+        previous_ms = 0
+        previous_chars = 0
+        for mark_ms, mark_chars in clean_marks:
+            mark_ms = max(previous_ms, mark_ms)
+            mark_chars = max(previous_chars, min(text_len, mark_chars))
+            if audio_end_ms <= mark_ms:
+                if mark_ms <= previous_ms:
+                    return mark_chars
+                ratio = (audio_end_ms - previous_ms) / max(1, mark_ms - previous_ms)
+                return int(previous_chars + (mark_chars - previous_chars) * max(0.0, min(1.0, ratio)))
+            previous_ms = mark_ms
+            previous_chars = mark_chars
+        if isinstance(final_ms, int | float) and int(final_ms) > previous_ms:
+            if audio_end_ms >= int(final_ms):
+                return text_len
+            ratio = (audio_end_ms - previous_ms) / max(1, int(final_ms) - previous_ms)
+            return int(previous_chars + (text_len - previous_chars) * max(0.0, min(1.0, ratio)))
+        return text_len if audio_end_ms >= previous_ms else previous_chars
+
+    def _conversation_item_added_events(self, item: dict[str, object]) -> list[dict[str, object]]:
+        item_id = item.get("id")
+        explicit_previous_item_id = item.pop("_previous_item_id", None)
+        previous_item_id = (
+            explicit_previous_item_id if isinstance(explicit_previous_item_id, str) else self._last_conversation_item_id
+        )
+        if isinstance(item_id, str) and item_id:
+            self._last_conversation_item_id = item_id
+        return [
+            {
+                "type": "conversation.item.added",
+                "previous_item_id": previous_item_id,
+                "item": item,
+            },
+            {
+                "type": "conversation.item.created",
+                "previous_item_id": previous_item_id,
+                "item": item,
+            },
+        ]
+
+    def _conversation_item_done_event(self, item: dict[str, object]) -> dict[str, object]:
+        item_id = item.get("id")
+        previous_item_id = self._previous_item_id(item_id) if isinstance(item_id, str) else None
+        if isinstance(item_id, str) and item_id:
+            self._conversation_items[item_id] = item
+            self._last_conversation_item_id = item_id
+        return {
+            "type": "conversation.item.done",
+            "previous_item_id": previous_item_id,
+            "item": item,
+        }
+
+    def _remove_conversation_item(self, item_id: str) -> bool:
+        removed = self._conversation_items.pop(item_id, None) is not None
+        if self._last_conversation_item_id == item_id:
+            self._last_conversation_item_id = next(reversed(self._conversation_items), None)
+        self._item_truncation_cursors.pop(item_id, None)
+        return removed
+
+    def _response_output_item_added_events(
+        self,
+        *,
+        response_id: object,
+        item: dict[str, object],
+    ) -> list[dict[str, object]]:
+        return [
+            {
+                "type": "response.output_item.added",
+                "response_id": response_id,
+                "output_index": 0,
+                "item": item,
+            },
+        ]
+
+    @staticmethod
+    def _response_content_part(*, transcript: str = "") -> dict[str, object]:
+        return {
+            "type": "audio",
+            "transcript": transcript,
+        }
+
+    @staticmethod
+    def _response_text_content_part(*, text: str = "") -> dict[str, object]:
+        return {
+            "type": "text",
+            "text": text,
+        }
+
+    @staticmethod
+    def _response_item_content_part(
+        *,
+        transcript: str = "",
+        audio_duration_ms: int | None = None,
+        audio_text_marks: list[dict[str, int]] | None = None,
+    ) -> dict[str, object]:
+        part: dict[str, object] = {
+            "type": "output_audio",
+            "transcript": transcript,
+        }
+        if audio_duration_ms is not None:
+            part["audio_duration_ms"] = int(audio_duration_ms)
+        if audio_text_marks:
+            part["audio_text_marks"] = [dict(mark) for mark in audio_text_marks]
+        return part
+
+    @staticmethod
+    def _response_item_text_content_part(*, text: str = "") -> dict[str, object]:
+        return {
+            "type": "output_text",
+            "text": text,
+        }
+
+    def _previous_item_id(self, item_id: str) -> str | None:
+        previous: str | None = None
+        for known_id in self._conversation_items:
+            if known_id == item_id:
+                return previous
+            previous = known_id
+        if self._last_conversation_item_id == item_id:
+            return previous
+        return self._last_conversation_item_id
+
+    def _input_audio_buffer_committed_event(
+        self,
+        *,
+        item_id: str,
+        event: dict[str, Any],
+    ) -> dict[str, object]:
+        return {
+            "type": "input_audio_buffer.committed",
+            "previous_item_id": self._previous_item_id(item_id),
+            "item_id": item_id,
+            "event": event,
+        }
+
+    def _session_create_from_realtime(self, session_payload: dict[str, object]) -> dict[str, object]:
+        self._apply_realtime_session_defaults(session_payload)
+        model = session_payload.get("model")
+        audio_config = session_payload.get("audio")
+        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        extra_body = (
+            dict(session_payload.get("extra_body")) if isinstance(session_payload.get("extra_body"), dict) else {}
+        )
+        extra_body["realtime_session_payload"] = self._json_safe_realtime_payload(session_payload)
+        if isinstance(session_payload.get("tools"), list):
+            extra_body["realtime_tools"] = session_payload["tools"]
+        if isinstance(session_payload.get("tool_choice"), str | dict):
+            extra_body["realtime_tool_choice"] = session_payload["tool_choice"]
+        if isinstance(session_payload.get("metadata"), dict):
+            extra_body["realtime_metadata"] = dict(session_payload["metadata"])
+        if isinstance(session_payload.get("include"), list):
+            extra_body["realtime_include"] = list(session_payload["include"])
+        if isinstance(session_payload.get("prompt"), dict):
+            extra_body["realtime_prompt"] = dict(session_payload["prompt"])
+        input_audio_transcription = self._input_audio_transcription_config(session_payload)
+        if isinstance(input_audio_transcription, dict):
+            extra_body["realtime_input_audio_transcription"] = dict(input_audio_transcription)
+        if isinstance(session_payload.get("input_audio_noise_reduction"), dict):
+            extra_body["realtime_input_audio_noise_reduction"] = dict(session_payload["input_audio_noise_reduction"])
+        if isinstance(audio_input, dict) and isinstance(audio_input.get("noise_reduction"), dict):
+            extra_body["realtime_input_audio_noise_reduction"] = dict(audio_input["noise_reduction"])
+        if isinstance(session_payload.get("audio"), dict):
+            extra_body["realtime_audio"] = dict(session_payload["audio"])
+        if isinstance(session_payload.get("tracing"), str | dict):
+            extra_body["realtime_tracing"] = session_payload["tracing"]
+        response_format = self._duplex_response_format(self._output_audio_format)
+        extra_body.setdefault("realtime_output_audio_format", self._output_audio_format)
+        overlap_fields = self._realtime_overlap_fields(session_payload)
+        voice = session_payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        speed = session_payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        return {
+            "type": "session.create",
+            "session_id": session_payload.get("session_id") or session_payload.get("id"),
+            "session": {
+                "model": model,
+                "modalities": (
+                    session_payload.get("modalities") or session_payload.get("output_modalities") or ["text", "audio"]
+                ),
+                "instructions": session_payload.get("instructions"),
+                "voice": voice,
+                "ref_audio": session_payload.get("ref_audio"),
+                "response_format": response_format,
+                "temperature": session_payload.get("temperature"),
+                "max_tokens": self.realtime_max_output_tokens(
+                    session_payload.get("max_response_output_tokens")
+                    or session_payload.get("max_output_tokens")
+                    or session_payload.get("max_tokens")
+                ),
+                "speed": speed,
+                "idle_timeout_s": session_payload.get("idle_timeout_s") or 300.0,
+                **overlap_fields,
+                "extra_body": extra_body,
+            },
+        }
+
+    def _apply_realtime_session_defaults(self, session_payload: dict[str, object]) -> None:
+        input_format: object = session_payload.get("input_audio_format")
+        audio_config = session_payload.get("audio")
+        if input_format is None and isinstance(audio_config, dict):
+            audio_input = audio_config.get("input")
+            if isinstance(audio_input, dict):
+                input_format = audio_input.get("format")
+        input_format, input_rate = self._parse_realtime_audio_format(input_format)
+        if isinstance(input_format, str) and input_format.lower() in REALTIME_INPUT_AUDIO_FORMATS:
+            self._input_audio_format = input_format
+        output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
+        output_rate_raw: object | None = None
+        if output_format is None and isinstance(audio_config, dict):
+            audio_output = audio_config.get("output")
+            if isinstance(audio_output, dict):
+                output_format = audio_output.get("format")
+                output_rate_raw = audio_output.get("sample_rate_hz") or audio_output.get("sample_rate")
+        output_format, output_rate = self._parse_realtime_audio_format(output_format)
+        if output_rate is None and isinstance(output_rate_raw, int | float) and output_rate_raw > 0:
+            output_rate = int(output_rate_raw)
+        if isinstance(output_format, str) and output_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
+            self._output_audio_format = self._realtime_output_format(output_format)
+        sample_rate = session_payload.get("sample_rate_hz") or session_payload.get("sample_rate")
+        if sample_rate is None and isinstance(audio_config, dict):
+            audio_input = audio_config.get("input")
+            if isinstance(audio_input, dict):
+                sample_rate = audio_input.get("sample_rate_hz") or audio_input.get("sample_rate")
+        if sample_rate is None:
+            sample_rate = input_rate
+        if isinstance(sample_rate, int | float) and sample_rate > 0:
+            self._input_sample_rate_hz = int(sample_rate)
+        if isinstance(output_rate, int | float) and output_rate > 0:
+            self._output_sample_rate_hz = int(output_rate)
+        overlap_fields = self._realtime_overlap_fields(session_payload)
+        overlap_silence_rms = overlap_fields.get("overlap_silence_rms")
+        if isinstance(overlap_silence_rms, int | float):
+            self._overlap_silence_rms = max(0.0, float(overlap_silence_rms))
+
+    @classmethod
+    def _validate_realtime_session_audio_formats(cls, session_payload: dict[str, object]) -> str | None:
+        audio_config = session_payload.get("audio")
+        input_format: object = session_payload.get("input_audio_format")
+        if input_format is None and isinstance(audio_config, dict):
+            audio_input = audio_config.get("input")
+            if isinstance(audio_input, dict):
+                input_format = audio_input.get("format")
+        parsed_input, _ = cls._parse_realtime_audio_format(input_format)
+        if input_format is not None and not (
+            isinstance(parsed_input, str) and parsed_input.lower() in REALTIME_INPUT_AUDIO_FORMATS
+        ):
+            return f"Unsupported input_audio_format: {input_format}"
+
+        output_format: object = session_payload.get("output_audio_format") or session_payload.get("response_format")
+        if output_format is None and isinstance(audio_config, dict):
+            audio_output = audio_config.get("output")
+            if isinstance(audio_output, dict):
+                output_format = audio_output.get("format")
+        parsed_output, _ = cls._parse_realtime_audio_format(output_format)
+        if output_format is not None and not (
+            isinstance(parsed_output, str) and parsed_output.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
+        ):
+            return f"Unsupported output_audio_format: {output_format}"
+        return None
+
+    @classmethod
+    def _validate_realtime_response_audio_formats(cls, response_payload: dict[str, object]) -> str | None:
+        output_format: object = response_payload.get("output_audio_format") or response_payload.get("response_format")
+        audio_config = response_payload.get("audio")
+        if output_format is None and isinstance(audio_config, dict):
+            audio_output = audio_config.get("output")
+            if isinstance(audio_output, dict):
+                output_format = audio_output.get("format")
+        parsed_output, _ = cls._parse_realtime_audio_format(output_format)
+        if output_format is not None and not (
+            isinstance(parsed_output, str) and parsed_output.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
+        ):
+            return f"Unsupported output_audio_format: {output_format}"
+        return None
+
+    @classmethod
+    def _validate_conversation_item_audio_formats(cls, item: object) -> str | None:
+        if not isinstance(item, dict):
+            return None
+        content = item.get("content")
+        if not isinstance(content, list):
+            return None
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            if part.get("type") not in {"input_audio", "audio"}:
+                continue
+            raw_format = part.get("format")
+            parsed_format, _ = cls._parse_realtime_audio_format(raw_format)
+            if raw_format is not None and not (
+                isinstance(parsed_format, str) and parsed_format.lower() in REALTIME_INPUT_AUDIO_FORMATS
+            ):
+                return f"Unsupported input_audio format in conversation.item.create: {raw_format}"
+        return None
+
+    @staticmethod
+    def _json_safe_realtime_payload(payload: dict[str, object]) -> dict[str, object]:
+        clean: dict[str, object] = {}
+        for key, value in payload.items():
+            if key == "extra_body":
+                continue
+            if isinstance(value, str | int | float | bool) or value is None:
+                clean[key] = value
+            elif isinstance(value, dict):
+                clean[key] = RealtimeInputTranslator._json_safe_realtime_payload(value)
+            elif isinstance(value, list):
+                clean[key] = [
+                    (RealtimeInputTranslator._json_safe_realtime_payload(item) if isinstance(item, dict) else item)
+                    for item in value
+                    if isinstance(item, str | int | float | bool | dict) or item is None
+                ]
+        return clean
+
+    @staticmethod
+    def _parse_realtime_audio_format(raw_format: object) -> tuple[object, int | None]:
+        def normalize_format(fmt: str) -> str:
+            normalized = fmt.lower()
+            if normalized in {"audio/pcm", "pcm"}:
+                return "pcm16"
+            if normalized in {"audio/wav", "wav"}:
+                return "wav"
+            if normalized in {"audio/pcm16", "pcm16", "pcm_s16le", "s16le"}:
+                return "pcm16"
+            if normalized in {"audio/pcm_f32le", "pcm_f32le", "f32le"}:
+                return "pcm_f32le"
+            if normalized in {"audio/g711_ulaw", "g711_ulaw", "g711-ulaw", "ulaw", "mulaw"}:
+                return "g711_ulaw"
+            if normalized in {"audio/g711_alaw", "g711_alaw", "g711-alaw", "alaw"}:
+                return "g711_alaw"
+            return fmt
+
+        if isinstance(raw_format, str):
+            return normalize_format(raw_format), None
+        if not isinstance(raw_format, dict):
+            return raw_format, None
+        rate = raw_format.get("rate") or raw_format.get("sample_rate_hz") or raw_format.get("sample_rate")
+        sample_rate_hz = int(rate) if isinstance(rate, int | float) and rate > 0 else None
+        fmt = raw_format.get("type") or raw_format.get("format")
+        if not isinstance(fmt, str):
+            return raw_format, sample_rate_hz
+        return normalize_format(fmt), sample_rate_hz
+
+    @staticmethod
+    def _duplex_response_format(realtime_format: str) -> str:
+        normalized = realtime_format.lower()
+        if normalized in {"pcm16", "pcm_s16le", "s16le"}:
+            return "pcm"
+        if normalized in {"g711_ulaw", "g711_alaw"}:
+            return "pcm"
+        if normalized in {"wav", "pcm"}:
+            return normalized
+        return "wav"
+
+    @staticmethod
+    def _realtime_output_format(duplex_format: object) -> str:
+        if isinstance(duplex_format, str) and duplex_format.lower() in {"g711_ulaw", "g711_alaw"}:
+            return duplex_format.lower()
+        if isinstance(duplex_format, str) and duplex_format.lower() == "pcm":
+            return "pcm16"
+        return str(duplex_format or "wav")
+
+    @staticmethod
+    def _is_supported_realtime_input_format(fmt: object) -> bool:
+        return isinstance(fmt, str) and fmt.lower() in REALTIME_INPUT_AUDIO_FORMATS
+
+    @staticmethod
+    def _input_explicitly_non_speech(event: dict[str, object]) -> bool:
+        for key in ("is_speech", "speech"):
+            value = event.get(key)
+            if isinstance(value, bool):
+                return not value
+        vad = event.get("vad")
+        if isinstance(vad, dict):
+            value = vad.get("is_speech")
+            if isinstance(value, bool):
+                return not value
+            probability = vad.get("speech_probability", vad.get("probability"))
+            if isinstance(probability, int | float):
+                return float(probability) < 0.5
+        probability = event.get("speech_probability")
+        return isinstance(probability, int | float) and float(probability) < 0.5
+
+    def _input_looks_like_speech(self, event: dict[str, object], *, audio: object, fmt: object) -> bool:
+        if RealtimeInputTranslator._input_explicitly_non_speech(event):
+            return False
+        for key in ("is_speech", "speech"):
+            value = event.get(key)
+            if isinstance(value, bool):
+                return value
+        vad = event.get("vad")
+        if isinstance(vad, dict):
+            probability = vad.get("speech_probability", vad.get("probability"))
+            if isinstance(probability, int | float):
+                return float(probability) >= 0.5
+        probability = event.get("speech_probability")
+        if isinstance(probability, int | float):
+            return float(probability) >= 0.5
+        if fmt != "pcm_f32le" or not isinstance(audio, str):
+            return True
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError):
+            return True
+        if len(raw) < 4 or len(raw) % 4 != 0:
+            return True
+        samples = np.frombuffer(raw, dtype=np.float32)
+        if samples.size == 0:
+            return False
+        rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
+        threshold = event.get("overlap_silence_rms")
+        if not isinstance(threshold, int | float):
+            vad = event.get("vad")
+            if isinstance(vad, dict):
+                threshold = vad.get("silence_rms")
+        silence_rms = float(threshold) if isinstance(threshold, int | float) else self._overlap_silence_rms
+        return rms >= max(0.0, silence_rms)
+
+    @staticmethod
+    def _copy_realtime_input_hints(source: dict[str, object], target: dict[str, object]) -> None:
+        for key in (
+            "duration_ms",
+            "audio_duration_ms",
+            "audio_start_ms",
+            "audio_end_ms",
+            "is_speech",
+            "speech",
+            "speech_probability",
+            "vad",
+            "overlap_action",
+            "overlap",
+            "force_barge_in",
+            "force_listen",
+            "text",
+            "transcript",
+        ):
+            if key in source:
+                target[key] = source[key]
+
+    @classmethod
+    def _realtime_overlap_fields(cls, session_payload: dict[str, object]) -> dict[str, object]:
+        fields: dict[str, object] = {}
+        if isinstance(session_payload.get("overlap_policy"), str):
+            fields["overlap_policy"] = session_payload["overlap_policy"]
+        for key in ("overlap_short_ack_ms", "overlap_barge_in_ms", "overlap_silence_rms"):
+            value = session_payload.get(key)
+            if isinstance(value, int | float):
+                fields[key] = value
+
+        if isinstance(session_payload.get("playback_commit_policy"), str):
+            fields["playback_commit_policy"] = session_payload["playback_commit_policy"]
+        return fields
+
+    @staticmethod
+    def _validate_realtime_video_frames(video_frames: object, max_slice_nums: object) -> str | None:
+        """Validate omni-duplex camera frames on input_audio_buffer.append.
+
+        Wire contract matches the official MiniCPM-o-Demo omni client: one
+        base64 JPEG per ~1 s audio chunk. HD slicing (max_slice_nums > 1) is
+        not implemented by the duplex adapter yet and is rejected explicitly
+        rather than silently ignored.
+        """
+        if max_slice_nums not in (None, 1):
+            return "max_slice_nums > 1 (HD slicing) is not implemented by the duplex Realtime adapter"
+        if not isinstance(video_frames, list):
+            return "video_frames must be a list of base64-encoded images"
+        frames = [frame for frame in video_frames if frame is not None]
+        if len(frames) > 2:
+            return "video_frames carries more than 2 frames for one append; send ~1 frame per 1 s chunk"
+        for frame in frames:
+            if not isinstance(frame, str) or not frame:
+                return "video_frames entries must be non-empty base64 strings"
+            if len(frame) > 4_000_000:
+                return "video_frames entry exceeds 4MB base64; reduce capture resolution or JPEG quality"
+            try:
+                header = base64.b64decode(frame[:64] + "=" * (-len(frame[:64]) % 4))
+            except (binascii.Error, ValueError):
+                return "video_frames entries must be valid base64"
+            if not (header.startswith(b"\xff\xd8") or header.startswith(b"\x89PNG")):
+                return "video_frames entries must be JPEG or PNG images"
+        return None
+
+    @staticmethod
+    def _validate_realtime_turn_detection(session_payload: dict[str, object]) -> str | None:
+        configured_values: list[tuple[str, object]] = []
+        if "turn_detection" in session_payload:
+            configured_values.append(("turn_detection", session_payload["turn_detection"]))
+        audio_config = session_payload.get("audio")
+        if isinstance(audio_config, dict):
+            audio_input = audio_config.get("input")
+            if isinstance(audio_input, dict) and "turn_detection" in audio_input:
+                configured_values.append(("audio.input.turn_detection", audio_input["turn_detection"]))
+        for field_path, turn_detection in configured_values:
+            if turn_detection is None:
+                continue
+            turn_detection_type = turn_detection.get("type") if isinstance(turn_detection, dict) else turn_detection
+            return (
+                f"{field_path}={turn_detection_type!r} is not implemented by the duplex Realtime adapter; "
+                "set turn_detection to null and commit input explicitly, or use the model-owned duplex policy"
+            )
+        return None
+
+    @staticmethod
+    def _input_audio_transcription_config(session_payload: dict[str, object]) -> dict[str, object] | None:
+        transcription = session_payload.get("input_audio_transcription")
+        if isinstance(transcription, dict):
+            return transcription
+        audio_config = session_payload.get("audio")
+        if not isinstance(audio_config, dict):
+            return None
+        audio_input = audio_config.get("input")
+        if not isinstance(audio_input, dict):
+            return None
+        transcription = audio_input.get("transcription")
+        return transcription if isinstance(transcription, dict) else None
+
+    @staticmethod
+    def realtime_max_output_tokens(value: object) -> int | None:
+        """Normalize Realtime max output tokens.
+
+        OpenAI Realtime clients commonly send ``"inf"`` for unbounded output.
+        The duplex core represents that as ``None`` because model-specific
+        defaults remain in force.
+        """
+        if value is None:
+            return None
+        if isinstance(value, str) and value.strip().lower() in {"inf", "infinity", "unlimited"}:
+            return None
+        if isinstance(value, int) and value > 0:
+            return int(value)
+        return None
+
+    async def _conversation_item_to_duplex(self, event: dict[str, object]) -> dict[str, object] | None:
+        item = event.get("item")
+        if not isinstance(item, dict):
+            return None
+        item = self._normalize_conversation_item(item)
+        previous_item_id = event.get("previous_item_id")
+        if isinstance(previous_item_id, str):
+            item["_previous_item_id"] = previous_item_id
+        item_id = str(item["id"])
+        item_type = item.get("type")
+        role = item.get("role")
+        if item_type != "message" or role in {"assistant", "system"}:
+            return {
+                "type": "turn.signal",
+                "event": "conversation.item.create",
+                "payload": {"item": item},
+            }
+        self._conversation_items[item_id] = item
+        content = item.get("content")
+        if not isinstance(content, list):
+            return None
+        text_chunks: list[str] = []
+        audio_events: list[dict[str, object]] = []
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            if part.get("type") in {"input_text", "text"} and isinstance(part.get("text"), str):
+                text_chunks.append(str(part["text"]))
+            if part.get("type") in {"input_audio", "audio"}:
+                audio = part.get("audio") or part.get("data")
+                fmt, format_rate = self._parse_realtime_audio_format(part.get("format") or self._input_audio_format)
+                sample_rate_hz = (
+                    part.get("sample_rate_hz") or part.get("sample_rate") or format_rate or self._input_sample_rate_hz
+                )
+                if not self._is_supported_realtime_input_format(fmt):
+                    continue
+                try:
+                    audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
+                        audio,
+                        fmt,
+                        sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int | float) else None,
+                    )
+                except ValueError as exc:
+                    await self._send_realtime_payload(
+                        self._realtime_error_payload(
+                            "bad_event",
+                            str(exc),
+                            event_id=event.get("event_id"),
+                            param="sample_rate_hz",
+                        )
+                    )
+                    return None
+                if not isinstance(audio, str) or not audio:
+                    continue
+                speech_hints = dict(event)
+                speech_hints.update(part)
+                if not self._input_looks_like_speech(speech_hints, audio=audio, fmt=fmt):
+                    continue
+                self._input_speech_started = True
+                payload = {
+                    "type": "input_audio_buffer.append",
+                    "audio": audio,
+                    "format": fmt,
+                    "sample_rate_hz": sample_rate_hz,
+                }
+                self._copy_realtime_input_hints(part, payload)
+                self._copy_realtime_input_hints(event, payload)
+                audio_events.append(payload)
+        if audio_events:
+            self._input_audio_buffer_has_audio = True
+            transcript = self._input_transcript_from_item(item)
+            for extra_event in audio_events[1:]:
+                self._pending_outbound.put_nowait(extra_event)
+            commit_payload: dict[str, object] = {
+                "type": "input_audio_buffer.commit",
+                "final": True,
+                "realtime_item_id": item_id,
+                "response_create": False,
+            }
+            if transcript:
+                commit_payload["transcript"] = transcript
+            self._pending_outbound.put_nowait(commit_payload)
+            return audio_events[0]
+        if not text_chunks:
+            return None
+        text_item = dict(item)
+        text_item["status"] = "completed"
+        return {
+            "type": "turn.signal",
+            "event": "conversation.item.create",
+            "payload": {"item": text_item},
+        }
+
+    def _remember_input_transcript_hint(self, event: dict[str, object]) -> None:
+        transcript = event.get("transcript")
+        if not isinstance(transcript, str):
+            transcript = event.get("text") if isinstance(event.get("text"), str) else None
+        if not isinstance(transcript, str):
+            hints = event.get("hints")
+            if isinstance(hints, dict):
+                transcript = hints.get("transcript")
+                if not isinstance(transcript, str):
+                    transcript = hints.get("text") if isinstance(hints.get("text"), str) else None
+        if isinstance(transcript, str) and transcript:
+            if (
+                self._input_audio_buffer_transcript_parts
+                and self._input_audio_buffer_transcript_parts[-1] == transcript
+            ):
+                return
+            self._input_audio_buffer_transcript_parts.append(transcript)
+
+    def _consume_input_transcript_hint(self) -> str:
+        transcript = "".join(self._input_audio_buffer_transcript_parts).strip()
+        self._input_audio_buffer_transcript_parts.clear()
+        return transcript
+
+    @staticmethod
+    def _input_transcript_from_item(item: dict[str, object]) -> str:
+        content = item.get("content")
+        if not isinstance(content, list):
+            return ""
+        parts: list[str] = []
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            for key in ("transcript", "text"):
+                value = part.get(key)
+                if isinstance(value, str) and value:
+                    if part.get("type") in {"input_audio", "audio", "audio_transcript", "transcript"}:
+                        parts.append(value)
+                        break
+        return "".join(parts).strip()
+
+    @staticmethod
+    def _input_audio_transcription_completed_event(
+        item_id: str,
+        item: dict[str, object],
+    ) -> dict[str, object] | None:
+        content = item.get("content")
+        if not isinstance(content, list):
+            return None
+        transcript_parts: list[str] = []
+        for index, part in enumerate(content):
+            if not isinstance(part, dict):
+                continue
+            if part.get("type") != "input_audio":
+                continue
+            transcript = part.get("transcript")
+            if isinstance(transcript, str) and transcript:
+                transcript_parts.append(transcript)
+                return {
+                    "type": "conversation.item.input_audio_transcription.completed",
+                    "item_id": item_id,
+                    "content_index": index,
+                    "transcript": "".join(transcript_parts),
+                }
+        return None
+
+    def _pop_pending_commit_item_id(self) -> str:
+        try:
+            return self._pending_commit_item_ids.get_nowait()
+        except asyncio.QueueEmpty:
+            return f"item_{uuid4().hex}"
+
+    async def _emit_input_speech_started(self, event: dict[str, object]) -> None:
+        if self._input_speech_started:
+            return
+        self._input_speech_started = True
+        if self._active_input_item_id is None:
+            self._active_input_item_id = f"item_{uuid4().hex}"
+        await self._send_realtime_payload(
+            {
+                "type": "input_audio_buffer.speech_started",
+                "audio_start_ms": int(event.get("audio_start_ms", 0) or 0),
+                "item_id": self._active_input_item_id,
+            }
+        )
+
+    async def _emit_input_speech_stopped(self, event: dict[str, object], *, item_id: str) -> None:
+        if not self._input_speech_started:
+            return
+        self._input_speech_started = False
+        audio_end_ms = event.get("audio_end_ms", event.get("audio_ms", 0))
+        await self._send_realtime_payload(
+            {
+                "type": "input_audio_buffer.speech_stopped",
+                "audio_end_ms": int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
+                "item_id": item_id,
+            }
+        )
diff --git a/vllm_omni/experimental/fullduplex/openai/realtime_output.py b/vllm_omni/experimental/fullduplex/openai/realtime_output.py
new file mode 100644
index 000000000..57c07c852
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/realtime_output.py
@@ -0,0 +1,907 @@
+from __future__ import annotations
+
+from typing import Any
+from uuid import uuid4
+
+from vllm_omni.experimental.fullduplex.openai.audio import convert_output_audio
+from vllm_omni.experimental.fullduplex.openai.realtime_state import (
+    _RealtimeResponseState,
+)
+
+
+class RealtimeOutputProjector:
+    """Project internal duplex events onto the OpenAI Realtime schema."""
+
+    def _from_duplex_event(self, event: dict[str, Any]) -> list[dict[str, object]]:
+        event_type = event.get("type")
+        if event_type == "session.created":
+            session = self._realtime_session_payload(event.get("session"))
+            created: dict[str, object] = {"type": "session.created", "session": session}
+            for key in (
+                "incarnation",
+                "attachment_generation",
+                "resume_token",
+            ):
+                if key in event:
+                    created[key] = event[key]
+            payloads: list[dict[str, object]] = [created]
+            if self._initial_session_update:
+                payloads.append({"type": "session.updated", "session": session})
+                self._initial_session_update = False
+            self._hold_realtime_output_until_session_created = False
+            if self._held_realtime_payloads:
+                payloads.extend(self._held_realtime_payloads)
+                self._held_realtime_payloads = []
+            return payloads
+        if event_type == "session.updated":
+            session = self._realtime_session_payload(event.get("session"))
+            return [{"type": "session.updated", "session": session}]
+        if event_type in {
+            "session.resumed",
+            "session.heartbeat_ack",
+            "session.replaced",
+            "session.expired",
+            "session.resync_required",
+        }:
+            if event_type == "session.resumed":
+                self._hold_realtime_output_until_session_created = False
+            return [dict(event)]
+        if event_type == "response.created":
+            response_id = event.get("response_id")
+            if isinstance(response_id, str) and response_id:
+                self._active_response_id = response_id
+                self._last_response_id = response_id
+            item_id = self._response_item_id(response_id)
+            modalities = event.get("modalities")
+            has_audio_modality = not isinstance(modalities, list) or "audio" in modalities
+            item = {
+                "id": item_id,
+                "object": "realtime.item",
+                "type": "message",
+                "role": "assistant",
+                "status": "in_progress",
+                "content": [],
+            }
+            self._conversation_items[item_id] = item
+            payloads = [
+                self._response_created_event(event),
+                *self._conversation_item_added_events(item),
+                *self._response_output_item_added_events(response_id=response_id, item=item),
+            ]
+            if has_audio_modality:
+                payloads.extend(self._ensure_response_audio_part_added(response_id))
+            return payloads
+        if event_type == "response.listen":
+            return [
+                {
+                    "type": "response.listen",
+                    "session_id": event.get("session_id"),
+                    "epoch": event.get("epoch"),
+                    "response": {
+                        "object": "realtime.response",
+                        "status": "listening",
+                        "metadata": event,
+                    },
+                }
+            ]
+        if event_type == "response.speak":
+            response_id = event.get("response_id")
+            state = self._response_state(response_id)
+            if state is not None:
+                if state.speak_emitted:
+                    return []
+                state.speak_emitted = True
+            return [
+                {
+                    "type": "response.speak",
+                    "response_id": response_id,
+                    "item_id": self._response_item_id(response_id),
+                    "output_index": 0,
+                    "content_index": 0,
+                    "metadata": self._response_speak_metadata(event),
+                }
+            ]
+        if event_type == "overlap.decision":
+            return [
+                {
+                    "type": "overlap.decision",
+                    "session_id": event.get("session_id"),
+                    "epoch": event.get("epoch"),
+                    "policy": event.get("policy"),
+                    "action": event.get("action"),
+                    "reason": event.get("reason"),
+                    "metadata": event,
+                }
+            ]
+        if event_type == "response.output_audio.delta":
+            response_id = event.get("response_id")
+            audio = event.get("audio", "")
+            payloads: list[dict[str, object]] = []
+            if isinstance(audio, str) and audio:
+                payloads.extend(self._ensure_response_audio_part_added(response_id))
+                payloads.extend(self._realtime_audio_delta_events(event, response_id, audio))
+                self._refresh_in_progress_response_item(response_id)
+            text = event.get("text")
+            has_text = isinstance(text, str) and bool(text)
+            if has_text:
+                self._append_response_transcript(response_id, text)
+                self._refresh_in_progress_response_item(response_id)
+            # Keep the audio.delta + transcript.delta pair invariant even for
+            # text-less units (deduplicated continuations, turn-end flush):
+            # clients that treat the pair as unit-complete would otherwise
+            # wait on a transcript that never comes.
+            emit_transcript = has_text or (isinstance(audio, str) and bool(audio))
+            if emit_transcript:
+                if not has_text:
+                    text = ""
+                payloads.append(
+                    {
+                        "type": "response.audio_transcript.delta",
+                        "response_id": response_id,
+                        "item_id": self._response_item_id(response_id),
+                        "output_index": 0,
+                        "content_index": 0,
+                        "delta": text,
+                    }
+                )
+            if event.get("end_of_turn") is True:
+                payloads.extend(self._realtime_audio_done_events(event, response_id))
+                payloads.extend(
+                    self._realtime_response_terminal_events(
+                        event,
+                        response_id,
+                        status="completed",
+                        status_details={
+                            "type": "completed",
+                            "reason": event.get("finish_reason") or "stop",
+                        },
+                    )
+                )
+            return payloads
+        if event_type == "response.text.delta":
+            response_id = event.get("response_id")
+            text = event.get("delta", "")
+            state = self._response_state(response_id)
+            if state is not None and isinstance(text, str) and text:
+                state.text_parts.append(text)
+                self._refresh_in_progress_response_item(response_id)
+            payloads = self._ensure_response_text_part_added(response_id)
+            payloads.append(
+                {
+                    "type": "response.output_text.delta",
+                    "response_id": response_id,
+                    "item_id": self._response_item_id(response_id),
+                    "output_index": 0,
+                    "content_index": 1 if state is not None and state.audio_part_added else 0,
+                    "delta": text,
+                }
+            )
+            return payloads
+        if event_type == "response.done":
+            response_id = event.get("response_id")
+            status = event.get("status") if isinstance(event.get("status"), str) else "completed"
+            status_details = event.get("status_details") if isinstance(event.get("status_details"), dict) else None
+            return [
+                *self._realtime_audio_done_events(event, response_id),
+                *self._realtime_response_terminal_events(
+                    event,
+                    response_id,
+                    status=status,
+                    status_details=status_details,
+                ),
+            ]
+        if event_type == "input.committed":
+            event_item_id = event.get("realtime_item_id")
+            item_id = (
+                event_item_id
+                if isinstance(event_item_id, str) and event_item_id
+                else self._pop_pending_commit_item_id()
+            )
+            item = self._conversation_items.get(item_id)
+            created_payload: list[dict[str, object]] = []
+            if item is None:
+                message = event.get("message")
+                no_response = event.get("no_response") is True
+                is_speech = event.get("is_speech")
+                item = {
+                    "id": item_id,
+                    "object": "realtime.item",
+                    "type": "message",
+                    "role": "user",
+                    "status": "completed",
+                    "content": (
+                        [{"type": "input_audio", "transcript": "", "is_speech": False}]
+                        if no_response and is_speech is False
+                        else self._user_item_content_from_duplex_message(message)
+                    ),
+                }
+                self._conversation_items[item_id] = item
+                created_payload.extend(self._conversation_item_added_events(item))
+            item["status"] = "completed"
+            payloads = created_payload + [
+                self._input_audio_buffer_committed_event(item_id=item_id, event=event),
+            ]
+            transcription_event = self._input_audio_transcription_completed_event(item_id, item)
+            if transcription_event is not None:
+                payloads.append(transcription_event)
+            payloads.append(self._conversation_item_done_event(item))
+            return payloads
+        if event_type == "input.cancelled":
+            return [{"type": "input_audio_buffer.cleared"}]
+        if event_type == "input_audio_buffer.cleared":
+            return [{"type": "input_audio_buffer.cleared"}]
+        if event_type == "audio.cancelled":
+            response_id = event.get("response_id")
+            payloads: list[dict[str, object]] = []
+            if event.get("reason") == "output_audio_buffer_clear":
+                if not isinstance(response_id, str) or not response_id:
+                    response_id = self._active_response_id or self._last_response_id
+                payloads.append(
+                    {
+                        "type": "output_audio_buffer.cleared",
+                        "response_id": response_id,
+                    }
+                )
+                if not isinstance(response_id, str) or not response_id:
+                    return payloads
+            elif not isinstance(response_id, str) or not response_id:
+                response_id = self._active_response_id
+            if not isinstance(response_id, str) or not response_id:
+                return payloads
+            if self._response_is_done(response_id):
+                return payloads
+            committed_ms = event.get("committed_ms")
+            if isinstance(committed_ms, int | float):
+                item_id = self._response_item_id(response_id)
+                committed_audio_ms = max(0, int(committed_ms))
+                self._item_truncation_cursors[item_id] = (0, committed_audio_ms)
+                item = self._conversation_items.get(item_id)
+                if item is not None:
+                    self._truncate_realtime_item_content(
+                        item,
+                        content_index=0,
+                        audio_end_ms=committed_audio_ms,
+                    )
+                payloads.append(
+                    {
+                        "type": "conversation.item.truncated",
+                        "item_id": item_id,
+                        "content_index": 0,
+                        "audio_end_ms": committed_audio_ms,
+                        "event": event,
+                    }
+                )
+            payloads.extend(self._realtime_audio_done_events(event, response_id))
+            payloads.extend(
+                self._realtime_response_terminal_events(
+                    event,
+                    response_id,
+                    status="cancelled",
+                    status_details={
+                        "type": "cancelled",
+                        "reason": event.get("reason") or "client_cancelled",
+                    },
+                )
+            )
+            if isinstance(response_id, str) and response_id == self._active_response_id:
+                self._active_response_id = None
+            return payloads
+        if event_type == "playback.acknowledged":
+            return [{"type": "playback.acknowledged", "event": event}]
+        if event_type == "conversation.item.created":
+            item = event.get("item")
+            if isinstance(item, dict) and isinstance(item.get("id"), str):
+                item_id = str(item["id"])
+                already_known = item_id in self._conversation_items
+                self._conversation_items[item_id] = item
+                if already_known:
+                    if item.get("status") == "completed":
+                        return [self._conversation_item_done_event(item)]
+                    return []
+                payloads = self._conversation_item_added_events(item)
+                if item.get("status") == "completed":
+                    payloads.append(self._conversation_item_done_event(item))
+                return payloads
+            return [{"type": "conversation.item.created", "item": item, "event": event}]
+        if event_type == "conversation.item.deleted":
+            item_id = event.get("item_id")
+            if isinstance(item_id, str):
+                self._remove_conversation_item(item_id)
+            return [
+                {
+                    "type": "conversation.item.deleted",
+                    "item_id": item_id,
+                    "event": event,
+                }
+            ]
+        if event_type == "conversation.item.truncated":
+            item_id = event.get("item_id")
+            audio_end_ms = event.get("audio_end_ms")
+            content_index = event.get("content_index", 0)
+            if isinstance(item_id, str):
+                item = self._conversation_items.get(item_id)
+                if item is not None:
+                    self._truncate_realtime_item_content(
+                        item,
+                        content_index=int(content_index) if isinstance(content_index, int | float) else 0,
+                        audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
+                    )
+            return [
+                {
+                    "type": "conversation.item.truncated",
+                    "item_id": item_id,
+                    "content_index": content_index,
+                    "audio_end_ms": audio_end_ms,
+                    "event": event,
+                }
+            ]
+        if event_type == "response.output_item.done":
+            response_id = event.get("response_id")
+            return self._realtime_response_terminal_events(
+                event,
+                response_id,
+                status="completed",
+                status_details={
+                    "type": "completed",
+                    "reason": event.get("finish_reason") or "stop",
+                },
+            )
+        if event_type == "error":
+            raw_error = event.get("error")
+            if isinstance(raw_error, dict):
+                return [event]
+            message = str(raw_error or event.get("message") or "Duplex runtime error")
+            code = str(event.get("code") or "duplex_error")
+            return [self._realtime_error_payload(code, message)]
+        if event_type == "session.closed":
+            return [{"type": "session.closed", "event": event}]
+        return [{"type": f"duplex.{event_type}", "event": event}]
+
+    @staticmethod
+    def _user_item_content_from_duplex_message(message: object) -> list[dict[str, object]]:
+        if not isinstance(message, dict):
+            return [{"type": "input_audio", "transcript": ""}]
+        message_transcript = message.get("transcript")
+        content = message.get("content")
+        if isinstance(content, str):
+            return [{"type": "input_text", "text": content}]
+        if not isinstance(content, list):
+            return [
+                {
+                    "type": "input_audio",
+                    "transcript": message_transcript if isinstance(message_transcript, str) else "",
+                }
+            ]
+        parts: list[dict[str, object]] = []
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            part_type = part.get("type")
+            if part_type in {"text", "input_text"} and isinstance(part.get("text"), str):
+                parts.append({"type": "input_text", "text": part["text"]})
+                continue
+            if part_type == "audio_url":
+                transcript = (
+                    part.get("transcript")
+                    if isinstance(part.get("transcript"), str)
+                    else message_transcript
+                    if isinstance(message_transcript, str)
+                    else ""
+                )
+                parts.append({"type": "input_audio", "transcript": transcript})
+                continue
+            if part_type in {"audio", "input_audio"}:
+                transcript = part.get("transcript") if isinstance(part.get("transcript"), str) else ""
+                parts.append({"type": "input_audio", "transcript": transcript})
+        return parts or [{"type": "input_audio", "transcript": ""}]
+
+    def _realtime_session_payload(self, session: object) -> object:
+        if not isinstance(session, dict):
+            return session
+        payload = dict(session)
+        payload.setdefault("object", "realtime.session")
+        payload.setdefault("type", "realtime")
+        payload.setdefault("id", payload.get("id") or self._default_session_id)
+        payload.setdefault("model", payload.get("model") or self._default_model)
+        payload.setdefault("input_audio_format", self._input_audio_format)
+        payload.setdefault("output_audio_format", self._output_audio_format)
+        payload.setdefault("modalities", payload.get("modalities") or ["text", "audio"])
+        payload.setdefault("output_modalities", payload.get("output_modalities") or payload.get("modalities"))
+        payload.setdefault("object", "realtime.session")
+        payload.setdefault(
+            "audio",
+            {
+                "input": {
+                    "format": self._realtime_audio_format_object(
+                        self._input_audio_format,
+                        sample_rate_hz=self._input_sample_rate_hz,
+                    ),
+                    "sample_rate_hz": self._input_sample_rate_hz,
+                },
+                "output": {
+                    "format": self._realtime_audio_format_object(
+                        self._output_audio_format,
+                        sample_rate_hz=self._output_sample_rate_hz,
+                    ),
+                },
+            },
+        )
+        payload.setdefault("turn_detection", payload.get("turn_detection"))
+        payload.setdefault("input_audio_transcription", payload.get("input_audio_transcription"))
+        payload.setdefault("tracing", payload.get("tracing"))
+        return payload
+
+    @staticmethod
+    def _realtime_audio_format_object(fmt: object, *, sample_rate_hz: int | None = None) -> dict[str, object]:
+        if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le", "pcm"}:
+            payload: dict[str, object] = {"type": "audio/pcm"}
+        elif isinstance(fmt, str) and fmt.lower() == "pcm_f32le":
+            payload = {"type": "audio/pcm_f32le"}
+        elif isinstance(fmt, str) and fmt.lower() == "g711_ulaw":
+            payload = {"type": "audio/g711_ulaw"}
+        elif isinstance(fmt, str) and fmt.lower() == "g711_alaw":
+            payload = {"type": "audio/g711_alaw"}
+        else:
+            payload = {"type": "audio/wav"}
+        if sample_rate_hz is not None:
+            payload["rate"] = int(sample_rate_hz)
+        return payload
+
+    def _response_state(
+        self,
+        response_id: object,
+        *,
+        event: dict[str, Any] | None = None,
+        create: bool = True,
+    ) -> _RealtimeResponseState | None:
+        if isinstance(response_id, str) and response_id:
+            key: str | int = response_id
+            item_id = f"item_{response_id}"
+        elif event is not None:
+            key = id(event)
+            item_id = f"item_{uuid4().hex}"
+        else:
+            return None
+        state = self._response_states.get(key)
+        if state is None and create:
+            state = _RealtimeResponseState(item_id=item_id)
+            self._response_states[key] = state
+        return state
+
+    def _response_is_done(self, response_id: object) -> bool:
+        state = self._response_state(response_id, create=False)
+        return state is not None and state.done_emitted
+
+    def _response_item_id(self, response_id: object) -> str:
+        state = self._response_state(response_id)
+        if state is not None:
+            return state.item_id
+        return f"item_{uuid4().hex}"
+
+    def _response_done_output_item(
+        self,
+        response_id: object,
+        *,
+        status: str,
+    ) -> dict[str, object]:
+        item_id = self._response_item_id(response_id)
+        state = self._response_state(response_id)
+        transcript = state.transcript if state is not None else ""
+        text = state.text if state is not None else ""
+        audio_duration_ms = state.audio_duration_ms if state is not None else None
+        audio_text_marks = state.audio_text_marks if state is not None else None
+        content: list[dict[str, object]] = []
+        if (state is not None and state.audio_part_added) or transcript or audio_duration_ms is not None:
+            content.append(
+                self._response_item_content_part(
+                    transcript=transcript,
+                    audio_duration_ms=audio_duration_ms,
+                    audio_text_marks=audio_text_marks,
+                )
+            )
+        if text:
+            content.append(self._response_item_text_content_part(text=text))
+        item = {
+            "id": item_id,
+            "object": "realtime.item",
+            "type": "message",
+            "role": "assistant",
+            "status": status,
+            "content": content,
+        }
+        self._apply_pending_item_truncation(item)
+        return item
+
+    def _apply_pending_item_truncation(self, item: dict[str, object]) -> None:
+        item_id = item.get("id")
+        if not isinstance(item_id, str) or not item_id:
+            return
+        cursor = self._item_truncation_cursors.get(item_id)
+        if cursor is None:
+            return
+        content_index, audio_end_ms = cursor
+        self._truncate_realtime_item_content(
+            item,
+            content_index=content_index,
+            audio_end_ms=audio_end_ms,
+        )
+
+    def _refresh_in_progress_response_item(self, response_id: object) -> None:
+        if not isinstance(response_id, str) or not response_id:
+            return
+        item_id = self._response_item_id(response_id)
+        item = self._conversation_items.get(item_id)
+        if not isinstance(item, dict):
+            return
+        content = item.get("content")
+        if not isinstance(content, list):
+            content = []
+            item["content"] = content
+
+        state = self._response_state(response_id)
+        if state is None:
+            return
+        transcript = state.transcript
+        audio_duration_ms = state.audio_duration_ms
+        audio_text_marks = state.audio_text_marks
+        has_audio = state.audio_part_added or bool(transcript) or audio_duration_ms is not None
+        if has_audio:
+            audio_part = self._response_item_content_part(
+                transcript=transcript,
+                audio_duration_ms=audio_duration_ms,
+                audio_text_marks=audio_text_marks,
+            )
+            if content and isinstance(content[0], dict) and content[0].get("type") in {"audio", "output_audio"}:
+                content[0] = audio_part
+            else:
+                content.insert(0, audio_part)
+
+        text = state.text
+        if text:
+            text_index = (
+                1
+                if content
+                and isinstance(content[0], dict)
+                and content[0].get("type")
+                in {
+                    "audio",
+                    "output_audio",
+                }
+                else 0
+            )
+            text_part = self._response_item_text_content_part(text=text)
+            if (
+                len(content) > text_index
+                and isinstance(content[text_index], dict)
+                and content[text_index].get("type") in {"text", "output_text"}
+            ):
+                content[text_index] = text_part
+            else:
+                content.insert(text_index, text_part)
+
+        self._apply_pending_item_truncation(item)
+
+    def _append_response_transcript(self, response_id: object, text: str) -> None:
+        state = self._response_state(response_id)
+        if state is None or not text:
+            return
+        state.transcript_parts.append(text)
+
+    def _ensure_response_text_part_added(self, response_id: object) -> list[dict[str, object]]:
+        state = self._response_state(response_id)
+        if state is None:
+            return []
+        if state.text_part_added:
+            return []
+        state.text_part_added = True
+        content_index = 1 if state.audio_part_added else 0
+        return [
+            {
+                "type": "response.content_part.added",
+                "response_id": response_id,
+                "item_id": self._response_item_id(response_id),
+                "output_index": 0,
+                "content_index": content_index,
+                "part": self._response_text_content_part(),
+            }
+        ]
+
+    def _ensure_response_audio_part_added(self, response_id: object) -> list[dict[str, object]]:
+        state = self._response_state(response_id)
+        if state is None:
+            return []
+        if state.audio_part_added:
+            return []
+        state.audio_part_added = True
+        return [
+            {
+                "type": "response.content_part.added",
+                "response_id": response_id,
+                "item_id": self._response_item_id(response_id),
+                "output_index": 0,
+                "content_index": 0,
+                "part": self._response_content_part(),
+            }
+        ]
+
+    def _remember_response_audio_metadata(self, response_id: object, event: dict[str, Any]) -> None:
+        state = self._response_state(response_id)
+        if state is None:
+            return
+        duration = event.get("audio_duration_ms")
+        playback = event.get("playback")
+        if not isinstance(duration, int | float) and isinstance(playback, dict):
+            duration = playback.get("sent_ms") or playback.get("generated_ms")
+        if isinstance(duration, int | float):
+            state.audio_duration_ms = max(state.audio_duration_ms or 0, int(duration))
+        marks = event.get("audio_text_marks")
+        if not isinstance(marks, list):
+            return
+        clean_marks: list[dict[str, int]] = []
+        for mark in marks:
+            if not isinstance(mark, dict):
+                continue
+            text_chars = mark.get("text_chars")
+            audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
+            if not isinstance(text_chars, int | float) or not isinstance(audio_end_ms, int | float):
+                continue
+            clean_marks.append(
+                {
+                    "text_chars": max(0, int(text_chars)),
+                    "audio_end_ms": max(0, int(audio_end_ms)),
+                }
+            )
+        if clean_marks:
+            merged = list(state.audio_text_marks)
+            merged.extend(clean_marks)
+            deduped: dict[tuple[int, int], dict[str, int]] = {}
+            for mark in merged:
+                deduped[(int(mark["audio_end_ms"]), int(mark["text_chars"]))] = mark
+            state.audio_text_marks = sorted(
+                deduped.values(),
+                key=lambda mark: (mark["audio_end_ms"], mark["text_chars"]),
+            )
+
+    def _response_created_event(self, event: dict[str, Any]) -> dict[str, object]:
+        response_id = event.get("response_id")
+        metadata = event.get("metadata")
+        if not isinstance(metadata, dict):
+            metadata = {}
+        metadata = {**metadata, "duplex_event": event}
+        return {
+            "type": "response.created",
+            "response_id": response_id,
+            "response": {
+                "id": response_id,
+                "object": "realtime.response",
+                "status": "in_progress",
+                "status_details": None,
+                "output": [],
+                "modalities": event.get("modalities") or ["audio", "text"],
+                "metadata": metadata,
+            },
+        }
+
+    def _realtime_audio_delta_events(
+        self,
+        event: dict[str, Any],
+        response_id: object,
+        audio: str,
+    ) -> list[dict[str, object]]:
+        item_id = self._response_item_id(response_id)
+        fmt, format_rate = self._parse_realtime_audio_format(event.get("format", "wav"))
+        source_fmt = self._realtime_output_format(fmt)
+        source_sample_rate_hz = event.get("sample_rate_hz") or format_rate
+        target_sample_rate_hz = (
+            self._output_sample_rate_hz if self._output_audio_format in {"g711_ulaw", "g711_alaw"} else None
+        )
+        audio, fmt, converted_sample_rate_hz = convert_output_audio(
+            audio,
+            source_fmt=source_fmt,
+            target_fmt=self._output_audio_format,
+            source_sample_rate_hz=(
+                int(source_sample_rate_hz) if isinstance(source_sample_rate_hz, int | float) else None
+            ),
+            target_sample_rate_hz=target_sample_rate_hz,
+        )
+        sample_rate_hz = (
+            converted_sample_rate_hz
+            if fmt in {"g711_ulaw", "g711_alaw"}
+            else event.get("sample_rate_hz") or format_rate or self._output_sample_rate_hz
+        )
+        metadata: dict[str, object] = {}
+        for key in ("session_id", "epoch", "model_speak", "end_of_turn", "playback", "vllm_omni"):
+            if key in event:
+                metadata[key] = event[key]
+        duration_ms = event.get("audio_duration_ms")
+        if isinstance(duration_ms, int | float):
+            metadata["audio_duration_ms"] = int(duration_ms)
+        marks = event.get("audio_text_marks")
+        if isinstance(marks, list):
+            metadata["audio_text_marks"] = marks
+        state = self._response_state(response_id)
+        if state is not None:
+            state.audio_delta_emitted = True
+            self._remember_response_audio_metadata(response_id, event)
+        payloads: list[dict[str, object]] = []
+        if state is not None and not state.speak_emitted and metadata.get("model_speak") is True:
+            state.speak_emitted = True
+            payloads.insert(
+                0,
+                {
+                    "type": "response.speak",
+                    "response_id": response_id,
+                    "item_id": item_id,
+                    "output_index": 0,
+                    "content_index": 0,
+                    "metadata": self._response_speak_metadata(event),
+                },
+            )
+        payloads.append(
+            {
+                "type": "response.audio.delta",
+                "response_id": response_id,
+                "item_id": item_id,
+                "output_index": 0,
+                "content_index": 0,
+                "delta": audio,
+                "format": fmt,
+                **({"sample_rate_hz": int(sample_rate_hz)} if isinstance(sample_rate_hz, int | float) else {}),
+                **({"metadata": metadata} if metadata else {}),
+            }
+        )
+        return payloads
+
+    @staticmethod
+    def _response_speak_metadata(event: dict[str, Any]) -> dict[str, object]:
+        return {key: event[key] for key in ("session_id", "epoch", "model_speak") if key in event}
+
+    def _realtime_audio_done_events(
+        self,
+        event: dict[str, Any],
+        response_id: object,
+    ) -> list[dict[str, object]]:
+        item_id = self._response_item_id(response_id)
+        state = self._response_state(response_id, event=event)
+        transcript = state.transcript if state is not None else ""
+        payloads: list[dict[str, object]] = []
+        if isinstance(response_id, str) and state is not None and not state.audio_delta_emitted and not transcript:
+            return payloads
+        if state is None or not state.audio_done_emitted:
+            if state is not None:
+                state.audio_done_emitted = True
+            payloads.append(
+                {
+                    "type": "response.audio.done",
+                    "response_id": response_id,
+                    "item_id": item_id,
+                    "output_index": 0,
+                    "content_index": 0,
+                }
+            )
+            if transcript:
+                payloads.append(
+                    {
+                        "type": "response.audio_transcript.done",
+                        "response_id": response_id,
+                        "item_id": item_id,
+                        "output_index": 0,
+                        "content_index": 0,
+                        "transcript": transcript,
+                    }
+                )
+        return payloads
+
+    def _realtime_response_terminal_events(
+        self,
+        event: dict[str, Any],
+        response_id: object,
+        *,
+        status: str = "completed",
+        status_details: dict[str, object] | None = None,
+    ) -> list[dict[str, object]]:
+        item_id = self._response_item_id(response_id)
+        state = self._response_state(response_id, event=event)
+        transcript = state.transcript if state is not None else ""
+        payloads: list[dict[str, object]] = []
+        if state is not None and state.audio_part_added and not state.audio_part_done:
+            state.audio_part_done = True
+            payloads.append(
+                {
+                    "type": "response.content_part.done",
+                    "response_id": response_id,
+                    "item_id": item_id,
+                    "output_index": 0,
+                    "content_index": 0,
+                    "part": self._response_content_part(transcript=transcript),
+                }
+            )
+        if state is not None and state.text_parts and not state.output_text_done:
+            state.output_text_done = True
+            content_index = 1 if state.audio_part_added else 0
+            payloads.append(
+                {
+                    "type": "response.output_text.done",
+                    "response_id": response_id,
+                    "item_id": item_id,
+                    "output_index": 0,
+                    "content_index": content_index,
+                    "text": state.text,
+                }
+            )
+        if state is not None and state.text_parts and not state.text_part_done:
+            state.text_part_done = True
+            content_index = 1 if state.audio_part_added else 0
+            payloads.append(
+                {
+                    "type": "response.content_part.done",
+                    "response_id": response_id,
+                    "item_id": item_id,
+                    "output_index": 0,
+                    "content_index": content_index,
+                    "part": self._response_text_content_part(text=state.text),
+                }
+            )
+        if state is None or not state.output_item_done:
+            if state is not None:
+                state.output_item_done = True
+            item = self._response_done_output_item(response_id, status=status)
+            payloads.append(
+                {
+                    "type": "response.output_item.done",
+                    "response_id": response_id,
+                    "output_index": 0,
+                    "item": item,
+                }
+            )
+            if state is None or not state.conversation_item_done:
+                if state is not None:
+                    state.conversation_item_done = True
+                payloads.append(self._conversation_item_done_event(item))
+        done_event = self._realtime_response_done_event(
+            {**event, "response_id": response_id},
+            state=state,
+            status=status,
+            status_details=status_details,
+        )
+        if done_event is not None:
+            payloads.append(done_event)
+            payloads.append(self._rate_limits_updated_event())
+            if isinstance(response_id, str) and response_id == self._active_response_id:
+                self._active_response_id = None
+        return payloads
+
+    def _realtime_response_done_event(
+        self,
+        event: dict[str, Any],
+        *,
+        state: _RealtimeResponseState | None = None,
+        status: str = "completed",
+        status_details: dict[str, object] | None = None,
+    ) -> dict[str, object] | None:
+        response_id = event.get("response_id")
+        if state is None:
+            state = self._response_state(response_id, event=event)
+        if state is not None:
+            if state.done_emitted:
+                return None
+            state.done_emitted = True
+        return {
+            "type": "response.done",
+            "response_id": response_id,
+            "response": {
+                "id": response_id,
+                "object": "realtime.response",
+                "status": status,
+                "status_details": status_details,
+                "output": [self._response_done_output_item(response_id, status=status)],
+                "metadata": event,
+            },
+        }
+
+    @staticmethod
+    def _rate_limits_updated_event() -> dict[str, object]:
+        # vLLM-Omni does not yet expose a Realtime-specific quota budget. Emit
+        # the terminal event with an empty list so clients that sequence on
+        # rate_limits.updated do not need a private vLLM branch.
+        return {"type": "rate_limits.updated", "rate_limits": []}
diff --git a/vllm_omni/experimental/fullduplex/openai/realtime_session.py b/vllm_omni/experimental/fullduplex/openai/realtime_session.py
new file mode 100644
index 000000000..519c071cf
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/realtime_session.py
@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from uuid import uuid4
+
+from fastapi import WebSocket
+
+from vllm_omni.experimental.fullduplex.openai import realtime_state as _state
+from vllm_omni.experimental.fullduplex.openai.realtime_input import (
+    RealtimeInputTranslator,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_output import (
+    RealtimeOutputProjector,
+)
+
+REALTIME_ERROR_TYPES_BY_CODE = _state.REALTIME_ERROR_TYPES_BY_CODE
+REALTIME_INPUT_AUDIO_FORMATS = _state.REALTIME_INPUT_AUDIO_FORMATS
+REALTIME_OUTPUT_AUDIO_FORMATS = _state.REALTIME_OUTPUT_AUDIO_FORMATS
+RealtimeSessionState = _state.RealtimeSessionState
+_RealtimeResponseState = _state._RealtimeResponseState
+
+
+class NativeRealtimeSessionProtocol(
+    RealtimeInputTranslator,
+    RealtimeOutputProjector,
+    _state.RealtimeStateOwner,
+):
+    """Compatibility facade for one native Realtime protocol session.
+
+    Input translation, output projection, and mutable state have separate
+    owners. The facade retains the established import path and private helper
+    surface used by serving and protocol contract tests.
+    """
+
+    def __init__(self, query_params: Any) -> None:
+        self._state = RealtimeSessionState.from_query_params(query_params)
+
+    def bind_sender(self, send_realtime_json) -> None:
+        self._send_realtime_json = send_realtime_json
+
+    def _default_session_payload(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "model": self._default_model,
+            "session_id": self._default_session_id,
+        }
+        if self._default_extra_body:
+            payload["extra_body"] = dict(self._default_extra_body)
+        return payload
+
+    async def receive_internal_event_text(self, websocket: WebSocket) -> str:
+        if not self._pending_outbound.empty():
+            return json.dumps(await self._pending_outbound.get())
+        if not self._opened and not self._resume_only and not self._autostarted_default_session and self._default_model:
+            self._opened = True
+            self._autostarted_default_session = True
+            return json.dumps(self._session_create_from_realtime(self._default_session_payload()))
+        while True:
+            if not self._pending_outbound.empty():
+                return json.dumps(await self._pending_outbound.get())
+            raw = await websocket.receive_text()
+            try:
+                event = json.loads(raw)
+            except json.JSONDecodeError:
+                return raw
+            if not isinstance(event, dict):
+                return raw
+            if not self._opened and event.get("type") == "session.resume":
+                self._opened = True
+                translated = await self._to_duplex_event(event)
+                if translated is None:
+                    if not self._pending_outbound.empty():
+                        return json.dumps(await self._pending_outbound.get())
+                    continue
+                return json.dumps(translated)
+            if not self._opened and self._resume_only:
+                translated = await self._to_duplex_event(event)
+                if translated is None:
+                    if not self._pending_outbound.empty():
+                        return json.dumps(await self._pending_outbound.get())
+                    continue
+                return json.dumps(translated)
+            if not self._opened and event.get("type") != "session.update":
+                self._opened = True
+                await self._pending_outbound.put(self._session_create_from_realtime(self._default_session_payload()))
+                translated = await self._to_duplex_event(event)
+                if translated is not None:
+                    await self._send_realtime_input_ack(event)
+                    await self._pending_outbound.put(translated)
+                return json.dumps(await self._pending_outbound.get())
+            translated = await self._to_duplex_event(event)
+            if translated is None:
+                if not self._pending_outbound.empty():
+                    return json.dumps(await self._pending_outbound.get())
+                continue
+            await self._send_realtime_input_ack(event)
+            return json.dumps(translated)
+
+    def encode_outbound_event(self, data: dict[str, Any]) -> list[dict[str, object]]:
+        payloads = self._from_duplex_event(data)
+        for payload in payloads:
+            self._attach_event_id(payload)
+        return payloads
+
+    @staticmethod
+    def _attach_event_id(payload: dict[str, object]) -> None:
+        payload.setdefault("event_id", f"event_{uuid4().hex}")
+
+    async def _send_realtime_payload(self, payload: dict[str, object]) -> None:
+        self._attach_event_id(payload)
+        if (
+            self._hold_realtime_output_until_session_created
+            and payload.get("type") != "error"
+            and payload.get("type") != "session.created"
+        ):
+            self._held_realtime_payloads.append(payload)
+            return
+        if self._send_realtime_json is None:
+            raise RuntimeError("Native Realtime sender is not bound")
+        await self._send_realtime_json(payload)
+
+    @staticmethod
+    def _realtime_error_payload(
+        code: str,
+        message: str,
+        *,
+        event_id: object | None = None,
+        param: object | None = None,
+    ) -> dict[str, object]:
+        error: dict[str, object] = {
+            "type": REALTIME_ERROR_TYPES_BY_CODE.get(code, "invalid_request_error"),
+            "code": code,
+            "message": message,
+        }
+        if isinstance(event_id, str) and event_id:
+            error["event_id"] = event_id
+        if isinstance(param, str) and param:
+            error["param"] = param
+        return {"type": "error", "error": error}
diff --git a/vllm_omni/experimental/fullduplex/openai/realtime_state.py b/vllm_omni/experimental/fullduplex/openai/realtime_state.py
new file mode 100644
index 000000000..ac3b2a8de
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/realtime_state.py
@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar
+
+REALTIME_INPUT_AUDIO_FORMATS = {
+    "pcm16",
+    "pcm_s16le",
+    "s16le",
+    "pcm_f32le",
+    "g711_ulaw",
+    "g711_alaw",
+}
+REALTIME_OUTPUT_AUDIO_FORMATS = {
+    "pcm16",
+    "pcm_s16le",
+    "s16le",
+    "wav",
+    "pcm",
+    "g711_ulaw",
+    "g711_alaw",
+}
+REALTIME_ERROR_TYPES_BY_CODE = {
+    "bad_event": "invalid_request_error",
+    "bad_audio": "invalid_request_error",
+    "config_timeout": "invalid_request_error",
+    "invalid_json": "invalid_request_error",
+    "event_too_large": "invalid_request_error",
+    "unknown_event": "invalid_request_error",
+    "internal_error": "server_error",
+    "runtime_open_failed": "server_error",
+    "runtime_open_unsupported": "server_error",
+    "runtime_append_failed": "server_error",
+    "runtime_append_task_failed": "server_error",
+    "runtime_signal_failed": "server_error",
+    "runtime_close_failed": "server_error",
+    "runtime_abort_failed": "server_error",
+    "runtime_data_plane_stream_failed": "server_error",
+    "runtime_data_plane_text_without_audio": "server_error",
+    "response_error": "server_error",
+    "chat_error": "server_error",
+    "duplex_session_busy": "rate_limit_error",
+    "resource_exhausted": "rate_limit_error",
+    "response_already_active": "invalid_request_error",
+    "response_not_active": "invalid_request_error",
+    "response_create_without_input": "invalid_request_error",
+    "input_audio_buffer_empty": "invalid_request_error",
+    "missing_item_id": "invalid_request_error",
+    "item_not_found": "invalid_request_error",
+    "unsupported_audio_format": "invalid_request_error",
+    "unsupported_ref_audio_path": "invalid_request_error",
+    "ref_audio_required": "invalid_request_error",
+    "model_update_unsupported": "invalid_request_error",
+    "voice_update_after_audio_unsupported": "invalid_request_error",
+    "ref_audio_update_unsupported": "invalid_request_error",
+    "native_text_append_unsupported": "invalid_request_error",
+    "runtime_native_stage_role_required": "server_error",
+    "runtime_native_runner_kv_required": "server_error",
+}
+
+
+@dataclass(slots=True)
+class _RealtimeResponseState:
+    item_id: str
+    transcript_parts: list[str] = field(default_factory=list)
+    text_parts: list[str] = field(default_factory=list)
+    audio_duration_ms: int | None = None
+    audio_text_marks: list[dict[str, int]] = field(default_factory=list)
+    audio_delta_emitted: bool = False
+    audio_done_emitted: bool = False
+    audio_part_added: bool = False
+    audio_part_done: bool = False
+    text_part_added: bool = False
+    text_part_done: bool = False
+    output_text_done: bool = False
+    output_item_done: bool = False
+    conversation_item_done: bool = False
+    speak_emitted: bool = False
+    done_emitted: bool = False
+
+    @property
+    def transcript(self) -> str:
+        return "".join(self.transcript_parts)
+
+    @property
+    def text(self) -> str:
+        return "".join(self.text_parts)
+
+
+@dataclass(slots=True)
+class RealtimeSessionState:
+    """Single mutable authority for one Realtime protocol session."""
+
+    _opened: bool = False
+    _autostarted_default_session: bool = False
+    _resume_only: bool = False
+    _pending_outbound: asyncio.Queue[dict[str, object]] = field(default_factory=asyncio.Queue)
+    _held_realtime_payloads: list[dict[str, object]] = field(default_factory=list)
+    _hold_realtime_output_until_session_created: bool = True
+    _default_model: object | None = None
+    _default_session_id: object | None = None
+    _default_extra_body: dict[str, object] = field(default_factory=dict)
+    _input_audio_format: str = "pcm16"
+    _input_sample_rate_hz: int = 16000
+    _output_audio_format: str = "pcm16"
+    _overlap_silence_rms: float = 0.003
+    _send_realtime_json: Any = None
+    _initial_session_update: bool = False
+    _input_speech_started: bool = False
+    _response_states: dict[str | int, _RealtimeResponseState] = field(default_factory=dict)
+    _item_truncation_cursors: dict[str, tuple[int, int]] = field(default_factory=dict)
+    _active_response_id: str | None = None
+    _last_response_id: str | None = None
+    _conversation_items: dict[str, dict[str, object]] = field(default_factory=dict)
+    _pending_commit_item_ids: asyncio.Queue[str] = field(default_factory=asyncio.Queue)
+    _last_conversation_item_id: str | None = None
+    _output_sample_rate_hz: int | None = None
+    _active_input_item_id: str | None = None
+    _input_audio_buffer_has_audio: bool = False
+    _input_audio_buffer_had_non_speech: bool = False
+    _input_audio_buffer_transcript_parts: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_query_params(cls, query_params: Any) -> RealtimeSessionState:
+        if hasattr(query_params, "query_params"):
+            query_params = query_params.query_params
+        getter = query_params.get if hasattr(query_params, "get") else None
+        native_duplex = getter("minicpmo45_native_duplex") if getter is not None else None
+        resume_only = getter("resume") if getter is not None else None
+        autostart = getter("autostart") if getter is not None else None
+        default_extra_body = {}
+        if str(native_duplex).strip().lower() in {"1", "true", "yes", "on"}:
+            default_extra_body["minicpmo45_native_duplex"] = True
+        return cls(
+            _resume_only=(
+                str(resume_only).strip().lower() in {"1", "true", "yes", "on"}
+                or str(autostart).strip().lower() in {"0", "false", "no", "off"}
+            ),
+            _default_model=getter("model") if getter is not None else None,
+            _default_session_id=(getter("session_id") if getter is not None else None),
+            _default_extra_body=default_extra_body,
+        )
+
+
+_StateValue = TypeVar("_StateValue")
+
+
+class _RealtimeStateField(Generic[_StateValue]):
+    """Explicit descriptor binding one protocol attribute to session state."""
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        del owner
+        self._name = name
+
+    def __get__(self, instance: Any, owner: type | None = None) -> _StateValue | _RealtimeStateField[_StateValue]:
+        del owner
+        if instance is None:
+            return self
+        return getattr(instance._state, self._name)
+
+    def __set__(self, instance: Any, value: _StateValue) -> None:
+        setattr(instance._state, self._name, value)
+
+
+class RealtimeStateOwner:
+    """Declare the mutable state surface shared by input/output projectors."""
+
+    _state: RealtimeSessionState
+    _opened: bool = _RealtimeStateField()
+    _autostarted_default_session: bool = _RealtimeStateField()
+    _resume_only: bool = _RealtimeStateField()
+    _pending_outbound: asyncio.Queue[dict[str, object]] = _RealtimeStateField()
+    _held_realtime_payloads: list[dict[str, object]] = _RealtimeStateField()
+    _hold_realtime_output_until_session_created: bool = _RealtimeStateField()
+    _default_model: object | None = _RealtimeStateField()
+    _default_session_id: object | None = _RealtimeStateField()
+    _default_extra_body: dict[str, object] = _RealtimeStateField()
+    _input_audio_format: str = _RealtimeStateField()
+    _input_sample_rate_hz: int = _RealtimeStateField()
+    _output_audio_format: str = _RealtimeStateField()
+    _overlap_silence_rms: float = _RealtimeStateField()
+    _send_realtime_json: Any = _RealtimeStateField()
+    _initial_session_update: bool = _RealtimeStateField()
+    _input_speech_started: bool = _RealtimeStateField()
+    _response_states: dict[str | int, _RealtimeResponseState] = _RealtimeStateField()
+    _item_truncation_cursors: dict[str, tuple[int, int]] = _RealtimeStateField()
+    _active_response_id: str | None = _RealtimeStateField()
+    _last_response_id: str | None = _RealtimeStateField()
+    _conversation_items: dict[str, dict[str, object]] = _RealtimeStateField()
+    _pending_commit_item_ids: asyncio.Queue[str] = _RealtimeStateField()
+    _last_conversation_item_id: str | None = _RealtimeStateField()
+    _output_sample_rate_hz: int | None = _RealtimeStateField()
+    _active_input_item_id: str | None = _RealtimeStateField()
+    _input_audio_buffer_has_audio: bool = _RealtimeStateField()
+    _input_audio_buffer_had_non_speech: bool = _RealtimeStateField()
+    _input_audio_buffer_transcript_parts: list[str] = _RealtimeStateField()
diff --git a/vllm_omni/experimental/fullduplex/openai/runtime_adapter.py b/vllm_omni/experimental/fullduplex/openai/runtime_adapter.py
new file mode 100644
index 000000000..f88cffd3b
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/runtime_adapter.py
@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Iterable, Mapping, MutableMapping
+from importlib import import_module
+from typing import Any, Protocol
+
+
+class ServingRuntimeConfigError(ValueError):
+    """A model serving plugin rejected client-visible runtime configuration."""
+
+    def __init__(self, message: str, *, code: str = "invalid_duplex_runtime_config") -> None:
+        super().__init__(message)
+        self.code = code
+
+
+class PcmAppendReservation(Protocol):
+    operation_id: str
+    payload: dict[str, object] | None
+
+    @property
+    def active(self) -> bool: ...
+
+    @property
+    def byte_count(self) -> int: ...
+
+    def commit(self) -> None: ...
+
+    def rollback(self) -> None: ...
+
+
+class PcmAppendBuffer(Protocol):
+    @property
+    def pending_byte_count(self) -> int: ...
+
+    def clear(self) -> None: ...
+
+    def clear_force_listen(self) -> None: ...
+
+    def has_pending(self) -> bool: ...
+
+    def has_reserved(self) -> bool: ...
+
+    def prepare_append(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+        allow_emit: bool,
+    ) -> PcmAppendReservation | None: ...
+
+    def prepare_commit(
+        self,
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+    ) -> PcmAppendReservation: ...
+
+    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None: ...
+
+
+class ServingRuntimeSessionState(Protocol):
+    audio_buffer: PcmAppendBuffer
+    input_since_commit: bool
+    speech_since_commit: bool
+    committed_audio_payload: dict[str, object] | None
+    committed_audio_operation_id: str | None
+    committed_audio_reserved_bytes: int
+    deferred_response_create: bool
+    deferred_precreate_response: bool
+    data_plane_task: asyncio.Task[None] | None
+    data_plane_restart_requested: bool
+    continuation_owner_id: str | None
+    continuation_units: int
+    pending_silence_task: asyncio.Task[bool] | None
+    pending_silence_owner_id: str | None
+    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | None
+
+    def retain_committed_audio(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str | None,
+        reserved_bytes: int = 0,
+    ) -> None: ...
+
+    def clear_committed_audio(self) -> int: ...
+
+    def clear_continuation(self) -> None: ...
+
+
+class RuntimeDataPlane(Protocol):
+    def begin_request(self, request_id: str) -> None: ...
+
+    def is_terminal(self, request_id: str | None) -> bool: ...
+
+    def mark_terminal(self, request_id: str) -> None: ...
+
+    def close_stream(self, request_id: str) -> None: ...
+
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None: ...
+
+    def project(self, result: object, *, context: object | None = None) -> Iterable[dict[str, object]]: ...
+
+
+class ServingRuntimeAdapter(Protocol):
+    adapter_id: str
+    session_states: MutableMapping[str, ServingRuntimeSessionState]
+    data_plane: RuntimeDataPlane
+    clean_response_done_prefix: str
+    interrupted_tts_prefix: str
+    private_runtime_config_keys: frozenset[str]
+
+    def create_session_state(self) -> ServingRuntimeSessionState: ...
+
+    def session_state(self, session_id: str) -> ServingRuntimeSessionState: ...
+
+    def remove_session_state(self, session_id: str) -> None: ...
+
+    def is_enabled(self, config: object) -> bool: ...
+
+    def capabilities(self, *, max_sessions: int) -> object: ...
+
+    def validate_client_extra_body(self, extra_body: object) -> None: ...
+
+    async def prepare_runtime_config(self, config: object, *, model_config: Any) -> dict[str, object]: ...
+
+    def runtime_config_for_update(
+        self,
+        config: object,
+        current: Mapping[str, object],
+    ) -> dict[str, object]: ...
+
+    def data_plane_context(
+        self,
+        *,
+        epoch: int,
+        turn_id: int,
+        active_response_turn_id: int | None,
+        active_response_id: str | None,
+        auto_responds: bool,
+        response_format: str,
+        speed: float | None,
+        modalities: tuple[str, ...],
+    ) -> object: ...
+
+
+def load_serving_runtime_adapter(
+    path: str,
+    encode_audio,
+) -> ServingRuntimeAdapter:
+    module_name, separator, attribute_name = path.rpartition(".")
+    if not separator:
+        raise ValueError(f"Invalid duplex serving runtime adapter path: {path!r}")
+    adapter_type = getattr(import_module(module_name), attribute_name)
+    return validate_serving_runtime_adapter(adapter_type(encode_audio))
+
+
+def validate_serving_runtime_adapter(adapter: object) -> ServingRuntimeAdapter:
+    required_methods = (
+        "create_session_state",
+        "session_state",
+        "remove_session_state",
+        "is_enabled",
+        "capabilities",
+        "validate_client_extra_body",
+        "prepare_runtime_config",
+        "runtime_config_for_update",
+        "data_plane_context",
+    )
+    missing = [name for name in required_methods if not callable(getattr(adapter, name, None))]
+    if missing:
+        raise TypeError(f"Duplex serving runtime adapter is missing callable method(s): {', '.join(missing)}")
+    if not isinstance(getattr(adapter, "adapter_id", None), str) or not adapter.adapter_id:
+        raise TypeError("Duplex serving runtime adapter must declare adapter_id")
+    if not isinstance(getattr(adapter, "session_states", None), MutableMapping):
+        raise TypeError("Duplex serving runtime adapter must declare mutable session_states")
+    for prefix_name in ("clean_response_done_prefix", "interrupted_tts_prefix"):
+        if not isinstance(getattr(adapter, prefix_name, None), str):
+            raise TypeError(f"Duplex serving runtime adapter must declare {prefix_name}")
+    private_keys = getattr(adapter, "private_runtime_config_keys", None)
+    if not isinstance(private_keys, frozenset) or any(not isinstance(key, str) for key in private_keys):
+        raise TypeError("Duplex serving runtime adapter must declare private_runtime_config_keys as frozenset[str]")
+    data_plane = getattr(adapter, "data_plane", None)
+    if data_plane is None:
+        raise TypeError("Duplex serving runtime adapter must declare data_plane")
+    data_plane_methods = (
+        "begin_request",
+        "is_terminal",
+        "mark_terminal",
+        "close_stream",
+        "close_session",
+        "project",
+    )
+    missing_data_plane_methods = [name for name in data_plane_methods if not callable(getattr(data_plane, name, None))]
+    if missing_data_plane_methods:
+        raise TypeError(
+            "Duplex serving runtime adapter data_plane is missing callable method(s): "
+            + ", ".join(missing_data_plane_methods)
+        )
+    return adapter  # type: ignore[return-value]
+
+
+def payload_turn_id(payload: object) -> int | None:
+    if not isinstance(payload, Mapping):
+        return None
+    return coerce_int(payload.get("duplex_turn_id", payload.get("model_turn_id")))
+
+
+def coerce_int(value: object) -> int | None:
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
diff --git a/vllm_omni/experimental/fullduplex/openai/runtime_bridge.py b/vllm_omni/experimental/fullduplex/openai/runtime_bridge.py
new file mode 100644
index 000000000..258f512b6
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/runtime_bridge.py
@@ -0,0 +1,1311 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import inspect
+from collections.abc import Mapping
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+
+import numpy as np
+from vllm.logger import init_logger
+
+from vllm_omni.experimental.fullduplex.engine.duplex_control_client import DuplexControlRequestError
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import duplex_data_plane_request_info
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexSession,
+    DuplexSessionState,
+)
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    coerce_int,
+    payload_turn_id,
+)
+
+logger = init_logger(__name__)
+
+
+class NativeRuntimeBridgeMixin:
+    """Bridge serving sessions to native runtime control and data-plane APIs."""
+
+    _NATIVE_RUNTIME_FENCE_CONTRACT = {
+        "open_duplex_session_async": ("fence",),
+        "append_duplex_input_async": ("fence",),
+        "signal_duplex_turn_async": ("fence", "next_fence"),
+        "close_duplex_session_async": ("fence",),
+    }
+
+    async def _open_runtime_session(self, session: DuplexSession, send_json) -> dict[str, object] | bool:
+        contract_error = self._native_runtime_contract_error(session)
+        if contract_error is not None:
+            await send_json(
+                {
+                    "type": "error",
+                    "code": "runtime_contract_invalid",
+                    "error": contract_error,
+                }
+            )
+            return False
+        open_session = getattr(self._chat_service.engine_client, "open_duplex_session_async", None)
+        if not callable(open_session):
+            return True
+        try:
+            open_kwargs = {
+                "session_mode": "duplex",
+                "capabilities": session.capabilities.as_dict(),
+                "session_config": session.config.as_dict(),
+                "timeout": self._runtime_control_timeout_s(session),
+            }
+            if self._callable_accepts_keyword(open_session, "runtime_config"):
+                open_kwargs["runtime_config"] = dict(session.runtime_config)
+            if self._callable_accepts_keyword(open_session, "fence"):
+                open_kwargs["fence"] = DuplexFence(
+                    session.session_id,
+                    epoch=session.epoch,
+                    turn_id=session.turn_id,
+                    incarnation=session.incarnation,
+                )
+            result = await open_session(session.session_id, **open_kwargs)
+        except Exception as exc:
+            if isinstance(exc, DuplexControlRequestError) and exc.code == "resource_exhausted":
+                logger.info("Duplex runtime session admission rejected: %s", exc)
+            else:
+                logger.exception("Failed to open duplex runtime session: %s", exc)
+            await self._send_runtime_error(send_json, "runtime_open_failed", exc, session=session)
+            return False
+        if (
+            isinstance(result, dict)
+            and session.capabilities.implementation_level == "model_native_duplex"
+            and self._runtime_control_failed(result)
+        ):
+            await send_json(
+                {
+                    "type": "error",
+                    "error": "Native duplex runtime is not available for this session",
+                    "code": ("runtime_open_unsupported" if result.get("unsupported_count") else "runtime_open_failed"),
+                    "runtime_control": self._redact_runtime_control_result(result),
+                }
+            )
+            return False
+        return result if isinstance(result, dict) else True
+
+    async def _append_runtime_input(
+        self,
+        session: DuplexSession,
+        payload: object,
+        *,
+        operation_id: str | None = None,
+        final: bool,
+        send_json,
+        mode: str = "append_tokens",
+        expected_epoch: int | None = None,
+    ) -> tuple[bool, bool]:
+        if not session.capabilities.supports_input_append:
+            return True, False
+        append_input = getattr(self._chat_service.engine_client, "append_duplex_input_async", None)
+        if not callable(append_input):
+            return True, False
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return True, False
+        try:
+            append_kwargs = {
+                "mode": mode,
+                "payload": payload,
+                "final": final,
+                "timeout": self._runtime_control_timeout_s(session),
+            }
+            if operation_id is not None and self._callable_accepts_keyword(append_input, "operation_id"):
+                append_kwargs["operation_id"] = operation_id
+            if expected_epoch is not None and self._callable_accepts_keyword(append_input, "expected_epoch"):
+                append_kwargs["expected_epoch"] = expected_epoch
+            if self._callable_accepts_keyword(append_input, "fence"):
+                payload_turn = payload_turn_id(payload)
+                append_kwargs["fence"] = DuplexFence(
+                    session.session_id,
+                    epoch=session.epoch,
+                    turn_id=(
+                        payload_turn
+                        if payload_turn is not None
+                        else (
+                            session.active_response_turn_id
+                            if session.active_response_turn_id is not None
+                            else session.turn_id
+                        )
+                    ),
+                    incarnation=session.incarnation,
+                )
+            if self._callable_accepts_keyword(append_input, "collect_outputs"):
+                append_kwargs["collect_outputs"] = False
+            result = await append_input(session.session_id, **append_kwargs)
+        except Exception as exc:
+            logger.exception("Failed to append duplex runtime input: %s", exc)
+            await self._send_runtime_error(send_json, "runtime_append_failed", exc, session=session)
+            return False, False
+        if isinstance(result, dict) and self._runtime_control_failed(result):
+            await self._send_runtime_control_error(
+                send_json,
+                "runtime_append_failed",
+                "Duplex runtime append failed",
+                result,
+                session=session,
+            )
+            return False, False
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return True, False
+        await self._send_runtime_control_if_needed(send_json, result, session=session)
+        request_id, _ = self._data_plane_request_info(result) if isinstance(result, dict) else (None, None)
+        if request_id is not None:
+            self._serving_runtime_adapter.data_plane.begin_request(request_id)
+        close_reason, emitted_response = await self._send_native_duplex_events(
+            send_json,
+            result,
+            session=session,
+            expected_epoch=expected_epoch,
+        )
+        # A resumable data-plane append remains active even when its persistent
+        # drain task already exists. Treating only a newly-created drain as
+        # activity clears active_request_id after later appends and prevents a
+        # terminal TTS segment from scheduling the next model decision.
+        emitted_response = emitted_response or request_id is not None
+        if close_reason is None and await self._start_native_data_plane_stream_task(
+            send_json,
+            result,
+            session=session,
+            expected_epoch=expected_epoch,
+        ):
+            emitted_response = True
+        if close_reason is not None:
+            if not await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
+                return False, emitted_response
+            session.close()
+            await send_json(
+                {
+                    "type": "session.closed",
+                    "session_id": session.session_id,
+                    "reason": close_reason,
+                }
+            )
+            return False, emitted_response
+        return True, emitted_response
+
+    @staticmethod
+    def _callable_accepts_keyword(fn, name: str) -> bool:
+        try:
+            params = inspect.signature(fn).parameters.values()
+        except (TypeError, ValueError):
+            return True
+        return any(param.kind == inspect.Parameter.VAR_KEYWORD or param.name == name for param in params)
+
+    def _native_runtime_contract_error(self, session: DuplexSession) -> str | None:
+        if session.capabilities.implementation_level != "model_native_duplex":
+            return None
+        engine_client = self._chat_service.engine_client
+        invalid: list[str] = []
+        for method_name, required_keywords in self._NATIVE_RUNTIME_FENCE_CONTRACT.items():
+            method = getattr(engine_client, method_name, None)
+            if not callable(method):
+                invalid.append(f"{method_name} is missing")
+                continue
+            try:
+                parameters = tuple(inspect.signature(method).parameters.values())
+            except (TypeError, ValueError):
+                invalid.append(f"{method_name} signature is not inspectable")
+                continue
+            accepts_kwargs = any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters)
+            declared = {parameter.name for parameter in parameters}
+            missing = [name for name in required_keywords if not accepts_kwargs and name not in declared]
+            if missing:
+                invalid.append(f"{method_name} is missing keyword(s): {', '.join(missing)}")
+        if not invalid:
+            return None
+        return "Native duplex runtime requires the fenced control contract: " + "; ".join(invalid)
+
+    async def _start_native_data_plane_stream_task(
+        self,
+        send_json,
+        result: object,
+        *,
+        session: DuplexSession,
+        expected_epoch: int | None = None,
+    ) -> bool:
+        request_id, _ = self._data_plane_request_info(result)
+        if request_id is None or self._data_plane_outputs_finished(result):
+            return False
+        session.bind_request(request_id)
+
+        native = self._runtime_session_state(session)
+        old_task = native.data_plane_task
+        if old_task is not None and not old_task.done():
+            if self._session_auto_responds(session):
+                # One persistent drain per session, like the official worker's
+                # single synchronous loop: the resumable data-plane request id
+                # is stable, and cancel/restart on every append orphans any
+                # decision that lands in the swap window.
+                native.data_plane_restart_requested = True
+                return False
+            old_task.cancel()
+            try:
+                await asyncio.wait_for(asyncio.gather(old_task, return_exceptions=True), timeout=0.25)
+            except asyncio.TimeoutError:
+                pass
+
+        async def _run() -> None:
+            close_reason: str | None = None
+            try:
+                close_reason = await self._drain_native_data_plane_stream(
+                    send_json,
+                    result,
+                    session=session,
+                    expected_epoch=expected_epoch,
+                )
+                if close_reason is not None:
+                    if await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
+                        session.close()
+                        await send_json(
+                            {
+                                "type": "session.closed",
+                                "session_id": session.session_id,
+                                "reason": close_reason,
+                            }
+                        )
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                logger.exception("Failed to drain duplex data-plane stream: %s", exc)
+                await self._send_runtime_error(send_json, "runtime_data_plane_stream_failed", exc, session=session)
+                if session.state != DuplexSessionState.CLOSED:
+                    close_reason = "runtime_data_plane_stream_failed"
+                    if await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
+                        session.close()
+                        await send_json(
+                            {
+                                "type": "session.closed",
+                                "session_id": session.session_id,
+                                "reason": close_reason,
+                            }
+                        )
+            finally:
+                if native.data_plane_task is task:
+                    native.data_plane_task = None
+                restart_requested = (
+                    native.data_plane_restart_requested
+                    and close_reason is None
+                    and session.state != DuplexSessionState.CLOSED
+                    and session.active_request_id == request_id
+                    and (expected_epoch is None or session.epoch == expected_epoch)
+                )
+                native.data_plane_restart_requested = False
+                if close_reason is None and not self._session_auto_responds(session):
+                    # Auto-respond sessions keep one resumable stage-1 stream
+                    # whose audio accumulates across speak units; the offset
+                    # must survive drain-task turnover or every unit re-sends
+                    # the reply audio from the start.
+                    self._serving_runtime_adapter.data_plane.close_stream(request_id)
+            if restart_requested:
+                await self._start_native_data_plane_stream_task(
+                    send_json,
+                    result,
+                    session=session,
+                    expected_epoch=expected_epoch,
+                )
+            elif close_reason is None:
+                await self._maybe_continue_native_response(send_json, session=session, expected_epoch=expected_epoch)
+
+        task = asyncio.create_task(_run())
+        native.data_plane_task = task
+        return True
+
+    # One model unit (1 s at 16 kHz) of pcm_f32le silence, matching the
+    # official full-duplex behavior where the microphone keeps streaming
+    # silence while the assistant speaks; replies span multiple units.
+    _NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO = base64.b64encode(bytes(16000 * 4)).decode("ascii")
+    _NATIVE_RESPONSE_MAX_CONTINUATION_UNITS = 8
+
+    def _native_silence_unit_payload(self) -> dict[str, object]:
+        return {
+            "type": "audio",
+            "audio": self._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO,
+            "format": "pcm_f32le",
+            "sample_rate_hz": 16000,
+        }
+
+    def _native_response_continuations_remaining(self, session: DuplexSession, response_id: str) -> bool:
+        if self._session_auto_responds(session):
+            return True
+        native = self._runtime_session_state(session)
+        owner_id = f"response:{response_id}"
+        count = native.continuation_units if native.continuation_owner_id == owner_id else 0
+        return count < self._NATIVE_RESPONSE_MAX_CONTINUATION_UNITS
+
+    def _native_silence_continuation_is_stale(
+        self,
+        session: DuplexSession,
+        *,
+        request_id: str,
+        response_id: str | None,
+        response_owned: bool,
+        expected_epoch: int | None,
+        expected_incarnation: int,
+        expected_model_turn_id: int | None,
+    ) -> bool:
+        stale_common_owner = (
+            session.state == DuplexSessionState.CLOSED
+            or session.incarnation != expected_incarnation
+            or session.active_request_id != request_id
+            or (expected_epoch is not None and session.epoch != expected_epoch)
+        )
+        stale_response_owner = response_owned and session.active_response_id != response_id
+        stale_model_turn_owner = not response_owned and (
+            session.active_response_id is not None or session.turn_id != expected_model_turn_id
+        )
+        return stale_common_owner or stale_response_owner or stale_model_turn_owner
+
+    async def _maybe_continue_native_response(
+        self,
+        send_json,
+        *,
+        session: DuplexSession,
+        expected_epoch: int | None,
+        expected_model_turn_id: int | None = None,
+    ) -> None:
+        """Give an active model turn another silence unit.
+
+        A model turn can need another unit before it has emitted visible
+        text/audio and therefore before a Realtime response exists. Bind that
+        continuation to the model-turn identity; once a response exists, its
+        response/turn ownership remains the continuation fence.
+        """
+        response_id = session.active_response_id
+        native = self._runtime_session_state(session)
+        if session.state == DuplexSessionState.CLOSED:
+            native.clear_continuation()
+            return
+        request_id = session.active_request_id
+        if request_id is None:
+            native.clear_continuation()
+            return
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return
+        auto_response = self._session_auto_responds(session)
+        response_owned = response_id is not None
+        if response_owned:
+            owner_id = f"response:{response_id}"
+            payload_turn_id = (
+                session.active_response_turn_id if session.active_response_turn_id is not None else session.turn_id
+            )
+        else:
+            if not auto_response or expected_model_turn_id is None or session.turn_id != expected_model_turn_id:
+                native.clear_continuation()
+                return
+            owner_id = f"model-turn:{expected_model_turn_id}"
+            payload_turn_id = expected_model_turn_id
+        count = native.continuation_units if native.continuation_owner_id == owner_id else 0
+        if not auto_response and count >= self._NATIVE_RESPONSE_MAX_CONTINUATION_UNITS:
+            return
+        payload = self._native_silence_unit_payload()
+        payload["duplex_turn_id"] = payload_turn_id
+
+        scheduler = native.silence_continuation_scheduler
+        if scheduler is None:
+            return
+        try:
+            scheduled = await scheduler(
+                payload,
+                request_id=request_id,
+                owner_id=owner_id,
+                response_id=response_id,
+                response_owned=response_owned,
+                expected_epoch=expected_epoch,
+                expected_incarnation=session.incarnation,
+                expected_model_turn_id=expected_model_turn_id,
+                send_json=send_json,
+            )
+        except Exception as exc:
+            logger.exception("Failed to schedule duplex native response continuation: %s", exc)
+            scheduled = False
+        if scheduled:
+            native.continuation_owner_id = owner_id
+            native.continuation_units = count + 1
+
+    async def _cancel_native_data_plane_stream(self, session: DuplexSession) -> bool:
+        native = self._runtime_session_state(session)
+        task = native.data_plane_task
+        native.data_plane_task = None
+        native.data_plane_restart_requested = False
+        if task is None or task.done():
+            return False
+        task.cancel()
+        try:
+            await asyncio.wait_for(asyncio.gather(task, return_exceptions=True), timeout=0.25)
+        except asyncio.TimeoutError:
+            # Keep barge-in/cancel responsive. The task still carries the old
+            # expected_epoch and late model output is filtered by the writer.
+            pass
+        return True
+
+    async def _signal_runtime_session(
+        self,
+        session: DuplexSession,
+        event: str,
+        send_json=None,
+        *,
+        fence: DuplexFence | None = None,
+        next_fence: DuplexFence | None = None,
+        session_config: dict[str, object] | None = None,
+        runtime_config: dict[str, object] | None = None,
+    ) -> bool:
+        signal_turn = getattr(self._chat_service.engine_client, "signal_duplex_turn_async", None)
+        if not callable(signal_turn):
+            return True
+        try:
+            signal_kwargs = {
+                "event": event,
+                "timeout": self._runtime_control_timeout_s(session),
+            }
+            if self._callable_accepts_keyword(signal_turn, "fence"):
+                signal_kwargs["fence"] = fence or DuplexFence(
+                    session.session_id,
+                    epoch=session.epoch,
+                    turn_id=session.turn_id,
+                    incarnation=session.incarnation,
+                )
+            if next_fence is not None and self._callable_accepts_keyword(signal_turn, "next_fence"):
+                signal_kwargs["next_fence"] = next_fence
+            if session_config is not None and self._callable_accepts_keyword(signal_turn, "session_config"):
+                signal_kwargs["session_config"] = session_config
+            if runtime_config is not None and self._callable_accepts_keyword(signal_turn, "runtime_config"):
+                signal_kwargs["runtime_config"] = runtime_config
+            result = await signal_turn(session.session_id, **signal_kwargs)
+        except Exception as exc:
+            logger.exception("Failed to signal duplex runtime session: %s", exc)
+            if send_json is not None:
+                await self._send_runtime_error(send_json, "runtime_signal_failed", exc, session=session)
+            return False
+        if isinstance(result, dict) and self._runtime_signal_failed(result):
+            logger.warning(
+                "Duplex runtime signal failed: session=%s event=%s result=%s",
+                session.session_id,
+                event,
+                self._redact_runtime_control_result(result),
+            )
+            if send_json is not None:
+                await self._send_runtime_control_error(
+                    send_json,
+                    "runtime_signal_failed",
+                    "Duplex runtime signal failed",
+                    result,
+                    session=session,
+                )
+            return False
+        await self._send_runtime_control_if_needed(send_json, result, session=session)
+        return True
+
+    async def _close_runtime_session(self, session: DuplexSession, *, reason: str, send_json=None) -> bool:
+        close_session = getattr(self._chat_service.engine_client, "close_duplex_session_async", None)
+        if not callable(close_session):
+            return True
+        try:
+            close_kwargs = {
+                "reason": reason,
+                "timeout": self._runtime_control_timeout_s(session),
+            }
+            if self._callable_accepts_keyword(close_session, "fence"):
+                close_kwargs["fence"] = DuplexFence(
+                    session.session_id,
+                    epoch=session.epoch,
+                    turn_id=session.turn_id,
+                    incarnation=session.incarnation,
+                )
+            result = await close_session(session.session_id, **close_kwargs)
+        except Exception as exc:
+            logger.exception("Failed to close duplex runtime session: %s", exc)
+            if send_json is not None:
+                await self._send_runtime_error(send_json, "runtime_close_failed", exc, session=session)
+            return False
+        if isinstance(result, dict) and self._runtime_control_failed(result):
+            if send_json is not None:
+                await self._send_runtime_control_error(
+                    send_json,
+                    "runtime_close_failed",
+                    "Duplex runtime close failed",
+                    result,
+                    session=session,
+                )
+            return False
+        await self._send_runtime_control_if_needed(send_json, result, session=session)
+        return True
+
+    @staticmethod
+    def _runtime_control_timeout_s(session: DuplexSession) -> float:
+        raw = session.config.extra_body.get("duplex_control_timeout_s") or session.config.extra_body.get(
+            "runtime_control_timeout_s"
+        )
+        if isinstance(raw, int | float) and raw > 0:
+            return float(raw)
+        if session.capabilities.implementation_level == "model_native_duplex":
+            return 60.0
+        return 10.0
+
+    async def _send_runtime_control_if_needed(
+        self,
+        send_json,
+        result: object,
+        *,
+        session: DuplexSession,
+    ) -> None:
+        if send_json is None:
+            return
+        if not isinstance(result, dict):
+            return
+        if not result.get("unsupported_count") and not result.get("error_count"):
+            return
+        await send_json(
+            {
+                "type": "runtime.control",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "result": self._redact_runtime_control_result(result),
+            }
+        )
+
+    @staticmethod
+    def _runtime_control_failed(result: dict[str, object]) -> bool:
+        if result.get("ok") is False:
+            return True
+        for key in ("unsupported_count", "error_count"):
+            value = result.get(key)
+            if isinstance(value, int | float) and value > 0:
+                return True
+        return False
+
+    @classmethod
+    def _runtime_signal_failed(cls, result: dict[str, object]) -> bool:
+        error_count = result.get("error_count")
+        if isinstance(error_count, int | float) and error_count > 0:
+            return True
+        if result.get("ok") is not False:
+            return False
+        return not cls._runtime_signal_has_data_plane_ack(result)
+
+    @classmethod
+    def _runtime_signal_has_data_plane_ack(cls, value: object) -> bool:
+        if isinstance(value, dict):
+            if value.get("data_plane_signal") is True and value.get("supported") is True:
+                return True
+            return any(cls._runtime_signal_has_data_plane_ack(child) for child in value.values())
+        if isinstance(value, list | tuple):
+            return any(cls._runtime_signal_has_data_plane_ack(item) for item in value)
+        return False
+
+    @classmethod
+    def _redact_runtime_control_result(cls, value: object) -> object:
+        if isinstance(value, dict):
+            redacted = {
+                key: cls._redact_runtime_control_result(child)
+                for key, child in value.items()
+                if key
+                not in {
+                    "stage_handoff",
+                    "tts_handoff",
+                    "omni_payload",
+                    "tts_hidden_states",
+                    "tts_token_ids",
+                    "traceback",
+                }
+            }
+            native_result = redacted.get("native_result")
+            if isinstance(native_result, dict):
+                if native_result.get("requires_stage_handoff") is True:
+                    native_result.pop("requires_stage_handoff", None)
+                if native_result.get("requires_tts_stage") is True:
+                    native_result.pop("requires_tts_stage", None)
+            return redacted
+        if isinstance(value, list | tuple):
+            return [cls._redact_runtime_control_result(item) for item in value]
+        if is_dataclass(value) and not isinstance(value, type):
+            # Control results carry typed values straight from the engine:
+            # `fence` and `accepted_fence` are `DuplexFence` instances added by
+            # `DuplexControlClient.execute`. This redacted value is emitted on
+            # the wire (for example `session.created.runtime_control` in
+            # `session_runner`), where `WebSocket.send_json` would raise
+            # `TypeError: Object of type DuplexFence is not JSON serializable`
+            # and kill the session during the handshake.
+            return {key: cls._redact_runtime_control_result(child) for key, child in asdict(value).items()}
+        if isinstance(value, Enum):
+            return value.value
+        return value
+
+    async def _send_native_duplex_events(
+        self,
+        send_json,
+        result: object,
+        *,
+        session: DuplexSession,
+        expected_epoch: int | None = None,
+    ) -> tuple[str | None, bool]:
+        if send_json is None:
+            return None, False
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return None, False
+        close_reason: str | None = None
+        emitted_response = False
+        request_id, _ = self._data_plane_request_info(result)
+        if self._serving_runtime_adapter.data_plane.is_terminal(request_id):
+            return None, False
+        if request_id is not None and session.active_request_id is None:
+            session.bind_request(request_id)
+        context = self._runtime_data_plane_context(session)
+        for native_result in self._serving_runtime_adapter.data_plane.project(result, context=context):
+            close_reason_for_result, did_emit = await self._send_one_native_duplex_event(
+                send_json,
+                native_result,
+                session=session,
+                expected_epoch=expected_epoch,
+            )
+            emitted_response = emitted_response or did_emit
+            close_reason = close_reason or close_reason_for_result
+            if expected_epoch is not None and session.epoch != expected_epoch:
+                return None, emitted_response
+        return close_reason, emitted_response
+
+    async def _drain_native_data_plane_stream(
+        self,
+        send_json,
+        result: object,
+        *,
+        session: DuplexSession,
+        expected_epoch: int | None = None,
+    ) -> str | None:
+        request_id, response_stage_id = self._data_plane_request_info(result)
+        if request_id is None:
+            return None
+        if self._data_plane_outputs_finished(result):
+            return None
+        collect_outputs = getattr(
+            self._chat_service.engine_client,
+            "collect_duplex_data_plane_outputs_async",
+            None,
+        )
+        if not callable(collect_outputs):
+            return None
+
+        close_reason: str | None = None
+        empty_polls = 0
+        while close_reason is None:
+            if self._serving_runtime_adapter.data_plane.is_terminal(request_id):
+                return None
+            if self._session_auto_responds(session):
+                active_request_id = session.active_request_id
+                if active_request_id is not None and active_request_id != request_id:
+                    return None
+            if expected_epoch is not None and session.epoch != expected_epoch:
+                return None
+            if session.state == DuplexSessionState.CLOSED:
+                return None
+            outputs = await collect_outputs(
+                request_id,
+                response_stage_id=response_stage_id,
+                timeout=self._runtime_control_timeout_s(session),
+            )
+            if expected_epoch is not None and session.epoch != expected_epoch:
+                return None
+            if not outputs:
+                # An empty poll means no output arrived within one control
+                # window, not that the stream is over. Exiting here orphans a
+                # decision that lands moments later: it would sit queued until
+                # the NEXT append starts a fresh drain task, adding one full
+                # chunk of latency to every model decision.
+                empty_polls += 1
+                if empty_polls >= 3:
+                    return None
+                continue
+            empty_polls = 0
+            drain_result = {
+                "data_plane_outputs": outputs,
+            }
+            close_reason, emitted_response = await self._send_native_duplex_events(
+                send_json,
+                drain_result,
+                session=session,
+                expected_epoch=expected_epoch,
+            )
+            if (
+                self._data_plane_outputs_finished(drain_result)
+                and emitted_response
+                and not self._session_auto_responds(session)
+            ):
+                # Auto-respond sessions are resumable: every segment ends
+                # with finished=True but the stream continues with the next
+                # audio chunk. Exiting here would make each decision wait for
+                # the next append to start a fresh drain task (one full chunk
+                # of added latency); keep draining until epoch change,
+                # session close, or cancellation by a newer drain task.
+                return close_reason
+            # A batch without a client-visible event (e.g. the generic
+            # stage-0 final-output message that precedes the listen/speak
+            # decision in the same segment) must not terminate the drain;
+            # the real decision is still in flight.
+        return close_reason
+
+    @staticmethod
+    def _data_plane_outputs_finished(result: object) -> bool:
+        if not isinstance(result, dict):
+            return False
+        outputs = result.get("data_plane_outputs")
+        if not isinstance(outputs, list) or not outputs:
+            return False
+        return bool(getattr(outputs[-1], "finished", False))
+
+    @staticmethod
+    def _data_plane_request_info(result: object) -> tuple[str | None, int | None]:
+        if not isinstance(result, dict):
+            return None, None
+        return duplex_data_plane_request_info(result)
+
+    def _runtime_data_plane_context(self, session: DuplexSession) -> object:
+        response_config = session.response_config
+        return self._serving_runtime_adapter.data_plane_context(
+            epoch=session.epoch,
+            turn_id=session.turn_id,
+            active_response_turn_id=session.active_response_turn_id,
+            active_response_id=session.active_response_id,
+            auto_responds=self._session_auto_responds(session),
+            response_format=response_config.response_format,
+            speed=response_config.speed,
+            modalities=tuple(response_config.modalities),
+        )
+
+    async def _send_one_native_duplex_event(
+        self,
+        send_json,
+        native_result: dict[str, object],
+        *,
+        session: DuplexSession,
+        expected_epoch: int | None = None,
+    ) -> tuple[str | None, bool]:
+        close_reason: str | None = None
+        emitted_response = False
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return close_reason, emitted_response
+        data_plane_request_id = native_result.get("data_plane_request_id")
+        if isinstance(data_plane_request_id, str) and self._serving_runtime_adapter.data_plane.is_terminal(
+            data_plane_request_id
+        ):
+            return close_reason, emitted_response
+        active_request_matches = session.active_request_id == data_plane_request_id or (
+            self._session_auto_responds(session) and session.active_request_id is None
+        )
+        if isinstance(data_plane_request_id, str) and not active_request_matches:
+            return close_reason, emitted_response
+        if isinstance(native_result.get("error_code"), str):
+            response_id = session.active_response_id
+            await send_json(
+                {
+                    "type": "error",
+                    "code": native_result.get("error_code"),
+                    "session_id": session.session_id,
+                    "epoch": session.epoch,
+                    "error": str(native_result.get("error") or "Duplex native data-plane error"),
+                }
+            )
+            if response_id is not None:
+                session.end_response(commit_text=False)
+                await send_json(
+                    {
+                        "type": "response.done",
+                        "session_id": session.session_id,
+                        "response_id": response_id,
+                        "epoch": session.epoch,
+                        "committed": False,
+                        "status": "failed",
+                        "status_details": {
+                            "type": "failed",
+                            "reason": native_result.get("error_code"),
+                        },
+                        "playback": session.playback.as_dict(),
+                    }
+                )
+            return close_reason, True
+        if native_result.get("requires_stage_handoff") is True or native_result.get("requires_tts_stage") is True:
+            # Stage0 announces a talker handoff before Stage1 has produced
+            # client-visible audio. A single client input stream may contain
+            # several model turns, including terminal-only turns. Reserve the
+            # protocol response only when Stage1 emits text/audio so empty
+            # model turns cannot create empty responses or steal later audio.
+            return close_reason, False
+        is_listen = native_result.get("is_listen")
+        model_turn_id = coerce_int(native_result.get("model_turn_id"))
+        if native_result.get("is_buffering") is True or native_result.get("prefill_success") is False:
+            if native_result.get("data_plane_request_id") == session.active_request_id:
+                session.clear_request()
+            payload = {
+                "type": "response.listen",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "reason": native_result.get("reason") or "buffering",
+                "model_listen": False,
+                "buffering": True,
+            }
+            self._attach_native_runtime_metadata(payload, native_result)
+            await send_json(payload)
+            return close_reason, emitted_response
+        if is_listen is True:
+            await self._end_active_response_before_future_model_turn(
+                send_json,
+                session=session,
+                model_turn_id=model_turn_id,
+            )
+            if (
+                session.active_response_id is not None
+                and model_turn_id is not None
+                and not session.active_response_accepts_model_turn(model_turn_id)
+            ):
+                return close_reason, emitted_response
+            non_terminal_auto_listen = (
+                self._session_auto_responds(session)
+                and session.active_response_id is not None
+                and session.active_request_id is not None
+                and native_result.get("end_of_turn") is not True
+            )
+            if non_terminal_auto_listen:
+                await self._maybe_continue_native_response(
+                    send_json,
+                    session=session,
+                    expected_epoch=expected_epoch,
+                )
+                return close_reason, emitted_response
+            auto_response = self._session_auto_responds(session)
+            if not auto_response and data_plane_request_id == session.active_request_id:
+                session.clear_request()
+            model_listen = native_result.get("model_listen")
+            if not isinstance(model_listen, bool):
+                model_listen = native_result.get("reason") in {None, "", "model_listen"}
+            response_id = session.active_response_id
+            if isinstance(data_plane_request_id, str) and not auto_response:
+                self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
+            emitted_response = True
+            payload = {
+                "type": "response.listen",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "reason": native_result.get("reason") or "model_listen",
+                "model_listen": model_listen,
+            }
+            self._attach_native_runtime_metadata(payload, native_result)
+            await send_json(payload)
+            if native_result.get("abort_data_plane_request") is True and isinstance(data_plane_request_id, str):
+                await self._abort_request_background(
+                    session,
+                    data_plane_request_id,
+                    send_json,
+                    notify=False,
+                )
+            if response_id is not None:
+                if not self._session_auto_responds(session) and self._native_response_continuations_remaining(
+                    session, response_id
+                ):
+                    # The official model often listens for a silence beat or
+                    # two before answering; keep the response open and give it
+                    # the next silence unit as a decision point.
+                    await self._maybe_continue_native_response(
+                        send_json,
+                        session=session,
+                        expected_epoch=expected_epoch,
+                    )
+                    return close_reason, emitted_response
+                session.end_response(commit_text=False, preserve_request=auto_response)
+                await send_json(
+                    {
+                        "type": "response.done",
+                        "session_id": session.session_id,
+                        "response_id": response_id,
+                        "epoch": session.epoch,
+                        "committed": False,
+                        "playback": session.playback.as_dict(),
+                    }
+                )
+            return close_reason, emitted_response
+
+        text = native_result.get("text")
+        audio = native_result.get("audio_data", native_result.get("audio"))
+        end_of_turn = bool(native_result.get("end_of_turn", False))
+        has_text = isinstance(text, str) and bool(text)
+        has_audio = isinstance(audio, str) and bool(audio)
+        if not has_text and not has_audio and not end_of_turn:
+            tts_segment_ended = (
+                native_result.get("stage_role") == "tts" and native_result.get("abort_data_plane_request") is True
+            )
+            if (
+                tts_segment_ended
+                and self._session_auto_responds(session)
+                and (model_turn_id is not None or session.active_response_id is not None)
+            ):
+                await self._maybe_continue_native_response(
+                    send_json,
+                    session=session,
+                    expected_epoch=expected_epoch,
+                    expected_model_turn_id=model_turn_id,
+                )
+            return close_reason, emitted_response
+        if end_of_turn and not has_text and not has_audio and session.active_response_id is None:
+            if isinstance(data_plane_request_id, str):
+                if not self._session_auto_responds(session) and data_plane_request_id == session.active_request_id:
+                    session.clear_request()
+                if not self._session_auto_responds(session):
+                    self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
+            if model_turn_id is not None:
+                session.complete_model_turn(model_turn_id)
+            if self._session_auto_responds(session):
+                self._runtime_session_state(session).clear_continuation()
+                emitted_response = True
+                payload = {
+                    "type": "response.listen",
+                    "session_id": session.session_id,
+                    "epoch": session.epoch,
+                    "reason": "model_turn_completed_without_output",
+                    "model_listen": True,
+                }
+                self._attach_native_runtime_metadata(payload, native_result)
+                await send_json(payload)
+            return close_reason, emitted_response
+        if session.active_response_id is None and model_turn_id is not None and model_turn_id < session.turn_id:
+            # A continuation append can already be in flight when the prior
+            # response reaches turn EOS.  Its late audio still carries the
+            # completed model turn, so it must not reserve a second Realtime
+            # response for that turn.
+            return close_reason, emitted_response
+        await self._end_active_response_before_future_model_turn(
+            send_json,
+            session=session,
+            model_turn_id=model_turn_id,
+        )
+        if (
+            session.active_response_id is not None
+            and model_turn_id is not None
+            and not session.active_response_accepts_model_turn(model_turn_id)
+        ):
+            return close_reason, emitted_response
+        emitted_response = True
+        response_created = False
+        response_id = session.active_response_id
+        if response_id is None:
+            response_id = session.begin_response(turn_id=model_turn_id)
+            response_created = True
+            await send_json(
+                self._response_created_payload(
+                    session,
+                    response_id,
+                    epoch=session.epoch,
+                )
+            )
+        response_stage_metrics = session.accumulate_response_stage_metrics(
+            native_result.get("stage_metrics") if isinstance(native_result.get("stage_metrics"), Mapping) else None
+        )
+        if response_created:
+            speak_payload = {
+                "type": "response.speak",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": session.epoch,
+                "text": text if isinstance(text, str) else "",
+                "end_of_turn": end_of_turn,
+                "model_speak": True,
+            }
+            self._attach_native_runtime_metadata(
+                speak_payload,
+                native_result,
+                stage_metrics=response_stage_metrics,
+            )
+            await send_json(speak_payload)
+        previous_sent_ms = session.playback.sent_ms
+        text_chars_before_append = len("".join(session.assistant_text_buffer))
+        if isinstance(text, str):
+            session.append_assistant_text(text)
+        duration_ms = native_result.get("audio_duration_ms")
+        text_chars = len("".join(session.assistant_text_buffer))
+        mark_duration_ms = None
+        mark_text_chars: int | None = text_chars
+        if native_result.get("audio_text_mark") is False:
+            mark_text_chars = None
+        if isinstance(duration_ms, int | float):
+            mark_duration_ms = int(duration_ms)
+            if native_result.get("audio_duration_is_cumulative") is not True:
+                mark_duration_ms += session.playback.sent_ms
+        audio_text_marks = native_result.get("audio_text_marks")
+        audio_text_marks = self._normalize_native_audio_text_marks(
+            audio_text_marks if isinstance(audio_text_marks, list) else None,
+            audio_offset_ms=(
+                0
+                if native_result.get("audio_text_marks_are_cumulative") is True
+                or native_result.get("audio_duration_is_cumulative") is True
+                else previous_sent_ms
+            ),
+            text_offset_chars=(
+                0 if native_result.get("audio_text_marks_are_cumulative") is True else text_chars_before_append
+            ),
+        )
+        session.mark_audio_sent(
+            mark_duration_ms,
+            text_chars=mark_text_chars if mark_duration_ms is not None else None,
+            audio_text_marks=audio_text_marks,
+        )
+        payload = {
+            "type": "response.output_audio.delta",
+            "session_id": session.session_id,
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "text": text if isinstance(text, str) else "",
+            "audio": audio if isinstance(audio, str) else "",
+            "format": (
+                native_result.get("audio_format")
+                if isinstance(native_result.get("audio_format"), str)
+                else session.response_config.response_format
+            ),
+            "end_of_turn": end_of_turn,
+            "model_speak": True,
+        }
+        if mark_duration_ms is not None:
+            payload["audio_duration_ms"] = mark_duration_ms
+        if audio_text_marks:
+            payload["audio_text_marks"] = audio_text_marks
+        elif mark_duration_ms is not None and mark_text_chars is not None:
+            payload["audio_text_marks"] = [
+                {
+                    "text_chars": max(0, int(mark_text_chars)),
+                    "audio_end_ms": max(0, int(mark_duration_ms)),
+                }
+            ]
+        payload["playback"] = session.playback.as_dict()
+        sample_rate_hz = native_result.get("sample_rate_hz") or native_result.get("audio_sample_rate_hz")
+        if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) > 0:
+            payload["sample_rate_hz"] = int(sample_rate_hz)
+        self._attach_native_runtime_metadata(
+            payload,
+            native_result,
+            stage_metrics=response_stage_metrics,
+        )
+        await send_json(payload)
+        if (
+            not end_of_turn
+            and native_result.get("stage_role") == "tts"
+            and native_result.get("abort_data_plane_request") is True
+            and self._session_auto_responds(session)
+        ):
+            await self._maybe_continue_native_response(
+                send_json,
+                session=session,
+                expected_epoch=expected_epoch,
+            )
+        if end_of_turn:
+            data_plane_request_id = native_result.get("data_plane_request_id")
+            if isinstance(data_plane_request_id, str) and not self._session_auto_responds(session):
+                self._serving_runtime_adapter.data_plane.close_stream(data_plane_request_id)
+            if isinstance(data_plane_request_id, str):
+                if not self._session_auto_responds(session) and data_plane_request_id == session.active_request_id:
+                    session.clear_request()
+                if not self._session_auto_responds(session):
+                    self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
+            should_commit = self._should_commit_response_to_history(session, response_id)
+            committed_message = session.end_response(
+                commit_text=should_commit,
+                preserve_request=self._session_auto_responds(session),
+            )
+            model_turn_id = coerce_int(native_result.get("model_turn_id"))
+            if model_turn_id is not None:
+                session.complete_model_turn(model_turn_id)
+            if should_commit:
+                session.register_history_item(f"item_{response_id}", committed_message)
+            await send_json(
+                {
+                    "type": "response.done",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": session.epoch,
+                    "committed": committed_message is not None,
+                    "playback": session.playback.as_dict(),
+                }
+            )
+        return close_reason, emitted_response
+
+    async def _end_active_response_before_future_model_turn(
+        self,
+        send_json,
+        *,
+        session: DuplexSession,
+        model_turn_id: int | None,
+    ) -> None:
+        if not self._session_auto_responds(session):
+            return
+        response_id = session.active_response_id
+        active_turn_id = session.active_response_turn_id
+        if response_id is None or model_turn_id is None or active_turn_id is None:
+            return
+        if int(model_turn_id) <= int(active_turn_id):
+            return
+        session.complete_model_turn(int(model_turn_id) - 1)
+        should_commit = self._should_commit_response_to_history(session, response_id)
+        committed_message = session.end_response(
+            commit_text=should_commit,
+            preserve_request=True,
+        )
+        if should_commit:
+            session.register_history_item(f"item_{response_id}", committed_message)
+        await send_json(
+            {
+                "type": "response.done",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": session.epoch,
+                "committed": committed_message is not None,
+                "playback": session.playback.as_dict(),
+            }
+        )
+
+    @staticmethod
+    def _normalize_native_audio_text_marks(
+        audio_text_marks: list[object] | None,
+        *,
+        audio_offset_ms: int,
+        text_offset_chars: int,
+    ) -> list[dict[str, int]] | None:
+        if not audio_text_marks:
+            return None
+        normalized: list[dict[str, int]] = []
+        for raw_mark in audio_text_marks:
+            if not isinstance(raw_mark, dict):
+                continue
+            raw_text_chars = raw_mark.get("text_chars")
+            raw_audio_end_ms = raw_mark.get("audio_end_ms", raw_mark.get("audio_ms"))
+            if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
+                continue
+            normalized.append(
+                {
+                    "text_chars": max(0, int(raw_text_chars) + int(text_offset_chars)),
+                    "audio_end_ms": max(0, int(raw_audio_end_ms) + int(audio_offset_ms)),
+                }
+            )
+        return normalized or None
+
+    def _cleanup_duplex_session_state(self, session: DuplexSession) -> None:
+        session_id = session.session_id
+        self._serving_runtime_adapter.remove_session_state(session_id)
+        self._serving_runtime_adapter.data_plane.close_session(
+            session_id,
+            active_request_id=session.active_request_id,
+        )
+
+    def _encode_native_data_plane_audio(
+        self,
+        audio_data: object,
+        sample_rate_hz: int,
+        response_format: str,
+        speed: float | None,
+    ) -> str | None:
+        if audio_data is None:
+            return None
+        try:
+            import torch
+
+            from vllm_omni.entrypoints.openai.protocol.audio import CreateAudio
+
+            if isinstance(audio_data, torch.Tensor):
+                audio_tensor = audio_data.detach().cpu().float().numpy()
+            else:
+                audio_tensor = np.asarray(audio_data, dtype=np.float32)
+            if audio_tensor.ndim > 1:
+                audio_tensor = audio_tensor.reshape(-1)
+            audio_response = self._chat_service.create_audio(
+                CreateAudio(
+                    audio_tensor=audio_tensor,
+                    sample_rate=sample_rate_hz,
+                    response_format=response_format,
+                    speed=float(speed) if isinstance(speed, int | float) and speed > 0 else 1.0,
+                    stream_format="audio",
+                    base64_encode=True,
+                )
+            )
+            return str(audio_response.audio_data)
+        except Exception:
+            logger.exception("Failed to encode duplex data-plane audio output")
+            return None
+
+    @staticmethod
+    def _attach_native_runtime_metadata(
+        payload: dict[str, object],
+        native_result: dict[str, object],
+        *,
+        stage_metrics: Mapping[str, object] | None = None,
+    ) -> None:
+        metadata: dict[str, object] = {}
+        runtime_impl = native_result.get("runtime_impl")
+        if isinstance(runtime_impl, str) and runtime_impl:
+            metadata["runtime_impl"] = runtime_impl
+        owned_runtime = native_result.get("owned_runtime")
+        if isinstance(owned_runtime, bool):
+            metadata["owned_runtime"] = owned_runtime
+        model_turn_id = coerce_int(native_result.get("model_turn_id"))
+        if model_turn_id is not None:
+            metadata["model_turn_id"] = model_turn_id
+        for name in (
+            "uses_model_runner_scheduler",
+            "runner_kv_backed",
+        ):
+            value = native_result.get(name)
+            if isinstance(value, bool):
+                metadata[name] = value
+        effective_stage_metrics = stage_metrics if stage_metrics is not None else native_result.get("stage_metrics")
+        if isinstance(effective_stage_metrics, Mapping):
+            metadata["stage_metrics"] = {
+                str(stage_id): dict(values)
+                for stage_id, values in effective_stage_metrics.items()
+                if isinstance(values, Mapping)
+            }
+        if metadata:
+            payload["vllm_omni"] = metadata
+
+    async def _send_runtime_error(
+        self,
+        send_json,
+        code: str,
+        exc: Exception,
+        *,
+        session: DuplexSession | None = None,
+    ) -> None:
+        retryable = False
+        message = str(exc)
+        if isinstance(exc, DuplexControlRequestError):
+            code = exc.code
+            retryable = exc.retryable
+            error_data = exc.result.get("error")
+            if isinstance(error_data, dict) and isinstance(error_data.get("message"), str):
+                message = error_data["message"]
+        payload: dict[str, object] = {
+            "type": "error",
+            "code": code,
+            "error": message,
+            "retryable": retryable,
+        }
+        if session is not None:
+            payload["session_id"] = session.session_id
+            payload["epoch"] = session.epoch
+        await send_json(payload)
+
+    async def _send_runtime_control_error(
+        self,
+        send_json,
+        code: str,
+        message: str,
+        result: dict[str, object],
+        *,
+        session: DuplexSession,
+    ) -> None:
+        await send_json(
+            {
+                "type": "error",
+                "code": code,
+                "error": message,
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "runtime_control": self._redact_runtime_control_result(result),
+            }
+        )
diff --git a/vllm_omni/experimental/fullduplex/openai/serving.py b/vllm_omni/experimental/fullduplex/openai/serving.py
new file mode 100644
index 000000000..3ce23ea8b
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/serving.py
@@ -0,0 +1,1764 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import binascii
+import inspect
+import json
+from collections.abc import Mapping
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import numpy as np
+from fastapi import WebSocket
+from vllm.logger import init_logger
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.entrypoints.openai.duplex_capability import (
+    should_enable_duplex_endpoint,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import duplex_resource_request_id
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence, DuplexSessionLifecycleMessage
+from vllm_omni.experimental.fullduplex.openai.chat_fallback import (
+    ChatFallbackProjectorMixin,
+)
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexCapabilities,
+    DuplexCommittedInput,
+    DuplexOverlapPolicy,
+    DuplexPlaybackCommitPolicy,
+    DuplexSession,
+    DuplexSessionConfig,
+    DuplexSessionRegistry,
+    DuplexSessionState,
+    DuplexTurnController,
+    ResponseCreateOptions,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_session import (
+    REALTIME_OUTPUT_AUDIO_FORMATS,
+    NativeRealtimeSessionProtocol,
+)
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    ServingRuntimeAdapter,
+    ServingRuntimeConfigError,
+    ServingRuntimeSessionState,
+    load_serving_runtime_adapter,
+    validate_serving_runtime_adapter,
+)
+from vllm_omni.experimental.fullduplex.openai.runtime_bridge import (
+    NativeRuntimeBridgeMixin,
+)
+from vllm_omni.experimental.fullduplex.openai.session_attachment import (
+    DuplexJournalGapError,
+    DuplexSessionAttachmentRegistry,
+    InvalidResumeTokenError,
+)
+from vllm_omni.experimental.fullduplex.openai.session_runner import (
+    DuplexSessionRunnerMixin,
+)
+from vllm_omni.experimental.fullduplex.openai.websocket import (
+    DOMAIN_TERMINAL_EVENTS,
+    DuplexSessionTasks,
+    DuplexWebSocketActor,
+)
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+logger = init_logger(__name__)
+
+__all__ = ["OmniDuplexSessionHandler", "should_enable_duplex_endpoint"]
+
+_DEFAULT_CONFIG_TIMEOUT_S = 10.0
+_DEFAULT_IDLE_TIMEOUT_S = 300.0
+
+
+@dataclass(frozen=True)
+class _DuplexSessionHandshake:
+    session: DuplexSession
+    resumed: bool = False
+    attachment_generation: int | None = None
+
+
+class OmniDuplexSessionHandler(
+    DuplexSessionRunnerMixin,
+    NativeRuntimeBridgeMixin,
+    ChatFallbackProjectorMixin,
+):
+    """WebSocket handler for RFC-style full-duplex session control.
+
+    This owns the serving-side session actor, ordered inbound mailbox,
+    barge-in epoch, turn controller, and playback commit state. Generic sessions
+    can still fall back to chat requests, while MiniCPM-o 4.5 native sessions
+    route audio appends through scheduler data-plane stage requests. It
+    deliberately does not claim core persistent KV lease support.
+    """
+
+    def __init__(
+        self,
+        *,
+        chat_service: OmniOpenAIServingChat,
+        config_timeout_s: float = _DEFAULT_CONFIG_TIMEOUT_S,
+        idle_timeout_s: float = _DEFAULT_IDLE_TIMEOUT_S,
+        duplex_session_config: DuplexSessionRuntimeConfig | None = None,
+        serving_runtime_adapter: ServingRuntimeAdapter | None = None,
+        serving_runtime_adapter_path: str | None = None,
+    ) -> None:
+        self._chat_service = chat_service
+        self._config_timeout_s = config_timeout_s
+        self._idle_timeout_s = idle_timeout_s
+        self._duplex_session_config = duplex_session_config or DuplexSessionRuntimeConfig()
+        self._registry = DuplexSessionRegistry(
+            DuplexCapabilities(
+                supports_model_native_turn_policy=False,
+                supports_input_append=False,
+                supports_replace_latest_chunk=True,
+                supports_reencode_context=True,
+                supports_turn_commit_only=True,
+                supports_kv_lease=False,
+            )
+        )
+        self._turn_controller = DuplexTurnController()
+        adapter_path = serving_runtime_adapter_path or getattr(
+            chat_service,
+            "duplex_serving_adapter_path",
+            None,
+        )
+        if serving_runtime_adapter is not None:
+            self._serving_runtime_adapter = validate_serving_runtime_adapter(serving_runtime_adapter)
+        elif isinstance(adapter_path, str) and adapter_path:
+            self._serving_runtime_adapter = load_serving_runtime_adapter(
+                adapter_path,
+                self._encode_native_data_plane_audio,
+            )
+        else:
+            raise ValueError("A duplex serving runtime adapter must be explicitly configured")
+        self._session_tasks: dict[str, DuplexSessionTasks] = {}
+        self._realtime_protocols: dict[str, NativeRealtimeSessionProtocol] = {}
+        self._lease_generations: dict[str, int] = {}
+        self._resync_required_sessions: set[str] = set()
+        self._lifecycle_queue = getattr(self._chat_service.engine_client, "duplex_lifecycle_events", None)
+        self._lifecycle_task: asyncio.Task[None] | None = None
+        self._attachment_registry = DuplexSessionAttachmentRegistry(
+            replay_ttl_s=self._duplex_session_config.resume_replay_ttl_s,
+            replay_max_bytes_per_session=self._duplex_session_config.resume_replay_max_bytes_per_session,
+            disconnect_grace_s=self._duplex_session_config.disconnect_grace_s,
+        )
+
+    async def handle_realtime_session(self, websocket: WebSocket) -> None:
+        await self.handle_session(
+            websocket,
+            realtime_protocol=NativeRealtimeSessionProtocol(websocket.query_params),
+        )
+
+    def _ensure_lifecycle_listener(self) -> None:
+        if not isinstance(self._lifecycle_queue, asyncio.Queue):
+            return
+        if self._lifecycle_task is None or self._lifecycle_task.done():
+            self._lifecycle_task = asyncio.create_task(
+                self._run_lifecycle_listener(),
+                name="duplex-serving-lifecycle",
+            )
+
+    async def _run_lifecycle_listener(self) -> None:
+        queue = self._lifecycle_queue
+        if not isinstance(queue, asyncio.Queue):
+            return
+        try:
+            while True:
+                message = await queue.get()
+                try:
+                    if isinstance(message, DuplexSessionLifecycleMessage):
+                        await self._apply_runtime_lifecycle(message)
+                finally:
+                    queue.task_done()
+                if self._registry.active_count() == 0:
+                    return
+        finally:
+            if self._lifecycle_task is asyncio.current_task():
+                self._lifecycle_task = None
+
+    async def _apply_runtime_lifecycle(self, message: DuplexSessionLifecycleMessage) -> None:
+        session = self._registry.get(message.session_id)
+        if session is None:
+            return
+        fence = message.fence
+        if (
+            fence.session_id != session.session_id
+            or fence.incarnation != session.incarnation
+            or fence.epoch < session.epoch
+        ):
+            return
+        current_generation = self._lease_generations.get(session.session_id, 0)
+        if message.lease_generation < current_generation:
+            return
+        protocol = self._realtime_protocols.get(session.session_id)
+        expired_payload: dict[str, object] = {
+            "type": "session.expired",
+            "session_id": session.session_id,
+            "incarnation": session.incarnation,
+            "reason": message.reason,
+        }
+        if protocol is not None:
+            expired_payload = protocol.encode_outbound_event(expired_payload)[0]
+        with suppress(Exception):
+            await self._attachment_registry.send_event(
+                session.session_id,
+                expired_payload,
+                journal=False,
+            )
+
+        tasks = self._session_tasks.pop(session.session_id, None)
+        if tasks is not None:
+            await tasks.cancel_append_tasks()
+            active_response_task = tasks.active_response_task
+            if active_response_task is not None and not active_response_task.done():
+                active_response_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await active_response_task
+        native = self._serving_runtime_adapter.session_states.get(session.session_id)
+        if native is not None and native.data_plane_task is not None:
+            data_plane_task = native.data_plane_task
+            native.data_plane_task = None
+            data_plane_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await data_plane_task
+        if session.active_response_id is not None:
+            session.end_response(commit_text=False)
+        self._cleanup_duplex_session_state(session)
+        self._registry.close(session.session_id)
+        self._realtime_protocols.pop(session.session_id, None)
+        self._lease_generations.pop(session.session_id, None)
+        self._resync_required_sessions.discard(session.session_id)
+        attachment = await self._attachment_registry.close(session.session_id)
+        if attachment is not None:
+            with suppress(Exception):
+                await attachment.close("session_expired")
+
+    def _stop_lifecycle_listener_if_idle(self) -> None:
+        task = self._lifecycle_task
+        if self._registry.active_count() != 0 or task is None or task.done():
+            return
+        if task is not asyncio.current_task():
+            task.cancel()
+            self._lifecycle_task = None
+
+    @staticmethod
+    def _native_audio_payload_size_bytes(payload: Mapping[str, object]) -> int:
+        audio = payload.get("audio") or payload.get("data")
+        if not isinstance(audio, str):
+            return 0
+        try:
+            return len(base64.b64decode(audio, validate=True))
+        except (ValueError, binascii.Error):
+            return 0
+
+    async def _apply_outbound_session_event(
+        self,
+        payload: dict[str, object],
+        *,
+        session: DuplexSession | None,
+        actor: DuplexWebSocketActor,
+        native: ServingRuntimeSessionState,
+        realtime_protocol: NativeRealtimeSessionProtocol | None,
+    ) -> tuple[bool, dict[str, object] | None]:
+        """Apply domain transitions before an event is queued for transport."""
+        payload_type = payload.get("type")
+        is_terminal = payload_type in DOMAIN_TERMINAL_EVENTS
+        if is_terminal and session is not None:
+            payload_epoch = payload.get("epoch")
+            if isinstance(payload_epoch, int) and payload_epoch != session.epoch:
+                return False, None
+            if payload_type in {"response.done", "response.listen"} and (
+                actor.closing or session.state == DuplexSessionState.CLOSED
+            ):
+                return False, None
+        elif actor._is_stale_model_output(payload):
+            return False, None
+
+        if payload_type == "session.closed":
+            actor.close_reason = actor.close_reason or str(payload.get("reason") or "closed")
+            if session is not None:
+                session.mark_closing()
+
+        if not is_terminal or session is None:
+            return True, None
+
+        terminal_status = payload.get("status")
+        terminal_status_details = payload.get("status_details")
+        if terminal_status is None and isinstance(terminal_status_details, dict):
+            terminal_status = terminal_status_details.get("type")
+        response_terminal = payload_type == "response.done" or (
+            payload_type == "response.listen" and session.active_response_id is not None
+        )
+        can_promote_overlap = response_terminal and terminal_status not in {"cancelled", "failed"}
+        deferred_overlap_payload: dict[str, object] | None = None
+        continuous_input_crosses_terminal = (
+            can_promote_overlap
+            and realtime_protocol is not None
+            and self._session_auto_responds(session)
+            and native.input_since_commit
+            and not native.deferred_response_create
+        )
+        if continuous_input_crosses_terminal:
+            # Auto-response is a model-owned continuous stream. A response
+            # terminal advances the model turn without requiring the browser
+            # to close its Realtime input item. Keep any partial model unit so
+            # later PCM can complete it. Serving does not create or promote a
+            # new model generation here; Stage0 advances generation identity
+            # only after the model's terminal token.
+            session.reset_overlap_speech()
+            return True, None
+        realtime_input_still_open = (
+            can_promote_overlap
+            and realtime_protocol is not None
+            and native.input_since_commit
+            and not native.deferred_response_create
+        )
+        if realtime_input_still_open:
+            # response.done only closes the assistant response. It does not
+            # close the current Realtime input item, and it does not reserve
+            # or advance a model generation.
+            session.reset_overlap_speech()
+            return True, None
+        if can_promote_overlap and session.overlap_speech_ms > 0:
+            has_deferred_overlap = native.audio_buffer.has_pending() or native.committed_audio_payload is not None
+            should_promote_overlap = (
+                session.state == DuplexSessionState.OPEN
+                and self._uses_native_input_append(session)
+                and has_deferred_overlap
+                and session.overlap_speech_ms > session.config.overlap_short_ack_ms
+            )
+            if should_promote_overlap:
+                flushed_reserved_bytes = native.audio_buffer.pending_byte_count
+                deferred_overlap_payload = native.audio_buffer.flush(
+                    chunk_period_ms=session.capabilities.chunk_period_ms or 1000
+                )
+                if native.committed_audio_payload is not None:
+                    if deferred_overlap_payload is not None:
+                        deferred_overlap_payload = self._merge_native_audio_payloads(
+                            native.committed_audio_payload,
+                            deferred_overlap_payload,
+                        )
+                    else:
+                        deferred_overlap_payload = native.committed_audio_payload
+                if self._session_auto_responds(session) and deferred_overlap_payload is not None:
+                    deferred_overlap_payload = dict(deferred_overlap_payload)
+                    deferred_overlap_payload["force_listen"] = False
+                if deferred_overlap_payload is not None:
+                    native.retain_committed_audio(
+                        deferred_overlap_payload,
+                        operation_id=native.committed_audio_operation_id,
+                        reserved_bytes=flushed_reserved_bytes,
+                    )
+                native.input_since_commit = deferred_overlap_payload is not None
+                if realtime_protocol is not None:
+                    native.deferred_response_create = True
+                    native.deferred_precreate_response = False
+                    deferred_overlap_payload = None
+            else:
+                had_pending_overlap_audio = native.audio_buffer.has_pending()
+                native.audio_buffer.clear()
+                native.input_since_commit = False
+                native.speech_since_commit = False
+                if had_pending_overlap_audio and realtime_protocol is not None:
+                    await realtime_protocol.discard_pending_input_audio(audio_end_ms=session.overlap_speech_ms)
+                if payload_type in {"audio.cancelled", "input.cancelled", "session.closed"}:
+                    session.release_input_bytes(native.clear_committed_audio())
+
+        session.reset_overlap_speech()
+        if can_promote_overlap and native.deferred_response_create and native.committed_audio_payload is not None:
+            deferred_overlap_payload = native.committed_audio_payload
+            native.deferred_response_create = False
+            native.input_since_commit = False
+            native.speech_since_commit = False
+        return True, deferred_overlap_payload
+
+    @staticmethod
+    def _advance_barge_in_epoch(session: DuplexSession) -> tuple[int, dict[str, int]]:
+        old_playback = session.playback.as_dict()
+        new_epoch = session.barge_in()
+        session.clear_playback_cursor()
+        return new_epoch, old_playback
+
+    @staticmethod
+    def _commit_played_response_history(
+        session: DuplexSession,
+        response_id: str | None,
+        committed_ms: int,
+    ) -> None:
+        if not response_id or committed_ms < 0:
+            return
+        session.truncate_history_item(
+            f"item_{response_id}",
+            audio_end_ms=committed_ms,
+            playback=session.playback_for_response(response_id),
+        )
+
+    @staticmethod
+    def _should_commit_response_to_history(session: DuplexSession, response_id: str | None) -> bool:
+        if response_id is not None and response_id != session.active_response_id:
+            return True
+        mode = session.response_config.extra_body.get("realtime_response_conversation")
+        return not isinstance(mode, str) or mode.strip().lower() != "none"
+
+    def _response_created_payload(
+        self,
+        session: DuplexSession,
+        response_id: str,
+        *,
+        epoch: int,
+        request_id: str | None = None,
+    ) -> dict[str, object]:
+        response_config = session.response_config
+        payload: dict[str, object] = {
+            "type": "response.created",
+            "session_id": session.session_id,
+            "response_id": response_id,
+            "epoch": epoch,
+            "modalities": list(response_config.modalities),
+        }
+        if request_id is not None:
+            payload["request_id"] = request_id
+        metadata = response_config.extra_body.get("realtime_response_metadata")
+        if not isinstance(metadata, dict):
+            metadata = response_config.extra_body.get("realtime_metadata")
+        if isinstance(metadata, dict):
+            payload["metadata"] = dict(metadata)
+        conversation = response_config.extra_body.get("realtime_response_conversation")
+        if isinstance(conversation, str):
+            payload["conversation"] = conversation
+        prompt = response_config.extra_body.get("realtime_response_prompt")
+        if isinstance(prompt, dict):
+            payload["prompt"] = dict(prompt)
+        return payload
+
+    def _overlap_decision(
+        self,
+        session: DuplexSession,
+        event: dict[str, object],
+        payload: dict[str, object],
+    ) -> dict[str, object]:
+        """Classify input that arrives while assistant audio is active.
+
+        This is a serving-side policy. The model still owns listen/speak
+        decisions for normal chunks; overlap policy only decides whether the
+        current assistant response should be interrupted before the new audio is
+        appended.
+        """
+        duration_ms = self._input_audio_duration_ms(event, payload)
+        is_speech = self._input_looks_like_speech(event, payload, session=session)
+        if not session.capabilities.supports_barge_in and self._event_requests_barge_in(event):
+            return self._defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=is_speech)
+        explicit = event.get("overlap_action") or event.get("overlap")
+        if isinstance(explicit, str):
+            normalized = explicit.strip().lower()
+            if normalized in {"barge_in", "interrupt", "cancel"}:
+                return {
+                    "action": "barge_in",
+                    "reason": "client_overlap_action",
+                    "duration_ms": duration_ms,
+                    "buffer_audio": True,
+                }
+            if normalized in {"listen", "continue", "continue_output", "ack"}:
+                session.reset_overlap_speech()
+                return {
+                    "action": "listen",
+                    "reason": "client_overlap_action",
+                    "duration_ms": duration_ms,
+                    "buffer_audio": (
+                        normalized == "listen" and is_speech and duration_ms > session.config.overlap_short_ack_ms
+                    ),
+                    "defer_runtime_append": True,
+                }
+            if normalized in {"drop", "ignore", "silence"}:
+                session.reset_overlap_speech()
+                return {
+                    "action": "drop",
+                    "reason": "client_overlap_action",
+                    "duration_ms": duration_ms,
+                    "buffer_audio": False,
+                }
+
+        if bool(event.get("force_barge_in", False)):
+            return {
+                "action": "barge_in",
+                "reason": "client_force_barge_in",
+                "duration_ms": duration_ms,
+                "buffer_audio": True,
+            }
+        if self._session_auto_responds(session):
+            # Full-duplex input remains model-owned while output is active. Feed
+            # complete model units into the existing Stage0 stream immediately;
+            # playback only controls history ACKs, not model admission.
+            if is_speech:
+                session.accumulate_overlap_speech(duration_ms)
+            return {
+                "action": "listen",
+                "reason": "auto_response_continuous",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+                "defer_runtime_append": False,
+                "force_listen": False,
+                "preserve_realtime_input": True,
+            }
+        if bool(event.get("force_listen", False)):
+            session.reset_overlap_speech()
+            return {
+                "action": "listen",
+                "reason": "client_force_listen",
+                "duration_ms": duration_ms,
+                "buffer_audio": is_speech,
+                "defer_runtime_append": True,
+            }
+
+        policy = session.config.overlap_policy
+        if not is_speech:
+            if session.overlap_speech_ms <= 0:
+                session.reset_overlap_speech()
+            return {
+                "action": "drop",
+                "reason": "silence_or_noise",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": False,
+            }
+
+        if self._is_short_ack_transcript_hint(event, payload):
+            session.reset_overlap_speech()
+            return {
+                "action": "listen",
+                "reason": "short_ack_transcript",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": False,
+                "defer_runtime_append": True,
+            }
+
+        if policy == DuplexOverlapPolicy.LISTEN_ONLY.value:
+            session.accumulate_overlap_speech(duration_ms)
+            return {
+                "action": "listen",
+                "reason": "policy_listen_only",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+                "defer_runtime_append": True,
+            }
+
+        if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value and not session.capabilities.supports_barge_in:
+            return self._defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=True)
+
+        session.accumulate_overlap_speech(duration_ms)
+        if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value:
+            return {
+                "action": "barge_in",
+                "reason": "policy_barge_in_on_speech",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+            }
+
+        if (
+            duration_ms <= session.config.overlap_short_ack_ms
+            and session.overlap_speech_ms <= session.config.overlap_short_ack_ms
+        ):
+            return {
+                "action": "listen",
+                "reason": "short_ack",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+                "defer_runtime_append": True,
+            }
+        if session.overlap_speech_ms >= session.config.overlap_barge_in_ms:
+            if not session.capabilities.supports_barge_in:
+                return {
+                    "action": "listen",
+                    "reason": "barge_in_unsupported",
+                    "duration_ms": duration_ms,
+                    "overlap_speech_ms": session.overlap_speech_ms,
+                    "buffer_audio": True,
+                    "defer_runtime_append": True,
+                }
+            return {
+                "action": "barge_in",
+                "reason": "long_overlap_speech",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+            }
+        return {
+            "action": "listen",
+            "reason": "accumulating_overlap_speech",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+            "defer_runtime_append": True,
+        }
+
+    @staticmethod
+    def _event_requests_barge_in(event: Mapping[str, object]) -> bool:
+        if event.get("force_barge_in") is True:
+            return True
+        explicit = event.get("overlap_action") or event.get("overlap")
+        return isinstance(explicit, str) and explicit.strip().lower() in {
+            "barge_in",
+            "interrupt",
+            "cancel",
+        }
+
+    @staticmethod
+    def _defer_unsupported_barge_in(
+        session: DuplexSession,
+        *,
+        duration_ms: int,
+        is_speech: bool,
+    ) -> dict[str, object]:
+        if is_speech:
+            session.accumulate_overlap_speech(duration_ms)
+        return {
+            "action": "listen",
+            "reason": "barge_in_unsupported",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": is_speech,
+            "defer_runtime_append": True,
+        }
+
+    @staticmethod
+    def _barge_in_unsupported_error(session: DuplexSession) -> dict[str, object]:
+        return {
+            "type": "error",
+            "session_id": session.session_id,
+            "code": "barge_in_unsupported",
+            "error": "Barge-in is not supported by this duplex model",
+        }
+
+    @staticmethod
+    def _is_short_ack_transcript_hint(event: dict[str, object], payload: dict[str, object]) -> bool:
+        raw_text = event.get("transcript") or event.get("text") or payload.get("transcript") or payload.get("text")
+        if not isinstance(raw_text, str):
+            return False
+        normalized = raw_text.strip().lower()
+        if not normalized:
+            return False
+        compact = "".join(ch for ch in normalized if ch.isalnum() or "\u4e00" <= ch <= "\u9fff")
+        if compact in {
+            "嗯",
+            "嗯嗯",
+            "对",
+            "对的",
+            "好",
+            "好的",
+            "继续",
+            "继续说",
+            "可以",
+            "是的",
+            "yes",
+            "yeah",
+            "yep",
+            "ok",
+            "okay",
+            "continue",
+            "goon",
+            "right",
+        }:
+            return True
+        return normalized in {"go on", "keep going", "please continue"}
+
+    @staticmethod
+    def _input_audio_duration_ms(event: dict[str, object], payload: dict[str, object]) -> int:
+        for key in ("duration_ms", "audio_duration_ms"):
+            value = event.get(key)
+            if isinstance(value, int | float):
+                return max(0, int(value))
+        fmt = payload.get("format")
+        sample_rate_hz = payload.get("sample_rate_hz")
+        audio = payload.get("audio")
+        if fmt == "pcm_f32le" and isinstance(sample_rate_hz, int) and sample_rate_hz > 0 and isinstance(audio, str):
+            try:
+                raw = base64.b64decode(audio, validate=True)
+            except (binascii.Error, ValueError):
+                return 0
+            return int((len(raw) // 4) * 1000 / sample_rate_hz)
+        return 0
+
+    @staticmethod
+    def _merge_native_audio_payloads(
+        first: dict[str, object],
+        second: dict[str, object],
+    ) -> dict[str, object]:
+        if first.get("format") != "pcm_f32le" or second.get("format") != "pcm_f32le":
+            return second
+        first_rate = first.get("sample_rate_hz")
+        second_rate = second.get("sample_rate_hz")
+        if not isinstance(first_rate, int) or not isinstance(second_rate, int) or first_rate != second_rate:
+            return second
+        first_audio = first.get("audio")
+        second_audio = second.get("audio")
+        if not isinstance(first_audio, str) or not isinstance(second_audio, str):
+            return second
+        try:
+            first_raw = base64.b64decode(first_audio, validate=True)
+            second_raw = base64.b64decode(second_audio, validate=True)
+        except (binascii.Error, ValueError):
+            return second
+        merged = dict(second)
+        merged["audio"] = base64.b64encode(first_raw + second_raw).decode("ascii")
+        merged["sample_rate_hz"] = first_rate
+        merged_frames = [
+            frame
+            for source in (first.get("video_frames"), second.get("video_frames"))
+            if isinstance(source, list)
+            for frame in source
+            if isinstance(frame, str) and frame
+        ]
+        if merged_frames:
+            merged["video_frames"] = merged_frames
+        else:
+            merged.pop("video_frames", None)
+        merged["force_listen"] = bool(first.get("force_listen", False)) or bool(second.get("force_listen", False))
+        merged.pop("force_speak", None)
+        merged["is_speech"] = bool(first.get("is_speech", False)) or bool(second.get("is_speech", False))
+        return merged
+
+    @classmethod
+    def _should_force_listen_for_short_commit(
+        cls,
+        session: DuplexSession,
+        event: dict[str, object],
+        payload: dict[str, object],
+    ) -> bool:
+        """Keep very short committed Realtime chunks in listen mode.
+
+        Realtime VAD can emit a commit for a short pause even when the user has
+        not actually yielded the turn. For MiniCPM-o native duplex, make that
+        policy explicit by steering the scheduler path to the model listen
+        token instead of letting a sub-second chunk start a response.
+        """
+        if event.get("force_listen") is True or payload.get("force_listen") is True:
+            return True
+        if event.get("force_barge_in") is True:
+            return False
+        if event.get("response_create") is not True:
+            return False
+        duration_ms = cls._input_audio_duration_ms(event, payload)
+        return 0 < duration_ms <= session.config.overlap_short_ack_ms
+
+    def _runtime_session_state(self, session: DuplexSession) -> ServingRuntimeSessionState:
+        return self._serving_runtime_adapter.session_state(session.session_id)
+
+    # Temporary compatibility accessors for downstream tests and extensions.
+    def _minicpmo_session_state(self, session: DuplexSession) -> ServingRuntimeSessionState:
+        return self._runtime_session_state(session)
+
+    @property
+    def _minicpmo_sessions(self):
+        return self._serving_runtime_adapter.session_states
+
+    @property
+    def _minicpmo_data_plane(self):
+        return self._serving_runtime_adapter.data_plane
+
+    def _should_force_listen_for_auto_response_overlap(
+        self,
+        session: DuplexSession,
+        event: dict[str, object],
+        payload: dict[str, object],
+    ) -> bool:
+        if not self._session_auto_responds(session):
+            return False
+        if event.get("force_barge_in") is True:
+            return False
+        return event.get("force_listen") is True or payload.get("force_listen") is True
+
+    @staticmethod
+    def _assistant_playback_active(session: DuplexSession) -> bool:
+        return (
+            session.config.playback_commit_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
+            and session.playback.sent_ms > session.playback.committed_ms
+        )
+
+    @staticmethod
+    def _input_looks_like_speech(
+        event: dict[str, object],
+        payload: dict[str, object],
+        *,
+        session: DuplexSession,
+    ) -> bool:
+        for key in ("is_speech", "speech"):
+            value = event.get(key)
+            if isinstance(value, bool):
+                return value
+        vad = event.get("vad")
+        if isinstance(vad, dict):
+            value = vad.get("is_speech")
+            if isinstance(value, bool):
+                return value
+            probability = vad.get("speech_probability", vad.get("probability"))
+            if isinstance(probability, int | float):
+                return float(probability) >= 0.5
+        probability = event.get("speech_probability")
+        if isinstance(probability, int | float):
+            return float(probability) >= 0.5
+
+        fmt = payload.get("format")
+        audio = payload.get("audio")
+        if fmt in {"pcm_f32le", "pcm16"} and isinstance(audio, str):
+            try:
+                raw = base64.b64decode(audio, validate=True)
+            except (binascii.Error, ValueError):
+                return True
+            if fmt == "pcm_f32le":
+                if len(raw) < 4 or len(raw) % 4 != 0:
+                    return True
+                samples = np.frombuffer(raw, dtype=np.float32)
+            else:
+                if len(raw) < 2 or len(raw) % 2 != 0:
+                    return True
+                samples = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
+            if samples.size == 0:
+                return False
+            rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
+            return rms >= session.config.overlap_silence_rms
+        return True
+
+    async def _emit_overlap_decision(
+        self,
+        send_json,
+        session: DuplexSession,
+        decision: dict[str, object],
+    ) -> None:
+        await send_json(
+            {
+                "type": "overlap.decision",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "policy": session.config.overlap_policy,
+                **decision,
+            }
+        )
+
+    async def _open_session(
+        self,
+        websocket: WebSocket,
+        send_json,
+        *,
+        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
+        attachment_send=None,
+        attachment_close=None,
+    ) -> _DuplexSessionHandshake | None:
+        raw = await self._receive_text(
+            websocket,
+            self._config_timeout_s,
+            realtime_protocol=realtime_protocol,
+        )
+        if raw is None:
+            await send_json({"type": "error", "error": "Timeout waiting for session.create", "code": "config_timeout"})
+            return None
+        try:
+            event = json.loads(raw)
+        except json.JSONDecodeError:
+            await send_json({"type": "error", "error": "Invalid JSON in session.create", "code": "invalid_json"})
+            return None
+        if isinstance(event, dict) and event.get("type") == "session.resume":
+            if realtime_protocol is None:
+                await send_json(
+                    {
+                        "type": "error",
+                        "error": "session.resume requires the Realtime protocol",
+                        "code": "unsupported_session_resume",
+                    }
+                )
+                return None
+            return await self._resume_session_handshake(
+                event,
+                send_json=send_json,
+                realtime_protocol=realtime_protocol,
+                attachment_send=attachment_send,
+                attachment_close=attachment_close,
+            )
+        if not isinstance(event, dict) or event.get("type") not in {"session.create", "open_session", "session.config"}:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": f"Expected session.create, got: {event.get('type') if isinstance(event, dict) else None}",
+                    "code": "bad_event",
+                }
+            )
+            return None
+
+        config = DuplexSessionConfig.from_event(event)
+        if config.idle_timeout_s == _DEFAULT_IDLE_TIMEOUT_S:
+            config.idle_timeout_s = self._idle_timeout_s
+        use_native_runtime = self._uses_serving_runtime_adapter(config)
+        runtime_config: dict[str, object] = {}
+        if use_native_runtime:
+            try:
+                runtime_config = await self._serving_runtime_adapter.prepare_runtime_config(
+                    config,
+                    model_config=getattr(self._chat_service, "model_config", None),
+                )
+            except ServingRuntimeConfigError as exc:
+                await send_json({"type": "error", "error": str(exc), "code": exc.code})
+                return None
+            except ValueError as exc:
+                await send_json({"type": "error", "error": str(exc), "code": "unsupported_ref_audio_path"})
+                return None
+        session_id = event.get("session_id") if isinstance(event.get("session_id"), str) else None
+        session = self._registry.create(config=config, session_id=session_id)
+        if use_native_runtime:
+            session.replace_capabilities(
+                self._serving_runtime_adapter.capabilities(
+                    max_sessions=self._duplex_session_config.max_sessions,
+                )
+            )
+            session.replace_runtime_config(runtime_config)
+        return _DuplexSessionHandshake(session=session)
+
+    async def _resume_session_handshake(
+        self,
+        event: dict[str, object],
+        *,
+        send_json,
+        realtime_protocol: NativeRealtimeSessionProtocol,
+        attachment_send,
+        attachment_close,
+    ) -> _DuplexSessionHandshake | None:
+        session_id = event.get("session_id")
+        incarnation = event.get("incarnation")
+        resume_token = event.get("resume_token")
+        last_received = event.get("last_received_server_event_seq", 0)
+        if (
+            not isinstance(session_id, str)
+            or not session_id
+            or not isinstance(incarnation, int)
+            or incarnation < 0
+            or not isinstance(resume_token, str)
+            or not resume_token
+            or not isinstance(last_received, int)
+            or last_received < 0
+        ):
+            await send_json(
+                {
+                    "type": "error",
+                    "error": (
+                        "session.resume requires session_id, incarnation, resume_token, "
+                        "and a non-negative event sequence"
+                    ),
+                    "code": "invalid_session_resume",
+                }
+            )
+            return None
+        session = self._registry.get(session_id)
+        if session is None or session.state != DuplexSessionState.OPEN:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": f"Unknown or expired duplex session: {session_id}",
+                    "code": "session_resume_expired",
+                }
+            )
+            return None
+        if not session.capabilities.supports_session_resume:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": f"Session does not support resume: {session_id}",
+                    "code": "unsupported_session_resume",
+                }
+            )
+            return None
+        try:
+            await self._attachment_registry.authenticate_resume(
+                session_id,
+                incarnation=incarnation,
+                resume_token=resume_token,
+                last_received_server_event_seq=last_received,
+            )
+        except InvalidResumeTokenError:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": "Invalid duplex session resume token",
+                    "code": "invalid_resume_token",
+                }
+            )
+            return None
+        except DuplexJournalGapError:
+            await send_json(
+                {
+                    "type": "session.resync_required",
+                    "session_id": session_id,
+                    "reason": "journal_gap",
+                }
+            )
+            return None
+        except (KeyError, ValueError) as exc:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": str(exc),
+                    "code": "session_resume_conflict",
+                }
+            )
+            return None
+
+        resume_runtime = getattr(self._chat_service.engine_client, "resume_duplex_session_async", None)
+        if not callable(resume_runtime):
+            await send_json(
+                {
+                    "type": "error",
+                    "error": "Duplex runtime does not expose session resume control",
+                    "code": "runtime_resume_unsupported",
+                }
+            )
+            return None
+        expected_generation = self._lease_generations.get(session_id, 0)
+        try:
+            runtime_result = await resume_runtime(
+                session_id,
+                fence=DuplexFence(
+                    session.session_id,
+                    epoch=session.epoch,
+                    turn_id=session.turn_id,
+                    incarnation=session.incarnation,
+                ),
+                expected_lease_generation=expected_generation,
+            )
+            lease_generation = self._runtime_lease_generation(runtime_result)
+            if lease_generation is None:
+                raise RuntimeError("runtime resume result omitted lease_generation")
+        except Exception as exc:
+            await send_json(
+                {
+                    "type": "error",
+                    "error": str(exc),
+                    "code": "runtime_resume_failed",
+                }
+            )
+            return None
+
+        if not callable(attachment_send) or not callable(attachment_close):
+            raise RuntimeError("session.resume requires transport attachment callbacks")
+
+        def activation_payload_factory(token, generation: int) -> dict[str, object]:
+            internal = {
+                "type": "session.resumed",
+                "session_id": session_id,
+                "incarnation": incarnation,
+                "attachment_generation": generation,
+                "resume_token": token.plaintext,
+            }
+            return realtime_protocol.encode_outbound_event(internal)[0]
+
+        try:
+            resumed = await self._attachment_registry.resume(
+                session_id,
+                incarnation=incarnation,
+                resume_token=resume_token,
+                last_received_server_event_seq=last_received,
+                send=attachment_send,
+                close=attachment_close,
+                activation_payload_factory=activation_payload_factory,
+            )
+        except Exception as exc:
+            # The engine-side CAS already advanced even if the transport
+            # vanished before it received the rotated token. Keep that
+            # generation so the registry's one-shot recovery token can retry.
+            self._lease_generations[session_id] = lease_generation
+            await send_json(
+                {
+                    "type": "error",
+                    "error": str(exc),
+                    "code": "session_resume_conflict",
+                }
+            )
+            return None
+        self._lease_generations[session_id] = lease_generation
+        replaced = resumed.replaced_attachment
+        if replaced is not None:
+            replaced_payload = realtime_protocol.encode_outbound_event(
+                {
+                    "type": "session.replaced",
+                    "session_id": session_id,
+                    "attachment_generation": replaced.generation,
+                }
+            )[0]
+            with suppress(Exception):
+                await replaced.send(replaced_payload)
+            with suppress(Exception):
+                await replaced.close("session_replaced")
+        return _DuplexSessionHandshake(
+            session=session,
+            resumed=True,
+            attachment_generation=resumed.attachment_generation,
+        )
+
+    @classmethod
+    def _runtime_lease_generation(cls, result: object) -> int | None:
+        if isinstance(result, dict):
+            generation = result.get("lease_generation")
+            if isinstance(generation, int):
+                return generation
+            for key in ("stage_results", "result"):
+                generation = cls._runtime_lease_generation(result.get(key))
+                if generation is not None:
+                    return generation
+            return None
+        if isinstance(result, list | tuple):
+            for item in result:
+                generation = cls._runtime_lease_generation(item)
+                if generation is not None:
+                    return generation
+        return None
+
+    def _uses_serving_runtime_adapter(self, config: DuplexSessionConfig) -> bool:
+        return self._serving_runtime_adapter.is_enabled(config)
+
+    def _runtime_session_update_error(
+        self,
+        session: DuplexSession,
+        payload: dict[str, object],
+    ) -> dict[str, object] | None:
+        if not self._uses_native_input_append(session):
+            return None
+        try:
+            self._serving_runtime_adapter.validate_client_extra_body(payload.get("extra_body"))
+        except ServingRuntimeConfigError as exc:
+            return {
+                "type": "error",
+                "session_id": session.session_id,
+                "code": exc.code,
+                "error": str(exc),
+            }
+        return None
+
+    def _runtime_config_for_session_update(
+        self,
+        session: DuplexSession,
+        candidate_config: DuplexSessionConfig,
+    ) -> dict[str, object]:
+        if not self._uses_native_input_append(session):
+            return dict(session.runtime_config)
+        return self._serving_runtime_adapter.runtime_config_for_update(
+            candidate_config,
+            dict(session.runtime_config),
+        )
+
+    def _runtime_session_candidate_update_error(
+        self,
+        session: DuplexSession,
+        candidate_config: DuplexSessionConfig,
+    ) -> dict[str, object] | None:
+        if not self._uses_native_input_append(session):
+            return None
+        if not self._config_requests_audio_output(candidate_config):
+            return None
+        if "ref_audio_data" in session.runtime_config:
+            return None
+        return {
+            "type": "error",
+            "session_id": session.session_id,
+            "code": "ref_audio_required",
+            "error": "MiniCPM-o native duplex audio output requires ref_audio",
+        }
+
+    @staticmethod
+    def _uses_native_input_append(session: DuplexSession) -> bool:
+        return (
+            session.capabilities.implementation_level == "model_native_duplex"
+            and session.capabilities.supports_input_append
+        )
+
+    @staticmethod
+    def _config_requests_audio_output(config: DuplexSessionConfig) -> bool:
+        return any(str(modality).lower() == "audio" for modality in config.modalities)
+
+    @staticmethod
+    def _native_stage0_request_id(session: DuplexSession, epoch: int) -> str:
+        return duplex_resource_request_id(
+            DuplexFence(
+                session.session_id,
+                epoch=epoch,
+                incarnation=session.incarnation,
+            ),
+            "stage0",
+        )
+
+    @staticmethod
+    def _session_auto_responds(session: DuplexSession) -> bool:
+        """Full-duplex / model-driven mode.
+
+        When set, the server runs per-chunk speak-generation continuously (like
+        the official MiniCPM-o ``duplex_generate`` loop) instead of waiting for an
+        explicit ``response.create``: each ~chunk_period of appended audio is
+        emitted and fed to the stage0 stream so the model itself decides to speak
+        or listen. Signaled by the client via ``extra_body.auto_response`` (or
+        ``extra_body.full_duplex``).
+        """
+        extra = getattr(session.config, "extra_body", None)
+        if not isinstance(extra, dict):
+            return False
+        return extra.get("auto_response") is True or extra.get("full_duplex") is True
+
+    async def _receive_text(
+        self,
+        websocket: WebSocket,
+        timeout_s: float,
+        *,
+        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
+    ) -> str | None:
+        try:
+            if realtime_protocol is not None:
+                return await asyncio.wait_for(
+                    realtime_protocol.receive_internal_event_text(websocket),
+                    timeout=max(0.1, timeout_s),
+                )
+            return await asyncio.wait_for(websocket.receive_text(), timeout=max(0.1, timeout_s))
+        except asyncio.TimeoutError:
+            return None
+
+    @staticmethod
+    def _input_committed_payload(
+        session: DuplexSession,
+        committed: DuplexCommittedInput,
+        *,
+        realtime_item_id: object | None = None,
+    ) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "type": "input.committed",
+            "session_id": session.session_id,
+            "turn_id": committed.turn_id,
+            "epoch": committed.epoch,
+            "history_len": len(session.history),
+            "message": committed.message,
+        }
+        if isinstance(realtime_item_id, str) and realtime_item_id:
+            payload["realtime_item_id"] = realtime_item_id
+        return payload
+
+    @staticmethod
+    def _commit_native_audio_input(
+        session: DuplexSession,
+        *,
+        realtime_item_id: object | None = None,
+        transcript: object | None = None,
+        turn_id: int | None = None,
+    ) -> DuplexCommittedInput:
+        clean_transcript = transcript.strip() if isinstance(transcript, str) else None
+        committed = session.commit_native_audio_input(
+            transcript=clean_transcript or None,
+            turn_id=turn_id,
+        )
+        if isinstance(realtime_item_id, str) and realtime_item_id:
+            session.register_history_item(realtime_item_id, committed.message)
+        return committed
+
+    @staticmethod
+    def _native_audio_committed_payload(
+        session: DuplexSession,
+        *,
+        committed: DuplexCommittedInput | None = None,
+        realtime_item_id: object | None = None,
+        transcript: object | None = None,
+    ) -> dict[str, object]:
+        message = committed.message if committed is not None else None
+        if not isinstance(message, dict):
+            input_audio_part: dict[str, object] = {
+                "type": "audio_url",
+                "audio_url": {"url": "native-duplex:input-audio"},
+            }
+            if isinstance(transcript, str) and transcript:
+                input_audio_part["transcript"] = transcript
+            message = {
+                "role": "user",
+                "content": [input_audio_part],
+            }
+        payload: dict[str, object] = {
+            "type": "input.committed",
+            "session_id": session.session_id,
+            "turn_id": committed.turn_id if committed is not None else session.turn_id,
+            "epoch": committed.epoch if committed is not None else session.epoch,
+            "history_len": len(session.history),
+            "native_audio": True,
+            "message": message,
+        }
+        if isinstance(transcript, str) and transcript:
+            payload["transcript"] = transcript
+        if isinstance(realtime_item_id, str) and realtime_item_id:
+            payload["realtime_item_id"] = realtime_item_id
+        return payload
+
+    @staticmethod
+    def _apply_session_update(session: DuplexSession, payload: dict[str, object]) -> dict[str, object] | None:
+        model = payload.get("model")
+        audio_config = payload.get("audio")
+        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        voice = payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        if isinstance(model, str) and session.config.model is not None and model != session.config.model:
+            return {
+                "type": "error",
+                "session_id": session.session_id,
+                "code": "model_update_unsupported",
+                "error": "session.update cannot change model for an open realtime duplex session",
+            }
+        if isinstance(model, str) and session.config.model is None:
+            session.config.model = model
+        if isinstance(voice, str) and (session.playback.generated_ms > 0 or session.playback.sent_ms > 0):
+            return {
+                "type": "error",
+                "session_id": session.session_id,
+                "code": "voice_update_after_audio_unsupported",
+                "error": "session.update cannot change voice after audio output has started",
+            }
+        if isinstance(payload.get("ref_audio"), str):
+            return {
+                "type": "error",
+                "session_id": session.session_id,
+                "code": "ref_audio_update_unsupported",
+                "error": "session.update cannot change ref_audio after the native duplex runtime is open",
+            }
+        if isinstance(payload.get("instructions"), str):
+            session.config.instructions = str(payload["instructions"])
+        elif "instructions" in payload and payload.get("instructions") is None:
+            session.config.instructions = None
+        if isinstance(voice, str):
+            session.config.voice = str(voice)
+        elif "voice" in payload and payload.get("voice") is None:
+            session.config.voice = None
+        response_format = payload.get("output_audio_format") or payload.get("response_format")
+        if response_format is None and isinstance(audio_config, dict):
+            if isinstance(audio_output, dict):
+                response_format = audio_output.get("format")
+        response_format, _ = NativeRealtimeSessionProtocol._parse_realtime_audio_format(response_format)
+        if isinstance(response_format, str) and response_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
+            session.config.response_format = NativeRealtimeSessionProtocol._duplex_response_format(response_format)
+        if isinstance(payload.get("temperature"), int | float):
+            session.config.temperature = float(payload["temperature"])
+        speed = payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        if isinstance(speed, int | float):
+            session.config.speed = float(speed)
+        max_tokens = (
+            payload.get("max_response_output_tokens")
+            if "max_response_output_tokens" in payload
+            else payload.get("max_output_tokens")
+            if "max_output_tokens" in payload
+            else payload.get("max_tokens")
+        )
+        if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
+            session.config.max_tokens = NativeRealtimeSessionProtocol.realtime_max_output_tokens(max_tokens)
+        if isinstance(payload.get("overlap_policy"), str):
+            session.config.overlap_policy = DuplexSessionConfig._normalize_overlap_policy(
+                str(payload["overlap_policy"])
+            )
+        if isinstance(payload.get("overlap_short_ack_ms"), int | float):
+            session.config.overlap_short_ack_ms = max(0, int(payload["overlap_short_ack_ms"]))
+        if isinstance(payload.get("overlap_barge_in_ms"), int | float):
+            session.config.overlap_barge_in_ms = max(0, int(payload["overlap_barge_in_ms"]))
+        if isinstance(payload.get("overlap_silence_rms"), int | float):
+            session.config.overlap_silence_rms = max(0.0, float(payload["overlap_silence_rms"]))
+        if isinstance(payload.get("playback_commit_policy"), str):
+            session.config.playback_commit_policy = DuplexSessionConfig._normalize_playback_commit_policy(
+                str(payload["playback_commit_policy"])
+            )
+        modalities = payload.get("modalities") or payload.get("output_modalities")
+        if isinstance(modalities, list) and all(isinstance(item, str) for item in modalities):
+            session.config.modalities = list(modalities)
+        if isinstance(payload.get("extra_body"), dict):
+            session.config.extra_body.update(payload["extra_body"])
+            extra = payload["extra_body"]
+            if isinstance(extra.get("overlap_policy"), str):
+                session.config.overlap_policy = DuplexSessionConfig._normalize_overlap_policy(
+                    str(extra["overlap_policy"])
+                )
+            if isinstance(extra.get("playback_commit_policy"), str):
+                session.config.playback_commit_policy = DuplexSessionConfig._normalize_playback_commit_policy(
+                    str(extra["playback_commit_policy"])
+                )
+        if isinstance(payload.get("tools"), list):
+            session.config.extra_body["realtime_tools"] = payload["tools"]
+        elif "tools" in payload and payload.get("tools") is None:
+            session.config.extra_body.pop("realtime_tools", None)
+        if isinstance(payload.get("tool_choice"), str | dict):
+            session.config.extra_body["realtime_tool_choice"] = payload["tool_choice"]
+        elif "tool_choice" in payload and payload.get("tool_choice") is None:
+            session.config.extra_body.pop("realtime_tool_choice", None)
+        if isinstance(payload.get("metadata"), dict):
+            session.config.extra_body["realtime_metadata"] = dict(payload["metadata"])
+        elif "metadata" in payload and payload.get("metadata") is None:
+            session.config.extra_body.pop("realtime_metadata", None)
+        if isinstance(payload.get("include"), list):
+            session.config.extra_body["realtime_include"] = list(payload["include"])
+        elif "include" in payload and payload.get("include") is None:
+            session.config.extra_body.pop("realtime_include", None)
+        if isinstance(payload.get("prompt"), dict):
+            session.config.extra_body["realtime_prompt"] = dict(payload["prompt"])
+        elif "prompt" in payload and payload.get("prompt") is None:
+            session.config.extra_body.pop("realtime_prompt", None)
+        input_audio_transcription = NativeRealtimeSessionProtocol._input_audio_transcription_config(payload)
+        if isinstance(input_audio_transcription, dict):
+            session.config.extra_body["realtime_input_audio_transcription"] = dict(input_audio_transcription)
+        elif "input_audio_transcription" in payload and payload.get("input_audio_transcription") is None:
+            session.config.extra_body.pop("realtime_input_audio_transcription", None)
+        if isinstance(payload.get("input_audio_noise_reduction"), dict):
+            session.config.extra_body["realtime_input_audio_noise_reduction"] = dict(
+                payload["input_audio_noise_reduction"]
+            )
+        elif "input_audio_noise_reduction" in payload and payload.get("input_audio_noise_reduction") is None:
+            session.config.extra_body.pop("realtime_input_audio_noise_reduction", None)
+        if isinstance(audio_input, dict) and isinstance(audio_input.get("noise_reduction"), dict):
+            session.config.extra_body["realtime_input_audio_noise_reduction"] = dict(audio_input["noise_reduction"])
+        elif isinstance(audio_input, dict) and audio_input.get("noise_reduction") is None:
+            session.config.extra_body.pop("realtime_input_audio_noise_reduction", None)
+        if isinstance(payload.get("audio"), dict):
+            session.config.extra_body["realtime_audio"] = dict(payload["audio"])
+        elif "audio" in payload and payload.get("audio") is None:
+            session.config.extra_body.pop("realtime_audio", None)
+        if isinstance(payload.get("tracing"), str | dict):
+            session.config.extra_body["realtime_tracing"] = payload["tracing"]
+        elif "tracing" in payload and payload.get("tracing") is None:
+            session.config.extra_body.pop("realtime_tracing", None)
+        session.config.extra_body["realtime_session_payload"] = (
+            NativeRealtimeSessionProtocol._json_safe_realtime_payload(payload)
+        )
+        return None
+
+    def _apply_response_create_options(
+        self,
+        session: DuplexSession,
+        payload: dict[str, object],
+    ) -> str | None:
+        """Reserve options that apply only to the next response lifecycle."""
+        audio_config = payload.get("audio")
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        if session.capabilities.implementation_level == "model_native_duplex":
+            nested_voice = audio_output.get("voice") if isinstance(audio_output, dict) else None
+            unsupported = (
+                payload.get("instructions") is not None
+                or payload.get("voice") is not None
+                or nested_voice is not None
+                or payload.get("temperature") is not None
+                or any(
+                    payload.get(field_name) is not None
+                    for field_name in ("max_response_output_tokens", "max_output_tokens", "max_tokens")
+                )
+                or payload.get("tools") is not None
+                or payload.get("tool_choice") is not None
+            )
+            if unsupported:
+                return "unsupported_native_response_options"
+
+        instructions = str(payload["instructions"]) if isinstance(payload.get("instructions"), str) else None
+        voice = payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        voice = str(voice) if isinstance(voice, str) else None
+        response_format = payload.get("output_audio_format") or payload.get("response_format")
+        if response_format is None and isinstance(audio_config, dict):
+            if isinstance(audio_output, dict):
+                response_format = audio_output.get("format")
+        response_format, _ = NativeRealtimeSessionProtocol._parse_realtime_audio_format(response_format)
+        if isinstance(response_format, str) and response_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
+            response_format = NativeRealtimeSessionProtocol._duplex_response_format(response_format)
+        else:
+            response_format = None
+        temperature = float(payload["temperature"]) if isinstance(payload.get("temperature"), int | float) else None
+        speed = payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        speed = float(speed) if isinstance(speed, int | float) else None
+        max_tokens = (
+            payload.get("max_response_output_tokens")
+            if "max_response_output_tokens" in payload
+            else payload.get("max_output_tokens")
+            if "max_output_tokens" in payload
+            else payload.get("max_tokens")
+        )
+        if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
+            max_tokens = NativeRealtimeSessionProtocol.realtime_max_output_tokens(max_tokens)
+        else:
+            max_tokens = None
+        modalities = payload.get("modalities") or payload.get("output_modalities")
+        if isinstance(modalities, list) and all(isinstance(item, str) for item in modalities):
+            modalities = tuple(modalities)
+        else:
+            modalities = None
+        response_extra: dict[str, object] = {}
+        conversation = payload.get("conversation")
+        if isinstance(conversation, str):
+            response_extra["realtime_response_conversation"] = conversation
+        metadata = payload.get("metadata")
+        if isinstance(metadata, dict):
+            response_extra["realtime_response_metadata"] = dict(metadata)
+        prompt = payload.get("prompt")
+        if isinstance(prompt, dict):
+            response_extra["realtime_response_prompt"] = dict(prompt)
+        if isinstance(payload.get("tools"), list):
+            response_extra["realtime_response_tools"] = payload["tools"]
+        if isinstance(payload.get("tool_choice"), str | dict):
+            response_extra["realtime_response_tool_choice"] = payload["tool_choice"]
+        extra_body = payload.get("extra_body")
+        if isinstance(extra_body, dict):
+            if session.capabilities.implementation_level == "model_native_duplex":
+                response_extra.update(
+                    (key, value)
+                    for key, value in extra_body.items()
+                    if key not in self._serving_runtime_adapter.private_runtime_config_keys
+                )
+            else:
+                response_extra.update(extra_body)
+        try:
+            session.reserve_response_options(
+                ResponseCreateOptions(
+                    instructions=instructions,
+                    voice=voice,
+                    response_format=response_format,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    speed=speed,
+                    modalities=modalities,
+                    extra_body=response_extra,
+                )
+            )
+        except RuntimeError:
+            return "response_already_active"
+        return None
+
+    @staticmethod
+    def _realtime_item_to_history_message(item: object) -> dict[str, object] | None:
+        if not isinstance(item, dict):
+            return None
+        role = item.get("role")
+        if role not in {"system", "user", "assistant"}:
+            return None
+        content = item.get("content")
+        if isinstance(content, str):
+            text = content.strip()
+            return {"role": role, "content": text} if text else None
+        if not isinstance(content, list):
+            return None
+        text_chunks: list[str] = []
+        audio_chunks: list[dict[str, object]] = []
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            part_type = part.get("type")
+            if part_type in {"input_text", "text", "output_text"} and isinstance(part.get("text"), str):
+                text_chunks.append(str(part["text"]))
+            elif part_type in {"input_audio", "audio"}:
+                audio = part.get("audio") or part.get("data")
+                fmt = part.get("format") if isinstance(part.get("format"), str) else "wav"
+                if isinstance(audio, str) and audio:
+                    audio_chunks.append(
+                        {
+                            "type": "audio_url",
+                            "audio_url": {
+                                "url": f"data:audio/{fmt};base64,{audio}",
+                            },
+                        }
+                    )
+            elif part_type in {"audio_transcript", "transcript"} and isinstance(part.get("text"), str):
+                text_chunks.append(str(part["text"]))
+        text = "".join(text_chunks).strip()
+        if audio_chunks:
+            content_items: list[dict[str, object]] = []
+            if text:
+                content_items.append({"type": "text", "text": text})
+            content_items.extend(audio_chunks)
+            return {"role": role, "content": content_items}
+        if text:
+            return {"role": role, "content": text}
+        return None
+
+    async def _handle_playback_ack(self, session: DuplexSession, event: dict[str, object], send_json) -> None:
+        played_ms = event.get("played_ms", event.get("audio_ms", 0))
+        committed_ms = event.get("committed_ms")
+        if not isinstance(played_ms, int | float):
+            await send_json({"type": "error", "error": "playback.ack requires played_ms", "code": "bad_event"})
+            return
+        committed_cursor = int(committed_ms) if isinstance(committed_ms, int | float) else int(played_ms)
+        item_id = event.get("item_id")
+        response_id = event.get("response_id")
+        response_id = response_id if isinstance(response_id, str) and response_id else None
+        if not isinstance(item_id, str) or not item_id:
+            item_id = f"item_{response_id}" if response_id is not None else None
+        elif response_id is None and item_id.startswith("item_"):
+            response_id = item_id.removeprefix("item_")
+        if response_id is None and item_id is None and len(session.pending_history_item_ids) == 1:
+            item_id = next(iter(session.pending_history_item_ids))
+            if item_id.startswith("item_"):
+                response_id = item_id.removeprefix("item_")
+        if response_id is None and item_id is None and session.active_response_id is not None:
+            response_id = session.active_response_id
+            item_id = f"item_{response_id}"
+        if event.get("truncate") is True:
+            playback = session.acknowledge_playback(
+                int(played_ms),
+                committed_cursor,
+                response_id=response_id,
+            )
+            playback = session.truncate_playback_commit(
+                committed_cursor,
+                response_id=response_id,
+            )
+        else:
+            playback = session.acknowledge_playback(
+                int(played_ms),
+                committed_cursor,
+                response_id=response_id,
+            )
+        committed_history = False
+        if isinstance(item_id, str) and item_id:
+            committed_history = session.truncate_history_item(
+                item_id,
+                audio_end_ms=committed_cursor,
+                playback=playback,
+            )
+        elif session.pending_history_item_ids:
+            # A plain playback ack has no OpenAI item id. Commit the only
+            # uncommitted assistant candidate if the session has an unambiguous
+            # pending response; otherwise wait for conversation.item.truncate.
+            pending_ids = list(session.pending_history_item_ids)
+            if len(pending_ids) == 1:
+                item_id = pending_ids[0]
+                committed_history = session.truncate_history_item(
+                    item_id,
+                    audio_end_ms=committed_cursor,
+                    playback=playback,
+                )
+        elif session.active_response_id is not None:
+            item_id = f"item_{session.active_response_id}"
+            committed_history = session.truncate_history_item(
+                item_id,
+                audio_end_ms=committed_cursor,
+                playback=playback,
+            )
+        elif session.last_assistant_full_message is not None:
+            if item_id is None and session.history_item_ids:
+                assistant_item_ids = [
+                    known_item_id
+                    for known_item_id, message in session.history_item_ids.items()
+                    if message.get("role") == "assistant"
+                ]
+                if len(assistant_item_ids) == 1:
+                    item_id = assistant_item_ids[0]
+            if isinstance(item_id, str) and item_id:
+                committed_history = session.truncate_history_item(
+                    item_id,
+                    audio_end_ms=committed_cursor,
+                    playback=playback,
+                )
+        await send_json(
+            {
+                "type": "playback.acknowledged",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "item_id": item_id,
+                "played_ms": int(played_ms),
+                "committed_ms": committed_cursor,
+                "truncate": event.get("truncate") is True,
+                "playback": playback.as_dict(),
+                "history_committed": committed_history,
+            }
+        )
+        if committed_history and committed_cursor >= max(playback.sent_ms, playback.generated_ms):
+            session.release_response_playback(response_id)
+
+    async def _cancel_active_response(
+        self,
+        session: DuplexSession,
+        active_task: asyncio.Task[None] | None,
+        send_json,
+        *,
+        reason: str,
+        notify: bool = True,
+    ) -> bool:
+        has_running_task = active_task is not None and not active_task.done()
+        if not has_running_task and session.active_request_id is None and session.active_response_id is None:
+            return False
+
+        old_epoch = session.epoch
+        old_request_id = session.active_request_id
+        old_response_id = session.active_response_id
+        committed_ms = session.playback.committed_ms
+        committed_message = session.end_response(
+            commit_text=self._should_commit_response_to_history(session, old_response_id),
+            playback_commit_policy=DuplexPlaybackCommitPolicy.ACK_ONLY.value,
+        )
+        if old_response_id is not None:
+            item_id = f"item_{old_response_id}"
+            if committed_message is not None:
+                session.register_history_item(item_id, committed_message)
+            elif committed_ms > 0:
+                session.truncate_history_item(item_id, audio_end_ms=committed_ms)
+        new_epoch, old_playback = self._advance_barge_in_epoch(session)
+        if old_request_id is not None:
+            await self._abort_request_background(
+                session,
+                old_request_id,
+                send_json,
+                notify=notify,
+            )
+        if has_running_task and active_task is not None:
+            active_task.cancel()
+            try:
+                await asyncio.wait_for(asyncio.gather(active_task, return_exceptions=True), timeout=0.25)
+            except asyncio.TimeoutError:
+                pass
+        if notify:
+            await send_json(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": old_response_id,
+                    "reason": reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+        return True
+
+    async def _abort_request_background(
+        self,
+        session: DuplexSession,
+        request_id: str,
+        send_json,
+        *,
+        notify: bool,
+    ) -> None:
+        try:
+            abort_internal = getattr(self._chat_service.engine_client, "_abort_internal_requests", None)
+            if callable(abort_internal):
+                result = abort_internal([request_id])
+            else:
+                result = self._chat_service.engine_client.abort([request_id])
+            if inspect.isawaitable(result):
+                await result
+        except Exception as exc:
+            logger.exception("Failed to abort duplex request %s: %s", request_id, exc)
+            if notify and session.state != DuplexSessionState.CLOSED:
+                await self._send_runtime_error(send_json, "runtime_abort_failed", exc, session=session)
+
+    async def _cancel_pending_input(self, session: DuplexSession, send_json, *, reason: str) -> None:
+        cancelled = session.cancel_pending_input()
+        self._advance_barge_in_epoch(session)
+        await send_json(
+            {
+                "type": "input.cancelled",
+                "session_id": session.session_id,
+                "reason": reason,
+                "epoch": session.epoch,
+                "cancelled": cancelled,
+            }
+        )
diff --git a/vllm_omni/experimental/fullduplex/openai/session_attachment.py b/vllm_omni/experimental/fullduplex/openai/session_attachment.py
new file mode 100644
index 000000000..b0faa65d2
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/session_attachment.py
@@ -0,0 +1,486 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+import json
+import secrets
+import time
+from collections import deque
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass, field
+from types import MappingProxyType
+
+
+class InvalidResumeTokenError(RuntimeError):
+    pass
+
+
+class DuplexJournalGapError(RuntimeError):
+    pass
+
+
+class DuplexJournalOverflowError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class ResumeToken:
+    plaintext: str = field(repr=False)
+
+    @classmethod
+    def generate(cls) -> ResumeToken:
+        return cls(secrets.token_urlsafe(32))
+
+
+@dataclass
+class DuplexResumeCredential:
+    token_digest: bytes
+
+    @classmethod
+    def from_token(cls, token: ResumeToken) -> DuplexResumeCredential:
+        return cls(token_digest=cls._digest(token.plaintext))
+
+    @staticmethod
+    def _digest(plaintext: str) -> bytes:
+        return hashlib.sha256(plaintext.encode("utf-8")).digest()
+
+    def verify(self, plaintext: str) -> bool:
+        return hmac.compare_digest(self.token_digest, self._digest(plaintext))
+
+    def rotate(self) -> ResumeToken:
+        token = ResumeToken.generate()
+        self.token_digest = self._digest(token.plaintext)
+        return token
+
+
+@dataclass(frozen=True)
+class DuplexTransportAttachment:
+    generation: int
+    send: Callable[[dict[str, object]], Awaitable[None]] = field(repr=False)
+    close: Callable[[str], Awaitable[None]] = field(repr=False)
+
+
+@dataclass(frozen=True)
+class JournalEntry:
+    sequence: int
+    created_monotonic: float
+    encoded_bytes: int
+    payload: Mapping[str, object] = field(repr=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "payload", MappingProxyType(dict(self.payload)))
+
+
+class DuplexEventJournal:
+    def __init__(
+        self,
+        *,
+        max_bytes: int,
+        ttl_s: float,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        if max_bytes <= 0:
+            raise ValueError("journal max_bytes must be positive")
+        if ttl_s <= 0:
+            raise ValueError("journal ttl_s must be positive")
+        self._max_bytes = max_bytes
+        self._ttl_s = ttl_s
+        self._clock = clock or time.monotonic
+        self._entries: deque[JournalEntry] = deque()
+        self._next_sequence = 1
+        self._dropped_through = 0
+        self._retained_bytes = 0
+        self._overflowed = False
+
+    @property
+    def retained_bytes(self) -> int:
+        return self._retained_bytes
+
+    @property
+    def overflowed(self) -> bool:
+        return self._overflowed
+
+    @property
+    def last_sequence(self) -> int:
+        return self._next_sequence - 1
+
+    def record(self, payload: Mapping[str, object]) -> JournalEntry:
+        if self._overflowed:
+            raise DuplexJournalOverflowError("duplex event journal already exceeded its byte limit")
+        self.prune()
+        sequence = self._next_sequence
+        sequenced_payload = dict(payload)
+        sequenced_payload["server_event_seq"] = sequence
+        encoded_bytes = len(
+            json.dumps(
+                sequenced_payload,
+                separators=(",", ":"),
+                ensure_ascii=False,
+            ).encode("utf-8")
+        )
+        if self._retained_bytes + encoded_bytes > self._max_bytes:
+            self._overflowed = True
+            raise DuplexJournalOverflowError(
+                f"duplex event journal byte limit exceeded: {self._retained_bytes + encoded_bytes} > {self._max_bytes}"
+            )
+        entry = JournalEntry(
+            sequence=sequence,
+            created_monotonic=self._clock(),
+            encoded_bytes=encoded_bytes,
+            payload=sequenced_payload,
+        )
+        self._entries.append(entry)
+        self._retained_bytes += encoded_bytes
+        self._next_sequence += 1
+        return entry
+
+    def acknowledge(self, sequence: int) -> int:
+        if sequence < 0:
+            raise ValueError("acknowledged sequence must not be negative")
+        if sequence > self.last_sequence:
+            raise ValueError(f"acknowledged sequence {sequence} is newer than journal head {self.last_sequence}")
+        removed = 0
+        while self._entries and self._entries[0].sequence <= sequence:
+            entry = self._entries.popleft()
+            self._retained_bytes -= entry.encoded_bytes
+            removed += 1
+        self._dropped_through = max(self._dropped_through, sequence)
+        return removed
+
+    def prune(self, now: float | None = None) -> int:
+        effective_now = self._clock() if now is None else now
+        cutoff = effective_now - self._ttl_s
+        removed = 0
+        while self._entries and self._entries[0].created_monotonic <= cutoff:
+            entry = self._entries.popleft()
+            self._retained_bytes -= entry.encoded_bytes
+            self._dropped_through = max(self._dropped_through, entry.sequence)
+            removed += 1
+        return removed
+
+    def replay_after(self, sequence: int) -> tuple[JournalEntry, ...]:
+        if sequence < 0:
+            raise ValueError("replay sequence must not be negative")
+        self.prune()
+        if self._overflowed:
+            raise DuplexJournalGapError("duplex event journal overflowed; replay is incomplete")
+        if sequence < self._dropped_through:
+            raise DuplexJournalGapError(
+                f"requested sequence {sequence} is older than retained journal boundary {self._dropped_through}"
+            )
+        if sequence > self.last_sequence:
+            raise ValueError(f"requested sequence {sequence} is newer than journal head {self.last_sequence}")
+        return tuple(entry for entry in self._entries if entry.sequence > sequence)
+
+
+@dataclass(frozen=True)
+class DuplexSessionAttachmentCreated:
+    session_id: str
+    incarnation: int
+    attachment_generation: int
+    resume_token: ResumeToken = field(repr=False)
+
+
+@dataclass(frozen=True)
+class DuplexSessionResumeResult:
+    session_id: str
+    incarnation: int
+    attachment_generation: int
+    resume_token: ResumeToken = field(repr=False)
+    replay_entries: tuple[JournalEntry, ...] = ()
+    replaced_attachment: DuplexTransportAttachment | None = None
+
+
+@dataclass
+class _DuplexSessionAttachmentState:
+    session_id: str
+    incarnation: int
+    credential: DuplexResumeCredential
+    journal: DuplexEventJournal
+    attachment: DuplexTransportAttachment | None
+    attachment_generation: int
+    outbound_lock: asyncio.Lock = field(default_factory=asyncio.Lock, repr=False)
+    recovery_token_digest: bytes | None = field(default=None, repr=False)
+    grace_task: asyncio.Task[None] | None = field(default=None, repr=False)
+
+
+class DuplexSessionAttachmentRegistry:
+    def __init__(
+        self,
+        *,
+        replay_ttl_s: float,
+        replay_max_bytes_per_session: int,
+        disconnect_grace_s: float = 30.0,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        if replay_ttl_s <= 0:
+            raise ValueError("replay_ttl_s must be positive")
+        if replay_max_bytes_per_session <= 0:
+            raise ValueError("replay_max_bytes_per_session must be positive")
+        if disconnect_grace_s <= 0:
+            raise ValueError("disconnect_grace_s must be positive")
+        self._replay_ttl_s = replay_ttl_s
+        self._replay_max_bytes_per_session = replay_max_bytes_per_session
+        self._disconnect_grace_s = disconnect_grace_s
+        self._clock = clock or time.monotonic
+        self._sessions: dict[str, _DuplexSessionAttachmentState] = {}
+        self._lock = asyncio.Lock()
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(session_ids={sorted(self._sessions)})"
+
+    async def create(
+        self,
+        session_id: str,
+        *,
+        incarnation: int,
+        send: Callable[[dict[str, object]], Awaitable[None]],
+        close: Callable[[str], Awaitable[None]],
+    ) -> DuplexSessionAttachmentCreated:
+        async with self._lock:
+            if session_id in self._sessions:
+                raise ValueError(f"duplex attachment session already exists: {session_id}")
+            token = ResumeToken.generate()
+            generation = 1
+            self._sessions[session_id] = _DuplexSessionAttachmentState(
+                session_id=session_id,
+                incarnation=incarnation,
+                credential=DuplexResumeCredential.from_token(token),
+                journal=DuplexEventJournal(
+                    max_bytes=self._replay_max_bytes_per_session,
+                    ttl_s=self._replay_ttl_s,
+                    clock=self._clock,
+                ),
+                attachment=DuplexTransportAttachment(
+                    generation=generation,
+                    send=send,
+                    close=close,
+                ),
+                attachment_generation=generation,
+            )
+            return DuplexSessionAttachmentCreated(
+                session_id=session_id,
+                incarnation=incarnation,
+                attachment_generation=generation,
+                resume_token=token,
+            )
+
+    async def send_event(
+        self,
+        session_id: str,
+        payload: Mapping[str, object],
+        *,
+        journal: bool = True,
+    ) -> JournalEntry | None:
+        """Sequence and dispatch one event to the current attachment.
+
+        The per-session lock keeps wire order equal to journal order without
+        serializing unrelated sessions. A detached session still records
+        replayable events, but has no transport side effect.
+        """
+        async with self._lock:
+            state = self._require(session_id)
+        async with state.outbound_lock:
+            async with self._lock:
+                if self._sessions.get(session_id) is not state:
+                    raise KeyError(f"unknown duplex attachment session: {session_id}")
+                entry = state.journal.record(payload) if journal else None
+                attachment = state.attachment
+                wire_payload = dict(entry.payload) if entry is not None else dict(payload)
+            if attachment is not None:
+                await attachment.send(wire_payload)
+            return entry
+
+    async def acknowledge(self, session_id: str, sequence: int) -> int:
+        async with self._lock:
+            return self._require(session_id).journal.acknowledge(sequence)
+
+    async def detach(
+        self,
+        session_id: str,
+        *,
+        attachment_generation: int,
+        on_grace_expired: Callable[[], Awaitable[None]] | None = None,
+    ) -> bool:
+        async with self._lock:
+            state = self._sessions.get(session_id)
+            if state is None or state.attachment_generation != attachment_generation:
+                return False
+            state.attachment = None
+            if state.grace_task is not None:
+                state.grace_task.cancel()
+            state.grace_task = (
+                asyncio.create_task(
+                    self._run_disconnect_grace(
+                        state,
+                        attachment_generation=attachment_generation,
+                        callback=on_grace_expired,
+                    )
+                )
+                if on_grace_expired is not None
+                else None
+            )
+            return True
+
+    async def is_current_attachment(self, session_id: str, attachment_generation: int) -> bool:
+        async with self._lock:
+            state = self._sessions.get(session_id)
+            return (
+                state is not None
+                and state.attachment is not None
+                and state.attachment_generation == attachment_generation
+            )
+
+    async def authenticate_resume(
+        self,
+        session_id: str,
+        *,
+        incarnation: int,
+        resume_token: str,
+        last_received_server_event_seq: int,
+    ) -> None:
+        """Validate transport credentials before any engine resume control."""
+        async with self._lock:
+            state = self._require(session_id)
+            self._validate_resume_identity(
+                state,
+                incarnation=incarnation,
+                resume_token=resume_token,
+            )
+            state.journal.replay_after(last_received_server_event_seq)
+
+    async def resume(
+        self,
+        session_id: str,
+        *,
+        incarnation: int,
+        resume_token: str,
+        last_received_server_event_seq: int,
+        send: Callable[[dict[str, object]], Awaitable[None]],
+        close: Callable[[str], Awaitable[None]],
+        activation_payload_factory: Callable[[ResumeToken, int], Mapping[str, object]] | None = None,
+    ) -> DuplexSessionResumeResult:
+        async with self._lock:
+            state = self._require(session_id)
+        async with state.outbound_lock:
+            async with self._lock:
+                if self._sessions.get(session_id) is not state:
+                    raise KeyError(f"unknown duplex attachment session: {session_id}")
+                used_recovery = self._validate_resume_identity(
+                    state,
+                    incarnation=incarnation,
+                    resume_token=resume_token,
+                )
+                replay_entries = state.journal.replay_after(last_received_server_event_seq)
+                accepted_token_digest = (
+                    state.recovery_token_digest if used_recovery else bytes(state.credential.token_digest)
+                )
+                if state.grace_task is not None:
+                    state.grace_task.cancel()
+                    state.grace_task = None
+                state.recovery_token_digest = None
+                rotated_token = state.credential.rotate()
+                replaced = state.attachment
+                state.attachment_generation += 1
+                attachment_generation = state.attachment_generation
+                state.attachment = DuplexTransportAttachment(
+                    generation=attachment_generation,
+                    send=send,
+                    close=close,
+                )
+            if activation_payload_factory is not None:
+                try:
+                    await send(dict(activation_payload_factory(rotated_token, attachment_generation)))
+                    for entry in replay_entries:
+                        await send(dict(entry.payload))
+                except Exception:
+                    async with self._lock:
+                        if (
+                            self._sessions.get(session_id) is state
+                            and state.attachment_generation == attachment_generation
+                        ):
+                            state.attachment = None
+                            state.recovery_token_digest = accepted_token_digest
+                    raise
+            return DuplexSessionResumeResult(
+                session_id=session_id,
+                incarnation=incarnation,
+                attachment_generation=attachment_generation,
+                resume_token=rotated_token,
+                replay_entries=replay_entries,
+                replaced_attachment=replaced,
+            )
+
+    async def close(self, session_id: str) -> DuplexTransportAttachment | None:
+        async with self._lock:
+            state = self._sessions.pop(session_id, None)
+            if state is not None and state.grace_task is not None:
+                state.grace_task.cancel()
+            return state.attachment if state is not None else None
+
+    async def _run_disconnect_grace(
+        self,
+        state: _DuplexSessionAttachmentState,
+        *,
+        attachment_generation: int,
+        callback: Callable[[], Awaitable[None]] | None,
+    ) -> None:
+        try:
+            await asyncio.sleep(self._disconnect_grace_s)
+        except asyncio.CancelledError:
+            return
+        async with self._lock:
+            if (
+                self._sessions.get(state.session_id) is not state
+                or state.attachment is not None
+                or state.attachment_generation != attachment_generation
+            ):
+                return
+            state.grace_task = None
+        if callback is not None:
+            await callback()
+
+    def _require(self, session_id: str) -> _DuplexSessionAttachmentState:
+        state = self._sessions.get(session_id)
+        if state is None:
+            raise KeyError(f"unknown duplex attachment session: {session_id}")
+        return state
+
+    @staticmethod
+    def _validate_resume_identity(
+        state: _DuplexSessionAttachmentState,
+        *,
+        incarnation: int,
+        resume_token: str,
+    ) -> bool:
+        if incarnation != state.incarnation:
+            raise ValueError(f"duplex attachment incarnation mismatch: expected {state.incarnation}, got {incarnation}")
+        if state.credential.verify(resume_token):
+            return False
+        recovery_digest = state.recovery_token_digest
+        if (
+            state.attachment is None
+            and recovery_digest is not None
+            and hmac.compare_digest(recovery_digest, DuplexResumeCredential._digest(resume_token))
+        ):
+            return True
+        raise InvalidResumeTokenError(f"invalid resume token for duplex session {state.session_id}")
+
+
+__all__ = [
+    "DuplexEventJournal",
+    "DuplexJournalGapError",
+    "DuplexJournalOverflowError",
+    "DuplexResumeCredential",
+    "DuplexSessionAttachmentCreated",
+    "DuplexSessionAttachmentRegistry",
+    "DuplexSessionResumeResult",
+    "DuplexTransportAttachment",
+    "InvalidResumeTokenError",
+    "JournalEntry",
+    "ResumeToken",
+]
diff --git a/vllm_omni/experimental/fullduplex/openai/session_runner.py b/vllm_omni/experimental/fullduplex/openai/session_runner.py
new file mode 100644
index 000000000..4b5e4f2e6
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/session_runner.py
@@ -0,0 +1,1946 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+from contextlib import suppress
+from copy import deepcopy
+
+from fastapi import WebSocket, WebSocketDisconnect
+from vllm.logger import init_logger
+
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.openai.audio import convert_input_audio_with_rate
+from vllm_omni.experimental.fullduplex.openai.commit_policy import (
+    CommitAction,
+    CommitSnapshot,
+    decide_commit_action,
+)
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexPlaybackCommitPolicy,
+    DuplexSession,
+    DuplexSessionState,
+    DuplexTurnEventType,
+)
+from vllm_omni.experimental.fullduplex.openai.realtime_session import (
+    NativeRealtimeSessionProtocol,
+)
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    PcmAppendReservation,
+    ServingRuntimeSessionState,
+    payload_turn_id,
+)
+from vllm_omni.experimental.fullduplex.openai.session_attachment import (
+    DuplexJournalOverflowError,
+)
+from vllm_omni.experimental.fullduplex.openai.websocket import (
+    DuplexWebSocketActor,
+    is_input_event,
+    normalize_duplex_input_event,
+)
+
+logger = init_logger(__name__)
+
+_MAX_EVENT_BYTES = 15 * 1024 * 1024
+
+
+class DuplexSessionRunnerMixin:
+    """Run one ordered WebSocket mailbox for a duplex session."""
+
+    async def handle_session(
+        self,
+        websocket: WebSocket,
+        *,
+        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
+    ) -> None:
+        await websocket.accept()
+        session: DuplexSession | None = None
+        actor = DuplexWebSocketActor(
+            websocket,
+            current_epoch=lambda: session.epoch if session is not None else None,
+            session_closed=lambda: session is not None and session.state == DuplexSessionState.CLOSED,
+            outbound_protocol=realtime_protocol,
+        )
+        runtime_opened = False
+        runtime_closed = False
+        attachment_ready = False
+        attachment_generation: int | None = None
+        resume_credential_delivered = False
+        transport_detached = False
+        pending_turn_reservations = 0
+
+        async def attachment_send(payload: dict[str, object]) -> None:
+            nonlocal resume_credential_delivered
+            try:
+                await websocket.send_json(payload)
+            except RuntimeError as exc:
+                message = str(exc)
+                if "after sending 'websocket.close'" in message or "response already completed" in message:
+                    raise WebSocketDisconnect(code=1006) from exc
+                raise
+            if payload.get("type") == "session.created" and isinstance(payload.get("resume_token"), str):
+                resume_credential_delivered = True
+
+        async def attachment_close(reason: str) -> None:
+            close = getattr(websocket, "close", None)
+            if callable(close):
+                await close(code=1000, reason=reason)
+
+        async def send_attachment_payload(payload: dict[str, object], *, journal: bool) -> None:
+            assert session is not None
+            session_id = session.session_id
+            should_journal = journal and session_id not in self._resync_required_sessions
+            try:
+                await self._attachment_registry.send_event(
+                    session_id,
+                    payload,
+                    journal=should_journal,
+                )
+            except DuplexJournalOverflowError:
+                first_overflow = session_id not in self._resync_required_sessions
+                self._resync_required_sessions.add(session_id)
+                if first_overflow:
+                    resync_payload: dict[str, object] = {
+                        "type": "session.resync_required",
+                        "session_id": session_id,
+                        "reason": "journal_overflow",
+                    }
+                    if realtime_protocol is not None:
+                        resync_payload = realtime_protocol.encode_outbound_event(resync_payload)[0]
+                    await self._attachment_registry.send_event(
+                        session_id,
+                        resync_payload,
+                        journal=False,
+                    )
+                await self._attachment_registry.send_event(
+                    session_id,
+                    payload,
+                    journal=False,
+                )
+
+        if realtime_protocol is not None:
+
+            async def send_realtime_raw(payload: dict[str, object]) -> None:
+                if attachment_ready and session is not None:
+                    await send_attachment_payload(
+                        payload,
+                        journal=payload.get("type") not in {"session.created", "session.resumed"},
+                    )
+                    return
+                raw_payload = dict(payload)
+                raw_payload["_realtime_raw"] = True
+                await actor.send_json(raw_payload)
+
+            realtime_protocol.bind_sender(send_realtime_raw)
+        native: ServingRuntimeSessionState = self._serving_runtime_adapter.create_session_state()
+
+        def begin_close(reason: str) -> None:
+            actor.closing = True
+            actor.close_reason = reason
+            if session is not None:
+                session.mark_closing()
+
+        event_emit_lock = asyncio.Lock()
+
+        async def send_outbound(payload: dict[str, object]) -> None:
+            if not attachment_ready or session is None:
+                await actor.send_json(dict(payload))
+                return
+            if realtime_protocol is None:
+                await send_attachment_payload(
+                    payload,
+                    journal=payload.get("type") not in {"session.created", "session.resumed"},
+                )
+                return
+            for projected in realtime_protocol.encode_outbound_event(payload):
+                await send_attachment_payload(
+                    projected,
+                    journal=projected.get("type") not in {"session.created", "session.resumed"},
+                )
+
+        async def emit_event(payload: dict[str, object]) -> None:
+            deferred_precreate_response = False
+            async with event_emit_lock:
+                accepted, deferred_overlap_payload = await self._apply_outbound_session_event(
+                    payload,
+                    session=session,
+                    actor=actor,
+                    native=native,
+                    realtime_protocol=realtime_protocol,
+                )
+                if not accepted:
+                    return
+                await send_outbound(payload)
+                if deferred_overlap_payload is not None:
+                    deferred_precreate_response = native.deferred_precreate_response
+                    native.deferred_precreate_response = False
+            if deferred_overlap_payload is not None and session is not None and not actor.closing:
+                await start_native_append(
+                    deferred_overlap_payload,
+                    final=True,
+                    precreate_response=deferred_precreate_response,
+                    operation_id=native.committed_audio_operation_id,
+                    retained_committed_payload=(
+                        deferred_overlap_payload if native.committed_audio_payload is deferred_overlap_payload else None
+                    ),
+                )
+
+        writer_task = asyncio.create_task(actor.writer_loop(), name="duplex-session-writer")
+        reader_task: asyncio.Task[None] | None = None
+
+        async def read_event_loop() -> None:
+            nonlocal pending_turn_reservations
+            assert session is not None
+            try:
+                while not actor.closing:
+                    raw = await self._receive_text(
+                        websocket,
+                        session.config.idle_timeout_s,
+                        realtime_protocol=realtime_protocol,
+                    )
+                    if raw is None:
+                        await actor.enqueue_event({"type": "__timeout__"})
+                        return
+                    if len(raw.encode("utf-8")) > _MAX_EVENT_BYTES:
+                        await emit_event(
+                            {"type": "error", "error": "Duplex event too large", "code": "event_too_large"}
+                        )
+                        continue
+                    try:
+                        event = json.loads(raw)
+                    except json.JSONDecodeError:
+                        await emit_event({"type": "error", "error": "Invalid JSON event", "code": "invalid_json"})
+                        continue
+                    if not isinstance(event, dict):
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "Duplex event must be a JSON object",
+                                "code": "bad_event",
+                            }
+                        )
+                        continue
+                    event = normalize_duplex_input_event(event)
+                    event_type = event.get("type")
+                    if not isinstance(event_type, str):
+                        await emit_event(
+                            {"type": "error", "error": "Duplex event missing string type", "code": "bad_event"}
+                        )
+                        continue
+                    if event_type in {"input.commit", "input_audio_buffer.commit"}:
+                        if not session.reserve_pending_turn(
+                            limit=self._duplex_session_config.max_pending_turns_per_session
+                        ):
+                            await emit_event(
+                                {
+                                    "type": "error",
+                                    "error": "Duplex session has too many pending input turns",
+                                    "code": "input_backpressure",
+                                }
+                            )
+                            continue
+                        event["_duplex_pending_turn_reserved"] = True
+                        pending_turn_reservations += 1
+                    if is_input_event(event_type) and native_response_in_progress():
+                        event["_duplex_overlap_candidate"] = True
+                    await actor.enqueue_event(event)
+            except WebSocketDisconnect:
+                await actor.enqueue_event({"type": "__disconnect__"})
+
+        async def next_actor_event() -> dict[str, object]:
+            nonlocal pending_turn_reservations, transport_detached
+            event = await actor.next_event()
+            if event.pop("_duplex_pending_turn_reserved", False) and session is not None:
+                session.release_pending_turn()
+                pending_turn_reservations = max(0, pending_turn_reservations - 1)
+            if (
+                attachment_ready
+                and attachment_generation is not None
+                and session is not None
+                and not await self._attachment_registry.is_current_attachment(
+                    session.session_id,
+                    attachment_generation,
+                )
+            ):
+                transport_detached = True
+                return {"type": "__replaced_attachment__"}
+            return event
+
+        def native_response_in_progress() -> bool:
+            if session is None:
+                return False
+            if session.active_response_id is not None:
+                return True
+            if (
+                session.config.playback_commit_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
+                and session.playback.sent_ms > session.playback.committed_ms
+            ):
+                return True
+            if actor.active_response_task is not None and not actor.active_response_task.done():
+                return True
+            if actor.has_response_bound_append_tasks():
+                return True
+            return False
+
+        def clear_completed_pending_silence() -> None:
+            task = native.pending_silence_task
+            if task is not None and task.done():
+                native.pending_silence_task = None
+                native.pending_silence_owner_id = None
+
+        def mark_pending_silence_superseded() -> None:
+            task = native.pending_silence_task
+            if task is None:
+                return
+            if task.done():
+                native.pending_silence_task = None
+            # Do not cancel the task or clear native_append_tail here. A
+            # silence append may already have reached the Engine, and local
+            # cancellation cannot retract that RPC. The sequencer preserves
+            # wire order; before_append will skip silence that has not started.
+            native.pending_silence_owner_id = None
+
+        def real_native_input_waiting() -> bool:
+            clear_completed_pending_silence()
+            return (
+                native.audio_buffer.has_pending()
+                or native.audio_buffer.has_reserved()
+                or actor.has_queued_input_events()
+            )
+
+        async def start_native_append(
+            payload: object,
+            *,
+            final: bool,
+            precreate_response: bool = False,
+            pcm_reservation: PcmAppendReservation | None = None,
+            operation_id: str | None = None,
+            retained_committed_payload: dict[str, object] | None = None,
+            silence_continuation: bool = False,
+            before_append=None,
+        ) -> asyncio.Task[bool] | None:
+            if session is None:
+                return
+            if not silence_continuation:
+                mark_pending_silence_superseded()
+            append_epoch = session.epoch
+            append_turn_id = payload_turn_id(payload)
+            if append_turn_id is None:
+                append_turn_id = session.turn_id
+            request_id = self._native_stage0_request_id(session, append_epoch)
+            if final or precreate_response:
+                session.bind_request(request_id)
+            if precreate_response:
+                session.bind_response_turn(append_turn_id)
+            if precreate_response and session.active_response_id is None:
+                response_id = session.begin_response(turn_id=append_turn_id)
+                await emit_event(
+                    self._response_created_payload(
+                        session,
+                        response_id,
+                        epoch=append_epoch,
+                    )
+                )
+            precreated_response_id = session.active_response_id if precreate_response else None
+
+            async def _run() -> bool:
+                nonlocal runtime_closed
+                try:
+                    append_ok, emitted_response = await self._append_runtime_input(
+                        session,
+                        payload,
+                        operation_id=(pcm_reservation.operation_id if pcm_reservation is not None else operation_id),
+                        final=final,
+                        send_json=emit_event,
+                        mode="append_audio_chunk",
+                        expected_epoch=append_epoch,
+                    )
+                    if append_ok:
+                        if pcm_reservation is not None:
+                            pcm_reservation.commit()
+                            session.release_input_bytes(pcm_reservation.byte_count)
+                        if (
+                            retained_committed_payload is not None
+                            and native.committed_audio_payload is retained_committed_payload
+                        ):
+                            session.release_input_bytes(native.clear_committed_audio())
+                    elif pcm_reservation is not None:
+                        pcm_reservation.rollback()
+                    if (
+                        not append_ok
+                        and precreated_response_id is not None
+                        and session.active_response_id == precreated_response_id
+                    ):
+                        session.end_response(commit_text=False)
+                        await emit_event(
+                            {
+                                "type": "response.done",
+                                "session_id": session.session_id,
+                                "response_id": precreated_response_id,
+                                "epoch": session.epoch,
+                                "committed": False,
+                                "status": "failed",
+                                "status_details": {
+                                    "type": "failed",
+                                    "reason": "runtime_append_failed",
+                                },
+                                "playback": session.playback.as_dict(),
+                            }
+                        )
+                    if not append_ok and session.state == DuplexSessionState.CLOSED:
+                        runtime_closed = True
+                        return False
+                    if not emitted_response and session.epoch == append_epoch:
+                        if session.active_request_id == self._native_stage0_request_id(session, append_epoch):
+                            session.clear_request(request_id)
+                        if final:
+                            await emit_event(
+                                self._turn_controller.signal(session, DuplexTurnEventType.USER_STARTED.value)
+                            )
+                    return append_ok
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:
+                    if pcm_reservation is not None:
+                        pcm_reservation.rollback()
+                    logger.exception("Native duplex append task failed: %s", exc)
+                    await self._send_runtime_error(emit_event, "runtime_append_task_failed", exc, session=session)
+                    if session.state != DuplexSessionState.CLOSED:
+                        begin_close("runtime_append_task_failed")
+                        if await self._close_runtime_session(
+                            session,
+                            reason="runtime_append_task_failed",
+                            send_json=emit_event,
+                        ):
+                            runtime_closed = True
+                            session.close()
+                            await emit_event(
+                                {
+                                    "type": "session.closed",
+                                    "session_id": session.session_id,
+                                    "reason": "runtime_append_task_failed",
+                                }
+                            )
+                    return False
+
+            async def _run_in_wire_order(predecessor: asyncio.Task[bool] | None) -> bool:
+                if predecessor is not None:
+                    try:
+                        predecessor_ok = await predecessor
+                    except asyncio.CancelledError:
+                        current = asyncio.current_task()
+                        if current is not None and current.cancelling():
+                            raise
+                        predecessor_ok = False
+                    except Exception:
+                        predecessor_ok = False
+                    if not predecessor_ok:
+                        if pcm_reservation is not None:
+                            pcm_reservation.rollback()
+                        return False
+                if actor.closing or runtime_closed or session.state != DuplexSessionState.OPEN:
+                    if pcm_reservation is not None:
+                        pcm_reservation.rollback()
+                    return False
+                if before_append is not None and not before_append():
+                    if pcm_reservation is not None:
+                        pcm_reservation.rollback()
+                    return True
+                if pcm_reservation is not None and not pcm_reservation.active:
+                    return False
+                return await _run()
+
+            predecessor = actor.native_append_tail
+            if predecessor is not None and predecessor.done():
+                try:
+                    predecessor_ok = predecessor.result()
+                except (asyncio.CancelledError, Exception):
+                    predecessor_ok = False
+                if not predecessor_ok:
+                    # Appends already queued behind a failed predecessor keep
+                    # their captured dependency and stop. A later wire command
+                    # is an explicit retry and starts a new chain.
+                    predecessor = None
+            task = asyncio.create_task(_run_in_wire_order(predecessor))
+            actor.native_append_tail = task
+            actor.track_append_task(
+                task,
+                epoch=append_epoch,
+                mode="append_audio_chunk",
+                final=final,
+                response_bound=final or precreate_response,
+            )
+            if silence_continuation:
+                native.pending_silence_task = task
+
+                def _clear_done_pending_silence(done: asyncio.Task[bool]) -> None:
+                    if native.pending_silence_task is done:
+                        native.pending_silence_task = None
+                        native.pending_silence_owner_id = None
+
+                task.add_done_callback(_clear_done_pending_silence)
+            # Let this wire-order effect start before the next mailbox event can
+            # cancel it. Later native appends still serialize on predecessor.
+            await asyncio.sleep(0)
+            return task
+
+        async def schedule_native_silence_continuation(
+            payload: object,
+            *,
+            request_id: str,
+            owner_id: str,
+            response_id: str | None,
+            response_owned: bool,
+            expected_epoch: int | None,
+            expected_incarnation: int,
+            expected_model_turn_id: int | None,
+            send_json,
+        ) -> bool:
+            del send_json
+            if session is None:
+                return False
+            clear_completed_pending_silence()
+            pending_silence = native.pending_silence_task
+            if pending_silence is not None and not pending_silence.done():
+                if pending_silence is asyncio.current_task():
+                    return False
+                try:
+                    if not await pending_silence:
+                        return False
+                except asyncio.CancelledError:
+                    current = asyncio.current_task()
+                    if current is not None and current.cancelling():
+                        raise
+                    return False
+                except Exception:
+                    return False
+                clear_completed_pending_silence()
+                pending_silence = native.pending_silence_task
+                if pending_silence is not None and not pending_silence.done():
+                    return False
+            append_tail = actor.native_append_tail
+            if (append_tail is None or append_tail.done()) and real_native_input_waiting():
+                return False
+            continuation_delay_s = max(
+                0.0,
+                float(session.capabilities.chunk_period_ms or 1000) / 1000.0,
+            )
+            if continuation_delay_s > 0:
+                await asyncio.sleep(continuation_delay_s)
+                if (
+                    actor.native_append_tail is not append_tail
+                    or ((append_tail is None or append_tail.done()) and real_native_input_waiting())
+                    or self._native_silence_continuation_is_stale(
+                        session,
+                        request_id=request_id,
+                        response_id=response_id,
+                        response_owned=response_owned,
+                        expected_epoch=expected_epoch,
+                        expected_incarnation=expected_incarnation,
+                        expected_model_turn_id=expected_model_turn_id,
+                    )
+                ):
+                    return False
+
+            def _still_valid() -> bool:
+                return not real_native_input_waiting() and not self._native_silence_continuation_is_stale(
+                    session,
+                    request_id=request_id,
+                    response_id=response_id,
+                    response_owned=response_owned,
+                    expected_epoch=expected_epoch,
+                    expected_incarnation=expected_incarnation,
+                    expected_model_turn_id=expected_model_turn_id,
+                )
+
+            native.pending_silence_owner_id = owner_id
+            task = await start_native_append(
+                payload,
+                final=False,
+                silence_continuation=True,
+                before_append=_still_valid,
+            )
+            if task is None:
+                native.pending_silence_owner_id = None
+                return False
+            return True
+
+        async def wait_for_native_append_tail() -> bool:
+            predecessor = actor.native_append_tail
+            if predecessor is None:
+                return True
+            try:
+                return await predecessor
+            except asyncio.CancelledError:
+                current = asyncio.current_task()
+                if current is not None and current.cancelling():
+                    raise
+                return False
+            except Exception:
+                # The append task already emitted its runtime error. Preserve
+                # wire order before the update path decides whether to continue.
+                return False
+
+        async def start_runtime_append(
+            payload: object,
+            *,
+            final: bool,
+            mode: str = "append_tokens",
+        ) -> None:
+            """Schedule non-native runtime appends without blocking WS input.
+
+            Model-native appends use ``start_native_append`` because they can
+            create data-plane response streams. Generic runtime appends still
+            need the same control-plane isolation so cancel/close can preempt a
+            slow engine append.
+            """
+            if session is None:
+                return
+            append_epoch = session.epoch
+
+            async def _run() -> None:
+                nonlocal runtime_closed
+                try:
+                    append_ok, emitted_response = await self._append_runtime_input(
+                        session,
+                        payload,
+                        final=final,
+                        send_json=emit_event,
+                        mode=mode,
+                        expected_epoch=append_epoch,
+                    )
+                    if not append_ok:
+                        if session.state == DuplexSessionState.CLOSED:
+                            runtime_closed = True
+                        return
+                    if not emitted_response and session.epoch == append_epoch:
+                        await emit_event(self._turn_controller.signal(session, DuplexTurnEventType.USER_STARTED.value))
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:
+                    logger.exception("Duplex runtime append task failed: %s", exc)
+                    await self._send_runtime_error(emit_event, "runtime_append_task_failed", exc, session=session)
+
+            task = asyncio.create_task(_run())
+            actor.track_append_task(
+                task,
+                epoch=append_epoch,
+                mode=mode,
+                final=final,
+                response_bound=final,
+            )
+
+        try:
+            handshake = await self._open_session(
+                websocket,
+                emit_event,
+                realtime_protocol=realtime_protocol,
+                attachment_send=attachment_send,
+                attachment_close=attachment_close,
+            )
+            if handshake is None:
+                return
+            session = handshake.session
+            if handshake.resumed:
+                native = self._serving_runtime_adapter.session_states[session.session_id]
+                actor.tasks = self._session_tasks[session.session_id]
+                persisted_protocol = self._realtime_protocols.get(session.session_id)
+                if persisted_protocol is None:
+                    raise RuntimeError(f"Missing Realtime protocol state for resumed session {session.session_id}")
+                realtime_protocol = persisted_protocol
+                realtime_protocol.bind_sender(send_realtime_raw)
+                attachment_generation = handshake.attachment_generation
+                attachment_ready = True
+                resume_credential_delivered = True
+                runtime_opened = True
+                self._ensure_lifecycle_listener()
+                reader_task = asyncio.create_task(read_event_loop(), name="duplex-session-reader")
+            else:
+                self._serving_runtime_adapter.session_states[session.session_id] = native
+                self._session_tasks[session.session_id] = actor.tasks
+                if realtime_protocol is not None:
+                    self._realtime_protocols[session.session_id] = realtime_protocol
+            native.silence_continuation_scheduler = schedule_native_silence_continuation
+            if realtime_protocol is not None:
+                session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
+            if not handshake.resumed:
+                open_result = await self._open_runtime_session(session, emit_event)
+                if open_result is False:
+                    return
+                runtime_opened = True
+                created_attachment = await self._attachment_registry.create(
+                    session.session_id,
+                    incarnation=session.incarnation,
+                    send=attachment_send,
+                    close=attachment_close,
+                )
+                attachment_generation = created_attachment.attachment_generation
+                attachment_ready = True
+                self._lease_generations[session.session_id] = 0
+                self._ensure_lifecycle_listener()
+                created_payload: dict[str, object] = {
+                    "type": "session.created",
+                    "session": session.as_public_dict(),
+                }
+                if session.capabilities.supports_session_resume:
+                    created_payload.update(
+                        {
+                            "incarnation": session.incarnation,
+                            "attachment_generation": attachment_generation,
+                            "resume_token": created_attachment.resume_token.plaintext,
+                        }
+                    )
+                if isinstance(open_result, dict):
+                    created_payload["runtime_control"] = self._redact_runtime_control_result(open_result)
+                await emit_event(created_payload)
+                resume_credential_delivered = session.capabilities.supports_session_resume
+                reader_task = asyncio.create_task(read_event_loop(), name="duplex-session-reader")
+
+            while True:
+                event = await next_actor_event()
+                event_type = event.get("type")
+
+                if event_type == "__replaced_attachment__":
+                    return
+
+                if event_type == "__timeout__":
+                    begin_close("timeout")
+                    native.audio_buffer.clear()
+                    session.release_all_input_bytes()
+                    native.input_since_commit = False
+                    native.speech_since_commit = False
+                    native.clear_committed_audio()
+                    await actor.cancel_append_tasks()
+                    await self._cancel_native_data_plane_stream(session)
+                    await self._cancel_active_response(
+                        session,
+                        actor.active_response_task,
+                        emit_event,
+                        reason="timeout",
+                        notify=True,
+                    )
+                    actor.active_response_task = None
+                    runtime_closed = await self._close_runtime_session(
+                        session,
+                        reason="timeout",
+                        send_json=emit_event,
+                    )
+                    if not runtime_closed:
+                        return
+                    session.close()
+                    await emit_event(
+                        {
+                            "type": "session.closed",
+                            "session_id": session.session_id,
+                            "reason": "timeout",
+                        }
+                    )
+                    return
+
+                if event_type == "__disconnect__":
+                    transport_detached = True
+                    return
+
+                if not isinstance(event_type, str):
+                    continue
+
+                if event_type == "session.heartbeat":
+                    touch_session = getattr(self._chat_service.engine_client, "touch_duplex_session_async", None)
+                    if not callable(touch_session):
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "Duplex runtime does not expose heartbeat control",
+                                "code": "runtime_touch_unsupported",
+                            }
+                        )
+                        continue
+                    try:
+                        await touch_session(
+                            session.session_id,
+                            fence=DuplexFence(
+                                session.session_id,
+                                epoch=session.epoch,
+                                turn_id=session.turn_id,
+                                incarnation=session.incarnation,
+                            ),
+                            activity=DuplexLeaseActivity.HEARTBEAT,
+                        )
+                    except Exception as exc:
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": str(exc),
+                                "code": "runtime_touch_failed",
+                            }
+                        )
+                        continue
+                    await emit_event(
+                        {
+                            "type": "session.heartbeat_ack",
+                            "session_id": session.session_id,
+                        }
+                    )
+                    continue
+
+                if event_type == "session.event_ack":
+                    acknowledged = event.get("server_event_seq")
+                    if not isinstance(acknowledged, int) or acknowledged < 0:
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "session.event_ack requires a non-negative server_event_seq",
+                                "code": "invalid_event_ack",
+                            }
+                        )
+                        continue
+                    try:
+                        await self._attachment_registry.acknowledge(session.session_id, acknowledged)
+                    except ValueError as exc:
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": str(exc),
+                                "code": "invalid_event_ack",
+                            }
+                        )
+                    continue
+
+                if event_type == "turn.signal" and event.get("event") in {
+                    "input.cancel",
+                    "response.cancel",
+                    "barge_in",
+                }:
+                    payload = event.get("payload")
+                    normalized_event = dict(payload) if isinstance(payload, dict) else {}
+                    normalized_event.update(event)
+                    normalized_event["type"] = event["event"]
+                    event = normalized_event
+                    event_type = str(event["type"])
+
+                if event_type == "session.close":
+                    with suppress(asyncio.TimeoutError):
+                        await asyncio.wait_for(actor.output_queue.join(), timeout=1.0)
+                    begin_close("session_close")
+                    if session.state == DuplexSessionState.CLOSED:
+                        runtime_closed = True
+                        return
+                    native.audio_buffer.clear()
+                    session.release_all_input_bytes()
+                    native.input_since_commit = False
+                    native.speech_since_commit = False
+                    native.clear_committed_audio()
+                    await actor.cancel_append_tasks()
+                    await self._cancel_native_data_plane_stream(session)
+                    await self._cancel_active_response(
+                        session,
+                        actor.active_response_task,
+                        emit_event,
+                        reason="session_close",
+                    )
+                    runtime_closed = await self._close_runtime_session(
+                        session,
+                        reason="session_close",
+                        send_json=emit_event,
+                    )
+                    actor.active_response_task = None
+                    if not runtime_closed:
+                        return
+                    await emit_event({"type": "session.closed", "session_id": session.session_id})
+                    session.close()
+                    return
+
+                if event_type == "input_audio_buffer.clear":
+                    native.audio_buffer.clear()
+                    session.release_all_input_bytes()
+                    native.input_since_commit = False
+                    native.speech_since_commit = False
+                    native.clear_committed_audio()
+                    cancelled = session.cancel_pending_input()
+                    await emit_event(
+                        {
+                            "type": "input_audio_buffer.cleared",
+                            "session_id": session.session_id,
+                            "epoch": session.epoch,
+                            "drained_input_events": 0,
+                            "cancelled": cancelled,
+                        }
+                    )
+                    continue
+
+                if event_type == "barge_in" and not session.capabilities.supports_barge_in:
+                    await emit_event(self._barge_in_unsupported_error(session))
+                    continue
+
+                if event_type in {"input.cancel", "response.cancel", "barge_in", "output_audio_buffer.clear"}:
+                    cancel_reason = (
+                        "output_audio_buffer_clear" if event_type == "output_audio_buffer.clear" else "barge_in"
+                    )
+                    cancelled_fence = DuplexFence(
+                        session.session_id,
+                        epoch=session.epoch,
+                        turn_id=session.turn_id,
+                        incarnation=session.incarnation,
+                    )
+                    if event_type == "response.cancel":
+                        requested_response_id = event.get("response_id")
+                        has_active_response_work = native_response_in_progress()
+                        if (
+                            isinstance(requested_response_id, str)
+                            and session.active_response_id is not None
+                            and requested_response_id != session.active_response_id
+                        ):
+                            await emit_event(
+                                {
+                                    "type": "error",
+                                    "session_id": session.session_id,
+                                    "code": "response_not_active",
+                                    "error": f"Response is not active: {requested_response_id}",
+                                }
+                            )
+                            continue
+                        if not has_active_response_work:
+                            if realtime_protocol is not None and isinstance(requested_response_id, str):
+                                continue
+                            await emit_event(
+                                {
+                                    "type": "error",
+                                    "session_id": session.session_id,
+                                    "code": "response_not_active",
+                                    "error": "response.cancel requires an active response",
+                                }
+                            )
+                            continue
+                    had_native_unbuffered_append = (
+                        self._uses_native_input_append(session)
+                        and native.input_since_commit
+                        and not native.audio_buffer.has_pending()
+                    )
+                    playback_was_active = self._assistant_playback_active(session)
+                    if event_type in {"input.cancel", "barge_in"}:
+                        native.audio_buffer.clear()
+                        session.release_all_input_bytes()
+                        native.input_since_commit = False
+                        native.speech_since_commit = False
+                        native.clear_committed_audio()
+                    had_native_append = await actor.cancel_append_tasks(
+                        response_bound_only=event_type in {"response.cancel", "output_audio_buffer.clear"},
+                    )
+                    had_native_stream = native.data_plane_task is not None
+                    cancelled = await self._cancel_active_response(
+                        session,
+                        actor.active_response_task,
+                        emit_event,
+                        reason=cancel_reason,
+                    )
+                    had_native_stream = await self._cancel_native_data_plane_stream(session) or had_native_stream
+                    if not cancelled and (had_native_stream or had_native_append or had_native_unbuffered_append):
+                        old_epoch = session.epoch
+                        old_response_id = session.active_response_id
+                        committed_ms = session.playback.committed_ms
+                        self._commit_played_response_history(session, old_response_id, committed_ms)
+                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
+                        await emit_event(
+                            {
+                                "type": "audio.cancelled",
+                                "session_id": session.session_id,
+                                "response_id": old_response_id,
+                                "reason": cancel_reason,
+                                "cancelled_epoch": old_epoch,
+                                "epoch": new_epoch,
+                                "committed_ms": committed_ms,
+                                "playback": old_playback,
+                            }
+                        )
+                        cancelled = True
+                    if not cancelled and playback_was_active:
+                        old_epoch = session.epoch
+                        committed_ms = session.playback.committed_ms
+                        self._commit_played_response_history(session, session.last_response_id, committed_ms)
+                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
+                        await emit_event(
+                            {
+                                "type": "audio.cancelled",
+                                "session_id": session.session_id,
+                                "response_id": session.last_response_id,
+                                "reason": cancel_reason,
+                                "cancelled_epoch": old_epoch,
+                                "epoch": new_epoch,
+                                "committed_ms": committed_ms,
+                                "playback": old_playback,
+                            }
+                        )
+                        cancelled = True
+                    if not cancelled and event_type == "response.cancel":
+                        old_epoch = session.epoch
+                        old_response_id = session.active_response_id
+                        committed_ms = session.playback.committed_ms
+                        self._commit_played_response_history(session, old_response_id, committed_ms)
+                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
+                        await emit_event(
+                            {
+                                "type": "audio.cancelled",
+                                "session_id": session.session_id,
+                                "response_id": old_response_id,
+                                "reason": cancel_reason,
+                                "cancelled_epoch": old_epoch,
+                                "epoch": new_epoch,
+                                "committed_ms": committed_ms,
+                                "playback": old_playback,
+                            }
+                        )
+                        cancelled = True
+                    if not cancelled and event_type == "output_audio_buffer.clear":
+                        old_playback = session.playback.as_dict()
+                        committed_ms = session.playback.committed_ms
+                        session.clear_playback_cursor()
+                        await emit_event(
+                            {
+                                "type": "audio.cancelled",
+                                "session_id": session.session_id,
+                                "response_id": session.active_response_id,
+                                "reason": cancel_reason,
+                                "cancelled_epoch": session.epoch,
+                                "epoch": session.epoch,
+                                "committed_ms": committed_ms,
+                                "playback": old_playback,
+                            }
+                        )
+                        actor.active_response_task = None
+                        continue
+                    if not cancelled:
+                        await self._cancel_pending_input(session, emit_event, reason="barge_in")
+                    if not await self._signal_runtime_session(
+                        session,
+                        "barge_in",
+                        emit_event,
+                        fence=cancelled_fence,
+                        next_fence=(
+                            DuplexFence(
+                                session.session_id,
+                                epoch=session.epoch,
+                                turn_id=session.turn_id,
+                                incarnation=session.incarnation,
+                            )
+                            if session.epoch > cancelled_fence.epoch
+                            else None
+                        ),
+                    ):
+                        continue
+                    actor.active_response_task = None
+                    continue
+
+                if event_type == "turn.signal":
+                    turn_event = event.get("event")
+                    if isinstance(turn_event, str):
+                        if turn_event == "barge_in" and not session.capabilities.supports_barge_in:
+                            await emit_event(self._barge_in_unsupported_error(session))
+                            continue
+                        if turn_event == "session.update":
+                            payload = event.get("payload")
+                            if not isinstance(payload, dict):
+                                await emit_event(
+                                    {
+                                        "type": "error",
+                                        "session_id": session.session_id,
+                                        "code": "bad_event",
+                                        "error": "session.update requires a session payload",
+                                    }
+                                )
+                                continue
+                            if not await wait_for_native_append_tail():
+                                continue
+                            runtime_update_error = self._runtime_session_update_error(session, payload)
+                            if runtime_update_error is not None:
+                                await emit_event(runtime_update_error)
+                                continue
+                            previous_config = session.config
+                            candidate_config = deepcopy(previous_config)
+                            session.replace_config(candidate_config)
+                            try:
+                                update_error = self._apply_session_update(session, payload)
+                            finally:
+                                session.replace_config(previous_config)
+                            if update_error is not None:
+                                await emit_event(update_error)
+                                continue
+                            runtime_update_error = self._runtime_session_candidate_update_error(
+                                session,
+                                candidate_config,
+                            )
+                            if runtime_update_error is not None:
+                                await emit_event(runtime_update_error)
+                                continue
+                            candidate_runtime_config = self._runtime_config_for_session_update(
+                                session,
+                                candidate_config,
+                            )
+                            if not await self._signal_runtime_session(
+                                session,
+                                turn_event,
+                                emit_event,
+                                session_config=candidate_config.as_dict(),
+                                runtime_config=candidate_runtime_config,
+                            ):
+                                continue
+                            session.replace_config(candidate_config)
+                            session.replace_runtime_config(candidate_runtime_config)
+                            await emit_event(
+                                {
+                                    "type": "session.updated",
+                                    "session": session.as_public_dict(),
+                                }
+                            )
+                            continue
+                        if turn_event == "conversation.item.create":
+                            payload = event.get("payload")
+                            item = payload.get("item") if isinstance(payload, dict) else None
+                            message = self._realtime_item_to_history_message(item)
+                            item_id = item.get("id") if isinstance(item, dict) else None
+                            if message is not None:
+                                session.append_history_message(message)
+                                session.register_history_item(item_id if isinstance(item_id, str) else None, message)
+                            await emit_event(
+                                {
+                                    "type": "conversation.item.created",
+                                    "session_id": session.session_id,
+                                    "item": item,
+                                    "created": message is not None,
+                                }
+                            )
+                            continue
+                        if turn_event == "conversation.item.delete":
+                            payload = event.get("payload")
+                            item_id = payload.get("item_id") if isinstance(payload, dict) else None
+                            deleted = session.delete_history_item(item_id) if isinstance(item_id, str) else False
+                            await emit_event(
+                                {
+                                    "type": "conversation.item.deleted",
+                                    "session_id": session.session_id,
+                                    "item_id": item_id,
+                                    "deleted": deleted,
+                                }
+                            )
+                            continue
+                        if turn_event == "conversation.item.truncate":
+                            payload = event.get("payload")
+                            item_id = payload.get("item_id") if isinstance(payload, dict) else None
+                            audio_end_ms = payload.get("audio_end_ms") if isinstance(payload, dict) else None
+                            truncated = (
+                                session.truncate_history_item(
+                                    item_id,
+                                    audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
+                                )
+                                if isinstance(item_id, str)
+                                else False
+                            )
+                            await emit_event(
+                                {
+                                    "type": "conversation.item.truncated",
+                                    "session_id": session.session_id,
+                                    "item_id": item_id,
+                                    "content_index": (
+                                        payload.get("content_index", 0) if isinstance(payload, dict) else 0
+                                    ),
+                                    "audio_end_ms": audio_end_ms,
+                                    "truncated": truncated,
+                                }
+                            )
+                            continue
+                        await emit_event(self._turn_controller.signal(session, turn_event, event))
+                    else:
+                        await emit_event({"type": "error", "error": "turn.signal requires event", "code": "bad_event"})
+                    continue
+
+                if event_type == "playback.ack":
+                    await self._handle_playback_ack(session, event, emit_event)
+                    continue
+
+                if event_type == "input.text.append":
+                    session.mark_user_input_activity()
+                    text = event.get("text")
+                    if not isinstance(text, str):
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "input.text.append requires text",
+                                "code": "bad_event",
+                            }
+                        )
+                        continue
+                    if self._uses_native_input_append(session):
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "The selected native duplex runtime accepts audio append only",
+                                "code": "native_text_append_unsupported",
+                            }
+                        )
+                        continue
+                    else:
+                        session.append_text(text)
+                    if session.capabilities.supports_input_append:
+                        await start_runtime_append(text, final=False, mode="append_tokens")
+                    continue
+
+                if event_type == "input_audio_buffer.append":
+                    session.mark_user_input_activity()
+                    audio = event.get("audio") or event.get("data")
+                    if not isinstance(audio, str):
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "input.audio.append requires audio",
+                                "code": "bad_event",
+                            }
+                        )
+                        continue
+                    if not session.capabilities.supports_barge_in and self._event_requests_barge_in(event):
+                        await emit_event(self._barge_in_unsupported_error(session))
+                        event = dict(event)
+                        event.pop("force_barge_in", None)
+                        for key in ("overlap_action", "overlap"):
+                            value = event.get(key)
+                            if isinstance(value, str) and value.strip().lower() in {
+                                "barge_in",
+                                "interrupt",
+                                "cancel",
+                            }:
+                                event.pop(key, None)
+                    fmt = event.get("format") if isinstance(event.get("format"), str) else "pcm16"
+                    default_sample_rate_hz = 16000
+                    sr_raw = event.get("sample_rate_hz") or event.get("sample_rate")
+                    sample_rate_hz = sr_raw if isinstance(sr_raw, int | float) else default_sample_rate_hz
+                    try:
+                        audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
+                            audio,
+                            fmt,
+                            sample_rate_hz=sample_rate_hz,
+                        )
+                    except ValueError as exc:
+                        await emit_event({"type": "error", "error": str(exc), "code": "bad_event"})
+                        continue
+                    if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le"}:
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "error": "input_audio_buffer.append pcm16 audio could not be decoded",
+                                "code": "bad_audio",
+                            }
+                        )
+                        continue
+                    force_listen = bool(event.get("force_listen", False))
+                    payload = {
+                        "type": "audio",
+                        "audio": audio,
+                        "format": fmt,
+                        "sample_rate_hz": sample_rate_hz,
+                        "force_listen": force_listen,
+                    }
+                    video_frames = event.get("video_frames")
+                    if isinstance(video_frames, list):
+                        frames = [frame for frame in video_frames if isinstance(frame, str) and frame]
+                        if frames:
+                            payload["video_frames"] = frames
+                    # Speech/silence tag for the Stage0 turn-ended latch.
+                    payload["is_speech"] = self._input_looks_like_speech(event, payload, session=session)
+                    defer_native_append = False
+                    buffer_overlap_audio = True
+                    if self._uses_native_input_append(session):
+                        mark_pending_silence_superseded()
+                        overlap_active = not self._session_auto_responds(session) and native_response_in_progress()
+                        if overlap_active:
+                            decision = self._overlap_decision(session, event, payload)
+                            await self._emit_overlap_decision(emit_event, session, decision)
+                            action = decision.get("action")
+                            if action == "drop":
+                                if realtime_protocol is not None:
+                                    await realtime_protocol.discard_pending_input_audio(
+                                        audio_end_ms=self._input_audio_duration_ms(event, payload)
+                                    )
+                                continue
+                            if action == "listen":
+                                buffer_overlap_audio = bool(decision.get("buffer_audio", True))
+                                defer_native_append = bool(decision.get("defer_runtime_append", True))
+                                if (
+                                    not buffer_overlap_audio
+                                    and realtime_protocol is not None
+                                    and decision.get("preserve_realtime_input") is not True
+                                ):
+                                    await realtime_protocol.discard_pending_input_audio(
+                                        audio_end_ms=self._input_audio_duration_ms(event, payload)
+                                    )
+                                if decision.get("force_listen", True) is True:
+                                    payload["force_listen"] = True
+                            else:
+                                event["force_barge_in"] = True
+                                cancelled_fence = DuplexFence(
+                                    session.session_id,
+                                    epoch=session.epoch,
+                                    turn_id=session.turn_id,
+                                    incarnation=session.incarnation,
+                                )
+                                playback_was_active = self._assistant_playback_active(session)
+                                buffer_overlap_audio = True
+                                defer_native_append = False
+                                native.audio_buffer.clear_force_listen()
+                                session.reset_overlap_speech()
+                                native.input_since_commit = False
+                                native.speech_since_commit = False
+                                await actor.cancel_append_tasks()
+                                had_native_stream = native.data_plane_task is not None
+                                cancelled = await self._cancel_active_response(
+                                    session,
+                                    actor.active_response_task,
+                                    emit_event,
+                                    reason="barge_in",
+                                )
+                                had_native_stream = (
+                                    await self._cancel_native_data_plane_stream(session) or had_native_stream
+                                )
+                                if not cancelled and had_native_stream:
+                                    old_epoch = session.epoch
+                                    old_response_id = session.active_response_id
+                                    committed_ms = session.playback.committed_ms
+                                    self._commit_played_response_history(session, old_response_id, committed_ms)
+                                    new_epoch, old_playback = self._advance_barge_in_epoch(session)
+                                    await emit_event(
+                                        {
+                                            "type": "audio.cancelled",
+                                            "session_id": session.session_id,
+                                            "response_id": old_response_id,
+                                            "reason": "barge_in",
+                                            "cancelled_epoch": old_epoch,
+                                            "epoch": new_epoch,
+                                            "committed_ms": committed_ms,
+                                            "playback": old_playback,
+                                        }
+                                    )
+                                    cancelled = True
+                                if not cancelled and playback_was_active:
+                                    old_epoch = session.epoch
+                                    committed_ms = session.playback.committed_ms
+                                    self._commit_played_response_history(
+                                        session, session.last_response_id, committed_ms
+                                    )
+                                    new_epoch, old_playback = self._advance_barge_in_epoch(session)
+                                    await emit_event(
+                                        {
+                                            "type": "audio.cancelled",
+                                            "session_id": session.session_id,
+                                            "response_id": session.last_response_id,
+                                            "reason": "barge_in",
+                                            "cancelled_epoch": old_epoch,
+                                            "epoch": new_epoch,
+                                            "committed_ms": committed_ms,
+                                            "playback": old_playback,
+                                        }
+                                    )
+                                    cancelled = True
+                                if session.epoch > cancelled_fence.epoch:
+                                    if not await self._signal_runtime_session(
+                                        session,
+                                        "barge_in",
+                                        emit_event,
+                                        fence=cancelled_fence,
+                                        next_fence=DuplexFence(
+                                            session.session_id,
+                                            epoch=session.epoch,
+                                            turn_id=session.turn_id,
+                                            incarnation=session.incarnation,
+                                        ),
+                                    ):
+                                        continue
+                                actor.active_response_task = None
+                        elif not self._session_auto_responds(session) and not self._input_looks_like_speech(
+                            event, payload, session=session
+                        ):
+                            # Turn-mode only: skip silent chunks so they don't open a
+                            # response. In auto-respond (full-duplex) mode the model owns
+                            # the speak/listen decision and MUST receive silence units --
+                            # the official model typically starts speaking during the
+                            # silence after a question.
+                            await emit_event(
+                                {
+                                    "type": "response.listen",
+                                    "session_id": session.session_id,
+                                    "epoch": session.epoch,
+                                    "reason": "silence_or_noise",
+                                }
+                            )
+                            continue
+                        if self._should_force_listen_for_auto_response_overlap(session, event, payload):
+                            # Auto-response keeps a long-lived native Stage0 stream.
+                            # While assistant audio is still active, silence from the
+                            # browser should advance the model in listen mode rather
+                            # than letting the same stream start another assistant
+                            # segment. Speech/barge-in chunks remain model-owned.
+                            payload["force_listen"] = True
+                        if not buffer_overlap_audio:
+                            continue
+                        session.mark_user_input_activity()
+                        native.input_since_commit = True
+                        native.speech_since_commit = native.speech_since_commit or self._input_looks_like_speech(
+                            event, payload, session=session
+                        )
+                        try:
+                            raw_audio_bytes = self._native_audio_payload_size_bytes(payload)
+                            if not session.reserve_input_bytes(
+                                raw_audio_bytes,
+                                limit=self._duplex_session_config.max_pending_input_bytes_per_session,
+                            ):
+                                await emit_event(
+                                    {
+                                        "type": "error",
+                                        "error": "Duplex session pending input exceeds server limit",
+                                        "code": "input_backpressure",
+                                    }
+                                )
+                                continue
+                            allow_emit = not defer_native_append and (
+                                realtime_protocol is None
+                                or event_type != "input_audio_buffer.append"
+                                # Full-duplex: emit each ~chunk_period of audio so the model
+                                # runs per-chunk generation (speak/listen) without an explicit
+                                # response.create, matching the official duplex_generate loop.
+                                or self._session_auto_responds(session)
+                            )
+                            pcm_reservation = native.audio_buffer.prepare_append(
+                                payload,
+                                operation_id=uuid.uuid4().hex,
+                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+                                allow_emit=allow_emit,
+                            )
+                        except ValueError as exc:
+                            session.release_input_bytes(raw_audio_bytes)
+                            await emit_event({"type": "error", "error": str(exc), "code": "bad_event"})
+                            continue
+                        if pcm_reservation is None:
+                            continue
+                        if pcm_reservation.byte_count == 0:
+                            session.release_input_bytes(raw_audio_bytes)
+                        payload = pcm_reservation.payload
+                    else:
+                        session.append_audio(audio, fmt=fmt, sample_rate_hz=sample_rate_hz)
+                    if self._uses_native_input_append(session):
+                        await start_native_append(
+                            payload,
+                            final=False,
+                            pcm_reservation=pcm_reservation,
+                        )
+                        continue
+                    if session.capabilities.supports_input_append:
+                        await start_runtime_append(payload, final=False, mode="append_audio_chunk")
+                    continue
+
+                if event_type in {"input.commit", "input_audio_buffer.commit", "response.create"}:
+                    realtime_item_id = event.get("realtime_item_id")
+                    realtime_validated_audio_commit = (
+                        event_type == "input_audio_buffer.commit"
+                        and isinstance(realtime_item_id, str)
+                        and bool(realtime_item_id)
+                    )
+                    if (
+                        self._uses_native_input_append(session)
+                        and event_type in {"input.commit", "input_audio_buffer.commit"}
+                        and not await wait_for_native_append_tail()
+                    ):
+                        continue
+                    if event_type == "input_audio_buffer.commit" and event.get("is_speech") is False:
+                        native.input_since_commit = False
+                        native.speech_since_commit = False
+                        native.audio_buffer.clear()
+                        session.release_all_input_bytes()
+                        native.clear_committed_audio()
+                        await emit_event(
+                            {
+                                "type": "input.committed",
+                                "session_id": session.session_id,
+                                "turn_id": session.turn_id,
+                                "epoch": session.epoch,
+                                "empty": True,
+                                "is_speech": False,
+                                "no_response": True,
+                            }
+                        )
+                        await emit_event(
+                            {
+                                "type": "response.listen",
+                                "session_id": session.session_id,
+                                "epoch": session.epoch,
+                                "reason": "silence_or_noise",
+                            }
+                        )
+                        continue
+                    should_create_response = (
+                        event_type == "response.create"
+                        or bool(event.get("response_create", event_type == "input.commit"))
+                        or (event_type == "input_audio_buffer.commit" and self._session_auto_responds(session))
+                    )
+                    precreate_response_requested = event_type == "response.create" or bool(
+                        event.get("response_create", event_type == "input.commit")
+                    )
+                    if event_type == "response.create":
+                        response_payload = event.get("response")
+                        if isinstance(response_payload, dict):
+                            response_options_error = self._apply_response_create_options(session, response_payload)
+                            if response_options_error is not None:
+                                error_message = (
+                                    "The selected native duplex runtime does not support generation "
+                                    "overrides for instructions, voice, temperature, max tokens, tools, or "
+                                    "tool_choice."
+                                    if response_options_error == "unsupported_native_response_options"
+                                    else "response.create cannot reserve options while another response is active."
+                                )
+                                await emit_event(
+                                    {
+                                        "type": "error",
+                                        "session_id": session.session_id,
+                                        "epoch": session.epoch,
+                                        "code": response_options_error,
+                                        "error": error_message,
+                                    }
+                                )
+                                continue
+                    if self._uses_native_input_append(session) and event_type == "input_audio_buffer.commit":
+                        has_pending_native_audio = (
+                            native.input_since_commit
+                            or native.audio_buffer.has_pending()
+                            or native.committed_audio_payload is not None
+                            or realtime_validated_audio_commit
+                        )
+                        if (
+                            not has_pending_native_audio
+                            and not actor.native_append_tasks
+                            and native.data_plane_task is None
+                        ):
+                            await emit_event(
+                                {
+                                    "type": "error",
+                                    "session_id": session.session_id,
+                                    "epoch": session.epoch,
+                                    "code": "input_audio_buffer_empty",
+                                    "error": "input_audio_buffer.commit requires a non-empty input audio buffer.",
+                                }
+                            )
+                            continue
+                        commit_action = decide_commit_action(
+                            CommitSnapshot(
+                                auto_responds=self._session_auto_responds(session),
+                                speech_since_commit=native.speech_since_commit,
+                                active_response_id=session.active_response_id,
+                                overlap_speech_ms=session.overlap_speech_ms,
+                                native_response_in_progress=native_response_in_progress(),
+                                playback_active=self._assistant_playback_active(session),
+                            )
+                        )
+                        if commit_action is CommitAction.DEFER_ACTIVE_RESPONSE:
+                            if session.overlap_speech_ms <= session.config.overlap_short_ack_ms:
+                                native.audio_buffer.clear()
+                                session.release_all_input_bytes()
+                                native.input_since_commit = False
+                                native.speech_since_commit = False
+                                native.clear_committed_audio()
+                                if realtime_protocol is not None:
+                                    await realtime_protocol.discard_pending_input_audio(
+                                        audio_end_ms=session.overlap_speech_ms
+                                    )
+                                await emit_event(
+                                    {
+                                        "type": "input.committed",
+                                        "session_id": session.session_id,
+                                        "turn_id": session.turn_id,
+                                        "epoch": session.epoch,
+                                        "empty": True,
+                                        "is_speech": False,
+                                        "overlap_ack": True,
+                                        "no_response": True,
+                                    }
+                                )
+                                session.reset_overlap_speech()
+                                session.discard_response_options()
+                                continue
+
+                            commit_reservation = native.audio_buffer.prepare_commit(
+                                operation_id=uuid.uuid4().hex,
+                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+                            )
+                            deferred_payload = commit_reservation.payload
+                            if deferred_payload is None:
+                                commit_reservation.commit()
+                            else:
+                                if native.committed_audio_payload is not None:
+                                    deferred_payload = self._merge_native_audio_payloads(
+                                        native.committed_audio_payload,
+                                        deferred_payload,
+                                    )
+                                native.retain_committed_audio(
+                                    deferred_payload,
+                                    operation_id=commit_reservation.operation_id,
+                                    reserved_bytes=commit_reservation.byte_count,
+                                )
+                                commit_reservation.commit()
+                                native.deferred_response_create = should_create_response
+                                native.deferred_precreate_response = precreate_response_requested
+                                native.input_since_commit = False
+                                native.speech_since_commit = False
+                                committed = self._commit_native_audio_input(
+                                    session,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                                committed_payload = self._native_audio_committed_payload(
+                                    session,
+                                    committed=committed,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                                committed_payload["overlap_deferred"] = True
+                                committed_payload["response_create_deferred"] = should_create_response
+                                await emit_event(committed_payload)
+                                continue
+                        if commit_action is CommitAction.START_AUTO_RESPONSE:
+                            commit_reservation = native.audio_buffer.prepare_commit(
+                                operation_id=uuid.uuid4().hex,
+                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+                            )
+                            committed_input = commit_reservation.payload
+                            final_payload = committed_input
+                            if native.committed_audio_payload is not None:
+                                if final_payload is not None:
+                                    final_payload = self._merge_native_audio_payloads(
+                                        native.committed_audio_payload,
+                                        final_payload,
+                                    )
+                                else:
+                                    final_payload = native.committed_audio_payload
+                            commit_reservation.commit()
+                            if final_payload is not None:
+                                native.retain_committed_audio(
+                                    final_payload,
+                                    operation_id=commit_reservation.operation_id,
+                                    reserved_bytes=commit_reservation.byte_count,
+                                )
+                            native.deferred_response_create = False
+                            native.input_since_commit = False
+                            native.speech_since_commit = False
+                            data_plane_turn_id = session.turn_id
+                            committed = self._commit_native_audio_input(
+                                session,
+                                realtime_item_id=event.get("realtime_item_id"),
+                                transcript=event.get("transcript"),
+                                turn_id=data_plane_turn_id,
+                            )
+                            await emit_event(
+                                self._native_audio_committed_payload(
+                                    session,
+                                    committed=committed,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                            )
+                            if final_payload is not None:
+                                await start_native_append(
+                                    {
+                                        **final_payload,
+                                        "duplex_turn_id": data_plane_turn_id,
+                                    },
+                                    final=True,
+                                    precreate_response=False,
+                                    operation_id=commit_reservation.operation_id,
+                                    retained_committed_payload=final_payload,
+                                )
+                            continue
+                    if self._uses_native_input_append(session) and event_type == "response.create":
+                        if (
+                            native_response_in_progress()
+                            or actor.native_append_tasks
+                            or native.data_plane_task is not None
+                        ):
+                            if session.active_response_id is None and (
+                                session.active_request_id is not None
+                                or actor.native_append_tasks
+                                or native.data_plane_task is not None
+                            ):
+                                continue
+                            await emit_event(
+                                {
+                                    "type": "error",
+                                    "session_id": session.session_id,
+                                    "epoch": session.epoch,
+                                    "code": "response_already_active",
+                                    "error": "response.create cannot start while another response is active.",
+                                }
+                            )
+                            session.discard_response_options()
+                            continue
+                        if native.committed_audio_payload is not None:
+                            committed_payload = native.committed_audio_payload
+                            operation_id = native.committed_audio_operation_id
+                            if operation_id is None:
+                                operation_id = uuid.uuid4().hex
+                                native.committed_audio_operation_id = operation_id
+                            await start_native_append(
+                                committed_payload,
+                                final=True,
+                                precreate_response=True,
+                                operation_id=operation_id,
+                                retained_committed_payload=committed_payload,
+                            )
+                            continue
+                        await emit_event(
+                            {
+                                "type": "error",
+                                "session_id": session.session_id,
+                                "epoch": session.epoch,
+                                "code": "response_create_without_input",
+                                "error": "Native duplex response.create requires committed audio input.",
+                            }
+                        )
+                        session.discard_response_options()
+                        continue
+                    if self._uses_native_input_append(session) and not native_response_in_progress():
+                        commit_reservation = (
+                            native.audio_buffer.prepare_commit(
+                                operation_id=uuid.uuid4().hex,
+                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+                            )
+                            if event_type in {"input.commit", "input_audio_buffer.commit"}
+                            else None
+                        )
+                        flushed_buffer_reserved_bytes = (
+                            native.audio_buffer.pending_byte_count if commit_reservation is None else 0
+                        )
+                        flushed = (
+                            commit_reservation.payload
+                            if commit_reservation is not None
+                            else native.audio_buffer.flush(chunk_period_ms=session.capabilities.chunk_period_ms or 1000)
+                        )
+                        if native.committed_audio_payload is not None:
+                            if flushed is not None:
+                                flushed = self._merge_native_audio_payloads(
+                                    native.committed_audio_payload,
+                                    flushed,
+                                )
+                            else:
+                                flushed = native.committed_audio_payload
+                        if commit_reservation is not None:
+                            commit_reservation.commit()
+                        if flushed is not None:
+                            if self._should_force_listen_for_short_commit(session, event, flushed):
+                                flushed = dict(flushed)
+                                flushed["force_listen"] = True
+                            native.input_since_commit = False
+                            committed = self._commit_native_audio_input(
+                                session,
+                                realtime_item_id=event.get("realtime_item_id"),
+                                transcript=event.get("transcript"),
+                            )
+                            await emit_event(
+                                self._native_audio_committed_payload(
+                                    session,
+                                    committed=committed,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                            )
+                            if should_create_response:
+                                native.retain_committed_audio(
+                                    flushed,
+                                    operation_id=(
+                                        commit_reservation.operation_id
+                                        if commit_reservation is not None
+                                        else uuid.uuid4().hex
+                                    ),
+                                    reserved_bytes=(
+                                        commit_reservation.byte_count
+                                        if commit_reservation is not None
+                                        else flushed_buffer_reserved_bytes
+                                    ),
+                                )
+                                await start_native_append(
+                                    flushed,
+                                    final=True,
+                                    precreate_response=True,
+                                    operation_id=native.committed_audio_operation_id,
+                                    retained_committed_payload=flushed,
+                                )
+                            else:
+                                native.retain_committed_audio(
+                                    flushed,
+                                    operation_id=(
+                                        commit_reservation.operation_id
+                                        if commit_reservation is not None
+                                        else uuid.uuid4().hex
+                                    ),
+                                    reserved_bytes=(
+                                        commit_reservation.byte_count
+                                        if commit_reservation is not None
+                                        else flushed_buffer_reserved_bytes
+                                    ),
+                                )
+                                native.deferred_response_create = False
+                            continue
+                    native_had_uncommitted_audio = self._uses_native_input_append(session) and (
+                        native.input_since_commit
+                        or native.audio_buffer.has_pending()
+                        or native.committed_audio_payload is not None
+                        or realtime_validated_audio_commit
+                    )
+                    committed = session.commit_user_input()
+                    if self._uses_native_input_append(session) and event_type in {
+                        "input_audio_buffer.commit",
+                        "input.commit",
+                    }:
+                        native.input_since_commit = False
+                        native.speech_since_commit = False
+                    if committed is None and event_type != "response.create":
+                        if self._uses_native_input_append(session):
+                            committed = (
+                                self._commit_native_audio_input(
+                                    session,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                                if native_had_uncommitted_audio
+                                else None
+                            )
+                            await emit_event(
+                                self._native_audio_committed_payload(
+                                    session,
+                                    committed=committed,
+                                    realtime_item_id=event.get("realtime_item_id"),
+                                    transcript=event.get("transcript"),
+                                )
+                            )
+                        else:
+                            await emit_event(
+                                {
+                                    "type": "input.committed",
+                                    "session_id": session.session_id,
+                                    "empty": True,
+                                }
+                            )
+                        continue
+                    if committed is not None:
+                        realtime_item_id = event.get("realtime_item_id")
+                        if isinstance(realtime_item_id, str):
+                            session.register_history_item(realtime_item_id, committed.message)
+                        await emit_event(
+                            self._input_committed_payload(
+                                session,
+                                committed,
+                                realtime_item_id=realtime_item_id,
+                            )
+                        )
+                    if not should_create_response:
+                        continue
+                    if actor.active_response_task is not None and not actor.active_response_task.done():
+                        await self._cancel_active_response(
+                            session,
+                            actor.active_response_task,
+                            emit_event,
+                            reason="new_response",
+                        )
+                    actor.active_response_task = asyncio.create_task(self._run_response(session, emit_event))
+                    continue
+
+                await emit_event(
+                    {
+                        "type": "error",
+                        "error": f"Unknown duplex event: {event_type}",
+                        "code": "unknown_event",
+                    }
+                )
+
+        except WebSocketDisconnect:
+            logger.info("Duplex session disconnected")
+            transport_detached = True
+        except Exception as exc:
+            logger.exception("Duplex session failed: %s", exc)
+            with suppress(Exception):
+                await emit_event({"type": "error", "error": str(exc), "code": "internal_error"})
+        finally:
+            if session is not None:
+                if reader_task is not None and not reader_task.done():
+                    reader_task.cancel()
+                    with suppress(asyncio.CancelledError):
+                        await reader_task
+                while pending_turn_reservations > 0:
+                    session.release_pending_turn()
+                    pending_turn_reservations -= 1
+                resumable_detach = (
+                    transport_detached
+                    and runtime_opened
+                    and not runtime_closed
+                    and session.state == DuplexSessionState.OPEN
+                    and session.capabilities.supports_session_resume
+                    and attachment_generation is not None
+                    and resume_credential_delivered
+                )
+                if resumable_detach:
+
+                    async def cancel_orphan_response_after_grace() -> None:
+                        tasks = self._session_tasks.get(session.session_id)
+                        current_session = self._registry.get(session.session_id)
+                        if tasks is None or current_session is not session or session.state != DuplexSessionState.OPEN:
+                            return
+                        await tasks.cancel_append_tasks(response_bound_only=True)
+                        await self._cancel_native_data_plane_stream(session)
+                        await self._cancel_active_response(
+                            session,
+                            tasks.active_response_task,
+                            emit_event,
+                            reason="disconnect_grace_expired",
+                            notify=False,
+                        )
+                        tasks.active_response_task = None
+
+                    detached = await self._attachment_registry.detach(
+                        session.session_id,
+                        attachment_generation=attachment_generation,
+                        on_grace_expired=cancel_orphan_response_after_grace,
+                    )
+                    touch_session = getattr(self._chat_service.engine_client, "touch_duplex_session_async", None)
+                    if detached and callable(touch_session):
+                        with suppress(Exception):
+                            await touch_session(
+                                session.session_id,
+                                fence=DuplexFence(
+                                    session.session_id,
+                                    epoch=session.epoch,
+                                    turn_id=session.turn_id,
+                                    incarnation=session.incarnation,
+                                ),
+                                activity=DuplexLeaseActivity.DETACH,
+                            )
+                else:
+                    begin_close(actor.close_reason or "disconnect")
+                    await actor.cancel_append_tasks()
+                    await self._cancel_native_data_plane_stream(session)
+                    await self._cancel_active_response(
+                        session,
+                        actor.active_response_task,
+                        emit_event,
+                        reason="disconnect",
+                        notify=False,
+                    )
+                    if runtime_opened and not runtime_closed and session.state != DuplexSessionState.CLOSED:
+                        await self._close_runtime_session(session, reason="disconnect")
+                    self._cleanup_duplex_session_state(session)
+                    self._registry.close(session.session_id)
+                    self._session_tasks.pop(session.session_id, None)
+                    self._realtime_protocols.pop(session.session_id, None)
+                    self._lease_generations.pop(session.session_id, None)
+                    self._resync_required_sessions.discard(session.session_id)
+                    with suppress(Exception):
+                        await self._attachment_registry.close(session.session_id)
+                    self._stop_lifecycle_listener_if_idle()
+            await actor.close_writer()
+            with suppress(Exception):
+                await asyncio.wait_for(actor.output_queue.join(), timeout=2.0)
+            if not writer_task.done():
+                writer_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await writer_task
diff --git a/vllm_omni/experimental/fullduplex/openai/websocket.py b/vllm_omni/experimental/fullduplex/openai/websocket.py
new file mode 100644
index 000000000..18cd11c8d
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/openai/websocket.py
@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from fastapi import WebSocketDisconnect
+
+INPUT_EVENTS = frozenset(
+    {
+        "input.text.append",
+        "input_audio_buffer.append",
+        "input.commit",
+        "input_audio_buffer.commit",
+        "response.create",
+    }
+)
+
+_INPUT_EVENT_ALIASES = {
+    "signal_turn": "turn.signal",
+    "close_session": "session.close",
+    "audio.playback_ack": "playback.ack",
+    "input_text.append": "input.text.append",
+    "push_text": "input.text.append",
+    "input.audio.append": "input_audio_buffer.append",
+    "push_chunk": "input_audio_buffer.append",
+}
+_WAV_AUDIO_ALIASES = frozenset({"input.audio.append", "push_chunk"})
+
+
+def normalize_duplex_input_event(event: dict[str, object]) -> dict[str, object]:
+    """Normalize compatibility aliases before an event enters the mailbox."""
+    event_type = event.get("type")
+    if not isinstance(event_type, str):
+        return event
+    canonical_type = _INPUT_EVENT_ALIASES.get(event_type)
+    if canonical_type is None:
+        return event
+    normalized = dict(event)
+    normalized["type"] = canonical_type
+    if event_type in _WAV_AUDIO_ALIASES:
+        normalized.setdefault("format", "wav")
+    return normalized
+
+
+MODEL_OUTPUT_EVENTS = frozenset(
+    {
+        "response.created",
+        "response.listen",
+        "response.speak",
+        "response.output_item.added",
+        "response.content_part.added",
+        "response.output_audio.delta",
+        "response.audio.delta",
+        "response.output_audio.done",
+        "response.audio.done",
+        "response.output_text.delta",
+        "response.output_text.done",
+        "response.text.delta",
+        "response.text.done",
+        "response.message",
+        "response.output_item.done",
+        "response.content_part.done",
+        "response.done",
+        "runtime.control",
+    }
+)
+DOMAIN_TERMINAL_EVENTS = frozenset(
+    {
+        "response.done",
+        "response.listen",
+        "audio.cancelled",
+        "input.cancelled",
+        "session.closed",
+    }
+)
+
+
+def is_input_event(event_type: object) -> bool:
+    return isinstance(event_type, str) and event_type in INPUT_EVENTS
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexAppendTaskMeta:
+    epoch: int
+    mode: str
+    final: bool
+    response_bound: bool
+
+
+@dataclass
+class DuplexSessionTasks:
+    """Connection-independent task handles for one resumable session."""
+
+    native_append_tasks: dict[asyncio.Task[bool], DuplexAppendTaskMeta] = field(default_factory=dict)
+    native_append_tail: asyncio.Task[bool] | None = None
+    active_response_task: asyncio.Task[None] | None = None
+
+    def track_append_task(
+        self,
+        task: asyncio.Task[bool],
+        *,
+        epoch: int,
+        mode: str,
+        final: bool,
+        response_bound: bool,
+    ) -> None:
+        self.native_append_tasks[task] = DuplexAppendTaskMeta(epoch, mode, final, response_bound)
+        task.add_done_callback(self.native_append_tasks.pop)
+
+    def has_response_bound_append_tasks(self) -> bool:
+        return any(meta.response_bound for meta in self.native_append_tasks.values())
+
+    async def cancel_append_tasks(self, timeout_s: float = 0.25, *, response_bound_only: bool = False) -> bool:
+        tasks = [
+            task for task, meta in self.native_append_tasks.items() if not response_bound_only or meta.response_bound
+        ]
+        if not tasks:
+            return False
+        for task in tasks:
+            task.cancel()
+        try:
+            await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), timeout=timeout_s)
+        except TimeoutError:
+            pass
+        return True
+
+
+@dataclass
+class DuplexWebSocketActor:
+    """Own ordered WebSocket I/O queues, but no domain identity."""
+
+    websocket: Any
+    current_epoch: Callable[[], int | None] | None = None
+    session_closed: Callable[[], bool] | None = None
+    output_queue: asyncio.Queue[dict[str, object] | None] = field(default_factory=asyncio.Queue)
+    mailbox: asyncio.Queue[dict[str, object]] = field(default_factory=asyncio.Queue)
+    outbound_protocol: Any | None = None
+    tasks: DuplexSessionTasks = field(default_factory=DuplexSessionTasks)
+    closing: bool = False
+    close_reason: str | None = None
+    stale_output_dropped: int = 0
+    _queued_input_events: int = 0
+
+    @property
+    def native_append_tasks(self) -> dict[asyncio.Task[bool], DuplexAppendTaskMeta]:
+        return self.tasks.native_append_tasks
+
+    @property
+    def active_response_task(self) -> asyncio.Task[None] | None:
+        return self.tasks.active_response_task
+
+    @active_response_task.setter
+    def active_response_task(self, task: asyncio.Task[None] | None) -> None:
+        self.tasks.active_response_task = task
+
+    @property
+    def native_append_tail(self) -> asyncio.Task[bool] | None:
+        return self.tasks.native_append_tail
+
+    @native_append_tail.setter
+    def native_append_tail(self, task: asyncio.Task[bool] | None) -> None:
+        self.tasks.native_append_tail = task
+
+    async def enqueue_event(self, event: dict[str, object]) -> None:
+        if is_input_event(event.get("type")):
+            self._queued_input_events += 1
+        await self.mailbox.put(event)
+
+    async def next_event(self) -> dict[str, object]:
+        event = await self.mailbox.get()
+        if is_input_event(event.get("type")):
+            self._queued_input_events = max(0, self._queued_input_events - 1)
+        self.mailbox.task_done()
+        return event
+
+    def has_queued_input_events(self) -> bool:
+        return self._queued_input_events > 0
+
+    async def send_json(self, payload: dict[str, object]) -> None:
+        await self.output_queue.put(payload)
+
+    async def close_writer(self) -> None:
+        await self.output_queue.put(None)
+
+    async def writer_loop(self) -> None:
+        while True:
+            payload = await self.output_queue.get()
+            try:
+                if payload is None:
+                    return
+                raw_realtime = payload.pop("_realtime_raw", False) is True
+                if not raw_realtime and self._is_stale_model_output(payload):
+                    self.stale_output_dropped += 1
+                    continue
+                try:
+                    if raw_realtime:
+                        await self.websocket.send_json(payload)
+                    elif self.outbound_protocol is not None:
+                        for projected in self.outbound_protocol.encode_outbound_event(payload):
+                            await self.websocket.send_json(projected)
+                    else:
+                        await self.websocket.send_json(payload)
+                except (WebSocketDisconnect, RuntimeError):
+                    return
+            finally:
+                self.output_queue.task_done()
+
+    def _is_stale_model_output(self, payload: dict[str, object]) -> bool:
+        event_type = payload.get("type")
+        if event_type in DOMAIN_TERMINAL_EVENTS:
+            return False
+        if event_type not in MODEL_OUTPUT_EVENTS:
+            return False
+        if self.closing and event_type not in {"response.listen", "runtime.control"}:
+            return True
+        expected_epoch = self.current_epoch() if self.current_epoch is not None else None
+        if (
+            self.session_closed is not None
+            and self.session_closed()
+            and event_type
+            not in {
+                "response.listen",
+                "runtime.control",
+            }
+        ):
+            return True
+        epoch = payload.get("epoch")
+        return isinstance(epoch, int) and isinstance(expected_epoch, int) and epoch != expected_epoch
+
+    def track_append_task(
+        self,
+        task: asyncio.Task[bool],
+        *,
+        epoch: int,
+        mode: str,
+        final: bool,
+        response_bound: bool,
+    ) -> None:
+        self.tasks.track_append_task(
+            task,
+            epoch=epoch,
+            mode=mode,
+            final=final,
+            response_bound=response_bound,
+        )
+
+    def has_response_bound_append_tasks(self) -> bool:
+        return self.tasks.has_response_bound_append_tasks()
+
+    async def cancel_append_tasks(self, timeout_s: float = 0.25, *, response_bound_only: bool = False) -> bool:
+        return await self.tasks.cancel_append_tasks(timeout_s, response_bound_only=response_bound_only)
+
+
+__all__ = [
+    "DOMAIN_TERMINAL_EVENTS",
+    "DuplexAppendTaskMeta",
+    "DuplexSessionTasks",
+    "DuplexWebSocketActor",
+    "is_input_event",
+]
diff --git a/vllm_omni/experimental/fullduplex/output.py b/vllm_omni/experimental/fullduplex/output.py
new file mode 100644
index 000000000..bfe2243f9
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/output.py
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from typing import Any
+
+from vllm_omni.outputs import OmniRequestOutput
+
+DUPLEX_OUTPUT_DECISION_KEY = "_vllm_omni.experimental.fullduplex.duplex_output_decision"
+
+
+def attach_duplex_output_decision(
+    output: OmniRequestOutput,
+    decision: object,
+) -> OmniRequestOutput:
+    custom_output = dict(output._custom_output)
+    custom_output[DUPLEX_OUTPUT_DECISION_KEY] = decision
+    output._custom_output = custom_output
+    return output
+
+
+def get_duplex_output_decision(output: object) -> Any | None:
+    if not isinstance(output, OmniRequestOutput):
+        return None
+    custom_output = output._custom_output
+    if not isinstance(custom_output, dict):
+        return None
+    return custom_output.get(DUPLEX_OUTPUT_DECISION_KEY)
+
+
+__all__ = [
+    "DUPLEX_OUTPUT_DECISION_KEY",
+    "attach_duplex_output_decision",
+    "get_duplex_output_decision",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/DESIGN.md b/vllm_omni/experimental/fullduplex/personaplex/DESIGN.md
new file mode 100644
index 000000000..623f08353
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/DESIGN.md
@@ -0,0 +1,259 @@
+# PersonaPlex Unified Full-Duplex Design
+
+## Status and target
+
+This design adapts PersonaPlex PR #4771 to the unified full-duplex runtime on
+top of:
+
+- vLLM-Omni `origin/main`: `67c54777bb22e9e7e08fdf7c47a64f06b566fc47`
+- PersonaPlex PR head: `477fb7c225f0c06991bc8aa55eadbd908ba282e4`
+
+The target is the engine-native path:
+
+```text
+/v1/realtime?duplex=1
+  -> OpenAI Realtime session actor
+  -> DuplexRequestClient
+  -> AsyncOmni correlated RPC
+  -> DuplexControlPlane
+  -> resumable Stage 0 request
+  -> PersonaPlex Talker
+  -> streaming PersonaPlex Code2Wav
+  -> PersonaPlex data-plane projector
+  -> response.audio.delta + response.audio_transcript.delta
+```
+
+The standalone `/api/chat` and `/v1/audio/duplex` server remains a compatibility
+surface. It is not evidence that the unified engine path works.
+
+## Why configuration-only enablement is invalid
+
+The current staged pipeline is explicitly turn based. Its Talker reads
+`pplex_user_codes`, `pplex_prefill_text`, and `pplex_silence_codes`, but no
+production staged input path writes those fields. The voice prompt, persona
+prefill, and streaming Mimi state live only in the standalone
+`PersonaPlexEngine`.
+
+Setting only the following fields would therefore advertise an endpoint whose
+model never receives the live microphone stream:
+
+```python
+duplex_control_enabled = True
+duplex_runtime_extension = "..."
+duplex_serving_adapter = "..."
+```
+
+The adapter must supply a real scheduler data plane, not just endpoint
+capabilities.
+
+## Supported scope
+
+The unified implementation supports:
+
+- up to two engine-owned sessions on one replica;
+- 24 kHz mono float PCM input;
+- one 1920-sample, 80 ms model frame per physical append unit;
+- continuous user input while assistant audio is generated or played;
+- bundled `.pt` voice prompts and a session persona;
+- greedy text and depformer sampling, matching the current PersonaPlex port;
+- `/v1/realtime?duplex=1`;
+- engine lease close, disconnect cleanup, reconnect after cleanup, and explicit
+  response cancellation without cross-session state reuse.
+
+The implementation does not claim:
+
+- more than two simultaneous PersonaPlex sessions on one replica;
+- arbitrary WAV voice cloning;
+- turn-based `response.create` semantics for an otherwise continuous model;
+- scheduler migration of live codec state between replicas;
+- exact output equality with the standalone engine after different scheduling
+  boundaries.
+
+The capability payload derives multi-session support from the configured
+session limit. The shipped two-session deployment reports
+`supports_multi_session=true` and `supports_multi_session_same_replica=true`.
+`duplex_session.max_sessions` is the only capacity source: config resolution
+propagates it to every stage as `duplex_max_sessions`, and both Mimi pools read
+that model-config value. Connector extras do not carry a second model-specific
+capacity knob that could drift from engine admission.
+It still reports `supports_barge_in=false`: the generic epoch fence can suppress
+stale transport output, but neither PersonaPlex nor the current MiniCPM-o 4.5
+adapter proves that model-owned streaming state can be destructively rewound or
+restarted at a playback cursor. Continuous overlapping speech is model-native
+duplex behavior, not by itself a barge-in contract.
+
+## Components and ownership
+
+### Serving adapter
+
+`PersonaPlexServingRuntimeAdapter` owns only serving-side state:
+
+- a transactional PCM append buffer;
+- validation of `voice_prompt` and `instructions`;
+- public capabilities;
+- PersonaPlex data-plane output projection.
+
+It accepts 24 kHz `pcm_f32le`, groups client packets into whole 1920-sample
+frames, zero-pads only the final residual, and rolls a reservation back when an
+engine append fails. It never loads CUDA weights and never encodes user audio.
+
+Client input cannot provide local filesystem paths. A voice is a bundled
+basename such as `NATF2.pt`; the worker resolves it under the local model
+checkpoint. `instructions` is the persona string.
+
+### Runtime extension
+
+`PersonaPlexDuplexRuntimeExtension` is pure model policy. It:
+
+- configures greedy Stage 0 sampling and bounded segment lengths;
+- maps each accepted PCM append to a scheduler prompt;
+- places immutable session identity, append sequence, PCM payload, voice, and
+  persona under `model_intermediate_buffer["duplex"]`;
+- reserves exactly one scheduler prompt slot per encoded Mimi frame, plus the
+  first-append voice/persona prefill length;
+- never performs model inference or owns session state.
+
+The extension returns no turn/listen decision. PersonaPlex is an always-clocked
+model, so visible audio/text comes from the final stage data plane.
+
+### Stage 0 streaming runtime
+
+The Talker owns a `PersonaPlexStage0DuplexRuntime` helper, analogous to
+MiniCPM-o's Stage 0 helper but with PersonaPlex lockstep semantics.
+
+For each admitted session it owns:
+
+- streaming Mimi encoder convolution and transformer state;
+- the selected voice embedding bundle;
+- persona tokenization and prefill embeddings;
+- the prior user code frame needed by the one-frame acoustic delay;
+- append identity used to make a retried scheduler update idempotent.
+
+The first append builds this ordered prefill:
+
+```text
+voice embeddings
+  -> encoded silence
+  -> <system> persona <system> tokens with encoded silence
+  -> encoded silence
+  -> first live user frame
+```
+
+Later appends encode only new 1920-sample frames. The helper returns the
+per-frame user codes and prompt embeddings through the request's
+`model_intermediate_buffer`. The normal vLLM runner remains authoritative for
+attention metadata, block tables, KV allocation, scheduling, and sampling.
+
+The Talker must distinguish resumable prompt prefill from decode positions.
+Prompt rows consume the exact prepared embeddings; sampled decode rows continue
+to use the existing delayed agent/user frame construction. No code path may
+fall back to an all-initial user stream for a duplex request.
+
+Cleanup is keyed by the full `(session_id, incarnation)` identity. Every live
+session has an independent Mimi encoder instance; encoder convolution/KV state
+is never shared between asynchronously scheduled sessions. A finished or
+aborted scheduler request resets and returns only that session's encoder.
+
+### Stage 1 streaming decoder
+
+The current `PersonaPlexCode2Wav` calls one-shot `MimiModel.decode` and is not
+CUDA-graph safe. Unified duplex uses eager Stage 1 and maintains an independent
+streaming Mimi decoder for every active request. Decoder ownership is keyed by
+the stable Stage 1 request id and released by `on_requests_finished`; a mixed
+batch must never advance another request's convolution or transformer state.
+
+Each Stage 0 segment emits de-delayed agent codebooks. Stage 1 decodes only the
+new code frames, emits only the new PCM suffix, and resets state when the
+request is closed. Connector chunk boundaries retain the final raw code frame
+needed to de-delay the next chunk.
+
+The deploy default sets Stage 1 `enforce_eager: true`; a default configuration
+that fails during CUDA graph capture is not an acceptable deployment profile.
+
+### Data-plane projector
+
+`PersonaPlexDataPlaneSession` converts cumulative or delta Stage 1 output into
+model-neutral native results:
+
+```python
+{
+    "stage_role": "tts",
+    "data_plane_request_id": request_id,
+    "text": text_delta,
+    "audio_data": encoded_audio_delta,
+    "audio_format": response_format,
+    "sample_rate_hz": 24000,
+    "audio_duration_ms": delta_duration,
+    "end_of_turn": False,
+}
+```
+
+It owns per-request audio and text cursors so a cumulative output cannot replay
+old audio. PersonaPlex keeps one visible response open while continuous output
+arrives. Session close or cancellation terminates that response through the
+generic Realtime lifecycle; a codec segment finishing is not a conversational
+turn boundary.
+
+## Error and lifecycle contracts
+
+- Unsupported sample rate, malformed base64, non-finite PCM, invalid voice
+  basename, or changed format fails before scheduler submission.
+- Append is prepare/submit/commit. Failure rolls back the exact reserved PCM
+  bytes and does not advance the model frame cursor.
+- A repeated `operation_id` must not encode or submit the same frame twice.
+- Input iterator exceptions execute the same cleanup as explicit close.
+- Cancellation does not release the engine lease until the stage request and
+  any in-flight codec operation are actually finished.
+- A bounded cleanup timeout returns a cleanup error and keeps the session in
+  the closing admission set; it must not make the slot available while work
+  still mutates shared state.
+- New sessions cannot observe the previous voice, persona, PCM tail, Mimi
+  convolution state, or Talker delayed code frame.
+
+The legacy `PersonaPlexDuplexRuntime.run()` and standalone server drain path
+must follow the same exception-safe rule while they remain in the tree.
+
+## Testing and acceptance
+
+### Contract tests
+
+Tests first cover:
+
+- pipeline registration enables the control plane and selects both PersonaPlex
+  adapters;
+- the capability payload is two-session, 80 ms, append-only, and honest;
+- PCM reservation commit/rollback, partial-frame flush, invalid input, and
+  operation idempotency;
+- runtime prompt fields and exact token budgeting;
+- first-append voice/persona prefill followed by live user codes;
+- later appends retain per-session Mimi state and do not replay prefill;
+- interleaved Stage 0 and Stage 1 work preserves independent codec histories;
+- output projection emits only audio/text deltas;
+- close, exception, timeout, and reconnect cleanup;
+- ordinary non-duplex imports do not load PersonaPlex modules.
+
+### Remote H20 validation
+
+Validation runs in an isolated remote worktree using the ModelScope
+`nv-community/personaplex-7b-v1` checkpoint and its Mimi dependency.
+
+The required evidence is:
+
+1. default `personaplex.yaml` reaches ready without a local eager override;
+2. `/health` returns 200;
+3. `/v1/realtime?duplex=1` reports `model_native_duplex`, `chunk_period_ms=80`,
+   and two-session admission;
+4. paced 24 kHz PCM appends produce finite, non-silent 24 kHz audio deltas and
+   text deltas;
+5. microphone input continues during assistant output without cancelling the
+   scheduler request;
+6. two paced sessions simultaneously produce independent non-empty audio, and
+   a third session is rejected with `resource_exhausted`;
+7. closing either session frees only its scheduler request and GPU codec state,
+   after which a replacement session can use a different persona without state
+   leakage;
+8. malformed input returns one typed error and does not poison the next append;
+9. all focused unit tests and `git diff --check` pass.
+
+Audio that is empty, all zero, non-finite, or only a protocol `listen` event is
+not a successful end-to-end result.
diff --git a/vllm_omni/experimental/fullduplex/personaplex/__init__.py b/vllm_omni/experimental/fullduplex/personaplex/__init__.py
new file mode 100644
index 000000000..bf6c711bb
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/__init__.py
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex full-duplex backend for the experimental fullduplex framework.
+
+PersonaPlex (``nvidia/personaplex-7b-v1``) is a Moshi finetune: a pure-lockstep
+speech-to-speech model. This package plugs it into the model-agnostic
+``fullduplex/core`` seam without touching the engine:
+
+- :class:`PersonaPlexConfig`   immutable session config (voice / persona / sampling)
+- :class:`PersonaPlexEngine`   the moshi-free lockstep engine (``FrameStepper``;
+  single session and B concurrent slots with elastic per-slot recycle)
+- :class:`PersonaPlexSession`  lockstep driver (the runnable serving primitive)
+- :class:`PersonaPlexDuplexAdapter`  the ``core.DuplexAdapter`` for lockstep audio
+- :class:`PersonaPlexDuplexRuntime`  the model-owned lockstep lifecycle
+  (start-once / drain-on-close; ``core`` stays verbatim upstream)
+"""
+
+from vllm_omni.experimental.fullduplex.personaplex.adapter import (
+    PersonaPlexDuplexAdapter,
+    PersonaPlexDuplexRuntime,
+)
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.engine import (
+    FrameOutput,
+    FrameStepper,
+    PersonaPlexEngine,
+)
+from vllm_omni.experimental.fullduplex.personaplex.runtime import PrefillStep
+from vllm_omni.experimental.fullduplex.personaplex.session import PersonaPlexSession
+
+__all__ = [
+    "FrameOutput",
+    "FrameStepper",
+    "PersonaPlexConfig",
+    "PersonaPlexDuplexAdapter",
+    "PersonaPlexDuplexRuntime",
+    "PersonaPlexEngine",
+    "PersonaPlexSession",
+    "PrefillStep",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/adapter.py b/vllm_omni/experimental/fullduplex/personaplex/adapter.py
new file mode 100644
index 000000000..1508931f8
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/adapter.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex duplex adapter + model-owned lockstep runtime.
+
+PersonaPlex is a *continuous* (frame-clocked, no turn-taking) model: one eternal
+``respond()`` that pulls one 80 ms user frame at a time and emits one agent
+frame + text token. The shared ``core.DuplexRuntime`` implements the turn
+lifecycle (start/cancel per trigger), which does not fit lockstep, so the
+lifecycle lives HERE as :class:`PersonaPlexDuplexRuntime` — model policy stays
+in the model package, mirroring #3907's model-owned minicpmo45 runtime, and
+``core`` remains verbatim upstream.
+
+Stepping happens off the event loop (``asyncio.to_thread``, as Moshi's own
+server does) so the input side stays live — that is what makes barge-in work
+without any explicit flush.
+
+Depends only on the ``FrameStepper`` protocol, so it is exercised by GPU-free
+tests with a stub stepper; ``PersonaPlexEngine`` is the real backend.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import Any
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.core import protocol as ev
+from vllm_omni.experimental.fullduplex.core.adapter import DuplexAdapter, DuplexCapability, OutputChunk
+from vllm_omni.experimental.fullduplex.core.runtime import DuplexRuntime, Emit
+from vllm_omni.experimental.fullduplex.core.session import DuplexSession, DuplexState
+from vllm_omni.experimental.fullduplex.personaplex.engine import FrameStepper
+from vllm_omni.experimental.fullduplex.personaplex.session import MAX_PENDING_INPUT, offer_realtime
+
+_CLOSE = object()  # sentinel: drain the inbox and end the eternal response
+
+
+class PersonaPlexDuplexAdapter(DuplexAdapter):
+    """Drive a :class:`FrameStepper` as a continuous full-duplex response."""
+
+    def __init__(
+        self,
+        stepper: FrameStepper,
+        *,
+        voice_prompt: str | None = None,
+        persona: str | None = None,
+    ) -> None:
+        self._stepper = stepper
+        self._voice_prompt = voice_prompt
+        self._persona = persona
+        self._frame_size = stepper.frame_size
+        # Bounded, drop-oldest: input arriving faster than the stepper can run
+        # must shed stale frames (realtime), not grow memory + latency unbounded.
+        self._inbox: asyncio.Queue[Any] = asyncio.Queue(maxsize=MAX_PENDING_INPUT)
+        self._pending = np.zeros(0, dtype=np.float32)
+        self._opened = False
+
+    def capabilities(self) -> DuplexCapability:
+        return DuplexCapability(
+            input_modalities=frozenset({"audio"}),
+            output_modalities=frozenset({"audio", "text"}),
+            proactive=True,
+        )
+
+    async def on_input(self, session: DuplexSession, modality: str, data: Any) -> None:
+        """Frame incoming PCM into exact 80 ms windows and queue them for the loop."""
+        if modality != "audio":
+            return
+        samples = np.ascontiguousarray(data, dtype=np.float32).reshape(-1)
+        self._pending = np.concatenate([self._pending, samples]) if self._pending.size else samples
+        n = self._frame_size
+        while self._pending.shape[0] >= n:
+            frame, self._pending = self._pending[:n], self._pending[n:]
+            offer_realtime(self._inbox, frame)
+
+    async def respond(self, session: DuplexSession) -> AsyncIterator[OutputChunk]:
+        """The eternal lockstep loop: one user frame in, one agent frame + text out."""
+        if not self._opened:
+            await asyncio.to_thread(self._stepper.open_session, self._voice_prompt, self._persona)
+            self._opened = True
+        while True:
+            frame = await self._inbox.get()
+            if frame is _CLOSE:
+                break
+            out = await asyncio.to_thread(self._stepper.step, frame)
+            if out.audio is not None:
+                yield OutputChunk("audio", out.audio)
+            if out.text:
+                yield OutputChunk("text", out.text)
+
+    async def on_close(self, session: DuplexSession) -> None:
+        # Model-owned drain signal (not part of the core DuplexAdapter ABC):
+        # PersonaPlexDuplexRuntime calls this on every exit path. Pad + flush a
+        # partial final frame (same contract as PersonaPlexSession.flush()) so
+        # the tail of the user's audio is stepped, not dropped.
+        if self._pending.size:
+            pad = self._frame_size - self._pending.shape[0]
+            frame = np.concatenate([self._pending, np.zeros(pad, dtype=np.float32)])
+            self._pending = np.zeros(0, dtype=np.float32)
+            offer_realtime(self._inbox, frame)
+        offer_realtime(self._inbox, _CLOSE)
+
+    async def on_barge_in(self, session: DuplexSession) -> None:
+        # No-op: Moshi-class models perceive the user continuously, so an interrupt
+        # needs no downstream flush — the next frames simply steer the model.
+        return
+
+
+class PersonaPlexDuplexRuntime(DuplexRuntime):
+    """Model-owned lockstep lifecycle: start once, never supersede, drain on exit.
+
+    ``core.DuplexRuntime`` runs the turn lifecycle — every trigger starts a new
+    response that supersedes and cancels the previous one. A lockstep model has
+    exactly ONE response for the whole session: it consumes user frames as they
+    arrive and only ends when the input side goes away. Keeping this here (not
+    as a flag on the shared runtime) mirrors #3907's model-owned minicpmo45
+    runtime: model policy lives in the model package.
+    """
+
+    async def run(self, inputs: AsyncIterator[dict], emit: Emit) -> None:
+        task: asyncio.Task | None = None
+        try:
+            async for event in inputs:
+                etype = event.get("type")
+                if etype == ev.INPUT_APPEND:
+                    modality = event.get("modality", "")
+                    if modality not in self._capabilities.input_modalities:
+                        await emit(ev.error(f"unsupported input modality: {modality}"))
+                        continue
+                    await self.adapter.on_input(self.session, modality, event.get("data"))
+                    self.session.state = DuplexState.LISTENING
+                    task = self._ensure_started(task, emit)
+                elif etype in (ev.INPUT_COMMIT, ev.RESPONSE_CREATE):
+                    task = self._ensure_started(task, emit)
+                elif etype == ev.RESPONSE_CANCEL:
+                    # Barge-in is native for lockstep models: bump the epoch for the
+                    # playback cursor but keep the single response streaming.
+                    await self._barge_in()
+                    await emit(ev.cancelled(self.session.response_index))
+                elif etype == ev.PLAYBACK_ACK:
+                    await self.adapter.on_playback_ack(self.session, int(event.get("cursor", 0)))
+                elif etype == ev.CLOSE:
+                    break
+        finally:
+            # Drain on EVERY exit path: CLOSE, iterator EOF, transport errors,
+            # and cancellation must not leave the eternal response blocked on
+            # its inbox or the session outside CLOSED.
+            try:
+                if task is not None and not task.done():
+                    await self.adapter.on_close(self.session)
+                    await task
+            finally:
+                self.session.state = DuplexState.CLOSED
+
+    def _ensure_started(self, task: asyncio.Task | None, emit: Emit) -> asyncio.Task:
+        # Start the single eternal response exactly once; never supersede it.
+        if task is None or task.done():
+            return asyncio.create_task(self._respond_once(emit))
+        return task
+
+    async def _respond_once(self, emit: Emit) -> None:
+        # One response for the whole session. No staleness checks: the loop ends
+        # only when the adapter's respond() returns (after on_close drains its
+        # input).
+        response_index, _ = self.session.begin_response()
+        await emit(ev.created(response_index))
+        try:
+            async for chunk in self.adapter.respond(self.session):
+                await emit(ev.delta(response_index, chunk.modality, chunk.data))
+        except asyncio.CancelledError:
+            raise
+        except Exception as err:
+            await emit(ev.error(f"response failed: {err}"))
+        finally:
+            await emit(ev.done(response_index))
+            self.session.end_response()
diff --git a/vllm_omni/experimental/fullduplex/personaplex/config.py b/vllm_omni/experimental/fullduplex/personaplex/config.py
new file mode 100644
index 000000000..1cfa4b736
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/config.py
@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Configuration for the PersonaPlex full-duplex backend.
+
+PersonaPlex (``nvidia/personaplex-7b-v1``) is a Moshi finetune: a pure-lockstep
+full-duplex speech-to-speech model running at the Mimi codec frame rate
+(12.5 Hz / 80 ms). One config drives both the offline driver and the duplex
+adapter. Defaults mirror the PersonaPlex reference loop.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Mimi codec constants (loaders.py: SAMPLE_RATE / FRAME_RATE). Fixed by the
+# pretrained checkpoint; exposed here only so the rest of the package never
+# hard-codes them.
+SAMPLE_RATE = 24000
+FRAME_RATE = 12.5
+FRAME_SIZE = int(SAMPLE_RATE / FRAME_RATE)  # 1920 samples per 80 ms frame
+
+# Default assistant persona shipped with PersonaPlex (offline.py:335).
+DEFAULT_PERSONA = "You are a wise and friendly teacher. Answer questions or provide advice in a clear and engaging way."
+
+
+@dataclass(frozen=True)
+class PersonaPlexConfig:
+    """Immutable session configuration for a PersonaPlex conversation.
+
+    Attributes:
+        hf_repo: HuggingFace repo holding the weights, Mimi codec and tokenizer.
+        voice_prompt: Voice-clone reference. Either a bundled basename
+            (``"NATF2.pt"`` / ``"NATM1.pt"`` from ``voices.tgz``) or a path to a
+            ``.pt`` embedding bundle or a reference ``.wav``.
+        persona: System role text; injected as ``<system> ... <system>`` into the
+            inner-monologue stream at session start.
+        device: Torch device for the backend (``"cuda"`` / ``"cpu"``).
+        cpu_offload: Offload LM layers to CPU when GPU memory is tight (needs
+            ``accelerate``).
+        batch_size: Concurrent conversation slots sharing one engine. ``1`` is
+            the single-session path; ``> 1`` enables elastic batching with
+            per-slot recycle for new callers.
+
+    Note: the native stepper decodes greedily (argmax) for both the text head
+    and the depformer, so there are no sampling knobs here yet. Temperature /
+    top-k / seed fields will be added if and when a sampling path is wired in.
+    """
+
+    hf_repo: str = "nvidia/personaplex-7b-v1"
+    voice_prompt: str = "NATF2.pt"
+    persona: str = DEFAULT_PERSONA
+
+    device: str = "cuda"
+    cpu_offload: bool = False
+
+    batch_size: int = 1
+
+    @property
+    def sample_rate(self) -> int:
+        return SAMPLE_RATE
+
+    @property
+    def frame_size(self) -> int:
+        return FRAME_SIZE
diff --git a/vllm_omni/experimental/fullduplex/personaplex/data_plane.py b/vllm_omni/experimental/fullduplex/personaplex/data_plane.py
new file mode 100644
index 000000000..96e1f9e20
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/data_plane.py
@@ -0,0 +1,228 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    duplex_resource_request_belongs_to_session,
+)
+
+EncodeAudio = Callable[[object, int, str, float | None], str | None]
+
+
+@dataclass(frozen=True, slots=True)
+class PersonaPlexDataPlaneContext:
+    epoch: int = 0
+    turn_id: int = 0
+    active_response_turn_id: int | None = None
+    active_response_id: str | None = None
+    auto_responds: bool = True
+    response_format: str = "wav"
+    speed: float | None = None
+    modalities: tuple[str, ...] = ("audio", "text")
+
+
+@dataclass(slots=True)
+class _RequestCursor:
+    audio_samples: int = 0
+    text: str = ""
+    terminal: bool = False
+
+
+class PersonaPlexDataPlaneSession:
+    """Project cumulative staged PersonaPlex output into Realtime deltas."""
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        self._encode_audio = encode_audio
+        self._requests: dict[str, _RequestCursor] = {}
+
+    def begin_request(self, request_id: str) -> None:
+        self._requests.setdefault(request_id, _RequestCursor()).terminal = False
+
+    def is_terminal(self, request_id: str | None) -> bool:
+        if request_id is None:
+            return False
+        state = self._requests.get(request_id)
+        return state is not None and state.terminal
+
+    def mark_terminal(self, request_id: str) -> None:
+        self._requests.setdefault(request_id, _RequestCursor()).terminal = True
+
+    def close_stream(self, request_id: str) -> None:
+        self._requests.pop(request_id, None)
+
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None:
+        if active_request_id is not None:
+            self._requests.pop(active_request_id, None)
+        for request_id in list(self._requests):
+            if duplex_resource_request_belongs_to_session(request_id, session_id):
+                self._requests.pop(request_id, None)
+
+    def project(
+        self,
+        result: object,
+        *,
+        context: PersonaPlexDataPlaneContext | None = None,
+    ) -> Iterator[dict[str, object]]:
+        if not isinstance(result, dict):
+            return
+        outputs = result.get("data_plane_outputs")
+        if not isinstance(outputs, list):
+            return
+        context = context or PersonaPlexDataPlaneContext()
+        for output in outputs:
+            projected = self._project_output(output, context=context)
+            if projected is not None:
+                yield projected
+
+    def _project_output(
+        self,
+        output: object,
+        *,
+        context: PersonaPlexDataPlaneContext,
+    ) -> dict[str, object] | None:
+        output, completion = _unwrap_output(output)
+        request_id = getattr(output, "request_id", None)
+        if not isinstance(request_id, str) or not request_id:
+            request_id = None
+        state = self._requests.setdefault(request_id, _RequestCursor()) if request_id is not None else _RequestCursor()
+        multimodal = _multimodal_output(output, completion)
+        audio = _audio_value(multimodal)
+        audio_delta = _slice_audio(audio, state.audio_samples)
+        audio_samples = _num_samples(audio)
+        if audio_samples is not None:
+            state.audio_samples = audio_samples
+
+        text = _text_value(multimodal, completion)
+        text_delta = _text_delta(text, state.text)
+        if text:
+            state.text = text
+
+        sample_rate_hz = _sample_rate(multimodal)
+        encoded = self._encode_audio(audio_delta, sample_rate_hz, context.response_format, context.speed)
+        if not encoded and not text_delta:
+            return None
+        delta_samples = _num_samples(audio_delta) or 0
+        return {
+            "supported": True,
+            "stage_role": "tts",
+            "is_listen": False,
+            "data_plane_request_id": request_id,
+            "text": text_delta,
+            "audio_data": encoded or "",
+            "audio_format": context.response_format,
+            "sample_rate_hz": sample_rate_hz,
+            "audio_duration_ms": round(delta_samples * 1000 / max(1, sample_rate_hz)),
+            "end_of_turn": False,
+            "uses_model_runner_scheduler": True,
+            "runner_kv_backed": True,
+            "runtime_impl": "scheduler_data_plane",
+            "owned_runtime": False,
+        }
+
+
+def _unwrap_output(output: object) -> tuple[object, object | None]:
+    inner = getattr(output, "request_output", None)
+    if inner is not None and inner is not output:
+        output = inner
+    outputs = getattr(output, "outputs", None)
+    completion = outputs[0] if isinstance(outputs, list) and outputs else None
+    return output, completion
+
+
+def _multimodal_output(output: object, completion: object | None) -> dict[str, object]:
+    for candidate in (
+        getattr(output, "multimodal_output", None),
+        getattr(completion, "multimodal_output", None) if completion is not None else None,
+    ):
+        if isinstance(candidate, Mapping) and candidate:
+            return dict(candidate)
+    return {}
+
+
+def _audio_value(multimodal: dict[str, object]) -> object | None:
+    value = next(
+        (multimodal[key] for key in ("audio", "model_outputs", "latent") if key in multimodal),
+        None,
+    )
+    if isinstance(value, list) and len(value) == 1:
+        return value[0]
+    return value
+
+
+def _text_value(multimodal: dict[str, object], completion: object | None) -> str:
+    for candidate in (
+        multimodal.get("text"),
+        multimodal.get("llm_output_text"),
+        getattr(completion, "text", None) if completion is not None else None,
+    ):
+        if isinstance(candidate, str) and candidate:
+            return candidate
+    return ""
+
+
+def _text_delta(text: str, previous: str) -> str:
+    if not text:
+        return ""
+    if text == previous:
+        return ""
+    if previous and text.startswith(previous):
+        return text[len(previous) :]
+    return text
+
+
+def _slice_audio(audio: object | None, offset: int) -> object | None:
+    samples = _num_samples(audio)
+    if samples is None or samples <= 0:
+        return None
+    if offset <= 0 or samples < offset:
+        return audio
+    if samples == offset:
+        return None
+    try:
+        import torch
+
+        if isinstance(audio, torch.Tensor):
+            return audio.reshape(-1)[offset:].contiguous()
+    except Exception:
+        pass
+    return np.asarray(audio, dtype=np.float32).reshape(-1)[offset:]
+
+
+def _num_samples(audio: object | None) -> int | None:
+    if audio is None:
+        return None
+    try:
+        import torch
+
+        if isinstance(audio, torch.Tensor):
+            return int(audio.numel())
+    except Exception:
+        pass
+    try:
+        return int(np.asarray(audio, dtype=np.float32).size)
+    except Exception:
+        return None
+
+
+def _sample_rate(multimodal: dict[str, object]) -> int:
+    value = multimodal.get("sr", multimodal.get("sample_rate_hz", 24000))
+    if isinstance(value, list) and value:
+        value = value[0]
+    if hasattr(value, "item"):
+        try:
+            value = value.item()
+        except Exception:
+            value = 24000
+    return int(value) if isinstance(value, int | float) else 24000
+
+
+__all__ = [
+    "PersonaPlexDataPlaneContext",
+    "PersonaPlexDataPlaneSession",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/engine.py b/vllm_omni/experimental/fullduplex/personaplex/engine.py
new file mode 100644
index 000000000..488676aa1
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/engine.py
@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex duplex protocol home (moshi-free).
+
+Defines the narrow ``FrameStepper`` seam (one 80 ms user frame in, one agent
+frame + text piece out) that the session driver, the duplex adapter and the
+GPU-free tests depend on, and re-exports the native lockstep engine that
+implements it. The implementation lives in ``runtime.py`` and is built
+entirely from vllm-omni-native components (streaming Helium temporal, input
+embeddings, depformer, streaming Mimi codec) — the external ``moshi`` package
+is no longer used.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class FrameOutput:
+    """Result of stepping the model by exactly one 80 ms frame.
+
+    Attributes:
+        audio: Agent PCM for this frame (``frame_size`` mono float32 samples), or
+            ``None`` during the model's initial delay/warmup frames.
+        text: Inner-monologue text piece for this frame, or ``None`` when the
+            model emitted a padding token (silence between words).
+    """
+
+    audio: NDArray[np.float32] | None
+    text: str | None
+
+
+@runtime_checkable
+class FrameStepper(Protocol):
+    """The single seam between PersonaPlex and the duplex framework.
+
+    A stepper consumes one user audio frame and returns one agent frame. It owns
+    all conversation state (KV caches / streaming buffers); callers never re-feed
+    history. ``PersonaPlexEngine`` is the real implementation; tests pass a stub.
+    """
+
+    sample_rate: int
+    frame_size: int
+
+    def open_session(self, voice_prompt: str | None = None, persona: str | None = None) -> None:
+        """Reset streaming state and inject the voice clone + persona prompt."""
+        ...
+
+    def step(self, user_pcm: NDArray[np.float32]) -> FrameOutput:
+        """Advance the conversation by one frame of exactly ``frame_size`` samples."""
+        ...
+
+
+from vllm_omni.experimental.fullduplex.personaplex.runtime import (  # noqa: E402
+    PersonaPlexEngine,
+    PrefillStep,
+)
+
+__all__ = [
+    "FrameOutput",
+    "FrameStepper",
+    "PersonaPlexEngine",
+    "PrefillStep",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/input.py b/vllm_omni/experimental/fullduplex/personaplex/input.py
new file mode 100644
index 000000000..2fe57442a
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/input.py
@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import base64
+import binascii
+
+import numpy as np
+
+_SAMPLE_RATE_HZ = 24000
+_FRAME_SAMPLES = 1920
+_BYTES_PER_SAMPLE = 4
+
+
+class PersonaPlexPcmAppendReservation:
+    __slots__ = (
+        "_active",
+        "_owner",
+        "_raw",
+        "operation_id",
+        "payload",
+    )
+
+    def __init__(
+        self,
+        *,
+        owner: PersonaPlexPcmAppendBuffer,
+        operation_id: str,
+        payload: dict[str, object] | None,
+        raw: bytes,
+    ) -> None:
+        self._owner = owner
+        self.operation_id = operation_id
+        self.payload = payload
+        self._raw = raw
+        self._active = True
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @property
+    def byte_count(self) -> int:
+        return len(self._raw)
+
+    def commit(self) -> None:
+        self._owner._commit_reservation(self)
+
+    def rollback(self) -> None:
+        self._owner._rollback_reservation(self)
+
+
+class PersonaPlexPcmAppendBuffer:
+    """Transactionally frame 24 kHz float PCM into PersonaPlex 80 ms units."""
+
+    def __init__(self) -> None:
+        self._buffer = bytearray()
+        self._sample_rate_hz: int | None = None
+        self._reservations: list[PersonaPlexPcmAppendReservation] = []
+
+    @property
+    def pending_byte_count(self) -> int:
+        return len(self._buffer)
+
+    def has_pending(self) -> bool:
+        return bool(self._buffer)
+
+    def has_reserved(self) -> bool:
+        return any(reservation.active for reservation in self._reservations)
+
+    def clear_force_listen(self) -> None:
+        return
+
+    def clear(self) -> None:
+        for reservation in self._reservations:
+            reservation._active = False
+        self._reservations.clear()
+        self._buffer.clear()
+        self._sample_rate_hz = None
+
+    def prepare_append(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+        allow_emit: bool,
+    ) -> PersonaPlexPcmAppendReservation | None:
+        if chunk_period_ms != 80:
+            raise ValueError("PersonaPlex chunk_period_ms must be 80")
+        if any(reservation.active and reservation.operation_id == operation_id for reservation in self._reservations):
+            raise ValueError(f"PersonaPlex duplicate active operation_id: {operation_id}")
+
+        raw = self._decode_payload(payload)
+        self._buffer.extend(raw)
+        if not allow_emit or len(self._buffer) < _FRAME_SAMPLES * _BYTES_PER_SAMPLE:
+            return None
+        return self._reserve_frame(payload, operation_id=operation_id, flush=False)
+
+    def prepare_commit(
+        self,
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+    ) -> PersonaPlexPcmAppendReservation:
+        if chunk_period_ms != 80:
+            raise ValueError("PersonaPlex chunk_period_ms must be 80")
+        if not self._buffer:
+            reservation = PersonaPlexPcmAppendReservation(
+                owner=self,
+                operation_id=operation_id,
+                payload=None,
+                raw=b"",
+            )
+            self._reservations.append(reservation)
+            return reservation
+        payload: dict[str, object] = {
+            "type": "audio",
+            "format": "pcm_f32le",
+            "sample_rate_hz": self._sample_rate_hz or _SAMPLE_RATE_HZ,
+            "audio": "",
+            "final": True,
+        }
+        return self._reserve_frame(payload, operation_id=operation_id, flush=True)
+
+    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None:
+        reservation = self.prepare_commit(
+            operation_id="personaplex-flush",
+            chunk_period_ms=chunk_period_ms,
+        )
+        payload = reservation.payload
+        reservation.commit()
+        return payload
+
+    def _decode_payload(self, payload: dict[str, object]) -> bytes:
+        if payload.get("format") != "pcm_f32le":
+            raise ValueError("PersonaPlex input format must be pcm_f32le")
+        sample_rate_hz = payload.get("sample_rate_hz")
+        if sample_rate_hz != _SAMPLE_RATE_HZ:
+            raise ValueError("PersonaPlex sample_rate_hz must be 24000")
+        if self._sample_rate_hz is not None and self._sample_rate_hz != sample_rate_hz:
+            raise ValueError("PersonaPlex sample_rate_hz changed within a session")
+        audio = payload.get("audio")
+        if not isinstance(audio, str):
+            raise ValueError("PersonaPlex audio must be base64 pcm_f32le")
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise ValueError("PersonaPlex audio is not valid base64") from exc
+        if len(raw) % _BYTES_PER_SAMPLE:
+            raise ValueError("PersonaPlex pcm_f32le byte length must be divisible by four")
+        samples = np.frombuffer(raw, dtype="<f4")
+        if not np.isfinite(samples).all():
+            raise ValueError("PersonaPlex pcm_f32le samples must be finite")
+        self._sample_rate_hz = int(sample_rate_hz)
+        return raw
+
+    def _reserve_frame(
+        self,
+        source_payload: dict[str, object],
+        *,
+        operation_id: str,
+        flush: bool,
+    ) -> PersonaPlexPcmAppendReservation:
+        frame_bytes = _FRAME_SAMPLES * _BYTES_PER_SAMPLE
+        if flush:
+            consumed_bytes = min(len(self._buffer), frame_bytes)
+        else:
+            consumed_bytes = frame_bytes
+        raw = bytes(self._buffer[:consumed_bytes])
+        del self._buffer[:consumed_bytes]
+        encoded_raw = raw + b"\x00" * (frame_bytes - consumed_bytes)
+        payload = dict(source_payload)
+        payload["type"] = "audio"
+        payload["format"] = "pcm_f32le"
+        payload["sample_rate_hz"] = _SAMPLE_RATE_HZ
+        payload["audio"] = base64.b64encode(encoded_raw).decode("ascii")
+        reservation = PersonaPlexPcmAppendReservation(
+            owner=self,
+            operation_id=operation_id,
+            payload=payload,
+            raw=raw,
+        )
+        self._reservations.append(reservation)
+        return reservation
+
+    def _commit_reservation(self, reservation: PersonaPlexPcmAppendReservation) -> None:
+        if not reservation.active:
+            return
+        reservation._active = False
+        self._reservations.remove(reservation)
+
+    def _rollback_reservation(self, reservation: PersonaPlexPcmAppendReservation) -> None:
+        if not reservation.active:
+            return
+        try:
+            index = self._reservations.index(reservation)
+        except ValueError:
+            reservation._active = False
+            return
+        rolled_back = self._reservations[index:]
+        restored = b"".join(item._raw for item in rolled_back if item.active)
+        self._buffer[:0] = restored
+        for item in rolled_back:
+            item._active = False
+        del self._reservations[index:]
+
+
+__all__ = [
+    "PersonaPlexPcmAppendBuffer",
+    "PersonaPlexPcmAppendReservation",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/policy.py b/vllm_omni/experimental/fullduplex/personaplex/policy.py
new file mode 100644
index 000000000..8e6062d0d
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/policy.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex frame/token contract (the model *policy*, no engine state).
+
+This mirrors the ``minicpmo45`` model-package layout from PR #3907: the token
+contract lives in ``policy.py``, the model-owned runtime in ``runtime.py``.
+Everything here is a constant or a pure function of the checkpoint's lockstep
+conventions; nothing touches weights, devices, or streaming state.
+
+Frame layout per 80 ms tick: 17 token rows -- row 0 inner-monologue text,
+rows 1-8 agent audio codebooks, rows 9-16 user audio codebooks.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+# Inner-monologue token ids that carry no displayable text (EPAD, PAD).
+NON_TEXT_TOKEN_IDS = frozenset({0, 3})
+ZERO_TEXT_TOKEN = 3
+# Mimi token constants for the hybrid system prompt (agent silence / user sine).
+SILENCE_TOKENS = (948, 243, 1178, 546, 1736, 1030, 1978, 2008)
+SINE_TOKENS = (430, 1268, 381, 1611, 1095, 1495, 56, 472)
+# LM initial ("beginning of stream") token ids: audio rows use the codec
+# cardinality, the text row uses the text vocabulary size.
+AUDIO_INITIAL_TOKEN = 2048
+TEXT_INITIAL_TOKEN = 32000
+TEXT_VOCAB_SIZE = 32000
+AUDIO_SILENCE_FRAME_CNT = 6  # 0.5 s at 12.5 Hz
+
+
+@dataclass(frozen=True)
+class PrefillStep:
+    """One tick of a recycled slot's system-prompt replay (see batched serving)."""
+
+    kind: str  # "sacrifice" | "voice" | "voice_end" | "tokens"
+    embedding: Any = None  # [1, 1, H] tensor for kind == "voice"
+    moshi_tokens: Any = None  # [8] tensor for kind == "tokens"
+    text_token: int | None = None
+    user_sine: bool = False
+
+
+def wrap_with_system_tags(text: str) -> str:
+    t = text.strip()
+    return t if t.startswith("<system>") else f"<system> {t} <system>"
+
+
+__all__ = [
+    "AUDIO_INITIAL_TOKEN",
+    "AUDIO_SILENCE_FRAME_CNT",
+    "NON_TEXT_TOKEN_IDS",
+    "PrefillStep",
+    "SILENCE_TOKENS",
+    "SINE_TOKENS",
+    "TEXT_INITIAL_TOKEN",
+    "TEXT_VOCAB_SIZE",
+    "ZERO_TEXT_TOKEN",
+    "wrap_with_system_tags",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/runtime.py b/vllm_omni/experimental/fullduplex/personaplex/runtime.py
new file mode 100644
index 000000000..885b36aa5
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/runtime.py
@@ -0,0 +1,473 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Moshi-free PersonaPlex lockstep engine (native temporal + depformer + Mimi).
+
+This is the real-time duplex backend built entirely from vllm-omni-native
+components: :class:`PersonaPlexTemporalStreaming` (ring-KV Helium),
+:class:`PersonaPlexInputEmbeddings`, :class:`PersonaPlexDepformer` and
+:class:`PersonaPlexMimiCodec`. It reimplements the reference lockstep semantics
+(staging ring, per-codebook delays, warmup gates, hybrid system-prompt prefill,
+per-slot elastic recycle) as first-class policy code, so the external ``moshi``
+package is no longer needed at runtime.
+
+Lockstep contract per 80 ms tick (17 token rows: text, 8 agent codebooks, 8
+user codebooks; delays ``[0, 1x8-ish from checkpoint]``):
+
+1. Mimi-encode the user frame and write it (delayed) into the staging ring.
+2. Read the model input at ``(o - 1) % CT``, embed, step the temporal.
+3. Greedy text token; depformer expands the 16 audio rows (teacher-forced where
+   the staging ring already holds provided values).
+4. Write sampled rows at ``o % CT``; gather the de-delayed output frame; decode
+   agent rows 1..8 through Mimi (rows still in warmup are sanitized to silence
+   tokens: the LM's initial audio token id equals the codec cardinality and is
+   out of range for the codebook tables).
+
+Elastic recycle mirrors the verified design from the moshi-hosted path: the
+temporal ring KV masks the recycled row (plus the one LM "sacrifice tick"
+write), the staging row is wiped to initial tokens, and the system prompt
+(voice embeddings, silence spacer, persona tokens, silence) is replayed per-row
+while other slots keep conversing.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tarfile
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.policy import (
+    AUDIO_INITIAL_TOKEN,
+    AUDIO_SILENCE_FRAME_CNT,
+    NON_TEXT_TOKEN_IDS,
+    SILENCE_TOKENS,
+    SINE_TOKENS,
+    TEXT_INITIAL_TOKEN,
+    TEXT_VOCAB_SIZE,
+    ZERO_TEXT_TOKEN,
+    PrefillStep,
+    wrap_with_system_tags,
+)
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+logger = logging.getLogger(__name__)
+
+
+class PersonaPlexEngine:
+    """Frame-lockstep PersonaPlex on native components only (no moshi).
+
+    One class serves both surfaces: the single-session ``FrameStepper`` protocol
+    (``open_session`` / ``step``) and the batched slot API consumed by
+    ``serving/batched.py`` (``open_batch`` / ``prefill_steps`` / ``recycle_slot``
+    / ``voice_end`` / ``end_prefill`` / ``step_batch``).
+    """
+
+    def __init__(self, config: PersonaPlexConfig | None = None) -> None:
+        self.config = config or PersonaPlexConfig()
+        self.sample_rate = self.config.sample_rate
+        self.frame_size = self.config.frame_size
+        # Serializes the single-session FrameStepper surface (open_session/step)
+        # across worker threads: a cancelled asyncio task cannot stop a running
+        # engine call, so a racing open() must wait for the in-flight step.
+        # The batched surface is serialized by BatchedSessionManager instead.
+        self._fs_lock = threading.Lock()
+        self._loaded = False
+        self._opened = False
+        self._tokenizer = None
+        self._codec = None
+        self._temporal = None
+        self._emb = None
+        self._dep = None
+        self._voice_embeddings = None  # [T, 1, 1, H]
+        self._voice_cache = None  # [1, K, CT]
+        self._loaded_voice = None  # name/path of the currently loaded voice
+        # lockstep state (built at open time)
+        self._cache = None  # [B, K, CT] long
+        self._provided = None  # [B, K, CT] bool
+        self._initial = None  # [K] long
+        self._delays = None  # [K] long (python list)
+        self._phys = 0
+        self._local = None  # [B] cpu long
+
+    # -- loading --------------------------------------------------------------
+
+    def load(self) -> PersonaPlexEngine:
+        if self._loaded:
+            return self
+        import sentencepiece
+        import torch
+        from huggingface_hub import hf_hub_download
+        from safetensors.torch import load_file
+
+        from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+            PersonaPlexConfig as _PPModelConfig,
+        )
+        from vllm_omni.model_executor.models.personaplex.personaplex_depformer import (
+            PersonaPlexDepformer,
+        )
+        from vllm_omni.model_executor.models.personaplex.personaplex_embeddings import (
+            PersonaPlexInputEmbeddings,
+        )
+        from vllm_omni.model_executor.models.personaplex.personaplex_mimi import (
+            PersonaPlexMimiCodec,
+        )
+        from vllm_omni.model_executor.models.personaplex.personaplex_temporal import (
+            PersonaPlexTemporalStreaming,
+        )
+
+        cfg = self.config
+        B = cfg.batch_size
+        logger.info("PersonaPlex native: loading Mimi codec")
+        self._codec = PersonaPlexMimiCodec(device=cfg.device)
+        self._codec.streaming_init(B)
+
+        tok_path = hf_hub_download(cfg.hf_repo, "tokenizer_spm_32k_3.model")
+        self._tokenizer = sentencepiece.SentencePieceProcessor(tok_path)
+
+        logger.info("PersonaPlex native: loading temporal + depformer + embeddings")
+        sd = load_file(hf_hub_download(cfg.hf_repo, "model.safetensors"), device=cfg.device)
+        dtype = torch.bfloat16
+        self._temporal = PersonaPlexTemporalStreaming().to(cfg.device, dtype)
+        self._temporal.load_weights(sd)
+        self._temporal.eval()
+        self._temporal.streaming_init(B)
+
+        ppcfg = _PPModelConfig()
+        self._emb = PersonaPlexInputEmbeddings(ppcfg).to(cfg.device, dtype)
+        self._emb.load_weights(sd)
+        self._emb.eval()
+        self._dep = PersonaPlexDepformer(ppcfg.depformer_config, temporal_hidden_size=4096, text_card=32000).to(
+            cfg.device, dtype
+        )
+        self._dep.load_weights(sd)
+        self._dep.eval()
+        del sd
+        torch.accelerator.empty_cache()
+
+        K = 17
+        self._delays = [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]  # text, agent cb0..7, user cb0..7
+        self._initial = torch.tensor(
+            [TEXT_INITIAL_TOKEN] + [AUDIO_INITIAL_TOKEN] * 16, dtype=torch.long, device=cfg.device
+        )
+        ct = max(self._delays) + 3
+        self._cache = torch.full((B, K, ct), AUDIO_INITIAL_TOKEN, dtype=torch.long, device=cfg.device)
+        self._provided = torch.zeros((B, K, ct), dtype=torch.bool, device=cfg.device)
+        self._local = torch.zeros(B, dtype=torch.long)
+        self._sine = torch.tensor(SINE_TOKENS, dtype=torch.long, device=cfg.device)
+        self._silence = torch.tensor(SILENCE_TOKENS, dtype=torch.long, device=cfg.device)
+
+        self._load_voice(cfg.voice_prompt)
+        self._loaded = True
+        return self
+
+    def _load_voice(self, voice: str) -> None:
+        import torch
+
+        if voice == self._loaded_voice:
+            return
+        path = self._resolve_voice_prompt(voice)
+        if not path.endswith(".pt"):
+            raise ValueError(f"native stack needs a .pt voice-embedding bundle; got {path!r}")
+        state = torch.load(path, map_location=self.config.device, weights_only=True)
+        self._voice_embeddings = state["embeddings"].to(self.config.device)
+        self._voice_cache = state["cache"].to(self.config.device)
+        self._loaded_voice = voice
+
+    def _resolve_voice_prompt(self, voice: str) -> str:
+        from huggingface_hub import hf_hub_download
+
+        if os.path.exists(voice):
+            return voice
+        tgz = Path(hf_hub_download(self.config.hf_repo, "voices.tgz"))
+        vdir = tgz.parent / "voices"
+        if not vdir.exists():
+            with tarfile.open(tgz, "r:gz") as tar:
+                tar.extractall(path=tgz.parent)  # noqa: S202 - trusted first-party bundle
+        cand = vdir / voice
+        if not cand.exists():
+            raise FileNotFoundError(f"voice prompt {voice!r} not found in voices.tgz")
+        return str(cand)
+
+    # -- lockstep core ----------------------------------------------------------
+
+    def _reset_all_streaming(self) -> None:
+        self._codec.reset_streaming()
+        self._temporal.reset_streaming()
+        self._cache.fill_(AUDIO_INITIAL_TOKEN)
+        self._cache[:, 0, :] = TEXT_INITIAL_TOKEN
+        self._provided.fill_(False)
+        self._phys = 0
+        self._local.zero_()
+
+    def _tick(
+        self,
+        user_codes,  # [B, 8] long or None (prefill rows overridden separately)
+        forced_moshi=None,  # [B, 8] long (values used on force_mask rows)
+        forced_text=None,  # [B] long
+        force_mask=None,  # [B] bool (device)
+        embed_override=None,  # ([B, 1, H], [B] bool rows)
+    ):
+        """One lockstep step. Returns (ran, out[B,17] | None)."""
+        import torch
+
+        B, K, CT = self._cache.shape
+        o = self._phys
+        lo = self._local
+
+        if user_codes is not None:
+            for q in range(8):
+                k = 9 + q
+                wp = (o + self._delays[k]) % CT
+                self._cache[:, k, wp] = user_codes[:, q]
+                self._provided[:, k, wp] = True
+        if forced_moshi is not None and force_mask is not None:
+            for q in range(8):
+                k = 1 + q
+                wp = (o + self._delays[k]) % CT
+                self._cache[force_mask, k, wp] = forced_moshi[force_mask, q]
+                self._provided[force_mask, k, wp] = True
+        if forced_text is not None and force_mask is not None:
+            wp = (o + self._delays[0]) % CT
+            self._cache[force_mask, 0, wp] = forced_text[force_mask]
+            self._provided[force_mask, 0, wp] = True
+
+        for k, delay in enumerate(self._delays):
+            warm = lo <= delay  # [B] cpu bool
+            if bool(warm.any()):
+                wd = warm.to(self._cache.device)
+                pos = o % CT
+                self._cache[:, k, pos] = torch.where(wd, self._initial[k].expand(B), self._cache[:, k, pos])
+                self._provided[:, k, pos] = self._provided[:, k, pos] | wd
+
+        if o == 0:
+            # Genuine cold start: no prior physical frame to read as model input.
+            self._cache[:, :, 0] = self._initial.view(1, K).expand(B, K)
+            self._phys += 1
+            self._local += 1
+            return False, None
+
+        mip = (o - 1) % CT
+        tp = o % CT
+        input_ = self._cache[:, :, mip]  # [B, K]
+        target_ = self._cache[:, :, tp]
+        provided_ = self._provided[:, :, tp]
+
+        emb = self._emb(input_.unsqueeze(-1))  # [B, 1, H]
+        if embed_override is not None:
+            ov, rows = embed_override
+            emb = torch.where(rows.view(B, 1, 1), ov.to(emb.dtype), emb)
+        hidden, text_logits = self._temporal.step(emb)
+
+        sampled_text = text_logits.float().view(B, -1).argmax(-1)  # greedy
+        next_text = torch.where(provided_[:, 0], target_[:, 0], sampled_text)
+        audio = self._dep(next_text, hidden, audio_tokens=target_[:, 1:], audio_provided=provided_[:, 1:])  # [B, 16]
+
+        self._provided[:, :, mip] = False
+        self._cache[:, 0, tp] = torch.where(~provided_[:, 0], sampled_text, self._cache[:, 0, tp])
+        self._cache[:, 1:, tp] = torch.where(~provided_[:, 1:], audio, self._cache[:, 1:, tp])
+
+        max_delay = max(self._delays)
+        valid = lo > max_delay
+        if not bool(valid.any()):
+            self._phys += 1
+            self._local += 1
+            return True, None
+
+        idx = torch.tensor(
+            [(self._phys - max_delay + d) % CT for d in self._delays],
+            device=self._cache.device,
+            dtype=torch.long,
+        )
+        out = self._cache.gather(2, idx.view(1, K, 1).expand(B, K, 1)).squeeze(-1)  # [B, K]
+        self._last_valid = valid.clone()
+        self._phys += 1
+        self._local += 1
+        return True, out
+
+    def _boot_prefill(self, persona: str | None) -> None:
+        """Batch-wide hybrid system prompt: voice -> cache restore -> silence ->
+        persona -> silence (all rows identical)."""
+        import torch
+
+        B = self.config.batch_size
+        dev = self.config.device
+        dummy_user = self._initial[9:].view(1, 8).expand(B, 8)
+        dummy_moshi = self._initial[1:9].view(1, 8).expand(B, 8)
+        zero_text = torch.full((B,), ZERO_TEXT_TOKEN, dtype=torch.long, device=dev)
+        all_rows = torch.ones(B, dtype=torch.bool, device=dev)
+
+        for e in self._voice_embeddings:
+            ov = e.view(1, 1, -1).expand(B, 1, -1)
+            while True:
+                ran, _ = self._tick(dummy_user, dummy_moshi, zero_text, all_rows, embed_override=(ov, all_rows))
+                if ran:
+                    break
+        self._cache.copy_(self._voice_cache.expand_as(self._cache))
+
+        sine = self._sine.view(1, 8).expand(B, 8)
+        silence = self._silence.view(1, 8).expand(B, 8)
+        text = persona if persona is not None else self.config.persona
+        toks = self._tokenizer.encode(wrap_with_system_tags(text)) if text else []
+        for phase_toks in (
+            [ZERO_TEXT_TOKEN] * AUDIO_SILENCE_FRAME_CNT,
+            toks,
+            [ZERO_TEXT_TOKEN] * AUDIO_SILENCE_FRAME_CNT,
+        ):
+            for t in phase_toks:
+                tt = torch.full((B,), int(t), dtype=torch.long, device=dev)
+                self._tick(sine, silence, tt, all_rows)
+        self._codec.reset_streaming()
+
+    # -- batched surface (mirrors the previous engine's API) --------------------
+
+    def open_batch(self) -> None:
+        if not self._loaded:
+            self.load()
+        self._reset_all_streaming()
+        self._boot_prefill(None)
+        self._opened = True
+        logger.info("PersonaPlex native: %d slots prefilled", self.config.batch_size)
+
+    def prefill_steps(self, persona: str | None = None) -> list[PrefillStep]:
+        zero = self._silence
+        silence = [
+            PrefillStep("tokens", moshi_tokens=zero, text_token=ZERO_TEXT_TOKEN, user_sine=True)
+            for _ in range(AUDIO_SILENCE_FRAME_CNT)
+        ]
+        steps: list[PrefillStep] = [PrefillStep("sacrifice")]
+        for e in self._voice_embeddings:
+            steps.append(PrefillStep("voice", embedding=e.view(1, 1, -1)))
+        steps.append(PrefillStep("voice_end"))
+        steps.extend(silence)
+        text = persona if persona is not None else self.config.persona
+        if text:
+            for tok in self._tokenizer.encode(wrap_with_system_tags(text)):
+                steps.append(PrefillStep("tokens", moshi_tokens=zero, text_token=int(tok), user_sine=True))
+        steps.extend(silence)
+        return steps
+
+    def recycle_slot(self, b: int) -> None:
+        self._temporal.reset_slot(b)
+        self._temporal.bump_slot_start(b)  # LM sacrifice-tick semantics
+        self._local[b] = 0
+        self._cache[b] = self._initial.view(-1, 1).expand(-1, self._cache.shape[2])
+        self._provided[b] = False
+
+    def voice_end(self, b: int) -> None:
+        import torch
+
+        ct = self._cache.shape[2]
+        shift = int((self._phys - int(self._local[b])) % ct)
+        self._cache[b] = torch.roll(self._voice_cache[0], shifts=shift, dims=-1)
+
+    def end_prefill(self, b: int) -> None:
+        self._codec.reset_slot(b)
+
+    def step_batch(self, user_pcm: NDArray[np.float32], prefill: dict[int, PrefillStep] | None = None):
+        import torch
+
+        if not self._opened:
+            raise RuntimeError("open_batch() must be called before step_batch()")
+        cfg = self.config
+        B = cfg.batch_size
+        pcm = np.ascontiguousarray(user_pcm, dtype=np.float32).reshape(B, self.frame_size)
+        codes = self._codec.encode_frame(torch.from_numpy(pcm).to(cfg.device)).long()
+        return self._step_from_codes(codes, prefill)
+
+    def step_codes(self, user_codes, prefill: dict[int, PrefillStep] | None = None):
+        """Drive the lockstep loop from precomputed user codes (golden replays).
+
+        Kept public deliberately: bit-exact golden-replay verification must
+        bypass the Mimi encoder, whose streaming conv state makes encoded
+        codes run-order dependent (valid but not reproducible token-for-token).
+        """
+        return self._step_from_codes(user_codes.to(self.config.device).long(), prefill)
+
+    def _step_from_codes(self, codes, prefill):
+        import torch
+
+        from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput
+
+        cfg = self.config
+        B = cfg.batch_size
+        dev = cfg.device
+        forced_moshi = forced_text = force_mask = embed_override = None
+        if prefill:
+            force_mask = torch.zeros(B, dtype=torch.bool, device=dev)
+            embed_rows = torch.zeros(B, dtype=torch.bool, device=dev)
+            emb_full = None
+            forced_moshi = self._initial[1:9].view(1, 8).expand(B, 8).clone()
+            forced_text = torch.full((B,), ZERO_TEXT_TOKEN, dtype=torch.long, device=dev)
+            for b, stp in prefill.items():
+                if stp.kind == "voice_end":
+                    raise ValueError("voice_end is not a tick; call engine.voice_end(b)")
+                codes[b] = self._sine if stp.user_sine else self._initial[9:]
+                if stp.kind == "voice":
+                    embed_rows[b] = True
+                    if emb_full is None:
+                        emb_full = torch.zeros(B, 1, stp.embedding.shape[-1], dtype=stp.embedding.dtype, device=dev)
+                    emb_full[b] = stp.embedding[0]
+                    force_mask[b] = True  # dummy staging like step_embeddings
+                else:
+                    force_mask[b] = True
+                    if stp.kind == "tokens":
+                        forced_moshi[b] = stp.moshi_tokens
+                        forced_text[b] = int(stp.text_token)
+            if bool(embed_rows.any()):
+                embed_override = (emb_full, embed_rows)
+
+        ran, out = self._tick(codes, forced_moshi, forced_text, force_mask, embed_override)
+        self.last_out_tokens = None if out is None else out.detach().cpu()
+        if not ran or out is None:
+            return [None] * B
+
+        valid = self._last_valid  # [B] cpu bool
+        emit = [bool(valid[b]) and (not prefill or b not in prefill) for b in range(B)]
+        audio_tokens = out[:, 1:9].clone()
+        if not all(emit):
+            hide = torch.tensor([not e for e in emit], device=dev).view(B, 1)
+            audio_tokens = torch.where(hide, self._silence.view(1, 8).expand(B, 8), audio_tokens)
+        pcm_out = self._codec.decode_frame(audio_tokens)  # [B, frame]
+        outs = []
+        for b in range(B):
+            if not emit[b]:
+                outs.append(None)
+                continue
+            audio = pcm_out[b].float().detach().cpu().numpy().astype(np.float32)
+            outs.append(FrameOutput(audio=audio, text=self._decode_text(int(out[b, 0].item()))))
+        return outs
+
+    # -- single-session FrameStepper surface -------------------------------------
+
+    def open_session(self, voice_prompt: str | None = None, persona: str | None = None) -> None:
+        with self._fs_lock:
+            if not self._loaded:
+                self.load()
+            # Always resolve a voice: falling back to the configured default here
+            # keeps a previous session's custom voice from leaking into this one.
+            self._load_voice(voice_prompt or self.config.voice_prompt)
+            self._reset_all_streaming()
+            self._boot_prefill(persona)
+            self._opened = True
+
+    def step(self, user_pcm: NDArray[np.float32]):
+        with self._fs_lock:
+            pcm = np.ascontiguousarray(user_pcm, dtype=np.float32).reshape(-1)
+            if pcm.shape[0] != self.frame_size:
+                raise ValueError(f"expected {self.frame_size} samples per frame, got {pcm.shape[0]}")
+            outs = self.step_batch(pcm.reshape(1, -1))
+        from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput
+
+        return outs[0] if outs[0] is not None else FrameOutput(audio=None, text=None)
+
+    def _decode_text(self, token_id: int) -> str | None:
+        if token_id in NON_TEXT_TOKEN_IDS or token_id >= TEXT_VOCAB_SIZE:
+            return None
+        return self._tokenizer.id_to_piece(token_id).replace("▁", " ")
diff --git a/vllm_omni/experimental/fullduplex/personaplex/runtime_extension.py b/vllm_omni/experimental/fullduplex/personaplex/runtime_extension.py
new file mode 100644
index 000000000..036103a43
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/runtime_extension.py
@@ -0,0 +1,129 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import base64
+import binascii
+from typing import Any
+
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexAppendPlan,
+    DuplexInputMode,
+    DuplexOutputDecision,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+_FRAME_BYTES = 1920 * 4
+
+
+def _validated_frame_payload(payload: object) -> dict[str, object]:
+    if not isinstance(payload, dict):
+        raise ValueError("PersonaPlex duplex append payload must be a mapping")
+    if payload.get("format") != "pcm_f32le":
+        raise ValueError("PersonaPlex duplex append format must be pcm_f32le")
+    if payload.get("sample_rate_hz") != 24000:
+        raise ValueError("PersonaPlex duplex append sample_rate_hz must be 24000")
+    audio = payload.get("audio")
+    if not isinstance(audio, str):
+        raise ValueError("PersonaPlex duplex append audio must be base64 pcm_f32le")
+    try:
+        raw = base64.b64decode(audio, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise ValueError("PersonaPlex duplex append audio is not valid base64") from exc
+    if len(raw) != _FRAME_BYTES:
+        raise ValueError("PersonaPlex duplex append must contain exactly 1920 samples")
+    return dict(payload)
+
+
+class PersonaPlexDuplexRuntimeExtension:
+    """PersonaPlex policy for the engine-owned resumable duplex request."""
+
+    def configure_sampling_params(
+        self,
+        *,
+        runtime_config: dict[str, Any],
+        defaults: tuple[object, ...],
+    ) -> tuple[object, ...]:
+        del runtime_config
+        if not defaults:
+            return defaults
+        configured = list(defaults)
+        stage0 = defaults[0]
+        if isinstance(stage0, SamplingParams):
+            stage0 = stage0.clone()
+            stage0.temperature = 0.0
+            stage0.top_k = 1
+            stage0.max_tokens = 1
+            configured[0] = stage0
+        return tuple(configured)
+
+    def plan_append(
+        self,
+        *,
+        request_id: str,
+        fence: DuplexFence,
+        session_config: dict[str, Any],
+        runtime_config: dict[str, Any],
+        seq: int,
+        turn_seq: int,
+        mode: DuplexInputMode,
+        payload: object,
+        final: bool,
+        sampling_params: object,
+    ) -> DuplexAppendPlan:
+        del sampling_params
+        if mode is not DuplexInputMode.APPEND_AUDIO_CHUNK:
+            raise ValueError(f"PersonaPlex does not support duplex input mode {mode.value!r}")
+        normalized_payload = _validated_frame_payload(payload)
+        prefill_slots = runtime_config.get("personaplex_prefill_slots", 0)
+        try:
+            prefill_slots = max(0, int(prefill_slots))
+        except (TypeError, ValueError) as exc:
+            raise ValueError("personaplex_prefill_slots must be a non-negative integer") from exc
+        prompt_slots = 1 + (prefill_slots if seq <= 1 else 0)
+        return DuplexAppendPlan(
+            prompt={
+                "prompt_token_ids": [0] * prompt_slots,
+                "model_intermediate_buffer": {
+                    "request_id": request_id,
+                    "global_request_id": [fence.session_id],
+                    "duplex": {
+                        "data_plane": True,
+                        "fence": fence,
+                        "session_id": fence.session_id,
+                        "incarnation": fence.incarnation,
+                        "epoch": fence.epoch,
+                        "turn_id": fence.turn_id,
+                        "response_seq": fence.response_seq,
+                        "seq": seq,
+                        "turn_seq": turn_seq,
+                        "mode": mode.value,
+                        "payload": normalized_payload,
+                        "final": final,
+                        "session_config": dict(session_config),
+                        "runtime_config": dict(runtime_config),
+                        "scheduler_token_budget": prompt_slots,
+                    },
+                },
+            }
+        )
+
+    def decide_output(
+        self,
+        *,
+        stage_id: int,
+        final_stage_id: int,
+        segment_finished: bool,
+        segment_token_ids: tuple[int, ...],
+        segment_output_metadata: dict[str, Any],
+        output: object,
+    ) -> DuplexOutputDecision | None:
+        del stage_id, final_stage_id, segment_finished
+        del segment_token_ids, segment_output_metadata, output
+        return None
+
+
+__all__ = ["PersonaPlexDuplexRuntimeExtension"]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/serving/__init__.py b/vllm_omni/experimental/fullduplex/personaplex/serving/__init__.py
new file mode 100644
index 000000000..c3044a80d
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/serving/__init__.py
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex full-duplex WebSocket serving (PCM in / PCM + text out)."""
+
+from typing import Any
+
+__all__ = ["create_app", "main"]
+
+
+def __getattr__(name: str) -> Any:
+    if name not in __all__:
+        raise AttributeError(name)
+    from vllm_omni.experimental.fullduplex.personaplex.serving import server
+
+    return getattr(server, name)
diff --git a/vllm_omni/experimental/fullduplex/personaplex/serving/batched.py b/vllm_omni/experimental/fullduplex/personaplex/serving/batched.py
new file mode 100644
index 000000000..26abd92a8
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/serving/batched.py
@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Slot manager + lockstep tick loop for batched PersonaPlex serving.
+
+Pure-python orchestration over a :class:`PersonaPlexEngine`-shaped object
+(injected, so tests run GPU-free with a stub): a fixed table of B conversation
+slots, one shared wall-clock 80 ms tick that advances every non-idle slot, and
+per-slot recycle prefill for new callers.
+
+Threading model: ``tick()`` runs on a dedicated stepping thread (the engine call
+is synchronous CUDA work); ``acquire``/``release``/``feed`` are called from the
+asyncio thread. All slot state is guarded by one lock; per-frame output is
+handed off via each slot's ``on_output`` callback (called on the stepping
+thread -- the server bridges to asyncio with ``call_soon_threadsafe``).
+"""
+
+from __future__ import annotations
+
+import enum
+import logging
+import threading
+import time
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class SlotPhase(enum.Enum):
+    IDLE = "idle"
+    PREFILL = "prefill"
+    LIVE = "live"
+
+
+@dataclass
+class Slot:
+    index: int
+    phase: SlotPhase = SlotPhase.IDLE
+    used: bool = False  # a used slot must be recycled before reuse
+    needs_recycle: bool = False  # engine.reset executed by the tick thread only
+    epoch: int = 0
+    pending: np.ndarray = field(default_factory=lambda: np.zeros(0, dtype=np.float32))
+    inq: deque = field(default_factory=deque)
+    prefill: deque = field(default_factory=deque)
+    on_output: Callable[[Any], None] | None = None  # FrameOutput, stepping thread
+    on_ready: Callable[[], None] | None = None  # prefill finished, stepping thread
+
+
+class BatchedSessionManager:
+    """Own the slot table and drive one engine tick per call to :meth:`tick`."""
+
+    def __init__(self, engine, max_buffered_frames: int = 25) -> None:
+        self.engine = engine
+        self.frame_size = engine.frame_size
+        self.batch_size = engine.config.batch_size
+        self.max_buffered_frames = max_buffered_frames
+        self.slots = [Slot(index=i) for i in range(self.batch_size)]
+        self.lock = threading.Lock()
+        # step_batch advances EVERY row each tick (lockstep), so once any tick has
+        # run, "pristine" idle rows have silently drifted from their boot prefill
+        # and must be recycled before a client may join them.
+        self._ticked = False
+
+    # -- connection side (asyncio thread) ------------------------------------
+
+    def acquire(self, persona: str | None = None) -> tuple[Slot, bool] | None:
+        """Claim an idle slot. Returns ``(slot, ready_now)`` or ``None`` if full.
+
+        A pristine slot (never used since boot, and claimed before the first
+        engine tick) still carries the default voice + persona from
+        ``open_batch`` and is live immediately when no custom persona is
+        requested. Otherwise the slot is recycled and its system prompt
+        replayed over the next ticks (``ready_now == False``) -- including
+        pristine rows after ticking has started, because lockstep stepping
+        advances every row whether or not a client is attached.
+        """
+        with self.lock:
+            slot = next((s for s in self.slots if s.phase is SlotPhase.IDLE), None)
+            if slot is None:
+                return None
+            slot.epoch += 1
+            slot.pending = np.zeros(0, dtype=np.float32)
+            slot.inq.clear()
+            slot.prefill.clear()
+            if not slot.used and persona is None and not self._ticked:
+                slot.phase = SlotPhase.LIVE
+                slot.used = True
+                return slot, True
+            # The engine reset itself must run BETWEEN engine steps, i.e. on the
+            # stepping thread -- only mark it here; tick() executes it.
+            slot.prefill.extend(self.engine.prefill_steps(persona))
+            slot.needs_recycle = True
+            slot.phase = SlotPhase.PREFILL
+            slot.used = True
+            return slot, False
+
+    def release(self, slot: Slot) -> None:
+        with self.lock:
+            slot.phase = SlotPhase.IDLE
+            slot.epoch += 1
+            slot.on_output = None
+            slot.on_ready = None
+            slot.inq.clear()
+            slot.prefill.clear()
+            slot.pending = np.zeros(0, dtype=np.float32)
+
+    def feed(self, slot: Slot, pcm: np.ndarray, epoch: int) -> None:
+        """Buffer incoming PCM and carve it into exact engine frames."""
+        with self.lock:
+            if slot.epoch != epoch or slot.phase is SlotPhase.IDLE:
+                return
+            samples = np.ascontiguousarray(pcm, dtype=np.float32).reshape(-1)
+            slot.pending = np.concatenate([slot.pending, samples]) if slot.pending.size else samples
+            n = self.frame_size
+            while slot.pending.shape[0] >= n:
+                frame, slot.pending = slot.pending[:n], slot.pending[n:]
+                slot.inq.append(frame)
+                while len(slot.inq) > self.max_buffered_frames:
+                    slot.inq.popleft()  # realtime: drop the oldest backlog
+
+    # -- stepping side (dedicated thread) ------------------------------------
+
+    def tick(self) -> bool:
+        """Advance every non-idle slot one frame. Returns False when all idle."""
+        with self.lock:
+            if all(s.phase is SlotPhase.IDLE for s in self.slots):
+                return False
+            self._ticked = True
+            pcm = np.zeros((self.batch_size, self.frame_size), dtype=np.float32)
+            prefill: dict[int, Any] = {}
+            emitters: list[tuple[Slot, int]] = []
+            for slot in self.slots:
+                if slot.phase is SlotPhase.LIVE:
+                    if slot.inq:
+                        pcm[slot.index] = slot.inq.popleft()
+                    emitters.append((slot, slot.epoch))
+                elif slot.phase is SlotPhase.PREFILL:
+                    if slot.needs_recycle:
+                        self.engine.recycle_slot(slot.index)
+                        slot.needs_recycle = False
+                    while slot.prefill and slot.prefill[0].kind == "voice_end":
+                        self.engine.voice_end(slot.index)
+                        slot.prefill.popleft()
+                    if slot.prefill:
+                        prefill[slot.index] = slot.prefill.popleft()
+                    else:
+                        self.engine.end_prefill(slot.index)
+                        slot.phase = SlotPhase.LIVE
+                        emitters.append((slot, slot.epoch))
+                        if slot.on_ready is not None:
+                            slot.on_ready()
+
+        outs = self.engine.step_batch(pcm, prefill or None)
+
+        with self.lock:
+            for slot, epoch in emitters:
+                out = outs[slot.index]
+                if out is None or slot.epoch != epoch or slot.on_output is None:
+                    continue
+                slot.on_output(out)
+        return True
+
+    def run_forever(self, stop: threading.Event, frame_seconds: float = 0.08) -> None:
+        """Wall-clock-paced stepping loop (run on a dedicated thread)."""
+        next_t = time.monotonic()
+        while not stop.is_set():
+            did = self.tick()
+            if not did:
+                time.sleep(frame_seconds / 4)
+                next_t = time.monotonic()
+                continue
+            next_t += frame_seconds
+            delay = next_t - time.monotonic()
+            if delay > 0:
+                time.sleep(delay)
+            elif delay < -1.0:
+                # Fell far behind realtime (e.g. B too large for the GPU); resync
+                # rather than bursting to catch up.
+                logger.warning("batched tick loop %.1fs behind realtime; resyncing", -delay)
+                next_t = time.monotonic()
diff --git a/vllm_omni/experimental/fullduplex/personaplex/serving/server.py b/vllm_omni/experimental/fullduplex/personaplex/serving/server.py
new file mode 100644
index 000000000..fcb857628
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/serving/server.py
@@ -0,0 +1,539 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex full-duplex server, compatible with the OFFICIAL Moshi web client.
+
+Serves the official PersonaPlex web UI (``dist.tgz`` from ``nvidia/personaplex-7b-v1``,
+the same bundle ``moshi.server`` downloads) and implements its WebSocket protocol at
+``/api/chat`` -- but driven by our native-component engine instead of moshi's server.
+
+Built on **aiohttp**, mirroring ``moshi.server`` exactly: aiohttp writes+drains each
+WebSocket frame promptly, whereas uvicorn's ``websockets`` backend coalesces many small
+(~80 ms Opus) frames into a send buffer, which makes browser playback choppy even when
+the engine is real-time. aiohttp ships as a moshi dependency, so this adds nothing new.
+
+Moshi protocol (binary WS messages, first byte = tag):
+  server -> client  ``\\x00``                 handshake (ready, after system prompts)
+  client -> server  ``\\x01`` + opus bytes    mic audio (Opus @ 24kHz)
+  server -> client  ``\\x01`` + opus bytes    agent audio (Opus @ 24kHz)
+  server -> client  ``\\x02`` + utf8          inner-monologue text
+Query params on connect: ``text_prompt`` (persona), ``voice_prompt`` (voice file).
+
+Run (auto-downloads the official UI; open http://<host>:8124/):
+    HF_TOKEN=... CUDA_VISIBLE_DEVICES=0 python -m \\
+        vllm_omni.experimental.fullduplex.personaplex.serving.server --port 8124
+
+A raw-PCM endpoint (``/v1/audio/duplex``, JSON ``open`` + float32 frames) remains for
+tooling/tests that do not want an Opus dependency.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import contextlib
+import functools
+import json
+import logging
+import tarfile
+import threading
+from pathlib import Path
+
+import numpy as np
+import sphn
+from aiohttp import WSMsgType, web
+from huggingface_hub import hf_hub_download
+
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.engine import PersonaPlexEngine
+from vllm_omni.experimental.fullduplex.personaplex.serving.batched import BatchedSessionManager
+from vllm_omni.experimental.fullduplex.personaplex.session import (
+    PersonaPlexServingSessionState,
+    PersonaPlexSession,
+    offer_realtime,
+)
+
+logger = logging.getLogger(__name__)
+_HF_REPO = "nvidia/personaplex-7b-v1"
+
+
+def _opus_encode(writer: sphn.OpusStreamWriter, pcm: np.ndarray) -> bytes:
+    """Encode one PCM frame to Opus bytes, across sphn API versions.
+
+    sphn 0.2.x returns the encoded bytes straight from ``append_pcm``; the older
+    0.1.x buffers and requires a ``read_bytes`` drain. Handle both.
+    """
+    out = writer.append_pcm(np.ascontiguousarray(pcm, dtype=np.float32))
+    if out is None and hasattr(writer, "read_bytes"):
+        out = writer.read_bytes()
+    return out or b""
+
+
+def _opus_decode(reader: sphn.OpusStreamReader, data: bytes) -> np.ndarray | None:
+    """Decode Opus bytes to PCM, across sphn API versions (see ``_opus_encode``)."""
+    out = reader.append_bytes(data)
+    if out is None and hasattr(reader, "read_pcm"):
+        out = reader.read_pcm()
+    if out is None or getattr(out, "shape", (0,))[-1] == 0:
+        return None
+    return np.asarray(out, dtype=np.float32)
+
+
+def _official_web_dir() -> Path | None:
+    """Download + extract the official PersonaPlex web client (dist.tgz)."""
+    try:
+        tgz = Path(hf_hub_download(_HF_REPO, "dist.tgz"))
+        dist = tgz.parent / "dist"
+        if not dist.exists():
+            with tarfile.open(tgz, "r:gz") as tar:
+                tar.extractall(path=tgz.parent)  # noqa: S202 - trusted first-party bundle
+        return dist if dist.exists() else None
+    except Exception as exc:  # network / auth / layout
+        logger.warning("official web client unavailable (%s); / will return an error note", exc)
+        return None
+
+
+class DuplexServer:
+    """Owns the loaded engine; serves one duplex conversation at a time.
+
+    A capacity-one lease covers the entire WebSocket lifetime on BOTH endpoints:
+    the engine is a single shared streaming state, so a second concurrent
+    connection would reset and corrupt the live conversation. Extra connections
+    are rejected with 1013 (try again later). Engine work (``open``/``feed``,
+    synchronous CUDA) runs on a worker thread so the event loop stays free for
+    WebSocket traffic and close handling.
+    """
+
+    def __init__(self, config: PersonaPlexConfig) -> None:
+        self.config = config
+        self.engine = PersonaPlexEngine(config)
+        self._active = False  # capacity-one session lease (event-loop confined)
+        self._lease_release_tasks: set[asyncio.Task] = set()
+
+    def load(self) -> None:
+        self.engine.load()
+
+    async def _lease(self, ws: web.WebSocketResponse) -> bool:
+        """Try to claim the single-session lease; reject the connection if held."""
+        if self._active:
+            await ws.close(code=1013, message=b"another conversation is active")
+            return False
+        self._active = True
+        return True
+
+    async def _engine_call(self, state: PersonaPlexServingSessionState, fn, *args, **kwargs):
+        """Run one synchronous engine call on a worker thread, tracked for drain.
+
+        Cancelling the awaiting task does NOT stop the worker thread, and it
+        marks the asyncio wrapper future cancelled (``done()``) even while the
+        thread keeps running, so the future itself cannot signal completion.
+        The worker instead sets a plain ``threading.Event`` when the call truly
+        finishes; :meth:`_drain_inflight` waits on that event before the lease
+        is released. Without this, a fast reconnect could acquire the lease and
+        call ``open()`` while the previous connection's final ``step()`` is
+        still mutating the shared engine on its thread.
+        """
+        call = functools.partial(fn, *args, **kwargs)
+        finished = threading.Event()
+
+        def run_and_signal():
+            try:
+                return call()
+            finally:
+                finished.set()
+
+        state.inflight = finished
+        result = await asyncio.get_running_loop().run_in_executor(None, run_and_signal)
+        state.inflight = None  # on cancellation, the event stays referenced for drain
+        return result
+
+    @staticmethod
+    async def _drain_inflight(state: PersonaPlexServingSessionState, timeout: float = 5.0) -> bool:
+        """Wait out any engine call still running on a worker thread."""
+        finished = state.inflight
+        if finished is None or finished.is_set():
+            return True
+        return bool(await asyncio.to_thread(finished.wait, timeout))
+
+    async def _release_lease_when_finished(self, state: PersonaPlexServingSessionState) -> None:
+        finished = state.inflight
+        if finished is not None and not finished.is_set():
+            await asyncio.to_thread(finished.wait)
+        self._active = False
+
+    async def _release_lease_after_drain(
+        self,
+        state: PersonaPlexServingSessionState,
+        *,
+        timeout: float = 5.0,
+    ) -> bool:
+        """Release now when drained, otherwise retain the lease until completion."""
+        if await self._drain_inflight(state, timeout):
+            self._active = False
+            return True
+
+        logger.error(
+            "PersonaPlex engine cleanup exceeded %.1fs; retaining the session lease until the worker thread finishes",
+            timeout,
+        )
+        task = asyncio.create_task(self._release_lease_when_finished(state))
+        self._lease_release_tasks.add(task)
+        task.add_done_callback(self._lease_release_tasks.discard)
+        return False
+
+    # ---- official Moshi protocol (Opus over aiohttp WS) ---------------------
+
+    async def handle_chat(self, request: web.Request) -> web.WebSocketResponse:
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        if not await self._lease(ws):
+            return ws
+        state = PersonaPlexServingSessionState()
+        try:
+            persona = (request.query.get("text_prompt") or "").strip() or None
+            voice = (request.query.get("voice_prompt") or "").strip() or None
+            sr = self.engine.sample_rate
+            session = PersonaPlexSession(self.engine, self.config)
+            # System-prompt prefill is seconds of GPU work; keep it off the loop.
+            await self._engine_call(state, session.open, voice_prompt=voice, persona=persona)
+
+            reader = sphn.OpusStreamReader(sr)
+            writer = sphn.OpusStreamWriter(sr)
+            await ws.send_bytes(b"\x00")  # ready handshake
+
+            async def recv_loop() -> None:
+                try:
+                    async for msg in ws:
+                        if msg.type == WSMsgType.BINARY:
+                            data = msg.data
+                            if data and data[0] == 1:
+                                pcm = _opus_decode(reader, data[1:])
+                                if pcm is not None:
+                                    offer_realtime(state.pcm_queue, pcm)
+                        elif msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.ERROR):
+                            break
+                finally:
+                    state.closed = True
+
+            async def proc_loop() -> None:
+                # Drain decoded PCM and step the model, streaming agent Opus + text
+                # out. The synchronous engine step runs on a worker thread.
+                while not state.closed:
+                    try:
+                        pcm = await asyncio.wait_for(state.pcm_queue.get(), timeout=0.25)
+                    except asyncio.TimeoutError:
+                        continue
+                    for frame_out in await self._engine_call(state, session.feed, pcm):
+                        if frame_out.audio is not None:
+                            opus = _opus_encode(writer, frame_out.audio)
+                            if opus:
+                                await ws.send_bytes(b"\x01" + opus)
+                        if frame_out.text:
+                            await ws.send_bytes(b"\x02" + frame_out.text.encode("utf8"))
+
+            tasks = [asyncio.create_task(recv_loop()), asyncio.create_task(proc_loop())]
+            try:
+                _, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+                for t in pending:
+                    t.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await t
+            finally:
+                with contextlib.suppress(Exception):
+                    await ws.close()
+        finally:
+            # A cancelled feed/open may still be running on its worker thread;
+            # wait it out BEFORE freeing the lease, or a fast reconnect races
+            # the shared engine (CUDA illegal access / cross-session bleed).
+            await self._release_lease_after_drain(state)
+        return ws
+
+    # ---- simple raw-PCM protocol (no Opus, for tests) ----------------------
+
+    async def handle_raw(self, request: web.Request) -> web.WebSocketResponse:
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        if not await self._lease(ws):
+            return ws
+        session = PersonaPlexSession(self.engine, self.config)
+        state = PersonaPlexServingSessionState()
+        opened = False
+        try:
+            async for msg in ws:
+                if msg.type == WSMsgType.TEXT:
+                    req = json.loads(msg.data)
+                    if req.get("type") == "open":
+                        await self._engine_call(
+                            state, session.open, voice_prompt=req.get("voice"), persona=req.get("persona")
+                        )
+                        opened = True
+                        await ws.send_json({"type": "ready"})
+                    elif req.get("type") == "close":
+                        if opened:
+                            await self._emit(ws, await self._engine_call(state, session.flush))
+                        await ws.send_json({"type": "done"})
+                        break
+                elif msg.type == WSMsgType.BINARY:
+                    if not opened:
+                        await self._engine_call(state, session.open)
+                        opened = True
+                    pcm = np.frombuffer(msg.data, dtype=np.float32)
+                    await self._emit(ws, await self._engine_call(state, session.feed, pcm))
+                elif msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.ERROR):
+                    break
+        finally:
+            # Same as handle_chat: wait out any worker-thread engine call
+            # before freeing the lease (see _engine_call).
+            await self._release_lease_after_drain(state)
+            with contextlib.suppress(Exception):
+                await ws.close()
+        return ws
+
+    @staticmethod
+    async def _emit(ws: web.WebSocketResponse, outputs: list) -> None:
+        for frame_out in outputs:
+            if frame_out.audio is not None:
+                await ws.send_bytes(np.ascontiguousarray(frame_out.audio, dtype=np.float32).tobytes())
+            if frame_out.text:
+                await ws.send_json({"type": "text", "text": frame_out.text})
+
+
+class BatchedDuplexServer:
+    """Serve ``batch_size`` concurrent duplex conversations on one engine.
+
+    Same wire protocols as :class:`DuplexServer`; each connection claims a slot
+    from the shared :class:`BatchedSessionManager`, whose stepping thread ticks
+    all live slots in lockstep at 12.5 Hz wall clock. A connection with a custom
+    ``text_prompt`` (or reusing a previously used slot) waits while the slot's
+    system prompt is replayed per-row (voice embeddings + persona), then gets the
+    ready handshake. Per-connection custom voices are not supported in batched
+    mode (fixed default voice; ``voice_prompt`` is ignored with a warning).
+    """
+
+    def __init__(self, config: PersonaPlexConfig) -> None:
+        self.config = config
+        self.engine = PersonaPlexEngine(config)
+        self.manager: BatchedSessionManager | None = None
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def load(self) -> None:
+        self.engine.load()
+        self.engine.open_batch()
+        self.manager = BatchedSessionManager(self.engine)
+        self._thread = threading.Thread(
+            target=self.manager.run_forever, args=(self._stop,), daemon=True, name="pplex-tick"
+        )
+        self._thread.start()
+
+    def shutdown(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+
+    async def _acquire(self, ws: web.WebSocketResponse, persona: str | None):
+        """Claim a slot and wait until it is live.
+
+        Returns ``PersonaPlexServingSessionState`` (slot + bounded output queue)
+        or ``None`` when the server is full. Exception-safe: if this coroutine
+        is cancelled (client gone mid-prefill) or the wait fails, the slot is
+        released instead of leaking in the PREFILL/LIVE phase.
+        """
+        acquired = self.manager.acquire(persona=persona)
+        if acquired is None:
+            await ws.close(code=1013, message=b"all conversation slots busy")
+            return None
+        slot, ready_now = acquired
+        try:
+            loop = asyncio.get_running_loop()
+            state = PersonaPlexServingSessionState(slot=slot, epoch=slot.epoch)
+            ready = asyncio.Event()
+            with self.manager.lock:
+                # Bounded handoff: the tick thread produces one frame per 80 ms;
+                # a client that stops reading gets drop-oldest, not unbounded RAM.
+                slot.on_output = lambda frame_out: loop.call_soon_threadsafe(offer_realtime, state.out_queue, frame_out)
+                if ready_now:
+                    ready.set()
+                else:
+                    slot.on_ready = lambda: loop.call_soon_threadsafe(ready.set)
+            await ready.wait()
+        except BaseException:
+            self.manager.release(slot)
+            raise
+        return state
+
+    async def handle_chat(self, request: web.Request) -> web.WebSocketResponse:
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        persona = (request.query.get("text_prompt") or "").strip() or None
+        if (request.query.get("voice_prompt") or "").strip():
+            logger.warning("batched mode ignores per-connection voice_prompt (fixed default voice)")
+        state = await self._acquire(ws, persona)
+        if state is None:
+            return ws
+        try:
+            sr = self.engine.sample_rate
+            reader = sphn.OpusStreamReader(sr)
+            writer = sphn.OpusStreamWriter(sr)
+            await ws.send_bytes(b"\x00")  # ready handshake
+
+            async def recv_loop() -> None:
+                try:
+                    async for msg in ws:
+                        if msg.type == WSMsgType.BINARY:
+                            data = msg.data
+                            if data and data[0] == 1:
+                                pcm = _opus_decode(reader, data[1:])
+                                if pcm is not None:
+                                    self.manager.feed(state.slot, pcm, state.epoch)
+                        elif msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.ERROR):
+                            break
+                finally:
+                    state.closed = True
+
+            async def out_loop() -> None:
+                while not state.closed:
+                    try:
+                        frame_out = await asyncio.wait_for(state.out_queue.get(), timeout=0.25)
+                    except asyncio.TimeoutError:
+                        continue
+                    if frame_out.audio is not None:
+                        msg = _opus_encode(writer, frame_out.audio)
+                        if msg:
+                            await ws.send_bytes(b"\x01" + msg)
+                    if frame_out.text:
+                        await ws.send_bytes(b"\x02" + frame_out.text.encode("utf8"))
+
+            tasks = [asyncio.create_task(recv_loop()), asyncio.create_task(out_loop())]
+            _, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+            for t in pending:
+                t.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await t
+        finally:
+            self.manager.release(state.slot)
+            with contextlib.suppress(Exception):
+                await ws.close()
+        return ws
+
+    async def handle_raw(self, request: web.Request) -> web.WebSocketResponse:
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        state: PersonaPlexServingSessionState | None = None
+        sender: asyncio.Task | None = None
+
+        async def pump(outq: asyncio.Queue) -> None:
+            # Forward slot output continuously (the tick loop produces in realtime).
+            while True:
+                frame_out = await outq.get()
+                if frame_out.audio is not None:
+                    await ws.send_bytes(np.ascontiguousarray(frame_out.audio, dtype=np.float32).tobytes())
+                if frame_out.text:
+                    await ws.send_json({"type": "text", "text": frame_out.text})
+
+        try:
+            async for msg in ws:
+                if msg.type == WSMsgType.TEXT:
+                    req = json.loads(msg.data)
+                    if req.get("type") == "open":
+                        if state is not None:
+                            # One slot lease per connection; a second `open` would
+                            # silently leak the first slot and its pump.
+                            await ws.send_json({"type": "error", "error": "session already open"})
+                            continue
+                        state = await self._acquire(ws, (req.get("persona") or "").strip() or None)
+                        if state is None:
+                            return ws
+                        sender = asyncio.create_task(pump(state.out_queue))
+                        await ws.send_json({"type": "ready"})
+                    elif req.get("type") == "close":
+                        await asyncio.sleep(0.3)  # let in-flight frames flush via pump
+                        await ws.send_json({"type": "done"})
+                        break
+                elif msg.type == WSMsgType.BINARY and state is not None:
+                    self.manager.feed(state.slot, np.frombuffer(msg.data, dtype=np.float32), state.epoch)
+                elif msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.ERROR):
+                    break
+        finally:
+            # Release FIRST and unconditionally: a pump that already failed (e.g.
+            # peer reset mid-send) re-raises on await and must not leak the slot.
+            if state is not None:
+                self.manager.release(state.slot)
+            if sender is not None:
+                sender.cancel()
+                try:
+                    await sender
+                except asyncio.CancelledError:
+                    pass
+                except Exception:
+                    logger.debug("raw output pump ended with an error", exc_info=True)
+            with contextlib.suppress(Exception):
+                await ws.close()
+        return ws
+
+
+def create_app(config: PersonaPlexConfig) -> web.Application:
+    server = BatchedDuplexServer(config) if config.batch_size > 1 else DuplexServer(config)
+    web_dir = _official_web_dir()
+
+    async def _startup(_app: web.Application) -> None:
+        logger.info("PersonaPlex duplex server: loading engine (batch_size=%d)", config.batch_size)
+        server.load()
+        logger.info("PersonaPlex duplex server: ready (official web: %s)", bool(web_dir))
+
+    async def _cleanup(_app: web.Application) -> None:
+        if isinstance(server, BatchedDuplexServer):
+            server.shutdown()
+
+    app = web.Application()
+    app.on_startup.append(_startup)
+    app.on_cleanup.append(_cleanup)
+
+    async def health(_request: web.Request) -> web.Response:
+        return web.json_response({"status": "ok"})
+
+    app.router.add_get("/health", health)
+    app.router.add_get("/api/chat", server.handle_chat)
+    app.router.add_get("/v1/audio/duplex", server.handle_raw)
+
+    # Serve the official PersonaPlex web client (explicit routes are matched first).
+    if web_dir is not None:
+
+        async def index(_request: web.Request) -> web.FileResponse:
+            return web.FileResponse(web_dir / "index.html")
+
+        app.router.add_get("/", index)
+        app.router.add_static("/", path=str(web_dir), follow_symlinks=True, name="web")
+    else:
+
+        async def index_missing(_request: web.Request) -> web.Response:
+            return web.json_response({"error": f"official web client unavailable; check access to {_HF_REPO}"})
+
+        app.router.add_get("/", index_missing)
+
+    return app
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--host", default="0.0.0.0")
+    ap.add_argument("--port", type=int, default=8124)
+    ap.add_argument("--persona", default=None)
+    ap.add_argument("--voice", default="NATF2.pt")
+    ap.add_argument(
+        "--batch-size",
+        type=int,
+        default=1,
+        help="Concurrent conversation slots on one engine (elastic batching when > 1).",
+    )
+    args = ap.parse_args()
+    logging.basicConfig(level=logging.INFO)
+    cfg = PersonaPlexConfig(
+        voice_prompt=args.voice,
+        batch_size=args.batch_size,
+        **({"persona": args.persona} if args.persona else {}),
+    )
+    web.run_app(create_app(cfg), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/vllm_omni/experimental/fullduplex/personaplex/serving_adapter.py b/vllm_omni/experimental/fullduplex/personaplex/serving_adapter.py
new file mode 100644
index 000000000..66244ca68
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/serving_adapter.py
@@ -0,0 +1,233 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Mapping
+from copy import deepcopy
+from dataclasses import dataclass, field
+from pathlib import PurePath
+from typing import Any
+
+from vllm_omni.experimental.fullduplex.openai.protocol import (
+    DuplexCapabilities,
+)
+from vllm_omni.experimental.fullduplex.openai.runtime_adapter import (
+    ServingRuntimeConfigError,
+)
+from vllm_omni.experimental.fullduplex.personaplex.config import DEFAULT_PERSONA
+from vllm_omni.experimental.fullduplex.personaplex.data_plane import (
+    PersonaPlexDataPlaneContext,
+    PersonaPlexDataPlaneSession,
+)
+from vllm_omni.experimental.fullduplex.personaplex.input import (
+    PersonaPlexPcmAppendBuffer,
+)
+
+EncodeAudio = Callable[[object, int, str, float | None], str | None]
+
+_PRIVATE_RUNTIME_CONFIG_KEYS = frozenset(
+    {
+        "personaplex_prefill_slots",
+        "personaplex_model_path",
+    }
+)
+
+
+@dataclass(slots=True)
+class PersonaPlexServingSessionState:
+    audio_buffer: PersonaPlexPcmAppendBuffer = field(default_factory=PersonaPlexPcmAppendBuffer)
+    input_since_commit: bool = False
+    speech_since_commit: bool = False
+    committed_audio_payload: dict[str, object] | None = None
+    committed_audio_operation_id: str | None = None
+    committed_audio_reserved_bytes: int = 0
+    deferred_response_create: bool = False
+    deferred_precreate_response: bool = False
+    data_plane_task: asyncio.Task[None] | None = None
+    data_plane_restart_requested: bool = False
+    continuation_owner_id: str | None = None
+    continuation_units: int = 0
+    pending_silence_task: asyncio.Task[bool] | None = None
+    pending_silence_owner_id: str | None = None
+    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | None = None
+
+    def retain_committed_audio(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str | None,
+        reserved_bytes: int = 0,
+    ) -> None:
+        self.committed_audio_payload = payload
+        self.committed_audio_operation_id = operation_id
+        self.committed_audio_reserved_bytes += max(0, int(reserved_bytes))
+
+    def clear_committed_audio(self) -> int:
+        reserved_bytes = self.committed_audio_reserved_bytes
+        self.committed_audio_payload = None
+        self.committed_audio_operation_id = None
+        self.committed_audio_reserved_bytes = 0
+        self.deferred_response_create = False
+        self.deferred_precreate_response = False
+        return reserved_bytes
+
+    def clear_continuation(self) -> None:
+        self.continuation_owner_id = None
+        self.continuation_units = 0
+        self.pending_silence_task = None
+        self.pending_silence_owner_id = None
+
+
+class PersonaPlexServingRuntimeAdapter:
+    adapter_id = "personaplex"
+    clean_response_done_prefix = ""
+    interrupted_tts_prefix = ""
+    private_runtime_config_keys = _PRIVATE_RUNTIME_CONFIG_KEYS
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        self.session_states: dict[str, PersonaPlexServingSessionState] = {}
+        self.data_plane = PersonaPlexDataPlaneSession(encode_audio)
+
+    def create_session_state(self) -> PersonaPlexServingSessionState:
+        return PersonaPlexServingSessionState()
+
+    def session_state(self, session_id: str) -> PersonaPlexServingSessionState:
+        return self.session_states.setdefault(session_id, self.create_session_state())
+
+    def remove_session_state(self, session_id: str) -> None:
+        self.session_states.pop(session_id, None)
+
+    @staticmethod
+    def is_enabled(config: object) -> bool:
+        del config
+        return True
+
+    @staticmethod
+    def capabilities(*, max_sessions: int) -> DuplexCapabilities:
+        supports_multi_session = max_sessions > 1
+        return DuplexCapabilities(
+            supports_model_native_turn_policy=True,
+            supports_external_turn_signal=False,
+            supports_client_commit=False,
+            supports_barge_in=False,
+            supports_playback_ack=True,
+            supports_input_append=True,
+            supports_replace_latest_chunk=False,
+            supports_reencode_context=False,
+            supports_rollback_to_checkpoint=False,
+            supports_turn_commit_only=False,
+            supports_model_internal_state=True,
+            supports_stage_resumption=True,
+            supports_core_resumable_request=True,
+            supports_stage_connector_handoff=True,
+            supports_independent_io_streams=True,
+            supports_realtime_endpoint=True,
+            supports_multi_session=supports_multi_session,
+            supports_multi_session_same_replica=supports_multi_session,
+            supports_session_lease=True,
+            supports_session_resume=False,
+            session_admission_mode="engine_managed",
+            supports_audio_truncate=False,
+            requires_model_runner_kv=True,
+            requires_native_stage_role=True,
+            implementation_level="model_native_duplex",
+            adapter_patterns=["scheduler_data_plane"],
+            input_modes=["append_audio_chunk"],
+            signal_sources=["model_native", "client_event"],
+            stage_handoff_transport="scheduler_data_plane",
+            chunk_period_ms=80,
+            target_barge_in_latency_ms=None,
+        )
+
+    @staticmethod
+    def validate_client_extra_body(extra_body: object) -> None:
+        if not isinstance(extra_body, dict):
+            return
+        private = sorted(_PRIVATE_RUNTIME_CONFIG_KEYS.intersection(extra_body))
+        if private:
+            raise ServingRuntimeConfigError("PersonaPlex runtime configuration is server-owned: " + ", ".join(private))
+
+    @classmethod
+    async def prepare_runtime_config(
+        cls,
+        config: object,
+        *,
+        model_config: Any,
+    ) -> dict[str, object]:
+        extra_body = getattr(config, "extra_body", None)
+        cls.validate_client_extra_body(extra_body)
+        model_path = getattr(model_config, "model", None)
+        if not isinstance(model_path, str) or not model_path:
+            raise ServingRuntimeConfigError("PersonaPlex model path is unavailable")
+        voice = cls._voice_name(getattr(config, "voice", None))
+        instructions = getattr(config, "instructions", None) or DEFAULT_PERSONA
+        from vllm_omni.experimental.fullduplex.personaplex.stage0 import (
+            personaplex_prefill_slots,
+        )
+
+        try:
+            prefill_slots = await asyncio.to_thread(
+                personaplex_prefill_slots,
+                model_path,
+                voice,
+                str(instructions),
+            )
+        except Exception as exc:
+            raise ServingRuntimeConfigError(f"PersonaPlex voice/persona prefill could not be prepared: {exc}") from exc
+        return {
+            "personaplex_model_path": model_path,
+            "personaplex_voice_prompt": voice,
+            "personaplex_persona": str(instructions),
+            "personaplex_prefill_slots": prefill_slots,
+        }
+
+    @classmethod
+    def runtime_config_for_update(
+        cls,
+        config: object,
+        current: Mapping[str, object],
+    ) -> dict[str, object]:
+        cls.validate_client_extra_body(getattr(config, "extra_body", None))
+        runtime_config = deepcopy(dict(current))
+        runtime_config["personaplex_voice_prompt"] = cls._voice_name(getattr(config, "voice", None))
+        runtime_config["personaplex_persona"] = str(getattr(config, "instructions", None) or DEFAULT_PERSONA)
+        return runtime_config
+
+    @staticmethod
+    def data_plane_context(
+        *,
+        epoch: int,
+        turn_id: int,
+        active_response_turn_id: int | None,
+        active_response_id: str | None,
+        auto_responds: bool,
+        response_format: str,
+        speed: float | None,
+        modalities: tuple[str, ...],
+    ) -> PersonaPlexDataPlaneContext:
+        return PersonaPlexDataPlaneContext(
+            epoch=epoch,
+            turn_id=turn_id,
+            active_response_turn_id=active_response_turn_id,
+            active_response_id=active_response_id,
+            auto_responds=auto_responds,
+            response_format=response_format,
+            speed=speed,
+            modalities=modalities,
+        )
+
+    @staticmethod
+    def _voice_name(value: object) -> str:
+        voice = value if isinstance(value, str) and value else "NATF2.pt"
+        path = PurePath(voice)
+        if path.name != voice or path.suffix != ".pt" or any(part == ".." for part in path.parts):
+            raise ServingRuntimeConfigError("PersonaPlex voice must be a bundled .pt basename")
+        return voice
+
+
+__all__ = [
+    "PersonaPlexServingRuntimeAdapter",
+    "PersonaPlexServingSessionState",
+]
diff --git a/vllm_omni/experimental/fullduplex/personaplex/session.py b/vllm_omni/experimental/fullduplex/personaplex/session.py
new file mode 100644
index 000000000..b3a476f12
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/session.py
@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex lockstep session driver — the runnable serving primitive.
+
+Mirrors JoyVL's ``serving/session.py``: a thin, framework-free driver that owns a
+``FrameStepper`` and turns arbitrary-length PCM chunks from a client into exact
+80 ms frames, stepping the model one frame at a time. This is the path that
+actually runs end to end (offline driver and any WS server build on it); the
+``DuplexAdapter`` is a separate demonstration of the generic framework seam.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.personaplex.config import PersonaPlexConfig
+from vllm_omni.experimental.fullduplex.personaplex.engine import FrameOutput, FrameStepper
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+# Realtime queue bounds: 80 ms/frame, so 50 frames = 4 s of backlog. Anything
+# beyond that means the peer cannot keep up and old frames are already useless.
+MAX_PENDING_INPUT = 50
+MAX_PENDING_OUTPUT = 50
+
+
+def offer_realtime(queue: asyncio.Queue, item: Any) -> None:
+    """Enqueue with a drop-oldest policy (realtime streams must never grow unbounded)."""
+    while True:
+        try:
+            queue.put_nowait(item)
+            return
+        except asyncio.QueueFull:
+            with contextlib.suppress(asyncio.QueueEmpty):
+                queue.get_nowait()
+
+
+@dataclass
+class PersonaPlexServingSessionState:
+    """Mutable per-connection serving state (the minicpmo45 ``session.py`` role).
+
+    One instance per WebSocket connection, for both server modes: the
+    single-session server uses ``pcm_queue`` (decoded mic PCM awaiting the
+    engine); the batched server uses ``out_queue`` + ``slot``/``epoch`` (engine
+    output awaiting send, and the claimed slot lease). ``closed`` tears both
+    pump loops down.
+    """
+
+    pcm_queue: asyncio.Queue = field(default_factory=lambda: asyncio.Queue(maxsize=MAX_PENDING_INPUT))
+    out_queue: asyncio.Queue = field(default_factory=lambda: asyncio.Queue(maxsize=MAX_PENDING_OUTPUT))
+    closed: bool = False
+    slot: Any = None  # batched mode: the claimed serving/batched.py Slot
+    epoch: int = 0  # batched mode: slot epoch at claim time (stale-guard)
+    # Single-session mode: completion event of the engine call currently running
+    # on a worker thread. Task cancellation cannot stop that thread (and marks
+    # the asyncio future cancelled while the thread runs on), so the server
+    # waits on this event before releasing its lease (DuplexServer._engine_call).
+    inflight: Any = None
+
+
+class PersonaPlexSession:
+    """Drive one PersonaPlex conversation in strict frame lockstep.
+
+    A session buffers incoming PCM and emits exactly one :class:`FrameOutput` per
+    completed ``frame_size`` window. Partial tails are held until enough samples
+    arrive (or ``flush()`` pads them out at end of stream).
+    """
+
+    def __init__(self, stepper: FrameStepper, config: PersonaPlexConfig | None = None) -> None:
+        self.stepper = stepper
+        self.config = config or PersonaPlexConfig()
+        self.frame_size = stepper.frame_size
+        self._pending = np.zeros(0, dtype=np.float32)
+        self._opened = False
+
+    def open(self, voice_prompt: str | None = None, persona: str | None = None) -> None:
+        """Inject the voice clone + persona and arm the conversation."""
+        self.stepper.open_session(voice_prompt=voice_prompt, persona=persona)
+        self._pending = np.zeros(0, dtype=np.float32)
+        self._opened = True
+
+    def feed(self, pcm: NDArray[np.float32]) -> list[FrameOutput]:
+        """Append PCM and step every newly completed frame.
+
+        Returns one :class:`FrameOutput` per frame consumed from the buffer this
+        call (possibly empty if fewer than ``frame_size`` samples are buffered).
+        """
+        if not self._opened:
+            raise RuntimeError("PersonaPlexSession.open() must be called before feed()")
+        samples = np.ascontiguousarray(pcm, dtype=np.float32).reshape(-1)
+        self._pending = np.concatenate([self._pending, samples]) if self._pending.size else samples
+
+        outputs: list[FrameOutput] = []
+        n = self.frame_size
+        while self._pending.shape[0] >= n:
+            frame, self._pending = self._pending[:n], self._pending[n:]
+            outputs.append(self.stepper.step(frame))
+        return outputs
+
+    def flush(self) -> list[FrameOutput]:
+        """Zero-pad and step any buffered tail; call once at end of input."""
+        if self._pending.shape[0] == 0:
+            return []
+        pad = self.frame_size - self._pending.shape[0]
+        frame = np.concatenate([self._pending, np.zeros(pad, dtype=np.float32)])
+        self._pending = np.zeros(0, dtype=np.float32)
+        return [self.stepper.step(frame)]
+
+    def run(self, pcm: NDArray[np.float32]) -> tuple[NDArray[np.float32], str]:
+        """Convenience for offline use: feed a whole utterance, return (audio, text).
+
+        Concatenates every emitted agent frame and joins the inner-monologue text.
+        """
+        outputs = self.feed(pcm) + self.flush()
+        chunks = [o.audio for o in outputs if o.audio is not None]
+        audio = np.concatenate(chunks) if chunks else np.zeros(0, dtype=np.float32)
+        text = "".join(o.text for o in outputs if o.text)
+        return audio, text
diff --git a/vllm_omni/experimental/fullduplex/personaplex/stage0.py b/vllm_omni/experimental/fullduplex/personaplex/stage0.py
new file mode 100644
index 000000000..a11c5dc40
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/personaplex/stage0.py
@@ -0,0 +1,467 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import tarfile
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from vllm_omni.experimental.fullduplex.personaplex.policy import (
+    AUDIO_SILENCE_FRAME_CNT,
+    SILENCE_TOKENS,
+    SINE_TOKENS,
+    ZERO_TEXT_TOKEN,
+    wrap_with_system_tags,
+)
+
+_FRAME_SAMPLES = 1920
+
+
+@dataclass(slots=True)
+class PersonaPlexStage0PreparedAppend:
+    input_ids: Any
+    inputs_embeds: Any
+    user_codes: Any
+    info_update: dict[str, Any]
+    prefill_applied: bool
+    prompt_offset: int
+
+
+@dataclass(slots=True)
+class PersonaPlexStage0SessionState:
+    session_id: str
+    incarnation: int
+    user_codes: Any | None = None
+    last_text_token: Any | None = None
+    last_agent_codes: Any | None = None
+    prefill_slots: int = 0
+    prepared_identity: tuple[int, int] | None = None
+    sampled_identity: tuple[int, int] | None = None
+    prepared: PersonaPlexStage0PreparedAppend | None = None
+    last_seq: int = 0
+    request_ids: set[str] = field(default_factory=set)
+    codec: Any | None = None
+
+
+def _tokenizer_path(model_path: str) -> Path:
+    path = Path(model_path) / "tokenizer_spm_32k_3.model"
+    if not path.is_file():
+        raise FileNotFoundError(f"PersonaPlex tokenizer not found: {path}")
+    return path
+
+
+def load_personaplex_tokenizer(model_path: str):
+    import sentencepiece
+
+    tokenizer = sentencepiece.SentencePieceProcessor(str(_tokenizer_path(model_path)))
+    return lambda text: list(tokenizer.encode(text))
+
+
+def load_personaplex_voice_state(model_path: str, voice: str) -> dict[str, Any]:
+    import torch
+
+    root = Path(model_path)
+    for candidate in (root / "voices" / voice, root / voice):
+        if candidate.is_file():
+            state = torch.load(candidate, map_location="cpu", weights_only=True)
+            if isinstance(state, dict):
+                return state
+            raise ValueError(f"PersonaPlex voice bundle is not a mapping: {candidate}")
+
+    archive = root / "voices.tgz"
+    if archive.is_file():
+        with tarfile.open(archive, "r:gz") as tar:
+            member = next(
+                (item for item in tar.getmembers() if item.isfile() and Path(item.name).name == voice),
+                None,
+            )
+            if member is not None:
+                extracted = tar.extractfile(member)
+                if extracted is None:
+                    raise FileNotFoundError(f"PersonaPlex voice prompt {voice!r} is unreadable")
+                state = torch.load(io.BytesIO(extracted.read()), map_location="cpu", weights_only=True)
+                if isinstance(state, dict):
+                    return state
+                raise ValueError(f"PersonaPlex voice bundle {voice!r} is not a mapping")
+    raise FileNotFoundError(f"PersonaPlex bundled voice prompt {voice!r} was not found under {model_path!r}")
+
+
+def personaplex_prefill_slots(model_path: str, voice: str, persona: str) -> int:
+    state = load_personaplex_voice_state(model_path, voice)
+    embeddings = state.get("embeddings")
+    if not hasattr(embeddings, "shape") or len(embeddings.shape) < 1:
+        raise ValueError(f"PersonaPlex voice prompt {voice!r} has no embeddings")
+    tokenizer = load_personaplex_tokenizer(model_path)
+    persona_tokens = tokenizer(wrap_with_system_tags(persona)) if persona else []
+    return int(embeddings.shape[0]) + 2 * AUDIO_SILENCE_FRAME_CNT + len(persona_tokens)
+
+
+class PersonaPlexStage0DuplexRuntime:
+    """Own per-session streaming Mimi encoders and first-append prefill."""
+
+    def __init__(
+        self,
+        stage_model: Any,
+        *,
+        model_path: str,
+        device: str,
+        codec: Any | None = None,
+        codec_factory: Callable[[], Any] | None = None,
+        max_sessions: int = 1,
+        tokenizer=None,
+        voice_loader=None,
+    ) -> None:
+        if max_sessions <= 0:
+            raise ValueError("PersonaPlex Stage 0 max_sessions must be positive")
+        self.stage_model = stage_model
+        self.model_path = model_path
+        self.device = device
+        self.max_sessions = max_sessions
+        self._codec_factory = codec_factory
+        self._free_codecs: list[Any] = []
+        self._tokenizer = tokenizer
+        self._voice_loader = voice_loader
+        self.sessions: dict[tuple[str, int], PersonaPlexStage0SessionState] = {}
+        self.request_sessions: dict[str, tuple[str, int]] = {}
+        if codec is not None:
+            codec.streaming_init(1)
+            self._free_codecs.append(codec)
+
+    def prepare_append(
+        self,
+        duplex: dict[str, Any],
+        *,
+        prompt_len: int,
+        request_id: str | None = None,
+    ) -> PersonaPlexStage0PreparedAppend:
+        import torch
+
+        session_id = duplex.get("session_id")
+        if not isinstance(session_id, str) or not session_id:
+            raise ValueError("PersonaPlex duplex append requires session_id")
+        incarnation = _coerce_non_negative_int(duplex.get("incarnation"), "incarnation")
+        epoch = _coerce_non_negative_int(duplex.get("epoch"), "epoch")
+        seq = _coerce_positive_int(duplex.get("seq"), "seq")
+        identity = (epoch, seq)
+        key = (session_id, incarnation)
+
+        state = self.sessions.get(key)
+        if state is None:
+            if len(self.sessions) >= self.max_sessions:
+                raise RuntimeError(f"PersonaPlex Stage 0 session capacity {self.max_sessions} is exhausted")
+            state = PersonaPlexStage0SessionState(
+                session_id=session_id,
+                incarnation=incarnation,
+                codec=self._acquire_codec(),
+            )
+            self.sessions[key] = state
+        if request_id:
+            state.request_ids.add(request_id)
+            self.request_sessions[request_id] = key
+        if state.prepared_identity == identity and state.prepared is not None:
+            return state.prepared
+        if seq <= state.last_seq:
+            raise ValueError(f"PersonaPlex duplex append seq must increase: last={state.last_seq}, got={seq}")
+
+        pcm = self._decode_pcm(duplex.get("payload"))
+        codec = state.codec
+        if codec is None:
+            raise RuntimeError("PersonaPlex Stage 0 session has no streaming encoder")
+        encoded = codec.encode_frame(torch.from_numpy(pcm).reshape(1, _FRAME_SAMPLES))
+        user_frame = encoded.detach().to(dtype=torch.long, device="cpu").reshape(1, -1)
+        if user_frame.shape[1] < 8:
+            raise RuntimeError(
+                f"PersonaPlex Mimi encoder returned {user_frame.shape[1]} codebooks, expected at least 8"
+            )
+        user_frame = user_frame[:, :8].contiguous()
+        state.user_codes = user_frame if state.user_codes is None else torch.cat([state.user_codes, user_frame], dim=0)
+
+        runtime_config = duplex.get("runtime_config")
+        runtime_config = dict(runtime_config) if isinstance(runtime_config, dict) else {}
+        first_append = state.last_seq == 0
+        device, dtype = self._model_device_dtype()
+        silence = torch.tensor(SILENCE_TOKENS, dtype=torch.long, device=device)
+        sine = torch.tensor(SINE_TOKENS, dtype=torch.long, device=device)
+        text_token = state.last_text_token
+        if text_token is None:
+            text_token = torch.tensor([ZERO_TEXT_TOKEN], dtype=torch.long, device=device)
+        last_agent = state.last_agent_codes if state.last_agent_codes is not None else silence
+        user_frame_count = state.user_codes.shape[0]
+        # Match the native lockstep ring: the temporal input sees the previous
+        # effective agent frame. User cb0 trails the frame being appended by one
+        # tick and user cb1..7 trail it by two ticks. Before live user frames
+        # fill those slots, text-prompt prefill leaves encoded sine on user rows.
+        user_d0 = state.user_codes[-2].to(device) if user_frame_count > 1 else sine
+        user_d1 = state.user_codes[-3].to(device) if user_frame_count > 2 else sine
+        depformer_audio_tokens = torch.cat(
+            [
+                silence,
+                user_frame[0, :1].to(device),
+                user_d0[1:8],
+            ]
+        )
+        depformer_audio_provided = torch.tensor(
+            [
+                False,
+                *([first_append] * 7),
+                *([True] * 8),
+            ],
+            dtype=torch.bool,
+            device=device,
+        )
+        live_embed = self.stage_model._build_frame_embed(
+            text_token,
+            last_agent,
+            last_agent,
+            device,
+            user_d0=user_d0,
+            user_d1=user_d1,
+        )
+        if first_append:
+            voice = runtime_config.get("personaplex_voice_prompt", "NATF2.pt")
+            persona = runtime_config.get("personaplex_persona", "")
+            if not isinstance(voice, str) or not voice:
+                raise ValueError("PersonaPlex runtime voice prompt is invalid")
+            if not isinstance(persona, str):
+                raise ValueError("PersonaPlex runtime persona is invalid")
+            voice_state = self._load_voice(voice)
+            voice_embeddings = voice_state.get("embeddings")
+            if not isinstance(voice_embeddings, torch.Tensor) or voice_embeddings.numel() == 0:
+                raise ValueError(f"PersonaPlex voice prompt {voice!r} has no embeddings")
+            voice_embeddings = voice_embeddings.reshape(-1, voice_embeddings.shape[-1]).to(
+                device=device,
+                dtype=dtype,
+            )
+            tokenizer = self._load_tokenizer()
+            persona_tokens = tokenizer(wrap_with_system_tags(persona)) if persona else []
+            prefill_tokens = torch.tensor(
+                [
+                    *([ZERO_TEXT_TOKEN] * AUDIO_SILENCE_FRAME_CNT),
+                    *persona_tokens,
+                    *([ZERO_TEXT_TOKEN] * AUDIO_SILENCE_FRAME_CNT),
+                ],
+                dtype=torch.long,
+                device=device,
+            )
+            token_prefill = self.stage_model._build_prefill_embed(
+                prefill_tokens,
+                0,
+                int(prefill_tokens.numel()),
+                device,
+                silence,
+                user_sine=sine,
+            )
+            prefill_embeds = torch.cat(
+                [
+                    voice_embeddings,
+                    token_prefill.to(dtype=dtype),
+                ],
+                dim=0,
+            )
+            state.prefill_slots = int(prefill_embeds.shape[0])
+            full_embeds = torch.cat([prefill_embeds, live_embed.to(dtype=dtype)], dim=0)
+        else:
+            full_embeds = live_embed.to(dtype=dtype)
+
+        prepared_len = int(full_embeds.shape[0])
+        prompt_offset = int(prompt_len) - prepared_len
+        if prompt_offset < 0:
+            raise ValueError(
+                f"PersonaPlex scheduler prompt reservation mismatch: reserved={prompt_len}, prepared={prepared_len}"
+            )
+        input_ids = torch.zeros((prepared_len,), dtype=torch.long, device=device)
+        info_update = {
+            "pplex_user_codes": state.user_codes,
+            "pplex_silence_codes": silence.detach().cpu(),
+            "pplex_depformer_audio_tokens": depformer_audio_tokens.detach().cpu(),
+            "pplex_depformer_audio_provided": depformer_audio_provided.detach().cpu(),
+            "meta": {
+                "pplex_frame": state.prefill_slots + int(state.user_codes.shape[0]),
+                "pplex_prefill_len": state.prefill_slots,
+            },
+            "duplex": {
+                "stage0_prepared": True,
+                "prefill_applied": first_append,
+                "session_id": session_id,
+                "incarnation": incarnation,
+                "epoch": epoch,
+                "seq": seq,
+            },
+        }
+        prepared = PersonaPlexStage0PreparedAppend(
+            input_ids=input_ids,
+            inputs_embeds=full_embeds,
+            user_codes=state.user_codes,
+            info_update=info_update,
+            prefill_applied=first_append,
+            prompt_offset=prompt_offset,
+        )
+        state.prepared_identity = identity
+        state.prepared = prepared
+        state.last_seq = seq
+        return prepared
+
+    def record_sample(
+        self,
+        *,
+        request_id: str,
+        text_token: Any,
+        agent_codes: Any,
+    ) -> None:
+        """Commit one sampled temporal frame for the next live append."""
+        import torch
+
+        key = self.request_sessions.get(request_id)
+        if key is None:
+            raise KeyError(f"PersonaPlex Stage 0 request is not attached to a live session: {request_id}")
+        state = self.sessions.get(key)
+        if state is None or state.prepared_identity is None:
+            raise RuntimeError(f"PersonaPlex Stage 0 request has no prepared append: {request_id}")
+        if state.sampled_identity == state.prepared_identity:
+            return
+
+        text = torch.as_tensor(text_token, device=self._model_device_dtype()[0], dtype=torch.long).reshape(-1)
+        codes = torch.as_tensor(agent_codes, device=text.device, dtype=torch.long).reshape(-1)
+        if text.numel() != 1:
+            raise ValueError(f"PersonaPlex Stage 0 expected one sampled text token, got {text.numel()}")
+        if codes.numel() < 8:
+            raise ValueError(f"PersonaPlex Stage 0 expected at least 8 agent codes, got {codes.numel()}")
+
+        effective_codes = codes[:8].clone()
+        prepared = state.prepared
+        if prepared is None:
+            raise RuntimeError(f"PersonaPlex Stage 0 request has no prepared payload: {request_id}")
+        target = prepared.info_update.get("pplex_depformer_audio_tokens")
+        provided = prepared.info_update.get("pplex_depformer_audio_provided")
+        if not isinstance(target, torch.Tensor) or not isinstance(provided, torch.Tensor):
+            raise RuntimeError("PersonaPlex Stage 0 prepared payload has no depformer teacher-forcing state")
+        target = target.reshape(-1).to(device=effective_codes.device, dtype=torch.long)
+        provided = provided.reshape(-1).to(device=effective_codes.device, dtype=torch.bool)
+        if target.numel() < 8 or provided.numel() < 8:
+            raise RuntimeError("PersonaPlex Stage 0 depformer teacher-forcing state is shorter than one agent frame")
+        effective_codes = torch.where(provided[:8], target[:8], effective_codes)
+        state.last_agent_codes = effective_codes.detach()
+        state.last_text_token = text.detach()
+        state.sampled_identity = state.prepared_identity
+
+    def close_request(self, request_id: str) -> None:
+        key = self.request_sessions.pop(request_id, None)
+        if key is None:
+            return
+        state = self.sessions.get(key)
+        if state is None:
+            return
+        state.request_ids.discard(request_id)
+        if not state.request_ids:
+            self.close_session(*key)
+
+    def close_session(self, session_id: str, incarnation: int) -> None:
+        key = (session_id, incarnation)
+        state = self.sessions.pop(key, None)
+        if state is None:
+            return
+        for request_id in state.request_ids:
+            self.request_sessions.pop(request_id, None)
+        if state.codec is not None:
+            state.codec.reset_streaming()
+            self._free_codecs.append(state.codec)
+            state.codec = None
+
+    def _acquire_codec(self):
+        if self._free_codecs:
+            return self._free_codecs.pop()
+        if self._codec_factory is not None:
+            codec = self._codec_factory()
+            codec.streaming_init(1)
+            return codec
+        from vllm_omni.model_executor.models.personaplex.personaplex_mimi import (
+            PersonaPlexMimiCodec,
+        )
+
+        checkpoint = Path(self.model_path) / "tokenizer-e351c8d8-checkpoint125.safetensors"
+        codec = PersonaPlexMimiCodec(
+            checkpoint=str(checkpoint) if checkpoint.is_file() else None,
+            device=self.device,
+        )
+        codec.streaming_init(1)
+        return codec
+
+    def _load_tokenizer(self):
+        if self._tokenizer is None:
+            self._tokenizer = load_personaplex_tokenizer(self.model_path)
+        return self._tokenizer
+
+    def _load_voice(self, voice: str) -> dict[str, Any]:
+        if self._voice_loader is not None:
+            state = self._voice_loader(voice)
+        else:
+            state = load_personaplex_voice_state(self.model_path, voice)
+        if not isinstance(state, dict):
+            raise ValueError(f"PersonaPlex voice prompt {voice!r} is not a mapping")
+        return state
+
+    def _model_device_dtype(self):
+        import torch
+
+        try:
+            parameter = next(self.stage_model.parameters())
+            return parameter.device, parameter.dtype
+        except Exception:
+            device = getattr(self.stage_model, "device", torch.device(self.device))
+            dtype = getattr(self.stage_model, "dtype", torch.float32)
+            return torch.device(device), dtype
+
+    @staticmethod
+    def _decode_pcm(payload: object) -> np.ndarray:
+        if not isinstance(payload, dict):
+            raise ValueError("PersonaPlex duplex payload must be a mapping")
+        if payload.get("format") != "pcm_f32le" or payload.get("sample_rate_hz") != 24000:
+            raise ValueError("PersonaPlex Stage 0 requires 24 kHz pcm_f32le")
+        audio = payload.get("audio")
+        if not isinstance(audio, str):
+            raise ValueError("PersonaPlex Stage 0 requires base64 audio")
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise ValueError("PersonaPlex Stage 0 audio is not valid base64") from exc
+        samples = np.frombuffer(raw, dtype="<f4")
+        if samples.size != _FRAME_SAMPLES:
+            raise ValueError(f"PersonaPlex Stage 0 requires {_FRAME_SAMPLES} samples per append")
+        if not np.isfinite(samples).all():
+            raise ValueError("PersonaPlex Stage 0 samples must be finite")
+        return np.ascontiguousarray(samples, dtype=np.float32).copy()
+
+
+def _coerce_non_negative_int(value: object, name: str) -> int:
+    try:
+        result = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"PersonaPlex duplex {name} must be an integer") from exc
+    if result < 0:
+        raise ValueError(f"PersonaPlex duplex {name} must be non-negative")
+    return result
+
+
+def _coerce_positive_int(value: object, name: str) -> int:
+    result = _coerce_non_negative_int(value, name)
+    if result <= 0:
+        raise ValueError(f"PersonaPlex duplex {name} must be positive")
+    return result
+
+
+__all__ = [
+    "PersonaPlexStage0DuplexRuntime",
+    "PersonaPlexStage0PreparedAppend",
+    "PersonaPlexStage0SessionState",
+    "load_personaplex_tokenizer",
+    "load_personaplex_voice_state",
+    "personaplex_prefill_slots",
+]
diff --git a/vllm_omni/experimental/fullduplex/request_client.py b/vllm_omni/experimental/fullduplex/request_client.py
new file mode 100644
index 000000000..d39a037a2
--- /dev/null
+++ b/vllm_omni/experimental/fullduplex/request_client.py
@@ -0,0 +1,383 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Callable, MutableMapping
+from typing import Protocol
+
+from vllm_omni.engine.messages import ErrorMessage, OutputMessage
+from vllm_omni.entrypoints.client_request_state import ClientRequestState
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    duplex_data_plane_request_info,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.output import get_duplex_output_decision
+from vllm_omni.metrics.stats import OrchestratorAggregator as OrchestratorMetrics
+from vllm_omni.outputs import OmniRequestOutput
+
+
+class DuplexEnginePort(Protocol):
+    """Engine control methods required by the experimental request client.
+
+    The protocol keeps request preregistration and output collection testable
+    without coupling this component to ``AsyncOmniEngine``.
+    """
+
+    async def open_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+    async def append_duplex_input_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+    async def signal_duplex_turn_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+    async def close_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+    async def touch_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+    async def resume_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
+
+
+class DuplexRequestOutputPort:
+    """Narrow output-processing surface owned by the AsyncOmni entrypoint."""
+
+    def __init__(
+        self,
+        *,
+        request_states: MutableMapping[str, ClientRequestState],
+        num_stages: int,
+        log_stats: bool,
+        start_output_handler: Callable[[], object],
+        process_single_result: Callable[..., OmniRequestOutput | None],
+    ) -> None:
+        self.request_states = request_states
+        self.num_stages = num_stages
+        self.log_stats = log_stats
+        self._start_output_handler = start_output_handler
+        self._process_single_result = process_single_result
+
+    def start_output_handler(self) -> None:
+        self._start_output_handler()
+
+    def process_single_result(self, *args, **kwargs) -> OmniRequestOutput | None:
+        return self._process_single_result(*args, **kwargs)
+
+
+class DuplexRequestClient:
+    """Owns duplex request identity, preregistration and output collection."""
+
+    def __init__(self, engine: DuplexEnginePort, output_port: DuplexRequestOutputPort) -> None:
+        self.engine = engine
+        self.output_port = output_port
+
+    @staticmethod
+    def request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
+        return duplex_data_plane_request_info(result)
+
+    async def open(
+        self,
+        session_id: str,
+        *,
+        session_mode: str,
+        capabilities: dict[str, object] | None,
+        session_config: dict[str, object] | None,
+        runtime_config: dict[str, object] | None,
+        fence: DuplexFence,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        # Lifecycle expiry messages share the engine output channel. Start its
+        # sole dispatcher before open so an idle session can be reaped even if
+        # it never submits an append request.
+        self.output_port.start_output_handler()
+        kwargs: dict[str, object] = {
+            "session_mode": session_mode,
+            "capabilities": capabilities,
+            "session_config": session_config,
+            "fence": fence,
+            "timeout": timeout,
+        }
+        if runtime_config is not None:
+            kwargs["runtime_config"] = runtime_config
+        return await self.engine.open_duplex_session_async(session_id, **kwargs)
+
+    async def append(
+        self,
+        session_id: str,
+        *,
+        mode: str,
+        payload: object,
+        operation_id: str | None,
+        final: bool,
+        expected_epoch: int | None,
+        fence: DuplexFence,
+        timeout: float | None,
+        collect_outputs: bool,
+    ) -> dict[str, object]:
+        kwargs: dict[str, object] = {
+            "mode": mode,
+            "payload": payload,
+            "final": final,
+            "expected_epoch": expected_epoch,
+            "timeout": timeout,
+            "fence": fence,
+        }
+        if operation_id is not None:
+            kwargs["operation_id"] = operation_id
+
+        expected_request_id = duplex_resource_request_id(fence, "stage0")
+        request_state = self.output_port.request_states.get(expected_request_id)
+        created_request_state = request_state is None
+        if request_state is None:
+            request_state = ClientRequestState(expected_request_id)
+            self.output_port.request_states[expected_request_id] = request_state
+        if request_state.metrics is None:
+            wall_start_ts = time.time()
+            request_state.metrics = OrchestratorMetrics(
+                self.output_port.num_stages,
+                self.output_port.log_stats,
+                wall_start_ts,
+                max(0, self.output_port.num_stages - 1),
+            )
+            request_state.request_arrival_ts = wall_start_ts
+        self.output_port.start_output_handler()
+        try:
+            result = await self.engine.append_duplex_input_async(session_id, **kwargs)
+        except BaseException:
+            if created_request_state and request_state.queue.empty():
+                self.output_port.request_states.pop(expected_request_id, None)
+            raise
+
+        request_id, response_stage_id = duplex_data_plane_request_info(result)
+        if request_id is None:
+            if created_request_state and request_state.queue.empty():
+                self.output_port.request_states.pop(expected_request_id, None)
+            return result
+        if request_id != expected_request_id:
+            if created_request_state and request_state.queue.empty():
+                self.output_port.request_states.pop(expected_request_id, None)
+            raise RuntimeError(
+                f"duplex data-plane request id mismatch: expected {expected_request_id!r}, got {request_id!r}"
+            )
+        if not collect_outputs:
+            return result
+        outputs = await self.collect_outputs(
+            request_id,
+            request_state,
+            response_stage_id=response_stage_id,
+            timeout=timeout,
+        )
+        if outputs:
+            result = dict(result)
+            result["data_plane_outputs"] = outputs
+        return result
+
+    async def collect_registered_outputs(
+        self,
+        request_id: str,
+        *,
+        response_stage_id: int | None,
+        timeout: float | None,
+    ) -> list[OmniRequestOutput]:
+        self.output_port.start_output_handler()
+        request_state = self.output_port.request_states.get(request_id)
+        if request_state is None:
+            return []
+        return await self.collect_outputs(
+            request_id,
+            request_state,
+            response_stage_id=response_stage_id,
+            timeout=timeout,
+        )
+
+    async def signal(
+        self,
+        session_id: str,
+        *,
+        event: str,
+        fence: DuplexFence,
+        next_fence: DuplexFence | None,
+        session_config: dict[str, object] | None,
+        runtime_config: dict[str, object] | None,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        kwargs: dict[str, object] = {"event": event, "fence": fence, "timeout": timeout}
+        if next_fence is not None:
+            kwargs["next_fence"] = next_fence
+        if session_config is not None:
+            kwargs["session_config"] = session_config
+        if runtime_config is not None:
+            kwargs["runtime_config"] = runtime_config
+        result = await self.engine.signal_duplex_turn_async(session_id, **kwargs)
+        if event in {"barge_in", "input.cancel", "response.cancel"}:
+            self.output_port.request_states.pop(duplex_resource_request_id(fence, "stage0"), None)
+        return result
+
+    async def close(
+        self,
+        session_id: str,
+        *,
+        reason: str,
+        fence: DuplexFence,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        result = await self.engine.close_duplex_session_async(
+            session_id,
+            reason=reason,
+            fence=fence,
+            timeout=timeout,
+        )
+        self.output_port.request_states.pop(duplex_resource_request_id(fence, "stage0"), None)
+        return result
+
+    async def touch(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        activity: DuplexLeaseActivity,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return await self.engine.touch_duplex_session_async(
+            session_id,
+            fence=fence,
+            activity=activity,
+            timeout=timeout,
+        )
+
+    async def resume(
+        self,
+        session_id: str,
+        *,
+        fence: DuplexFence,
+        expected_lease_generation: int,
+        timeout: float | None,
+    ) -> dict[str, object]:
+        return await self.engine.resume_duplex_session_async(
+            session_id,
+            fence=fence,
+            expected_lease_generation=expected_lease_generation,
+            timeout=timeout,
+        )
+
+    async def collect_outputs(
+        self,
+        request_id: str,
+        request_state: ClientRequestState,
+        *,
+        response_stage_id: int | None,
+        timeout: float | None,
+    ) -> list[OmniRequestOutput]:
+        deadline = None if timeout is None else time.monotonic() + timeout
+        wall_start_ts = request_state.request_arrival_ts or time.time()
+        final_stage_id = response_stage_id if response_stage_id is not None else max(0, self.output_port.num_stages - 1)
+        num_stages = max(self.output_port.num_stages, final_stage_id + 1)
+        metrics = getattr(request_state, "metrics", None) or OrchestratorMetrics(
+            num_stages,
+            self.output_port.log_stats,
+            wall_start_ts,
+            final_stage_id,
+        )
+        stage_event_cursor = metrics.stage_event_cursor(request_id)
+        request_start_ts = {request_id: wall_start_ts}
+        outputs: list[OmniRequestOutput] = []
+        while True:
+            remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
+            if remaining == 0.0:
+                break
+            try:
+                message = await asyncio.wait_for(request_state.queue.get(), timeout=remaining)
+            except asyncio.TimeoutError:
+                break
+            if isinstance(message, ErrorMessage):
+                raise RuntimeError(message.error)
+            if not isinstance(message, OutputMessage):
+                continue
+            engine_outputs = message.engine_outputs
+            is_response_stage = response_stage_id is None or message.stage_id >= response_stage_id
+            is_direct_response = self.is_direct_response(engine_outputs)
+            output_to_collect = None
+            if isinstance(engine_outputs, OmniRequestOutput):
+                output_to_collect = engine_outputs
+                if message.metrics is not None:
+                    existing_metrics = dict(output_to_collect.metrics)
+                    metrics.process_stage_metrics(
+                        result={"metrics": message.metrics},
+                        stage_type="",
+                        stage_id=message.stage_id,
+                        req_id=request_id,
+                        engine_outputs=engine_outputs,
+                        finished=message.finished,
+                        final_output_type=engine_outputs.final_output_type,
+                        output_to_yield=output_to_collect,
+                        event_cursor=stage_event_cursor,
+                    )
+                    generated_metrics = dict(output_to_collect.metrics)
+                    existing_stage_metrics = existing_metrics.get("stage_metrics")
+                    generated_stage_metrics = generated_metrics.get("stage_metrics")
+                    if isinstance(existing_stage_metrics, dict) and isinstance(generated_stage_metrics, dict):
+                        generated_metrics["stage_metrics"] = {
+                            **existing_stage_metrics,
+                            **generated_stage_metrics,
+                        }
+                    output_to_collect.metrics = {
+                        **existing_metrics,
+                        **generated_metrics,
+                    }
+            elif is_response_stage:
+                output_to_collect = self.output_port.process_single_result(
+                    message,
+                    message.stage_id,
+                    metrics,
+                    request_start_ts,
+                    wall_start_ts,
+                    final_stage_id,
+                    stage_event_cursor,
+                )
+            if output_to_collect is not None and (is_response_stage or is_direct_response):
+                if message.finished:
+                    output_to_collect.finished = True
+                outputs.append(output_to_collect)
+            if message.finished or outputs:
+                break
+        return outputs
+
+    @classmethod
+    def is_direct_response(cls, output: object) -> bool:
+        multimodal_output = cls.multimodal_output(output)
+        if not multimodal_output:
+            return False
+        return multimodal_output.get("duplex_direct_response") is True or multimodal_output.get(
+            "duplex_native_decision"
+        ) in {"listen", "speak"}
+
+    @classmethod
+    def multimodal_output(cls, output: object) -> dict[str, object]:
+        if isinstance(output, OmniRequestOutput):
+            decision = get_duplex_output_decision(output)
+            if decision is not None:
+                return dict(decision.metadata)
+            private_output = getattr(output, "_multimodal_output", None)
+            multimodal_output = output.multimodal_output
+            if isinstance(multimodal_output, dict) and multimodal_output:
+                return multimodal_output
+            inner_output = getattr(output, "request_output", None)
+            if inner_output is not None and inner_output is not output:
+                inner_multimodal_output = cls.multimodal_output(inner_output)
+                if inner_multimodal_output:
+                    return inner_multimodal_output
+            if isinstance(private_output, dict):
+                return private_output
+            return multimodal_output if isinstance(multimodal_output, dict) else {}
+        multimodal_output = getattr(output, "multimodal_output", None)
+        if isinstance(multimodal_output, dict):
+            return multimodal_output
+        outputs = getattr(output, "outputs", None)
+        completion = outputs[0] if isinstance(outputs, list) and outputs else None
+        multimodal_output = getattr(completion, "multimodal_output", None) if completion is not None else None
+        return multimodal_output if isinstance(multimodal_output, dict) else {}
+
+
+__all__ = ["DuplexEnginePort", "DuplexRequestClient", "DuplexRequestOutputPort"]
diff --git a/vllm_omni/experimental/world_models/__init__.py b/vllm_omni/experimental/world_models/__init__.py
new file mode 100644
index 000000000..9b01de3d0
--- /dev/null
+++ b/vllm_omni/experimental/world_models/__init__.py
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""World-model session state (RFC #4480).
+
+Model-agnostic session state for AR-diffusion world models: a typed
+``StateObject`` contract and a ``SessionStateManager`` that owns the objects
+per session, plus per-model adapters that present a model's own per-session
+cache over that contract. APIs may change without notice.
+"""
+
+from __future__ import annotations
diff --git a/vllm_omni/experimental/world_models/adapters/__init__.py b/vllm_omni/experimental/world_models/adapters/__init__.py
new file mode 100644
index 000000000..7f218e2c1
--- /dev/null
+++ b/vllm_omni/experimental/world_models/adapters/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Per-model adapters onto the world-model session state contract (RFC #4480)."""
+
+from __future__ import annotations
diff --git a/vllm_omni/experimental/world_models/adapters/state_dreamzero_adapter.py b/vllm_omni/experimental/world_models/adapters/state_dreamzero_adapter.py
new file mode 100644
index 000000000..ea355b471
--- /dev/null
+++ b/vllm_omni/experimental/world_models/adapters/state_dreamzero_adapter.py
@@ -0,0 +1,315 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Adapter presenting ``DreamZeroState``'s surface over the session manager.
+
+``DreamZeroStateAdapter`` exposes the exact public methods and attributes that
+``pipeline_dreamzero.py`` touches on its state object, so the pipeline can use
+it interchangeably with the bespoke ``DreamZeroState`` (behind the opt-in flag).
+
+DreamZero's attention KV lives in the AR-Diffusion engine's paged pool
+(``self._ar_diffusion_kv_state``) and is *not* managed here; this adapter
+covers the model's non-KV session state. Storage is delegated to typed
+``StateObject`` instances owned by the ``SessionStateManager``:
+
+    * the stitched frame buffer            -> ``LatentBuffer`` (ring)
+    * accumulated AR video latents         -> ``LatentBuffer`` (append, CPU)
+    * recent VAE encoder output            -> ``LatentBuffer`` (ring, bounded)
+
+The remaining metadata (counters, conditioning tensors, the Wan encoder
+causal-conv cache) lives in the session's ``attrs``, so a freshly constructed
+adapter for an existing session sees the same data (the manager is the single
+source of truth and the single LRU authority). Which values earn a
+``StateObject`` and which stay attributes follows the rule in
+``docs/features/session_state_manager.md``: a ``StateObject`` when the manager
+must be able to act on the value, an attribute when it only carries it.
+
+The public methods mirror ``DreamZeroState`` statement for statement, so the two
+can be diffed to check equivalence. The deviations are forced by the buffer
+members being ``StateObject``s rather than a plain deque/list/tensor: a read
+uses ``.view()`` where the original reads ``list(...)`` or indexes/iterates the
+container, and a wholesale replacement uses ``self._session.put(...)`` where the
+original reassigns the attribute. The one behavioural difference is deliberate
+and documented on ``_ensure_encoder_buffer``: the encoder output is bounded
+here and unbounded in the original, which the pointwise ``quant_conv`` makes
+numerically indistinguishable to the only reader.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+import torch
+
+from vllm_omni.diffusion.models.dreamzero.state_dreamzero import FRAMES_PER_CHUNK
+from vllm_omni.experimental.world_models.session_state.attrs import SessionAttr
+from vllm_omni.experimental.world_models.session_state.manager import SessionStateManager
+from vllm_omni.experimental.world_models.session_state.objects import LatentBuffer
+
+logger = logging.getLogger(__name__)
+
+_FRAMES = "frames"
+_VIDEO_LATENTS = "video_latents"
+_VAE_ENCODER_OUT = "vae_encoder_out"
+
+# Latent frames of VAE encoder output retained by default. DreamZero passes its
+# own ``num_frame_per_block``; this is only the fallback for callers that build
+# an adapter directly (tests, other entry points).
+DEFAULT_VAE_ENCODER_WINDOW = 2
+
+
+class DreamZeroStateAdapter:
+    """Drop-in replacement for ``DreamZeroState`` backed by the manager.
+
+    Session-scoped metadata is declared once per attribute via ``SessionAttr``
+    (reads fall back to the default; writes go through to the pinned session).
+    """
+
+    call_count = SessionAttr[int](default=0, coerce=int)
+    current_start_frame = SessionAttr[int](default=0, coerce=int)
+    clip_feas = SessionAttr[torch.Tensor | None](default=None)
+    ys = SessionAttr[torch.Tensor | None](default=None)
+    language = SessionAttr[torch.Tensor | None](default=None)
+    prompt_embeds = SessionAttr[torch.Tensor | None](default=None)
+    # -- incremental VAE encoder stream --
+    vae_stream_initialized = SessionAttr[bool](default=False, coerce=bool)
+    # The Wan encoder's per-layer causal convolution cache: 24 entries, 603 MiB
+    # per session, constant from the first few steps onward and by far the
+    # largest thing a DreamZero session holds. It is an attribute all the same:
+    # it is replaced wholesale, it has no recompute source (rebuilding it means
+    # re-encoding the whole observation history, which is not retained), and
+    # freeing it mid-session breaks the stream, so ending the session is the
+    # only release -- which reclaims attributes anyway.
+    vae_enc_feat_map = SessionAttr[list[torch.Tensor | None] | None](default=None)
+    vae_pending_body_frames = SessionAttr[torch.Tensor | None](default=None)
+
+    def __init__(
+        self,
+        session_id: str | None,
+        manager: SessionStateManager,
+        *,
+        vae_encoder_window: int = DEFAULT_VAE_ENCODER_WINDOW,
+    ) -> None:
+        self._session_id = session_id
+        if vae_encoder_window <= 0:
+            raise ValueError(f"vae_encoder_window must be positive, got {vae_encoder_window}")
+        self.vae_encoder_window = vae_encoder_window
+        # Pin the session for this adapter's lifetime. The manager may evict the
+        # session from its lookup table to bound memory, but an adapter that is
+        # mid-generation keeps its own reference, so the in-progress state is not
+        # lost -- matching the bespoke DreamZeroState, which the caller holds even
+        # after it leaves the table. A fresh adapter is built per forward, so the
+        # session is still marked recently-used on each step.
+        self._session = manager.get_or_create_session(session_id)
+        self._ensure_frame_buffer()
+
+    @property
+    def session_id(self) -> str | None:
+        """The session this adapter views, as passed at construction.
+
+        Lets the pipeline match the alias against a runner-supplied session id
+        when the engine signals that session's close/reset.
+        """
+        return self._session_id
+
+    # -- session / metadata plumbing ------------------------------------
+
+    @staticmethod
+    def _new_frame_buffer() -> LatentBuffer[np.ndarray]:
+        buffer: LatentBuffer[np.ndarray] = LatentBuffer()
+        buffer.allocate(maxlen=FRAMES_PER_CHUNK)
+        return buffer
+
+    @staticmethod
+    def _new_video_buffer() -> LatentBuffer[torch.Tensor]:
+        buffer: LatentBuffer[torch.Tensor] = LatentBuffer()
+        buffer.allocate(maxlen=None)
+        return buffer
+
+    def _ensure_frame_buffer(self) -> LatentBuffer[np.ndarray]:
+        """The stitched-frame ring for this session (created on first use)."""
+        return self._session.get_or_create(_FRAMES, self._new_frame_buffer, LatentBuffer)
+
+    def _ensure_video_buffer(self) -> LatentBuffer[torch.Tensor]:
+        """The accumulated AR video-latent chunks (unbounded, CPU)."""
+        return self._session.get_or_create(_VIDEO_LATENTS, self._new_video_buffer, LatentBuffer)
+
+    def _new_encoder_buffer(self) -> LatentBuffer[torch.Tensor]:
+        buffer: LatentBuffer[torch.Tensor] = LatentBuffer()
+        buffer.allocate(maxlen=self.vae_encoder_window)
+        return buffer
+
+    def _ensure_encoder_buffer(self) -> LatentBuffer[torch.Tensor]:
+        """The recent VAE encoder output, as a ring of per-chunk tensors.
+
+        The bespoke state concatenates every encoded chunk into one tensor that
+        is cleared only by a *session* reset -- a window reset deliberately
+        keeps it -- so it grows for as long as the session lives. Its only
+        reader, ``_vae_stream_get_observation_latents``, quantises the whole
+        history and then keeps the last ``num_frame_per_block`` latent frames.
+        ``quant_conv`` is a ``WanCausalConv3d`` of kernel size 1, pointwise in
+        time, so those last frames do not depend on the discarded ones: keeping
+        a ring of ``vae_encoder_window`` frames is numerically identical and
+        bounded.
+        """
+        return self._session.get_or_create(_VAE_ENCODER_OUT, self._new_encoder_buffer, LatentBuffer)
+
+    @property
+    def vae_encoder_out(self) -> torch.Tensor | None:
+        """The retained encoder output as one tensor, or ``None`` when empty."""
+        chunks = self._ensure_encoder_buffer().view()
+        if not chunks:
+            return None
+        if len(chunks) == 1:
+            return chunks[0]
+        return torch.cat(chunks, dim=2)
+
+    @vae_encoder_out.setter
+    def vae_encoder_out(self, value: torch.Tensor | None) -> None:
+        # Seeding (``_vae_stream_seed``) and clearing (``reset``) both assign
+        # wholesale; growth goes through ``append_vae_encoder_chunk``.
+        buffer = self._new_encoder_buffer()
+        if value is not None:
+            buffer.append(value)
+        self._session.put(_VAE_ENCODER_OUT, buffer)
+
+    def append_vae_encoder_chunk(self, encoder_chunk: torch.Tensor) -> None:
+        """Append one encoded chunk, evicting the oldest beyond the window."""
+        self._ensure_encoder_buffer().append(encoder_chunk)
+
+    @property
+    def stitched_buffer(self) -> LatentBuffer[np.ndarray]:
+        return self._ensure_frame_buffer()
+
+    @property
+    def video_latents_across_time(self) -> LatentBuffer[torch.Tensor]:
+        # Read access only; a wholesale replace goes through ``_session.put``
+        # (see reset / clear_video_latents).
+        return self._ensure_video_buffer()
+
+    def reset_vae_encoder_stream(self) -> None:
+        """Clear incremental Wan VAE encoder state used across AR steps."""
+        self.vae_stream_initialized = False
+        self.vae_enc_feat_map = None
+        self.vae_encoder_out = None
+        self.vae_pending_body_frames = None
+
+    # -- frame accumulation ----------------------------------------------
+
+    def accumulate_frames(self, stitched: np.ndarray) -> np.ndarray:
+        """Accumulate stitched frames and return multi-frame video."""
+        if stitched.ndim == 3:
+            self.stitched_buffer.append(stitched)
+        elif stitched.ndim == 4:
+            self.stitched_buffer.extend(list(stitched))
+        else:
+            raise ValueError(f"Expected 3D or 4D stitched, got {stitched.ndim}D")
+
+        num_frames = 1 if self.call_count == 0 else FRAMES_PER_CHUNK
+
+        buffer_frames = self.stitched_buffer.view()
+        if len(buffer_frames) >= num_frames:
+            frames = buffer_frames[-num_frames:]
+        else:
+            frames = buffer_frames
+            while len(frames) < num_frames:
+                frames.insert(0, buffer_frames[0])
+
+        self.call_count += 1
+        return np.stack(frames, axis=0)
+
+    # -- video-latent accumulation ---------------------------------------
+
+    def append_video_latents(self, video_out: torch.Tensor) -> None:
+        """Append one AR chunk of normalized video latents for later decode."""
+        if video_out.dim() != 5:
+            raise ValueError(f"Expected 5D video_out, got shape {tuple(video_out.shape)}")
+        # Upstream ``torch.cat(..., dim=2)`` uses (B, C, T, H, W).
+        chunk = video_out.transpose(1, 2).detach().cpu()
+        self.video_latents_across_time.append(chunk)
+        logger.info(
+            "append_video_latents: chunk_shape=%s total_chunks=%d total_latent_t=%d",
+            tuple(chunk.shape),
+            len(self.video_latents_across_time),
+            int(sum(c.shape[2] for c in self.video_latents_across_time.view())),
+        )
+
+    def get_concatenated_video_latents(self) -> torch.Tensor | None:
+        """Return all accumulated chunks concatenated along the time dimension."""
+        chunks = self.video_latents_across_time.view()
+        if not chunks:
+            return None
+        if len(chunks) == 1:
+            return chunks[0]
+        return torch.cat(chunks, dim=2)
+
+    def clear_video_latents(self) -> None:
+        """Drop accumulated video latents without resetting frame/VAE state."""
+        self._session.put(_VIDEO_LATENTS, self._new_video_buffer())
+
+    # -- reset / should_reset --------------------------------------------
+
+    def reset(self, *, clear_video_latents: bool = True) -> None:
+        """Clear session state.
+
+        A session reset (``clear_video_latents=True``) drops everything,
+        including the prompt-embed cache and the incremental VAE encoder stream.
+        A window ("inference") reset (``False``) keeps the accumulated video
+        latents, ``language``, ``prompt_embeds``, and the VAE encoder stream --
+        the prompt is unchanged and the Wan feat_cache history is independent of
+        the DiT attention window. The survivors are kept the way the original
+        keeps them: by leaving them untouched inside the skipped ``if`` block.
+        """
+        saved_video_latents = [] if clear_video_latents else self._ensure_video_buffer().view()
+        self._session.put(_FRAMES, self._new_frame_buffer())
+        self.call_count = 0
+        restored_video = self._new_video_buffer()
+        restored_video.extend(saved_video_latents)
+        self._session.put(_VIDEO_LATENTS, restored_video)
+
+        self.current_start_frame = 0
+
+        self.clip_feas = None
+        self.ys = None
+        if clear_video_latents:
+            # Session reset: drop the prompt-embed cache and VAE encoder stream.
+            self.language = None
+            self.prompt_embeds = None
+            self.reset_vae_encoder_stream()
+
+    def reset_inference_state(self) -> None:
+        """Reset window/frame state after local attention rolls without dropping video latents."""
+        self.reset(clear_video_latents=False)
+
+    def reset_reason(
+        self,
+        text_tokens: torch.Tensor | None,
+        num_video_frames: int,
+        local_attn_size: int,
+    ) -> str | None:
+        """Return why state should reset before the next forward(), if any."""
+        if self.language is None:
+            logger.info("language is None, resetting")
+            return "session"
+
+        if text_tokens is not None and not torch.equal(self.language, text_tokens):
+            logger.info("language changed, resetting")
+            return "session"
+
+        if num_video_frames == 1 and self.call_count > 1:
+            logger.info("single frame input after first call, resetting")
+            return "session"
+
+        if local_attn_size != -1 and self.current_start_frame >= local_attn_size:
+            logger.info(
+                "current_start_frame %d >= local_attn_size %d, resetting inference state",
+                self.current_start_frame,
+                local_attn_size,
+            )
+            return "inference"
+
+        return None
+
+    def should_reset(self, text_tokens: torch.Tensor | None, num_video_frames: int, local_attn_size: int) -> bool:
+        """Determine if state should be reset before this forward()."""
+        return self.reset_reason(text_tokens, num_video_frames, local_attn_size) is not None
diff --git a/vllm_omni/experimental/world_models/session_state/__init__.py b/vllm_omni/experimental/world_models/session_state/__init__.py
new file mode 100644
index 000000000..953e2615a
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/__init__.py
@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Session memory for AR-diffusion world models (RFC #4480).
+
+Typed ``StateObject`` instances owned per session by ``SessionStateManager``.
+This package is model-agnostic; a model opts in by adapting its own per-session
+cache onto this contract (e.g. ``state_dreamzero_adapter.DreamZeroStateAdapter``).
+See RFC #4480 for the full design and roadmap.
+"""
+
+from vllm_omni.experimental.world_models.session_state.accounting import (
+    SeenStorages,
+    device_bytes,
+)
+from vllm_omni.experimental.world_models.session_state.attrs import SessionAttr
+from vllm_omni.experimental.world_models.session_state.base import StateObject
+from vllm_omni.experimental.world_models.session_state.manager import (
+    DEFAULT_MAX_SESSIONS,
+    SessionState,
+    SessionStateManager,
+    resolve_session_state_config,
+)
+from vllm_omni.experimental.world_models.session_state.objects import LatentBuffer
+
+__all__ = [
+    "DEFAULT_MAX_SESSIONS",
+    "LatentBuffer",
+    "SeenStorages",
+    "StateObject",
+    "SessionAttr",
+    "SessionState",
+    "SessionStateManager",
+    "device_bytes",
+    "resolve_session_state_config",
+]
diff --git a/vllm_omni/experimental/world_models/session_state/accounting.py b/vllm_omni/experimental/world_models/session_state/accounting.py
new file mode 100644
index 000000000..d8304efdd
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/accounting.py
@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Per-device byte accounting for session state (RFC #4480).
+
+A session holds bytes in more than one place -- device tensors, host tensors,
+NumPy frame buffers -- and those are different resources: a GPU pool that is
+scarce and contended, and host memory that is not. Summing them into a single
+number answers no question anyone has, so the accounting here is keyed by the
+device the bytes live on and is never reduced to a scalar by this module.
+
+Two details make the numbers honest:
+
+* **Storages, not elements.** ``numel() * element_size()`` measures the logical
+  view, but a narrow slice of a large buffer keeps the whole allocation alive.
+  Counting ``untyped_storage().nbytes()`` reports what is actually pinned.
+* **Views deduplicated.** Two tensors sharing one storage are counted once, via
+  the caller-supplied ``seen`` set. Pass the *same* set across every value in a
+  session so an alias between two state objects (or between an object and an
+  attribute) does not double-count.
+
+Anything that is not a tensor, an array, or a container of those contributes
+nothing. That is not a heuristic: in this codebase the only device memory a
+session can hold is a ``torch.Tensor``. CUDA graph pools, collective buffers
+and the paged KV blocks of PR #4534 are owned by the engine, never by a session.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+import numpy as np
+import torch
+
+# ``(device string, storage address)`` of a storage already counted.
+SeenStorages = set[tuple[str, int]]
+
+_HOST = "cpu"
+
+
+def device_bytes(value: object, seen: SeenStorages) -> dict[str, int]:
+    """Bytes pinned by ``value``, keyed by the device they live on.
+
+    ``seen`` accumulates the storages already counted and is mutated in place;
+    share one set across a whole session to deduplicate aliases.
+    """
+    totals: dict[str, int] = {}
+    _accumulate(value, seen, totals)
+    return totals
+
+
+def merge_bytes(into: dict[str, int], other: Mapping[str, int]) -> dict[str, int]:
+    """Add ``other`` into ``into`` per device, in place."""
+    for device, count in other.items():
+        into[device] = into.get(device, 0) + count
+    return into
+
+
+def _accumulate(value: object, seen: SeenStorages, totals: dict[str, int]) -> None:
+    if isinstance(value, torch.Tensor):
+        storage = value.untyped_storage()
+        device = str(value.device)
+        key = (device, storage.data_ptr())
+        if key in seen:
+            return
+        seen.add(key)
+        totals[device] = totals.get(device, 0) + storage.nbytes()
+        return
+
+    if isinstance(value, np.ndarray):
+        # ``base is not None`` marks a view; NumPy views are cheap to alias and
+        # carry no address we can key on as reliably as a torch storage, so the
+        # owning array is what gets counted.
+        owner = value if value.base is None else value.base
+        if isinstance(owner, np.ndarray):
+            key = (_HOST, owner.__array_interface__["data"][0])
+            if key in seen:
+                return
+            seen.add(key)
+            totals[_HOST] = totals.get(_HOST, 0) + int(owner.nbytes)
+        return
+
+    if isinstance(value, Mapping):
+        for item in value.values():
+            _accumulate(item, seen, totals)
+        return
+
+    # ``str``/``bytes`` are Sequences but hold no device memory; excluding them
+    # also stops the recursion from walking a string one character at a time.
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        for item in value:
+            _accumulate(item, seen, totals)
+        return
diff --git a/vllm_omni/experimental/world_models/session_state/attrs.py b/vllm_omni/experimental/world_models/session_state/attrs.py
new file mode 100644
index 000000000..708b5857d
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/attrs.py
@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Typed session-attribute descriptor (RFC #4480).
+
+``SessionAttr`` lets an adapter declare each piece of session-scoped scalar or
+tensor metadata as one class-level line instead of a hand-written property
+pair. The descriptor reads and writes ``SessionState.attrs`` on the host
+object's pinned ``_session``, using the attribute's own name as the key, so
+each key string exists exactly once. Because the read falls back to the
+declared default when the key is absent, an adapter clears a value simply by
+assigning the default (or by clearing ``attrs``), keeping its method bodies a
+line-for-line mirror of the model's original state class.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Generic, Protocol, TypeVar, cast, overload
+
+from vllm_omni.experimental.world_models.session_state.manager import SessionState
+
+T = TypeVar("T")
+
+
+class HasSessionState(Protocol):
+    """Host contract: any object holding a pinned ``SessionState``."""
+
+    _session: SessionState
+
+
+class SessionAttr(Generic[T]):
+    """Data descriptor for one session-scoped metadata value.
+
+    Declared at class level on an adapter::
+
+        class SomeAdapter:
+            call_count = SessionAttr[int](default=0, coerce=int)
+            language = SessionAttr[torch.Tensor | None](default=None)
+
+    Reads return ``attrs.get(<name>, default)``; writes go through ``coerce``
+    (when given) and straight into the session's ``attrs``, so a freshly
+    constructed adapter for an existing session sees the same data.
+    """
+
+    def __init__(
+        self,
+        *,
+        default: T,
+        coerce: Callable[[T], T] | None = None,
+    ) -> None:
+        self.default = default
+        self.coerce = coerce
+        self.name = ""  # assigned by ``__set_name__``
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self.name = name
+
+    @overload
+    def __get__(self, obj: None, objtype: type | None = None) -> SessionAttr[T]: ...
+
+    @overload
+    def __get__(self, obj: HasSessionState, objtype: type | None = None) -> T: ...
+
+    def __get__(self, obj: HasSessionState | None, objtype: type | None = None) -> SessionAttr[T] | T:
+        if obj is None:
+            return self
+        return cast("T", obj._session.attrs.get(self.name, self.default))
+
+    def __set__(self, obj: HasSessionState, value: T) -> None:
+        obj._session.attrs[self.name] = self.coerce(value) if self.coerce is not None else value
diff --git a/vllm_omni/experimental/world_models/session_state/base.py b/vllm_omni/experimental/world_models/session_state/base.py
new file mode 100644
index 000000000..be1d04016
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/base.py
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""The ``StateObject`` contract for session state (RFC #4480).
+
+A session is a named collection of ``StateObject`` instances. The interface
+deliberately speaks only of bytes, growth, read views, commitment, and
+evictability -- never tokens, layers, or attention. Writes are two-phase:
+``stage()`` holds data for an in-progress window, ``commit()`` promotes it to
+persistent context, and ``discard()`` drops it.
+
+A concrete class may back its storage with plain (non-paged) buffers; the
+contract itself does not require that. Several methods are
+intentionally inert and documented as such; they exist so that paged-KV
+backing and speculative forking can be added without changing any call site.
+See RFC #4480 for the full design and roadmap.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+
+from vllm_omni.experimental.world_models.session_state.accounting import SeenStorages
+
+# What writers pass into ``stage()`` / ``commit()`` / ``append()``.
+PayloadT = TypeVar("PayloadT")
+# What ``view()`` hands to the consumer (not necessarily the payload type:
+# an append buffer views as a list of payloads).
+ViewT = TypeVar("ViewT")
+
+
+class StateObject(ABC, Generic[PayloadT, ViewT]):
+    """One typed unit of session state with a uniform lifecycle.
+
+    A session's state is a named collection of these objects; the kinds of
+    memory they represent include attention K/V (growing self-attention
+    caches, or conditioning K/V written once and reread), constant-size
+    recurrent state (e.g. a linear-attention carry), frame or latent buffers,
+    and retrieval pools. A concrete class binds ``PayloadT`` and ``ViewT`` to
+    its real payload and view types and implements the abstract methods; the
+    non-abstract methods provide the default behaviour described in their
+    docstrings.
+
+    The contract is storage-agnostic. A concrete class may hold its bytes in
+    a buffer it owns, or it may be a handle to storage owned by another
+    component, such as a paged KV pool. In the handle case it delegates its
+    lifecycle operations to that owner instead of copying the data.
+    """
+
+    # The dependency edge: what this object rebuilds from. ``None`` means it is
+    # never recomputable (it must be preempted or rejected, not silently
+    # dropped).
+    recompute_source: StateObject | None = None
+    # Estimated work to rebuild, given ``recompute_source`` is resident.
+    recompute_cost: int = 0
+    # Payload held by ``stage()`` until ``discard()`` clears it.
+    _staged: PayloadT | None = None
+
+    @abstractmethod
+    def allocate(self) -> None:
+        """Size and initialise the backing storage to its empty state.
+
+        Concrete classes declare their sizing parameters as typed keyword-only
+        arguments (e.g. ``LatentBuffer.allocate(maxlen=...)``); a mistyped
+        keyword raises ``TypeError`` instead of being silently ignored.
+        """
+
+    def stage(self, payload: PayloadT) -> None:
+        """Hold data for an in-progress window.
+
+        Single-window writers go straight through ``commit()``, so the default
+        implementation only records the payload and is otherwise inert.
+        Speculative forking is the intended consumer of staged state.
+        """
+        self._staged = payload
+
+    @abstractmethod
+    def commit(self, payload: PayloadT | None = None) -> None:
+        """Promote data to persistent context.
+
+        For a plain-buffer object this is the synchronous write into its
+        committed storage (e.g. ``cache[i] = updated_kv.clone()``).
+        """
+
+    def discard(self) -> None:
+        """Drop staged data (speculative rejection).
+
+        Clears any recorded staged payload; committed bytes are never touched.
+        """
+        self._staged = None
+
+    def append(self, payload: PayloadT) -> None:
+        """``stage()`` + ``commit()``; single-shot writers use only this."""
+        self.commit(payload)
+
+    @abstractmethod
+    def view(self, *, include_staged: bool = True) -> ViewT:
+        """Return what the consumer (attention metadata, pipeline) reads."""
+
+    # ``policy`` deliberately stays ``Any``: the policy protocol belongs to
+    # the byte-budget eviction planner (RFC #4480), and defining it here
+    # would invent an interface that design owns.
+    def evict(self, policy: Any = None) -> int:
+        """Release this object's backing storage so it can be reused; return the
+        bytes freed.
+
+        This is the backend-agnostic release hook. For a plain buffer it drops
+        the buffer and lets the garbage collector reclaim it; for a paged backend
+        it returns the blocks to the pool so they can be recycled. Never reclaims
+        staged bytes.
+
+        Precondition: only call this when the object is no longer in use.
+        Releasing storage that is still referenced is a correctness bug (another
+        consumer could reuse it). Count-based session eviction therefore does NOT
+        call this — it only drops the lookup-table entry and lets an unreferenced
+        session be garbage-collected. The intended driver of this hook is a
+        byte-budget eviction planner with the recompute-DAG safety described in
+        RFC #4480.
+        """
+        freed = self.nbytes
+        self.reset()
+        return freed
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Clear back to the unallocated state."""
+
+    @abstractmethod
+    def nbytes_by_device(self, seen: SeenStorages) -> dict[str, int]:
+        """Bytes held in this object's committed storage, keyed by device.
+
+        Staged payloads are not counted. ``seen`` deduplicates storages across
+        the whole session -- pass it through to ``device_bytes`` rather than
+        starting a fresh set, or two views on one buffer are counted twice.
+        """
+
+    @property
+    def nbytes(self) -> int:
+        """Total bytes held, summed over every device.
+
+        Only meaningful when the caller genuinely does not care where the bytes
+        live (``evict()`` reporting what it freed, for instance). Anything
+        deciding against a budget wants ``nbytes_by_device`` instead: host and
+        device memory are different resources and their sum is not a quantity.
+        """
+        return sum(self.nbytes_by_device(set()).values())
+
+    @property
+    @abstractmethod
+    def resident(self) -> bool:
+        """Whether data is currently in memory (not yet evicted)."""
+
+    @property
+    def recomputable(self) -> bool:
+        """Droppable-and-rebuildable *right now*.
+
+        Derived, not declared: true only while ``recompute_source`` is still
+        resident, so the answer changes as other objects are evicted.
+        """
+        return self.recompute_source is not None and self.recompute_source.resident
diff --git a/vllm_omni/experimental/world_models/session_state/manager.py b/vllm_omni/experimental/world_models/session_state/manager.py
new file mode 100644
index 000000000..bb08c064c
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/manager.py
@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Session memory manager (RFC #4480).
+
+``SessionStateManager`` maps ``session_id -> {name: StateObject}`` and is the
+single authority for session lifecycle and eviction. It evicts by session count
+(LRU), matching the per-model session caches it adapts (e.g. DreamZero's), so
+an adapted model keeps the same eviction behaviour. A byte budget is recorded
+for observability; enforcing it is left to a byte-budget eviction planner (see
+RFC #4480).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from collections import OrderedDict
+from collections.abc import Callable
+from contextlib import AbstractContextManager
+from typing import TypeVar
+
+from vllm_omni.experimental.world_models.session_state.accounting import (
+    SeenStorages,
+    device_bytes,
+    merge_bytes,
+)
+from vllm_omni.experimental.world_models.session_state.base import StateObject
+
+logger = logging.getLogger(__name__)
+
+# Matches DreamZero's MAX_DREAMZERO_SESSIONS cap so an adapted DreamZero
+# evicts identically.
+DEFAULT_MAX_SESSIONS = 64
+
+M = TypeVar("M", bound=StateObject)
+
+
+class SessionState:
+    """The named ``StateObject`` collection for one session."""
+
+    def __init__(self) -> None:
+        self._objects: dict[str, StateObject] = {}
+        # Session-scoped scalar/tensor metadata that is not itself a typed
+        # StateObject (e.g. counters, cached conditioning tensors). Persists
+        # across the per-call adapters that read/write it.
+        # ``object`` (not ``Any``) so every read site must narrow explicitly.
+        self.attrs: dict[str, object] = {}
+
+    def get(self, name: str) -> StateObject | None:
+        return self._objects.get(name)
+
+    def put(self, name: str, obj: StateObject) -> StateObject:
+        self._objects[name] = obj
+        return obj
+
+    def get_or_create(self, name: str, factory: Callable[[], M], cls: type[M]) -> M:
+        """Return the resident object of type ``cls`` under ``name``, building
+        it via ``factory`` when absent, wrong-typed, or no longer resident."""
+        obj = self._objects.get(name)
+        if not isinstance(obj, cls) or not obj.resident:
+            obj = factory()
+            self._objects[name] = obj
+        return obj
+
+    def names(self) -> list[str]:
+        return list(self._objects)
+
+    def reset(self) -> None:
+        for obj in self._objects.values():
+            obj.reset()
+        # Clear session-scoped metadata too, so a reset leaves nothing stale
+        # (otherwise language/current_start_frame/clip_feas/ys would survive).
+        self.attrs.clear()
+
+    def nbytes_by_device(self, seen: SeenStorages | None = None) -> dict[str, int]:
+        """Bytes this session holds, keyed by device.
+
+        Both buckets are walked. A ``StateObject`` and a session attribute are
+        different in what the *manager* may do with them -- release, accumulate,
+        stage and commit versus merely carry -- but not in whether their bytes
+        occupy memory, so the accounting covers both. One ``seen`` set spans the
+        whole session, so a tensor aliased between the two buckets is counted
+        once.
+        """
+        shared: SeenStorages = set() if seen is None else seen
+        totals: dict[str, int] = {}
+        for obj in self._objects.values():
+            merge_bytes(totals, obj.nbytes_by_device(shared))
+        merge_bytes(totals, device_bytes(self.attrs, shared))
+        return totals
+
+    @property
+    def nbytes(self) -> int:
+        """Total bytes held, summed over every device -- see
+        ``StateObject.nbytes`` on why a budget wants the per-device split."""
+        return sum(self.nbytes_by_device().values())
+
+
+class SessionStateManager:
+    """Owns per-session state and arbitrates the (count-based) LRU.
+
+    The manager lives beside ``DiffusionRequestState`` (owned by the pipeline),
+    not inside its ``extra`` dict: the manager is cross-request and long-lived,
+    whereas ``DiffusionRequestState`` is per-request and transient.
+    """
+
+    def __init__(
+        self,
+        max_sessions: int = DEFAULT_MAX_SESSIONS,
+        byte_budget: int | None = None,
+        lock_factory: Callable[[], AbstractContextManager[object]] = threading.Lock,
+    ) -> None:
+        if max_sessions <= 0:
+            raise ValueError(f"max_sessions must be positive, got {max_sessions}")
+        self.max_sessions = max_sessions
+        # Recorded for observability; enforcement is left to an eviction
+        # planner (see RFC #4480). Not scoped to a device: which pool a budget
+        # applies to is a question for whoever enforces it, so read
+        # ``nbytes_by_device()`` and pick the pool at the point of enforcement.
+        self.byte_budget = byte_budget
+        self._sessions: OrderedDict[str, SessionState] = OrderedDict()
+        # The locking strategy is injected rather than hard-coded: callers
+        # that run the manager from worker threads keep the default
+        # ``threading.Lock``, while an async or single-threaded owner can pass
+        # e.g. ``contextlib.nullcontext`` (or a custom strategy) without any
+        # call-site change -- the manager only ever does ``with self._lock:``.
+        # Heavier operations (paged allocation, eviction planning) keep this
+        # seam.
+        self._lock = lock_factory()
+        self.hits = 0
+        self.misses = 0
+        self.evictions = 0
+
+    @staticmethod
+    def _key(session_id: str | None) -> str:
+        return str(session_id or "default")
+
+    def get_or_create_session(self, session_id: str | None) -> SessionState:
+        key = self._key(session_id)
+        with self._lock:
+            session = self._sessions.get(key)
+            if session is None:
+                self.misses += 1
+                session = SessionState()
+                self._sessions[key] = session
+                while len(self._sessions) > self.max_sessions:
+                    # Drop the oldest from the table only; do not free its
+                    # buffers. An adapter still using the session keeps its own
+                    # reference, so its state survives (matching a model's own
+                    # per-session state object, which the caller holds even
+                    # after it leaves the table). Unreferenced sessions are
+                    # GC-reclaimed.
+                    self._sessions.popitem(last=False)
+                    self.evictions += 1
+            else:
+                self.hits += 1
+                self._sessions.move_to_end(key)
+            return session
+
+    def drop_session(self, session_id: str | None) -> bool:
+        """Release one session explicitly and free its buffers.
+
+        This is the end-of-session signal a model's engine raises on close,
+        eviction, or reset -- distinct from the count-based LRU in
+        ``get_or_create_session``, which only drops the *table* entry and lets an
+        adapter still holding the session keep it alive. Here the session is
+        finished, so its ``StateObject`` buffers and carried attributes are reset
+        to release their memory. Returns whether a session was present.
+        """
+        key = self._key(session_id)
+        with self._lock:
+            session = self._sessions.pop(key, None)
+            if session is None:
+                return False
+            session.reset()
+            return True
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._sessions)
+
+    def __contains__(self, session_id: str | None) -> bool:
+        with self._lock:
+            return self._key(session_id) in self._sessions
+
+    def nbytes_by_device(self) -> dict[str, int]:
+        """Bytes held across every live session, keyed by device."""
+        with self._lock:
+            return self._nbytes_by_device_locked()
+
+    def _nbytes_by_device_locked(self) -> dict[str, int]:
+        # One ``seen`` set across all sessions: sessions can legitimately share
+        # a storage (a conditioning tensor broadcast to several of them), and
+        # the total is what the process holds, not the sum of what each session
+        # would hold alone.
+        shared: SeenStorages = set()
+        totals: dict[str, int] = {}
+        for session in self._sessions.values():
+            merge_bytes(totals, session.nbytes_by_device(shared))
+        return totals
+
+    def stats(self) -> dict[str, int]:
+        """Counters plus per-device byte totals.
+
+        Byte keys are prefixed ``nbytes:`` and named by device -- ``nbytes:cpu``,
+        ``nbytes:cuda:0`` -- because host and device memory are different
+        resources and their sum answers no question. ``total_nbytes`` is kept
+        for callers that only want a single number.
+        """
+        with self._lock:
+            by_device = self._nbytes_by_device_locked()
+            stats: dict[str, int] = {
+                "sessions": len(self._sessions),
+                "max_sessions": self.max_sessions,
+                "total_nbytes": sum(by_device.values()),
+                "hits": self.hits,
+                "misses": self.misses,
+                "evictions": self.evictions,
+            }
+            for device, count in sorted(by_device.items()):
+                stats[f"nbytes:{device}"] = count
+            return stats
+
+
+def resolve_session_state_config(
+    enable: bool | None = None,
+    max_sessions: int | None = None,
+) -> tuple[bool, int]:
+    """Combine explicit args with env-var overrides.
+
+    Environment variables (for quick enablement without touching config files):
+
+        ``OMNI_DIFFUSION_SESSION_STATE_MANAGER`` (``1``/``0``/``true``/``false``)
+        ``OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS`` (positive int)
+
+    Precedence: a *set* environment variable wins over the value passed in
+    (i.e. over ``OmniDiffusionConfig.enable_session_state_manager``), in both
+    directions -- ``...SESSION_MEMORY_MANAGER=0`` force-disables the manager
+    even when the config enables it. Unset or unparsable values leave the
+    passed-in value untouched (an unparsable ``MAX_SESSIONS`` logs a warning
+    and is ignored). This mirrors how other omni feature toggles allow quick
+    A/B flips on a deployed config.
+    """
+    env_enable = os.environ.get("OMNI_DIFFUSION_SESSION_STATE_MANAGER")
+    if env_enable is not None:
+        parsed = env_enable.strip().lower()
+        if parsed in ("1", "true", "yes", "on"):
+            enable = True
+        elif parsed in ("0", "false", "no", "off"):
+            enable = False
+
+    env_size = os.environ.get("OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS")
+    if env_size is not None:
+        try:
+            env_size_int = int(env_size)
+            if env_size_int > 0:
+                max_sessions = env_size_int
+        except ValueError:
+            logger.warning(
+                "Ignoring non-integer OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS=%r.",
+                env_size,
+            )
+
+    return bool(enable), int(max_sessions or DEFAULT_MAX_SESSIONS)
diff --git a/vllm_omni/experimental/world_models/session_state/objects.py b/vllm_omni/experimental/world_models/session_state/objects.py
new file mode 100644
index 000000000..e9e1f4152
--- /dev/null
+++ b/vllm_omni/experimental/world_models/session_state/objects.py
@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Concrete memory objects (RFC #4480).
+
+``LatentBuffer`` backs its storage with a plain (monolithic) buffer. Attention
+KV is deliberately absent: for DreamZero it is owned by the AR-Diffusion engine's
+paged pool (PR #4534), and the RFC's ``PagedKV`` arrives in Phase 1 as a
+handle wrapping that engine state rather than a dense buffer here. The RFC's
+``FixedState`` and ``RetrievalStore`` land with their first consumers, but the
+names are reserved.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Iterable
+from typing import TypeVar
+
+from vllm_omni.experimental.world_models.session_state.accounting import (
+    SeenStorages,
+    device_bytes,
+)
+from vllm_omni.experimental.world_models.session_state.base import StateObject
+
+# The frame/chunk type a ``LatentBuffer`` holds (e.g. ``np.ndarray`` pixel
+# frames, ``torch.Tensor`` latent chunks).
+ItemT = TypeVar("ItemT")
+
+
+class LatentBuffer(StateObject[ItemT, list[ItemT]]):
+    """Append / ring buffer of latent or pixel frames.
+
+    A bounded ``deque`` (``maxlen`` set at ``allocate()`` time). The object
+    only stores and views the frames; model-specific stacking stays in the
+    caller.
+    """
+
+    def __init__(self) -> None:
+        self._buf: deque[ItemT] | None = None
+
+    def allocate(self, *, maxlen: int | None = None) -> None:
+        self._buf = deque(maxlen=maxlen)
+
+    def append(self, payload: ItemT) -> None:
+        if self._buf is None:
+            raise RuntimeError("LatentBuffer is not allocated; call allocate() first.")
+        self._buf.append(payload)
+
+    def extend(self, payloads: Iterable[ItemT]) -> None:
+        if self._buf is None:
+            raise RuntimeError("LatentBuffer is not allocated; call allocate() first.")
+        self._buf.extend(payloads)
+
+    def commit(self, payload: ItemT | None = None) -> None:
+        if payload is not None:
+            self.append(payload)
+
+    def view(self, *, include_staged: bool = True) -> list[ItemT]:
+        if self._buf is None:
+            raise RuntimeError("LatentBuffer is not allocated; call allocate() first.")
+        return list(self._buf)
+
+    def __len__(self) -> int:
+        return 0 if self._buf is None else len(self._buf)
+
+    def reset(self) -> None:
+        self._buf = None
+
+    def nbytes_by_device(self, seen: SeenStorages) -> dict[str, int]:
+        if self._buf is None:
+            return {}
+        return device_bytes(list(self._buf), seen)
+
+    @property
+    def resident(self) -> bool:
+        return self._buf is not None
diff --git a/vllm_omni/inputs/data.py b/vllm_omni/inputs/data.py
index 73ac80642..5e6b5275e 100644
--- a/vllm_omni/inputs/data.py
+++ b/vllm_omni/inputs/data.py
@@ -1,35 +1,28 @@
 import copy
 import pprint
 from dataclasses import asdict, dataclass, field
-from typing import Any, TypeAlias, TypedDict
+from typing import Any, TypeAlias
 
-from vllm.inputs import PromptType
+import torch
+from typing_extensions import NotRequired, TypedDict
+from vllm.inputs import EmbedsPrompt, PromptType, TextPrompt, TokensPrompt
+from vllm.inputs.engine import TokensInput
 from vllm.sampling_params import SamplingParams
 
 from vllm_omni.lora.request import LoRARequest
 
-try:
-    from typing import NotRequired
-except ImportError:
-    # Python < 3.11: use typing_extensions
-    from typing_extensions import NotRequired
-
-
-import torch
-from vllm.inputs import EmbedsPrompt, TextPrompt, TokensPrompt
-from vllm.inputs.engine import TokensInput
-
 
 class OmniTextPrompt(TextPrompt):
-    """Text prompt with optional embeddings and additional information.
+    """Text prompt with optional embeddings and stage payloads.
 
     Extends TextPrompt to support prompt embeddings and additional
     information payloads for direct transfer between pipeline stages.
 
     Attributes:
         prompt_embeds: Optional tensor containing prompt embeddings
-        additional_information: Optional dictionary containing additional
-            information (tensors or lists) to pass along with the prompt
+        additional_information: Legacy optional dictionary containing
+            additional information to pass along with the prompt.
+        model_intermediate_buffer: Optional runner-owned stage payload.
     """
 
     negative_prompt: NotRequired[str]
@@ -39,18 +32,34 @@ class OmniTextPrompt(TextPrompt):
     prompt_embeds: NotRequired[torch.Tensor]
     negative_prompt_embeds: NotRequired[torch.Tensor]
     additional_information: NotRequired[dict[str, Any]]
+    model_intermediate_buffer: NotRequired[dict[str, Any]]
+
+
+class OmniInteractionEvent(OmniTextPrompt, total=False):
+    """Prompt-event payload for mid-stream interactions."""
+
+    pass
+
+
+class OmniInteractionPrompt(TypedDict, total=False):
+    """Mid-stream interaction payload."""
+
+    event_id: NotRequired[str]
+    event: NotRequired[OmniInteractionEvent]
+    transition_chunks: NotRequired[int]
 
 
 class OmniTokensPrompt(TokensPrompt):
-    """Tokens prompt with optional embeddings and additional information.
+    """Tokens prompt with optional embeddings and stage payloads.
 
     Extends TokensPrompt to support prompt embeddings and additional
     information payloads for direct transfer between pipeline stages.
 
     Attributes:
         prompt_embeds: Optional tensor containing prompt embeddings
-        additional_information: Optional dictionary containing additional
-            information (tensors or lists) to pass along with the prompt
+        additional_information: Legacy optional dictionary containing
+            additional information to pass along with the prompt.
+        model_intermediate_buffer: Optional runner-owned stage payload.
     """
 
     negative_prompt: NotRequired[str]
@@ -61,10 +70,11 @@ class OmniTokensPrompt(TokensPrompt):
     # New: optional additional information dictionary
     # Values may be torch.Tensor or list
     additional_information: NotRequired[dict[str, Any]]
+    model_intermediate_buffer: NotRequired[dict[str, Any]]
 
 
 class OmniTokenInputs(TokensInput):
-    """Token inputs with optional embeddings and additional information.
+    """Token inputs with optional embeddings and stage payloads.
 
     Extends TokensInput to support prompt embeddings and additional
     information payloads for direct transfer between pipeline stages.
@@ -72,8 +82,9 @@ class OmniTokenInputs(TokensInput):
     Attributes:
         prompt_embeds: Optional tensor containing prompt embeddings
             aligned with token IDs
-        additional_information: Optional dictionary containing additional
-            information (tensors or lists) to pass along with the inputs
+        additional_information: Legacy optional dictionary containing
+            additional information to pass along with the inputs.
+        model_intermediate_buffer: Optional runner-owned stage payload.
     """
 
     # New: optional prompt embeddings aligned with token ids
@@ -84,18 +95,20 @@ class OmniTokenInputs(TokensInput):
     # New: optional additional information dictionary
     # Values may be torch.Tensor or list
     additional_information: NotRequired[dict[str, Any]]
+    model_intermediate_buffer: NotRequired[dict[str, Any]]
 
 
 class OmniEmbedsPrompt(EmbedsPrompt):
-    """Embeddings prompt with optional additional information.
+    """Embeddings prompt with optional stage payloads.
 
     Extends EmbedsPrompt to support additional information payloads
     for direct transfer between pipeline stages.
 
     Attributes:
         prompt_embeds: Optional tensor containing prompt embeddings
-        additional_information: Optional dictionary containing additional
-            information (tensors or lists) to pass along with the prompt
+        additional_information: Legacy optional dictionary containing
+            additional information to pass along with the prompt.
+        model_intermediate_buffer: Optional runner-owned stage payload.
     """
 
     # New: optional prompt embeddings aligned with token ids
@@ -105,6 +118,7 @@ class OmniEmbedsPrompt(EmbedsPrompt):
     # New: optional additional information dictionary
     # Values may be torch.Tensor or list
     additional_information: NotRequired[dict[str, Any]]
+    model_intermediate_buffer: NotRequired[dict[str, Any]]
 
 
 class OmniCustomPrompt(TypedDict, total=False):
@@ -143,6 +157,7 @@ def token_inputs_omni(
     cache_salt: str | None = None,
     prompt_embeds: torch.Tensor | None = None,
     additional_information: dict[str, Any] | None = None,
+    model_intermediate_buffer: dict[str, Any] | None = None,
 ) -> OmniTokenInputs:
     """Construct token inputs with optional embeddings and metadata.
 
@@ -154,8 +169,9 @@ def token_inputs_omni(
         prompt: Optional prompt string
         cache_salt: Optional cache salt for prefix caching
         prompt_embeds: Optional tensor containing prompt embeddings
-        additional_information: Optional dictionary containing additional
-            information (tensors or lists)
+        additional_information: Legacy optional dictionary containing
+            additional information (tensors or lists).
+        model_intermediate_buffer: Optional runner-owned stage payload.
 
     Returns:
         OmniTokenInputs instance with the provided data
@@ -170,6 +186,8 @@ def token_inputs_omni(
         inputs["prompt_embeds"] = prompt_embeds
     if additional_information is not None:
         inputs["additional_information"] = additional_information
+    if model_intermediate_buffer is not None:
+        inputs["model_intermediate_buffer"] = model_intermediate_buffer
 
     return inputs
 
@@ -245,9 +263,10 @@ class OmniDiffusionSamplingParams:
     # Scheduler parameters – ``None`` means "not explicitly set by the caller";
     # each pipeline's ``forward()`` decides its own model-specific default.
     num_inference_steps: int | None = None
-    guidance_scale: float = 0.0
+    guidance_scale: float | None = None
     guidance_scale_provided: bool = False
     guidance_scale_2: float | None = None
+    guidance_scale_2_provided: bool = False
     guidance_rescale: float = 0.0
     strength: float | None = None  # I2I: Z-Image specific now, uses to control denoising start timestep
     decode_timestep: float | list[float] | None = None
@@ -353,5 +372,30 @@ class OmniDiffusionSamplingParams:
     def clone(self) -> "OmniDiffusionSamplingParams":
         return copy.deepcopy(self)
 
+    @classmethod
+    def from_params(cls, params: Any) -> "OmniDiffusionSamplingParams":
+        """Normalize caller params for diffusion stages.
+
+        Existing Omni params are returned unchanged. Plain vLLM SamplingParams
+        copy seed and matching extra_args fields; remaining extra_args stay nested.
+        Unsupported types raise TypeError.
+        """
+        if isinstance(params, cls):
+            return params
+        if isinstance(params, SamplingParams):
+            extra = dict(getattr(params, "extra_args", None) or {})
+            known = set(cls.__dataclass_fields__)
+            mapped = {k: extra.pop(k) for k in list(extra) if k in known}
+            if extra:
+                mapped["extra_args"] = extra
+            seed = getattr(params, "seed", None)
+            if seed is not None:
+                mapped.setdefault("seed", seed)
+            return cls(**mapped)
+        raise TypeError(
+            "Diffusion stage requires OmniDiffusionSamplingParams or vllm.SamplingParams, "
+            f"got {type(params).__name__!r}."
+        )
+
 
 OmniSamplingParams: TypeAlias = SamplingParams | OmniDiffusionSamplingParams
diff --git a/vllm_omni/inputs/preprocess.py b/vllm_omni/inputs/preprocess.py
index 7282d7a52..3da1ef897 100644
--- a/vllm_omni/inputs/preprocess.py
+++ b/vllm_omni/inputs/preprocess.py
@@ -60,6 +60,9 @@ class OmniInputPreprocessor(InputPreprocessor):
             additional_information = parsed_content.get("additional_information")
             if additional_information is not None:
                 inputs["additional_information"] = additional_information
+            model_intermediate_buffer = parsed_content.get("model_intermediate_buffer")
+            if model_intermediate_buffer is not None:
+                inputs["model_intermediate_buffer"] = model_intermediate_buffer
         elif "mm_processor_kwargs" in parsed_content:
             # Presence — not truthiness. An explicitly-set empty dict still
             # signals "route through the multimodal processor" (needed for
@@ -81,6 +84,7 @@ class OmniInputPreprocessor(InputPreprocessor):
                 prompt_token_ids,
                 prompt_embeds=parsed_content.get("prompt_embeds"),
                 additional_information=parsed_content.get("additional_information"),
+                model_intermediate_buffer=parsed_content.get("model_intermediate_buffer"),
             )
         prompt_embeds = parsed_content.get("prompt_embeds")
         if prompt_embeds is not None:
@@ -88,6 +92,9 @@ class OmniInputPreprocessor(InputPreprocessor):
         additional_information = parsed_content.get("additional_information")
         if additional_information is not None:
             inputs["additional_information"] = additional_information
+        model_intermediate_buffer = parsed_content.get("model_intermediate_buffer")
+        if model_intermediate_buffer is not None:
+            inputs["model_intermediate_buffer"] = model_intermediate_buffer
         if cache_salt := parsed_content.get("cache_salt"):
             inputs["cache_salt"] = cache_salt
 
@@ -101,6 +108,7 @@ class OmniInputPreprocessor(InputPreprocessor):
         prompt_token_ids = self._truncate_inputs(parsed_content["prompt_token_ids"], tokenization_kwargs)
         prompt_embeds = parsed_content.get("prompt_embeds")
         additional_information = parsed_content.get("additional_information")
+        model_intermediate_buffer = parsed_content.get("model_intermediate_buffer")
 
         multi_modal_data = parsed_content.get("multi_modal_data")
 
@@ -119,11 +127,14 @@ class OmniInputPreprocessor(InputPreprocessor):
                 prompt_token_ids=prompt_token_ids,
                 prompt_embeds=prompt_embeds,
                 additional_information=additional_information,
+                model_intermediate_buffer=model_intermediate_buffer,
             )
         if prompt_embeds is not None:
             inputs["prompt_embeds"] = prompt_embeds
         if additional_information is not None:
             inputs["additional_information"] = additional_information
+        if model_intermediate_buffer is not None:
+            inputs["model_intermediate_buffer"] = model_intermediate_buffer
         if prompt_text := parsed_content.get("prompt"):
             inputs["prompt"] = prompt_text
         if cache_salt := parsed_content.get("cache_salt"):
@@ -147,6 +158,9 @@ class OmniInputPreprocessor(InputPreprocessor):
         additional_information = parsed_content.get("additional_information")
         if additional_information is not None:
             inputs["additional_information"] = additional_information  # type: ignore[typeddict-unknown-key]
+        model_intermediate_buffer = parsed_content.get("model_intermediate_buffer")
+        if model_intermediate_buffer is not None:
+            inputs["model_intermediate_buffer"] = model_intermediate_buffer  # type: ignore[typeddict-unknown-key]
 
         return inputs
 
diff --git a/vllm_omni/metrics/__init__.py b/vllm_omni/metrics/__init__.py
index 6814a5891..7b6a2979f 100644
--- a/vllm_omni/metrics/__init__.py
+++ b/vllm_omni/metrics/__init__.py
@@ -1,6 +1,11 @@
 from .prometheus import OmniPrometheusMetrics, OmniRequestCounter
 from .stats import OrchestratorAggregator, StageRequestStats, StageStats
-from .utils import count_tokens_from_outputs
+from .utils import (
+    count_audio_chunk_frames,
+    count_audio_frames,
+    count_image_pixels,
+    count_tokens_from_outputs,
+)
 
 __all__ = [
     "OmniPrometheusMetrics",
@@ -8,5 +13,8 @@ __all__ = [
     "OrchestratorAggregator",
     "StageStats",
     "StageRequestStats",
+    "count_audio_chunk_frames",
+    "count_audio_frames",
+    "count_image_pixels",
     "count_tokens_from_outputs",
 ]
diff --git a/vllm_omni/metrics/definitions.py b/vllm_omni/metrics/definitions.py
index 9660e4f34..23a1364a4 100644
--- a/vllm_omni/metrics/definitions.py
+++ b/vllm_omni/metrics/definitions.py
@@ -13,7 +13,9 @@ time-bearing metrics use the ``_s`` suffix (values in seconds), counters use
 
 import logging
 import os
-from typing import Any
+from collections.abc import Mapping, Sequence
+
+from vllm_omni.metrics.utils import resolve_int_by_sequential_keys
 
 # vllm_omni: namespace for omni-specific Prometheus families, distinct from
 # the upstream vllm:* families.
@@ -243,8 +245,20 @@ BYTES_BUCKETS = (
 
 
 # ============================================================================
-# Audio-continuity defaults
+# Audio defaults (shared by server-side observe and bench-side calculation)
 # ============================================================================
+# Most common across vllm-omni talker variants (cosyvoice3, omnivoice,
+# qwen3_tts, mimo_audio). voxcpm2 uses 48000, stable_audio 44100,
+# ming_flash 16000 — these models surface a rate at runtime on one of
+# ``_SAMPLE_RATE_KEYS``, so DEFAULT_AUDIO_SAMPLE_RATE only applies when no
+# usable positive rate is found (and as the bench PCM default when env is unset).
+# Streamed OpenAI ``response_format=pcm`` is PCM_16 (s16le); sample width is fixed.
+DEFAULT_AUDIO_SAMPLE_RATE = 24000
+DEFAULT_AUDIO_CHANNELS = 1
+DEFAULT_AUDIO_SAMPLE_WIDTH = 2  # PCM s16le bytes per sample
+AUDIO_SAMPLE_RATE_ENV = "VLLM_OMNI_BENCH_AUDIO_SAMPLE_RATE"
+AUDIO_CHANNELS_ENV = "VLLM_OMNI_BENCH_AUDIO_CHANNELS"
+
 # Default underrun threshold — kept aligned with the bench-side default and
 # the commonly-cited "audible gap" threshold for streaming TTS.
 AUDIO_CONTINUITY_DEFAULT_THRESHOLD_S = 0.1
@@ -253,8 +267,8 @@ AUDIO_CONTINUITY_DEFAULT_THRESHOLD_S = 0.1
 # ============================================================================
 # Formula helpers (shared by server-side observe and bench-side calculation)
 # ============================================================================
-def compute_audio_rtf(stage_gen_time_s: float, audio_duration_s: float) -> float:
-    """RTF = stage_gen_time / audio_content_duration.
+def compute_audio_rtf(audio_generation_latency_s: float, audio_duration_s: float) -> float:
+    """RTF = audio_generation_latency / audio_content_duration.
 
     SLO red line < 1 — must generate faster than content plays back to stream.
     Returns 0.0 when audio_duration_s is non-positive (caller decides whether
@@ -262,7 +276,30 @@ def compute_audio_rtf(stage_gen_time_s: float, audio_duration_s: float) -> float
     """
     if audio_duration_s <= 0:
         return 0.0
-    return stage_gen_time_s / audio_duration_s
+    return audio_generation_latency_s / audio_duration_s
+
+
+def compute_audio_frames(
+    pcm_nbytes: int,
+    *,
+    sample_width: int = DEFAULT_AUDIO_SAMPLE_WIDTH,
+    channels: int = DEFAULT_AUDIO_CHANNELS,
+) -> int:
+    """Convert a PCM byte length to sample/frame count.
+
+    ``pcm_nbytes`` is the raw byte size of interleaved PCM (e.g.
+    ``total_pcm_bytes`` or ``len(wav_pcm_buffer)``). Defaults match the
+    streamed s16le mono contract
+    (``DEFAULT_AUDIO_SAMPLE_WIDTH``, ``DEFAULT_AUDIO_CHANNELS``);
+    WAV callers should pass header values.
+
+    Returns 0 when the byte count or frame width (``sample_width * channels``)
+    is non-positive.
+    """
+    frame_width = sample_width * channels
+    if pcm_nbytes <= 0 or frame_width <= 0:
+        return 0
+    return pcm_nbytes // frame_width
 
 
 def compute_denoise_step_latency(stage_gen_time: float, num_inference_steps: int) -> float:
@@ -278,40 +315,45 @@ def compute_denoise_step_latency(stage_gen_time: float, num_inference_steps: int
 # ============================================================================
 # Audio sample-rate resolution
 # ============================================================================
-# Most common across vllm-omni talker variants (cosyvoice3, omnivoice,
-# qwen3_tts, mimo_audio). voxcpm2 uses 48000, stable_audio 44100,
-# ming_flash 16000 — these models populate multimodal_output["audio_sample_rate"]
-# at runtime so this default only kicks in when the field is missing.
-DEFAULT_AUDIO_SAMPLE_RATE = 24000
-DEFAULT_AUDIO_CHANNELS = 1
-AUDIO_SAMPLE_RATE_ENV = "VLLM_OMNI_BENCH_AUDIO_SAMPLE_RATE"
-AUDIO_CHANNELS_ENV = "VLLM_OMNI_BENCH_AUDIO_CHANNELS"
-
 _SAMPLE_RATE_KEYS = ("output_sample_rate", "audio_sample_rate", "sample_rate", "sampling_rate", "sr")
 
 
-def resolve_audio_sample_rate(source: dict[str, Any] | Any | None) -> int:
-    """Extract audio sample_rate from a dict or config object, with fallbacks.
+def resolve_audio_sample_rate_or_none(
+    source: Sequence[Mapping[str, object] | object | None] | Mapping[str, object] | object | None,
+) -> int | None:
+    """Extract an explicitly configured audio sample rate, or ``None`` when absent.
 
-    Tries the same key chain as serving_chat.py's audio response path so
-    /metrics audio_duration_s = audio_frames / sample_rate stays consistent
-    with what the OpenAI streaming endpoint reports back to clients. Also
-    accepts config objects that expose the same values as attributes.
-    Returns DEFAULT_AUDIO_SAMPLE_RATE when no usable value is present.
+    ``source`` may be:
+
+    - a Mapping (e.g. ``multimodal_output`` / config dict)
+    - an object exposing the same fields as attributes
+    - a Sequence of the above (``str`` / ``bytes`` excluded); the first
+      positive rate found across items wins
     """
-    if not source:
-        return DEFAULT_AUDIO_SAMPLE_RATE
-    for key in _SAMPLE_RATE_KEYS:
-        raw = source.get(key) if isinstance(source, dict) else getattr(source, key, None)
-        if raw is None:
-            continue
-        try:
-            value = int(raw)
-        except (TypeError, ValueError):
-            continue
-        if value > 0:
-            return value
-    return DEFAULT_AUDIO_SAMPLE_RATE
+    if isinstance(source, Sequence) and not isinstance(source, (str, bytes, bytearray)):
+        for item in source:
+            rate = resolve_int_by_sequential_keys(item, _SAMPLE_RATE_KEYS)
+            if rate is not None:
+                return rate
+        return None
+    return resolve_int_by_sequential_keys(source, _SAMPLE_RATE_KEYS)
+
+
+def resolve_audio_sample_rate(
+    source: Sequence[Mapping[str, object] | object | None] | Mapping[str, object] | object | None,
+    default: int = DEFAULT_AUDIO_SAMPLE_RATE,
+) -> int:
+    """Extract audio sample rate from a dict, config object, or list thereof.
+
+    Delegates to :func:`resolve_audio_sample_rate_or_none` (same key chain and
+    coerce rules). Returns ``default`` (``DEFAULT_AUDIO_SAMPLE_RATE`` unless
+    overridden) when no usable positive rate is present.
+
+    Used so /metrics ``audio_duration_s = audio_frames / sample_rate`` stays
+    consistent with rates surfaced on multimodal outputs and stage configs.
+    """
+    rate = resolve_audio_sample_rate_or_none(source)
+    return rate if rate is not None else default
 
 
 def stream_pcm_format_from_env(
diff --git a/vllm_omni/metrics/modality.py b/vllm_omni/metrics/modality.py
index 73d46ee8b..fd455ad36 100644
--- a/vllm_omni/metrics/modality.py
+++ b/vllm_omni/metrics/modality.py
@@ -15,9 +15,9 @@ Contents:
 - ``observe_audio_streaming_finalize``: emits ``audio_underrun_s`` +
   ``audio_continuity_ok_total`` at SSE close using accumulated per-chunk
   arrival timestamps.
-- ``_extract_mm_output`` / ``_count_audio_frames``: shape-tolerant helpers
-  for the heterogeneous multimodal_output payloads emitted by different
-  audio pipelines.
+- ``extract_mm_output`` / ``count_audio_frames`` (from ``metrics.utils``):
+  shape-tolerant helpers for the heterogeneous multimodal_output payloads
+  emitted by different audio pipelines.
 """
 
 from __future__ import annotations
@@ -27,6 +27,7 @@ from typing import Any
 from prometheus_client import Counter, Histogram
 
 from vllm_omni.metrics import definitions as defs
+from vllm_omni.metrics.utils import count_audio_frames, extract_mm_output
 
 _stage_labels = list(defs.STAGE_LABELS)
 
@@ -139,53 +140,6 @@ class OmniModalityMetrics:
         ).inc()
 
 
-def _extract_mm_output(engine_outputs: Any) -> dict[str, Any]:
-    """Return the multimodal_output dict regardless of where it's nested.
-
-    Three shapes seen in the wild:
-      * ``engine_outputs.multimodal_output`` — synthesized on OmniRequestOutput
-        for some pipelines (often empty for AR audio)
-      * ``engine_outputs.outputs[0].multimodal_output`` — vllm CompletionOutput
-        nesting (where actual qwen3-omni audio data lives)
-      * neither — returns ``{}``
-    """
-    mm = getattr(engine_outputs, "multimodal_output", None)
-    if isinstance(mm, dict) and mm:
-        return mm
-    outs = getattr(engine_outputs, "outputs", None)
-    if outs:
-        nested = getattr(outs[0], "multimodal_output", None)
-        if isinstance(nested, dict):
-            return nested
-    return {}
-
-
-def _count_audio_frames(mm_out: dict[str, Any]) -> int:
-    """Sum the per-tensor sample count of audio chunks in mm_out["audio"].
-
-    Returns the total number of audio frames (samples) across all chunks.
-    For multi-dim tensors (e.g. shape [channels, samples]) the last axis is
-    treated as the sample dim; for 1-D tensors the only axis is the sample
-    dim; scalars count as 1.
-    """
-    audio_chunks = mm_out.get("audio") if isinstance(mm_out, dict) else None
-    if audio_chunks is None:
-        return 0
-    chunks = audio_chunks if isinstance(audio_chunks, list) else [audio_chunks]
-    n = 0
-    for t in chunks:
-        try:
-            ndim = getattr(t, "ndim", 0)
-            shape = getattr(t, "shape", None)
-            if ndim == 0 or shape is None or len(shape) == 0:
-                n += 1
-            else:
-                n += int(shape[-1])
-        except Exception:
-            continue
-    return n
-
-
 def observe_modality_at_finalize(
     mod_metrics: OmniModalityMetrics,
     *,
@@ -213,7 +167,7 @@ def observe_modality_at_finalize(
     stage_label = str(stage_id)
     replica_label = str(replica_id)
     gen_time_s = float(getattr(stage_metrics, "stage_gen_time_ms", 0.0)) / 1000.0
-    mm_out = _extract_mm_output(engine_outputs)
+    mm_out = extract_mm_output(engine_outputs)
 
     sample_rate = defs.resolve_audio_sample_rate(mm_out)
     # `stage_metrics.audio_generated_frames` is the legacy per-chunk
@@ -222,7 +176,7 @@ def observe_modality_at_finalize(
     # field lookup in place in case the accumulator gets re-wired upstream.
     n_frames = int(getattr(stage_metrics, "audio_generated_frames", 0) or 0)
     if n_frames == 0:
-        n_frames = _count_audio_frames(mm_out)
+        n_frames = count_audio_frames(mm_out)
     mod_metrics.inc_audio_frames(stage_label, replica_label, n_frames)
     duration_s = n_frames / sample_rate if sample_rate > 0 else 0.0
     if duration_s > 0:
diff --git a/vllm_omni/metrics/stats.py b/vllm_omni/metrics/stats.py
index a282d7d50..3d08adae0 100644
--- a/vllm_omni/metrics/stats.py
+++ b/vllm_omni/metrics/stats.py
@@ -381,6 +381,7 @@ class OrchestratorAggregator:
         finished: bool,
         final_output_type: str | None,
         output_to_yield: Any | None,
+        event_cursor: int = 0,
     ) -> None:
         """Process and record stage metrics.
 
@@ -409,7 +410,7 @@ class OrchestratorAggregator:
                 return
 
             rid_key = str(req_id)
-            stage_snapshot = self._build_stage_metrics_snapshot(rid_key)
+            stage_snapshot = self._build_stage_metrics_snapshot(rid_key, event_cursor=event_cursor)
 
             # 3. Not finished yet — expose incremental per-stage snapshot for streaming clients.
             if not finished:
@@ -423,7 +424,11 @@ class OrchestratorAggregator:
             # token fields only for text stages (OpenAI-style completion token accounting).
             output_to_yield.metrics = {"stage_metrics": stage_snapshot}
             stage_event = next(
-                (evt for evt in reversed(self.stage_events.get(rid_key, [])) if evt.stage_id == stage_id),
+                (
+                    evt
+                    for evt in reversed(self.stage_events.get(rid_key, [])[event_cursor:])
+                    if evt.stage_id == stage_id
+                ),
                 None,
             )
             if stage_event is not None and stage_event.final_output_type == "text":
@@ -541,10 +546,18 @@ class OrchestratorAggregator:
         current[defs.TIME_PER_OUTPUT_UNIT_MS] = remaining_ms / float(output_count - 1) if output_count > 1 else 0.0
         return current
 
-    def _build_stage_metrics_snapshot(self, req_id: str) -> dict[str, dict[str, Any]]:
+    def stage_event_cursor(self, req_id: str) -> int:
+        return len(self.stage_events.get(str(req_id), ()))
+
+    def _build_stage_metrics_snapshot(
+        self,
+        req_id: str,
+        *,
+        event_cursor: int = 0,
+    ) -> dict[str, dict[str, Any]]:
         """Aggregate per-stage metrics for ``req_id`` (string key), for streaming/benchmark clients."""
         snapshot: dict[str, dict[str, Any]] = {}
-        for evt in self.stage_events.get(req_id, []):
+        for evt in self.stage_events.get(req_id, [])[event_cursor:]:
             sid = int(evt.stage_id) if evt.stage_id is not None else -1
             if sid < 0:
                 continue
diff --git a/vllm_omni/metrics/utils.py b/vllm_omni/metrics/utils.py
index 2062eb5ba..ef8f69ed1 100644
--- a/vllm_omni/metrics/utils.py
+++ b/vllm_omni/metrics/utils.py
@@ -1,10 +1,217 @@
-from collections.abc import Callable
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import fields
 from typing import Any
 
 from prettytable import PrettyTable
 
 
+def coerce_positive_int_scalar(value: object) -> int | None:
+    """Coerce a value to a positive int without importing tensor libs.
+
+    Meant to pull positive integers such as sample rate out of the shapes
+    that show up across omni stage outputs / configs:
+
+    - plain ``int``: ``44100``
+    - ``torch.Tensor`` / numpy scalar: ``tensor(44100)`` (via ``.item()``)
+    - ``list`` / ``tuple`` wrap: ``[tensor(44100)]`` or ``[44100]``
+    - Mapping field values: ``{"sr": tensor(44100)}`` → coerce the field
+      value (key lookup is done by the caller, e.g.
+      :func:`resolve_int_by_sequential_keys`)
+
+    Returns ``None`` when the value is missing, unparsable, or not positive.
+    """
+    if value is None:
+        return None
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            coerced = coerce_positive_int_scalar(item)
+            if coerced is not None:
+                return coerced
+        return None
+    item = getattr(value, "item", None)
+    if callable(item):
+        try:
+            value = item()
+        except Exception:
+            return None
+    try:
+        value = int(value)
+    except (TypeError, ValueError):
+        return None
+    return value if value > 0 else None
+
+
+def resolve_int_by_sequential_keys(
+    source: Mapping[str, object] | object | None,
+    keys: Sequence[str],
+) -> int | None:
+    """Return the first positive int found by trying ``keys`` in order.
+
+    For each key, looks up ``source[key]`` when ``source`` is a Mapping, otherwise
+    ``getattr(source, key, None)``. Values are coerced via :func:`coerce_positive_int_scalar`.
+    Returns ``None`` when ``source`` is empty/missing or no key yields a usable int.
+    """
+    if not source:
+        return None
+    for key in keys:
+        raw = source.get(key) if isinstance(source, Mapping) else getattr(source, key, None)
+        value = coerce_positive_int_scalar(raw)
+        if value is not None:
+            return value
+    return None
+
+
+def extract_mm_output(mm_source: object) -> Mapping[str, Any]:
+    """Return the first non-empty multimodal_output Mapping on ``mm_source``.
+
+    Lookup order:
+      1. ``mm_source.multimodal_output`` — top-level attribute / property
+      2. ``mm_source.outputs[0].multimodal_output`` — CompletionOutput nesting
+         (typical AR audio path)
+
+    Accepts both plain ``dict`` and ``MultimodalPayload`` (a ``Mapping``).
+    Returns ``{}`` when neither location yields a non-empty Mapping.
+
+    Args:
+        mm_source: Duck-typed container with optional ``multimodal_output`` and/or
+            ``outputs`` (e.g. vLLM ``RequestOutput`` or ``OmniRequestOutput``).
+
+    Returns:
+        The first non-empty multimodal Mapping found, or an empty ``dict``.
+    """
+    mm = getattr(mm_source, "multimodal_output", None)
+    if isinstance(mm, Mapping) and mm:
+        return mm
+    outs = getattr(mm_source, "outputs", None)
+    if outs:
+        nested = getattr(outs[0], "multimodal_output", None)
+        if isinstance(nested, Mapping) and nested:
+            return nested
+    return {}
+
+
+def iter_mm_outputs(mm_source: object) -> list[Mapping[str, Any]]:
+    """Collect all non-empty multimodal_output Mappings from ``mm_source``.
+
+    Lookup order:
+      1. ``mm_source.multimodal_output`` — top-level attribute / property
+      2. each ``mm_source.outputs[i].multimodal_output`` — every CompletionOutput
+         entry that carries a non-empty multimodal Mapping
+
+    Accepts both plain ``dict`` and ``MultimodalPayload`` (a ``Mapping``).
+    Used by stage-pool metrics aggregation that needs to visit every mm payload.
+
+    Args:
+        mm_source: Duck-typed container with optional ``multimodal_output`` and/or
+            ``outputs`` (e.g. vLLM ``RequestOutput`` or ``OmniRequestOutput``).
+
+    Returns:
+        A list of non-empty multimodal Mappings in discovery order. Empty when
+        none are present.
+    """
+    multimodal_outputs: list[Mapping[str, Any]] = []
+    outer_mm = getattr(mm_source, "multimodal_output", None)
+    if isinstance(outer_mm, Mapping) and outer_mm:
+        multimodal_outputs.append(outer_mm)
+    for output in getattr(mm_source, "outputs", None) or []:
+        inner_mm = getattr(output, "multimodal_output", None)
+        if isinstance(inner_mm, Mapping) and inner_mm:
+            multimodal_outputs.append(inner_mm)
+    return multimodal_outputs
+
+
+def count_audio_chunk_frames(audio_chunk: object) -> int:
+    """Count frames (samples) in one audio tensor / chunk.
+
+    Audio chunks are concatenated on dim=-1 in the output processor, so the
+    frame/sample axis is the last dim (e.g. ``[channels, frames]``). Keep this
+    aligned with serving_chat.py: audio tensors are consumed as ``(T,)``,
+    ``(C, T)``, or ``(B, C, T)``. Flattening would corrupt multi-channel audio.
+
+    Args:
+        audio_chunk: A single audio tensor/array-like, or a scalar-like value.
+
+    Returns:
+        Frame count for this chunk. Uses ``shape[-1]`` when shaped; otherwise
+        ``len(...)``; scalars / unlenable values count as ``1``.
+    """
+    shape = getattr(audio_chunk, "shape", None)
+    if shape is not None and len(shape) > 0:
+        return int(shape[-1])
+    try:
+        return len(audio_chunk)  # type: ignore[arg-type]
+    except TypeError:
+        return 1
+
+
+def count_audio_frames(mm_out: Mapping[str, Any]) -> int:
+    """Sum frame counts over all audio chunks in ``mm_out["audio"]`` or with other related keys.
+
+    For multi-dim tensors (e.g. shape ``[channels, samples]``) the last axis is
+    the sample dim; for 1-D tensors the only axis is the sample dim; scalars
+    count as 1. Missing or empty ``audio`` yields ``0``.
+
+    Args:
+        mm_out: A multimodal_output Mapping (plain ``dict`` or
+            ``MultimodalPayload``) that may contain an ``audio`` or related key whose value
+            is one chunk or a list of chunks.
+
+    Returns:
+        Total audio frames (samples) across all chunks.
+    """
+    audio_chunks = None
+    if isinstance(mm_out, Mapping):
+        for key in ("audio", "model_outputs"):
+            audio_chunks = mm_out.get(key)
+            if audio_chunks is not None:
+                break
+    if audio_chunks is None:
+        return 0
+    chunks = audio_chunks if isinstance(audio_chunks, list) else [audio_chunks]
+    return sum(count_audio_chunk_frames(chunk) for chunk in chunks)
+
+
+def count_image_pixels(value: object) -> int:
+    """Count pixels in one image value, or sum over a nested list/tuple.
+
+    Accepts PIL-like objects (``size=(W, H)``), tensors / arrays with a
+    ``shape`` attribute, and nested ``list`` / ``tuple`` containers.
+
+    Shape heuristics (aligned with StagePool image metrics):
+
+    - ``ndim >= 4`` (e.g. ``BCHW``): ``B * H * W`` via
+      ``dims[0] * dims[-2] * dims[-1]``
+    - ``ndim == 3`` and ``dims[0] in (1, 3, 4)``: CHW → ``H * W``
+    - ``ndim == 3`` and ``dims[-1] in (1, 3, 4)``: HWC → ``H * W``
+    - otherwise: ``dims[-2] * dims[-1]``
+
+    Returns ``0`` when ``value`` is missing or cannot be interpreted.
+    """
+    if value is None:
+        return 0
+    if isinstance(value, (list, tuple)):
+        return sum(count_image_pixels(item) for item in value)
+
+    size = getattr(value, "size", None)
+    if isinstance(size, tuple) and len(size) >= 2:
+        try:
+            return int(size[0]) * int(size[1])
+        except (TypeError, ValueError):
+            return 0
+
+    shape = getattr(value, "shape", None)
+    if shape is None or len(shape) < 2:
+        return 0
+    dims = [int(dim) for dim in shape]
+    if len(dims) >= 4:
+        return dims[0] * dims[-2] * dims[-1]
+    if len(dims) == 3 and dims[0] in (1, 3, 4):
+        return dims[1] * dims[2]
+    if len(dims) == 3 and dims[-1] in (1, 3, 4):
+        return dims[0] * dims[1]
+    return dims[-2] * dims[-1]
+
+
 def _build_field_defs(
     cls: type,
     exclude: set[str],
diff --git a/vllm_omni/model_executor/models/audex/__init__.py b/vllm_omni/model_executor/models/audex/__init__.py
new file mode 100644
index 000000000..208f01a7c
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/vllm_omni/model_executor/models/audex/audex_code2wav.py b/vllm_omni/model_executor/models/audex/audex_code2wav.py
new file mode 100644
index 000000000..749830709
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/audex_code2wav.py
@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex code2wav: streaming speech-codec-token → waveform stage.
+
+Wraps the vendored Audex causal speech decoder (see ``speech_decoder/``).
+Unlike the flow/vocoder stages of other TTS models, the decoder is natively
+stateful and streaming: one ``AudexCausalSpeechDecoderSession`` per request
+holds the decode cache, each engine step pushes only the newly received codec
+frames, and the session's 4-frame lookahead tail is drained by ``flush()``
+when the request finishes. The stage therefore never re-decodes left context
+and always returns delta audio.
+"""
+
+from collections.abc import Iterable
+from typing import Any
+
+import torch
+from torch import nn
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+
+from vllm_omni.model_executor.models.audex.speech_decoder import (
+    AudexCausalSpeechDecoderConfig,
+    AudexCausalSpeechDecoderModel,
+    AudexCausalSpeechDecoderSession,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+logger = init_logger(__name__)
+
+# Frames per decoder emit. 5 frames = 100 ms at 50 fps — the granularity the
+# official streaming demo uses; small enough for a fast first audible chunk.
+_DEFAULT_EMIT_CHUNK_FRAMES = 5
+
+
+def _meta_int(value: Any, default: int = 0) -> int:
+    if isinstance(value, torch.Tensor):
+        return int(value.reshape(-1)[0].item()) if value.numel() else default
+    if isinstance(value, list | tuple):
+        return _meta_int(value[0], default) if value else default
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _meta_bool(value: Any) -> bool:
+    if isinstance(value, torch.Tensor):
+        return bool(value.reshape(-1)[0].item()) if value.numel() else False
+    if isinstance(value, list | tuple):
+        return _meta_bool(value[0]) if value else False
+    return bool(value)
+
+
+def _meta_str(value: Any) -> str | None:
+    if isinstance(value, list | tuple):
+        return _meta_str(value[0]) if value else None
+    if isinstance(value, str):
+        return value
+    return None
+
+
+def _codes_from_runtime_info(runtime_info: dict[str, Any] | None) -> list[int]:
+    """Extract this step's new codec frame ids from the connector payload."""
+    if not isinstance(runtime_info, dict):
+        return []
+    codes = runtime_info.get("codes")
+    if not isinstance(codes, dict):
+        return []
+    audio = codes.get("audio")
+    if isinstance(audio, torch.Tensor):
+        return audio.reshape(-1).tolist()
+    if isinstance(audio, list | tuple):
+        return [int(c) for c in audio]
+    return []
+
+
+class AudexCode2Wav(nn.Module):
+    """Stage-1 model for Audex TTS (GenerationModelRunner)."""
+
+    input_modalities = "audio"
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+        self.vllm_config = vllm_config
+        self.model_path = vllm_config.model_config.model
+
+        self.have_multimodal_outputs = True
+        self.has_preprocess = False
+        self.has_postprocess = False
+        self.enable_update_additional_information = True
+        self.requires_raw_input_tokens = True
+
+        # Build the decoder skeleton from config so vLLM's memory profiler
+        # sees it at startup; weights load later in load_weights().
+        config = AudexCausalSpeechDecoderConfig.from_pretrained(self.model_path)
+        self.decoder = AudexCausalSpeechDecoderModel(config)
+        self.decoder.eval()
+        self._sample_rate = int(config.sample_rate)
+
+        extra_cfg = self._connector_extra_config()
+        self._emit_chunk_frames = _meta_int(extra_cfg.get("decoder_emit_chunk_frames"), _DEFAULT_EMIT_CHUNK_FRAMES)
+        if self._emit_chunk_frames <= 0:
+            raise ValueError(f"decoder_emit_chunk_frames must be positive, got {self._emit_chunk_frames}")
+
+        # One streaming session per in-flight request, keyed by the request id
+        # carried in each chunk payload's meta (equal to the stage-1 engine
+        # request id, so on_requests_finished can free aborted requests too).
+        self._sessions: dict[str, AudexCausalSpeechDecoderSession] = {}
+
+    def _connector_extra_config(self) -> dict[str, Any]:
+        connector_cfg = getattr(self.vllm_config.model_config, "stage_connector_config", None)
+        if isinstance(connector_cfg, dict):
+            extra = connector_cfg.get("extra", connector_cfg)
+            return extra if isinstance(extra, dict) else {}
+        extra = getattr(connector_cfg, "extra", None)
+        return extra if isinstance(extra, dict) else {}
+
+    # -------------------- vLLM model interface --------------------
+
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        # This stage ignores token embeddings; keep a stable dummy for the runner.
+        if input_ids.numel() == 0:
+            return torch.empty((0, 1), device=input_ids.device, dtype=torch.float32)
+        return torch.zeros((input_ids.shape[0], 1), device=input_ids.device, dtype=torch.float32)
+
+    def compute_logits(self, hidden_states: torch.Tensor | OmniOutput, sampling_metadata: Any = None) -> None:
+        return None
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        state_dict = dict(weights)
+        self.decoder.load_state_dict(state_dict, strict=True)
+        device = self.vllm_config.device_config.device
+        self.decoder.to(device=device, dtype=torch.float32)
+        return {f"decoder.{name}" for name in state_dict}
+
+    def on_requests_finished(self, finished_req_ids: Iterable[str]) -> None:
+        """Free decoder sessions for finished/aborted requests."""
+        for req_id in finished_req_ids:
+            self._sessions.pop(req_id, None)
+
+    def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput | tuple, **kwargs: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+        # The runner may unpack the NamedTuple in transit; rebuild it.
+        if isinstance(model_outputs, tuple) and len(model_outputs) == len(OmniOutput._fields):
+            return OmniOutput(*model_outputs)
+        raise TypeError(f"AudexCode2Wav expected OmniOutput, got {type(model_outputs)}")
+
+    # -------------------- decoding --------------------
+
+    def _session_for(self, req_id: str) -> AudexCausalSpeechDecoderSession:
+        session = self._sessions.get(req_id)
+        if session is None:
+            session = self.decoder.create_session(
+                chunk_frames=self._emit_chunk_frames,
+                return_numpy=False,
+            )
+            self._sessions[req_id] = session
+        return session
+
+    def _decode_request(self, req_id: str, codes: list[int], finished: bool) -> torch.Tensor:
+        """Push new frames into the request's session; return this step's delta audio."""
+        if finished and not codes and req_id not in self._sessions:
+            # Zero codec tokens for the whole request. Do NOT raise: an
+            # exception in forward() kills the engine core for every request.
+            # Returning empty audio lets the serving layer fail this request.
+            logger.error("Audex code2wav: request %s finished with no codec tokens; no audio generated", req_id)
+            return torch.empty(0, dtype=torch.float32)
+        chunks: list[torch.Tensor] = []
+        session = self._session_for(req_id)
+        with torch.inference_mode():
+            if codes:
+                for _sr, chunk in session.push([[int(c)] for c in codes]):
+                    chunks.append(chunk.reshape(-1))
+            if finished:
+                for _sr, chunk in session.flush():
+                    chunks.append(chunk.reshape(-1))
+        if finished:
+            self._sessions.pop(req_id, None)
+        if not chunks:
+            return torch.empty(0, dtype=torch.float32)
+        return torch.cat(chunks).to(torch.float32)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        positions: torch.Tensor | None = None,
+        intermediate_tensors: Any = None,
+        inputs_embeds: torch.Tensor | None = None,
+        runtime_additional_information: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        runtime_infos = runtime_additional_information or []
+        # One output entry per scheduled request, even on steps where a
+        # request's chunk payload has not arrived yet.
+        seq_token_counts = kwargs.get("seq_token_counts")
+        if seq_token_counts is not None:
+            num_reqs = len(seq_token_counts)
+        elif input_ids is not None and input_ids.numel() > 0 and not runtime_infos:
+            num_reqs = 1
+        else:
+            num_reqs = len(runtime_infos)
+
+        audios: list[torch.Tensor] = []
+        sr_tensor = torch.tensor(self._sample_rate, dtype=torch.int32)
+        for i in range(num_reqs):
+            info = runtime_infos[i] if i < len(runtime_infos) else {}
+            info = info if isinstance(info, dict) else {}
+            meta = info.get("meta", {})
+            meta = meta if isinstance(meta, dict) else {}
+            req_id = _meta_str(meta.get("req_id"))
+            # async_chunk delivers ``stream_finished`` (the adapter strips
+            # ``finished``); the sync full-payload path delivers ``finished``.
+            finished = _meta_bool(meta.get("stream_finished")) or _meta_bool(meta.get("finished"))
+            codes = _codes_from_runtime_info(info)
+            if req_id is None:
+                if codes:
+                    raise ValueError("Audex code2wav chunk payload is missing meta.req_id")
+                audios.append(torch.empty(0, dtype=torch.float32))
+                continue
+            audios.append(self._decode_request(req_id, codes, finished))
+
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={"model_outputs": audios, "sr": [sr_tensor] * num_reqs},
+        )
diff --git a/vllm_omni/model_executor/models/audex/audex_omni.py b/vllm_omni/model_executor/models/audex/audex_omni.py
new file mode 100644
index 000000000..6795a4341
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/audex_omni.py
@@ -0,0 +1,322 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+#
+# Adapted from nvidia/Nemotron-Labs-Audex-2B (Apache-2.0):
+#   inference_scripts_vllm/audioqa_scripts/audex_2b_vllm/modeling_audex_vllm.py
+#   inference_scripts_vllm/audioqa_scripts/audex_2b_vllm/audio_encoder.py
+"""Audex audio-understanding model (``checkpoint_folder_full``): S2T / audio QA.
+
+Mirrors the Qwen2-Audio pattern with the 2B dense backbone:
+  * ``language_model``  = the vllm-omni ``NemotronDenseForCausalLM`` port
+    (wrapped via ``init_vllm_registered_model``; resolved through the omni
+    model registry).
+  * ``audio_tower``     = transformers ``Qwen2AudioEncoder`` ("NV-Whisper");
+    a parameter-free avg pool maps 1500 → 750 frames per padded 30 s clip.
+  * ``audio_projector`` = RMSNorm → fc1 → relu² → fc2 (no bias), matching the
+    release ``NemotronHAudexProjector``.
+
+``embed_multimodal(...)`` runs encoder+projector and returns one embedding
+tensor per audio item; vLLM's ``SupportsMultiModal.embed_input_ids`` merges
+them into the ``<so_embedding>`` placeholder positions. The encoder runs in
+microbatches over clips so peak memory is bounded regardless of audio length
+(up to the 900 s / 30-clip cap enforced by the processor).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Annotated, Literal
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from vllm.config import VllmConfig
+from vllm.model_executor.models.interfaces import (
+    HasInnerState,
+    IsHybrid,
+    MultiModalEmbeddings,
+    SupportsMambaPrefixCaching,
+    SupportsMultiModal,
+    SupportsPP,
+)
+from vllm.model_executor.models.utils import (
+    init_vllm_registered_model,
+    maybe_prefix,
+)
+from vllm.multimodal import MULTIMODAL_REGISTRY
+from vllm.sequence import IntermediateTensors
+from vllm.utils.tensor_schema import TensorSchema, TensorShape
+
+from vllm_omni.model_executor.models.audex.audex_omni_processing import (
+    AUDIO_ENCODER_MICRO_BATCH,
+    SOUND_TOKEN,
+    AudexDummyInputsBuilder,
+    AudexMultiModalProcessor,
+    AudexProcessingInfo,
+)
+
+
+class AudexProjector(nn.Module):
+    """Megatron sound_projection equivalent (matches HF NemotronHAudexProjector)."""
+
+    def __init__(
+        self,
+        audio_encoder_hidden_size: int,
+        intermediate_size: int,
+        text_hidden_size: int,
+        activation: str = "relu2",
+        norm_eps: float = 1e-5,
+    ) -> None:
+        super().__init__()
+        self.norm_weight = nn.Parameter(torch.ones(audio_encoder_hidden_size))
+        self.norm_eps = norm_eps
+        self.fc1 = nn.Linear(audio_encoder_hidden_size, intermediate_size, bias=False)
+        self.fc2 = nn.Linear(intermediate_size, text_hidden_size, bias=False)
+        self.activation = activation
+
+    def _rms_norm(self, x: torch.Tensor) -> torch.Tensor:
+        dtype = x.dtype
+        x = x.float()
+        variance = x.pow(2).mean(dim=-1, keepdim=True)
+        x = x * torch.rsqrt(variance + self.norm_eps)
+        return (self.norm_weight.float() * x).to(dtype)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self._rms_norm(hidden_states)
+        hidden_states = self.fc1(hidden_states)
+        if self.activation == "relu2":
+            hidden_states = F.relu(hidden_states).pow(2)
+        elif self.activation == "gelu":
+            hidden_states = F.gelu(hidden_states)
+        else:
+            raise ValueError(f"Unsupported audio projector activation: {self.activation}")
+        return self.fc2(hidden_states)
+
+
+def _build_qwen2_audio_encoder(audio_config: dict) -> nn.Module:
+    from transformers.models.qwen2_audio.configuration_qwen2_audio import (
+        Qwen2AudioEncoderConfig,
+    )
+    from transformers.models.qwen2_audio.modeling_qwen2_audio import Qwen2AudioEncoder
+
+    cfg = Qwen2AudioEncoderConfig(**dict(audio_config))
+    return Qwen2AudioEncoder(cfg)
+
+
+class AudexAudioFeatureInputs(TensorSchema):
+    """
+    Dimensions:
+        - c: total number of 30s clips (flattened across audio items)
+        - b: number of audio items
+    """
+
+    type: Literal["audio_features"] = "audio_features"
+    input_features: Annotated[torch.Tensor, TensorShape("c", 128, 3000)]
+    audio_num_clips: Annotated[list[int], None] = None
+
+
+@MULTIMODAL_REGISTRY.register_processor(
+    AudexMultiModalProcessor,
+    info=AudexProcessingInfo,
+    dummy_inputs=AudexDummyInputsBuilder,
+)
+class NemotronDenseAudexForConditionalGeneration(
+    nn.Module,
+    SupportsMultiModal,
+    SupportsPP,
+):
+    _LM_ARCHITECTURE = "NemotronDenseForCausalLM"
+
+    @classmethod
+    def get_placeholder_str(cls, modality: str, i: int) -> str | None:
+        if modality.startswith("audio"):
+            return SOUND_TOKEN
+        raise ValueError(f"Only audio modality is supported, got {modality}")
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__()
+        config = vllm_config.model_config.hf_config
+        self.config = config
+
+        with self._mark_language_model(vllm_config):
+            self.language_model = init_vllm_registered_model(
+                vllm_config=vllm_config,
+                hf_config=config,
+                prefix=maybe_prefix(prefix, "language_model"),
+                architectures=[self._LM_ARCHITECTURE],
+            )
+        llm_dtype = self.language_model.config.dtype
+        assert isinstance(llm_dtype, torch.dtype)
+        self.llm_dtype = llm_dtype
+
+        with self._mark_tower_model(vllm_config, "audio"):
+            self.audio_tower = _build_qwen2_audio_encoder(config.audio_config).to(llm_dtype)
+            self.audio_projector = AudexProjector(
+                audio_encoder_hidden_size=config.audio_encoder_hidden_size,
+                intermediate_size=config.audio_projector_intermediate_size,
+                text_hidden_size=config.hidden_size,
+                activation=config.audio_projector_activation,
+                norm_eps=config.audio_projector_norm_eps,
+            ).to(llm_dtype)
+
+        self.make_empty_intermediate_tensors = self.language_model.make_empty_intermediate_tensors
+
+    def get_language_model(self) -> nn.Module:
+        return self.language_model
+
+    def _parse_and_validate_audio_input(self, **kwargs: object):
+        input_features = kwargs.pop("input_features", None)
+        audio_num_clips = kwargs.pop("audio_num_clips", None)
+        if input_features is None:
+            return None
+        return AudexAudioFeatureInputs(
+            type="audio_features",
+            input_features=input_features,
+            audio_num_clips=audio_num_clips,
+            validate=False,
+        )
+
+    @torch.inference_mode()
+    def _encode_clips(self, input_features: torch.Tensor) -> torch.Tensor:
+        """(C, 128, 3000) -> (C, 750, hidden) via microbatched encoder+projector."""
+        param = next(self.audio_tower.parameters())
+        input_features = input_features.to(device=param.device, dtype=param.dtype)
+        out_chunks = []
+        for start in range(0, input_features.shape[0], AUDIO_ENCODER_MICRO_BATCH):
+            chunk = input_features[start : start + AUDIO_ENCODER_MICRO_BATCH]
+            hidden = self.audio_tower(input_features=chunk, return_dict=True).last_hidden_state
+            out_chunks.append(self.audio_projector(hidden))
+        return torch.cat(out_chunks, dim=0)
+
+    def _process_audio_input(self, audio_input) -> tuple[torch.Tensor, ...]:
+        input_features = audio_input["input_features"]
+        audio_num_clips = audio_input["audio_num_clips"]
+        if input_features.ndim == 4:
+            input_features = input_features.flatten(0, 1)
+
+        projected = self._encode_clips(input_features)
+        per_clip = projected.reshape(projected.shape[0], -1, projected.shape[-1])
+
+        if audio_num_clips is None:
+            num_clips_list = [projected.shape[0]]
+        elif isinstance(audio_num_clips, torch.Tensor):
+            num_clips_list = audio_num_clips.flatten().tolist()
+        else:
+            num_clips_list = [int(x) for x in audio_num_clips]
+
+        grouped: list[torch.Tensor] = []
+        offset = 0
+        for n in num_clips_list:
+            clips = per_clip[offset : offset + n]
+            grouped.append(clips.reshape(-1, clips.shape[-1]))
+            offset += n
+        return tuple(grouped)
+
+    def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:
+        audio_input = self._parse_and_validate_audio_input(**kwargs)
+        if audio_input is None:
+            return []
+        return self._process_audio_input(audio_input)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **kwargs: object,
+    ) -> torch.Tensor | IntermediateTensors:
+        if intermediate_tensors is not None:
+            inputs_embeds = None
+        return self.language_model.model(input_ids, positions, intermediate_tensors, inputs_embeds=inputs_embeds)
+
+    def compute_logits(self, hidden_states: torch.Tensor, sampling_metadata=None) -> torch.Tensor | None:
+        return self.language_model.compute_logits(hidden_states)
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        """Split the combined weight stream into LLM / audio_tower / projector.
+
+        vLLM streams *all* ``.safetensors`` in the model dir; route
+        ``audio_encoder.*``/``audio_projector.*`` to the audio modules and
+        leave the remaining ``model.*``/``lm_head.*`` names untouched so the
+        wrapped NemotronDenseForCausalLM loader applies its own qkv fusion
+        and remapping.
+        """
+        loaded: set[str] = set()
+        lm_weights: list[tuple[str, torch.Tensor]] = []
+        enc_sd: dict[str, torch.Tensor] = {}
+        proj_map: dict[str, torch.Tensor] = {}
+
+        for name, w in weights:
+            if name.startswith("audio_encoder."):
+                enc_sd[name[len("audio_encoder.") :]] = w
+            elif name == "audio_projector.norm.weight":
+                proj_map["norm_weight"] = w
+            elif name.startswith("audio_projector."):
+                proj_map[name[len("audio_projector.") :]] = w
+            else:
+                lm_weights.append((name, w))
+
+        lm_loaded = self.language_model.load_weights(lm_weights)
+        loaded |= {f"language_model.{n}" for n in lm_loaded}
+
+        if not enc_sd:
+            raise ValueError("No audio_encoder.* weights found in checkpoint stream.")
+        missing, unexpected = self.audio_tower.load_state_dict(enc_sd, strict=False)
+        if missing:
+            raise ValueError(f"Missing audio_tower params: {list(missing)[:8]}")
+        if unexpected:
+            raise ValueError(f"Unexpected audio_tower keys: {list(unexpected)[:8]}")
+        loaded |= {f"audio_tower.{k}" for k in enc_sd}
+
+        if set(proj_map) != {"norm_weight", "fc1.weight", "fc2.weight"}:
+            raise ValueError(f"Unexpected audio_projector keys: {sorted(proj_map)}")
+        self.audio_projector.load_state_dict(proj_map, strict=True)
+        loaded |= {f"audio_projector.{k}" for k in proj_map}
+
+        return loaded
+
+
+@MULTIMODAL_REGISTRY.register_processor(
+    AudexMultiModalProcessor,
+    info=AudexProcessingInfo,
+    dummy_inputs=AudexDummyInputsBuilder,
+)
+class NemotronHAudexForConditionalGeneration(
+    NemotronDenseAudexForConditionalGeneration,
+    IsHybrid,
+    HasInnerState,
+    SupportsMambaPrefixCaching,
+):
+    """Audex 30B-A3B audio-understanding model (``checkpoint_folder_full``).
+
+    Mirrors nvidia/Nemotron-Labs-Audex-30B-A3B's
+    ``inference_scripts_vllm/audioqa_scripts/audex_30b_a3b_vllm/modeling_audex_vllm.py``:
+    the same encoder/projector/processing as the dense 2B wrapper around
+    vLLM's native hybrid Mamba+MoE ``NemotronHForCausalLM``, whose state
+    hooks are delegated below.
+    """
+
+    _LM_ARCHITECTURE = "NemotronHForCausalLM"
+
+    is_hybrid = True
+    has_inner_state = True
+    supports_mamba_prefix_caching = True
+
+    @classmethod
+    def get_mamba_state_shape_from_config(cls, vllm_config):
+        from vllm.model_executor.models.nemotron_h import NemotronHForCausalLM
+
+        return NemotronHForCausalLM.get_mamba_state_shape_from_config(vllm_config)
+
+    @classmethod
+    def get_mamba_state_dtype_from_config(cls, vllm_config):
+        from vllm.model_executor.models.nemotron_h import NemotronHForCausalLM
+
+        return NemotronHForCausalLM.get_mamba_state_dtype_from_config(vllm_config)
+
+    @classmethod
+    def get_mamba_state_copy_func(cls):
+        from vllm.model_executor.models.nemotron_h import NemotronHForCausalLM
+
+        return NemotronHForCausalLM.get_mamba_state_copy_func()
diff --git a/vllm_omni/model_executor/models/audex/audex_omni_processing.py b/vllm_omni/model_executor/models/audex/audex_omni_processing.py
new file mode 100644
index 000000000..5e4c53908
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/audex_omni_processing.py
@@ -0,0 +1,260 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+#
+# Adapted from nvidia/Nemotron-Labs-Audex-2B (Apache-2.0):
+#   inference_scripts_vllm/audioqa_scripts/audex_2b_vllm/audio_features.py
+#   inference_scripts_vllm/audioqa_scripts/audex_2b_vllm/processing_audex_vllm.py
+"""Multimodal processing for Audex audio understanding (S2T / audio QA).
+
+No unified HF ``ProcessorMixin`` exists for Audex (only a
+``WhisperFeatureExtractor`` under ``audio_preprocessor/``), so
+``_call_hf_processor`` is fully overridden: it tokenizes the prompt and
+builds NV-Whisper features with 30 s non-overlapping windows (last clip
+zero-padded), exactly mirroring the release HF path.
+
+Placeholder expansion uses vLLM's ``PromptReplacement``: a single
+``<so_embedding>`` per audio expands to ``<so_start>`` + N*``<so_embedding>``
++ ``<so_end>`` where N = num_clips * 750.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import BatchFeature
+from vllm.config.multimodal import BaseDummyOptions
+from vllm.inputs import MultiModalDataDict
+from vllm.multimodal.inputs import MultiModalFieldConfig, MultiModalKwargsItems
+from vllm.multimodal.parse import MultiModalDataItems, MultiModalDataParser
+from vllm.multimodal.processing import (
+    BaseDummyInputsBuilder,
+    BaseMultiModalProcessor,
+    BaseProcessingInfo,
+    PromptReplacement,
+    PromptUpdate,
+    PromptUpdateDetails,
+)
+
+SOUND_TOKEN = "<so_embedding>"
+SOUND_START_TOKEN = "<so_start>"
+SOUND_END_TOKEN = "<so_end>"
+
+SOUND_EMBEDDING_SIZE = 750
+SOUND_CLIP_DURATION = 30.0
+SOUND_TARGET_RATE = 16000
+
+MAX_AUDIO_SECONDS = 900
+MAX_AUDIO_CLIPS = 30
+MAX_AUDIO_TOKENS = MAX_AUDIO_CLIPS * SOUND_EMBEDDING_SIZE
+
+AUDIO_ENCODER_MICRO_BATCH = 8
+
+
+# ---------------------------------------------------------------- features
+
+
+def normalize_audio(audio: np.ndarray) -> np.ndarray:
+    """Return mono float32 audio in [-1, 1], matching the Megatron/HF path."""
+    audio = np.asarray(audio)
+    if audio.ndim == 2:
+        if audio.shape[1] <= 2:
+            audio = audio.mean(axis=1)
+        elif audio.shape[0] <= 2:
+            audio = audio.mean(axis=0)
+        else:
+            raise ValueError(f"Unsupported audio shape: {audio.shape}")
+
+    if audio.dtype == np.int16:
+        audio = audio.astype(np.float32) / 32768.0
+    elif audio.dtype != np.float32:
+        audio = audio.astype(np.float32)
+
+    max_abs = float(np.abs(audio).max()) if audio.size else 0.0
+    if max_abs > 1.0:
+        audio = audio / max_abs
+    return audio.astype(np.float32, copy=False)
+
+
+def split_audio_into_clips(
+    audio: np.ndarray,
+    sample_rate: int = SOUND_TARGET_RATE,
+    clip_duration: float = SOUND_CLIP_DURATION,
+) -> list[np.ndarray]:
+    """Split audio into fixed clips; pad the final clip to full length."""
+    audio = normalize_audio(audio)
+    clip_samples = int(round(sample_rate * clip_duration))
+    if clip_samples <= 0:
+        raise ValueError(f"Invalid clip_samples: {clip_samples}")
+    if audio.size == 0:
+        audio = np.zeros(1, dtype=np.float32)
+
+    num_clips = max(1, math.ceil(audio.shape[0] / clip_samples))
+    clips: list[np.ndarray] = []
+    for idx in range(num_clips):
+        start = idx * clip_samples
+        clip = audio[start : start + clip_samples]
+        if clip.shape[0] < clip_samples:
+            clip = np.pad(clip, (0, clip_samples - clip.shape[0]))
+        clips.append(clip.astype(np.float32, copy=False))
+    return clips
+
+
+def extract_whisper_features(
+    feature_extractor,
+    audio: np.ndarray,
+    sample_rate: int = SOUND_TARGET_RATE,
+    clip_duration: float = SOUND_CLIP_DURATION,
+) -> torch.Tensor:
+    """Return NV-Whisper input features shaped (num_clips, 128, 3000)."""
+    clips = split_audio_into_clips(audio, sample_rate=sample_rate, clip_duration=clip_duration)
+    features = feature_extractor(
+        clips,
+        sampling_rate=sample_rate,
+        return_tensors="pt",
+        padding="max_length",
+        return_attention_mask=False,
+    )
+    input_features = features.input_features
+    if input_features.ndim != 3:
+        raise ValueError(f"Expected 3D Whisper features, got {tuple(input_features.shape)}")
+    return input_features
+
+
+# ---------------------------------------------------------------- processor
+
+
+class AudexProcessingInfo(BaseProcessingInfo):
+    def get_hf_config(self):
+        return self.ctx.model_config.hf_config
+
+    def get_feature_extractor(self, **kwargs: object):
+        from transformers import AutoFeatureExtractor
+
+        config = self.get_hf_config()
+        path = getattr(config, "audio_preprocessor_path", None) or "audio_preprocessor"
+        candidate = Path(path)
+        if not candidate.is_absolute():
+            candidate = Path(self.ctx.model_config.model) / candidate
+        return AutoFeatureExtractor.from_pretrained(str(candidate))
+
+    def get_data_parser(self):
+        return MultiModalDataParser(target_sr=SOUND_TARGET_RATE, target_channels=1)
+
+    def get_supported_mm_limits(self) -> Mapping[str, int | None]:
+        return {"audio": 1}
+
+    def get_mm_max_tokens_per_item(self, seq_len: int, mm_counts: Mapping[str, int] | None = None) -> Mapping[str, int]:
+        return {"audio": MAX_AUDIO_TOKENS}
+
+    def sound_token_ids(self) -> tuple[int, int, int]:
+        cfg = self.get_hf_config()
+        return (
+            int(cfg.sound_start_token_id),
+            int(cfg.sound_token_id),
+            int(cfg.sound_end_token_id),
+        )
+
+
+class AudexDummyInputsBuilder(BaseDummyInputsBuilder[AudexProcessingInfo]):
+    def get_dummy_text(self, mm_counts: Mapping[str, int]) -> str:
+        return SOUND_TOKEN * mm_counts.get("audio", 0)
+
+    def get_dummy_mm_data(
+        self,
+        seq_len: int,
+        mm_counts: Mapping[str, int],
+        mm_options: Mapping[str, BaseDummyOptions] | None = None,
+    ) -> MultiModalDataDict:
+        num_audios = mm_counts.get("audio", 0)
+        audio_len = int(SOUND_CLIP_DURATION * SOUND_TARGET_RATE)
+        overrides = mm_options.get("audio") if mm_options else None
+        return {"audio": self._get_dummy_audios(length=audio_len, num_audios=num_audios, overrides=overrides)}
+
+
+class AudexMultiModalProcessor(BaseMultiModalProcessor[AudexProcessingInfo]):
+    def _call_hf_processor(
+        self,
+        prompt: str,
+        mm_data: Mapping[str, object],
+        mm_kwargs: Mapping[str, Any],
+        tok_kwargs: Mapping[str, object],
+    ) -> BatchFeature:
+        tokenizer = self.info.get_tokenizer()
+        prompt_ids = tokenizer(prompt, add_special_tokens=False).input_ids
+
+        audios = mm_data.get("audios", []) or mm_data.get("audio", [])
+        if not audios:
+            return BatchFeature(dict(input_ids=[prompt_ids]), tensor_type="pt")
+
+        feature_extractor = self.info.get_feature_extractor()
+        all_features: list[torch.Tensor] = []
+        audio_num_clips: list[int] = []
+        for item in audios:
+            audio = item[0] if isinstance(item, tuple) else item
+            audio = normalize_audio(np.asarray(audio))
+            duration = len(audio) / SOUND_TARGET_RATE
+            if duration > MAX_AUDIO_SECONDS:
+                raise ValueError(f"Audio duration {duration:.1f}s exceeds MAX_AUDIO_SECONDS={MAX_AUDIO_SECONDS}s.")
+            clips = split_audio_into_clips(audio, sample_rate=SOUND_TARGET_RATE, clip_duration=SOUND_CLIP_DURATION)
+            if len(clips) > MAX_AUDIO_CLIPS:
+                raise ValueError(f"Audio needs {len(clips)} clips > MAX_AUDIO_CLIPS={MAX_AUDIO_CLIPS}.")
+            feats = extract_whisper_features(
+                feature_extractor,
+                audio,
+                sample_rate=SOUND_TARGET_RATE,
+                clip_duration=SOUND_CLIP_DURATION,
+            )
+            all_features.append(feats)
+            audio_num_clips.append(feats.shape[0])
+
+        input_features = torch.cat(all_features, dim=0)
+        return BatchFeature(
+            dict(
+                input_ids=[prompt_ids],
+                input_features=input_features,
+                audio_num_clips=torch.tensor(audio_num_clips, dtype=torch.long),
+            ),
+            tensor_type="pt",
+        )
+
+    def _get_mm_fields_config(
+        self,
+        hf_inputs: BatchFeature,
+        hf_processor_mm_kwargs: Mapping[str, object],
+    ) -> Mapping[str, MultiModalFieldConfig]:
+        audio_num_clips = hf_inputs.get("audio_num_clips", torch.zeros(0, dtype=torch.long))
+        return dict(
+            input_features=MultiModalFieldConfig.flat_from_sizes("audio", audio_num_clips),
+            audio_num_clips=MultiModalFieldConfig.batched("audio"),
+        )
+
+    def _get_prompt_updates(
+        self,
+        mm_items: MultiModalDataItems,
+        hf_processor_mm_kwargs: Mapping[str, Any],
+        out_mm_kwargs: MultiModalKwargsItems,
+    ) -> Sequence[PromptUpdate]:
+        so_start, so_embed, so_end = self.info.sound_token_ids()
+        out_mm_data = out_mm_kwargs.get_data()
+        num_clips = out_mm_data.get("audio_num_clips", torch.zeros(0, dtype=torch.long))
+        num_clips_list = num_clips.flatten().tolist() if hasattr(num_clips, "flatten") else list(num_clips)
+
+        def get_replacement_audex(item_idx: int):
+            n = int(num_clips_list[item_idx]) * SOUND_EMBEDDING_SIZE
+            if n < 1:
+                raise ValueError(f"Audio item {item_idx} produced 0 embeddings.")
+            full = [so_start] + [so_embed] * n + [so_end]
+            return PromptUpdateDetails.select_token_id(full, so_embed)
+
+        return [
+            PromptReplacement(
+                modality="audio",
+                target=[so_embed],
+                replacement=get_replacement_audex,
+            )
+        ]
diff --git a/vllm_omni/model_executor/models/audex/audex_thinker.py b/vllm_omni/model_executor/models/audex/audex_thinker.py
new file mode 100644
index 000000000..c336786bb
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/audex_thinker.py
@@ -0,0 +1,414 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# Adapted from the NemotronDense vLLM plugin bundled with
+# nvidia/Nemotron-Labs-Audex-2B (nemotron_dense_vllm_plugin), which is not
+# installed as a package; the model code is carried here instead.
+"""Audex thinker: the Nemotron dense decoder-only LM that autoregressively
+emits ``<speechcodec_N>`` tokens for TTS.
+
+The thinker is a plain token-in/token-out vLLM model. Speech-codec token
+extraction happens in the stage input processors
+(``vllm_omni/model_executor/stage_input_processors/audex.py``), which read the
+sampled token stream directly, so no omni-specific output plumbing is needed
+here.
+"""
+
+from collections.abc import Iterable
+from itertools import islice
+from typing import Any
+
+import torch
+from torch import nn
+from vllm.compilation.decorators import support_torch_compile
+from vllm.config import CacheConfig, VllmConfig
+from vllm.distributed import get_pp_group, get_tensor_model_parallel_world_size
+from vllm.model_executor.layers.activation import get_act_fn
+from vllm.model_executor.layers.attention import Attention
+from vllm.model_executor.layers.linear import (
+    ColumnParallelLinear,
+    QKVParallelLinear,
+    RowParallelLinear,
+)
+from vllm.model_executor.layers.logits_processor import LogitsProcessor
+from vllm.model_executor.layers.quantization import QuantizationConfig
+from vllm.model_executor.layers.rotary_embedding import get_rope
+from vllm.model_executor.layers.vocab_parallel_embedding import (
+    ParallelLMHead,
+    VocabParallelEmbedding,
+)
+from vllm.model_executor.model_loader.weight_utils import (
+    default_weight_loader,
+    maybe_remap_kv_scale_name,
+)
+from vllm.model_executor.models.interfaces import SupportsLoRA, SupportsPP
+from vllm.model_executor.models.utils import (
+    AutoWeightsLoader,
+    PPMissingLayer,
+    is_pp_missing_parameter,
+    make_empty_intermediate_tensors_factory,
+    make_layers,
+    maybe_prefix,
+)
+from vllm.sequence import IntermediateTensors
+
+
+class NemotronDenseRMSNorm(nn.Module):
+    def __init__(self, hidden_size: int, eps: float = 1e-5):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+
+class NemotronDenseMLP(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        intermediate_size: int,
+        hidden_act: str,
+        quant_config: QuantizationConfig | None = None,
+        bias: bool = False,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.up_proj = ColumnParallelLinear(
+            input_size=hidden_size,
+            output_size=intermediate_size,
+            bias=bias,
+            quant_config=quant_config,
+            prefix=f"{prefix}.up_proj",
+        )
+        self.down_proj = RowParallelLinear(
+            input_size=intermediate_size,
+            output_size=hidden_size,
+            bias=bias,
+            quant_config=quant_config,
+            prefix=f"{prefix}.down_proj",
+        )
+        self.act_fn = get_act_fn(hidden_act)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        up, _ = self.up_proj(x)
+        x = self.act_fn(up)
+        x, _ = self.down_proj(x)
+        return x
+
+
+class NemotronDenseAttention(nn.Module):
+    def __init__(
+        self,
+        config: Any,
+        hidden_size: int,
+        num_heads: int,
+        num_kv_heads: int,
+        max_position_embeddings: int = 8192,
+        quant_config: QuantizationConfig | None = None,
+        bias: bool = False,
+        cache_config: CacheConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.hidden_size = hidden_size
+        tp_size = get_tensor_model_parallel_world_size()
+        self.total_num_heads = num_heads
+        assert self.total_num_heads % tp_size == 0
+        self.num_heads = self.total_num_heads // tp_size
+        self.total_num_kv_heads = num_kv_heads
+        if self.total_num_kv_heads >= tp_size:
+            assert self.total_num_kv_heads % tp_size == 0
+        else:
+            assert tp_size % self.total_num_kv_heads == 0
+        self.num_kv_heads = max(1, self.total_num_kv_heads // tp_size)
+        self.head_dim = getattr(config, "head_dim", None)
+        if self.head_dim is None:
+            self.head_dim = self.hidden_size // self.total_num_heads
+        self.q_size = self.num_heads * self.head_dim
+        self.kv_size = self.num_kv_heads * self.head_dim
+        self.scaling = self.head_dim**-0.5
+        self.max_position_embeddings = max_position_embeddings
+
+        self.qkv_proj = QKVParallelLinear(
+            hidden_size=hidden_size,
+            head_size=self.head_dim,
+            total_num_heads=self.total_num_heads,
+            total_num_kv_heads=self.total_num_kv_heads,
+            bias=bias,
+            quant_config=quant_config,
+            prefix=f"{prefix}.qkv_proj",
+        )
+        self.o_proj = RowParallelLinear(
+            input_size=self.total_num_heads * self.head_dim,
+            output_size=hidden_size,
+            bias=bias,
+            quant_config=quant_config,
+            prefix=f"{prefix}.o_proj",
+        )
+
+        self.rotary_emb = get_rope(
+            self.head_dim,
+            max_position=max_position_embeddings,
+            rope_parameters=config.rope_parameters,
+        )
+        self.attn = Attention(
+            self.num_heads,
+            self.head_dim,
+            self.scaling,
+            num_kv_heads=self.num_kv_heads,
+            cache_config=cache_config,
+            quant_config=quant_config,
+            prefix=f"{prefix}.attn",
+        )
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+    ) -> torch.Tensor:
+        qkv, _ = self.qkv_proj(hidden_states)
+        q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
+        q, k = self.rotary_emb(positions, q, k)
+        attn_output = self.attn(q, k, v)
+        output, _ = self.o_proj(attn_output)
+        return output
+
+
+class NemotronDenseDecoderLayer(nn.Module):
+    def __init__(
+        self,
+        config: Any,
+        cache_config: CacheConfig | None = None,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        max_position_embeddings = getattr(config, "max_position_embeddings", 8192)
+        attention_bias = getattr(config, "attention_bias", False) or getattr(config, "bias", False)
+        self.self_attn = NemotronDenseAttention(
+            config=config,
+            hidden_size=self.hidden_size,
+            num_heads=config.num_attention_heads,
+            num_kv_heads=getattr(config, "num_key_value_heads", config.num_attention_heads),
+            max_position_embeddings=max_position_embeddings,
+            quant_config=quant_config,
+            bias=attention_bias,
+            cache_config=cache_config,
+            prefix=f"{prefix}.self_attn",
+        )
+        self.mlp = NemotronDenseMLP(
+            hidden_size=self.hidden_size,
+            intermediate_size=config.intermediate_size,
+            hidden_act=config.hidden_act,
+            quant_config=quant_config,
+            bias=getattr(config, "mlp_bias", False),
+            prefix=f"{prefix}.mlp",
+        )
+        self.input_layernorm = NemotronDenseRMSNorm(config.hidden_size, eps=config.norm_eps)
+        self.post_attention_layernorm = NemotronDenseRMSNorm(config.hidden_size, eps=config.norm_eps)
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        hidden_states = self.self_attn(positions=positions, hidden_states=hidden_states)
+        hidden_states = residual + hidden_states
+
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+        return hidden_states
+
+
+@support_torch_compile
+class NemotronDenseModel(nn.Module):
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+
+        config = vllm_config.model_config.hf_config
+        cache_config = vllm_config.cache_config
+        quant_config = vllm_config.quant_config
+
+        self.config = config
+        self.quant_config = quant_config
+
+        self.vocab_size = config.vocab_size
+
+        if get_pp_group().is_first_rank or (config.tie_word_embeddings and get_pp_group().is_last_rank):
+            self.embed_tokens = VocabParallelEmbedding(
+                self.vocab_size,
+                config.hidden_size,
+            )
+        else:
+            self.embed_tokens = PPMissingLayer()
+        self.start_layer, self.end_layer, self.layers = make_layers(
+            config.num_hidden_layers,
+            lambda prefix: NemotronDenseDecoderLayer(
+                config=config,
+                cache_config=cache_config,
+                quant_config=quant_config,
+                prefix=prefix,
+            ),
+            prefix=f"{prefix}.layers",
+        )
+        if get_pp_group().is_last_rank:
+            self.norm = NemotronDenseRMSNorm(config.hidden_size, eps=config.norm_eps)
+        else:
+            self.norm = PPMissingLayer()
+
+        self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(
+            ["hidden_states"], config.hidden_size
+        )
+
+    def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        return self.embed_tokens(input_ids)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None,
+        inputs_embeds: torch.Tensor | None = None,
+    ) -> torch.Tensor | IntermediateTensors:
+        if get_pp_group().is_first_rank:
+            if inputs_embeds is not None:
+                hidden_states = inputs_embeds
+            else:
+                hidden_states = self.embed_input_ids(input_ids)
+        else:
+            assert intermediate_tensors is not None
+            hidden_states = intermediate_tensors["hidden_states"]
+
+        for layer in islice(self.layers, self.start_layer, self.end_layer):
+            hidden_states = layer(positions, hidden_states)
+
+        if not get_pp_group().is_last_rank:
+            return IntermediateTensors({"hidden_states": hidden_states})
+
+        hidden_states = self.norm(hidden_states)
+        return hidden_states
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        stacked_params_mapping = [
+            (".qkv_proj", ".q_proj", "q"),
+            (".qkv_proj", ".k_proj", "k"),
+            (".qkv_proj", ".v_proj", "v"),
+        ]
+        params_dict = dict(self.named_parameters())
+        loaded_params: set[str] = set()
+        for name, loaded_weight in weights:
+            if self.quant_config is not None and (scale_name := self.quant_config.get_cache_scale(name)):
+                param = params_dict[scale_name]
+                weight_loader = getattr(param, "weight_loader", default_weight_loader)
+                loaded_weight = loaded_weight if loaded_weight.dim() == 0 else loaded_weight[0]
+                weight_loader(param, loaded_weight)
+                loaded_params.add(scale_name)
+                continue
+            for param_name, weight_name, shard_id in stacked_params_mapping:
+                if weight_name not in name:
+                    continue
+                name = name.replace(weight_name, param_name)
+                if name.endswith(".bias") and name not in params_dict:
+                    continue
+
+                if is_pp_missing_parameter(name, self):
+                    continue
+
+                param = params_dict[name]
+                weight_loader = param.weight_loader
+                weight_loader(param, loaded_weight, shard_id)
+
+                break
+            else:
+                if name.endswith(".bias") and name not in params_dict:
+                    continue
+                name = maybe_remap_kv_scale_name(name, params_dict)
+                if name is None:
+                    continue
+
+                if is_pp_missing_parameter(name, self):
+                    continue
+
+                param = params_dict[name]
+                weight_loader = getattr(param, "weight_loader", default_weight_loader)
+                weight_loader(param, loaded_weight)
+            loaded_params.add(name)
+        return loaded_params
+
+
+class NemotronDenseForCausalLM(nn.Module, SupportsLoRA, SupportsPP):
+    packed_modules_mapping = {
+        "qkv_proj": [
+            "q_proj",
+            "k_proj",
+            "v_proj",
+        ],
+    }
+
+    embedding_modules = {
+        "embed_tokens": "input_embeddings",
+        "lm_head": "output_embeddings",
+    }
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+        config = vllm_config.model_config.hf_config
+        quant_config = vllm_config.quant_config
+
+        assert hasattr(config, "norm_eps") and hasattr(config, "num_hidden_layers")
+
+        self.config = config
+        self.quant_config = quant_config
+
+        self.model = NemotronDenseModel(vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model"))
+        if get_pp_group().is_last_rank:
+            self.lm_head = ParallelLMHead(
+                config.vocab_size,
+                config.hidden_size,
+                quant_config=quant_config,
+                prefix=maybe_prefix(prefix, "lm_head"),
+            )
+            if config.tie_word_embeddings:
+                self.lm_head.weight = self.model.embed_tokens.weight
+
+            logit_scale = getattr(config, "logit_scale", 1.0)
+            self.logits_processor = LogitsProcessor(config.vocab_size, scale=logit_scale)
+        else:
+            self.lm_head = PPMissingLayer()
+
+        self.make_empty_intermediate_tensors = self.model.make_empty_intermediate_tensors
+
+    def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        return self.model.embed_input_ids(input_ids)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **kwargs: Any,
+    ) -> torch.Tensor | IntermediateTensors:
+        # The omni AR runner forwards extra bookkeeping kwargs (e.g.
+        # sampling_metadata); this plain LM ignores them.
+        return self.model(input_ids, positions, intermediate_tensors, inputs_embeds)
+
+    def compute_logits(
+        self,
+        hidden_states: torch.Tensor,
+        sampling_metadata: Any = None,
+    ) -> torch.Tensor | None:
+        return self.logits_processor(self.lm_head, hidden_states)
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        loader = AutoWeightsLoader(self)
+        return loader.load_weights(weights)
diff --git a/vllm_omni/model_executor/models/audex/audex_xcodec.py b/vllm_omni/model_executor/models/audex/audex_xcodec.py
new file mode 100644
index 000000000..56c967124
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/audex_xcodec.py
@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex TTA stage 1: XCodec1 RVQ codes → waveform.
+
+Unlike the streaming causal speech decoder used for TTS, XCodec1 is a CNN
+codec that the official flow decodes over the full sequence, so this stage
+runs sync full-payload only: each request delivers its complete
+de-interleaved ``[frames, 4]`` codec-id payload once at finish and the
+decode happens in a single call.
+
+The checkpoint (``hf-audio/xcodec-hubert-general-balanced``) is external to
+the Audex repo and loads through transformers remote code; the model
+skeleton is built from config at startup for vLLM's memory profiler and the
+weights arrive via the standard ``load_weights`` iteration over the
+snapshot's safetensors.
+"""
+
+from collections.abc import Iterable
+from typing import Any
+
+import torch
+from torch import nn
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+
+from vllm_omni.model_executor.models.audex.tta import (
+    XCODEC1_CODEBOOK_SIZE,
+    XCODEC1_NUM_CODEBOOKS,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+logger = init_logger(__name__)
+
+# Official cap on decoded frames (~10 s of audio at the codec frame rate).
+_DEFAULT_MAX_TTA_FRAMES = 500
+
+
+def _meta_str(value: Any) -> str | None:
+    if isinstance(value, list | tuple):
+        return _meta_str(value[0]) if value else None
+    if isinstance(value, str):
+        return value
+    return None
+
+
+def _codes_from_runtime_info(runtime_info: dict[str, Any] | None) -> torch.Tensor | None:
+    """Extract the ``[frames, 4]`` codec-id payload from the connector info."""
+    if not isinstance(runtime_info, dict):
+        return None
+    codes = runtime_info.get("codes")
+    if not isinstance(codes, dict):
+        return None
+    audio = codes.get("audio")
+    if isinstance(audio, torch.Tensor):
+        return audio
+    if isinstance(audio, list | tuple) and audio:
+        return torch.as_tensor(audio, dtype=torch.long)
+    return None
+
+
+class AudexXCodec1(nn.Module):
+    """Stage-1 model for Audex TTA (GenerationModelRunner)."""
+
+    input_modalities = "audio"
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+        self.vllm_config = vllm_config
+        self.model_path = vllm_config.model_config.model
+
+        self.have_multimodal_outputs = True
+        self.has_preprocess = False
+        self.has_postprocess = False
+        self.enable_update_additional_information = True
+        self.requires_raw_input_tokens = True
+
+        from transformers import AutoConfig, AutoModel
+
+        config = AutoConfig.from_pretrained(self.model_path, trust_remote_code=True)
+        self.codec = AutoModel.from_config(config, trust_remote_code=True)
+        self.codec.eval()
+        self._sample_rate = int(getattr(config, "sampling_rate", 16000))
+        self._max_frames = int(getattr(config, "max_tta_frames", _DEFAULT_MAX_TTA_FRAMES))
+
+    # -------------------- vLLM model interface --------------------
+
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        # This stage ignores token embeddings; keep a stable dummy for the runner.
+        if input_ids.numel() == 0:
+            return torch.empty((0, 1), device=input_ids.device, dtype=torch.float32)
+        return torch.zeros((input_ids.shape[0], 1), device=input_ids.device, dtype=torch.float32)
+
+    def compute_logits(self, hidden_states: torch.Tensor | OmniOutput, sampling_metadata: Any = None) -> None:
+        return None
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        state_dict = dict(weights)
+        self.codec.load_state_dict(state_dict, strict=True)
+        device = self.vllm_config.device_config.device
+        self.codec.to(device=device, dtype=torch.float32)
+        return {f"codec.{name}" for name in state_dict}
+
+    def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput | tuple, **kwargs: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+        # The runner may unpack the NamedTuple in transit; rebuild it.
+        if isinstance(model_outputs, tuple) and len(model_outputs) == len(OmniOutput._fields):
+            return OmniOutput(*model_outputs)
+        raise TypeError(f"AudexXCodec1 expected OmniOutput, got {type(model_outputs)}")
+
+    # -------------------- decoding --------------------
+
+    def _decode_codes(self, req_id: str | None, codes: torch.Tensor) -> torch.Tensor:
+        """Decode a ``[frames, 4]`` codec-id payload to a mono waveform."""
+        if codes.numel() == 0:
+            # Zero codec tokens for the whole request. Do NOT raise: an
+            # exception in forward() kills the engine core for every request.
+            # Returning empty audio lets the serving layer fail this request.
+            logger.error("Audex TTA: request %s finished with no codec tokens; no audio generated", req_id)
+            return torch.empty(0, dtype=torch.float32)
+        if codes.ndim != 2 or codes.shape[1] != XCODEC1_NUM_CODEBOOKS:
+            logger.error(
+                "Audex TTA: request %s payload has shape %s, expected [frames, %d]; no audio generated",
+                req_id,
+                tuple(codes.shape),
+                XCODEC1_NUM_CODEBOOKS,
+            )
+            return torch.empty(0, dtype=torch.float32)
+
+        device = self.vllm_config.device_config.device
+        with torch.inference_mode():
+            frames = codes[: self._max_frames].to(device=device, dtype=torch.long)
+            # [frames, 4] codec ids -> [1, 4, frames] per-layer indices.
+            layer_offsets = (
+                torch.arange(XCODEC1_NUM_CODEBOOKS, device=frames.device, dtype=frames.dtype) * XCODEC1_CODEBOOK_SIZE
+            )
+            per_layer = (frames - layer_offsets.view(1, -1)).clamp(0, XCODEC1_CODEBOOK_SIZE - 1)
+            stacked = per_layer.transpose(0, 1).unsqueeze(0)
+            decoded = self.codec.decode(stacked)
+            audio = decoded.audio_values if hasattr(decoded, "audio_values") else decoded[0]
+            return audio.reshape(-1).to(dtype=torch.float32, device="cpu")
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        positions: torch.Tensor | None = None,
+        intermediate_tensors: Any = None,
+        inputs_embeds: torch.Tensor | None = None,
+        runtime_additional_information: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        runtime_infos = runtime_additional_information or []
+        seq_token_counts = kwargs.get("seq_token_counts")
+        if seq_token_counts is not None:
+            num_reqs = len(seq_token_counts)
+        elif input_ids is not None and input_ids.numel() > 0 and not runtime_infos:
+            num_reqs = 1
+        else:
+            num_reqs = len(runtime_infos)
+
+        audios: list[torch.Tensor] = []
+        sr_tensor = torch.tensor(self._sample_rate, dtype=torch.int32)
+        for i in range(num_reqs):
+            info = runtime_infos[i] if i < len(runtime_infos) else {}
+            info = info if isinstance(info, dict) else {}
+            meta = info.get("meta", {})
+            meta = meta if isinstance(meta, dict) else {}
+            req_id = _meta_str(meta.get("req_id"))
+            codes = _codes_from_runtime_info(info)
+            if codes is None:
+                audios.append(torch.empty(0, dtype=torch.float32))
+                continue
+            audios.append(self._decode_codes(req_id, codes))
+
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={"model_outputs": audios, "sr": [sr_tensor] * num_reqs},
+        )
diff --git a/vllm_omni/model_executor/models/audex/cfg.py b/vllm_omni/model_executor/models/audex/cfg.py
new file mode 100644
index 000000000..488097216
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/cfg.py
@@ -0,0 +1,567 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+#
+# Adapted from nvidia/Nemotron-Labs-Audex-2B (Apache-2.0):
+#   inference_scripts_vllm/audiogen_scripts/cfg_logits_processor.py
+#   inference_scripts_vllm/audiogen_scripts/vllm_cfg_patch.py
+# Divergences from the official files are commented at the divergence site.
+"""Classifier-free guidance for the Audex thinker stage.
+
+CFG pairs a conditional request with an unconditional (null-prompt)
+companion in the same engine and blends their logits every step:
+
+    blended = uncond + cfg_scale * (cond - uncond)
+
+Both rows receive the blended logits and the sampled token is copied from
+the cond row to the uncond row, so the two sequences stay token-identical.
+Requests opt in via ``SamplingParams.extra_args``:
+
+    cond:   {"cfg_scale": 1.5, "cfg_role": "cond",   "cfg_pair_id": <id>}
+    uncond: {"cfg_scale": 1.5, "cfg_role": "uncond", "cfg_pair_id": <id>}
+
+Blending is only correct when both pair members decode the same position in
+the same engine step, so ``apply_cfg_patches()`` makes the vLLM scheduler
+pair-aware: a lone member waits for its partner, partners stay adjacent,
+their ``num_computed_tokens`` are equalized after every schedule, and they
+finish together. The patch is a no-op for engines that never see a CFG
+request (the pair registry stays empty).
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import Any
+
+import torch
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+from vllm.sampling_params import SamplingParams
+from vllm.v1.sample.logits_processor import (
+    BatchUpdate,
+    LogitsProcessor,
+    MoveDirectionality,
+)
+
+logger = init_logger(__name__)
+
+_COND = "cond"
+_UNCOND = "uncond"
+
+
+def _cfg_extra(request: Any, key: str) -> Any:
+    sampling_params = getattr(request, "sampling_params", None)
+    extra_args = getattr(sampling_params, "extra_args", None)
+    if extra_args:
+        return extra_args.get(key)
+    return None
+
+
+class AudexCFGLogitsProcessor(LogitsProcessor):
+    """Blend cond/uncond logits for classifier-free guidance.
+
+    Pairs are matched by ``cfg_pair_id``. For each pair the blended logits
+    are written to *both* rows so the sampler picks the same token; the
+    post-sampling copy of the cond token into the uncond slot is installed
+    by :meth:`_ensure_sample_patched` (which must run inside each worker
+    process, hence from ``__init__`` rather than a main-process patch).
+    """
+
+    _sample_patched = False
+
+    @classmethod
+    def validate_params(cls, params: SamplingParams) -> None:
+        extra_args = params.extra_args
+        if not extra_args:
+            return
+        role = extra_args.get("cfg_role")
+        if role is not None and role not in (_COND, _UNCOND):
+            raise ValueError(f"cfg_role must be 'cond' or 'uncond', got '{role}'")
+        scale = extra_args.get("cfg_scale")
+        if scale is not None and (not isinstance(scale, int | float) or scale < 1.0):
+            raise ValueError(f"cfg_scale must be >= 1.0, got {scale}")
+
+    def __init__(self, vllm_config: VllmConfig, device: torch.device, is_pin_memory: bool) -> None:
+        self._info: dict[int, dict[str, Any]] = {}
+        self._output_tokens: dict[int, list[int]] = {}
+        self._pairs: list[tuple[int, int, float]] = []
+        self._dirty = True
+        self._ensure_sample_patched()
+
+    @classmethod
+    def _ensure_sample_patched(cls) -> None:
+        """Install the post-sampling cond→uncond token copy (once per process)."""
+        if cls._sample_patched:
+            return
+        cls._sample_patched = True
+
+        # Divergence from the official file: it patches vLLM's
+        # ``GPUModelRunner._sample``, but vllm-omni's AR runner overrides
+        # ``_sample``, so the base-class patch would never run for the Audex
+        # thinker stage. Patch the omni AR runner instead.
+        from vllm_omni.worker.gpu_ar_model_runner import GPUARModelRunner
+
+        orig_sample = GPUARModelRunner._sample
+
+        def _sample_with_cfg_sync(self, logits, spec_decode_metadata):
+            sampler_output = orig_sample(self, logits, spec_decode_metadata)
+            for proc in self.input_batch.logitsprocs.all:
+                if isinstance(proc, AudexCFGLogitsProcessor) and proc._pairs:
+                    sampled = sampler_output.sampled_token_ids
+                    num_rows = sampled.shape[0] if hasattr(sampled, "shape") else len(sampled)
+                    for cond_idx, uncond_idx, _ in proc._pairs:
+                        # Steps that sample fewer rows than the persistent
+                        # batch (pure-prefill / partially scheduled steps)
+                        # have nothing to sync for this pair; the scheduler
+                        # pair patches keep both members step-locked on the
+                        # decode steps that matter.
+                        if cond_idx < num_rows and uncond_idx < num_rows:
+                            sampled[uncond_idx] = sampled[cond_idx]
+                    break
+            return sampler_output
+
+        _sample_with_cfg_sync._audex_cfg_sync = True  # type: ignore[attr-defined]
+        GPUARModelRunner._sample = _sample_with_cfg_sync
+        logger.info("AudexCFGLogitsProcessor: patched GPUARModelRunner._sample for CFG token sync")
+
+    def is_argmax_invariant(self) -> bool:
+        return False
+
+    def _reset(self) -> None:
+        self._info.clear()
+        self._output_tokens.clear()
+        self._pairs.clear()
+        self._dirty = True
+
+    def update_state(self, batch_update: BatchUpdate | None) -> None:
+        if batch_update is None:
+            return
+
+        for idx in batch_update.removed:
+            self._info.pop(idx, None)
+            self._output_tokens.pop(idx, None)
+
+        if not self._info and batch_update.added:
+            self._reset()
+
+        for idx, params, _, output_token_ids in batch_update.added:
+            extra_args = params.extra_args if params else None
+            if extra_args and extra_args.get("cfg_role") in (_COND, _UNCOND):
+                self._info[idx] = {
+                    "role": extra_args["cfg_role"],
+                    "cfg_scale": float(extra_args.get("cfg_scale", 1.0)),
+                    "pair_id": extra_args.get("cfg_pair_id"),
+                }
+                self._output_tokens[idx] = output_token_ids
+            else:
+                self._info.pop(idx, None)
+                self._output_tokens.pop(idx, None)
+        self._dirty = True
+
+        if self._info:
+            for src, dst, direction in batch_update.moved:
+                src_info = self._info.pop(src, None)
+                dst_info = self._info.pop(dst, None)
+                src_tokens = self._output_tokens.pop(src, None)
+                dst_tokens = self._output_tokens.pop(dst, None)
+                if src_info is not None:
+                    self._info[dst] = src_info
+                if src_tokens is not None:
+                    self._output_tokens[dst] = src_tokens
+                if direction == MoveDirectionality.SWAP:
+                    if dst_info is not None:
+                        self._info[src] = dst_info
+                    if dst_tokens is not None:
+                        self._output_tokens[src] = dst_tokens
+            self._dirty = True
+
+    def _rebuild_pairs(self) -> None:
+        by_pair: dict[str, dict[str, tuple[int, float]]] = {}
+        for idx, info in self._info.items():
+            pair_id = info.get("pair_id")
+            if pair_id is None:
+                continue
+            by_pair.setdefault(pair_id, {})[info["role"]] = (idx, info["cfg_scale"])
+
+        self._pairs = [
+            (roles[_COND][0], roles[_UNCOND][0], roles[_COND][1])
+            for roles in by_pair.values()
+            if _COND in roles and _UNCOND in roles
+        ]
+        self._dirty = False
+
+    def apply(self, logits: torch.Tensor) -> torch.Tensor:
+        if not self._info:
+            return logits
+
+        if self._dirty:
+            self._rebuild_pairs()
+
+        num_rows = logits.shape[0]
+        for cond_idx, uncond_idx, cfg_scale in self._pairs:
+            # Rows beyond this step's logits (pure-prefill / partially
+            # scheduled steps) have nothing to blend; decode steps carry
+            # both pair rows thanks to the scheduler pair patches.
+            if cond_idx >= num_rows or uncond_idx >= num_rows:
+                continue
+            blended = logits[uncond_idx] + cfg_scale * (logits[cond_idx] - logits[uncond_idx])
+            logits[cond_idx] = blended
+            logits[uncond_idx] = blended
+
+        return logits
+
+
+# ---------------------------------------------------------------------------
+# Scheduler pair synchronization
+# ---------------------------------------------------------------------------
+
+
+def _wait_queues(scheduler: Any) -> list[Any]:
+    # Divergence from the official (vLLM 0.20-era) file: vLLM 0.24 parks
+    # structurally not-ready requests in a second ``skipped_waiting`` queue;
+    # pair-hold must cover both queues or a lone member parked there would
+    # be admitted without its partner.
+    queues = [scheduler.waiting]
+    skipped = getattr(scheduler, "skipped_waiting", None)
+    if skipped is not None:
+        queues.append(skipped)
+    return queues
+
+
+def _pair_complete(scheduler: Any, request_id: str, blocked_ids: set[str] | None = None) -> bool:
+    pair_id = scheduler._cfg_req_to_pair.get(request_id)
+    if pair_id is None:
+        return True
+    roles = scheduler._cfg_pairs.get(pair_id, {})
+    if len(roles) != 2 or not all(rid in scheduler.requests for rid in roles.values()):
+        return False
+    if blocked_ids:
+        # A partner parked in skipped_waiting (e.g. waiting for remote KVs)
+        # may fail promotion this step while this member gets scheduled from
+        # waiting — hold this member until the partner is schedulable.
+        for rid in roles.values():
+            if rid != request_id and rid in blocked_ids:
+                return False
+    return True
+
+
+# Schedule steps a lone pair member may wait for its partner. Partners arrive
+# within a handful of steps in practice; exhausting this budget means the
+# companion was never created (e.g. prompt expansion failed), and the request
+# is released to decode unguided instead of hanging forever.
+_MAX_PAIR_HOLD_STEPS = 512
+
+
+def _drop_stale_pair(scheduler: Any, request_id: str) -> None:
+    pair_id = scheduler._cfg_req_to_pair.get(request_id)
+    if pair_id is None:
+        return
+    for rid in scheduler._cfg_pairs.pop(pair_id, {}).values():
+        scheduler._cfg_req_to_pair.pop(rid, None)
+    logger.warning(
+        "CFG pair %s: partner of %s never arrived after %d schedule steps; releasing the request unguided",
+        pair_id,
+        request_id,
+        _MAX_PAIR_HOLD_STEPS,
+    )
+
+
+def _hold_incomplete_pairs(scheduler: Any) -> list[tuple[Any, Any]]:
+    """Pull CFG requests whose partner is not yet admitted out of the wait queues.
+
+    The engine schedules as soon as the first member of a pair arrives over
+    IPC; without the hold, the lone member prefills one step early and the
+    pair is permanently offset by one token. Held requests are re-prepended
+    after the schedule step.
+    """
+    hold_counts: dict[str, int] = getattr(scheduler, "_cfg_hold_counts", None) or {}
+    scheduler._cfg_hold_counts = hold_counts
+
+    skipped = getattr(scheduler, "skipped_waiting", None)
+    blocked_ids = {req.request_id for req in list(skipped)} if skipped is not None else set()
+
+    held: list[tuple[Any, Any]] = []
+    for queue in _wait_queues(scheduler):
+        # A member is only "blocked" for its partner's sake when it sits in
+        # the OTHER queue; members of the queue being scanned move together.
+        partner_blockers = blocked_ids if queue is not skipped else set()
+        held_here = []
+        for request in list(queue):
+            if _pair_complete(scheduler, request.request_id, partner_blockers):
+                hold_counts.pop(request.request_id, None)
+                continue
+            count = hold_counts.get(request.request_id, 0) + 1
+            if count > _MAX_PAIR_HOLD_STEPS:
+                hold_counts.pop(request.request_id, None)
+                _drop_stale_pair(scheduler, request.request_id)
+                continue
+            hold_counts[request.request_id] = count
+            held_here.append(request)
+        if held_here:
+            queue.remove_requests(held_here)
+            held.extend((queue, req) for req in held_here)
+    return held
+
+
+def _release_held(held: list[tuple[Any, Any]]) -> None:
+    for queue, request in reversed(held):
+        queue.prepend_request(request)
+
+
+def _reorder_waiting_for_cfg(scheduler: Any) -> None:
+    """Move CFG pair partners adjacent in the FCFS waiting queue."""
+    waiting = scheduler.waiting
+    # Only the FCFS queue (a deque) has caller-controlled ordering; priority
+    # queues order themselves and pair sync then relies on hold + equalize.
+    if not isinstance(waiting, deque) or len(waiting) < 2:
+        return
+
+    requests = list(waiting)
+    waiting.clear()
+
+    seen: set[str] = set()
+    result: list[Any] = []
+    for request in requests:
+        rid = request.request_id
+        if rid in seen:
+            continue
+        seen.add(rid)
+        result.append(request)
+
+        pair_id = scheduler._cfg_req_to_pair.get(rid)
+        if pair_id is None:
+            continue
+        for partner_id in scheduler._cfg_pairs.get(pair_id, {}).values():
+            if partner_id != rid and partner_id not in seen:
+                for candidate in requests:
+                    if candidate.request_id == partner_id:
+                        seen.add(partner_id)
+                        result.append(candidate)
+                        break
+
+    waiting.extend(result)
+
+
+def _equalize_cfg_pair_progress(scheduler: Any, scheduler_output: Any) -> None:
+    """Bring both members of every CFG pair to the same ``num_computed_tokens``.
+
+    Prefix-cache hits or unequal chunked-prefill budget can leave one member
+    ahead after a schedule step; reduce the faster member's allocation so
+    both land on the same position. Over-allocated KV blocks remain and are
+    consumed next step — nothing leaks.
+    """
+    for roles in scheduler._cfg_pairs.values():
+        cond_id = roles.get(_COND)
+        uncond_id = roles.get(_UNCOND)
+        if not cond_id or not uncond_id:
+            continue
+
+        cond_sched = scheduler_output.num_scheduled_tokens.get(cond_id, 0)
+        uncond_sched = scheduler_output.num_scheduled_tokens.get(uncond_id, 0)
+        if cond_sched == 0 or uncond_sched == 0:
+            continue
+
+        cond_req = scheduler.requests.get(cond_id)
+        uncond_req = scheduler.requests.get(uncond_id)
+        if not cond_req or not uncond_req:
+            continue
+
+        if cond_req.num_computed_tokens == uncond_req.num_computed_tokens:
+            continue
+
+        target = min(cond_req.num_computed_tokens, uncond_req.num_computed_tokens)
+
+        feasible = all(
+            req.num_computed_tokens - target < sched
+            for req, sched in ((cond_req, cond_sched), (uncond_req, uncond_sched))
+        )
+        if not feasible:
+            continue
+
+        for req_id, req, orig_sched in (
+            (cond_id, cond_req, cond_sched),
+            (uncond_id, uncond_req, uncond_sched),
+        ):
+            diff = req.num_computed_tokens - target
+            if diff > 0:
+                req.num_computed_tokens = target
+                scheduler_output.num_scheduled_tokens[req_id] = orig_sched - diff
+                scheduler_output.total_num_scheduled_tokens -= diff
+                logger.debug(
+                    "CFG equalize %s: %d -> %d scheduled, computed -> %d",
+                    req_id,
+                    orig_sched,
+                    orig_sched - diff,
+                    target,
+                )
+
+
+def _drop_split_pairs(scheduler: Any) -> None:
+    """Deregister a desynced CFG pair (one member preempted / left behind).
+
+    Manual re-preemption surgery is unsafe against the upstream scheduler.
+    Instead, a pair that split anyway (KV-pressure preemption of exactly one
+    member, or unrecoverable progress skew) is dropped from the registry:
+    the cond request continues UNGUIDED (its logits are never blended again)
+    rather than being re-paired against a desynced partner, and the
+    companion's discarded output no longer matters.
+    """
+    if not scheduler._cfg_pairs:
+        return
+
+    running_ids = {req.request_id for req in scheduler.running}
+    to_drop: list[tuple[str, str, str, str]] = []
+    for pair_id, roles in scheduler._cfg_pairs.items():
+        cond_id = roles.get(_COND)
+        uncond_id = roles.get(_UNCOND)
+        if cond_id is None or uncond_id is None:
+            continue
+        if cond_id not in scheduler.requests or uncond_id not in scheduler.requests:
+            continue
+
+        cond_running = cond_id in running_ids
+        uncond_running = uncond_id in running_ids
+        if cond_running != uncond_running:
+            # Split only counts once decoding started: a lone member that has
+            # computed tokens while its partner was pushed back is desynced.
+            runner = scheduler.requests.get(cond_id if cond_running else uncond_id)
+            if runner is not None and runner.num_computed_tokens > 0:
+                to_drop.append((pair_id, cond_id, uncond_id, "one member preempted"))
+            continue
+
+        if cond_running and uncond_running:
+            cond_req = scheduler.requests.get(cond_id)
+            uncond_req = scheduler.requests.get(uncond_id)
+            if cond_req and uncond_req and cond_req.num_computed_tokens != uncond_req.num_computed_tokens:
+                logger.warning(
+                    "CFG pair progress mismatch (equalize will retry): %s@%d vs %s@%d",
+                    cond_id,
+                    cond_req.num_computed_tokens,
+                    uncond_id,
+                    uncond_req.num_computed_tokens,
+                )
+
+    for pair_id, cond_id, uncond_id, reason in to_drop:
+        scheduler._cfg_pairs.pop(pair_id, None)
+        scheduler._cfg_req_to_pair.pop(cond_id, None)
+        scheduler._cfg_req_to_pair.pop(uncond_id, None)
+        logger.warning(
+            "CFG pair %s split (%s); releasing cond=%s unguided, uncond=%s output is discarded",
+            pair_id,
+            reason,
+            cond_id,
+            uncond_id,
+        )
+
+
+_patches_applied = False
+
+
+def cfg_patches_applied() -> bool:
+    """True once :func:`apply_cfg_patches` has patched the scheduler in this process."""
+    return _patches_applied
+
+
+def _patch_scheduler() -> None:
+    from vllm.v1.core.sched.scheduler import Scheduler
+
+    orig_init = Scheduler.__init__
+    orig_add = Scheduler.add_request
+    orig_finish = Scheduler.finish_requests
+    orig_schedule = Scheduler.schedule
+
+    def _init(self, *args: Any, **kwargs: Any) -> None:
+        orig_init(self, *args, **kwargs)
+        self._cfg_pairs: dict[str, dict[str, str]] = {}
+        self._cfg_req_to_pair: dict[str, str] = {}
+
+    def _add(self, request: Any) -> None:
+        orig_add(self, request)
+        pair_id = _cfg_extra(request, "cfg_pair_id")
+        role = _cfg_extra(request, "cfg_role")
+        if pair_id and role:
+            self._cfg_pairs.setdefault(pair_id, {})[role] = request.request_id
+            self._cfg_req_to_pair[request.request_id] = pair_id
+            # An asymmetric prefix-cache hit (the cond prompt shares cached
+            # branches; the <unk> null prompt does not) can advance one
+            # member past what post-schedule equalization can claw back.
+            # Skip prefix-cache reads for CFG requests entirely.
+            if hasattr(request, "skip_reading_prefix_cache"):
+                request.skip_reading_prefix_cache = True
+
+    def _finish(self, request_ids: Any, finished_status: Any) -> Any:
+        if request_ids is None:
+            result = orig_finish(self, request_ids, finished_status)
+            self._cfg_pairs.clear()
+            self._cfg_req_to_pair.clear()
+            return result
+
+        if isinstance(request_ids, str):
+            request_ids = {request_ids}
+        else:
+            request_ids = set(request_ids)
+
+        # Finish both members together: a surviving partner would decode
+        # unpaired garbage (its logits are never blended again).
+        partner_ids: set[str] = set()
+        for req_id in request_ids:
+            pair_id = self._cfg_req_to_pair.get(req_id)
+            if pair_id is None:
+                continue
+            for rid in self._cfg_pairs.get(pair_id, {}).values():
+                if rid != req_id and rid in self.requests:
+                    partner_ids.add(rid)
+
+        all_ids = request_ids | partner_ids
+        result = orig_finish(self, all_ids, finished_status)
+
+        for req_id in all_ids:
+            pair_id = self._cfg_req_to_pair.pop(req_id, None)
+            if pair_id:
+                self._cfg_pairs.pop(pair_id, None)
+        return result
+
+    def _schedule(self, *args: Any, **kwargs: Any) -> Any:
+        if not self._cfg_pairs:
+            return orig_schedule(self, *args, **kwargs)
+
+        _reorder_waiting_for_cfg(self)
+        held = _hold_incomplete_pairs(self)
+
+        # Chunked prefill can split one pair member's prompt across steps
+        # while the other fits in a single step; halving the long-prefill
+        # threshold makes both chunk, and equalize aligns the remainder.
+        scheduler_config = getattr(self, "scheduler_config", None)
+        orig_threshold = getattr(scheduler_config, "long_prefill_token_threshold", None)
+        if scheduler_config is not None and orig_threshold is not None:
+            scheduler_config.long_prefill_token_threshold = self.max_num_scheduled_tokens // 2
+        try:
+            scheduler_output = orig_schedule(self, *args, **kwargs)
+        finally:
+            if scheduler_config is not None and orig_threshold is not None:
+                scheduler_config.long_prefill_token_threshold = orig_threshold
+            _release_held(held)
+
+        _equalize_cfg_pair_progress(self, scheduler_output)
+        _drop_split_pairs(self)
+        return scheduler_output
+
+    _schedule._audex_cfg_patched = True  # type: ignore[attr-defined]
+
+    Scheduler.__init__ = _init
+    Scheduler.add_request = _add
+    Scheduler.finish_requests = _finish
+    Scheduler.schedule = _schedule
+
+
+def apply_cfg_patches() -> None:
+    """Make the vLLM v1 scheduler CFG-pair-aware. Idempotent, per process.
+
+    Must run in the engine-core process before ``Scheduler`` is constructed
+    (the ``__init__`` wrapper installs the pair registry).
+    """
+    global _patches_applied
+    if _patches_applied:
+        return
+    _patches_applied = True
+    logger.info("Applying Audex CFG scheduler patches to vLLM v1")
+    _patch_scheduler()
diff --git a/vllm_omni/model_executor/models/audex/checkpoint.py b/vllm_omni/model_executor/models/audex/checkpoint.py
new file mode 100644
index 000000000..38b0531e6
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/checkpoint.py
@@ -0,0 +1,186 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex checkpoint layout preparation.
+
+The nvidia/Nemotron-Labs-Audex-2B repo deduplicates weights: the
+``checkpoint_folder_audiogen`` (and ``checkpoint_folder_textonly``) index
+files reference safetensors shards that physically live only under
+``checkpoint_folder_full``. The official repo ships a prepare script that
+symlinks them; this replicates that step automatically so users can pass the
+repo root without any manual preparation.
+"""
+
+import json
+import os
+import shutil
+
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+_WEIGHT_SOURCE_FOLDER = "checkpoint_folder_full"
+
+# Download profiles: each deployment pulls only the repo subset its stages
+# need. The dedup weight shards are appended per-model at call time from
+# the audiogen index (see _dedup_shard_patterns); the static lists here
+# hold only the model-independent folders.
+_SNAPSHOT_PROFILE_PATTERNS = {
+    "tts": [
+        "config.json",
+        "checkpoint_folder_audiogen/*",
+        "audex_causal_speech_decoder/*",
+    ],
+    # TTA reuses the audiogen thinker; waveform decode happens in the
+    # external XCodec1 checkpoint (see ensure_xcodec1_snapshot), so the
+    # bundled speech decoder is not pulled.
+    "tta": [
+        "config.json",
+        "checkpoint_folder_audiogen/*",
+    ],
+    # The audio-capable full checkpoint: both weight shards, audio
+    # preprocessor assets, chat template, and remote-code modeling files.
+    "full": [
+        "config.json",
+        f"{_WEIGHT_SOURCE_FOLDER}/*",
+    ],
+}
+
+XCODEC1_DEFAULT_REPO = "hf-audio/xcodec-hubert-general-balanced"
+
+_AUDIOGEN_INDEX_FILE = "checkpoint_folder_audiogen/model.safetensors.index.json"
+
+
+def _download_audiogen_index(model: str) -> str:
+    """Resolve the audiogen dedup index to a local path (tiny, cache-first).
+
+    Cache-first keeps warm-cache boots offline-safe and avoids a Hub
+    metadata round trip per stage-engine boot; a cache miss falls back to
+    the network.
+    """
+    from huggingface_hub import hf_hub_download
+
+    try:
+        return hf_hub_download(model, _AUDIOGEN_INDEX_FILE, local_files_only=True)
+    except Exception:
+        return hf_hub_download(model, _AUDIOGEN_INDEX_FILE)
+
+
+def _dedup_shard_patterns(model: str) -> list[str]:
+    """Shards under the full checkpoint referenced by the audiogen index.
+
+    The audiogen folder deduplicates its LM weights into
+    ``checkpoint_folder_full`` shards (1 of 2 on the 2B, a subset of 14 on
+    the 30B-A3B); the ``tts``/``tta`` profiles must download exactly those.
+    Falls back to every full-checkpoint shard when the index is unreadable.
+    """
+    try:
+        with open(_download_audiogen_index(model)) as f:
+            weight_map = json.load(f).get("weight_map", {})
+        shards = sorted(set(weight_map.values()))
+        if shards:
+            return [f"{_WEIGHT_SOURCE_FOLDER}/{shard}" for shard in shards]
+    except Exception as exc:
+        logger.warning(
+            "Could not resolve the audiogen dedup shards for %s from %s (%s); downloading all full-checkpoint shards",
+            model,
+            _AUDIOGEN_INDEX_FILE,
+            exc,
+        )
+    return [f"{_WEIGHT_SOURCE_FOLDER}/model-*.safetensors"]
+
+
+def ensure_audex_snapshot(model: str, profile: str = "tts") -> str:
+    """Resolve ``model`` to a local repo-root directory, downloading if needed.
+
+    Local paths pass through untouched. For an HF repo id, download (or reuse
+    from cache) exactly the subset the requesting stage's ``profile`` needs,
+    so per-stage ``model_subdir`` joins land on a real snapshot instead of
+    the repo-id string on a fresh cache. Falls back to a cached snapshot
+    when offline.
+    """
+    if os.path.isdir(model):
+        return model
+
+    patterns = _SNAPSHOT_PROFILE_PATTERNS.get(profile)
+    if patterns is None:
+        raise ValueError(
+            f"Unknown Audex snapshot profile {profile!r}; expected one of {sorted(_SNAPSHOT_PROFILE_PATTERNS)}"
+        )
+
+    patterns = list(patterns)
+    if profile in ("tts", "tta"):
+        patterns += _dedup_shard_patterns(model)
+
+    from huggingface_hub import snapshot_download
+
+    try:
+        return snapshot_download(model, allow_patterns=patterns)
+    except Exception as download_exc:
+        try:
+            return snapshot_download(model, allow_patterns=patterns, local_files_only=True)
+        except Exception:
+            raise RuntimeError(
+                f"Could not resolve the Audex repo {model!r} (profile {profile!r}): the download "
+                "failed and no cached snapshot with the required folders was found."
+            ) from download_exc
+
+
+def ensure_xcodec1_snapshot(model: str | None) -> str:
+    """Resolve the external XCodec1 checkpoint (TTA waveform decoder).
+
+    Accepts a local directory or an HF repo id; ``None``/empty falls back to
+    the official ``hf-audio/xcodec-hubert-general-balanced``.
+    """
+    model = model or XCODEC1_DEFAULT_REPO
+    if os.path.isdir(model):
+        return model
+
+    from huggingface_hub import snapshot_download
+
+    try:
+        return snapshot_download(model)
+    except Exception as download_exc:
+        try:
+            return snapshot_download(model, local_files_only=True)
+        except Exception:
+            raise RuntimeError(
+                f"Could not resolve the XCodec1 checkpoint {model!r}: the download failed and "
+                "no cached snapshot was found. Download it manually or point the TTA deploy "
+                "yaml's stage-1 model at a local copy."
+            ) from download_exc
+
+
+def ensure_audiogen_weights(model_dir: str) -> None:
+    """Link index-referenced shards missing from ``model_dir`` from the full checkpoint.
+
+    No-op when the shards are already present (or the layout is unexpected);
+    raises only if a referenced shard exists nowhere.
+    """
+    index_path = os.path.join(model_dir, "model.safetensors.index.json")
+    if not os.path.isfile(index_path):
+        return
+    try:
+        with open(index_path) as f:
+            weight_map = json.load(f).get("weight_map", {})
+    except (OSError, ValueError) as exc:
+        logger.warning("Could not read %s: %s", index_path, exc)
+        return
+
+    source_dir = os.path.join(os.path.dirname(os.path.abspath(model_dir)), _WEIGHT_SOURCE_FOLDER)
+    for shard in sorted(set(weight_map.values())):
+        dst = os.path.join(model_dir, shard)
+        if os.path.exists(dst):
+            continue
+        src = os.path.join(source_dir, shard)
+        if not os.path.exists(src):
+            raise FileNotFoundError(
+                f"Audex checkpoint shard {shard!r} is missing from {model_dir} and "
+                f"{source_dir}. Download the repo's {_WEIGHT_SOURCE_FOLDER}/ folder "
+                "(it holds the deduplicated weight shards)."
+            )
+        try:
+            os.symlink(os.path.relpath(src, model_dir), dst)
+            logger.info("Linked Audex weight shard %s -> %s", dst, src)
+        except OSError:
+            shutil.copy2(src, dst)
+            logger.info("Copied Audex weight shard %s -> %s", src, dst)
diff --git a/vllm_omni/model_executor/models/audex/pipeline.py b/vllm_omni/model_executor/models/audex/pipeline.py
new file mode 100644
index 000000000..8723a2138
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/pipeline.py
@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex (Nemotron-Labs-Audex-2B) TTS pipeline topology.
+
+Stage 0: Thinker  — ChatML text prompt → <speechcodec_N> tokens (LLM AR).
+Stage 1: Code2Wav — streaming causal speech decoder → 16 kHz waveform.
+
+Users pass the HF repo ROOT (its manifest config.json carries
+``model_type: nemotron_labs_audex``); per-stage checkpoints resolve through
+``model_subdir``/``tokenizer_subdir``. The decoder subfolder has no tokenizer
+files, so stage 1's tokenizer also points at the thinker checkpoint.
+"""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+_PROC = "vllm_omni.model_executor.stage_input_processors.audex"
+
+# <speechgen_end> token id in checkpoint_folder_audiogen's tokenizer; pinned
+# by a unit test against the real tokenizer fixture.
+AUDEX_SPEECHGEN_END_TOKEN_ID = 131076
+
+# <audiogen_end> stops TTA generation (pinned in tests via models/audex/tta.py).
+AUDEX_AUDIOGEN_END_TOKEN_ID = 131074
+
+# No pipeline-level model_arch: stage-0 classes resolve from each
+# checkpoint's own ``architectures`` (dense on the 2B, NemotronH on the
+# 30B-A3B); forcing one name via hf_overrides would misbind the other
+# size. Decoder stages keep their explicit per-stage model_arch.
+AUDEX_TTS_PIPELINE = PipelineConfig(
+    model_type="audex_tts",
+    default_deploy_config_name="audex_tts.yaml",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="audex_thinker",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            owns_tokenizer=True,
+            engine_output_type="latent",
+            model_subdir="checkpoint_folder_audiogen",
+            tokenizer_subdir="checkpoint_folder_audiogen",
+            # Emits the unconditional CFG companion for cfg_scale > 1.0
+            # requests; a no-op for unguided requests.
+            prompt_expand_func=f"{_PROC}.expand_cfg_prompts",
+            async_chunk_process_next_stage_input_func=(f"{_PROC}.thinker2code2wav_async_chunk"),
+            custom_process_next_stage_input_func=f"{_PROC}.thinker2code2wav_full_payload",
+            sampling_constraints={
+                "detokenize": False,
+                "stop_token_ids": [AUDEX_SPEECHGEN_END_TOKEN_ID],
+            },
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="audex_code2wav",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="AudexCode2Wav",
+            model_subdir="audex_causal_speech_decoder",
+            tokenizer_subdir="checkpoint_folder_audiogen",
+            sync_process_input_func=f"{_PROC}.thinker2code2wav_token_only",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
+
+
+# Text-to-audio (caption → general audio): same audiogen thinker checkpoint,
+# but the output rides the interleaved 4-codebook <audiocodec_N> RVQ block
+# and decodes through the EXTERNAL XCodec1 checkpoint. XCodec1 is a CNN codec
+# decoded over the full sequence, so this pipeline is sync full-payload only
+# (deploy yaml sets async_chunk: false). CFG is effectively mandatory for TTA
+# quality (official default scale 3.0).
+# Cascaded speech-to-speech: the audio-capable full checkpoint serves all
+# three official passes (ASR → chat → TTS) in one deployment; only the TTS
+# pass (output modality "audio", final_stage_id 1) traverses the streaming
+# speech decoder — text-modality passes finish at stage 0 and never reach
+# the codec path. The cascade itself is orchestrated by the client/example.
+AUDEX_S2S_PIPELINE = PipelineConfig(
+    model_type="audex_s2s",
+    default_deploy_config_name="audex_s2s.yaml",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="audex_omni",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            final_output=True,
+            final_output_type="text",
+            owns_tokenizer=True,
+            requires_multimodal_data=True,
+            engine_output_type="latent",
+            model_subdir="checkpoint_folder_full",
+            tokenizer_subdir="checkpoint_folder_full",
+            prompt_expand_func=f"{_PROC}.expand_cfg_prompts",
+            async_chunk_process_next_stage_input_func=(f"{_PROC}.thinker2code2wav_async_chunk"),
+            custom_process_next_stage_input_func=f"{_PROC}.thinker2code2wav_full_payload",
+            # <speechgen_end> additionally stops the TTS pass; text passes
+            # stop at their natural eos first. detokenize stays on for the
+            # text-final passes.
+            sampling_constraints={
+                "detokenize": True,
+                "stop_token_ids": [AUDEX_SPEECHGEN_END_TOKEN_ID],
+            },
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="audex_code2wav",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="AudexCode2Wav",
+            model_subdir="audex_causal_speech_decoder",
+            # The decoder folder has no tokenizer files. Borrow the audiogen
+            # tokenizer (not checkpoint_folder_full): this stage resolves its
+            # snapshot with the "tts" download profile, which guarantees
+            # checkpoint_folder_audiogen but not the full folder's tokenizer,
+            # so per-stage / clean-cache launches would otherwise fail.
+            tokenizer_subdir="checkpoint_folder_audiogen",
+            sync_process_input_func=f"{_PROC}.thinker2code2wav_token_only",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
+
+
+# Audio understanding (ASR / audio QA): single-stage deployment of the
+# audio-capable full checkpoint — speech (+ text instruction) in, text out.
+# Modeled on the ming_flash_omni / qwen2_5_omni thinker-only pipelines.
+AUDEX_THINKER_ONLY_PIPELINE = PipelineConfig(
+    model_type="audex_thinker_only",
+    default_deploy_config_name="audex_thinker_only.yaml",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="audex_omni",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            final_output=True,
+            final_output_type="text",
+            owns_tokenizer=True,
+            requires_multimodal_data=True,
+            engine_output_type="text",
+            model_subdir="checkpoint_folder_full",
+            tokenizer_subdir="checkpoint_folder_full",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
+
+
+AUDEX_TTA_PIPELINE = PipelineConfig(
+    model_type="audex_tta",
+    default_deploy_config_name="audex_tta.yaml",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="audex_tta_thinker",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            owns_tokenizer=True,
+            engine_output_type="latent",
+            model_subdir="checkpoint_folder_audiogen",
+            tokenizer_subdir="checkpoint_folder_audiogen",
+            prompt_expand_func=f"{_PROC}.expand_cfg_prompts",
+            custom_process_next_stage_input_func=f"{_PROC}.thinker2xcodec_full_payload",
+            sampling_constraints={
+                "detokenize": False,
+                "stop_token_ids": [AUDEX_AUDIOGEN_END_TOKEN_ID],
+            },
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="audex_xcodec",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="AudexXCodec1",
+            # Length placeholder for the stage-1 request; the bulk codec
+            # payload ships via thinker2xcodec_full_payload.
+            sync_process_input_func=f"{_PROC}.thinker2code2wav_token_only",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/audex/prompt.py b/vllm_omni/model_executor/models/audex/prompt.py
new file mode 100644
index 000000000..c3ee43c7e
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/prompt.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex TTS/TTA prompt construction.
+
+The Audex thinker consumes the exact ChatML prompt used by the official
+inference script (``inference_scripts_vllm/audiogen_scripts/run_audio_gen_vllm.py``
+in the nvidia/Nemotron-Labs-Audex-2B repo). The checkpoint's bundled chat
+template opens a thinking block (``<think>\\n``) instead of the closed
+``<think></think>`` + ``<speechgen_start>`` priming that TTS generation
+requires, so the prompt is built from a literal template here; a unit test
+pins it byte-for-byte against the official format.
+
+``build_null_prompt`` is the unconditional-prompt counterpart used by
+classifier-free guidance: the transcription is replaced with repeated
+``<unk>`` tokens, iteratively adjusted so the tokenized null prompt is
+exactly as long as the conditional prompt (the CFG pair must decode the
+same positions).
+"""
+
+AUDEX_SYSTEM_PROMPT = "You are a helpful and harmless assistant.\n\nYou are not allowed to use any tools."
+
+# ``{text}`` carries its own leading whitespace: the conditional prompt uses
+# " {transcription}" (matching the official script byte-for-byte), while the
+# CFG null prompt inserts the bare ``<unk>`` run. ``<unk>`` is a special
+# token, so a leading space would tokenize as a standalone space token and
+# make some conditional lengths unreachable by whole-``<unk>`` steps.
+_TTS_PROMPT_TEMPLATE = (
+    "<|im_start|>system\n{system_prompt}<|im_end|>\n"
+    "<|im_start|>user\n<|text to speech|> Generate speech for this transcription.{text}<|im_end|>\n"
+    "<|im_start|>assistant\n<think></think><speechgen_start>"
+)
+
+_TTA_PROMPT_TEMPLATE = (
+    "<|im_start|>system\n{system_prompt}<|im_end|>\n"
+    "<|im_start|>user\n<|text to audio|> Generate audio for this caption.{text}<|im_end|>\n"
+    "<|im_start|>assistant\n<think></think><audiogen_start>"
+)
+
+
+def build_cond_prompt(text: str) -> str:
+    """Build the conditional TTS prompt for one transcription."""
+    text = text.strip()
+    if not text:
+        raise ValueError("Audex TTS requires non-empty input text")
+    return _TTS_PROMPT_TEMPLATE.format(system_prompt=AUDEX_SYSTEM_PROMPT, text=f" {text}")
+
+
+def build_tta_cond_prompt(caption: str) -> str:
+    """Build the conditional TTA prompt for one audio caption."""
+    caption = caption.strip()
+    if not caption:
+        raise ValueError("Audex TTA requires a non-empty caption")
+    return _TTA_PROMPT_TEMPLATE.format(system_prompt=AUDEX_SYSTEM_PROMPT, text=f" {caption}")
+
+
+def _length_matched_null(cond_prompt: str, tokenizer, template: str, max_iters: int) -> str:
+    target_len = len(tokenizer.encode(cond_prompt))
+    n_unk = 1
+    for _ in range(max_iters):
+        prompt = template.format(system_prompt=AUDEX_SYSTEM_PROMPT, text="<unk>" * n_unk)
+        diff = target_len - len(tokenizer.encode(prompt))
+        if diff == 0:
+            return prompt
+        n_unk = max(1, n_unk + diff)
+        if diff < 0 and n_unk == 1:
+            break
+    raise ValueError(f"Could not length-match the CFG null prompt to {target_len} tokens")
+
+
+def build_null_prompt(cond_prompt: str, tokenizer, max_iters: int = 64) -> str:
+    """Unconditional TTS prompt for CFG (length-matched ``<unk>`` padding).
+
+    Replaces the transcription with ``<unk>`` repeated, adjusting the count
+    until ``tokenizer.encode`` yields exactly the conditional prompt's
+    length. Raises when no count matches so callers can fail the request
+    instead of submitting a misaligned pair.
+    """
+    return _length_matched_null(cond_prompt, tokenizer, _TTS_PROMPT_TEMPLATE, max_iters)
+
+
+def build_tta_null_prompt(cond_prompt: str, tokenizer, max_iters: int = 64) -> str:
+    """Unconditional TTA prompt for CFG (length-matched ``<unk>`` padding)."""
+    return _length_matched_null(cond_prompt, tokenizer, _TTA_PROMPT_TEMPLATE, max_iters)
diff --git a/vllm_omni/model_executor/models/audex/speech_decoder/__init__.py b/vllm_omni/model_executor/models/audex/speech_decoder/__init__.py
new file mode 100644
index 000000000..329c19233
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/speech_decoder/__init__.py
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+"""Vendored Audex causal speech decoder (Apache-2.0).
+
+Verbatim copy of the ``audex_causal_speech_decoder`` remote-code package from
+nvidia/Nemotron-Labs-Audex-2B. Vendored because transformers' dynamic module
+loader resolves HuggingFace-cache blob symlinks to their real paths, which
+breaks the package's relative imports when loading with trust_remote_code
+directly from a hub snapshot.
+"""
+
+from .configuration_audex_causal_speech_decoder import AudexCausalSpeechDecoderConfig
+from .modeling_audex_causal_speech_decoder import (
+    AudexCausalSpeechDecoderModel,
+    AudexCausalSpeechDecoderSession,
+)
+
+__all__ = [
+    "AudexCausalSpeechDecoderConfig",
+    "AudexCausalSpeechDecoderModel",
+    "AudexCausalSpeechDecoderSession",
+]
diff --git a/vllm_omni/model_executor/models/audex/speech_decoder/configuration_audex_causal_speech_decoder.py b/vllm_omni/model_executor/models/audex/speech_decoder/configuration_audex_causal_speech_decoder.py
new file mode 100644
index 000000000..7895fcdea
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/speech_decoder/configuration_audex_causal_speech_decoder.py
@@ -0,0 +1,50 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from transformers import PretrainedConfig
+
+
+class AudexCausalSpeechDecoderConfig(PretrainedConfig):
+    model_type = "audex_causal_speech_decoder"
+
+    def __init__(
+        self,
+        hidden_dim: int = 2048,
+        depth: int = 12,
+        heads: int = 32,
+        pos_meb_dim: int = 64,
+        hop_length: int = 320,
+        vq_dim: int = 2048,
+        lookahead_steps: int = 4,
+        sample_rate: int = 16000,
+        codebook_levels: list[int] | None = None,
+        codebook_size: int = 65536,
+        token_embed_dim: int = 8,
+        embed_tokens_from_codes: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.hidden_dim = hidden_dim
+        self.depth = depth
+        self.heads = heads
+        self.pos_meb_dim = pos_meb_dim
+        self.hop_length = hop_length
+        self.vq_dim = vq_dim
+        self.lookahead_steps = lookahead_steps
+        self.sample_rate = sample_rate
+        self.codebook_levels = codebook_levels or [4, 4, 4, 4, 4, 4, 4, 4]
+        self.codebook_size = codebook_size
+        self.token_embed_dim = token_embed_dim
+        self.embed_tokens_from_codes = embed_tokens_from_codes
diff --git a/vllm_omni/model_executor/models/audex/speech_decoder/modeling_audex_causal_speech_decoder.py b/vllm_omni/model_executor/models/audex/speech_decoder/modeling_audex_causal_speech_decoder.py
new file mode 100644
index 000000000..3e6ea97fa
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/speech_decoder/modeling_audex_causal_speech_decoder.py
@@ -0,0 +1,478 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from transformers import PreTrainedModel
+
+from .configuration_audex_causal_speech_decoder import AudexCausalSpeechDecoderConfig
+from .streaming_utils import load_audex_causal_speech_decoder as _load_decoder_for_remote_code
+
+REMOTE_CODE_IMPORTS = (_load_decoder_for_remote_code,)
+
+
+class RotaryPositionalEmbeddings(nn.Module):
+    def __init__(self, dim: int, max_seq_len: int = 4096, base: int = 10_000) -> None:
+        super().__init__()
+        self.dim = dim
+        self.base = base
+        self.max_seq_len = max_seq_len
+        self.rope_init()
+        self._rope_ready = False
+
+    def rope_init(self, device: torch.device | None = None) -> None:
+        theta = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, device=device)[: (self.dim // 2)].float() / self.dim))
+        self.register_buffer("theta", theta, persistent=False)
+        self.build_rope_cache(self.max_seq_len)
+
+    def build_rope_cache(self, max_seq_len: int = 4096) -> None:
+        self.max_seq_len = max_seq_len
+        seq_idx = torch.arange(max_seq_len, dtype=self.theta.dtype, device=self.theta.device)
+        idx_theta = torch.einsum("i, j -> ij", seq_idx, self.theta).float()
+        cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1)
+        self.register_buffer("cache", cache, persistent=False)
+
+    def forward(self, x: torch.Tensor, *, input_pos: torch.Tensor | None = None) -> torch.Tensor:
+        seq_len = x.size(1)
+        needed_seq_len = seq_len if input_pos is None else int(input_pos.max().item()) + 1
+        if (
+            not getattr(self, "_rope_ready", False)
+            or self.theta.device != x.device
+            or needed_seq_len > self.cache.size(0)
+        ):
+            self.rope_init(device=x.device)
+            if needed_seq_len > self.cache.size(0):
+                self.build_rope_cache(max(needed_seq_len, self.cache.size(0) * 2))
+            self._rope_ready = True
+
+        rope_cache = self.cache[:seq_len] if input_pos is None else self.cache[input_pos]
+        xshaped = x.float().reshape(*x.shape[:-1], -1, 2)
+        rope_cache = rope_cache.view(-1, xshaped.size(1), 1, xshaped.size(3), 2)
+        x_out = torch.stack(
+            [
+                xshaped[..., 0] * rope_cache[..., 0] - xshaped[..., 1] * rope_cache[..., 1],
+                xshaped[..., 1] * rope_cache[..., 0] + xshaped[..., 0] * rope_cache[..., 1],
+            ],
+            -1,
+        )
+        return x_out.flatten(3).type_as(x)
+
+
+class CausalCodecDecoderCache:
+    def __init__(self) -> None:
+        self.key_values: dict[int, tuple[Tensor, Tensor]] = {}
+        self.position = 0
+
+    def input_positions(self, length: int, device: torch.device) -> Tensor:
+        return torch.arange(self.position, self.position + length, device=device).unsqueeze(0)
+
+    def update(self, layer_idx: int, key: Tensor, value: Tensor) -> tuple[Tensor, Tensor]:
+        if layer_idx in self.key_values:
+            prev_key, prev_value = self.key_values[layer_idx]
+            key = torch.cat([prev_key, key], dim=2)
+            value = torch.cat([prev_value, value], dim=2)
+        self.key_values[layer_idx] = (key, value)
+        return key, value
+
+    def advance(self, length: int) -> None:
+        self.position += length
+
+    def reset(self) -> None:
+        self.key_values.clear()
+        self.position = 0
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        norm_x = torch.mean(x**2, dim=-1, keepdim=True)
+        return x * torch.rsqrt(norm_x + self.eps) * self.weight
+
+
+class MLP(nn.Module):
+    def __init__(self, dim: int) -> None:
+        super().__init__()
+        self.fc1 = nn.Linear(dim, 4 * dim, bias=False)
+        self.silu = nn.SiLU()
+        self.fc2 = nn.Linear(4 * dim, dim, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.fc2(self.silu(self.fc1(x)))
+
+
+class Attention(nn.Module):
+    def __init__(self, dim: int, n_heads: int, rotary_embed: RotaryPositionalEmbeddings, layer_idx: int):
+        super().__init__()
+        if dim % n_heads != 0:
+            raise ValueError(f"dim must be divisible by n_heads, got dim={dim}, n_heads={n_heads}")
+        self.n_heads = n_heads
+        self.layer_idx = layer_idx
+        self.rotary_embed = rotary_embed
+        self.c_attn = nn.Linear(dim, 3 * dim, bias=False)
+        self.c_proj = nn.Linear(dim, dim, bias=False)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cache: CausalCodecDecoderCache | None = None,
+        input_pos: Tensor | None = None,
+    ) -> torch.Tensor:
+        batch_size, seq_len, _ = x.shape
+        qkv = self.c_attn(x)
+        head_dim = qkv.size(-1) // (3 * self.n_heads)
+        qkv = qkv.view(batch_size, seq_len, 3, self.n_heads, head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+
+        q = self.rotary_embed(q.transpose(1, 2), input_pos=input_pos).transpose(1, 2)
+        k = self.rotary_embed(k.transpose(1, 2), input_pos=input_pos).transpose(1, 2)
+        if cache is None:
+            y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        else:
+            if input_pos is None:
+                raise ValueError("input_pos is required when cache is set")
+            k, v = cache.update(self.layer_idx, k, v)
+            key_pos = torch.arange(k.size(2), device=x.device).view(1, 1, 1, -1)
+            attn_mask = key_pos <= input_pos.view(input_pos.size(0), 1, -1, 1)
+            y = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask)
+        return self.c_proj(y.transpose(1, 2).contiguous().view(batch_size, seq_len, -1))
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, dim: int, n_heads: int, rotary_embed: RotaryPositionalEmbeddings, layer_idx: int):
+        super().__init__()
+        self.att_norm = RMSNorm(dim)
+        self.ffn_norm = RMSNorm(dim)
+        self.att = Attention(dim=dim, n_heads=n_heads, rotary_embed=rotary_embed, layer_idx=layer_idx)
+        self.mlp = MLP(dim=dim)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cache: CausalCodecDecoderCache | None = None,
+        input_pos: Tensor | None = None,
+    ) -> torch.Tensor:
+        x = x + self.att(self.att_norm(x), cache=cache, input_pos=input_pos)
+        return x + self.mlp(self.ffn_norm(x))
+
+
+class PatchHead(nn.Module):
+    def __init__(self, dim: int, hop_length: int = 320):
+        super().__init__()
+        self.proj = nn.Linear(dim, hop_length, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = torch.tanh(self.proj(x))
+        return x.reshape(x.size(0), 1, -1)
+
+
+class CausalVocosBackbone(nn.Module):
+    def __init__(
+        self,
+        hidden_dim: int = 2048,
+        depth: int = 12,
+        heads: int = 32,
+        pos_meb_dim: int = 64,
+    ):
+        super().__init__()
+        rotary_embed = RotaryPositionalEmbeddings(dim=pos_meb_dim)
+        self.transformers = nn.ModuleList(
+            [
+                TransformerBlock(dim=hidden_dim, n_heads=heads, rotary_embed=rotary_embed, layer_idx=idx)
+                for idx in range(depth)
+            ]
+        )
+        self.final_layer_norm = RMSNorm(hidden_dim)
+
+    def forward(self, x: torch.Tensor, cache: CausalCodecDecoderCache | None = None) -> torch.Tensor:
+        input_pos = None
+        if cache is not None:
+            input_pos = cache.input_positions(x.size(1), x.device).expand(x.size(0), -1)
+        for block in self.transformers:
+            x = block(x, cache=cache, input_pos=input_pos)
+        if cache is not None:
+            cache.advance(x.size(1))
+        return self.final_layer_norm(x)
+
+
+class CausalCodecDecoderVocos(nn.Module):
+    def __init__(
+        self,
+        hidden_dim: int = 2048,
+        depth: int = 12,
+        heads: int = 32,
+        pos_meb_dim: int = 64,
+        hop_length: int = 320,
+        vq_dim: int = 2048,
+        lookahead_steps: int = 0,
+    ):
+        super().__init__()
+        if lookahead_steps < 0:
+            raise ValueError(f"lookahead_steps must be >= 0, got {lookahead_steps}")
+
+        self.wav_proj = nn.Linear(hop_length, hidden_dim, bias=False)
+        self.fc_post_a = nn.Linear(vq_dim, hidden_dim, bias=False)
+        self.lookahead_steps = lookahead_steps
+        if lookahead_steps > 0:
+            self.lookahead_conv = nn.Conv1d(
+                hidden_dim,
+                hidden_dim,
+                kernel_size=lookahead_steps + 1,
+                padding=0,
+                groups=hidden_dim,
+                bias=False,
+            )
+            self.lookahead_act = nn.SiLU()
+            self.lookahead_proj = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=1, bias=False)
+            nn.init.zeros_(self.lookahead_proj.weight)
+        else:
+            self.lookahead_conv = None
+            self.lookahead_act = None
+            self.lookahead_proj = None
+        self.backbone = CausalVocosBackbone(hidden_dim, depth, heads, pos_meb_dim)
+        self.head = PatchHead(hidden_dim, hop_length)
+
+    def _project_tokens(self, vq_emb: torch.Tensor) -> torch.Tensor:
+        return self.fc_post_a(vq_emb)
+
+    def _apply_lookahead(self, x: torch.Tensor) -> torch.Tensor:
+        if self.lookahead_conv is None:
+            return x
+        if self.lookahead_act is None or self.lookahead_proj is None:
+            raise RuntimeError("lookahead modules are not initialized")
+        h = F.pad(x.transpose(1, 2), (0, self.lookahead_steps))
+        h = self.lookahead_proj(self.lookahead_act(self.lookahead_conv(h)))
+        return x + h.transpose(1, 2)
+
+    def _apply_lookahead_window(self, x: torch.Tensor) -> torch.Tensor:
+        if self.lookahead_conv is None:
+            return x
+        if self.lookahead_act is None or self.lookahead_proj is None:
+            raise RuntimeError("lookahead modules are not initialized")
+        if x.size(1) <= self.lookahead_steps:
+            raise ValueError(f"lookahead window needs more than {self.lookahead_steps} frames, got {x.size(1)}")
+        h = self.lookahead_proj(self.lookahead_act(self.lookahead_conv(x.transpose(1, 2))))
+        return x[:, : h.size(2)] + h.transpose(1, 2)
+
+    def decode_cached(
+        self,
+        vq_emb: torch.Tensor,
+        cache: CausalCodecDecoderCache,
+        lookahead_vq_emb: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        x = self._project_tokens(vq_emb)
+        if self.lookahead_steps > 0:
+            if lookahead_vq_emb is None:
+                lookahead_vq_emb = vq_emb.new_zeros(vq_emb.size(0), self.lookahead_steps, vq_emb.size(-1))
+            if lookahead_vq_emb.size(1) != self.lookahead_steps:
+                raise ValueError(
+                    f"lookahead_vq_emb must have {self.lookahead_steps} frames, got {lookahead_vq_emb.size(1)}"
+                )
+            lookahead_x = self._project_tokens(lookahead_vq_emb)
+            x = self._apply_lookahead_window(torch.cat([x, lookahead_x], dim=1))
+        x = self.backbone(x, cache=cache)
+        return self.head(x)
+
+    def forward(
+        self,
+        vq_emb: torch.Tensor,
+        patched_wav: torch.Tensor | None = None,
+        alpha: float = 0.0,
+    ) -> torch.Tensor:
+        x = self._project_tokens(vq_emb)
+        x = self._apply_lookahead(x)
+        if patched_wav is not None:
+            h = self.wav_proj(patched_wav)
+            mask = torch.bernoulli(
+                torch.full(
+                    (x.size(0), x.size(1), 1),
+                    min(max(alpha, 0.0), 1.0),
+                    device=x.device,
+                    dtype=x.dtype,
+                )
+            )
+            x = x + h * mask
+        return self.head(self.backbone(x))
+
+
+class AudexSpeechTokenEmbedder(nn.Module):
+    def __init__(
+        self,
+        output_dim: int,
+        token_embed_dim: int,
+        codebook_levels: Sequence[int],
+    ) -> None:
+        super().__init__()
+        if len(codebook_levels) != token_embed_dim:
+            raise ValueError(
+                f"token_embed_dim={token_embed_dim} must match codebook_levels length={len(codebook_levels)}"
+            )
+        self.codebook_levels = tuple(int(level) for level in codebook_levels)
+        self.project_out = nn.Linear(token_embed_dim, output_dim)
+
+    def forward(self, indices: torch.Tensor) -> torch.Tensor:
+        if indices.size(-1) != 1:
+            raise ValueError(f"indices last dimension must be 1, got {indices.size(-1)}")
+        levels = torch.tensor(self.codebook_levels, dtype=torch.long, device=indices.device)
+        basis = torch.cumprod(torch.cat([levels.new_ones(1), levels[:-1]]), dim=0)
+        level_indices = (indices.long() // basis) % levels
+        dtype = self.project_out.weight.dtype
+        codes = level_indices.to(dtype=dtype)
+        levels = levels.to(dtype=dtype)
+        codes = codes * (2.0 / (levels - 1.0)) - 1.0
+        return self.project_out(codes)
+
+    def get_output_from_indices(self, indices: torch.Tensor) -> torch.Tensor:
+        return self(indices)
+
+
+class AudexCausalSpeechDecoderModel(PreTrainedModel):
+    config_class = AudexCausalSpeechDecoderConfig
+    base_model_prefix = "module"
+    all_tied_weights_keys: dict[str, Any] = {}
+    Cache = CausalCodecDecoderCache
+
+    def __init__(self, config: AudexCausalSpeechDecoderConfig):
+        super().__init__(config)
+        self.audex_speech_token_embedder = AudexSpeechTokenEmbedder(
+            output_dim=config.vq_dim,
+            token_embed_dim=config.token_embed_dim,
+            codebook_levels=config.codebook_levels,
+        )
+        self.module = CausalCodecDecoderVocos(
+            hidden_dim=config.hidden_dim,
+            depth=config.depth,
+            heads=config.heads,
+            pos_meb_dim=config.pos_meb_dim,
+            hop_length=config.hop_length,
+            vq_dim=config.vq_dim,
+            lookahead_steps=config.lookahead_steps,
+        )
+
+    @property
+    def lookahead_steps(self) -> int:
+        return self.module.lookahead_steps
+
+    def create_cache(self) -> CausalCodecDecoderCache:
+        return CausalCodecDecoderCache()
+
+    def decode_cached(
+        self,
+        vq_emb: torch.Tensor,
+        cache: CausalCodecDecoderCache,
+        lookahead_vq_emb: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        return self.module.decode_cached(vq_emb, cache, lookahead_vq_emb=lookahead_vq_emb)
+
+    def create_session(
+        self,
+        *,
+        chunk_frames: int = 1,
+        sample_rate: int | None = None,
+        return_numpy: bool = True,
+    ) -> AudexCausalSpeechDecoderSession:
+        return AudexCausalSpeechDecoderSession(
+            decoder=self,
+            chunk_frames=chunk_frames,
+            sample_rate=sample_rate or self.config.sample_rate,
+            return_numpy=return_numpy,
+        )
+
+    def forward(
+        self,
+        vq_emb: torch.Tensor,
+        patched_wav: torch.Tensor | None = None,
+        alpha: float = 0.0,
+    ) -> torch.Tensor:
+        return self.module(vq_emb, patched_wav=patched_wav, alpha=alpha)
+
+
+class AudexCausalSpeechDecoderSession:
+    def __init__(
+        self,
+        decoder: AudexCausalSpeechDecoderModel,
+        *,
+        chunk_frames: int,
+        sample_rate: int,
+        return_numpy: bool,
+    ):
+        if chunk_frames <= 0:
+            raise ValueError(f"chunk_frames must be positive, got {chunk_frames}")
+        self.decoder = decoder
+        self.chunk_frames = chunk_frames
+        self.sample_rate = sample_rate
+        self.return_numpy = return_numpy
+        self.cache = decoder.create_cache()
+        self.buffer: list[list[int]] = []
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.decoder.parameters()).device
+
+    def reset(self) -> None:
+        self.cache = self.decoder.create_cache()
+        self.buffer.clear()
+
+    def push(self, token_frames: Sequence[Sequence[int]]) -> Iterator[tuple[int, Any]]:
+        self.buffer.extend(list(frame) for frame in token_frames)
+        yield from self._drain(flush=False)
+
+    def flush(self) -> Iterator[tuple[int, Any]]:
+        yield from self._drain(flush=True)
+
+    def _drain(self, *, flush: bool) -> Iterator[tuple[int, Any]]:
+        ready_frames = len(self.buffer) - self.decoder.lookahead_steps
+        while self.buffer and (flush or ready_frames >= self.chunk_frames):
+            emit_frames = min(self.chunk_frames, len(self.buffer)) if flush else self.chunk_frames
+            wav = self._decode_buffered_frames(emit_frames, flush=flush)
+            del self.buffer[:emit_frames]
+            ready_frames = len(self.buffer) - self.decoder.lookahead_steps
+            yield self.sample_rate, self._format_chunk(wav)
+
+    def _embed_speech_token_frames(self, token_frames: Sequence[Sequence[int]]) -> torch.Tensor:
+        indices = torch.tensor(token_frames, dtype=torch.long, device=self.device).unsqueeze(0)
+        return self.decoder.audex_speech_token_embedder.get_output_from_indices(indices)
+
+    def _decode_buffered_frames(self, emit_frames: int, *, flush: bool) -> torch.Tensor:
+        with torch.inference_mode():
+            vq_emb = self._embed_speech_token_frames(self.buffer[:emit_frames])
+            lookahead_vq_emb = None
+            if self.decoder.lookahead_steps > 0:
+                future_frames = self.buffer[emit_frames : emit_frames + self.decoder.lookahead_steps]
+                future_parts = []
+                if future_frames:
+                    future_parts.append(self._embed_speech_token_frames(future_frames))
+                missing_frames = self.decoder.lookahead_steps - len(future_frames) if flush else 0
+                if missing_frames > 0:
+                    future_parts.append(vq_emb.new_zeros(vq_emb.size(0), missing_frames, vq_emb.size(-1)))
+                lookahead_vq_emb = torch.cat(future_parts, dim=1) if future_parts else None
+            return self.decoder.decode_cached(vq_emb, self.cache, lookahead_vq_emb=lookahead_vq_emb)
+
+    def _format_chunk(self, wav: torch.Tensor) -> Any:
+        chunk = wav.squeeze().float().detach().cpu()
+        if not self.return_numpy:
+            return chunk
+
+        import numpy as np
+
+        return chunk.numpy().astype(np.float32, copy=False)
diff --git a/vllm_omni/model_executor/models/audex/speech_decoder/streaming_utils.py b/vllm_omni/model_executor/models/audex/speech_decoder/streaming_utils.py
new file mode 100644
index 000000000..31c5a108c
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/speech_decoder/streaming_utils.py
@@ -0,0 +1,140 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, AsyncIterator, Iterable, Iterator, Sequence
+from typing import TYPE_CHECKING, Any
+
+import torch
+from transformers import AutoModel
+
+if TYPE_CHECKING:
+    from .modeling_audex_causal_speech_decoder import AudexCausalSpeechDecoderModel
+
+
+def freeze_model(model: torch.nn.Module) -> torch.nn.Module:
+    model.eval()
+    for param in model.parameters():
+        param.requires_grad = False
+    return model
+
+
+def load_audex_causal_speech_decoder(
+    model_path: str,
+    *,
+    device: torch.device | str = "cuda",
+    dtype: torch.dtype | str | None = None,
+) -> AudexCausalSpeechDecoderModel:
+    kwargs = {"trust_remote_code": True}
+    if dtype is not None:
+        kwargs["torch_dtype"] = dtype
+    model = AutoModel.from_pretrained(model_path, **kwargs)
+    return freeze_model(model.to(device))
+
+
+def _decoder_device(decoder: AudexCausalSpeechDecoderModel) -> torch.device:
+    return next(decoder.parameters()).device
+
+
+def _embed_speech_token_frames(
+    decoder: AudexCausalSpeechDecoderModel,
+    token_frames: Sequence[Sequence[int]],
+    device: torch.device,
+) -> torch.Tensor:
+    indices = torch.tensor(token_frames, dtype=torch.long, device=device).unsqueeze(0)
+    return decoder.audex_speech_token_embedder.get_output_from_indices(indices)
+
+
+def decode_speech_token_frames(
+    token_frames: Iterable[Sequence[int]],
+    decoder: AudexCausalSpeechDecoderModel,
+    *,
+    device: torch.device | str | None = None,
+    chunk_frames: int = 1,
+) -> Iterator[torch.Tensor]:
+    if chunk_frames <= 0:
+        raise ValueError(f"chunk_frames must be positive, got {chunk_frames}")
+
+    device = torch.device(device) if device is not None else _decoder_device(decoder)
+    cache = decoder.create_cache()
+    buffer: list[list[int]] = []
+    lookahead_steps = decoder.lookahead_steps
+
+    for token_frame in token_frames:
+        buffer.append(list(token_frame))
+        while len(buffer) > lookahead_steps:
+            emit_frames = min(chunk_frames, len(buffer) - lookahead_steps)
+            wav = _decode_buffered_frames(decoder, cache, buffer, emit_frames, device, flush=False)
+            del buffer[:emit_frames]
+            yield wav
+
+    while buffer:
+        emit_frames = min(chunk_frames, len(buffer))
+        wav = _decode_buffered_frames(decoder, cache, buffer, emit_frames, device, flush=True)
+        del buffer[:emit_frames]
+        yield wav
+
+
+async def decode_speech_token_stream(
+    token_stream: AsyncIterable[Sequence[int]],
+    decoder: AudexCausalSpeechDecoderModel,
+    *,
+    device: torch.device | str | None = None,
+    chunk_frames: int = 1,
+) -> AsyncIterator[torch.Tensor]:
+    if chunk_frames <= 0:
+        raise ValueError(f"chunk_frames must be positive, got {chunk_frames}")
+
+    device = torch.device(device) if device is not None else _decoder_device(decoder)
+    cache = decoder.create_cache()
+    buffer: list[list[int]] = []
+    lookahead_steps = decoder.lookahead_steps
+
+    async for token_frame in token_stream:
+        buffer.append(list(token_frame))
+        while len(buffer) > lookahead_steps:
+            emit_frames = min(chunk_frames, len(buffer) - lookahead_steps)
+            wav = _decode_buffered_frames(decoder, cache, buffer, emit_frames, device, flush=False)
+            del buffer[:emit_frames]
+            yield wav
+
+    while buffer:
+        emit_frames = min(chunk_frames, len(buffer))
+        wav = _decode_buffered_frames(decoder, cache, buffer, emit_frames, device, flush=True)
+        del buffer[:emit_frames]
+        yield wav
+
+
+def _decode_buffered_frames(
+    decoder: AudexCausalSpeechDecoderModel,
+    cache: Any,
+    buffer: Sequence[Sequence[int]],
+    emit_frames: int,
+    device: torch.device,
+    *,
+    flush: bool,
+) -> torch.Tensor:
+    with torch.inference_mode():
+        vq_emb = _embed_speech_token_frames(decoder, buffer[:emit_frames], device)
+        lookahead_vq_emb = None
+        if decoder.lookahead_steps > 0:
+            future_frames = buffer[emit_frames : emit_frames + decoder.lookahead_steps]
+            future_parts = []
+            if future_frames:
+                future_parts.append(_embed_speech_token_frames(decoder, future_frames, device))
+            missing_frames = decoder.lookahead_steps - len(future_frames) if flush else 0
+            if missing_frames > 0:
+                future_parts.append(vq_emb.new_zeros(vq_emb.size(0), missing_frames, vq_emb.size(-1)))
+            lookahead_vq_emb = torch.cat(future_parts, dim=1) if future_parts else None
+        return decoder.decode_cached(vq_emb, cache, lookahead_vq_emb=lookahead_vq_emb)
diff --git a/vllm_omni/model_executor/models/audex/tta.py b/vllm_omni/model_executor/models/audex/tta.py
new file mode 100644
index 000000000..1cabe3fd1
--- /dev/null
+++ b/vllm_omni/model_executor/models/audex/tta.py
@@ -0,0 +1,293 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+#
+# Adapted from nvidia/Nemotron-Labs-Audex-2B (Apache-2.0):
+#   inference_scripts_vllm/audiogen_scripts/tta_rvq_logits_processor.py
+#   inference_scripts_vllm/audiogen_scripts/run_audio_gen_vllm_rvq_logit_mask.py
+# Divergences from the official files are commented at the divergence site.
+"""Audex text-to-audio (TTA) token space: RVQ phase masking and helpers.
+
+TTA output is an interleaved 4-codebook RVQ stream over ``<audiocodec_N>``
+tokens: generated position ``p`` (counted from ``<audiogen_start>``) must
+come from codebook ``p % 4``, whose codec-id range is
+``[phase * 1024, (phase + 1) * 1024)``. The tokenizer defines 8192
+``<audiocodec_*>`` symbols; only codec ids 0..4095 (the 4 quantizers XCodec1
+decodes) are generated — the upper half stays disallowed.
+
+Unguided/unmasked sampling emits phase-invalid sequences that XCodec1 cannot
+decode, so :class:`TTARVQPhaseMaskLogitsProcessor` is required for validity,
+driven per request by ``SamplingParams.extra_args["tta_rvq"]``:
+
+    {
+        "phase_token_ids": [[...1024 ids...] x 4],
+        "start_tid": <audiogen_start id>,
+        "end_tid": <audiogen_end id>,
+        "codec_cap": <max codec tokens or None>,
+        "start_in_prompt": <bool>,
+    }
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import torch
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+from vllm.v1.sample.logits_processor import (
+    BatchUpdate,
+    LogitsProcessor,
+    MoveDirectionality,
+)
+
+logger = init_logger(__name__)
+
+NEG_INF = float("-inf")
+XCODEC1_NUM_CODEBOOKS = 4
+XCODEC1_CODEBOOK_SIZE = 1024
+
+# Pinned by a unit test against the real checkpoint tokenizer.
+AUDEX_AUDIOGEN_START_TOKEN_ID = 131073
+AUDEX_AUDIOGEN_END_TOKEN_ID = 131074
+AUDEX_AUDIOCODEC_TOKEN_OFFSET = 196613
+AUDEX_AUDIOCODEC_VOCAB_SIZE = 8192
+
+
+def build_tta_phase_token_ids(tokenizer: Any) -> tuple[list[list[int]], int, int]:
+    """Group tokenizer ids of ``<audiocodec_N>`` into the 4 RVQ phases.
+
+    Phase ``p`` collects the tokenizer ids for codec ids
+    ``[p*1024, (p+1)*1024)``. Fails loudly on missing markers or an
+    incomplete codec vocab.
+
+    Returns ``(phase_token_ids, audiogen_start_tid, audiogen_end_tid)``.
+    """
+    vocab = tokenizer.get_vocab()
+    start_tid = vocab.get("<audiogen_start>")
+    end_tid = vocab.get("<audiogen_end>")
+    if start_tid is None or end_tid is None:
+        raise ValueError(f"Missing marker token ids: audiogen_start={start_tid}, audiogen_end={end_tid}")
+
+    phase_token_ids: list[list[int]] = []
+    for phase in range(XCODEC1_NUM_CODEBOOKS):
+        ids: list[int] = []
+        missing: list[int] = []
+        for codec_id in range(phase * XCODEC1_CODEBOOK_SIZE, (phase + 1) * XCODEC1_CODEBOOK_SIZE):
+            tok = vocab.get(f"<audiocodec_{codec_id}>")
+            if tok is None:
+                missing.append(codec_id)
+            else:
+                ids.append(tok)
+        if missing:
+            raise ValueError(
+                f"Incomplete codec vocab for RVQ phase {phase}: missing {len(missing)} codec ids (e.g. {missing[:5]})"
+            )
+        phase_token_ids.append(ids)
+
+    return phase_token_ids, int(start_tid), int(end_tid)
+
+
+def validate_rvq_phase(
+    codec_ids: list[int],
+    codebook_size: int = XCODEC1_CODEBOOK_SIZE,
+    num_codebooks: int = XCODEC1_NUM_CODEBOOKS,
+) -> dict[str, Any]:
+    """Check that ``codec_ids[i]`` falls in RVQ phase ``i % 4``'s codec range."""
+    mismatch_count = 0
+    first_mismatch = None
+    for i, codec_id in enumerate(codec_ids):
+        expected = i % num_codebooks
+        lo = expected * codebook_size
+        if not (lo <= codec_id < lo + codebook_size):
+            mismatch_count += 1
+            if first_mismatch is None:
+                first_mismatch = [i, int(codec_id), int(codec_id // codebook_size), int(expected)]
+    return {
+        "phase_valid": mismatch_count == 0,
+        "mismatch_count": mismatch_count,
+        "first_mismatch": first_mismatch,
+        "codec_count": len(codec_ids),
+    }
+
+
+class TTARVQPhaseMaskLogitsProcessor(LogitsProcessor):
+    """Mask logits to the RVQ-phase-valid token set for Audex TTA requests.
+
+    Per batch row:
+      ``_req[idx]``           -> {"start_tid", "end_tid", "codec_cap", "start_in_prompt"}
+      ``_output_tokens[idx]`` -> live reference to the request's output ids
+      ``_start_pos[idx]``     -> cached index of <audiogen_start> once seen;
+                                 -1 means the prompt already ended with it.
+
+    The disallow masks are vocab-sized boolean tensors built once on the
+    first ``apply`` (using the real ``logits.shape[-1]`` so vocab padding is
+    also forbidden).
+    """
+
+    def __init__(self, vllm_config: VllmConfig, device: torch.device, is_pin_memory: bool) -> None:
+        self.device = device
+        self._req: dict[int, dict[str, Any]] = {}
+        self._output_tokens: dict[int, list[int]] = {}
+        self._start_pos: dict[int, int] = {}
+
+        self._phase_token_ids: list[list[int]] | None = None
+        self._mask_end_tid: int | None = None
+
+        self._disallow_phase: torch.Tensor | None = None
+        self._disallow_phase0_end: torch.Tensor | None = None
+        self._disallow_except_end: torch.Tensor | None = None
+
+    def is_argmax_invariant(self) -> bool:
+        return False
+
+    def _reset(self) -> None:
+        self._req.clear()
+        self._output_tokens.clear()
+        self._start_pos.clear()
+
+    def update_state(self, batch_update: BatchUpdate | None) -> None:
+        if batch_update is None:
+            return
+
+        for idx in batch_update.removed:
+            self._req.pop(idx, None)
+            self._output_tokens.pop(idx, None)
+            self._start_pos.pop(idx, None)
+
+        if not self._req and batch_update.added:
+            self._reset()
+
+        for idx, params, _, output_token_ids in batch_update.added:
+            extra_args = params.extra_args if params else None
+            tta = extra_args.get("tta_rvq") if extra_args else None
+            if tta:
+                self._req[idx] = {
+                    "start_tid": tta["start_tid"],
+                    "end_tid": tta["end_tid"],
+                    "codec_cap": tta.get("codec_cap"),
+                    "start_in_prompt": bool(tta.get("start_in_prompt", False)),
+                }
+                self._output_tokens[idx] = output_token_ids
+                if self._req[idx]["start_in_prompt"]:
+                    self._start_pos[idx] = -1
+                else:
+                    self._start_pos.pop(idx, None)
+                if self._phase_token_ids is None:
+                    self._phase_token_ids = tta["phase_token_ids"]
+                    self._mask_end_tid = tta["end_tid"]
+            else:
+                self._req.pop(idx, None)
+                self._output_tokens.pop(idx, None)
+                self._start_pos.pop(idx, None)
+
+        if self._req:
+            for src, dst, direction in batch_update.moved:
+                src_req = self._req.pop(src, None)
+                dst_req = self._req.pop(dst, None)
+                src_tokens = self._output_tokens.pop(src, None)
+                dst_tokens = self._output_tokens.pop(dst, None)
+                src_pos = self._start_pos.pop(src, None)
+                dst_pos = self._start_pos.pop(dst, None)
+                if src_req is not None:
+                    self._req[dst] = src_req
+                if src_tokens is not None:
+                    self._output_tokens[dst] = src_tokens
+                if src_pos is not None:
+                    self._start_pos[dst] = src_pos
+                if direction == MoveDirectionality.SWAP:
+                    if dst_req is not None:
+                        self._req[src] = dst_req
+                    if dst_tokens is not None:
+                        self._output_tokens[src] = dst_tokens
+                    if dst_pos is not None:
+                        self._start_pos[src] = dst_pos
+
+    def _build_masks(self, vocab_size: int) -> None:
+        if self._phase_token_ids is None or self._mask_end_tid is None:
+            raise RuntimeError(
+                "TTARVQPhaseMaskLogitsProcessor: phase token ids missing; "
+                "extra_args['tta_rvq'] was not provided for a TTA request."
+            )
+        if len(self._phase_token_ids) != XCODEC1_NUM_CODEBOOKS:
+            raise RuntimeError(
+                f"TTARVQPhaseMaskLogitsProcessor: expected {XCODEC1_NUM_CODEBOOKS} phase id "
+                f"lists, got {len(self._phase_token_ids)}."
+            )
+
+        allow = torch.zeros((XCODEC1_NUM_CODEBOOKS, vocab_size), dtype=torch.bool, device=self.device)
+        for phase, ids in enumerate(self._phase_token_ids):
+            if not ids:
+                raise RuntimeError(f"TTARVQPhaseMaskLogitsProcessor: empty token id list for RVQ phase {phase}.")
+            idx = torch.as_tensor(ids, dtype=torch.long, device=self.device)
+            if int(idx.max()) >= vocab_size or int(idx.min()) < 0:
+                raise RuntimeError(
+                    f"TTARVQPhaseMaskLogitsProcessor: phase {phase} token id out of range for vocab_size={vocab_size}."
+                )
+            allow[phase].index_fill_(0, idx, True)
+
+        end_onehot = torch.zeros(vocab_size, dtype=torch.bool, device=self.device)
+        if self._mask_end_tid < 0 or self._mask_end_tid >= vocab_size:
+            raise RuntimeError(
+                f"TTARVQPhaseMaskLogitsProcessor: end token id out of range "
+                f"for vocab_size={vocab_size}: {self._mask_end_tid}."
+            )
+        end_onehot[self._mask_end_tid] = True
+
+        self._disallow_phase = ~allow
+        self._disallow_phase0_end = ~(allow[0] | end_onehot)
+        self._disallow_except_end = ~end_onehot
+        logger.info(
+            "TTARVQPhaseMaskLogitsProcessor: built masks vocab=%d end_tid=%d (pid=%d)",
+            vocab_size,
+            self._mask_end_tid,
+            os.getpid(),
+        )
+
+    def apply(self, logits: torch.Tensor) -> torch.Tensor:
+        if not self._req:
+            return logits
+
+        if self._disallow_phase is None:
+            self._build_masks(logits.shape[-1])
+
+        num_rows = logits.shape[0]
+        for idx, state in self._req.items():
+            # Rows beyond this step's logits (pure-prefill / partially
+            # scheduled steps) have nothing to mask; the persistent-batch
+            # index re-enters range on the decode steps that sample.
+            if idx >= num_rows:
+                continue
+            tokens = self._output_tokens.get(idx)
+            if tokens is None:
+                continue
+            n = len(tokens)
+
+            start_pos = self._start_pos.get(idx)
+            if start_pos is None:
+                start_tid = state["start_tid"]
+                for i in range(n):
+                    if tokens[i] == start_tid:
+                        start_pos = i
+                        self._start_pos[idx] = i
+                        break
+                if start_pos is None:
+                    continue
+
+            position = n - start_pos - 1
+            if position < 0:
+                continue
+
+            cap = state["codec_cap"]
+            if cap is not None and position >= cap:
+                disallow = self._disallow_except_end
+            else:
+                phase = position & (XCODEC1_NUM_CODEBOOKS - 1)
+                if phase == 0:
+                    disallow = self._disallow_phase0_end if position > 0 else self._disallow_phase[0]
+                else:
+                    disallow = self._disallow_phase[phase]
+
+            logits[idx].masked_fill_(disallow, NEG_INF)
+
+        return logits
diff --git a/vllm_omni/model_executor/models/aura_omni/pipeline.py b/vllm_omni/model_executor/models/aura_omni/pipeline.py
index 273589e1b..14aa5ff30 100644
--- a/vllm_omni/model_executor/models/aura_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/aura_omni/pipeline.py
@@ -24,6 +24,7 @@ _QWEN3_TTS_PROC = "vllm_omni.model_executor.stage_input_processors.qwen3_tts"
 
 AURA_OMNI_PIPELINE = PipelineConfig(
     model_type="aura_omni",
+    default_deploy_config_name="aura_omni.yaml",
     model_arch="Qwen3ASRForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/bagel/pipeline.py b/vllm_omni/model_executor/models/bagel/pipeline.py
index c68a531c2..b0544222f 100644
--- a/vllm_omni/model_executor/models/bagel/pipeline.py
+++ b/vllm_omni/model_executor/models/bagel/pipeline.py
@@ -27,6 +27,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.bagel"
 
 BAGEL_PIPELINE = PipelineConfig(
     model_type="bagel",
+    default_deploy_config_name="bagel.yaml",
     model_arch="OmniBagelForConditionalGeneration",
     hf_architectures=("BagelForConditionalGeneration",),
     stages=(
@@ -63,6 +64,7 @@ BAGEL_PIPELINE = PipelineConfig(
 
 BAGEL_THINK_PIPELINE = PipelineConfig(
     model_type="bagel_think",
+    default_deploy_config_name="bagel_think.yaml",
     model_arch="OmniBagelForConditionalGeneration",
     hf_architectures=(),
     stages=(
@@ -96,6 +98,7 @@ BAGEL_THINK_PIPELINE = PipelineConfig(
 
 BAGEL_SINGLE_STAGE_PIPELINE = PipelineConfig(
     model_type="bagel_single_stage",
+    default_deploy_config_name="bagel_single_stage.yaml",
     model_arch="BagelForConditionalGeneration",
     hf_architectures=(),
     stages=(
diff --git a/vllm_omni/model_executor/models/common/qwen3_code_predictor.py b/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
index 7ac2ba123..1bea2a124 100644
--- a/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
+++ b/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
@@ -89,7 +89,7 @@ def _rotate_half(x: torch.Tensor) -> torch.Tensor:
 
 
 class _RotaryEmbedding(CustomOp):
-    """RoPE with HuggingFace-compatible CPU/CUDA math and cached NPU tables."""
+    """RoPE with cached cos/sin tables; ``forward_native`` keeps the HF on-the-fly math."""
 
     def __init__(self, config) -> None:
         super().__init__()
@@ -101,25 +101,34 @@ class _RotaryEmbedding(CustomOp):
         rope_theta = getattr(config, "rope_theta", 10000.0)
         inv_freq = 1.0 / (rope_theta ** (torch.arange(0, head_dim, 2, dtype=torch.float32) / head_dim))
         self.register_buffer("inv_freq", inv_freq, persistent=False)
-        if current_omni_platform.is_npu():
-            max_seq = int(getattr(config, "num_code_groups", 0) or 0) + 1
-            positions = torch.arange(max_seq, dtype=torch.float32)
-            freqs = torch.outer(positions, inv_freq)
-            emb = torch.cat((freqs, freqs), dim=-1)
-            self.register_buffer("cos_cached", emb.cos(), persistent=False)
-            self.register_buffer("sin_cached", emb.sin(), persistent=False)
+
+        # Build the cos/sin lookup tables once.  ``num_code_groups + 1``
+        # positions cover every re-prefill step of the code predictor.  Compute
+        # in float32 (matching HF) and cast per-call in forward.
+        max_seq = int(getattr(config, "num_code_groups", 0) or 0) + 1
+        positions = torch.arange(max_seq, dtype=torch.float32)
+        freqs = torch.outer(positions, inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos(), persistent=False)
+        self.register_buffer("sin_cached", emb.sin(), persistent=False)
+
+    def _lookup(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        # position_ids: [batch, seq_len] -> cos/sin: [batch, seq_len, head_dim]
+        cos = self.cos_cached[position_ids]
+        sin = self.sin_cached[position_ids]
+        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
 
     def forward_npu(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        return self.cos_cached[position_ids].to(dtype=x.dtype), self.sin_cached[position_ids].to(dtype=x.dtype)
+        return self._lookup(x, position_ids)
 
     def forward_cuda(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        return self.forward_native(x, position_ids)
+        return self._lookup(x, position_ids)
 
     def forward_xpu(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        return self.forward_native(x, position_ids)
+        return self._lookup(x, position_ids)
 
     def forward_native(self, x: torch.Tensor, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        # position_ids: [batch, seq_len]
+        # HuggingFace on-the-fly computation, kept as a numeric reference.
         inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1)
         position_ids_expanded = position_ids[:, None, :].float()
 
diff --git a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
index b3e178565..f2f9a6a0f 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
@@ -73,6 +73,19 @@ def _cosyvoice3_trt_enabled() -> bool:
     return os.environ.get("COSYVOICE3_TRT", "1") not in ("0", "false", "False", "")
 
 
+def _campplus_onnx_providers() -> list[str]:
+    """ONNX-Runtime providers for the campplus speaker-embedding session.
+
+    Prefer ``MUSAExecutionProvider`` (from the onnxruntime-musa build) with a
+    CPU fallback when it is available; otherwise CPU only. The MUSA kernels
+    differ from the CPU reference by a few percent on the embedding, which
+    conditions voice cloning -- verify voice similarity if that matters.
+    """
+    if "MUSAExecutionProvider" in onnxruntime.get_available_providers():
+        return ["MUSAExecutionProvider", "CPUExecutionProvider"]
+    return ["CPUExecutionProvider"]
+
+
 class CosyVoice3MultiModalProcessingInfo(BaseProcessingInfo):
     def get_hf_config(self):
         """If the config is not already present pass it
@@ -163,7 +176,7 @@ class CosyVoice3MultiModalProcessor(BaseMultiModalProcessor[CosyVoice3MultiModal
             campplus_session = onnxruntime.InferenceSession(
                 campplus_onnx_path,
                 sess_options=option,
-                providers=["CPUExecutionProvider"],
+                providers=_campplus_onnx_providers(),
             )
 
         return {
@@ -922,6 +935,7 @@ class CosyVoice3Model(
         if getattr(self, "_code2wav_trt_done", False):
             return
         self._code2wav_trt_done = True
+
         if not (_cosyvoice3_trt_enabled() and torch.cuda.is_available()):
             return
         onnx_path = self._resolve_flow_estimator_onnx()
diff --git a/vllm_omni/model_executor/models/cosyvoice3/pipeline.py b/vllm_omni/model_executor/models/cosyvoice3/pipeline.py
index a8d51fdfe..413dc1dc3 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/pipeline.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/pipeline.py
@@ -22,6 +22,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.cosyvoice3"
 
 COSYVOICE3_PIPELINE = PipelineConfig(
     model_type="cosyvoice3",
+    default_deploy_config_name="cosyvoice3.yaml",
     model_arch="CosyVoice3Model",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/covo_audio/pipeline.py b/vllm_omni/model_executor/models/covo_audio/pipeline.py
index f604bc57d..c2e1911ef 100644
--- a/vllm_omni/model_executor/models/covo_audio/pipeline.py
+++ b/vllm_omni/model_executor/models/covo_audio/pipeline.py
@@ -17,6 +17,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.covo_audio"
 
 COVO_AUDIO_PIPELINE = PipelineConfig(
     model_type="covo_audio",
+    default_deploy_config_name="covo_audio.yaml",
     model_arch="CovoAudioForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/dreamzero/pipeline.py b/vllm_omni/model_executor/models/dreamzero/pipeline.py
index bc815dedc..58ba5b24d 100644
--- a/vllm_omni/model_executor/models/dreamzero/pipeline.py
+++ b/vllm_omni/model_executor/models/dreamzero/pipeline.py
@@ -10,6 +10,7 @@ from vllm_omni.config.stage_config import (
 
 DREAMZERO_PIPELINE = PipelineConfig(
     model_type="dreamzero",
+    default_deploy_config_name="dreamzero.yaml",
     model_arch="DreamZeroPipeline",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/dynin_omni/pipeline.py b/vllm_omni/model_executor/models/dynin_omni/pipeline.py
index db0c51e35..584b6ab5c 100644
--- a/vllm_omni/model_executor/models/dynin_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/dynin_omni/pipeline.py
@@ -23,6 +23,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.dynin_omni"
 
 DYNIN_OMNI_PIPELINE = PipelineConfig(
     model_type="dynin_omni",
+    default_deploy_config_name="dynin_omni.yaml",
     model_arch="DyninOmniForConditionalGeneration",
     # Arch-fallback safety net: route by hf_config.architectures when the
     # auto-detected model_type does not match the registry key exactly.
diff --git a/vllm_omni/model_executor/models/fish_speech/pipeline.py b/vllm_omni/model_executor/models/fish_speech/pipeline.py
index baee1b5e7..1cb113094 100644
--- a/vllm_omni/model_executor/models/fish_speech/pipeline.py
+++ b/vllm_omni/model_executor/models/fish_speech/pipeline.py
@@ -20,6 +20,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.fish_speech"
 
 FISH_SPEECH_PIPELINE = PipelineConfig(
     model_type="fish_qwen3_omni",
+    default_deploy_config_name="fish_qwen3_omni.yaml",
     model_arch="FishSpeechSlowARForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/glm_image/glm_image_ar.py b/vllm_omni/model_executor/models/glm_image/glm_image_ar.py
index 278e372d7..77aef398b 100644
--- a/vllm_omni/model_executor/models/glm_image/glm_image_ar.py
+++ b/vllm_omni/model_executor/models/glm_image/glm_image_ar.py
@@ -2414,6 +2414,11 @@ class GlmImageForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP
     # linear increments during decode.
     precomputed_mrope_decode = True
 
+    # The downstream GLM-Image diffusion stage consumes generated token ids and
+    # optional VQ-VAE image ids, not AR hidden states. Avoid copying one hidden
+    # vector to host at every decode step.
+    omni_pooler_payload_include_hidden = False
+
     packed_modules_mapping = {
         "qkv_proj": [
             "q_proj",
diff --git a/vllm_omni/model_executor/models/glm_image/pipeline.py b/vllm_omni/model_executor/models/glm_image/pipeline.py
index bd041292c..fd74bfad8 100644
--- a/vllm_omni/model_executor/models/glm_image/pipeline.py
+++ b/vllm_omni/model_executor/models/glm_image/pipeline.py
@@ -14,6 +14,7 @@ from vllm_omni.config.stage_config import (
 
 GLM_IMAGE_PIPELINE = PipelineConfig(
     model_type="glm_image",
+    default_deploy_config_name="glm_image.yaml",
     model_arch="GlmImageForConditionalGeneration",
     hf_architectures=("GlmImageForConditionalGeneration",),
     diffusers_class_name="GlmImagePipeline",
diff --git a/vllm_omni/model_executor/models/glm_tts/pipeline.py b/vllm_omni/model_executor/models/glm_tts/pipeline.py
index f016a993e..2a1fedd3f 100644
--- a/vllm_omni/model_executor/models/glm_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/glm_tts/pipeline.py
@@ -12,6 +12,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.glm_tts"
 
 GLM_TTS_PIPELINE = PipelineConfig(
     model_type="glm_tts",
+    default_deploy_config_name="glm_tts.yaml",
     model_arch="GLMTTSForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/gr00t/pipeline.py b/vllm_omni/model_executor/models/gr00t/pipeline.py
index 38a76f297..a2e4c8133 100644
--- a/vllm_omni/model_executor/models/gr00t/pipeline.py
+++ b/vllm_omni/model_executor/models/gr00t/pipeline.py
@@ -10,6 +10,7 @@ from vllm_omni.config.stage_config import (
 
 GR00T_N1D7_PIPELINE = PipelineConfig(
     model_type="Gr00tN1d7",
+    default_deploy_config_name="Gr00tN1d7.yaml",
     model_arch="Gr00tN1d7Pipeline",
     hf_architectures=("Gr00tN1d7",),
     stages=(
diff --git a/vllm_omni/model_executor/models/higgs_audio_v2/pipeline.py b/vllm_omni/model_executor/models/higgs_audio_v2/pipeline.py
index fb6832569..1d3db52d6 100644
--- a/vllm_omni/model_executor/models/higgs_audio_v2/pipeline.py
+++ b/vllm_omni/model_executor/models/higgs_audio_v2/pipeline.py
@@ -12,6 +12,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.higgs_audio_v2"
 
 HIGGS_AUDIO_V2_PIPELINE = PipelineConfig(
     model_type="higgs_audio_v2",
+    default_deploy_config_name="higgs_audio_v2.yaml",
     model_arch="HiggsAudioV2ForConditionalGeneration",
     hf_architectures=("HiggsAudioV2ForConditionalGeneration",),
     stages=(
diff --git a/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py b/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
index f51adafa9..579d0cd13 100644
--- a/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
+++ b/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
@@ -35,6 +35,8 @@ from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
 from vllm.model_executor.models.qwen3 import Qwen3Model
 from vllm.platforms import current_platform
 from vllm.v1.outputs import SamplerOutput
+from vllm.v1.sample.metadata import SamplingMetadata
+from vllm.v1.sample.ops.topk_topp_sampler import apply_top_k_top_p
 
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.transformers_utils.configs.higgs_audio_v3 import (
@@ -983,7 +985,11 @@ class HiggsAudioV3TalkerForConditionalGeneration(nn.Module):
 
         # Sample per-codebook
         cb_logits_2d = cb_logits.reshape(-1, cb_logits.shape[-1])
-        codes_2d = self._sample_audio_codes(cb_logits_2d)
+        codes_2d = self._sample_audio_codes(
+            cb_logits_2d,
+            sampling_metadata,
+            int(cb_logits.shape[1]),
+        )
         codes_flat = codes_2d.view(cb_logits.shape[0], cb_logits.shape[1]).to(torch.long)
 
         self._update_delay_state_batched(
@@ -1337,23 +1343,42 @@ class HiggsAudioV3TalkerForConditionalGeneration(nn.Module):
         self._postprocess_audio_rows = num_rows
         self._postprocess_audio_active_rows = 0
 
-    def _sample_audio_codes(self, logits_2d: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _expand_audio_sampling_params(
+        sampling_metadata: SamplingMetadata, logits_2d: torch.Tensor, num_codebooks: int
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch_size, remainder = divmod(int(logits_2d.shape[0]), num_codebooks)
+        if remainder:
+            raise ValueError(f"audio codebook logits rows must be divisible by {num_codebooks}")
+
+        def expand(value, default, dtype):
+            if value is None:
+                value = torch.full((batch_size,), default, device=logits_2d.device, dtype=dtype)
+            else:
+                value = torch.as_tensor(value, device=logits_2d.device, dtype=dtype).expand(batch_size)
+            return value.repeat_interleave(num_codebooks)
+
+        return (
+            expand(sampling_metadata.temperature, 0.0 if sampling_metadata.all_greedy else 1.0, logits_2d.dtype),
+            expand(sampling_metadata.top_k, logits_2d.shape[-1], torch.long),
+            expand(sampling_metadata.top_p, 1.0, logits_2d.dtype),
+        )
+
+    def _sample_audio_codes(
+        self, logits_2d: torch.Tensor, sampling_metadata: SamplingMetadata, num_codebooks: int = 8
+    ) -> torch.Tensor:
         """Replicate upstream sampling: temperature → top-k → top-p → multinomial."""
         x = logits_2d.float()
-        top_k = 50
-        top_p = 0.95
-        if 0 < top_k < x.shape[-1]:
-            kth = x.topk(top_k, dim=-1).values[..., -1:]
-            x = x.masked_fill(x < kth, float("-inf"))
-        if 0.0 < top_p < 1.0:
-            sorted_logits, sorted_idx = x.sort(dim=-1, descending=True)
-            cumprobs = sorted_logits.softmax(dim=-1).cumsum(dim=-1)
-            sorted_mask = cumprobs > top_p
-            sorted_mask[..., 1:] = sorted_mask[..., :-1].clone()
-            sorted_mask[..., 0] = False
-            mask = torch.zeros_like(x, dtype=torch.bool)
-            mask.scatter_(-1, sorted_idx, sorted_mask)
-            x = x.masked_fill(mask, float("-inf"))
+        temperatures, top_ks, top_ps = self._expand_audio_sampling_params(sampling_metadata, x, num_codebooks)
+        top_ks = torch.where(top_ks <= 0, torch.full_like(top_ks, x.shape[-1]), top_ks)
+        top_ks = top_ks.clamp(max=x.shape[-1])
+        top_ps = top_ps.clamp(min=0.0, max=1.0)
+        temperatures = torch.where(torch.isfinite(temperatures), temperatures, torch.ones_like(temperatures))
+        top_ps = torch.where(torch.isfinite(top_ps), top_ps, torch.ones_like(top_ps))
+        greedy = temperatures <= 0
+        safe_temperatures = torch.where(greedy, torch.ones_like(temperatures), temperatures)
+        x.div_(safe_temperatures.unsqueeze(-1))
+        x = apply_top_k_top_p(x, top_ks, top_ps)
         # Detect all-masked rows BEFORE softmax (softmax of all-inf yields NaN).
         has_finite = torch.isfinite(x).any(dim=-1)
         all_masked = ~has_finite
@@ -1362,7 +1387,8 @@ class HiggsAudioV3TalkerForConditionalGeneration(nn.Module):
         safe_x = torch.where(all_masked.unsqueeze(-1), torch.zeros_like(x), x)
         probs = safe_x.softmax(dim=-1)
         sampled = torch.multinomial(probs, num_samples=1).squeeze(-1)
-        return torch.where(all_masked, fallback, sampled)
+        sampled = torch.where(all_masked, fallback, sampled)
+        return torch.where(greedy, logits_2d.argmax(dim=-1), sampled)
 
     # ------------------------------------------------------------------ omni output
     def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput, **kwargs: Any) -> OmniOutput:
diff --git a/vllm_omni/model_executor/models/higgs_audio_v3/pipeline.py b/vllm_omni/model_executor/models/higgs_audio_v3/pipeline.py
index 2f35c497e..9bfc411df 100644
--- a/vllm_omni/model_executor/models/higgs_audio_v3/pipeline.py
+++ b/vllm_omni/model_executor/models/higgs_audio_v3/pipeline.py
@@ -24,6 +24,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.higgs_audio_v3"
 
 HIGGS_AUDIO_V3_PIPELINE = PipelineConfig(
     model_type="higgs_multimodal_qwen3",
+    default_deploy_config_name="higgs_multimodal_qwen3.yaml",
     model_arch="HiggsAudioV3TalkerForConditionalGeneration",
     hf_architectures=("HiggsMultimodalQwen3ForConditionalGeneration",),
     stages=(
diff --git a/vllm_omni/model_executor/models/hunyuan_image3/pipeline.py b/vllm_omni/model_executor/models/hunyuan_image3/pipeline.py
index 06ebff9c7..fd53043bd 100644
--- a/vllm_omni/model_executor/models/hunyuan_image3/pipeline.py
+++ b/vllm_omni/model_executor/models/hunyuan_image3/pipeline.py
@@ -18,6 +18,7 @@ _HUNYUAN_IMAGE3_INPUT_PROCESSOR = "vllm_omni.model_executor.stage_input_processo
 
 HUNYUAN_IMAGE3_PIPELINE = PipelineConfig(
     model_type="hunyuan_image_3_moe",
+    default_deploy_config_name="hunyuan_image_3_moe.yaml",
     model_arch=_HUNYUAN_IMAGE3_MODEL_ARCH,
     hf_architectures=_HUNYUAN_IMAGE3_HF_ARCHS,
     stages=(
@@ -50,6 +51,7 @@ HUNYUAN_IMAGE3_PIPELINE = PipelineConfig(
 
 HUNYUAN_IMAGE3_AR_PIPELINE = PipelineConfig(
     model_type="hunyuan_image3_ar",
+    default_deploy_config_name="hunyuan_image3_ar.yaml",
     model_arch=_HUNYUAN_IMAGE3_MODEL_ARCH,
     hf_architectures=(),
     stages=(
@@ -71,6 +73,7 @@ HUNYUAN_IMAGE3_AR_PIPELINE = PipelineConfig(
 
 HUNYUAN_IMAGE3_DIT_PIPELINE = PipelineConfig(
     model_type="hunyuan_image3_dit",
+    default_deploy_config_name="hunyuan_image3_dit.yaml",
     model_arch=_HUNYUAN_IMAGE3_MODEL_ARCH,
     hf_architectures=(),
     stages=(
diff --git a/vllm_omni/model_executor/models/hunyuan_video/__init__.py b/vllm_omni/model_executor/models/hunyuan_video/__init__.py
new file mode 100644
index 000000000..208f01a7c
--- /dev/null
+++ b/vllm_omni/model_executor/models/hunyuan_video/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/vllm_omni/model_executor/models/hunyuan_video/pipeline.py b/vllm_omni/model_executor/models/hunyuan_video/pipeline.py
new file mode 100644
index 000000000..341d14e5d
--- /dev/null
+++ b/vllm_omni/model_executor/models/hunyuan_video/pipeline.py
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""HunyuanVideo-1.5 pipeline topology."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+HUNYUAN_VIDEO_15_PIPELINE = PipelineConfig(
+    model_type="hunyuan_video_15",
+    model_arch="HunyuanVideo15Pipeline",
+    diffusers_class_name="HunyuanVideo15Pipeline",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="dit",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="video",
+            model_arch="HunyuanVideo15Pipeline",
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/indextts2/pipeline.py b/vllm_omni/model_executor/models/indextts2/pipeline.py
index 2ce02cee8..50f866ffd 100644
--- a/vllm_omni/model_executor/models/indextts2/pipeline.py
+++ b/vllm_omni/model_executor/models/indextts2/pipeline.py
@@ -16,6 +16,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.indextts2"
 
 INDEXTTS2_PIPELINE = PipelineConfig(
     model_type="indextts2",
+    default_deploy_config_name="indextts2.yaml",
     model_arch="IndexTTS2TalkerForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/lance/pipeline.py b/vllm_omni/model_executor/models/lance/pipeline.py
index 777f8942d..126a23acb 100644
--- a/vllm_omni/model_executor/models/lance/pipeline.py
+++ b/vllm_omni/model_executor/models/lance/pipeline.py
@@ -15,6 +15,7 @@ from vllm_omni.config.stage_config import (
 
 LANCE_PIPELINE = PipelineConfig(
     model_type="lance",
+    default_deploy_config_name="lance.yaml",
     model_arch="LancePipeline",
     hf_architectures=(),
     stages=(
diff --git a/vllm_omni/model_executor/models/mammoth_moda2/mammoth_moda2.py b/vllm_omni/model_executor/models/mammoth_moda2/mammoth_moda2.py
index 2fe616cfd..47c2b5e37 100644
--- a/vllm_omni/model_executor/models/mammoth_moda2/mammoth_moda2.py
+++ b/vllm_omni/model_executor/models/mammoth_moda2/mammoth_moda2.py
@@ -6,7 +6,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import Qwen2Config
+from transformers import Qwen2Config, Qwen3VLProcessor
 from transformers.models.qwen2_5_vl.processing_qwen2_5_vl import Qwen2_5_VLProcessor
 from vllm.config import CacheConfig, VllmConfig
 from vllm.distributed import get_pp_group
@@ -30,7 +30,15 @@ from vllm.model_executor.models.qwen2_5_vl import (
     Qwen2_5_VLProcessingInfo,
 )
 from vllm.model_executor.models.qwen2_vl import Qwen2VLMultiModalDataParser
+from vllm.model_executor.models.qwen3 import Qwen3DecoderLayer, Qwen3MLP
+from vllm.model_executor.models.qwen3_vl import (
+    Qwen3VLDummyInputsBuilder,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMultiModalProcessor,
+    Qwen3VLProcessingInfo,
+)
 from vllm.model_executor.models.utils import (
+    AutoWeightsLoader,
     PPMissingLayer,
     WeightsMapper,
     init_vllm_registered_model,
@@ -51,6 +59,18 @@ from vllm_omni.model_executor.models.utils import add_prefix_to_loaded_weights
 from vllm_omni.transformers_utils.configs.mammoth_moda2 import Mammothmoda2Config
 
 
+def _runtime_meta(runtime_info: dict[str, Any]) -> dict[str, Any]:
+    """Accept both legacy flat metadata and the canonical nested payload."""
+    meta = runtime_info.get("meta")
+    return meta if isinstance(meta, dict) else runtime_info
+
+
+def _first_int(value: Any) -> int:
+    if isinstance(value, (list, tuple)):
+        value = value[0]
+    return int(value)
+
+
 def moe_enable(moe_type, layer_type, layer_idx) -> bool:
     """Determine if MoE should be enabled for a specific layer type and index.
 
@@ -291,6 +311,7 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
         self.gen_vocab_size = int(getattr(config, "gen_vocab_size", 0) or 0)
 
         self.base_vocab_size = int(self.gen_vocab_start_index) if self.extra_gen_vocab else int(config.vocab_size)
+        self.org_base_vocab_size = int(getattr(config, "base_vocab_size", self.base_vocab_size))
         # The configuration level (hf_text_config.vocab_size) has been extended to base+gen
         # by the upstream config class. Use config.vocab_size as the total vocab size.
         self.total_vocab_size = int(getattr(config, "vocab_size", self.base_vocab_size))
@@ -299,6 +320,7 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
             self.embed_tokens = VocabParallelEmbedding(
                 self.base_vocab_size,
                 config.hidden_size,
+                org_num_embeddings=self.org_base_vocab_size,
                 quant_config=quant_config,
                 prefix=f"{prefix}.embed_tokens",
             )
@@ -322,6 +344,7 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
             self.lm_head = ParallelLMHead(
                 self.base_vocab_size,
                 config.hidden_size,
+                org_num_embeddings=self.org_base_vocab_size,
                 quant_config=quant_config,
                 prefix=f"{prefix}.lm_head",
             )
@@ -425,6 +448,7 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
         positions: torch.Tensor,
         intermediate_tensors: IntermediateTensors | None = None,
         inputs_embeds: torch.Tensor | None = None,
+        deepstack_input_embeds: IntermediateTensors | None = None,
     ) -> torch.Tensor | IntermediateTensors:
         if get_pp_group().is_first_rank:
             if inputs_embeds is not None:
@@ -446,8 +470,17 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
             residual = intermediate_tensors["residual"]
             gen_token_mask = intermediate_tensors.tensors.get("gen_token_mask")
 
-        for idx, layer in enumerate(islice(self.layers, self.start_layer, self.end_layer)):
+        for idx, layer in enumerate(
+            islice(self.layers, self.start_layer, self.end_layer),
+            start=self.start_layer,
+        ):
             hidden_states, residual = layer(positions, hidden_states, residual, gen_token_mask)
+            # The vision encoder's deepstack_visual_indexes select which vision
+            # layers produce these features. The resulting tensors are keyed
+            # 0..N-1 and, as in Qwen3-Omni, are injected into the first N
+            # language-model layers.
+            if deepstack_input_embeds is not None and idx < len(deepstack_input_embeds):
+                hidden_states = hidden_states + deepstack_input_embeds[f"deepstack_input_embeds_{idx}"]
 
         if not get_pp_group().is_last_rank:
             tensors = {"hidden_states": hidden_states, "residual": residual}
@@ -532,6 +565,65 @@ class MammothModa2Qwen2ForCausalLM(nn.Module, SupportsPP):
         return loaded_params
 
 
+class Mammoth3DecoderLayer(Qwen3DecoderLayer):
+    """Qwen3 decoder layer with MammothModa2's generation MLP expert."""
+
+    def __init__(
+        self,
+        config,
+        layer_idx: int,
+        cache_config: CacheConfig | None = None,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__(config, cache_config, quant_config, prefix)
+        self.moe_enable = moe_enable(config.moe_type, "ffn", layer_idx)
+        self.gen_mlp = (
+            Qwen3MLP(
+                hidden_size=self.hidden_size,
+                intermediate_size=config.intermediate_size,
+                hidden_act=config.hidden_act,
+                quant_config=quant_config,
+                prefix=f"{prefix}.gen_mlp",
+            )
+            if self.moe_enable
+            else None
+        )
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+        residual: torch.Tensor | None,
+        gen_token_mask: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if residual is None:
+            residual = hidden_states
+            hidden_states = self.input_layernorm(hidden_states)
+        else:
+            hidden_states, residual = self.input_layernorm(hidden_states, residual)
+        hidden_states = self.self_attn(positions=positions, hidden_states=hidden_states)
+        hidden_states, residual = self.post_attention_layernorm(hidden_states, residual)
+        hidden_states = moe_forward(
+            hidden_states,
+            self.mlp,
+            self.gen_mlp,
+            gen_token_mask if self.moe_enable else None,
+        )
+        return hidden_states, residual
+
+
+class MammothModa2Qwen3ForCausalLM(MammothModa2Qwen2ForCausalLM):
+    """MammothModa2 generation-aware language model using Qwen3 attention."""
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__(
+            vllm_config=vllm_config,
+            prefix=prefix,
+            decoder_layer_type=Mammoth3DecoderLayer,
+        )
+
+
 @MULTIMODAL_REGISTRY.register_processor(
     MammothModa2ARMultiModalProcessor,
     info=MammothModa2ARProcessingInfo,
@@ -604,17 +696,17 @@ class MammothModa2ARForConditionalGeneration(Qwen2_5_VLForConditionalGeneration)
         num_reqs = int(logits.shape[0])
         for i in range(num_reqs):
             runtime_info = runtime_infos[i] if isinstance(runtime_infos[i], dict) else {}
-            meta = runtime_info.get("meta", {})
+            meta = _runtime_meta(runtime_info)
             omni_task = meta.get("omni_task")
             if not isinstance(omni_task, list) or not omni_task or omni_task[0] != "t2i":
                 # Text/understanding/chat: forbid sampling from the extra gen vocab.
                 logits[i, self.language_model.base_vocab_size :] = neg_inf
                 continue
 
-            ar_width = meta["ar_width"][0]
-            eol_token_id = meta["eol_token_id"][0]
-            visual_start = meta["visual_token_start_id"][0]
-            visual_end = meta["visual_token_end_id"][0]
+            ar_width = _first_int(meta["ar_width"])
+            eol_token_id = _first_int(meta["eol_token_id"])
+            visual_start = _first_int(meta["visual_token_start_id"])
+            visual_end = _first_int(meta["visual_token_end_id"])
             generated_len = runtime_info["generated_len"]
 
             row = logits[i]
@@ -682,6 +774,100 @@ class MammothModa2ARForConditionalGeneration(Qwen2_5_VLForConditionalGeneration)
         return logits
 
 
+class MammothModa2Qwen3ProcessingInfo(Qwen3VLProcessingInfo):
+    """Qwen3-VL processing using MammothModa2's nested AR configuration."""
+
+    def get_hf_config(self):
+        mammoth_cfg: Mammothmoda2Config = self.ctx.get_hf_config(Mammothmoda2Config)
+        return mammoth_cfg.llm_config
+
+    def get_hf_processor(self, **kwargs: object) -> Qwen3VLProcessor:
+        # The MammothModa2 repository does not ship tokenizer_config.json, so
+        # AutoProcessor otherwise resolves only the image processor and leaves
+        # Qwen3-VL's image placeholder undefined.
+        return self.ctx.get_hf_processor(
+            Qwen3VLProcessor,
+            use_fast=kwargs.pop("use_fast", True),
+            **kwargs,
+        )
+
+    def get_supported_mm_limits(self) -> Mapping[str, int | None]:
+        return {"image": None}
+
+
+@MULTIMODAL_REGISTRY.register_processor(
+    Qwen3VLMultiModalProcessor,
+    info=MammothModa2Qwen3ProcessingInfo,
+    dummy_inputs=Qwen3VLDummyInputsBuilder,
+)
+class MammothModa2Qwen3ARForConditionalGeneration(Qwen3VLForConditionalGeneration):
+    """MammothModa2-Dev Qwen3-VL stage for understanding and generation."""
+
+    hf_to_vllm_mapper = WeightsMapper(
+        orig_to_new_prefix={
+            "llm_model.model.visual.": "visual.",
+            "llm_model.lm_head.": "language_model.lm_head.",
+            "llm_model.model.language_model.gen_embed_tokens.": "language_model.gen_embed_tokens.",
+            "llm_model.model.language_model.": "language_model.",
+            "llm_model.gen_head.": "language_model.gen_head.",
+            "gen_image_condition_refiner.": None,
+            "gen_transformer.": None,
+            "gen_vae.": None,
+            "gen_tokenizer.": None,
+        }
+    )
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        mammoth_cfg = vllm_config.model_config.hf_config
+        ar_hf_config = getattr(mammoth_cfg, "llm_config", mammoth_cfg)
+        ar_vllm_config = vllm_config.with_hf_config(
+            ar_hf_config,
+            architectures=vllm_config.model_config.architectures,
+        )
+        super().__init__(vllm_config=ar_vllm_config, prefix=prefix)
+        text_config = ar_hf_config.text_config
+        self.language_model = MammothModa2Qwen3ForCausalLM(
+            vllm_config=ar_vllm_config.with_hf_config(text_config),
+            prefix=maybe_prefix(prefix, "language_model"),
+        )
+        self.make_empty_intermediate_tensors = self.language_model.make_empty_intermediate_tensors
+        self._last_runtime_additional_information: list[dict[str, Any]] | None = None
+
+    def forward(self, *args, **kwargs):
+        runtime_infos = kwargs.get("runtime_additional_information")
+        self._last_runtime_additional_information = runtime_infos if isinstance(runtime_infos, list) else None
+        return super().forward(*args, **kwargs)
+
+    def compute_logits(self, hidden_states: torch.Tensor):
+        logits = super().compute_logits(hidden_states)
+        if not isinstance(logits, torch.Tensor) or self._last_runtime_additional_information is None:
+            return logits
+        neg_inf = -float("inf")
+        for i, runtime_info in enumerate(self._last_runtime_additional_information):
+            meta = _runtime_meta(runtime_info) if isinstance(runtime_info, dict) else {}
+            if (meta.get("omni_task") or [None])[0] != "t2i":
+                logits[i, self.language_model.base_vocab_size :] = neg_inf
+                continue
+            ar_width = _first_int(meta["ar_width"])
+            eol_token_id = _first_int(meta["eol_token_id"])
+            visual_start = _first_int(meta["visual_token_start_id"])
+            visual_end = _first_int(meta["visual_token_end_id"])
+            row = logits[i]
+            if int(runtime_info["generated_len"]) % (ar_width + 1) == ar_width:
+                eol_logit = row[eol_token_id].clone()
+                row.fill_(neg_inf)
+                row[eol_token_id] = eol_logit
+            else:
+                row[:visual_start] = neg_inf
+                row[visual_end + 1 :] = neg_inf
+                row[eol_token_id] = neg_inf
+        return logits
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        loader = AutoWeightsLoader(self)
+        return loader.load_weights(weights, mapper=self.hf_to_vllm_mapper)
+
+
 @MULTIMODAL_REGISTRY.register_processor(
     MammothModa2ARMultiModalProcessor,
     info=MammothModa2ARProcessingInfo,
@@ -716,7 +902,11 @@ class MammothModa2ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
                 vllm_config=vllm_config,
                 prefix=maybe_prefix(prefix, "ar"),
                 hf_config=cfg.llm_config if hasattr(cfg, "llm_config") else cfg.text_config,
-                architectures=["MammothModa2ARForConditionalGeneration"],
+                architectures=[
+                    "MammothModa2Qwen3ARForConditionalGeneration"
+                    if getattr(cfg.llm_config, "model_type", "") == "mammothmoda2_qwen3_vl"
+                    else "MammothModa2ARForConditionalGeneration"
+                ],
             )
             self.model = self.ar
         elif self.model_stage == "dit":
@@ -750,6 +940,26 @@ class MammothModa2ForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
             return self.model.get_language_model()
         return self.model
 
+    def embed_input_ids(
+        self,
+        input_ids: torch.Tensor,
+        multimodal_embeddings=None,
+        *,
+        is_multimodal: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if isinstance(self.model, MammothModa2Qwen3ARForConditionalGeneration):
+            return self.model.embed_input_ids(
+                input_ids,
+                multimodal_embeddings=multimodal_embeddings,
+                is_multimodal=is_multimodal,
+            )
+        return SupportsMultiModal.embed_input_ids(
+            self,
+            input_ids,
+            multimodal_embeddings=multimodal_embeddings,
+            is_multimodal=is_multimodal,
+        )
+
     def get_multimodal_embeddings(self, **kwargs: object):
         # Backward compatibility: route through embed_multimodal.
         return self.embed_multimodal(**kwargs)
diff --git a/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py b/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
index be35eb562..830c63aff 100644
--- a/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
+++ b/vllm_omni/model_executor/models/mammoth_moda2/pipeline.py
@@ -18,6 +18,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.mammoth_moda2"
 
 MAMMOTH_MODA2_PIPELINE = PipelineConfig(
     model_type="mammoth_moda2",
+    default_deploy_config_name="mammoth_moda2.yaml",
     model_arch="MammothModa2ForConditionalGeneration",
     hf_architectures=("Mammothmoda2Model", "MammothModa2ForConditionalGeneration"),
     stages=(
@@ -49,6 +50,7 @@ MAMMOTH_MODA2_PIPELINE = PipelineConfig(
 # Single-stage AR variant for understanding / summarization tasks
 MAMMOTH_MODA2_AR_PIPELINE = PipelineConfig(
     model_type="mammoth_moda2_ar",
+    default_deploy_config_name="mammoth_moda2_ar.yaml",
     model_arch="MammothModa2ForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/mimo_audio/mimo_audio.py b/vllm_omni/model_executor/models/mimo_audio/mimo_audio.py
index ecf094c87..2af6abd42 100644
--- a/vllm_omni/model_executor/models/mimo_audio/mimo_audio.py
+++ b/vllm_omni/model_executor/models/mimo_audio/mimo_audio.py
@@ -793,9 +793,21 @@ class MiMoAudioForConditionalGeneration(
                 **kwargs,
             )
 
+            # next_speech_tokens is request-indexed (num_reqs, 1, 8, 4), not
+            # token-indexed, so ship it as a per-request list. The payload
+            # builder slices batched tensors by token offsets (start:end),
+            # which only coincides with the request index in pure-decode
+            # steps; in a mixed prefill+decode batch every request would
+            # receive the whole batch tensor, leaking codes across requests
+            # and crashing the downstream ragged-list conversion.
+            if next_speech_tokens is not None:
+                speech_token_payload = list(next_speech_tokens.split(1, dim=0))
+            else:
+                speech_token_payload = None
+
             return OmniOutput(
                 text_hidden_states=text_hidden_states.reshape(-1, text_hidden_states.shape[-1]),
-                multimodal_outputs={"codes": {"audio": next_speech_tokens}},
+                multimodal_outputs={"codes": {"audio": speech_token_payload}},
             )
 
         if self.model_stage == "code2wav":
diff --git a/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py b/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
index 48715fb98..19a339056 100644
--- a/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
+++ b/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
@@ -897,20 +897,28 @@ class MiMoAudioLLMForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
         input_ids: torch.Tensor,
         *,
         request_ids: list[str],
-        query_start_loc: torch.Tensor,
+        query_start_loc_list: list[int],
         kwargs: dict,
     ) -> tuple[dict[str, any], dict]:
         has_merge_mm_embedding = False
         merge_mm_embedding_info: dict[str, any] = {}
         seq_len = input_ids.shape[1] if input_ids.ndim == 2 else input_ids.shape[0]
 
-        for req_idx, req_id in enumerate(request_ids):
-            query_start_loc_by_req = int(query_start_loc[req_idx].item())
-            query_end_loc_by_req = int(query_start_loc[req_idx + 1].item())
-            input_ids_by_req = input_ids[query_start_loc_by_req:query_end_loc_by_req]
-            seq_len_by_req = input_ids_by_req.shape[1] if input_ids_by_req.ndim == 2 else input_ids_by_req.shape[0]
+        # Only each request's start token is ever read below, and only for
+        # single-token requests. Gather just those start offsets (num_reqs elements)
+        # to host instead of copying the whole flattened sequence every forward.
+        # query_start_loc entries are flat token offsets, so we index the flattened
+        # ids by the same offsets and derive per-request length from the boundaries.
+        flat_input_ids = input_ids.reshape(-1)
+        start_positions = query_start_loc_list[:-1]
+        start_is_empty_cpu = (flat_input_ids[start_positions] == self.empty_token_id).cpu().tolist()
 
-            if seq_len_by_req == 1 and bool(input_ids_by_req == self.empty_token_id):
+        for req_idx, req_id in enumerate(request_ids):
+            query_start_loc_by_req = query_start_loc_list[req_idx]
+            query_end_loc_by_req = query_start_loc_list[req_idx + 1]
+            seq_len_by_req = query_end_loc_by_req - query_start_loc_by_req
+
+            if seq_len_by_req == 1 and start_is_empty_cpu[req_idx]:
                 merge_mm_embedding_info[req_id] = {
                     "query_start_loc": query_start_loc_by_req,
                     "query_end_loc": query_end_loc_by_req,
@@ -1035,13 +1043,19 @@ class MiMoAudioLLMForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
         inputs_embeds: torch.Tensor | None = None,
         **kwargs: object,
     ) -> torch.Tensor | IntermediateTensors:
+        # Materialize the request boundaries on the host once instead of one
+        # `.item()` sync per boundary in the loops below.
         _forward_context = get_forward_context()
-        _default_query_start_loc = torch.tensor([0, input_ids.shape[-1]], device=input_ids.device)
-        query_start_loc = (
-            next(iter(_forward_context.attn_metadata.values())).query_start_loc
-            if _forward_context.attn_metadata is not None
-            else _default_query_start_loc
-        )
+        if _forward_context.attn_metadata is not None:
+            query_start_loc = next(iter(_forward_context.attn_metadata.values())).query_start_loc
+            query_start_loc_list = query_start_loc.tolist()
+        else:
+            # Single implicit request over all tokens. Build the host boundaries
+            # directly (no .tolist() D2H); the small device tensor is still needed
+            # for logits_indices below.
+            n_tokens = int(input_ids.shape[-1])
+            query_start_loc_list = [0, n_tokens]
+            query_start_loc = torch.tensor([0, n_tokens], device=input_ids.device)
 
         runtime_additional_information = kwargs.get("runtime_additional_information", [])
         if runtime_additional_information:
@@ -1054,7 +1068,7 @@ class MiMoAudioLLMForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
         merge_mm_embedding_info, has_merge_mm_embedding, kwargs = self._collect_merge_mm_embedding_info(
             input_ids,
             request_ids=request_ids,
-            query_start_loc=query_start_loc,
+            query_start_loc_list=query_start_loc_list,
             kwargs=kwargs,
         )
 
@@ -1077,15 +1091,18 @@ class MiMoAudioLLMForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
         batch_next_speech_tokens: torch.Tensor | None = None
 
         if not is_capturing and next_ids is not None and num_reqs > 0:
-            if (next_ids == self.empty_token_id).any():
+            # Copy the empty-token mask to host once; the `.any()` gate and the
+            # per-request checks below then avoid a GPU sync each.
+            next_is_empty_cpu = (next_ids == self.empty_token_id).cpu()
+            if bool(next_is_empty_cpu.any()):
                 batch_hs_list = []
                 valid_mask = []
 
                 for req_idx in range(num_reqs):
-                    start = int(query_start_loc[req_idx].item())
-                    end = int(query_start_loc[req_idx + 1].item())
+                    start = query_start_loc_list[req_idx]
+                    end = query_start_loc_list[req_idx + 1]
                     hs_req = hidden_states[start:end][-1:, :]
-                    is_empty = bool(next_ids[req_idx] == self.empty_token_id)
+                    is_empty = bool(next_is_empty_cpu[req_idx])
                     valid_mask.append(is_empty)
 
                     if not is_empty:
diff --git a/vllm_omni/model_executor/models/mimo_audio/pipeline.py b/vllm_omni/model_executor/models/mimo_audio/pipeline.py
index 9de6575d9..9e54979de 100644
--- a/vllm_omni/model_executor/models/mimo_audio/pipeline.py
+++ b/vllm_omni/model_executor/models/mimo_audio/pipeline.py
@@ -23,6 +23,7 @@ _IM_END_TOKEN_ID = 151645
 
 MIMO_AUDIO_PIPELINE = PipelineConfig(
     model_type="mimo_audio",
+    default_deploy_config_name="mimo_audio.yaml",
     # HF ``architectures: ["MiMoAudioModel"]`` is also the registry key in
     # ``model_executor/models/registry.py``; it resolves to the internal
     # class ``MiMoAudioForConditionalGeneration`` in ``mimo_audio.py``.
diff --git a/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py b/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
index e7b305b1e..8868e9d2a 100644
--- a/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
+++ b/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
@@ -27,6 +27,7 @@ from vllm.sequence import IntermediateTensors
 from vllm_omni.model_executor.custom_process_mixin import CustomProcessMixin
 from vllm_omni.model_executor.model_loader.weight_utils import download_weights_from_hf_specific
 from vllm_omni.model_executor.models.common.ming.audio_vae import AudioVAE, AudioVAEConfig
+from vllm_omni.model_executor.models.ming_tts.constants import SPEAKER_EMBEDDING_DIM
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.transformers_utils.configs.ming_flash_omni import MingFlashOmniTalkerConfig
 
@@ -120,8 +121,7 @@ class MingFlashOmniTalkerForConditionalGeneration(nn.Module, CustomProcessMixin)
         )
         self.aggregator = Aggregator(llm_input_dim=self.hidden_size, **config.aggregator)
         self.stop_head = nn.Linear(self.hidden_size, 2, bias=True)
-        # CAMPPlus 192-dim -> hidden
-        self.spk_head = nn.Linear(192, self.hidden_size, bias=True)
+        self.spk_head = nn.Linear(SPEAKER_EMBEDDING_DIM, self.hidden_size, bias=True)
 
         # AudioVAE
         self.audio_vae, self._vae_weight_source = self._init_audio_vae(config, self.talker_dir, model_path)
diff --git a/vllm_omni/model_executor/models/ming_flash_omni/pipeline.py b/vllm_omni/model_executor/models/ming_flash_omni/pipeline.py
index e416a117e..da8c24843 100644
--- a/vllm_omni/model_executor/models/ming_flash_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/ming_flash_omni/pipeline.py
@@ -21,6 +21,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.ming_flash_omni"
 
 MING_FLASH_OMNI_PIPELINE = PipelineConfig(
     model_type="ming_flash_omni",
+    default_deploy_config_name="ming_flash_omni.yaml",
     model_arch="MingFlashOmniForConditionalGeneration",
     # Upstream HF config applies model_type="bailingmm_moe_v2_lite"
     # (the thinker sub-config name) rather than "ming_flash_omni".
@@ -66,6 +67,7 @@ MING_FLASH_OMNI_PIPELINE = PipelineConfig(
 # Standalone TTS variant: talker only.
 MING_FLASH_OMNI_TTS_PIPELINE = PipelineConfig(
     model_type="ming_flash_omni_tts",
+    default_deploy_config_name="ming_flash_omni_tts.yaml",
     model_arch="MingFlashOmniTalkerForConditionalGeneration",
     stages=(
         StagePipelineConfig(
@@ -87,6 +89,7 @@ MING_FLASH_OMNI_TTS_PIPELINE = PipelineConfig(
 # Thinker-only variant: multimodal understanding with text output
 MING_FLASH_OMNI_THINKER_ONLY_PIPELINE = PipelineConfig(
     model_type="ming_flash_omni_thinker_only",
+    default_deploy_config_name="ming_flash_omni_thinker_only.yaml",
     model_arch="MingFlashOmniForConditionalGeneration",
     stages=(
         StagePipelineConfig(
@@ -109,6 +112,7 @@ MING_FLASH_OMNI_THINKER_ONLY_PIPELINE = PipelineConfig(
 # Thinker + image-generation (diffusion) variant: text-to-image / img2img.
 MING_FLASH_OMNI_IMAGE_PIPELINE = PipelineConfig(
     model_type="ming_flash_omni_image",
+    default_deploy_config_name="ming_flash_omni_image.yaml",
     model_arch="MingFlashOmniForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/ming_tts/audio_prep.py b/vllm_omni/model_executor/models/ming_tts/audio_prep.py
index 378cd222d..055948932 100644
--- a/vllm_omni/model_executor/models/ming_tts/audio_prep.py
+++ b/vllm_omni/model_executor/models/ming_tts/audio_prep.py
@@ -16,6 +16,7 @@ from .config_ming_tts import (
     VAE_PATCH_SIZE,
     MingTTSConfig,
 )
+from .constants import SPEAKER_EMBEDDING_DIM
 
 
 def pad_prompt_waveform(
@@ -56,7 +57,7 @@ def coerce_prompt_waveform(value: Any) -> torch.Tensor:
 
 def coerce_speaker_embeddings(value: Any, *, use_zero_spk_emb: bool = False) -> list[torch.Tensor] | None:
     if value is None:
-        return [torch.zeros((192,), dtype=torch.float32)] if use_zero_spk_emb else None
+        return [torch.zeros((SPEAKER_EMBEDDING_DIM,), dtype=torch.float32)] if use_zero_spk_emb else None
     if isinstance(value, torch.Tensor):
         tensor = value.detach()
         if tensor.ndim == 1:
@@ -78,10 +79,10 @@ def coerce_speaker_embeddings(value: Any, *, use_zero_spk_emb: bool = False) ->
     else:
         return coerce_speaker_embeddings(torch.as_tensor(value), use_zero_spk_emb=use_zero_spk_emb)
     if not items:
-        return [torch.zeros((192,), dtype=torch.float32)] if use_zero_spk_emb else None
+        return [torch.zeros((SPEAKER_EMBEDDING_DIM,), dtype=torch.float32)] if use_zero_spk_emb else None
     for item in items:
-        if int(item.numel()) != 192:
-            raise ValueError(f"Ming speaker embedding must have 192 dims, got {int(item.numel())}")
+        if int(item.numel()) != SPEAKER_EMBEDDING_DIM:
+            raise ValueError(f"Ming speaker embedding must have {SPEAKER_EMBEDDING_DIM} dims, got {int(item.numel())}")
     return items
 
 
diff --git a/vllm_omni/model_executor/models/ming_tts/config_ming_tts.py b/vllm_omni/model_executor/models/ming_tts/config_ming_tts.py
index fdac2a30e..a6dc270c3 100644
--- a/vllm_omni/model_executor/models/ming_tts/config_ming_tts.py
+++ b/vllm_omni/model_executor/models/ming_tts/config_ming_tts.py
@@ -35,6 +35,9 @@ from .constants import (
     KEY_REQUEST_ID,
     KEY_SIGMA,
     KEY_SPEAKER_EMBEDDING,
+    KEY_SPEAKER_SAMPLE_RATES,
+    KEY_SPEAKER_WAVEFORM,
+    KEY_SPEAKER_WAVEFORM_LENGTHS,
     KEY_TEMPERATURE,
     KEY_TEXT_MODE,
     LATENT_CHUNK_SIZE,
@@ -326,6 +329,9 @@ __all__ = [
     "KEY_REQUEST_ID",
     "KEY_SIGMA",
     "KEY_SPEAKER_EMBEDDING",
+    "KEY_SPEAKER_SAMPLE_RATES",
+    "KEY_SPEAKER_WAVEFORM",
+    "KEY_SPEAKER_WAVEFORM_LENGTHS",
     "KEY_TEMPERATURE",
     "KEY_TEXT_MODE",
     "LATENT_CHUNK_SIZE",
diff --git a/vllm_omni/model_executor/models/ming_tts/constants.py b/vllm_omni/model_executor/models/ming_tts/constants.py
index e0508bda7..397de3288 100644
--- a/vllm_omni/model_executor/models/ming_tts/constants.py
+++ b/vllm_omni/model_executor/models/ming_tts/constants.py
@@ -43,6 +43,7 @@ LLM_VOCAB_SIZE = 151936
 AGGREGATOR_HIDDEN_SIZE = 1024
 VAE_PATCH_SIZE = 4
 SAMPLE_RATE = 44100
+SPEAKER_EMBEDDING_DIM = 192  # CAMPPlus output width and speaker projection input width
 
 # AudioVAE frame/hop geometry (confirmed)
 AUDIO_FRAME_HOP = 882  # enc input_dim / hop_size / dec output_dim
@@ -73,6 +74,9 @@ KEY_LAST_STOP_PROB = "ming_last_stop_prob"
 KEY_NEXT_EMBEDS = "ming_next_embeds"
 KEY_PROMPT_LATENTS = "ming_prompt_latents"
 KEY_SPEAKER_EMBEDDING = "ming_speaker_embedding"
+KEY_SPEAKER_WAVEFORM = "ming_speaker_waveform"
+KEY_SPEAKER_WAVEFORM_LENGTHS = "ming_speaker_waveform_lengths"
+KEY_SPEAKER_SAMPLE_RATES = "ming_speaker_sample_rates"
 KEY_REQUEST_ID = "ming_request_id"
 KEY_CHUNK_ID = "ming_chunk_id"
 KEY_CFG = "ming_cfg"
diff --git a/vllm_omni/model_executor/models/ming_tts/ming_tts.py b/vllm_omni/model_executor/models/ming_tts/ming_tts.py
index 70a414186..d6e2ac92d 100644
--- a/vllm_omni/model_executor/models/ming_tts/ming_tts.py
+++ b/vllm_omni/model_executor/models/ming_tts/ming_tts.py
@@ -20,7 +20,6 @@ from .audio_prep import (
     _find_speaker_placeholder_positions,
     _initial_history,
     _take_scalar,
-    coerce_speaker_embeddings,
 )
 from .config_ming_tts import (
     AUDIO_START_TOKEN_ID,
@@ -33,13 +32,13 @@ from .config_ming_tts import (
     KEY_NEXT_EMBEDS,
     KEY_REQUEST_ID,
     KEY_SIGMA,
-    KEY_SPEAKER_EMBEDDING,
     KEY_TEMPERATURE,
     KEY_TEXT_MODE,
     MingTTSConfig,
 )
 from .patch_emission import MING_STOP_REASON_KEY
 from .prompt_encoder import _resolve_prompt_latents
+from .speaker_extractor import _resolve_speaker_embeddings
 
 
 class _ModelSampleAdapter(nn.Module):
@@ -64,8 +63,12 @@ class MingTTSForConditionalGeneration(nn.Module, SupportsPP, CustomProcessMixin)
         self.requires_raw_input_tokens = False
         self.model_stage = vllm_config.model_config.model_stage
         self._prompt_encoder = None
+        self._speaker_extractor = None
 
         if self.model_stage == "llm":
+            from vllm_omni.utils.speaker_cache import get_speaker_cache
+
+            self._speaker_cache = get_speaker_cache()
             self.model = init_vllm_registered_model(vllm_config=vllm_config, architectures=["MingLLMModel"])
             self.has_preprocess = True
             self.has_postprocess = True
@@ -174,13 +177,7 @@ class MingTTSForConditionalGeneration(nn.Module, SupportsPP, CustomProcessMixin)
         )
         update[KEY_LATENT_HISTORY] = history.detach().to("cpu").contiguous()
 
-        speaker_embedding = info_dict.get(KEY_SPEAKER_EMBEDDING, info_dict.get("speaker_embedding"))
-        speaker_embeddings = None
-        if speaker_embedding is not None:
-            speaker_embeddings = coerce_speaker_embeddings(
-                speaker_embedding,
-                use_zero_spk_emb=bool(info_dict.get("use_zero_spk_emb", False)),
-            )
+        speaker_embeddings = _resolve_speaker_embeddings(self, info_dict)
         if speaker_embeddings is not None and len(speaker_embeddings) > 0:
             speaker_slots = _find_speaker_placeholder_positions(input_ids, self.ming_config)
             if len(speaker_slots) < len(speaker_embeddings):
diff --git a/vllm_omni/model_executor/models/ming_tts/ming_tts_llm.py b/vllm_omni/model_executor/models/ming_tts/ming_tts_llm.py
index 39ddd7b9f..c0ec5a513 100644
--- a/vllm_omni/model_executor/models/ming_tts/ming_tts_llm.py
+++ b/vllm_omni/model_executor/models/ming_tts/ming_tts_llm.py
@@ -33,6 +33,7 @@ from .config_ming_tts import (
     KEY_TEXT_MODE,
     MingTTSConfig,
 )
+from .constants import SPEAKER_EMBEDDING_DIM
 from .flowloss_head import FlowLoss
 from .patch_emission import (
     MING_STOP_REASON_CODES,
@@ -57,10 +58,20 @@ _CFM_STEPS = 10
 
 
 class MingLLMModel(nn.Module):
+    # Drop the tensor on purpose, otherwise upstream vLLM would reject.
+    # The vendor never reaches them either (audio_gate/image_gate never fire)
+    # dropping them keeps routing identical to the reference implementation.
+    # https://github.com/inclusionAI/Ming-omni-tts/blob/main/modeling_bailingmm.py#L427-L428
+    # https://github.com/inclusionAI/Ming-omni-tts/blob/main/modeling_bailing_moe.py#L510-L520
     hf_to_vllm_mapper = WeightsMapper(
+        orig_to_new_substr={
+            ".mlp.audio_gate.": None,
+            ".mlp.image_gate.": None,
+        },
         orig_to_new_prefix={
+            "model.lm_head.": None,
             "model.model.": "model.",
-        }
+        },
     )
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
@@ -91,7 +102,7 @@ class MingLLMModel(nn.Module):
             **self.ming_config.ditar_config,
         )
         self.stop_head = nn.Linear(self.ming_config.llm_hidden_size, 2, bias=True)
-        self.spk_head = nn.Linear(192, self.ming_config.llm_hidden_size, bias=True)
+        self.spk_head = nn.Linear(SPEAKER_EMBEDDING_DIM, self.ming_config.llm_hidden_size, bias=True)
         self.flowloss.to(dtype=self.fm_dtype)
         self.linear_proj_audio.to(dtype=self.fm_dtype)
         self.stop_head.to(dtype=self.fm_dtype)
diff --git a/vllm_omni/model_executor/models/ming_tts/pipeline.py b/vllm_omni/model_executor/models/ming_tts/pipeline.py
index 762dcf6fd..86eecd41e 100644
--- a/vllm_omni/model_executor/models/ming_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/ming_tts/pipeline.py
@@ -12,6 +12,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.ming_tts"
 
 MING_TTS_PIPELINE = PipelineConfig(
     model_type="ming_tts",
+    default_deploy_config_name="ming_tts.yaml",
     model_arch="MingTTSForConditionalGeneration",
     hf_architectures=("MingTTSForConditionalGeneration", "BailingMMNativeForConditionalGeneration"),
     # The dense (0.5B) and MoE (16.8B) share architectures=["BailingMMNativeForConditionalGeneration"]
@@ -63,6 +64,7 @@ MING_TTS_PIPELINE = PipelineConfig(
 # Keep this for auto-detection of deploy config yaml.
 MING_TTS_MOE_PIPELINE = PipelineConfig(
     model_type="ming_tts_moe",
+    default_deploy_config_name="ming_tts_moe.yaml",
     model_arch="MingTTSForConditionalGeneration",
     hf_architectures=("MingTTSForConditionalGeneration", "BailingMMNativeForConditionalGeneration"),
     # Disambiguate from the dense-0.5B ming_tts pipeline
diff --git a/vllm_omni/model_executor/models/ming_tts/prompt_assembly.py b/vllm_omni/model_executor/models/ming_tts/prompt_assembly.py
index 36817022a..5960af742 100644
--- a/vllm_omni/model_executor/models/ming_tts/prompt_assembly.py
+++ b/vllm_omni/model_executor/models/ming_tts/prompt_assembly.py
@@ -265,6 +265,7 @@ def build_ming_dense_prompt(
     prompt_waveform: Any = None,
     prompt_latents: Any = None,
     speaker_embedding: Any = None,
+    speaker_count: int | None = None,
     use_zero_spk_emb: bool = False,
     request_id: str | None = None,
     model_variant: str | None = None,
@@ -273,6 +274,17 @@ def build_ming_dense_prompt(
         model_variant = detect_model_variant(tokenizer)
     instruction_text = create_instruction(instruction)
     speaker_embeddings = coerce_speaker_embeddings(speaker_embedding, use_zero_spk_emb=use_zero_spk_emb)
+    if speaker_count is None:
+        effective_speaker_count = 0 if speaker_embeddings is None else len(speaker_embeddings)
+    else:
+        effective_speaker_count = int(speaker_count)
+        if effective_speaker_count < 0:
+            raise ValueError(f"speaker_count must be >= 0, got {effective_speaker_count}")
+        if speaker_embeddings is not None and effective_speaker_count != len(speaker_embeddings):
+            raise ValueError(
+                f"speaker_count={effective_speaker_count} does not match "
+                f"{len(speaker_embeddings)} provided speaker embeddings"
+            )
     effective_runtime_controls = resolve_effective_runtime_controls(text=text, runtime_controls=runtime_controls)
 
     prompt_waveform_tensor = None
@@ -305,7 +317,7 @@ def build_ming_dense_prompt(
         text=text,
         instruction=instruction_text,
         prompt_text=prompt_text if prompt_patch_count > 0 else None,
-        speaker_count=0 if speaker_embeddings is None else len(speaker_embeddings),
+        speaker_count=effective_speaker_count,
         prompt_patch_count=prompt_patch_count,
     )
 
diff --git a/vllm_omni/model_executor/models/ming_tts/speaker_extractor.py b/vllm_omni/model_executor/models/ming_tts/speaker_extractor.py
index 00523c26f..8e9f69068 100644
--- a/vllm_omni/model_executor/models/ming_tts/speaker_extractor.py
+++ b/vllm_omni/model_executor/models/ming_tts/speaker_extractor.py
@@ -1,14 +1,33 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 # Adopted from https://github.com/inclusionAI/Ming-omni-tts/blob/main/spkemb_extractor.py
+from __future__ import annotations
+
 import os
+import threading
+from typing import TYPE_CHECKING, Any
 
 import torch
 import torchaudio
+from vllm.logger import init_logger
 from vllm.multimodal.media.audio import load_audio
 
 from vllm_omni.model_executor.models.ming_flash_omni.spk_embedding import SpkembExtractor
 
+from .audio_prep import coerce_prompt_waveform, coerce_speaker_embeddings
+from .constants import (
+    KEY_SPEAKER_EMBEDDING,
+    KEY_SPEAKER_SAMPLE_RATES,
+    KEY_SPEAKER_WAVEFORM,
+    KEY_SPEAKER_WAVEFORM_LENGTHS,
+)
+
+if TYPE_CHECKING:
+    from .ming_tts import MingTTSForConditionalGeneration
+
+logger = init_logger(__name__)
+_EXTRACTOR_LOAD_LOCK = threading.Lock()
+
 
 def resolve_model_to_local_path(model):
     if os.path.isdir(model):
@@ -49,3 +68,114 @@ class MingSpeakerEmbeddingExtractor:
 
     def extract_many(self, audio_paths):
         return [self.extract_from_file(path) for path in audio_paths]
+
+
+def _load_speaker_extractor(wrapper: MingTTSForConditionalGeneration) -> MingSpeakerEmbeddingExtractor:
+    extractor = getattr(wrapper, "_speaker_extractor", None)
+    if extractor is not None:
+        return extractor
+
+    with _EXTRACTOR_LOAD_LOCK:
+        extractor = getattr(wrapper, "_speaker_extractor", None)
+        if extractor is None:
+            model_path = wrapper.vllm_config.model_config.model
+            extractor = MingSpeakerEmbeddingExtractor(model_path, target_sr=16000)
+            wrapper._speaker_extractor = extractor
+    return extractor
+
+
+def _speaker_waveforms_from_info(
+    info_dict: dict[str, Any],
+    default_sample_rate: int,
+) -> list[tuple[torch.Tensor, int]]:
+    raw_waveform = info_dict.get(KEY_SPEAKER_WAVEFORM)
+    if raw_waveform is None:
+        return []
+
+    waveform = coerce_prompt_waveform(raw_waveform)
+    raw_lengths = info_dict.get(KEY_SPEAKER_WAVEFORM_LENGTHS)
+    if raw_lengths is None:
+        parts = [waveform]
+    else:
+        lengths = torch.as_tensor(raw_lengths).detach().reshape(-1).to(torch.int64).cpu().tolist()
+        if not lengths or any(int(length) <= 0 for length in lengths):
+            raise ValueError(f"Invalid Ming speaker waveform lengths: {lengths}")
+        if sum(int(length) for length in lengths) > int(waveform.shape[-1]):
+            raise ValueError(
+                "Ming speaker waveform lengths exceed the waveform size: "
+                f"lengths={lengths}, waveform_samples={int(waveform.shape[-1])}"
+            )
+
+        parts = []
+        offset = 0
+        for length in lengths:
+            end = offset + int(length)
+            parts.append(waveform[:, offset:end])
+            offset = end
+
+    raw_sample_rates = info_dict.get(KEY_SPEAKER_SAMPLE_RATES)
+    if raw_sample_rates is None:
+        sample_rates = [int(default_sample_rate)] * len(parts)
+    else:
+        sample_rates = torch.as_tensor(raw_sample_rates).detach().reshape(-1).to(torch.int64).cpu().tolist()
+        if len(sample_rates) != len(parts) or any(int(sample_rate) <= 0 for sample_rate in sample_rates):
+            raise ValueError(
+                f"Invalid Ming speaker sample rates: sample_rates={sample_rates}, waveform_count={len(parts)}"
+            )
+    return [(waveform_part, int(sample_rate)) for waveform_part, sample_rate in zip(parts, sample_rates, strict=True)]
+
+
+def _resolve_speaker_embeddings(
+    wrapper: MingTTSForConditionalGeneration,
+    info_dict: dict[str, Any],
+) -> list[torch.Tensor] | None:
+    direct_embedding = info_dict.get(KEY_SPEAKER_EMBEDDING, info_dict.get("speaker_embedding"))
+    use_zero_spk_emb = bool(info_dict.get("use_zero_spk_emb", False))
+    if direct_embedding is not None or use_zero_spk_emb:
+        return coerce_speaker_embeddings(direct_embedding, use_zero_spk_emb=use_zero_spk_emb)
+
+    voice_name = info_dict.get("voice_name")
+    if isinstance(voice_name, (list, tuple)):
+        voice_name = voice_name[0] if voice_name else None
+    created_at = info_dict.get("voice_created_at", 0)
+    if isinstance(created_at, (list, tuple)):
+        created_at = created_at[0] if created_at else 0
+    if isinstance(created_at, torch.Tensor):
+        created_at = created_at.detach().reshape(-1)[0].item() if created_at.numel() else 0
+
+    cache = wrapper._speaker_cache
+    cache_key = None
+    if isinstance(voice_name, str) and voice_name.strip():
+        cache_key = cache.make_cache_key(voice_name, model_type="ming_tts", created_at=int(created_at or 0))
+        cached = cache.get(cache_key)
+        if cached is not None:
+            cached_embeddings = coerce_speaker_embeddings(cached.get("speaker_embedding"))
+            if cached_embeddings is not None:
+                logger.debug("Speaker cache HIT for Ming-TTS speaker '%s'", voice_name)
+                return cached_embeddings
+
+    waveform_inputs = _speaker_waveforms_from_info(info_dict, int(wrapper.ming_config.sample_rate))
+    if not waveform_inputs:
+        if cache_key is not None:
+            raise ValueError(f"Ming-TTS speaker '{voice_name}' was requested without reference audio on cache miss")
+        return None
+
+    extractor = _load_speaker_extractor(wrapper)
+    embeddings = [
+        extractor.extract_from_waveform(waveform, sample_rate).detach().reshape(-1).to(torch.float32).cpu()
+        for waveform, sample_rate in waveform_inputs
+    ]
+    resolved = coerce_speaker_embeddings(embeddings)
+    if cache_key is not None and resolved is not None:
+        cached_embedding = resolved[0] if len(resolved) == 1 else torch.stack(resolved, dim=0)
+        cache.put(cache_key, {"speaker_embedding": cached_embedding})
+        logger.debug("Speaker cache STORE for Ming-TTS speaker '%s'", voice_name)
+    return resolved
+
+
+__all__ = [
+    "MingSpeakerEmbeddingExtractor",
+    "_load_speaker_extractor",
+    "_resolve_speaker_embeddings",
+    "resolve_model_to_local_path",
+]
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py b/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py
new file mode 100644
index 000000000..5ffde9e15
--- /dev/null
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py
@@ -0,0 +1,484 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Strict, state-explicit batching for MiniCPM-o 4.5 Token2wav."""
+
+from __future__ import annotations
+
+from contextlib import nullcontext
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+_SILENCE_TOKEN = 4218
+
+
+def _autocast_disabled(device: torch.device):
+    """Disable any enclosing autocast region on ``device``.
+
+    ``torch.amp.autocast`` resolves the autocast dtype for ``device_type``
+    while constructing the context, which raises on accelerators (e.g. Ascend
+    NPU) that never registered autocast support. Degrade to a no-op there: an
+    enclosing region can only exist on a device type torch already knows.
+    """
+    try:
+        return torch.amp.autocast(device.type, enabled=False)
+    except (RuntimeError, TypeError, ValueError):
+        return nullcontext()
+
+
+def tensor_signature(value: torch.Tensor) -> tuple[tuple[int, ...], str, str]:
+    return tuple(value.shape), str(value.dtype), value.device.type
+
+
+def state_shape_signature(state: BatchedToken2WavState) -> tuple[Any, ...]:
+    flow = tuple((name, tensor_signature(state.flow_cache[name])) for name in sorted(state.flow_cache))
+    hift = tuple((name, tensor_signature(state.hift_cache[name])) for name in sorted(state.hift_cache))
+    return flow, hift
+
+
+@dataclass(frozen=True)
+class PromptFeatures:
+    speech_tokens: torch.Tensor
+    speaker_embedding: torch.Tensor
+    mels: torch.Tensor
+
+
+@dataclass(frozen=True)
+class BatchedToken2WavState:
+    flow_cache: dict[str, torch.Tensor]
+    hift_cache: dict[str, torch.Tensor]
+
+
+class BatchedToken2Wav(nn.Module):
+    """Drive Token2wav's modules with dynamically-sized, request-owned caches.
+
+    This class intentionally never calls ``Token2wav.stream`` or
+    ``Token2wav.__call__``. The upstream object is used only as a one-time
+    asset loader and prompt feature extractor.
+    """
+
+    def __init__(self, token2wav: Any, trt_stepper: Any | None = None):
+        super().__init__()
+        self._token2wav = token2wav
+        # Optional TrtDiTStepper (step_audio2_dit_trt): replaces only the
+        # per-timestep DiT estimator call; encoder and HiFT stay on torch.
+        self._trt_stepper = trt_stepper
+        self.flow = token2wav.flow
+        self.hift = token2wav.hift
+        hift_parameter = next(self.hift.parameters(), None)
+        if hift_parameter is not None and hift_parameter.device.type == "cuda":
+            # Prime the CUDA state used by HiFT during backend construction.
+            # Otherwise, the first live audio chunk can fail when async stages
+            # share one GPU.
+            device = hift_parameter.device
+            dtype = hift_parameter.dtype
+            mel_channels = int(self.hift.conv_pre.in_channels)
+            with (
+                torch.inference_mode(),
+                torch.random.fork_rng(devices=[device]),
+                _autocast_disabled(device),
+            ):
+                # 50 mel frames match the default first streamed vocoder chunk.
+                speech, source = self.hift(
+                    torch.zeros((1, mel_channels, 50), device=device, dtype=dtype),
+                    torch.zeros((1, 1, 0), device=device, dtype=dtype),
+                )
+            torch.accelerator.synchronize(device)
+            del speech, source
+            torch.accelerator.empty_cache()
+        self.float16 = bool(token2wav.float16)
+        self.n_timesteps = int(token2wav.n_timesteps)
+        self.mel_cache_len = int(token2wav.mel_cache_len)
+        self.source_cache_len = int(token2wav.source_cache_len)
+        self.register_buffer(
+            "speech_window",
+            token2wav.speech_window.detach().clone(),
+            persistent=False,
+        )
+        self._prompt_features: dict[tuple[str, str], PromptFeatures] = {}
+
+    def prepare_prompt(self, prompt_cache_id: str, prompt_wav: str) -> PromptFeatures:
+        cache_key = (prompt_cache_id, prompt_wav)
+        cached = self._prompt_features.get(cache_key)
+        if cached is None:
+            # The generation runner may wrap model.forward in bf16 autocast,
+            # and vLLM constructs the model under a bf16 default dtype, while
+            # S3Tokenizer prompt extraction uses fp32 convolution weights.
+            previous_dtype = torch.get_default_dtype()
+            try:
+                torch.set_default_dtype(torch.float32)
+                with _autocast_disabled(self.speech_window.device):
+                    values = self._token2wav._prepare_prompt(prompt_wav)
+            finally:
+                torch.set_default_dtype(previous_dtype)
+            cached = PromptFeatures(
+                speech_tokens=values[0],
+                speaker_embedding=values[2],
+                mels=values[3],
+            )
+            self._prompt_features[cache_key] = cached
+        return cached
+
+    def evict_prompt(self, prompt_cache_id: str, prompt_wav: str) -> None:
+        """Release request-owned prompt features after stream completion."""
+        self._prompt_features.pop((prompt_cache_id, prompt_wav), None)
+
+    @staticmethod
+    def _repeat_prompt(features: PromptFeatures, batch_size: int) -> tuple[torch.Tensor, ...]:
+        return (
+            features.speech_tokens.expand(batch_size, -1),
+            features.speaker_embedding.expand(batch_size, -1),
+            features.mels.expand(batch_size, -1, -1),
+        )
+
+    def _autocast(self, device: torch.device):
+        if device.type != "cuda":
+            return nullcontext()
+        if not self.float16:
+            return torch.amp.autocast("cuda", enabled=False)
+        return torch.amp.autocast(
+            "cuda",
+            dtype=torch.float16,
+        )
+
+    def _pre_lookahead_len(self) -> int | None:
+        """Right-context width of the encoder's pre-lookahead convolution.
+
+        ``None`` when the encoder does not expose one, so callers keep working
+        against encoder implementations without that layer.
+        """
+        layer = getattr(self.flow.encoder, "pre_lookahead_layer", None)
+        width = getattr(layer, "pre_lookahead_len", None)
+        return int(width) if width is not None else None
+
+    def _encode_chunk(
+        self,
+        tokens: torch.Tensor,
+        *,
+        last_chunk: bool,
+        cnn_cache: torch.Tensor | None,
+        att_cache: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        embedded = self.flow.input_embedding(tokens)
+        hidden, new_cnn, new_att = self.flow.encoder.forward_chunk(
+            xs=embedded,
+            last_chunk=last_chunk,
+            cnn_cache=cnn_cache,
+            att_cache=att_cache,
+        )
+        return self.flow.encoder_proj(hidden), new_cnn, new_att
+
+    @staticmethod
+    def _estimator_buffers(
+        estimator: nn.Module,
+        x: torch.Tensor,
+        old_att: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        blocks = estimator.blocks
+        depth = len(blocks)
+        batch_size = int(x.shape[0])
+        chunk_size = int(x.shape[2])
+        old_att_len = int(old_att.shape[3]) if old_att is not None else 0
+        block0 = blocks[0]
+        cnn_channels = int(block0.conv.in_channels + block0.conv.out_channels)
+        cnn_width = int(block0.conv.block[1].causal_padding[0])
+        heads = int(block0.attn.num_heads)
+        att_width = int(block0.attn.head_dim * 2)
+        cnn = x.new_empty((depth, batch_size, cnn_channels, cnn_width))
+        att = x.new_empty((depth, batch_size, heads, old_att_len + chunk_size, att_width))
+        return cnn, att
+
+    def _estimator_step(
+        self,
+        estimator: nn.Module,
+        *,
+        x: torch.Tensor,
+        mu: torch.Tensor,
+        time: torch.Tensor,
+        speakers: torch.Tensor,
+        cond: torch.Tensor,
+        cnn_cache: torch.Tensor | None,
+        att_cache: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        if self._trt_stepper is not None:
+            out, new_cnn, new_att = self._trt_stepper.step(
+                x=x,
+                mu=mu,
+                t=time,
+                spks=speakers,
+                cond=cond,
+                cnn_cache=cnn_cache,
+                att_cache=att_cache,
+            )
+            return out.to(mu.dtype), new_cnn, new_att
+        time_embedding = estimator.t_embedder(time).unsqueeze(1)
+        width = int(x.shape[-1])
+        speaker_features = speakers.unsqueeze(-1).expand(-1, -1, width)
+        estimator_input = torch.cat((x, mu, speaker_features, cond), dim=1)
+        cnn_out, att_out = self._estimator_buffers(estimator, estimator_input, att_cache)
+        old_cnn: Any = cnn_cache if cnn_cache is not None else [None] * len(estimator.blocks)
+        old_att: Any = att_cache if att_cache is not None else [None] * len(estimator.blocks)
+        result = estimator.blocks_forward_chunk(
+            estimator_input,
+            time_embedding,
+            None,
+            old_cnn,
+            old_att,
+            cnn_out,
+            att_out,
+        )
+        return result, cnn_out, att_out
+
+    def _decode_cfm(
+        self,
+        mu: torch.Tensor,
+        speakers: torch.Tensor,
+        cond: torch.Tensor,
+        *,
+        cnn_cache: torch.Tensor | None,
+        att_cache: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        decoder = self.flow.decoder
+        estimator = decoder.estimator
+        batch_size = int(mu.shape[0])
+        offset = int(att_cache.shape[4]) if att_cache is not None else 0
+        end = offset + int(mu.shape[2])
+        if end > int(decoder.rand_noise.shape[2]):
+            raise RuntimeError(
+                "MiniCPMO45Code2WavBatchError "
+                f'{{"reason":"noise_capacity","required":{end},'
+                f'"available":{int(decoder.rand_noise.shape[2])}}}'
+            )
+        x = decoder.rand_noise[:, :, offset:end].expand(batch_size, -1, -1).clone()
+        timeline = torch.linspace(
+            0,
+            1,
+            self.n_timesteps + 1,
+            device=mu.device,
+            dtype=mu.dtype,
+        )
+        timeline = 1 - torch.cos(timeline * 0.5 * torch.pi)
+        time = timeline[0].expand(batch_size)
+        mu_cfg = torch.cat((mu, torch.zeros_like(mu)), dim=0)
+        speakers_cfg = torch.cat((speakers, torch.zeros_like(speakers)), dim=0)
+        cond_cfg = torch.cat((cond, torch.zeros_like(cond)), dim=0)
+        next_cnn: list[torch.Tensor] = []
+        next_att: list[torch.Tensor] = []
+        dt = timeline[1] - timeline[0]
+        for step in range(self.n_timesteps):
+            old_cnn = cnn_cache[step] if cnn_cache is not None else None
+            old_att = att_cache[step] if att_cache is not None else None
+            estimate, step_cnn, step_att = self._estimator_step(
+                estimator,
+                x=torch.cat((x, x), dim=0),
+                mu=mu_cfg,
+                time=torch.cat((time, time), dim=0),
+                speakers=speakers_cfg,
+                cond=cond_cfg,
+                cnn_cache=old_cnn,
+                att_cache=old_att,
+            )
+            conditional, unconditional = estimate.split(batch_size, dim=0)
+            velocity = (1.0 + decoder.inference_cfg_rate) * conditional - decoder.inference_cfg_rate * unconditional
+            x = x + dt * velocity
+            time = time + dt
+            if step + 1 < self.n_timesteps:
+                dt = timeline[step + 2] - time[0]
+            next_cnn.append(step_cnn)
+            next_att.append(step_att)
+        return x, torch.stack(next_cnn), torch.stack(next_att)
+
+    @staticmethod
+    def _split_flow_cache(cache: dict[str, torch.Tensor], batch_size: int) -> list[dict[str, torch.Tensor]]:
+        result: list[dict[str, torch.Tensor]] = []
+        for row in range(batch_size):
+            result.append(
+                {
+                    "conformer_cnn_cache": cache["conformer_cnn_cache"][row : row + 1].detach().clone(),
+                    "conformer_att_cache": cache["conformer_att_cache"][:, row : row + 1].detach().clone(),
+                    "estimator_cnn_cache": torch.cat(
+                        (
+                            cache["estimator_cnn_cache"][:, :, row : row + 1],
+                            cache["estimator_cnn_cache"][:, :, batch_size + row : batch_size + row + 1],
+                        ),
+                        dim=2,
+                    ).detach(),
+                    "estimator_att_cache": torch.cat(
+                        (
+                            cache["estimator_att_cache"][:, :, row : row + 1],
+                            cache["estimator_att_cache"][:, :, batch_size + row : batch_size + row + 1],
+                        ),
+                        dim=2,
+                    ).detach(),
+                }
+            )
+        return result
+
+    @staticmethod
+    def _stack_flow_cache(states: list[BatchedToken2WavState]) -> dict[str, torch.Tensor]:
+        flows = [state.flow_cache for state in states]
+        conditional_cnn = [flow["estimator_cnn_cache"][:, :, 0:1] for flow in flows]
+        unconditional_cnn = [flow["estimator_cnn_cache"][:, :, 1:2] for flow in flows]
+        conditional_att = [flow["estimator_att_cache"][:, :, 0:1] for flow in flows]
+        unconditional_att = [flow["estimator_att_cache"][:, :, 1:2] for flow in flows]
+        return {
+            "conformer_cnn_cache": torch.cat([flow["conformer_cnn_cache"] for flow in flows], dim=0),
+            "conformer_att_cache": torch.cat([flow["conformer_att_cache"] for flow in flows], dim=1),
+            "estimator_cnn_cache": torch.cat((*conditional_cnn, *unconditional_cnn), dim=2),
+            "estimator_att_cache": torch.cat((*conditional_att, *unconditional_att), dim=2),
+        }
+
+    def setup_batch(
+        self,
+        features: PromptFeatures,
+        batch_size: int,
+    ) -> list[BatchedToken2WavState]:
+        prompt_tokens, speakers, prompt_mels = self._repeat_prompt(features, batch_size)
+        lookahead_width = self._pre_lookahead_len()
+        lookahead = prompt_tokens.new_full(
+            (batch_size, 3 if lookahead_width is None else lookahead_width),
+            _SILENCE_TOKEN,
+        )
+        with self._autocast(prompt_tokens.device):
+            hidden, conformer_cnn, conformer_att = self._encode_chunk(
+                torch.cat((prompt_tokens, lookahead), dim=1),
+                last_chunk=False,
+                cnn_cache=None,
+                att_cache=None,
+            )
+            projected_speakers = self.flow.spk_embed_affine_layer(F.normalize(speakers, dim=1))
+            _, estimator_cnn, estimator_att = self._decode_cfm(
+                hidden.transpose(1, 2).contiguous(),
+                projected_speakers,
+                prompt_mels.transpose(1, 2).contiguous(),
+                cnn_cache=None,
+                att_cache=None,
+            )
+        flow_cache = {
+            "conformer_cnn_cache": conformer_cnn,
+            "conformer_att_cache": conformer_att,
+            "estimator_cnn_cache": estimator_cnn,
+            "estimator_att_cache": estimator_att,
+        }
+        split = self._split_flow_cache(flow_cache, batch_size)
+        mel_channels = int(prompt_mels.shape[2])
+        return [
+            BatchedToken2WavState(
+                flow_cache=row,
+                hift_cache={
+                    "mel": prompt_mels.new_zeros((1, mel_channels, 0)),
+                    "source": prompt_mels.new_zeros((1, 1, 0)),
+                    "speech": prompt_mels.new_zeros((1, 0)),
+                },
+            )
+            for row in split
+        ]
+
+    @staticmethod
+    def _fade_in_out(
+        speech: torch.Tensor,
+        previous: torch.Tensor,
+        window: torch.Tensor,
+    ) -> torch.Tensor:
+        overlap = min(
+            int(window.shape[0] // 2),
+            int(speech.shape[-1]),
+            int(previous.shape[-1]),
+        )
+        result = speech.clone()
+        if overlap > 0:
+            result[..., :overlap] = (
+                result[..., :overlap] * window[:overlap] + previous[..., -overlap:] * window[-overlap:]
+            )
+        return result
+
+    def decode_batch(
+        self,
+        tokens: torch.Tensor,
+        features: PromptFeatures,
+        states: list[BatchedToken2WavState],
+        *,
+        last_chunk: bool,
+        flush_encoder: bool = False,
+    ) -> tuple[list[torch.Tensor], list[BatchedToken2WavState]]:
+        batch_size = int(tokens.shape[0])
+        if batch_size != len(states):
+            raise ValueError(f"tokens batch {batch_size} != state batch {len(states)}")
+        # The encoder's pre-lookahead convolution consumes ``pre_lookahead_len``
+        # frames of right context and keeps no left cache, so a non-final chunk
+        # must carry at least one full kernel. Only the final chunk is allowed
+        # to be shorter: ``forward_chunk`` zero-pads it by the lookahead width.
+        lookahead = self._pre_lookahead_len()
+        if lookahead is not None and not last_chunk:
+            num_frames = int(tokens.shape[1])
+            if num_frames <= lookahead:
+                raise RuntimeError(
+                    "MiniCPMO45Code2WavBatchError "
+                    f'{{"reason":"chunk_below_lookahead_window","frames":{num_frames},'
+                    f'"minimum":{lookahead + 1}}}'
+                )
+        flow_cache = self._stack_flow_cache(states)
+        speakers = features.speaker_embedding.expand(batch_size, -1)
+        with self._autocast(tokens.device):
+            hidden, conformer_cnn, conformer_att = self._encode_chunk(
+                tokens,
+                last_chunk=last_chunk or flush_encoder,
+                cnn_cache=flow_cache["conformer_cnn_cache"],
+                att_cache=flow_cache["conformer_att_cache"],
+            )
+            projected_speakers = self.flow.spk_embed_affine_layer(F.normalize(speakers, dim=1))
+            cond = torch.zeros_like(hidden).transpose(1, 2).contiguous()
+            chunk_mel, estimator_cnn, estimator_att = self._decode_cfm(
+                hidden.transpose(1, 2).contiguous(),
+                projected_speakers,
+                cond,
+                cnn_cache=flow_cache["estimator_cnn_cache"],
+                att_cache=flow_cache["estimator_att_cache"],
+            )
+
+        prompt_len = int(features.mels.shape[1])
+        if estimator_att.shape[4] > prompt_len + 100:
+            estimator_att = torch.cat(
+                (estimator_att[..., :prompt_len, :], estimator_att[..., -100:, :]),
+                dim=4,
+            )
+        if conformer_att.shape[3] > prompt_len + 100:
+            conformer_att = torch.cat(
+                (conformer_att[..., :prompt_len, :], conformer_att[..., -100:, :]),
+                dim=3,
+            )
+        new_flow = self._split_flow_cache(
+            {
+                "conformer_cnn_cache": conformer_cnn,
+                "conformer_att_cache": conformer_att,
+                "estimator_cnn_cache": estimator_cnn,
+                "estimator_att_cache": estimator_att,
+            },
+            batch_size,
+        )
+        old_mel = torch.cat([state.hift_cache["mel"] for state in states], dim=0)
+        old_source = torch.cat([state.hift_cache["source"] for state in states], dim=0)
+        old_speech = torch.cat([state.hift_cache["speech"] for state in states], dim=0)
+        mel = torch.cat((old_mel, chunk_mel), dim=2)
+        speech, source = self.hift(mel, old_source)
+        if old_speech.shape[-1] > 0:
+            window = self.speech_window.to(device=speech.device, dtype=speech.dtype)
+            speech = self._fade_in_out(speech, old_speech, window)
+        next_hift = {
+            "mel": mel[..., -self.mel_cache_len :].detach(),
+            "source": source[..., -self.source_cache_len :].detach(),
+            "speech": speech[..., -self.source_cache_len :].detach(),
+        }
+        emitted = speech if last_chunk else speech[..., : -self.source_cache_len]
+        next_states = [
+            BatchedToken2WavState(
+                flow_cache=new_flow[row],
+                hift_cache={name: value[row : row + 1].detach().clone() for name, value in next_hift.items()},
+            )
+            for row in range(batch_size)
+        ]
+        audios = [emitted[row].reshape(-1).to(dtype=torch.float32) for row in range(batch_size)]
+        return audios, next_states
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py
new file mode 100644
index 000000000..019ab0594
--- /dev/null
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py
@@ -0,0 +1,788 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Strict batched codec-to-waveform stage for MiniCPM-o 4.5."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from hashlib import sha256
+from pathlib import Path
+from typing import Any
+
+import soundfile as sf
+import torch
+import torch.nn as nn
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+from .batched_token2wav import (
+    BatchedToken2Wav,
+    BatchedToken2WavState,
+    state_shape_signature,
+)
+
+logger = init_logger(__name__)
+
+
+def _resolve_model_dir(model_ref: str, revision: str | None = None) -> str:
+    """Resolve ``model_ref`` to a local directory containing the repo assets.
+
+    ``model_config.model`` is a filesystem path in local deployments but a
+    Hugging Face repo id in hub/CI deployments; the prompt-audio and
+    token2wav asset lookups need a real directory either way.
+    """
+    if Path(model_ref).is_dir():
+        return model_ref
+    from huggingface_hub import snapshot_download
+
+    return snapshot_download(model_ref, revision=revision, allow_patterns=["assets/*"])
+
+
+def _batch_error(reason: str, **details: Any) -> RuntimeError:
+    payload = {"reason": reason, **details}
+    return RuntimeError(f"MiniCPMO45Code2WavBatchError {json.dumps(payload, sort_keys=True)}")
+
+
+def _scalar(value: Any, default: Any = None) -> Any:
+    if isinstance(value, torch.Tensor):
+        return value.reshape(-1)[0].item() if value.numel() else default
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return _scalar(value[0], default) if value else default
+    return default if value is None else value
+
+
+def _codec_tensor(value: Any, fallback: torch.Tensor) -> torch.Tensor:
+    if isinstance(value, torch.Tensor):
+        return value.reshape(-1).to(device=fallback.device, dtype=torch.long)
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return torch.as_tensor(value, device=fallback.device, dtype=torch.long).reshape(-1)
+    return fallback.reshape(-1).to(dtype=torch.long)
+
+
+# Keys the runner stamps on every step regardless of stage input (see
+# OmniGPUModelRunner._preprocess and the NPU _gather_runtime_additional_information
+# override). A step carrying only these has no producer payload at all.
+_RUNNER_STAMPED_KEYS = frozenset({"request_id", "req_id", "generated_len", "meta"})
+
+
+def _carries_stage_payload(info: Mapping[str, Any], meta: Mapping[str, Any]) -> bool:
+    """Whether this step carries anything the Talker stage actually sent.
+
+    Any real async-chunk payload brings producer metadata along, whether the
+    transport delivers it nested under ``meta`` or as flattened ``meta.*`` keys.
+    """
+    if any(key not in _RUNNER_STAMPED_KEYS for key in info):
+        return True
+    return meta is not info and any(key not in _RUNNER_STAMPED_KEYS for key in meta)
+
+
+@dataclass(frozen=True)
+class _RequestState:
+    cache_epoch: int
+    chunk_seq: int
+    prompt_cache_id: str
+    prompt_wav: str
+    token2wav: BatchedToken2WavState
+
+
+@dataclass
+class _RuntimePrompt:
+    cache_id: str
+    path: str
+    owners: set[str]
+
+
+@dataclass(frozen=True)
+class _WorkItem:
+    output_index: int
+    state_id: str
+    request_id: str
+    cache_epoch: int
+    chunk_seq: int
+    prompt_cache_id: str
+    prompt_wav: str
+    last_chunk: bool
+    tokens: torch.Tensor
+    previous: _RequestState | None
+    runtime_prompt_key: str | None
+    duplex_epoch: int
+    duplex_turn_id: int
+    segment_text_utf8: torch.Tensor
+    tts_is_last_chunk: bool
+    segment_end: bool
+    turn_end: bool
+    has_payload: bool = True
+
+
+class MiniCPMO45Code2Wav(nn.Module):
+    """LLM_GENERATION model that admits only true exact-shape GPU batches."""
+
+    input_modalities = "audio"
+    have_multimodal_outputs = True
+    enable_update_additional_information = True
+    requires_raw_input_tokens = True
+    requires_request_ids = True
+    has_preprocess = False
+    has_postprocess = False
+
+    def __init__(
+        self,
+        *,
+        vllm_config: VllmConfig,
+        prefix: str = "",
+    ):
+        super().__init__()
+        del prefix
+        self.vllm_config = vllm_config
+        self.model_path = str(vllm_config.model_config.model)
+        self._model_revision = getattr(vllm_config.model_config, "revision", None)
+        self.backend: BatchedToken2Wav | None = None
+        self._states: dict[str, _RequestState] = {}
+        self._runtime_prompts: dict[str, _RuntimePrompt] = {}
+        self._request_prompt_keys: dict[str, str] = {}
+        self._runtime_prompt_dir = tempfile.TemporaryDirectory(
+            prefix="minicpmo45-runtime-prompts-",
+        )
+        extra = self._extra_config()
+        self._min_batch_size = int(extra.get("code2wav_min_batch_size", 1))
+        if self._min_batch_size < 1:
+            raise ValueError("MiniCPM-o Code2Wav code2wav_min_batch_size must be >= 1")
+        self._default_prompt_id = str(extra.get("prompt_cache_id", "HT_ref_audio"))
+        self._prompt_wav_override = extra.get("prompt_wav")
+
+    @property
+    def _default_prompt_wav(self) -> str:
+        if self._prompt_wav_override is not None:
+            return str(self._prompt_wav_override)
+        return str(Path(self.model_path) / "assets" / "HT_ref_audio.wav")
+
+    def _extra_config(self) -> dict[str, Any]:
+        model_config = getattr(self.vllm_config, "model_config", None)
+        connector = getattr(model_config, "stage_connector_config", None)
+        if isinstance(connector, Mapping):
+            extra = connector.get("extra", connector)
+        else:
+            extra = getattr(connector, "extra", None)
+        return dict(extra) if isinstance(extra, Mapping) else {}
+
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        return torch.zeros((input_ids.numel(), 1), device=input_ids.device, dtype=torch.float32)
+
+    def compute_logits(self, hidden_states: Any, sampling_metadata: Any = None) -> None:
+        return None
+
+    def _materialize_runtime_prompt(
+        self,
+        ref_audio: Any,
+        sample_rate: Any,
+    ) -> tuple[str, _RuntimePrompt]:
+        sample_rate_hz = int(_scalar(sample_rate, 0))
+        waveform = torch.as_tensor(ref_audio, dtype=torch.float32).reshape(-1).cpu().contiguous()
+        if sample_rate_hz <= 0:
+            raise _batch_error("invalid_ref_audio_sample_rate", sample_rate=sample_rate_hz)
+        if waveform.numel() == 0:
+            raise _batch_error("empty_ref_audio")
+        if not bool(torch.isfinite(waveform).all().item()):
+            raise _batch_error("non_finite_ref_audio")
+
+        digest = sha256()
+        digest.update(waveform.numpy().tobytes())
+        digest.update(str(sample_rate_hz).encode())
+        cache_key = digest.hexdigest()
+        cache_id = f"runtime-ref-{cache_key[:24]}-{sample_rate_hz}"
+        path = str(Path(self._runtime_prompt_dir.name) / f"minicpmo45_ref_{cache_key[:24]}_{sample_rate_hz}.wav")
+        entry = self._runtime_prompts.get(cache_key)
+        if entry is None:
+            entry = _RuntimePrompt(cache_id=cache_id, path=path, owners=set())
+            self._runtime_prompts[cache_key] = entry
+        prompt_path = Path(entry.path)
+        if not prompt_path.is_file():
+            with tempfile.NamedTemporaryFile(
+                dir=prompt_path.parent,
+                prefix=f".{prompt_path.stem}-",
+                suffix=".wav",
+                delete=False,
+            ) as handle:
+                temporary_path = Path(handle.name)
+            try:
+                sf.write(
+                    temporary_path,
+                    waveform.numpy(),
+                    sample_rate_hz,
+                    format="WAV",
+                )
+                os.replace(temporary_path, prompt_path)
+            finally:
+                temporary_path.unlink(missing_ok=True)
+        return cache_key, entry
+
+    def _resolve_prompt(
+        self,
+        state_id: str,
+        info: Mapping[str, Any],
+        meta: Mapping[str, Any],
+        previous: _RequestState | None,
+    ) -> tuple[str, str, str | None]:
+        codes = info.get("codes")
+        ref_audio = codes.get("ref") if isinstance(codes, Mapping) else None
+        if ref_audio is not None:
+            cache_key, entry = self._materialize_runtime_prompt(
+                ref_audio,
+                meta.get("ref_audio_sr"),
+            )
+            return entry.cache_id, entry.path, cache_key
+
+        if previous is not None:
+            return previous.prompt_cache_id, previous.prompt_wav, self._request_prompt_keys.get(state_id)
+
+        cache_key = self._request_prompt_keys.get(state_id)
+        entry = self._runtime_prompts.get(cache_key) if cache_key is not None else None
+        if entry is not None:
+            return entry.cache_id, entry.path, cache_key
+
+        return (
+            str(_scalar(meta.get("prompt_cache_id"), self._default_prompt_id)),
+            str(_scalar(meta.get("prompt_wav"), self._default_prompt_wav)),
+            None,
+        )
+
+    def _release_request_prompt(self, state_id: str) -> None:
+        cache_key = self._request_prompt_keys.pop(state_id, None)
+        entry = self._runtime_prompts.get(cache_key) if cache_key is not None else None
+        if entry is None:
+            return
+        entry.owners.discard(state_id)
+        if entry.owners:
+            return
+        if self.backend is not None:
+            self.backend.evict_prompt(entry.cache_id, entry.path)
+        Path(entry.path).unlink(missing_ok=True)
+        self._runtime_prompts.pop(cache_key, None)
+
+    def _commit_runtime_prompt_owners(self, items: list[_WorkItem]) -> None:
+        for item in items:
+            cache_key = item.runtime_prompt_key
+            if cache_key is None:
+                continue
+            previous_key = self._request_prompt_keys.get(item.state_id)
+            if previous_key != cache_key:
+                self._release_request_prompt(item.state_id)
+            entry = self._runtime_prompts.get(cache_key)
+            if entry is not None:
+                entry.owners.add(item.state_id)
+                self._request_prompt_keys[item.state_id] = cache_key
+
+    def _prune_unowned_runtime_prompts(self) -> None:
+        for cache_key, entry in list(self._runtime_prompts.items()):
+            if entry.owners:
+                continue
+            if self.backend is not None:
+                self.backend.evict_prompt(entry.cache_id, entry.path)
+            Path(entry.path).unlink(missing_ok=True)
+            self._runtime_prompts.pop(cache_key, None)
+
+    @staticmethod
+    def _split_segments(input_ids: torch.Tensor, counts: Any) -> list[torch.Tensor]:
+        flat = input_ids.reshape(-1)
+        if counts is None:
+            return [flat]
+        if not isinstance(counts, Sequence) or isinstance(counts, (str, bytes, bytearray)):
+            raise _batch_error("invalid_seq_token_counts", value_type=type(counts).__name__)
+        normalized = [int(value) for value in counts]
+        if any(value < 0 for value in normalized):
+            raise _batch_error("negative_seq_token_count", counts=normalized)
+        if sum(normalized) != int(flat.numel()):
+            raise _batch_error(
+                "seq_token_count_mismatch",
+                counts=normalized,
+                total=int(flat.numel()),
+            )
+        return list(torch.split(flat, normalized))
+
+    def _parse_item(
+        self,
+        index: int,
+        state_id: str,
+        segment: torch.Tensor,
+        info: Mapping[str, Any],
+    ) -> _WorkItem:
+        meta = info.get("meta")
+        if not isinstance(meta, Mapping):
+            meta = info
+        request_id = str(_scalar(meta.get("request_id"), _scalar(info.get("request_id"), "")))
+        if not _carries_stage_payload(info, meta):
+            # The producer attached nothing to this step, only the bookkeeping
+            # the runner stamps on every request. The stage was scheduled on
+            # the placeholder prompt that async-chunk pre-warm submits before
+            # the first codec window arrives: those tokens are reserved slots,
+            # not codec data, and one bogus frame is shorter than the vocoder's
+            # lookahead window. Such a step carries no producer metadata at
+            # all, so it cannot be held to the payload contract below either.
+            return _WorkItem(
+                output_index=index,
+                state_id=state_id,
+                request_id=request_id or state_id,
+                cache_epoch=0,
+                chunk_seq=0,
+                prompt_cache_id=self._default_prompt_id,
+                prompt_wav=self._default_prompt_wav,
+                last_chunk=False,
+                tokens=segment.new_empty(0, dtype=torch.long),
+                previous=None,
+                runtime_prompt_key=None,
+                duplex_epoch=-1,
+                duplex_turn_id=-1,
+                segment_text_utf8=torch.empty(0, dtype=torch.uint8),
+                tts_is_last_chunk=False,
+                segment_end=False,
+                turn_end=False,
+                has_payload=False,
+            )
+        if not request_id:
+            raise _batch_error("missing_request_id", output_index=index)
+        cache_epoch = int(_scalar(meta.get("cache_epoch"), 0))
+        chunk_seq = int(_scalar(meta.get("chunk_seq"), 0))
+        if cache_epoch < 0 or chunk_seq < 0:
+            raise _batch_error(
+                "negative_stream_position",
+                request_id=request_id,
+                cache_epoch=cache_epoch,
+                chunk_seq=chunk_seq,
+            )
+        last_chunk = bool(_scalar(meta.get("last_chunk"), False))
+        tts_is_last_chunk = bool(_scalar(meta.get("tts_is_last_chunk"), False))
+        codes = info.get("codes")
+        audio = codes.get("audio") if isinstance(codes, Mapping) else None
+        tokens = _codec_tensor(audio, segment)
+        if int(_scalar(meta.get("code_flat_numel"), tokens.numel())) == 0:
+            # The generation scheduler reserves one placeholder token for an
+            # empty terminal or segment-boundary chunk. The producer's
+            # explicit length is the authority, so do not decode that
+            # placeholder as codec data.
+            tokens = segment.new_empty(0, dtype=torch.long)
+        previous = self._states.get(state_id)
+        if previous is None:
+            if chunk_seq != 0:
+                raise _batch_error(
+                    "missing_state_for_chunk",
+                    request_id=request_id,
+                    cache_epoch=cache_epoch,
+                    chunk_seq=chunk_seq,
+                )
+        elif cache_epoch < previous.cache_epoch:
+            raise _batch_error(
+                "stale_cache_epoch",
+                request_id=request_id,
+                expected=previous.cache_epoch,
+                actual=cache_epoch,
+            )
+        elif cache_epoch > previous.cache_epoch:
+            if chunk_seq != 0:
+                raise _batch_error(
+                    "new_epoch_requires_first_chunk",
+                    request_id=request_id,
+                    cache_epoch=cache_epoch,
+                    chunk_seq=chunk_seq,
+                )
+            previous = None
+        elif chunk_seq != previous.chunk_seq + 1:
+            raise _batch_error(
+                "stale_or_reordered_chunk",
+                request_id=request_id,
+                expected=previous.chunk_seq + 1,
+                actual=chunk_seq,
+            )
+        prompt_cache_id, prompt_wav, runtime_prompt_key = self._resolve_prompt(
+            state_id,
+            info,
+            meta,
+            previous,
+        )
+        if previous is not None and prompt_cache_id != previous.prompt_cache_id:
+            raise _batch_error(
+                "prompt_changed_midstream",
+                request_id=request_id,
+                expected=previous.prompt_cache_id,
+                actual=prompt_cache_id,
+            )
+        if previous is not None and prompt_wav != previous.prompt_wav:
+            raise _batch_error(
+                "prompt_changed_midstream",
+                request_id=request_id,
+                expected=previous.prompt_wav,
+                actual=prompt_wav,
+            )
+        segment_text_utf8 = meta.get("llm_output_text_utf8")
+        if not isinstance(segment_text_utf8, torch.Tensor):
+            segment_text_utf8 = torch.empty(0, dtype=torch.uint8)
+        return _WorkItem(
+            output_index=index,
+            state_id=state_id,
+            request_id=request_id,
+            cache_epoch=cache_epoch,
+            chunk_seq=chunk_seq,
+            prompt_cache_id=prompt_cache_id,
+            prompt_wav=prompt_wav,
+            last_chunk=last_chunk,
+            tokens=tokens,
+            previous=previous,
+            runtime_prompt_key=runtime_prompt_key,
+            duplex_epoch=int(_scalar(meta.get("duplex_epoch"), -1)),
+            duplex_turn_id=int(_scalar(meta.get("duplex_turn_id"), -1)),
+            segment_text_utf8=segment_text_utf8,
+            tts_is_last_chunk=tts_is_last_chunk,
+            segment_end=bool(_scalar(meta.get("segment_end"), False)),
+            turn_end=bool(_scalar(meta.get("turn_end"), False)),
+        )
+
+    @staticmethod
+    def _bucket_key(item: _WorkItem) -> tuple[Any, ...]:
+        cache_signature: Any
+        if item.previous is None:
+            cache_signature = ("uninitialized",)
+        else:
+            cache_signature = state_shape_signature(item.previous.token2wav)
+        return (
+            item.prompt_cache_id,
+            item.prompt_wav,
+            int(item.tokens.numel()),
+            cache_signature,
+            item.last_chunk,
+            item.tts_is_last_chunk,
+            item.cache_epoch,
+        )
+
+    @torch.inference_mode()
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        positions: torch.Tensor | None = None,
+        intermediate_tensors: Any = None,
+        inputs_embeds: torch.Tensor | None = None,
+        runtime_additional_information: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        del positions, intermediate_tensors, inputs_embeds
+        ids = input_ids if isinstance(input_ids, torch.Tensor) else torch.empty(0, dtype=torch.long)
+        segments = self._split_segments(ids, kwargs.get("seq_token_counts"))
+        empty = torch.empty(0, dtype=torch.float32, device=ids.device)
+        sample_rate = torch.tensor(24000, dtype=torch.int32)
+        if not runtime_additional_information:
+            count = len(segments)
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={
+                    "model_outputs": [empty for _ in range(count)],
+                    "sr": [sample_rate for _ in range(count)],
+                },
+            )
+        if len(runtime_additional_information) != len(segments):
+            raise _batch_error(
+                "runtime_info_count_mismatch",
+                segments=len(segments),
+                runtime_infos=len(runtime_additional_information),
+            )
+        if self.backend is None:
+            # load_format=dummy (CI core_model runs) skips model.load_weights()
+            # entirely, but Token2wav's assets live beside the checkpoint rather
+            # than in its weight iterator, so they still have to be loaded for
+            # this stage to produce anything. Build them on first use, outside
+            # inference mode so the parameters are ordinary tensors.
+            logger.warning_once(
+                "MiniCPM-o Code2Wav backend was not built during weight loading "
+                "(load_format=%s); loading Token2wav assets now.",
+                getattr(getattr(self.vllm_config, "load_config", None), "load_format", "unknown"),
+            )
+            with torch.inference_mode(False), torch.no_grad():
+                self._build_backend()
+
+        state_ids = kwargs.get("request_ids")
+        if state_ids is None:
+            state_ids = []
+            for index, info in enumerate(runtime_additional_information):
+                if not isinstance(info, Mapping):
+                    state_ids.append(str(index))
+                    continue
+                meta = info.get("meta")
+                source = meta if isinstance(meta, Mapping) else info
+                state_ids.append(str(_scalar(source.get("request_id"), index)))
+        if len(state_ids) != len(segments):
+            raise _batch_error(
+                "request_id_count_mismatch",
+                segments=len(segments),
+                request_ids=len(state_ids),
+            )
+        items: list[_WorkItem] = []
+        try:
+            for index, (state_id, segment, info) in enumerate(
+                zip(state_ids, segments, runtime_additional_information, strict=True)
+            ):
+                if not isinstance(info, Mapping):
+                    raise _batch_error(
+                        "invalid_runtime_info",
+                        output_index=index,
+                        value_type=type(info).__name__,
+                    )
+                items.append(self._parse_item(index, str(state_id), segment, info))
+        except Exception:
+            self._prune_unowned_runtime_prompts()
+            raise
+        state_ids = [item.state_id for item in items]
+        if len(state_ids) != len(set(state_ids)):
+            self._prune_unowned_runtime_prompts()
+            raise _batch_error("duplicate_request_in_forward", request_ids=state_ids)
+        outputs = [empty for _ in segments]
+        sentinels = [item for item in items if item.last_chunk and item.tokens.numel() == 0]
+        segment_markers = [
+            item for item in items if not item.last_chunk and item.tts_is_last_chunk and item.tokens.numel() == 0
+        ]
+        compute_items = [item for item in items if item.tokens.numel() > 0]
+        invalid_empty = [
+            item.request_id
+            for item in items
+            if item.has_payload and not item.last_chunk and not item.tts_is_last_chunk and item.tokens.numel() == 0
+        ]
+        if invalid_empty:
+            self._prune_unowned_runtime_prompts()
+            raise _batch_error("empty_nonfinal_chunk", request_ids=invalid_empty)
+
+        buckets: dict[tuple[Any, ...], list[_WorkItem]] = {}
+        for item in compute_items:
+            buckets.setdefault(self._bucket_key(item), []).append(item)
+        undersized = [
+            {
+                "size": len(bucket),
+                "request_ids": [item.request_id for item in bucket],
+                "codec_len": int(bucket[0].tokens.numel()),
+            }
+            for bucket in buckets.values()
+            if len(bucket) < self._min_batch_size
+        ]
+        if undersized:
+            self._prune_unowned_runtime_prompts()
+            raise _batch_error(
+                "exact_shape_bucket_below_minimum",
+                minimum=self._min_batch_size,
+                buckets=undersized,
+            )
+
+        pending: dict[str, _RequestState | None] = {item.state_id: None for item in sentinels}
+        pending.update(
+            {
+                item.state_id: _RequestState(
+                    cache_epoch=item.cache_epoch,
+                    chunk_seq=item.chunk_seq,
+                    prompt_cache_id=item.prompt_cache_id,
+                    prompt_wav=item.prompt_wav,
+                    token2wav=item.previous.token2wav,
+                )
+                for item in segment_markers
+                if item.previous is not None
+            }
+        )
+        initial_marker_buckets: dict[tuple[str, str], list[_WorkItem]] = {}
+        for item in segment_markers:
+            if item.previous is None:
+                initial_marker_buckets.setdefault(
+                    (item.prompt_cache_id, item.prompt_wav),
+                    [],
+                ).append(item)
+        for bucket in initial_marker_buckets.values():
+            try:
+                features = self.backend.prepare_prompt(
+                    bucket[0].prompt_cache_id,
+                    bucket[0].prompt_wav,
+                )
+                states = self.backend.setup_batch(features, len(bucket))
+            except Exception as exc:
+                self._prune_unowned_runtime_prompts()
+                if isinstance(exc, RuntimeError) and str(exc).startswith("MiniCPMO45Code2WavBatchError "):
+                    raise
+                raise _batch_error(
+                    "backend_unsupported_or_failed",
+                    request_ids=[item.request_id for item in bucket],
+                    error_type=type(exc).__name__,
+                    error=str(exc),
+                ) from exc
+            if len(states) != len(bucket):
+                self._prune_unowned_runtime_prompts()
+                raise _batch_error(
+                    "backend_result_size_mismatch",
+                    expected=len(bucket),
+                    states=len(states),
+                )
+            for item, state in zip(bucket, states, strict=True):
+                pending[item.state_id] = _RequestState(
+                    cache_epoch=item.cache_epoch,
+                    chunk_seq=item.chunk_seq,
+                    prompt_cache_id=item.prompt_cache_id,
+                    prompt_wav=item.prompt_wav,
+                    token2wav=state,
+                )
+        for bucket in buckets.values():
+            batch_size = len(bucket)
+            try:
+                features = self.backend.prepare_prompt(
+                    bucket[0].prompt_cache_id,
+                    bucket[0].prompt_wav,
+                )
+                if bucket[0].previous is None:
+                    states = self.backend.setup_batch(features, batch_size)
+                else:
+                    states = [item.previous.token2wav for item in bucket if item.previous is not None]
+                tokens = torch.stack([item.tokens for item in bucket], dim=0)
+                audios, next_states = self.backend.decode_batch(
+                    tokens,
+                    features,
+                    states,
+                    last_chunk=bucket[0].last_chunk,
+                )
+            except Exception as exc:
+                self._prune_unowned_runtime_prompts()
+                if isinstance(exc, RuntimeError) and str(exc).startswith("MiniCPMO45Code2WavBatchError "):
+                    raise
+                raise _batch_error(
+                    "backend_unsupported_or_failed",
+                    request_ids=[item.request_id for item in bucket],
+                    error_type=type(exc).__name__,
+                    error=str(exc),
+                ) from exc
+            if len(audios) != batch_size or len(next_states) != batch_size:
+                self._prune_unowned_runtime_prompts()
+                raise _batch_error(
+                    "backend_result_size_mismatch",
+                    expected=batch_size,
+                    audios=len(audios),
+                    states=len(next_states),
+                )
+            for item, audio, next_state in zip(bucket, audios, next_states, strict=True):
+                outputs[item.output_index] = audio.reshape(-1).to(dtype=torch.float32)
+                pending[item.state_id] = (
+                    None
+                    if item.last_chunk
+                    else _RequestState(
+                        cache_epoch=item.cache_epoch,
+                        chunk_seq=item.chunk_seq,
+                        prompt_cache_id=item.prompt_cache_id,
+                        prompt_wav=item.prompt_wav,
+                        token2wav=next_state,
+                    )
+                )
+
+        self._commit_runtime_prompt_owners(items)
+        for request_id, state in pending.items():
+            if state is None:
+                self._states.pop(request_id, None)
+            else:
+                self._states[request_id] = state
+        sample_rate_tensor = torch.as_tensor(sample_rate, dtype=torch.int32)
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={
+                "model_outputs": outputs,
+                "sr": [sample_rate_tensor.clone() for _ in outputs],
+                # Generation runner wire payloads are flat and tensor-only.
+                # Dotted metadata keys are unflattened again by the output
+                # processor before the full-duplex data plane consumes them.
+                "meta.duplex_epoch": [torch.tensor(item.duplex_epoch, dtype=torch.int32) for item in items],
+                "meta.duplex_turn_id": [torch.tensor(item.duplex_turn_id, dtype=torch.int32) for item in items],
+                "meta.llm_output_text_utf8": [item.segment_text_utf8 for item in items],
+                "meta.tts_is_last_chunk": [torch.tensor(item.tts_is_last_chunk, dtype=torch.bool) for item in items],
+                "meta.segment_end": [torch.tensor(item.segment_end, dtype=torch.bool) for item in items],
+                "meta.turn_end": [torch.tensor(item.turn_end, dtype=torch.bool) for item in items],
+            },
+        )
+
+    def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
+        for request_id in finished_req_ids:
+            state_id = str(request_id)
+            self._states.pop(state_id, None)
+            self._release_request_prompt(state_id)
+
+    def make_omni_output(self, model_outputs: Any, **_: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+        if isinstance(model_outputs, tuple) and len(model_outputs) == len(OmniOutput._fields):
+            return OmniOutput(*model_outputs)
+        raise TypeError(f"MiniCPMO45Code2Wav expected OmniOutput, got {type(model_outputs).__name__}")
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        for _ in weights:
+            pass
+        self._build_backend()
+        # Token2wav loads flow.pt and hift.pt inside its constructor instead of
+        # from the parent MiniCPM checkpoint iterator. Report those registered
+        # parameters as initialized so vLLM's strict loader audit does not
+        # misclassify the independently loaded Stage-2 weights as missing.
+        return {name for name, _ in self.named_parameters()}
+
+    def _build_backend(self) -> None:
+        """Load the Token2wav assets that back this stage."""
+        if self.backend is not None:
+            return
+
+        # In-tree adapter over StepAudio2Token2WavCore on every platform. It
+        # matches the external `stepaudio2-minicpmo` Token2wav bit-for-bit on
+        # CUDA (same cosyvoice2 flow/DiT modules and weights) while dropping
+        # that package's hard-coded `.cuda()` calls, and auto-applies the
+        # Ascend fixes (HiFT linear downsample, DiT mask expand, MATH SDPA)
+        # on NPU.
+        from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_token2wav import (
+            MiniCPMO45Token2wav as Token2wav,
+        )
+        from vllm_omni.platforms import current_omni_platform
+
+        extra = self._extra_config()
+        # Hub repo ids only need to become local directories once the vocoder
+        # assets are actually read; unit tests construct this model with fake
+        # paths and must not trigger a hub download (#5442).
+        self.model_path = _resolve_model_dir(self.model_path, self._model_revision)
+        prompt_path = Path(self._default_prompt_wav)
+        if not prompt_path.is_file():
+            raise FileNotFoundError(f"MiniCPM-o Code2Wav prompt audio not found: {prompt_path}")
+        token2wav_path = Path(self.model_path) / "assets" / "token2wav"
+        if not token2wav_path.is_dir():
+            raise FileNotFoundError(f"MiniCPM-o Code2Wav assets not found: {token2wav_path}")
+        use_float16 = bool(extra.get("token2wav_float16", False))
+        previous_dtype = torch.get_default_dtype()
+        try:
+            # vLLM constructs bf16 models under a bf16 default-dtype context.
+            # Token2wav contains fp32-only S3Tokenizer/HiFT modules, so build
+            # its independent assets in their native precision.
+            torch.set_default_dtype(torch.float32)
+            token2wav = Token2wav(
+                str(token2wav_path),
+                float16=use_float16,
+                n_timesteps=int(extra.get("token2wav_n_timesteps", 10)),
+            )
+        finally:
+            torch.set_default_dtype(previous_dtype)
+
+        trt_stepper = None
+        use_trt = bool(extra.get("token2wav_trt", False)) or os.environ.get("MINICPMO_TOKEN2WAV_TRT", "") == "1"
+        # TensorRT is CUDA-only; other platforms ignore the toggle.
+        if use_trt and current_omni_platform.is_cuda():
+            from vllm_omni.model_executor.models.step_audio2.step_audio2_dit_trt import build_dit_trt_stepper
+
+            dtype_name = str(
+                extra.get("token2wav_trt_dtype", os.environ.get("MINICPMO_TOKEN2WAV_TRT_DTYPE", "fp16"))
+            ).lower()
+            trt_dtype = torch.float32 if dtype_name in ("fp32", "float32") else torch.float16
+            max_batch = int(extra.get("token2wav_trt_max_batch", 16))
+            device = next(token2wav.flow.parameters()).device
+            trt_stepper = build_dit_trt_stepper(
+                token2wav.flow.decoder.estimator,
+                device=device,
+                dtype=trt_dtype,
+                max_batch=max_batch,
+            )
+            logger.info("MiniCPM-o Code2Wav: DiT estimator running on TensorRT (%s)", dtype_name)
+            token2wav.enable_trt_spk_embedding()
+            logger.info("MiniCPM-o Code2Wav: campplus speaker embedding running on TensorRT")
+        self.backend = BatchedToken2Wav(token2wav, trt_stepper=trt_stepper)
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
index d9b48807a..f2733f3b7 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
@@ -18,10 +18,13 @@
 # limitations under the License.
 
 from collections.abc import Iterable
+from contextlib import suppress
 from functools import cached_property
+from typing import Any
 
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 from vllm.config import VllmConfig
 from vllm.logger import init_logger
 from vllm.model_executor.models.interfaces import SupportsMRoPE, SupportsMultiModal, SupportsPP
@@ -31,6 +34,8 @@ from vllm.sequence import IntermediateTensors
 from vllm.v1.outputs import SamplerOutput
 from vllm.v1.sample.metadata import SamplingMetadata
 
+from vllm_omni.experimental.fullduplex.minicpmo45.policy import MiniCPMO45DuplexPolicy
+from vllm_omni.experimental.fullduplex.model_executor import DuplexSamplingRow
 from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
     MiniCPMO45OmniLLMDummyInputsBuilder,
     MiniCPMO45OmniLLMMultiModalProcessor,
@@ -52,11 +57,11 @@ logger = init_logger(__name__)
 class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP, SupportsMRoPE):
     """MiniCPM-o 4.5 Omni model for conditional generation.
 
-    Two-stage pipeline:
+    Three-stage pipeline:
     - thinker (model_stage="llm"): image / video / audio encoders + 3D
       resampler + the omni LLM that emits text + hidden states.
-    - talker  (model_stage="tts"): MiniCPMTTS + the in-process Token2Wav
-      vocoder that emits the final audio waveform directly.
+    - talker  (model_stage="tts"): native continuous MiniCPMTTS AR that emits
+      codec-token deltas for the separate Code2Wav stage.
     """
 
     @classmethod
@@ -80,6 +85,11 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         # Store configs
         self.config = config
         self.multimodal_config = multimodal_config
+        from vllm_omni.experimental.fullduplex.minicpmo45.compat import (
+            patch_minicpmo_remote_config,
+        )
+
+        patch_minicpmo_remote_config(config)
 
         self.model_stage = vllm_config.model_config.model_stage
 
@@ -89,8 +99,7 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
                 vllm_config=vllm_config,
                 prefix=maybe_prefix(prefix, "thinker"),
                 hf_config=config,
-                # Registry key — must match the entries declared in
-                # vllm_omni/model_executor/models/registry.py::_OMNI_MODELS.
+                # Use registry architecture key
                 architectures=["MiniCPMO45OmniLLMForConditionalGeneration"],
             )
             self.model = self.thinker
@@ -98,21 +107,18 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
 
         elif self.model_stage == "tts":
             self.thinker = None
-            # Initialize talker model — runs MiniCPMTTS + the in-process
-            # Token2Wav vocoder and emits the final audio waveform directly.
+            # The Talker is always the runner-owned continuous codec producer.
             self.talker = init_vllm_registered_model(
                 vllm_config=vllm_config,
                 prefix=maybe_prefix(prefix, "talker"),
                 hf_config=config,
-                # Registry key — must match the entries declared in
-                # vllm_omni/model_executor/models/registry.py::_OMNI_MODELS.
+                # Use registry architecture key
                 architectures=["MiniCPMO45OmniTTSForConditionalGeneration"],
             )
             # Initialize multimodal components if needed
             if hasattr(self.talker, "init_multi_modal"):
                 self.talker.init_multi_modal(config)
             self.model = self.talker
-
         else:
             raise ValueError(f"Invalid model stage: {self.model_stage}. Must be one of: 'llm', 'tts'")
 
@@ -120,10 +126,18 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         self.make_empty_intermediate_tensors = (
             (self.thinker.make_empty_intermediate_tensors)
             if self.model_stage == "llm" and self.thinker is not None
+            else self.talker.make_empty_intermediate_tensors
+            if self.talker is not None
             else lambda: None
         )
 
         self._language_model_names = ["model"]
+        self.prefer_model_sampler = self.model_stage in {"llm", "tts"}
+        # Both AR stages require model-specific embeddings.  The Thinker uses
+        # preprocess for duplex audio, while the Talker converts the
+        # tts_token_ids/tts_hidden_states handoff into its conditioning
+        # embeddings and initializes request-local codec generation state.
+        self.has_preprocess = self.model_stage in {"llm", "tts"}
 
     @cached_property
     def sampler(self):
@@ -133,6 +147,82 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
 
         return Sampler()
 
+    def prepare_duplex_sampling(
+        self,
+        logits: torch.Tensor,
+        sampling_metadata: SamplingMetadata,
+        rows: tuple[DuplexSamplingRow, ...],
+    ) -> None:
+        """Apply MiniCPM duplex policy before the standard model sampler."""
+        del sampling_metadata
+        self._minicpmo45_active_duplex_rows = [row.row_idx for row in rows]
+        self._minicpmo45_duplex_row_sessions = {
+            row.row_idx: (row.session_id, row.incarnation) for row in rows if row.session_id is not None
+        }
+        request_sessions = getattr(self, "_minicpmo45_duplex_request_sessions", None)
+        if not isinstance(request_sessions, dict):
+            request_sessions = {}
+            self._minicpmo45_duplex_request_sessions = request_sessions
+        request_sessions.update(
+            {row.request_id: (row.session_id, row.incarnation) for row in rows if row.session_id is not None}
+        )
+        self._minicpmo45_duplex_row_payloads = {row.row_idx: row.payload for row in rows if row.payload is not None}
+        self._minicpmo45_duplex_row_max_tokens = {
+            row.row_idx: row.max_tokens for row in rows if row.max_tokens is not None
+        }
+        if self.model_stage != "llm" or not rows or logits.ndim != 2:
+            return
+
+        token_ids = self._minicpmo45_native_duplex_token_ids()
+        listen_id = int(token_ids.get("listen_token_id", -1))
+        turn_eos_id = int(token_ids.get("turn_eos_token_id", -1))
+        if listen_id < 0 or listen_id >= logits.shape[-1]:
+            return
+
+        force_listen_segments = getattr(
+            self,
+            "_minicpmo45_force_listen_applied_segments",
+            None,
+        )
+        if not isinstance(force_listen_segments, set):
+            force_listen_segments = set()
+            self._minicpmo45_force_listen_applied_segments = force_listen_segments
+        helper = getattr(self, "_minicpmo45_duplex_data_plane_helper", None)
+        helper_sessions = getattr(helper, "sessions", None) if helper is not None else None
+        for row in rows:
+            row_idx = row.row_idx
+            if row_idx < 0 or row_idx >= logits.shape[0]:
+                continue
+            payload = row.payload
+            if not isinstance(payload, dict):
+                continue
+            force_listen = payload.get("force_listen") is True
+            is_speech = payload.get("is_speech")
+            segment_key = (row.request_id, row.seq if row.seq is not None else -1)
+            session_key = (row.session_id, row.incarnation) if row.session_id is not None else None
+            if turn_eos_id >= 0 and session_key is not None:
+                state = helper_sessions.get(session_key) if isinstance(helper_sessions, dict) else None
+                pending_speech_context = (
+                    bool(getattr(state, "pending_speech_context", False)) if state is not None else False
+                )
+                if is_speech is True:
+                    if state is not None:
+                        with suppress(Exception):
+                            state.last_terminator_token = None
+                else:
+                    turn_ended = bool(getattr(state, "current_turn_ended", True)) if state is not None else False
+                    if turn_ended and not pending_speech_context:
+                        force_listen = True
+
+            if not force_listen:
+                continue
+            if force_listen and segment_key in force_listen_segments:
+                continue
+            if force_listen:
+                logits[row_idx, :] = float("-inf")
+                logits[row_idx, listen_id] = 0.0
+                force_listen_segments.add(segment_key)
+
     # -------------------- Device utilities --------------------
     @staticmethod
     def _module_device(module: nn.Module) -> torch.device:
@@ -150,7 +240,7 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         thinker_device: str | torch.device | None = None,
         talker_device: str | torch.device | None = None,
     ) -> None:
-        """Optionally move thinker / talker to different devices.
+        """Optionally move the thinker and talker to different devices.
 
         Example:
             model.move_submodules_to_devices(
@@ -168,7 +258,22 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         input_ids: torch.Tensor,
         multimodal_embeddings=None,
     ) -> torch.Tensor:
-        return self.model.get_input_embeddings(input_ids, multimodal_embeddings)
+        embed_fn = getattr(self.model, "get_input_embeddings", None)
+        if callable(embed_fn):
+            try:
+                return embed_fn(input_ids, multimodal_embeddings)
+            except TypeError:
+                embeddings = embed_fn()
+                if callable(embeddings):
+                    return embeddings(input_ids)
+            except AttributeError:
+                pass
+
+        embed_tokens = getattr(getattr(getattr(self.model, "llm", None), "model", None), "embed_tokens", None)
+        if callable(embed_tokens):
+            return embed_tokens(input_ids)
+
+        raise AttributeError(f"{type(self.model).__name__} does not expose token embeddings")
 
     def embed_input_ids(
         self,
@@ -181,6 +286,184 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
             return self.get_input_embeddings(input_ids)
         return super().embed_input_ids(input_ids, multimodal_embeddings, is_multimodal=is_multimodal)
 
+    def preprocess(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor | None = None,
+        **kwargs,
+    ) -> tuple[torch.Tensor, torch.Tensor, dict[str, object]]:
+        """Model-runner data-plane hook for MiniCPM-o 4.5 duplex audio.
+
+        The scheduler owns the request, block table, attention metadata, KV,
+        and sampler. This hook only turns the current duplex audio append into
+        the prompt embeddings consumed by the normal runner forward.
+        """
+        if self.model_stage == "tts":
+            return self.talker.preprocess(input_ids=input_ids, input_embeds=input_embeds, **kwargs)
+        if self.model_stage != "llm":
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {}
+
+        duplex = kwargs.get("duplex")
+        if not isinstance(duplex, dict) or duplex.get("data_plane") is not True:
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {}
+
+        prompt_len_meta = kwargs.get("duplex_prompt_len")
+        token_offset_meta = kwargs.get("duplex_token_offset", 0)
+        if (
+            isinstance(prompt_len_meta, int)
+            and isinstance(token_offset_meta, int)
+            and token_offset_meta >= prompt_len_meta
+        ):
+            # Decode step of the resumable duplex request: input_ids are the
+            # runner-sampled tokens and the normal embedding lookup is the
+            # correct input. Slicing the (prompt-only) duplex embeddings here
+            # would come up empty and pad-fill, feeding a </unit> embedding in
+            # place of every sampled token and corrupting generation.
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {}
+
+        helper = self._duplex_data_plane_helper()
+        session_id = str(duplex.get("session_id") or "")
+        try:
+            incarnation = int(duplex.get("incarnation", 0))
+        except (TypeError, ValueError):
+            incarnation = 0
+        payload = duplex.get("payload")
+        if not session_id or not isinstance(payload, dict):
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {"duplex": {"prefill_success": False, "reason": "bad_duplex_payload"}}
+
+        session_key = (session_id, incarnation)
+        state = helper.sessions.get(session_key)
+        if state is None:
+            from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import (
+                _MiniCPMO45Stage0SessionState,
+            )
+
+            state = _MiniCPMO45Stage0SessionState(session_id=session_id)
+            helper.sessions[session_key] = state
+            session_config = duplex.get("session_config")
+            session_config = dict(session_config) if isinstance(session_config, dict) else {}
+            runtime_config = duplex.get("runtime_config")
+            runtime_config = dict(runtime_config) if isinstance(runtime_config, dict) else {}
+            if hasattr(helper.thinker, "audio_past_key_values"):
+                helper.thinker.audio_past_key_values = None
+            helper._configure_streaming_processor(state)
+            helper._prepare_session_context(state, session_config, runtime_config=runtime_config)
+
+        audio_waveform = helper._decode_audio_payload(payload)
+        try:
+            video_frames = helper._decode_video_frames_payload(payload)
+        except ValueError as exc:
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {"duplex": {"prefill_success": False, "reason": str(exc)}}
+        seq = duplex.get("seq")
+        try:
+            seq = int(seq) if seq is not None else None
+        except (TypeError, ValueError):
+            seq = None
+        epoch = duplex.get("epoch")
+        try:
+            epoch = int(epoch) if epoch is not None else None
+        except (TypeError, ValueError):
+            epoch = None
+        result = helper._stage_prefill_embeddings_only(
+            state,
+            audio_waveform,
+            video_frames=video_frames,
+            epoch=epoch,
+            seq=seq,
+            is_speech=bool(payload.get("is_speech", False)),
+            final=bool(duplex.get("final")),
+        )
+        update_result = dict(result)
+        update_result.pop("inputs_embeds", None)
+        if result.get("success") is not True:
+            embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
+            return input_ids, embeds, {"duplex": update_result}
+
+        target_dtype = (
+            input_embeds.dtype if input_embeds is not None else self.get_input_embeddings(input_ids[:1]).dtype
+        )
+        full_req_embeds = result["inputs_embeds"].to(device=input_ids.device, dtype=target_dtype)
+        full_input_token_ids = list(result.get("input_token_ids") or [])
+        prompt_len = kwargs.get("duplex_prompt_len")
+        try:
+            prompt_len = int(prompt_len) if prompt_len is not None else int(full_req_embeds.shape[0])
+        except (TypeError, ValueError):
+            prompt_len = int(full_req_embeds.shape[0])
+        pad_token_id = helper.stage_padding_token_id()
+        if prompt_len > int(full_req_embeds.shape[0]):
+            pad_len = prompt_len - int(full_req_embeds.shape[0])
+            pad_ids = torch.full(
+                (pad_len,),
+                pad_token_id,
+                dtype=input_ids.dtype,
+                device=input_ids.device,
+            )
+            pad_embeds = self.get_input_embeddings(pad_ids).to(dtype=full_req_embeds.dtype)
+            # The appended duplex tokens occupy the tail of the request prompt
+            # and the runner schedules the span [num_computed_tokens, prompt_len).
+            # Padding must therefore sit in front of the real chunk embeddings;
+            # otherwise the audio lands outside the scheduled span, is never
+            # forwarded, and generation runs on pad tokens only. Keeping the
+            # embeddings last also places the decode position directly after the
+            # final audio embedding, matching the official listen/speak decision
+            # point.
+            full_req_embeds = torch.cat([pad_embeds, full_req_embeds], dim=0)
+            full_input_token_ids = [pad_token_id] * pad_len + full_input_token_ids
+        elif prompt_len < int(full_req_embeds.shape[0]):
+            logger.warning(
+                "MiniCPM-o duplex append produced %d embeddings but the scheduler "
+                "reserved only %d prompt slots; the tail will be truncated. "
+                "Increase the duplex scheduler token budget.",
+                int(full_req_embeds.shape[0]),
+                prompt_len,
+            )
+
+        span_len = int(input_ids.shape[0])
+        token_offset = kwargs.get("duplex_token_offset", 0)
+        try:
+            token_offset = max(0, int(token_offset))
+        except (TypeError, ValueError):
+            token_offset = 0
+        req_embeds = full_req_embeds[token_offset : token_offset + span_len]
+        if req_embeds.shape[0] < span_len:
+            pad_ids = torch.full(
+                (span_len - req_embeds.shape[0],),
+                pad_token_id,
+                dtype=input_ids.dtype,
+                device=input_ids.device,
+            )
+            pad_embeds = self.get_input_embeddings(pad_ids).to(dtype=req_embeds.dtype)
+            req_embeds = torch.cat([req_embeds, pad_embeds], dim=0)
+        elif req_embeds.shape[0] > span_len:
+            req_embeds = req_embeds[:span_len]
+
+        input_token_ids = full_input_token_ids[token_offset : token_offset + span_len]
+        if len(input_token_ids) < span_len:
+            input_token_ids.extend([pad_token_id] * (span_len - len(input_token_ids)))
+        if input_token_ids:
+            req_input_ids = torch.tensor(input_token_ids, dtype=input_ids.dtype, device=input_ids.device)
+            update_result["duplex_prompt_token_ids"] = full_input_token_ids
+        else:
+            req_input_ids = torch.full_like(input_ids, helper._required_token_id("unit_token_id"))
+        return req_input_ids, req_embeds, {"duplex": update_result}
+
+    def _duplex_data_plane_helper(self):
+        helper = getattr(self, "_minicpmo45_duplex_data_plane_helper", None)
+        if helper is not None:
+            return helper
+        from vllm_omni.experimental.fullduplex.minicpmo45.stage0 import MiniCPMO45Stage0DuplexRuntime
+
+        model_path = getattr(getattr(self.vllm_config, "model_config", None), "model", None)
+        device = str(self._module_device(self.thinker if self.thinker is not None else self))
+        helper = MiniCPMO45Stage0DuplexRuntime(self, model_path=model_path, device=device)
+        self._minicpmo45_duplex_data_plane_helper = helper
+        return helper
+
     def get_multimodal_embeddings(self, **kwargs):
         # Delegate to the active stage submodule when it implements MM encoding.
         mm_fn = getattr(self.model, "get_multimodal_embeddings", None)
@@ -210,8 +493,7 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         Workflow:
         1) Thinker (model_stage="llm"): Image / video / audio encoders +
            3D resampler + omni LLM → text + hidden states.
-        2) Talker (model_stage="tts"): MiniCPMTTS + the in-process
-           Token2Wav vocoder → audio waveform (final pipeline output).
+        2) Talker (model_stage="tts"): native MiniCPMTTS AR → codec deltas.
         """
         if self.model_stage == "llm":
             # Normalize to batched inputs if caller provides 1D/2D unbatched tensors
@@ -275,64 +557,79 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
                 text_hidden_states = text_hidden_states.squeeze(0)
 
             # Return hidden states with latent in multimodal_outputs for stage_input_processors
+            multimodal_outputs = {"latent": text_hidden_states}
+            runtime_info = kwargs.get("runtime_additional_information")
+            if runtime_info and isinstance(runtime_info, list) and len(runtime_info) > 0:
+                duplex_rows = []
+                for req_info in runtime_info:
+                    duplex_info = req_info.get("duplex") if isinstance(req_info, dict) else None
+                    duplex_rows.append(duplex_info if isinstance(duplex_info, dict) else {})
+
+                prompt_rows = []
+                for duplex_info in duplex_rows:
+                    prompt_token_ids = duplex_info.get("duplex_prompt_token_ids")
+                    # This is a complete per-handoff snapshot, not a generated
+                    # tensor delta. Keep it as row-local metadata so output
+                    # accumulation replaces the previous value instead of
+                    # attempting to concatenate variable-length prompts.
+                    prompt_rows.append(list(prompt_token_ids) if isinstance(prompt_token_ids, list) else None)
+                if any(row is not None for row in prompt_rows):
+                    multimodal_outputs["duplex_prompt_token_ids"] = prompt_rows
+
+                special_keys = {
+                    key
+                    for duplex_info in duplex_rows
+                    for key, value in (
+                        duplex_info.get("special_token_ids", {}).items()
+                        if isinstance(duplex_info.get("special_token_ids"), dict)
+                        else ()
+                    )
+                    if isinstance(key, str) and isinstance(value, int) and value >= 0
+                }
+                if special_keys:
+                    multimodal_outputs["meta"] = {
+                        key: [
+                            torch.tensor(
+                                [int(value)],
+                                dtype=torch.long,
+                                device=text_hidden_states.device,
+                            )
+                            if isinstance(value, int) and value >= 0
+                            else None
+                            for duplex_info in duplex_rows
+                            for value in [
+                                (
+                                    duplex_info.get("special_token_ids", {}).get(key)
+                                    if isinstance(duplex_info.get("special_token_ids"), dict)
+                                    else None
+                                )
+                            ]
+                        ]
+                        for key in sorted(special_keys)
+                    }
             return OmniOutput(
                 text_hidden_states=text_hidden_states,
-                multimodal_outputs={"latent": text_hidden_states},
+                multimodal_outputs=multimodal_outputs,
             )
 
-        # Talker stage: runs MiniCPMTTS + the in-process Token2Wav vocoder and
-        # emits the final audio waveform directly.
+        # Talker stage: runner-owned native AR only. Waveform generation belongs
+        # to the separate Code2Wav stage.
         if self.model_stage == "tts":
-            if input_ids is not None:
-                num_tokens = input_ids.shape[0]
-                device = input_ids.device
-            elif inputs_embeds is not None:
-                num_tokens = inputs_embeds.shape[0]
-                device = inputs_embeds.device
-            else:
-                num_tokens = 1
-                device = current_omni_platform.get_torch_device()
-            hidden_dim = self.config.hidden_size if hasattr(self.config, "hidden_size") else 2560
-
-            # Profile/dummy run: both input_ids and inputs_embeds are None.
-            # Note: SupportsMultiModal preprocessing converts input_ids to
-            # inputs_embeds, so input_ids=None alone does NOT indicate a dummy run.
-            if input_ids is None and inputs_embeds is None:
-                dummy_hidden = torch.zeros(num_tokens, hidden_dim, device=device)
-                return OmniOutput(text_hidden_states=dummy_hidden, multimodal_outputs=None)
-
-            runtime_info = kwargs.get("runtime_additional_information")
-            talker_info = {}
-            if runtime_info and isinstance(runtime_info, list) and len(runtime_info) > 0:
-                talker_info = runtime_info[0] if isinstance(runtime_info[0], dict) else {}
-
-            with torch.inference_mode():
-                talker_result = self.talker(
-                    input_ids=input_ids,
-                    positions=positions,
-                    inputs_embeds=inputs_embeds,
-                    additional_information=talker_info,
-                )
-
-            dummy_hidden = torch.zeros(num_tokens, hidden_dim, device=device)
-
-            # Talker returns a (mel_spec, waveform_or_None) tuple. MiniCPM-o
-            # 4.5 emits only the waveform (mel_spec is always None); keep the
-            # 2-slot unpack so a future mel-emitting variant can plug in
-            # without changing the wrapper.
-            mm_out: dict = {}
-            if isinstance(talker_result, tuple) and len(talker_result) == 2:
-                _, waveform = talker_result
-                if waveform is not None:
-                    mm_out["model_outputs"] = [waveform]
-
-            return OmniOutput(
-                text_hidden_states=dummy_hidden,
-                multimodal_outputs=mm_out if mm_out else None,
+            return self.talker(
+                input_ids=input_ids,
+                positions=positions,
+                intermediate_tensors=intermediate_tensors,
+                inputs_embeds=inputs_embeds,
+                **kwargs,
             )
 
         raise ValueError(f"Unsupported model stage: {self.model_stage}")
 
+    def make_omni_output(self, model_outputs, **kwargs):
+        if self.model_stage != "tts":
+            return model_outputs
+        return self.talker.make_omni_output(model_outputs, **kwargs)
+
     def compute_logits(self, hidden_states: torch.Tensor | OmniOutput) -> torch.Tensor | None:
         # Handle OmniOutput type
         if isinstance(hidden_states, OmniOutput):
@@ -341,26 +638,445 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         # Use model for logits computation
         return self.model.compute_logits(hidden_states)
 
+    def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
+        request_sessions = getattr(self, "_minicpmo45_duplex_request_sessions", None)
+        helper = getattr(self, "_minicpmo45_duplex_data_plane_helper", None)
+        sessions = getattr(helper, "sessions", None) if helper is not None else None
+        if isinstance(request_sessions, dict):
+            for request_id in finished_req_ids:
+                session_key = request_sessions.pop(request_id, None)
+                if session_key is not None and isinstance(sessions, dict):
+                    sessions.pop(session_key, None)
+        forced_segments = getattr(self, "_minicpmo45_force_listen_applied_segments", None)
+        if isinstance(forced_segments, set):
+            finished = set(finished_req_ids)
+            completed_segments = {segment for segment in forced_segments if segment[0] in finished}
+            forced_segments.difference_update(completed_segments)
+        if hasattr(self.model, "on_requests_finished"):
+            self.model.on_requests_finished(finished_req_ids)
+
     def sample(
         self,
         logits: torch.Tensor,
         sampling_metadata: SamplingMetadata,
     ) -> SamplerOutput | None:
-        # Use model for sampling
-        return self.model.sample(logits, sampling_metadata)
+        native_duplex = self._sample_minicpmo45_native_duplex_stage0(
+            logits,
+            sampling_metadata,
+            duplex_rows=getattr(self, "_minicpmo45_active_duplex_rows", None),
+        )
+        if native_duplex is not None:
+            return native_duplex
+        if self.model_stage == "tts":
+            return self.model.sample(logits, sampling_metadata)
+        return None
+
+    def _sample_minicpmo45_native_duplex_stage0(
+        self,
+        logits: torch.Tensor,
+        sampling_metadata: SamplingMetadata,
+        *,
+        duplex_rows: list[int] | None = None,
+    ) -> SamplerOutput | None:
+        if self.model_stage != "llm" or logits.ndim != 2 or logits.shape[0] == 0:
+            return None
+        token_ids = self._minicpmo45_native_duplex_token_ids()
+        unit_id = token_ids.get("unit_token_id", -1)
+        if unit_id < 0:
+            return None
+        native_rows = self._minicpmo45_native_duplex_prompt_rows(
+            sampling_metadata,
+            unit_id,
+            logits.shape[0],
+            duplex_rows=duplex_rows,
+        )
+        if not native_rows or len(native_rows) != logits.shape[0]:
+            return None
+
+        sampled_ids: list[int] = []
+        for row_idx in range(logits.shape[0]):
+            row_logits = logits[row_idx : row_idx + 1].clone()
+            sampled = self._sample_minicpmo45_native_duplex_row(
+                row_logits,
+                sampling_metadata,
+                row_idx=row_idx,
+                token_ids=token_ids,
+            )
+            self._record_minicpmo45_duplex_terminator(row_idx, sampled, token_ids)
+            sampled_ids.append(sampled)
+        return SamplerOutput(
+            sampled_token_ids=torch.tensor(sampled_ids, device=logits.device, dtype=torch.int32).unsqueeze(-1),
+            logprobs_tensors=None,
+        )
+
+    def _sample_minicpmo45_native_duplex_row(
+        self,
+        logits: torch.Tensor,
+        sampling_metadata: SamplingMetadata,
+        *,
+        row_idx: int,
+        token_ids: dict[str, int],
+    ) -> int:
+        chunk_eos_id = token_ids.get("chunk_eos_token_id", -1)
+        generator = getattr(sampling_metadata, "generators", {}).get(row_idx)
+        output_token_ids = getattr(sampling_metadata, "output_token_ids", None) or []
+        raw_recent_tokens = output_token_ids[row_idx] if row_idx < len(output_token_ids) else []
+        recent_tokens = [int(token_id) for token_id in raw_recent_tokens if isinstance(token_id, int) and token_id >= 0]
+        temperature = float(self._sampling_metadata_value(sampling_metadata, "temperature", row_idx, 0.7))
+        top_k = int(self._sampling_metadata_value(sampling_metadata, "top_k", row_idx, 100))
+        top_p = float(self._sampling_metadata_value(sampling_metadata, "top_p", row_idx, 0.8))
+        state = self._minicpmo45_duplex_state_for_row(row_idx)
+        if chunk_eos_id >= 0 and chunk_eos_id < logits.shape[-1]:
+            max_speak_tokens = int(
+                getattr(
+                    self,
+                    "max_new_speak_tokens_per_chunk",
+                    MiniCPMO45DuplexPolicy.DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK,
+                )
+                or MiniCPMO45DuplexPolicy.DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK
+            )
+            request_max_tokens = self._minicpmo45_duplex_row_request_max_tokens(row_idx)
+            effective_max_speak_tokens = max_speak_tokens
+            if request_max_tokens is not None:
+                effective_max_speak_tokens = min(effective_max_speak_tokens, request_max_tokens)
+            if len(recent_tokens) >= max(1, effective_max_speak_tokens - 1):
+                return int(chunk_eos_id)
+
+            # Match the released StreamDecoder: first sample the original
+            # distribution only to preserve the model's own chunk boundary.
+            # If it does not choose chunk_eos, mask that token before the
+            # normal text/listen/turn sampling pass below.
+            if getattr(sampling_metadata, "all_greedy", False):
+                boundary_sample = int(torch.argmax(logits, dim=-1).item())
+            else:
+                boundary_probs = F.softmax(logits, dim=-1)
+                boundary_sample = int(torch.multinomial(boundary_probs, num_samples=1, generator=generator).item())
+            if boundary_sample == chunk_eos_id:
+                return int(chunk_eos_id)
+
+        logits = logits.clone()
+        forbidden = self._minicpmo45_native_forbidden_token_ids(token_ids)
+        if forbidden:
+            valid_forbidden = [token_id for token_id in forbidden if 0 <= token_id < logits.shape[-1]]
+            if valid_forbidden:
+                logits[:, valid_forbidden] = float("-inf")
+
+        generated_tokens = getattr(state, "generated_tokens", None)
+        repetition_tokens = generated_tokens if generated_tokens else recent_tokens
+        repetition_penalty = 1.05
+        if repetition_penalty != 1.0 and repetition_tokens:
+            history_size = MiniCPMO45DuplexPolicy.REPETITION_HISTORY_SIZE
+            for token_id in set(repetition_tokens[-history_size:]):
+                if token_id < 0 or token_id >= logits.shape[-1]:
+                    continue
+                logits[0, token_id] /= repetition_penalty
+
+        if getattr(sampling_metadata, "all_greedy", False) or temperature <= 0:
+            sampled = int(torch.argmax(logits, dim=-1).item())
+            self._record_minicpmo45_duplex_generation_token(row_idx, sampled)
+            sampled = self._maybe_cut_minicpmo45_native_duplex_text_chunk(
+                sampled,
+                recent_tokens,
+                token_ids,
+            )
+            return self._finalize_minicpmo45_native_duplex_sample(row_idx, sampled, token_ids)
+
+        logits = logits / temperature
+        logits = self._top_k_top_p_filter(logits, top_k=top_k, top_p=top_p)
+        probs = F.softmax(logits, dim=-1)
+        sampled = int(torch.multinomial(probs, num_samples=1, generator=generator).item())
+        self._record_minicpmo45_duplex_generation_token(row_idx, sampled)
+        sampled = self._maybe_cut_minicpmo45_native_duplex_text_chunk(
+            sampled,
+            recent_tokens,
+            token_ids,
+        )
+        return self._finalize_minicpmo45_native_duplex_sample(
+            row_idx,
+            sampled,
+            token_ids,
+        )
+
+    def _maybe_cut_minicpmo45_native_duplex_text_chunk(
+        self,
+        sampled: int,
+        recent_tokens: list[int],
+        token_ids: dict[str, int],
+    ) -> int:
+        chunk_eos_id = token_ids.get("chunk_eos_token_id", -1)
+        if chunk_eos_id < 0:
+            return int(sampled)
+        special_ids = self._minicpmo45_native_special_token_ids(token_ids)
+        if sampled in special_ids:
+            return int(sampled)
+        max_chars = int(
+            getattr(
+                self,
+                "max_speak_chars_per_chunk",
+                MiniCPMO45DuplexPolicy.DEFAULT_MAX_SPEAK_CHARS_PER_CHUNK,
+            )
+            or MiniCPMO45DuplexPolicy.DEFAULT_MAX_SPEAK_CHARS_PER_CHUNK
+        )
+        if max_chars <= 0:
+            return int(sampled)
+        tokenizer = self._minicpmo45_tokenizer()
+        decode = getattr(tokenizer, "decode", None)
+        if not callable(decode):
+            return int(sampled)
+        candidate_tokens = self._minicpmo45_current_chunk_tokens(recent_tokens, token_ids)
+        candidate_tokens.append(int(sampled))
+        try:
+            text = decode(candidate_tokens, skip_special_tokens=True)
+        except TypeError:
+            text = decode(candidate_tokens)
+        except Exception:
+            return int(sampled)
+        return int(chunk_eos_id) if isinstance(text, str) and len(text) >= max_chars else int(sampled)
+
+    @staticmethod
+    def _minicpmo45_current_chunk_tokens(
+        tokens: list[int],
+        token_ids: dict[str, int],
+    ) -> list[int]:
+        boundaries = {
+            token_ids.get("listen_token_id", -1),
+            token_ids.get("chunk_eos_token_id", -1),
+            token_ids.get("chunk_tts_eos_token_id", -1),
+            token_ids.get("turn_eos_token_id", -1),
+        }
+        start = 0
+        for idx, token_id in enumerate(tokens):
+            if token_id in boundaries:
+                start = idx + 1
+        return list(tokens[start:])
+
+    def _minicpmo45_duplex_state_for_row(self, row_idx: int):
+        row_sessions = getattr(self, "_minicpmo45_duplex_row_sessions", None)
+        session_key = row_sessions.get(row_idx) if isinstance(row_sessions, dict) else None
+        if not session_key:
+            return None
+        helper = getattr(self, "_minicpmo45_duplex_data_plane_helper", None)
+        sessions = getattr(helper, "sessions", None) if helper is not None else None
+        return sessions.get(session_key) if isinstance(sessions, dict) else None
+
+    def _minicpmo45_duplex_payload_for_row(self, row_idx: int) -> dict[str, Any] | None:
+        row_payloads = getattr(self, "_minicpmo45_duplex_row_payloads", None)
+        payload = row_payloads.get(row_idx) if isinstance(row_payloads, dict) else None
+        return payload if isinstance(payload, dict) else None
+
+    def _minicpmo45_duplex_row_request_max_tokens(self, row_idx: int) -> int | None:
+        row_max_tokens = getattr(self, "_minicpmo45_duplex_row_max_tokens", None)
+        value = row_max_tokens.get(row_idx) if isinstance(row_max_tokens, dict) else None
+        try:
+            max_tokens = int(value)
+        except (TypeError, ValueError):
+            return None
+        return max_tokens if max_tokens > 0 else None
+
+    def _finalize_minicpmo45_native_duplex_sample(
+        self,
+        row_idx: int,
+        sampled: int,
+        token_ids: dict[str, int],
+    ) -> int:
+        listen_id = token_ids.get("listen_token_id", -1)
+        tts_bos_id = token_ids.get("tts_bos_token_id", -1)
+        state = self._minicpmo45_duplex_state_for_row(row_idx)
+        payload = self._minicpmo45_duplex_payload_for_row(row_idx)
+        force_listen = isinstance(payload, dict) and payload.get("force_listen") is True
+        if (
+            sampled == listen_id
+            and 0 <= tts_bos_id
+            and state is not None
+            and not getattr(state, "current_turn_ended", True)
+            and not force_listen
+        ):
+            return int(tts_bos_id)
+        return int(sampled)
+
+    def _record_minicpmo45_duplex_generation_token(self, row_idx: int, sampled: int) -> None:
+        """Track tokens returned by the model-policy decoder.
+
+        The released StreamDecoder is constructed without special_token_ids, so
+        every normally decoded token participates in repetition penalty. Forced
+        listen bypasses that decoder, while chunk_eos boundary decisions return
+        before this method is called.
+        """
+        state = self._minicpmo45_duplex_state_for_row(row_idx)
+        if state is None:
+            return
+        payload = self._minicpmo45_duplex_payload_for_row(row_idx)
+        if isinstance(payload, dict) and payload.get("force_listen") is True:
+            return
+        generated_tokens = getattr(state, "generated_tokens", None)
+        if not isinstance(generated_tokens, list):
+            generated_tokens = []
+            state.generated_tokens = generated_tokens
+        generated_tokens.append(int(sampled))
+        history_size = MiniCPMO45DuplexPolicy.REPETITION_HISTORY_SIZE
+        del generated_tokens[:-history_size]
+
+    def _record_minicpmo45_duplex_terminator(self, row_idx: int, sampled: int, token_ids: dict[str, int]) -> None:
+        """Remember sampled unit state for the next append.
+
+        The scheduler session update discards the final sampled token of a
+        segment before the next streaming update, but the official duplex
+        format feeds it (terminator + </unit>) into the KV at every unit
+        boundary, and the model's listen/speak policy depends on seeing its own
+        past decisions. Non-terminators clear the turn-ended latch."""
+        state = self._minicpmo45_duplex_state_for_row(row_idx)
+        if state is None:
+            return
+        payload = self._minicpmo45_duplex_payload_for_row(row_idx)
+        force_listen = isinstance(payload, dict) and payload.get("force_listen") is True
+        listen_id = token_ids.get("listen_token_id", -1)
+        tts_bos_id = token_ids.get("tts_bos_token_id", -1)
+        chunk_eos_id = token_ids.get("chunk_eos_token_id", -1)
+        chunk_tts_eos_id = token_ids.get("chunk_tts_eos_token_id", -1)
+        turn_eos_id = token_ids.get("turn_eos_token_id", -1)
+        terminators = {listen_id, chunk_eos_id, chunk_tts_eos_id, turn_eos_id}
+        if sampled in terminators:
+            state.pending_terminator_token = int(sampled)
+            state.last_terminator_token = int(sampled)
+            if sampled == turn_eos_id or (sampled == listen_id and force_listen):
+                state.current_turn_ended = True
+                with suppress(Exception):
+                    state.pending_speech_response_open = False
+            return
+        if (
+            sampled == tts_bos_id
+            and getattr(state, "current_turn_ended", True)
+            and getattr(state, "pending_speech_context", False)
+        ):
+            with suppress(Exception):
+                state.pending_speech_response_open = True
+        elif getattr(state, "pending_speech_response_open", False):
+            with suppress(Exception):
+                state.pending_speech_context = False
+                state.pending_speech_response_open = False
+        elif getattr(state, "current_turn_ended", True):
+            with suppress(Exception):
+                state.pending_speech_context = False
+        state.pending_terminator_token = None
+        state.last_terminator_token = None
+        state.current_turn_ended = False
+
+    def _minicpmo45_tokenizer(self):
+        if hasattr(self, "_minicpmo45_tokenizer_cache"):
+            return self._minicpmo45_tokenizer_cache
+        tokenizer = None
+        get_tokenizer = getattr(getattr(self, "thinker", None), "get_tokenizer", None)
+        if callable(get_tokenizer):
+            tokenizer = get_tokenizer()
+        if tokenizer is None:
+            try:
+                from vllm.tokenizers import cached_tokenizer_from_config
+
+                tokenizer = cached_tokenizer_from_config(self.vllm_config.model_config)
+            except Exception:
+                pass
+        self._minicpmo45_tokenizer_cache = tokenizer
+        return tokenizer
+
+    def _minicpmo45_native_duplex_token_ids(self) -> dict[str, int]:
+        cached = getattr(self, "_minicpmo45_native_duplex_token_ids_cache", None)
+        if isinstance(cached, dict):
+            return cached
+        tokenizer = self._minicpmo45_tokenizer()
+        cached = MiniCPMO45DuplexPolicy.token_ids_from_tokenizer(tokenizer)
+        self._minicpmo45_native_duplex_token_ids_cache = cached
+        return cached
+
+    def _minicpmo45_native_duplex_prompt_rows(
+        self,
+        sampling_metadata: SamplingMetadata,
+        unit_id: int,
+        batch_size: int,
+        *,
+        duplex_rows: list[int] | None = None,
+    ) -> list[int]:
+        if duplex_rows is not None:
+            rows: list[int] = []
+            for row in duplex_rows:
+                try:
+                    row_idx = int(row)
+                except (TypeError, ValueError):
+                    continue
+                if 0 <= row_idx < batch_size:
+                    rows.append(row_idx)
+            return rows
+
+        prompt_token_ids = getattr(sampling_metadata, "prompt_token_ids", None)
+        if prompt_token_ids is None:
+            return []
+        if prompt_token_ids.ndim == 1:
+            prompt_token_ids = prompt_token_ids.unsqueeze(0)
+        rows: list[int] = []
+        for row_idx in range(min(batch_size, int(prompt_token_ids.shape[0]))):
+            row = prompt_token_ids[row_idx]
+            if torch.count_nonzero(row == unit_id).item() >= 2:
+                rows.append(row_idx)
+        return rows
+
+    def _minicpmo45_native_forbidden_token_ids(self, token_ids: dict[str, int]) -> list[int]:
+        tokenizer = self._minicpmo45_tokenizer()
+        bad_token_ids = getattr(tokenizer, "bad_token_ids", []) if tokenizer is not None else []
+        return MiniCPMO45DuplexPolicy.native_forbidden_token_ids(token_ids, bad_token_ids=bad_token_ids)
+
+    def _minicpmo45_native_special_token_ids(self, token_ids: dict[str, int]) -> set[int]:
+        tokenizer = self._minicpmo45_tokenizer()
+        return MiniCPMO45DuplexPolicy.native_special_token_ids(
+            token_ids,
+            tokenizer_special_ids=getattr(tokenizer, "all_special_ids", []) if tokenizer is not None else [],
+        )
+
+    @staticmethod
+    def _sampling_metadata_value(
+        sampling_metadata: SamplingMetadata,
+        name: str,
+        row_idx: int,
+        default: float,
+    ) -> float:
+        value = getattr(sampling_metadata, name, None)
+        if value is None:
+            return default
+        if isinstance(value, torch.Tensor):
+            if value.numel() == 0:
+                return default
+            if value.ndim == 0:
+                return float(value.item())
+            idx = min(row_idx, int(value.numel()) - 1)
+            return float(value.reshape(-1)[idx].item())
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _top_k_top_p_filter(logits: torch.Tensor, *, top_k: int, top_p: float) -> torch.Tensor:
+        if top_k > 0 and top_k < logits.shape[-1]:
+            kth = torch.topk(logits, top_k, dim=-1).values[..., -1, None]
+            logits = logits.masked_fill(logits < kth, float("-inf"))
+        if 0.0 < top_p < 1.0:
+            sorted_logits, sorted_indices = torch.sort(logits, descending=True, dim=-1)
+            cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+            sorted_remove = cumulative_probs > top_p
+            sorted_remove[..., 1:] = sorted_remove[..., :-1].clone()
+            sorted_remove[..., 0] = False
+            remove = torch.zeros_like(logits, dtype=torch.bool)
+            remove.scatter_(dim=-1, index=sorted_indices, src=sorted_remove)
+            logits = logits.masked_fill(remove, float("-inf"))
+        return logits
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-        """Load weights for the active stage of the omni model."""
+        """Load weights for all components of the omni model."""
         loaded_weights = set()
         thinker_weights = []
         talker_weights = []
 
         # MiniCPM-o checkpoint prefixes → stage mapping:
         #   thinker: vpm, resampler, llm, apm, audio_projection_layer
-        #   talker:  tts (MiniCPMTTS); the Token2Wav vocoder weights load
-        #            separately inside the talker module from the
-        #            ``assets/token2wav`` subdirectory and do not appear
-        #            in this iterator.
+        #   talker:  tts (native MiniCPMTTS AR codec producer)
         for k, v in weights:
             if k.startswith(("vpm.", "resampler.", "llm.", "apm.", "audio_projection_layer.")):
                 thinker_weights.append((k, v))
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
index b930578d6..a182848cf 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
@@ -128,8 +128,9 @@ from vllm.multimodal.processing import (
 from vllm.sequence import IntermediateTensors
 
 
-def encode_tokens(tokenizer, prompt: str) -> list[int]:
-    """Tokenize ``prompt`` without adding special tokens."""
+# vllm.transformers_utils.tokenizer no longer exists in upstream vLLM;
+# _encode_tokens uses tokenizer.encode() as the only code path.
+def _encode_tokens(tokenizer: Any, prompt: str) -> list[int]:
     return tokenizer.encode(prompt, add_special_tokens=False)
 
 
@@ -328,7 +329,7 @@ class MiniCPMOConfig(Qwen2Config):
         tts_config=None,
         use_image_id=True,
         vision_batch_size=16,
-        audio_pool_step=2,
+        audio_pool_step=5,
         audio_chunk_length=1.0,
         stream_input=False,
         init_vision=True,
@@ -760,12 +761,20 @@ class MiniCPMVImageProcessor(BaseImageProcessor):
         )
 
 
-AutoImageProcessor.register("MiniCPMVImageProcessor", MiniCPMVImageProcessor)
+# transformers >= 5.x requires the config *class* (not a string) as the
+# first arg to AutoImageProcessor.register — it does `key.__module__`
+# internally. Passing "MiniCPMVImageProcessor" raises:
+#   AttributeError: 'str' object has no attribute '__module__'
+# See also processing_gr00t_n1d7.py for the same transformers API change.
+AutoImageProcessor.register(MiniCPMOConfig, MiniCPMVImageProcessor, exist_ok=True)
 
 
 # ============== SigLIP Vision Transformer Classes ==============
+FlashAttentionUnpaddingMetadata: TypeAlias = tuple[torch.Tensor, torch.Tensor, int]
+
+
 # Copied from transformers.models.llama.modeling_llama._get_unpad_data
-def _get_unpad_data(attention_mask):
+def _get_unpad_data(attention_mask: torch.Tensor) -> FlashAttentionUnpaddingMetadata:
     seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
     indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
     max_seqlen_in_batch = seqlens_in_batch.max().item()
@@ -931,47 +940,86 @@ class SiglipVisionEmbeddings(nn.Module):
         self.num_positions = self.num_patches
         self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
 
+    def _create_grid_position_ids(
+        self,
+        patch_grid_height: int,
+        patch_grid_width: int,
+        boundaries: torch.Tensor,
+    ) -> torch.Tensor:
+        fractional_coords_h = torch.arange(
+            0,
+            1 - 1e-6,
+            1 / patch_grid_height,
+            device=boundaries.device,
+        )
+        fractional_coords_w = torch.arange(
+            0,
+            1 - 1e-6,
+            1 / patch_grid_width,
+            device=boundaries.device,
+        )
+        bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
+        bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
+        return (bucket_coords_h[:, None] * self.num_patches_per_side + bucket_coords_w).flatten()
+
+    def _create_position_ids(
+        self,
+        patch_attention_mask: torch.BoolTensor,
+        tgt_sizes: torch.IntTensor | None,
+        device: torch.device,
+    ) -> torch.Tensor:
+        batch_size = patch_attention_mask.size(0)
+        flat_patch_attention_mask = patch_attention_mask.reshape(batch_size, -1).to(device="cpu")
+
+        if tgt_sizes is None:
+            # As in the legacy path, infer rectangular grid sizes from a (B, H, W) mask.
+            target_sizes = torch.stack(
+                (
+                    patch_attention_mask[:, :, 0].sum(dim=1),
+                    patch_attention_mask[:, 0, :].sum(dim=1),
+                ),
+                dim=1,
+            )
+        else:
+            target_sizes = tgt_sizes
+
+        # Group construction on the host preserves the legacy floating-point
+        # mapping and is faster than device-side construction for vision grids.
+        target_sizes_list = target_sizes.detach().to(device="cpu").tolist()
+        position_ids = torch.zeros(flat_patch_attention_mask.shape, dtype=torch.long)
+        boundaries = torch.arange(
+            1 / self.num_patches_per_side,
+            1.0,
+            1 / self.num_patches_per_side,
+        )
+        grid_position_ids: dict[tuple[int, int], torch.Tensor] = {}
+
+        for batch_idx, (patch_grid_height, patch_grid_width) in enumerate(target_sizes_list):
+            grid_shape = (int(patch_grid_height), int(patch_grid_width))
+            grid_ids = grid_position_ids.get(grid_shape)
+            if grid_ids is None:
+                grid_ids = self._create_grid_position_ids(*grid_shape, boundaries)
+                grid_position_ids[grid_shape] = grid_ids
+
+            position_ids[batch_idx, flat_patch_attention_mask[batch_idx]] = grid_ids
+
+        return position_ids.to(device=device)
+
     def forward(
         self,
         pixel_values: torch.FloatTensor,
         patch_attention_mask: torch.BoolTensor,
         tgt_sizes: torch.IntTensor | None = None,
     ) -> torch.Tensor:
-        batch_size = pixel_values.size(0)
-
         patch_embeds = self.patch_embedding(pixel_values)
         embeddings = patch_embeds.flatten(2).transpose(1, 2)
 
-        max_im_h, max_im_w = pixel_values.size(2), pixel_values.size(3)
-        max_nb_patches_h, max_nb_patches_w = max_im_h // self.patch_size, max_im_w // self.patch_size
-        boundaries = torch.arange(1 / self.num_patches_per_side, 1.0, 1 / self.num_patches_per_side)
-        position_ids = torch.full(
-            size=(
-                batch_size,
-                max_nb_patches_h * max_nb_patches_w,
-            ),
-            fill_value=0,
+        position_ids = self._create_position_ids(
+            patch_attention_mask,
+            tgt_sizes,
+            device=self.position_embedding.weight.device,
         )
 
-        for batch_idx, p_attn_mask in enumerate(patch_attention_mask):
-            if tgt_sizes is not None:
-                nb_patches_h = tgt_sizes[batch_idx][0]
-                nb_patches_w = tgt_sizes[batch_idx][1]
-            else:
-                nb_patches_h = p_attn_mask[:, 0].sum()
-                nb_patches_w = p_attn_mask[0].sum()
-
-            fractional_coords_h = torch.arange(0, 1 - 1e-6, 1 / nb_patches_h)
-            fractional_coords_w = torch.arange(0, 1 - 1e-6, 1 / nb_patches_w)
-
-            bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
-            bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
-
-            pos_ids = (bucket_coords_h[:, None] * self.num_patches_per_side + bucket_coords_w).flatten()
-            position_ids[batch_idx][p_attn_mask.view(-1).cpu()] = pos_ids
-
-        position_ids = position_ids.to(self.position_embedding.weight.device)
-
         embeddings = embeddings + self.position_embedding(position_ids)
         return embeddings
 
@@ -1071,6 +1119,7 @@ class SiglipFlashAttention2(SiglipAttention):
         past_key_value: tuple[torch.Tensor] | None = None,
         output_attentions: bool = False,
         use_cache: bool = False,
+        unpadding_metadata: FlashAttentionUnpaddingMetadata | None = None,
         **kwargs,
     ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
         output_attentions = False
@@ -1133,7 +1182,13 @@ class SiglipFlashAttention2(SiglipAttention):
             value_states = value_states.to(target_dtype)
 
         attn_output = self._flash_attention_forward(
-            query_states, key_states, value_states, attention_mask, q_len, dropout=dropout_rate
+            query_states,
+            key_states,
+            value_states,
+            attention_mask,
+            q_len,
+            dropout=dropout_rate,
+            unpadding_metadata=unpadding_metadata,
         )
 
         attn_output = attn_output.reshape(bsz, q_len, self.embed_dim).contiguous()
@@ -1145,7 +1200,15 @@ class SiglipFlashAttention2(SiglipAttention):
         return attn_output, attn_weights
 
     def _flash_attention_forward(
-        self, query_states, key_states, value_states, attention_mask, query_length, dropout=0.0, softmax_scale=None
+        self,
+        query_states,
+        key_states,
+        value_states,
+        attention_mask,
+        query_length,
+        dropout=0.0,
+        softmax_scale=None,
+        unpadding_metadata: FlashAttentionUnpaddingMetadata | None = None,
     ):
         """
         Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token
@@ -1173,7 +1236,12 @@ class SiglipFlashAttention2(SiglipAttention):
         if attention_mask is not None:
             batch_size = query_states.shape[0]
             query_states, key_states, value_states, indices_q, cu_seq_lens, max_seq_lens = self._upad_input(
-                query_states, key_states, value_states, attention_mask, query_length
+                query_states,
+                key_states,
+                value_states,
+                attention_mask,
+                query_length,
+                unpadding_metadata=unpadding_metadata,
             )
 
             cu_seqlens_q, cu_seqlens_k = cu_seq_lens
@@ -1200,8 +1268,18 @@ class SiglipFlashAttention2(SiglipAttention):
 
         return attn_output
 
-    def _upad_input(self, query_layer, key_layer, value_layer, attention_mask, query_length):
-        indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask)
+    def _upad_input(
+        self,
+        query_layer,
+        key_layer,
+        value_layer,
+        attention_mask,
+        query_length,
+        unpadding_metadata: FlashAttentionUnpaddingMetadata | None = None,
+    ):
+        if unpadding_metadata is None:
+            unpadding_metadata = _get_unpad_data(attention_mask)
+        indices_k, cu_seqlens_k, max_seqlen_in_batch_k = unpadding_metadata
         batch_size, kv_seq_len, num_key_value_heads, head_dim = key_layer.shape
 
         key_layer = index_first_axis(
@@ -1271,6 +1349,7 @@ class SiglipEncoderLayer(nn.Module):
         hidden_states: torch.Tensor,
         attention_mask: torch.Tensor,
         output_attentions: bool | None = False,
+        unpadding_metadata: FlashAttentionUnpaddingMetadata | None = None,
     ) -> tuple[torch.FloatTensor]:
         """
         Args:
@@ -1285,11 +1364,19 @@ class SiglipEncoderLayer(nn.Module):
         residual = hidden_states
 
         hidden_states = self.layer_norm1(hidden_states)
-        hidden_states, attn_weights = self.self_attn(
-            hidden_states=hidden_states,
-            attention_mask=attention_mask,
-            output_attentions=output_attentions,
-        )
+        if self._use_flash_attention_2:
+            hidden_states, attn_weights = self.self_attn(
+                hidden_states=hidden_states,
+                attention_mask=attention_mask,
+                output_attentions=output_attentions,
+                unpadding_metadata=unpadding_metadata,
+            )
+        else:
+            hidden_states, attn_weights = self.self_attn(
+                hidden_states=hidden_states,
+                attention_mask=attention_mask,
+                output_attentions=output_attentions,
+            )
         hidden_states = residual + hidden_states
 
         residual = hidden_states
@@ -1390,6 +1477,7 @@ class SiglipEncoder(nn.Module):
         self.config = config
         self.layers = nn.ModuleList([SiglipEncoderLayer(config) for _ in range(config.num_hidden_layers)])
         self.gradient_checkpointing = False
+        self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
 
     # Ignore copy
     def forward(
@@ -1430,6 +1518,9 @@ class SiglipEncoder(nn.Module):
         all_attentions = () if output_attentions else None
 
         hidden_states = inputs_embeds
+        unpadding_metadata = (
+            _get_unpad_data(attention_mask) if self._use_flash_attention_2 and attention_mask is not None else None
+        )
         for encoder_layer in self.layers:
             if output_hidden_states:
                 encoder_states = encoder_states + (hidden_states,)
@@ -1439,12 +1530,14 @@ class SiglipEncoder(nn.Module):
                     hidden_states,
                     attention_mask,
                     output_attentions,
+                    unpadding_metadata,
                 )
             else:
                 layer_outputs = encoder_layer(
                     hidden_states,
                     attention_mask,
                     output_attentions=output_attentions,
+                    unpadding_metadata=unpadding_metadata,
                 )
 
             hidden_states = layer_outputs[0]
@@ -2517,7 +2610,11 @@ class MiniCPMWhisperEncoder(WhisperEncoder):
         return_dict=None,
         past_key_values: EncoderDecoderCache | None = None,
         use_cache: bool | None = None,
-    ) -> BaseModelOutputWithPast | tuple:
+        use_extra_context: bool | None = False,
+        prefix_extra_frames: int | None = 1,
+        suffix_extra_frames: int | None = 1,
+        cnn_min_length: int | None = None,
+    ) -> BaseModelOutputWithPast | tuple[Any, ...]:
         r"""
         Forward pass of the Whisper encoder.
 
@@ -2628,9 +2725,37 @@ class MiniCPMWhisperEncoder(WhisperEncoder):
         # Ignore copy
         input_features = input_features.to(dtype=self.conv1.weight.dtype, device=self.conv1.weight.device)
 
+        original_length = input_features.shape[2]
+        padded_for_cnn = False
+        if cnn_min_length is not None and original_length < cnn_min_length:
+            padded_features = torch.zeros(
+                input_features.shape[0],
+                input_features.shape[1],
+                cnn_min_length,
+                dtype=input_features.dtype,
+                device=input_features.device,
+            )
+            padded_features[:, :, :original_length] = input_features
+            input_features = padded_features
+            padded_for_cnn = True
+
         inputs_embeds = nn.functional.gelu(self.conv1(input_features))
         inputs_embeds = nn.functional.gelu(self.conv2(inputs_embeds))
 
+        if padded_for_cnn:
+            actual_cnn_output_length = (original_length + 1) // 2
+            inputs_embeds = inputs_embeds[:, :, :actual_cnn_output_length]
+
+        if use_extra_context:
+            prefix_extra_frames = int(prefix_extra_frames or 0)
+            suffix_extra_frames = int(suffix_extra_frames or 0)
+            prefix_to_remove = (prefix_extra_frames + 1) // 2 if prefix_extra_frames > 0 else 0
+            suffix_to_remove = (suffix_extra_frames + 1) // 2 if suffix_extra_frames > 0 else 0
+            if prefix_to_remove > 0:
+                inputs_embeds = inputs_embeds[:, :, prefix_to_remove:]
+            if 0 < suffix_to_remove < inputs_embeds.shape[2]:
+                inputs_embeds = inputs_embeds[:, :, :-suffix_to_remove]
+
         inputs_embeds = inputs_embeds.permute(0, 2, 1)
 
         embed_pos = self.embed_positions.weight
@@ -2834,6 +2959,9 @@ class MiniCPMO45OmniLLMProcessingInfo(BaseProcessingInfo):
     ) -> str:
         hf_processor = self.get_hf_processor()
 
+        # Keep prompt placeholders aligned with the encoder's checkpoint config.
+        hf_processor.pool_step = self.get_default_audio_pool_step()
+
         return hf_processor.get_audio_placeholder(
             audio_lens,
             chunk_input=chunk_input,
@@ -2841,7 +2969,7 @@ class MiniCPMO45OmniLLMProcessingInfo(BaseProcessingInfo):
         )
 
     def get_default_audio_pool_step(self) -> int:
-        return getattr(self.get_hf_config(), "audio_pool_step", 2)
+        return getattr(self.get_hf_config(), "audio_pool_step", 5)
 
     def get_default_audio_sampling_rate(self) -> int:
         return 16000
@@ -3167,9 +3295,33 @@ class MiniCPMOAudioEmbeddingItems(DictEmbeddingItems):
 
 
 def _minicpmo_field_config(hf_inputs: Mapping[str, torch.Tensor]):
+    audio_features = hf_inputs.get("audio_features")
+    audio_feature_lens = hf_inputs.get("audio_feature_lens")
+    audio_features_cfg = MultiModalFieldConfig.batched("audio")
+
+    if audio_features is not None and audio_feature_lens is not None:
+        num_features = len(audio_features)
+        num_audios = len(audio_feature_lens)
+
+        if num_features > num_audios:
+            chunks_per_audio = [lens.numel() if isinstance(lens, torch.Tensor) else 1 for lens in audio_feature_lens]
+            if sum(chunks_per_audio) != num_features:
+                chunks_per_audio = [
+                    max(int((lens != 0).sum()), 1) if isinstance(lens, torch.Tensor) else 1
+                    for lens in audio_feature_lens
+                ]
+
+            slice_idxs = [0]
+            for num_chunks in chunks_per_audio:
+                slice_idxs.append(slice_idxs[-1] + num_chunks)
+            audio_features_cfg = MultiModalFieldConfig.flat(
+                "audio",
+                [slice(slice_idxs[i], slice_idxs[i + 1]) for i in range(len(chunks_per_audio))],
+            )
+
     return dict(
         **_minicpmv_field_config(hf_inputs),
-        audio_features=MultiModalFieldConfig.batched("audio"),
+        audio_features=audio_features_cfg,
         audio_feature_lens=MultiModalFieldConfig.batched("audio"),
         audio_embeds=MultiModalFieldConfig.batched("audio"),
     )
@@ -3257,7 +3409,7 @@ class MiniCPMO45OmniLLMMultiModalProcessor(BaseMultiModalProcessor[MiniCPMO45Omn
                     tokenization_kwargs=tokenization_kwargs,
                 )
             tokenizer = self.info.get_tokenizer()
-            prompt_ids = encode_tokens(tokenizer, prompt)
+            prompt_ids = _encode_tokens(tokenizer, prompt)
         else:
             prompt_ids = self._apply_hf_processor_tokens_only(prompt)
             if use_tts:
@@ -3308,10 +3460,23 @@ class MiniCPMO45OmniLLMMultiModalProcessor(BaseMultiModalProcessor[MiniCPMO45Omn
     ) -> bool:
         return False
 
-    def get_image_prompt_texts(self, image_size: ImageSize, image_idx: int = 0) -> str:
+    def get_image_prompt_texts(
+        self,
+        image_size: ImageSize,
+        image_idx: int = 0,
+        max_slice_nums: int | None = None,
+        use_image_id: bool | None = None,
+    ) -> str:
+        # ``process_images`` forwards ``mm_processor_kwargs`` to the pixel path, so the
+        # placeholder grid must honor the same ``max_slice_nums``; otherwise a request that
+        # sets it (e.g. interleaved omni frames with max_slice_nums=1) produces fewer image
+        # features than placeholder ``<unk>`` slots. ``use_image_id`` is likewise per-request
+        # so callers can match MiniCPM-o's omni path, which emits no ``<image_id>`` prefix.
         return self.info.get_slice_image_placeholder(
             image_size,
             image_idx=image_idx,
+            max_slice_nums=max_slice_nums,
+            **({} if use_image_id is None else {"use_image_id": use_image_id}),
         )
 
     def get_video_prompt_texts(self, image_size: ImageSize, num_frames: int) -> str:
@@ -3361,11 +3526,17 @@ class MiniCPMO45OmniLLMMultiModalProcessor(BaseMultiModalProcessor[MiniCPMO45Omn
                 out_keys={"audio_features", "audio_feature_lens"},
             )
 
+            flat_feature_lens: list[int] = []
+            for lens in audio_inputs["audio_feature_lens"]:
+                if isinstance(lens, torch.Tensor):
+                    flat_feature_lens.extend(lens.flatten().tolist())
+                else:
+                    flat_feature_lens.append(int(lens))
             unpadded_audio_features = [
                 feat[:, :feature_len]
                 for feat, feature_len in zip(
                     audio_inputs["audio_features"],
-                    audio_inputs["audio_feature_lens"],
+                    flat_feature_lens,
                 )
             ]
             audio_inputs["audio_features"] = unpadded_audio_features
@@ -3495,13 +3666,21 @@ class MiniCPMO45OmniLLMMultiModalProcessor(BaseMultiModalProcessor[MiniCPMO45Omn
                 additional_placeholders.append((modality, sub_pattern))
         placeholders += additional_placeholders
 
+        image_max_slice_nums = hf_processor_mm_kwargs.get("max_slice_nums")
+        image_use_image_id = hf_processor_mm_kwargs.get("use_image_id")
+
         def get_image_replacement(item_idx: int):
             images = mm_items.get_items("image", (MiniCPMVImageEmbeddingItems, ImageProcessorItems))
 
             image_size = images.get_image_size(item_idx)
 
             return PromptUpdateDetails.select_text(
-                self.get_image_prompt_texts(image_size, item_idx),
+                self.get_image_prompt_texts(
+                    image_size,
+                    item_idx,
+                    max_slice_nums=None if image_max_slice_nums is None else int(image_max_slice_nums),  # type: ignore[arg-type]
+                    use_image_id=None if image_use_image_id is None else bool(image_use_image_id),
+                ),
                 "<unk>",
             )
 
@@ -3740,8 +3919,18 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
         else:
             text_config = Qwen2Config.from_dict(config_dict)
             llm_arch = "Qwen2ForCausalLM"
+        from vllm_omni.experimental.fullduplex.minicpmo45.compat import (
+            patch_minicpmo_remote_config,
+        )
+
+        patch_minicpmo_remote_config(text_config)
+        text_vllm_config = (
+            vllm_config.with_hf_config(text_config)
+            if callable(getattr(vllm_config, "with_hf_config", None))
+            else vllm_config
+        )
         self.llm = init_vllm_registered_model(
-            vllm_config=vllm_config,
+            vllm_config=text_vllm_config,
             prefix=maybe_prefix(prefix, "llm"),
             hf_config=text_config,
             architectures=[llm_arch],
@@ -3769,11 +3958,13 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
             self.audio_avg_pooler = nn.AvgPool1d(config.audio_pool_step, stride=config.audio_pool_step)
             self.audio_projection_layer = MultiModalProjector(in_dim=audio_output_dim, out_dim=embed_dim)
             self.audio_encoder_layer = -1
+            self.audio_past_key_values = None
         else:
             self.apm = None
             self.audio_avg_pooler = None
             self.audio_projection_layer = None
             self.audio_encoder_layer = None
+            self.audio_past_key_values = None
 
         self.mm_token_ids = set[int]()
         self.make_empty_intermediate_tensors = self.llm.make_empty_intermediate_tensors
@@ -4038,6 +4229,8 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
         device = pixel_values[0].device
         dtype = pixel_values[0].dtype
 
+        # VPM batching bounds encoder activations below, while this padding
+        # buffer intentionally remains sized for the full input batch.
         all_pixel_values = torch.zeros((B, 3, P, L), dtype=dtype, device=device)
         for i, pixel_values_item in enumerate(pixel_values):
             L_item = pixel_values_item.shape[-1]
@@ -4051,16 +4244,29 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
         for i, num_patches_item in enumerate(num_patches):
             patch_attn_mask[i, :num_patches_item] = True
 
-        vision_embedding = self.vpm(
-            all_pixel_values,
-            patch_attention_mask=patch_attn_mask.unsqueeze(1),
-            tgt_sizes=tgt_sizes,
-        )
+        patch_attn_mask = patch_attn_mask.unsqueeze(1)
 
-        if not isinstance(vision_embedding, torch.Tensor):
-            vision_embedding = vision_embedding.last_hidden_state
+        def encode_vision(start: int, end: int) -> torch.Tensor:
+            chunk_tgt_sizes = tgt_sizes[start:end]
+            vision_embedding = self.vpm(
+                all_pixel_values[start:end],
+                patch_attention_mask=patch_attn_mask[start:end],
+                tgt_sizes=chunk_tgt_sizes,
+            )
 
-        return self.resampler(vision_embedding, tgt_sizes)
+            if not isinstance(vision_embedding, torch.Tensor):
+                vision_embedding = vision_embedding.last_hidden_state
+
+            return vision_embedding
+
+        vision_batch_size = max(1, int(self.config.vision_batch_size))
+        if B <= vision_batch_size:
+            return self.resampler(encode_vision(0, B), tgt_sizes)
+
+        vision_embeddings = [
+            encode_vision(start, min(start + vision_batch_size, B)) for start in range(0, B, vision_batch_size)
+        ]
+        return self.resampler(torch.cat(vision_embeddings, dim=0), tgt_sizes)
 
     def _process_vision_input(
         self,
@@ -4097,15 +4303,21 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
             torch.Tensor: mask
 
         """
-        ret = torch.zeros(size, size, device=device, dtype=torch.bool)
-        for i in range(size):
-            if num_left_chunks < 0:
-                start = 0
-            else:
-                start = max((i // chunk_size - num_left_chunks) * chunk_size, 0)
-            ending = min((i // chunk_size + 1) * chunk_size + num_lookhead, size)
-            ret[i, start:ending] = True
-        return ret
+        indices = torch.arange(size, device=device)
+        chunk_index = indices // chunk_size
+        chunk_end = torch.clamp(
+            (chunk_index + 1) * chunk_size + num_lookhead,
+            max=size,
+        )
+
+        mask = indices.unsqueeze(0) < chunk_end.unsqueeze(1)
+        if num_left_chunks >= 0:
+            chunk_start = torch.clamp(
+                (chunk_index - num_left_chunks) * chunk_size,
+                min=0,
+            )
+            mask.logical_and_(indices.unsqueeze(0) >= chunk_start.unsqueeze(1))
+        return mask
 
     def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor):
         input_lengths_after_cnn = (input_lengths - 1) // 2 + 1
@@ -4177,9 +4389,19 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
             audio_attention_mask_ = torch.logical_or(audio_attention_mask_, torch.logical_not(chunk_mask))
 
         audio_attention_mask[audio_attention_mask_] = float("-inf")
-        audio_states = self.apm(wavforms, attention_mask=audio_attention_mask, output_hidden_states=True).hidden_states[
-            self.audio_encoder_layer
-        ]
+        selects_final_layer = self.audio_encoder_layer == -1
+        audio_outputs = self.apm(
+            wavforms,
+            attention_mask=audio_attention_mask,
+            output_hidden_states=not selects_final_layer,
+        )
+        if selects_final_layer:
+            audio_states = audio_outputs.last_hidden_state
+        else:
+            # Whisper follows the Hugging Face hidden-state ordering: the
+            # embedding output, followed by each encoder layer output.
+            assert audio_outputs.hidden_states is not None
+            audio_states = audio_outputs.hidden_states[self.audio_encoder_layer]
         audio_embeds = self.audio_projection_layer(audio_states)
 
         audio_embeds = audio_embeds.transpose(1, 2)
@@ -4202,6 +4424,100 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
 
         return final_audio_embeds
 
+    def get_audio_embedding_streaming(
+        self,
+        data: MiniCPMOAudioFeatureInputs,
+        use_extra_context: bool = False,
+        prefix_extra_frames: int = 1,
+        suffix_extra_frames: int = 1,
+        cnn_min_length: int | None = None,
+    ) -> list[list[torch.Tensor]]:
+        if self.apm is None or self.audio_projection_layer is None or self.audio_avg_pooler is None:
+            return []
+
+        wavforms = data["audio_features"]
+        audio_feature_lens_raw = data["audio_feature_lens"]
+        if isinstance(wavforms, list):
+            if not wavforms:
+                return []
+            batch_size = len(wavforms)
+            channels = wavforms[0].shape[-2]
+            max_len = max(item.shape[-1] for item in wavforms)
+            wavforms_tensor = torch.zeros(
+                (batch_size, channels, max_len),
+                dtype=wavforms[0].dtype,
+                device=wavforms[0].device,
+            )
+            for idx, item in enumerate(wavforms):
+                wavforms_tensor[idx, ..., : item.shape[-1]] = item
+            wavforms = wavforms_tensor
+        if isinstance(audio_feature_lens_raw, torch.Tensor):
+            audio_feature_lens_raw = audio_feature_lens_raw.unbind(0)
+        if wavforms.shape[0] == 0:
+            return []
+        audio_feature_lens = torch.hstack(audio_feature_lens_raw)
+        batch_size, _, max_mel_seq_len = wavforms.shape
+        assert batch_size == 1
+
+        current_seq_len = (max_mel_seq_len - 1) // 2 + 1
+        if use_extra_context:
+            prefix_to_remove = (int(prefix_extra_frames) + 1) // 2 if prefix_extra_frames > 0 else 0
+            suffix_to_remove = (int(suffix_extra_frames) + 1) // 2 if suffix_extra_frames > 0 else 0
+            current_seq_len = current_seq_len - prefix_to_remove - suffix_to_remove
+        if current_seq_len <= 0:
+            return []
+
+        if self.audio_past_key_values is not None:
+            cache_length = self.audio_past_key_values[0][0].shape[2]
+            apm_max_len = self.apm.embed_positions.weight.shape[0]
+            if cache_length + current_seq_len >= apm_max_len:
+                logger.warning(
+                    "audio_past_key_values length %s exceeds %s, reset.",
+                    cache_length + current_seq_len,
+                    apm_max_len,
+                )
+                self.audio_past_key_values = None
+
+        past_len = 0
+        if self.audio_past_key_values is not None:
+            past_len = self.audio_past_key_values[0][0].shape[2]
+        total_seq_len = past_len + current_seq_len
+        audio_attention_mask = torch.zeros(
+            (batch_size, 1, current_seq_len, total_seq_len),
+            dtype=self.apm.conv1.weight.dtype,
+            device=wavforms.device,
+        )
+
+        audio_outputs = self.apm(
+            wavforms,
+            past_key_values=self.audio_past_key_values,
+            use_cache=True,
+            output_hidden_states=True,
+            attention_mask=audio_attention_mask,
+            use_extra_context=use_extra_context,
+            prefix_extra_frames=prefix_extra_frames,
+            suffix_extra_frames=suffix_extra_frames,
+            cnn_min_length=cnn_min_length,
+        )
+        audio_states = audio_outputs.hidden_states[self.audio_encoder_layer]
+        self.audio_past_key_values = audio_outputs.past_key_values
+
+        audio_embeds = self.audio_projection_layer(audio_states)
+        audio_embeds = audio_embeds.transpose(1, 2)
+        audio_embeds = self.audio_avg_pooler(audio_embeds)
+        audio_embeds = audio_embeds.transpose(1, 2)
+
+        _, feature_lens_after_pooling = self._get_feat_extract_output_lengths(audio_feature_lens)
+        final_audio_embeds: list[list[torch.Tensor]] = []
+        idx = 0
+        for i in range(len(audio_feature_lens_raw)):
+            target_audio_embeds = []
+            for _ in range(len(audio_feature_lens_raw[i])):
+                target_audio_embeds.append(audio_embeds[idx, : feature_lens_after_pooling[idx], :])
+                idx += 1
+            final_audio_embeds.append(target_audio_embeds)
+        return final_audio_embeds
+
     def _process_audio_input(
         self,
         audio_input: MiniCPMOAudioInputs,
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
index 083f54afe..02b0bf91f 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_tts.py
@@ -2,76 +2,128 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 # Adapted from:
 # https://huggingface.co/openbmb/MiniCPM-o-4_5/blob/main/modeling_minicpmo.py
-"""MiniCPM-o 4.5 Talker + Token2Wav: MiniCPMTTS with hidden_text_merge condition.
+"""MiniCPM-o 4.5 native autoregressive Talker.
 
 Pipeline:
   1. Receive thinker hidden_states + full token IDs via additional_information
   2. Extract tts_bos..tts_eos region
   3. Build condition: emb_text(tokens) + projector_semantic(hidden) (hidden_text_merge)
-  4. Run MiniCPMTTS.generate() -> discrete audio tokens
-  5. Run Token2wav(tokens) -> waveform bytes -> numpy array
+  4. Continuously generate request-aligned discrete audio-code deltas
 """
 
-import io
-import logging
-import os
 from collections.abc import Iterable
+from typing import Any
 
-import numpy as np
-import soundfile as sf
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from transformers import LlamaConfig
 from vllm.config import VllmConfig
+from vllm.logger import init_logger
 from vllm.model_executor.models.interfaces import SupportsPP
+from vllm.model_executor.models.llama import LlamaModel
+from vllm.model_executor.models.utils import maybe_prefix
+from vllm.v1.sample.sampler import Sampler
 
+from vllm_omni.experimental.fullduplex.engine.intermediate import get_tts_handoff
+from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.platforms import current_omni_platform
 
-try:
-    from stepaudio2 import Token2wav as _Token2wav
+logger = init_logger(__name__)
 
-    _stepaudio2_available = True
-except ImportError:
-    _Token2wav = None
-    _stepaudio2_available = False
-
-logger = logging.getLogger(__name__)
+_REPETITION_WINDOW = 16
+_MIN_AUDIO_TOKENS = 64
+_MAX_AUDIO_TOKENS = 2048
+_AUDIO_TOKENS_PER_TEXT_TOKEN = 10
+# Codec-token sampling happens inside the model; vLLM sampling parameters
+# only choose the Talker's binary continue/stop row.
+_CODEC_SEED = 42
+_CODEC_TEMPERATURE = 0.8
+_CODEC_TOP_K = 25
+_CODEC_TOP_P = 0.85
+_CODEC_REPETITION_PENALTY = 1.05
+_CODEC_MIN_TOKENS = 50
+_DUPLEX_CODEC_TOKENS_PER_CHUNK = 26
 
 
-def _install_torchaudio_soundfile_shim() -> None:
-    """Monkey-patch torchaudio.load to use soundfile instead of the default
-    torchcodec backend, which requires libtorchcodec/ffmpeg shared libs that
-    may be missing on the deployment machine."""
-    try:
-        import torchaudio
+def _max_audio_tokens(condition_tokens: int) -> int:
+    """Bound codec generation with a conservative text-length estimate.
 
-        if getattr(torchaudio, "_soundfile_shim_installed", False):
-            return
-        _orig_load = torchaudio.load
-
-        def _patched_load(uri, *args, **kwargs):
-            try:
-                return _orig_load(uri, *args, **kwargs)
-            except Exception:
-                import numpy as _np
-                import soundfile as _sf
-
-                data, sr = _sf.read(uri, dtype="float32", always_2d=True)
-                wav = torch.from_numpy(_np.ascontiguousarray(data.T))
-                return wav, sr
-
-        torchaudio.load = _patched_load
-        torchaudio._soundfile_shim_installed = True
-        logger.info("Installed torchaudio.load soundfile shim")
-    except Exception as _e:
-        logger.warning("Could not install torchaudio shim: %s", _e)
+    EOS is masked for the first 50 steps, so a direct ``text_tokens * 10``
+    limit can terminate short responses before EOS is eligible. The 2048
+    ceiling matches the checkpoint's native generation default and keeps the
+    sequence within the Talker's 4096-position context.
+    """
+    return max(
+        _MIN_AUDIO_TOKENS,
+        min(_MAX_AUDIO_TOKENS, condition_tokens * _AUDIO_TOKENS_PER_TEXT_TOKEN),
+    )
 
 
-_install_torchaudio_soundfile_shim()
+def _restore_weight_norm_weight(weight_g: torch.Tensor, weight_v: torch.Tensor) -> torch.Tensor:
+    """Materialize ``weight_norm(..., dim=0)`` checkpoint parameters."""
+    return torch._weight_norm(weight_v, weight_g, dim=0)
+
+
+def _apply_repetition_penalty(
+    logits: torch.Tensor,
+    history: torch.Tensor,
+    *,
+    penalty: float,
+    window_size: int,
+) -> torch.Tensor:
+    """Match MiniCPMTTS' frequency-aware repetition penalty."""
+    if penalty == 1.0 or history.numel() == 0:
+        return logits
+    recent = history.reshape(-1)[-window_size:].to(device=logits.device, dtype=torch.long)
+    frequencies = torch.bincount(recent, minlength=logits.shape[-1]).to(dtype=logits.dtype)
+    alpha = torch.pow(torch.as_tensor(penalty, device=logits.device, dtype=logits.dtype), frequencies)
+    return torch.where(logits < 0, logits * alpha, logits / alpha)
+
+
+def _apply_top_k_top_p(
+    logits: torch.Tensor,
+    *,
+    top_k: int | None,
+    top_p: float | None,
+    min_tokens_to_keep: int = 3,
+) -> torch.Tensor:
+    """Apply the same candidate floors as the upstream Transformers warpers."""
+    filtered = logits.clone()
+    vocab_size = filtered.shape[-1]
+    # MiniCPM-o's gen_logits() appends TopPLogitsWarper before
+    # TopKLogitsWarper. The order is observable for fixed-seed sampling.
+    if top_p is not None and 0.0 < top_p < 1.0:
+        sorted_logits, sorted_indices = torch.sort(filtered, descending=False, dim=-1)
+        cumulative_probs = torch.softmax(sorted_logits, dim=-1).cumsum(dim=-1)
+        remove = cumulative_probs <= (1.0 - float(top_p))
+        remove[..., -min_tokens_to_keep:] = False
+        remove = remove.scatter(-1, sorted_indices, remove)
+        filtered.masked_fill_(remove, float("-inf"))
+    if top_k is not None and top_k > 0:
+        keep = min(vocab_size, max(int(top_k), min_tokens_to_keep))
+        threshold = torch.topk(filtered, keep, dim=-1).values[..., -1, None]
+        filtered.masked_fill_(filtered < threshold, float("-inf"))
+    return filtered
+
+
+class _MiniCPMTTSProjector(nn.Module):
+    """Checkpoint-compatible hidden-state projector used by MiniCPMTTS."""
+
+    def __init__(self, input_size: int, hidden_size: int):
+        super().__init__()
+        self.linear1 = nn.Linear(input_size, hidden_size, bias=True)
+        self.relu = nn.ReLU()
+        self.linear2 = nn.Linear(hidden_size, hidden_size, bias=True)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.linear2(self.relu(self.linear1(hidden_states)))
 
 
 class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
-    """MiniCPM-o 4.5 Talker: MiniCPMTTS + Token2wav in a single forward pass."""
+    """Runner-owned MiniCPM-o 4.5 Talker that emits codec tokens only."""
+
+    requires_request_sample_eligibility = True
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
         super().__init__()
@@ -80,12 +132,14 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
         config: MiniCPMOConfig = vllm_config.model_config.hf_config
         self.config = config
         self.vllm_config = vllm_config
-
-        self.tts = None
-        self.audio_tokenizer = None
-        self._assets_loaded = False
+        self._batch_stop_logits: torch.Tensor | None = None
+        self._request_generators: dict[str, torch.Generator] = {}
+        self._request_audio_states: dict[str, dict[str, Any]] = {}
+        self._deferred_cleanup_ids: set[str] = set()
 
         tts_config = getattr(config, "tts_config", None)
+        if tts_config is None and getattr(config, "model_type", None) == "minicpmtts":
+            tts_config = config
         if tts_config is not None:
             self._tts_config = tts_config
             self._tts_bos_id = getattr(tts_config, "audio_bos_token_id", 151687)
@@ -93,273 +147,436 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
             self._num_audio_tokens = getattr(tts_config, "num_audio_tokens", 6562)
             self._hidden_size = getattr(tts_config, "hidden_size", 768)
             self._normalize = getattr(tts_config, "normalize_projected_hidden", True)
+            self._codec_seed = int(getattr(tts_config, "seed", _CODEC_SEED))
+            self._codec_temperature = float(getattr(tts_config, "temperature", _CODEC_TEMPERATURE))
+            self._codec_top_k = int(getattr(tts_config, "top_k", _CODEC_TOP_K))
+            self._codec_top_p = float(getattr(tts_config, "top_p", _CODEC_TOP_P))
+            self._codec_repetition_penalty = float(getattr(tts_config, "repetition_penalty", _CODEC_REPETITION_PENALTY))
+            self._codec_min_tokens = int(getattr(tts_config, "min_new_tokens", _CODEC_MIN_TOKENS))
         else:
             self._tts_config = None
 
-    def _lazy_init_tts(self):
-        if self._assets_loaded or self._tts_config is None:
-            return
-        try:
-            model_path = self.vllm_config.model_config.model
-            import os
-            import sys
+        self.has_preprocess = True
+        self.has_postprocess = False
+        self.gpu_resident_buffer_keys: set[tuple[str, str]] = {
+            ("audio_codes", "current"),
+            ("audio_codes", "accumulated"),
+        }
+        self._init_native_talker(prefix)
 
-            if model_path not in sys.path:
-                sys.path.insert(0, model_path)
-            from transformers.dynamic_module_utils import get_class_from_dynamic_module
+    def _init_native_talker(self, prefix: str) -> None:
+        if self._tts_config is None:
+            raise ValueError("MiniCPM-o continuous Talker requires tts_config")
+        cfg = self._tts_config
+        if int(getattr(cfg, "num_vq", 1)) != 1:
+            raise ValueError(
+                "MiniCPM-o continuous Talker currently requires num_vq=1; "
+                f"checkpoint reports {getattr(cfg, 'num_vq', None)}"
+            )
+        llama_config = LlamaConfig(
+            vocab_size=32000,
+            hidden_size=int(cfg.hidden_size),
+            intermediate_size=int(cfg.intermediate_size),
+            num_hidden_layers=int(cfg.num_hidden_layers),
+            num_attention_heads=int(cfg.num_attention_heads),
+            num_key_value_heads=int(cfg.num_key_value_heads),
+            hidden_act=getattr(cfg, "hidden_act", "silu"),
+            max_position_embeddings=int(cfg.max_position_embeddings),
+            rms_norm_eps=float(getattr(cfg, "rms_norm_eps", 1e-6)),
+            tie_word_embeddings=False,
+        )
+        talker_config = self.vllm_config.with_hf_config(llama_config, architectures=["LlamaForCausalLM"])
+        talker_config.model_config.hf_text_config = llama_config
+        self.tts_model = LlamaModel(
+            vllm_config=talker_config,
+            prefix=maybe_prefix(prefix, "tts_obj.model"),
+        )
+        self.emb_text = nn.Embedding(int(cfg.num_text_tokens), int(cfg.hidden_size))
+        self.projector_semantic = _MiniCPMTTSProjector(int(cfg.llm_dim), int(cfg.hidden_size))
+        self.emb_code = nn.ModuleList(
+            [nn.Embedding(int(cfg.num_audio_tokens), int(cfg.hidden_size)) for _ in range(int(cfg.num_vq))]
+        )
+        self.head_code = nn.ModuleList(
+            [nn.Linear(int(cfg.hidden_size), int(cfg.num_audio_tokens), bias=False) for _ in range(int(cfg.num_vq))]
+        )
+        self.make_empty_intermediate_tensors = self.tts_model.make_empty_intermediate_tensors
 
-            MiniCPMTTS = get_class_from_dynamic_module("modeling_minicpmo.MiniCPMTTS", model_path)
+    def _boundary_embeddings(self) -> torch.Tensor:
+        """Embed the ``<text_eos><audio_bos>`` tail every condition ends with."""
+        ids = torch.tensor(
+            [self._text_eos_id, self._tts_bos_id],
+            device=self.emb_text.weight.device,
+            dtype=torch.long,
+        )
+        return self.emb_text(ids)
 
-            # MiniCPMTTS.__init__ reads `config.top_p / top_k / repetition_penalty`
-            # directly (modeling_minicpmo.py L4112-4114), but the model repo's
-            # config.json `tts_config` block does not declare these fields and
-            # PretrainedConfig in recent transformers no longer surfaces
-            # generation-style params on `self.config`. Inject the defaults the
-            # upstream code itself ships with (modeling_minicpmo.py L2212-2214,
-            # L3132-3133) so attribute access does not raise.
-            for _attr, _default in (("top_p", 0.8), ("top_k", 100), ("repetition_penalty", 1.02)):
-                if not hasattr(self._tts_config, _attr):
-                    setattr(self._tts_config, _attr, _default)
-
-            prev_dtype = torch.get_default_dtype()
-            torch.set_default_dtype(torch.float32)
-            try:
-                self.tts_obj = MiniCPMTTS(config=self._tts_config, audio_tokenizer=None)
-            finally:
-                torch.set_default_dtype(prev_dtype)
-            self.emb_text = self.tts_obj.emb_text
-            self.projector_semantic = self.tts_obj.projector_semantic
-
-            token2wav_dir = os.path.join(model_path, "assets", "token2wav")
-            if os.path.isdir(token2wav_dir):
-                if not _stepaudio2_available:
-                    raise ImportError(
-                        "MiniCPM-o 4.5 token2wav stage requires the `stepaudio2` Python "
-                        "module (a MiniCPM-o-flavored Token2wav vocoder, NOT the upstream "
-                        "stepfun-ai/Step-Audio2 — the upstream signature does not accept "
-                        "n_timesteps and will fail at __init__). Install via:\n"
-                        "    pip install 'vllm-omni[minicpmo]'   # recommended, declared as PR extra\n"
-                        "Equivalent direct installs of the same `from stepaudio2 import Token2wav`\n"
-                        "entry point used by openbmb/MiniCPM-o-4_5/modeling_minicpmo.py:\n"
-                        "    pip install stepaudio2-minicpmo     # bare token2wav package\n"
-                        "    pip install 'minicpmo-utils[all]'   # MiniCPM-o umbrella (also brings image/video deps)"
-                    )
-                prev_dtype2 = torch.get_default_dtype()
-                torch.set_default_dtype(torch.float32)
-                try:
-                    # NB: this must be the MiniCPM-o-flavored Token2wav from
-                    # the `stepaudio2-minicpmo` PyPI package (or the
-                    # `minicpmo-utils[all]` umbrella), not the upstream
-                    # `stepfun-ai/Step-Audio2` repo. The MiniCPM-o variant's
-                    # __init__ accepts n_timesteps; the upstream signature is
-                    # (model_path, float16=False) and will raise
-                    # TypeError on n_timesteps. See ImportError message below
-                    # for installation guidance.
-                    self.audio_tokenizer = _Token2wav(token2wav_dir, float16=False, n_timesteps=10)
-                finally:
-                    torch.set_default_dtype(prev_dtype2)
-                self.tts_obj.audio_tokenizer = self.audio_tokenizer
-                logger.info("Loaded Token2wav from %s", token2wav_dir)
-            # Only mark init as complete after every step succeeds, so a
-            # partial failure leaves the next call free to retry the full
-            # init instead of short-circuiting back to a silent empty path.
-            self._assets_loaded = True
-        except ImportError:
-            # Surface missing dependencies directly so users can act on them
-            # instead of getting a silent None waveform downstream.
-            raise
-        except Exception:
-            # Re-raise non-import init failures (bad token2wav assets, missing
-            # weights, OOM during Token2wav construction, etc.) so the server
-            # fails loudly at startup / first request instead of returning
-            # silent empty audio for every subsequent request.
-            logger.error("Failed to init 4.5 TTS", exc_info=True)
-            raise
-
-    def generate_speech(
+    def _build_condition_embeddings(
         self,
         tts_token_ids: torch.Tensor,
         tts_hidden_states: torch.Tensor,
-    ) -> np.ndarray | None:
-        """Run full 4.5 TTS pipeline using original MiniCPMTTS.generate."""
-        self._lazy_init_tts()
-        if not hasattr(self, "tts_obj") or self.tts_obj is None:
-            logger.warning("generate_speech: tts_obj not initialized")
-            return None
-
-        tts = self.tts_obj
-        device = tts.emb_text.weight.device
-        dtype = tts.emb_text.weight.dtype
-
-        llm_embeds = tts.emb_text(tts_token_ids.to(device))
-        hidden_embeds = tts.projector_semantic(tts_hidden_states.to(device=device, dtype=dtype))
-        if getattr(tts.config, "normalize_projected_hidden", False):
-            hidden_embeds = F.normalize(hidden_embeds, p=2, dim=-1)
-        tts_embeds = llm_embeds + hidden_embeds
-
-        text_eos = tts.emb_text(torch.tensor([tts.config.text_eos_token_id], device=device, dtype=torch.long))
-        audio_bos = tts.emb_text(torch.tensor([tts.audio_bos_token_id], device=device, dtype=torch.long))
-        spk_embeds = torch.zeros(0, tts.config.hidden_size, device=device, dtype=tts_embeds.dtype)
-
-        inputs_embeds = torch.cat([spk_embeds, tts_embeds, text_eos, audio_bos], dim=0).unsqueeze(0)
-        logger.info("generate_speech: inputs_embeds shape=%s", list(inputs_embeds.shape))
-
-        # Scale max_new_token with input text length to avoid mid-stream truncation on long
-        # responses (default 2048 can only cover ~300 text tokens at ~6x audio/text ratio).
-        # Empirically 511 text tokens → 1951 audio tokens (~3.8x) finishes cleanly, so use 10x
-        # as a safe upper bound with a floor of 2048 and a hard cap of 16384 to bound latency/mem.
-        num_text = int(tts_token_ids.shape[-1]) if tts_token_ids.ndim > 0 else 0
-        max_new_token = max(2048, min(16384, num_text * 10))
-
-        eos_token = torch.tensor([tts.config.num_audio_tokens - 1], dtype=torch.long, device=device)
-        outputs = tts.generate(
-            inputs_embeds=inputs_embeds,
-            eos_token=eos_token,
-            max_new_token=max_new_token,
-            show_tqdm=False,
-        )
-        generated_tokens = outputs.new_ids.squeeze(-1)
-        logger.info(
-            "generate_speech: generated %d audio tokens (cap=%d, text_tokens=%d)",
-            generated_tokens.shape[-1],
-            max_new_token,
-            num_text,
-        )
-
-        if self.audio_tokenizer is None:
-            logger.warning("No audio_tokenizer")
-            return None
-
-        import torchaudio
-
-        model_path = self.vllm_config.model_config.model
-        default_ref = os.path.join(model_path, "assets", "HT_ref_audio.wav")
-        prompt_wav_path = default_ref if os.path.exists(default_ref) else None
-
-        _orig_save = torchaudio.save
-
-        def _patched_save(uri, src, sample_rate, **kw):
-            kw.pop("backend", None)
-            if hasattr(uri, "write"):
-                sf.write(uri, src.cpu().numpy().T, sample_rate, format="WAV")
-                return
-            return _orig_save(uri, src, sample_rate, backend="soundfile", **kw)
-
-        torchaudio.save = _patched_save
-        prev_dtype = torch.get_default_dtype()
-        torch.set_default_dtype(torch.float32)
-        try:
-            with torch.amp.autocast("cuda", enabled=False):
-                token_list = generated_tokens.squeeze(0).tolist()
-                num_tokens = len(token_list)
-
-                # For long outputs, the one-shot vocoder path
-                # (Token2wav.__call__ -> flow.inference) runs full O(N^2) self-
-                # attention over all audio tokens and OOMs on a 24GB card once
-                # N exceeds a few thousand (e.g. 4964 tokens needs ~3GiB for a
-                # single attention matmul). Switch to the chunked / streaming
-                # vocoder (set_stream_cache + stream) which truncates the flow
-                # attention caches to prompt_len + 100 steps on every chunk,
-                # keeping peak memory bounded regardless of total length.
-                STREAM_THRESHOLD = int(os.environ.get("MINICPMO45_TTS_STREAM_THRESHOLD", "2500"))  # ~100s @ 25Hz
-                CHUNK_SIZE = int(os.environ.get("MINICPMO45_TTS_STREAM_CHUNK", "50"))  # ~2s per chunk
-                MIN_TAIL = 6  # must exceed flow.pre_lookahead_len (typically 3)
-
-                if num_tokens <= STREAM_THRESHOLD:
-                    wav_bytes = self.audio_tokenizer(token_list, prompt_wav_path)
-                    waveform, sr = sf.read(io.BytesIO(wav_bytes))
-                    waveform = waveform.astype(np.float32)
-                else:
-                    # Build chunk boundaries, merging a too-small tail into the
-                    # previous chunk so every chunk satisfies MIN_TAIL.
-                    boundaries = []
-                    i = 0
-                    while i < num_tokens:
-                        end = min(i + CHUNK_SIZE, num_tokens)
-                        if 0 < num_tokens - end < MIN_TAIL:
-                            end = num_tokens
-                        boundaries.append((i, end))
-                        i = end
-
-                    logger.info(
-                        "generate_speech: streaming vocoder, %d tokens -> %d chunks (chunk=%d)",
-                        num_tokens,
-                        len(boundaries),
-                        CHUNK_SIZE,
-                    )
-
-                    stream_cache, hift_cache_dict = self.audio_tokenizer.set_stream_cache(prompt_wav_path)
-                    self.audio_tokenizer.stream_cache = stream_cache
-                    self.audio_tokenizer.hift_cache_dict = hift_cache_dict
-
-                    try:
-                        pieces = []
-                        for idx, (s, e) in enumerate(boundaries):
-                            is_last = idx == len(boundaries) - 1
-                            wav_np = self.audio_tokenizer.stream(
-                                token_list[s:e],
-                                prompt_wav_path,
-                                last_chunk=is_last,
-                                return_waveform=True,
-                            )
-                            pieces.append(np.asarray(wav_np).reshape(-1))
-                        waveform = np.concatenate(pieces, axis=0).astype(np.float32)
-                        sr = 24000
-                    finally:
-                        # Free per-request streaming state so the next request starts clean
-                        self.audio_tokenizer.stream_cache = None
-                        self.audio_tokenizer.hift_cache_dict = {}
-        finally:
-            torch.set_default_dtype(prev_dtype)
-            torchaudio.save = _orig_save
-
-        logger.info("generate_speech: waveform %d samples, sr=%d", waveform.shape[0], sr)
-        return waveform
-
-    def _generate_tokens(self, inputs_embeds: torch.Tensor, max_new_token: int = 2048) -> torch.Tensor | None:
-        """Autoregressive generation of audio tokens using the TTS LlamaModel."""
-        device = inputs_embeds.device
-        eos_token = self._num_audio_tokens - 1
-        condition_length = inputs_embeds.shape[1]
-        num_vq = len(self.emb_code)
-
-        new_tokens = torch.zeros(1, max_new_token, num_vq, device=device, dtype=torch.long)
-        past_key_values = None
-        finished = False
-
-        for t in range(max_new_token):
-            if t == 0:
-                emb = inputs_embeds
-                position_ids = torch.arange(condition_length, device=device).unsqueeze(0)
-            else:
-                code_emb = [self.emb_code[q](new_tokens[:, t - 1 : t, q]) for q in range(num_vq)]
-                emb = torch.stack(code_emb, -1).sum(-1)
-                position_ids = torch.tensor([[condition_length + t - 1]], device=device)
-
-            outputs = self.tts_model(
-                inputs_embeds=emb,
-                position_ids=position_ids,
-                past_key_values=past_key_values,
-                use_cache=True,
+        *,
+        native_duplex: bool = False,
+    ) -> torch.Tensor:
+        if tts_token_ids.numel() == 0 or tts_hidden_states.numel() == 0:
+            # The thinker can legally emit an empty speech segment (<|tts_bos|>
+            # immediately followed by a boundary token) when it decides not to
+            # speak. Condition on the boundary tokens alone, which matches the
+            # 2-token scheduler prompt the stage bridge builds for an empty
+            # handoff.
+            return self._boundary_embeddings()
+        device = self.emb_text.weight.device
+        dtype = self.emb_text.weight.dtype
+        token_ids = tts_token_ids.to(device=device, dtype=torch.long).reshape(-1)
+        hidden = tts_hidden_states.to(device=device, dtype=dtype)
+        if hidden.shape[0] != token_ids.shape[0] and token_ids.shape[0] != 1:
+            raise ValueError(
+                "MiniCPM-o Talker condition length mismatch: "
+                f"token_ids={token_ids.shape[0]} hidden_states={hidden.shape[0]}"
             )
-            hidden = outputs.last_hidden_state
-            past_key_values = outputs.past_key_values
+        text_embeds = self.emb_text(token_ids)
+        hidden_embeds = self.projector_semantic(hidden)
+        if self._normalize:
+            hidden_embeds = F.normalize(hidden_embeds, p=2, dim=-1)
+        audio_bos = self.emb_text(torch.tensor([self._tts_bos_id], device=device, dtype=torch.long))
+        condition = text_embeds + hidden_embeds
+        if native_duplex:
+            # Match MiniCPMTTS.generate_chunk's streaming condition.
+            return torch.cat([condition, audio_bos], dim=0)
+        return torch.cat([condition, self._boundary_embeddings()], dim=0)
 
-            logits = torch.stack([self.head_code[q](hidden[:, -1]) for q in range(num_vq)], dim=-1)
-            logits = logits.float() / 0.8
+    def preprocess(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor | None,
+        **info_dict: Any,
+    ) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]]:
+        """Build request-local prefill/decode embeddings for the vLLM runner."""
+        del input_embeds
+        span_len = int(input_ids.shape[0])
+        is_prefill = bool(info_dict.get("_omni_is_prefill", False))
+        state = info_dict.get("audio_state")
+        first_call = not isinstance(state, dict)
 
-            if t < 50:
-                logits[:, eos_token, :] = -float("inf")
+        if is_prefill or first_call:
+            token_ids, hidden_states = get_tts_handoff(info_dict)
+            # Cross-process stage transport serializes CPU tensors as lists.
+            # Normalize both local tensor handoffs and transported payloads
+            # before validating/building the Talker condition.
+            if isinstance(token_ids, (list, tuple)):
+                token_ids = torch.as_tensor(token_ids, dtype=torch.long)
+            if isinstance(hidden_states, (list, tuple)):
+                hidden_states = torch.as_tensor(hidden_states, dtype=torch.float32)
+            if not isinstance(token_ids, torch.Tensor) or not isinstance(hidden_states, torch.Tensor):
+                available = sorted(key for key in info_dict if not key.startswith("_"))
+                raise ValueError(
+                    "MiniCPM-o Talker requires tensor tts_token_ids and "
+                    "tts_hidden_states conditioning; "
+                    f"received token_ids={type(token_ids).__name__}, "
+                    f"hidden_states={type(hidden_states).__name__}, "
+                    f"available_keys={available}"
+                )
+            # An empty condition means the thinker chose not to speak: finish the
+            # request up front so it emits zero audio codes instead of killing
+            # the stage engine.
+            empty_condition = token_ids.numel() == 0 or hidden_states.numel() == 0
+            if empty_condition:
+                logger.warning_once(
+                    "MiniCPM-o Talker received an empty condition (request %s); this request produces no audio.",
+                    info_dict.get("request_id"),
+                )
+            native_duplex = bool(info_dict.get("native_duplex", False))
+            full_embeds = self._build_condition_embeddings(
+                token_ids,
+                hidden_states,
+                native_duplex=native_duplex,
+            )
+            offset = int(info_dict.get("_omni_num_computed_tokens", 0))
+            request_id = str(info_dict.get("request_id", "0"))
+            meta = info_dict.get("meta")
+            # The handoff rebuilds only the tail-aligned Talker condition.
+            # Materialize zero-token embeddings for any scheduler prompt
+            # prefix so chunked prefill can slice from a non-zero offset.
+            prompt_len = info_dict.get("_omni_prompt_len")
+            target_len = int(prompt_len) if prompt_len is not None else offset + span_len
+            prefix_len = target_len - full_embeds.shape[0]
+            if prefix_len > 0:
+                placeholder_ids = torch.zeros(
+                    prefix_len,
+                    dtype=torch.long,
+                    device=self.emb_text.weight.device,
+                )
+                full_embeds = torch.cat([self.emb_text(placeholder_ids), full_embeds], dim=0)
+            embeds = full_embeds[offset : offset + span_len]
+            if embeds.shape[0] != span_len:
+                raise ValueError(
+                    "MiniCPM-o Talker prefill span exceeds condition: "
+                    f"request_id={info_dict.get('request_id')} offset={offset} "
+                    f"span={span_len} condition={full_embeds.shape[0]} "
+                    f"tts_ids={token_ids.shape[0]} tts_hidden={hidden_states.shape[0]} "
+                    f"prompt_len={info_dict.get('_omni_prompt_len')}"
+                )
+            duplex_boundary = isinstance(meta, dict) and (
+                bool(meta.get("turn_start", False)) or bool(meta.get("turn_end", False))
+            )
+            if native_duplex:
+                max_tokens = _DUPLEX_CODEC_TOKENS_PER_CHUNK
+                min_tokens = 0 if duplex_boundary else _DUPLEX_CODEC_TOKENS_PER_CHUNK
+            else:
+                max_tokens = _max_audio_tokens(int(token_ids.numel()))
+                min_tokens = self._codec_min_tokens
+            state = {
+                "step": 0,
+                "max_tokens": max_tokens,
+                "min_tokens": min_tokens,
+                "finished": empty_condition,
+            }
+            request_states = getattr(self, "_request_audio_states", None)
+            if request_states is None:
+                request_states = {}
+                self._request_audio_states = request_states
+            request_states[request_id] = state
+            empty_codes = torch.empty(0, dtype=torch.long, device=embeds.device)
+            return (
+                input_ids,
+                embeds,
+                {
+                    "audio_state": state,
+                    "audio_codes": {
+                        "current": empty_codes,
+                        "accumulated": empty_codes,
+                    },
+                },
+            )
 
-            probs = F.softmax(logits, dim=1)
-            idx = torch.multinomial(probs.view(-1, probs.shape[1]), 1).view(1, num_vq)
-            new_tokens[:, t] = idx
+        current = (info_dict.get("audio_codes", {}) or {}).get("current")
+        if not isinstance(current, torch.Tensor) or current.numel() != 1:
+            if state.get("finished"):
+                # A request that finished before sampling any code can still be
+                # scheduled for decode steps while sampling min_tokens masks the
+                # stop token. make_omni_output ignores its hidden states, so any
+                # shape-correct embedding will do.
+                weight = self.emb_code[0].weight
+                return input_ids, weight.new_zeros((span_len, weight.shape[1])), {}
+            raise RuntimeError("MiniCPM-o Talker decode is missing the previous request-local audio code")
+        code = current.to(device=self.emb_code[0].weight.device, dtype=torch.long).reshape(1)
+        embeds = self.emb_code[0](code)
+        return input_ids, embeds, {}
 
-            if (idx == eos_token).any():
-                finished = True
-                break
+    def _request_generator(self, request_id: str, device: torch.device) -> torch.Generator:
+        generator = self._request_generators.get(request_id)
+        if generator is None:
+            generator = torch.Generator(device=device)
+            generator.manual_seed(self._codec_seed)
+            self._request_generators[request_id] = generator
+        return generator
 
-        return new_tokens[:, : t + 1 if finished else t, :]
+    def _sample_audio_code(
+        self,
+        hidden_state: torch.Tensor,
+        history: torch.Tensor,
+        request_id: str,
+        step: int,
+    ) -> torch.Tensor:
+        logits = self.head_code[0](hidden_state).float() / self._codec_temperature
+        eos_id = self._num_audio_tokens - 1
+        logits = _apply_repetition_penalty(
+            logits,
+            history,
+            penalty=self._codec_repetition_penalty,
+            window_size=_REPETITION_WINDOW,
+        )
+        request_states = getattr(self, "_request_audio_states", {})
+        state = request_states.get(request_id)
+        min_tokens = (
+            int(state.get("min_tokens", self._codec_min_tokens)) if isinstance(state, dict) else self._codec_min_tokens
+        )
+        if step < min_tokens:
+            logits[..., eos_id] = float("-inf")
+        logits = _apply_top_k_top_p(
+            logits,
+            top_k=self._codec_top_k,
+            top_p=self._codec_top_p,
+            min_tokens_to_keep=3,
+        )
+        probabilities = torch.softmax(logits, dim=-1)
+        return torch.multinomial(
+            probabilities,
+            num_samples=1,
+            generator=self._request_generator(request_id, probabilities.device),
+        ).reshape(())
+
+    def make_omni_output(
+        self,
+        model_outputs: torch.Tensor | OmniOutput,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+        hidden = model_outputs
+        infos = kwargs.get("model_intermediate_buffer") or []
+        spans = kwargs.get("request_token_spans")
+        if spans is None or len(spans) != len(infos):
+            raise RuntimeError("MiniCPM-o continuous Talker requires one request_token_span per request")
+        sample_eligible = kwargs.get("request_sample_eligible")
+        if sample_eligible is None:
+            sample_eligible = [True] * len(infos)
+        if len(sample_eligible) != len(infos):
+            raise RuntimeError(
+                f"MiniCPM-o continuous Talker received {len(sample_eligible)} sampling flags for {len(infos)} requests"
+            )
+        emit_duplex_metadata = any(isinstance(info, dict) and info.get("native_duplex") is True for info in infos)
+
+        stop_rows: list[torch.Tensor] = []
+        codec_deltas: list[torch.Tensor] = []
+        terminal_flags: list[torch.Tensor] = []
+        native_duplex_flags: list[torch.Tensor] = []
+        duplex_epochs: list[torch.Tensor] = []
+        duplex_turn_ids: list[torch.Tensor] = []
+        segment_texts_utf8: list[torch.Tensor] = []
+        turn_end_flags: list[torch.Tensor] = []
+        empty_delta = hidden.new_empty((0, 1), dtype=torch.long)
+        for index, info in enumerate(infos):
+            info_dict = info if isinstance(info, dict) else {}
+            native_duplex = info_dict.get("native_duplex") is True
+            if emit_duplex_metadata:
+                duplex_info = info_dict.get("duplex")
+                if not isinstance(duplex_info, dict):
+                    duplex_info = {}
+                epoch = duplex_info.get("epoch", -1)
+                turn_id = duplex_info.get("turn_id", -1)
+                if native_duplex and not all(
+                    isinstance(value, int) and not isinstance(value, bool) and value >= 0 for value in (epoch, turn_id)
+                ):
+                    raise RuntimeError(
+                        "MiniCPM-o native duplex Talker requires non-negative integer "
+                        f"epoch and turn_id, got epoch={epoch!r}, turn_id={turn_id!r}"
+                    )
+                meta_info = info_dict.get("meta")
+                if not isinstance(meta_info, dict):
+                    meta_info = {}
+                segment_text = meta_info.get("native_duplex_segment_text", "") if native_duplex else ""
+                if not isinstance(segment_text, str):
+                    segment_text = ""
+                turn_eos_id = meta_info.get("turn_eos_token_id")
+                ids_info = info_dict.get("ids")
+                tts_ids = ids_info.get("tts") if native_duplex and isinstance(ids_info, dict) else None
+                if isinstance(tts_ids, torch.Tensor):
+                    contains_turn_eos = isinstance(turn_eos_id, int) and bool(
+                        torch.any(tts_ids.reshape(-1) == turn_eos_id).item()
+                    )
+                elif isinstance(tts_ids, (list, tuple)):
+                    contains_turn_eos = isinstance(turn_eos_id, int) and turn_eos_id in tts_ids
+                else:
+                    contains_turn_eos = False
+                native_duplex_flags.append(torch.tensor(native_duplex, dtype=torch.bool))
+                duplex_epochs.append(torch.tensor(epoch if isinstance(epoch, int) else -1, dtype=torch.long))
+                duplex_turn_ids.append(torch.tensor(turn_id if isinstance(turn_id, int) else -1, dtype=torch.long))
+                segment_texts_utf8.append(
+                    torch.tensor(
+                        list(segment_text.encode("utf-8")),
+                        dtype=torch.uint8,
+                    )
+                )
+                turn_end_flags.append(torch.tensor(native_duplex and contains_turn_eos, dtype=torch.bool))
+
+            if not isinstance(info, dict):
+                stop_rows.append(hidden.new_tensor([0.0, float("-inf")]))
+                codec_deltas.append(empty_delta)
+                terminal_flags.append(torch.tensor(False, dtype=torch.bool))
+                continue
+            start, end = spans[index]
+            end = min(int(end), int(hidden.shape[0]))
+            if int(start) >= end:
+                stop_rows.append(hidden.new_tensor([0.0, float("-inf")]))
+                codec_deltas.append(empty_delta)
+                terminal_flags.append(torch.tensor(False, dtype=torch.bool))
+                continue
+            request_id = str(info.get("request_id", index))
+            request_states = getattr(self, "_request_audio_states", None)
+            if request_states is None:
+                request_states = {}
+                self._request_audio_states = request_states
+            state = request_states.get(request_id)
+            if not isinstance(state, dict):
+                state = dict(info.get("audio_state", {}) or {})
+                request_states[request_id] = state
+            if state.get("finished"):
+                stop_rows.append(hidden.new_tensor([float("-inf"), 0.0]))
+                codec_deltas.append(empty_delta)
+                terminal_flags.append(torch.tensor(False, dtype=torch.bool))
+                continue
+            if not sample_eligible[index]:
+                # vLLM computes a logit row for incomplete chunked prefills but
+                # discards its sampled token. Advancing codec/RNG state here
+                # would make output depend on prefill chunking and compaction.
+                stop_rows.append(hidden.new_tensor([0.0, float("-inf")]))
+                codec_deltas.append(empty_delta)
+                terminal_flags.append(torch.tensor(False, dtype=torch.bool))
+                continue
+            codes = state.get("codes")
+            if not isinstance(codes, torch.Tensor):
+                codes = (info.get("audio_codes", {}) or {}).get("accumulated")
+            if not isinstance(codes, torch.Tensor):
+                codes = torch.empty(0, dtype=torch.long, device=hidden.device)
+            else:
+                codes = codes.to(device=hidden.device, dtype=torch.long).reshape(-1)
+            step = int(state.get("step", 0))
+            sampled = self._sample_audio_code(hidden[end - 1 : end], codes, request_id, step)
+            sampled_id = int(sampled.item())
+            is_eos = sampled_id == self._num_audio_tokens - 1
+            state["step"] = int(state.get("step", 0)) + 1
+            reached_limit = int(state["step"]) >= int(state.get("max_tokens", 2048))
+            finished = is_eos or reached_limit
+            state["finished"] = finished
+            # MiniCPMTTS.generate_chunk consumes the boundary sample but
+            # returns only codes that were fed into the retained KV state.
+            if not is_eos and not reached_limit:
+                codes = torch.cat([codes[-(_REPETITION_WINDOW - 1) :], sampled.reshape(1)])
+                delta = sampled.reshape(1, 1)
+            else:
+                delta = empty_delta
+            state["codes"] = codes
+            info["audio_state"] = state
+            info["audio_codes"] = {
+                "current": sampled.reshape(1),
+                "accumulated": codes,
+            }
+            codec_deltas.append(delta)
+            terminal_flags.append(torch.tensor(finished, dtype=torch.bool))
+            stop_rows.append(hidden.new_tensor([float("-inf"), 0.0] if finished else [0.0, float("-inf")]))
+
+        self._batch_stop_logits = torch.stack(stop_rows, dim=0) if stop_rows else hidden.new_empty((0, 2))
+        # Lists are deliberate: the runner routes element i to request i,
+        # preserving compaction alignment while emitting only this step's code.
+        meta_outputs = {"finished": terminal_flags}
+        if emit_duplex_metadata:
+            meta_outputs.update(
+                {
+                    "native_duplex": native_duplex_flags,
+                    "duplex_epoch": duplex_epochs,
+                    "duplex_turn_id": duplex_turn_ids,
+                    "llm_output_text_utf8": segment_texts_utf8,
+                    "turn_end": turn_end_flags,
+                }
+            )
+        multimodal_outputs: dict[str, Any] = {
+            "codes": {"audio": codec_deltas},
+            "meta": meta_outputs,
+        }
+        return OmniOutput(
+            text_hidden_states=hidden,
+            multimodal_outputs=multimodal_outputs,
+        )
+
+    def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
+        self._deferred_cleanup_ids.update(str(req_id) for req_id in finished_req_ids)
+
+    def _flush_deferred_cleanup(self) -> None:
+        request_audio_states = getattr(self, "_request_audio_states", {})
+        for request_id in self._deferred_cleanup_ids:
+            self._request_generators.pop(request_id, None)
+            request_audio_states.pop(request_id, None)
+        self._deferred_cleanup_ids.clear()
 
     def _dummy_hidden_states(
         self,
@@ -391,62 +608,77 @@ class MiniCPMO45OmniTTSForConditionalGeneration(nn.Module, SupportsPP):
         positions=None,
         intermediate_tensors=None,
         inputs_embeds=None,
-        additional_information=None,
         **kwargs,
     ):
-        if additional_information is None:
-            additional_information = {}
-
-        tts_token_ids = additional_information.get("tts_token_ids")
-        tts_hidden_states = additional_information.get("tts_hidden_states")
-        tts_text = additional_information.get("llm_output_text", [""])
-        if isinstance(tts_text, list):
-            tts_text = tts_text[0] if tts_text else ""
-
-        if tts_token_ids is None or tts_hidden_states is None:
-            # KV cache profiling / dummy run path — no real TTS input yet.
-            logger.debug("4.5 Talker: dummy forward (missing tts_token_ids/tts_hidden_states)")
+        self._flush_deferred_cleanup()
+        if input_ids is None and inputs_embeds is None:
             return self._dummy_hidden_states(input_ids, positions, inputs_embeds)
-
-        logger.info("4.5 Talker: generating speech for %d tokens", tts_token_ids.shape[0])
-        waveform = self.generate_speech(tts_token_ids, tts_hidden_states)
-        # Tuple layout: (mel_spec, waveform). 4.5 talker emits only waveform,
-        # so mel_spec stays None; the wrapper unpacks in this order and
-        # packages the waveform into ``multimodal_outputs["model_outputs"]``.
-        if waveform is not None:
-            return None, torch.tensor(waveform, dtype=torch.float32)
-        return None, None
+        return self.tts_model(
+            input_ids=input_ids,
+            positions=positions,
+            intermediate_tensors=intermediate_tensors,
+            inputs_embeds=inputs_embeds,
+        )
 
     def compute_logits(self, hidden_states, *args, **kwargs):
-        return torch.zeros(1, 2, device=hidden_states.device if isinstance(hidden_states, torch.Tensor) else "cuda")
+        if not isinstance(hidden_states, torch.Tensor):
+            return None
+        if self._batch_stop_logits is None:
+            return torch.zeros(
+                hidden_states.shape[0],
+                2,
+                device=hidden_states.device,
+                dtype=torch.float32,
+            )
+        logits = self._batch_stop_logits
+        self._batch_stop_logits = None
+        return logits
 
     def sample(self, logits, sampling_metadata):
-        return None
+        return Sampler()(logits, sampling_metadata)
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):
-        loaded = set()
-        tts_weights = {}
-        for k, v in weights:
-            if k.startswith("tts."):
-                tts_weights[k.replace("tts.", "", 1)] = v
-                # vllm sanity-checks `loaded` against `named_parameters()`.
-                # The submodule is attached at `self.tts_obj`, not `self.tts`,
-                # so report the loaded name under the on-module path.
-                loaded.add(k.replace("tts.", "tts_obj.", 1))
+        return self._load_native_weights(weights)
 
-        if tts_weights and self._tts_config is not None:
-            self._lazy_init_tts()
-            if hasattr(self, "tts_obj") and self.tts_obj is not None:
-                missing, unexpected = self.tts_obj.load_state_dict(tts_weights, strict=False)
-                if missing:
-                    logger.warning("TTS missing keys (%d): %s", len(missing), missing[:5])
-                if unexpected:
-                    logger.warning("TTS unexpected keys (%d): %s", len(unexpected), unexpected[:5])
-                self.tts_obj = self.tts_obj.to("cuda")
-                self.emb_text = self.tts_obj.emb_text
-                self.projector_semantic = self.tts_obj.projector_semantic
-                logger.info("Loaded %d TTS weights, moved to cuda", len(tts_weights))
+    def _load_native_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        loaded: set[str] = set()
+        backbone_weights: list[tuple[str, torch.Tensor]] = []
+        direct_params = dict(self.named_parameters())
+        head_g = head_v = None
 
+        for name, tensor in weights:
+            if not name.startswith("tts."):
+                continue
+            stripped = name[len("tts.") :]
+            if stripped.startswith("model."):
+                backbone_weights.append((stripped[len("model.") :], tensor))
+                continue
+            if stripped == "head_code.0.parametrizations.weight.original0":
+                head_g = tensor
+                continue
+            if stripped == "head_code.0.parametrizations.weight.original1":
+                head_v = tensor
+                continue
+            target = stripped
+            parameter = direct_params.get(target)
+            if parameter is None:
+                continue
+            parameter.data.copy_(tensor.to(device=parameter.device, dtype=parameter.dtype))
+            loaded.add(target)
+
+        for name in self.tts_model.load_weights(backbone_weights):
+            loaded.add(f"tts_model.{name}")
+
+        if head_g is None or head_v is None:
+            raise ValueError("MiniCPM-o checkpoint is missing weight-norm Talker head parameters")
+        restored = _restore_weight_norm_weight(head_g, head_v)
+        self.head_code[0].weight.data.copy_(
+            restored.to(
+                device=self.head_code[0].weight.device,
+                dtype=self.head_code[0].weight.dtype,
+            )
+        )
+        loaded.add("head_code.0.weight")
         return loaded
 
     def get_input_embeddings(self, input_ids, multimodal_embeddings=None, **kwargs):
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_token2wav.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_token2wav.py
new file mode 100644
index 000000000..9451c2560
--- /dev/null
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_token2wav.py
@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""MiniCPM-o 4.5 Token2wav adapter over in-tree ``StepAudio2Token2WavCore``.
+
+``minicpmo_4_5_omni_tts`` historically depended on the external
+``from stepaudio2 import Token2wav`` entry point (``stepaudio2-minicpmo``).
+That package hard-codes ``.cuda()`` and duplicates the flow/HiFT stack that
+vLLM-Omni already vendors for Step-Audio2 (which also carries the Ascend/NPU
+fixes: HiFT linear downsample, DiT mask expand, MATH SDPA, compile disable,
+PE buffer extension).
+
+This module exposes the same call surface MiniCPM expects
+(``__call__`` / ``set_stream_cache`` / ``stream``) while delegating the
+actual vocoder work to
+``vllm_omni.model_executor.models.step_audio2.step_audio2_token2wav.StepAudio2Token2WavCore``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import torch
+
+from vllm_omni.model_executor.models.step_audio2.step_audio2_token2wav import (
+    StepAudio2Token2WavCore,
+    _StreamState,
+)
+
+
+def _resolve_device(device: str | torch.device | None) -> str:
+    if device is not None:
+        return str(device)
+    try:
+        from vllm_omni.platforms import current_omni_platform
+
+        plat_dev = getattr(current_omni_platform, "device_type", None)
+        if plat_dev:
+            return str(plat_dev)
+    except Exception:
+        pass
+    if torch.cuda.is_available():
+        return "cuda"
+    if hasattr(torch, "npu") and torch.npu.is_available():
+        return "npu"
+    return "cpu"
+
+
+class MiniCPMO45Token2wav:
+    """Token2wav-compatible facade around ``StepAudio2Token2WavCore``.
+
+    Matches the MiniCPM-o / ``stepaudio2-minicpmo`` vocoder API used by
+    ``MiniCPMO45OmniTTSForConditionalGeneration.generate_speech``:
+
+    * ``Token2wav(model_path, float16=False, n_timesteps=10)``
+    * ``__(tokens, prompt_wav) -> wav_bytes``
+    * ``set_stream_cache(prompt_wav) -> (stream_cache, hift_cache_dict)``
+    * ``stream(tokens, prompt_wav, last_chunk=..., return_waveform=...)``
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        float16: bool = False,
+        n_timesteps: int = 10,
+        device: str | torch.device | None = None,
+    ):
+        self.float16 = float16
+        self.n_timesteps = n_timesteps
+        self.device = _resolve_device(device)
+        self._core = StepAudio2Token2WavCore(
+            model_path=model_path,
+            float16=float16,
+            device=self.device,
+            n_timesteps=n_timesteps,
+        )
+        # Eager-load so construction failures surface at init time (same as
+        # the external Token2wav package), not on the first request.
+        self._core._ensure_models_loaded()
+
+        # Mutable streaming fields expected by MiniCPM's long-form path.
+        self.stream_cache: Any | None = None
+        self.hift_cache_dict: dict[str, torch.Tensor] = {}
+
+        # The external ``stepaudio2.Token2wav`` class builds ``speech_window``
+        # eagerly in ``__init__``. ``StepAudio2Token2WavCore`` only creates it
+        # lazily inside ``setup_stream_for``, so materialize it here: the
+        # 3-stage ``BatchedToken2Wav`` wrapper clones it at construction time.
+        if self._core.speech_window is None:
+            self._core.speech_window = torch.from_numpy(np.hamming(2 * self._core.source_cache_len)).to(
+                device=self.device, dtype=torch.float32
+            )
+
+    # --- Surface expected by ``BatchedToken2Wav`` (3-stage Code2Wav) ---------
+    # ``BatchedToken2Wav`` wraps this object as a one-time asset loader and
+    # module holder; it never calls ``__call__`` / ``stream`` / ``set_stream_cache``.
+    # Expose the same attributes the upstream ``stepaudio2.Token2wav`` provides.
+
+    @property
+    def flow(self) -> torch.nn.Module:
+        return self._core.flow
+
+    @property
+    def hift(self) -> torch.nn.Module:
+        return self._core.hift
+
+    @property
+    def mel_cache_len(self) -> int:
+        return self._core.mel_cache_len
+
+    @property
+    def source_cache_len(self) -> int:
+        return self._core.source_cache_len
+
+    @property
+    def speech_window(self) -> torch.Tensor:
+        return self._core.speech_window
+
+    def _prepare_prompt(self, prompt_wav: str):
+        """Delegate prompt feature extraction to the wrapped core."""
+        return self._core._prepare_prompt(prompt_wav)
+
+    def enable_trt_spk_embedding(self) -> None:
+        """Run the campplus speaker-embedding model on TensorRT."""
+        self._core.enable_trt_spk_embedding()
+
+    def __call__(self, generated_speech_tokens, prompt_wav) -> bytes:
+        """One-shot tokens → 24 kHz WAV bytes."""
+        return self._core.forward(
+            generated_speech_tokens,
+            prompt_wav,
+            return_bytes=True,
+        )
+
+    def set_stream_cache(self, prompt_wav: str):
+        """Initialise flow + HiFT caches for chunked vocoding.
+
+        Returns ``(stream_cache, hift_cache_dict)`` so callers can assign them
+        back onto this object the way ``stepaudio2.Token2wav`` does.
+        """
+        state = _StreamState()
+        self._core.setup_stream_for(prompt_wav, state)
+        self.stream_cache = state.stream_cache
+        self.hift_cache_dict = state.hift_cache_dict
+        return self.stream_cache, self.hift_cache_dict
+
+    def stream(
+        self,
+        generated_speech_tokens,
+        prompt_wav: str,
+        last_chunk: bool = False,
+        return_waveform: bool = False,
+    ):
+        """Process one streaming chunk; updates ``stream_cache`` / ``hift_cache_dict``."""
+        if self.stream_cache is None:
+            raise ValueError("stream_cache is not set")
+
+        state = _StreamState()
+        state.setup_done = True
+        state.stream_cache = self.stream_cache
+        state.hift_cache_dict = self.hift_cache_dict
+
+        speech = self._core.stream_chunk_for(
+            list(generated_speech_tokens),
+            prompt_wav,
+            last_chunk,
+            state,
+        )
+        self.stream_cache = state.stream_cache
+        self.hift_cache_dict = state.hift_cache_dict
+
+        wav_np = speech.detach().float().cpu().numpy()
+        if return_waveform:
+            return wav_np
+
+        wav_np = np.clip(wav_np, -1.0, 1.0)
+        wav_int16 = (wav_np * 32767.0).astype("<i2")
+        return wav_int16.tobytes()
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py b/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
index 701e014e6..b8fed05f1 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
@@ -3,12 +3,11 @@
 """MiniCPM-o 4.5 pipeline topology (frozen).
 
 Stage 0: Thinker — multimodal understanding + text generation.
-Stage 1: Talker  — MiniCPMTTS + Token2Wav, emits the final audio waveform.
+Stage 1: Talker  — MiniCPMTTS, emits codec tokens.
+Stage 2: Code2Wav — codec tokens to the final audio waveform.
 
-The thinker -> talker bridge passes the hidden states + token ids extracted
-from the thinker output through ``minicpmo_4_5_omni.llm2tts``; the talker
-runs MiniCPMTTS and the on-device Token2wav vocoder in the same process and
-returns the waveform directly as the pipeline's final audio output.
+The thinker -> talker bridge uses ``llm2tts``. The talker -> Code2Wav bridge
+streams request-routed codec chunks.
 """
 
 from vllm_omni.config.stage_config import (
@@ -22,7 +21,13 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni"
 
 MINICPMO_4_5_PIPELINE = PipelineConfig(
     model_type="minicpmo_4_5",
+    default_deploy_config_name="minicpmo_4_5.yaml",
     model_arch="MiniCPMO45OmniForConditionalGeneration",
+    duplex_runtime_extension=("vllm_omni.experimental.fullduplex.minicpmo45.runtime.MiniCPMO45DuplexRuntimeExtension"),
+    duplex_serving_adapter=(
+        "vllm_omni.experimental.fullduplex.minicpmo45.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
+    ),
+    duplex_control_enabled=True,
     # MiniCPM-o 4.5's HF config.json reports `model_type="minicpmo"` and
     # `architectures=["MiniCPMO"]` — both shared verbatim with older MiniCPM-o
     # 1.0 / 2.6 checkpoints. The only field distinguishing the generations is
@@ -50,28 +55,26 @@ MINICPMO_4_5_PIPELINE = PipelineConfig(
         StagePipelineConfig(
             stage_id=1,
             model_stage="tts",
-            # Stage 1 shares the top-level wrapper class
-            # (``MiniCPMO45OmniForConditionalGeneration``) inherited from
-            # ``model_arch`` above. The wrapper dispatches on ``model_stage``
-            # and, for ``"tts"``, instantiates the standalone TTS submodule
-            # (``MiniCPMO45OmniTTSForConditionalGeneration``) internally.
-            # Routing through the wrapper is required so that the runner-side
-            # ``runtime_additional_information`` payload reaches the talker
-            # (the standalone TTS class only reads ``additional_information``,
-            # so wiring stage 1 directly to it would always trigger the dummy
-            # path) and so the resulting waveform is packaged as
-            # ``OmniOutput.multimodal_outputs["model_outputs"]`` instead of
-            # being returned as a bare tuple that the AR runner would mistake
-            # for hidden states. ``hf_config_name="tts_config"`` keeps KV
-            # cache / mrope sizing scoped to the talker sub-config.
             execution_type=StageExecutionType.LLM_AR,
             input_sources=(0,),
+            hf_config_name="tts_config",
+            engine_output_type="latent",
+            custom_process_input_func=f"{_PROC}.llm2tts",
+            custom_process_next_stage_input_func=f"{_PROC}.tts2code2wav_full_payload",
+            async_chunk_process_next_stage_input_func=f"{_PROC}.tts2code2wav_async_chunk",
+            sampling_constraints={"detokenize": False},
+        ),
+        StagePipelineConfig(
+            stage_id=2,
+            model_stage="code2wav",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(1,),
             final_output=True,
             final_output_type="audio",
-            hf_config_name="tts_config",
             engine_output_type="audio",
-            custom_process_input_func=f"{_PROC}.llm2tts",
-            sampling_constraints={"detokenize": False},
+            model_arch="MiniCPMO45Code2Wav",
+            sync_process_input_func=f"{_PROC}.tts2code2wav_token_only",
+            sampling_constraints={"detokenize": True},
         ),
     ),
 )
diff --git a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
index b34b5b944..99dcb33e4 100644
--- a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
+++ b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer.py
@@ -354,12 +354,11 @@ class _ProjectedTransformer(nn.Module):
     ) -> None:
         super().__init__()
         self.downsample_ratio: int = 1
-        # Upstream always materializes a learned Linear here regardless of
-        # whether input_dimension == d_model — substituting Identity when
-        # the dims happen to match silently drops a trained projection.
-        self.in_proj = nn.Linear(input_dimension, d_model, bias=False)
+        self.in_proj = nn.Linear(input_dimension, d_model, bias=False) if input_dimension != d_model else nn.Identity()
         self.transformer = _Transformer(d_model=d_model, **kwargs)
-        self.out_proj = nn.Linear(d_model, output_dimension, bias=False)
+        self.out_proj = (
+            nn.Linear(d_model, output_dimension, bias=False) if output_dimension != d_model else nn.Identity()
+        )
 
     def forward(self, x: torch.Tensor, lengths: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         x = self.in_proj(x.transpose(1, 2))  # (B, D, T) → (B, T, d_model)
diff --git a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer_v2.py b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer_v2.py
index f3ba18c36..098f53792 100644
--- a/vllm_omni/model_executor/models/moss_tts/audio_tokenizer_v2.py
+++ b/vllm_omni/model_executor/models/moss_tts/audio_tokenizer_v2.py
@@ -102,12 +102,22 @@ class StreamingState:
 
     def __post_init__(self):
         self.exec_mask = torch.ones(self.batch_size, dtype=torch.bool, device=self.device)
+        self._owns_exec_mask = True
+
+    def bind_exec_mask(self, exec_mask: torch.Tensor) -> None:
+        if exec_mask.shape != (self.batch_size,):
+            raise ValueError(f"Expected exec_mask shape ({self.batch_size},), got {tuple(exec_mask.shape)}")
+        if exec_mask.device != self.device:
+            raise ValueError(f"Expected exec_mask on {self.device}, got {exec_mask.device}")
+        self.exec_mask = exec_mask
+        self._owns_exec_mask = False
 
     def set_exec_mask(self, exec_mask: torch.Tensor):
         self.exec_mask[:] = exec_mask
 
     def reset(self, reset_mask: torch.Tensor) -> None:
-        self.exec_mask[:] = torch.where(reset_mask, torch.ones_like(self.exec_mask), self.exec_mask)
+        if self._owns_exec_mask:
+            self.exec_mask.masked_fill_(reset_mask, True)
 
     def __enter__(self):
         # ExitStack expects a context manager; returning self is conventional and useful for debugging.
@@ -117,6 +127,28 @@ class StreamingState:
         pass
 
 
+@dataclass(frozen=True)
+class StreamingExecutionContext:
+    """Map compact execution rows to persistent streaming-state slots.
+
+    ``state_slot_ids`` and ``valid_rows`` both have shape ``(B_execution,)``.
+    CUDA Graph padding rows use dedicated scratch slots and ``valid_rows=False``.
+    """
+
+    state_slot_ids: torch.Tensor
+    valid_rows: torch.Tensor
+
+    def validate(self, *, batch_size: int, state_capacity: int, device: torch.device) -> None:
+        if self.state_slot_ids.shape != (batch_size,):
+            raise ValueError(f"Expected state_slot_ids shape ({batch_size},), got {tuple(self.state_slot_ids.shape)}")
+        if self.valid_rows.shape != (batch_size,):
+            raise ValueError(f"Expected valid_rows shape ({batch_size},), got {tuple(self.valid_rows.shape)}")
+        if self.state_slot_ids.device != device or self.valid_rows.device != device:
+            raise ValueError("Streaming execution metadata must be on the same device as decoder inputs.")
+        if self.state_slot_ids.dtype != torch.long or self.valid_rows.dtype != torch.bool:
+            raise TypeError("state_slot_ids must be int64 and valid_rows must be bool.")
+
+
 class StreamingModule(nn.Module):
     """Base class for streaming components."""
 
@@ -447,11 +479,56 @@ class RingKVCache:
     def reset(self, reset_mask: torch.Tensor) -> None:
         self.end_offset[:] = torch.where(reset_mask, torch.zeros_like(self.end_offset), self.end_offset)
 
-    def complete(self, k: torch.Tensor, v: torch.Tensor, exec_mask: torch.Tensor) -> KVCacheResult:
+    def reset_slots(self, state_slot_ids: torch.Tensor) -> None:
+        if state_slot_ids.numel() == 0:
+            return
+        slots = state_slot_ids.to(device=self.end_offset.device, dtype=torch.long)
+        self.end_offset.index_fill_(0, slots, 0)
+
+    def complete(
+        self,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        exec_mask: torch.Tensor | None = None,
+        execution_context: StreamingExecutionContext | None = None,
+    ) -> KVCacheResult:
         B, H, T, D = k.shape
         if T <= 0:
             raise ValueError(f"Expected T > 0, got T={T}")
 
+        if execution_context is not None:
+            if not self.respect_exec_mask:
+                raise RuntimeError("Dynamic state-slot execution does not support weights_per_step attention.")
+            slots = execution_context.state_slot_ids
+            valid_rows = execution_context.valid_rows
+            end_offset = self.end_offset.index_select(0, slots)
+            row_cache = self.cache.index_select(1, slots)
+
+            indexes = torch.arange(T, device=end_offset.device, dtype=end_offset.dtype)
+            indexes = (indexes + end_offset.view(-1, 1)) % self.capacity
+            scatter_indexes = indexes.view(B, 1, T, 1).expand(-1, H, T, D)
+            row_cache[0].scatter_(2, scatter_indexes, k)
+            row_cache[1].scatter_(2, scatter_indexes, v)
+            # Live and graph-padding rows always map to distinct slots. The
+            # latter map only to scratch state, so this write cannot corrupt a
+            # request even though dense graph operators still execute it.
+            self.cache.index_copy_(1, slots, row_cache)
+
+            cache_indexes = torch.arange(self.capacity, device=end_offset.device, dtype=torch.long)
+            last_offset = end_offset.view(-1, 1) + T - 1
+            end_index = last_offset % self.capacity
+            delta = cache_indexes - end_index
+            positions = torch.where(
+                delta <= 0,
+                last_offset + delta,
+                last_offset + delta - self.capacity,
+            )
+            next_offset = torch.where(valid_rows, end_offset + T, end_offset)
+            self.end_offset.index_copy_(0, slots, next_offset)
+            invalid = cache_indexes >= next_offset.view(-1, 1)
+            positions = torch.where(invalid, torch.full_like(positions, -1), positions)
+            return KVCacheResult(row_cache[0], row_cache[1], positions)
+
         indexes = torch.arange(T, device=self.end_offset.device, dtype=self.end_offset.dtype)
         indexes = indexes + self.end_offset.view(-1, 1)
         indexes = indexes % self.capacity
@@ -479,6 +556,8 @@ class RingKVCache:
         )
 
         if self.respect_exec_mask:
+            if exec_mask is None:
+                raise ValueError("exec_mask is required for fixed-width streaming execution.")
             self.end_offset[:] = torch.where(exec_mask, self.end_offset + T, self.end_offset)
         else:
             self.end_offset.add_(T)
@@ -507,6 +586,14 @@ class MHAState(StreamingState):
             self.kv_cache.reset(reset_mask)
         self.offset_cpu = 0
 
+    def reset_slots(self, state_slot_ids: torch.Tensor) -> None:
+        if state_slot_ids.numel() == 0:
+            return
+        slots = state_slot_ids.to(device=self.offset.device, dtype=torch.long)
+        self.offset.index_fill_(0, slots, 0)
+        if self.kv_cache is not None:
+            self.kv_cache.reset_slots(slots)
+
 
 def apply_weights_per_step(
     modules: nn.ModuleList,
@@ -600,7 +687,8 @@ class MossAudioTokenizerMultiheadAttention(StreamingModule):
     def _init_streaming_state(self, batch_size: int) -> MHAState:
         in_proj = cast(nn.Linear, self.in_projs[0])
         device = cast(torch.device, in_proj.weight.device)
-        dtype = cast(torch.dtype, in_proj.weight.dtype)
+        weight_dtype = cast(torch.dtype, in_proj.weight.dtype)
+        dtype = torch.bfloat16 if device.type == "cuda" else weight_dtype
 
         dim_per_head = self.embed_dim // self.num_heads
         if self.context is None:
@@ -625,21 +713,37 @@ class MossAudioTokenizerMultiheadAttention(StreamingModule):
             offset_cpu=0,
         )
 
-    def _complete_kv(self, k, v) -> KVCacheResult:
+    def _complete_kv(
+        self,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        execution_context: StreamingExecutionContext | None = None,
+    ) -> KVCacheResult:
         state = cast(MHAState | None, self._streaming_state)
         if state is None:
             return KVCacheResult.from_kv(k, v)
         if state.kv_cache is None:
             return KVCacheResult.from_kv(k, v)
-        return state.kv_cache.complete(k, v, state.exec_mask)
+        return state.kv_cache.complete(k, v, state.exec_mask, execution_context)
 
-    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor):
+    def forward(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        execution_context: StreamingExecutionContext | None = None,
+    ):
         state = cast(MHAState | None, self._streaming_state)
         B, T = query.shape[:2]
 
         if state is None:
             offset = torch.zeros(B, device=query.device, dtype=torch.long)
             offset_cpu = 0
+        elif execution_context is not None:
+            if self.weights_per_step:
+                raise RuntimeError("Dynamic codec state slots do not support weights_per_step attention.")
+            offset = state.offset.index_select(0, execution_context.state_slot_ids)
+            offset_cpu = 0
         else:
             offset = state.offset
             offset_cpu = state.offset_cpu
@@ -652,7 +756,7 @@ class MossAudioTokenizerMultiheadAttention(StreamingModule):
         if self.rope:
             q, k = self.rope(q, k, offset, time_before_heads=False)
 
-        k, v, pos_k = self._complete_kv(k, v)
+        k, v, pos_k = self._complete_kv(k, v, execution_context)
         pos_k = pos_k[:, None]
 
         if self.causal:
@@ -670,8 +774,12 @@ class MossAudioTokenizerMultiheadAttention(StreamingModule):
         x = apply_weights_per_step(self.out_projs, self.weights_per_step_schedule, x, offset_cpu)
 
         if state is not None:
-            state.offset[:] = torch.where(state.exec_mask, state.offset + T, state.offset)
-            state.offset_cpu += T
+            if execution_context is None:
+                state.offset[:] = torch.where(state.exec_mask, state.offset + T, state.offset)
+                state.offset_cpu += T
+            else:
+                next_offset = torch.where(execution_context.valid_rows, offset + T, offset)
+                state.offset.index_copy_(0, execution_context.state_slot_ids, next_offset)
         return x
 
 
@@ -688,6 +796,11 @@ class LayerState(StreamingState):
         super().reset(reset_mask)
         self.offset_cpu = 0
 
+    def reset_slots(self, state_slot_ids: torch.Tensor) -> None:
+        # This state is only meaningful for weights_per_step models, which are
+        # rejected by the dynamic state-slot path.
+        self.offset_cpu = 0
+
 
 class MossAudioTokenizerTransformerLayer(StreamingModule):
     """Transformer layer with streaming support."""
@@ -763,8 +876,14 @@ class MossAudioTokenizerTransformerLayer(StreamingModule):
         device = next(iter(self.parameters())).device
         return LayerState(batch_size, device, offset_cpu=0)
 
-    def _ff_block(self, x: torch.Tensor) -> torch.Tensor:
+    def _ff_block(
+        self,
+        x: torch.Tensor,
+        execution_context: StreamingExecutionContext | None = None,
+    ) -> torch.Tensor:
         state = self._streaming_state
+        if execution_context is not None and self.weights_per_step:
+            raise RuntimeError("Dynamic codec state slots do not support weights_per_step transformer layers.")
         offset = state.offset_cpu if isinstance(state, LayerState) else 0
 
         x_orig = x
@@ -782,17 +901,25 @@ class MossAudioTokenizerTransformerLayer(StreamingModule):
                 update = self.gating(x)
         return x_orig.to(update) + self.layer_scale_2(update)
 
-    def _sa_block(self, x: torch.Tensor):
+    def _sa_block(
+        self,
+        x: torch.Tensor,
+        execution_context: StreamingExecutionContext | None = None,
+    ):
         x_orig = x
         x = self.norm1(x)
-        update = self.self_attn(x, x, x)
+        update = self.self_attn(x, x, x, execution_context=execution_context)
         return x_orig.to(update) + self.layer_scale_1(update)
 
-    def forward(self, x: torch.Tensor):
-        x = self._sa_block(x)
-        x = self._ff_block(x)
+    def forward(
+        self,
+        x: torch.Tensor,
+        execution_context: StreamingExecutionContext | None = None,
+    ):
+        x = self._sa_block(x, execution_context)
+        x = self._ff_block(x, execution_context)
         state = self._streaming_state
-        if state is not None:
+        if state is not None and execution_context is None:
             assert isinstance(state, LayerState)
             state.offset_cpu += x.shape[1]
         return x
@@ -811,6 +938,11 @@ class TransformerState(StreamingState):
         super().reset(reset_mask)
         self.offsets[:] = torch.where(reset_mask, torch.zeros_like(self.offsets), self.offsets)
 
+    def reset_slots(self, state_slot_ids: torch.Tensor) -> None:
+        if state_slot_ids.numel() == 0:
+            return
+        self.offsets.index_fill_(0, state_slot_ids.to(device=self.offsets.device, dtype=torch.long), 0)
+
 
 class MossAudioTokenizerTransformer(StreamingModule):
     """Transformer with streaming/causal support."""
@@ -869,15 +1001,17 @@ class MossAudioTokenizerTransformer(StreamingModule):
     def forward(self, x: torch.Tensor, *args, **kwargs):
         B, T, C = x.shape
         state = self._streaming_state
-        offsets = (
-            torch.zeros(1, dtype=torch.long, device=x.device)
-            if state is None
-            else (
-                state.offsets
-                if isinstance(state, TransformerState)
-                else torch.zeros(1, dtype=torch.long, device=x.device)
-            )
-        )
+        execution_context = kwargs.get("execution_context")
+        if execution_context is not None and not isinstance(execution_context, StreamingExecutionContext):
+            raise TypeError("execution_context must be a StreamingExecutionContext.")
+        if state is None:
+            offsets = torch.zeros(1, dtype=torch.long, device=x.device)
+        elif not isinstance(state, TransformerState):
+            raise TypeError(f"Unexpected transformer state: {type(state).__name__}")
+        elif execution_context is None:
+            offsets = state.offsets
+        else:
+            offsets = state.offsets.index_select(0, execution_context.state_slot_ids)
 
         if self.positional_embedding in {"sin", "sin_rope"}:
             positions = torch.arange(T, device=x.device).view(1, -1, 1)
@@ -890,7 +1024,11 @@ class MossAudioTokenizerTransformer(StreamingModule):
 
         if state is not None:
             assert isinstance(state, TransformerState)
-            state.offsets[:] = torch.where(state.exec_mask, state.offsets + T, state.offsets)
+            if execution_context is None:
+                state.offsets[:] = torch.where(state.exec_mask, state.offsets + T, state.offsets)
+            else:
+                next_offsets = torch.where(execution_context.valid_rows, offsets + T, offsets)
+                state.offsets.index_copy_(0, execution_context.state_slot_ids, next_offsets)
         return x
 
 
@@ -1235,6 +1373,76 @@ class MossAudioTokenizerResidualLFQ(nn.Module):
                 for _ in range(num_quantizers)
             ]
         )
+        self.register_buffer("_decode_lut", None, persistent=False)
+        self.register_buffer("_decode_lut_bias", None, persistent=False)
+        self.register_buffer("_decode_lut_quantizer_ids", None, persistent=False)
+
+    @torch.no_grad()
+    def build_decode_lut(
+        self,
+        num_quantizers: int,
+        *,
+        dtype: torch.dtype,
+    ) -> None:
+        """Fold the inference-only LFQ decode projections into code tables."""
+        if not 0 < num_quantizers <= len(self.quantizers):
+            raise ValueError(f"num_quantizers must be in [1, {len(self.quantizers)}], got {num_quantizers}")
+
+        output_proj = self.output_proj
+        if isinstance(output_proj, nn.Identity):
+            output_weight = None
+            output_bias = torch.zeros(
+                self.output_dim,
+                device=self.quantizers[0].codebook.weight.device,
+                dtype=torch.float32,
+            )
+        elif isinstance(output_proj, nn.Conv1d) and output_proj.kernel_size == (1,):
+            output_weight = output_proj.weight.detach().squeeze(-1).float()
+            output_bias = (
+                output_proj.bias.detach().float()
+                if output_proj.bias is not None
+                else torch.zeros(
+                    self.output_dim,
+                    device=output_weight.device,
+                    dtype=torch.float32,
+                )
+            )
+        else:
+            raise TypeError(
+                "LFQ decoded LUT requires output_proj to be Identity or Conv1d(kernel_size=1), "
+                f"got {type(output_proj).__name__}"
+            )
+
+        decoded_tables: list[torch.Tensor] = []
+        for quantizer in self.quantizers[:num_quantizers]:
+            quantizer = cast(MossAudioTokenizerLFQ, quantizer)
+            inner_proj = quantizer.out_proj
+            codebook = quantizer.codebook.weight.detach().float()
+            if isinstance(inner_proj, nn.Identity):
+                decoded = codebook
+            elif isinstance(inner_proj, nn.Conv1d) and inner_proj.kernel_size == (1,):
+                inner_weight = inner_proj.weight.detach().squeeze(-1).float()
+                inner_bias = inner_proj.bias.detach().float() if inner_proj.bias is not None else None
+                decoded = F.linear(codebook, inner_weight, inner_bias)
+            else:
+                raise TypeError(
+                    "LFQ decoded LUT requires quantizer out_proj to be Identity or Conv1d(kernel_size=1), "
+                    f"got {type(inner_proj).__name__}"
+                )
+
+            if output_weight is not None:
+                # Apply the shared outer bias once after summing all codebooks.
+                decoded = F.linear(decoded, output_weight, bias=None)
+            decoded_tables.append(decoded)
+
+        lut = torch.stack(decoded_tables).to(dtype=dtype)
+        self._decode_lut = lut
+        self._decode_lut_bias = output_bias.to(dtype=dtype)
+        self._decode_lut_quantizer_ids = torch.arange(
+            num_quantizers,
+            device=lut.device,
+            dtype=torch.long,
+        ).view(-1, 1, 1)
 
     @torch.no_grad()
     def forward(
@@ -1276,6 +1484,12 @@ class MossAudioTokenizerResidualLFQ(nn.Module):
 
     def decode_codes(self, codes: torch.Tensor) -> torch.Tensor:
         nq, B, T = codes.shape
+        if self._decode_lut is not None and nq <= self._decode_lut.shape[0]:
+            quantizer_ids = self._decode_lut_quantizer_ids[:nq]
+            decoded = self._decode_lut[quantizer_ids, codes].sum(dim=0)
+            decoded = decoded + self._decode_lut_bias
+            return decoded.transpose(1, 2)
+
         emb = torch.zeros(B, self.rvq_dim, T, device=codes.device, dtype=torch.float32)
         for i, quantizer in enumerate(self.quantizers[:nq]):
             quantizer = cast(MossAudioTokenizerLFQ, quantizer)
@@ -1389,34 +1603,177 @@ class MossAudioTokenizerModel(MossAudioTokenizerPreTrainedModel):
                 f"got current_frame_rate={current_frame_rate}, expected={expected_output_frame_rate}."
             )
 
+        self._streaming_modules: list[StreamingModule] = []
+        self._streaming_exec_mask: torch.Tensor | None = None
+        self._decoder_state_capacity = 0
+        self._decoder_slot_offsets: torch.Tensor | None = None
         self.post_init()
 
-    def _start_streaming(self, batch_size: int):
-        """Start streaming mode for all modules."""
+    def _start_streaming(self, batch_size: int, *, decoder_only: bool = False) -> None:
+        """Start streaming with one shared, address-stable execution mask."""
+        if self._streaming_modules:
+            raise RuntimeError("MOSS Audio Tokenizer is already streaming.")
+
+        root: nn.Module = self.decoder if decoder_only else self
+        shared_exec_mask = torch.ones(
+            batch_size,
+            dtype=torch.bool,
+            device=next(self.parameters()).device,
+        )
+        streaming_modules: list[StreamingModule] = []
 
         def _start(module):
             if isinstance(module, StreamingModule):
-                module._streaming_state = module._init_streaming_state(batch_size)
+                if module._streaming_state is not None:
+                    raise RuntimeError("A MOSS Audio Tokenizer submodule is already streaming.")
+                state = module._init_streaming_state(batch_size)
+                state.bind_exec_mask(shared_exec_mask)
+                module._streaming_state = state
+                streaming_modules.append(module)
 
-        self.apply(_start)
+        root.apply(_start)
+        self._streaming_modules = streaming_modules
+        self._streaming_exec_mask = shared_exec_mask
+        if decoder_only:
+            self._centralize_decoder_slot_offsets(batch_size)
 
-    def _stop_streaming(self):
+    def _centralize_decoder_slot_offsets(self, state_capacity: int) -> None:
+        """Pack per-module slot offsets so reset needs one CUDA kernel."""
+        state_tensors: list[tuple[StreamingState, list[tuple[object, str]]]] = []
+        for module in self._streaming_modules:
+            state = module._streaming_state
+            fields: list[tuple[object, str]] = []
+            if isinstance(state, MHAState):
+                fields.append((state, "offset"))
+                if state.kv_cache is not None:
+                    fields.append((state.kv_cache, "end_offset"))
+            elif isinstance(state, TransformerState):
+                fields.append((state, "offsets"))
+            else:
+                continue
+
+            if not all(
+                isinstance(getattr(owner, name), torch.Tensor)
+                and getattr(owner, name).shape == (state_capacity,)
+                and getattr(owner, name).dtype == torch.long
+                for owner, name in fields
+            ):
+                raise RuntimeError(
+                    "Dynamic decoder state slots require every per-slot offset to use the full decoder state capacity."
+                )
+            state_tensors.append((state, fields))
+
+        num_offsets = sum(len(fields) for _, fields in state_tensors)
+        if num_offsets == 0:
+            raise RuntimeError("Dynamic decoder state pool has no per-slot offsets.")
+        storage = torch.zeros(
+            (num_offsets, state_capacity),
+            dtype=torch.long,
+            device=next(self.parameters()).device,
+        )
+        row = 0
+        for state, fields in state_tensors:
+            for owner, name in fields:
+                setattr(owner, name, storage[row])
+                row += 1
+        self._decoder_slot_offsets = storage
+
+    def _stop_streaming(self) -> None:
         """Stop streaming mode for all modules."""
+        for module in self._streaming_modules:
+            module._streaming_state = None
+        self._streaming_modules = []
+        self._streaming_exec_mask = None
+        self._decoder_state_capacity = 0
+        self._decoder_slot_offsets = None
 
-        def _stop(module):
-            if isinstance(module, StreamingModule):
-                module._streaming_state = None
+    def initialize_decoder_state_pool(self, state_capacity: int, scratch_capacity: int = 0) -> None:
+        """Allocate persistent decoder state independently of execution B."""
+        if state_capacity <= 0 or scratch_capacity < 0:
+            raise ValueError(f"Invalid decoder state capacities: state={state_capacity}, scratch={scratch_capacity}.")
+        self._start_streaming(state_capacity + scratch_capacity, decoder_only=True)
+        self._decoder_state_capacity = state_capacity + scratch_capacity
 
-        self.apply(_stop)
+    def close_decoder_state_pool(self) -> None:
+        self._stop_streaming()
+
+    def reset_decoder_state_slots(self, state_slot_ids: torch.Tensor) -> None:
+        if not self._streaming_modules:
+            raise RuntimeError("MOSS Audio Tokenizer decoder state pool is not initialized.")
+        if state_slot_ids.numel() == 0:
+            return
+        slot_offsets = self._decoder_slot_offsets
+        if slot_offsets is None:
+            raise RuntimeError("MOSS Audio Tokenizer decoder slot offsets are not initialized.")
+        if state_slot_ids.device.type == "cpu":
+            if int(state_slot_ids.min()) < 0 or int(state_slot_ids.max()) >= self._decoder_state_capacity:
+                raise ValueError(
+                    f"Decoder state slots must be in [0, {self._decoder_state_capacity}), got {state_slot_ids.tolist()}"
+                )
+        slots = state_slot_ids.to(device=slot_offsets.device, dtype=torch.long)
+        slot_offsets.index_fill_(1, slots, 0)
+
+    def decode_streaming_batch(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        valid_rows: torch.Tensor,
+    ) -> MossAudioTokenizerDecoderOutput:
+        if not self._streaming_modules:
+            raise RuntimeError("MOSS Audio Tokenizer decoder state pool is not initialized.")
+        execution_context = StreamingExecutionContext(state_slot_ids=state_slot_ids, valid_rows=valid_rows)
+        execution_context.validate(
+            batch_size=int(codes.shape[1]),
+            state_capacity=self._decoder_state_capacity,
+            device=codes.device,
+        )
+        audio, audio_lengths = self.decode_streaming_tensors(
+            codes,
+            codes_lengths,
+            state_slot_ids,
+            valid_rows,
+        )
+        return MossAudioTokenizerDecoderOutput(audio=audio, audio_lengths=audio_lengths)
+
+    def decode_streaming_tensors(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        valid_rows: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Tensor-only streaming decode boundary for vLLM compilation."""
+        execution_context = StreamingExecutionContext(
+            state_slot_ids=state_slot_ids,
+            valid_rows=valid_rows,
+        )
+        return self._decode_frame_tensors(codes, codes_lengths, execution_context=execution_context)
 
     def _set_streaming_exec_mask(self, exec_mask: torch.Tensor) -> None:
-        """Set the active slot mask on every live streaming module."""
+        """Update the shared active-slot mask with one device copy."""
+        shared_exec_mask = self._streaming_exec_mask
+        if shared_exec_mask is None:
+            raise RuntimeError("MOSS Audio Tokenizer is not streaming.")
+        if exec_mask.shape != shared_exec_mask.shape:
+            raise ValueError(f"Expected exec_mask shape {tuple(shared_exec_mask.shape)}, got {tuple(exec_mask.shape)}")
+        shared_exec_mask.copy_(exec_mask.to(device=shared_exec_mask.device, dtype=torch.bool), non_blocking=True)
 
-        def _set(module):
-            if isinstance(module, StreamingModule) and module._streaming_state is not None:
-                module._streaming_state.set_exec_mask(exec_mask.to(module._streaming_state.device))
-
-        self.apply(_set)
+    def _reset_streaming_slots(self, reset_mask: torch.Tensor) -> None:
+        """Reset cached decoder state without traversing the full module tree."""
+        shared_exec_mask = self._streaming_exec_mask
+        if shared_exec_mask is None:
+            raise RuntimeError("MOSS Audio Tokenizer is not streaming.")
+        if reset_mask.shape != shared_exec_mask.shape:
+            raise ValueError(
+                f"Expected reset_mask shape {tuple(shared_exec_mask.shape)}, got {tuple(reset_mask.shape)}"
+            )
+        reset_mask = reset_mask.to(device=shared_exec_mask.device, dtype=torch.bool)
+        shared_exec_mask.masked_fill_(reset_mask, True)
+        for module in self._streaming_modules:
+            state = module._streaming_state
+            if state is not None:
+                state.reset(reset_mask)
 
     @contextmanager
     def streaming(self, batch_size: int = 1):
@@ -1427,6 +1784,15 @@ class MossAudioTokenizerModel(MossAudioTokenizerPreTrainedModel):
         finally:
             self._stop_streaming()
 
+    @contextmanager
+    def decoder_streaming(self, batch_size: int = 1):
+        """Stream decoder-only inference without allocating encoder state."""
+        self._start_streaming(batch_size, decoder_only=True)
+        try:
+            yield
+        finally:
+            self._stop_streaming()
+
     def _prepare_waveform_batch(self, wav_list: list[torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         if len(wav_list) == 0:
             raise ValueError("`wav_list` must contain at least one waveform.")
@@ -1621,28 +1987,52 @@ class MossAudioTokenizerModel(MossAudioTokenizerPreTrainedModel):
         )
 
     @torch.no_grad()
-    def _decode_frame(
+    def _decode_frame_tensors(
         self,
         codes: torch.Tensor,
         codes_lengths: torch.Tensor | None = None,
-    ) -> MossAudioTokenizerDecoderOutput:
-        """Detokenize discrete tokens into audio waveform."""
+        execution_context: StreamingExecutionContext | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Detokenize codes and return tensors without Python output wrappers."""
         nq, B, T = codes.shape
         device = codes.device
 
         if codes_lengths is None:
             codes_lengths = torch.full((B,), T, device=device, dtype=torch.long)
 
-        # Decode from codes
-        quantizer = cast(MossAudioTokenizerResidualVQ | MossAudioTokenizerResidualLFQ, self.quantizer)
-        zq = quantizer.decode_codes(codes)
+        # Keep eager execution and CUDA Graph capture on the same BF16 path.
+        with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            quantizer = cast(MossAudioTokenizerResidualVQ | MossAudioTokenizerResidualLFQ, self.quantizer)
+            zq = quantizer.decode_codes(codes)
 
-        d, d_lengths = zq, codes_lengths
-        for decoder_module in self.decoder:
-            d, d_lengths = decoder_module(d, d_lengths)
+            d, d_lengths = zq, codes_lengths
+            for decoder_module in self.decoder:
+                if isinstance(decoder_module, StreamingModule):
+                    d, d_lengths = decoder_module(
+                        d,
+                        d_lengths,
+                        execution_context=execution_context,
+                    )
+                else:
+                    d, d_lengths = decoder_module(d, d_lengths)
 
         d, d_lengths = self._restore_channels_from_codec(d, d_lengths)
-        return MossAudioTokenizerDecoderOutput(audio=d, audio_lengths=d_lengths)
+        return d, d_lengths
+
+    @torch.no_grad()
+    def _decode_frame(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor | None = None,
+        execution_context: StreamingExecutionContext | None = None,
+    ) -> MossAudioTokenizerDecoderOutput:
+        """Compatibility wrapper around the tensor-only decoder."""
+        audio, audio_lengths = self._decode_frame_tensors(
+            codes,
+            codes_lengths,
+            execution_context=execution_context,
+        )
+        return MossAudioTokenizerDecoderOutput(audio=audio, audio_lengths=audio_lengths)
 
     def encode(  # type: ignore[override]
         self,
diff --git a/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py b/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py
new file mode 100644
index 000000000..52815dd3b
--- /dev/null
+++ b/vllm_omni/model_executor/models/moss_tts/cuda_graph_streaming_decoder_wrapper.py
@@ -0,0 +1,282 @@
+# Copyright 2026 OpenMOSS and the vLLM-Omni team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+"""CUDA graphs for compact MOSS-TTS streaming codec batches."""
+
+from __future__ import annotations
+
+import copy
+import time
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+from torch.cuda import CUDAGraph
+from vllm.compilation.decorators import support_torch_compile
+from vllm.config import CUDAGraphMode, VllmConfig
+from vllm.config.vllm import set_current_vllm_config
+from vllm.logger import init_logger
+from vllm.platforms import current_platform
+
+logger = init_logger(__name__)
+
+
+@support_torch_compile(
+    dynamic_arg_dims={
+        "codes": {1: "batch", 2: "frames"},
+        "codes_lengths": {0: "batch"},
+        "state_slot_ids": {0: "batch"},
+        "valid_rows": {0: "batch"},
+    }
+)
+class _MossStreamingDecodeCompileAdapter(nn.Module):
+    """Expose the BF16 codec streaming hot path to vLLM compile.
+
+    The dtype is part of the class identity intentionally: vLLM's AOT cache
+    drops runtime guards, so an artifact traced with the old FP32 decoder
+    weights must never be reused after the decoder is materialized as BF16.
+    """
+
+    def __init__(self, codec: nn.Module, *, vllm_config: VllmConfig) -> None:
+        super().__init__()
+        self.codec = codec
+
+    def forward(
+        self,
+        codes: torch.Tensor,
+        codes_lengths: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        valid_rows: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        return self.codec.decode_streaming_tensors(codes, codes_lengths, state_slot_ids, valid_rows)
+
+
+@dataclass
+class _CapturedStreamingDecodeGraph:
+    graph: CUDAGraph
+    static_codes: torch.Tensor
+    static_lengths: torch.Tensor
+    static_state_slot_ids: torch.Tensor
+    static_valid_rows: torch.Tensor
+    static_audio: torch.Tensor
+    static_audio_lengths: torch.Tensor
+
+
+class CUDAGraphStreamingDecoderWrapper:
+    """Replay streaming decode graphs keyed by ``(B_bucket, exact_T)``.
+
+    Persistent codec state is addressed through ``state_slot_ids``. Graph
+    padding rows use non-leaseable scratch slots, so graph batch width is no
+    longer tied to the number of live stream states.
+    """
+
+    def __init__(
+        self,
+        codec: nn.Module,
+        *,
+        state_capacity: int,
+        batch_sizes: list[int],
+        frame_sizes: list[int],
+        num_quantizers: int,
+        vllm_config: VllmConfig,
+    ) -> None:
+        self.codec = codec
+        self.state_capacity = int(state_capacity)
+        self.batch_sizes = sorted({int(size) for size in batch_sizes if 0 < int(size) <= state_capacity})
+        self.frame_sizes = sorted({int(size) for size in frame_sizes if int(size) > 0})
+        self.num_quantizers = int(num_quantizers)
+        self.graphs: dict[tuple[int, int], _CapturedStreamingDecodeGraph] = {}
+        self._pool = None
+        self._warmed_up = False
+        # vLLM owns Inductor compilation; this wrapper remains the sole owner
+        # of CUDA Graph capture/replay because it understands persistent codec
+        # state slots. Disable vLLM's CUDA Graph layer to avoid nested graphs.
+        compile_config = copy.copy(vllm_config)
+        compile_config.compilation_config = copy.copy(vllm_config.compilation_config)
+        compile_config.compilation_config.cudagraph_mode = CUDAGraphMode.NONE
+        compile_config.compilation_config.static_forward_context = {}
+        with set_current_vllm_config(compile_config):
+            self._compiled_decode: nn.Module | None = _MossStreamingDecodeCompileAdapter(
+                codec,
+                vllm_config=compile_config,
+            )
+
+    @property
+    def is_ready(self) -> bool:
+        return bool(self.graphs)
+
+    @property
+    def capture_sizes(self) -> list[tuple[int, int]]:
+        return sorted(self.graphs)
+
+    @property
+    def scratch_capacity(self) -> int:
+        return max(self.batch_sizes, default=0)
+
+    @torch.no_grad()
+    def warmup(self, device: torch.device) -> None:
+        if self._warmed_up:
+            return
+        self._warmed_up = True
+        if device.type != "cuda" or not self.batch_sizes or not self.frame_sizes:
+            return
+
+        capture_keys = sorted(
+            ((batch_size, frame_size) for batch_size in self.batch_sizes for frame_size in self.frame_sizes),
+            reverse=True,
+        )
+        logger.info(
+            "MOSS-TTS streaming decoder CUDA graph warmup: n_vq=%d (B,T)=%s",
+            self.num_quantizers,
+            list(reversed(capture_keys)),
+        )
+        start_s = time.perf_counter()
+        with torch.cuda.device(device):
+            for batch_size, frame_size in capture_keys:
+                key = (batch_size, frame_size)
+                try:
+                    compiled = self._capture(batch_size, frame_size, device)
+                    logger.info(
+                        "  Captured %s MOSS-TTS streaming decoder CUDA graph for (B,T)=%s",
+                        "compiled" if compiled else "plain",
+                        key,
+                    )
+                except Exception:
+                    self.graphs.pop(key, None)
+                    logger.warning(
+                        "  Failed to capture MOSS-TTS streaming decoder CUDA graph for (B,T)=%s; using eager",
+                        key,
+                        exc_info=True,
+                    )
+        logger.info(
+            "MOSS-TTS streaming decoder CUDA graph warmup complete: %d/%d captured in %.1f ms",
+            len(self.graphs),
+            len(capture_keys),
+            (time.perf_counter() - start_s) * 1000.0,
+        )
+
+    @torch.no_grad()
+    def _capture(self, batch_size: int, frame_size: int, device: torch.device) -> bool:
+        if self._compiled_decode is not None:
+            try:
+                self._capture_with_decode(
+                    batch_size,
+                    frame_size,
+                    device,
+                    self._compiled_decode,
+                )
+                return True
+            except Exception:
+                logger.warning(
+                    "vLLM compile/capture failed for MOSS-TTS (B,T)=(%d,%d); falling back to a plain CUDA Graph",
+                    batch_size,
+                    frame_size,
+                    exc_info=True,
+                )
+                scratch_slots = self.state_capacity + torch.arange(
+                    batch_size,
+                    dtype=torch.long,
+                    device=device,
+                )
+                self.codec.reset_decoder_state_slots(scratch_slots)
+                self._compiled_decode = None
+        self._capture_with_decode(
+            batch_size,
+            frame_size,
+            device,
+            self.codec.decode_streaming_tensors,
+        )
+        return False
+
+    @torch.no_grad()
+    def _capture_with_decode(
+        self,
+        batch_size: int,
+        frame_size: int,
+        device: torch.device,
+        decode,
+    ) -> None:
+        codes = torch.zeros(
+            self.num_quantizers,
+            batch_size,
+            frame_size,
+            dtype=torch.long,
+            device=device,
+        )
+        lengths = torch.zeros(batch_size, dtype=torch.long, device=device)
+        scratch_slots = self.state_capacity + torch.arange(batch_size, dtype=torch.long, device=device)
+        valid_rows = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+        stream = torch.cuda.Stream()
+        stream.wait_stream(torch.cuda.current_stream())
+        with torch.cuda.stream(stream):
+            for _ in range(3):
+                _ = decode(codes, lengths, scratch_slots, valid_rows)
+        torch.cuda.current_stream().wait_stream(stream)
+        torch.accelerator.synchronize(device)
+        self.codec.reset_decoder_state_slots(scratch_slots)
+
+        if self._pool is None:
+            self._pool = current_platform.get_global_graph_pool()
+        graph = CUDAGraph()
+        with torch.cuda.graph(graph, pool=self._pool, capture_error_mode="thread_local"):
+            audio, audio_lengths = decode(codes, lengths, scratch_slots, valid_rows)
+
+        self.graphs[(batch_size, frame_size)] = _CapturedStreamingDecodeGraph(
+            graph=graph,
+            static_codes=codes,
+            static_lengths=lengths,
+            static_state_slot_ids=scratch_slots,
+            static_valid_rows=valid_rows,
+            static_audio=audio,
+            static_audio_lengths=audio_lengths,
+        )
+
+    def _select_batch_size(self, actual_batch_size: int) -> int | None:
+        return next((size for size in self.batch_sizes if size >= actual_batch_size), None)
+
+    def _select_frame_size(self, actual_frame_size: int, allow_padding: bool) -> int | None:
+        if actual_frame_size in self.frame_sizes:
+            return actual_frame_size
+        if not allow_padding:
+            return None
+        return next((size for size in self.frame_sizes if size >= actual_frame_size), None)
+
+    @torch.no_grad()
+    def decode(
+        self,
+        codes: torch.Tensor,
+        state_slot_ids: torch.Tensor,
+        *,
+        allow_frame_padding: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor, int] | None:
+        if not codes.is_cuda or torch.cuda.is_current_stream_capturing():
+            return None
+        n_vq, actual_batch_size, frame_size = codes.shape
+        if int(n_vq) != self.num_quantizers or state_slot_ids.shape != (actual_batch_size,):
+            return None
+        batch_size = self._select_batch_size(int(actual_batch_size))
+        if batch_size is None:
+            return None
+        graph_frame_size = self._select_frame_size(int(frame_size), allow_frame_padding)
+        if graph_frame_size is None:
+            return None
+        entry = self.graphs.get((batch_size, graph_frame_size))
+        if entry is None:
+            return None
+
+        entry.static_codes.zero_()
+        entry.static_codes[:, :actual_batch_size, :frame_size].copy_(codes, non_blocking=True)
+        entry.static_lengths.zero_()
+        entry.static_lengths[:actual_batch_size].fill_(int(frame_size))
+        entry.static_state_slot_ids.copy_(
+            self.state_capacity + torch.arange(batch_size, dtype=torch.long, device=entry.static_state_slot_ids.device)
+        )
+        entry.static_state_slot_ids[:actual_batch_size].copy_(state_slot_ids, non_blocking=True)
+        entry.static_valid_rows.zero_()
+        entry.static_valid_rows[:actual_batch_size].fill_(True)
+        entry.graph.replay()
+        return entry.static_audio, entry.static_audio_lengths, int(actual_batch_size)
+
+
+__all__ = ["CUDAGraphStreamingDecoderWrapper"]
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
index 60f455240..2a1e9a468 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_codec.py
@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import contextlib
 from collections.abc import Iterable
 from typing import Any
 
@@ -15,6 +14,7 @@ from vllm.config import VllmConfig
 from vllm.logger import init_logger
 from vllm.model_executor.model_loader import DefaultModelLoader
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+from vllm.utils.torch_utils import set_default_torch_dtype
 
 from vllm_omni.model_executor.models.moss_tts.audio_tokenizer import (
     MossAudioTokenizerConfig,
@@ -26,6 +26,9 @@ from vllm_omni.model_executor.models.moss_tts.audio_tokenizer_v2 import (
 from vllm_omni.model_executor.models.moss_tts.configuration_moss_audio_tokenizer_v2 import (
     MossAudioTokenizerConfig as MossAudioTokenizerV2Config,
 )
+from vllm_omni.model_executor.models.moss_tts.cuda_graph_streaming_decoder_wrapper import (
+    CUDAGraphStreamingDecoderWrapper,
+)
 from vllm_omni.model_executor.models.moss_tts.moss_codec_cudagraph import (
     MossTTSCUDAGraphCodecWrapper,
 )
@@ -35,92 +38,166 @@ logger = init_logger(__name__)
 
 
 class _MossCodecStreamSession:
-    """Persistent streaming decode session for vendored MOSS-Audio-Tokenizer-v2."""
+    """Persistent state pool with compact per-step execution batches."""
 
     def __init__(
         self,
         codec: nn.Module,
         *,
-        stream_slots: int,
+        state_capacity: int,
         n_vq: int,
+        vllm_config: VllmConfig,
+        graph_batch_sizes: list[int] | None = None,
+        graph_frame_sizes: list[int] | None = None,
     ) -> None:
         self._codec = codec
-        self._stream_slots = int(stream_slots)
-        self._batch_size = self._stream_slots
+        self._state_capacity = int(state_capacity)
         self._n_vq = int(n_vq)
         self._device = next(codec.parameters()).device
-        self._free_stream_slots = list(range(self._stream_slots))
-        self._exit_stack = contextlib.ExitStack()
+        self._free_stream_slots = list(reversed(range(self._state_capacity)))
+        self._leased_slots: set[int] = set()
         self._closed = False
+        self._cudagraph_wrapper: CUDAGraphStreamingDecoderWrapper | None = None
+        batch_sizes = sorted({int(size) for size in (graph_batch_sizes or []) if 0 < int(size) <= self._state_capacity})
+        frame_sizes = sorted({int(size) for size in (graph_frame_sizes or []) if int(size) > 0})
+        scratch_capacity = max(batch_sizes, default=0) if self._device.type == "cuda" else 0
+        self._total_state_capacity = self._state_capacity + scratch_capacity
+        self._state_slot_ids = torch.arange(
+            self._total_state_capacity,
+            device=self._device,
+            dtype=torch.long,
+        )
+        self._samples_per_frame = int(codec.downsample_rate)
+        initialize_state_pool = getattr(codec, "initialize_decoder_state_pool", None)
+        if not callable(initialize_state_pool):
+            raise RuntimeError("The streaming codec does not implement a decoder state pool.")
         with torch.no_grad():
-            self._exit_stack.enter_context(codec.streaming(self._batch_size))
+            initialize_state_pool(self._state_capacity, scratch_capacity)
+        if batch_sizes and frame_sizes and self._device.type == "cuda":
+            self._cudagraph_wrapper = CUDAGraphStreamingDecoderWrapper(
+                codec,
+                state_capacity=self._state_capacity,
+                batch_sizes=batch_sizes,
+                frame_sizes=frame_sizes,
+                num_quantizers=self._n_vq,
+                vllm_config=vllm_config,
+            )
+            self._cudagraph_wrapper.warmup(self._device)
+            self.reset_slots(list(range(self._state_capacity + scratch_capacity)))
+            if not self._cudagraph_wrapper.is_ready:
+                self._cudagraph_wrapper = None
 
     def acquire(self) -> int | None:
         if not self._free_stream_slots:
             return None
-        return self._free_stream_slots.pop()
+        slot = self._free_stream_slots.pop()
+        self._leased_slots.add(slot)
+        return slot
 
-    def release(self, slot: int) -> None:
+    def release(self, slot: int, *, state_already_reset: bool = False) -> None:
         if self._closed:
             return
-        self.reset_slots([slot])
+        if slot not in self._leased_slots:
+            return
+        if not state_already_reset:
+            self.reset_slots([slot])
+        self._leased_slots.remove(slot)
         self._free_stream_slots.append(slot)
 
+    def _reset_slot_ids(self, slot_ids: torch.Tensor) -> None:
+        reset_streaming_slots = getattr(self._codec, "reset_decoder_state_slots", None)
+        if not callable(reset_streaming_slots):
+            raise RuntimeError("The streaming codec does not implement state-slot reset.")
+        with torch.no_grad():
+            reset_streaming_slots(slot_ids)
+
     def reset_slots(self, slots: list[int]) -> None:
         if not slots:
             return
-        reset_mask = torch.zeros(self._batch_size, dtype=torch.bool, device=self._device)
-        reset_mask[slots] = True
-
-        def _reset(module: nn.Module) -> None:
-            state = getattr(module, "_streaming_state", None)
-            if state is not None:
-                state.reset(reset_mask.to(state.device))
-
-        with torch.no_grad():
-            self._codec.apply(_reset)
+        if min(slots) < 0 or max(slots) >= self._total_state_capacity:
+            raise ValueError(f"Decoder state slots must be in [0, {self._total_state_capacity}), got {slots}")
+        start = slots[0]
+        if slots != list(range(start, start + len(slots))):
+            raise ValueError(f"Decoder state slots must be contiguous, got {slots}")
+        self._reset_slot_ids(self._state_slot_ids[start : start + len(slots)])
 
     def close(self) -> None:
         if self._closed:
             return
+        close_state_pool = getattr(self._codec, "close_decoder_state_pool", None)
         with torch.no_grad():
-            self._exit_stack.close()
+            if callable(close_state_pool):
+                close_state_pool()
         self._closed = True
 
     @torch.no_grad()
-    def step(self, slot_codes: dict[int, torch.Tensor]) -> dict[int, torch.Tensor]:
+    def step(
+        self,
+        slot_codes: dict[int, torch.Tensor],
+        *,
+        terminal_slots: set[int] | None = None,
+    ) -> dict[int, torch.Tensor]:
         if not slot_codes:
             return {}
+        terminal_slots = terminal_slots or set()
+        if not terminal_slots.issubset(slot_codes):
+            raise ValueError("terminal_slots must be a subset of the decode batch slots.")
         step_lengths = {int(codes.shape[1]) for codes in slot_codes.values()}
         if len(step_lengths) != 1:
             raise ValueError(f"MOSS codec streaming step needs uniform T, got {sorted(step_lengths)}")
         (step_t,) = step_lengths
-        codes_step = torch.zeros(
-            self._n_vq,
-            self._batch_size,
-            step_t,
-            dtype=torch.long,
-            device=self._device,
+        slots = list(slot_codes)
+        if any(slot not in self._leased_slots for slot in slots):
+            raise RuntimeError(f"Streaming decode references an unleased state slot: {slots}")
+        codes_step = torch.stack(
+            [slot_codes[slot].to(device=self._device, dtype=torch.long) for slot in slots],
+            dim=1,
         )
-        codes_lengths = torch.zeros(self._batch_size, dtype=torch.long, device=self._device)
-        exec_mask = torch.zeros(self._batch_size, dtype=torch.bool, device=self._device)
-        for slot, codes in slot_codes.items():
-            codes_step[:, slot, :] = codes.to(device=self._device, dtype=torch.long)
-            codes_lengths[slot] = int(codes.shape[1])
-            exec_mask[slot] = True
+        state_slot_ids = torch.tensor(slots, device=self._device, dtype=torch.long)
 
-        self._codec._set_streaming_exec_mask(exec_mask)
-        result = self._codec._decode_frame(codes_step, codes_lengths)
-        if result.audio is None:
-            return {}
-        audio = result.audio.detach().to("cpu", torch.float32)
-        lengths = result.audio_lengths.detach().to("cpu") if result.audio_lengths is not None else None
+        graph_output: tuple[torch.Tensor, torch.Tensor, int] | None = None
+        if self._cudagraph_wrapper is not None:
+            # A terminal tail can safely pad T to a larger graph: decoder
+            # attention is causal, audio_lengths trims the padding, and every
+            # affected state slot is reset immediately after this step.
+            graph_output = self._cudagraph_wrapper.decode(
+                codes_step,
+                state_slot_ids,
+                allow_frame_padding=len(terminal_slots) == len(slots),
+            )
+
+        used_cudagraph = graph_output is not None
+        if used_cudagraph:
+            audio_tensor, _, actual_batch_size = graph_output
+            audio_tensor = audio_tensor[:actual_batch_size]
+        else:
+            codes_lengths = torch.full(
+                (len(slots),),
+                step_t,
+                dtype=torch.long,
+                device=self._device,
+            )
+            valid_rows = torch.ones(len(slots), dtype=torch.bool, device=self._device)
+            result = self._codec.decode_streaming_batch(
+                codes_step,
+                codes_lengths,
+                state_slot_ids,
+                valid_rows,
+            )
+            if result.audio is None:
+                return {}
+            audio_tensor = result.audio
+
+        if terminal_slots:
+            terminal_rows = [row for row, slot in enumerate(slots) if slot in terminal_slots]
+            terminal_slot_ids = state_slot_ids if len(terminal_rows) == len(slots) else state_slot_ids[terminal_rows]
+            self._reset_slot_ids(terminal_slot_ids)
+
+        audio = audio_tensor.detach().to("cpu", torch.float32)
+        audio_length = step_t * self._samples_per_frame
         out: dict[int, torch.Tensor] = {}
-        for slot in slot_codes:
-            wav = audio[slot]
-            if lengths is not None:
-                wav = wav[..., : int(lengths[slot].item())]
-            out[slot] = wav.contiguous()
+        for row, slot in enumerate(slots):
+            out[slot] = audio[row, ..., :audio_length].contiguous()
         return out
 
 
@@ -173,11 +250,17 @@ class MossTTSCodecDecoder(nn.Module):
         self._n_channels: int = 1
         self._sr_tensor = torch.tensor(self._OUTPUT_SAMPLE_RATE, dtype=torch.int32)
         self._stream_session: _MossCodecStreamSession | None = None
-        self._stream_slots: int = self._connector_int("codec_stream_slots", default=0)
-        self._stream_max_step_frames: int = self._connector_int("codec_max_step_frames", default=100)
+        scheduler_cfg = getattr(self.vllm_config, "scheduler_config", None)
+        self._stream_state_capacity = max(1, int(getattr(scheduler_cfg, "max_num_seqs", 1) or 1))
+        self._initial_stream_chunk_frames: int = self._connector_int("initial_codec_chunk_frames", default=0)
+        self._stream_chunk_frames: int = self._connector_int("codec_chunk_frames", default=0)
+        self._stream_max_step_frames: int = self._stream_chunk_frames or 100
         self._stream_req_slots: dict[str, int] = {}
-        self._stream_pending_codes: dict[str, list[torch.Tensor]] = {}
-        self._stream_starved_reqs: set[str] = set()
+        self._async_chunk = bool(getattr(self.vllm_config.model_config, "async_chunk", False))
+        self._streaming_graph_batch_sizes = self._streaming_graph_batch_sizes_from_compilation_config()
+        self._streaming_graph_frame_sizes = sorted(
+            {frames for frames in (self._initial_stream_chunk_frames, self._stream_chunk_frames) if frames > 0}
+        )
 
     # ------------------------------------------------------------------
     # vLLM-Omni stubs (codec has no AR loop)
@@ -240,14 +323,21 @@ class MossTTSCodecDecoder(nn.Module):
                 },
             )
 
+        if self._async_chunk and runtime_additional_information is None:
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={
+                    "model_outputs": [empty] * num_req,
+                    "sr": [sr_tensor] * num_req,
+                },
+            )
+
         audios: list[torch.Tensor] = [empty] * num_req
         srs: list[torch.Tensor] = [sr_tensor] * num_req
         device = next(self._codec.parameters()).device
         streaming_work: list[tuple[int, str, torch.Tensor, bool]] = []
 
         if input_ids is None or input_ids.numel() == 0:
-            for i, wav in self._finish_empty_streaming_requests(info_list).items():
-                audios[i] = wav.reshape(-1) if wav.ndim == 1 or int(wav.shape[0]) == 1 else wav
             return OmniOutput(
                 text_hidden_states=None,
                 multimodal_outputs={"model_outputs": audios, "sr": srs},
@@ -263,11 +353,15 @@ class MossTTSCodecDecoder(nn.Module):
                 "MossTTS codec requires seq_token_counts; otherwise concatenated "
                 "codec tokens cannot be split per request."
             )
-        if sum(token_counts) != int(ids_flat.shape[0]):
+        real_token_count = sum(token_counts)
+        input_token_count = int(ids_flat.shape[0])
+        if real_token_count > input_token_count:
             raise RuntimeError(
                 "MossTTS codec seq_token_counts mismatch: "
-                f"counts={token_counts}, sum={sum(token_counts)}, input_tokens={int(ids_flat.shape[0])}."
+                f"counts={token_counts}, sum={real_token_count}, input_tokens={input_token_count}."
             )
+        if real_token_count < input_token_count:
+            ids_flat = ids_flat[:real_token_count]
 
         num_req = len(token_counts)
         if len(info_list) < num_req:
@@ -293,12 +387,7 @@ class MossTTSCodecDecoder(nn.Module):
                 continue
             meta = (info.get("meta", {}) if isinstance(info, dict) else {}) or {}
             finished = bool(meta.get("stream_finished", meta.get("finished", False)))
-            streaming_enabled = bool(meta.get("codec_streaming", False))
-            code_flat_numel = meta.get("code_flat_numel")
-            if streaming_enabled and finished and code_flat_numel is not None and int(code_flat_numel) == 0:
-                for _, wav in self._finish_empty_streaming_requests([info]).items():
-                    audios[i] = wav.reshape(-1) if wav.ndim == 1 or int(wav.shape[0]) == 1 else wav
-                continue
+            streaming_enabled = self._async_chunk
             if seg.numel() % self._n_vq != 0:
                 logger.warning(
                     "MossTTS codec input length %d not divisible by n_vq %d; skipping.",
@@ -366,40 +455,6 @@ class MossTTSCodecDecoder(nn.Module):
             multimodal_outputs={"model_outputs": audios, "sr": srs},
         )
 
-    def _finish_empty_streaming_requests(self, info_list: list[dict[str, Any]]) -> dict[int, torch.Tensor]:
-        """Release codec stream state for empty finish sentinels.
-
-        Stage-0 can finish on a step that emits no new audio frame. The stage
-        input processor forwards that as an empty payload with finished=true.
-        If a request never acquired a stream slot, do not offline-decode its
-        buffered codes here: streaming requests must only emit client deltas.
-        """
-        session = self._stream_session
-        outputs: dict[int, torch.Tensor] = {}
-        if session is None:
-            return outputs
-        for i, info in enumerate(info_list):
-            if not isinstance(info, dict):
-                continue
-            meta = (info.get("meta", {}) or {}) if isinstance(info.get("meta", {}), dict) else {}
-            if not bool(meta.get("codec_streaming", False)):
-                continue
-            finished = bool(meta.get("stream_finished", meta.get("finished", False)))
-            if not finished:
-                continue
-            req_key = self._runtime_request_key(info, meta, i)
-            slot = self._stream_req_slots.get(req_key)
-            pending = req_key in self._stream_pending_codes
-            if slot is not None or pending:
-                if pending and slot is None:
-                    logger.warning(
-                        "MOSS codec stream request %s finished before a codec stream slot became available; "
-                        "dropping buffered codes instead of offline-decoding a non-delta waveform.",
-                        req_key,
-                    )
-                self._finish_stream_request(req_key, session, slot)
-        return outputs
-
     @staticmethod
     def _normalize_seq_token_counts(value: Any) -> list[int] | None:
         if value is None:
@@ -438,14 +493,13 @@ class MossTTSCodecDecoder(nn.Module):
             return None
         if self._stream_session is not None:
             return self._stream_session
-        slots = self._stream_slots
-        if slots <= 0:
-            scheduler_cfg = getattr(self.vllm_config, "scheduler_config", None)
-            slots = int(getattr(scheduler_cfg, "max_num_seqs", 1) or 1)
         self._stream_session = _MossCodecStreamSession(
             self._codec,
-            stream_slots=max(1, slots),
+            state_capacity=self._stream_state_capacity,
             n_vq=self._n_vq,
+            vllm_config=self.vllm_config,
+            graph_batch_sizes=self._streaming_graph_batch_sizes,
+            graph_frame_sizes=self._streaming_graph_frame_sizes,
         )
         return self._stream_session
 
@@ -462,44 +516,32 @@ class MossTTSCodecDecoder(nn.Module):
         max_step_frames = max(1, int(self._stream_max_step_frames))
 
         for output_index, request_id, codes_nq_t, finished in items:
-            pending = self._stream_pending_codes.get(request_id)
             slot = self._stream_req_slots.get(request_id)
             if slot is None:
                 slot = session.acquire()
                 if slot is None:
-                    self._append_stream_pending(request_id, codes_nq_t)
-                    if request_id not in self._stream_starved_reqs:
-                        logger.warning(
-                            "MOSS codec streaming slots exhausted; buffering %s until a stream slot is available.",
-                            request_id,
-                        )
-                        self._stream_starved_reqs.add(request_id)
-                    if finished:
-                        logger.warning(
-                            "MOSS codec stream request %s finished before a codec stream slot became available; "
-                            "dropping buffered codes instead of offline-decoding a non-delta waveform.",
-                            request_id,
-                        )
-                        self._finish_stream_request(request_id, session, None)
-                    continue
+                    raise RuntimeError(
+                        "MOSS codec state capacity exhausted. Stage-1 admission must count idle live streams "
+                        f"against max_num_seqs={self._stream_state_capacity}; refusing to drop audio codes."
+                    )
                 self._stream_req_slots[request_id] = slot
 
-            if pending:
-                self._append_stream_pending(request_id, codes_nq_t)
-                replay_codes = self._pop_stream_pending(request_id)
-                wav = self._decode_stream_slot_sequence(session, slot, replay_codes)
-                if wav is not None:
-                    outputs[output_index] = wav
-                if finished:
-                    self._finish_stream_request(request_id, session, slot)
-                continue
-
             if int(codes_nq_t.shape[1]) > max_step_frames:
-                wav = self._decode_stream_slot_sequence(session, slot, codes_nq_t)
+                wav = self._decode_stream_slot_sequence(
+                    session,
+                    slot,
+                    codes_nq_t,
+                    terminal=finished,
+                )
                 if wav is not None:
                     outputs[output_index] = wav
                 if finished:
-                    self._finish_stream_request(request_id, session, slot)
+                    self._finish_stream_request(
+                        request_id,
+                        session,
+                        slot,
+                        state_already_reset=True,
+                    )
                 continue
 
             grouped.setdefault(int(codes_nq_t.shape[1]), []).append(
@@ -508,32 +550,29 @@ class MossTTSCodecDecoder(nn.Module):
 
         for group in grouped.values():
             plan = {slot: codes_nq_t for _, _, slot, codes_nq_t, _ in group}
-            decoded = session.step(plan)
+            terminal_slots = {slot for _, _, slot, _, finished in group if finished}
+            decoded = session.step(plan, terminal_slots=terminal_slots)
             for output_index, request_id, slot, _, finished in group:
                 wav = decoded.get(slot)
                 if wav is not None:
                     outputs[output_index] = wav
                 if finished:
-                    self._finish_stream_request(request_id, session, slot)
+                    self._finish_stream_request(
+                        request_id,
+                        session,
+                        slot,
+                        state_already_reset=True,
+                    )
 
         return outputs
 
-    def _append_stream_pending(self, request_id: str, codes_nq_t: torch.Tensor) -> None:
-        self._stream_pending_codes.setdefault(request_id, []).append(
-            codes_nq_t.detach().to("cpu", torch.long).contiguous()
-        )
-
-    def _pop_stream_pending(self, request_id: str) -> torch.Tensor:
-        pending = self._stream_pending_codes.pop(request_id, [])
-        if not pending:
-            return torch.empty((self._n_vq, 0), dtype=torch.long)
-        return torch.cat(pending, dim=1).contiguous()
-
     def _decode_stream_slot_sequence(
         self,
         session: _MossCodecStreamSession,
         slot: int,
         codes_nq_t: torch.Tensor,
+        *,
+        terminal: bool = False,
     ) -> torch.Tensor | None:
         if codes_nq_t.numel() == 0:
             return None
@@ -541,7 +580,11 @@ class MossTTSCodecDecoder(nn.Module):
         parts: list[torch.Tensor] = []
         for start in range(0, int(codes_nq_t.shape[1]), max_step_frames):
             chunk = codes_nq_t[:, start : start + max_step_frames]
-            decoded = session.step({slot: chunk})
+            is_terminal_chunk = terminal and start + max_step_frames >= int(codes_nq_t.shape[1])
+            decoded = session.step(
+                {slot: chunk},
+                terminal_slots={slot} if is_terminal_chunk else None,
+            )
             wav = decoded.get(slot)
             if wav is not None:
                 parts.append(wav)
@@ -554,12 +597,12 @@ class MossTTSCodecDecoder(nn.Module):
         request_id: str,
         session: _MossCodecStreamSession,
         slot: int | None,
+        *,
+        state_already_reset: bool = False,
     ) -> None:
         if slot is not None:
-            session.release(slot)
+            session.release(slot, state_already_reset=state_already_reset)
         self._stream_req_slots.pop(request_id, None)
-        self._stream_pending_codes.pop(request_id, None)
-        self._stream_starved_reqs.discard(request_id)
 
     def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
         """Release codec streaming slots when requests finish outside payload flow.
@@ -574,17 +617,12 @@ class MossTTSCodecDecoder(nn.Module):
         for req_id in finished_req_ids:
             request_id = str(req_id)
             slot = self._stream_req_slots.get(request_id)
-            has_state = (
-                slot is not None or request_id in self._stream_pending_codes or request_id in self._stream_starved_reqs
-            )
-            if not has_state:
+            if slot is None:
                 continue
             if session is not None:
                 self._finish_stream_request(request_id, session, slot)
             else:
                 self._stream_req_slots.pop(request_id, None)
-                self._stream_pending_codes.pop(request_id, None)
-                self._stream_starved_reqs.discard(request_id)
 
     def _connector_int(self, name: str, default: int = 0) -> int:
         model_cfg = getattr(self.vllm_config, "model_config", None)
@@ -597,6 +635,15 @@ class MossTTSCodecDecoder(nn.Module):
             return int(extra_cfg[name])
         return default
 
+    def _streaming_graph_batch_sizes_from_compilation_config(self) -> list[int]:
+        if getattr(self.vllm_config.model_config, "enforce_eager", True):
+            return []
+        compilation_config = getattr(self.vllm_config, "compilation_config", None)
+        capture_sizes = getattr(compilation_config, "cudagraph_capture_sizes", None)
+        if capture_sizes:
+            return sorted({int(size) for size in capture_sizes if 0 < int(size) <= self._stream_state_capacity})
+        return []
+
     # ------------------------------------------------------------------
     # Weight loading
     # ------------------------------------------------------------------
@@ -614,9 +661,17 @@ class MossTTSCodecDecoder(nn.Module):
             pass
 
         codec_path = self._codec_path
-        logger.info("Loading MOSS Audio Tokenizer from %s", codec_path)
+        device = self.vllm_config.device_config.device
+        logger.info("Loading MOSS Audio Tokenizer from %s directly on %s", codec_path, device)
 
-        codec_cfg, codec = self._build_codec(codec_path)
+        # This codec comes from a secondary checkpoint, so it cannot be built
+        # by the outer stage's normal initialize_model() call. Re-enter the
+        # same target-device/default-dtype contexts used by vLLM's
+        # BaseModelLoader.load_model() instead of constructing an 8 GiB FP32
+        # model on CPU and copying the whole module to the GPU afterwards.
+        with set_default_torch_dtype(torch.float32):
+            with device:
+                codec_cfg, codec = self._build_codec(codec_path)
 
         model_loader = DefaultModelLoader(self.vllm_config.load_config)
         source = DefaultModelLoader.Source(
@@ -694,9 +749,20 @@ class MossTTSCodecDecoder(nn.Module):
             skipped[:3] if skipped else "none",
         )
 
-        device = self.vllm_config.device_config.device
-        codec.to(device=device, dtype=torch.float32)
         codec.eval()
+        if device.type != "cpu":
+            codec.decoder.to(dtype=torch.bfloat16)
+        build_decode_lut = getattr(codec.quantizer, "build_decode_lut", None)
+        if callable(build_decode_lut):
+            lut_dtype = torch.bfloat16 if device.type == "cuda" else torch.float32
+            build_decode_lut(self._n_vq, dtype=lut_dtype)
+            lut = codec.quantizer._decode_lut
+            logger.info(
+                "MOSS Audio Tokenizer LFQ decoded LUT: shape=%s dtype=%s size=%.1f MiB",
+                tuple(lut.shape),
+                lut.dtype,
+                lut.numel() * lut.element_size() / (1024**2),
+            )
         self._codec = codec
         inferred_channels = 2 if "v2" in codec_path.lower() else 1
         self._n_channels = int(
@@ -716,7 +782,9 @@ class MossTTSCodecDecoder(nn.Module):
             self._n_channels,
         )
 
-        self._maybe_enable_decoder_cudagraph(device)
+        self._configure_decoder_cudagraph(device)
+        if self._async_chunk and self._streaming_graph_batch_sizes and self._streaming_graph_frame_sizes:
+            self._ensure_stream_session()
 
         # vLLM's track_weights_loading() compares the returned set against
         # ``self.named_parameters()``. After ``self._codec = codec`` above,
@@ -725,26 +793,50 @@ class MossTTSCodecDecoder(nn.Module):
         return {f"_codec.{name}" for name, _ in codec.named_parameters()}
 
     def _build_codec(self, codec_path: str) -> tuple[Any, nn.Module]:
-        try:
-            codec_cfg = MossAudioTokenizerV2Config.from_pretrained(codec_path)
-            codec = MossAudioTokenizerV2Model(codec_cfg)
-            logger.info("Using vendored MOSS Audio Tokenizer v2 classes from %s", codec_path)
-            return codec_cfg, codec
-        except Exception:
-            logger.exception(
-                "Failed to instantiate vendored MOSS Audio Tokenizer v2; falling back to legacy vendored codec."
-            )
+        config_dict, _ = MossAudioTokenizerV2Config.get_config_dict(codec_path)
+        is_v2 = config_dict.get("number_channels", 1) >= 2
+
+        if is_v2:
+            try:
+                codec_cfg = MossAudioTokenizerV2Config.from_pretrained(codec_path)
+                codec = MossAudioTokenizerV2Model(codec_cfg)
+                logger.info("Using vendored MOSS Audio Tokenizer v2 classes from %s", codec_path)
+                return codec_cfg, codec
+            except Exception:
+                logger.exception(
+                    "Failed to instantiate vendored MOSS Audio Tokenizer v2; falling back to legacy vendored codec."
+                )
 
         codec_cfg = MossAudioTokenizerConfig.from_pretrained(codec_path)
         codec = MossAudioTokenizerModel(codec_cfg)
+        logger.info("Using vendored MOSS Audio Tokenizer v1 classes from %s", codec_path)
         return codec_cfg, codec
 
-    def _maybe_enable_decoder_cudagraph(self, device: torch.device) -> None:
-        """Capture CUDA Graphs for the codec decoder if enforce_eager is False."""
+    def _configure_decoder_cudagraph(self, device: torch.device) -> None:
+        """Select the codec CUDA Graph path.
+
+        ``enforce_eager`` is the single graph on/off switch. If graphing is
+        enabled, ``async_chunk`` decides whether decode uses the persistent
+        streaming-state wrapper or the offline full-chunk wrapper.
+        """
         if getattr(self.vllm_config.model_config, "enforce_eager", True):
+            self._streaming_graph_batch_sizes = []
             return
         if self._codec is None:
             return
+        if self._async_chunk:
+            logger.info(
+                "MOSS-TTS codec CUDA Graph selected streaming wrapper: B=%s exact_T=%s",
+                self._streaming_graph_batch_sizes,
+                self._streaming_graph_frame_sizes,
+            )
+            return
+
+        self._enable_non_streaming_decoder_cudagraph(device)
+
+    def _enable_non_streaming_decoder_cudagraph(self, device: torch.device) -> None:
+        if self._codec is None:
+            return
 
         # Read capture sizes from the connector's extra config (same convention
         # as Qwen3-TTS), falling back to a sensible default covering common
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
index e0d871b46..7ee551f29 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_local_depth.py
@@ -22,10 +22,14 @@ from __future__ import annotations
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from vllm.logger import init_logger
 
 from vllm_omni.model_executor.models.moss_tts.modeling_moss_tts_local import (
     _sample_token,
 )
+from vllm_omni.platforms import current_omni_platform
+
+logger = init_logger(__name__)
 
 
 class _MossTTSLocalAttention(nn.Module):
@@ -135,6 +139,7 @@ class MossTTSLocalDepthTransformer(nn.Module):
         rope_base = float(getattr(gpt2_config, "rope_base", 1_000_000.0))
         self.h = nn.ModuleList([_MossTTSLocalBlock(self.hidden_size, n_head, inner_size, rope_base, eps)])
         self.ln_f = nn.LayerNorm(self.hidden_size, eps=eps)
+        self._compiled_forward_prefix = None
 
     def _forward_prefix(self, seq_embeds: torch.Tensor) -> torch.Tensor:
         hidden_states = seq_embeds
@@ -142,6 +147,24 @@ class MossTTSLocalDepthTransformer(nn.Module):
             hidden_states = block(hidden_states)
         return self.ln_f(hidden_states)
 
+    def setup_compile(self) -> None:
+        if self._compiled_forward_prefix is not None:
+            return
+        if not current_omni_platform.supports_torch_inductor():
+            self._compiled_forward_prefix = self._forward_prefix
+            logger.warning_once("MOSS-TTS local depth torch.compile disabled on this platform")
+            return
+        self._compiled_forward_prefix = torch.compile(
+            self._forward_prefix,
+            dynamic=False,
+            options={"epilogue_fusion": False},
+        )
+        logger.info("MOSS-TTS local depth prefix enabled with torch.compile")
+
+    def _run_prefix(self, seq_embeds: torch.Tensor) -> torch.Tensor:
+        forward_prefix = self._compiled_forward_prefix or self._forward_prefix
+        return forward_prefix(seq_embeds)
+
     @torch.no_grad()
     def generate_frame(
         self,
@@ -180,7 +203,7 @@ class MossTTSLocalDepthTransformer(nn.Module):
         embeds = backbone_last_hidden.new_zeros((batch_size, n_vq, self.hidden_size), dtype=dtype)
         embeds[:, 0, :] = backbone_last_hidden.to(dtype)
 
-        hidden = self._forward_prefix(embeds[:, :1, :])
+        hidden = self._run_prefix(embeds[:, :1, :])
         local_hidden = hidden[:, 0, :]
 
         binary_logits = local_text_lm_head(local_hidden).float()
@@ -231,7 +254,7 @@ class MossTTSLocalDepthTransformer(nn.Module):
 
             if channel_index + 1 < n_vq:
                 embeds[:, channel_index + 1, :] = audio_embeddings[channel_index](channel_token).to(dtype)
-                hidden = self._forward_prefix(embeds[:, : channel_index + 2, :])
+                hidden = self._run_prefix(embeds[:, : channel_index + 2, :])
                 local_hidden = hidden[:, channel_index + 1, :]
 
         return should_continue, codes
diff --git a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
index 9758c922e..171e57328 100644
--- a/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
+++ b/vllm_omni/model_executor/models/moss_tts/modeling_moss_tts_talker.py
@@ -1321,7 +1321,14 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         # additive-fusion gathers (avoids an n_vq-iteration Python loop).
         self._stacked_audio_emb_w: torch.Tensor | None = None
         self.mtp_hidden_size = hidden_size
-        self.talker_mtp_accepts_req_infos = True
+        self.talker_mtp_graph_safe = True
+        self.talker_mtp_output_key = ("audio_codes", "current")
+        self.use_async_omni_output = False
+        self.eager_omni_postprocess_before_async_output = True
+        self.omni_pooler_payload_include_hidden = False
+        self.postprocess_uses_multimodal_outputs = False
+        self.postprocess_uses_req_infos = False
+        self._batch_should_continue: torch.Tensor | None = None
 
         self.gpu_resident_buffer_keys: set[tuple[str, str]] = {
             ("audio_codes", "current"),
@@ -1373,6 +1380,38 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         logits = hidden_states.new_full((num_rows, self.text_vocab_size), float("-inf"))
 
         states = self._batch_state or []
+        batch_continue_mask = self._batch_should_continue
+        if isinstance(batch_continue_mask, torch.Tensor) and batch_continue_mask.numel() > 0:
+            should_by_req = batch_continue_mask.reshape(-1)
+            if should_by_req.device != logits.device or should_by_req.dtype != torch.bool:
+                should_by_req = should_by_req.to(device=logits.device, dtype=torch.bool)
+            if int(should_by_req.numel()) == num_rows:
+                should_continue = should_by_req
+            else:
+                row_req_indices: list[int] = []
+                for req_idx, (_state, row_start, row_end) in enumerate(
+                    _iter_state_row_spans(
+                        states,
+                        getattr(self, "_batch_state_spans", None),
+                        num_rows,
+                    )
+                ):
+                    if req_idx >= int(should_by_req.shape[0]):
+                        continue
+                    row_req_indices.extend([req_idx] * max(0, row_end - row_start))
+                if row_req_indices:
+                    req_t = torch.tensor(row_req_indices, device=logits.device, dtype=torch.long)
+                    should_continue = should_by_req.index_select(0, req_t)
+                else:
+                    should_continue = torch.ones((num_rows,), device=logits.device, dtype=torch.bool)
+            if int(should_continue.numel()) != num_rows:
+                should_continue = torch.ones((num_rows,), device=logits.device, dtype=torch.bool)
+            zeros = logits.new_zeros((num_rows,))
+            neg_inf = logits.new_full((num_rows,), float("-inf"))
+            logits[:, self.audio_assistant_slot_token_id] = torch.where(should_continue, zeros, neg_inf)
+            logits[:, self.im_end_token_id] = torch.where(should_continue, neg_inf, zeros)
+            return logits
+
         for state, row_start, row_end in _iter_state_row_spans(
             states,
             getattr(self, "_batch_state_spans", None),
@@ -1441,7 +1480,6 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
 
             ref_codes = (info_dict.get("codes", {}) or {}).get("ref")
             ref_offset = int(info_dict.get("ref_offset", 0))
-            last_ref_row = None
             if isinstance(ref_codes, torch.Tensor) and ref_codes.numel() > 0:
                 if ref_codes.dim() == 1 and ref_codes.numel() % self.n_vq == 0:
                     ref_codes = ref_codes.view(-1, self.n_vq)
@@ -1451,23 +1489,9 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
                     if chunk.numel() > 0 and chunk.shape[0] == span_len:
                         codes = chunk.to(device=device, dtype=torch.long)
                         embeds = embeds + self._audio_embed(codes)
-                        last_ref_row = codes[-1].detach()
-
-            current_codes = (
-                last_ref_row
-                if last_ref_row is not None
-                else torch.full((self.n_vq,), self.audio_pad_token_id, dtype=torch.long, device=device)
-            )
-
-            max_new_frames = info_dict.get("max_new_frames", [-1])[0]
 
             info_update: dict[str, Any] = {
-                "audio_state": {
-                    "is_stopping": False,
-                    "step": 0,
-                    "max_new_frames": max_new_frames,
-                },
-                "audio_codes": {"current": current_codes, "emit": False},
+                "audio_state": {"is_stopping": False},
                 "ref_offset": ref_offset + span_len,
             }
             return input_ids, embeds, info_update
@@ -1483,7 +1507,64 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
             mtp_hidden = last_hidden.to(device=device, dtype=text_embed.dtype).reshape(1, -1)
         else:
             mtp_hidden = torch.zeros((1, self.hidden_size), device=device, dtype=text_embed.dtype)
-        return input_ids, text_embed, {"mtp_inputs": (mtp_hidden, torch.zeros_like(mtp_hidden))}
+        state = info_dict.get("audio_state", {}) or {}
+        active = isinstance(state, dict) and not bool(state.get("is_stopping"))
+        mtp_control = torch.zeros_like(mtp_hidden)
+        mtp_control[:, :1] = 1.0 if active else 0.0
+        return input_ids, text_embed, {"mtp_inputs": (mtp_hidden, mtp_control)}
+
+    def preprocess_decode_batch(
+        self,
+        *,
+        input_ids: torch.Tensor,
+        req_infos: list[dict[str, Any]],
+    ) -> tuple[
+        torch.Tensor,
+        torch.Tensor,
+        torch.Tensor,
+        torch.Tensor,
+        list[dict[str, Any]],
+    ]:
+        """Batch the tensor work from the decode branch of ``preprocess``."""
+        input_ids = input_ids.reshape(-1)
+        batch_size = len(req_infos)
+        if input_ids.numel() != batch_size:
+            raise ValueError(
+                f"MOSS-TTS Local decode preprocess received {input_ids.numel()} token ids for {batch_size} requests"
+            )
+
+        text_embeds = self.model.embed_tokens(input_ids)
+        hidden_rows: list[torch.Tensor] = []
+        active_rows: list[bool] = []
+        for info in req_infos:
+            last_hidden = (info.get("hidden_states", {}) or {}).get("last")
+            if isinstance(last_hidden, torch.Tensor) and last_hidden.numel() > 0:
+                hidden_rows.append(
+                    last_hidden.to(
+                        device=text_embeds.device,
+                        dtype=text_embeds.dtype,
+                    ).reshape(1, -1)
+                )
+            else:
+                hidden_rows.append(text_embeds.new_zeros((1, self.hidden_size)))
+
+            state = info.get("audio_state", {}) or {}
+            active_rows.append(isinstance(state, dict) and not bool(state.get("is_stopping")))
+
+        last_talker_hidden = torch.cat(hidden_rows, dim=0)
+        text_step = torch.zeros_like(last_talker_hidden)
+        text_step[:, 0] = torch.tensor(
+            active_rows,
+            device=text_step.device,
+            dtype=text_step.dtype,
+        )
+        return (
+            input_ids,
+            text_embeds,
+            last_talker_hidden,
+            text_step,
+            [{} for _ in range(batch_size)],
+        )
 
     def postprocess(self, hidden_states: torch.Tensor, **_: Any) -> dict[str, Any]:
         if hidden_states.numel() == 0:
@@ -1502,21 +1583,15 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         top_k: int | None = None,
         top_p: float | None = None,
         generator: torch.Generator | None = None,
-        req_infos: list[dict[str, Any]] | None = None,
         **_: Any,
-    ) -> tuple[torch.Tensor, None]:
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         bsz = int(input_embeds.shape[0])
-        dev = input_embeds.device
-        input_embeds_out = input_embeds.reshape(bsz, -1).clone()
-        req_infos = req_infos or [{} for _ in range(bsz)]
-
-        def write_update(info: dict[str, Any], update: dict[str, Any]) -> None:
-            for key, value in update.items():
-                if isinstance(value, dict):
-                    target = info.setdefault(key, {})
-                    target.update(value)
-                else:
-                    info[key] = value
+        input_embeds_out = input_embeds.reshape(bsz, -1)
+        last_talker_hidden = last_talker_hidden.reshape(bsz, -1).to(
+            device=input_embeds.device,
+            dtype=input_embeds.dtype,
+        )
+        active_mask = text_step.reshape(bsz, -1)[:, :1] > 0
 
         # Match MOSS-TTS Local v1.5's model-card/SGLang defaults. The generic
         # stage SamplingParams are for the backbone token loop and should not
@@ -1526,89 +1601,32 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         audio_top_p = 0.8
         do_sample_val = True if do_sample is None else bool(do_sample)
 
-        for i in range(bsz):
-            info = req_infos[i] if i < len(req_infos) and isinstance(req_infos[i], dict) else {}
-            state = dict(info.get("audio_state", {}) or {})
-            step = int(state.get("step", 0))
-            max_new_frames = int(state.get("max_new_frames", -1))
-            acc = (info.get("audio_codes", {}) or {}).get("accumulated")
+        should_continue_t, new_codes = self.local_transformer.generate_frame(
+            last_talker_hidden,
+            self.audio_lm_heads,
+            self.audio_embeddings,
+            self.local_text_lm_head,
+            n_vq=self.n_vq,
+            do_sample=do_sample_val,
+            temperature=audio_temperature,
+            top_k=audio_top_k,
+            top_p=audio_top_p,
+            repetition_penalty=1.0,
+            history_per_codebook=None,
+            generator=generator,
+        )
+        new_codes = new_codes.to(device=input_embeds.device, dtype=torch.long)
+        emit_mask = active_mask & should_continue_t.reshape(bsz, 1)
+        audio_embed = self._audio_embed(new_codes).to(dtype=input_embeds_out.dtype)
+        input_embeds_out = input_embeds_out + audio_embed * emit_mask.to(dtype=input_embeds_out.dtype)
 
-            if state.get("is_stopping"):
-                write_update(
-                    info,
-                    {
-                        "audio_state": state,
-                        "audio_codes": {
-                            "current": input_embeds.new_empty((0, self.n_vq), dtype=torch.long),
-                            "emit": False,
-                        },
-                    },
-                )
-                continue
-
-            rep_window = 50
-            if isinstance(acc, torch.Tensor) and acc.numel() > 0:
-                tail = acc[-rep_window:].long().cpu().tolist()
-                hist_per_cb = [[row[cb] for row in tail] for cb in range(self.n_vq)]
-            else:
-                hist_per_cb = [[] for _ in range(self.n_vq)]
-
-            should_continue_t, new_codes_b = self.local_transformer.generate_frame(
-                last_talker_hidden[i : i + 1],
-                self.audio_lm_heads,
-                self.audio_embeddings,
-                self.local_text_lm_head,
-                n_vq=self.n_vq,
-                do_sample=do_sample_val,
-                temperature=audio_temperature,
-                top_k=audio_top_k,
-                top_p=audio_top_p,
-                repetition_penalty=1.0,
-                history_per_codebook=hist_per_cb,
-                generator=generator,
-            )
-            should_continue = bool(should_continue_t[0].item())
-            new_codes = new_codes_b.squeeze(0).to(device=dev, dtype=torch.long)
-
-            if not should_continue or (0 <= max_new_frames <= step):
-                state["is_stopping"] = True
-                state["step"] = step + 1
-                write_update(
-                    info,
-                    {
-                        "audio_state": state,
-                        "audio_codes": {
-                            "current": input_embeds.new_empty((0, self.n_vq), dtype=torch.long),
-                            "accumulated": acc,
-                            "emit": False,
-                        },
-                    },
-                )
-                continue
-
-            if isinstance(acc, torch.Tensor) and acc.numel() > 0:
-                updated_acc = torch.cat([acc.to(dev), new_codes.unsqueeze(0)], dim=0)
-            else:
-                updated_acc = new_codes.unsqueeze(0)
-
-            state["step"] = step + 1
-            current = new_codes.unsqueeze(0)
-            input_embeds_out[i : i + 1] = input_embeds_out[i : i + 1] + self._audio_embed(current).to(
-                dtype=input_embeds_out.dtype
-            )
-            write_update(
-                info,
-                {
-                    "audio_state": state,
-                    "audio_codes": {
-                        "current": current,
-                        "accumulated": updated_acc,
-                        "emit": True,
-                    },
-                },
-            )
-
-        return input_embeds_out, None
+        keep = emit_mask.reshape(-1)
+        output_codes = torch.where(
+            keep.unsqueeze(1),
+            new_codes,
+            torch.full_like(new_codes, self.audio_pad_token_id),
+        )
+        return input_embeds_out, output_codes
 
     # ------------------------------------------------------------------
     # Package runner-generated audio frames
@@ -1622,6 +1640,7 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
         if isinstance(model_outputs, OmniOutput):
             self._batch_state = None
             self._batch_state_spans = None
+            self._batch_should_continue = None
             return model_outputs
 
         hidden = model_outputs  # (S, H)
@@ -1631,46 +1650,41 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
 
         for info in info_dicts:
             if isinstance(info, dict) and not isinstance(info.get("audio_state"), dict):
-                info["audio_state"] = {"is_stopping": False, "step": 0, "max_new_frames": -1}
+                info["audio_state"] = {"is_stopping": False}
 
         self._batch_state = [(info["audio_state"] if isinstance(info, dict) else {}) for info in info_dicts]
         self._batch_state_spans = kwargs.get("request_token_spans")
-
+        should_values: list[torch.Tensor] = []
+        have_mtp_output = False
         per_req_codes: list[torch.Tensor] = []
         have_codes = False
         for info in info_dicts:
-            current = (info.get("audio_codes", {}) or {}).get("current") if isinstance(info, dict) else None
-            emit = bool((info.get("audio_codes", {}) or {}).get("emit")) if isinstance(info, dict) else False
-            if emit and isinstance(current, torch.Tensor) and current.numel() > 0:
+            audio_codes = (info.get("audio_codes", {}) or {}) if isinstance(info, dict) else {}
+            current = audio_codes.pop("current", None)
+            if isinstance(current, torch.Tensor) and current.numel() > 0:
                 codes = current.to(device=hidden.device, dtype=torch.long)
                 if codes.dim() == 1:
                     codes = codes.unsqueeze(0)
-                per_req_codes.append(codes)
-                have_codes = True
+                should_continue = codes.ne(self.audio_pad_token_id).any(dim=-1)
+                should_values.append(should_continue.reshape(-1)[:1])
+                have_mtp_output = True
+                emitted_codes = codes[should_continue]
+                per_req_codes.append(emitted_codes)
+                have_codes = have_codes or emitted_codes.numel() > 0
             else:
+                should_values.append(torch.ones((1,), device=hidden.device, dtype=torch.bool))
                 per_req_codes.append(hidden.new_empty((0, self.n_vq), dtype=torch.long))
+        self._batch_should_continue = torch.cat(should_values, dim=0) if have_mtp_output and should_values else None
 
         if not have_codes:
             return OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
 
         # Local-v1.5 emits the current raw code frame (no delay pattern); the
         # pipeline routes those rows through ``talker2codec_raw_async_chunk``.
-        per_req_ref_codes: list[torch.Tensor] = []
-        for info in info_dicts:
-            ref_codes = (info.get("codes", {}) or {}).get("ref") if isinstance(info, dict) else None
-            if isinstance(ref_codes, torch.Tensor) and ref_codes.numel() > 0:
-                ref_codes = ref_codes.detach()
-                if ref_codes.dim() == 1 and ref_codes.numel() % self.n_vq == 0:
-                    ref_codes = ref_codes.view(-1, self.n_vq)
-                if ref_codes.dim() == 2 and ref_codes.shape[1] == self.n_vq:
-                    per_req_ref_codes.append(ref_codes.to(device=hidden.device, dtype=torch.long))
-                    continue
-            per_req_ref_codes.append(hidden.new_empty((0, self.n_vq), dtype=torch.long))
-
         return OmniOutput(
             text_hidden_states=hidden,
             multimodal_outputs={
-                "codes": {"audio": per_req_codes, "ref": per_req_ref_codes},
+                "codes": {"audio": per_req_codes},
             },
         )
 
@@ -1720,6 +1734,9 @@ class MossTTSLocalTalkerForGeneration(nn.Module):
             [e.weight.detach() for e in self.audio_embeddings], dim=0
         )  # (n_vq, audio_vocab_size, hidden_size)
 
+        if not self.vllm_config.model_config.enforce_eager:
+            self.local_transformer.setup_compile()
+
         logger.info(
             "[MossTTSLocal] loaded %d/%d params; skipped=%d (first 5: %s)",
             len(loaded),
diff --git a/vllm_omni/model_executor/models/moss_tts/moss_codec_cudagraph.py b/vllm_omni/model_executor/models/moss_tts/moss_codec_cudagraph.py
index 71585f1c0..ed03c018e 100644
--- a/vllm_omni/model_executor/models/moss_tts/moss_codec_cudagraph.py
+++ b/vllm_omni/model_executor/models/moss_tts/moss_codec_cudagraph.py
@@ -1,6 +1,6 @@
 """CUDA Graph acceleration for the MOSS Audio Tokenizer codec decoder.
 
-Captures the codec decode method (_decode_frame, or _decode on the vendored codec) for a set of fixed frame-count
+Captures MossAudioTokenizerModel._decode for a set of fixed frame-count
 bucket sizes, then replays the captured graph at inference time to eliminate
 kernel-launch overhead.  Inputs that exceed all captured sizes fall back to
 eager execution transparently.
@@ -24,7 +24,7 @@ logger = init_logger(__name__)
 
 
 class MossTTSCUDAGraphCodecWrapper:
-    """CUDA Graph wrapper for the codec decode method (_decode_frame, or _decode on the vendored codec).
+    """CUDA Graph wrapper for MossAudioTokenizerModel._decode.
 
     Graphs are keyed by padded_T (int).  On each call the actual T is
     bucket-matched to the smallest pre-captured size >= T.  The static code
@@ -51,15 +51,6 @@ class MossTTSCUDAGraphCodecWrapper:
         enabled: bool = True,
     ) -> None:
         self.model = model
-        # Upstream remote-code tokenizer exposes _decode_frame; the vendored
-        # MossAudioTokenizerModel still exposes _decode. Resolve once here so
-        # both codec implementations work.
-        decode_fn = getattr(model, "_decode_frame", None) or getattr(model, "_decode", None)
-        if decode_fn is None:
-            raise AttributeError(
-                f"{type(model).__module__}.{type(model).__name__} exposes neither _decode_frame nor _decode"
-            )
-        self._decode_fn = decode_fn
         self.capture_sizes: list[int] = sorted(capture_sizes)
         self.num_quantizers = num_quantizers
         self.enabled = enabled
@@ -108,7 +99,7 @@ class MossTTSCUDAGraphCodecWrapper:
             dummy_codes = torch.zeros(nq, 1, size, dtype=torch.long, device=device)
             dummy_lengths = torch.tensor([size], dtype=torch.long, device=device)
             with torch.no_grad():
-                _ = self._decode_fn(dummy_codes, dummy_lengths)
+                _ = self.model._decode(dummy_codes, dummy_lengths)
 
         torch.accelerator.synchronize(device)
 
@@ -141,13 +132,13 @@ class MossTTSCUDAGraphCodecWrapper:
 
         # Extra eager warmup inside capture to ensure all kernels are compiled.
         with torch.no_grad():
-            _ = self._decode_fn(static_codes, static_lengths)
+            _ = self.model._decode(static_codes, static_lengths)
         torch.accelerator.synchronize(device)
 
         graph = CUDAGraph()
         with torch.no_grad():
             with torch.cuda.graph(graph, pool=current_platform.get_global_graph_pool()):
-                static_out = self._decode_fn(static_codes, static_lengths)
+                static_out = self.model._decode(static_codes, static_lengths)
 
         self.graphs[size] = graph
         self.static_codes[size] = static_codes
diff --git a/vllm_omni/model_executor/models/moss_tts/pipeline.py b/vllm_omni/model_executor/models/moss_tts/pipeline.py
index c6cf5c86c..f499654a4 100644
--- a/vllm_omni/model_executor/models/moss_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/moss_tts/pipeline.py
@@ -22,6 +22,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.moss_tts"
 
 MOSS_TTS_PIPELINE = PipelineConfig(
     model_type="moss_tts",
+    default_deploy_config_name="moss_tts.yaml",
     model_arch="MossTTSDelayModel",  # HF architectures string
     stages=(
         StagePipelineConfig(
@@ -45,6 +46,7 @@ MOSS_TTS_PIPELINE = PipelineConfig(
             final_output_type="audio",
             engine_output_type="audio",
             model_arch="MossTTSCodecDecoder",
+            retains_state_across_chunks=True,
             sync_process_input_func=f"{_PROC}.talker2codec",
             sampling_constraints={"detokenize": True},
         ),
@@ -53,6 +55,7 @@ MOSS_TTS_PIPELINE = PipelineConfig(
 
 MOSS_TTS_REALTIME_PIPELINE = PipelineConfig(
     model_type="moss_tts_realtime",
+    default_deploy_config_name="moss_tts_realtime.yaml",
     model_arch="MossTTSRealtime",  # different talker class from the delay variant
     stages=(
         StagePipelineConfig(
@@ -74,6 +77,7 @@ MOSS_TTS_REALTIME_PIPELINE = PipelineConfig(
             final_output_type="audio",
             engine_output_type="audio",
             model_arch="MossTTSCodecDecoder",
+            retains_state_across_chunks=True,
             sync_process_input_func=f"{_PROC}.talker2codec",
             sampling_constraints={"detokenize": True},
         ),
@@ -82,6 +86,7 @@ MOSS_TTS_REALTIME_PIPELINE = PipelineConfig(
 
 MOSS_TTS_LOCAL_PIPELINE = PipelineConfig(
     model_type="moss_tts_local",
+    default_deploy_config_name="moss_tts_local.yaml",
     model_arch="MossTTSLocalModel",  # different talker class: GPT2-style local depth transformer
     stages=(
         StagePipelineConfig(
@@ -106,6 +111,7 @@ MOSS_TTS_LOCAL_PIPELINE = PipelineConfig(
             final_output_type="audio",
             engine_output_type="audio",
             model_arch="MossTTSCodecDecoder",
+            retains_state_across_chunks=True,
             sync_process_input_func=f"{_PROC}.talker2codec",
             sampling_constraints={"detokenize": True},
         ),
diff --git a/vllm_omni/model_executor/models/moss_tts_nano/pipeline.py b/vllm_omni/model_executor/models/moss_tts_nano/pipeline.py
index 749c4f980..c089ea90e 100644
--- a/vllm_omni/model_executor/models/moss_tts_nano/pipeline.py
+++ b/vllm_omni/model_executor/models/moss_tts_nano/pipeline.py
@@ -18,6 +18,7 @@ from vllm_omni.config.stage_config import (
 
 MOSS_TTS_NANO_PIPELINE = PipelineConfig(
     model_type="moss_tts_nano",
+    default_deploy_config_name="moss_tts_nano.yaml",
     model_arch="MossTTSNanoForCausalLM",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/omnivoice/pipeline.py b/vllm_omni/model_executor/models/omnivoice/pipeline.py
index 88d479459..760d5314f 100644
--- a/vllm_omni/model_executor/models/omnivoice/pipeline.py
+++ b/vllm_omni/model_executor/models/omnivoice/pipeline.py
@@ -14,6 +14,7 @@ from vllm_omni.config.stage_config import (
 
 OMNIVOICE_PIPELINE = PipelineConfig(
     model_type="omnivoice",
+    default_deploy_config_name="omnivoice.yaml",
     model_arch="OmniVoicePipeline",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/personaplex/__init__.py b/vllm_omni/model_executor/models/personaplex/__init__.py
new file mode 100644
index 000000000..b4e3d49cd
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/__init__.py
@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""vllm-omni integration for PersonaPlex (a Moshi finetune, full-duplex S2S).
+
+Offline/batch runs go through a two-stage audio->audio pipeline (talker ->
+code2wav); real-time conversation is served over the duplex WebSocket path.
+"""
+
+from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+    PersonaPlexConfig,
+    PersonaPlexDepformerConfig,
+    PersonaPlexMimiConfig,
+)
+
+__all__ = [
+    "PersonaPlexConfig",
+    "PersonaPlexDepformerConfig",
+    "PersonaPlexMimiConfig",
+]
diff --git a/vllm_omni/model_executor/models/personaplex/configuration_helium.py b/vllm_omni/model_executor/models/personaplex/configuration_helium.py
new file mode 100644
index 000000000..1158637ac
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/configuration_helium.py
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Configuration for the PersonaPlex Helium temporal transformer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from transformers import PretrainedConfig
+
+__all__ = ["HeliumConfig"]
+
+
+class HeliumConfig(PretrainedConfig):
+    """Minimal HF config for the Moshi temporal LM backbone.
+
+    The defaults are measured from the PersonaPlex checkpoint rather than inferred
+    from Moshi's higher-level kwargs.
+    """
+
+    model_type = "helium"
+    keys_to_ignore_at_inference = ("past_key_values",)
+
+    def __init__(
+        self,
+        hidden_size: int = 4096,
+        num_hidden_layers: int = 32,
+        num_attention_heads: int = 32,
+        head_dim: int = 128,
+        num_key_value_heads: int = 32,
+        intermediate_size: int = 11264,
+        max_position_embeddings: int = 3000,
+        rope_theta: float = 10000.0,
+        rms_norm_eps: float = 1e-8,
+        vocab_size: int = 32000,
+        sliding_window: int = 3000,
+        hidden_act: str = "silu",
+        attention_bias: bool = False,
+        mlp_bias: bool = False,
+        tie_word_embeddings: bool = False,
+        use_cache: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.head_dim = head_dim
+        self.num_key_value_heads = num_key_value_heads
+        self.intermediate_size = intermediate_size
+        self.max_position_embeddings = max_position_embeddings
+        self.rope_theta = rope_theta
+        self.rms_norm_eps = rms_norm_eps
+        self.vocab_size = vocab_size
+        self.sliding_window = sliding_window
+        self.hidden_act = hidden_act
+        self.attention_bias = attention_bias
+        self.mlp_bias = mlp_bias
+        self.use_cache = use_cache
diff --git a/vllm_omni/model_executor/models/personaplex/configuration_personaplex.py b/vllm_omni/model_executor/models/personaplex/configuration_personaplex.py
new file mode 100644
index 000000000..e43e12168
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/configuration_personaplex.py
@@ -0,0 +1,278 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Configuration for PersonaPlex (a Moshi finetune; 2-stage audio->audio pipeline).
+
+PersonaPlex is a staged AR speech model composed of:
+
+* a *temporal transformer* (a Llama-variant Helium backbone) that predicts, per
+  frame, the next text token and the codebook-0 audio token;
+* a *depformer* (a small per-step transformer) that, conditioned on the temporal
+  hidden state, predicts the remaining audio codebooks;
+* the Mimi neural audio codec, which turns the audio codebooks into 24 kHz PCM.
+
+The temporal-transformer hyperparameters live in
+:class:`~vllm_omni.model_executor.models.personaplex.configuration_helium.HeliumConfig`
+(already used by the talker the lead is building). This module reuses it as the
+``temporal_config`` sub-config so the config tree carries a single source of
+truth, and adds two further sub-configs (``depformer_config`` and
+``mimi_config``).
+
+All defaults are *measured* from the PersonaPlex checkpoint, whose own
+``config.json`` is empty; do not treat the Moshi higher-level kwargs as
+authoritative.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+from vllm_omni.model_executor.models.personaplex.configuration_helium import (
+    HeliumConfig,
+)
+
+logger = logging.get_logger(__name__)
+
+__all__ = [
+    "PersonaPlexConfig",
+    "PersonaPlexDepformerConfig",
+    "PersonaPlexMimiConfig",
+    "HeliumConfig",
+]
+
+
+class PersonaPlexDepformerConfig(PretrainedConfig):
+    r"""Configuration for the PersonaPlex depformer (per-step code predictor).
+
+    The depformer is a small autoregressive transformer that runs ``dep_q``
+    inner steps per temporal frame, conditioned on the temporal hidden state,
+    to predict the audio codebooks. Only the first ``num_active_codebooks``
+    codebooks (``cb 0..7``) are decoded to PCM by Mimi; the remaining codebooks
+    up to ``dep_q`` are predicted but not vocoded.
+
+    Args:
+        hidden_size (`int`, *optional*, defaults to 1024):
+            Dimension of the depformer hidden representations.
+        num_hidden_layers (`int`, *optional*, defaults to 6):
+            Number of depformer transformer layers.
+        num_attention_heads (`int`, *optional*, defaults to 16):
+            Number of attention heads per depformer layer.
+        head_dim (`int`, *optional*, defaults to 64):
+            Per-head attention dimension (``hidden_size // num_attention_heads``).
+        max_position_embeddings (`int`, *optional*, defaults to 8):
+            The depformer context length (``ctx``): one position per inner step.
+        dep_q (`int`, *optional*, defaults to 16):
+            Number of audio codebooks the depformer predicts per frame.
+        num_active_codebooks (`int`, *optional*, defaults to 8):
+            Number of leading codebooks actually decoded to PCM by Mimi.
+        card (`int`, *optional*, defaults to 2048):
+            Per-codebook cardinality (audio vocab size).
+        rope_theta (`float`, *optional*, defaults to 10000.0):
+            The base period of the RoPE embeddings.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-8):
+            The epsilon used by the fp32 RMS normalization layers.
+        hidden_act (`str`, *optional*, defaults to `"silu"`):
+            SwiGLU gate activation.
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether attention projections carry a bias.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether the MLP projections carry a bias.
+    """
+
+    model_type = "personaplex_depformer"
+    keys_to_ignore_at_inference = ("past_key_values",)
+
+    def __init__(
+        self,
+        hidden_size: int = 1024,
+        num_hidden_layers: int = 6,
+        num_attention_heads: int = 16,
+        head_dim: int = 64,
+        num_key_value_heads: int = 16,
+        intermediate_size: int = 2816,
+        max_position_embeddings: int = 8,
+        dep_q: int = 16,
+        num_active_codebooks: int = 8,
+        card: int = 2048,
+        rope_theta: float = 10000.0,
+        rms_norm_eps: float = 1e-8,
+        hidden_act: str = "silu",
+        attention_bias: bool = False,
+        mlp_bias: bool = False,
+        tie_word_embeddings: bool = False,
+        use_cache: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.head_dim = head_dim
+        self.num_key_value_heads = num_key_value_heads
+        self.intermediate_size = intermediate_size
+        self.max_position_embeddings = max_position_embeddings
+        self.dep_q = dep_q
+        self.num_active_codebooks = num_active_codebooks
+        self.card = card
+        self.rope_theta = rope_theta
+        self.rms_norm_eps = rms_norm_eps
+        self.hidden_act = hidden_act
+        self.attention_bias = attention_bias
+        self.mlp_bias = mlp_bias
+        self.use_cache = use_cache
+
+
+class PersonaPlexMimiConfig(PretrainedConfig):
+    r"""Configuration for the Mimi neural audio codec used by PersonaPlex.
+
+    The Mimi weights and module live in the external ``moshi`` package; this
+    config only carries the scalars the vllm-omni serving layer needs to size
+    buffers and compute audio durations. The actual decoder is instantiated by
+    :class:`PersonaPlexCode2Wav` via ``moshi.models.loaders.get_mimi``.
+
+    Args:
+        sample_rate (`int`, *optional*, defaults to 24000):
+            Output PCM sample rate in Hz.
+        frame_rate (`float`, *optional*, defaults to 12.5):
+            Mimi codec frame rate in Hz (one frame every 80 ms).
+        samples_per_frame (`int`, *optional*, defaults to 1920):
+            PCM samples produced per codec frame (``sample_rate / frame_rate``).
+        num_codebooks (`int`, *optional*, defaults to 8):
+            Number of active audio codebooks decoded to PCM (``cb 0..7``).
+        card (`int`, *optional*, defaults to 2048):
+            Per-codebook cardinality.
+        num_channels (`int`, *optional*, defaults to 1):
+            Number of output audio channels (mono).
+        mimi_name (`str`, *optional*):
+            Filename of the Mimi weight checkpoint inside the model repo. When
+            ``None``, :class:`PersonaPlexCode2Wav` falls back to
+            ``moshi.models.loaders.MIMI_NAME``.
+    """
+
+    model_type = "personaplex_mimi"
+
+    def __init__(
+        self,
+        sample_rate: int = 24000,
+        frame_rate: float = 12.5,
+        samples_per_frame: int = 1920,
+        num_codebooks: int = 8,
+        card: int = 2048,
+        num_channels: int = 1,
+        mimi_name: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.sample_rate = sample_rate
+        self.frame_rate = frame_rate
+        self.samples_per_frame = samples_per_frame
+        self.num_codebooks = num_codebooks
+        self.card = card
+        self.num_channels = num_channels
+        self.mimi_name = mimi_name
+
+
+class PersonaPlexConfig(PretrainedConfig):
+    r"""Top-level configuration for ``PersonaPlexTalkerForConditionalGeneration``.
+
+    Mirrors the Qwen3-TTS config layout: a top-level config holding sub-configs
+    for each component. The temporal transformer config is the *text config*
+    that vLLM consumes (it exposes ``hidden_size`` / ``num_attention_heads`` and
+    drives the talker's vLLM Llama backbone).
+
+    Args:
+        temporal_config (`dict` or `HeliumConfig`, *optional*):
+            The temporal-transformer (Helium) backbone config.
+        depformer_config (`dict` or `PersonaPlexDepformerConfig`, *optional*):
+            The depformer (per-step code predictor) config.
+        mimi_config (`dict` or `PersonaPlexMimiConfig`, *optional*):
+            The Mimi codec config.
+        text_vocab_size (`int`, *optional*, defaults to 32000):
+            Text / ``lm_head`` vocabulary size.
+        text_embedding_rows (`int`, *optional*, defaults to 32001):
+            Number of rows in the text embedding table (one extra padding row).
+        audio_vocab_size (`int`, *optional*, defaults to 2048):
+            Per-codebook audio cardinality (``card``).
+        num_audio_codebooks (`int`, *optional*, defaults to 16):
+            Total number of audio codebooks (``n_q``).
+        mimi_name (`str`, *optional*):
+            Convenience mirror of ``mimi_config.mimi_name``; if set, it
+            overrides the value carried inside ``mimi_config``.
+    """
+
+    model_type = "personaplex"
+    sub_configs = {
+        "temporal_config": HeliumConfig,
+        "depformer_config": PersonaPlexDepformerConfig,
+        "mimi_config": PersonaPlexMimiConfig,
+    }
+
+    def __init__(
+        self,
+        temporal_config: dict | HeliumConfig | None = None,
+        depformer_config: dict | PersonaPlexDepformerConfig | None = None,
+        mimi_config: dict | PersonaPlexMimiConfig | None = None,
+        text_vocab_size: int = 32000,
+        text_embedding_rows: int = 32001,
+        audio_vocab_size: int = 2048,
+        num_audio_codebooks: int = 16,
+        mimi_name: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if temporal_config is None:
+            temporal_config = {}
+            logger.info("temporal_config is None. Initializing Helium backbone with default values")
+        if depformer_config is None:
+            depformer_config = {}
+            logger.info("depformer_config is None. Initializing depformer with default values")
+        if mimi_config is None:
+            mimi_config = {}
+            logger.info("mimi_config is None. Initializing Mimi codec config with default values")
+
+        self.temporal_config = self._coerce(temporal_config, HeliumConfig)
+        self.depformer_config = self._coerce(depformer_config, PersonaPlexDepformerConfig)
+        self.mimi_config = self._coerce(mimi_config, PersonaPlexMimiConfig)
+
+        super().__init__(**kwargs)
+
+        # The PersonaPlex checkpoint's config.json is empty (no ``architectures``);
+        # supply the primary (stage-0 talker) arch so vLLM's ModelConfig resolves a
+        # generate-capable model. The code2wav stage arch comes from the pipeline.
+        if not getattr(self, "architectures", None):
+            self.architectures = ["PersonaPlexTalkerForConditionalGeneration"]
+
+        self.text_vocab_size = text_vocab_size
+        self.text_embedding_rows = text_embedding_rows
+        self.audio_vocab_size = audio_vocab_size
+        self.num_audio_codebooks = num_audio_codebooks
+
+        # ``mimi_name`` is allowed both at the top level (convenient for
+        # hf_overrides / a flat config.json) and inside ``mimi_config``. Keep
+        # them in sync, preferring an explicit top-level value.
+        if mimi_name is not None:
+            self.mimi_config.mimi_name = mimi_name
+        self.mimi_name = self.mimi_config.mimi_name
+
+    @staticmethod
+    def _coerce(value: Any, config_cls: type[PretrainedConfig]) -> PretrainedConfig:
+        if isinstance(value, config_cls):
+            return value
+        if isinstance(value, dict):
+            return config_cls(**value)
+        raise TypeError(f"Expected dict or {config_cls.__name__}, got {type(value).__name__}")
+
+    @property
+    def sample_rate(self) -> int:
+        """Output PCM sample rate in Hz (delegates to the Mimi config)."""
+        return int(self.mimi_config.sample_rate)
+
+    def get_text_config(self, **kwargs: Any) -> PretrainedConfig:
+        # vLLM expects the text config to expose hidden_size / num_attention_heads.
+        # For PersonaPlex the temporal-transformer (Helium) config is the text
+        # model config that drives the talker's vLLM Llama backbone.
+        return self.temporal_config
diff --git a/vllm_omni/model_executor/models/personaplex/modeling_helium.py b/vllm_omni/model_executor/models/personaplex/modeling_helium.py
new file mode 100644
index 000000000..e4ac8d885
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/modeling_helium.py
@@ -0,0 +1,548 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""vLLM-native PersonaPlex Helium temporal transformer.
+
+The module maps the Moshi temporal LM backbone onto vLLM's Llama-style decoder
+components. It intentionally does not include Moshi's text/audio input
+embeddings or depformer; PersonaPlex feeds temporal `inputs_embeds` directly.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from itertools import islice
+
+import torch
+from torch import nn
+from vllm.compilation.decorators import support_torch_compile
+from vllm.config import CacheConfig, VllmConfig
+from vllm.distributed import get_pp_group, get_tensor_model_parallel_world_size
+from vllm.model_executor.layers.activation import SiluAndMul
+from vllm.model_executor.layers.attention import Attention
+from vllm.model_executor.layers.layernorm import RMSNorm
+from vllm.model_executor.layers.linear import (
+    MergedColumnParallelLinear,
+    QKVParallelLinear,
+    RowParallelLinear,
+)
+from vllm.model_executor.layers.logits_processor import LogitsProcessor
+from vllm.model_executor.layers.quantization import QuantizationConfig
+from vllm.model_executor.layers.rotary_embedding import get_rope
+from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+from vllm.model_executor.models.interfaces import SupportsLoRA, SupportsPP
+from vllm.model_executor.models.utils import (
+    PPMissingLayer,
+    is_pp_missing_parameter,
+    make_empty_intermediate_tensors_factory,
+    make_layers,
+    maybe_prefix,
+)
+from vllm.sequence import IntermediateTensors
+from vllm.v1.attention.backend import AttentionType
+
+from vllm_omni.model_executor.models.personaplex.configuration_helium import (
+    HeliumConfig,
+)
+
+__all__ = ["HeliumForCausalLM", "HeliumModel"]
+
+
+class HeliumRMSNorm(RMSNorm):
+    """Moshi-compatible RMSNorm.
+
+    Moshi stores the parameter as `alpha` with shape `[1, 1, hidden]` and
+    computes variance and the alpha multiply in fp32 before casting back to the
+    input dtype. vLLM's parameter is named `weight`; the loader squeezes alpha.
+    """
+
+    def _forward_f32(self, x: torch.Tensor) -> torch.Tensor:
+        output_dtype = x.dtype
+        x_f32 = x.float()
+        variance = x_f32.pow(2).mean(dim=-1, keepdim=True)
+        x_f32 = x_f32 * torch.rsqrt(variance + self.variance_epsilon)
+        if self.has_weight:
+            x_f32 = x_f32 * self.weight.float()
+        return x_f32.to(output_dtype)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        residual: torch.Tensor | None = None,
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        if residual is None:
+            return self._forward_f32(x)
+        residual = residual + x
+        return self._forward_f32(residual), residual
+
+
+class HeliumMLP(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        intermediate_size: int,
+        hidden_act: str,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        if hidden_act != "silu":
+            raise ValueError(f"Unsupported activation: {hidden_act}. Only silu is supported.")
+        self.gate_up_proj = MergedColumnParallelLinear(
+            input_size=hidden_size,
+            output_sizes=[intermediate_size] * 2,
+            bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.gate_up_proj",
+        )
+        self.down_proj = RowParallelLinear(
+            input_size=intermediate_size,
+            output_size=hidden_size,
+            bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.down_proj",
+        )
+        self.act_fn = SiluAndMul()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x, _ = self.gate_up_proj(x)
+        x = self.act_fn(x)
+        x, _ = self.down_proj(x)
+        return x
+
+
+def _get_helium_rope(config: HeliumConfig):
+    rope_kwargs = {
+        "head_size": config.head_dim,
+        "max_position": config.max_position_embeddings,
+        "is_neox_style": False,
+        "rope_parameters": {"base": config.rope_theta},
+    }
+    try:
+        return get_rope(**rope_kwargs)
+    except TypeError:
+        # vLLM 0.23 uses `rope_parameters`; this fallback is for older local
+        # source trees whose get_rope still takes rotary_dim/base/rope_scaling.
+        return get_rope(
+            head_size=config.head_dim,
+            rotary_dim=config.head_dim,
+            max_position=config.max_position_embeddings,
+            base=config.rope_theta,
+            is_neox_style=False,
+        )
+
+
+class HeliumAttention(nn.Module):
+    def __init__(
+        self,
+        config: HeliumConfig,
+        hidden_size: int,
+        num_heads: int,
+        num_kv_heads: int,
+        cache_config: CacheConfig | None = None,
+        quant_config: QuantizationConfig | None = None,
+        prefix: str = "",
+        attn_type: str = AttentionType.DECODER,
+    ) -> None:
+        super().__init__()
+        self.hidden_size = hidden_size
+        tp_size = get_tensor_model_parallel_world_size()
+        self.total_num_heads = num_heads
+        assert self.total_num_heads % tp_size == 0
+        self.num_heads = self.total_num_heads // tp_size
+        self.total_num_kv_heads = num_kv_heads
+        if self.total_num_kv_heads >= tp_size:
+            assert self.total_num_kv_heads % tp_size == 0
+        else:
+            assert tp_size % self.total_num_kv_heads == 0
+        self.num_kv_heads = max(1, self.total_num_kv_heads // tp_size)
+        self.head_dim = config.head_dim
+        self.q_size = self.num_heads * self.head_dim
+        self.kv_size = self.num_kv_heads * self.head_dim
+        self.scaling = self.head_dim**-0.5
+
+        self.qkv_proj = QKVParallelLinear(
+            hidden_size=hidden_size,
+            head_size=self.head_dim,
+            total_num_heads=self.total_num_heads,
+            total_num_kv_heads=self.total_num_kv_heads,
+            bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.qkv_proj",
+        )
+        self.o_proj = RowParallelLinear(
+            input_size=self.total_num_heads * self.head_dim,
+            output_size=hidden_size,
+            bias=False,
+            quant_config=quant_config,
+            prefix=f"{prefix}.o_proj",
+        )
+        self.rotary_emb = _get_helium_rope(config)
+        self.attn = Attention(
+            self.num_heads,
+            self.head_dim,
+            self.scaling,
+            num_kv_heads=self.num_kv_heads,
+            cache_config=cache_config,
+            quant_config=quant_config,
+            per_layer_sliding_window=config.sliding_window,
+            prefix=f"{prefix}.attn",
+            attn_type=attn_type,
+        )
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+    ) -> torch.Tensor:
+        qkv, _ = self.qkv_proj(hidden_states)
+        q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
+        q, k = self.rotary_emb(positions, q, k)
+        attn_output = self.attn(q, k, v)
+        output, _ = self.o_proj(attn_output)
+        return output
+
+
+class HeliumDecoderLayer(nn.Module):
+    def __init__(
+        self,
+        vllm_config: VllmConfig,
+        prefix: str = "",
+        config: HeliumConfig | None = None,
+    ) -> None:
+        super().__init__()
+        config = config or vllm_config.model_config.hf_config
+        cache_config = vllm_config.cache_config
+        quant_config = vllm_config.quant_config
+        self.hidden_size = config.hidden_size
+
+        self.self_attn = HeliumAttention(
+            config=config,
+            hidden_size=self.hidden_size,
+            num_heads=config.num_attention_heads,
+            num_kv_heads=config.num_key_value_heads,
+            cache_config=cache_config,
+            quant_config=quant_config,
+            prefix=f"{prefix}.self_attn",
+            attn_type=AttentionType.DECODER,
+        )
+        self.mlp = HeliumMLP(
+            hidden_size=self.hidden_size,
+            intermediate_size=config.intermediate_size,
+            hidden_act=config.hidden_act,
+            quant_config=quant_config,
+            prefix=f"{prefix}.mlp",
+        )
+        self.input_layernorm = HeliumRMSNorm(
+            config.hidden_size,
+            eps=config.rms_norm_eps,
+        )
+        self.post_attention_layernorm = HeliumRMSNorm(
+            config.hidden_size,
+            eps=config.rms_norm_eps,
+        )
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+        residual: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if residual is None:
+            residual = hidden_states
+            hidden_states = self.input_layernorm(hidden_states)
+        else:
+            hidden_states, residual = self.input_layernorm(hidden_states, residual)
+
+        hidden_states = self.self_attn(
+            positions=positions,
+            hidden_states=hidden_states,
+        )
+
+        hidden_states, residual = self.post_attention_layernorm(
+            hidden_states,
+            residual,
+        )
+        hidden_states = self.mlp(hidden_states)
+        return hidden_states, residual
+
+
+def _flatten_inputs(
+    hidden_states: torch.Tensor,
+    positions: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, tuple[int, int] | None]:
+    if hidden_states.dim() != 3:
+        return hidden_states, positions.reshape(-1), None
+
+    batch, seq_len, hidden = hidden_states.shape
+    flat_hidden = hidden_states.reshape(batch * seq_len, hidden)
+    if positions.dim() == 1:
+        if positions.numel() == seq_len:
+            flat_positions = positions.unsqueeze(0).expand(batch, seq_len).reshape(-1)
+        elif positions.numel() == batch * seq_len:
+            flat_positions = positions.reshape(-1)
+        else:
+            raise ValueError(
+                "1D positions must have length S or B*S when inputs_embeds is "
+                f"3D, got {positions.numel()} for B={batch}, S={seq_len}."
+            )
+    else:
+        flat_positions = positions.reshape(-1)
+    return flat_hidden, flat_positions, (batch, seq_len)
+
+
+@support_torch_compile(
+    dynamic_arg_dims={
+        "input_ids": 0,
+        "positions": 0,
+        "intermediate_tensors": 0,
+        "inputs_embeds": 0,
+    }
+)
+class HeliumModel(nn.Module):
+    def __init__(
+        self,
+        *,
+        vllm_config: VllmConfig,
+        prefix: str = "",
+        layer_type: type[nn.Module] = HeliumDecoderLayer,
+        config: HeliumConfig | None = None,
+    ) -> None:
+        super().__init__()
+        # ``config`` lets a composite model (e.g. the PersonaPlex talker) build the
+        # Helium backbone from its temporal sub-config while the engine's top-level
+        # hf_config is the composite PersonaPlexConfig. Defaults to the engine's.
+        config = config or vllm_config.model_config.hf_config
+        self.config = config
+        self.quant_config = vllm_config.quant_config
+        self.vocab_size = config.vocab_size
+
+        self.start_layer, self.end_layer, self.layers = make_layers(
+            config.num_hidden_layers,
+            lambda prefix: layer_type(vllm_config=vllm_config, prefix=prefix, config=config),
+            prefix=f"{prefix}.layers",
+        )
+        if get_pp_group().is_last_rank:
+            self.norm = HeliumRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        else:
+            self.norm = PPMissingLayer()
+
+        self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(
+            ["hidden_states", "residual"],
+            config.hidden_size,
+        )
+
+    def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        raise ValueError(
+            "Helium temporal forward requires inputs_embeds; Moshi token "
+            "embeddings are intentionally not part of this vLLM module."
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+    ) -> torch.Tensor | IntermediateTensors:
+        unflatten_shape: tuple[int, int] | None = None
+        if get_pp_group().is_first_rank:
+            if inputs_embeds is None:
+                raise ValueError("HeliumModel.forward requires inputs_embeds.")
+            hidden_states, positions, unflatten_shape = _flatten_inputs(
+                inputs_embeds,
+                positions,
+            )
+            residual = None
+        else:
+            assert intermediate_tensors is not None
+            hidden_states = intermediate_tensors["hidden_states"]
+            residual = intermediate_tensors["residual"]
+            positions = positions.reshape(-1)
+
+        for layer in islice(self.layers, self.start_layer, self.end_layer):
+            hidden_states, residual = layer(
+                positions,
+                hidden_states,
+                residual,
+            )
+
+        if not get_pp_group().is_last_rank:
+            return IntermediateTensors({"hidden_states": hidden_states, "residual": residual})
+
+        hidden_states, _ = self.norm(hidden_states, residual)
+        if unflatten_shape is not None:
+            batch, seq_len = unflatten_shape
+            hidden_states = hidden_states.reshape(batch, seq_len, -1)
+        return hidden_states
+
+
+class HeliumForCausalLM(nn.Module, SupportsLoRA, SupportsPP):
+    packed_modules_mapping = {
+        "qkv_proj": ["q_proj", "k_proj", "v_proj"],
+        "gate_up_proj": ["gate_proj", "up_proj"],
+    }
+    embedding_modules = {
+        "lm_head": "output_embeddings",
+    }
+
+    def __init__(
+        self,
+        *,
+        vllm_config: VllmConfig,
+        prefix: str = "",
+        layer_type: type[nn.Module] = HeliumDecoderLayer,
+    ) -> None:
+        super().__init__()
+        config = vllm_config.model_config.hf_config
+        self.config = config
+        self.quant_config = vllm_config.quant_config
+        self.model = HeliumModel(
+            vllm_config=vllm_config,
+            prefix=maybe_prefix(prefix, "model"),
+            layer_type=layer_type,
+        )
+        if get_pp_group().is_last_rank:
+            self.lm_head = ParallelLMHead(
+                config.vocab_size,
+                config.hidden_size,
+                quant_config=self.quant_config,
+                prefix=maybe_prefix(prefix, "lm_head"),
+            )
+        else:
+            self.lm_head = PPMissingLayer()
+        self.logits_processor = LogitsProcessor(config.vocab_size)
+        self.make_empty_intermediate_tensors = self.model.make_empty_intermediate_tensors
+
+    def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        return self.model.embed_input_ids(input_ids)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+    ) -> torch.Tensor | IntermediateTensors:
+        return self.model(
+            input_ids=input_ids,
+            positions=positions,
+            intermediate_tensors=intermediate_tensors,
+            inputs_embeds=inputs_embeds,
+        )
+
+    def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor | None:
+        if hidden_states.dim() == 3:
+            batch, seq_len, hidden = hidden_states.shape
+            flat_hidden = hidden_states.reshape(batch * seq_len, hidden)
+            logits = self.logits_processor(self.lm_head, flat_hidden)
+            if logits is None:
+                return None
+            return logits.reshape(batch, seq_len, -1)
+        return self.logits_processor(self.lm_head, hidden_states)
+
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]] | Mapping[str, torch.Tensor],
+    ) -> set[str]:
+        if isinstance(weights, Mapping):
+            weights = weights.items()
+
+        params_dict = dict(self.named_parameters(remove_duplicate=False))
+        loaded_params: set[str] = set()
+
+        for name, loaded_weight in weights:
+            mapped = self._load_moshi_weight(name, loaded_weight, params_dict)
+            loaded_params.update(mapped)
+
+        return loaded_params
+
+    def _load_moshi_weight(
+        self,
+        name: str,
+        loaded_weight: torch.Tensor,
+        params_dict: dict[str, nn.Parameter],
+    ) -> set[str]:
+        if name == "out_norm.alpha":
+            return self._load_direct(
+                "model.norm.weight",
+                loaded_weight.squeeze(),
+                params_dict,
+            )
+        if name == "text_linear.weight":
+            return self._load_direct("lm_head.weight", loaded_weight, params_dict)
+
+        prefix = "transformer.layers."
+        if not name.startswith(prefix):
+            return set()
+
+        rest = name.removeprefix(prefix)
+        layer_index, _, suffix = rest.partition(".")
+        if not layer_index.isdigit() or not suffix:
+            return set()
+
+        base = f"model.layers.{layer_index}"
+        if suffix == "self_attn.in_proj_weight":
+            q_weight, k_weight, v_weight = loaded_weight.chunk(3, dim=0)
+            param_name = f"{base}.self_attn.qkv_proj.weight"
+            self._load_shard(param_name, q_weight, "q", params_dict)
+            self._load_shard(param_name, k_weight, "k", params_dict)
+            self._load_shard(param_name, v_weight, "v", params_dict)
+            return {param_name}
+        if suffix == "self_attn.out_proj.weight":
+            return self._load_direct(
+                f"{base}.self_attn.o_proj.weight",
+                loaded_weight,
+                params_dict,
+            )
+        if suffix == "gating.linear_in.weight":
+            gate_weight, up_weight = loaded_weight.chunk(2, dim=0)
+            param_name = f"{base}.mlp.gate_up_proj.weight"
+            self._load_shard(param_name, gate_weight, 0, params_dict)
+            self._load_shard(param_name, up_weight, 1, params_dict)
+            return {param_name}
+        if suffix == "gating.linear_out.weight":
+            return self._load_direct(
+                f"{base}.mlp.down_proj.weight",
+                loaded_weight,
+                params_dict,
+            )
+        if suffix == "norm1.alpha":
+            return self._load_direct(
+                f"{base}.input_layernorm.weight",
+                loaded_weight.squeeze(),
+                params_dict,
+            )
+        if suffix == "norm2.alpha":
+            return self._load_direct(
+                f"{base}.post_attention_layernorm.weight",
+                loaded_weight.squeeze(),
+                params_dict,
+            )
+        return set()
+
+    def _load_direct(
+        self,
+        name: str,
+        loaded_weight: torch.Tensor,
+        params_dict: dict[str, nn.Parameter],
+    ) -> set[str]:
+        if name not in params_dict or is_pp_missing_parameter(name, self):
+            return set()
+        param = params_dict[name]
+        weight_loader = getattr(param, "weight_loader", default_weight_loader)
+        weight_loader(param, loaded_weight)
+        return {name}
+
+    def _load_shard(
+        self,
+        name: str,
+        loaded_weight: torch.Tensor,
+        shard_id: str | int,
+        params_dict: dict[str, nn.Parameter],
+    ) -> None:
+        if name not in params_dict or is_pp_missing_parameter(name, self):
+            return
+        param = params_dict[name]
+        weight_loader = param.weight_loader
+        weight_loader(param, loaded_weight, shard_id)
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_code2wav.py b/vllm_omni/model_executor/models/personaplex/personaplex_code2wav.py
new file mode 100644
index 000000000..a5712aa40
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_code2wav.py
@@ -0,0 +1,433 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Stage-1 Code2Wav model for PersonaPlex (Moshi finetune).
+
+This is the ``LLM_GENERATION`` codec stage of the 2-stage PersonaPlex pipeline.
+It consumes the per-frame audio codebooks produced by the talker (stage 0) and
+the depformer (built by the lead), and turns them into 24 kHz PCM by calling the
+external Mimi neural codec from the ``moshi`` package.
+
+Layout contract (mirrors ``Qwen3TTSCode2Wav``):
+
+* Per request, ``input_ids`` holds a flat codebook-major codec sequence
+  ``[k * F]`` where ``k`` is the number of *active* codebooks Mimi decodes
+  (``num_codebooks``, i.e. the ``cb 0..7`` slice) and ``F`` is the number of
+  codec frames. The talker emits a 17-row token stack per frame; the input
+  processor (built by the lead) keeps only rows ``1:9`` (the 8 PCM-bearing audio
+  codebooks) and flattens them codebook-major before this stage.
+* ``forward(...)`` returns an :class:`OmniOutput` whose ``multimodal_outputs``
+  carries ``{"model_outputs": [wav_per_request], "sr": [sr_per_request]}`` — the
+  exact shape ``Qwen3TTSCode2Wav`` returns, so the downstream audio packer is
+  unchanged.
+
+The Mimi decoder is the transformers ``MimiModel`` (kyutai/mimi weights), not
+in vLLM's safetensors loader, so they are loaded eagerly in ``load_weights``
+part of the vLLM weights iterator (the codec owns its own checkpoint; see the
+experimental fullduplex package for the same pattern).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn as nn
+from vllm.config import VllmConfig
+from vllm.forward_context import get_forward_context, is_forward_context_available
+from vllm.logger import init_logger
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+logger = init_logger(__name__)
+
+_MIMI_DECODE_BATCH_FRAMES = 5
+
+
+def _codec_ids_from_payload_or_input(
+    input_ids: torch.Tensor,
+    runtime_info: Mapping[str, Any] | None,
+) -> torch.Tensor:
+    """Prefer connector-delivered codec ids over scheduler placeholders."""
+    if isinstance(runtime_info, Mapping):
+        codes = runtime_info.get("codes")
+        if isinstance(codes, Mapping):
+            audio = codes.get("audio")
+            if isinstance(audio, torch.Tensor) and audio.numel() > 0:
+                return audio.reshape(-1).to(device=input_ids.device, dtype=torch.long)
+            if isinstance(audio, (list, tuple)) and audio:
+                return torch.as_tensor(audio, device=input_ids.device, dtype=torch.long).reshape(-1)
+    return input_ids.reshape(-1).to(dtype=torch.long)
+
+
+class PersonaPlexCode2Wav(nn.Module):
+    """Stage-1 Code2Wav model for PersonaPlex (GenerationModelRunner).
+
+    Wraps the external Mimi decoder. The vLLM generation runner only calls a
+    handful of methods on this module: ``embed_input_ids`` (dummy embeddings),
+    ``compute_logits`` (none -- this stage never samples), ``forward`` (the
+    actual codec->PCM decode), ``make_omni_output`` (output normalization), and
+    ``load_weights`` (eager Mimi construction).
+    """
+
+    input_modalities = "audio"
+    requires_request_ids = True
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__()
+        self.vllm_config = vllm_config
+        self.model_path = vllm_config.model_config.model
+        self.config = vllm_config.model_config.hf_config
+
+        # Runner-facing capability flags, matching Qwen3TTSCode2Wav so the
+        # GenerationModelRunner drives this stage the same way.
+        self.have_multimodal_outputs = True
+        self.has_preprocess = False
+        self.has_postprocess = False
+        self.enable_update_additional_information = True
+        self.requires_raw_input_tokens = True
+
+        mimi_cfg = getattr(self.config, "mimi_config", None)
+        # Number of *active* codebooks Mimi decodes to PCM (cb 0..7).
+        self._num_codebooks = int(getattr(mimi_cfg, "num_codebooks", 8))
+        self._output_sample_rate = int(getattr(mimi_cfg, "sample_rate", 24000))
+        self._samples_per_frame = int(getattr(mimi_cfg, "samples_per_frame", 1920))
+        self._mimi_name = getattr(mimi_cfg, "mimi_name", None) or getattr(self.config, "mimi_name", None)
+        self._max_codec_sessions = int(getattr(vllm_config.model_config, "duplex_max_sessions", 1))
+
+        # The Mimi module is constructed in load_weights() (it owns its own
+        # weight format) and assigned here so vLLM's memory profiler can see it.
+        self.mimi: nn.Module | None = None
+        self._additional_mimi = nn.ModuleList()
+        self._mimi_device: torch.device | None = None
+        self._request_codes: dict[str, torch.Tensor] = {}
+        self._request_codec_slots: dict[str, int] = {}
+
+    # ------------------------------------------------------------------
+    # Runner-facing no-op / placeholder hooks (mirror Qwen3TTSCode2Wav).
+    # ------------------------------------------------------------------
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        # This stage ignores token embeddings; keep a stable dummy embedding so
+        # the vLLM runner has a valid hidden-state placeholder.
+        if input_ids.numel() == 0:
+            return torch.empty((0, 1), device=input_ids.device, dtype=torch.float32)
+        return torch.zeros((input_ids.shape[0], 1), device=input_ids.device, dtype=torch.float32)
+
+    def compute_logits(
+        self,
+        hidden_states: torch.Tensor | OmniOutput,
+        sampling_metadata: Any = None,
+    ) -> None:
+        # Code2Wav never samples; the runner short-circuits when logits are None.
+        return None
+
+    def get_dummy_runtime_additional_information(self, num_reqs: int) -> list[dict[str, object]]:
+        return [{"meta": {"personaplex_dummy_profile": True}} for _ in range(num_reqs)]
+
+    def _split_request_ids(
+        self,
+        ids: torch.Tensor,
+        seq_token_counts: list[int] | None = None,
+    ) -> list[torch.Tensor]:
+        """Split concatenated ``input_ids`` into per-request segments.
+
+        Uses ``seq_token_counts`` (injected by the runner via model_kwargs) when
+        available, falling back to forward-context ``ubatch_slices`` when
+        micro-batching is active. Returns ``[ids]`` for single-request batches.
+        Mirrors ``Qwen3TTSCode2Wav._split_request_ids``.
+        """
+        if seq_token_counts is not None and len(seq_token_counts) > 1:
+            boundaries = [0]
+            for count in seq_token_counts:
+                boundaries.append(boundaries[-1] + count)
+            n = ids.numel()
+            return [ids[boundaries[i] : min(boundaries[i + 1], n)] for i in range(len(seq_token_counts))]
+        if is_forward_context_available():
+            slices = get_forward_context().ubatch_slices
+            if slices is not None and len(slices) > 1 and not any(hasattr(s, "token_slice") for s in slices):
+                boundaries = [0]
+                for s in slices:
+                    boundaries.append(boundaries[-1] + s)
+                return [ids[boundaries[i] : boundaries[i + 1]] for i in range(len(boundaries) - 1)]
+        return [ids]
+
+    # ------------------------------------------------------------------
+    # Decode.
+    # ------------------------------------------------------------------
+    @torch.no_grad()
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        positions: torch.Tensor | None = None,
+        intermediate_tensors: Any = None,
+        inputs_embeds: torch.Tensor | None = None,
+        runtime_additional_information: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        """Decode flat codebook-major codec ids into PCM via Mimi.
+
+        ``input_ids`` per request is ``[k * F]`` (codebook-major), where ``k``
+        is ``self._num_codebooks``. The connector may send either a new delta
+        chunk or the cumulative prefix of a resumable request. Request-local
+        code history identifies the new suffix, and the streaming Mimi decoder
+        consumes each new frame exactly once.
+        """
+        sr_val = int(self._output_sample_rate)
+        sr_tensor = torch.tensor(sr_val, dtype=torch.int32)
+        empty = torch.zeros((0,), dtype=torch.float32)
+
+        if input_ids is None or input_ids.numel() == 0:
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={"model_outputs": [empty], "sr": [sr_tensor]},
+            )
+
+        ids = input_ids.reshape(-1).to(dtype=torch.long)
+        request_ids_list = self._split_request_ids(ids, kwargs.get("seq_token_counts"))
+        num_req = len(request_ids_list)
+        state_ids = self._resolve_request_ids(
+            num_req,
+            kwargs.get("request_ids"),
+            runtime_additional_information,
+        )
+
+        if self.mimi is None:
+            raise RuntimeError("PersonaPlexCode2Wav.forward called before Mimi was loaded in load_weights().")
+
+        k = int(self._num_codebooks)
+        device = self._mimi_device or ids.device
+        audios: list[torch.Tensor] = [empty] * num_req
+        srs = [sr_tensor] * num_req
+
+        for i, req_ids in enumerate(request_ids_list):
+            runtime_info = (
+                runtime_additional_information[i]
+                if runtime_additional_information is not None and i < len(runtime_additional_information)
+                else None
+            )
+            meta = runtime_info.get("meta") if isinstance(runtime_info, Mapping) else None
+            if isinstance(meta, Mapping) and meta.get("personaplex_dummy_profile") is True:
+                continue
+            flat = _codec_ids_from_payload_or_input(req_ids, runtime_info)
+            n = int(flat.numel())
+            if n == 0 or n % k != 0:
+                if n > 0:
+                    logger.warning(
+                        "PersonaPlex Code2Wav input_ids length %d not divisible by "
+                        "num_codebooks %d; skipping malformed request.",
+                        n,
+                        k,
+                    )
+                continue
+            frames = n // k
+            codes_kf = flat.reshape(k, frames)
+            state_id = state_ids[i]
+            delta_kf = self._new_code_suffix(state_id, codes_kf)
+            if delta_kf.shape[1] == 0:
+                continue
+            wav = self._decode_streaming_frames(state_id, delta_kf.to(device=device))
+            if wav.numel() > 0:
+                audios[i] = wav.to(dtype=torch.float32).reshape(-1)
+
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={"model_outputs": audios, "sr": srs},
+        )
+
+    @staticmethod
+    def _resolve_request_ids(
+        count: int,
+        request_ids: object,
+        runtime_additional_information: list[dict[str, Any]] | None,
+    ) -> list[str | None]:
+        if isinstance(request_ids, list | tuple):
+            if len(request_ids) != count:
+                raise ValueError(
+                    "PersonaPlex Code2Wav request id count does not match inputs: "
+                    f"request_ids={len(request_ids)}, inputs={count}"
+                )
+            return [str(request_id) for request_id in request_ids]
+
+        infos = runtime_additional_information or []
+        resolved: list[str | None] = []
+        for index in range(count):
+            info = infos[index] if index < len(infos) else None
+            request_id = None
+            if isinstance(info, Mapping):
+                request_id = info.get("request_id")
+                if request_id is None:
+                    meta = info.get("meta")
+                    if isinstance(meta, Mapping):
+                        request_id = meta.get("request_id")
+            resolved.append(str(request_id) if request_id is not None else None)
+        return resolved
+
+    def _new_code_suffix(self, request_id: str | None, codes_kf: torch.Tensor) -> torch.Tensor:
+        if request_id is None:
+            return codes_kf
+
+        incoming = codes_kf.detach().to(device="cpu", dtype=torch.long)
+        previous = self._request_codes.get(request_id)
+        if (
+            previous is not None
+            and incoming.shape[1] >= previous.shape[1]
+            and torch.equal(incoming[:, : previous.shape[1]], previous)
+        ):
+            delta = incoming[:, previous.shape[1] :]
+            self._request_codes[request_id] = incoming
+            return delta
+
+        self._request_codes[request_id] = incoming if previous is None else torch.cat([previous, incoming], dim=1)
+        return incoming
+
+    def _decode_streaming_frames(self, request_id: str | None, codes_kf: torch.Tensor) -> torch.Tensor:
+        codec, ephemeral = self._codec_for_request(request_id)
+        if not hasattr(codec, "decode_frame"):
+            raise RuntimeError("PersonaPlex Code2Wav requires a streaming Mimi decoder")
+
+        decode_frames = getattr(codec, "decode_frames", None)
+        chunks: list[torch.Tensor] = []
+        for start in range(0, codes_kf.shape[1], _MIMI_DECODE_BATCH_FRAMES):
+            frame_batch = codes_kf[:, start : start + _MIMI_DECODE_BATCH_FRAMES]
+            if frame_batch.shape[1] > 1 and callable(decode_frames):
+                chunks.append(self._flatten_wav(decode_frames(frame_batch.unsqueeze(0))))
+            else:
+                chunks.extend(
+                    self._flatten_wav(codec.decode_frame(frame_batch[:, frame].unsqueeze(0)))
+                    for frame in range(frame_batch.shape[1])
+                )
+        wav = torch.cat(chunks, dim=0) if chunks else codes_kf.new_empty(0, dtype=torch.float32)
+        if ephemeral:
+            codec.reset_streaming()
+        return wav
+
+    def _set_mimi_codecs(self, codecs: list[nn.Module]) -> None:
+        if not codecs:
+            raise ValueError("PersonaPlex Code2Wav requires at least one Mimi decoder")
+        self.mimi = codecs[0]
+        self._additional_mimi = nn.ModuleList(codecs[1:])
+        self._request_codec_slots.clear()
+
+    def _mimi_codecs(self) -> list[nn.Module]:
+        if self.mimi is None:
+            return []
+        return [self.mimi, *self._additional_mimi]
+
+    def _codec_for_request(self, request_id: str | None) -> tuple[nn.Module, bool]:
+        codecs = self._mimi_codecs()
+        if not codecs:
+            raise RuntimeError("PersonaPlexCode2Wav.forward called before Mimi was loaded in load_weights().")
+        occupied = set(self._request_codec_slots.values())
+        if request_id is not None:
+            slot = self._request_codec_slots.get(request_id)
+            if slot is None:
+                slot = next((index for index in range(len(codecs)) if index not in occupied), None)
+                if slot is None:
+                    raise RuntimeError(f"PersonaPlex Code2Wav decoder capacity {len(codecs)} is exhausted")
+                codecs[slot].streaming_init(1)
+                self._request_codec_slots[request_id] = slot
+            return codecs[slot], False
+
+        slot = next((index for index in range(len(codecs)) if index not in occupied), None)
+        if slot is None:
+            raise RuntimeError(f"PersonaPlex Code2Wav decoder capacity {len(codecs)} is exhausted")
+        codecs[slot].streaming_init(1)
+        return codecs[slot], True
+
+    def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
+        for request_id in finished_req_ids:
+            state_id = str(request_id)
+            self._request_codes.pop(state_id, None)
+            slot = self._request_codec_slots.pop(state_id, None)
+            codecs = self._mimi_codecs()
+            if slot is not None and slot < len(codecs):
+                codecs[slot].reset_streaming()
+
+    @staticmethod
+    def _flatten_wav(wav: torch.Tensor) -> torch.Tensor:
+        """Normalize Mimi's decode output to a 1D PCM tensor.
+
+        Mimi may return ``[B, samples]`` or ``[B, C, samples]`` depending on the
+        moshi version; PersonaPlex is mono (``C == 1``), so collapse to 1D.
+        """
+        if wav.dim() == 3:
+            # [B, C, T] -> take batch 0, channel 0.
+            return wav[0, 0]
+        if wav.dim() == 2:
+            # [B, T] -> batch 0.
+            return wav[0]
+        return wav.reshape(-1)
+
+    def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput | tuple, **kwargs: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+
+        if isinstance(model_outputs, tuple) and len(model_outputs) == len(OmniOutput._fields):
+            return OmniOutput(*model_outputs)
+
+        if not (isinstance(model_outputs, tuple) and len(model_outputs) == 2):
+            raise TypeError(
+                "PersonaPlexCode2Wav expected OmniOutput, OmniOutput tuple, "
+                f"or (audio_tensor, sr) outputs, got {type(model_outputs)}"
+            )
+
+        audio_tensor, sr = model_outputs
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={
+                "model_outputs": audio_tensor,
+                "sr": sr,
+            },
+        )
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        """Construct and load the external Mimi decoder.
+
+        The primary vLLM weights iterator carries no Code2Wav parameters (Mimi
+        owns its own checkpoint format), so it is drained and the Mimi module is
+        built from the moshi package's loader.
+        """
+        # Drain the primary iterator so callers don't hang on an unconsumed
+        # generator; none of these weights belong to this stage.
+        for _ in weights:
+            pass
+
+        device = self.vllm_config.device_config.device
+        from vllm_omni.model_executor.models.personaplex.personaplex_mimi import (
+            PersonaPlexMimiCodec,
+        )
+
+        checkpoint = Path(self.model_path) / (self._mimi_name or "tokenizer-e351c8d8-checkpoint125.safetensors")
+        codecs = [
+            PersonaPlexMimiCodec(
+                checkpoint=str(checkpoint) if checkpoint.is_file() else None,
+                device=str(device),
+            ).eval()
+            for _ in range(self._max_codec_sessions)
+        ]
+        self._set_mimi_codecs(codecs)
+        self._mimi_device = torch.device(str(device))
+        reported_sr = getattr(codecs[0].model.config, "sampling_rate", None)
+        if reported_sr is not None:
+            self._output_sample_rate = int(reported_sr)
+        bytes_per_mib = 1024**2
+        per_slot_weight_mib = (
+            sum(parameter.numel() * parameter.element_size() for parameter in codecs[0].parameters()) / bytes_per_mib
+        )
+        total_weight_mib = (
+            sum(parameter.numel() * parameter.element_size() for codec in codecs for parameter in codec.parameters())
+            / bytes_per_mib
+        )
+        logger.info(
+            "PersonaPlex Code2Wav loaded %d Mimi stream(s): "
+            "per_slot_weight_mib=%.2f total_weight_mib=%.2f "
+            "num_codebooks=%d sample_rate=%d samples_per_frame=%d",
+            len(codecs),
+            per_slot_weight_mib,
+            total_weight_mib,
+            self._num_codebooks,
+            self._output_sample_rate,
+            self._samples_per_frame,
+        )
+        return {name for name, _ in self.named_parameters() if name.startswith(("mimi.", "_additional_mimi."))}
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_depformer.py b/vllm_omni/model_executor/models/personaplex/personaplex_depformer.py
new file mode 100644
index 000000000..2a9a12905
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_depformer.py
@@ -0,0 +1,366 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex depformer: the per-step audio code predictor.
+
+The depformer is the small autoregressive head that, conditioned on one temporal
+hidden state, predicts the ``dep_q`` audio codebooks of a single Mimi frame. It
+is a faithful eager port of Moshi's depformer (``moshi.models.lm`` +
+``moshi.modules.transformer``), kept deliberately outside vLLM's paged-attention
+engine: its attention KV is reset every frame and only spans the ``dep_q`` inner
+steps, so paging buys nothing here. This mirrors how the existing TTS code
+predictors live alongside, not inside, the AR talker.
+
+Faithful-port details (all measured from ``nvidia/personaplex-7b-v1``):
+
+* **Per-step weights** (``weights_per_step``): each inner step ``t`` uses its own
+  attention in/out projection and its own gating MLP, selected by index (Moshi's
+  ``multi_linear``). There are ``dep_q`` weight sets per layer.
+* **No positional embedding** (``depformer_pos_emb="none"``): no RoPE, no sin.
+* **Causal attention over all inner steps**: Moshi forces the depformer's
+  ``context`` to None, so each step attends to every prior inner step (KV
+  capacity == ``weights_per_step``); the KV cache is rebuilt every temporal frame.
+* **fp32 RMSNorm** (``rms_norm_f32``, eps 1e-8) with the weight stored as
+  ``alpha`` of shape ``[1, 1, dim]``.
+* **SiLU gating** MLP (Moshi ``ActivationGating``): ``linear_in`` projects to
+  ``2 * hidden``; the halves are combined as ``silu(a) * b`` then ``linear_out``.
+* **ScaledEmbedding** with ``zero_idx = -1`` (the special token maps to the zero
+  vector); audio table is ``card + 1`` rows, text table ``text_card + 1``.
+
+The checkpoint ships ``dep_q = 8`` weight sets; the production loader (Moshi's
+``get_moshi_lm``) overrides ``dep_q = 16`` and fills sets 8..15 by copying 0..7.
+:meth:`PersonaPlexDepformer.load_weights` replicates that expansion so the module
+loads directly from the raw ``model.safetensors`` as well as from an
+already-expanded Moshi instance.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+    PersonaPlexDepformerConfig,
+)
+
+__all__ = ["PersonaPlexDepformer"]
+
+# Moshi's special "no token / zero embedding" sentinel (``LMModel.zero_token_id``).
+_ZERO_IDX = -1
+
+# A builder takes the source state dict and returns the tensor for one target
+# param, or None when the source lacks it.
+_Builder = Callable[[dict], "torch.Tensor | None"]
+
+
+def _rms_norm_f32(x: torch.Tensor, alpha: torch.Tensor, eps: float) -> torch.Tensor:
+    """Moshi ``_rms_norm`` with the fp32 accumulation path.
+
+    Variance and the alpha multiply run in float32 before casting back, matching
+    ``moshi.modules.transformer._rms_norm`` exactly (``dtype=torch.float``).
+    """
+    x_dtype = x.dtype
+    x_f32 = x.float()
+    var = eps + x_f32.pow(2).mean(dim=-1, keepdim=True)
+    y = x_f32 * (alpha.float() * torch.rsqrt(var))
+    return y.to(x_dtype)
+
+
+class _ScaledEmbedding(nn.Embedding):
+    """``nn.Embedding`` matching Moshi's ``ScaledEmbedding`` (no norm, zero_idx).
+
+    Inputs equal to ``zero_idx`` produce the zero vector; all other inputs are
+    clamped to ``>= 0`` before the lookup. ``norm_emb`` is False for PersonaPlex,
+    so no embedding norm is applied.
+    """
+
+    def __init__(self, num_embeddings: int, embedding_dim: int, zero_idx: int = _ZERO_IDX) -> None:
+        super().__init__(num_embeddings, embedding_dim)
+        self.zero_idx = zero_idx
+
+    def forward(self, idx: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        is_zero = idx == self.zero_idx
+        y = super().forward(idx.clamp(min=0))
+        zero = torch.zeros(1, dtype=y.dtype, device=y.device)
+        return torch.where(is_zero[..., None], zero, y)
+
+
+class _DepformerLayer(nn.Module):
+    """One depformer transformer layer with per-step attention + gating.
+
+    Attention and gating weights carry a leading ``dep_q`` axis; the active inner
+    step selects the slice (Moshi ``multi_linear`` / ``gating[t]``). KV is supplied
+    per call so the caller controls the per-frame reset and the sliding window.
+    """
+
+    def __init__(self, config: PersonaPlexDepformerConfig) -> None:
+        super().__init__()
+        dim = config.hidden_size
+        self.dim = dim
+        self.num_heads = config.num_attention_heads
+        self.head_dim = config.head_dim
+        self.dep_q = config.dep_q
+        self.eps = config.rms_norm_eps
+
+        # Per-step fused QKV and output projections, stored exactly as Moshi does:
+        # ``in_proj_weight`` is [dep_q * 3*dim, dim]; ``out_proj`` is [dep_q*dim, dim].
+        self.in_proj_weight = nn.Parameter(torch.empty(self.dep_q * 3 * dim, dim))
+        self.out_proj_weight = nn.Parameter(torch.empty(self.dep_q * dim, dim))
+
+        # fp32 RMSNorm weights (Moshi ``alpha``, shape [1, 1, dim]).
+        self.norm1_alpha = nn.Parameter(torch.ones(1, 1, dim))
+        self.norm2_alpha = nn.Parameter(torch.ones(1, 1, dim))
+
+        # Per-step SiLU gating MLP. ``linear_in`` -> [2*hidden, dim]; ``linear_out`` -> [dim, hidden].
+        hidden = config.intermediate_size
+        self.gating_in = nn.Parameter(torch.empty(self.dep_q, 2 * hidden, dim))
+        self.gating_out = nn.Parameter(torch.empty(self.dep_q, dim, hidden))
+
+    def _in_proj(self, step: int) -> torch.Tensor:
+        return self.in_proj_weight.view(self.dep_q, 3 * self.dim, self.dim)[step]
+
+    def _out_proj(self, step: int) -> torch.Tensor:
+        return self.out_proj_weight.view(self.dep_q, self.dim, self.dim)[step]
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        step: int,
+        kv: dict[str, torch.Tensor | None],
+    ) -> torch.Tensor:
+        """Run inner step ``step`` for a ``[B, 1, dim]`` input, updating ``kv`` in place."""
+        # --- self-attention (per-step weights, causal sliding window, no RoPE) ---
+        residual = x
+        h = _rms_norm_f32(x, self.norm1_alpha, self.eps).squeeze(1)  # [B, dim]
+        qkv = F.linear(h, self._in_proj(step))  # [B, 3*dim]
+        q, k, v = qkv.split(self.dim, dim=-1)
+        b = q.shape[0]
+        q = q.view(b, self.num_heads, 1, self.head_dim)
+        k = k.view(b, self.num_heads, 1, self.head_dim)
+        v = v.view(b, self.num_heads, 1, self.head_dim)
+
+        if kv["k"] is None:
+            k_hist, v_hist = k, v
+        else:
+            k_hist = torch.cat([kv["k"], k], dim=2)
+            v_hist = torch.cat([kv["v"], v], dim=2)
+        kv["k"], kv["v"] = k_hist, v_hist
+
+        # Moshi forces the depformer's ``context`` to None (lm.py: kwargs_dep[
+        # "context"] = None), so attention spans ALL prior inner steps -- the KV
+        # capacity is ``weights_per_step`` (== dep_q), never windowed. The query is
+        # the newest step and every key is causal w.r.t. it, so no mask is needed.
+        attn = F.scaled_dot_product_attention(q, k_hist, v_hist)  # [B, H, 1, Dh]
+        attn = attn.reshape(b, self.dim)
+        out = F.linear(attn, self._out_proj(step)).unsqueeze(1)  # [B, 1, dim]
+        x = residual + out
+
+        # --- feed-forward (per-step SiLU gating) ---
+        residual = x
+        h = _rms_norm_f32(x, self.norm2_alpha, self.eps).squeeze(1)  # [B, dim]
+        gated = F.linear(h, self.gating_in[step])  # [B, 2*hidden]
+        a, b_half = gated.chunk(2, dim=-1)
+        update = F.linear(F.silu(a) * b_half, self.gating_out[step]).unsqueeze(1)
+        return residual + update
+
+
+class PersonaPlexDepformer(nn.Module):
+    """Moshi depformer as a standalone per-frame code predictor.
+
+    Call :meth:`forward` once per temporal frame with the frame's text token and
+    temporal hidden state; it runs ``dep_q`` inner AR steps (greedy by default,
+    matching Moshi's ``use_sampling=False``) and returns the ``dep_q`` audio codes.
+    """
+
+    def __init__(
+        self,
+        config: PersonaPlexDepformerConfig,
+        temporal_hidden_size: int,
+        text_card: int = 32000,
+    ) -> None:
+        super().__init__()
+        self.config = config
+        self.dep_q = config.dep_q
+        self.card = config.card
+        dim = config.hidden_size
+
+        # Per-codebook projection of the temporal hidden state (``depformer_multi_linear``).
+        self.depformer_in = nn.ModuleList([nn.Linear(temporal_hidden_size, dim, bias=False) for _ in range(self.dep_q)])
+        # Step-0 conditions on the text token; steps 1..dep_q-1 on the previous audio code.
+        self.depformer_text_emb = _ScaledEmbedding(text_card + 1, dim)
+        self.depformer_emb = nn.ModuleList([_ScaledEmbedding(self.card + 1, dim) for _ in range(self.dep_q - 1)])
+        self.layers = nn.ModuleList([_DepformerLayer(config) for _ in range(config.num_hidden_layers)])
+        # Per-codebook output heads (Moshi ``linears``).
+        self.linears = nn.ModuleList([nn.Linear(dim, self.card, bias=False) for _ in range(self.dep_q)])
+
+    @torch.inference_mode()
+    def forward(
+        self,
+        text_token: torch.Tensor,
+        transformer_out: torch.Tensor,
+        audio_tokens: torch.Tensor | None = None,
+        audio_provided: torch.Tensor | None = None,
+        return_logits: bool = False,
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """Predict the ``dep_q`` audio codes for one frame.
+
+        Args:
+            text_token: ``[B]`` sampled text token for the frame.
+            transformer_out: ``[B, 1, temporal_hidden]`` temporal hidden state.
+            audio_tokens: optional ``[B, dep_q]`` teacher-forcing codes.
+            audio_provided: optional ``[B, dep_q]`` bool mask; where True the
+                corresponding ``audio_tokens`` entry overrides the sampled code as
+                the next-step input (partial teacher forcing, as in Moshi).
+            return_logits: also return the per-step logits ``[B, dep_q, card]``.
+
+        Returns:
+            ``[B, dep_q]`` long tensor of sampled (greedy) audio codes, plus the
+            per-step logits when ``return_logits`` is set.
+        """
+        if transformer_out.dim() != 3 or transformer_out.shape[1] != 1:
+            raise ValueError(f"transformer_out must be [B, 1, H]; got {tuple(transformer_out.shape)}")
+        prev = text_token
+        kv = [{"k": None, "v": None} for _ in self.layers]
+        codes: list[torch.Tensor] = []
+        logits_all: list[torch.Tensor] = []
+        for step in range(self.dep_q):
+            x = self.depformer_in[step](transformer_out)  # [B, 1, dim]
+            if step == 0:
+                cond = self.depformer_text_emb(prev.unsqueeze(1))
+            else:
+                cond = self.depformer_emb[step - 1](prev.unsqueeze(1))
+            x = x + cond
+            for li, layer in enumerate(self.layers):
+                x = layer(x, step, kv[li])
+            logits = self.linears[step](x).squeeze(1)  # [B, card]
+            sampled = logits.float().argmax(dim=-1)  # greedy [B]
+            codes.append(sampled)
+            if return_logits:
+                logits_all.append(logits.float())
+            if audio_provided is not None and audio_tokens is not None:
+                prev = torch.where(audio_provided[:, step], audio_tokens[:, step], sampled)
+            else:
+                prev = sampled
+        stacked = torch.stack(codes, dim=1)  # [B, dep_q]
+        if return_logits:
+            return stacked, torch.stack(logits_all, dim=1)  # [B, dep_q, card]
+        return stacked
+
+    # ------------------------------------------------------------------
+    # Weight loading
+    # ------------------------------------------------------------------
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]] | Mapping[str, torch.Tensor],
+    ) -> set[str]:
+        """Load Moshi depformer weights, expanding ``dep_q`` 8 -> 16 if needed.
+
+        Accepts the raw checkpoint names (``depformer.*``, ``depformer_in.N``,
+        ``depformer_emb.N``, ``depformer_text_emb``, ``linears.N``). Per-step
+        modules present only for steps 0..7 are copied to 8..15, and the fused
+        attention projections are tiled, exactly as Moshi's ``get_moshi_lm`` does.
+        """
+        src = dict(weights.items() if isinstance(weights, Mapping) else weights)
+        src = {k: v for k, v in src.items() if self._is_depformer_key(k)}
+        params = dict(self.named_parameters())
+        loaded: set[str] = set()
+
+        for tgt, build in self._weight_plan().items():
+            tensor = build(src)
+            if tensor is None:
+                continue
+            param = params[tgt]
+            if tensor.shape != param.shape:
+                raise ValueError(
+                    f"shape mismatch for {tgt}: checkpoint {tuple(tensor.shape)} vs param {tuple(param.shape)}"
+                )
+            param.data.copy_(tensor.to(param.dtype))
+            loaded.add(tgt)
+        return loaded
+
+    @staticmethod
+    def _is_depformer_key(name: str) -> bool:
+        return name.startswith(("depformer.", "depformer_in.", "depformer_emb.", "depformer_text_emb", "linears."))
+
+    def _weight_plan(self) -> dict[str, _Builder]:
+        """Map each of this module's params to a builder over the source state dict."""
+        dim = self.config.hidden_size
+
+        def step_or_copy(prefix: str, step: int, suffix: str = "weight") -> _Builder:
+            # cb 8..15 fall back to cb (step-8) when absent (Moshi copy_missing_weights).
+            def build(src: dict[str, torch.Tensor]) -> torch.Tensor | None:
+                key = f"{prefix}.{step}.{suffix}"
+                if key in src:
+                    return src[key]
+                if step >= 8:
+                    return src.get(f"{prefix}.{step - 8}.{suffix}")
+                return None
+
+            return build
+
+        def expand_attn(layer: int, kind: str, per_step_rows: int) -> _Builder:
+            # ``in_proj_weight`` [steps*per_step_rows, dim] / ``out_proj.weight`` likewise;
+            # tile an 8-step checkpoint block up to dep_q (Moshi concat-copy expansion).
+            def build(src: dict[str, torch.Tensor]) -> torch.Tensor | None:
+                key = f"depformer.layers.{layer}.self_attn.{kind}"
+                t = src.get(key)
+                if t is None:
+                    return None
+                steps = t.shape[0] // per_step_rows
+                if steps < self.dep_q:
+                    reps = (self.dep_q + steps - 1) // steps
+                    t = t.repeat(reps, 1)[: self.dep_q * per_step_rows]
+                return t
+
+            return build
+
+        plan: dict[str, _Builder] = {}
+        # depformer_in / linears / depformer_emb / text_emb
+        for step in range(self.dep_q):
+            plan[f"depformer_in.{step}.weight"] = step_or_copy("depformer_in", step)
+            plan[f"linears.{step}.weight"] = step_or_copy("linears", step)
+        plan["depformer_text_emb.weight"] = lambda src: src.get("depformer_text_emb.weight")
+        for step in range(self.dep_q - 1):
+            plan[f"depformer_emb.{step}.weight"] = step_or_copy("depformer_emb", step)
+
+        # per-layer attention + norms + gating
+        for layer in range(self.config.num_hidden_layers):
+            lp = f"depformer.layers.{layer}"
+            plan[f"layers.{layer}.in_proj_weight"] = expand_attn(layer, "in_proj_weight", 3 * dim)
+            plan[f"layers.{layer}.out_proj_weight"] = expand_attn(layer, "out_proj.weight", dim)
+            plan[f"layers.{layer}.norm1_alpha"] = self._reshape_alpha(f"{lp}.norm1.alpha")
+            plan[f"layers.{layer}.norm2_alpha"] = self._reshape_alpha(f"{lp}.norm2.alpha")
+            plan[f"layers.{layer}.gating_in"] = self._stack_gating(lp, "linear_in")
+            plan[f"layers.{layer}.gating_out"] = self._stack_gating(lp, "linear_out")
+        return plan
+
+    @staticmethod
+    def _reshape_alpha(key: str) -> _Builder:
+        def build(src: dict[str, torch.Tensor]) -> torch.Tensor | None:
+            t = src.get(key)
+            return None if t is None else t.reshape(1, 1, -1)
+
+        return build
+
+    def _stack_gating(self, layer_prefix: str, which: str) -> _Builder:
+        """Stack the dep_q per-step gating weights into one [dep_q, ...] tensor.
+
+        Steps 8..15 fall back to step (n-8) when the checkpoint only ships 8
+        (Moshi ``copy_missing_weights``).
+        """
+
+        def build(src: dict[str, torch.Tensor]) -> torch.Tensor | None:
+            slabs: list[torch.Tensor] = []
+            for step in range(self.dep_q):
+                key = f"{layer_prefix}.gating.{step}.{which}.weight"
+                if key not in src and step >= 8:
+                    key = f"{layer_prefix}.gating.{step - 8}.{which}.weight"
+                t = src.get(key)
+                if t is None:
+                    return None
+                slabs.append(t)
+            return torch.stack(slabs, dim=0)
+
+        return build
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_embeddings.py b/vllm_omni/model_executor/models/personaplex/personaplex_embeddings.py
new file mode 100644
index 000000000..18c502f98
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_embeddings.py
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex input embeddings (Moshi ``embed_codes``).
+
+The temporal transformer (:class:`HeliumForCausalLM`) consumes precomputed
+``inputs_embeds`` rather than token ids. Those embeddings come from Moshi's
+``embed_codes``: a per-frame ``[B, 1 + n_q, S]`` token stack (row 0 = text,
+rows 1..n_q = audio codebooks) is mapped through one text embedding plus ``n_q``
+audio-codebook embeddings and summed into ``[B, S, hidden]``.
+
+This module owns exactly those embedding tables (Moshi ``text_emb`` and
+``emb.0..n_q-1``), which ``modeling_helium`` deliberately omits. The talker
+(Task 2) uses it to build the temporal ``inputs_embeds`` for both the system /
+voice-prompt prefill and the per-frame decode step.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+
+import torch
+from torch import nn
+
+from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+    PersonaPlexConfig,
+)
+from vllm_omni.model_executor.models.personaplex.personaplex_depformer import (
+    _ScaledEmbedding,
+)
+
+__all__ = ["PersonaPlexInputEmbeddings"]
+
+
+class PersonaPlexInputEmbeddings(nn.Module):
+    """Moshi ``embed_codes``: summed text + audio-codebook embeddings.
+
+    Args:
+        config: the top-level PersonaPlex config (supplies the temporal hidden
+            size, the audio cardinality / codebook count, and the text table size).
+    """
+
+    def __init__(self, config: PersonaPlexConfig) -> None:
+        super().__init__()
+        dim = config.temporal_config.hidden_size
+        self.num_audio_codebooks = config.num_audio_codebooks  # n_q (16)
+        # Text table has one extra row for the special token (text_card + 1).
+        self.text_emb = _ScaledEmbedding(config.text_embedding_rows, dim)
+        # Each audio table is card + 1 rows; ``embed_codes`` uses all n_q codebooks.
+        self.audio_emb = nn.ModuleList(
+            [_ScaledEmbedding(config.audio_vocab_size + 1, dim) for _ in range(self.num_audio_codebooks)]
+        )
+
+    def forward(self, sequence: torch.Tensor) -> torch.Tensor:
+        """Map a ``[B, 1 + n_q, S]`` token stack to ``[B, S, hidden]``.
+
+        Row 0 is the text stream; rows ``1..n_q`` are the audio codebooks (in
+        Moshi's layout the audio rows carry both the agent and user streams).
+        """
+        if sequence.dim() != 3 or sequence.shape[1] != self.num_audio_codebooks + 1:
+            raise ValueError(f"sequence must be [B, {self.num_audio_codebooks + 1}, S]; got {tuple(sequence.shape)}")
+        emb = self.text_emb(sequence[:, 0])  # [B, S, hidden]
+        for cb in range(self.num_audio_codebooks):
+            emb = emb + self.audio_emb[cb](sequence[:, cb + 1])
+        return emb
+
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]] | Mapping[str, torch.Tensor],
+    ) -> set[str]:
+        """Load Moshi ``text_emb`` and ``emb.0..n_q-1`` embedding tables."""
+        src = dict(weights.items() if isinstance(weights, Mapping) else weights)
+        params = dict(self.named_parameters())
+        loaded: set[str] = set()
+
+        plan: dict[str, str] = {"text_emb.weight": "text_emb.weight"}
+        for cb in range(self.num_audio_codebooks):
+            plan[f"audio_emb.{cb}.weight"] = f"emb.{cb}.weight"
+
+        for tgt, key in plan.items():
+            if key not in src:
+                continue
+            param = params[tgt]
+            tensor = src[key]
+            if tensor.shape != param.shape:
+                raise ValueError(
+                    f"shape mismatch for {tgt}: checkpoint {tuple(tensor.shape)} vs param {tuple(param.shape)}"
+                )
+            param.data.copy_(tensor.to(param.dtype))
+            loaded.add(tgt)
+        return loaded
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py b/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py
new file mode 100644
index 000000000..48df20fab
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_mimi.py
@@ -0,0 +1,413 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Streaming Mimi codec for PersonaPlex (moshi-free).
+
+Frame-clocked duplex needs a codec that encodes/decodes exactly one 80 ms frame
+per call with state carried across the conversation. The ``moshi`` package
+provided that; this module removes the dependency by combining:
+
+- **transformers ``MimiModel``** (``kyutai/mimi`` — the same checkpoint family
+  PersonaPlex ships) for the quantizer and every SEANet conv weight. Its
+  streaming support only covers the encoder convs, so conv streaming is done
+  here instead, uniformly.
+- **Our own streaming wrappers** mirroring the Moshi reference semantics (MIT),
+  verified against recorded reference outputs:
+  * ``Conv1d``: left-context carry of ``effective_kernel - stride`` samples,
+    zero-initialized at stream start (``pad_mode="constant"``).
+  * ``ConvTranspose1d``: overlap-add tail carry of ``kernel - stride`` output
+    samples, with the double-counted bias subtracted on merge.
+  * transformer: the encoder/decoder transformers use a 250-position sliding
+    context over a ring KV with absolute-offset RoPE. Hugging Face's cache path
+    diverges once the window engages (position 250), so the transformers are
+    reimplemented here on the same ring-KV design as
+    ``personaplex_temporal.py`` and loaded directly from the PersonaPlex
+    checkpoint's fused layout (LayerNorm + per-layer LayerScale + GELU FFN).
+
+All per-stream state is ``[B, ...]`` with per-row reset (``reset_slot``), so the
+codec composes with elastic slot recycling in batched duplex serving.
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from vllm_omni.model_executor.models.personaplex.personaplex_temporal import (
+    _apply_rope,
+    _RingKV,
+)
+
+DEFAULT_HF_REPO = "kyutai/mimi"
+FRAME_SIZE = 1920
+CODEBOOKS = 8
+
+
+def _map_moshi_codec_weights(
+    state_dict: dict[str, torch.Tensor],
+) -> dict[str, torch.Tensor]:
+    """Map bundled Moshi codec keys to ``transformers.MimiModel`` keys."""
+
+    mapped: dict[str, torch.Tensor] = {}
+    transformer_prefixes = ("encoder_transformer.", "decoder_transformer.")
+    for name, tensor in state_dict.items():
+        if name.startswith(transformer_prefixes):
+            continue
+
+        if name.startswith("encoder.model."):
+            target = name.replace("encoder.model.", "encoder.layers.", 1)
+            target = target.replace(".conv.conv.", ".conv.")
+        elif name.startswith("decoder.model."):
+            target = name.replace("decoder.model.", "decoder.layers.", 1)
+            target = target.replace(".convtr.convtr.", ".conv.")
+            target = target.replace(".conv.conv.", ".conv.")
+        elif name.startswith("downsample.conv.conv.conv."):
+            target = name.replace("downsample.conv.conv.conv.", "downsample.conv.", 1)
+        elif name.startswith("upsample.convtr.convtr.convtr."):
+            target = name.replace("upsample.convtr.convtr.convtr.", "upsample.conv.", 1)
+        elif name.startswith("quantizer.rvq_first."):
+            target = name.replace(
+                "quantizer.rvq_first.",
+                "quantizer.semantic_residual_vector_quantizer.",
+                1,
+            )
+        elif name.startswith("quantizer.rvq_rest."):
+            target = name.replace(
+                "quantizer.rvq_rest.",
+                "quantizer.acoustic_residual_vector_quantizer.",
+                1,
+            )
+        else:
+            raise KeyError(f"unrecognized PersonaPlex Mimi checkpoint key: {name}")
+
+        target = target.replace(".vq.layers.", ".layers.")
+        target = target.replace("._codebook._initialized", ".codebook.initialized")
+        target = target.replace("._codebook.cluster_usage", ".codebook.cluster_usage")
+        target = target.replace("._codebook.embedding_sum", ".codebook.embed_sum")
+        mapped[target] = tensor
+    return mapped
+
+
+class _StreamConv1d:
+    """Moshi ``RawStreamingConv1d``: causal left-context carry per call.
+
+    ``pad_mode`` controls the stream-start left padding: SEANet convs use zeros
+    (``constant``); the down/upsample resamplers use ``replicate`` (the first
+    real sample), marked per row so elastic slot recycling re-primes correctly.
+    """
+
+    def __init__(self, conv: nn.Conv1d, pad_mode: str = "constant") -> None:
+        self.conv = conv
+        self.kernel = (conv.kernel_size[0] - 1) * conv.dilation[0] + 1
+        self.stride = conv.stride[0]
+        self.pad_mode = pad_mode
+        self.prev: torch.Tensor | None = None
+        self._fresh: torch.Tensor | None = None
+
+    def reset(self, batch_size: int, device, dtype) -> None:
+        pad = self.kernel - self.stride
+        self.prev = torch.zeros(batch_size, self.conv.in_channels, pad, device=device, dtype=dtype)
+        self._fresh = torch.ones(batch_size, dtype=torch.bool)
+
+    def reset_slot(self, b: int) -> None:
+        self.prev[b].zero_()
+        self._fresh[b] = True
+
+    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+        if self.pad_mode == "replicate" and bool(self._fresh.any()):
+            pad = self.prev.shape[-1]
+            edge = x[..., 0:1].expand(-1, -1, pad)
+            fresh = self._fresh.to(x.device).view(-1, 1, 1)
+            self.prev = torch.where(fresh, edge.to(self.prev.dtype), self.prev)
+        self._fresh[:] = False
+        x = torch.cat([self.prev, x], dim=-1)
+        t = x.shape[-1]
+        num_frames = max(0, (t - self.kernel) // self.stride + 1)
+        self.prev = x[..., num_frames * self.stride :]
+        if num_frames == 0:
+            return x.new_zeros(x.shape[0], self.conv.out_channels, 0)
+        return self.conv(x[..., : (num_frames - 1) * self.stride + self.kernel])
+
+
+class _StreamConvTr1d:
+    """Moshi ``RawStreamingConvTranspose1d``: overlap-add tail carry per call."""
+
+    def __init__(self, conv: nn.ConvTranspose1d) -> None:
+        self.conv = conv
+        self.kernel = conv.kernel_size[0]
+        self.stride = conv.stride[0]
+        self.partial: torch.Tensor | None = None
+
+    def reset(self, batch_size: int, device, dtype) -> None:
+        self.partial = torch.zeros(
+            batch_size, self.conv.out_channels, self.kernel - self.stride, device=device, dtype=dtype
+        )
+        self._fresh = torch.ones(batch_size, dtype=torch.bool)
+
+    def reset_slot(self, b: int) -> None:
+        self.partial[b].zero_()
+        self._fresh[b] = True
+
+    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.conv(x)
+        length = out.shape[-1]
+        tail = self.kernel - self.stride
+        pt = self.partial.shape[-1]
+        merge = self.partial.clone()
+        if self.conv.bias is not None:
+            # The carried tail already includes the bias; the fresh output adds
+            # it again, so subtract one copy -- except on a row's very first
+            # frame, where the carry is zeros by construction.
+            merge = merge - self.conv.bias[:, None]
+            merge[self._fresh] = 0.0
+            self._fresh[:] = False
+        out[..., :pt] += merge
+        self.partial = out[..., length - tail :].clone()
+        return out[..., : length - tail]
+
+
+class _MimiTransformerLayer(nn.Module):
+    """Moshi mimi transformer layer: LayerNorm, LayerScale, GELU FFN, no biases."""
+
+    def __init__(self, dim: int = 512, num_heads: int = 8, ffn: int = 2048) -> None:
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.in_proj_weight = nn.Parameter(torch.empty(3 * dim, dim))
+        self.out_proj_weight = nn.Parameter(torch.empty(dim, dim))
+        self.linear1 = nn.Parameter(torch.empty(ffn, dim))
+        self.linear2 = nn.Parameter(torch.empty(dim, ffn))
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+        self.scale1 = nn.Parameter(torch.empty(dim))
+        self.scale2 = nn.Parameter(torch.empty(dim))
+
+    def forward(self, x: torch.Tensor, kv: _RingKV, offset: torch.Tensor, context: int) -> torch.Tensor:
+        B, T, _ = x.shape
+        h = self.norm1(x)
+        qkv = F.linear(h, self.in_proj_weight)
+        qkv = qkv.view(B, T, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        q, k = _apply_rope(q, k, offset)
+        keys, values, pos_k = kv.complete(k, v)
+        pos_k = pos_k.view(pos_k.shape[0], 1, pos_k.shape[1])
+        pos_q = offset + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
+        delta = pos_q - pos_k
+        attn_bias = (pos_k >= 0) & (delta >= 0) & (delta < context)
+        attn = F.scaled_dot_product_attention(q, keys, values, attn_bias.unsqueeze(1), dropout_p=0.0)
+        attn = attn.transpose(1, 2).reshape(B, T, self.dim)
+        x = x + self.scale1 * F.linear(attn, self.out_proj_weight)
+        h = self.norm2(x)
+        h = F.linear(F.gelu(F.linear(h, self.linear1)), self.linear2)
+        return x + self.scale2 * h
+
+
+class _MimiStreamingTransformer(nn.Module):
+    """The 8-layer mimi encoder/decoder transformer as a stateful stepper."""
+
+    def __init__(self, num_layers: int = 8, dim: int = 512, num_heads: int = 8, context: int = 250) -> None:
+        super().__init__()
+        self.context = context
+        self.layers = nn.ModuleList([_MimiTransformerLayer(dim, num_heads) for _ in range(num_layers)])
+        self._kv: list[_RingKV] | None = None
+        self._offset: torch.Tensor | None = None
+
+    def streaming_init(self, batch_size: int) -> None:
+        p = next(self.parameters())
+        heads = self.layers[0].num_heads
+        hd = self.layers[0].head_dim
+        self._kv = [_RingKV(batch_size, heads, hd, self.context, p.device, p.dtype) for _ in self.layers]
+        self._offset = torch.zeros(1, device=p.device, dtype=torch.long)
+
+    def reset_streaming(self) -> None:
+        for kv in self._kv:
+            kv.reset()
+        self._offset.zero_()
+
+    def reset_slot(self, b: int) -> None:
+        for kv in self._kv:
+            kv.reset_slot(b)
+
+    def step(self, x: torch.Tensor) -> torch.Tensor:
+        """``x`` is ``[B, T, dim]`` (T = positions this frame, typically 2)."""
+        for layer, kv in zip(self.layers, self._kv):
+            x = layer(x, kv, self._offset, self.context)
+        self._offset.add_(x.shape[1])
+        return x
+
+    def load_weights(self, state_dict: dict[str, torch.Tensor], prefix: str) -> int:
+        loaded = 0
+        with torch.no_grad():
+            for i, layer in enumerate(self.layers):
+                base = f"{prefix}.transformer.layers.{i}"
+                pairs = [
+                    (layer.in_proj_weight, f"{base}.self_attn.in_proj_weight"),
+                    (layer.out_proj_weight, f"{base}.self_attn.out_proj.weight"),
+                    (layer.linear1, f"{base}.linear1.weight"),
+                    (layer.linear2, f"{base}.linear2.weight"),
+                    (layer.norm1.weight, f"{base}.norm1.weight"),
+                    (layer.norm1.bias, f"{base}.norm1.bias"),
+                    (layer.norm2.weight, f"{base}.norm2.weight"),
+                    (layer.norm2.bias, f"{base}.norm2.bias"),
+                    (layer.scale1, f"{base}.layer_scale_1.scale"),
+                    (layer.scale2, f"{base}.layer_scale_2.scale"),
+                ]
+                for param, name in pairs:
+                    param.data.copy_(state_dict[name].reshape(param.shape).to(param.dtype))
+                    loaded += 1
+        return loaded
+
+
+def _walk_seanet(layers) -> list[tuple[str, object]]:
+    """Wrap a Hugging Face Mimi SEANet layer list with streaming conv state."""
+    stages: list[tuple[str, object]] = []
+    for layer in layers:
+        kind = type(layer).__name__
+        if kind == "MimiConv1d":
+            stages.append(("conv", _StreamConv1d(layer.conv)))
+        elif kind == "MimiConvTranspose1d":
+            stages.append(("convtr", _StreamConvTr1d(layer.conv)))
+        elif kind == "ELU":
+            stages.append(("act", layer))
+        elif kind == "MimiResnetBlock":
+            block = (
+                layer.block[0],
+                _StreamConv1d(layer.block[1].conv),
+                layer.block[2],
+                _StreamConv1d(layer.block[3].conv),
+            )
+            stages.append(("res", block))
+        else:  # pragma: no cover - unexpected layer type
+            raise ValueError(f"unhandled Mimi SEANet layer: {kind}")
+    return stages
+
+
+class PersonaPlexMimiCodec(nn.Module):
+    """Streaming Mimi encode/decode at one 80 ms frame per call (moshi-free)."""
+
+    def __init__(self, hf_repo: str = DEFAULT_HF_REPO, checkpoint: str | None = None, device: str = "cuda") -> None:
+        super().__init__()
+        from huggingface_hub import hf_hub_download
+        from safetensors.torch import load_file
+        from transformers import MimiConfig, MimiModel
+
+        self.device = torch.device(device)
+
+        # The PersonaPlex repo ships the reference mimi checkpoint in the moshi
+        # fused layout. Build the matching Transformers graph locally, then load
+        # every codec tensor from that bundled checkpoint. Only the two HF
+        # transformer stacks remain absent because the streaming implementations
+        # below replace them with the checkpoint's fused QKV layout.
+        if checkpoint is None:
+            checkpoint = hf_hub_download(
+                "nvidia/personaplex-7b-v1",
+                "tokenizer-e351c8d8-checkpoint125.safetensors",
+            )
+        sd = load_file(checkpoint, device=str(self.device))
+        self.model = MimiModel(MimiConfig())
+        codec_state = _map_moshi_codec_weights(sd)
+        incompatible = self.model.load_state_dict(codec_state, strict=False)
+        expected_missing = {
+            name
+            for name in self.model.state_dict()
+            if name.startswith(("encoder_transformer.", "decoder_transformer."))
+        }
+        if set(incompatible.missing_keys) != expected_missing or incompatible.unexpected_keys:
+            raise RuntimeError(
+                "PersonaPlex Mimi checkpoint did not exactly cover the local codec graph: "
+                f"missing={sorted(set(incompatible.missing_keys) - expected_missing)}, "
+                f"unexpected={sorted(incompatible.unexpected_keys)}"
+            )
+        # The fused streaming transformers below replace these unloaded HF
+        # stacks. Drop their randomly initialized weights before moving Mimi to
+        # the target device.
+        del self.model.encoder_transformer, self.model.decoder_transformer
+        self.model = self.model.to(self.device).eval()
+        self.dtype = next(self.model.parameters()).dtype
+        self.encoder_transformer = _MimiStreamingTransformer().to(self.device, self.dtype)
+        self.decoder_transformer = _MimiStreamingTransformer().to(self.device, self.dtype)
+        n_enc = self.encoder_transformer.load_weights(sd, "encoder_transformer")
+        n_dec = self.decoder_transformer.load_weights(sd, "decoder_transformer")
+        assert n_enc == n_dec == 80, (n_enc, n_dec)
+        del sd
+
+        m = self.model
+        self._enc_stages = _walk_seanet(m.encoder.layers)
+        self._downsample = _StreamConv1d(m.downsample.conv, pad_mode="replicate")
+        self._upsample = _StreamConvTr1d(m.upsample.conv)
+        self._dec_stages = _walk_seanet(m.decoder.layers)
+        self._batch_size: int | None = None
+
+    # -- streaming state ------------------------------------------------------
+
+    def _conv_states(self):
+        for _, stage in (*self._enc_stages, *self._dec_stages):
+            if isinstance(stage, (_StreamConv1d, _StreamConvTr1d)):
+                yield stage
+            elif isinstance(stage, tuple):
+                yield stage[1]
+                yield stage[3]
+        yield self._downsample
+        yield self._upsample
+
+    def streaming_init(self, batch_size: int) -> None:
+        self._batch_size = batch_size
+        for s in self._conv_states():
+            s.reset(batch_size, self.device, self.dtype)
+        self.encoder_transformer.streaming_init(batch_size)
+        self.decoder_transformer.streaming_init(batch_size)
+
+    def reset_streaming(self) -> None:
+        assert self._batch_size is not None
+        for state in self._conv_states():
+            for b in range(self._batch_size):
+                state.reset_slot(b)
+        self.encoder_transformer.reset_streaming()
+        self.decoder_transformer.reset_streaming()
+
+    def reset_slot(self, b: int) -> None:
+        for s in self._conv_states():
+            s.reset_slot(b)
+        self.encoder_transformer.reset_slot(b)
+        self.decoder_transformer.reset_slot(b)
+
+    # -- per-frame codec -------------------------------------------------------
+
+    @staticmethod
+    def _run_stages(x: torch.Tensor, stages) -> torch.Tensor:
+        for kind, stage in stages:
+            if kind == "res":
+                act0, conv1, act2, conv3 = stage
+                x = x + conv3(act2(conv1(act0(x))))
+            else:
+                x = stage(x)
+        return x
+
+    @torch.no_grad()
+    def encode_frame(self, pcm: torch.Tensor) -> torch.Tensor:
+        """``[B, frame_size]`` float PCM -> ``[B, 8]`` codes."""
+        x = pcm.to(self.device, self.dtype).view(-1, 1, FRAME_SIZE)
+        x = self._run_stages(x, self._enc_stages)
+        x = self.encoder_transformer.step(x.transpose(1, 2)).transpose(1, 2)
+        x = self._downsample(x)
+        codes = self.model.quantizer.encode(x)  # [Q, B, T]
+        return codes[:CODEBOOKS, :, 0].transpose(0, 1).contiguous()
+
+    @torch.no_grad()
+    def decode_frame(self, codes: torch.Tensor) -> torch.Tensor:
+        """``[B, 8]`` codes -> ``[B, frame_size]`` float PCM."""
+        emb = self.model.quantizer.decode(codes.to(self.device).view(-1, CODEBOOKS, 1))
+        emb = self._upsample(emb)
+        emb = self.decoder_transformer.step(emb.transpose(1, 2)).transpose(1, 2)
+        x = self._run_stages(emb, self._dec_stages)
+        return x[:, 0, :]
+
+    @torch.no_grad()
+    def decode_frames(self, codes: torch.Tensor) -> torch.Tensor:
+        """``[B, 8, F]`` codes -> ``[B, F * frame_size]`` float PCM."""
+        emb = self.model.quantizer.decode(codes.to(self.device))
+        emb = self._upsample(emb)
+        emb = self.decoder_transformer.step(emb.transpose(1, 2)).transpose(1, 2)
+        x = self._run_stages(emb, self._dec_stages)
+        return x[:, 0, :]
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_talker.py b/vllm_omni/model_executor/models/personaplex/personaplex_talker.py
new file mode 100644
index 000000000..5e56e7a7c
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_talker.py
@@ -0,0 +1,639 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex talker: the temporal transformer as a vLLM-native omni AR stage.
+
+This is the stage-0 (``LLM_AR``) model the OmniGPUModelRunner drives. It composes
+three pieces, each verified in isolation against Moshi:
+
+* the Helium temporal transformer (:class:`HeliumModel`) on vLLM paged attention,
+  consuming per-frame ``inputs_embeds`` and producing the per-frame hidden state;
+* the input embeddings (:class:`PersonaPlexInputEmbeddings`, ``embed_codes``) that
+  build those ``inputs_embeds`` from the delayed 17-row token stack;
+* the depformer (:class:`PersonaPlexDepformer`) that, conditioned on the temporal
+  hidden state and the sampled text token, predicts the per-frame audio codes.
+
+Per-frame protocol (OmniGPUModelRunner, gpu_model_runner.py):
+
+1. ``compute_logits`` produces the text logits; the engine samples the text token.
+2. ``preprocess`` (per-request, with that request's ``additional_information``)
+   carries Moshi's acoustic-delay cache and the precomputed user-audio code stream,
+   builds the base ``inputs_embeds`` for the current frame, and exposes the
+   previous frame's temporal hidden + text-step embedding via ``mtp_inputs``.
+3. ``talker_mtp`` (batched, stateless) runs the depformer to predict the agent
+   codes and finishes the next frame's ``inputs_embeds``; the codes are stored
+   under ``talker_mtp_output_key=("codes","audio")`` for the Mimi code2wav stage.
+
+Phase 1 is turn-based: the user-audio rows (9..16) come from a precomputed Mimi
+encode of the input WAV (built in ``preprocess``); live duplex is Phase 2.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+import torch
+from torch import nn
+from vllm.config import VllmConfig
+from vllm.distributed import get_pp_group
+from vllm.model_executor.layers.logits_processor import LogitsProcessor
+from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+from vllm.model_executor.models.utils import PPMissingLayer, maybe_prefix
+from vllm.sequence import IntermediateTensors
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.model_executor.models.personaplex.configuration_personaplex import (
+    PersonaPlexConfig,
+)
+from vllm_omni.model_executor.models.personaplex.modeling_helium import HeliumModel
+from vllm_omni.model_executor.models.personaplex.personaplex_depformer import (
+    PersonaPlexDepformer,
+)
+from vllm_omni.model_executor.models.personaplex.personaplex_embeddings import (
+    PersonaPlexInputEmbeddings,
+)
+
+__all__ = ["PersonaPlexTalkerForConditionalGeneration"]
+
+
+class PersonaPlexTalkerForConditionalGeneration(nn.Module):
+    """vLLM-native PersonaPlex talker (temporal transformer + depformer).
+
+    Plain ``nn.Module`` (not ``SupportsPP``): inheriting a vLLM Protocol puts
+    ``Protocol`` in the MRO and breaks vLLM's runtime ``isinstance`` check for
+    ``VllmModelForTextGeneration``, which would misclassify the talker as a
+    non-generate model. Qwen3-TTS's talker is plain ``nn.Module`` for the same
+    reason; PersonaPlex does not need pipeline parallelism.
+    """
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__()
+        self.vllm_config = vllm_config
+        config: PersonaPlexConfig = vllm_config.model_config.hf_config  # type: ignore[assignment]
+        self.config = config
+        self.temporal_config = config.temporal_config
+        hidden = self.temporal_config.hidden_size
+        self._dtype = getattr(vllm_config.model_config, "dtype", torch.bfloat16)
+
+        # Temporal backbone on vLLM paged attention (consumes inputs_embeds).
+        self.model = HeliumModel(
+            vllm_config=vllm_config,
+            prefix=maybe_prefix(prefix, "model"),
+            config=self.temporal_config,
+        )
+        # Text head (Moshi text_linear -> lm_head), vocab = text_vocab_size (32000).
+        if get_pp_group().is_last_rank:
+            self.lm_head = ParallelLMHead(
+                config.text_vocab_size,
+                hidden,
+                quant_config=vllm_config.quant_config,
+                prefix=maybe_prefix(prefix, "lm_head"),
+            )
+        else:
+            self.lm_head = PPMissingLayer()
+        self.logits_processor = LogitsProcessor(config.text_vocab_size)
+        self.make_empty_intermediate_tensors = self.model.make_empty_intermediate_tensors
+
+        # Verified custom components: embed_codes + depformer.
+        self.input_embeddings = PersonaPlexInputEmbeddings(config)
+        self.depformer = PersonaPlexDepformer(
+            config.depformer_config,
+            temporal_hidden_size=hidden,
+            text_card=config.text_vocab_size,
+        )
+
+        # Omni AR runner contract.
+        self.have_multimodal_outputs = True
+        self.has_preprocess = True
+        self.has_postprocess = True  # capture each frame's hidden for the next depformer step
+        self.requires_full_prefix_cached_hidden_states = False
+        # Keep the per-frame "last" hidden on GPU (avoids a CPU round-trip each step).
+        self.gpu_resident_buffer_keys: set[tuple[str, str]] = {("hidden_states", "last")}
+        self.mtp_hidden_size = hidden
+        self.talker_mtp_output_key = ("codes", "audio")
+        # dep_q audio codebooks per frame; only cb 0..num_active are vocoded.
+        self.dep_q = config.depformer_config.dep_q
+        self.num_active_codebooks = config.depformer_config.num_active_codebooks
+
+    # ------------------------------------------------------------------
+    # Core forward / logits
+    # ------------------------------------------------------------------
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        """Placeholder embedding for vLLM's ``VllmModel`` protocol.
+
+        The talker is driven by precomputed ``inputs_embeds`` (built in
+        ``preprocess`` via ``embed_codes``); ``input_ids`` are only in-vocab
+        bookkeeping placeholders. Return a zero embedding of the temporal hidden
+        size — the runner replaces it with the real per-frame ``inputs_embeds``.
+        """
+        return torch.zeros(
+            (input_ids.shape[0], self.mtp_hidden_size),
+            device=input_ids.device,
+            dtype=self._dtype,
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **_: Any,
+    ) -> torch.Tensor | IntermediateTensors:
+        return self.model(input_ids, positions, intermediate_tensors, inputs_embeds)
+
+    def compute_logits(
+        self,
+        hidden_states: torch.Tensor | OmniOutput,
+        sampling_metadata: Any = None,
+    ) -> torch.Tensor | None:
+        if isinstance(hidden_states, OmniOutput):
+            hidden_states = hidden_states.text_hidden_states
+        if hidden_states is None:
+            return None
+        if hidden_states.dim() == 3:
+            b, s, h = hidden_states.shape
+            logits = self.logits_processor(self.lm_head, hidden_states.reshape(b * s, h))
+            return None if logits is None else logits.reshape(b, s, -1)
+        return self.logits_processor(self.lm_head, hidden_states)
+
+    def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput, **kwargs: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            return model_outputs
+        hidden = model_outputs
+        info_dicts = kwargs.get("model_intermediate_buffer") or kwargs.get("runtime_additional_information") or []
+        audio_codes_list: list[torch.Tensor] = []
+        for info in info_dicts:
+            if not isinstance(info, dict):
+                continue
+            ac = info.get("codes", {}).get("audio")
+            if isinstance(ac, torch.Tensor):
+                audio_codes_list.append(ac)
+        if not audio_codes_list:
+            return OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
+        audio_codes = torch.cat(audio_codes_list, dim=0)
+        hidden = hidden[: int(audio_codes.shape[0])]
+        return OmniOutput(text_hidden_states=hidden, multimodal_outputs={"codes": {"audio": audio_codes}})
+
+    # ------------------------------------------------------------------
+    # Per-frame omni AR protocol: preprocess (stateful) + talker_mtp (batched)
+    # ------------------------------------------------------------------
+    def _initial_frame_embed(self, device: torch.device) -> torch.Tensor:
+        """``embed_codes`` of Moshi's initial token frame (text+audio SOS)."""
+        text_init = self.config.text_vocab_size  # text_initial_token_id
+        audio_init = self.config.audio_vocab_size  # card == initial audio token
+        n_q = self.config.num_audio_codebooks
+        stack = torch.empty((1, 1 + n_q, 1), dtype=torch.long, device=device)
+        stack[:, 0] = text_init
+        stack[:, 1:] = audio_init
+        return self.input_embeddings(stack).reshape(1, -1)  # [1, hidden]
+
+    def _build_frame_embed(
+        self,
+        text_token: torch.Tensor,
+        last_agent: torch.Tensor | None,
+        prev_agent: torch.Tensor | None,
+        device: torch.device,
+        user_d0: torch.Tensor | None = None,
+        user_d1: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Full ``inputs_embeds`` for a decode frame (Moshi cache read at offset-1).
+
+        Acoustic-delay decomposition (delays ``[0, 0,1x7, 0,1x7]``): after a
+        depformer step, Moshi writes every unforced agent codebook into the
+        current cache target. The next temporal input therefore reads the whole
+        previous effective agent frame. User writes are delayed by codebook, so
+        user cb0 and cb1..7 still come from ``user_d0`` and ``user_d1``.
+        Unfilled positions default to the initial token (card).
+        """
+        n_q = self.config.num_audio_codebooks  # 16 (8 agent + 8 user)
+        n_user = n_q // 2  # 8
+        audio_init = self.config.audio_vocab_size  # card == initial audio token (Moshi cache default)
+        # No-history / not-yet-generated delayed positions = the initial token (card),
+        # NOT 0 (verified against Moshi's per-frame input stack).
+        stack = torch.full((1, 1 + n_q, 1), audio_init, dtype=torch.long, device=device)
+        stack[:, 0] = text_token.reshape(1)
+        # The full effective agent frame was stored at the previous cache target
+        # after applying any teacher forcing. The next cache read sees all eight
+        # codebooks from that frame.
+        if last_agent is not None and last_agent.numel() >= n_user:
+            stack[0, 1 : 1 + n_user, 0] = last_agent.reshape(-1)[:n_user].to(device)
+        # user cb0 (row 9) delay-0; user cb1..7 (rows 10..16) delay-1.
+        user_base = 1 + n_user  # row index 9
+        if user_d0 is not None and user_d0.numel() >= 1:
+            stack[0, user_base, 0] = user_d0.reshape(-1)[0].to(device)
+        if user_d1 is not None and user_d1.numel() >= n_user:
+            stack[0, user_base + 1 : user_base + n_user, 0] = user_d1.reshape(-1)[1:n_user].to(device)
+        return self.input_embeddings(stack).reshape(1, -1)  # [1, hidden]
+
+    def _build_prefill_embed(
+        self,
+        prefill_text: torch.Tensor,
+        offset: int,
+        span: int,
+        device: torch.device,
+        silence: torch.Tensor | None = None,
+        user_sine: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        """Per-frame embeds for the persona system-prompt prefill.
+
+        Each frame forces the persona/silence text token (row 0). The agent rows
+        use Mimi-encoded silence, while the user rows optionally use the encoded
+        sine frame from PersonaPlex's native text-prompt prefill. Without an
+        explicit user frame, both sides fall back to silence.
+        """
+        n_q = self.config.num_audio_codebooks
+        n_user = n_q // 2
+        zero_text = 3  # Moshi LMGen.zero_text_code (silence/pad text)
+        sil = (
+            silence.reshape(-1).to(device) if isinstance(silence, torch.Tensor) and silence.numel() >= n_user else None
+        )
+        user = (
+            user_sine.reshape(-1).to(device)
+            if isinstance(user_sine, torch.Tensor) and user_sine.numel() >= n_user
+            else sil
+        )
+        total = int(prefill_text.numel())
+        rows = []
+        for i in range(span):
+            pos = offset + i
+            text_tok = int(prefill_text[pos].item()) if pos < total else zero_text
+            stack = torch.zeros((1, 1 + n_q, 1), dtype=torch.long, device=device)
+            stack[:, 0] = text_tok
+            if sil is not None:
+                stack[0, 1 : 1 + n_user, 0] = sil[:n_user]  # agent rows = encoded silence
+            if user is not None:
+                stack[0, 1 + n_user : 1 + 2 * n_user, 0] = user[:n_user]
+            rows.append(self.input_embeddings(stack).reshape(1, -1))
+        return torch.cat(rows, dim=0)  # [span, hidden]
+
+    @staticmethod
+    def _user_frame(info: dict[str, Any], frame_idx: int) -> torch.Tensor | None:
+        """Fetch the Mimi-encoded user codes for ``frame_idx`` (or None / out of range)."""
+        uc = info.get("pplex_user_codes")
+        if uc is None:
+            return None
+        if not isinstance(uc, torch.Tensor):
+            uc = torch.as_tensor(uc, dtype=torch.long)
+        if uc.ndim != 2 or frame_idx < 0 or frame_idx >= uc.shape[0]:
+            return None
+        return uc[frame_idx]
+
+    @staticmethod
+    def _last_agent_codes(info: dict[str, Any]) -> torch.Tensor | None:
+        codes = info.get("codes")
+        if isinstance(codes, dict):
+            ac = codes.get("audio")
+            if isinstance(ac, torch.Tensor) and ac.numel() > 0:
+                return (ac[-1] if ac.ndim == 2 else ac).reshape(-1)
+        return None
+
+    def preprocess(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor | None,
+        **info_dict: Any,
+    ) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]]:
+        """Build the current frame's ``inputs_embeds`` and the mtp inputs.
+
+        Prefill emits the initial-token frame embedding; each decode step builds the
+        delayed base frame (everything but agent cb0, which ``talker_mtp`` adds).
+        """
+        additional = info_dict.get("additional_information")
+        if isinstance(additional, dict):
+            merged = {k: v for k, v in info_dict.items() if k != "additional_information"}
+            for k, v in additional.items():
+                merged.setdefault(k, v)
+            info_dict = merged
+        meta = info_dict.get("meta", {}) if isinstance(info_dict.get("meta"), dict) else {}
+
+        device = input_ids.device
+        span = int(input_ids.shape[0])
+        is_prefill_raw = info_dict.get("_omni_is_prefill")
+        if isinstance(is_prefill_raw, bool):
+            is_prefill = is_prefill_raw
+        else:
+            is_prefill = span > 1
+
+        duplex = info_dict.get("duplex")
+        if isinstance(duplex, dict) and duplex.get("data_plane") is True and is_prefill:
+            prompt_len_raw = info_dict.get("duplex_prompt_len", span)
+            try:
+                prompt_len = int(prompt_len_raw)
+            except (TypeError, ValueError):
+                prompt_len = span
+            prepared = self._duplex_stage0_runtime().prepare_append(
+                duplex,
+                prompt_len=prompt_len,
+                request_id=(str(info_dict["request_id"]) if isinstance(info_dict.get("request_id"), str) else None),
+            )
+            offset_raw = info_dict.get("duplex_token_offset", 0)
+            try:
+                offset = max(0, int(offset_raw))
+            except (TypeError, ValueError):
+                offset = 0
+            local_offset = offset - prepared.prompt_offset
+            if local_offset < 0:
+                raise ValueError(
+                    "PersonaPlex scheduled span precedes the current append: "
+                    f"offset={offset}, append_offset={prepared.prompt_offset}, "
+                    f"span={span}, prompt={prompt_len}"
+                )
+            req_embeds = prepared.inputs_embeds[local_offset : local_offset + span].to(
+                device=device,
+                dtype=self._dtype,
+            )
+            req_input_ids = prepared.input_ids[local_offset : local_offset + span].to(device=device)
+            if req_embeds.shape[0] != span or req_input_ids.shape[0] != span:
+                raise ValueError(
+                    "PersonaPlex duplex prompt slice is shorter than the scheduled span: "
+                    f"offset={offset}, span={span}, prompt={prompt_len}"
+                )
+            return req_input_ids, req_embeds, prepared.info_update
+
+        zero_hidden = torch.zeros((1, self.mtp_hidden_size), device=device, dtype=self._dtype)
+
+        prefill_text = info_dict.get("pplex_prefill_text")
+        prefill_len = int(prefill_text.numel()) if isinstance(prefill_text, torch.Tensor) else 0
+
+        if is_prefill:
+            offset = max(0, int(info_dict.get("_omni_num_computed_tokens", 0) or 0))
+            if isinstance(prefill_text, torch.Tensor) and prefill_text.numel() > 0:
+                # Persona system-prompt prefill (step_system_prompts analog).
+                silence = info_dict.get("pplex_silence_codes")
+                emb = self._build_prefill_embed(prefill_text, offset, span, device, silence)
+            else:
+                emb = self._initial_frame_embed(device)
+                if span > 1:
+                    emb = emb.expand(span, -1).contiguous()
+            ids_out = input_ids.clone()
+            info_update = {
+                "meta": {
+                    "pplex_frame": int(meta.get("pplex_frame", 0)) + span,
+                    "pplex_prefill_len": prefill_len,
+                },
+                "mtp_inputs": (zero_hidden, zero_hidden),
+            }
+            return ids_out, emb, info_update
+
+        # Decode: input_ids == the text token sampled last step (delay-0 text).
+        text_token = input_ids.reshape(-1)[:1]
+        # Agent acoustic delay: cb0 (delay 0) = gen[t-1] = the last stored codes;
+        # cb1..7 (delay 1) = gen[t-2] = the codes carried from the previous frame.
+        last_agent = self._last_agent_codes(info_dict)
+        prev_agent = info_dict.get("pplex_prev_agent")
+        if prev_agent is not None and not isinstance(prev_agent, torch.Tensor):
+            prev_agent = torch.as_tensor(prev_agent, dtype=torch.long)
+        # Real user stream (Phase-1 turn-based): user cb0 delay-0, cb1..7 delay-1.
+        # Index into the user stream relative to the first decode frame (after the
+        # persona prefill), so the user audio aligns with the agent's response.
+        prefill_len = int(meta.get("pplex_prefill_len", prefill_len) or 0)
+        # decode_frame = pplex_frame - prefill_len (the prefill frame already advanced
+        # pplex_frame, so this is d+1 at decode step d). Verified vs Moshi's per-frame
+        # stack: user cb0 (delay 0) = enc[decode_frame-1] = enc[d]; cb1..7 (delay 1) =
+        # enc[decode_frame-2]. (The agent stream lags one more: agent cb0 = gen[d-1].)
+        decode_frame = max(0, int(meta.get("pplex_frame", 0)) - prefill_len)
+        user_d0 = self._user_frame(info_dict, decode_frame - 1)
+        user_d1 = self._user_frame(info_dict, decode_frame - 2)
+        base = self._build_frame_embed(text_token, last_agent, prev_agent, device, user_d0, user_d1)
+        text_step = self.input_embeddings.text_emb(text_token.reshape(1, 1)).reshape(1, -1)
+        # The previous frame's temporal hidden (written by postprocess into
+        # hidden_states["last"]) conditions this frame's depformer. Falls back to
+        # zeros only on the very first decode step (no prior hidden yet).
+        hs = info_dict.get("hidden_states", {}) if isinstance(info_dict.get("hidden_states"), dict) else {}
+        last_hidden = hs.get("last")
+        if isinstance(last_hidden, torch.Tensor) and last_hidden.numel() > 0:
+            last_hidden = last_hidden.reshape(1, -1).to(device=device, dtype=self._dtype)
+        else:
+            last_hidden = zero_hidden
+        info_update = {
+            "meta": {"pplex_frame": int(meta.get("pplex_frame", 0)) + 1},
+            "mtp_inputs": (last_hidden, text_step),
+        }
+        # Carry this frame's gen[t-1] forward; next frame reads it as gen[t-2] (cb1..7).
+        if last_agent is not None:
+            info_update["pplex_prev_agent"] = last_agent.detach().to(torch.long).cpu()
+        return input_ids, base, info_update
+
+    def _duplex_stage0_runtime(self):
+        runtime = getattr(self, "_personaplex_duplex_stage0_runtime", None)
+        if runtime is not None:
+            return runtime
+        from vllm_omni.experimental.fullduplex.personaplex.stage0 import (
+            PersonaPlexStage0DuplexRuntime,
+        )
+
+        model_path = str(getattr(self.vllm_config.model_config, "model", ""))
+        device = str(next(self.parameters()).device)
+        runtime = PersonaPlexStage0DuplexRuntime(
+            self,
+            model_path=model_path,
+            device=device,
+            max_sessions=int(getattr(self.vllm_config.model_config, "duplex_max_sessions", 1)),
+        )
+        self._personaplex_duplex_stage0_runtime = runtime
+        return runtime
+
+    def on_requests_finished(self, finished_req_ids: set[str] | list[str]) -> None:
+        runtime = getattr(self, "_personaplex_duplex_stage0_runtime", None)
+        if runtime is None:
+            return
+        for request_id in finished_req_ids:
+            runtime.close_request(request_id)
+
+    def postprocess(self, hidden_states: torch.Tensor, **_: Any) -> dict[str, Any]:
+        """Capture this frame's last hidden for the next step's depformer (mtp)."""
+        if hidden_states is None or hidden_states.numel() == 0:
+            return {}
+        return {"hidden_states": {"last": hidden_states[-1, :].detach()}}
+
+    def talker_mtp(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor,
+        last_talker_hidden: torch.Tensor,
+        text_step: torch.Tensor,
+        **kwargs: Any,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Run the depformer for the frame and finish its ``inputs_embeds``.
+
+        Returns ``(inputs_embeds, audio_codes[B, dep_q])``. ``audio_codes`` are
+        stored under ``("codes","audio")``; ``inputs_embeds`` (base from preprocess
+        + the fresh agent cb0 embedding, the delay-0 acoustic token) feeds the next
+        temporal forward.
+        """
+        bsz = int(input_ids.shape[0])
+        dtype = self._dtype
+        text_token = input_ids.reshape(bsz).to(torch.long)
+        hidden = last_talker_hidden.reshape(bsz, 1, -1).to(dtype)
+
+        codes = self.depformer(text_token, hidden)  # [B, dep_q] == gen[t]
+
+        # The frame's inputs_embeds is built fully in preprocess (Moshi cache read at
+        # offset-1, with agent cb0 = gen[t-1]); gen[t] feeds the NEXT frame, so pass
+        # the embed through unchanged and just emit this frame's codes.
+        inputs_embeds = input_embeds.reshape(bsz, -1).to(dtype)
+        return inputs_embeds, codes.to(torch.long)
+
+    def post_sample_talker_mtp(
+        self,
+        *,
+        input_ids: torch.Tensor,
+        hidden_states: torch.Tensor,
+        req_ids: list[str],
+        req_infos: list[dict[str, Any]],
+    ) -> torch.Tensor:
+        """Generate depformer codes for a one-token resumable duplex segment.
+
+        The normal runner invokes ``talker_mtp`` at the start of the next decode
+        step. PersonaPlex's unified duplex request instead appends one audio
+        frame and stops after one sampled text token, so there is no next decode
+        step. Run the same depformer dependency immediately from the current
+        sampled text token and temporal hidden state.
+        """
+        bsz = int(input_ids.shape[0])
+        if len(req_infos) != bsz:
+            raise ValueError(
+                f"PersonaPlex depformer request information does not match batch: {len(req_infos)} != {bsz}"
+            )
+        text_token = input_ids.reshape(bsz).to(torch.long)
+        hidden = hidden_states.reshape(bsz, 1, -1).to(self._dtype)
+        audio_tokens: list[torch.Tensor] = []
+        audio_provided: list[torch.Tensor] = []
+        for info in req_infos:
+            tokens = info.get("pplex_depformer_audio_tokens")
+            provided = info.get("pplex_depformer_audio_provided")
+            if not isinstance(tokens, torch.Tensor) or not isinstance(provided, torch.Tensor):
+                raise ValueError("PersonaPlex duplex depformer teacher-forcing state is missing")
+            tokens = tokens.reshape(-1)
+            provided = provided.reshape(-1)
+            if tokens.shape != provided.shape:
+                raise ValueError(
+                    "PersonaPlex depformer teacher-forcing token/mask shapes differ: "
+                    f"{tuple(tokens.shape)} != {tuple(provided.shape)}"
+                )
+            audio_tokens.append(tokens)
+            audio_provided.append(provided)
+        codes = self.depformer(
+            text_token,
+            hidden,
+            audio_tokens=torch.stack(audio_tokens).to(
+                device=hidden.device,
+                dtype=torch.long,
+            ),
+            audio_provided=torch.stack(audio_provided).to(
+                device=hidden.device,
+                dtype=torch.bool,
+            ),
+        ).to(torch.long)
+        runtime = self._duplex_stage0_runtime()
+        for row, request_id in enumerate(req_ids):
+            runtime.record_sample(
+                request_id=request_id,
+                text_token=text_token[row],
+                agent_codes=codes[row],
+            )
+        return codes
+
+    # ------------------------------------------------------------------
+    # Weight loading
+    # ------------------------------------------------------------------
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        """Route the Moshi checkpoint into the three components.
+
+        * ``transformer.*`` / ``out_norm.alpha`` -> the Helium temporal backbone
+          (same q/k-split + gate/up-split + alpha-squeeze map as HeliumForCausalLM).
+        * ``text_linear.weight`` -> ``lm_head``.
+        * ``emb.*`` / ``text_emb.weight`` -> input embeddings.
+        * ``depformer*`` / ``linears.*`` -> depformer.
+        """
+        weights = list(weights)
+        params = dict(self.named_parameters(remove_duplicate=False))
+        loaded: set[str] = set()
+
+        emb_w: list[tuple[str, torch.Tensor]] = []
+        dep_w: list[tuple[str, torch.Tensor]] = []
+        for name, w in weights:
+            if name.startswith(("emb.", "text_emb.")):
+                emb_w.append((name, w))
+            elif name.startswith(("depformer.", "depformer_in.", "depformer_emb.", "depformer_text_emb", "linears.")):
+                dep_w.append((name, w))
+            elif name == "text_linear.weight":
+                self._load_direct("lm_head.weight", w, params, loaded)
+            else:
+                loaded |= self._load_temporal(name, w, params)
+
+        # Delegate to the verified component loaders, prefixed into this module.
+        for sub, sub_w in (("input_embeddings", emb_w), ("depformer", dep_w)):
+            module = getattr(self, sub)
+            for tgt in module.load_weights(sub_w):
+                loaded.add(f"{sub}.{tgt}")
+        return loaded
+
+    def _load_temporal(
+        self,
+        name: str,
+        loaded_weight: torch.Tensor,
+        params: dict[str, nn.Parameter],
+    ) -> set[str]:
+        out: set[str] = set()
+        if name == "out_norm.alpha":
+            self._load_direct("model.norm.weight", loaded_weight.squeeze(), params, out)
+            return out
+        prefix = "transformer.layers."
+        if not name.startswith(prefix):
+            return out
+        rest = name.removeprefix(prefix)
+        layer_index, _, suffix = rest.partition(".")
+        if not layer_index.isdigit() or not suffix:
+            return out
+        base = f"model.layers.{layer_index}"
+        if suffix == "self_attn.in_proj_weight":
+            q, k, v = loaded_weight.chunk(3, dim=0)
+            pname = f"{base}.self_attn.qkv_proj.weight"
+            self._load_shard(pname, q, "q", params)
+            self._load_shard(pname, k, "k", params)
+            self._load_shard(pname, v, "v", params)
+            out.add(pname)
+        elif suffix == "self_attn.out_proj.weight":
+            self._load_direct(f"{base}.self_attn.o_proj.weight", loaded_weight, params, out)
+        elif suffix == "gating.linear_in.weight":
+            gate, up = loaded_weight.chunk(2, dim=0)
+            pname = f"{base}.mlp.gate_up_proj.weight"
+            self._load_shard(pname, gate, 0, params)
+            self._load_shard(pname, up, 1, params)
+            out.add(pname)
+        elif suffix == "gating.linear_out.weight":
+            self._load_direct(f"{base}.mlp.down_proj.weight", loaded_weight, params, out)
+        elif suffix == "norm1.alpha":
+            self._load_direct(f"{base}.input_layernorm.weight", loaded_weight.squeeze(), params, out)
+        elif suffix == "norm2.alpha":
+            self._load_direct(f"{base}.post_attention_layernorm.weight", loaded_weight.squeeze(), params, out)
+        return out
+
+    @staticmethod
+    def _load_direct(
+        name: str,
+        loaded_weight: torch.Tensor,
+        params: dict[str, nn.Parameter],
+        loaded: set[str],
+    ) -> None:
+        if name not in params:
+            return
+        param = params[name]
+        weight_loader = getattr(param, "weight_loader", default_weight_loader)
+        weight_loader(param, loaded_weight)
+        loaded.add(name)
+
+    @staticmethod
+    def _load_shard(
+        name: str,
+        loaded_weight: torch.Tensor,
+        shard_id: str | int,
+        params: dict[str, nn.Parameter],
+    ) -> None:
+        if name not in params:
+            return
+        param = params[name]
+        param.weight_loader(param, loaded_weight, shard_id)
diff --git a/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py b/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py
new file mode 100644
index 000000000..717e4d505
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/personaplex_temporal.py
@@ -0,0 +1,257 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Streaming Helium temporal transformer for PersonaPlex (moshi-free, plain torch).
+
+Frame-clocked duplex needs a stateful per-frame forward: one 80 ms step consumes
+one summed frame embedding and returns the temporal hidden + text logits, with a
+sliding-window KV carried across the conversation. vLLM's engine path serves the
+offline/staged flavor of this model (``modeling_helium.HeliumForCausalLM``); this
+module is the REAL-TIME flavor: no engine context, a fixed-capacity ring KV, and
+static shapes so the whole step is CUDA-graphable.
+
+Semantics mirror the Moshi streaming transformer exactly (MIT; the reference for
+the ``nvidia/personaplex-7b-v1`` checkpoint), op for op, so greedy decoding is
+bit-comparable against recorded reference outputs:
+
+- fp32 RMSNorm with ``alpha`` weights (norm1/norm2/out_norm)
+- fused in-proj attention, interleaved (non-neox) RoPE applied at the ABSOLUTE
+  offset in fp32, relative-position causal mask over a ring KV with
+  ``context``-window truncation
+- SiLU gating MLP with fused ``linear_in`` (gate/up) and ``linear_out``
+- ``transformer_out`` is the POST-``out_norm`` hidden; ``text_logits`` is
+  ``text_linear`` of that hidden
+
+Weights load directly from the moshi checkpoint's fused layout
+(``transformer.layers.{i}.self_attn.in_proj_weight`` etc.), keeping the exact
+computation order of the reference.
+
+Per-slot elastic recycle (concurrent serving) uses the same per-row
+``start_offset`` masking verified for the moshi-hosted path: writes stay uniform
+because every slot ticks in lockstep; ``reset_slot`` only moves that row's
+valid-window start. The LM-specific "+1 sacrifice tick" bump is the CALLER's
+job (see the fullduplex PersonaPlex stage0), matching the split introduced when
+the +1 was found to be wrong for codec streams.
+"""
+
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from vllm_omni.model_executor.models.personaplex.personaplex_depformer import _rms_norm_f32
+
+
+def _apply_rope(q: torch.Tensor, k: torch.Tensor, offset: torch.Tensor, max_period: float = 10_000.0):
+    """Interleaved RoPE at absolute ``offset``, fp32 rotation (moshi ``apply_rope``)."""
+    B, H, T, D = q.shape
+    ds = torch.arange(D // 2, device=q.device, dtype=torch.float32)
+    freqs = torch.exp(ds * (-math.log(max_period) * 2 / D))
+    ts = offset.float() + torch.arange(T, device=q.device, dtype=torch.float32)
+    ts = ts.view(1, -1, 1)
+
+    dims = q.shape[:-1]
+    q = q.view(*dims, D // 2, 2)
+    k = k.view(*dims, D // 2, 2)
+    qr, qi = q[..., 0].float(), q[..., 1].float()
+    kr, ki = k[..., 0].float(), k[..., 1].float()
+    rotr = torch.cos(freqs * ts)
+    roti = torch.sin(freqs * ts)
+    qor = qr * rotr - qi * roti
+    qoi = qr * roti + qi * rotr
+    kor = kr * rotr - ki * roti
+    koi = kr * roti + ki * rotr
+    dtype = q.dtype
+    qo = torch.stack([qor.to(dtype), qoi.to(dtype)], dim=-1)
+    ko = torch.stack([kor.to(dtype), koi.to(dtype)], dim=-1)
+    return qo.view(*dims, D), ko.view(*dims, D)
+
+
+class _RingKV:
+    """Fixed-capacity KV ring with per-row valid-window start (elastic recycle).
+
+    Uniform writes (all rows tick together) + a per-row mask via absolute
+    positions; with ``start_offset == 0`` everywhere this is the plain streaming
+    cache. All shapes static -> CUDA-graph safe.
+    """
+
+    def __init__(self, batch_size: int, num_heads: int, dim_per_head: int, capacity: int, device, dtype):
+        self.capacity = capacity
+        self.cache = torch.zeros((2, batch_size, num_heads, capacity, dim_per_head), device=device, dtype=dtype)
+        self.end_offset = torch.zeros(1, device=device, dtype=torch.long)
+        self.start_offset = torch.zeros(batch_size, device=device, dtype=torch.long)
+
+    def reset(self) -> None:
+        self.end_offset.zero_()
+        self.start_offset.zero_()
+
+    def reset_slot(self, b: int) -> None:
+        # Mask everything written so far for row b; the row's next write is its
+        # first visible entry. (LM sacrifice-tick +1 is applied by the caller.)
+        self.start_offset[b] = self.end_offset.clone()
+
+    def bump_slot_start(self, b: int) -> None:
+        self.start_offset[b] += 1
+
+    def complete(self, k: torch.Tensor, v: torch.Tensor):
+        B, H, T, D = k.shape
+        indexes = torch.arange(T, device=self.end_offset.device, dtype=self.end_offset.dtype) + self.end_offset
+        indexes = indexes % self.capacity
+        self.cache[0].index_copy_(2, indexes, k)
+        self.cache[1].index_copy_(2, indexes, v)
+        self.end_offset.add_(T)
+
+        idx = torch.arange(self.capacity, device=self.end_offset.device, dtype=torch.long)
+        invalid = idx >= self.end_offset
+        end_index = self.end_offset % self.capacity
+        delta = idx - end_index
+        # `delta <= 0` (not `< 0`) is moshi's exact convention (transformer.py
+        # RingKVCache.complete). It labels the just-past-newest slot as the future
+        # write position, so once the ring has wrapped the single oldest in-window
+        # cell is excluded and the effective window is capacity-1. This is inherited
+        # verbatim from the reference and only shows after the window fills (Helium
+        # ~3000 frames / 240 s); it costs one frame out of thousands. Do NOT change
+        # this to `< 0`: it would diverge from moshi and break greedy bit-parity.
+        positions = torch.where(delta <= 0, self.end_offset + delta, self.end_offset + delta - self.capacity)
+        positions = torch.where(invalid, torch.full_like(positions, -1), positions)
+        positions = positions.view(1, -1)  # [1, capacity]
+        below = positions < self.start_offset.view(-1, 1)  # [B, capacity]
+        positions = torch.where(below, torch.full_like(positions, -1), positions)
+        return self.cache[0], self.cache[1], positions
+
+
+class _TemporalLayer(nn.Module):
+    """One Helium decoder layer in the checkpoint's fused layout."""
+
+    def __init__(self, dim: int, num_heads: int, hidden: int) -> None:
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.in_proj_weight = nn.Parameter(torch.empty(3 * dim, dim))
+        self.out_proj_weight = nn.Parameter(torch.empty(dim, dim))
+        self.gating_in = nn.Parameter(torch.empty(2 * hidden, dim))
+        self.gating_out = nn.Parameter(torch.empty(dim, hidden))
+        self.norm1_alpha = nn.Parameter(torch.ones(1, 1, dim))
+        self.norm2_alpha = nn.Parameter(torch.ones(1, 1, dim))
+
+    def forward(self, x: torch.Tensor, kv: _RingKV, offset: torch.Tensor, context: int) -> torch.Tensor:
+        B, T, _ = x.shape
+        h = _rms_norm_f32(x, self.norm1_alpha, 1e-8)
+        qkv = F.linear(h, self.in_proj_weight)
+        # Layout mirrors moshi's einops "b t (p h d) -> p b h t d" exactly, so the
+        # downstream kernels see identical strides (bit-level replay agreement).
+        qkv = qkv.view(B, T, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        q, k = _apply_rope(q, k, offset)
+
+        keys, values, pos_k = kv.complete(k, v)
+        pos_k = pos_k.view(pos_k.shape[0], 1, pos_k.shape[1])  # [B, 1, cap]
+        pos_q = offset + torch.arange(T, device=q.device, dtype=torch.long).view(1, -1, 1)
+        delta = pos_q - pos_k
+        attn_bias = (pos_k >= 0) & (delta >= 0) & (delta < context)
+        attn_bias = attn_bias.unsqueeze(1)  # [B, 1, T, cap]
+        attn = F.scaled_dot_product_attention(q, keys, values, attn_bias, dropout_p=0.0)
+        attn = attn.transpose(1, 2).reshape(B, T, self.dim)
+        x = x + F.linear(attn, self.out_proj_weight)
+
+        h = _rms_norm_f32(x, self.norm2_alpha, 1e-8)
+        a, b = F.linear(h, self.gating_in).chunk(2, dim=-1)
+        return x + F.linear(F.silu(a) * b, self.gating_out)
+
+
+class PersonaPlexTemporalStreaming(nn.Module):
+    """The 7B Helium temporal backbone as a stateful per-frame stepper.
+
+    ``step(frame_embedding [B, 1, dim]) -> (transformer_out [B, 1, dim],
+    text_logits [B, 1, 1, text_card])``, matching moshi's
+    ``LMModel.forward_embeddings`` contract so the existing native depformer and
+    input embeddings compose unchanged.
+    """
+
+    def __init__(
+        self,
+        dim: int = 4096,
+        num_layers: int = 32,
+        num_heads: int = 32,
+        hidden: int = 11264,
+        context: int = 3000,
+        text_card: int = 32000,
+        max_period: float = 10_000.0,
+    ) -> None:
+        super().__init__()
+        self.dim = dim
+        self.context = context
+        self.max_period = max_period
+        self.layers = nn.ModuleList([_TemporalLayer(dim, num_heads, hidden) for _ in range(num_layers)])
+        self.out_norm_alpha = nn.Parameter(torch.ones(1, 1, dim))
+        self.text_linear = nn.Parameter(torch.empty(text_card, dim))
+        self._kv: list[_RingKV] | None = None
+        self._offset: torch.Tensor | None = None
+
+    # -- streaming state ----------------------------------------------------
+
+    def streaming_init(self, batch_size: int) -> None:
+        p = next(self.parameters())
+        heads = self.layers[0].num_heads
+        head_dim = self.layers[0].head_dim
+        # Capacity = context window (the mask truncates at `context` anyway).
+        self._kv = [_RingKV(batch_size, heads, head_dim, self.context, p.device, p.dtype) for _ in self.layers]
+        self._offset = torch.zeros(1, device=p.device, dtype=torch.long)
+
+    def reset_streaming(self) -> None:
+        assert self._kv is not None, "call streaming_init first"
+        for kv in self._kv:
+            kv.reset()
+        self._offset.zero_()
+
+    def reset_slot(self, b: int) -> None:
+        assert self._kv is not None
+        for kv in self._kv:
+            kv.reset_slot(b)
+
+    def bump_slot_start(self, b: int) -> None:
+        """LM sacrifice-tick semantics: mask the one spurious post-recycle write."""
+        assert self._kv is not None
+        for kv in self._kv:
+            kv.bump_slot_start(b)
+
+    # -- per-frame step -------------------------------------------------------
+
+    @torch.no_grad()
+    def step(self, frame_embedding: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        assert self._kv is not None, "call streaming_init first"
+        x = frame_embedding
+        for layer, kv in zip(self.layers, self._kv):
+            x = layer(x, kv, self._offset, self.context)
+        self._offset.add_(x.shape[1])
+        out = _rms_norm_f32(x, self.out_norm_alpha, 1e-8)
+        text_logits = F.linear(out, self.text_linear)
+        return out, text_logits[:, None]
+
+    # -- weights --------------------------------------------------------------
+
+    def load_weights(self, state_dict: dict[str, torch.Tensor]) -> int:
+        """Load from the moshi checkpoint layout (fused, exact tensor reuse)."""
+        loaded = 0
+        with torch.no_grad():
+            for i, layer in enumerate(self.layers):
+                base = f"transformer.layers.{i}"
+                pairs = [
+                    (layer.in_proj_weight, f"{base}.self_attn.in_proj_weight"),
+                    (layer.out_proj_weight, f"{base}.self_attn.out_proj.weight"),
+                    (layer.gating_in, f"{base}.gating.linear_in.weight"),
+                    (layer.gating_out, f"{base}.gating.linear_out.weight"),
+                    (layer.norm1_alpha, f"{base}.norm1.alpha"),
+                    (layer.norm2_alpha, f"{base}.norm2.alpha"),
+                ]
+                for param, name in pairs:
+                    src = state_dict[name]
+                    param.data.copy_(src.reshape(param.shape).to(param.dtype))
+                    loaded += 1
+            self.out_norm_alpha.data.copy_(state_dict["out_norm.alpha"].reshape(self.out_norm_alpha.shape))
+            self.text_linear.data.copy_(state_dict["text_linear.weight"].to(self.text_linear.dtype))
+            loaded += 2
+        return loaded
diff --git a/vllm_omni/model_executor/models/personaplex/pipeline.py b/vllm_omni/model_executor/models/personaplex/pipeline.py
new file mode 100644
index 000000000..1865d4b3a
--- /dev/null
+++ b/vllm_omni/model_executor/models/personaplex/pipeline.py
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""PersonaPlex pipeline: Talker (AR decode -> Mimi codebooks) -> Code2Wav (codebooks -> 24 kHz PCM).
+
+PersonaPlex is a Moshi finetune (full-duplex speech-to-speech). For offline/batch
+runs it is served as a 2-stage vllm-omni audio->audio pipeline, reusing the
+Qwen3-TTS staged topology:
+
+* Stage 0 (``personaplex``) is the AR talker: the Helium temporal transformer
+  plus the depformer (both built by the lead). It emits the per-frame audio
+  codebooks as latents.
+* Stage 1 (``code2wav``) wraps the external Mimi codec and decodes the active
+  codebooks (``cb 0..7``) into PCM.
+
+The inter-stage input processors named below live in
+``vllm_omni.model_executor.stage_input_processors.personaplex`` and are part of
+the talker<->code2wav seam; they are built by the lead alongside the talker.
+"""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+# Talker<->Code2Wav input processors (built by lead; coupled to talker output).
+_PROC = "vllm_omni.model_executor.stage_input_processors.personaplex"
+
+PERSONAPLEX_PIPELINE = PipelineConfig(
+    model_type="personaplex",
+    # Pipeline-level default; the code2wav stage overrides per-stage below.
+    model_arch="PersonaPlexTalkerForConditionalGeneration",
+    default_deploy_config_name="personaplex.yaml",
+    duplex_runtime_extension=(
+        "vllm_omni.experimental.fullduplex.personaplex.runtime_extension.PersonaPlexDuplexRuntimeExtension"
+    ),
+    duplex_serving_adapter=(
+        "vllm_omni.experimental.fullduplex.personaplex.serving_adapter.PersonaPlexServingRuntimeAdapter"
+    ),
+    duplex_control_enabled=True,
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="personaplex",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            owns_tokenizer=True,
+            engine_output_type="latent",
+            # built by lead: talker emits a 17-row Mimi token stack per frame;
+            # these processors keep the PCM-bearing rows (cb 0..7) and flatten
+            # them codebook-major for the Code2Wav stage.
+            async_chunk_process_next_stage_input_func=(f"{_PROC}.talker2code2wav_async_chunk"),
+            custom_process_next_stage_input_func=f"{_PROC}.talker2code2wav_full_payload",
+            sampling_constraints={
+                "detokenize": False,
+            },
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="code2wav",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="PersonaPlexCode2Wav",
+            # In sync (non-async-chunk) mode the only pre-stage input proc is a
+            # length-only placeholder; the bulk codec payload ships via the
+            # worker connector from stage 0's full-payload producer.
+            # built by lead.
+            sync_process_input_func=f"{_PROC}.talker2code2wav_token_only",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py b/vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py
index b4ed8efee..4ce5ef207 100644
--- a/vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py
@@ -17,6 +17,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.qwen2_5_omni"
 
 QWEN2_5_OMNI_PIPELINE = PipelineConfig(
     model_type="qwen2_5_omni",
+    default_deploy_config_name="qwen2_5_omni.yaml",
     model_arch="Qwen2_5OmniForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py b/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
index d0df1c2ea..2648cacbd 100644
--- a/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
+++ b/vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
@@ -1,6 +1,8 @@
 """Thin Omni wrapper: reuse upstream Qwen2.5-Omni thinker with minimal overrides."""
 
-from collections.abc import Iterable, Iterator, Mapping
+import hashlib
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from functools import partial
 from typing import Any
 
 import numpy as np
@@ -15,6 +17,7 @@ from transformers.models.qwen2_5_omni.modeling_qwen2_5_omni import (
 )
 from vllm.config import VllmConfig
 from vllm.forward_context import set_forward_context
+from vllm.inputs import MultiModalHashes
 from vllm.logger import init_logger
 from vllm.model_executor.models.interfaces import (
     MultiModalEmbeddings,
@@ -28,6 +31,7 @@ from vllm.model_executor.models.qwen2_5_omni_thinker import (
     Qwen2_5OmniAudioFeatureInputs,
     Qwen2_5OmniThinkerDummyInputsBuilder,
     check_interleaved_audio_video,
+    create_qwen2_5_omni_thinker_field_factory,
     merge_interleaved_embeddings,
 )
 from vllm.model_executor.models.qwen2_5_omni_thinker import (
@@ -51,6 +55,9 @@ from vllm.model_executor.models.qwen2_5_vl import (
     Qwen2_5_VLVideoInputs,
     Qwen2_5_VLVideoPixelInputs,
 )
+from vllm.model_executor.models.qwen2_audio import (
+    _get_feat_extract_output_lengths,
+)
 from vllm.model_executor.models.utils import (
     AutoWeightsLoader,
     WeightsMapper,
@@ -60,12 +67,19 @@ from vllm.model_executor.models.utils import (
 from vllm.multimodal import MULTIMODAL_REGISTRY
 from vllm.multimodal.inputs import (
     MultiModalFeatureSpec,
+    MultiModalFieldConfig,
     MultiModalKwargsItems,
 )
-from vllm.multimodal.parse import MultiModalDataItems, VideoProcessorItems
+from vllm.multimodal.parse import AudioProcessorItems, MultiModalDataItems, VideoProcessorItems
+from vllm.multimodal.processing.context import TimingContext
+from vllm.multimodal.processing.inputs import ProcessorInputs
 from vllm.multimodal.processing.processor import (
+    MultiModalProcessingInfo,
     MultiModalPromptUpdates,
     PlaceholderFeaturesInfo,
+    PromptReplacement,
+    PromptUpdate,
+    PromptUpdateDetails,
 )
 from vllm.sequence import IntermediateTensors
 from vllm.utils.collection_utils import is_list_of
@@ -80,6 +94,158 @@ except (ImportError, ModuleNotFoundError):
     flash_attn = None
 logger = init_logger(__name__)
 
+_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY = "_vllm_omni_per_video_use_audio_in_video"
+
+
+def _normalize_use_audio_in_video(
+    value: object,
+    num_videos: int,
+) -> list[bool]:
+    if isinstance(value, torch.Tensor):
+        if value.numel() == 1:
+            return [bool(value.item())] * num_videos
+        values = value.flatten().tolist()
+    elif isinstance(value, np.ndarray):
+        if value.size == 1:
+            return [bool(value.item())] * num_videos
+        values = value.flatten().tolist()
+    elif isinstance(value, bool):
+        return [value] * num_videos
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        values = list(value)
+    else:
+        return [bool(value)] * num_videos
+
+    if len(values) != num_videos:
+        raise ValueError(
+            "use_audio_in_video must be a boolean or contain one boolean per "
+            f"video, but found {len(values)} values for {num_videos} videos."
+        )
+    return [bool(v) for v in values]
+
+
+def _normalize_per_video_use_audio_in_video(value: object) -> list[bool]:
+    if isinstance(value, torch.Tensor):
+        values = value.flatten().tolist()
+    elif isinstance(value, np.ndarray):
+        values = value.flatten().tolist()
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        values = list(value)
+    else:
+        values = [value]
+    return [bool(v) for v in values]
+
+
+def _is_per_video_use_audio_in_video(value: object) -> bool:
+    if isinstance(value, bool):
+        return False
+    if isinstance(value, torch.Tensor):
+        return value.numel() != 1
+    if isinstance(value, np.ndarray):
+        return value.size != 1
+    return isinstance(value, Sequence) and not isinstance(value, (str, bytes))
+
+
+def _get_request_video_use_audio_in_video(
+    hf_processor_mm_kwargs: Mapping[str, object],
+    num_videos: int,
+) -> list[bool]:
+    value = hf_processor_mm_kwargs.get(
+        _PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY,
+        hf_processor_mm_kwargs.get("use_audio_in_video", False),
+    )
+    return _normalize_use_audio_in_video(value, num_videos)
+
+
+def _prompt_update_has_audio_token(
+    mm_prompt_updates: MultiModalPromptUpdates,
+    item_idx: int,
+    audio_token_id: int,
+) -> bool:
+    updates = mm_prompt_updates.get("video", [])
+    if item_idx >= len(updates):
+        return False
+    return any(
+        audio_token_id in update.content.full for update in updates[item_idx] if isinstance(update.content.full, list)
+    )
+
+
+def _get_video_second_per_grid_t(
+    out_mm_data: Mapping[str, object],
+    hf_processor_mm_kwargs: Mapping[str, object],
+    item_idx: int,
+    default: float,
+) -> float:
+    second_per_grid_ts = out_mm_data.get("second_per_grid_ts")
+    if second_per_grid_ts is None:
+        second_per_grid_ts = hf_processor_mm_kwargs.get("second_per_grid_ts", None)
+    if second_per_grid_ts is None:
+        return default
+
+    if isinstance(second_per_grid_ts, torch.Tensor):
+        if second_per_grid_ts.numel() == 1:
+            return float(second_per_grid_ts.item())
+        return float(second_per_grid_ts.flatten()[item_idx].item())
+
+    if isinstance(second_per_grid_ts, np.ndarray):
+        if second_per_grid_ts.size == 1:
+            return float(second_per_grid_ts.item())
+        return float(second_per_grid_ts.flatten()[item_idx].item())
+
+    if isinstance(second_per_grid_ts, Sequence) and not isinstance(second_per_grid_ts, (str, bytes)):
+        return float(second_per_grid_ts[item_idx])
+
+    return float(second_per_grid_ts)
+
+
+def _filter_video_use_audio_in_video_for_uncached_items(
+    hf_processor_mm_kwargs: Mapping[str, object],
+    video_is_cached: Sequence[bool] | None,
+) -> Mapping[str, object]:
+    use_audio_in_video = hf_processor_mm_kwargs.get(
+        _PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY,
+        hf_processor_mm_kwargs.get("use_audio_in_video"),
+    )
+    if video_is_cached is None or not _is_per_video_use_audio_in_video(use_audio_in_video):
+        return hf_processor_mm_kwargs
+
+    mask = _normalize_use_audio_in_video(use_audio_in_video, len(video_is_cached))
+    missing_mask = [use_audio for use_audio, is_cached in zip(mask, video_is_cached) if not is_cached]
+
+    filtered_kwargs = dict(hf_processor_mm_kwargs)
+    filtered_kwargs["use_audio_in_video"] = missing_mask
+    filtered_kwargs[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] = missing_mask
+    second_per_grid_ts = hf_processor_mm_kwargs.get("second_per_grid_ts")
+    if (
+        isinstance(second_per_grid_ts, Sequence)
+        and not isinstance(second_per_grid_ts, (str, bytes))
+        and len(second_per_grid_ts) == len(video_is_cached)
+    ):
+        filtered_kwargs["second_per_grid_ts"] = [
+            second_per_grid_t
+            for second_per_grid_t, is_cached in zip(second_per_grid_ts, video_is_cached)
+            if not is_cached
+        ]
+    return filtered_kwargs
+
+
+def _coerce_use_audio_in_video_for_hf_processor(
+    mm_data: Mapping[str, object],
+    mm_kwargs: Mapping[str, object],
+) -> Mapping[str, object]:
+    use_audio_in_video = mm_kwargs.get("use_audio_in_video")
+    if not _is_per_video_use_audio_in_video(use_audio_in_video):
+        return mm_kwargs
+
+    video_use_audio_in_video = _normalize_per_video_use_audio_in_video(use_audio_in_video)
+
+    hf_mm_kwargs = dict(mm_kwargs)
+    # HF processors only support a global bool. For per-video masks, vLLM
+    # consumes the list while building prompt updates and placeholders.
+    hf_mm_kwargs["use_audio_in_video"] = False
+    hf_mm_kwargs[_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY] = video_use_audio_in_video
+    return hf_mm_kwargs
+
 
 def _presampled_videos_hf_kwargs(
     mm_data: Mapping[str, object],
@@ -87,12 +253,9 @@ def _presampled_videos_hf_kwargs(
 ) -> Mapping[str, object]:
     """Adjust HF video kwargs for videos pre-sampled by vLLM's video loader.
 
-    When ``video_metadata`` is present (emitted by
-    ``Qwen2_5OmniVideoProcessorItems``), the frames were already sampled
-    according to ``media_io_kwargs``, so the HF processor must not re-sample
-    them, and it needs the sampled fps (instead of its default) to compute
-    ``video_second_per_grid`` correctly. Otherwise the audio/video temporal
-    alignment breaks under ``use_audio_in_video=True``.
+    When ``video_metadata`` is present, the frames were already sampled
+    according to ``media_io_kwargs``. The HF processor should not resample
+    them and should use the sampled fps when computing temporal metadata.
     """
     video_metadata = mm_data.get("video_metadata")
     if not video_metadata:
@@ -109,18 +272,17 @@ def _presampled_videos_hf_kwargs(
             return None
         return len(indices) / float(duration)
 
-    # An explicit user-provided fps takes precedence.
     if "fps" not in videos_kwargs:
         fps_values = [_compute_sampled_video_fps(m) for m in video_metadata]
-        # HF accepts a single fps per call and uses it for every video's
-        # video_second_per_grid.
         known_fps = [fps for fps in fps_values if fps is not None]
         unique_fps = set(known_fps)
         if len(unique_fps) == 1:
             videos_kwargs["fps"] = known_fps[0]
         elif len(unique_fps) > 1:
             logger.warning(
-                f"Mixed sampled FPS {sorted(unique_fps)} in one request; HF accepts a single fps, using {known_fps[0]}."
+                "Mixed sampled FPS %s in one request; HF accepts a single fps, using %s.",
+                sorted(unique_fps),
+                known_fps[0],
             )
             videos_kwargs["fps"] = known_fps[0]
 
@@ -129,12 +291,7 @@ def _presampled_videos_hf_kwargs(
 
 
 class Qwen2_5OmniVideoProcessorItems(VideoProcessorItems):
-    """Video items that carry the loader's ``(frames, metadata)`` tuples.
-
-    The tuples are kept in ``data`` so that mm hashing and cache-miss
-    re-parsing retain the metadata; ``get_processor_data`` unpacks them into
-    the ``videos`` + ``video_metadata`` arguments of the HF processor.
-    """
+    """Video items that carry the loader's ``(frames, metadata)`` tuples."""
 
     def get_processor_data(self) -> Mapping[str, object]:
         from transformers.video_utils import VideoMetadata
@@ -151,7 +308,6 @@ class Qwen2_5OmniThinkerMultiModalDataParser(_Qwen2_5OmniThinkerMultiModalDataPa
         if data is None or isinstance(data, dict) or self.is_embeddings(data):
             return super()._parse_video_data(data)
 
-        # Normalize to a list of per-video items (same as the base parser).
         if (is_list_of(data, PILImage.Image) and len(data) > 0) or (
             isinstance(data, (np.ndarray, torch.Tensor)) and data.ndim == 4
         ):
@@ -164,11 +320,6 @@ class Qwen2_5OmniThinkerMultiModalDataParser(_Qwen2_5OmniThinkerMultiModalDataPa
             data_items = data
 
         videos_with_metadata = [self._get_video_with_metadata(item) for item in data_items]
-
-        # Metadata is optional: videos fetched by vLLM's media connector
-        # arrive as (frames, metadata) tuples, while plain arrays (e.g.
-        # offline `multi_modal_data` or dummy profiling inputs) carry no
-        # metadata and parse as before.
         if any(metadata is None for _, metadata in videos_with_metadata):
             return super()._parse_video_data(data)
 
@@ -195,14 +346,6 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
 ):
     """Override to fix use_audio_in_video detection when mm cache returns None."""
 
-    def _cached_apply_hf_processor(self, inputs, timing_ctx):
-        # If use_audio_in_video, process video and audio together; otherwise,
-        # skip cache to avoid errors.
-        # Prevents partial cache hits from causing processing failures.
-        if inputs.hf_processor_mm_kwargs.get("use_audio_in_video"):
-            return self._apply_hf_processor(inputs, timing_ctx)
-        return super()._cached_apply_hf_processor(inputs, timing_ctx)
-
     def _call_hf_processor(
         self,
         prompt: str,
@@ -211,12 +354,413 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
         tok_kwargs: Mapping[str, object],
     ):
         mm_kwargs = _presampled_videos_hf_kwargs(mm_data, mm_kwargs)
-        return super()._call_hf_processor(
+        mm_kwargs = _coerce_use_audio_in_video_for_hf_processor(mm_data, mm_kwargs)
+        hf_inputs = super()._call_hf_processor(
             prompt=prompt,
             mm_data=mm_data,
             mm_kwargs=mm_kwargs,
             tok_kwargs=tok_kwargs,
         )
+        per_video_mask = mm_kwargs.get(_PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY)
+        if per_video_mask is not None:
+            hf_inputs["use_audio_in_video"] = torch.tensor(per_video_mask)
+        return hf_inputs
+
+    def _get_mm_fields_config(
+        self,
+        hf_inputs,
+        hf_processor_mm_kwargs: Mapping[str, object],
+    ) -> Mapping[str, MultiModalFieldConfig]:
+        fields_config = dict(
+            create_qwen2_5_omni_thinker_field_factory(self.info.get_hf_config().vision_config.spatial_merge_size)(
+                hf_inputs
+            )
+        )
+        use_audio_in_video = hf_inputs.get("use_audio_in_video")
+        is_batched_mask = isinstance(use_audio_in_video, torch.Tensor) and use_audio_in_video.numel() > 1
+        if _PER_VIDEO_USE_AUDIO_IN_VIDEO_KEY in hf_processor_mm_kwargs or is_batched_mask:
+            fields_config["use_audio_in_video"] = MultiModalFieldConfig.batched("video")
+        return fields_config
+
+    def _get_video_use_audio_in_video(
+        self,
+        mm_kwargs: MultiModalKwargsItems,
+        mm_prompt_updates: MultiModalPromptUpdates,
+    ) -> list[bool]:
+        video_kwargs = mm_kwargs.get("video", [])
+        if not video_kwargs:
+            return []
+
+        audio_token_id = self.info.get_hf_config().audio_token_id
+        video_use_audio_in_video = []
+        has_use_audio_in_video = any(item is not None and "use_audio_in_video" in item for item in video_kwargs)
+        for item_idx, item in enumerate(video_kwargs):
+            if has_use_audio_in_video:
+                if item is None or "use_audio_in_video" not in item:
+                    video_use_audio_in_video.append(
+                        _prompt_update_has_audio_token(
+                            mm_prompt_updates,
+                            item_idx,
+                            audio_token_id,
+                        )
+                    )
+                    continue
+                use_audio_in_video_tensor = item["use_audio_in_video"].data
+                if use_audio_in_video_tensor.numel() > 0:
+                    video_use_audio_in_video.append(bool(use_audio_in_video_tensor.item()))
+                    continue
+                video_use_audio_in_video.append(False)
+                continue
+
+            video_use_audio_in_video.append(
+                _prompt_update_has_audio_token(
+                    mm_prompt_updates,
+                    item_idx,
+                    audio_token_id,
+                )
+            )
+
+        return video_use_audio_in_video
+
+    def _get_prompt_updates(
+        self,
+        mm_items: MultiModalDataItems,
+        hf_processor_mm_kwargs: Mapping[str, Any],
+        out_mm_kwargs: MultiModalKwargsItems,
+    ) -> Sequence[PromptUpdate]:
+        processor = self.info.get_hf_processor(**hf_processor_mm_kwargs)
+        tokenizer = self.info.get_tokenizer()
+        image_processor = self.info.get_image_processor(**hf_processor_mm_kwargs)
+        vocab = tokenizer.get_vocab()
+
+        audio_token = processor.audio_token
+        image_token = processor.image_token
+        video_token = processor.video_token
+        audio_token_id = vocab[audio_token]
+        image_token_id = vocab[image_token]
+        video_token_id = vocab[video_token]
+
+        out_mm_data = out_mm_kwargs.get_data()
+        audio_feature_lengths = out_mm_data.get("audio_feature_lengths")
+        feature_attention_mask = out_mm_data.get("feature_attention_mask")
+        if audio_feature_lengths is None and feature_attention_mask is None:
+            audio_output_lengths = []
+        elif audio_feature_lengths is not None:
+            _, audio_output_lens = _get_feat_extract_output_lengths(audio_feature_lengths)
+            audio_output_lengths = audio_output_lens.tolist()
+        elif feature_attention_mask is not None:
+            assert isinstance(feature_attention_mask, torch.Tensor)
+            _, audio_output_lens = _get_feat_extract_output_lengths(feature_attention_mask.sum(-1))
+            audio_output_lengths = audio_output_lens.tolist()
+
+        audio_in_video_item_idx = 0
+
+        def get_replacement_qwen2_audio(item_idx: int):
+            item_idx += audio_in_video_item_idx
+
+            num_features = audio_output_lengths[item_idx]
+            if num_features == 0:
+                audios = mm_items.get_items("audio", AudioProcessorItems)
+                audio = audios.get(item_idx)
+                raise ValueError(
+                    f"The audio {audio} (len={len(audio)}) is too short to be represented inside the model"
+                )
+
+            return [audio_token_id] * num_features
+
+        def get_replacement_qwen2_vision(item_idx: int, modality: str):
+            grid_thw = out_mm_data[f"{modality}_grid_thw"][item_idx]
+            assert isinstance(grid_thw, torch.Tensor)
+            merge_length = image_processor.merge_size**2
+
+            token_id = image_token_id if modality == "image" else video_token_id
+            return [token_id] * (int(grid_thw.prod()) // merge_length)
+
+        num_videos = mm_items.get_all_counts().get("video", 0)
+        video_use_audio_in_video = _get_request_video_use_audio_in_video(
+            hf_processor_mm_kwargs,
+            num_videos,
+        )
+        thinker_config = self.info.get_hf_config()
+
+        def get_replacement_qwen2_video(item_idx: int):
+            nonlocal audio_in_video_item_idx
+
+            if not video_use_audio_in_video[item_idx]:
+                return get_replacement_qwen2_vision(item_idx, modality="video")
+
+            audio_num_features = audio_output_lengths[audio_in_video_item_idx]
+            video_grid_thw = out_mm_data["video_grid_thw"][item_idx]
+
+            audio_in_video_item_idx += 1
+
+            video_second_per_grid_t = _get_video_second_per_grid_t(
+                out_mm_data,
+                hf_processor_mm_kwargs,
+                item_idx,
+                default=1.0,
+            )
+
+            updates = self.omni_get_updates_use_audio_in_video(
+                thinker_config=thinker_config,
+                audio_len=audio_num_features,
+                video_grid_thw=video_grid_thw,
+                video_second_per_grid_t=video_second_per_grid_t,
+            )
+
+            return PromptUpdateDetails.select_token_id(
+                seq=updates,
+                embed_token_id=video_token_id,
+            )
+
+        return [
+            PromptReplacement(
+                modality="audio",
+                target=audio_token,
+                replacement=get_replacement_qwen2_audio,
+            ),
+            PromptReplacement(
+                modality="image",
+                target=image_token,
+                replacement=partial(get_replacement_qwen2_vision, modality="image"),
+            ),
+            PromptReplacement(
+                modality="video",
+                target=video_token,
+                replacement=get_replacement_qwen2_video,
+            ),
+        ]
+
+    def _apply_hf_processor_mm_only(
+        self,
+        mm_items: MultiModalDataItems,
+        hf_processor_mm_kwargs: Mapping[str, object],
+        tokenization_kwargs: Mapping[str, object],
+    ):
+        mm_counts = mm_items.get_all_counts()
+
+        if "video" in mm_counts:
+            video_use_audio_in_video = _get_request_video_use_audio_in_video(
+                hf_processor_mm_kwargs,
+                mm_counts["video"],
+            )
+            if any(video_use_audio_in_video):
+                assert "audio" in mm_counts
+                mm_counts["audio"] -= sum(video_use_audio_in_video)
+
+        _, mm_processed_data, _ = self._apply_hf_processor_text_mm(
+            prompt_text=self.dummy_inputs.get_dummy_text(mm_counts),
+            mm_items=mm_items,
+            hf_processor_mm_kwargs=hf_processor_mm_kwargs,
+            tokenization_kwargs=tokenization_kwargs,
+        )
+
+        return mm_processed_data
+
+    def _get_audio_in_video_pairs(
+        self,
+        mm_data_items: MultiModalDataItems,
+        hf_processor_mm_kwargs: Mapping[str, object],
+    ) -> list[tuple[int, int]]:
+        """``(video_idx, audio_idx)`` pairs the HF processor handles as one
+        indivisible unit when the audio track is interleaved into the video.
+
+        Pairing follows omni's per-video mask convention: the j-th video with
+        ``use_audio_in_video=True`` pairs with ``audio[j]``.
+        """
+        num_videos = mm_data_items.get_count("video", strict=False)
+        num_audios = mm_data_items.get_count("audio", strict=False)
+        if num_videos == 0 or num_audios == 0:
+            return []
+
+        video_use_audio_in_video = _get_request_video_use_audio_in_video(
+            hf_processor_mm_kwargs,
+            num_videos,
+        )
+        videos_using_audio = [video_idx for video_idx, uses_audio in enumerate(video_use_audio_in_video) if uses_audio]
+        return list(zip(videos_using_audio, range(num_audios)))
+
+    @staticmethod
+    def _paired_cache_keys(
+        mm_hashes: MultiModalHashes,
+        aiv_pairs: list[tuple[int, int]],
+    ) -> MultiModalHashes:
+        """Processor-cache keys in which each paired video/audio key
+        incorporates the hash of both members, so a pair is reused only when
+        both match and any change misses the pair together. Semantic
+        ``mm_hashes`` are left untouched.
+        """
+        if not aiv_pairs:
+            return mm_hashes
+
+        mm_cache_keys = {modality: list(hashes) for modality, hashes in mm_hashes.items()}
+        for video_idx, audio_idx in aiv_pairs:
+            video_hash = mm_hashes["video"][video_idx]
+            audio_hash = mm_hashes["audio"][audio_idx]
+            pair_token = hashlib.sha256(f"{video_hash}\0{audio_hash}".encode()).hexdigest()[:16]
+            mm_cache_keys["video"][video_idx] = f"{video_hash}-aiv-{pair_token}"
+            mm_cache_keys["audio"][audio_idx] = f"{audio_hash}-aiv-{pair_token}"
+        return mm_cache_keys
+
+    def _cached_apply_hf_processor(
+        self,
+        inputs: ProcessorInputs,
+        timing_ctx: TimingContext,
+    ) -> tuple[list[int], MultiModalProcessingInfo, bool]:
+        """Cache-aware: processes video/audio pairs as units,
+        using pair-specific cache keys. Falls back to standard cache if no pairs."""
+
+        cache = self.cache
+
+        _, passthrough_data = self._get_hf_mm_data(inputs.mm_data_items)
+        if cache is None or passthrough_data:
+            return self._apply_hf_processor(inputs, timing_ctx)
+
+        aiv_pairs = self._get_audio_in_video_pairs(
+            inputs.mm_data_items,
+            inputs.hf_processor_mm_kwargs,
+        )
+
+        with timing_ctx.record("get_mm_hashes"):
+            mm_hashes = inputs.get_mm_hashes(self.info.model_id)
+
+        mm_cache_keys = self._paired_cache_keys(mm_hashes, aiv_pairs)
+
+        with timing_ctx.record("get_cache_missing_items"):
+            mm_is_cached = {modality: list(cache.is_cached(keys)) for modality, keys in mm_cache_keys.items()}
+            # A pair is one HF processing unit: if either member misses the
+            # cache (including LRU evicting just one), reprocess both.
+            for video_idx, audio_idx in aiv_pairs:
+                if not (mm_is_cached["video"][video_idx] and mm_is_cached["audio"][audio_idx]):
+                    mm_is_cached["video"][video_idx] = False
+                    mm_is_cached["audio"][audio_idx] = False
+
+            # TODO: Inlined from BaseMultiModalProcessor._get_cache_missing_items
+            # (pair expansion must run after is_cached); keep in sync with vLLM.
+            mm_missing_data = {}
+            for modality, items_is_cached in mm_is_cached.items():
+                missing_modality_data = []
+                for idx, item_is_cached in enumerate(items_is_cached):
+                    if item_is_cached:
+                        continue
+                    data = inputs.mm_data_items[modality][idx]
+                    if data is None:
+                        raise ValueError(f"Cache miss for {modality} at index {idx} but data is not provided.")
+                    missing_modality_data.append(data)
+                mm_missing_data[modality] = missing_modality_data
+            mm_missing_data_items = self.info.parse_mm_data(mm_missing_data, validate=False)
+
+        hf_processor_mm_kwargs = _filter_video_use_audio_in_video_for_uncached_items(
+            inputs.hf_processor_mm_kwargs,
+            mm_is_cached.get("video"),
+        )
+
+        with timing_ctx.record("apply_hf_processor"):
+            (
+                prompt_ids,
+                mm_missing_processed_data,
+                is_update_applied,
+            ) = self._apply_hf_processor_main(
+                prompt=inputs.prompt,
+                mm_items=mm_missing_data_items,
+                hf_processor_mm_kwargs=hf_processor_mm_kwargs,
+                tokenization_kwargs=inputs.tokenization_kwargs,
+                enable_hf_prompt_update=False,
+            )
+
+        mm_missing_kwargs = MultiModalKwargsItems.from_hf_inputs(
+            mm_missing_processed_data,
+            self._get_mm_fields_config(
+                mm_missing_processed_data,
+                hf_processor_mm_kwargs,
+            ),
+        )
+
+        mm_missing_prompt_updates = self._get_mm_prompt_updates(
+            mm_missing_data_items,
+            hf_processor_mm_kwargs,
+            mm_missing_kwargs,
+        )
+
+        with timing_ctx.record("merge_mm_kwargs"):
+            mm_kwargs, mm_prompt_updates = self._merge_mm_kwargs(
+                cache,
+                mm_hashes=mm_cache_keys,
+                mm_is_cached=mm_is_cached,
+                mm_missing_kwargs=mm_missing_kwargs,
+                mm_missing_prompt_updates=mm_missing_prompt_updates,
+            )
+
+        mm_info = MultiModalProcessingInfo(
+            kwargs=mm_kwargs,
+            hashes=mm_hashes,
+            prompt_updates=mm_prompt_updates,
+        )
+
+        return prompt_ids, mm_info, is_update_applied
+
+    def _derive_audio_from_video_placeholders(
+        self,
+        placeholders: Mapping[str, list[PlaceholderFeaturesInfo]],
+        mm_prompt_updates: MultiModalPromptUpdates,
+        video_use_audio_in_video: Sequence[bool] | None = None,
+    ) -> Mapping[str, list[PlaceholderFeaturesInfo]]:
+        if "video" not in placeholders:
+            return placeholders
+
+        num_videos = len(placeholders["video"])
+        if video_use_audio_in_video is None:
+            video_use_audio_in_video = [True] * num_videos
+        elif len(video_use_audio_in_video) != num_videos:
+            raise ValueError(
+                "use_audio_in_video must contain one boolean per video, "
+                f"but found {len(video_use_audio_in_video)} values for "
+                f"{num_videos} videos."
+            )
+
+        num_audio_in_video = sum(video_use_audio_in_video)
+        num_audios = len(mm_prompt_updates.get("audio", []))
+        if num_audios != num_audio_in_video:
+            raise ValueError(
+                "use_audio_in_video requires equal number of audio and video "
+                f"items using audio, got {num_audios=}, {num_audio_in_video=}"
+            )
+
+        tokenizer = self.info.get_tokenizer()
+        processor = self.info.get_hf_processor()
+        audio_token_id = tokenizer.get_vocab()[processor.audio_token]
+
+        result_placeholders = dict(placeholders)
+        audio_placeholders = []
+        video_placeholders = []
+
+        audio_idx = 0
+        for video_idx, video_placeholder in enumerate(placeholders["video"]):
+            audio_is_embed = torch.tensor(video_placeholder.tokens) == audio_token_id
+
+            if video_use_audio_in_video[video_idx]:
+                audio_placeholder = PlaceholderFeaturesInfo(
+                    modality="audio",
+                    item_idx=audio_idx,
+                    start_idx=video_placeholder.start_idx,
+                    tokens=video_placeholder.tokens,
+                    is_embed=audio_is_embed,
+                )
+                audio_placeholders.append(audio_placeholder)
+                audio_idx += 1
+
+            video_placeholder_with_mask = PlaceholderFeaturesInfo(
+                modality="video",
+                item_idx=video_idx,
+                start_idx=video_placeholder.start_idx,
+                tokens=video_placeholder.tokens,
+                is_embed=~audio_is_embed,
+            )
+            video_placeholders.append(video_placeholder_with_mask)
+
+        result_placeholders["audio"] = audio_placeholders
+        result_placeholders["video"] = video_placeholders
+        return result_placeholders
 
     def _maybe_apply_prompt_updates(
         self,
@@ -230,24 +774,8 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
         self._validate_mm_kwargs(mm_kwargs, mm_item_counts)
         self._validate_mm_updates(mm_prompt_updates, mm_item_counts)
 
-        # Detect use_audio_in_video from mm_kwargs
-        use_audio_in_video = False
-        if "video" in mm_kwargs:
-            for item in mm_kwargs["video"]:
-                if item and item.get("use_audio_in_video"):
-                    use_audio_in_video_tensor = item["use_audio_in_video"].data
-                    if use_audio_in_video_tensor.numel() > 0:
-                        use_audio_in_video = bool(use_audio_in_video_tensor.item())
-                        break
-            # for mutilmodality cache
-            if any(item is None for item in mm_kwargs["video"]):
-                video_token_id = self.info.get_hf_config().video_token_id
-                audio_token_id = self.info.get_hf_config().audio_token_id
-                video_audio_item_num = sum(id in (video_token_id, audio_token_id) for id in prompt_ids)
-                audio_updates_num = len(mm_prompt_updates.get("audio", []))
-                video_updates_num = len(mm_prompt_updates.get("video", []))
-                if video_audio_item_num != video_updates_num + audio_updates_num:
-                    use_audio_in_video = True
+        video_use_audio_in_video = self._get_video_use_audio_in_video(mm_kwargs, mm_prompt_updates)
+        use_audio_in_video = any(video_use_audio_in_video)
 
         if is_update_applied:
             mm_placeholders = self._find_mm_placeholders(
@@ -265,7 +793,11 @@ class Qwen2_5OmniThinkerMultiModalProcessor(
                     prompt_ids,
                     filtered_updates,
                 )
-                mm_placeholders = self._derive_audio_from_video_placeholders(mm_placeholders, mm_prompt_updates)
+                mm_placeholders = self._derive_audio_from_video_placeholders(
+                    mm_placeholders,
+                    mm_prompt_updates,
+                    video_use_audio_in_video,
+                )
             else:
                 prompt_ids, mm_placeholders = self._apply_prompt_updates(
                     prompt_ids,
@@ -810,8 +1342,6 @@ class Qwen2_5OmniThinkerForConditionalGeneration(
                 is_video,
                 is_audio,
                 is_multimodal,
-                num_video,
-                num_audio,
             )
 
         # Default: standard merge (no interleaving), same as parent class
diff --git a/vllm_omni/model_executor/models/qwen3_omni/pipeline.py b/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
index ca3a09f89..c93e764ef 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/pipeline.py
@@ -21,6 +21,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.qwen3_omni"
 
 QWEN3_OMNI_PIPELINE = PipelineConfig(
     model_type="qwen3_omni_moe",
+    default_deploy_config_name="qwen3_omni_moe.yaml",
     model_arch="Qwen3OmniMoeForConditionalGeneration",
     endpoint_restrictions=(
         EndpointRestriction(
@@ -87,7 +88,7 @@ QWEN3_OMNI_THINKER_ONLY_PIPELINE = PipelineConfig(
             owns_tokenizer=True,
             requires_multimodal_data=True,
             hf_config_name="thinker_config",
-            engine_output_type="latent",
+            engine_output_type="text",
             sampling_constraints={"detokenize": True},
         ),
     ),
diff --git a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
index 011496f86..f7d0553d4 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py
@@ -114,6 +114,7 @@ from vllm.multimodal.processing.processor import (
     PromptUpdate,
     PromptUpdateDetails,
 )
+from vllm.multimodal.utils import set_mm_embedding_modality
 from vllm.sequence import IntermediateTensors
 from vllm.transformers_utils.processor import cached_processor_from_config
 
@@ -121,6 +122,8 @@ from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
     Qwen2_5OmniConditionalGenerationMixin,
     Qwen2_5OmniThinkerMultiModalDataParser,
     Qwen2_5OmniThinkerMultiModalProcessor,
+    _get_request_video_use_audio_in_video,
+    _get_video_second_per_grid_t,
     _presampled_videos_hf_kwargs,
 )
 from vllm_omni.quantization.component_config import (
@@ -135,6 +138,14 @@ except (ImportError, ModuleNotFoundError):
 
 logger = init_logger(__name__)
 
+_THINKER_ARCHITECTURE = "Qwen3OmniMoeThinkerForConditionalGeneration"
+
+
+def _ensure_thinker_architecture(config: PretrainedConfig) -> None:
+    """Give the nested Thinker config the architecture required by MoE LoRA."""
+    if not config.architectures:
+        config.architectures = [_THINKER_ARCHITECTURE]
+
 
 class Qwen3Omni_VisionTransformer(_Qwen3Omni_VisionTransformer):
     """Subclass that fixes Qwen2_5_VisionAttention.forward() compatibility.
@@ -626,9 +637,6 @@ class Qwen3OmniMoeThinkerProcessingInfo(Qwen2AudioProcessingInfo, Qwen2_5_VLProc
     def get_data_parser(self):
         feature_extractor = self.get_feature_extractor()
 
-        # Install the Omni parser, which keeps video metadata from vLLM's
-        # video loader (see Qwen2_5OmniVideoProcessorItems); the parser
-        # inherited from Qwen2AudioProcessingInfo would drop it.
         return Qwen2_5OmniThinkerMultiModalDataParser(
             spatial_merge_size=self.get_hf_config().vision_config.spatial_merge_size,
             target_sr=feature_extractor.sampling_rate,
@@ -686,10 +694,8 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
         tok_kwargs: Mapping[str, object],
     ) -> BatchFeature:
         mm_data = dict(mm_data)
-        mm_kwargs = dict(mm_kwargs)
-        audios = mm_data.pop("audios", [])
-
         mm_kwargs = dict(_presampled_videos_hf_kwargs(mm_data, mm_kwargs))
+        audios = mm_data.pop("audios", [])
 
         def pad_to_hop_length(x: np.ndarray, hop_length: int) -> np.ndarray:
             length = x.shape[-1]
@@ -787,22 +793,8 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
         mm_item_counts = mm_items.get_all_counts()
         self._validate_mm_kwargs(mm_kwargs, mm_item_counts)
 
-        use_audio_in_video = False
-        if "video" in mm_kwargs:
-            for item in mm_kwargs["video"]:
-                if item and item["use_audio_in_video"].data:
-                    use_audio_in_video = True
-                else:
-                    use_audio_in_video = False
-            # for mutilmodality cache
-            if any(item is None for item in mm_kwargs["video"]):
-                video_token_id = self.info.get_hf_config().video_token_id
-                audio_token_id = self.info.get_hf_config().audio_token_id
-                video_audio_item_num = sum(id in (video_token_id, audio_token_id) for id in prompt_ids)
-                audio_updates_num = len(mm_prompt_updates.get("audio", []))
-                video_updates_num = len(mm_prompt_updates.get("video", []))
-                if video_audio_item_num != video_updates_num + audio_updates_num:
-                    use_audio_in_video = True
+        video_use_audio_in_video = self._get_video_use_audio_in_video(mm_kwargs, mm_prompt_updates)
+        use_audio_in_video = any(video_use_audio_in_video)
 
         # normal case with `use_audio_in_video=False`
         if is_update_applied:
@@ -821,7 +813,11 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
                     prompt_ids,
                     filtered_updates,
                 )
-                mm_placeholders = self._derive_audio_from_video_placeholders(mm_placeholders, mm_prompt_updates)
+                mm_placeholders = self._derive_audio_from_video_placeholders(
+                    mm_placeholders,
+                    mm_prompt_updates,
+                    video_use_audio_in_video,
+                )
             else:
                 prompt_ids, mm_placeholders = self._apply_prompt_updates(
                     prompt_ids,
@@ -935,25 +931,30 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
             token_id = image_token_id if modality == "image" else video_token_id
             return [token_id] * (int(grid_thw.prod()) // merge_length)
 
-        use_audio_in_video = hf_processor_mm_kwargs.get("use_audio_in_video", False)
+        num_videos = len(out_mm_data.get("video_grid_thw", []))
+        video_use_audio_in_video = _get_request_video_use_audio_in_video(
+            hf_processor_mm_kwargs,
+            num_videos,
+        )
         thinker_config = self.info.get_hf_config()
 
-        def get_replacement_qwen2_use_audio_in_video(item_idx: int):
+        def get_replacement_qwen2_video(item_idx: int):
             nonlocal audio_in_video_item_idx
+
+            if not video_use_audio_in_video[item_idx]:
+                return get_replacement_qwen2_vision(item_idx, modality="video")
+
             audio_num_features = audio_output_lengths[audio_in_video_item_idx]
             video_grid_thw = out_mm_data["video_grid_thw"][item_idx]
 
             audio_in_video_item_idx += 1
 
-            # Prefer the HF-computed value (temporal_patch_size / sampled fps)
-            # over request kwargs;
-            second_per_grid_ts = out_mm_data.get("second_per_grid_ts")
-            if second_per_grid_ts is None:
-                second_per_grid_ts = hf_processor_mm_kwargs.get("second_per_grid_ts", None)
-            if second_per_grid_ts is not None:
-                video_second_per_grid_t = float(second_per_grid_ts[item_idx])
-            else:
-                video_second_per_grid_t = 2.0
+            video_second_per_grid_t = _get_video_second_per_grid_t(
+                out_mm_data,
+                hf_processor_mm_kwargs,
+                item_idx,
+                default=2.0,
+            )
 
             placeholder = self.get_updates_use_audio_in_video(
                 thinker_config=thinker_config,
@@ -963,12 +964,6 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
             )
             return PromptUpdateDetails.select_token_id(placeholder, embed_token_id=video_token_id)
 
-        video_replacement_fn = (
-            get_replacement_qwen2_use_audio_in_video
-            if use_audio_in_video
-            else partial(get_replacement_qwen2_vision, modality="video")
-        )
-
         return [
             PromptReplacement(
                 modality="audio",
@@ -983,7 +978,7 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
             PromptReplacement(
                 modality="video",
                 target=video_token,
-                replacement=video_replacement_fn,
+                replacement=get_replacement_qwen2_video,
             ),
         ]
 
@@ -991,6 +986,7 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
         self,
         placeholders: Mapping[str, list[PlaceholderFeaturesInfo]],
         mm_prompt_updates: MultiModalPromptUpdates,
+        video_use_audio_in_video: Sequence[bool] | None = None,
     ) -> Mapping[str, list[PlaceholderFeaturesInfo]]:
         """
         Helper to derive audio placeholders from video placeholders when
@@ -1000,34 +996,62 @@ class Qwen3OmniMoeThinkerMultiModalProcessor(
             return placeholders
 
         num_videos = len(placeholders["video"])
-        num_audios = len(mm_prompt_updates.get("audio", []))
-        if num_audios != num_videos:
+        if video_use_audio_in_video is None:
+            video_use_audio_in_video = [True] * num_videos
+        elif len(video_use_audio_in_video) != num_videos:
             raise ValueError(
-                f"use_audio_in_video requires equal number of audio and video items, got {num_audios=}, {num_videos=}"
+                "use_audio_in_video must contain one boolean per video, "
+                f"but found {len(video_use_audio_in_video)} values for "
+                f"{num_videos} videos."
+            )
+
+        num_audio_in_video = sum(video_use_audio_in_video)
+        num_audios = len(mm_prompt_updates.get("audio", []))
+        if num_audios != num_audio_in_video:
+            raise ValueError(
+                "use_audio_in_video requires equal number of audio and video "
+                f"items using audio, got {num_audios=}, {num_audio_in_video=}"
             )
 
         tokenizer = self.info.get_tokenizer()
         processor = self.info.get_hf_processor()
         audio_token_id = tokenizer.get_vocab()[processor.audio_token]
+        video_token_id = tokenizer.get_vocab()[processor.video_token]
 
         result_placeholders = dict(placeholders)
         audio_placeholders = []
+        video_placeholders = []
 
-        # Each video is paired with one audio
+        # Each video using audio is paired with one audio
+        audio_idx = 0
         for video_idx, video_placeholder in enumerate(placeholders["video"]):
             # Create is_embed mask selecting only audio tokens
-            audio_is_embed = torch.tensor(video_placeholder.tokens) == audio_token_id
+            placeholder_tokens = torch.tensor(video_placeholder.tokens)
+            audio_is_embed = placeholder_tokens == audio_token_id
+            video_is_embed = placeholder_tokens == video_token_id
 
-            audio_placeholder = PlaceholderFeaturesInfo(
-                modality="audio",
+            if video_use_audio_in_video[video_idx]:
+                audio_placeholder = PlaceholderFeaturesInfo(
+                    modality="audio",
+                    item_idx=audio_idx,
+                    start_idx=video_placeholder.start_idx,
+                    tokens=video_placeholder.tokens,
+                    is_embed=audio_is_embed,
+                )
+                audio_placeholders.append(audio_placeholder)
+                audio_idx += 1
+
+            video_placeholder_with_mask = PlaceholderFeaturesInfo(
+                modality="video",
                 item_idx=video_idx,
                 start_idx=video_placeholder.start_idx,
                 tokens=video_placeholder.tokens,
-                is_embed=audio_is_embed,
+                is_embed=video_is_embed,
             )
-            audio_placeholders.append(audio_placeholder)
+            video_placeholders.append(video_placeholder_with_mask)
 
         result_placeholders["audio"] = audio_placeholders
+        result_placeholders["video"] = video_placeholders
         return result_placeholders
 
     def _get_raw_input_ids(
@@ -1106,6 +1130,9 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
     Qwen3OmniMoeConditionalGenerationMixin,
     SupportsTranscription,
 ):
+    # PEFT stores the expert LoRA matrices with an explicit expert dimension.
+    is_3d_moe_weight: bool = True
+
     hf_to_vllm_mapper = WeightsMapper(
         orig_to_new_prefix={
             "thinker.lm_head.": "language_model.lm_head.",
@@ -1149,6 +1176,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
         self.vllm_config = vllm_config  # needed for torch compile forward context
         hf_config = vllm_config.model_config.hf_config
         thinker_config: Qwen3OmniMoeThinkerConfig = getattr(hf_config, "thinker_config", None) or hf_config
+        _ensure_thinker_architecture(thinker_config)
         quant_config = vllm_config.quant_config
         multimodal_config = vllm_config.model_config.multimodal_config
         self.config = thinker_config
@@ -1393,6 +1421,13 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                     visual_dim = embeddings.shape[-1] // (multiscale_len + 1)
                     multi_dim = visual_dim * multiscale_len
                     embeddings_main, embeddings_multiscale = torch.split(embeddings, [visual_dim, multi_dim], dim=-1)
+                    # torch.split returns fresh views, so the `modality` tag the
+                    # encoder gather attached (gpu_model_runner._gather_mm_embeddings)
+                    # does not survive. merge_interleaved_embeddings groups by that
+                    # tag since vLLM #46213, so carry it across the split.
+                    modality = getattr(embeddings, "modality", None)
+                    if modality is not None:
+                        set_mm_embedding_modality(embeddings_main, modality)
                     multimodal_embeddings[index] = embeddings_main
                     multimodal_embeddings_multiscale.append(embeddings_multiscale)
                     if not is_interleaved:
@@ -1430,8 +1465,6 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                 is_video,
                 is_audio,
                 is_mm_device,
-                num_video,
-                num_audio,
             )
 
         # Default: standard merge (no interleaving), same as parent class.
@@ -1529,10 +1562,12 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
         Iterate over multimodal features sorted by position offset.
 
         Yields: (offset, modality, feature_data) where feature_data contains:
-        - image: {"grid_t", "grid_h", "grid_w", "t_factor"}
+        - image: {"grid_t", "grid_h", "grid_w", "t_factor",
+                  "placeholder_len"}
         - video: {"grid_t", "grid_h", "grid_w", "t_factor",
-                  "use_audio_in_video", "audio_feature_length"}
-        - audio: {"audio_feature_length"}
+                  "use_audio_in_video", "audio_feature_length",
+                  "placeholder_len"}
+        - audio: {"audio_feature_length", "placeholder_len"}
         """
         config = self.config
         spatial_merge_size = config.vision_config.spatial_merge_size
@@ -1555,6 +1590,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                         "grid_h": h // spatial_merge_size,
                         "grid_w": w // spatial_merge_size,
                         "t_factor": position_id_per_seconds,
+                        "placeholder_len": mm_feature.mm_position.length,
                     },
                 )
             elif modality == "video":
@@ -1576,12 +1612,20 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                         "t_factor": second_per_grid_ts * position_id_per_seconds,
                         "use_audio_in_video": use_audio_in_video,
                         "audio_feature_length": audio_for_video.get(offset),
+                        "placeholder_len": mm_feature.mm_position.length,
                     },
                 )
             elif modality == "audio":
                 if offset not in paired_audio_offsets:
                     audio_len = mm_feature.data["audio_feature_lengths"].data.item()
-                    yield offset, "audio", {"audio_feature_length": audio_len}
+                    yield (
+                        offset,
+                        "audio",
+                        {
+                            "audio_feature_length": audio_len,
+                            "placeholder_len": mm_feature.mm_position.length,
+                        },
+                    )
 
     def _compute_interleaved_positions(self, start_idx: int, data: dict[str, Any]) -> tuple[np.ndarray, int]:
         """
@@ -1594,9 +1638,13 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
         grid_h = data["grid_h"]
         grid_w = data["grid_w"]
         t_factor = data["t_factor"]
-        audio_feature_length = data["audio_feature_length"]
-
-        audio_len = self._compute_audio_token_count(audio_feature_length)
+        num_video = grid_t * grid_h * grid_w
+        placeholder_len = data.get("placeholder_len")
+        if placeholder_len is None:
+            audio_feature_length = data["audio_feature_length"]
+            audio_len = self._compute_audio_token_count(audio_feature_length)
+        else:
+            audio_len = max(0, int(placeholder_len) - num_video - 2)
 
         h_index = np.tile(np.arange(grid_h).reshape(1, -1, 1), (grid_t, 1, grid_w)).flatten()
         w_index = np.tile(np.arange(grid_w).reshape(1, 1, -1), (grid_t, grid_h, 1)).flatten()
@@ -1612,8 +1660,6 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
 
         pos_ids_list: list[np.ndarray] = []
         video_idx, audio_idx = 0, 0
-        num_video = grid_t * grid_h * grid_w
-
         while video_idx < num_video and audio_idx < audio_len:
             if video_t_values[video_idx] <= audio_t_values[audio_idx]:
                 pos_ids_list.append(video_pos[:, video_idx : video_idx + 1])
@@ -1703,9 +1749,18 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
         seq_len = len(input_tokens)
 
         llm_pos_ids_list: list[np.ndarray] = []
+        feature_summaries: list[dict[str, Any]] = []
         st = 0
 
         for offset, modality, data in self.iter_mm_features(mm_features):
+            feature_summaries.append(
+                {
+                    "offset": offset,
+                    "modality": modality,
+                    "placeholder_len": data.get("placeholder_len"),
+                    "use_audio_in_video": data.get("use_audio_in_video"),
+                }
+            )
             text_len = offset - st
             st_idx = int(llm_pos_ids_list[-1].max()) + 1 if llm_pos_ids_list else 0
 
@@ -1713,19 +1768,11 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                 llm_pos_ids_list.append(np.broadcast_to(np.arange(text_len), (3, text_len)) + st_idx)
                 st_idx += text_len
 
-            bos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
-            llm_pos_ids_list.append(bos_pos)
-            st_idx += 1
-
             if modality == "audio":
                 audio_tokens = self._compute_audio_token_count(data["audio_feature_length"])
                 audio_pos = np.broadcast_to(np.arange(audio_tokens), (3, audio_tokens)) + st_idx
                 llm_pos_ids_list.append(audio_pos)
-                st_idx = int(audio_pos.max()) + 1
-
-                eos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
-                llm_pos_ids_list.append(eos_pos)
-                st = offset + 1 + audio_tokens + 1
+                st = offset + int(data.get("placeholder_len", audio_tokens))
 
             elif modality == "image":
                 grid_t = data["grid_t"]
@@ -1739,11 +1786,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                 llm_pos_ids_list.append(grid_indices.reshape(3, -1) + st_idx)
 
                 image_len = grid_t * grid_h * grid_w
-                st_idx = int(llm_pos_ids_list[-1].max()) + 1
-
-                eos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
-                llm_pos_ids_list.append(eos_pos)
-                st = offset + 1 + image_len + 1
+                st = offset + int(data.get("placeholder_len", image_len))
 
             elif modality == "video":
                 grid_t = data["grid_t"]
@@ -1758,26 +1801,20 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
                     llm_pos_ids_list.append(grid_indices.reshape(3, -1) + st_idx)
 
                     video_len = grid_t * grid_h * grid_w
-                    st_idx = int(llm_pos_ids_list[-1].max()) + 1
-
-                    eos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
-                    llm_pos_ids_list.append(eos_pos)
-                    st = offset + 1 + video_len + 1
+                    st = offset + int(data.get("placeholder_len", video_len))
                 else:
-                    audio_bos_pos = np.broadcast_to(np.array([st_idx - 1]), (3, 1))
+                    audio_bos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
                     llm_pos_ids_list.append(audio_bos_pos)
+                    st_idx += 1
 
-                    pos_ids, _ = self._compute_interleaved_positions(st_idx, data)
+                    pos_ids, token_count = self._compute_interleaved_positions(st_idx, data)
                     llm_pos_ids_list.append(pos_ids)
                     st_idx = int(pos_ids.max()) + 1
 
                     eos_pos = np.broadcast_to(np.array([st_idx]), (3, 1))
                     llm_pos_ids_list.append(eos_pos)
-                    llm_pos_ids_list.append(eos_pos)
 
-                    video_len = grid_t * grid_h * grid_w
-                    audio_len = self._compute_audio_token_count(data["audio_feature_length"])
-                    st = offset + 2 + video_len + audio_len + 2
+                    st = offset + int(data.get("placeholder_len", token_count + 2))
 
         if st < seq_len:
             st_idx = int(llm_pos_ids_list[-1].max()) + 1 if llm_pos_ids_list else 0
@@ -1786,7 +1823,11 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(
 
         llm_positions = np.concatenate(llm_pos_ids_list, axis=1).reshape(3, -1)
         if llm_positions.shape[1] != seq_len:
-            raise RuntimeError("Position ids length mismatch with input ids length")
+            raise RuntimeError(
+                "Position ids length mismatch with input ids length: "
+                f"positions={llm_positions.shape[1]}, input_ids={seq_len}, "
+                f"features={feature_summaries}"
+            )
 
         mrope_position_delta = int(llm_positions.max()) + 1 - seq_len
         return torch.from_numpy(llm_positions), mrope_position_delta
diff --git a/vllm_omni/model_executor/models/qwen3_tts/pipeline.py b/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
index 7f50931dd..8a68e63cd 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/pipeline.py
@@ -15,6 +15,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.qwen3_tts"
 
 QWEN3_TTS_PIPELINE = PipelineConfig(
     model_type="qwen3_tts",
+    default_deploy_config_name="qwen3_tts.yaml",
     # Pipeline-level default; the code2wav stage overrides per-stage below.
     model_arch="Qwen3TTSTalkerForConditionalGeneration",
     stages=(
diff --git a/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py b/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
index 447823abb..9d6eb7aaa 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py
@@ -25,12 +25,9 @@ from torch import nn
 from torch.nn import functional as F
 from transformers import MimiConfig, MimiModel
 from transformers.activations import ACT2FN
-from transformers.cache_utils import Cache, DynamicCache
+from transformers.cache_utils import Cache
 from transformers.integrations import use_kernel_forward_from_hub
-from transformers.masking_utils import (
-    create_causal_mask,
-    create_sliding_window_causal_mask,
-)
+from transformers.masking_utils import create_sliding_window_causal_mask
 from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
 from transformers.modeling_layers import GradientCheckpointingLayer
 from transformers.modeling_outputs import BaseModelOutputWithPast
@@ -523,15 +520,64 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
         self.norm = Qwen3TTSTokenizerV2DecoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
         self.rotary_emb = Qwen3TTSTokenizerV2DecoderRotatoryEmbedding(config=config)
         self.gradient_checkpointing = False
-        self.has_sliding_layers = "sliding_attention" in self.config.layer_types
         self.window_size = config.sliding_window
 
         self.input_proj = nn.Linear(config.latent_dim, config.hidden_size)
         self.output_proj = nn.Linear(config.hidden_size, config.latent_dim)
 
+        # Code2Wav is cache-free and every decoder layer uses sliding attention.
+        # Cache an exact, compact mask per warmup shape instead of retaining a
+        # max_position_embeddings square buffer. CUDA Graph warmup populates
+        # these entries before capture, and dtype/device are part of the key.
+        self._sliding_attention_mask_cache: dict[tuple[int, torch.dtype, torch.device, str], torch.Tensor | None] = {}
+
         # Initialize weights and apply final processing
         self.post_init()
 
+    def _apply(self, fn, recurse=True):
+        # Cached masks are keyed by dtype/device and should not retain storage
+        # from the model's previous placement.
+        self._sliding_attention_mask_cache.clear()
+        return super()._apply(fn, recurse=recurse)
+
+    def _get_sliding_attention_mask(self, inputs_embeds: torch.Tensor) -> torch.Tensor | None:
+        sequence_length = int(inputs_embeds.shape[1])
+        max_position_embeddings = int(self.config.max_position_embeddings)
+        if sequence_length > max_position_embeddings:
+            raise ValueError(
+                f"Input length {sequence_length} exceeds max_position_embeddings {max_position_embeddings}"
+            )
+
+        attention_implementation = str(self.config._attn_implementation)
+        cache_key = (
+            sequence_length,
+            inputs_embeds.dtype,
+            inputs_embeds.device,
+            attention_implementation,
+        )
+        if cache_key not in self._sliding_attention_mask_cache:
+            # A batch-one mask broadcasts across requests and avoids caching a
+            # duplicate tensor for every batch size.
+            mask_inputs = inputs_embeds[:1]
+            mask_kwargs = {
+                "config": self.config,
+                "attention_mask": None,
+                "past_key_values": None,
+                "position_ids": None,
+            }
+            sig = inspect.signature(create_sliding_window_causal_mask)
+            if "input_embeds" in sig.parameters:
+                mask_kwargs["input_embeds"] = mask_inputs
+                mask_kwargs["cache_position"] = torch.arange(sequence_length, device=inputs_embeds.device)
+            else:
+                mask_kwargs["inputs_embeds"] = mask_inputs
+            sliding_attention_mask = create_sliding_window_causal_mask(**mask_kwargs)
+            if sliding_attention_mask is not None:
+                sliding_attention_mask = sliding_attention_mask.contiguous()
+            self._sliding_attention_mask_cache[cache_key] = sliding_attention_mask
+
+        return self._sliding_attention_mask_cache[cache_key]
+
     # Note: @check_model_inputs decorator removed for vLLM compatibility
     # The decorator causes "unexpected keyword argument 'inputs_embeds'" error
     @auto_docstring
@@ -554,57 +600,56 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
             raise ValueError("input_ids is not expected")
         if (input_ids is None) ^ (inputs_embeds is not None):
             raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+        if use_cache:
+            raise ValueError("Code2Wav sliding-mask caching does not support use_cache=True")
+        if past_key_values is not None:
+            raise ValueError("Code2Wav sliding-mask caching does not support past_key_values")
+        if attention_mask is not None and not isinstance(attention_mask, dict):
+            raise ValueError("Code2Wav cached masks require attention_mask to be None or a prepared mask mapping")
 
         if inputs_embeds is None:
             inputs_embeds = self.embed_tokens(input_ids)
 
         inputs_embeds = self.input_proj(inputs_embeds)
 
-        if use_cache and past_key_values is None:
-            past_key_values = DynamicCache(config=self.config)
+        sequence_length = inputs_embeds.shape[1]
+        expected_cache_position = torch.arange(sequence_length, device=inputs_embeds.device)
 
         if cache_position is None:
-            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
-            cache_position = torch.arange(
-                past_seen_tokens, past_seen_tokens + inputs_embeds.shape[1], device=inputs_embeds.device
-            )
+            cache_position = expected_cache_position
+        elif attention_mask is None and (
+            cache_position.shape != expected_cache_position.shape
+            or cache_position.device != expected_cache_position.device
+            or not torch.equal(cache_position, expected_cache_position)
+        ):
+            raise ValueError("Cached Code2Wav masks require contiguous zero-based cache_position")
 
         if position_ids is None:
             position_ids = cache_position.unsqueeze(0)
-
-        # It may already have been prepared by e.g. `generate`
-        if not isinstance(causal_mask_mapping := attention_mask, dict):
-            # Prepare mask arguments
-            mask_kwargs = {
-                "config": self.config,
-                "attention_mask": attention_mask,
-                "past_key_values": past_key_values,
-                "position_ids": position_ids,
-            }
-            # Handle API changes across transformers versions
-            sig = inspect.signature(create_causal_mask)
-            if "input_embeds" in sig.parameters:
-                mask_kwargs["input_embeds"] = inputs_embeds
-                mask_kwargs["cache_position"] = cache_position
-            else:
-                mask_kwargs["inputs_embeds"] = inputs_embeds
-            # Create the masks
-            causal_mask_mapping = {
-                "full_attention": create_causal_mask(**mask_kwargs),
-            }
-            # The sliding window alternating layers are not always activated depending on the config
-            if self.has_sliding_layers:
-                causal_mask_mapping["sliding_attention"] = create_sliding_window_causal_mask(**mask_kwargs)
+        elif attention_mask is None:
+            expected_position_ids = expected_cache_position.unsqueeze(0)
+            if (
+                position_ids.ndim != 2
+                or position_ids.shape[-1] != sequence_length
+                or position_ids.device != expected_position_ids.device
+                or not torch.equal(position_ids, expected_position_ids.expand_as(position_ids))
+            ):
+                raise ValueError("Cached Code2Wav masks require contiguous zero-based position_ids")
 
         hidden_states = inputs_embeds
 
+        if isinstance(attention_mask, dict):
+            sliding_attention_mask = attention_mask["sliding_attention"]
+        else:
+            sliding_attention_mask = self._get_sliding_attention_mask(inputs_embeds)
+
         # create position embeddings to be shared across the decoder layers
         position_embeddings = self.rotary_emb(hidden_states, position_ids)
 
         for decoder_layer in self.layers[: self.config.num_hidden_layers]:
             hidden_states = decoder_layer(
                 hidden_states,
-                attention_mask=causal_mask_mapping[decoder_layer.attention_type],
+                attention_mask=sliding_attention_mask,
                 position_ids=position_ids,
                 past_key_values=past_key_values,
                 use_cache=use_cache,
@@ -617,7 +662,7 @@ class Qwen3TTSTokenizerV2DecoderTransformerModel(Qwen3TTSTokenizerV2DecoderPreTr
         hidden_states = self.output_proj(hidden_states)
         return BaseModelOutputWithPast(
             last_hidden_state=hidden_states,
-            past_key_values=past_key_values if use_cache else None,
+            past_key_values=None,
         )
 
 
diff --git a/vllm_omni/model_executor/models/registry.py b/vllm_omni/model_executor/models/registry.py
index 6749d5cfc..fd76dadd8 100644
--- a/vllm_omni/model_executor/models/registry.py
+++ b/vllm_omni/model_executor/models/registry.py
@@ -84,6 +84,31 @@ _OMNI_MODELS = {
         "cosyvoice3",
         "CosyVoice3Model",
     ),
+    "NemotronDenseForCausalLM": (
+        "audex",
+        "audex_thinker",
+        "NemotronDenseForCausalLM",
+    ),
+    "AudexCode2Wav": (
+        "audex",
+        "audex_code2wav",
+        "AudexCode2Wav",
+    ),
+    "AudexXCodec1": (
+        "audex",
+        "audex_xcodec",
+        "AudexXCodec1",
+    ),
+    "NemotronDenseAudexForConditionalGeneration": (
+        "audex",
+        "audex_omni",
+        "NemotronDenseAudexForConditionalGeneration",
+    ),
+    "NemotronHAudexForConditionalGeneration": (
+        "audex",
+        "audex_omni",
+        "NemotronHAudexForConditionalGeneration",
+    ),
     "OmniVoiceModel": (
         "omnivoice",
         "omnivoice",
@@ -99,6 +124,16 @@ _OMNI_MODELS = {
         "mammoth_moda2",
         "MammothModa2ARForConditionalGeneration",
     ),
+    "MammothModa2Qwen3ARForConditionalGeneration": (
+        "mammoth_moda2",
+        "mammoth_moda2",
+        "MammothModa2Qwen3ARForConditionalGeneration",
+    ),
+    "MammothModa2Qwen3ForCausalLM": (
+        "mammoth_moda2",
+        "mammoth_moda2",
+        "MammothModa2Qwen3ForCausalLM",
+    ),
     "MammothModa2DiTPipeline": (
         "mammoth_moda2",
         "pipeline_mammothmoda2_dit",
@@ -129,6 +164,18 @@ _OMNI_MODELS = {
         "qwen3_tts_code2wav",
         "Qwen3TTSCode2Wav",
     ),
+    ## personaplex (Moshi finetune, full-duplex S2S; 2-stage audio->audio offline pipeline)
+    # built by lead: personaplex_talker module + PersonaPlexTalkerForConditionalGeneration.
+    "PersonaPlexTalkerForConditionalGeneration": (
+        "personaplex",
+        "personaplex_talker",
+        "PersonaPlexTalkerForConditionalGeneration",
+    ),
+    "PersonaPlexCode2Wav": (
+        "personaplex",
+        "personaplex_code2wav",
+        "PersonaPlexCode2Wav",
+    ),
     ## higgs-audio v2
     "HiggsAudioV2ForConditionalGeneration": (
         "higgs_audio_v2",
@@ -360,6 +407,11 @@ _OMNI_MODELS = {
         "minicpmo_4_5_omni_tts",
         "MiniCPMO45OmniTTSForConditionalGeneration",
     ),
+    "MiniCPMO45Code2Wav": (
+        "minicpmo_4_5",
+        "minicpmo_4_5_code2wav",
+        "MiniCPMO45Code2Wav",
+    ),
     "AuraQwen3VLForConditionalGeneration": (
         "aura_omni",
         "qwen3_vl",
diff --git a/vllm_omni/model_executor/models/soulx_singer/__init__.py b/vllm_omni/model_executor/models/soulx_singer/__init__.py
new file mode 100644
index 000000000..1ab85a8d3
--- /dev/null
+++ b/vllm_omni/model_executor/models/soulx_singer/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+# Keep this package lightweight. The pipeline registry imports pipeline.py
+# directly, while diffusion model classes are loaded lazily from their registry.
diff --git a/vllm_omni/model_executor/models/soulx_singer/pipeline.py b/vllm_omni/model_executor/models/soulx_singer/pipeline.py
new file mode 100644
index 000000000..4d2420528
--- /dev/null
+++ b/vllm_omni/model_executor/models/soulx_singer/pipeline.py
@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""SoulX-Singer pipeline topologies."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+SOULXSINGER_SVS_PIPELINE = PipelineConfig(
+    model_type="soulxsinger_svs",
+    default_deploy_config_name="soulxsinger_svs.yaml",
+    model_arch="SoulXSingerPipeline",
+    hf_architectures=("SoulXSingerPipeline",),
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="dit",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="audio",
+            model_arch="SoulXSingerPipeline",
+        ),
+    ),
+)
+
+SOULXSINGER_SVC_PIPELINE = PipelineConfig(
+    model_type="soulxsinger_svc",
+    default_deploy_config_name="soulxsinger_svc.yaml",
+    model_arch="SoulXSingerSVCPipeline",
+    hf_architectures=("SoulXSingerSVCPipeline",),
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="dit",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="audio",
+            model_arch="SoulXSingerSVCPipeline",
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/step_audio2/__init__.py b/vllm_omni/model_executor/models/step_audio2/__init__.py
index 0b6f07e28..e69de29bb 100644
--- a/vllm_omni/model_executor/models/step_audio2/__init__.py
+++ b/vllm_omni/model_executor/models/step_audio2/__init__.py
@@ -1,3 +0,0 @@
-from .step_audio2 import StepAudio2ForConditionalGeneration
-
-__all__ = ["StepAudio2ForConditionalGeneration"]
diff --git a/vllm_omni/model_executor/models/step_audio2/pipeline.py b/vllm_omni/model_executor/models/step_audio2/pipeline.py
new file mode 100644
index 000000000..7ba6d9ee1
--- /dev/null
+++ b/vllm_omni/model_executor/models/step_audio2/pipeline.py
@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Step-Audio2 pipeline topologies (frozen)."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+_PROC = "vllm_omni.model_executor.stage_input_processors.step_audio2"
+_HF_ARCHITECTURES = (
+    "StepAudio2ForCausalLM",
+    "StepAudio2ForConditionalGeneration",
+)
+
+
+STEP_AUDIO2_PIPELINE = PipelineConfig(
+    model_type="step_audio_2",
+    model_arch="StepAudio2ForConditionalGeneration",
+    hf_architectures=_HF_ARCHITECTURES,
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="step_audio2_thinker",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            final_output=True,
+            final_output_type="text",
+            owns_tokenizer=True,
+            requires_multimodal_data=True,
+            engine_output_type="latent",
+            model_arch="StepAudio2ThinkerForConditionalGeneration",
+            async_chunk_process_next_stage_input_func=f"{_PROC}.thinker2token2wav_async_chunk",
+            sampling_constraints={"detokenize": True},
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="token2wav",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="StepAudio2Token2WavModel",
+            sync_process_input_func=f"{_PROC}.thinker2token2wav",
+            sampling_constraints={"detokenize": False},
+        ),
+    ),
+)
+
+
+STEP_AUDIO2_ASR_PIPELINE = PipelineConfig(
+    model_type="step_audio_2_asr",
+    model_arch="StepAudio2ForConditionalGeneration",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="step_audio2_thinker",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            final_output=True,
+            final_output_type="text",
+            owns_tokenizer=True,
+            requires_multimodal_data=True,
+            engine_output_type="text",
+            model_arch="StepAudio2ThinkerForConditionalGeneration",
+            sampling_constraints={"detokenize": True},
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/step_audio2/step_audio2_dit_trt.py b/vllm_omni/model_executor/models/step_audio2/step_audio2_dit_trt.py
new file mode 100644
index 000000000..6feefd128
--- /dev/null
+++ b/vllm_omni/model_executor/models/step_audio2/step_audio2_dit_trt.py
@@ -0,0 +1,375 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""TensorRT acceleration for the Step-Audio2 / CosyVoice2 flow DiT estimator.
+
+Ports stepfun-ai/Step-Audio2#70 into vLLM-Omni. The upstream PR patches
+``cosyvoice2.flow.flow_matching`` to dispatch between a torch estimator and a
+raw TRT execution context; here the swap happens one level up instead — the
+batched Code2Wav driver (``BatchedToken2Wav._estimator_step``) already owns
+the per-timestep estimator call, so a :class:`TrtDiTStepper` replaces only
+that call and the pip-installed ``cosyvoice2`` package stays untouched.
+
+Differences from the upstream PR:
+
+* ONNX export is a function (:func:`export_dit_chunk_onnx`) that wraps the
+  already-loaded torch ``DiT`` module and runs at engine-build time — no
+  separate ``tools/export_onnx_*.py`` step.
+* The engine executes on the caller's current CUDA stream, so no context
+  pool, no private stream, and no ``synchronize()`` per call (a private
+  stream without synchronization produces silent garbage audio; with
+  synchronization it costs two round-trips per denoise step).
+* Cache tensors are exchanged as stacked ``(depth, 2B, ...)`` tensors, the
+  same layout ``BatchedToken2Wav`` already uses.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+_TRT_CACHE_ENV = "MINICPMO_TOKEN2WAV_TRT_CACHE"
+
+
+class _DiTChunkWrapper(nn.Module):
+    """ONNX-exportable streaming ``forward_chunk`` with explicit stacked caches.
+
+    Mirrors ``DiT.forward_chunk`` (cosyvoice2 pip package) but takes and
+    returns caches as plain tensors instead of registered buffers, matching
+    the I/O contract of the TRT engine and of ``BatchedToken2Wav``.
+    """
+
+    def __init__(self, dit: nn.Module):
+        super().__init__()
+        self.dit = dit
+
+    def forward(
+        self,
+        x: torch.Tensor,  # (2B, mel, T)
+        mu: torch.Tensor,  # (2B, mel, T)
+        t: torch.Tensor,  # (2B,)
+        spks: torch.Tensor,  # (2B, spk)
+        cond: torch.Tensor,  # (2B, mel, T)
+        cnn_cache: torch.Tensor,  # (depth, 2B, c1+c2, kernel-1)
+        att_cache: torch.Tensor,  # (depth, 2B, heads, L, head_dim*2)
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        t_emb = self.dit.t_embedder(t).unsqueeze(1)
+        spks_f = spks.unsqueeze(-1).expand(-1, -1, x.shape[-1])
+        h = torch.cat((x, mu, spks_f, cond), dim=1).transpose(1, 2)
+        h = self.dit.in_proj(h)
+        new_cnn = []
+        new_att = []
+        for i, block in enumerate(self.dit.blocks):
+            h, block_cnn, block_att = block.forward_chunk(h, t_emb, cnn_cache[i], att_cache[i], None)
+            new_cnn.append(block_cnn)
+            new_att.append(block_att)
+        h = self.dit.final_layer(h, t_emb)
+        return h.transpose(1, 2), torch.stack(new_cnn), torch.stack(new_att)
+
+
+def _dit_dims(dit: nn.Module) -> dict[str, int]:
+    block0 = dit.blocks[0]
+    return {
+        "depth": len(dit.blocks),
+        "mel": int(dit.out_channels),
+        "spk": int(dit.in_channels) - 3 * int(dit.out_channels),
+        "heads": int(block0.attn.num_heads),
+        "att_dim": int(block0.attn.head_dim) * 2,
+        "cnn_ch": int(block0.conv.in_channels + block0.conv.out_channels),
+        "cnn_w": int(block0.conv.block[1].causal_padding[0]),
+    }
+
+
+def export_dit_chunk_onnx(
+    dit: nn.Module,
+    onnx_path: str | Path,
+    device: torch.device,
+    dtype: torch.dtype = torch.float16,
+) -> None:
+    """Export the streaming DiT chunk graph to ONNX in ``dtype``.
+
+    Fused-in replacement for the upstream ``tools/export_onnx_streaming_token2wav.py``.
+    TensorRT >= 10 deprecates weakly-typed networks (TRT 11 removes
+    ``BuilderFlag.FP16`` outright), so the engine precision comes from the
+    ONNX graph itself. The DiT is deep-copied for the cast — the live torch
+    estimator keeps its original dtype.
+    """
+    import copy
+
+    dims = _dit_dims(dit)
+    export_dit = copy.deepcopy(dit).to(device=device, dtype=dtype).eval()
+    wrapper = _DiTChunkWrapper(export_dit).eval()
+    batch, chunk, cache_len = 2, 48, 16
+    sample = (
+        torch.randn(batch, dims["mel"], chunk, device=device, dtype=dtype),
+        torch.randn(batch, dims["mel"], chunk, device=device, dtype=dtype),
+        torch.rand(batch, device=device, dtype=dtype),
+        torch.randn(batch, dims["spk"], device=device, dtype=dtype),
+        torch.randn(batch, dims["mel"], chunk, device=device, dtype=dtype),
+        torch.zeros(dims["depth"], batch, dims["cnn_ch"], dims["cnn_w"], device=device, dtype=dtype),
+        torch.randn(dims["depth"], batch, dims["heads"], cache_len, dims["att_dim"], device=device, dtype=dtype),
+    )
+    input_names = ["x", "mu", "t", "spks", "cond", "cnn_cache", "att_cache"]
+    output_names = ["out", "new_cnn_cache", "new_att_cache"]
+    dynamic_axes = {
+        "x": {0: "b", 2: "t"},
+        "mu": {0: "b", 2: "t"},
+        "t": {0: "b"},
+        "spks": {0: "b"},
+        "cond": {0: "b", 2: "t"},
+        "cnn_cache": {1: "b"},
+        "att_cache": {1: "b", 3: "l"},
+        "out": {0: "b", 2: "t"},
+        "new_cnn_cache": {1: "b"},
+        "new_att_cache": {1: "b", 3: "l_out"},
+    }
+    logger.info("Exporting DiT chunk ONNX to %s", onnx_path)
+    onnx_path = Path(onnx_path)
+    onnx_path.parent.mkdir(parents=True, exist_ok=True)
+    # Process-unique temp name + atomic rename, so concurrent first builds on
+    # a shared cache dir never see (or clobber) a partially written file.
+    tmp = onnx_path.with_suffix(f".tmp.{os.getpid()}")
+    try:
+        with torch.no_grad():
+            torch.onnx.export(
+                wrapper,
+                sample,
+                str(tmp),
+                input_names=input_names,
+                output_names=output_names,
+                dynamic_axes=dynamic_axes,
+                opset_version=17,
+                dynamo=False,
+            )
+        os.replace(tmp, onnx_path)
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+def convert_onnx_to_trt(
+    onnx_path: str | Path,
+    plan_path: str | Path,
+    dims: dict[str, int],
+    *,
+    max_batch: int = 16,
+    max_len: int = 3000,
+    max_cache_len: int = 1000,
+) -> None:
+    """Build a TRT engine from the exported ONNX (fused-in from upstream tools).
+
+    Engine precision is strongly typed from the ONNX graph itself — export
+    the graph in the desired dtype (TRT 11 removed ``BuilderFlag.FP16``).
+    """
+    import tensorrt as trt
+
+    logger.info("Building DiT TRT engine at %s — this can take a few minutes", plan_path)
+    trt_logger = trt.Logger(trt.Logger.INFO)
+    builder = trt.Builder(trt_logger)
+    # TRT >= 10 removed EXPLICIT_BATCH (networks are always explicit-batch).
+    flag = getattr(trt.NetworkDefinitionCreationFlag, "EXPLICIT_BATCH", None)
+    network = builder.create_network(1 << int(flag) if flag is not None else 0)
+    parser = trt.OnnxParser(network, trt_logger)
+    with open(onnx_path, "rb") as f:
+        if not parser.parse(f.read()):
+            errors = [str(parser.get_error(i)) for i in range(parser.num_errors)]
+            raise ValueError(f"failed to parse {onnx_path}: {errors}")
+
+    config = builder.create_builder_config()
+
+    depth, mel, spk = dims["depth"], dims["mel"], dims["spk"]
+    heads, att_dim = dims["heads"], dims["att_dim"]
+    cnn_ch, cnn_w = dims["cnn_ch"], dims["cnn_w"]
+    opt_b = min(4, max_batch)
+    shapes = {
+        "x": [(2, mel, 2), (opt_b, mel, 500), (max_batch, mel, max_len)],
+        "mu": [(2, mel, 2), (opt_b, mel, 500), (max_batch, mel, max_len)],
+        "t": [(2,), (opt_b,), (max_batch,)],
+        "spks": [(2, spk), (opt_b, spk), (max_batch, spk)],
+        "cond": [(2, mel, 2), (opt_b, mel, 500), (max_batch, mel, max_len)],
+        "cnn_cache": [
+            (depth, 2, cnn_ch, cnn_w),
+            (depth, opt_b, cnn_ch, cnn_w),
+            (depth, max_batch, cnn_ch, cnn_w),
+        ],
+        "att_cache": [
+            (depth, 2, heads, 0, att_dim),
+            (depth, opt_b, heads, 500, att_dim),
+            (depth, max_batch, heads, max_cache_len, att_dim),
+        ],
+    }
+    profile = builder.create_optimization_profile()
+    for name, (mn, op, mx) in shapes.items():
+        profile.set_shape(name, mn, op, mx)
+    config.add_optimization_profile(profile)
+
+    engine_bytes = builder.build_serialized_network(network, config)
+    if engine_bytes is None:
+        raise RuntimeError("TensorRT engine build failed")
+    plan_path = Path(plan_path)
+    plan_path.parent.mkdir(parents=True, exist_ok=True)
+    # Process-unique temp name: concurrent first builds (multiple ranks on a
+    # shared cache dir) must not clobber each other's partial writes; the
+    # final os.replace stays atomic and last-writer-wins with equal content.
+    tmp = plan_path.with_suffix(f".tmp.{os.getpid()}")
+    try:
+        with open(tmp, "wb") as f:
+            f.write(engine_bytes)
+        os.replace(tmp, plan_path)
+    finally:
+        tmp.unlink(missing_ok=True)
+    logger.info("DiT TRT engine written to %s", plan_path)
+
+
+class TrtDiTStepper:
+    """Drop-in TRT replacement for one DiT denoise step.
+
+    ``step`` matches the tensors ``BatchedToken2Wav._decode_cfm`` has in hand
+    per timestep. Executes on the caller's current CUDA stream — same-stream
+    ordering makes explicit synchronization unnecessary.
+    """
+
+    def __init__(
+        self,
+        plan_path: str | Path,
+        dims: dict[str, int],
+        device: torch.device,
+        dtype: torch.dtype,
+        *,
+        max_batch: int = 16,
+        max_len: int = 3000,
+        max_cache_len: int = 1000,
+    ):
+        import tensorrt as trt
+
+        self.dims = dims
+        self.device = device
+        self.dtype = dtype
+        # Optimization-profile bounds the engine was built with; step() checks
+        # them so an out-of-profile call fails with a readable error instead
+        # of an opaque execute_async_v3 failure.
+        self.max_batch = int(max_batch)
+        self.max_len = int(max_len)
+        self.max_cache_len = int(max_cache_len)
+        with open(plan_path, "rb") as f:
+            self.engine = trt.Runtime(trt.Logger(trt.Logger.INFO)).deserialize_cuda_engine(f.read())
+        if self.engine is None:
+            raise RuntimeError(f"failed to deserialize TRT engine {plan_path}")
+        self.context = self.engine.create_execution_context()
+        if self.context is None:
+            raise RuntimeError("failed to create TRT execution context")
+        # TRT rejects null bindings; zero-length cache tensors share this address.
+        self._dummy = torch.zeros(1, device=device, dtype=dtype)
+
+    def _addr(self, tensor: torch.Tensor) -> int:
+        return self._dummy.data_ptr() if tensor.numel() == 0 else tensor.data_ptr()
+
+    def step(
+        self,
+        *,
+        x: torch.Tensor,
+        mu: torch.Tensor,
+        t: torch.Tensor,
+        spks: torch.Tensor,
+        cond: torch.Tensor,
+        cnn_cache: torch.Tensor | None,
+        att_cache: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        dims = self.dims
+        batch = int(x.shape[0])
+        chunk = int(x.shape[2])
+        cache_frames = int(att_cache.shape[3]) if att_cache is not None else 0
+        if batch > self.max_batch or chunk > self.max_len or cache_frames > self.max_cache_len:
+            raise ValueError(
+                f"DiT TRT engine profile exceeded: batch={batch} (max {self.max_batch}, "
+                f"= token2wav_trt_max_batch, CFG included), chunk={chunk} frames "
+                f"(max {self.max_len}), att cache={cache_frames} frames (max {self.max_cache_len}). "
+                "Rebuild the engine with a larger token2wav_trt_max_batch or disable token2wav_trt."
+            )
+        if cnn_cache is None:
+            cnn_cache = torch.zeros(
+                (dims["depth"], batch, dims["cnn_ch"], dims["cnn_w"]), device=self.device, dtype=self.dtype
+            )
+        if att_cache is None:
+            att_cache = torch.zeros(
+                (dims["depth"], batch, dims["heads"], 0, dims["att_dim"]), device=self.device, dtype=self.dtype
+            )
+        cache_len = int(att_cache.shape[3])
+
+        inputs = {
+            "x": x.to(self.dtype).contiguous(),
+            "mu": mu.to(self.dtype).contiguous(),
+            "t": t.to(self.dtype).contiguous(),
+            "spks": spks.to(self.dtype).contiguous(),
+            "cond": cond.to(self.dtype).contiguous(),
+            "cnn_cache": cnn_cache.to(self.dtype).contiguous(),
+            "att_cache": att_cache.to(self.dtype).contiguous(),
+        }
+        out = torch.empty((batch, dims["mel"], chunk), device=self.device, dtype=self.dtype)
+        new_cnn = torch.empty_like(inputs["cnn_cache"])
+        new_att = torch.empty(
+            (dims["depth"], batch, dims["heads"], cache_len + chunk, dims["att_dim"]),
+            device=self.device,
+            dtype=self.dtype,
+        )
+
+        for name, tensor in inputs.items():
+            self.context.set_input_shape(name, tuple(tensor.shape))
+            self.context.set_tensor_address(name, self._addr(tensor))
+        self.context.set_tensor_address("out", out.data_ptr())
+        self.context.set_tensor_address("new_cnn_cache", new_cnn.data_ptr())
+        self.context.set_tensor_address("new_att_cache", self._addr(new_att))
+
+        stream = torch.cuda.current_stream(self.device)
+        if not self.context.execute_async_v3(stream.cuda_stream):
+            raise RuntimeError("TRT DiT execution failed")
+        return out, new_cnn, new_att
+
+
+def _default_cache_dir() -> Path:
+    env = os.environ.get(_TRT_CACHE_ENV, "").strip()
+    if env:
+        return Path(env)
+    hf_home = os.environ.get("HF_HOME", "").strip()
+    base = Path(hf_home) if hf_home else Path.home() / ".cache" / "huggingface"
+    return base / "vllm_omni" / "token2wav_trt"
+
+
+def build_dit_trt_stepper(
+    dit: nn.Module,
+    *,
+    device: torch.device | str = "cuda",
+    dtype: torch.dtype = torch.float16,
+    max_batch: int = 16,
+    cache_dir: str | Path | None = None,
+) -> TrtDiTStepper:
+    """Export (if needed), build (if needed) and load the DiT TRT engine.
+
+    Artifacts are cached under ``cache_dir`` (default: ``$MINICPMO_TOKEN2WAV_TRT_CACHE``
+    or ``$HF_HOME/vllm_omni/token2wav_trt``), keyed by dtype/batch/TRT
+    version/GPU architecture — serialized plans are SM-specific, so a cache
+    shared across heterogeneous machines must not reuse another arch's plan.
+    """
+    import tensorrt as trt
+
+    device = torch.device(device)
+    dims = _dit_dims(dit)
+    cache = Path(cache_dir) if cache_dir is not None else _default_cache_dir()
+    cache.mkdir(parents=True, exist_ok=True)
+    dtype_tag = str(dtype).replace("torch.", "")
+    major, minor = torch.cuda.get_device_capability(device)
+    sm_tag = f"sm{major}{minor}"
+    onnx_path = cache / f"dit_chunk.d{dims['depth']}.{dtype_tag}.onnx"
+    plan_path = cache / (f"dit_chunk.d{dims['depth']}.{dtype_tag}.b{max_batch}.{sm_tag}.trt{trt.__version__}.plan")
+
+    if not plan_path.is_file() or plan_path.stat().st_size == 0:
+        if not onnx_path.is_file() or onnx_path.stat().st_size == 0:
+            export_dit_chunk_onnx(dit, onnx_path, device, dtype)
+        convert_onnx_to_trt(onnx_path, plan_path, dims, max_batch=max_batch)
+    else:
+        logger.info("Reusing cached DiT TRT engine %s", plan_path)
+    return TrtDiTStepper(plan_path, dims, device, dtype, max_batch=max_batch)
diff --git a/vllm_omni/model_executor/models/step_audio2/step_audio2_token2wav.py b/vllm_omni/model_executor/models/step_audio2/step_audio2_token2wav.py
index 86109ad9c..3923933f6 100644
--- a/vllm_omni/model_executor/models/step_audio2/step_audio2_token2wav.py
+++ b/vllm_omni/model_executor/models/step_audio2/step_audio2_token2wav.py
@@ -95,6 +95,23 @@ class StepAudio2Token2WavCore(nn.Module):
         self.source_cache_len = STREAM_SOURCE_CACHE_LEN
         self.speech_window: torch.Tensor | None = None  # created lazily on device
 
+        # On Ascend the talker worker never routes through
+        # ``NPUOmniPlatform.set_device``, so gate on ``current_omni_platform``
+        # and apply the Token2Wav NPU patch here (idempotent) before
+        # ``_ensure_models_loaded`` runs. Covers every
+        # construction site (Step-Audio2 wrapper + MiniCPM-o facade): patched
+        # ``_ensure_models_loaded`` replaces HiFT's failing linear downsample,
+        # while patched ``forward`` expands CosyVoice DiT masks and forces
+        # MATH SDPA (avoids FA 161001).
+        from vllm_omni.platforms import current_omni_platform
+
+        if current_omni_platform.is_npu():
+            from vllm_omni.platforms.npu.models.step_audio2_token2wav import (
+                apply_step_audio2_token2wav_npu_patch,
+            )
+
+            apply_step_audio2_token2wav_npu_patch()
+
     def _ensure_models_loaded(self):
         """Lazy load models on first use"""
         if self._models_loaded:
@@ -161,6 +178,28 @@ class StepAudio2Token2WavCore(nn.Module):
         self._ensure_models_loaded()
         return self._hift
 
+    def _forward_spk_embedding(self, spk_feat: torch.Tensor) -> torch.Tensor:
+        """Run campplus on ``[T, 80]`` fbank features; returns ``[1, 192]`` on ``self.device``."""
+        spk_model = self.spk_model
+        if isinstance(spk_model, onnxruntime.InferenceSession):
+            return torch.tensor(
+                spk_model.run(None, {spk_model.get_inputs()[0].name: spk_feat.unsqueeze(dim=0).cpu().numpy()})[0],
+                device=self.device,
+            )
+        # CampplusTRT (or any callable taking [T, 80] and returning [1, 192]).
+        return spk_model(spk_feat).to(self.device)
+
+    def enable_trt_spk_embedding(self) -> None:
+        """Swap the onnxruntime campplus session for the shared TensorRT engine.
+
+        Reuses the CosyVoice3 CAM++ engine wrapper — MiniCPM-o / Step-Audio2
+        ship the same campplus.onnx architecture and I/O contract.
+        """
+        from vllm_omni.model_executor.models.cosyvoice3.speaker_embedding_trt import get_campplus_trt
+
+        self._ensure_models_loaded()
+        self._spk_model = get_campplus_trt(f"{self.model_path}/campplus.onnx", device=self.device)
+
     def _prepare_prompt(self, prompt_wav: str):
         """Prepare prompt audio for conditioning"""
         # Prefer soundfile/librosa path to avoid torchaudio->torchcodec runtime coupling.
@@ -185,10 +224,7 @@ class StepAudio2Token2WavCore(nn.Module):
 
         spk_feat = kaldi.fbank(audio.unsqueeze(0), num_mel_bins=80, dither=0, sample_frequency=16000)
         spk_feat = spk_feat - spk_feat.mean(dim=0, keepdim=True)
-        spk_emb = torch.tensor(
-            self.spk_model.run(None, {self.spk_model.get_inputs()[0].name: spk_feat.unsqueeze(dim=0).cpu().numpy()})[0],
-            device=self.device,
-        )
+        spk_emb = self._forward_spk_embedding(spk_feat)
 
         # 24 kHz branch: mel spectrogram for flow model conditioning
         # Must resample from the ORIGINAL audio, not the 16 kHz version.
diff --git a/vllm_omni/model_executor/models/voxcpm2/pipeline.py b/vllm_omni/model_executor/models/voxcpm2/pipeline.py
index 0579ebc8c..c92cf61ba 100644
--- a/vllm_omni/model_executor/models/voxcpm2/pipeline.py
+++ b/vllm_omni/model_executor/models/voxcpm2/pipeline.py
@@ -15,6 +15,7 @@ from vllm_omni.config.stage_config import (
 
 VOXCPM2_PIPELINE = PipelineConfig(
     model_type="voxcpm2",
+    default_deploy_config_name="voxcpm2.yaml",
     model_arch="VoxCPM2TalkerForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
index 94ac454d8..3a1677d49 100644
--- a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
+++ b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
@@ -264,10 +264,12 @@ class _RequestState:
     decode_step_count: int = 0
     request_start_time: float = 0.0
     prefill_completed: bool = False
+    is_last_prefill_chunk: bool = False
     prompt_cache: dict | None = None
     prefill_masks: tuple | None = None
     is_stopping: bool = False
     precomputed_is_stopping: bool | None = None
+    prefill_embeds: torch.Tensor | None = None
 
 
 @dataclasses.dataclass
@@ -2054,7 +2056,7 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
 
             if is_prefill:
                 flush_decode_fsq_batch()
-                res_input, meta = self._prepare_residual_prefill(state, req_hidden, dev)
+                res_input, meta = self._prepare_residual_prefill(state, req_hidden, dev, req_pos)
             elif state.prefill_completed:
                 if (
                     self._enable_batched_fsq_fusion
@@ -2141,7 +2143,8 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                     offset += n
 
                     if is_prefill:
-                        prefill_batch.append((state, meta, res_out))
+                        if state.is_last_prefill_chunk:
+                            prefill_batch.append((state, meta, res_out))
                     else:
                         self._finish_decode(state, meta, res_out)
                         decoded_states.append(state)
@@ -2152,20 +2155,28 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                     for state, meta, res_out in prefill_batch:
                         self._finish_prefill(state, meta, res_out, dev)
 
-                collect_states = [state for state, _, _ in req_metas]
-                self._precompute_stop_flags_for_audio_collect(collect_states)
-                ready_audio_by_req = self._drain_ready_audio_copies_for_states(collect_states)
-                audio_by_req = self._collect_audio_batch(
-                    collect_states,
-                    initial_delayed_chunks_by_req={
-                        state.request_id: ready_audio_by_req.get(state.request_id)
-                        for state, is_prefill, _ in req_metas
-                        if not is_prefill
-                    },
-                )
+                collect_states = [
+                    state for state, is_prefill, _ in req_metas if not is_prefill or state.is_last_prefill_chunk
+                ]
+                audio_by_req: dict[str, torch.Tensor | None] = {}
+                if collect_states:
+                    self._precompute_stop_flags_for_audio_collect(collect_states)
+                    ready_audio_by_req = self._drain_ready_audio_copies_for_states(collect_states)
+                    audio_by_req = self._collect_audio_batch(
+                        collect_states,
+                        initial_delayed_chunks_by_req={
+                            state.request_id: ready_audio_by_req.get(state.request_id)
+                            for state, is_prefill, _ in req_metas
+                            if not is_prefill
+                        },
+                    )
                 for state, is_prefill, _ in req_metas:
-                    self._results_queue.append((state.request_id, state.precomputed_stop_logits))
-                    self._audio_queue.append((state.request_id, audio_by_req.get(state.request_id)))
+                    if is_prefill and not state.is_last_prefill_chunk:
+                        self._results_queue.append((state.request_id, None))
+                        self._audio_queue.append((state.request_id, None))
+                    else:
+                        self._results_queue.append((state.request_id, state.precomputed_stop_logits))
+                        self._audio_queue.append((state.request_id, audio_by_req.get(state.request_id)))
 
         self._pending_requests.clear()
         self._flush_deferred_cleanup()
@@ -2179,11 +2190,14 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         state: _RequestState,
         base_lm_out: torch.Tensor,
         dev: torch.device,
+        req_pos: torch.Tensor,
     ) -> tuple[torch.Tensor, _PrefillResidualMeta]:
         tts = self.tts
         text_mask, feat_mask, feat, feat_embed = state.prefill_masks
-        state.prefill_masks = None
-
+        text_mask = text_mask[:, req_pos]
+        feat_mask = feat_mask[:, req_pos]
+        feat = feat[:, req_pos]
+        feat_embed = feat_embed[:, req_pos]
         tts_len = text_mask.shape[1]
         scaffold_len = base_lm_out.shape[0]
         assert scaffold_len == tts_len, (
@@ -2424,6 +2438,9 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
             state.decode_step_count = 0
             state.request_start_time = time.perf_counter()
             state.prefill_completed = True
+            state.prefill_masks = None
+            state.prefill_embeds = None
+            state.prompt_cache = None
 
         self._perf.stop("prefill_tail_batch")
         if self._enable_profiling:
@@ -2465,6 +2482,9 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         state.decode_step_count = 0
         state.request_start_time = time.perf_counter()
         state.prefill_completed = True
+        state.prefill_embeds = None
+        state.prefill_masks = None
+        state.prompt_cache = None
         self._perf.stop("prefill_tail")
 
         if logger.isEnabledFor(logging.DEBUG):
@@ -3033,7 +3053,7 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         span_len = int(input_ids.shape[0])
         dev = input_ids.device
         req_id = info_dict.get("request_id", "default")
-        is_prefill = span_len > 1
+        is_prefill = bool(info_dict.get("_omni_is_prefill", span_len > 1))
 
         if is_prefill:
             # Do not evict state here: _pending_requests is a per-step prefix,
@@ -3056,22 +3076,29 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                 token_ids = token_ids[1:]
 
             state = self._get_or_create_state(req_id)
-            state.decode_pad = None
-            state.prefill_completed = False
-            state.decode_step_count = 0
-            state.precomputed_stop_logits = None
-            state.precomputed_is_stopping = None
-            state.last_audio_patch_gpu = None
-            if not hasattr(state, "pending_audio_chunks_gpu"):
-                state.pending_audio_chunks_gpu = []
-            if not hasattr(state, "pending_audio_copies"):
-                state.pending_audio_copies = []
-            state.pending_audio_chunks_gpu.clear()
-            state.pending_audio_copies.clear()
-            state.curr_embed_for_next = None
-            state.prev_feat_embed = None
-            state.curr_prefix_feat_cond = None
-            state.is_stopping = False
+            num_computed_tokens = int(info_dict.get("_omni_num_computed_tokens", 0))
+            is_first_prefill_chunk = num_computed_tokens == 0
+            if is_first_prefill_chunk:
+                state.decode_pad = None
+                state.prefill_completed = False
+                state.is_last_prefill_chunk = False
+                state.decode_step_count = 0
+                state.precomputed_stop_logits = None
+                state.precomputed_is_stopping = None
+                state.last_audio_patch_gpu = None
+                if not hasattr(state, "pending_audio_chunks_gpu"):
+                    state.pending_audio_chunks_gpu = []
+                if not hasattr(state, "pending_audio_copies"):
+                    state.pending_audio_copies = []
+                state.pending_audio_chunks_gpu.clear()
+                state.pending_audio_copies.clear()
+                state.curr_embed_for_next = None
+                state.prev_feat_embed = None
+                state.curr_prefix_feat_cond = None
+                state.is_stopping = False
+                state.prompt_cache = None
+                state.prefill_embeds = None
+                state.prefill_masks = None
 
             # Voice clone / continuation
             ref_audio = info_dict.get("reference_audio") or info_dict.get("ref_audio")
@@ -3088,13 +3115,12 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                 voice_profile = voice_profile[0] if voice_profile else None
             requires_precomputed_cache = isinstance(voice_profile, dict)
 
-            state.prompt_cache = None
             voice_name = info_dict.get("voice_name")
             if isinstance(voice_name, list):
                 voice_name = voice_name[0] if voice_name else None
             _created_at = int(info_dict.get("voice_created_at") or 0)
 
-            if voice_name:
+            if state.prompt_cache is None and voice_name:
                 _cache_key = self._speaker_cache.make_cache_key(
                     voice_name, model_type="voxcpm2", created_at=_created_at
                 )
@@ -3131,14 +3157,24 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
                     _key = self._speaker_cache.make_cache_key(voice_name, model_type="voxcpm2", created_at=_created_at)
                     self._speaker_cache.put(_key, {"ref_audio_feat": state.prompt_cache["ref_audio_feat"].cpu()})
                     logger.debug("Speaker cache STORE for VoxCPM2 speaker '%s'", voice_name)
-
-            inputs = self._build_prefill_inputs(token_ids, dev, req_id)
-            tts = self.tts
-            feat_embed = tts.enc_to_lm_proj(tts.feat_encoder(inputs.audio_feat))
-            text_embed = self.model.embed_input_ids(inputs.text_token.to(dev))
-            text_mask, feat_mask = inputs.text_mask, inputs.audio_mask
-            embeds = (text_mask.unsqueeze(-1) * text_embed + feat_mask.unsqueeze(-1) * feat_embed).squeeze(0)
-            state.prefill_masks = (text_mask, feat_mask, inputs.audio_feat, feat_embed)
+            if state.prefill_embeds is None or state.prefill_masks is None:
+                inputs = self._build_prefill_inputs(token_ids, dev, req_id)
+                tts = self.tts
+                feat_embed = tts.enc_to_lm_proj(tts.feat_encoder(inputs.audio_feat))
+                text_embed = self.model.embed_input_ids(inputs.text_token.to(dev))
+                text_mask, feat_mask = inputs.text_mask, inputs.audio_mask
+                embeds = (text_mask.unsqueeze(-1) * text_embed + feat_mask.unsqueeze(-1) * feat_embed).squeeze(0)
+                state.prefill_masks = (text_mask, feat_mask, inputs.audio_feat, feat_embed)
+                state.prefill_embeds = embeds
+            chunk_end = num_computed_tokens + span_len
+            state.is_last_prefill_chunk = chunk_end == state.prefill_embeds.shape[0]
+            if chunk_end > state.prefill_embeds.shape[0]:
+                raise ValueError(
+                    "VoxCPM2 chunked prefill exceeds the constructed prompt: "
+                    f"request_id={req_id} start={num_computed_tokens} end={chunk_end} "
+                    f"prompt_len={state.prefill_embeds.shape[0]}"
+                )
+            embeds = state.prefill_embeds[num_computed_tokens:chunk_end]
         else:
             state = self._active_states.get(req_id)
             curr = state.curr_embed_for_next if state else None
diff --git a/vllm_omni/model_executor/models/voxtral_tts/pipeline.py b/vllm_omni/model_executor/models/voxtral_tts/pipeline.py
index 3bc2743c6..e6bc712fe 100644
--- a/vllm_omni/model_executor/models/voxtral_tts/pipeline.py
+++ b/vllm_omni/model_executor/models/voxtral_tts/pipeline.py
@@ -16,6 +16,7 @@ _PROC = "vllm_omni.model_executor.stage_input_processors.voxtral_tts"
 
 VOXTRAL_TTS_PIPELINE = PipelineConfig(
     model_type="voxtral_tts",
+    default_deploy_config_name="voxtral_tts.yaml",
     model_arch="VoxtralTTSForConditionalGeneration",
     stages=(
         StagePipelineConfig(
diff --git a/vllm_omni/model_executor/models/wan2_2/__init__.py b/vllm_omni/model_executor/models/wan2_2/__init__.py
new file mode 100644
index 000000000..208f01a7c
--- /dev/null
+++ b/vllm_omni/model_executor/models/wan2_2/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/vllm_omni/model_executor/models/wan2_2/pipeline.py b/vllm_omni/model_executor/models/wan2_2/pipeline.py
new file mode 100644
index 000000000..7059845fa
--- /dev/null
+++ b/vllm_omni/model_executor/models/wan2_2/pipeline.py
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Wan2.2 TI2V pipeline topology."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+WAN2_2_TI2V_PIPELINE = PipelineConfig(
+    model_type="wan2_2_ti2v",
+    model_arch="WanPipeline",
+    diffusers_class_name="WanPipeline",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="dit",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="video",
+            model_arch="WanPipeline",
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/stage_configs/hunyuan_video_15_dit_fp8.yaml b/vllm_omni/model_executor/stage_configs/hunyuan_video_15_dit_fp8.yaml
deleted file mode 100644
index 097afc020..000000000
--- a/vllm_omni/model_executor/stage_configs/hunyuan_video_15_dit_fp8.yaml
+++ /dev/null
@@ -1,38 +0,0 @@
-# Stage config for running HunyuanVideo-1.5 DiT with ModelOpt FP8 auto-detect.
-# Single GPU. Bump `tensor_parallel_size` and `devices` for multi-GPU TP.
-#
-# Use with a ModelOpt FP8 checkpoint (e.g. produced by
-# examples/quantization/quantize_hunyuanvideo_15_modelopt_fp8.py).
-
-stage_args:
-  - stage_id: 0
-    stage_type: diffusion
-    runtime:
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      model_stage: dit
-      model_class_name: HunyuanVideo15Pipeline
-      max_num_seqs: 1
-      enforce_eager: true
-      trust_remote_code: true
-      distributed_executor_backend: "mp"
-      # HunyuanVideo-1.5 peak VRAM is dominated by the single-shot VAE decode of
-      # the full video (the DiT contributes little), so tiling the decode is the
-      # main memory lever — far more than FP8 (e.g. 480x832x33: ~117 -> ~47 GiB).
-      # Default it on here; override with --vae-use-tiling/false if you have headroom.
-      vae_use_tiling: true
-      parallel_config:
-        tensor_parallel_size: 1
-
-    final_output: true
-    final_output_type: video
-    is_comprehension: false
-    default_sampling_params:
-      seed: 42
-
-runtime:
-  enabled: true
-  defaults:
-    window_size: -1
-    max_inflight: 1
diff --git a/vllm_omni/model_executor/stage_configs/mimo_audio.yaml b/vllm_omni/model_executor/stage_configs/mimo_audio.yaml
deleted file mode 100644
index b81f27fe4..000000000
--- a/vllm_omni/model_executor/stage_configs/mimo_audio.yaml
+++ /dev/null
@@ -1,61 +0,0 @@
-
-# MiMo Audio deploy: 2-stage thinker+talker → code2wav.
-#
-# Default mode is async-chunk streaming on a single GPU (both stages on
-# device 0) through SharedMemoryConnector. For the legacy 2-GPU sync
-# pipeline (stage 1 on a second card), pass ``--no-async-chunk
-# --stage-overrides '{"1": {"devices": "1", "max_model_len": 18192, "max_num_batched_tokens": 18192}}'``
-# to the serve CLI.
-async_chunk: true
-dtype: bfloat16
-
-connectors:
-  connector_of_shared_memory:
-    name: SharedMemoryConnector
-    extra:
-      shm_threshold_bytes: 365536
-      codec_streaming: true
-      connector_get_sleep_s: 0.001
-      connector_get_max_wait_first_chunk: 3000
-      connector_get_max_wait: 300
-      codec_chunk_frames: 30
-      codec_left_context_frames: 40
-
-stages:
-  - stage_id: 0
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.5
-    enforce_eager: true
-    trust_remote_code: true
-    enable_prefix_caching: false
-    max_num_batched_tokens: 8192
-    max_model_len: 8192
-    devices: "0"
-    output_connectors:
-      to_stage_1: connector_of_shared_memory
-    default_sampling_params:
-      temperature: 0.6
-      top_p: 0.95
-      top_k: 50
-      max_tokens: 18192
-      seed: 42
-      repetition_penalty: 1.1
-
-  - stage_id: 1
-    max_num_seqs: 1
-    gpu_memory_utilization: 0.4
-    enforce_eager: true
-    trust_remote_code: true
-    enable_prefix_caching: false
-    async_scheduling: false
-    max_num_batched_tokens: 8192
-    max_model_len: 8192
-    devices: "0"
-    input_connectors:
-      from_stage_0: connector_of_shared_memory
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 18192
-      seed: 42
diff --git a/vllm_omni/model_executor/stage_configs/step_audio_2.yaml b/vllm_omni/model_executor/stage_configs/step_audio_2.yaml
deleted file mode 100644
index b560fea9b..000000000
--- a/vllm_omni/model_executor/stage_configs/step_audio_2.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# Stage config for Step-Audio2 with vLLM-Omni
-#
-# Two-stage pipeline:
-#   Stage 0 (Thinker): Audio understanding → Text + Audio tokens
-#   Stage 1 (Token2Wav): Audio tokens → Waveform (24kHz)
-#
-# Hardware requirement: 1-2 GPUs (can run on single GPU with devices: "0" for both)
-
-# Model configuration reference (for documentation)
-# Actual values are set in hf_overrides below
-#
-# Token configuration:
-#   text_max: 151688              # Maximum text token ID (inclusive)
-#   audio_start: 151696           # First audio token ID in absolute vocabulary
-#   audio_vocab_size: 6562        # Total number of audio tokens
-#   audio_eos: 6561               # Audio EOS token ID (relative to audio_start)
-#   audio_patch_token_id: 151690  # <audio_patch> placeholder token ID
-#
-# Encoder configuration:
-#   n_mels: 128                   # Number of mel frequency bins
-#   n_audio_ctx: 1500             # Audio context length
-#   n_audio_state: 512            # Audio encoder hidden state dimension
-#   n_audio_head: 8               # Number of attention heads
-#   n_audio_layer: 6              # Number of encoder layers
-#   kernel_size: 3                # Convolution kernel size for adapter
-#   adapter_stride: 2             # Stride for adapter convolution
-
-stage_args:
-  # Stage 0: Thinker (Audio Understanding + Token Generation)
-  - stage_id: 0
-    runtime:
-      process: true              # Run in separate process
-      devices: "0,1,2,3"          # Use 3 GPUs for tensor parallelism
-      max_batch_size: 1         # Single sample at a time
-    engine_args:
-      model_stage: step_audio2_thinker
-      model_arch: StepAudio2ThinkerForConditionalGeneration
-      tensor_parallel_size: 4   # Split model across 3 GPUs
-        # NOTE: All default values are defined in step_audio2_constants.py (DEFAULT_MODEL_CONFIG)
-        # Only override here if your model differs from the defaults
-        #
-        # Default values (for reference, from constants.py):
-        #   hidden_size: 4096              # Qwen2-7B (change to 1536 for 1.5B, 896 for 0.5B)
-        #   text_max: 151688
-        #   audio_start: 151696
-        #   audio_vocab_size: 6562
-        #   audio_eos: 6561
-        #   audio_patch_token_id: 151690
-        #   n_mels: 128
-        #   n_audio_ctx: 1500
-        #   n_audio_state: 512
-        #   n_audio_head: 8
-        #   n_audio_layer: 6
-        #   kernel_size: 3
-        #   adapter_stride: 2
-        #
-        # Uncomment and modify only if needed:
-        # hidden_size: 4096
-      worker_cls: vllm_omni.worker.gpu_ar_worker.GPUARWorker
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      gpu_memory_utilization: 0.8
-      enforce_eager: true        # Required for now
-      trust_remote_code: true
-      enable_prefix_caching: false
-      max_num_batched_tokens: 8192
-      engine_output_type: text   # Outputs text + audio tokens
-    is_comprehension: true       # This stage does comprehension
-    final_output: true          # Can be final output (for ASR mode)
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.7
-      top_p: 0.9
-      top_k: -1
-      max_tokens: 1024
-      seed: 42
-      detokenize: true
-      repetition_penalty: 1.05
-
-  # Stage 1: Token2Wav (Audio Synthesis)
-  - stage_id: 1
-    runtime:
-      process: true
-      devices: "3"              # Use GPU 3 (separate from Stage 0's 0-2)
-      max_batch_size: 1
-    engine_args:
-      model_stage: token2wav
-      model_arch: StepAudio2Token2WavModel
-      hf_overrides:
-        architectures: ["StepAudio2Token2WavForConditionalGeneration"]
-      worker_cls: vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
-
-      gpu_memory_utilization: 0.3  # Token2Wav needs less memory
-      enforce_eager: true
-      trust_remote_code: true
-      async_scheduling: false
-      enable_prefix_caching: false
-      max_num_batched_tokens: 4096
-      engine_output_type: audio    # Outputs waveform
-    engine_input_source: [0]       # Takes input from Stage 0
-    custom_process_input_func: vllm_omni.model_executor.stage_input_processors.step_audio2.thinker2token2wav
-    final_output: true            # Final output stage
-    final_output_type: audio
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 1
-      seed: 42
-      detokenize: false
-
-# Runtime configuration
-runtime:
-  enabled: true
-  defaults:
-    window_size: -1             # Wait for full input before triggering
-    max_inflight: 1             # Process one at a time
-
-  edges:
-    - from: 0                   # Thinker → Token2Wav
-      to: 1
-      window_size: -1           # Wait for complete output from Thinker
diff --git a/vllm_omni/model_executor/stage_configs/step_audio_2_asr.yaml b/vllm_omni/model_executor/stage_configs/step_audio_2_asr.yaml
deleted file mode 100644
index 1cecfddc5..000000000
--- a/vllm_omni/model_executor/stage_configs/step_audio_2_asr.yaml
+++ /dev/null
@@ -1,35 +0,0 @@
-# Stage config for Step-Audio2 ASR (speech-to-text only)
-#
-# Single-stage pipeline: only Thinker, no Token2Wav.
-# Use this for audio_to_text tasks where no audio output is needed.
-
-stage_args:
-  - stage_id: 0
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0,1"
-      max_batch_size: 1
-    engine_args:
-      model_stage: step_audio2_thinker
-      model_arch: StepAudio2ThinkerForConditionalGeneration
-      worker_type: ar
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      gpu_memory_utilization: 0.8
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      max_num_batched_tokens: 2048
-      tensor_parallel_size: 2
-      engine_output_type: text
-    is_comprehension: true
-    final_output: true
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.7
-      top_p: 0.9
-      top_k: -1
-      max_tokens: 1024
-      seed: 42
-      detokenize: true
-      repetition_penalty: 1.05
diff --git a/vllm_omni/model_executor/stage_configs/step_audio_2_async_chunk.yaml b/vllm_omni/model_executor/stage_configs/step_audio_2_async_chunk.yaml
deleted file mode 100644
index 98c484072..000000000
--- a/vllm_omni/model_executor/stage_configs/step_audio_2_async_chunk.yaml
+++ /dev/null
@@ -1,78 +0,0 @@
-# Stage config for Step-Audio2 with async_chunk support
-#
-# Two-stage pipeline with streaming between stages:
-#   Stage 0 (Thinker): Audio understanding → Text + Audio tokens (streamed in chunks)
-#   Stage 1 (Token2Wav): Audio tokens → Waveform (24kHz)
-#
-# Key difference from step_audio_2.yaml:
-#   - async_chunk: true enables streaming from Thinker to Token2Wav
-#   - Thinker uses custom_process_next_stage_input_func to send audio token chunks
-#   - Token2Wav receives chunks incrementally instead of waiting for full output
-#
-# Hardware requirement: 1-2 GPUs (can run on single GPU with devices: "0" for both)
-
-async_chunk: true
-stage_args:
-  # Stage 0: Thinker (Audio Understanding + Token Generation)
-  - stage_id: 0
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0,1"
-      max_batch_size: 1
-    engine_args:
-      model_stage: step_audio2_thinker
-      model_arch: StepAudio2ThinkerForConditionalGeneration
-      worker_type: ar
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      gpu_memory_utilization: 0.8
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      max_num_batched_tokens: 1024
-      tensor_parallel_size: 2
-      engine_output_type: latent
-      custom_process_next_stage_input_func: vllm_omni.model_executor.stage_input_processors.step_audio2.thinker2token2wav_async_chunk
-    is_comprehension: true
-    final_output: true
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.7
-      top_p: 0.9
-      top_k: -1
-      max_tokens: 1024
-      seed: 42
-      detokenize: true
-      repetition_penalty: 1.05
-
-  # Stage 1: Token2Wav (Audio Synthesis)
-  - stage_id: 1
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "3"
-      max_batch_size: 1
-    engine_args:
-      model_stage: token2wav
-      model_arch: StepAudio2Token2WavModel
-      worker_type: generation
-      hf_overrides:
-        architectures: ["StepAudio2Token2WavForConditionalGeneration"]
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
-      gpu_memory_utilization: 0.3
-      enforce_eager: true
-      trust_remote_code: true
-      async_scheduling: false
-      enable_prefix_caching: false
-      max_num_batched_tokens: 2048
-      engine_output_type: audio
-    engine_input_source: [0]
-    final_output: true
-    final_output_type: audio
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 1
-      seed: 42
-      detokenize: false
diff --git a/vllm_omni/model_executor/stage_configs/wan2_2_ti2v_dit_fp8.yaml b/vllm_omni/model_executor/stage_configs/wan2_2_ti2v_dit_fp8.yaml
deleted file mode 100644
index 1b1c40537..000000000
--- a/vllm_omni/model_executor/stage_configs/wan2_2_ti2v_dit_fp8.yaml
+++ /dev/null
@@ -1,41 +0,0 @@
-# Stage config for running Wan2.2 TI2V-5B DiT with ModelOpt FP8 auto-detect.
-# Single GPU (TI2V-5B fits 80GB BF16; FP8 drops by ~half).
-# For the A14B MoE variants, bump `tensor_parallel_size` and `devices`.
-#
-# Use with a ModelOpt FP8 checkpoint (e.g. produced by
-# examples/quantization/quantize_wan2_2_modelopt_fp8.py).
-
-stage_args:
-  - stage_id: 0
-    stage_type: diffusion
-    runtime:
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      model_stage: dit
-      # Wan2.2 TI2V-5B is served by the base Wan22Pipeline, which auto-detects
-      # expand_timesteps (TI2V-5B mode) from model_index.json. (The standalone
-      # Wan22TI2VPipeline was consolidated into Wan22Pipeline upstream.)
-      model_class_name: Wan22Pipeline
-      max_num_seqs: 1
-      enforce_eager: true
-      trust_remote_code: true
-      distributed_executor_backend: "mp"
-      # Tile the VAE decode by default. Wan2.2's 480p peak is DiT-dominated (so
-      # FP8 is the main lever here), but tiling adds headroom for higher
-      # resolutions / longer clips at negligible cost. Override with --vae-use-tiling/false.
-      vae_use_tiling: true
-      parallel_config:
-        tensor_parallel_size: 1
-
-    final_output: true
-    final_output_type: video
-    is_comprehension: false
-    default_sampling_params:
-      seed: 42
-
-runtime:
-  enabled: true
-  defaults:
-    window_size: -1
-    max_inflight: 1
diff --git a/vllm_omni/model_executor/stage_input_processors/audex.py b/vllm_omni/model_executor/stage_input_processors/audex.py
new file mode 100644
index 000000000..011ec9043
--- /dev/null
+++ b/vllm_omni/model_executor/stage_input_processors/audex.py
@@ -0,0 +1,356 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Audex thinker → code2wav stage input processors.
+
+The thinker is a plain token-autoregressive LM whose sampled stream contains
+``<speechcodec_N>`` tokens in a contiguous vocab block. These processors read
+the sampled token ids directly (no tokenizer, no multimodal outputs), map them
+to codec frame ids by subtracting the vocab offset, and ship single-codebook
+frame payloads to the code2wav stage.
+
+The downstream decoder is stateful-streaming (one session per request), so
+chunks carry ONLY new frames — no left-context replay — plus a ``finished``
+flag whose final (possibly empty) payload triggers the decoder's lookahead
+flush.
+"""
+
+from typing import Any
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.data_entry_keys import CodesStruct, MetaStruct, OmniPayloadStruct
+from vllm_omni.inputs.data import OmniTokensPrompt
+from vllm_omni.model_executor.stage_input_processors.bagel import ExpandedPrompt
+
+logger = init_logger(__name__)
+
+CFG_UNCOND_SUFFIX = "__cfg_uncond"
+
+# Vocab layout of nvidia/Nemotron-Labs-Audex-2B checkpoint_folder_audiogen:
+# <speechcodec_0> .. <speechcodec_65535> occupy a contiguous id block. The
+# deploy yaml can override both values; a unit test pins these defaults
+# against the real tokenizer.
+_DEFAULT_CODEC_TOKEN_OFFSET = 131077
+_DEFAULT_CODEC_VOCAB_SIZE = 65536
+
+# TTA <audiocodec_N> block (see models/audex/tta.py; pinned against the real
+# tokenizer there). Interleaved 4-codebook RVQ.
+_DEFAULT_AUDIOCODEC_TOKEN_OFFSET = 196613
+_DEFAULT_AUDIOCODEC_VOCAB_SIZE = 8192
+_TTA_NUM_CODEBOOKS = 4
+
+_STATE_KEY = "_audex_async_state"
+
+
+def _ensure_list(value: Any) -> list[int]:
+    if value is None:
+        return []
+    if isinstance(value, torch.Tensor):
+        return value.reshape(-1).tolist()
+    return list(value)
+
+
+def _connector_extra(transfer_manager: Any) -> dict[str, Any]:
+    connector = getattr(transfer_manager, "connector", None)
+    raw_cfg = getattr(connector, "config", {}) or {}
+    if isinstance(raw_cfg, dict):
+        extra = raw_cfg.get("extra", raw_cfg)
+        return extra if isinstance(extra, dict) else {}
+    return {}
+
+
+def _codec_frames(tokens: list[int], codec_offset: int, codec_size: int) -> list[int]:
+    """Map ``<speechcodec_N>`` token ids to codec frame ids, dropping all other tokens."""
+    return [int(t) - codec_offset for t in tokens if codec_offset <= int(t) < codec_offset + codec_size]
+
+
+def _finished_meta(request_id: Any) -> dict[str, Any]:
+    """Terminal-payload meta shared by the sync full-payload producers."""
+    return {
+        "finished": torch.tensor(True, dtype=torch.bool),
+        "req_id": [request_id],
+    }
+
+
+def _finished_request_codes(
+    transfer_manager: Any,
+    request: Any,
+    offset_key: str,
+    size_key: str,
+    default_offset: int,
+    default_size: int,
+) -> tuple[list[int], Any]:
+    """Codec frame ids from a finished request's full token stream, plus its id."""
+    cfg = _connector_extra(transfer_manager)
+    codec_offset = int(cfg.get(offset_key, default_offset))
+    codec_size = int(cfg.get(size_key, default_size))
+    output_token_ids = _ensure_list(getattr(request, "output_token_ids", []))
+    codes = _codec_frames(output_token_ids, codec_offset, codec_size)
+    request_id = getattr(request, "external_req_id", None) or getattr(request, "request_id", None)
+    return codes, request_id
+
+
+def _empty_finished_payload(request_id: Any, codebooks: int) -> dict[str, Any]:
+    """Terminal payload for a failed request on the sync full-payload path.
+
+    Stage 1 decodes it to empty audio, which the serving layer's no-audio
+    guard turns into a request-level error. Raising here instead would be
+    swallowed by the payload hook (no terminal payload -> stage-1 stall).
+    """
+    return {
+        "codes": {"audio": torch.empty((0, codebooks), dtype=torch.long)},
+        "meta": _finished_meta(request_id),
+    }
+
+
+def expand_cfg_prompts(prompt: dict[str, Any] | str, sampling_params: Any) -> list[ExpandedPrompt]:
+    """Emit the unconditional CFG companion for a guided Audex TTS request.
+
+    A request opts into CFG by carrying ``extra_args`` with
+    ``cfg_scale > 1.0``, ``cfg_role="cond"``, ``cfg_pair_id`` and the
+    pre-built length-matched ``cfg_null_prompt`` (constructed where a
+    tokenizer is available: the serving layer or the offline example).
+    Unguided requests (no/1.0 scale) expand to nothing, keeping the
+    disabled path identical to the non-CFG flow.
+    """
+    extra_args = getattr(sampling_params, "extra_args", None) or {}
+    try:
+        cfg_scale = float(extra_args.get("cfg_scale", 1.0))
+    except (TypeError, ValueError):
+        return []
+    if cfg_scale <= 1.0 or extra_args.get("cfg_role") != "cond":
+        return []
+
+    pair_id = extra_args.get("cfg_pair_id")
+    null_prompt = extra_args.get("cfg_null_prompt")
+    if not pair_id or not isinstance(null_prompt, str) or not null_prompt:
+        raise ValueError(
+            "Audex CFG request is missing cfg_pair_id/cfg_null_prompt in extra_args; "
+            "the caller must build the length-matched null prompt before submission"
+        )
+
+    if isinstance(prompt, dict):
+        companion_prompt: dict[str, Any] | str = {**prompt, "prompt": null_prompt}
+        companion_prompt.pop("prompt_token_ids", None)
+    else:
+        companion_prompt = null_prompt
+
+    return [
+        ExpandedPrompt(
+            prompt=companion_prompt,
+            role="uncond",
+            request_id_suffix=CFG_UNCOND_SUFFIX,
+            sampling_params_override={
+                "extra_args": {
+                    "cfg_scale": cfg_scale,
+                    "cfg_role": "uncond",
+                    "cfg_pair_id": pair_id,
+                }
+            },
+        )
+    ]
+
+
+def _extract_new_codes(
+    request: Any,
+    state: dict[str, Any],
+    codec_offset: int,
+    codec_size: int,
+) -> list[int]:
+    """Return codec frame ids from tokens sampled since the last call."""
+    output_token_ids = _ensure_list(getattr(request, "output_token_ids", []))
+    new_tokens = output_token_ids[int(state.get("seen_len", 0)) :]
+    state["seen_len"] = len(output_token_ids)
+    return _codec_frames(new_tokens, codec_offset, codec_size)
+
+
+def thinker2code2wav_async_chunk(
+    transfer_manager: Any,
+    multimodal_output: dict[str, Any] | None,
+    request: Any,
+    is_finished: bool = False,
+) -> OmniPayloadStruct | None:
+    """Async-chunk producer: sampled token stream → per-chunk codec frames."""
+    del multimodal_output  # thinker emits none; codes come from the token stream
+    request_id = request.external_req_id
+    finished = bool(is_finished or request.is_finished())
+
+    cfg = _connector_extra(transfer_manager)
+    chunk_frames = int(cfg.get("codec_chunk_frames", 25))
+    initial_chunk_frames = int(cfg.get("initial_codec_chunk_frames", chunk_frames))
+    codec_offset = int(cfg.get("codec_token_offset", _DEFAULT_CODEC_TOKEN_OFFSET))
+    codec_size = int(cfg.get("codec_vocab_size", _DEFAULT_CODEC_VOCAB_SIZE))
+    if chunk_frames <= 0 or initial_chunk_frames <= 0:
+        raise ValueError(
+            f"Invalid codec chunk config: codec_chunk_frames={chunk_frames}, "
+            f"initial_codec_chunk_frames={initial_chunk_frames}"
+        )
+
+    request_state = transfer_manager.request_payload.get(request_id)
+    if not isinstance(request_state, dict) or _STATE_KEY not in request_state:
+        request_state = {
+            _STATE_KEY: {
+                "seen_len": 0,
+                "pending": [],
+                "emitted_chunks": 0,
+                "total_frames": 0,
+                "terminal_sent": False,
+            }
+        }
+        transfer_manager.request_payload[request_id] = request_state
+    state = request_state[_STATE_KEY]
+    if state.get("terminal_sent", False):
+        return None
+
+    pending: list[int] = state["pending"]
+    new_codes = _extract_new_codes(request, state, codec_offset, codec_size)
+    pending.extend(new_codes)
+    state["total_frames"] = int(state.get("total_frames", 0)) + len(new_codes)
+
+    if finished and state["total_frames"] == 0:
+        # Fail fast: the transfer adapter logs this and still delivers the
+        # terminal marker, and the serving layer turns the audio-less request
+        # into a request-level error instead of a silent empty stream.
+        state["terminal_sent"] = True
+        raise ValueError(f"Audex thinker produced no codec tokens for request {request_id}")
+
+    # Hold back at least one frame on non-terminal emissions so the terminal
+    # chunk always carries codes: the generation scheduler never runs a final
+    # forward for an empty terminal chunk, and the decoder's lookahead tail is
+    # only flushed inside a forward that sees the finished flag.
+    target = initial_chunk_frames if state["emitted_chunks"] == 0 else chunk_frames
+    if not finished and len(pending) <= target:
+        return None
+
+    if finished:
+        emit, state["pending"] = pending, []
+        state["terminal_sent"] = True
+    else:
+        emit, state["pending"] = pending[:target], pending[target:]
+
+    state["emitted_chunks"] += 1
+    finished_flag = torch.tensor(finished, dtype=torch.bool)
+    # Shape [frames, 1]: 2-D codec payloads ride the connector's payload
+    # channel into ``runtime_additional_information`` (1-D tensors are
+    # rerouted onto the token path and never reach the model's payload view).
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=torch.tensor(emit, dtype=torch.long).reshape(-1, 1)),
+        meta=MetaStruct(
+            finished=finished_flag,
+            # The chunk adapter strips ``meta.finished`` before it reaches the
+            # stage-1 model; ``stream_finished`` survives and is what
+            # AudexCode2Wav uses to trigger the lookahead flush.
+            stream_finished=finished_flag,
+            req_id=[request_id],
+        ),
+    )
+
+
+def thinker2code2wav_full_payload(
+    transfer_manager: Any,
+    pooling_output: dict[str, Any] | None,
+    request: Any,
+) -> dict[str, Any] | None:
+    """Sync-path producer: ship the full codec sequence once at finish."""
+    del pooling_output  # thinker emits none; codes come from the token stream
+    codes, request_id = _finished_request_codes(
+        transfer_manager,
+        request,
+        "codec_token_offset",
+        "codec_vocab_size",
+        _DEFAULT_CODEC_TOKEN_OFFSET,
+        _DEFAULT_CODEC_VOCAB_SIZE,
+    )
+    if not codes:
+        # Do NOT raise: the sync payload hook swallows exceptions and returns
+        # None, so no terminal payload would reach stage 1 and the request
+        # would stall. An empty FINISHED payload lets stage 1 complete with
+        # empty audio and the serving-layer no-audio guard fail the request.
+        logger.error(
+            "Audex thinker produced no codec tokens for request %s; sending empty terminal payload", request_id
+        )
+        return _empty_finished_payload(request_id, codebooks=1)
+    return {"codes": {"audio": codes}, "meta": _finished_meta(request_id)}
+
+
+def thinker2xcodec_full_payload(
+    transfer_manager: Any,
+    pooling_output: dict[str, Any] | None,
+    request: Any,
+) -> dict[str, Any] | None:
+    """TTA sync-path producer: ship the de-interleaved RVQ payload at finish.
+
+    Filters ``<audiocodec_N>`` ids from the sampled stream, truncates to whole
+    4-token frames, and ships a ``[frames, 4]`` codec-id payload (offsets NOT
+    subtracted; the XCodec1 stage removes the per-layer offset).
+    """
+    del pooling_output  # thinker emits none; codes come from the token stream
+    codes, request_id = _finished_request_codes(
+        transfer_manager,
+        request,
+        "audiocodec_token_offset",
+        "audiocodec_vocab_size",
+        _DEFAULT_AUDIOCODEC_TOKEN_OFFSET,
+        _DEFAULT_AUDIOCODEC_VOCAB_SIZE,
+    )
+    # Error paths do NOT raise: the sync payload hook swallows exceptions and
+    # returns None, so no terminal payload would reach stage 1 and the
+    # request would stall. An empty FINISHED payload lets stage 1 complete
+    # with empty audio and the serving-layer no-audio guard fail the request.
+    if not codes:
+        logger.error(
+            "Audex TTA thinker produced no codec tokens for request %s; sending empty terminal payload", request_id
+        )
+        return _empty_finished_payload(request_id, codebooks=_TTA_NUM_CODEBOOKS)
+    usable = len(codes) - (len(codes) % _TTA_NUM_CODEBOOKS)
+    if usable == 0:
+        logger.error(
+            "Audex TTA thinker produced fewer than one full RVQ frame for request %s; sending empty terminal payload",
+            request_id,
+        )
+        return _empty_finished_payload(request_id, codebooks=_TTA_NUM_CODEBOOKS)
+
+    # Validate the ACTUAL generated stream against the 4-codebook phase
+    # contract before decode: XCodec's per-layer offset removal clamps
+    # invalid ids into range, which would silently mask a phase violation.
+    from vllm_omni.model_executor.models.audex.tta import validate_rvq_phase
+
+    validity = validate_rvq_phase(codes[:usable])
+    if not validity["phase_valid"]:
+        logger.error(
+            "Audex TTA thinker produced a phase-invalid RVQ stream for request %s: "
+            "%d mismatched positions (first mismatch [index, codec_id, got_phase, expected_phase] = %s); "
+            "sending empty terminal payload",
+            request_id,
+            validity["mismatch_count"],
+            validity["first_mismatch"],
+        )
+        return _empty_finished_payload(request_id, codebooks=_TTA_NUM_CODEBOOKS)
+
+    frames = torch.tensor(codes[:usable], dtype=torch.long).reshape(-1, _TTA_NUM_CODEBOOKS)
+    return {"codes": {"audio": frames}, "meta": _finished_meta(request_id)}
+
+
+def thinker2code2wav_token_only(
+    source_outputs: list[Any],
+    prompt: Any = None,
+    _requires_multimodal_data: bool = False,
+):
+    """Sync-side stage-1 engine-input builder (length placeholder).
+
+    The bulk codec payload ships via the worker connector from
+    ``thinker2code2wav_full_payload``; this only sizes the stage-1 request.
+    """
+    del prompt
+    engine_inputs: list[OmniTokensPrompt] = []
+    for source_output in source_outputs:
+        if not source_output.finished:
+            continue
+        output = source_output.outputs[0]
+        prompt_ids = _ensure_list(source_output.prompt_token_ids)
+        raw_output_ids = _ensure_list(output.cumulative_token_ids)
+        if raw_output_ids[: len(prompt_ids)] == prompt_ids:
+            raw_output_ids = raw_output_ids[len(prompt_ids) :]
+        engine_inputs.append(OmniTokensPrompt(prompt_token_ids=raw_output_ids))
+    return engine_inputs
diff --git a/vllm_omni/model_executor/stage_input_processors/chunk_size_utils.py b/vllm_omni/model_executor/stage_input_processors/chunk_size_utils.py
index 8b8956839..ad35c2349 100644
--- a/vllm_omni/model_executor/stage_input_processors/chunk_size_utils.py
+++ b/vllm_omni/model_executor/stage_input_processors/chunk_size_utils.py
@@ -1,6 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 def max_ic_for_chunk_size(chunk_size: int) -> int:
     """Largest power of 2 strictly less than chunk_size."""
@@ -31,3 +35,95 @@ def compute_dynamic_initial_chunk_size(
     load_factor = min(active_requests / max_num_seqs, 1.0)
     idx = int(round(load_factor * (len(steps) - 1)))
     return steps[idx]
+
+
+def parse_chunk_ramp(cfg: dict, steady: int | None = None) -> list[int] | None:
+    """Parse ``codec_chunk_ramp`` from connector extra config.
+
+    Accepts a list of positive ints or a comma-separated string.
+    Returns ``None`` when the key is absent or invalid (ramp disabled).
+    Requires >= 2 entries; all entries must be > 0.
+
+    When ``steady`` is provided, warns if ``ramp[-1] != steady`` (the last
+    ramp entry should match ``codec_chunk_frames`` to avoid reintroducing
+    the cliff the ramp is meant to eliminate).
+    """
+    raw = cfg.get("codec_chunk_ramp")
+    if raw is None:
+        return None
+    try:
+        if isinstance(raw, str):
+            raw = [int(x.strip()) for x in raw.split(",")]
+        ramp = [int(x) for x in raw]
+    except (TypeError, ValueError):
+        logger.warning("codec_chunk_ramp parse error for %r; disabling ramp.", raw)
+        return None
+    if len(ramp) < 2:
+        logger.warning("codec_chunk_ramp needs >= 2 entries, got %d; disabling.", len(ramp))
+        return None
+    if any(x <= 0 for x in ramp):
+        logger.warning("codec_chunk_ramp entries must be positive; disabling.")
+        return None
+    if steady is not None and ramp[-1] != steady:
+        logger.warning(
+            "codec_chunk_ramp[-1]=%d != codec_chunk_frames=%d; this reintroduces the chunk-size cliff at index %d.",
+            ramp[-1],
+            steady,
+            len(ramp) - 1,
+        )
+    return ramp
+
+
+def ramp_chunk_size(index: int, ramp: list[int], steady: int) -> int:
+    """Return the target chunk size for chunk ``index`` under the ramp schedule.
+
+    Indices within the ramp table use ``ramp[index]``; indices past the table
+    fall back to ``steady`` (typically ``codec_chunk_frames``).
+    """
+    if index < len(ramp):
+        return ramp[index]
+    return steady
+
+
+def ramp_cumulative(index: int, ramp: list[int], steady: int) -> int:
+    """Cumulative frame count through chunk ``index`` (inclusive).
+
+    O(len(ramp)) closed form: sum the ramp table once, then add
+    ``(index + 1 - len(ramp)) * steady`` for indices past the table.
+    """
+    ramp_len = len(ramp)
+    if index < ramp_len:
+        return sum(ramp[: index + 1])
+    return sum(ramp) + (index + 1 - ramp_len) * steady
+
+
+def compute_ramp_emit(
+    length: int,
+    chunk_index: int,
+    ramp: list[int],
+    steady: int,
+    finished: bool,
+) -> tuple[bool, int]:
+    """Decide whether to emit a chunk under the ramp schedule.
+
+    Uses cumulative thresholds to determine emission boundaries.  Each chunk
+    ``i`` covers frames ``[ramp_cumulative(i-1), ramp_cumulative(i))``.
+
+    Returns:
+        ``(emit, context_length)``
+
+        - ``emit=False, context_length=0``: not enough frames yet, hold.
+        - ``emit=True, context_length>0``: emit with this many new frames.
+        - ``emit=True, context_length=0``: finished with no new frames
+            (caller should emit an empty-finished sentinel).
+    """
+    threshold = ramp_cumulative(chunk_index, ramp, steady)
+    prev_threshold = ramp_cumulative(chunk_index - 1, ramp, steady) if chunk_index > 0 else 0
+
+    if not finished and length < threshold:
+        return False, 0
+
+    if finished and length <= prev_threshold:
+        return True, 0
+
+    return True, length - prev_threshold
diff --git a/vllm_omni/model_executor/stage_input_processors/mimo_audio.py b/vllm_omni/model_executor/stage_input_processors/mimo_audio.py
index 3a1a4441f..cd9ca7bf2 100644
--- a/vllm_omni/model_executor/stage_input_processors/mimo_audio.py
+++ b/vllm_omni/model_executor/stage_input_processors/mimo_audio.py
@@ -17,8 +17,8 @@ logger = init_logger(__name__)
 # sequence fed to stage-1 must not exceed this, otherwise gpu_input_batch
 # add_request will fail with a broadcast error when copying prompt_token_ids
 # into token_ids_cpu. Keep in sync with the stage-1 ``max_model_len`` in
-# ``vllm_omni/model_executor/stage_configs/mimo_audio.yaml`` and the offline
-# example ``examples/offline_inference/mimo_audio/end2end.py``.
+# ``vllm_omni/deploy/mimo_audio.yaml`` and the offline example
+# ``examples/offline_inference/mimo_audio/end2end.py``.
 MAX_CODE2WAV_TOKENS = 18192
 
 # Minimum safe values for codec streaming parameters.
diff --git a/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py b/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
index 799914846..d12a3b382 100644
--- a/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+++ b/vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
@@ -1,51 +1,683 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Stage input processor for MiniCPM-o 4.5: Thinker (LLM) -> Talker (TTS).
-
-This is the original vLLM-Omni bridge: it converts the thinker stage's
-hidden states + token ids into the talker stage's prompt payload. The
-talker model itself is adapted from openbmb/MiniCPM-o-4_5 (see the headers
-on vllm_omni/model_executor/models/minicpmo_4_5/*.py).
-"""
+"""MiniCPM-o 4.5 Thinker-to-Talker and Talker-to-Code2Wav bridges."""
 
+import logging
+from collections.abc import Callable, Mapping, Sequence
 from typing import Any
 
 import torch
 from vllm.inputs import TextPrompt
 
+from vllm_omni.data_entry_keys import CodesStruct, MetaStruct, OmniPayloadStruct
+from vllm_omni.experimental.fullduplex.engine.intermediate import (
+    build_duplex_intermediate_buffer,
+    set_ref_audio,
+    set_tts_handoff,
+)
 from vllm_omni.inputs.data import OmniTokensPrompt
 
+logger = logging.getLogger(__name__)
+_MINICPMO45_ASYNC_STATE = "_minicpmo45_async_codec_state"
+_MINICPMO45_STREAM_RECORD = "_minicpmo45_async_stream_record"
+_MINICPMO45_SILENCE_CODE = 4218
+_MINICPMO45_MIN_STREAM_BODY_FRAMES = 5
+
+
+class _MiniCPMO45MetaStruct(MetaStruct):
+    """Model-owned metadata for the split Talker-to-Code2Wav bridge."""
+
+    ref_audio_sr: int | None = None
+    native_duplex_segment_text: str | None = None
+    llm_output_text_utf8: torch.Tensor | None = None
+    duplex_turn_id: int | None = None
+    duplex_epoch: int | None = None
+    segment_end: bool | None = None
+    turn_end: bool | None = None
+    tts_is_last_chunk: bool | None = None
+
+
+def _extract_first_audio_ref(multi_modal_data):
+    if not isinstance(multi_modal_data, dict):
+        return None
+    audio_data = multi_modal_data.get("audio")
+    if audio_data is None:
+        return None
+    if isinstance(audio_data, list):
+        if not audio_data:
+            return None
+        audio_data = audio_data[0]
+
+    samples = None
+    sample_rate = None
+    if isinstance(audio_data, tuple) and len(audio_data) >= 2:
+        samples, sample_rate = audio_data[0], audio_data[1]
+    elif isinstance(audio_data, dict):
+        sample_rate = audio_data.get("sample_rate") or audio_data.get("sampling_rate") or audio_data.get("sr")
+        for key in ("audio", "wav", "samples", "array", "waveform"):
+            if key in audio_data:
+                samples = audio_data[key]
+                break
+    if samples is None or sample_rate is None:
+        return None
+
+    waveform = torch.as_tensor(samples, dtype=torch.float32)
+    if waveform.ndim > 1:
+        if waveform.shape[0] <= 2 and waveform.shape[-1] > waveform.shape[0]:
+            waveform = waveform.mean(dim=0)
+        else:
+            waveform = waveform.mean(dim=-1)
+    return waveform.reshape(-1).cpu(), int(sample_rate)
+
+
+def _extract_native_runtime_ref_audio(data_plane_metadata):
+    if not isinstance(data_plane_metadata, dict):
+        return None
+    runtime_config = data_plane_metadata.get("runtime_config")
+    if not isinstance(runtime_config, dict):
+        return None
+    from vllm_omni.experimental.fullduplex.minicpmo45.input import decode_native_ref_audio_from_config
+
+    waveform = decode_native_ref_audio_from_config({"extra_body": runtime_config})
+    if waveform is None:
+        return None
+    sample_rate = runtime_config.get("ref_audio_sample_rate_hz") or 16000
+    return torch.as_tensor(waveform, dtype=torch.float32).reshape(-1).cpu(), int(sample_rate)
+
+
+def _coerce_token_id_list(value):
+    if value is None:
+        return None
+    if hasattr(value, "detach"):
+        value = value.detach().cpu().reshape(-1).tolist()
+    if isinstance(value, list) and value and isinstance(value[0], list):
+        value = value[0]
+    if isinstance(value, tuple):
+        value = list(value)
+    if not isinstance(value, list):
+        return None
+    out = []
+    for item in value:
+        try:
+            out.append(int(item))
+        except (TypeError, ValueError):
+            return None
+    return out
+
+
+def _to_transport_list(value):
+    if hasattr(value, "detach"):
+        value = value.detach().cpu()
+    if isinstance(value, torch.Tensor):
+        return value.tolist()
+    return value
+
+
+def _coerce_int(value):
+    if hasattr(value, "detach"):
+        flat = value.detach().cpu().reshape(-1)
+        if flat.numel() == 0:
+            return None
+        value = flat[0].item()
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _codec_config(transfer_manager: Any) -> tuple[int, int]:
+    connector = getattr(transfer_manager, "connector", None)
+    raw_config = getattr(connector, "config", {}) or {}
+    config = raw_config.get("extra", raw_config) if isinstance(raw_config, dict) else {}
+    config = config if isinstance(config, dict) else {}
+    chunk_frames = int(config.get("codec_chunk_frames", 25))
+    left_context_frames = int(config.get("codec_left_context_frames", 3))
+    if chunk_frames <= 0 or left_context_frames < 0:
+        raise ValueError(
+            "Invalid MiniCPM-o codec chunk config: "
+            f"codec_chunk_frames={chunk_frames}, "
+            f"codec_left_context_frames={left_context_frames}"
+        )
+    return chunk_frames, left_context_frames
+
+
+def _codec_scalars(value: Any) -> list[int]:
+    """Normalize one request-routed codec delta to CPU scalar token IDs."""
+    if value is None:
+        return []
+    if isinstance(value, torch.Tensor):
+        if value.numel() == 0:
+            return []
+        return value.detach().to(device="cpu", dtype=torch.long).reshape(-1).tolist()
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        scalars: list[int] = []
+        for item in value:
+            scalars.extend(_codec_scalars(item))
+        return scalars
+    if isinstance(value, (int, bool)):
+        return [int(value)]
+    raise TypeError(f"Unsupported MiniCPM-o codec delta type: {type(value).__name__}")
+
+
+def _extract_codec_delta(pooling_output: Any, request_id: str) -> list[int]:
+    if pooling_output is None:
+        return []
+    if isinstance(pooling_output, Mapping):
+        meta = pooling_output.get("meta")
+        routed_id = meta.get("request_id") if isinstance(meta, Mapping) else None
+        routed_id = routed_id or pooling_output.get("request_id")
+        if routed_id is not None and str(routed_id) != request_id:
+            return []
+        codes = pooling_output.get("codes")
+        audio = codes.get("audio") if isinstance(codes, Mapping) else pooling_output.get("codes.audio")
+        return _codec_scalars(audio)
+    if isinstance(pooling_output, Sequence) and not isinstance(
+        pooling_output,
+        (str, bytes, bytearray),
+    ):
+        delta: list[int] = []
+        for item in pooling_output:
+            values = _extract_codec_delta(item, request_id) if isinstance(item, Mapping) else _codec_scalars(item)
+            delta.extend(values)
+        return delta
+    return _codec_scalars(pooling_output)
+
+
+def _drop_codec_state(transfer_manager: Any, request_id: str) -> None:
+    request_payload = getattr(transfer_manager, "request_payload", None)
+    if isinstance(request_payload, dict):
+        container = request_payload.get(request_id)
+        if isinstance(container, dict):
+            container.pop(_MINICPMO45_ASYNC_STATE, None)
+            if not container:
+                request_payload.pop(request_id, None)
+        else:
+            request_payload.pop(request_id, None)
+    code_accumulators = getattr(transfer_manager, "code_prompt_token_ids", None)
+    if hasattr(code_accumulators, "pop"):
+        code_accumulators.pop(request_id, None)
+
+
+def _is_aborted(request: Any) -> bool:
+    status_name = getattr(getattr(request, "status", None), "name", "")
+    return any(marker in status_name for marker in ("ABORT", "CANCEL", "IGNORED", "ERROR"))
+
+
+def tts2code2wav_async_chunk(
+    transfer_manager: Any,
+    multimodal_output: Any,
+    request: Any,
+    is_finished: bool = False,
+) -> OmniPayloadStruct | None:
+    """Stream request-owned MiniCPM-o codec windows to Code2Wav."""
+    external_id = getattr(request, "external_req_id", None)
+    internal_id = getattr(request, "request_id", None)
+    request_id = str(external_id if external_id is not None else internal_id)
+    internal_id = str(internal_id if internal_id is not None else request_id)
+    output_meta = multimodal_output.get("meta") if isinstance(multimodal_output, Mapping) else None
+    output_meta = output_meta if isinstance(output_meta, Mapping) else {}
+    native_duplex = bool(_coerce_int(output_meta.get("native_duplex")))
+    duplex_epoch = _coerce_int(output_meta.get("duplex_epoch"))
+    duplex_turn_id = _coerce_int(output_meta.get("duplex_turn_id"))
+    segment_text_utf8 = output_meta.get("llm_output_text_utf8")
+    if not isinstance(segment_text_utf8, torch.Tensor):
+        segment_text_utf8 = None
+    turn_end = bool(_coerce_int(output_meta.get("turn_end")))
+    duplex_turn_key = (duplex_epoch, duplex_turn_id)
+
+    request_payload = getattr(transfer_manager, "request_payload", None)
+    if request_payload is None:
+        request_payload = {}
+        transfer_manager.request_payload = request_payload
+    container = request_payload.get(request_id)
+    if not isinstance(container, dict):
+        container = {}
+        request_payload[request_id] = container
+
+    record = container.get(_MINICPMO45_STREAM_RECORD)
+    if not isinstance(record, dict):
+        record = {
+            "internal_id": internal_id,
+            "cache_epoch": 0,
+            "chunk_seq": 0,
+            "retired_internal_ids": set(),
+            "last_terminal_turn": None,
+        }
+        container[_MINICPMO45_STREAM_RECORD] = record
+    elif internal_id in record["retired_internal_ids"]:
+        return None
+    elif record["internal_id"] != internal_id:
+        record["retired_internal_ids"].add(record["internal_id"])
+        record["internal_id"] = internal_id
+        record["cache_epoch"] = int(record["cache_epoch"]) + 1
+        record["chunk_seq"] = 0
+        record["last_terminal_turn"] = None
+        _drop_codec_state(transfer_manager, request_id)
+
+    if _is_aborted(request):
+        record["retired_internal_ids"].add(internal_id)
+        _drop_codec_state(transfer_manager, request_id)
+        return None
+
+    if native_duplex and turn_end and record.get("last_terminal_turn") == duplex_turn_key:
+        return None
+
+    state = container.get(_MINICPMO45_ASYNC_STATE)
+    if not isinstance(state, dict):
+        state = {
+            "internal_id": internal_id,
+            "pending": [],
+            "pending_text_utf8": [],
+            "segment_text_recorded": False,
+            "left_context": [],
+            "codec_end": 0,
+        }
+        container[_MINICPMO45_ASYNC_STATE] = state
+
+    pending = state["pending"]
+    pending.extend(_extract_codec_delta(multimodal_output, request_id))
+    pending_text_utf8 = state.setdefault("pending_text_utf8", [])
+    current_text_utf8 = (
+        segment_text_utf8.detach().to(device="cpu", dtype=torch.uint8).reshape(-1).tolist()
+        if isinstance(segment_text_utf8, torch.Tensor)
+        else []
+    )
+    if native_duplex and current_text_utf8 and not state.get("segment_text_recorded", False):
+        # Talker repeats the unit text on every codec step. Queue it once for
+        # the first Code2Wav payload that can carry audio for this unit.
+        pending_text_utf8.extend(current_text_utf8)
+        state["segment_text_recorded"] = True
+    request_finished = getattr(request, "is_finished", None)
+    finished = bool(is_finished or (callable(request_finished) and request_finished()))
+    chunk_frames, left_context_frames = _codec_config(transfer_manager)
+    flush_pending = finished
+    last_chunk = bool(flush_pending and (not native_duplex or turn_end))
+    if not flush_pending and len(pending) < chunk_frames:
+        return None
+
+    hold_short_unit = (
+        native_duplex and flush_pending and not last_chunk and 0 < len(pending) < _MINICPMO45_MIN_STREAM_BODY_FRAMES
+    )
+    new_token_count = 0 if hold_short_unit else (len(pending) if flush_pending else chunk_frames)
+    new_codes = pending[:new_token_count]
+    del pending[:new_token_count]
+    codec_start = int(state["codec_end"])
+    codec_end = codec_start + new_token_count
+
+    if new_token_count:
+        if codec_start == 0:
+            context = [_MINICPMO45_SILENCE_CODE] * left_context_frames
+        else:
+            context = list(state["left_context"])
+        output_codes = [*context, *new_codes]
+        history = output_codes
+        state["left_context"] = history[-left_context_frames:] if left_context_frames else []
+    elif last_chunk and codec_start > 0 and state["left_context"]:
+        context = list(state["left_context"])
+        output_codes = context
+    else:
+        context = []
+        output_codes = []
+    state["codec_end"] = codec_end
+    code_flat_numel = len(output_codes)
+    if native_duplex and code_flat_numel > 0:
+        segment_text_utf8 = torch.tensor(pending_text_utf8, dtype=torch.uint8)
+        pending_text_utf8.clear()
+    if native_duplex and finished:
+        state["segment_text_recorded"] = False
+    if flush_pending and not last_chunk and code_flat_numel == 0:
+        # Keep the generic generation connector model-agnostic: a real token
+        # makes this control-only TTS boundary schedulable, while the explicit
+        # zero length tells Code2Wav to discard the placeholder.
+        output_codes = [0]
+
+    if last_chunk and not native_duplex:
+        record["retired_internal_ids"].add(internal_id)
+        _drop_codec_state(transfer_manager, request_id)
+
+    chunk_seq = int(record["chunk_seq"])
+    record["chunk_seq"] = chunk_seq + 1
+    ref_audio = None
+    ref_audio_sr = None
+    if int(record["cache_epoch"]) == 0 and chunk_seq == 0:
+        request_info = getattr(request, "additional_information", None)
+        if isinstance(request_info, Mapping):
+            codes_info = request_info.get("codes")
+            meta_info = request_info.get("meta")
+            raw_ref_audio = codes_info.get("ref") if isinstance(codes_info, Mapping) else None
+            raw_ref_audio_sr = meta_info.get("ref_audio_sr") if isinstance(meta_info, Mapping) else None
+            ref_audio_sr = _coerce_int(raw_ref_audio_sr)
+            if raw_ref_audio is not None:
+                ref_audio = torch.as_tensor(raw_ref_audio, dtype=torch.float32).reshape(-1).cpu()
+    finished_tensor = torch.tensor(last_chunk, dtype=torch.bool)
+    payload = OmniPayloadStruct(
+        codes=CodesStruct(
+            audio=torch.tensor(output_codes, dtype=torch.long),
+            ref=ref_audio,
+        ),
+        meta=_MiniCPMO45MetaStruct(
+            request_id=request_id,
+            chunk_seq=chunk_seq,
+            cache_epoch=int(record["cache_epoch"]),
+            code_flat_numel=code_flat_numel,
+            codec_chunk_frames=new_token_count,
+            codec_left_context_frames=len(context),
+            left_context_size=len(context),
+            last_chunk=last_chunk,
+            stream_finished=finished_tensor,
+            finished=finished_tensor,
+            is_segment_finished=finished_tensor,
+            req_id=[request_id],
+            duplex_epoch=duplex_epoch,
+            duplex_turn_id=duplex_turn_id,
+            llm_output_text_utf8=segment_text_utf8,
+            tts_is_last_chunk=flush_pending,
+            turn_end=turn_end and last_chunk,
+            ref_audio_sr=ref_audio_sr,
+        ),
+        request_id=request_id,
+    )
+    if last_chunk and native_duplex:
+        record["last_terminal_turn"] = duplex_turn_key
+        record["cache_epoch"] = int(record["cache_epoch"]) + 1
+        record["chunk_seq"] = 0
+        _drop_codec_state(transfer_manager, request_id)
+    return payload
+
+
+def tts2code2wav_full_payload(
+    transfer_manager: Any,
+    pooling_output: Any,
+    request: Any,
+) -> OmniPayloadStruct:
+    """Build one terminal Code2Wav payload when async chunks are disabled."""
+    external_id = getattr(request, "external_req_id", None)
+    internal_id = getattr(request, "request_id", None)
+    request_id = str(external_id if external_id is not None else internal_id)
+    codes = _extract_codec_delta(pooling_output, request_id)
+    _, left_context_frames = _codec_config(transfer_manager)
+    context = [_MINICPMO45_SILENCE_CODE] * left_context_frames if codes else []
+    output_codes = [*context, *codes]
+
+    request_info = getattr(request, "additional_information", None)
+    if not isinstance(request_info, Mapping):
+        request_info = {}
+    codes_info = request_info.get("codes")
+    if not isinstance(codes_info, Mapping):
+        codes_info = {}
+    meta_info = request_info.get("meta")
+    if not isinstance(meta_info, Mapping):
+        meta_info = {}
+    duplex_info = request_info.get("duplex")
+    if not isinstance(duplex_info, Mapping):
+        duplex_info = {}
+
+    ref_audio = codes_info.get("ref")
+    finished = torch.tensor(True, dtype=torch.bool)
+    return OmniPayloadStruct(
+        codes=CodesStruct(
+            audio=torch.tensor(output_codes, dtype=torch.long),
+            ref=torch.as_tensor(ref_audio, dtype=torch.float32).reshape(-1) if ref_audio is not None else None,
+        ),
+        meta=_MiniCPMO45MetaStruct(
+            request_id=request_id,
+            chunk_seq=0,
+            cache_epoch=0,
+            code_flat_numel=len(output_codes),
+            codec_chunk_frames=len(codes),
+            codec_left_context_frames=len(context),
+            left_context_size=len(context),
+            last_chunk=True,
+            stream_finished=finished,
+            finished=finished,
+            req_id=[request_id],
+            ref_audio_sr=_coerce_int(meta_info.get("ref_audio_sr")),
+            native_duplex_segment_text=(
+                str(meta_info["native_duplex_segment_text"])
+                if isinstance(meta_info.get("native_duplex_segment_text"), str)
+                else None
+            ),
+            duplex_turn_id=_coerce_int(duplex_info.get("model_turn_id", duplex_info.get("turn_id"))),
+            duplex_epoch=_coerce_int(duplex_info.get("epoch")),
+            segment_end=bool(meta_info.get("segment_end", False)),
+            turn_end=bool(meta_info.get("turn_end", False)),
+            tts_is_last_chunk=True,
+        ),
+        request_id=request_id,
+    )
+
+
+def tts2code2wav_token_only(
+    source_outputs: list[Any],
+    _prompt: Any = None,
+    _requires_multimodal_data: bool = False,
+) -> list[OmniTokensPrompt]:
+    """Build the sync Code2Wav placeholder; codec data arrives by connector."""
+    code2wav_inputs: list[OmniTokensPrompt] = []
+    for talker_output in source_outputs:
+        if not talker_output.finished:
+            continue
+        output = talker_output.outputs[0]
+        multimodal_output = getattr(output, "multimodal_output", None)
+        codes = multimodal_output.get("codes") if isinstance(multimodal_output, Mapping) else None
+        audio = (
+            codes.get("audio")
+            if isinstance(codes, Mapping)
+            else multimodal_output.get("codes.audio")
+            if isinstance(multimodal_output, Mapping)
+            else None
+        )
+        codec_codes = _codec_scalars(audio)
+        if not codec_codes:
+            continue
+        prompt_len = len(codec_codes) + 3
+        code2wav_inputs.append(
+            OmniTokensPrompt(
+                prompt_token_ids=[0] * prompt_len,
+                additional_information=None,
+                multi_modal_data=None,
+                mm_processor_kwargs=None,
+            )
+        )
+    return code2wav_inputs
+
+
+def _special_token_ids_from_mm_output(mm_output):
+    if not isinstance(mm_output, Mapping):
+        return {}
+    meta = mm_output.get("meta")
+    if not isinstance(meta, dict):
+        meta = {}
+    special_token_ids = mm_output.get("special_token_ids")
+    if not isinstance(special_token_ids, dict):
+        special_token_ids = {}
+    flat_meta = {
+        key.removeprefix("meta."): value
+        for key, value in mm_output.items()
+        if isinstance(key, str) and key.startswith("meta.")
+    }
+    return {
+        key: value
+        for key, value in (
+            (key, _coerce_int(value))
+            for source in (special_token_ids, meta, flat_meta)
+            for key, value in source.items()
+        )
+        if value is not None and value >= 0
+    }
+
+
+def _has_native_duplex_prompt_metadata(mm_output):
+    if not isinstance(mm_output, Mapping):
+        return False
+    return mm_output.get("duplex_prompt_token_ids") is not None or mm_output.get("ids.prompt") is not None
+
+
+def _require_native_tts_boundary_metadata(special_token_ids):
+    if special_token_ids.get("tts_bos_token_id") is None:
+        raise ValueError(
+            "MiniCPM-o native duplex TTS handoff requires tokenizer-derived "
+            "<|tts_bos|> metadata; refusing to infer special token ids."
+        )
+
+
+def _native_tts_boundary_token_ids(special_token_ids):
+    # Official duplex conditions the talker on mid-unit <|speak|> tokens AND
+    # the <|turn_eos|> token+hidden (its embedding is the trained stop
+    # signal); only chunk terminators and framing tokens bound the slice.
+    return {
+        token_id
+        for token_id in (
+            special_token_ids.get("tts_eos_token_id"),
+            special_token_ids.get("tts_pad_token_id"),
+            special_token_ids.get("listen_token_id"),
+            special_token_ids.get("chunk_eos_token_id"),
+            special_token_ids.get("chunk_tts_eos_token_id"),
+            special_token_ids.get("unit_token_id"),
+            special_token_ids.get("unit_end_token_id"),
+        )
+        if token_id is not None
+    }
+
+
+def _decode_native_duplex_token_ids(
+    token_ids: list[int],
+    streaming_context,
+    *,
+    request_id: str,
+) -> str | None:
+    decode_token_ids = getattr(streaming_context, "source_token_decoder", None)
+    if not isinstance(decode_token_ids, Callable):
+        return None
+    decode_ids = [int(token_id) for token_id in token_ids]
+    try:
+        try:
+            return str(decode_token_ids(decode_ids, skip_special_tokens=True))
+        except TypeError:
+            return str(decode_token_ids(decode_ids))
+    except Exception:
+        logger.exception("Failed to decode MiniCPM-o duplex token delta for request_id=%s", request_id)
+        return ""
+
+
+def _native_duplex_segment_output_ids(
+    output_ids: list[int],
+    output_text: str,
+    streaming_context,
+    *,
+    request_id: str,
+) -> tuple[list[int], str, bool]:
+    """Slice the cumulative thinker output down to the current segment.
+
+    Tracks how many output tokens were already handed to the talker in the
+    orchestrator's streaming bridge state. Segment transcript is decoded from
+    the same token delta, not from a character cursor over cumulative text.
+    """
+    bridge_states = getattr(streaming_context, "bridge_states", None)
+    if not isinstance(bridge_states, dict):
+        return output_ids, output_text, True
+    state = bridge_states.setdefault("minicpmo45_tts_handoff", {})
+    duplex_state = bridge_states.get("duplex")
+    turn_id = duplex_state.get("model_turn_id", duplex_state.get("turn_id")) if isinstance(duplex_state, dict) else None
+    if not isinstance(turn_id, int):
+        turn_id = None
+    if state.get("request_id") != request_id:
+        state["request_id"] = request_id
+        state["sent_output_len"] = 0
+        state["sent_output_ids"] = []
+    previous_turn_id = state.get("turn_id")
+    sent_len = state.get("sent_output_len", 0)
+    prev_output_ids = state.get("sent_output_ids", [])
+    if not isinstance(sent_len, int) or sent_len < 0 or sent_len > len(output_ids):
+        # Shrunken cumulative output = epoch reset after barge-in.
+        sent_len = 0
+    elif sent_len and isinstance(prev_output_ids, list):
+        prev_prefix = prev_output_ids[:sent_len]
+        current_prefix = output_ids[:sent_len]
+        if current_prefix != prev_prefix:
+            # Some runtimes restart output token ids after a turn boundary while
+            # others keep returning cumulative ids. Detect restart from the
+            # token prefix instead of clearing the cursor at turn_eos.
+            sent_len = 0
+    turn_start = sent_len == 0 or previous_turn_id != turn_id
+    segment_ids = output_ids[sent_len:]
+    decoded_segment_text = _decode_native_duplex_token_ids(
+        segment_ids,
+        streaming_context,
+        request_id=request_id,
+    )
+    if decoded_segment_text is not None:
+        segment_text = decoded_segment_text
+    elif sent_len == 0:
+        # Non-orchestrator unit tests and legacy callers may not install a
+        # decoder. Never slice cumulative text with a stale character cursor.
+        segment_text = output_text
+    else:
+        logger.warning(
+            "MiniCPM-o native duplex token delta decoder missing for request_id=%s; "
+            "suppressing cumulative transcript fallback",
+            request_id,
+        )
+        segment_text = ""
+    state["sent_output_len"] = len(output_ids)
+    state["sent_output_ids"] = list(output_ids)
+    state["turn_id"] = turn_id
+    return segment_ids, segment_text, turn_start
+
+
+def _native_duplex_data_plane_metadata(streaming_context) -> dict[str, object] | None:
+    bridge_states = getattr(streaming_context, "bridge_states", None)
+    if not isinstance(bridge_states, dict):
+        return None
+    duplex_state = bridge_states.get("duplex")
+    if not isinstance(duplex_state, dict):
+        return None
+
+    metadata: dict[str, object] = {"data_plane": True}
+    session_id = duplex_state.get("session_id")
+    if isinstance(session_id, str) and session_id:
+        metadata["session_id"] = session_id
+    incarnation = duplex_state.get("incarnation")
+    if isinstance(incarnation, int):
+        metadata["incarnation"] = incarnation
+    epoch = duplex_state.get("epoch")
+    if isinstance(epoch, int):
+        metadata["epoch"] = epoch
+    turn_id = duplex_state.get("model_turn_id", duplex_state.get("turn_id"))
+    if isinstance(turn_id, int):
+        metadata["turn_id"] = turn_id
+    session_config = duplex_state.get("session_config")
+    if isinstance(session_config, dict):
+        metadata["session_config"] = dict(session_config)
+    runtime_config = duplex_state.get("runtime_config")
+    if isinstance(runtime_config, dict):
+        metadata["runtime_config"] = dict(runtime_config)
+    return metadata
+
+
+def _build_tts_scheduler_prompt_token_ids(
+    tts_token_ids: torch.Tensor | None,
+    llm_output_ids: list[int],
+    prompt_token_ids: list[int],
+) -> list[int]:
+    if tts_token_ids is not None:
+        ids = _coerce_token_id_list(tts_token_ids)
+        if ids:
+            return ids
+    if llm_output_ids:
+        return llm_output_ids
+    if prompt_token_ids:
+        return prompt_token_ids[-1:]
+    raise ValueError("MiniCPM-o TTS stage requires at least one scheduler prompt token")
+
 
 def llm2tts(
-    source_outputs: list[Any],
-    prompt: OmniTokensPrompt | TextPrompt | dict | list | None = None,
+    source_outputs,
+    prompt: OmniTokensPrompt | TextPrompt = None,
     requires_multimodal_data: bool = False,
-    streaming_context: Any | None = None,
+    _streaming_context=None,
 ):
-    """Convert thinker stage output to talker stage input for MiniCPMO Omni.
-
-    The signature matches the framework's ``custom_process_input_func`` call
-    convention used by ``StageEngineCoreClientBase.process_engine_inputs``:
-
-        (source_outputs, prompt, requires_multimodal_data, streaming_context)
-
-    ``source_outputs`` is the already-resolved list of upstream engine
-    outputs (one entry per request), so we do not need to look anything up
-    via ``stage_list[source_stage_id].engine_outputs``.
-
-    Extracts from thinker output:
-      - Full hidden states (prompt + generated) for speaker embedding extraction
-      - Prompt token IDs (for finding spk_bos/spk_eos positions)
-      - Generated token IDs (for decoding TTS text)
-
-    The talker model will:
-      1. Find <|spk_bos|>/<|spk_eos|> positions in prompt_token_ids
-      2. Extract speaker embedding from hidden states at those positions
-      3. Decode generated text and extract TTS content
-      4. Run ConditionalChatTTS pipeline
-    """
-    del streaming_context  # not used by MiniCPM-o 4.5 turn-taking pipeline
-
+    """Build Talker conditioning for ordinary and full-duplex streaming."""
     if not source_outputs:
         raise ValueError("source_outputs cannot be empty")
 
@@ -55,75 +687,281 @@ def llm2tts(
     if not isinstance(prompt, list):
         prompt = [prompt]
 
-    multi_modal_data = {
-        llm_output.request_id: p.get("multi_modal_data", None) if isinstance(p, dict) else None
-        for llm_output, p in zip(llm_outputs, prompt)
-    }
+    multi_modal_data = {}
+    for llm_output, p in zip(llm_outputs, prompt):
+        if isinstance(p, dict):
+            multi_modal_data[llm_output.request_id] = p.get("multi_modal_data", None)
+        else:
+            multi_modal_data[llm_output.request_id] = getattr(p, "multi_modal_data", None)
 
-    for i, llm_output in enumerate(llm_outputs):
+    for llm_output in llm_outputs:
         output = llm_output.outputs[0]
-        prompt_token_ids = llm_output.prompt_token_ids
-        llm_output_ids = output.token_ids
+        request_mm_output = getattr(llm_output, "multimodal_output", None)
+        completion_mm_output = getattr(output, "multimodal_output", None)
+        if isinstance(request_mm_output, Mapping):
+            mm_output = request_mm_output
+        elif isinstance(completion_mm_output, Mapping):
+            mm_output = completion_mm_output
+        else:
+            mm_output = {}
+        special_token_ids = _special_token_ids_from_mm_output(mm_output)
+        prompt_token_ids = (
+            _coerce_token_id_list(mm_output.get("duplex_prompt_token_ids"))
+            or _coerce_token_id_list(mm_output.get("ids.prompt"))
+            or list(llm_output.prompt_token_ids)
+        )
+        llm_output_ids = getattr(output, "token_ids", None)
+        cumulative_output_ids = getattr(output, "cumulative_token_ids", None)
+        if llm_output_ids is None:
+            llm_output_ids = cumulative_output_ids or []
+        elif cumulative_output_ids is not None and len(cumulative_output_ids) > len(llm_output_ids):
+            # DELTA outputs (any streaming client) carry only the newest tokens,
+            # while the forwarded hidden states span prompt + whole reply. With
+            # the delta alone, tts_bos lands at the end of full_token_ids, the
+            # tts_bos..tts_eos slice collapses to nothing and the Talker is
+            # conditioned on an empty span, so the reply is silent.
+            llm_output_ids = cumulative_output_ids
+        # Always copy: CompletionOutput.token_ids can alias the upstream
+        # detokenizer's live token list. Forwarding that exact object as the
+        # talker prompt makes the stage-1 streaming update extend the list
+        # with itself (state and update bind the same object), doubling the
+        # thinker's recorded output every segment until the TTS engine input
+        # buffer overflows.
+        llm_output_ids = list(llm_output_ids)
+        thinker_text = getattr(output, "text", "") or ""
+        native_turn_start = False
+        if _has_native_duplex_prompt_metadata(mm_output):
+            # The thinker's resumable duplex request reports cumulative
+            # output ids/text, but earlier segments are already folded into
+            # the prompt by the scheduler session update, and the forwarded
+            # hidden states only cover the current prompt + current segment.
+            # Hand stage 1 exactly one segment per handoff so token/hidden
+            # alignment holds, the talker prompt grows linearly with new
+            # tokens instead of quadratically, and downstream transcripts
+            # carry per-unit deltas instead of re-sending the whole reply.
+            llm_output_ids, thinker_text, native_turn_start = _native_duplex_segment_output_ids(
+                llm_output_ids,
+                thinker_text,
+                _streaming_context,
+                request_id=str(llm_output.request_id),
+            )
         prompt_token_ids_len = len(prompt_token_ids)
 
-        latent = output.multimodal_output.get("latent", None)
+        latent = mm_output.get("latent", None)
         if latent is None:
             latent = output.hidden_states if hasattr(output, "hidden_states") else None
             if latent is None:
                 raise ValueError("No latent or hidden_states found in thinker output")
 
-        thinker_hidden_states = latent.clone().detach()
-
-        # Split hidden states: prompt portion has speaker embedding,
-        # generated portion has the text content
-        prompt_hidden = thinker_hidden_states[:prompt_token_ids_len].to(torch.float32)
-
-        # Extract decoded text from thinker output for TTS text extraction
-        thinker_text = getattr(output, "text", "") or ""
+        thinker_hidden_states = latent.detach()
+        if thinker_hidden_states.ndim == 3 and thinker_hidden_states.shape[0] == 1:
+            thinker_hidden_states = thinker_hidden_states.squeeze(0)
 
         # Build full token sequence and extract TTS region
-        full_token_ids = list(prompt_token_ids) + (
-            list(llm_output_ids) if not isinstance(llm_output_ids, list) else llm_output_ids
-        )
-        full_hidden = thinker_hidden_states.to(torch.float32)
+        full_token_ids = prompt_token_ids + llm_output_ids
 
-        # Detect TTS token IDs (4.5: 151703/151704, 2.6: 151691/151692)
-        tts_bos_id, tts_eos_id = 151691, 151692
-        for _id in [151703, 151704]:
-            if _id in full_token_ids:
-                tts_bos_id, tts_eos_id = 151703, 151704
-                break
+        tts_bos_id = special_token_ids.get("tts_bos_token_id")
+        is_native_duplex_handoff = _has_native_duplex_prompt_metadata(mm_output)
+        if is_native_duplex_handoff:
+            _require_native_tts_boundary_metadata(special_token_ids)
+        tts_end_ids = _native_tts_boundary_token_ids(special_token_ids)
 
-        tts_bos_idx = tts_eos_idx = None
-        for idx_t, tid in enumerate(full_token_ids):
-            if tid == tts_bos_id:
+        # Plain-chat (use_tts_template) fallback: non-duplex requests do not
+        # surface special_token_ids, so use MiniCPM-o 4.5's fixed boundaries.
+        if tts_bos_id is None and not is_native_duplex_handoff:
+            tts_bos_id = 151703
+            tts_end_ids = set(tts_end_ids) | {151704, 151645}
+
+        tts_bos_idx = None
+        # For native duplex the resumable prompt folds every earlier unit, so
+        # a <|tts_bos|> from an already-spoken reply can sit mid-prompt; only
+        # a boundary folded as the FINAL prompt token (this unit's decision)
+        # or one inside the current segment may start the slice, or stale
+        # text would be re-handed to the talker on text-less continuations.
+        search_start = max(0, prompt_token_ids_len - 1) if is_native_duplex_handoff else 0
+        for idx_t in range(search_start, len(full_token_ids)):
+            if full_token_ids[idx_t] == tts_bos_id:
                 tts_bos_idx = idx_t + 1
-            elif tid == tts_eos_id:
-                tts_eos_idx = idx_t
+        if tts_bos_idx is None and not is_native_duplex_handoff and llm_output_ids:
+            # Audio routing is a model-stage concern, not an OpenAI serving
+            # default. Plain chat templates do not include <|tts_bos|>; in
+            # that case condition the Talker on the generated assistant span.
+            tts_bos_idx = prompt_token_ids_len
+
+        tts_eos_idx = None
+        if tts_bos_idx is not None:
+            for idx_t in range(tts_bos_idx, len(full_token_ids)):
+                if full_token_ids[idx_t] in tts_end_ids:
+                    tts_eos_idx = idx_t
+                    break
 
         tts_token_ids_slice = tts_hidden_slice = None
-        if tts_bos_idx is not None and full_hidden.shape[0] > tts_bos_idx:
-            end_idx = tts_eos_idx if tts_eos_idx is not None else full_hidden.shape[0]
+        native_segment_end = False
+        if tts_bos_idx is not None and thinker_hidden_states.shape[0] > tts_bos_idx:
+            end_idx = tts_eos_idx if tts_eos_idx is not None else thinker_hidden_states.shape[0]
+            if is_native_duplex_handoff and tts_eos_idx is not None:
+                boundary_token = full_token_ids[tts_eos_idx]
+                native_segment_end = boundary_token in {
+                    special_token_ids.get("chunk_eos_token_id"),
+                    special_token_ids.get("chunk_tts_eos_token_id"),
+                }
             tts_token_ids_slice = torch.tensor(full_token_ids[tts_bos_idx:end_idx], dtype=torch.long)
-            tts_hidden_slice = full_hidden[tts_bos_idx:end_idx]
+            tts_hidden_slice = thinker_hidden_states[tts_bos_idx:end_idx].to(torch.float32).contiguous()
+        elif is_native_duplex_handoff:
+            # Official MiniCPM-o duplex does not prefill an assistant
+            # <|tts_bos|> boundary before generation. A segment delta can
+            # start with SEVERAL unit decisions (forced/model listens from
+            # chunks that produced no handoff accumulate ahead of the speak),
+            # so skip the leading listen run, then the speak decision itself;
+            # hidden states for TTS start after it and stop at the next
+            # chunk terminator.
+            listen_id = special_token_ids.get("listen_token_id")
+            speak_id = special_token_ids.get("speak_token_id")
+            out_ids = llm_output_ids
+            j = 0
+            while j < len(out_ids) and out_ids[j] == listen_id:
+                j += 1
+            if j < len(out_ids) and out_ids[j] == speak_id:
+                out_start = j + 1
+                out_end = len(out_ids)
+                turn_eos_id = special_token_ids.get("turn_eos_token_id")
+                for idx_t in range(out_start, len(out_ids)):
+                    token_id = out_ids[idx_t]
+                    if turn_eos_id is not None and token_id == turn_eos_id:
+                        # Native duplex trains the talker on the <|turn_eos|>
+                        # embedding itself, but any text sampled after it
+                        # belongs to a stale tail and must not enter TTS.
+                        out_end = idx_t + 1
+                        break
+                    if token_id in tts_end_ids:
+                        out_end = idx_t
+                        native_segment_end = token_id in {
+                            special_token_ids.get("chunk_eos_token_id"),
+                            special_token_ids.get("chunk_tts_eos_token_id"),
+                        }
+                        break
+                # Map output indices onto hidden rows by END alignment: the
+                # leading decision tokens of the delta may ALSO be folded into
+                # the resumable prompt (they belong to earlier non-forwarded
+                # segments), so prompt_len + delta over-counts them and
+                # front-aligned indexing truncates the slice. The hidden
+                # tensor's last len(out_ids) rows are the delta's rows.
+                hidden_base = int(thinker_hidden_states.shape[0]) - len(out_ids)
+                if hidden_base >= 0 and out_end > out_start:
+                    tts_token_ids_slice = torch.tensor(out_ids[out_start:out_end], dtype=torch.long)
+                    tts_hidden_slice = (
+                        thinker_hidden_states[hidden_base + out_start : hidden_base + out_end]
+                        .to(torch.float32)
+                        .contiguous()
+                    )
+            elif j < len(out_ids) and out_ids[j] not in tts_end_ids:
+                # HF streaming_generate does not require an explicit <|speak|>
+                # marker. If a unit starts directly with text, the first token
+                # is fed back into the LLM but is not included in
+                # total_hidden_in_unit; TTS starts from the following token.
+                out_start = j + 1
+                out_end = len(out_ids)
+                turn_eos_id = special_token_ids.get("turn_eos_token_id")
+                for idx_t in range(out_start, len(out_ids)):
+                    token_id = out_ids[idx_t]
+                    if turn_eos_id is not None and token_id == turn_eos_id:
+                        out_end = idx_t + 1
+                        break
+                    if token_id in tts_end_ids:
+                        out_end = idx_t
+                        native_segment_end = token_id in {
+                            special_token_ids.get("chunk_eos_token_id"),
+                            special_token_ids.get("chunk_tts_eos_token_id"),
+                        }
+                        break
+                hidden_base = int(thinker_hidden_states.shape[0]) - len(out_ids)
+                if hidden_base >= 0 and out_end > out_start:
+                    tts_token_ids_slice = torch.tensor(out_ids[out_start:out_end], dtype=torch.long)
+                    tts_hidden_slice = (
+                        thinker_hidden_states[hidden_base + out_start : hidden_base + out_end]
+                        .to(torch.float32)
+                        .contiguous()
+                    )
+        handoff_ids = _coerce_token_id_list(tts_token_ids_slice) if tts_token_ids_slice is not None else None
+        if is_native_duplex_handoff and handoff_ids:
+            handoff_text = _decode_native_duplex_token_ids(
+                handoff_ids,
+                _streaming_context,
+                request_id=str(llm_output.request_id),
+            )
+            if handoff_text is not None:
+                # Match the released streaming_generate contract: transcript
+                # text comes from total_ids_in_unit, the same slice that
+                # conditions the Talker.
+                thinker_text = handoff_text
+        model_intermediate_buffer = build_duplex_intermediate_buffer(
+            request_id=str(llm_output.request_id),
+            prompt_token_ids=prompt_token_ids,
+            output_token_ids=llm_output_ids,
+            output_text=thinker_text,
+            stream_output=is_native_duplex_handoff,
+            native_duplex=is_native_duplex_handoff,
+        )
+        if is_native_duplex_handoff:
+            turn_eos_id = special_token_ids.get("turn_eos_token_id")
+            meta = model_intermediate_buffer.setdefault("meta", {})
+            data_plane_metadata = _native_duplex_data_plane_metadata(_streaming_context)
+            if data_plane_metadata is not None:
+                model_intermediate_buffer["duplex"] = data_plane_metadata
+            meta["native_duplex_segment_text"] = thinker_text
+            meta.setdefault("override_keys", []).extend(
+                [
+                    "llm_output_text",
+                    ["meta", "native_duplex_segment_text"],
+                ]
+            )
+            if turn_eos_id is not None:
+                # The talker detects turn end from <|turn_eos|> inside the
+                # handed condition (official conditions on its embedding).
+                meta["turn_eos_token_id"] = int(turn_eos_id)
+            meta["turn_start"] = native_turn_start
+            if native_segment_end:
+                meta["segment_end"] = True
+        req_mm_data = multi_modal_data.get(llm_output.request_id)
+        ref_audio = _extract_first_audio_ref(req_mm_data)
+        if ref_audio is None:
+            ref_audio = _extract_native_runtime_ref_audio(
+                model_intermediate_buffer.get("duplex"),
+            )
+        if ref_audio is not None:
+            ref_waveform, ref_sr = ref_audio
+            set_ref_audio(model_intermediate_buffer, _to_transport_list(ref_waveform), ref_sr)
+        handoff_hidden = _to_transport_list(tts_hidden_slice) if tts_hidden_slice is not None else None
+        native_turn_end_handoff = False
+        if is_native_duplex_handoff:
+            turn_eos_id = special_token_ids.get("turn_eos_token_id")
+            native_turn_end_handoff = turn_eos_id is not None and handoff_ids is not None and turn_eos_id in handoff_ids
+            if not handoff_ids:
+                continue
+        set_tts_handoff(model_intermediate_buffer, handoff_ids, handoff_hidden)
+        if native_turn_end_handoff:
+            model_intermediate_buffer.setdefault("meta", {})["turn_end"] = True
 
-        additional_information = {
-            "prompt_embeds": prompt_hidden,
-            "prompt_token_ids": list(prompt_token_ids),
-            "llm_output_token_ids": list(llm_output_ids) if not isinstance(llm_output_ids, list) else llm_output_ids,
-            "llm_output_text": [thinker_text],
-        }
-        if tts_token_ids_slice is not None:
-            additional_information["tts_token_ids"] = tts_token_ids_slice
-        if tts_hidden_slice is not None:
-            additional_information["tts_hidden_states"] = tts_hidden_slice
-
-        # Minimal prompt token IDs: the talker's AR framework needs *some* tokens
-        # to do a single prefill step. We use [BOS, PAD, EOS] as a dummy.
+        if handoff_ids is not None and handoff_hidden is not None:
+            condition_suffix_length = 1 if is_native_duplex_handoff else 2
+            condition_length = max(len(handoff_ids), len(handoff_hidden)) + condition_suffix_length
+            scheduler_prompt_token_ids = [0] * condition_length
+            handoff_meta = model_intermediate_buffer.setdefault("meta", {})
+            handoff_meta["next_stage_prompt_len"] = condition_length
+            # Native duplex resumes one Talker request within a turn, but a new
+            # assistant turn must discard the previous turn's prompt and KV.
+            if not is_native_duplex_handoff or native_turn_start:
+                handoff_meta["replace_streaming_prompt"] = True
+        else:
+            scheduler_prompt_token_ids = _build_tts_scheduler_prompt_token_ids(
+                tts_token_ids_slice,
+                llm_output_ids,
+                prompt_token_ids,
+            )
         tts_inputs.append(
             OmniTokensPrompt(
-                prompt_token_ids=[1, 0, 2],
-                additional_information=additional_information,
+                prompt_token_ids=scheduler_prompt_token_ids,
+                model_intermediate_buffer=model_intermediate_buffer,
                 multi_modal_data=(
                     multi_modal_data[llm_output.request_id]
                     if requires_multimodal_data and multi_modal_data.get(llm_output.request_id) is not None
@@ -132,5 +970,12 @@ def llm2tts(
                 mm_processor_kwargs=None,
             )
         )
+        if native_turn_end_handoff:
+            bridge_states = getattr(_streaming_context, "bridge_states", None)
+            duplex_state = bridge_states.get("duplex") if isinstance(bridge_states, dict) else None
+            if isinstance(duplex_state, dict):
+                current_model_turn_id = duplex_state.get("model_turn_id", duplex_state.get("turn_id", 0))
+                if isinstance(current_model_turn_id, int):
+                    duplex_state["model_turn_id"] = current_model_turn_id + 1
 
     return tts_inputs
diff --git a/vllm_omni/model_executor/stage_input_processors/moss_tts.py b/vllm_omni/model_executor/stage_input_processors/moss_tts.py
index 3dfe2a603..3ba32271e 100644
--- a/vllm_omni/model_executor/stage_input_processors/moss_tts.py
+++ b/vllm_omni/model_executor/stage_input_processors/moss_tts.py
@@ -291,17 +291,11 @@ def talker2codec_raw_async_chunk(
             transfer_manager.code_prompt_token_ids.pop(req_id, None)
             transfer_manager.request_payload.pop(req_id, None)
             return OmniPayloadStruct(
-                # A non-empty sentinel is required so Stage-1 is scheduled.
-                # ``code_flat_numel=0`` tells the codec this is a control-only
-                # finish packet, not an audio code.
-                codes=CodesStruct(audio=torch.tensor([0], dtype=torch.long)),
                 meta=MetaStruct(
                     req_id=[req_id],
                     left_context_size=0,
-                    codec_streaming=True,
                     codec_chunk_frames=0,
                     codec_left_context_frames=0,
-                    code_flat_numel=0,
                     stream_finished=torch.tensor(True, dtype=torch.bool),
                     finished=torch.tensor(True, dtype=torch.bool),
                 ),
@@ -331,7 +325,6 @@ def talker2codec_raw_async_chunk(
         meta=MetaStruct(
             req_id=[req_id],
             left_context_size=0,
-            codec_streaming=True,
             codec_chunk_frames=int(chunk_codes.shape[0]),
             codec_left_context_frames=0,
             code_flat_numel=int(codec_flat.numel()),
diff --git a/vllm_omni/model_executor/stage_input_processors/personaplex.py b/vllm_omni/model_executor/stage_input_processors/personaplex.py
new file mode 100644
index 000000000..71f33ba33
--- /dev/null
+++ b/vllm_omni/model_executor/stage_input_processors/personaplex.py
@@ -0,0 +1,248 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Talker -> Code2Wav input processors for PersonaPlex.
+
+The talker (stage 0) emits, per frame, the ``dep_q`` depformer audio codes under
+``("codes","audio")``. Only the leading ``num_active_codebooks`` (the agent's
+``cb 0..7``) are decoded to PCM by Mimi; the trailing codebooks are the user
+stream and are not vocoded. These processors take the accumulated per-frame agent
+codes ``[F, dep_q]``, keep ``cb 0..7``, and flatten them codebook-major
+(``[8 * F]``) — the exact layout :class:`PersonaPlexCode2Wav` consumes.
+
+Mirrors the Qwen3-TTS processors (sync ``full_payload`` + ``token_only``; an
+async-chunk variant for the streaming path), but with PersonaPlex's agent-codebook
+slice instead of Qwen3-TTS's residual layout.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+
+from vllm_omni.data_entry_keys import (
+    CodesStruct,
+    MetaStruct,
+    OmniPayloadStruct,
+)
+
+_NUM_ACTIVE_CODEBOOKS = 8  # agent cb 0..7 (the PCM-bearing rows)
+
+
+def _empty_finished_payload() -> OmniPayloadStruct:
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=torch.empty(0, dtype=torch.long)),
+        meta=MetaStruct(finished=torch.tensor(True, dtype=torch.bool)),
+    )
+
+
+def _agent_codes_to_codebook_major(audio: torch.Tensor) -> torch.Tensor:
+    """``[F, dep_q]`` raw depformer agent codes -> de-delayed flat codebook-major.
+
+    The talker emits the raw per-frame depformer codes ``gen[t]`` (cb 0..7). Mimi
+    needs them ACOUSTICALLY DE-DELAYED to a common time step (Moshi agent delays
+    ``[0, 1, 1, 1, 1, 1, 1, 1]``): acoustic frame t's cb_k is predicted at step
+    ``t + delay[k]``, so output frame t = ``[gen[t][0], gen[t+1][1:8]]`` (cb0 from
+    the current step, cb1..7 from the NEXT step, since the delayed codebooks lag).
+    Without this the codebooks are misaligned by one frame and Mimi decodes garble.
+    The last frame has no successor for cb1..7, so it is dropped (the delay warmup).
+    """
+    if audio.ndim != 2 or audio.shape[0] < 2:
+        return torch.empty(0, dtype=torch.long)
+    audio = audio.to(torch.long)
+    k = min(_NUM_ACTIVE_CODEBOOKS, int(audio.shape[1]))
+    agent = audio[:, :k]
+    valid = (agent >= 0).all(dim=1)
+    agent = agent[valid]
+    if agent.shape[0] < 2:
+        return torch.empty(0, dtype=torch.long)
+    # De-delay: cb0 from frame t, cb1..7 from frame t+1 (drop the last frame).
+    cb0 = agent[:-1, 0:1]  # [F-1, 1]
+    cb_rest = agent[1:, 1:k]  # [F-1, k-1]
+    dd = torch.cat([cb0, cb_rest], dim=1)  # [F-1, k] de-delayed
+    # [F-1, k] -> [k, F-1] -> flat [k * (F-1)] (codebook-major), as Code2Wav expects.
+    return dd.transpose(0, 1).contiguous().reshape(-1)
+
+
+def talker2code2wav_token_only(
+    source_outputs: list,
+    prompt: Any = None,
+    _requires_multimodal_data: bool = False,
+) -> list:
+    """Sync ``process_engine_inputs``: build the code2wav placeholder inputs.
+
+    Returns one :class:`OmniTokensPrompt` per finished talker request, with
+    ``prompt_token_ids`` sized to the flat codebook-major codec length
+    (``num_active_codebooks * num_agent_frames``). The actual codec ids are
+    delivered via the worker connector payload from ``talker2code2wav_full_payload``.
+    """
+    from vllm_omni.inputs.data import OmniTokensPrompt
+
+    del prompt, _requires_multimodal_data
+    inputs: list = []
+    for talker_output in source_outputs:
+        if not getattr(talker_output, "finished", False):
+            continue
+        output = talker_output.outputs[0]
+        # The per-request output is the "latent" (engine_output_type="latent"); the
+        # codes ship via the connector full_payload. Size the placeholder from the
+        # generated token count (one AR token == one Mimi frame). prompt was 1 frame.
+        token_ids = getattr(output, "cumulative_token_ids", None) or getattr(output, "token_ids", None) or []
+        n_frames = max(len(token_ids) - 1, 0)
+        prompt_len = _NUM_ACTIVE_CODEBOOKS * n_frames
+        inputs.append(
+            OmniTokensPrompt(
+                prompt_token_ids=[0] * prompt_len,
+                additional_information=None,
+                multi_modal_data=None,
+                mm_processor_kwargs=None,
+            )
+        )
+    return inputs
+
+
+def talker2code2wav_full_payload(
+    transfer_manager: Any = None,
+    pooling_output: Any = None,
+    request: Any = None,
+    is_finished: bool = False,
+    **kwargs: Any,
+) -> OmniPayloadStruct:
+    """Producer: collect the talker's accumulated agent codes -> Code2Wav input.
+
+    Called by the connector with (transfer_manager, pooling_output, request,
+    is_finished). Prefer the request's additional_information payload under
+    ("codes","audio") (talker_mtp_output_key), while accepting pooling_output
+    and the legacy multimodal_output keyword as compatibility fallbacks.
+    """
+    del transfer_manager, is_finished
+
+    def _codes_from(src: Any) -> torch.Tensor | None:
+        if not isinstance(src, dict):
+            return None
+        nested = src.get("codes")
+        audio = nested.get("audio") if isinstance(nested, dict) else None
+        return audio if audio is not None else src.get("codes.audio")
+
+    audio = None
+    for source in (
+        getattr(request, "additional_information", None),
+        getattr(request, "additional_information_cpu", None),
+        pooling_output,
+        # Temporary compatibility shim for the two producer call contracts.
+        # Remove after https://github.com/vllm-project/vllm-omni/issues/4872
+        # provides validated full-payload and async-chunk processor protocols.
+        kwargs.get("multimodal_output"),
+    ):
+        audio = _codes_from(source)
+        if audio is not None:
+            break
+    if not isinstance(audio, torch.Tensor) or audio.numel() == 0:
+        return _empty_finished_payload()
+    flat = _agent_codes_to_codebook_major(audio)
+    if flat.numel() == 0:
+        return _empty_finished_payload()
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=flat),
+        meta=MetaStruct(finished=torch.tensor(True, dtype=torch.bool)),
+    )
+
+
+def talker2code2wav_async_chunk(
+    transfer_manager: Any,
+    multimodal_output: Any,
+    request: Any,
+    is_finished: bool = False,
+) -> OmniPayloadStruct | None:
+    """Streaming: accumulate per-frame agent codes, emit a codebook-major chunk.
+
+    Minimal fixed-chunk variant (no left-context / ref-code complexity, which
+    PersonaPlex does not use). Frames are buffered on the transfer manager until a
+    chunk's worth is ready (or the request finishes), then flushed.
+    """
+    request_id = getattr(request, "external_req_id", getattr(request, "request_id", "?"))
+    # The adapter passes ``is_finished=True`` for both a resumable segment
+    # boundary and the terminal request boundary. PersonaPlex must preserve the
+    # delayed cb1..7 tail across the former; only a non-resumable stop flushes
+    # the stream.
+    finished = bool(is_finished and not getattr(request, "resumable", False))
+    request_payload = getattr(transfer_manager, "request_payload", None)
+    if not isinstance(request_payload, dict):
+        request_payload = {}
+        transfer_manager.request_payload = request_payload
+    state = request_payload.setdefault(request_id, {})
+    frames = state.setdefault("personaplex_frames", [])
+
+    # Codes live in the server-side request's additional_information under
+    # ("codes","audio") (talker_mtp_output_key), not in multimodal_output (latent).
+    def _codes_from(src: Any) -> torch.Tensor | None:
+        if isinstance(src, dict):
+            nested = src.get("codes")
+            a = nested.get("audio") if isinstance(nested, dict) else None
+            return a if a is not None else src.get("codes.audio")
+        return None
+
+    # Explicit None fallback: `a or b` would evaluate bool(a) on a multi-element
+    # Tensor and raise "Boolean value of Tensor ... is ambiguous".
+    audio = _codes_from(getattr(request, "additional_information", None))
+    if audio is None:
+        audio = _codes_from(multimodal_output)
+    if isinstance(audio, torch.Tensor) and audio.numel() > 0:
+        a = audio if audio.ndim == 2 else audio.reshape(1, -1)
+        frames.append(a[-1].to(torch.long).cpu())  # latest frame's codes
+
+    connector = getattr(transfer_manager, "connector", None)
+    raw_cfg = getattr(connector, "config", {}) or {}
+    cfg = raw_cfg.get("extra", raw_cfg) if isinstance(raw_cfg, dict) else {}
+    chunk = int(cfg.get("codec_chunk_frames", 25))
+    initial_chunk = int(cfg.get("initial_codec_chunk_frames") or 0)
+    if chunk <= 0 or initial_chunk < 0:
+        raise ValueError(
+            "PersonaPlex codec chunk sizes must be positive/non-negative: "
+            f"codec_chunk_frames={chunk}, initial_codec_chunk_frames={initial_chunk}"
+        )
+    target_frames = initial_chunk if not state.get("personaplex_emitted") and initial_chunk > 0 else chunk
+
+    # De-delay needs one successor raw frame: N output acoustic frames require
+    # N + 1 raw depformer rows.
+    available_frames = max(0, len(frames) - 1)
+    if available_frames < target_frames and not finished:
+        # Each full-duplex input frame is a resumable stage-0 segment. Returning
+        # None would make the generic chunk adapter synthesize a
+        # segment-finished marker, wake Code2Wav with its one-token placeholder,
+        # and discard the buffered de-delay tail. Explicitly keep this transport
+        # chunk non-terminal until enough successor frames exist.
+        pending = torch.tensor(False, dtype=torch.bool)
+        return OmniPayloadStruct(
+            meta=MetaStruct(
+                finished=pending,
+                is_segment_finished=pending,
+            )
+        )
+    emit_frames = available_frames if finished else target_frames
+    if emit_frames <= 0:
+        if finished:
+            request_payload.pop(request_id, None)
+            return _empty_finished_payload()
+        return None
+
+    stacked = torch.stack(frames[: emit_frames + 1], dim=0)  # [F+1, dep_q]
+    flat = _agent_codes_to_codebook_major(stacked)
+    if finished:
+        request_payload.pop(request_id, None)
+    else:
+        # Row ``emit_frames`` is the successor used by the last emitted frame
+        # and the cb0 source for the next frame.
+        state["personaplex_frames"] = frames[emit_frames:]
+        state["personaplex_emitted"] = True
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=flat),
+        meta=MetaStruct(finished=torch.tensor(bool(finished), dtype=torch.bool)),
+    )
+
+
+__all__ = [
+    "talker2code2wav_token_only",
+    "talker2code2wav_full_payload",
+    "talker2code2wav_async_chunk",
+]
diff --git a/vllm_omni/model_executor/stage_input_processors/qwen3_omni.py b/vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
index edde6972d..7e28b94c3 100644
--- a/vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
+++ b/vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
@@ -685,19 +685,32 @@ def talker2code2wav_async_chunk(
     """
     Multimodal output version.
     """
-    if not isinstance(multimodal_output, Mapping):
-        return None
-    talker_codes = multimodal_output.get("codes", {})
-    if not isinstance(talker_codes, dict):
-        return None
-    code_predictor_codes = talker_codes.get("audio")
-    if code_predictor_codes is None:
-        return None
+    request_id = request.external_req_id
+    code_predictor_codes = None
+    if isinstance(multimodal_output, Mapping):
+        talker_codes = multimodal_output.get("codes", {})
+        if isinstance(talker_codes, dict):
+            code_predictor_codes = talker_codes.get("audio")
 
-    if code_predictor_codes.numel() == 0:
-        return None
+    sampling_params = getattr(request, "sampling_params", None)
+    stop_token_ids = set(getattr(sampling_params, "stop_token_ids", None) or [])
+    stop_token_id = getattr(sampling_params, "stop_token_id", None)
+    if stop_token_id is not None:
+        stop_token_ids.add(stop_token_id)
 
-    if not code_predictor_codes.any():
+    append_codes = (
+        isinstance(code_predictor_codes, torch.Tensor)
+        and code_predictor_codes.numel() > 0
+        and bool(code_predictor_codes.any())
+    )
+    if append_codes:
+        first_codebook = int(code_predictor_codes[0, 0].item())
+        if first_codebook in stop_token_ids:
+            logger.debug("skip stop-token codec frame: first_codebook=%s", first_codebook)
+            append_codes = False
+    if append_codes:
+        transfer_manager.code_prompt_token_ids[request_id].append(code_predictor_codes)
+    elif not is_finished:
         return None
 
     connector = getattr(transfer_manager, "connector", None)
@@ -707,20 +720,10 @@ def talker2code2wav_async_chunk(
     left_context_size_config = int(cfg.get("codec_left_context_frames", 25))
     configured_initial_chunk_size = int(cfg.get("initial_codec_chunk_frames") or 0)
 
-    sampling_params = getattr(request, "sampling_params", None)
-    stop_token_ids = set(getattr(sampling_params, "stop_token_ids", None) or [])
-    stop_token_id = getattr(sampling_params, "stop_token_id", None)
-    if stop_token_id is not None:
-        stop_token_ids.add(stop_token_id)
-    first_codebook = int(code_predictor_codes[0, 0].item())
-    if first_codebook in stop_token_ids:
-        logger.debug("skip stop-token codec frame: first_codebook=%s", first_codebook)
-        return None
-
-    request_id = request.external_req_id
     chunk_id = transfer_manager.put_req_chunk[request_id]
-    transfer_manager.code_prompt_token_ids[request_id].append(code_predictor_codes)
     length = len(transfer_manager.code_prompt_token_ids[request_id])
+    if length <= 0:
+        return None
 
     if configured_initial_chunk_size > 0:
         if chunk_id == 0:
@@ -732,6 +735,9 @@ def talker2code2wav_async_chunk(
     if chunk_length != 0 and not is_finished:
         return None
 
+    if is_finished and not append_codes and chunk_length == 0:
+        return None
+
     context_length = chunk_length if chunk_length != 0 else chunk_size_config
     # ensure left context does not exceed available length
     if configured_initial_chunk_size > 0 and chunk_id == 1:
diff --git a/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py b/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
index 597fc4db5..9b5e5ea38 100644
--- a/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+++ b/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
@@ -15,7 +15,9 @@ from vllm_omni.data_entry_keys import (
 )
 from vllm_omni.model_executor.stage_input_processors.chunk_size_utils import (
     compute_dynamic_initial_chunk_size,
+    compute_ramp_emit,
     max_ic_for_chunk_size,
+    parse_chunk_ramp,
 )
 from vllm_omni.model_executor.stage_input_processors.tts_utils import (
     extract_language_from_prompt,
@@ -27,13 +29,29 @@ from vllm_omni.model_executor.stage_input_processors.tts_utils import (
 logger = init_logger(__name__)
 
 
-def _qwen3_tts_empty_finished_payload():
-    """Empty-but-finished stage payload. Returned instead of None on a degenerate
-    talker take so the Stage-1 wait gate releases (code2wav handles empty codec
-    input -> 0-sample audio, request finished) rather than the connector silently
-    dropping the request and Stage-1 hanging to connector_get_max_wait."""
+def _qwen3_tts_degenerate_finished_payload():
+    """Single-placeholder-frame finished payload for a degenerate talker take.
+
+    Returning ``None`` here makes the connector silently drop the request, and
+    Stage-1's wait gate then polls to ``connector_get_max_wait`` (#4463).
+    Returning an *empty* finished payload (zero codec frames) is no better on
+    full-payload deploys: it produces a zero-token Stage-1 request, which the
+    generation scheduler placeholder-schedules once and then never collects
+    (the ``required_tokens <= 0`` branch only finishes requests through the
+    async-chunk transfer adapter). The request is left parked in ``running``
+    while the base-scheduler fallback schedules it at ``num_new_tokens = -1``,
+    which killed the whole stage EngineCore before #5269 and no-ops after it,
+    so the request never finishes either way (#5196, #5471).
+
+    The placeholder is one all-ones frame, emitted flat (codebook-major, the
+    same wire format the normal path below produces). Its values are valid by
+    ``_filter_audio_codes_qwen3_tts`` (non-negative, not all-zero, below
+    ``_CODEBOOK_SIZE``), so the request runs the normal one-shot code2wav
+    path and finishes cleanly with a single frame (~80 ms at 12 Hz) of
+    placeholder audio.
+    """
     return {
-        "codes": {"audio": torch.zeros(0, dtype=torch.long)},
+        "codes": {"audio": torch.ones(_NUM_QUANTIZERS_DEFAULT, dtype=torch.long)},
         "meta": {"finished": torch.tensor(True, dtype=torch.bool)},
     }
 
@@ -84,6 +102,12 @@ def talker2code2wav_async_chunk(
     configured_initial_chunk_size = int(cfg.get("initial_codec_chunk_frames") or 0)
     ref_code_context_frames = int(cfg.get("ref_code_context_frames") or left_context_size_config)
 
+    # Ramp: parse once per transfer_manager (config is static for the adapter's
+    # lifetime). When active, ramp replaces IC/steady entirely — skip dynamic IC.
+    if not hasattr(transfer_manager, "_ramp_parsed"):
+        transfer_manager._ramp_parsed = parse_chunk_ramp(cfg, steady=chunk_size)
+    ramp = transfer_manager._ramp_parsed
+
     # Per-request override takes priority over dynamic IC.
     fixed_initial_chunk_size = configured_initial_chunk_size > 0
     initial_chunk_size = configured_initial_chunk_size
@@ -100,7 +124,8 @@ def talker2code2wav_async_chunk(
             fixed_initial_chunk_size = True
 
     # Dynamic IC: cache per request so boundaries stay stable for its lifetime.
-    if not fixed_initial_chunk_size:
+    # Skipped when ramp is active (ramp replaces IC/steady entirely).
+    if ramp is None and not fixed_initial_chunk_size:
         _ic_cache = getattr(transfer_manager, "_cached_ic", None)
         if _ic_cache is None:
             _ic_cache = {}
@@ -143,21 +168,30 @@ def talker2code2wav_async_chunk(
             )
         return None
 
-    use_first_chunk = initial_chunk_size > 0 and initial_chunk_size < chunk_size
-
-    if use_first_chunk and length <= initial_chunk_size:
-        if not finished and length < initial_chunk_size:
+    if ramp is not None:
+        chunk_index = transfer_manager.ramp_chunk_count.get(request_id, 0)
+        emit, context_length = compute_ramp_emit(length, chunk_index, ramp, chunk_size, finished)
+        if not emit:
             return None
-        context_length = length if finished and length < initial_chunk_size else initial_chunk_size
+        if context_length == 0:
+            return OmniPayloadStruct(
+                codes=CodesStruct(audio=torch.empty(0, dtype=torch.long)),
+                meta=MetaStruct(finished=torch.tensor(True, dtype=torch.bool)),
+            )
     else:
-        # The initial chunk is only for TTFA. After that, return to the normal
-        # codec chunk size so Code2Wav is not flooded by repeated tiny windows.
-        initial_coverage = initial_chunk_size if use_first_chunk else 0
-        adjusted = length - initial_coverage
-        if not finished and adjusted % chunk_size != 0:
-            return None
-        chunk_length = adjusted % chunk_size
-        context_length = chunk_length if chunk_length != 0 else chunk_size
+        use_first_chunk = initial_chunk_size > 0 and initial_chunk_size < chunk_size
+
+        if use_first_chunk and length <= initial_chunk_size:
+            if not finished and length < initial_chunk_size:
+                return None
+            context_length = length if finished and length < initial_chunk_size else initial_chunk_size
+        else:
+            initial_coverage = initial_chunk_size if use_first_chunk else 0
+            adjusted = length - initial_coverage
+            if not finished and adjusted % chunk_size != 0:
+                return None
+            chunk_length = adjusted % chunk_size
+            context_length = chunk_length if chunk_length != 0 else chunk_size
 
     end_index = min(length, left_context_size_config + context_length)
     left_context_size = max(0, end_index - context_length)
@@ -382,7 +416,7 @@ def talker2code2wav_full_payload(
             type(pooling_output).__name__,
             rid,
         )
-        return _qwen3_tts_empty_finished_payload()
+        return _qwen3_tts_degenerate_finished_payload()
 
     # codes.audio — try flat dotted first (flatten_payload), then nested fallback.
     audio = pooling_output.get("codes.audio")
@@ -397,7 +431,7 @@ def talker2code2wav_full_payload(
             list(pooling_output.keys()),
             rid,
         )
-        return _qwen3_tts_empty_finished_payload()
+        return _qwen3_tts_degenerate_finished_payload()
     audio = audio.to(torch.long)
     audio = _filter_audio_codes_qwen3_tts(audio)
     if audio.numel() == 0:
@@ -406,7 +440,7 @@ def talker2code2wav_full_payload(
             "filter (negative/all-zero/out-of-range rows dropped) for req=%s.",
             rid,
         )
-        return _qwen3_tts_empty_finished_payload()
+        return _qwen3_tts_degenerate_finished_payload()
 
     output_token_ids = list(getattr(request, "output_token_ids", None) or [])
     seq_len = max(len(output_token_ids) - 1, 0)
diff --git a/vllm_omni/model_executor/stage_input_processors/step_audio2.py b/vllm_omni/model_executor/stage_input_processors/step_audio2.py
index 5e015aa7c..c0c0932b2 100644
--- a/vllm_omni/model_executor/stage_input_processors/step_audio2.py
+++ b/vllm_omni/model_executor/stage_input_processors/step_audio2.py
@@ -7,6 +7,7 @@ import torch
 from vllm.inputs import TextPrompt
 from vllm.logger import init_logger
 
+from vllm_omni.data_entry_keys import CodesStruct, MetaStruct, OmniPayloadStruct
 from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.inputs.data import OmniTokensPrompt
 from vllm_omni.model_executor.models.step_audio2.step_audio2_constants import (
@@ -35,14 +36,14 @@ def _ensure_list(x):
 
 def thinker2token2wav_async_chunk(
     transfer_manager: Any,
-    pooling_output: dict[str, Any],
+    multimodal_output: dict[str, Any] | None,
     request: OmniEngineCoreRequest,
     is_finished: bool = False,
-) -> dict[str, Any] | None:
+) -> OmniPayloadStruct | None:
     """
     Async chunk processor: stream audio tokens from Thinker to Token2Wav.
 
-    Unlike Qwen3-Omni which passes hidden states via pooling_output,
+    Unlike Qwen3-Omni which passes hidden states via multimodal_output,
     Step Audio2 generates audio tokens as part of the LLM autoregressive
     output (token IDs >= audio_start). This processor extracts those audio
     tokens from the running token stream and sends them in chunks.
@@ -62,14 +63,13 @@ def thinker2token2wav_async_chunk(
     Args:
         transfer_manager: OmniChunkTransferAdapter instance (has
             ``code_prompt_token_ids`` defaultdict for state tracking).
-        pooling_output: Pooler output dict (unused — audio tokens are in
+        multimodal_output: Multimodal output dict (unused — audio tokens are in
             the token ID stream, not in hidden states).
         request: Current engine request with access to all_token_ids.
         is_finished: Whether the upstream request has finished generating.
 
     Returns:
-        dict with framework-compatible fields, or None if the chunk is
-        not yet ready.
+        Structured connector payload, or None if the chunk is not yet ready.
     """
     audio_start = DEFAULT_TOKEN_CONFIG.audio_start
     audio_eos = DEFAULT_TOKEN_CONFIG.audio_eos
@@ -100,18 +100,22 @@ def thinker2token2wav_async_chunk(
         # Last chunk: send all remaining tokens
         if available <= 0:
             # No audio tokens at all (text-only response) — send EOF marker
-            return {
-                "code_predictor_codes": [],
-                "left_context_size": 1,  # 1 = last chunk
-                "finished": torch.tensor(True, dtype=torch.bool),
-            }
+            return OmniPayloadStruct(
+                codes=CodesStruct(audio=torch.empty(0, dtype=torch.long)),
+                meta=MetaStruct(
+                    left_context_size=1,  # 1 = last chunk
+                    finished=torch.tensor(True, dtype=torch.bool),
+                ),
+            )
         remaining_tokens = audio_tokens[consumed:]
         transfer_manager.code_prompt_token_ids[request_id].extend(remaining_tokens)
-        return {
-            "code_predictor_codes": remaining_tokens,
-            "left_context_size": 1,  # 1 = last chunk
-            "finished": torch.tensor(True, dtype=torch.bool),
-        }
+        return OmniPayloadStruct(
+            codes=CodesStruct(audio=torch.tensor(remaining_tokens, dtype=torch.long)),
+            meta=MetaStruct(
+                left_context_size=1,  # 1 = last chunk
+                finished=torch.tensor(True, dtype=torch.bool),
+            ),
+        )
     else:
         # Non-last chunk: need chunk_size + pre_lookahead_len tokens
         required = chunk_size + pre_lookahead_len
@@ -120,11 +124,13 @@ def thinker2token2wav_async_chunk(
         chunk_tokens = audio_tokens[consumed : consumed + required]
         # Only consume chunk_size tokens; the lookahead portion is re-used
         transfer_manager.code_prompt_token_ids[request_id].extend(audio_tokens[consumed : consumed + chunk_size])
-        return {
-            "code_predictor_codes": chunk_tokens,
-            "left_context_size": 0,  # 0 = not last chunk
-            "finished": torch.tensor(False, dtype=torch.bool),
-        }
+        return OmniPayloadStruct(
+            codes=CodesStruct(audio=torch.tensor(chunk_tokens, dtype=torch.long)),
+            meta=MetaStruct(
+                left_context_size=0,  # 0 = not last chunk
+                finished=torch.tensor(False, dtype=torch.bool),
+            ),
+        )
 
 
 def thinker2token2wav(
diff --git a/vllm_omni/model_extras/__init__.py b/vllm_omni/model_extras/__init__.py
index 5311f495b..1a3d71870 100644
--- a/vllm_omni/model_extras/__init__.py
+++ b/vllm_omni/model_extras/__init__.py
@@ -5,9 +5,11 @@ from vllm_omni.model_extras.registry import (
     build_image_to_image_prompt,
     build_image_to_video_prompt,
     build_text_to_image_prompt,
+    build_x_to_text_prompt,
     get_extra_body_params,
     get_extra_output_params,
     get_model_class_name,
+    get_x_to_text_model_family,
     should_init_extra_args_for_non_diffusion_stages,
 )
 
@@ -15,8 +17,10 @@ __all__ = [
     "build_image_to_image_prompt",
     "build_image_to_video_prompt",
     "build_text_to_image_prompt",
+    "build_x_to_text_prompt",
     "get_extra_body_params",
     "get_extra_output_params",
     "get_model_class_name",
+    "get_x_to_text_model_family",
     "should_init_extra_args_for_non_diffusion_stages",
 ]
diff --git a/vllm_omni/model_extras/bagel.py b/vllm_omni/model_extras/bagel.py
index e8cbcbf11..93646aad1 100644
--- a/vllm_omni/model_extras/bagel.py
+++ b/vllm_omni/model_extras/bagel.py
@@ -50,6 +50,23 @@ def build_image_to_image_prompt(
     return img_prompt
 
 
+def build_x_to_text_prompt(
+    model: str,
+    prompt: str,
+    has_image: bool,
+) -> tuple[dict[str, Any], list[int] | None]:
+    """Build BAGEL's chat prompt for text-output tasks."""
+    del model
+    image_token = "<|image_pad|>\n" if has_image else ""
+    return (
+        {
+            "prompt": f"<|im_start|>user\n{image_token}{prompt}<|im_end|>\n<|im_start|>assistant\n",
+            "modalities": ["text"],
+        },
+        None,
+    )
+
+
 BAGEL_EXTRA_BODY_PARAMS = frozenset(
     {
         "cfg_text_scale",
diff --git a/vllm_omni/model_extras/hunyuan_image3.py b/vllm_omni/model_extras/hunyuan_image3.py
new file mode 100644
index 000000000..8a53dfd54
--- /dev/null
+++ b/vllm_omni/model_extras/hunyuan_image3.py
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def build_x_to_text_prompt(
+    model: str,
+    prompt: str,
+    has_image: bool,
+) -> tuple[dict[str, Any], list[int] | None]:
+    """Build HunyuanImage-3 prompt tokens and stopping rules for T2T/I2T."""
+    from transformers import AutoTokenizer
+
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        build_prompt_tokens,
+        resolve_stop_token_ids,
+        resolve_sys_type,
+    )
+
+    task = "i2t" if has_image else "t2t"
+    tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=True)
+    build_kwargs: dict[str, Any] = {"task": task, "bot_task": None}
+    if has_image:
+        build_kwargs["num_images"] = 1
+    built = build_prompt_tokens(prompt, tokenizer, **build_kwargs)
+    return (
+        {
+            "prompt": prompt,
+            "prompt_token_ids": built.token_ids,
+            "modalities": ["text"],
+            "use_system_prompt": resolve_sys_type(None),
+        },
+        resolve_stop_token_ids(task=task, bot_task=None, tokenizer=tokenizer, image_size="auto"),
+    )
diff --git a/vllm_omni/model_extras/lingbot_video.py b/vllm_omni/model_extras/lingbot_video.py
new file mode 100644
index 000000000..c7aae3763
--- /dev/null
+++ b/vllm_omni/model_extras/lingbot_video.py
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+LINGBOT_VIDEO_EXTRA_BODY_PARAMS = frozenset(
+    {
+        "batch_cfg",
+        "flow_shift",
+        "negative_prompt",
+        "null_cond_clone_zero",
+        "offload_vae_during_denoise",
+        "output_type",
+        "refiner_sigma_tail_steps",
+        "shift",
+        "t_thresh",
+    }
+)
diff --git a/vllm_omni/model_extras/ltx2.py b/vllm_omni/model_extras/ltx2.py
new file mode 100644
index 000000000..5bac58469
--- /dev/null
+++ b/vllm_omni/model_extras/ltx2.py
@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Request parameters shared by official LTX guidance pipelines."""
+
+LTX_EXTRA_BODY_PARAMS = frozenset(
+    {
+        "video_cfg_scale",
+        "audio_cfg_scale",
+        "video_cfg_guidance_scale",
+        "audio_cfg_guidance_scale",
+        "video_stg_scale",
+        "audio_stg_scale",
+        "video_stg_guidance_scale",
+        "audio_stg_guidance_scale",
+        "video_modality_scale",
+        "audio_modality_scale",
+        "a2v_guidance_scale",
+        "v2a_guidance_scale",
+        "video_rescale_scale",
+        "audio_rescale_scale",
+        "video_stg_blocks",
+        "audio_stg_blocks",
+    }
+)
+
+LTX_EXTRA_OUTPUT_PARAMS = frozenset()
diff --git a/vllm_omni/model_extras/mammothmodal2_preview.py b/vllm_omni/model_extras/mammothmodal2_preview.py
index c17e428a8..96f3fb939 100644
--- a/vllm_omni/model_extras/mammothmodal2_preview.py
+++ b/vllm_omni/model_extras/mammothmodal2_preview.py
@@ -9,6 +9,11 @@ from typing import Any
 # bespoke MammothModa2 example used to convert image dimensions -> AR grid dims.
 _PATCH_SIZE = 16
 
+# Shared by Preview and Dev (see ``t2i_generation_config.json``).
+_EOL_TOKEN_ID = 152064
+_VISUAL_TOKEN_START_ID = 152072
+_VISUAL_TOKEN_END_ID = 168456
+
 _AR_SYSTEM_PROMPT = "You are a helpful image generator."
 
 
@@ -26,9 +31,8 @@ def build_text_to_image_prompt(
 
     Model-specific sampling knobs (``text_guidance_scale``, ``cfg_range``,
     ``num_inference_steps``) flow separately via ``extra_body`` -> ``extra_args``.
-    Config-derived token ids (``eol_token_id``, ``visual_token_start_id``,
-    ``visual_token_end_id``, ``visual_ids``) are sourced inside the AR stage
-    rather than passed by the caller -- see the ar2dit stage input processor.
+    The structural token ids are included in ``additional_information`` so the
+    AR sampler can apply the same constraints for both Preview and Dev.
 
     MammothModa2 t2i uses classifier-free guidance via ``text_guidance_scale``
     and has no explicit negative-prompt path, so ``negative_prompt`` is accepted
@@ -52,6 +56,9 @@ def build_text_to_image_prompt(
             "ar_height": [ar_height],
             "image_height": [h],
             "image_width": [w],
+            "eol_token_id": [_EOL_TOKEN_ID],
+            "visual_token_start_id": [_VISUAL_TOKEN_START_ID],
+            "visual_token_end_id": [_VISUAL_TOKEN_END_ID],
         },
     }
 
@@ -66,5 +73,29 @@ MAMMOTHMODA2_PREVIEW_EXTRA_BODY_PARAMS = frozenset(
         "num_inference_steps",
     }
 )
+
+
+def build_x_to_text_prompt(
+    model: str,
+    prompt: str,
+    has_image: bool,
+) -> tuple[dict[str, Any], list[int] | None]:
+    """Build MammothModa2's chat prompt for text-output tasks."""
+    del model
+    vision = "<|vision_start|><|image_pad|><|vision_end|>" if has_image else ""
+    return (
+        {
+            "prompt": (
+                "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n"
+                f"<|im_start|>user\n{vision}{prompt}<|im_end|>\n"
+                "<|im_start|>assistant\n"
+            ),
+            "modalities": ["text"],
+            "additional_information": {"omni_task": ["chat"]},
+        },
+        None,
+    )
+
+
 MAMMOTHMODA2_PREVIEW_EXTRA_OUTPUT_PARAMS = frozenset()
 MAMMOTHMODA2_PREVIEW_INIT_EXTRA_ARGS_FOR_NON_DIFFUSION_STAGES = True
diff --git a/vllm_omni/model_extras/registry.py b/vllm_omni/model_extras/registry.py
index 7103991c7..dab5b45cf 100644
--- a/vllm_omni/model_extras/registry.py
+++ b/vllm_omni/model_extras/registry.py
@@ -23,6 +23,7 @@ from vllm_omni.model_extras.bagel import (
 from vllm_omni.model_extras.bagel import (
     build_text_to_image_prompt as build_bagel_text_to_image_prompt,
 )
+from vllm_omni.model_extras.bagel import build_x_to_text_prompt as build_bagel_x_to_text_prompt
 from vllm_omni.model_extras.cosmos3 import (
     COSMOS3_EXTRA_BODY_PARAMS,
     COSMOS3_EXTRA_OUTPUT_PARAMS,
@@ -34,6 +35,9 @@ from vllm_omni.model_extras.helios import (
     HELIOS_EXTRA_BODY_PARAMS,
     HELIOS_EXTRA_OUTPUT_PARAMS,
 )
+from vllm_omni.model_extras.hunyuan_image3 import build_x_to_text_prompt as build_hunyuan_x_to_text_prompt
+from vllm_omni.model_extras.lingbot_video import LINGBOT_VIDEO_EXTRA_BODY_PARAMS
+from vllm_omni.model_extras.ltx2 import LTX_EXTRA_BODY_PARAMS, LTX_EXTRA_OUTPUT_PARAMS
 from vllm_omni.model_extras.magi_human import (
     MAGI_HUMAN_EXTRA_BODY_PARAMS,
     MAGI_HUMAN_EXTRA_OUTPUT_PARAMS,
@@ -46,6 +50,9 @@ from vllm_omni.model_extras.mammothmodal2_preview import (
 from vllm_omni.model_extras.mammothmodal2_preview import (
     build_text_to_image_prompt as build_mammothmoda2_text_to_image_prompt,
 )
+from vllm_omni.model_extras.mammothmodal2_preview import (
+    build_x_to_text_prompt as build_mammothmoda2_x_to_text_prompt,
+)
 from vllm_omni.model_extras.ming_flash_omni import (
     MING_FLASH_OMNI_EXTRA_BODY_PARAMS,
     MING_FLASH_OMNI_EXTRA_OUTPUT_PARAMS,
@@ -88,6 +95,50 @@ ImageToVideoPromptBuilder = Callable[
     ],
     dict[str, Any],
 ]
+XToTextPromptBuilder = Callable[[str, str, bool], tuple[dict[str, Any], list[int] | None]]
+
+
+def default_x_to_text_prompt(
+    model: str,
+    prompt: str,
+    has_image: bool,
+) -> tuple[dict[str, Any], list[int] | None]:
+    del model, has_image
+    return {"prompt": prompt, "modalities": ["text"]}, None
+
+
+_X_TO_TEXT_SPECS: dict[str, XToTextPromptBuilder] = {
+    "bagel": build_bagel_x_to_text_prompt,
+    "hunyuan_image3": build_hunyuan_x_to_text_prompt,
+    "mammoth_moda2": build_mammothmoda2_x_to_text_prompt,
+}
+
+
+def get_x_to_text_model_family(model: str) -> str:
+    """Resolve a text-output prompt family from a checkpoint's config.json."""
+    from vllm.transformers_utils.config import get_hf_file_to_dict
+
+    config = get_hf_file_to_dict("config.json", model) or {}
+    model_type = str(config.get("model_type", "")).lower()
+    architectures = {str(value).lower() for value in (config.get("architectures") or [])}
+    if model_type == "bagel" or "bagelforconditionalgeneration" in architectures:
+        return "bagel"
+    if model_type == "hunyuan_image_3_moe" or any("hunyuanimage3" in value for value in architectures):
+        return "hunyuan_image3"
+    if "mammoth" in model_type or any("mammothmoda2" in value for value in architectures):
+        return "mammoth_moda2"
+    return "generic"
+
+
+def build_x_to_text_prompt(
+    model_family: str,
+    model: str,
+    prompt: str,
+    has_image: bool,
+) -> tuple[dict[str, Any], list[int] | None]:
+    """Build a model-aware T2T/I2T prompt and optional stop-token ids."""
+    builder = _X_TO_TEXT_SPECS.get(model_family, default_x_to_text_prompt)
+    return builder(model, prompt, has_image)
 
 
 def default_text_to_image_prompt(
@@ -153,6 +204,11 @@ _EXTRA_SPECS: dict[str, dict[str, Any]] = {
         "extra_output_params": COSMOS3_EXTRA_OUTPUT_PARAMS,
         "text_to_image_prompt_builder": build_cosmos3_text_to_image_prompt,
     },
+    "Cosmos3OmniPipeline": {
+        "extra_body_params": COSMOS3_EXTRA_BODY_PARAMS,
+        "extra_output_params": COSMOS3_EXTRA_OUTPUT_PARAMS,
+        "text_to_image_prompt_builder": build_cosmos3_text_to_image_prompt,
+    },
     "MagiHumanPipeline": {
         "extra_body_params": MAGI_HUMAN_EXTRA_BODY_PARAMS,
         "extra_output_params": MAGI_HUMAN_EXTRA_OUTPUT_PARAMS,
@@ -165,6 +221,19 @@ _EXTRA_SPECS: dict[str, dict[str, Any]] = {
         "extra_body_params": HELIOS_EXTRA_BODY_PARAMS,
         "extra_output_params": HELIOS_EXTRA_OUTPUT_PARAMS,
     },
+    "LingBotVideoPipeline": {
+        "extra_body_params": LINGBOT_VIDEO_EXTRA_BODY_PARAMS,
+    },
+    **{
+        model_class_name: {
+            "extra_body_params": LTX_EXTRA_BODY_PARAMS,
+            "extra_output_params": LTX_EXTRA_OUTPUT_PARAMS,
+        }
+        for model_class_name in (
+            "LTX2Pipeline",
+            "LTX2DistilledPipeline",
+        )
+    },
     "WanVACEPipeline": {
         "extra_body_params": VACE_EXTRA_BODY_PARAMS,
         "extra_output_params": VACE_EXTRA_OUTPUT_PARAMS,
@@ -185,6 +254,11 @@ _EXTRA_SPECS: dict[str, dict[str, Any]] = {
     },
 }
 
+# Multi-stage discovery reports the top-level wrapper rather than its DiT
+# submodule, so both names must resolve to the same request adapters.
+_EXTRA_SPECS["MammothModa2ForConditionalGeneration"] = _EXTRA_SPECS["MammothModa2DiTPipeline"]
+_EXTRA_SPECS["Mammothmoda2Model"] = _EXTRA_SPECS["MammothModa2DiTPipeline"]
+
 
 def _get_spec(model_class_name: str | None) -> dict[str, Any] | None:
     if not model_class_name:
diff --git a/vllm_omni/outputs/__init__.py b/vllm_omni/outputs/__init__.py
index 2f2a6f2ee..d0e41dbf0 100644
--- a/vllm_omni/outputs/__init__.py
+++ b/vllm_omni/outputs/__init__.py
@@ -58,6 +58,18 @@ class OmniModelRunnerOutput(ModelRunnerOutput):
     kv_extracted_req_ids: list[str] | None = None
     omni_connector_output: OmniConnectorOutput | None = None
 
+    @classmethod
+    def with_kv_conn_output_only(cls, kv_connector_output: Any) -> "OmniModelRunnerOutput":
+        return cls(
+            req_ids=[],
+            req_id_to_index={},
+            sampled_token_ids=[],
+            logprobs=None,
+            prompt_logprobs_dict={},
+            pooler_output=[],
+            kv_connector_output=kv_connector_output,
+        )
+
 
 @dataclass
 class OmniRequestOutput:
@@ -71,6 +83,7 @@ class OmniRequestOutput:
         request_id: Unique identifier for this request
         finished: Whether generation is complete
         stage_id: Identifier of the stage that produced this output (pipeline mode)
+        replica_id: Identifier of the stage replica that produced this output
         final_output_type: Type of output ("text", "image", "audio", "latents")
         request_output: The underlying RequestOutput from the stage (pipeline mode)
         images: List of generated PIL images (diffusion mode)
@@ -84,6 +97,7 @@ class OmniRequestOutput:
 
     # Pipeline stage fields
     stage_id: int | None = None
+    replica_id: int | None = None
     final_output_type: str = "text"
     request_output: RequestOutput | None = None
 
@@ -142,6 +156,7 @@ class OmniRequestOutput:
         stage_id: int,
         final_output_type: str,
         request_output: RequestOutput,
+        replica_id: int | None = None,
     ) -> "OmniRequestOutput":
         """Create output from pipeline stage.
 
@@ -156,6 +171,7 @@ class OmniRequestOutput:
         return cls(
             request_id=getattr(request_output, "request_id", ""),
             stage_id=stage_id,
+            replica_id=replica_id,
             final_output_type=final_output_type,
             request_output=request_output,
             finished=True,
diff --git a/vllm_omni/outputs/multimodal_accumulation.py b/vllm_omni/outputs/multimodal_accumulation.py
new file mode 100644
index 000000000..715f6366c
--- /dev/null
+++ b/vllm_omni/outputs/multimodal_accumulation.py
@@ -0,0 +1,92 @@
+from typing import Any
+
+import torch
+
+from vllm_omni.outputs.mm_outputs import MultimodalPayload
+from vllm_omni.outputs.output_modality import DRAINABLE_MODALITIES
+
+CHUNK_METADATA_KEYS: frozenset[str] = frozenset(
+    {
+        "audio_text_total_chars",
+        "duplex_epoch",
+        "duplex_turn_id",
+        "llm_output_text_utf8",
+        "segment_end",
+        "tts_is_last_chunk",
+        "turn_end",
+    }
+)
+
+
+def _is_chunk_metadata_key(key: str) -> bool:
+    if key.startswith("meta."):
+        return key.split(".", 1)[1] in CHUNK_METADATA_KEYS
+    return key in CHUNK_METADATA_KEYS
+
+
+def replace_snapshot_keys(
+    accumulated: MultimodalPayload,
+    incoming: MultimodalPayload,
+) -> None:
+    """Replace per-chunk metadata with the latest values."""
+    for key in (*incoming.tensors, *incoming.metadata):
+        if _is_chunk_metadata_key(key):
+            accumulated.tensors.pop(key, None)
+            accumulated.metadata.pop(key, None)
+
+
+def drain_delta_payload(payload: MultimodalPayload) -> None:
+    """Remove client-facing delta data while retaining request-level state."""
+    for modality_key in DRAINABLE_MODALITIES:
+        key = str(modality_key)
+        payload.tensors.pop(key, None)
+        payload.metadata.pop(key, None)
+
+    for metadata_key in CHUNK_METADATA_KEYS:
+        flat_key = f"meta.{metadata_key}"
+        payload.tensors.pop(flat_key, None)
+        payload.metadata.pop(flat_key, None)
+
+    meta = payload.metadata.get("meta")
+    if isinstance(meta, dict):
+        filtered = {key: value for key, value in meta.items() if key not in CHUNK_METADATA_KEYS}
+        if filtered:
+            payload.metadata["meta"] = filtered
+        else:
+            payload.metadata.pop("meta", None)
+
+
+def _payload_meta_value(payload: MultimodalPayload, key: str) -> Any:
+    flat_key = f"meta.{key}"
+    if flat_key in payload.tensors:
+        return payload.tensors[flat_key]
+    if flat_key in payload.metadata:
+        return payload.metadata[flat_key]
+    meta = payload.metadata.get("meta")
+    if isinstance(meta, dict):
+        return meta.get(key)
+    return None
+
+
+def _last_scalar_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, bool | int):
+        return int(value)
+    if isinstance(value, list | tuple):
+        return _last_scalar_int(value[-1]) if value else None
+    if isinstance(value, torch.Tensor):
+        try:
+            if value.numel() == 0:
+                return None
+            return int(value.detach().cpu().reshape(-1)[-1].item())
+        except (RuntimeError, TypeError, ValueError):
+            return None
+    return None
+
+
+def is_non_final_delta_audio_chunk(payload: MultimodalPayload, mm_type: str | None) -> bool:
+    """Return whether an audio delta explicitly declares more chunks."""
+    if str(mm_type or "").lower() != "audio" and "audio" not in payload:
+        return False
+    return _last_scalar_int(_payload_meta_value(payload, "tts_is_last_chunk")) == 0
diff --git a/vllm_omni/outputs/output_modality.py b/vllm_omni/outputs/output_modality.py
index 2536a8ade..7cdbc1f19 100644
--- a/vllm_omni/outputs/output_modality.py
+++ b/vllm_omni/outputs/output_modality.py
@@ -8,7 +8,7 @@ for type-safe multimodal output routing and tensor merging.
 from __future__ import annotations
 
 import re
-from enum import Enum, Flag, StrEnum, auto
+from enum import Enum, Flag, auto
 
 _MODALITY_ALIASES: dict[str, str] = {
     "speech": "audio",
@@ -23,13 +23,17 @@ _MODALITY_ALIASES: dict[str, str] = {
 }
 
 
-class OutputModalityNames(StrEnum):
+class OutputModalityNames(str, Enum):
     """Keys for output modalities.
 
     TODO: (Alex) Integrate this with the big-flag enum below + throughout the code
     for better type safety (currently only used for output processor).
     """
 
+    # Keep the string conversion provided by ``enum.StrEnum`` while using the
+    # Python 3.10-compatible ``str, Enum`` form.
+    __str__ = str.__str__
+
     TEXT = "text"
     IMAGE = "image"
     AUDIO = "audio"
diff --git a/vllm_omni/outputs/output_processor.py b/vllm_omni/outputs/output_processor.py
index e39b995b0..9558d66e5 100644
--- a/vllm_omni/outputs/output_processor.py
+++ b/vllm_omni/outputs/output_processor.py
@@ -19,15 +19,15 @@ from vllm.v1.metrics.stats import IterationStats, RequestStateStats
 from vllm_omni.data_entry_keys import unflatten_payload
 from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.outputs.mm_outputs import MultimodalCompletionOutput, MultimodalPayload
-from vllm_omni.outputs.output_modality import (
-    DRAINABLE_MODALITIES,
-    OutputModality,
-    get_accumulation_strategy,
+from vllm_omni.outputs.multimodal_accumulation import (
+    drain_delta_payload,
+    is_non_final_delta_audio_chunk,
+    replace_snapshot_keys,
 )
+from vllm_omni.outputs.output_modality import OutputModality, get_accumulation_strategy
 
 logger = init_logger(__name__)
 
-
 # ---------------------------------------------------------------------------
 # Module-level helpers
 # ---------------------------------------------------------------------------
@@ -55,6 +55,14 @@ def _modality_to_type_string(modality: OutputModality) -> str:
     return "text"
 
 
+def _mean_time_per_output_token_ms(stats: RequestStateStats) -> float:
+    output_intervals = stats.num_generation_tokens - 1
+    if output_intervals <= 0:
+        return 0.0
+    decode_time_s = max(stats.last_token_ts - stats.first_token_ts, 0.0)
+    return decode_time_s * 1000.0 / float(output_intervals)
+
+
 class OmniRequestState(RequestState):
     """Request state for omni models, tracking multimodal outputs.
 
@@ -85,7 +93,7 @@ class OmniRequestState(RequestState):
 
     def apply_streaming_update(self, update) -> None:
         super().apply_streaming_update(update)
-        self.native_text_stats.arrival_time = update.arrival_time
+        self.native_text_stats = RequestStateStats(arrival_time=float(update.arrival_time or 0.0))
 
     def add_multimodal_tensor(self, payload: Any | None, mm_type: str | None) -> None:
         """Accumulate a multimodal tensor payload into the request state.
@@ -104,6 +112,7 @@ class OmniRequestState(RequestState):
 
             incoming = MultimodalPayload.from_raw(payload, modality_key)
             if incoming is not None:
+                replace_snapshot_keys(self.mm_accumulated, incoming)
                 self.mm_accumulated = self.mm_accumulated.merged_with(incoming)
         except (ValueError, TypeError, RuntimeError):
             logger.exception("Error accumulating multimodal tensor")
@@ -170,9 +179,13 @@ class OmniRequestState(RequestState):
                 kv_transfer_params,
             )
 
+        is_delta = self.output_kind == RequestOutputKind.DELTA
+        if is_delta and finish_reason is not None and is_non_final_delta_audio_chunk(self.mm_accumulated, self.mm_type):
+            finish_reason = None
+            stop_reason = None
+
         finished = finish_reason is not None
         final_only = self.output_kind == RequestOutputKind.FINAL_ONLY
-        is_delta = self.output_kind == RequestOutputKind.DELTA
 
         if not finished and final_only:
             return None
@@ -280,10 +293,10 @@ class OmniRequestState(RequestState):
                     output.cumulative_text = base_output.cumulative_text
 
                 # DELTA mode: drain modality keys (e.g. audio) so the next
-                # step only sees freshly accumulated data for those keys.
+                # step only sees freshly accumulated data for those keys and
+                # their client-facing per-chunk metadata.
                 if self.output_kind == RequestOutputKind.DELTA:
-                    for modality_key in DRAINABLE_MODALITIES:
-                        self.mm_accumulated.tensors.pop(modality_key, None)
+                    drain_delta_payload(self.mm_accumulated)
 
                 return output
         except (RuntimeError, TypeError, AttributeError):
@@ -391,6 +404,7 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
         return self._native_text_metrics_by_request.setdefault(
             request_id,
             {
+                "num_generation_tokens": 0,
                 "vllm_ttft_ms": 0.0,
                 "vllm_tpot_ms": 0.0,
                 "vllm_itl_ms": 0.0,
@@ -509,24 +523,34 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
                 upstream_outputs.append(eco)
 
         # Handle multimodal-only outputs (generation stages) locally.
-        self._process_mm_only_outputs(mm_only_outputs)
-
-        # Delegate text/pooling outputs to upstream.
-        return super().process_outputs(
-            upstream_outputs,
+        mm_request_outputs = self._process_mm_only_outputs(
+            mm_only_outputs,
             engine_core_timestamp=engine_core_timestamp,
             iteration_stats=iteration_stats,
         )
 
+        # Delegate text/pooling outputs to upstream.
+        processed = super().process_outputs(
+            upstream_outputs,
+            engine_core_timestamp=engine_core_timestamp,
+            iteration_stats=iteration_stats,
+        )
+        processed.request_outputs.extend(mm_request_outputs)
+        return processed
+
     def _process_mm_only_outputs(
         self,
         engine_core_outputs: list[EngineCoreOutput],
-    ) -> None:
+        *,
+        engine_core_timestamp: float | None = None,
+        iteration_stats: IterationStats | None = None,
+    ) -> list[OmniRequestOutput | PoolingRequestOutput]:
         """Handle outputs from generation stages that have no detokenizer.
 
         These cannot go through upstream process_outputs because it asserts
         detokenizer is not None when pooling_output is None.
         """
+        request_outputs: list[OmniRequestOutput | PoolingRequestOutput] = []
         for eco in engine_core_outputs:
             req_state = self.request_states.get(eco.request_id)
             if req_state is None or not isinstance(req_state, OmniRequestState):
@@ -537,9 +561,22 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             stop_reason = eco.stop_reason
             kv_transfer_params = eco.kv_transfer_params
             routed_experts = eco.routed_experts
-            req_state.num_cached_tokens = eco.num_cached_tokens
+            self._update_stats_from_output(
+                req_state,
+                eco,
+                engine_core_timestamp,
+                iteration_stats,
+            )
+            prefill_stats = getattr(eco, "prefill_stats", None)
+            if prefill_stats is not None:
+                req_state.num_cached_tokens = prefill_stats.num_cached_tokens
             req_state.is_prefilling = False
 
+            is_non_final_audio_chunk = (
+                finish_reason is not None
+                and req_state.output_kind == RequestOutputKind.DELTA
+                and is_non_final_delta_audio_chunk(req_state.mm_accumulated, req_state.mm_type)
+            )
             if request_output := req_state.make_request_output(
                 new_token_ids,
                 None,  # pooling_output
@@ -550,9 +587,18 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             ):
                 if req_state.queue is not None:
                     req_state.queue.put(request_output)
+                else:
+                    request_outputs.append(request_output)
 
-            if finish_reason is not None:
+            is_segment_finished = bool(getattr(eco, "is_segment_finished", False))
+            if finish_reason is not None and not is_segment_finished and not is_non_final_audio_chunk:
                 self._finish_request(req_state)
+                self._update_stats_from_finished(
+                    req_state,
+                    finish_reason,
+                    iteration_stats,
+                )
+        return request_outputs
 
     def _update_stats_from_output(
         self,
@@ -592,6 +638,7 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             req_state.lora_name,
         )
         record = self._native_text_metric_record(req_state.external_req_id)
+        record["num_generation_tokens"] = int(native_stats.num_generation_tokens)
         if was_prefilling:
             record["vllm_ttft_ms"] = max(float(native_stats.first_token_latency) * 1000.0, 0.0)
             return
@@ -601,6 +648,7 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             itls_ms = record.setdefault("vllm_itls_ms", [])
             itls_ms.append(itl_ms)
             record["vllm_itl_ms"] = sum(itls_ms) / float(len(itls_ms))
+        record["vllm_tpot_ms"] = _mean_time_per_output_token_ms(native_stats)
 
     def _update_stats_from_finished(
         self,
diff --git a/vllm_omni/platforms/cuda/platform.py b/vllm_omni/platforms/cuda/platform.py
index a05bb289a..4551126a7 100644
--- a/vllm_omni/platforms/cuda/platform.py
+++ b/vllm_omni/platforms/cuda/platform.py
@@ -36,7 +36,7 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
 
     @classmethod
     def get_default_stage_config_path(cls) -> str:
-        return "vllm_omni/model_executor/stage_configs"
+        return "vllm_omni/deploy"
 
     @classmethod
     def has_flash_attn_package(cls) -> bool:
@@ -57,6 +57,7 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = True,
     ) -> str:
         from vllm_omni.diffusion.envs import PACKAGES_CHECKER
 
@@ -119,8 +120,21 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
             # not abort startup — just treat FlashInfer as unavailable.
             logger.debug("FlashInfer probe failed (%s); treating as unavailable", e)
 
+        # TRTLLM_ATTN needs the trtllm-gen kernel specifically, not just any FlashInfer
+        # wheel. Probe the actual symbol so a released wheel lacking it does not get
+        # auto-routed to TRTLLM_ATTN and then crash on the first forward.
+        trtllm_gen_available = False
+        if flashinfer_available:
+            try:
+                from flashinfer.prefill import trtllm_ragged_attention_deepseek  # noqa: F401
+
+                trtllm_gen_available = True
+            except Exception as e:
+                logger.debug("trtllm-gen kernel probe failed (%s); treating as unavailable", e)
+
         if selected_backend is not None:
             backend_upper = selected_backend.upper()
+            cls.validate_diffusion_attn_backend(backend_upper)
             if backend_upper in ("FLASH_ATTN_HUB", "FLASH_ATTN_3_HUB"):
                 try:
                     importlib.import_module("kernels")
@@ -172,10 +186,37 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
                         "SageAttention/sageattention3_blackwell. Falling back to TORCH_SDPA backend."
                     )
                     return DiffusionAttentionBackendEnum.TORCH_SDPA.get_path()
+            if backend_upper == "TRTLLM_ATTN":
+                trtllm_attn_supported = compute_capability is not None and compute_capability.major == 10
+                if not trtllm_attn_supported:
+                    raise ValueError(
+                        "TRTLLM_ATTN diffusion attention backend requires a datacenter "
+                        "Blackwell GPU (SM100 / SM103, compute capability 10.x). Select a "
+                        "different --diffusion-attention-backend."
+                    )
+                if not flashinfer_available:
+                    raise ValueError(
+                        "TRTLLM_ATTN diffusion attention backend requires flashinfer, which is not installed."
+                    )
             backend = DiffusionAttentionBackendEnum[backend_upper]
             logger.debug("Using diffusion attention backend '%s'", backend_upper)
             return backend.get_path()
 
+        trtllm_attn_default_ok = (
+            allow_trtllm_default
+            and compute_capability is not None
+            and compute_capability.major == 10
+            and head_size == 128
+            and trtllm_gen_available
+        )
+        if trtllm_attn_default_ok:
+            logger.info(
+                "Defaulting to diffusion attention backend TRTLLM_ATTN (datacenter Blackwell %s, head_dim %d)",
+                sm_str,
+                head_size,
+            )
+            return DiffusionAttentionBackendEnum.TRTLLM_ATTN.get_path()
+
         if is_blackwell and cudnn_blackwell_ready:
             logger.info(
                 "Defaulting to diffusion attention backend CUDNN_ATTN (Blackwell %s, cuDNN %d)",
@@ -233,6 +274,17 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
     def synchronize(cls) -> None:
         torch.accelerator.synchronize()
 
+    @classmethod
+    def record_device_event(cls) -> torch.Event | None:
+        """Record a device event on the default stream to mark tensor readiness."""
+        try:
+            event = torch.Event()
+            event.record()
+            return event
+        except Exception:
+            logger.warning("Failed to record device event for cross-stream sync")
+            return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         free, _ = torch.cuda.mem_get_info(device)
@@ -247,6 +299,16 @@ class CudaOmniPlatform(OmniPlatform, CudaPlatformBase):
     def get_device_name(cls, device_id: int = 0) -> str:
         return torch.cuda.get_device_name(device_id)
 
+    @classmethod
+    def get_device_total_memory(cls, device_id: int = 0) -> int:
+        device_props = torch.cuda.get_device_properties(device_id)
+        return device_props.total_memory
+
+    @classmethod
+    def is_fully_connected(cls, device_ids: list[int]) -> bool:
+        logger.debug("NVLink detection not available on CudaOmniPlatform; assuming no NVLink.")
+        return False
+
     @classmethod
     def get_default_ir_op_priority(cls, vllm_config: VllmConfig) -> IrOpPriorityConfig:
         """Prefer ``vllm_c`` CUDA kernels over ``native`` for diffusion IR ops."""
diff --git a/vllm_omni/platforms/interface.py b/vllm_omni/platforms/interface.py
index 54725b553..fdd31ad21 100644
--- a/vllm_omni/platforms/interface.py
+++ b/vllm_omni/platforms/interface.py
@@ -70,13 +70,31 @@ class OmniPlatform(Platform):
         raise NotImplementedError
 
     @classmethod
-    def get_diffusion_model_impl_qualname(cls, op_name: str) -> str:
-        if op_name == "hunyuan_fused_moe":
-            return "vllm_omni.diffusion.models.hunyuan_image3.hunyuan_fused_moe.HunyuanFusedMoEDefault"
-        raise NotImplementedError(f"Unsupported diffusion model op: {op_name}")
+    def prepare_diffusion_op_runtime(cls, op_name: str, **kwargs: Any) -> None:
+        return None
 
     @classmethod
-    def prepare_diffusion_op_runtime(cls, op_name: str, **kwargs: Any) -> None:
+    def register_additional_diffusion_fused_moe_hooks(cls, moe_runner: Any) -> None:
+        # One-shot lazy kernel initialisation on the first forward (no-op unless
+        # the runner exposes an uninitialised quant_method). Mirrors the prior
+        # wrapper behaviour exactly, just bound to the runner module.
+        init_handle: Any = None
+
+        def _kernel_init_pre_hook(module: Any, args: Any, kwargs: Any) -> None:
+            nonlocal init_handle
+            quant_method = getattr(module, "quant_method", None)
+            if quant_method is not None and getattr(quant_method, "moe_kernel", None) is None:
+                quant_method.process_weights_after_loading(module)
+            if init_handle is not None:
+                init_handle.remove()
+
+        init_handle = moe_runner.register_forward_pre_hook(
+            _kernel_init_pre_hook,
+            with_kwargs=True,
+        )
+
+    @classmethod
+    def reset_diffusion_fused_moe_forward_context(cls) -> None:
         return None
 
     @classmethod
@@ -91,6 +109,7 @@ class OmniPlatform(Platform):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = False,
     ) -> str:
         """Get the diffusion attention backend class path for this platform.
 
@@ -101,12 +120,36 @@ class OmniPlatform(Platform):
             selected_backend: User-selected backend name (e.g., "FLASH_ATTN",
                 "TORCH_SDPA", "SAGE_ATTN"). If None, uses platform default.
             head_size: Attention head size.
+            allow_trtllm_default: Whether TRTLLM may be chosen as the default.
 
         Returns:
             Fully qualified class path of the selected backend.
         """
         raise NotImplementedError
 
+    @classmethod
+    def validate_diffusion_attn_backend(cls, selected_backend: str) -> None:
+        """Reject an explicitly selected backend this platform cannot run.
+
+        Platforms call this from ``get_diffusion_attn_backend_cls`` so that a
+        backend restricted to other hardware, or one whose kernel package is
+        missing, fails during resolution rather than at the first forward.
+        """
+        from vllm_omni.diffusion.attention.backends.registry import DiffusionAttentionBackendEnum
+
+        backend_upper = selected_backend.upper()
+        backend_cls = DiffusionAttentionBackendEnum[backend_upper].get_class()
+
+        supported = backend_cls.supported_platforms
+        platform = cls._omni_enum.value
+        if supported is not None and platform not in supported:
+            raise ValueError(
+                f"The {backend_upper} diffusion attention backend runs on {', '.join(supported)} only, "
+                f"but the current platform is {platform}. Select a backend supported here, "
+                "such as FLASH_ATTN or TORCH_SDPA."
+            )
+        backend_cls.validate_available()
+
     @classmethod
     def supports_torch_inductor(cls) -> bool:
         """Check if the platform supports torch.compile with inductor backend."""
@@ -137,10 +180,23 @@ class OmniPlatform(Platform):
         return "vllm_omni.diffusion.worker.diffusion_model_runner.DiffusionModelRunner"
 
     @classmethod
-    def init_diffusion_worker_vllm_config(cls, vllm_config: Any) -> None:
+    def init_diffusion_worker_vllm_config(
+        cls,
+        vllm_config: Any,
+    ) -> None:
         """Initialize platform-specific state for diffusion worker VllmConfig."""
         return None
 
+    @classmethod
+    def init_diffusion_model_runner_runtime(
+        cls,
+        vllm_config: Any,
+        od_config: Any,
+        device: torch.device,
+    ) -> None:
+        """Initialize platform-specific runtime state for diffusion model runners."""
+        return None
+
     @classmethod
     def get_torch_device(cls, local_rank: int | None = None) -> torch.device:
         raise NotImplementedError
@@ -157,6 +213,24 @@ class OmniPlatform(Platform):
     def synchronize(cls) -> None:
         raise NotImplementedError
 
+    # ── Async diffusion output: cross-stream sync ──
+
+    @classmethod
+    def record_device_event(cls):
+        """Record a device event on the default stream to mark tensor readiness.
+
+        On platforms where distributed communication (e.g. HCCL) may use
+        internal streams not visible to the default stream, this method
+        should synchronize the default stream before recording the event
+        to ensure the event captures all completed work including
+        cross-device communication results.
+
+        Returns ``None`` by default so that platforms without a native
+        implementation (ROCm, XPU, MUSA) fall through to a safe no-op.
+        Override in platform subclasses to provide real event support.
+        """
+        return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         raise NotImplementedError
diff --git a/vllm_omni/platforms/musa/platform.py b/vllm_omni/platforms/musa/platform.py
index 92a194d59..02ce155ee 100644
--- a/vllm_omni/platforms/musa/platform.py
+++ b/vllm_omni/platforms/musa/platform.py
@@ -32,7 +32,7 @@ class MUSAOmniPlatform(OmniPlatform, MUSAPlatformBase):
 
     @classmethod
     def get_default_stage_config_path(cls) -> str:
-        return "vllm_omni/model_executor/stage_configs"
+        return "vllm_omni/deploy"
 
     @classmethod
     def has_flash_attn_package(cls) -> bool:
@@ -45,6 +45,7 @@ class MUSAOmniPlatform(OmniPlatform, MUSAPlatformBase):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = False,
     ) -> str:
         """Get the diffusion attention backend class path for MUSA platform.
 
@@ -54,7 +55,8 @@ class MUSAOmniPlatform(OmniPlatform, MUSAPlatformBase):
             selected_backend: User-selected backend name (e.g., "FLASH_ATTN",
                 "TORCH_SDPA"). If None, uses platform default.
             head_size: Attention head size.
-
+            allow_trtllm_default: Does not support TRTLLM backend;
+                arg accepted for signature parity but unused.
         Returns:
             Fully qualified class path of the selected backend.
         """
@@ -78,6 +80,7 @@ class MUSAOmniPlatform(OmniPlatform, MUSAPlatformBase):
 
         if selected_backend is not None:
             backend_upper = selected_backend.upper()
+            cls.validate_diffusion_attn_backend(backend_upper)
             if backend_upper in ("FLASH_ATTN_HUB", "FLASH_ATTN_3_HUB"):
                 logger.warning(
                     "HuggingFace kernels-backed FlashAttention is "
@@ -152,6 +155,16 @@ class MUSAOmniPlatform(OmniPlatform, MUSAPlatformBase):
         """Synchronize all MUSA operations."""
         torch.musa.synchronize()
 
+    @classmethod
+    def record_device_event(cls) -> torch.Event | None:
+        try:
+            event = torch.musa.Event()
+            event.record()
+            return event
+        except Exception:
+            logger.warning("Failed to record MUSA device event for cross-stream sync")
+            return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         free, _ = torch.musa.mem_get_info(device)
diff --git a/vllm_omni/platforms/npu/layers/__init__.py b/vllm_omni/platforms/npu/layers/__init__.py
new file mode 100644
index 000000000..208f01a7c
--- /dev/null
+++ b/vllm_omni/platforms/npu/layers/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
diff --git a/vllm_omni/platforms/npu/models/hunyuan_fused_moe.py b/vllm_omni/platforms/npu/layers/fused_moe.py
similarity index 52%
rename from vllm_omni/platforms/npu/models/hunyuan_fused_moe.py
rename to vllm_omni/platforms/npu/layers/fused_moe.py
index 251eac2cf..e17610701 100644
--- a/vllm_omni/platforms/npu/models/hunyuan_fused_moe.py
+++ b/vllm_omni/platforms/npu/layers/fused_moe.py
@@ -4,14 +4,14 @@
 from typing import Any
 
 import torch
+import vllm.distributed.parallel_state as vllm_parallel_state
 import vllm.forward_context as _vllm_fc
 from vllm.config import VllmConfig
-from vllm.distributed import get_ep_group
+from vllm.distributed import get_dp_group, get_ep_group
 from vllm.distributed.parallel_state import (
     init_model_parallel_group as vllm_init_model_parallel_group,
 )
 from vllm_ascend.ascend_forward_context import MoECommType
-from vllm_ascend.ops.fused_moe.fused_moe import AscendFusedMoE
 from vllm_ascend.ops.fused_moe.moe_comm_method import _MoECommMethods
 from vllm_ascend.utils import AscendDeviceType, get_ascend_device_type
 
@@ -29,17 +29,6 @@ def _ensure_forward_context_attr(name: str, annotation: Any, default: Any) -> No
         setattr(_vllm_fc.ForwardContext, name, default)
 
 
-def _set_hunyuan_fused_moe_forward_context(num_tokens: int) -> None:
-    if not _vllm_fc.is_forward_context_available():
-        return
-
-    forward_context = _vllm_fc.get_forward_context()
-    forward_context.num_tokens = num_tokens
-    forward_context.moe_comm_type = _select_moe_comm_method(vllm_config=omni_get_ctx().vllm_config)
-    forward_context.moe_comm_method = _MoECommMethods.get(forward_context.moe_comm_type)
-    forward_context.flash_comm_v1_enabled = False
-
-
 def _init_mc2_group_for_diffusion(
     backend: str,
     local_rank: int,
@@ -74,16 +63,16 @@ def _select_moe_comm_method(vllm_config: VllmConfig) -> MoECommType | None:
     return moe_comm_type
 
 
-def prepare_hunyuan_fused_moe_runtime() -> None:
+def prepare_fused_moe_runtime() -> None:
     vllm_config = omni_get_ctx().vllm_config
-    if vllm_config.parallel_config.enable_expert_parallel:
-        backend = torch.distributed.get_backend(get_world_group().device_group)
-        local_rank = get_world_group().local_rank
-        _init_mc2_group_for_diffusion(
-            backend=backend,
-            local_rank=local_rank,
-            group_ranks=get_expert_parallel_group_ranks(),
-        )
+
+    backend = torch.distributed.get_backend(get_world_group().device_group)
+    local_rank = get_world_group().local_rank
+    _init_mc2_group_for_diffusion(
+        backend=backend,
+        local_rank=local_rank,
+        group_ranks=get_expert_parallel_group_ranks(),
+    )
 
     moe_comm_type = _select_moe_comm_method(vllm_config=vllm_config)
     _ensure_forward_context_attr("num_tokens", int | None, None)
@@ -91,24 +80,66 @@ def prepare_hunyuan_fused_moe_runtime() -> None:
     _ensure_forward_context_attr("moe_comm_type", MoECommType | None, moe_comm_type)
     _ensure_forward_context_attr("moe_comm_method", Any, _MoECommMethods.get(moe_comm_type))
     _ensure_forward_context_attr("flash_comm_v1_enabled", bool, False)
+    _ensure_forward_context_attr("max_tokens_across_dp", int | None, None)
+    _ensure_forward_context_attr("max_tokens_across_pcp", int | None, None)
 
 
-# NOTE: vLLM v0.20.0 folded SharedFusedMoE into FusedMoE, and vllm-ascend in turn
-# removed AscendSharedFusedMoE — the shared-experts / gate / multistream-overlap
-# paths now live directly on AscendFusedMoE and are activated by passing
-# shared_experts= as a kwarg.
-class AscendHunyuanFusedMoE(AscendFusedMoE):
-    def __init__(self, *, prefix: str = "", **kwargs: Any) -> None:
-        super().__init__(prefix=prefix, **kwargs)
-        self._prefix = prefix
+def reset_fused_moe_forward_context() -> None:
+    try:
+        forward_context = _vllm_fc.get_forward_context()
+    except AssertionError:
+        return
 
-    def forward(self, hidden_states: Any, router_logits: Any) -> Any:
-        _set_hunyuan_fused_moe_forward_context(hidden_states.shape[0])
-        return super().forward(hidden_states, router_logits)
+    # MoE input token counts can change between transformer forwards, for
+    # example when text tokens are present only in some forwards. Clear cached
+    # DP/PCP padding bounds so the first MoE layer recomputes them.
+    forward_context.max_tokens_across_dp = None
+    forward_context.max_tokens_across_pcp = None
 
-    def __del__(self):
-        import vllm_ascend.distributed.parallel_state as vllm_ascend_parallel_state
 
-        if vllm_ascend_parallel_state._MC2:
-            vllm_ascend_parallel_state._MC2.destroy()
-        vllm_ascend_parallel_state._MC2 = None
+def _set_max_tokens(forward_context: Any, hidden_states: torch.Tensor) -> None:
+    if (
+        getattr(forward_context, "max_tokens_across_dp", None) is not None
+        or getattr(forward_context, "max_tokens_across_pcp", None) is not None
+    ):
+        return
+
+    num_tokens_before_pcp = hidden_states.shape[0]
+    dp_metadata = getattr(forward_context, "dp_metadata", None)
+    if dp_metadata is not None:
+        max_tokens_across_dp = int(dp_metadata.num_tokens_across_dp_cpu.max().item())
+        forward_context.max_tokens_across_dp = max_tokens_across_dp
+        # DP prepare pads each rank to max_tokens_across_dp, then gathers
+        # all DP ranks before the PCP gather.
+        num_tokens_before_pcp = max_tokens_across_dp * get_dp_group().world_size
+
+    pcp_group = getattr(vllm_parallel_state, "_PCP", None)
+    if pcp_group is None or getattr(pcp_group, "world_size", 1) <= 1:
+        return
+
+    gathered_num_tokens: list[int | None] = [None] * pcp_group.world_size
+    torch.distributed.all_gather_object(
+        gathered_num_tokens,
+        int(num_tokens_before_pcp),
+        group=pcp_group.cpu_group,
+    )
+    if any(num_tokens is None for num_tokens in gathered_num_tokens):
+        raise RuntimeError(f"Failed to gather MoE PCP token counts: {gathered_num_tokens}")
+    forward_context.max_tokens_across_pcp = max(gathered_num_tokens)
+
+
+def fused_moe_forward_context_pre_hook(
+    module: Any,
+    args: Any,
+    kwargs: Any,
+) -> None:
+    forward_context = _vllm_fc.get_forward_context()
+
+    hidden_states = kwargs.get("hidden_states")
+    if hidden_states is None and args:
+        hidden_states = args[0]
+    if hidden_states is not None:
+        _set_max_tokens(forward_context, hidden_states)
+
+    forward_context.moe_comm_type = _select_moe_comm_method(vllm_config=omni_get_ctx().vllm_config)
+    forward_context.moe_comm_method = _MoECommMethods.get(forward_context.moe_comm_type)
diff --git a/vllm_omni/platforms/npu/layers/rotary_embedding.py b/vllm_omni/platforms/npu/layers/rotary_embedding.py
new file mode 100644
index 000000000..e7e335a16
--- /dev/null
+++ b/vllm_omni/platforms/npu/layers/rotary_embedding.py
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Shared NPU rotary embedding helpers."""
+
+from __future__ import annotations
+
+import torch
+import torch_npu
+
+
+def _bnsd_rotary_shape_is_supported(hidden_states: torch.Tensor) -> bool:
+    """Return whether the fused half-mode BNSD tiler supports the shape.
+
+    For the aligned-head-dimension branch, CANN requires
+    ``batch * num_heads <= seq_len * 8``. Other alignments are handled with
+    the BSND layout, which does not have this short-sequence limit.
+    """
+    if hidden_states.ndim != 4:
+        return False
+
+    batch_size, num_heads, seq_len, head_dim = hidden_states.shape
+    element_size = hidden_states.element_size()
+    if head_dim % 2 != 0 or element_size <= 0 or 32 % element_size != 0:
+        return False
+
+    half_dim_alignment = 32 // element_size
+    return head_dim // 2 % half_dim_alignment == 0 and batch_size * num_heads <= seq_len * 8
+
+
+def npu_rotary_mul_with_bsnd_fallback(
+    hidden_states: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    unsqueeze_dim: int,
+) -> torch.Tensor:
+    """Apply fused rotary multiplication, falling back from BNSD to BSND.
+
+    ``unsqueeze_dim=1`` denotes BNSD input following the Transformers rotary
+    embedding convention. Supported BNSD shapes stay on the fast path. Shapes
+    rejected by the CANN BNSD tiler are transposed to BSND for the fused op and
+    transposed back before returning.
+    """
+    if unsqueeze_dim != 1 or _bnsd_rotary_shape_is_supported(hidden_states):
+        return torch_npu.npu_rotary_mul(
+            hidden_states,
+            cos.unsqueeze(unsqueeze_dim),
+            sin.unsqueeze(unsqueeze_dim),
+        )
+
+    hidden_states_bsnd = hidden_states.transpose(1, 2).contiguous()
+    output_bsnd = torch_npu.npu_rotary_mul(
+        hidden_states_bsnd,
+        cos.unsqueeze(2),
+        sin.unsqueeze(2),
+    )
+    return output_bsnd.transpose(1, 2)
diff --git a/vllm_omni/platforms/npu/models/cosyvoice2_dit_attn.py b/vllm_omni/platforms/npu/models/cosyvoice2_dit_attn.py
new file mode 100644
index 000000000..7e1d5d540
--- /dev/null
+++ b/vllm_omni/platforms/npu/models/cosyvoice2_dit_attn.py
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""NPU patches for CosyVoice2 / Token2Wav DiT attention.
+
+CosyVoice2's DiT ``Attention.forward`` builds a key-padding style mask
+``(B, 1, 1, S)`` via ``mask.unsqueeze(1)`` and feeds it to
+``F.scaled_dot_product_attention``. On Ascend that call is routed to
+``npu_fusion_attention`` / ``aclnnFlashAttentionScore``, which only accepts
+mask shapes ``[B,N,S,S] / [B,1,S,S] / [1,1,S,S] / [S,S]`` and fails with
+error **161001** (tiling / parameter invalid) for ``[B,1,1,S]``.
+
+This module:
+1. Expands DiT attention masks to ``[B, 1, S, S]`` before SDPA.
+2. Provides a MATH-backend SDPA context so inference can avoid the fused FA
+   kernel entirely when the platform still incorrectly routes SDPA.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager, nullcontext
+
+import torch
+import torch.nn.functional as F
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+_PATCHED = False
+
+
+def _expand_attn_mask_for_npu(
+    attn_mask: torch.Tensor | None,
+    q_len: int,
+    kv_len: int | None = None,
+) -> torch.Tensor | None:
+    """Expand CosyVoice key-padding masks to Ascend FA-compatible shapes."""
+    if attn_mask is None:
+        return None
+    kv_len = kv_len if kv_len is not None else q_len
+
+    # (B, 1, S) key-padding -> (B, S_q, S_kv) then unsqueeze heads below.
+    if attn_mask.dim() == 3 and attn_mask.shape[-2] == 1:
+        attn_mask = attn_mask.expand(-1, q_len, -1)
+    if attn_mask.dim() == 3:
+        # (B, S_q, S_kv) -> (B, 1, S_q, S_kv)
+        attn_mask = attn_mask.unsqueeze(1)
+    if attn_mask.dim() == 4 and attn_mask.shape[-2] == 1 and kv_len > 1:
+        # (B, 1, 1, S) -> (B, 1, S_q, S)
+        attn_mask = attn_mask.expand(-1, -1, q_len, -1)
+    return attn_mask
+
+
+def _patched_attention_forward(self, x: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor:
+    b, t, c = x.shape
+
+    q = self.to_heads(self.to_q(x))
+    k = self.to_heads(self.to_k(x))
+    v = self.to_heads(self.to_v(x))
+
+    q = self.q_norm(q)
+    k = self.k_norm(k)
+
+    attn_mask = _expand_attn_mask_for_npu(attn_mask, q_len=t, kv_len=t)
+    x = F.scaled_dot_product_attention(
+        q,
+        k,
+        v,
+        attn_mask=attn_mask,
+        dropout_p=self.attn_drop.p if self.training else 0.0,
+    )
+    x = x.transpose(1, 2).reshape(b, t, -1)
+    x = self.proj(x)
+    x = self.proj_drop(x)
+    return x
+
+
+def _patched_attention_forward_chunk(
+    self,
+    x: torch.Tensor,
+    att_cache: torch.Tensor | None = None,
+    attn_mask: torch.Tensor | None = None,
+):
+    b, t, c = x.shape
+
+    q = self.to_heads(self.to_q(x))
+    k = self.to_heads(self.to_k(x))
+    v = self.to_heads(self.to_v(x))
+
+    q = self.q_norm(q)
+    k = self.k_norm(k)
+
+    if att_cache is not None:
+        k_cache, v_cache = att_cache.chunk(2, dim=3)
+        k = torch.cat([k, k_cache], dim=2)
+        v = torch.cat([v, v_cache], dim=2)
+
+    new_att_cache = torch.cat([k, v], dim=3)
+    kv_len = k.shape[2]
+    if attn_mask is not None:
+        attn_mask = _expand_attn_mask_for_npu(attn_mask, q_len=t, kv_len=kv_len)
+    x = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask)
+    x = x.transpose(1, 2).reshape(b, t, -1)
+    x = self.proj(x)
+    x = self.proj_drop(x)
+    return x, new_att_cache
+
+
+@contextmanager
+def npu_math_sdpa_context() -> Iterator[None]:
+    """Force SDPA MATH backend so Ascend does not call fused FA."""
+    try:
+        from torch.nn.attention import SDPBackend, sdpa_kernel
+
+        with sdpa_kernel(SDPBackend.MATH):
+            yield
+    except Exception:
+        # Older torch / missing backend enum — just run as-is.
+        with nullcontext():
+            yield
+
+
+def _disable_upsample_encoder_compile() -> None:
+    """Run CosyVoice2 UpsampleConformerEncoderV2 eagerly on Ascend.
+
+    ``forward_chunk`` is decorated with ``@torch.compile(dynamic=True,
+    backend="eager")`` upstream. The backend gives no speedup (still eager),
+    but Dynamo tracing of the relative-position attention with a KV cache
+    creates a symbolic add ``matrix_ac(..., chunk+cache) + matrix_bd(...,
+    (pos//2)+1)`` whose sizes Ascend torch's fake-tensor ``infer_size``
+    cannot reconcile, crashing on the 2nd+ streaming chunk. Unwrapping the
+    compile and disabling Dynamo keeps concrete shapes (always equal).
+    """
+    try:
+        from cosyvoice2.transformer import upsample_encoder_v2
+    except ImportError:
+        return
+
+    enc_cls = getattr(upsample_encoder_v2, "UpsampleConformerEncoderV2", None)
+    if enc_cls is None:
+        return
+
+    fn = enc_cls.forward_chunk
+    orig = getattr(fn, "_torchdynamo_orig_callable", None) or getattr(fn, "__wrapped__", fn)
+    enc_cls.forward_chunk = torch._dynamo.disable(orig)  # type: ignore[method-assign]
+    logger.info("Disabled torch.compile on CosyVoice2 UpsampleConformerEncoderV2.forward_chunk (Ascend eager)")
+
+
+def apply_cosyvoice2_dit_attn_npu_patch() -> None:
+    """Monkey-patch CosyVoice2 DiT Attention for Ascend FA mask constraints."""
+    global _PATCHED
+    if _PATCHED:
+        return
+
+    try:
+        from cosyvoice2.flow import decoder_dit
+    except ImportError:
+        logger.debug("cosyvoice2 not installed; skip DiT attn NPU patch")
+        return
+
+    attn_cls = getattr(decoder_dit, "Attention", None)
+    if attn_cls is None:
+        return
+
+    attn_cls.forward = _patched_attention_forward  # type: ignore[method-assign]
+    attn_cls.forward_chunk = _patched_attention_forward_chunk  # type: ignore[method-assign]
+    _disable_upsample_encoder_compile()
+    _PATCHED = True
+    logger.info("Applied CosyVoice2 DiT Attention NPU patch (expand attn_mask to Bx1xSxS for aclnnFlashAttentionScore)")
diff --git a/vllm_omni/platforms/npu/models/qwen3_tts_tokenizer_v2.py b/vllm_omni/platforms/npu/models/qwen3_tts_tokenizer_v2.py
index f89ecded9..f61b0ab7a 100644
--- a/vllm_omni/platforms/npu/models/qwen3_tts_tokenizer_v2.py
+++ b/vllm_omni/platforms/npu/models/qwen3_tts_tokenizer_v2.py
@@ -9,6 +9,10 @@ import torch
 import torch_npu
 from vllm.logger import init_logger
 
+from vllm_omni.platforms.npu.layers.rotary_embedding import (
+    npu_rotary_mul_with_bsnd_fallback,
+)
+
 logger = init_logger(__name__)
 
 _PATCHED = False
@@ -23,9 +27,10 @@ def _apply_rotary_pos_emb_npu(
     unsqueeze_dim: int = 1,
 ) -> tuple[torch.Tensor, torch.Tensor]:
     del position_ids
-    cos = cos.unsqueeze(unsqueeze_dim)
-    sin = sin.unsqueeze(unsqueeze_dim)
-    return torch_npu.npu_rotary_mul(q, cos, sin), torch_npu.npu_rotary_mul(k, cos, sin)
+    return (
+        npu_rotary_mul_with_bsnd_fallback(q, cos, sin, unsqueeze_dim),
+        npu_rotary_mul_with_bsnd_fallback(k, cos, sin, unsqueeze_dim),
+    )
 
 
 def _rms_norm_forward_npu(self, hidden_states: torch.Tensor) -> torch.Tensor:
diff --git a/vllm_omni/platforms/npu/models/step_audio2_token2wav.py b/vllm_omni/platforms/npu/models/step_audio2_token2wav.py
new file mode 100644
index 000000000..1641fee27
--- /dev/null
+++ b/vllm_omni/platforms/npu/models/step_audio2_token2wav.py
@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""NPU patches for Step-Audio2 / MiniCPM Token2Wav.
+
+Ascend-specific workarounds that must not live in the shared GPU model file:
+
+1. HiFT sine-source downsample — replace the failing 480x ``linear1d``
+   downsample with its exact midpoint form while keeping HiFT on NPU.
+2. CosyVoice2 DiT SDPA — force MATH backend (+ DiT attn mask expand) to
+   avoid fused FA rejecting CosyVoice ``(B,1,1,S)`` masks (error 161001).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager, nullcontext
+from types import MethodType
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+_PATCHED = False
+_original_ensure_models_loaded = None
+_original_forward = None
+_original_stream_chunk_for = None
+
+
+def _linear_downsample_even_scale(x: torch.Tensor, scale: int) -> torch.Tensor:
+    """Match ``F.interpolate(..., mode="linear")`` for an even integer scale.
+
+    With ``align_corners=False``, every output location for an even integer
+    downsample lies exactly halfway between two source samples. Selecting and
+    averaging those samples avoids Ascend/pytorch#150's ``linear1d`` kernel.
+    """
+    if scale <= 0 or scale % 2:
+        raise ValueError(f"scale must be a positive even integer, got {scale}")
+    if x.shape[-1] % scale:
+        raise ValueError(f"input length {x.shape[-1]} must be divisible by scale {scale}")
+
+    left = scale // 2 - 1
+    right = scale // 2
+    return (x[..., left::scale] + x[..., right::scale]) * 0.5
+
+
+def _run_original_f02sine_on_cpu(self, f0_values: torch.Tensor) -> torch.Tensor:
+    """Run the unmodified ``_f02sine`` without invoking NPU ``linear1d``."""
+    output_device = f0_values.device
+    output = self._step_audio2_original_f02sine(f0_values.cpu())
+    return output.to(output_device)
+
+
+def _f02sine_with_npu_safe_downsample(self, f0_values: torch.Tensor) -> torch.Tensor:
+    """Use the exact NPU midpoint path, with a narrow CPU fallback."""
+    if getattr(self, "flag_for_pulse", False):
+        return _run_original_f02sine_on_cpu(self, f0_values)
+
+    upsample_scale = self.upsample_scale
+    if upsample_scale <= 0:
+        raise ValueError(f"upsample_scale must be positive, got {upsample_scale}")
+
+    scale = int(upsample_scale)
+    midpoint_supported = scale == upsample_scale and scale % 2 == 0 and f0_values.shape[1] % scale == 0
+    if not midpoint_supported:
+        return _run_original_f02sine_on_cpu(self, f0_values)
+
+    rad_values = (f0_values / self.sampling_rate) % 1
+    rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], device=f0_values.device)
+    rand_ini[:, 0] = 0
+    rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
+
+    rad_values = _linear_downsample_even_scale(rad_values.transpose(1, 2), scale).transpose(1, 2)
+    phase = torch.cumsum(rad_values, dim=1) * 2 * np.pi
+    phase = F.interpolate(
+        phase.transpose(1, 2) * self.upsample_scale,
+        scale_factor=self.upsample_scale,
+        mode="linear",
+    ).transpose(1, 2)
+    return torch.sin(phase)
+
+
+def patch_step_audio2_hift_for_npu(hift: torch.nn.Module) -> None:
+    """Patch the non-causal Step-Audio2 HiFT implementation for Ascend.
+
+    The ``flashcosyvoice.SineGen2`` instantiated by Step-Audio2 1.0.0 is
+    non-causal and reduces a full-rate phase tensor by ``1 / 480`` before
+    restoring it to the waveform rate. Ascend's ``upsample_linear1d`` kernel
+    can raise an AIVector UB-address exception (ACL 507015) for that reduction.
+
+    The exact midpoint form keeps the common path on NPU. Unsupported or pulse
+    configurations delegate only ``_f02sine`` to CPU, preserving upstream
+    behavior without restoring the old whole-HiFT CPU offload.
+    """
+    if getattr(hift, "_step_audio2_npu_downsample_patched", False):
+        return
+
+    try:
+        sine_gen = hift.m_source.l_sin_gen
+        original_f02sine = sine_gen._f02sine
+    except AttributeError as exc:
+        raise TypeError("expected a Step-Audio2 flashcosyvoice HiFT with m_source.l_sin_gen._f02sine") from exc
+
+    if getattr(sine_gen, "causal", False):
+        raise ValueError("the Step-Audio2 NPU HiFT patch only supports non-causal SineGen2")
+
+    sine_gen._step_audio2_original_f02sine = original_f02sine
+    sine_gen._f02sine = MethodType(_f02sine_with_npu_safe_downsample, sine_gen)
+    hift._step_audio2_npu_downsample_patched = True
+    logger.info("Patched Step-Audio2 HiFT linear downsample for Ascend NPU")
+
+
+@contextmanager
+def npu_token2wav_sdpa_context() -> Iterator[None]:
+    """Expand CosyVoice masks + force MATH SDPA to avoid FA 161001."""
+    try:
+        from vllm_omni.platforms.npu.models.cosyvoice2_dit_attn import (
+            apply_cosyvoice2_dit_attn_npu_patch,
+            npu_math_sdpa_context,
+        )
+
+        apply_cosyvoice2_dit_attn_npu_patch()
+        with npu_math_sdpa_context():
+            yield
+    except Exception:
+        with nullcontext():
+            yield
+
+
+def _patched_ensure_models_loaded(self) -> None:
+    assert _original_ensure_models_loaded is not None
+    was_loaded = self._models_loaded
+    _original_ensure_models_loaded(self)
+    if was_loaded or self.device.type != "npu" or self._hift is None:
+        return
+    patch_step_audio2_hift_for_npu(self._hift)
+
+
+def _patched_forward(self, generated_speech_tokens, prompt_wav, return_bytes=True):
+    assert _original_forward is not None
+    if self.device.type != "npu":
+        return _original_forward(self, generated_speech_tokens, prompt_wav, return_bytes)
+    with npu_token2wav_sdpa_context():
+        return _original_forward(self, generated_speech_tokens, prompt_wav, return_bytes)
+
+
+def _patched_stream_chunk_for(self, audio_tokens, prompt_wav, last_chunk, state):
+    assert _original_stream_chunk_for is not None
+    if self.device.type != "npu":
+        return _original_stream_chunk_for(self, audio_tokens, prompt_wav, last_chunk, state)
+    with npu_token2wav_sdpa_context():
+        return _original_stream_chunk_for(self, audio_tokens, prompt_wav, last_chunk, state)
+
+
+def apply_step_audio2_token2wav_npu_patch() -> None:
+    """Monkey-patch StepAudio2Token2WavCore for Ascend NPU.
+
+    Import is deferred and optional: platform bootstrap (e.g. resolving
+    ``current_omni_platform`` from rotary embedding) must not require
+    Token2Wav optional deps such as ``librosa``.
+    """
+    global _PATCHED, _original_ensure_models_loaded, _original_forward, _original_stream_chunk_for
+    if _PATCHED:
+        return
+
+    try:
+        from vllm_omni.model_executor.models.step_audio2.step_audio2_token2wav import (
+            StepAudio2Token2WavCore,
+        )
+    except ImportError as e:
+        logger.debug("step_audio2 token2wav deps unavailable; skip NPU patch: %s", e)
+        return
+
+    _original_ensure_models_loaded = StepAudio2Token2WavCore._ensure_models_loaded
+    _original_forward = StepAudio2Token2WavCore.forward
+    _original_stream_chunk_for = StepAudio2Token2WavCore.stream_chunk_for
+
+    StepAudio2Token2WavCore._ensure_models_loaded = _patched_ensure_models_loaded  # type: ignore[method-assign]
+    StepAudio2Token2WavCore.forward = _patched_forward  # type: ignore[method-assign]
+    StepAudio2Token2WavCore.stream_chunk_for = _patched_stream_chunk_for  # type: ignore[method-assign]
+
+    _PATCHED = True
+    logger.debug("Applied NPU patch for StepAudio2Token2WavCore")
diff --git a/vllm_omni/platforms/npu/platform.py b/vllm_omni/platforms/npu/platform.py
index fe49455d5..0421814a0 100644
--- a/vllm_omni/platforms/npu/platform.py
+++ b/vllm_omni/platforms/npu/platform.py
@@ -33,6 +33,8 @@ class NPUOmniPlatform(OmniPlatform, NPUPlatform):
 
     # conv2d convolution operator in the code2wav module of Qwen3-TTS not being able to run on Aclnn
     def __init__(self) -> None:
+        from vllm_ascend.utils import adapt_patch
+
         from vllm_omni.platforms.npu._310p import apply_patches as apply_310p_patches
         from vllm_omni.platforms.npu.models.qwen3_tts_code2wav import (
             apply_qwen3_tts_code2wav_patch,
@@ -41,6 +43,7 @@ class NPUOmniPlatform(OmniPlatform, NPUPlatform):
             apply_qwen3_tts_tokenizer_v2_patch,
         )
 
+        adapt_patch(is_global_patch=True)
         apply_qwen3_tts_code2wav_patch()
         apply_qwen3_tts_tokenizer_v2_patch()
         apply_310p_patches()
@@ -74,25 +77,39 @@ class NPUOmniPlatform(OmniPlatform, NPUPlatform):
         init_ascend_config(vllm_config)
 
     @classmethod
-    def get_default_stage_config_path(cls) -> str:
-        return "vllm_omni/platforms/npu/stage_configs"
+    def init_diffusion_model_runner_runtime(cls, vllm_config: Any, od_config: Any, device: torch.device) -> None:
+        from vllm_ascend.ascend_forward_context import set_mc2_mask, set_mc2_tokens_capacity
+
+        set_mc2_tokens_capacity(vllm_config, od_config.max_num_seqs, 1)
+        set_mc2_mask(vllm_config, device)
 
     @classmethod
-    def get_diffusion_model_impl_qualname(cls, op_name: str) -> str:
-        if op_name == "hunyuan_fused_moe":
-            return "vllm_omni.platforms.npu.models.hunyuan_fused_moe.AscendHunyuanFusedMoE"
-        return super().get_diffusion_model_impl_qualname(op_name)
+    def get_default_stage_config_path(cls) -> str:
+        return "vllm_omni/deploy"
 
     @classmethod
     def prepare_diffusion_op_runtime(cls, op_name: str, **kwargs: Any) -> None:
-        if op_name != "hunyuan_fused_moe":
+        if op_name != "fused_moe":
             return
 
-        from vllm_omni.platforms.npu.models.hunyuan_fused_moe import (
-            prepare_hunyuan_fused_moe_runtime,
+        from vllm_omni.platforms.npu.layers.fused_moe import prepare_fused_moe_runtime
+
+        prepare_fused_moe_runtime()
+
+    @classmethod
+    def register_additional_diffusion_fused_moe_hooks(cls, moe_runner: Any) -> None:
+        from vllm_omni.platforms.npu.layers.fused_moe import fused_moe_forward_context_pre_hook
+
+        moe_runner.register_forward_pre_hook(
+            fused_moe_forward_context_pre_hook,
+            with_kwargs=True,
         )
 
-        prepare_hunyuan_fused_moe_runtime()
+    @classmethod
+    def reset_diffusion_fused_moe_forward_context(cls) -> None:
+        from vllm_omni.platforms.npu.layers.fused_moe import reset_fused_moe_forward_context
+
+        reset_fused_moe_forward_context()
 
     @classmethod
     def get_diffusion_packed_modules_mapping(
@@ -106,11 +123,14 @@ class NPUOmniPlatform(OmniPlatform, NPUPlatform):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = True,
     ) -> str:
+        # NPU has no TRTLLM backend; accepted for signature parity, ignored.
         from importlib.util import find_spec
 
         if selected_backend is not None:
             backend_upper = selected_backend.upper()
+            cls.validate_diffusion_attn_backend(backend_upper)
             if backend_upper in ("FLASH_ATTN_HUB", "FLASH_ATTN_3_HUB"):
                 logger.warning(
                     "HuggingFace kernels-backed FlashAttention is "
@@ -156,6 +176,25 @@ class NPUOmniPlatform(OmniPlatform, NPUPlatform):
     def synchronize(cls) -> None:
         torch.npu.synchronize()
 
+    @classmethod
+    def record_device_event(cls) -> torch.Event | None:
+        """Record a NPU event on the default stream to mark tensor readiness.
+
+        On NPU/Ascend with HCCL, distributed communication may use internal
+        streams not visible to the default stream. Synchronize the default
+        stream first so that HCCL results are written back before we record
+        the event, ensuring d2h_stream.wait_event() captures the complete
+        output data.
+        """
+        try:
+            torch.npu.current_stream().synchronize()
+            event = torch.npu.Event()
+            event.record()
+            return event
+        except Exception:
+            logger.warning("Failed to record NPU event for cross-stream sync")
+            return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         free, _ = torch.npu.mem_get_info(device)
diff --git a/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py b/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
index 9a8a55709..0ff7144a9 100644
--- a/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_ar_model_runner.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import logging
 import time
 from collections.abc import Mapping
 from copy import copy, deepcopy
@@ -28,8 +29,8 @@ from vllm.v1.outputs import (
 from vllm.v1.spec_decode.metadata import SpecDecodeMetadata
 from vllm.v1.structured_output.utils import apply_grammar_bitmask
 from vllm.v1.utils import record_function_or_nullcontext
+from vllm.v1.worker import mamba_utils
 from vllm.v1.worker.gpu_model_runner import AsyncGPUModelRunnerOutput, PerLayerAttnMetadata
-from vllm.v1.worker.mamba_utils import preprocess_mamba
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 from vllm_ascend.ascend_forward_context import set_ascend_forward_context
 from vllm_ascend.attention.utils import AscendCommonAttentionMetadata
@@ -43,9 +44,14 @@ from vllm_ascend.worker.model_runner_v1 import graph_capture
 
 from vllm_omni.data_entry_keys import flatten_payload
 from vllm_omni.distributed.omni_connectors.kv_transfer_manager import OmniKVTransferManager
+from vllm_omni.distributed.omni_connectors.utils.config import (
+    get_stage_connector_role,
+    stage_sends_async_output,
+)
 from vllm_omni.outputs import OmniModelRunnerOutput
 from vllm_omni.platforms.npu.worker.npu_model_runner import OmniNPUModelRunner
 from vllm_omni.utils.mm_outputs import build_mm_cpu, partition_payload_list, to_payload_element
+from vllm_omni.worker.omni_connector_model_runner_mixin import OmniConnectorModelRunnerMixin
 from vllm_omni.worker.sampling_utils import sanitize_min_tokens_stop_ids
 
 
@@ -100,7 +106,7 @@ class ExecuteModelState(NamedTuple):
     batch_desc: BatchDescriptor
     multimodal_outputs: Any # Omni-Specific
 
-class NPUARModelRunner(OmniNPUModelRunner):
+class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin):
     """Autoregressive NPU model runner that returns hidden states per request."""
 
     def __init__(self, *args, **kwargs):
@@ -112,7 +118,29 @@ class NPUARModelRunner(OmniNPUModelRunner):
         # Initialize KV cache manager (preserve vllm_config fallback behavior)
         self.kv_transfer_manager = OmniKVTransferManager.from_vllm_config(self.vllm_config, self.model_config)
         self._async_chunk = getattr(self.model_config, "async_chunk", False)
+        #  -------------------------------------- Omni-new -------------------------------------------------
+        _OMNI_CONNECTOR_INIT_ARCHS = {
+            "Qwen3OmniMoeForConditionalGeneration",
+            "Qwen2_5OmniForConditionalGeneration",
+            "CovoAudioForConditionalGeneration",
+            "MiMoAudioModel",
+            "Qwen3TTSTalkerForConditionalGeneration",
+            "Qwen3TTSCode2Wav",
+            "CosyVoice3Model",
+            "DyninOmniForConditionalGeneration",
+            "IndexTTS2TalkerForConditionalGeneration",
+        }
+        stage_archs = set(getattr(self.model_config, "architectures", None) or ())
+        model_arch_override = getattr(self.model_config, "model_arch", None)
+        if model_arch_override:
+            stage_archs.add(model_arch_override)
+        if stage_archs & _OMNI_CONNECTOR_INIT_ARCHS or get_stage_connector_role(self.model_config) is not None:
+            self.init_omni_connectors(
+                model_config=self.model_config,
+                kv_transfer_manager=self.kv_transfer_manager,
+            )
         self._downstream_payload_cache: dict[str, bool] = {}
+        #  -------------------------------------- Omni-new -------------------------------------------------
 
     def _make_buffer(self, *size, dtype, numpy=True):
         # Prevent ray from pinning the buffer due to large size
@@ -191,6 +219,35 @@ class NPUARModelRunner(OmniNPUModelRunner):
         model = getattr(self, "model", None)
         return bool(getattr(model, "requires_full_prefix_cached_hidden_states", True))
 
+    def _deferred_prefix_cache_mm_keys(self) -> set[str]:
+        """Model-declared multimodal keys whose prefix-cache writes are deferred."""
+        model = getattr(self, "model", None)
+        keys = getattr(model, "deferred_prefix_cache_mm_keys", ())
+        return set(keys or ())
+
+    def _stage_deferred_prefix_cache_mm_outputs(
+        self,
+        *,
+        scheduler_output: SchedulerOutput,
+        multimodal_outputs: Any,
+        query_start_loc_cpu: Any,
+    ) -> None:
+        """See gpu_ar_model_runner._stage_deferred_prefix_cache_mm_outputs."""
+        if self.omni_prefix_cache is None:
+            return
+
+        deferred_mm_cache_keys = self._deferred_prefix_cache_mm_keys()
+        if not deferred_mm_cache_keys:
+            return
+
+        self.omni_prefix_cache.stage_deferred_mm_outputs(
+            query_start_loc=query_start_loc_cpu,
+            input_batch=self.input_batch,
+            multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
+            num_scheduled_tokens=scheduler_output.num_scheduled_tokens,
+            deferred_mm_cache_keys=deferred_mm_cache_keys,
+        )
+
     def _maybe_update_prefix_cache(
         self,
         hidden_states: torch.Tensor,
@@ -199,19 +256,16 @@ class NPUARModelRunner(OmniNPUModelRunner):
         num_tokens_padded: int,
     ):
         if self.omni_prefix_cache is not None and get_pp_group().is_last_rank:
-            if multimodal_outputs is not None and not isinstance(multimodal_outputs, Mapping):
-                logger.warning_once(
-                    "prefix caching expects mm outputs to be a dict, but got %s",
-                    type(multimodal_outputs),
-                )
-
             hs_for_cache = hidden_states if self._model_needs_full_prefix_hidden_states() else None
+            slot_mapping_gpu = self.input_batch.block_table[0].slot_mapping.gpu
+            slot_mapping_cpu = slot_mapping_gpu[:num_tokens_padded].cpu()
             self.omni_prefix_cache.update_omni_tensor_prefix_cache(
                 hidden_states=hs_for_cache,
                 multimodal_outputs=flatten_payload(multimodal_outputs) if multimodal_outputs else multimodal_outputs,
                 num_tokens_unpadded=num_tokens_unpadded,
-                slot_mapping=self.input_batch.block_table[0].slot_mapping.cpu,
+                slot_mapping=slot_mapping_cpu,
                 num_tokens_padded=num_tokens_padded,
+                skip_mm_cache_keys=self._deferred_prefix_cache_mm_keys(),
             )
 
     def _maybe_get_combined_prefix_cache_tensors(
@@ -222,6 +276,11 @@ class NPUARModelRunner(OmniNPUModelRunner):
     ) -> tuple[dict[str, torch.Tensor] | None, dict | None]:
         combined_hidden_states, combined_multimodal_outputs = None, None
         if self.omni_prefix_cache is not None:
+            if (
+                not self._model_needs_full_prefix_hidden_states()
+                and not self.omni_prefix_cache.has_prefix_cached_new_req_ids()
+            ):
+                return None, None
             if self._model_needs_full_prefix_hidden_states():
                 combined_hidden_states = self.omni_prefix_cache.get_merged_hidden_states(
                     query_start_loc=self.query_start_loc.cpu,
@@ -340,9 +399,12 @@ class NPUARModelRunner(OmniNPUModelRunner):
             capturer = self.routed_experts_capturer
             if capturer is not None and hasattr(capturer, "finalize_pending_copy"):
                 capturer.finalize_pending_copy()
-        if self.ascend_config.profiling_chunk_config.enabled:
-            self._sync_device()
-            self._execution_start_time = time.perf_counter()
+        if self.ascend_config.scheduler_config.profiling_chunk_config.need_timing:
+            if getattr(scheduler_output, "disable_profiling_timing", False):
+                self.ascend_config.scheduler_config.profiling_chunk_config.need_timing = False
+            else:
+                self._sync_device()
+                self._execution_start_time = time.perf_counter()
         if self.execute_model_state is not None:
             raise RuntimeError("State error: sample_tokens() must be called after execute_model() returns None.")
 
@@ -380,6 +442,21 @@ class NPUARModelRunner(OmniNPUModelRunner):
             request_id_resolver=self._resolve_global_request_id,
         )
         #  -------------------------------------- Omni-new -------------------------------------------------
+        if hasattr(self, "_omni_connector"):
+            for request in getattr(scheduler_output, "pending_input_registrations", []):
+                self.register_chunk_recv(request)
+            self.recv_full_payload_inputs(scheduler_output)
+            if self._pending_full_payload_send:
+                flush_ids = set(getattr(scheduler_output, "finished_req_ids", set()))
+                flush_ids.update({rid for rid in self._pending_full_payload_send if rid not in self.requests})
+                if flush_ids:
+                    self.flush_full_payload_outputs(flush_ids)
+
+        if self.omni_prefix_cache is not None and scheduler_output.finished_req_ids:
+            self.omni_prefix_cache.commit_deferred_mm_outputs(
+                set(scheduler_output.finished_req_ids),
+                self.input_batch,
+            )
         # self._draft_token_ids is None when `input_fits_in_drafter=False`
         # and there is no draft tokens scheduled. so it need to update the
         # spec_decoding info in scheduler_output with async_scheduling.
@@ -387,20 +464,11 @@ class NPUARModelRunner(OmniNPUModelRunner):
         # scheduler_output in engine core process.
         # TODO(Ronald1995): deepcopy is expensive when there is a large
         # number of requests, optimize it later.
-        if ((
+        if (
             self.use_async_scheduling
             and self.num_spec_tokens
             and self._draft_token_ids is None  # type: ignore[has-type]
-        ) or (
-            # NOTE: This branch specifically triggers a deepcopy during the prefill phase
-            # only for PCP (Parallel Context Processing) + Multi-Modal (MM) scenarios.
-            # It does not affect other use cases. This is a temporary workaround and
-            # will be removed once upstream vLLM provides native support for PCP + MM.
-            self.pcp_size > 1
-            and self.supports_mm_inputs
-            and get_pp_group().is_first_rank
-            and not self.model_config.is_encoder_decoder
-        )):
+        ):
             scheduler_output = deepcopy(scheduler_output)
 
         #  -------------------------------------- Omni-new -------------------------------------------------
@@ -422,6 +490,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 #  -------------------------------------- Omni-new -------------------------------------------------
 
                 if has_ec_transfer() and get_ec_transfer().is_producer:
+                    self._start_dump_data()
                     with self.maybe_get_ec_connector_output(
                         scheduler_output,
                         encoder_cache=self.encoder_cache,
@@ -431,13 +500,15 @@ class NPUARModelRunner(OmniNPUModelRunner):
                         kv_ids = self.kv_extracted_req_ids
                         self.kv_extracted_req_ids = None
 
+                        self._finalize_dump_data()
                         output = make_empty_encoder_model_runner_output(scheduler_output)
                         if kv_ids:
                             output = copy(output)
                             output.kv_extracted_req_ids = kv_ids
-                        return output
+                        return self.attach_omni_connector_output(output)
 
-                if not num_scheduled_tokens:
+                # `<= 0`: upstream can schedule a negative span, which is truthy (#5196).
+                if num_scheduled_tokens <= 0:
                     if (
                         self.parallel_config.distributed_executor_backend == "external_launcher"
                         and self.parallel_config.data_parallel_size > 1
@@ -462,7 +533,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                         output = copy(output)
                         output.kv_extracted_req_ids = kv_ids
 
-                    return output
+                    return self.attach_omni_connector_output(output)
                 if self.cache_config.kv_sharing_fast_prefill:
                     assert not self.num_prompt_logprobs, (
                         "--kv-sharing-fast-prefill produces incorrect "
@@ -470,6 +541,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                         "it when the requests need prompt logprobs"
                     )
 
+                self._start_dump_data()
                 num_reqs = self.input_batch.num_reqs
                 req_ids = self.input_batch.req_ids
                 tokens = [scheduler_output.num_scheduled_tokens[i] for i in req_ids]
@@ -486,8 +558,6 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 )
 
                 num_tokens_unpadded = scheduler_output.total_num_scheduled_tokens
-                if self.pcp_size > 1:
-                    num_tokens_unpadded = self.pcp_manager.total_num_sampled_tokens_pcp
                 cascade_attn_prefix_lens = None
                 # Disable cascade attention when using microbatching (DBO)
                 if self.cascade_attn_enabled and not self.parallel_config.enable_dbo:
@@ -514,14 +584,15 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     num_encoder_reqs=len(scheduler_output.scheduled_encoder_inputs),
                 )
 
-                logger.debug(
-                    "Running batch with cudagraph_mode: %s, batch_descriptor: %s, "
-                    "should_ubatch: %s, num_tokens_across_dp: %s",
-                    cudagraph_mode,
-                    batch_desc,
-                    should_ubatch,
-                    num_tokens_across_dp,
-                )
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(
+                        "Running batch with cudagraph_mode: %s, batch_descriptor: %s, "
+                        "should_ubatch: %s, num_tokens_across_dp: %s",
+                        cudagraph_mode,
+                        batch_desc,
+                        should_ubatch,
+                        num_tokens_across_dp,
+                    )
 
                 num_tokens_padded = batch_desc.num_tokens
                 num_reqs_padded = batch_desc.num_reqs if batch_desc.num_reqs is not None else num_reqs
@@ -533,6 +604,9 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     self.parallel_config.num_ubatches,
                 )
 
+                if self.dynamic_eplb:
+                    self.update_eplb_heat_collection_status(num_tokens_padded)
+
                 pad_attn = cudagraph_mode == CUDAGraphMode.FULL
 
                 # NOTE(Angazenn): According to https://github.com/vllm-project/vllm/pull/30877,
@@ -546,7 +620,9 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     if deferred_state_corrections_fn:
                         deferred_state_corrections_fn()
                         deferred_state_corrections_fn = None
-                    preprocess_mamba(
+                    mamba_bufs = self._get_mamba_bufs()
+                    preprocess_bufs = mamba_bufs.preprocess
+                    mamba_utils.preprocess_mamba(
                         scheduler_output,
                         self.kv_cache_config,
                         self.cache_config,
@@ -555,7 +631,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                         self.requests,
                         self.compilation_config.static_forward_context,
                         self.model.get_mamba_state_copy_func(),
-                        self._get_mamba_copy_bufs(),
+                        preprocess_bufs,
                     )
                     # preprocess_mamba resets num_accepted_tokens_cpu to 1
                     # for requests whose state was copied to a new block.
@@ -564,13 +640,23 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     self.num_accepted_tokens.np[:num_reqs] = self.input_batch.num_accepted_tokens_cpu[:num_reqs]
                     self.num_accepted_tokens.copy_to_gpu(num_reqs)
 
+                    if mamba_bufs.postprocess_align is not None:
+                        mamba_utils.stage_postprocess_inputs_to_gpu(
+                            mamba_bufs.postprocess_align,
+                            scheduler_output,
+                            self.input_batch.req_ids,
+                            num_reqs,
+                            self.requests,
+                            self.mamba_state_idx,
+                        )
+
                 use_spec_decode = len(scheduler_output.scheduled_spec_decode_tokens) > 0
                 ubatch_slices_attn = ubatch_slices_padded if pad_attn else ubatch_slices
 
                 if (
                     cudagraph_mode == CUDAGraphMode.FULL
                     or (enable_sp() and not self.model_config.use_mla)
-                    and self.pcp_size * self.dcp_size == 1
+                    and self.dcp_size == 1
                 ):
                     # Currently, Graph Mode and SP will both pad num_tokens,
                     # Another possible condition is num_tokens_padded != num_tokens_unpadded
@@ -585,9 +671,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     )
 
                 (attn_metadata, spec_decode_common_attn_metadata) = self._build_attention_metadata(
-                    num_tokens=num_tokens_unpadded
-                    if not (self.use_cp and self.pcp_manager.pcp_use_hybrid_attn)
-                    else total_num_scheduled_tokens,
+                    num_tokens=num_tokens_unpadded,
                     num_tokens_padded=num_tokens_padded,
                     num_reqs=num_reqs,
                     num_reqs_padded=num_reqs_padded,
@@ -609,9 +693,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 ec_connector_output,
             ) = self._preprocess(
                 scheduler_output,
-                num_tokens_padded
-                if not (self.use_cp and self.pcp_manager.pcp_use_hybrid_attn)
-                else total_num_scheduled_tokens,
+                num_tokens_padded,
                 intermediate_tensors,
             )
 
@@ -642,21 +724,6 @@ class NPUARModelRunner(OmniNPUModelRunner):
             cudagraph_mode = CUDAGraphMode.NONE
             # Mark KV scales as calculated after the first forward pass
             self.calculate_kv_scales = False  # type: ignore[has-type]
-        # prevent debugger is None
-        if self.debugger is not None:
-            dbg_cfg = getattr(self.debugger, "config", None)
-            dump_level = str(getattr(dbg_cfg, "level", "L1")).upper() if dbg_cfg is not None else "L1"
-            if dump_level in ("L0", "MIX"):
-                self.debugger.start(model=self.model)
-            else:
-                self.debugger.start()
-        if self.ascend_config.enable_async_exponential:
-            self.sampler.do_async_exponential(
-                b_s=logits_indices.shape[0],
-                head_dim=self.model_config.get_vocab_size(),
-                generators=self.input_batch.sampling_metadata.generators,
-            )
-
         # Encoder-decoder models can only compile the pure decode steps where no
         # encoder inputs are present. Use eager for the first pass.
         num_encoder_reqs = len(scheduler_output.scheduled_encoder_inputs)
@@ -675,8 +742,10 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 batch_descriptor=batch_desc,
                 num_actual_tokens=scheduler_output.total_num_scheduled_tokens,
                 model_instance=self.model,
-                max_tokens_across_pcp=0 if self.pcp_size == 1 else self.pcp_manager.max_num_tokens_across_pcp,
                 skip_compiled=has_encoder_input,
+                has_sinks=self._has_sinks,
+                input_ids=input_ids,
+                eplb_heat_collection_status=self.eplb_heat_collection_status if self.dynamic_eplb else False,
             ),
             self.maybe_get_kv_connector_output(
                 scheduler_output,
@@ -685,6 +754,8 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 ),
             ) as kv_connector_output,
         ):
+            if self.cache_config.mamba_cache_mode == "align":
+                mamba_utils.do_mamba_copy_block(preprocess_bufs)
             hidden_states = self._model_forward(
                 num_tokens_padded, input_ids, positions, intermediate_tensors, inputs_embeds, **model_kwargs
             )
@@ -710,15 +781,6 @@ class NPUARModelRunner(OmniNPUModelRunner):
             aux_hidden_states = None
             if self.use_aux_hidden_state_outputs:
                 hidden_states, aux_hidden_states = hidden_states
-            if self.pcp_size > 1:
-                # NOTE we must `slice` hidden_states because pcp_allgather_restore_idx
-                # ignores the padding from CUDA Graph.
-                hidden_states = self.pcp_manager.get_restore_hidden_states(hidden_states)
-                if aux_hidden_states is not None:
-                    aux_hidden_states = [
-                        self.pcp_manager.get_restore_hidden_states(aux_hidden_states_pcp)
-                        for aux_hidden_states_pcp in aux_hidden_states
-                    ]
 
             #  -------------------------------------- Omni-new -------------------------------------------------
             self._maybe_update_prefix_cache(
@@ -736,9 +798,9 @@ class NPUARModelRunner(OmniNPUModelRunner):
                     assert isinstance(hidden_states, IntermediateTensors)
                     hidden_states.kv_connector_output = kv_connector_output
                     self.kv_connector_output = kv_connector_output
-                    if self.debugger is not None:
-                        self.debugger.stop()
-                        self.debugger.step()
+                    self._finalize_dump_data()
+                    if self.dynamic_eplb:
+                        self.eplb_updator.forward_end(self.eplb_heat_collection_status)
                     return hidden_states
                 if self.is_pooling_model:
                     # Return the pooling output.
@@ -746,9 +808,7 @@ class NPUARModelRunner(OmniNPUModelRunner):
                         hidden_states, num_scheduled_tokens, num_scheduled_tokens_np, kv_connector_output
                     )
                     output.kv_connector_output = kv_connector_output
-                    if self.debugger is not None:
-                        self.debugger.stop()
-                        self.debugger.step()
+                    self._finalize_dump_data()
                     return output
 
                 sample_hidden_states = hidden_states[logits_indices]
@@ -857,6 +917,8 @@ class NPUARModelRunner(OmniNPUModelRunner):
     ) -> OmniModelRunnerOutput | AsyncModelRunnerOutput | IntermediateTensors:
         kv_connector_output = self.kv_connector_output
         self.kv_connector_output = None
+        pp = get_pp_group()
+        use_pp_spec_decode = self.speculative_config is not None and pp.world_size > 1
 
         #  -------------------------------------- Omni-new -------------------------------------------------
         kv_extracted_req_ids = getattr(self, "kv_extracted_req_ids", None)
@@ -869,21 +931,16 @@ class NPUARModelRunner(OmniNPUModelRunner):
 
         if self.execute_model_state is None:
             # Nothing to do (PP non-final rank case), output isn't used.
-            # receive sampled token ids from the last PP rank when using
-            # async scheduling + pipeline parallelism so downstream code
-            # (e.g., PCP input preparation) can access them.
-            if self.use_async_scheduling and get_pp_group().world_size > 1:
-                self._pp_receive_prev_sampled_token_ids_to_input_batch()
             if not kv_connector_output:
                 return None  # noqa
             # In case of PP with kv transfer, we need to pass through the
             # kv_connector_output
             if kv_connector_output.is_empty():
-                return EMPTY_MODEL_RUNNER_OUTPUT
+                return self.attach_omni_connector_output(EMPTY_MODEL_RUNNER_OUTPUT)
 
             output = copy(EMPTY_MODEL_RUNNER_OUTPUT)
             output.kv_connector_output = kv_connector_output
-            return output
+            return self.attach_omni_connector_output(output)
 
         # Unpack ephemeral state.
         (
@@ -964,6 +1021,23 @@ class NPUARModelRunner(OmniNPUModelRunner):
             )
             self._copy_draft_token_ids_to_cpu(scheduler_output)
 
+        output_spec_token_ids = None
+        use_padded_batch = False
+        early_pp_padded_drafter = False
+        if self.speculative_config:
+            use_padded_batch = (
+                self.speculative_config.use_eagle()
+                or self.speculative_config.uses_draft_model()
+                or self.speculative_config.uses_extract_hidden_states()
+                or self.speculative_config.use_ngram_gpu()
+            ) and not self.speculative_config.disable_padded_drafter_batch
+            early_pp_padded_drafter = use_pp_spec_decode and not self.use_async_scheduling and use_padded_batch
+            if early_pp_padded_drafter:
+                self._draft_token_ids = None
+                self._draft_token_req_ids = None
+                with record_function_or_nullcontext("draft_token"):
+                    propose_draft_token_ids(sampler_output.sampled_token_ids)
+
         (
             logprobs_lists,
             valid_sampled_token_ids,
@@ -982,16 +1056,14 @@ class NPUARModelRunner(OmniNPUModelRunner):
 
         with record_function_or_nullcontext("draft_token"):
             if self.speculative_config:
-                use_padded_batch = (
-                    self.speculative_config
-                    and (self.speculative_config.use_eagle() or self.speculative_config.uses_draft_model())
-                    and not self.speculative_config.disable_padded_drafter_batch
-                )
-                if use_padded_batch:
+                if not early_pp_padded_drafter:
+                    self._draft_token_ids = None
+                    self._draft_token_req_ids = None
+                if use_padded_batch and not early_pp_padded_drafter:
                     # EAGLE speculative decoding can use the GPU sampled tokens
                     # as inputs, and does not need to wait for bookkeeping to finish.
                     propose_draft_token_ids(sampler_output.sampled_token_ids)
-                if self.speculative_config and not use_padded_batch:
+                if not use_padded_batch:
                     # ngram and other speculative decoding methods use the sampled
                     # tokens on the CPU, so they are run after bookkeeping.
                     propose_draft_token_ids(valid_sampled_token_ids)
@@ -1002,6 +1074,19 @@ class NPUARModelRunner(OmniNPUModelRunner):
             if self.speculative_config is not None:
                 self.finalize_kv_connector()
 
+            draft_token_ids = self._draft_token_ids if use_pp_spec_decode else None
+            if draft_token_ids is not None:
+                if isinstance(draft_token_ids, torch.Tensor):
+                    num_draft_reqs = draft_token_ids.shape[0]
+                    draft_ids_list = draft_token_ids[:num_draft_reqs].cpu().tolist()
+                    draft_req_ids = self._draft_token_req_ids
+                else:
+                    draft_ids_list = draft_token_ids
+                    draft_req_ids = self.input_batch.req_ids
+                if draft_ids_list and draft_req_ids:
+                    draft_by_req_id = dict(zip(draft_req_ids, draft_ids_list))
+                    output_spec_token_ids = [draft_by_req_id.get(req_id, []) for req_id in req_ids_output_copy]
+
         routed_experts_lists = None
         if self.model_config.enable_return_routed_experts:
             capturer = self.routed_experts_capturer
@@ -1045,6 +1130,12 @@ class NPUARModelRunner(OmniNPUModelRunner):
         if callable(query_start_loc_cpu):
             query_start_loc_cpu = query_start_loc_cpu()
 
+        self._stage_deferred_prefix_cache_mm_outputs(
+            scheduler_output=scheduler_output,
+            multimodal_outputs=multimodal_outputs,
+            query_start_loc_cpu=query_start_loc_cpu,
+        )
+
         pooler_output: list[dict[str, object]] | None = None
         if needs_pooler_payload:
             combined_hidden_states = None
@@ -1159,15 +1250,26 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 pooler_output.append(flatten_payload(payload))
 
         pooler_output = pooler_output or []
-        if self._async_chunk:
+        if self._async_chunk and stage_sends_async_output(self.model_config):
             pooler_inter, pooler_client = partition_payload_list(pooler_output)
         else:
             # Non-async-chunk ships the full payload to the next stage via
             # inter_stage_outputs (the NPU runner has no separate full-payload
             # accumulate). #4527's (None, pooler_output) starved it. (PR #4792)
             pooler_inter, pooler_client = pooler_output, pooler_output
+
+        # [Omni] Full-payload send-side accumulation. Mirrors gpu_ar_model_runner.py.
+        if pooler_inter and self._should_accumulate_full_payload_output():
+            with record_function_or_nullcontext("omni_output_builder:accumulate_full_payload_output"):
+                for i, rid in enumerate(req_ids_output_copy):
+                    req_state = self.requests.get(rid)
+                    if req_state is not None and pooler_inter[i]:
+                        self.accumulate_full_payload_output(rid, pooler_inter[i], req_state)
+
         inter_stage_outputs = self._build_multimodal_outputs(pooler_inter)
-        multimodal_outputs = self._build_multimodal_outputs(pooler_client)
+        multimodal_outputs = (
+            inter_stage_outputs if pooler_client is pooler_inter else self._build_multimodal_outputs(pooler_client)
+        )
         model_runner_output = OmniModelRunnerOutput(
             req_ids=req_ids_output_copy,
             req_id_to_index=req_id_to_index_output_copy,
@@ -1183,19 +1285,22 @@ class NPUARModelRunner(OmniNPUModelRunner):
         )
         model_runner_output.kv_extracted_req_ids = kv_extracted_req_ids
         model_runner_output.routed_experts = routed_experts_lists
+        model_runner_output.spec_token_ids = output_spec_token_ids
+        with record_function_or_nullcontext("omni_output_builder:get_omni_connector_output"):
+            model_runner_output.omni_connector_output = self.get_omni_connector_output()
         #  -------------------------------------- Omni-new -------------------------------------------------
 
-        if self.ascend_config.profiling_chunk_config.enabled and hasattr(self, "_execution_start_time"):
+        if self.ascend_config.scheduler_config.profiling_chunk_config.need_timing and hasattr(
+            self, "_execution_start_time"
+        ):
             self._sync_device()
             model_runner_output.execution_time_ms = (time.perf_counter() - self._execution_start_time) * 1000.0
 
         if self.dynamic_eplb:
             with record_function_or_nullcontext("EPLB update"):
-                self.eplb_updator.forward_end()
+                self.eplb_updator.forward_end(self.eplb_heat_collection_status)
 
-        if self.debugger is not None:
-            self.debugger.stop()
-            self.debugger.step()
+        self._finalize_dump_data()
 
         if self.need_accepted_tokens:
             assert self.sampling_done_event is not None
@@ -1206,14 +1311,6 @@ class NPUARModelRunner(OmniNPUModelRunner):
                 global_stream().wait_event(self.sampling_done_event)
                 self._update_states_after_model_execute(sampler_output.sampled_token_ids, scheduler_output)
 
-        # In async scheduling + PP, broadcast sampled token ids from the
-        # last PP rank so other PP ranks can receive them without going
-        # through the scheduler/engine IPC path.
-        if self.use_async_scheduling:
-            pp = get_pp_group()
-            if pp.world_size > 1 and pp.is_last_rank:
-                self._pp_broadcast_prev_sampled_token_ids(sampler_output.sampled_token_ids)
-
         if not self.use_async_scheduling:
             return model_runner_output
         async_output = AsyncGPUModelRunnerOutput(
diff --git a/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py b/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
index ea03842b4..24fa21524 100644
--- a/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import gc
+import logging
 import time
 from collections.abc import Mapping
 from copy import copy, deepcopy
@@ -21,8 +22,8 @@ from vllm.utils.math_utils import cdiv
 from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput
 from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT, AsyncModelRunnerOutput, make_empty_encoder_model_runner_output
 from vllm.v1.utils import record_function_or_nullcontext
+from vllm.v1.worker import mamba_utils
 from vllm.v1.worker.gpu_model_runner import AsyncGPUModelRunnerOutput, PerLayerAttnMetadata
-from vllm.v1.worker.mamba_utils import preprocess_mamba
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 from vllm.v1.worker.utils import sanity_check_mm_encoder_outputs
 from vllm_ascend.ascend_forward_context import set_ascend_forward_context
@@ -32,18 +33,45 @@ from vllm_ascend.ops.rotary_embedding import update_cos_sin
 from vllm_ascend.utils import enable_sp, lmhead_tp_enable
 from vllm_ascend.worker.model_runner_v1 import SEQ_LEN_WITH_MAX_PA_WORKSPACE
 
+from vllm_omni.distributed.omni_connectors.utils.config import get_stage_connector_role
 from vllm_omni.outputs import OmniModelRunnerOutput
 from vllm_omni.platforms.npu.worker.npu_ar_model_runner import ExecuteModelState, _ensure_tensor_values
 from vllm_omni.platforms.npu.worker.npu_model_runner import OmniNPUModelRunner
 from vllm_omni.utils.mm_outputs import partition_payload_list
+from vllm_omni.worker.omni_connector_model_runner_mixin import OmniConnectorModelRunnerMixin
 
 
-class NPUGenerationModelRunner(OmniNPUModelRunner):
+class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin):
     """Generation model runner for vLLM-omni on NPU (non-autoregressive)."""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._async_chunk = getattr(self.model_config, "async_chunk", False)
+        #  -------------------------------------- Omni-new -------------------------------------------------
+        # Mirrors the init allowlist in gpu_generation_model_runner.py. The
+        # connector-role fallback keeps consumer stages whose arch is not on the
+        # allowlist (e.g. MiniCPM-o 4.5 stage 2) from starving on input.
+        _OMNI_CONNECTOR_INIT_ARCHS = {
+            "Qwen3OmniMoeForConditionalGeneration",
+            "Qwen2_5OmniForConditionalGeneration",
+            "CovoAudioForConditionalGeneration",
+            "MiMoAudioModel",
+            "Qwen3TTSTalkerForConditionalGeneration",
+            "Qwen3TTSCode2Wav",
+            "AudexCode2Wav",
+            "AudexXCodec1",
+            "CosyVoice3Model",
+            "DyninOmniForConditionalGeneration",
+            "IndexTTS2S2MelDecoder",
+        }
+        if (
+            getattr(self.model_config, "model_arch", None) in _OMNI_CONNECTOR_INIT_ARCHS
+            or get_stage_connector_role(self.model_config) is not None
+        ):
+            self.init_omni_connectors(
+                model_config=self.model_config,
+            )
+        #  -------------------------------------- Omni-new -------------------------------------------------
 
     def _update_request_states(self, scheduler_output: SchedulerOutput):
         # remove requests
@@ -82,9 +110,12 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             capturer = self.routed_experts_capturer
             if capturer is not None and hasattr(capturer, "finalize_pending_copy"):
                 capturer.finalize_pending_copy()
-        if self.ascend_config.profiling_chunk_config.enabled:
-            self._sync_device()
-            self._execution_start_time = time.perf_counter()
+        if self.ascend_config.scheduler_config.profiling_chunk_config.need_timing:
+            if getattr(scheduler_output, "disable_profiling_timing", False):
+                self.ascend_config.scheduler_config.profiling_chunk_config.need_timing = False
+            else:
+                self._sync_device()
+                self._execution_start_time = time.perf_counter()
         if self.execute_model_state is not None:
             raise RuntimeError("State error: sample_tokens() must be called after execute_model() returns None.")
         # self._draft_token_ids is None when `input_fits_in_drafter=False`
@@ -96,15 +127,6 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
         # number of requests, optimize it later.
         if (
             self.use_async_scheduling and self.num_spec_tokens and self._draft_token_ids is None  # type: ignore[has-type]
-        ) or (
-            # NOTE: This branch specifically triggers a deepcopy during the prefill phase
-            # only for PCP (Parallel Context Processing) + Multi-Modal (MM) scenarios.
-            # It does not affect other use cases. This is a temporary workaround and
-            # will be removed once upstream vLLM provides native support for PCP + MM.
-            self.pcp_size > 1
-            and self.supports_mm_inputs
-            and get_pp_group().is_first_rank
-            and not self.model_config.is_encoder_decoder
         ):
             scheduler_output = deepcopy(scheduler_output)
 
@@ -113,6 +135,16 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             if kv_connector_metadata is not None:
                 get_kv_transfer_group().handle_preemptions(kv_connector_metadata)
 
+        if hasattr(self, "_omni_connector"):
+            for request in getattr(scheduler_output, "pending_input_registrations", []):
+                self.register_chunk_recv(request)
+            self.recv_full_payload_inputs(scheduler_output)
+            if self._pending_full_payload_send:
+                flush_ids = set(getattr(scheduler_output, "finished_req_ids", set()))
+                flush_ids.update({rid for rid in self._pending_full_payload_send if rid not in self.requests})
+                if flush_ids:
+                    self.flush_full_payload_outputs(flush_ids)
+
         num_scheduled_tokens = scheduler_output.total_num_scheduled_tokens
         with record_function_or_nullcontext("prepare input"):
             #  -------------------------------------- Omni-new -------------------------------------------------
@@ -123,15 +155,25 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                 # Update persistent batch states.
                 deferred_state_corrections_fn = self._update_states(scheduler_output)
 
+                #  -------------------------------------- Omni-new -------------------------------------------------
+                if scheduler_output.finished_req_ids and hasattr(self.model, "on_requests_finished"):
+                    self.model.on_requests_finished(scheduler_output.finished_req_ids)
+                #  -------------------------------------- Omni-new -------------------------------------------------
+
                 if has_ec_transfer() and get_ec_transfer().is_producer:
+                    self._start_dump_data()
                     with self.maybe_get_ec_connector_output(
                         scheduler_output,
                         encoder_cache=self.encoder_cache,
                     ) as ec_connector_output:
                         self._execute_mm_encoder(scheduler_output)
-                        return make_empty_encoder_model_runner_output(scheduler_output)
+                        self._finalize_dump_data()
+                        return self.attach_omni_connector_output(
+                            make_empty_encoder_model_runner_output(scheduler_output)
+                        )
 
-                if not num_scheduled_tokens:
+                # `<= 0`: upstream can schedule a negative span, which is truthy (#5196).
+                if num_scheduled_tokens <= 0:
                     if (
                         self.parallel_config.distributed_executor_backend == "external_launcher"
                         and self.parallel_config.data_parallel_size > 1
@@ -145,8 +187,10 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                         self._dummy_run(1)
                     if not has_kv_transfer_group():
                         # Return empty ModelRunnerOutput if no work to do.
-                        return EMPTY_MODEL_RUNNER_OUTPUT
-                    return self.kv_connector_no_forward(scheduler_output, self.vllm_config)
+                        return self.attach_omni_connector_output(EMPTY_MODEL_RUNNER_OUTPUT)
+                    return self.attach_omni_connector_output(
+                        self.kv_connector_no_forward(scheduler_output, self.vllm_config)
+                    )
                 if self.cache_config.kv_sharing_fast_prefill:
                     assert not self.num_prompt_logprobs, (
                         "--kv-sharing-fast-prefill produces incorrect "
@@ -154,6 +198,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                         "it when the requests need prompt logprobs"
                     )
 
+                self._start_dump_data()
                 num_reqs = self.input_batch.num_reqs
                 req_ids = self.input_batch.req_ids
                 tokens = [scheduler_output.num_scheduled_tokens[i] for i in req_ids]
@@ -170,8 +215,6 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                 )
 
                 num_tokens_unpadded = scheduler_output.total_num_scheduled_tokens
-                if self.pcp_size > 1:
-                    num_tokens_unpadded = self.pcp_manager.total_num_sampled_tokens_pcp
                 cascade_attn_prefix_lens = None
                 # Disable cascade attention when using microbatching (DBO)
                 if self.cascade_attn_enabled and not self.parallel_config.enable_dbo:
@@ -198,14 +241,15 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     num_encoder_reqs=len(scheduler_output.scheduled_encoder_inputs),
                 )
 
-                logger.debug(
-                    "Running batch with cudagraph_mode: %s, batch_descriptor: %s, "
-                    "should_ubatch: %s, num_tokens_across_dp: %s",
-                    cudagraph_mode,
-                    batch_desc,
-                    should_ubatch,
-                    num_tokens_across_dp,
-                )
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(
+                        "Running batch with cudagraph_mode: %s, batch_descriptor: %s, "
+                        "should_ubatch: %s, num_tokens_across_dp: %s",
+                        cudagraph_mode,
+                        batch_desc,
+                        should_ubatch,
+                        num_tokens_across_dp,
+                    )
 
                 num_tokens_padded = batch_desc.num_tokens
                 num_reqs_padded = batch_desc.num_reqs if batch_desc.num_reqs is not None else num_reqs
@@ -217,6 +261,9 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     self.parallel_config.num_ubatches,
                 )
 
+                if self.dynamic_eplb:
+                    self.update_eplb_heat_collection_status(num_tokens_padded)
+
                 pad_attn = cudagraph_mode == CUDAGraphMode.FULL
 
                 # NOTE(Angazenn): According to https://github.com/vllm-project/vllm/pull/30877,
@@ -230,7 +277,9 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     if deferred_state_corrections_fn:
                         deferred_state_corrections_fn()
                         deferred_state_corrections_fn = None
-                    preprocess_mamba(
+                    mamba_bufs = self._get_mamba_bufs()
+                    preprocess_bufs = mamba_bufs.preprocess
+                    mamba_utils.preprocess_mamba(
                         scheduler_output,
                         self.kv_cache_config,
                         self.cache_config,
@@ -239,7 +288,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                         self.requests,
                         self.compilation_config.static_forward_context,
                         self.model.get_mamba_state_copy_func(),
-                        self._get_mamba_copy_bufs(),
+                        preprocess_bufs,
                     )
                     # preprocess_mamba resets num_accepted_tokens_cpu to 1
                     # for requests whose state was copied to a new block.
@@ -248,13 +297,23 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     self.num_accepted_tokens.np[:num_reqs] = self.input_batch.num_accepted_tokens_cpu[:num_reqs]
                     self.num_accepted_tokens.copy_to_gpu(num_reqs)
 
+                    if mamba_bufs.postprocess_align is not None:
+                        mamba_utils.stage_postprocess_inputs_to_gpu(
+                            mamba_bufs.postprocess_align,
+                            scheduler_output,
+                            self.input_batch.req_ids,
+                            num_reqs,
+                            self.requests,
+                            self.mamba_state_idx,
+                        )
+
                 use_spec_decode = len(scheduler_output.scheduled_spec_decode_tokens) > 0
                 ubatch_slices_attn = ubatch_slices_padded if pad_attn else ubatch_slices
 
                 if (
                     cudagraph_mode == CUDAGraphMode.FULL
                     or (enable_sp() and not self.model_config.use_mla)
-                    and self.pcp_size * self.dcp_size == 1
+                    and self.dcp_size == 1
                 ):
                     # Currently, Graph Mode and SP will both pad num_tokens,
                     # Another possible condition is num_tokens_padded != num_tokens_unpadded
@@ -269,9 +328,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     )
 
                 (attn_metadata, spec_decode_common_attn_metadata) = self._build_attention_metadata(
-                    num_tokens=num_tokens_unpadded
-                    if not (self.use_cp and self.pcp_manager.pcp_use_hybrid_attn)
-                    else total_num_scheduled_tokens,
+                    num_tokens=num_tokens_unpadded,
                     num_tokens_padded=num_tokens_padded,
                     num_reqs=num_reqs,
                     num_reqs_padded=num_reqs_padded,
@@ -293,14 +350,16 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                 ec_connector_output,
             ) = self._preprocess(
                 scheduler_output,
-                num_tokens_padded
-                if not (self.use_cp and self.pcp_manager.pcp_use_hybrid_attn)
-                else total_num_scheduled_tokens,
+                num_tokens_padded,
                 intermediate_tensors,
             )
 
+            #  -------------------------------------- Omni-new -------------------------------------------------
             # [Omni] Pass token counts per request for code2wav output slicing
             model_kwargs["seq_token_counts"] = tokens
+            if getattr(self.model, "requires_request_ids", False):
+                model_kwargs["request_ids"] = list(req_ids)
+            #  -------------------------------------- Omni-new -------------------------------------------------
 
             # update global cos, sin
             update_cos_sin(positions)
@@ -316,21 +375,6 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             cudagraph_mode = CUDAGraphMode.NONE
             # Mark KV scales as calculated after the first forward pass
             self.calculate_kv_scales = False  # type: ignore[has-type]
-        # prevent debugger is None
-        if self.debugger is not None:
-            dbg_cfg = getattr(self.debugger, "config", None)
-            dump_level = str(getattr(dbg_cfg, "level", "L1")).upper() if dbg_cfg is not None else "L1"
-            if dump_level in ("L0", "MIX"):
-                self.debugger.start(model=self.model)
-            else:
-                self.debugger.start()
-        if self.ascend_config.enable_async_exponential:
-            self.sampler.do_async_exponential(
-                b_s=logits_indices.shape[0],
-                head_dim=self.model_config.get_vocab_size(),
-                generators=self.input_batch.sampling_metadata.generators,
-            )
-
         # Encoder-decoder models can only compile the pure decode steps where no
         # encoder inputs are present. Use eager for the first pass.
         num_encoder_reqs = len(scheduler_output.scheduled_encoder_inputs)
@@ -349,14 +393,18 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                 batch_descriptor=batch_desc,
                 num_actual_tokens=scheduler_output.total_num_scheduled_tokens,
                 model_instance=self.model,
-                max_tokens_across_pcp=0 if self.pcp_size == 1 else self.pcp_manager.max_num_tokens_across_pcp,
                 skip_compiled=has_encoder_input,
+                has_sinks=self._has_sinks,
+                input_ids=input_ids,
+                eplb_heat_collection_status=self.eplb_heat_collection_status if self.dynamic_eplb else False,
             ),
             self.maybe_get_kv_connector_output(
                 scheduler_output,
                 **({"defer_finalize": not clear_kv_metadata}),
             ) as kv_connector_output,
         ):
+            if self.cache_config.mamba_cache_mode == "align":
+                mamba_utils.do_mamba_copy_block(preprocess_bufs)
             #  -------------------------------------- Omni-new -------------------------------------------------
             outputs = self._run_generation_model(
                 num_tokens_padded=num_tokens_padded,
@@ -406,21 +454,16 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
 
         if self.execute_model_state is None:
             # Nothing to do (PP non-final rank case), output isn't used.
-            # receive sampled token ids from the last PP rank when using
-            # async scheduling + pipeline parallelism so downstream code
-            # (e.g., PCP input preparation) can access them.
-            if self.use_async_scheduling and get_pp_group().world_size > 1:
-                self._pp_receive_prev_sampled_token_ids_to_input_batch()
             if not kv_connector_output:
                 return None  # noqa
             # In case of PP with kv transfer, we need to pass through the
             # kv_connector_output
             if kv_connector_output.is_empty():
-                return EMPTY_MODEL_RUNNER_OUTPUT
+                return self.attach_omni_connector_output(EMPTY_MODEL_RUNNER_OUTPUT)
 
             output = copy(EMPTY_MODEL_RUNNER_OUTPUT)
             output.kv_connector_output = kv_connector_output
-            return output
+            return self.attach_omni_connector_output(output)
 
         # Unpack ephemeral state.
         (
@@ -489,6 +532,12 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
         # [Omni] Copy req_id mappings to avoid async scheduling mutation.
         req_ids_output_copy = self.input_batch.req_ids.copy()
         req_id_to_index_output_copy = self.input_batch.req_id_to_index.copy()
+        # [Omni] Full-payload send-side accumulation. Mirrors gpu_generation_model_runner.py.
+        if inter_stage_outputs and self._should_accumulate_full_payload_output():
+            for i, rid in enumerate(req_ids_output_copy):
+                req_state = self.requests.get(rid)
+                if req_state is not None and inter_stage_outputs[i]:
+                    self.accumulate_full_payload_output(rid, inter_stage_outputs[i], req_state)
         routed_experts_lists = None
         if self.vllm_config.model_config.enable_return_routed_experts and hasattr(
             self.input_batch, "num_tokens_no_spec"
@@ -509,22 +558,23 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             ec_connector_output=ec_connector_output if self.supports_mm_inputs else None,
         )
         output.routed_experts = routed_experts_lists
+        output.omni_connector_output = self.get_omni_connector_output()
         #  -------------------------------------- Omni-new -------------------------------------------------
 
         if self.speculative_config is not None:
             self.finalize_kv_connector()
 
-        if self.ascend_config.profiling_chunk_config.enabled and hasattr(self, "_execution_start_time"):
+        if self.ascend_config.scheduler_config.profiling_chunk_config.need_timing and hasattr(
+            self, "_execution_start_time"
+        ):
             self._sync_device()
             output.execution_time_ms = (time.perf_counter() - self._execution_start_time) * 1000.0
 
         if self.dynamic_eplb:
             with record_function_or_nullcontext("EPLB update"):
-                self.eplb_updator.forward_end()
+                self.eplb_updator.forward_end(self.eplb_heat_collection_status)
 
-        if self.debugger is not None:
-            self.debugger.stop()
-            self.debugger.step()
+        self._finalize_dump_data()
         if not self.use_async_scheduling:
             return output
         async_output = AsyncGPUModelRunnerOutput(
@@ -670,14 +720,16 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             force_has_lora=num_active_loras > 0,
             force_num_active_loras=num_active_loras,
         )
-        if self.use_cp:
-            self.pcp_manager.init_batch_info(
+        if self.use_dcp:
+            self.dcp_manager.init_batch_info(
                 num_scheduled_tokens,
                 num_reqs,
+                self.input_batch.num_computed_tokens_cpu,
+                self.input_batch.num_prompt_tokens,
             )
             if self.speculative_config:
-                self.pcp_manager.query_lens_pcp_full.cpu[:num_reqs] = torch.from_numpy(num_scheduled_tokens)
-                self.pcp_manager.query_lens_pcp_full.copy_to_gpu()
+                self.dcp_manager.query_lens_full.cpu[:num_reqs] = torch.from_numpy(num_scheduled_tokens)
+                self.dcp_manager.query_lens_full.copy_to_gpu()
         if cudagraph_runtime_mode is None:
             cudagraph_runtime_mode = _cudagraph_mode
         else:
@@ -691,66 +743,82 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             # pad is needed if the pad of `num_tokens` is triggered inside CudagraphDispatcher
             num_tokens_across_dp[:] = num_tokens_padded
             num_scheduled_tokens = num_scheduled_tokens.repeat(num_reqs_padded)
+
+        if self.dynamic_eplb:
+            self.update_eplb_heat_collection_status(num_tokens_padded)
+
         # vllm-ascend does not support ubatch now
         ubatch_slices, ubatch_slices_padded = None, None
         attn_metadata: PerLayerAttnMetadata | None = None
-        # Build attention metadata for dummy_run
-        if self._should_build_dummy_attn_metadata(force_attention, is_profile, cudagraph_runtime_mode):
-            if create_mixed_batch:
-                raise NotImplementedError(
-                    "create_mixed_batch is used for warmup deepgemm, vllm-ascend does not need it"
-                )
-            self.attn_state = AscendAttentionState.DecodeOnly
-            if self.speculative_config and self.speculative_config.method == "mtp":
-                # `AscendAttentionState.SpecDecoding` is only designed for mla
-                if self.vllm_config.model_config.use_mla:
-                    self.attn_state = AscendAttentionState.SpecDecoding
+        # Mirrors gpu_model_runner._dummy_run.
+        with self.synchronize_input_prep():
+            # Build attention metadata for dummy_run
+            if self._should_build_dummy_attn_metadata(force_attention, is_profile, cudagraph_runtime_mode):
+                if create_mixed_batch:
+                    raise NotImplementedError(
+                        "create_mixed_batch is used for warmup deepgemm, vllm-ascend does not need it"
+                    )
+                self.attn_state = AscendAttentionState.DecodeOnly
+                if self.speculative_config and self.speculative_config.method == "mtp":
+                    # `AscendAttentionState.SpecDecoding` is only designed for mla
+                    if self.vllm_config.model_config.use_mla:
+                        self.attn_state = AscendAttentionState.SpecDecoding
+                    else:
+                        self.attn_state = AscendAttentionState.ChunkedPrefill
+                # The reason why we use a fixed seq_len rather than max_query_len is that
+                # _npu_paged_attention_get_workspace only returns max workspace with specific
+                # seq_lens. We use this seq_len only when capturing graph, and still use max_query_len
+                # in inference. This will be removed once npu_fused_infer_attention_score
+                # outperforms _npu_paged_attention on all cases.
+                if profile_seq_lens is not None:
+                    seq_lens = profile_seq_lens
                 else:
-                    self.attn_state = AscendAttentionState.ChunkedPrefill
-            # The reason why we use a fixed seq_len rather than max_query_len is that
-            # _npu_paged_attention_get_workspace only returns max workspace with specific
-            # seq_lens. We use this seq_len only when capturing graph, and still use max_query_len
-            # in inference. This will be removed once npu_fused_infer_attention_score
-            # outperforms _npu_paged_attention on all cases.
-            if profile_seq_lens is not None:
-                seq_lens = profile_seq_lens
-            else:
-                seq_lens = (
-                    SEQ_LEN_WITH_MAX_PA_WORKSPACE
-                    if is_graph_capturing and using_paged_attention(num_tokens, self.vllm_config)
-                    else max_query_len
-                )  # type: ignore[assignment]
-            self.optimistic_seq_lens_cpu[:num_reqs] = seq_lens
-            self.optimistic_seq_lens_cpu[num_reqs:].fill_(0)
-            self.seq_lens.copy_(self.optimistic_seq_lens_cpu, non_blocking=True)
+                    seq_lens = (
+                        SEQ_LEN_WITH_MAX_PA_WORKSPACE
+                        if is_graph_capturing and using_paged_attention(num_tokens, self.vllm_config)
+                        else max_query_len
+                    )  # type: ignore[assignment]
+                self.optimistic_seq_lens_cpu[:num_reqs] = seq_lens
+                self.optimistic_seq_lens_cpu[num_reqs:].fill_(0)
+                self.seq_lens.copy_(self.optimistic_seq_lens_cpu, non_blocking=True)
 
-            cum_num_tokens = self._get_cumsum_and_arange(num_scheduled_tokens, self.query_pos.np)
-            self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
-            self.query_start_loc.copy_to_gpu()
-            if self._has_gdn:
-                self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
-                self.gdn_query_start_loc.copy_to_gpu()
+                cum_num_tokens = self._get_cumsum_and_arange(num_scheduled_tokens, self.query_pos.np)
+                self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                self.query_start_loc.copy_to_gpu()
+                if self._has_gdn:
+                    self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                    self.gdn_query_start_loc.copy_to_gpu()
 
-            if not profile_cpp:
-                num_reqs_padded = self._pad_query_start_loc_for_fia(
-                    self.query_start_loc,
-                    num_tokens_padded,
-                    num_reqs_padded,
-                    num_reqs,
-                    cudagraph_runtime_mode,
-                    batch_desc.num_reqs,
+                if not profile_cpp:
+                    num_reqs_padded = self._pad_query_start_loc_for_fia(
+                        self.query_start_loc,
+                        num_tokens_padded,
+                        num_reqs_padded,
+                        num_reqs,
+                        cudagraph_runtime_mode,
+                        batch_desc.num_reqs,
+                    )
+
+                # Dummy graph runs do not go through _prepare_inputs(), but GDN/Mamba
+                # metadata reads block_table[:num_reqs_padded] below. Sync padded
+                # rows as well so device-side metadata does not see stale block ids.
+                self.input_batch.block_table.commit_block_table(num_reqs_padded)
+
+                pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
+                attn_metadata, _ = self._build_attention_metadata(
+                    num_tokens=num_tokens_unpadded,
+                    num_tokens_padded=num_tokens_padded,
+                    num_reqs=num_reqs,
+                    num_reqs_padded=num_reqs_padded,
+                    max_query_len=max_query_len,
+                    ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
+                    for_cudagraph_capture=is_graph_capturing,
+                    num_scheduled_tokens_np=num_scheduled_tokens,
                 )
-
-            pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
-            attn_metadata, _ = self._build_attention_metadata(
-                num_tokens=num_tokens_unpadded,
-                num_tokens_padded=num_tokens_padded,
-                num_reqs=num_reqs_padded,
-                max_query_len=max_query_len,
-                ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
-                for_cudagraph_capture=is_graph_capturing,
-                num_scheduled_tokens_np=num_scheduled_tokens,
-            )
+                if not is_graph_capturing:
+                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
+                        blk_table = self.input_batch.block_table[kv_cache_gid]
+                        blk_table.slot_mapping.gpu.fill_(-1)
 
         with self.maybe_dummy_run_with_lora(
             self.lora_config,
@@ -789,6 +857,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             if hasattr(self.model, "get_dummy_runtime_additional_information"):
                 runtime_addi = self.model.get_dummy_runtime_additional_information(num_reqs)
                 model_kwargs["runtime_additional_information"] = runtime_addi
+            model_kwargs["seq_token_counts"] = [int(num_tokens_padded)]
             # -------------------------------------- Omni-new -------------------------------------------------
 
             if self.uses_mrope:
@@ -847,6 +916,9 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                 aclgraph_runtime_mode=cudagraph_runtime_mode,
                 batch_descriptor=batch_desc,
                 model_instance=self.model,
+                has_sinks=self._has_sinks,
+                input_ids=input_ids,
+                eplb_heat_collection_status=self.eplb_heat_collection_status if self.dynamic_eplb else False,
             ):
                 outputs = self.model(
                     input_ids=input_ids,
@@ -864,7 +936,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
             # -------------------------------------------------------------------------------------------------
             dummy_compute_logits(hidden_states)
 
-            if self.drafter:
+            if self.drafter and not profile_cpp:
                 self.drafter.dummy_run(
                     num_tokens=num_tokens_padded,
                     with_prefill=with_prefill,
@@ -877,10 +949,10 @@ class NPUGenerationModelRunner(OmniNPUModelRunner):
                     is_profile=is_profile,
                 )
             if is_profile and self.dynamic_eplb:
-                target = self.model.language_model if hasattr(self.model, "language_model") else self.model
-                target.clear_all_moe_loads()
-            if self.dynamic_eplb:
-                self.eplb_updator.forward_end()
+                self.eplb_updator.adaptor.clear_all_moe_loads()
+            if not is_profile and self.dynamic_eplb:
+                self.eplb_updator.forward_end(self.eplb_heat_collection_status)
+            self._finalize_dump_data(dump=False)
 
             return hidden_states, None
 
diff --git a/vllm_omni/platforms/npu/worker/npu_model_runner.py b/vllm_omni/platforms/npu/worker/npu_model_runner.py
index 671c7b7e5..bc8e4f0a2 100644
--- a/vllm_omni/platforms/npu/worker/npu_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_model_runner.py
@@ -20,6 +20,7 @@ from vllm_ascend.ops.rotary_embedding import update_cos_sin
 from vllm_ascend.utils import enable_sp, lmhead_tp_enable
 from vllm_ascend.worker.model_runner_v1 import SEQ_LEN_WITH_MAX_PA_WORKSPACE
 
+from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.platforms.npu._310p import is_310p
 from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
@@ -34,6 +35,37 @@ else:
 
 
 class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
+    def initialize_kv_cache(self, kv_cache_config) -> None:
+        """Create the omni tensor prefix cache.
+
+        The omni prefix cache is used to store the hidden states of the prefix tokens
+        """
+        NPUModelRunner.initialize_kv_cache(self, kv_cache_config)
+        if self.omni_prefix_cache is None and self.cache_config.enable_prefix_caching:
+            # Read num_blocks back off self.kv_cache_config: vllm-ascend
+            # deepcopies the config it was handed, so the value it stored is the
+            # authoritative one, not our caller's argument.
+            num_blocks = self.kv_cache_config.num_blocks
+            self.omni_prefix_cache = OmniTensorPrefixCache(
+                num_blocks=num_blocks,
+                block_size=self.cache_config.block_size,
+                hidden_size=self.model_config.get_hidden_size(),
+                hs_dtype=self.dtype,
+            )
+            logger.info(
+                "Initialized omni prefix cache on NPU (num_blocks=%d, block_size=%d, hidden_size=%d). "
+                "Hidden-state cache is pinned host memory of roughly %.1f GiB; each per-token "
+                "multimodal output key allocates another tensor of the same block shape.",
+                num_blocks,
+                self.cache_config.block_size,
+                self.model_config.get_hidden_size(),
+                num_blocks
+                * self.cache_config.block_size
+                * self.model_config.get_hidden_size()
+                * self.dtype.itemsize
+                / (1024**3),
+            )
+
     def load_model(self, *args, **kwargs) -> None:
         if is_310p():
             from vllm_omni.platforms.npu._310p.patch import apply_model_patches
@@ -44,8 +76,37 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
         # in _pad_for_sequence_parallelism during execute_model.
         # This is a workaround for vllm-ascend not passing vllm_config to enable_sp().
         enable_sp(self.vllm_config)
+        # ---------------------------------------Omni-new----------------------------------------------
+        model = getattr(self, "model", None)
+        override_fn = None
+        if bool(getattr(model, "supports_sampled_token_ids_cpu_override", False)):
+            candidate = getattr(model, "consume_sampled_token_ids_cpu_override", None)
+            if callable(candidate):
+                override_fn = candidate
+        self._sampled_token_ids_cpu_override = override_fn
+        self._omni_query_start_loc_model_kwarg = bool(getattr(model, "supports_omni_query_start_loc", False))
         self._maybe_enable_output_token_ids_for_model_sampler()
         self._init_talker_mtp()
+        self._prewarm_attention_capture_workspaces()
+        # ---------------------------------------Omni-new----------------------------------------------
+
+    def _update_states(self, scheduler_output) -> Any:
+        """Mirror NPUModelRunner._update_states and
+        call OmniGPUModelRunner._update_states to update Omni-specific states.
+        """
+        req_data = scheduler_output.scheduled_cached_reqs
+
+        if self.use_async_scheduling:
+            for i, req_id in enumerate(req_data.req_ids):
+                req_state = self.requests.get(req_id)
+                if req_state is None:
+                    continue
+                if req_data.num_computed_tokens[i] < req_state.num_computed_tokens:
+                    req_state.prev_num_draft_len = 0
+
+        self._apply_pp_sampled_tokens_from_scheduler_output(scheduler_output)
+
+        return OmniGPUModelRunner._update_states(self, scheduler_output)
 
     @torch.inference_mode()
     def _dummy_run(
@@ -130,14 +191,16 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
             force_has_lora=num_active_loras > 0,
             force_num_active_loras=num_active_loras,
         )
-        if self.use_cp:
-            self.pcp_manager.init_batch_info(
+        if self.use_dcp:
+            self.dcp_manager.init_batch_info(
                 num_scheduled_tokens,
                 num_reqs,
+                self.input_batch.num_computed_tokens_cpu,
+                self.input_batch.num_prompt_tokens,
             )
             if self.speculative_config:
-                self.pcp_manager.query_lens_pcp_full.cpu[:num_reqs] = torch.from_numpy(num_scheduled_tokens)
-                self.pcp_manager.query_lens_pcp_full.copy_to_gpu()
+                self.dcp_manager.query_lens_full.cpu[:num_reqs] = torch.from_numpy(num_scheduled_tokens)
+                self.dcp_manager.query_lens_full.copy_to_gpu()
         if cudagraph_runtime_mode is None:
             cudagraph_runtime_mode = _cudagraph_mode
         else:
@@ -151,66 +214,81 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
             # pad is needed if the pad of `num_tokens` is triggered inside CudagraphDispatcher
             num_tokens_across_dp[:] = num_tokens_padded
             num_scheduled_tokens = num_scheduled_tokens.repeat(num_reqs_padded)
+
+        if self.dynamic_eplb:
+            self.update_eplb_heat_collection_status(num_tokens_padded)
+
         # vllm-ascend does not support ubatch now
         ubatch_slices, ubatch_slices_padded = None, None
         attn_metadata: PerLayerAttnMetadata | None = None
-        # Build attention metadata for dummy_run
-        if self._should_build_dummy_attn_metadata(force_attention, is_profile, cudagraph_runtime_mode):
-            if create_mixed_batch:
-                raise NotImplementedError(
-                    "create_mixed_batch is used for warmup deepgemm, vllm-ascend does not need it"
-                )
-            self.attn_state = AscendAttentionState.DecodeOnly
-            if self.speculative_config and self.speculative_config.method == "mtp":
-                # `AscendAttentionState.SpecDecoding` is only designed for mla
-                if self.vllm_config.model_config.use_mla:
-                    self.attn_state = AscendAttentionState.SpecDecoding
+        with self.synchronize_input_prep():
+            # Build attention metadata for dummy_run
+            if self._should_build_dummy_attn_metadata(force_attention, is_profile, cudagraph_runtime_mode):
+                if create_mixed_batch:
+                    raise NotImplementedError(
+                        "create_mixed_batch is used for warmup deepgemm, vllm-ascend does not need it"
+                    )
+                self.attn_state = AscendAttentionState.DecodeOnly
+                if self.speculative_config and self.speculative_config.method == "mtp":
+                    # `AscendAttentionState.SpecDecoding` is only designed for mla
+                    if self.vllm_config.model_config.use_mla:
+                        self.attn_state = AscendAttentionState.SpecDecoding
+                    else:
+                        self.attn_state = AscendAttentionState.ChunkedPrefill
+                # The reason why we use a fixed seq_len rather than max_query_len is that
+                # _npu_paged_attention_get_workspace only returns max workspace with specific
+                # seq_lens. We use this seq_len only when capturing graph, and still use max_query_len
+                # in inference. This will be removed once npu_fused_infer_attention_score
+                # outperforms _npu_paged_attention on all cases.
+                if profile_seq_lens is not None:
+                    seq_lens = profile_seq_lens
                 else:
-                    self.attn_state = AscendAttentionState.ChunkedPrefill
-            # The reason why we use a fixed seq_len rather than max_query_len is that
-            # _npu_paged_attention_get_workspace only returns max workspace with specific
-            # seq_lens. We use this seq_len only when capturing graph, and still use max_query_len
-            # in inference. This will be removed once npu_fused_infer_attention_score
-            # outperforms _npu_paged_attention on all cases.
-            if profile_seq_lens is not None:
-                seq_lens = profile_seq_lens
-            else:
-                seq_lens = (
-                    SEQ_LEN_WITH_MAX_PA_WORKSPACE
-                    if is_graph_capturing and using_paged_attention(num_tokens, self.vllm_config)
-                    else max_query_len
-                )  # type: ignore[assignment]
-            self.optimistic_seq_lens_cpu[:num_reqs] = seq_lens
-            self.optimistic_seq_lens_cpu[num_reqs:].fill_(0)
-            self.seq_lens.copy_(self.optimistic_seq_lens_cpu, non_blocking=True)
+                    seq_lens = (
+                        SEQ_LEN_WITH_MAX_PA_WORKSPACE
+                        if is_graph_capturing and using_paged_attention(num_tokens, self.vllm_config)
+                        else max_query_len
+                    )  # type: ignore[assignment]
+                self.optimistic_seq_lens_cpu[:num_reqs] = seq_lens
+                self.optimistic_seq_lens_cpu[num_reqs:].fill_(0)
+                self.seq_lens.copy_(self.optimistic_seq_lens_cpu, non_blocking=True)
 
-            cum_num_tokens = self._get_cumsum_and_arange(num_scheduled_tokens, self.query_pos.np)
-            self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
-            self.query_start_loc.copy_to_gpu()
-            if self._has_gdn:
-                self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
-                self.gdn_query_start_loc.copy_to_gpu()
+                cum_num_tokens = self._get_cumsum_and_arange(num_scheduled_tokens, self.query_pos.np)
+                self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                self.query_start_loc.copy_to_gpu()
+                if self._has_gdn:
+                    self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                    self.gdn_query_start_loc.copy_to_gpu()
 
-            if not profile_cpp:
-                num_reqs_padded = self._pad_query_start_loc_for_fia(
-                    self.query_start_loc,
-                    num_tokens_padded,
-                    num_reqs_padded,
-                    num_reqs,
-                    cudagraph_runtime_mode,
-                    batch_desc.num_reqs,
+                if not profile_cpp:
+                    num_reqs_padded = self._pad_query_start_loc_for_fia(
+                        self.query_start_loc,
+                        num_tokens_padded,
+                        num_reqs_padded,
+                        num_reqs,
+                        cudagraph_runtime_mode,
+                        batch_desc.num_reqs,
+                    )
+
+                # Dummy graph runs do not go through _prepare_inputs(), but GDN/Mamba
+                # metadata reads block_table[:num_reqs_padded] below. Sync padded
+                # rows as well so device-side metadata does not see stale block ids.
+                self.input_batch.block_table.commit_block_table(num_reqs_padded)
+
+                pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
+                attn_metadata, _ = self._build_attention_metadata(
+                    num_tokens=num_tokens_unpadded,
+                    num_tokens_padded=num_tokens_padded,
+                    num_reqs=num_reqs,
+                    num_reqs_padded=num_reqs_padded,
+                    max_query_len=max_query_len,
+                    ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
+                    for_cudagraph_capture=is_graph_capturing,
+                    num_scheduled_tokens_np=num_scheduled_tokens,
                 )
-
-            pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
-            attn_metadata, _ = self._build_attention_metadata(
-                num_tokens=num_tokens_unpadded,
-                num_tokens_padded=num_tokens_padded,
-                num_reqs=num_reqs_padded,
-                max_query_len=max_query_len,
-                ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
-                for_cudagraph_capture=is_graph_capturing,
-                num_scheduled_tokens_np=num_scheduled_tokens,
-            )
+                if not is_graph_capturing:
+                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
+                        blk_table = self.input_batch.block_table[kv_cache_gid]
+                        blk_table.slot_mapping.gpu.fill_(-1)
 
         with self.maybe_dummy_run_with_lora(
             self.lora_config,
@@ -224,15 +302,24 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
         ):
             # Make sure padding doesn't exceed max_num_tokens
             assert num_tokens_padded <= self.max_num_tokens
-            if getattr(getattr(self, "model", None), "has_preprocess", False):
-                input_ids = self.input_ids.gpu[:num_tokens_padded]
-                inputs_embeds = self.inputs_embeds.gpu[:num_tokens_padded]
-            elif self.supports_mm_inputs and not self.model_config.is_encoder_decoder or self.enable_prompt_embeds:
+            # ---------------------------------------Omni-new----------------------------------------------
+            model_kwargs = self._init_model_kwargs()
+            if self.supports_mm_inputs and not self.model_config.is_encoder_decoder:
+                input_ids, inputs_embeds = self._prepare_mm_inputs(num_tokens_padded)
+                model_kwargs = {
+                    **model_kwargs,
+                    **self._dummy_mm_kwargs(num_reqs),
+                }
+            elif self.enable_prompt_embeds:
                 input_ids = None
                 inputs_embeds = self.inputs_embeds.gpu[:num_tokens_padded]
+            elif getattr(getattr(self, "model", None), "has_preprocess", False):
+                input_ids = self.input_ids.gpu[:num_tokens_padded]
+                inputs_embeds = self.inputs_embeds.gpu[:num_tokens_padded]
             else:
                 input_ids = self.input_ids.gpu[:num_tokens_padded]
                 inputs_embeds = None
+            # ---------------------------------------Omni-new----------------------------------------------
 
             if self.uses_mrope:
                 positions = self.mrope_positions.gpu[:, :num_tokens_padded]
@@ -290,6 +377,9 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                 aclgraph_runtime_mode=cudagraph_runtime_mode,
                 batch_descriptor=batch_desc,
                 model_instance=self.model,
+                has_sinks=self._has_sinks,
+                input_ids=input_ids,
+                eplb_heat_collection_status=self.eplb_heat_collection_status if self.dynamic_eplb else False,
             ):
                 # ---------------------------------------Omni-new----------------------------------------------
                 if getattr(self.model, "talker", None) is not None and self.has_talker_mtp:
@@ -309,6 +399,7 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                     positions=positions,
                     intermediate_tensors=intermediate_tensors,
                     inputs_embeds=inputs_embeds,
+                    **model_kwargs,
                 )
                 # ---------------------------------------Omni-new----------------------------------------------
             if self.use_aux_hidden_state_outputs:
@@ -320,7 +411,7 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
             # ---------------------------------------Omni-new----------------------------------------------
             dummy_compute_logits(hidden_states)
 
-            if self.drafter:
+            if self.drafter and not profile_cpp:
                 self.drafter.dummy_run(
                     num_tokens=num_tokens_padded,
                     with_prefill=with_prefill,
@@ -333,10 +424,10 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                     is_profile=is_profile,
                 )
             if is_profile and self.dynamic_eplb:
-                target = self.model.language_model if hasattr(self.model, "language_model") else self.model
-                target.clear_all_moe_loads()
-            if self.dynamic_eplb:
-                self.eplb_updator.forward_end()
+                self.eplb_updator.adaptor.clear_all_moe_loads()
+            if not is_profile and self.dynamic_eplb:
+                self.eplb_updator.forward_end(self.eplb_heat_collection_status)
+            self._finalize_dump_data(dump=False)
             return hidden_states, hidden_states
 
     def _model_forward(
@@ -375,11 +466,11 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
 
         if self.enable_enpu:
             # The soft segmentation scenario requires event.record first, then event.wait.
-            self._update_full_graph_params_if_needed(forward_context, num_tokens_padded, positions)
+            self._update_full_graph_params_if_needed(forward_context, num_tokens_padded)
             model_output = run_model()
         else:
             model_output = run_model()
-            self._update_full_graph_params_if_needed(forward_context, num_tokens_padded, positions)
+            self._update_full_graph_params_if_needed(forward_context, num_tokens_padded)
 
         # Omni-specific: wrap output if needed
         if not isinstance(model_output, OmniOutput) and hasattr(self.model, "make_omni_output"):
@@ -393,3 +484,32 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
             model_output = self._all_gather_hidden_states_and_aux(model_output)
 
         return model_output
+
+    def _gather_runtime_additional_information(self):
+        """NPU parity fix for MiniCPM-o-4.5 Code2Wav request_id injection.
+
+        On GPU, ``OmniGPUModelRunner._preprocess`` unconditionally writes
+        ``req_infos["request_id"] = req_id`` (gpu_model_runner.py:1756) so that
+        every stage's ``model_intermediate_buffer`` entry carries the engine
+        request id. The NPU runner inherits ``execute_model`` from vllm_ascend
+        and never runs omni's ``_preprocess``, so this id is otherwise missing
+        on NPU. This override mirrors that GPU step at the gather point (called
+        from ``_build_model_kwargs_extra`` -> forward), using the engine
+        authoritative ``input_batch.req_ids`` and writing it both top-level and
+        into ``meta`` so Code2Wav._parse_item (which reads either key) resolves
+        it. Only fills when absent, so async_chunk=True handoffs that already
+        carry the id are left untouched.
+        """
+        infos = super()._gather_runtime_additional_information()
+        for req_id, info in zip(self.input_batch.req_ids, infos):
+            if not isinstance(info, dict):
+                continue
+            if info.get("request_id"):
+                continue
+            meta = info.get("meta")
+            if not isinstance(meta, dict):
+                meta = {}
+                info["meta"] = meta
+            meta["request_id"] = req_id
+            info["request_id"] = req_id
+        return infos
diff --git a/vllm_omni/platforms/rocm/platform.py b/vllm_omni/platforms/rocm/platform.py
index f905fd73c..630777058 100644
--- a/vllm_omni/platforms/rocm/platform.py
+++ b/vllm_omni/platforms/rocm/platform.py
@@ -30,7 +30,7 @@ class RocmOmniPlatform(OmniPlatform, RocmPlatform):
     when the selected_backend is not specified.
 
     So the behaviour of the attention backend overriding logic currently lives in
-    extract_stage_metadata in `vllm_omni/engine/stage_init_utils.py`
+    extract_legacy_stage_metadata in `vllm_omni/engine/stage_init_utils.py`
 
     ```
     if current_omni_platform.is_rocm():
@@ -75,7 +75,21 @@ class RocmOmniPlatform(OmniPlatform, RocmPlatform):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = False,
     ) -> str:
+        """Get the diffusion attention backend class path for ROCm platform.
+
+        ROCm supports FLASH_ATTN via the aiter library, and SDPA as fallback.
+
+        Args:
+            selected_backend: User-selected backend name (e.g., "FLASH_ATTN",
+                "TORCH_SDPA"). If None, uses platform default.
+            head_size: Attention head size.
+            allow_trtllm_default: Does not support TRTLLM backend;
+                arg accepted for signature parity but unused.
+        Returns:
+            Fully qualified class path of the selected backend.
+        """
         from vllm._aiter_ops import is_aiter_found_and_supported
 
         # Check if aiter is available for Flash Attention support
@@ -88,6 +102,7 @@ class RocmOmniPlatform(OmniPlatform, RocmPlatform):
 
         if selected_backend is not None:
             backend_upper = selected_backend.upper()
+            cls.validate_diffusion_attn_backend(backend_upper)
             if backend_upper in ("FLASH_ATTN_HUB", "FLASH_ATTN_3_HUB"):
                 logger.warning(
                     "HuggingFace kernels-backed FlashAttention is "
@@ -122,7 +137,7 @@ class RocmOmniPlatform(OmniPlatform, RocmPlatform):
 
     @classmethod
     def get_default_stage_config_path(cls) -> str:
-        return "vllm_omni/platforms/rocm/stage_configs"
+        return "vllm_omni/deploy"
 
     @classmethod
     def get_torch_device(cls, local_rank: int | None = None) -> torch.device:
@@ -145,6 +160,16 @@ class RocmOmniPlatform(OmniPlatform, RocmPlatform):
     def synchronize(cls) -> None:
         torch.accelerator.synchronize()
 
+    @classmethod
+    def record_device_event(cls) -> torch.Event | None:
+        try:
+            event = torch.Event()
+            event.record()
+            return event
+        except Exception:
+            logger.warning("Failed to record device event for cross-stream sync")
+            return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         free, _ = torch.cuda.mem_get_info(device)
diff --git a/vllm_omni/platforms/xpu/platform.py b/vllm_omni/platforms/xpu/platform.py
index 0bc782e03..22cebeead 100644
--- a/vllm_omni/platforms/xpu/platform.py
+++ b/vllm_omni/platforms/xpu/platform.py
@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+import os
+
 import torch
 from vllm.config import VllmConfig
 from vllm.config.kernel import IrOpPriorityConfig
@@ -13,6 +15,13 @@ from vllm_omni.platforms.interface import OmniPlatform, OmniPlatformEnum
 logger = init_logger(__name__)
 
 
+# Use the native query; vLLM's XPU custom op reports free=0 in spawned workers.
+torch.accelerator.get_memory_info = lambda device=None: torch.xpu.mem_get_info(device)
+
+# The XPU sampler kernel is broken for omni on the current vLLM; use the native path.
+os.environ.setdefault("VLLM_XPU_USE_SAMPLER_KERNEL", "0")
+
+
 class XPUOmniPlatform(OmniPlatform, XPUPlatform):
     """XPU/Intel GPU implementation of OmniPlatform.
 
@@ -35,13 +44,16 @@ class XPUOmniPlatform(OmniPlatform, XPUPlatform):
         cls,
         selected_backend: str | None,
         head_size: int,
+        allow_trtllm_default: bool = False,
     ) -> str:
+        # XPU has no TRTLLM backend; arg accepted for signature parity but unused.
         compute_capability = torch.xpu.get_device_capability()
         # Intel Max 1100 and 1550 will not support flash_attn currently
         flash_attn_supported = compute_capability["architecture"] not in [13136561920]
 
         if selected_backend is not None:
             backend_upper = selected_backend.upper()
+            cls.validate_diffusion_attn_backend(backend_upper)
             if backend_upper in ("FLASH_ATTN_HUB", "FLASH_ATTN_3_HUB"):
                 logger.warning(
                     "HuggingFace kernels-backed FlashAttention is "
@@ -88,6 +100,16 @@ class XPUOmniPlatform(OmniPlatform, XPUPlatform):
     def synchronize(cls) -> None:
         torch.xpu.synchronize()
 
+    @classmethod
+    def record_device_event(cls) -> torch.Event | None:
+        try:
+            event = torch.xpu.Event()
+            event.record()
+            return event
+        except Exception:
+            logger.warning("Failed to record XPU device event for cross-stream sync")
+            return None
+
     @classmethod
     def get_free_memory(cls, device: torch.device | None = None) -> int:
         free, _ = torch.xpu.mem_get_info(device)
diff --git a/vllm_omni/platforms/xpu/stage_configs/voxtral_tts.yaml b/vllm_omni/platforms/xpu/stage_configs/voxtral_tts.yaml
deleted file mode 100644
index 0820ab632..000000000
--- a/vllm_omni/platforms/xpu/stage_configs/voxtral_tts.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# Voxtral TTS — Intel XPU (AR → audio tokenizer). Matches CUDA stage config knobs where noted.
-
-async_chunk: true
-stage_args:
-  - stage_id: 0
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      max_num_seqs: 32
-      model_stage: audio_generation
-      model_arch: VoxtralTTSForConditionalGeneration
-      worker_type: ar
-      worker_cls: vllm_omni.platforms.xpu.worker.xpu_ar_worker.XPUARWorker
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      gpu_memory_utilization: 0.7
-      enforce_eager: true
-      trust_remote_code: true
-      async_scheduling: true
-      engine_output_type: latent
-      enable_prefix_caching: false
-      tokenizer_mode: mistral
-      config_format: mistral
-      load_format: mistral
-      skip_mm_profiling: true
-      enable_chunked_prefill: false
-      max_model_len: 4096
-      distributed_executor_backend: "mp"
-      custom_process_next_stage_input_func: vllm_omni.model_executor.stage_input_processors.voxtral_tts.generator2tokenizer_async_chunk
-    output_connectors:
-      to_stage_1: connector_of_shared_memory
-    is_comprehension: true
-    final_output: false
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 2048
-      seed: 42
-      detokenize: True
-      repetition_penalty: 1.1
-
-  - stage_id: 1
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0"
-      max_batch_size: 1
-    engine_args:
-      model_stage: audio_tokenizer
-      model_arch: VoxtralTTSForConditionalGeneration
-      worker_type: generation
-      worker_cls: vllm_omni.platforms.xpu.worker.xpu_generation_worker.XPUGenerationWorker
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
-      async_scheduling: false
-      max_num_seqs: 1
-      gpu_memory_utilization: 0.28
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      skip_mm_profiling: true
-      engine_output_type: audio
-      tokenizer_mode: mistral
-      config_format: mistral
-      load_format: mistral
-      max_num_batched_tokens: 16384
-      max_model_len: 16384
-      distributed_executor_backend: "mp"
-    engine_input_source: [0]
-    is_comprehension: false
-    final_output: true
-    final_output_type: audio
-    input_connectors:
-      from_stage_0: connector_of_shared_memory
-    tts_args:
-      max_instructions_length: 500
-    default_sampling_params:
-      temperature: 0.9
-      top_p: 0.8
-      top_k: 40
-      max_tokens: 2048
-      seed: 42
-      detokenize: True
-      repetition_penalty: 1.05
-
-runtime:
-  enabled: true
-
-  connectors:
-    connector_of_shared_memory:
-      name: SharedMemoryConnector
-      extra:
-        shm_threshold_bytes: 65536
-        codec_streaming: true
-        connector_get_sleep_s: 0.01
-        connector_get_max_wait_first_chunk: 3000
-        connector_get_max_wait: 300
-        codec_chunk_frames: 25
-        codec_chunk_frames_at_begin: 5
-        codec_left_context_frames: 25
-
-  edges:
-    - from: 0
-      to: 1
diff --git a/vllm_omni/platforms/xpu/worker/xpu_ar_worker.py b/vllm_omni/platforms/xpu/worker/xpu_ar_worker.py
index ea6349264..9acf869f7 100644
--- a/vllm_omni/platforms/xpu/worker/xpu_ar_worker.py
+++ b/vllm_omni/platforms/xpu/worker/xpu_ar_worker.py
@@ -1,15 +1,22 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+from vllm.logger import init_logger
 from vllm.v1.worker.xpu_worker import XPUWorker
 
 from vllm_omni.platforms.xpu.worker.xpu_ar_model_runner import XPUARModelRunner
 from vllm_omni.worker.mixins import OmniWorkerMixin
 
+logger = init_logger(__name__)
+
 
 class XPUARWorker(OmniWorkerMixin, XPUWorker):
     """XPU AR worker for thinker/talker stages in Omni model."""
 
     def init_device(self):
         super().init_device()
+        if self.use_v2_model_runner:
+            # OMNI: v2 model runner does not yet include omni hooks.
+            logger.warning("OMNI XPUARWorker forces v1 model runner for omni hooks.")
+            self.use_v2_model_runner = False
         self.model_runner: XPUARModelRunner = XPUARModelRunner(self.vllm_config, self.device)
diff --git a/vllm_omni/platforms/xpu/worker/xpu_generation_worker.py b/vllm_omni/platforms/xpu/worker/xpu_generation_worker.py
index 9c6d530eb..d9bb790d3 100644
--- a/vllm_omni/platforms/xpu/worker/xpu_generation_worker.py
+++ b/vllm_omni/platforms/xpu/worker/xpu_generation_worker.py
@@ -1,15 +1,22 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
+from vllm.logger import init_logger
 from vllm.v1.worker.xpu_worker import XPUWorker
 
 from vllm_omni.platforms.xpu.worker.xpu_generation_model_runner import XPUGenerationModelRunner
 from vllm_omni.worker.mixins import OmniWorkerMixin
 
+logger = init_logger(__name__)
+
 
 class XPUGenerationWorker(OmniWorkerMixin, XPUWorker):
     """XPU generation worker for the code2wav (non-AR waveform generation) stage in the Omni model."""
 
     def init_device(self):
         super().init_device()
+        if self.use_v2_model_runner:
+            # OMNI: v2 model runner does not yet include omni hooks.
+            logger.warning("OMNI XPUGenerationWorker forces v1 model runner for omni hooks.")
+            self.use_v2_model_runner = False
         self.model_runner: XPUGenerationModelRunner = XPUGenerationModelRunner(self.vllm_config, self.device)
diff --git a/vllm_omni/quantization/int8_config.py b/vllm_omni/quantization/int8_config.py
index 37d430047..ea096f9d5 100644
--- a/vllm_omni/quantization/int8_config.py
+++ b/vllm_omni/quantization/int8_config.py
@@ -50,9 +50,55 @@ if TYPE_CHECKING:
 # Dynamic quantization is supported first.
 ACTIVATION_SCHEMES = ["dynamic"]
 
+# Ascend's npu_quant_matmul (QuantBatchMatmulV3) refuses a weight whose last
+# dimension exceeds this, and it fails at the first forward rather than at load
+# time. Layers still wider than the limit after TP sharding stay unquantized.
+NPU_QUANT_MATMUL_MAX_OUT_FEATURES = 65535
+
 logger = init_logger(__name__)
 
 
+def _fell_back_to_unquantized_npu(
+    layer: torch.nn.Module,
+    input_size_per_partition: int,
+    output_partition_sizes: list[int],
+    input_size: int,
+    output_size: int,
+    params_dtype: torch.dtype,
+    **extra_weight_attrs,
+) -> bool:
+    """Swap a layer to unquantized weights when npu_quant_matmul cannot run its shape.
+
+    The check uses the per-partition output size because that is what the kernel
+    actually sees; a layer over the limit on one rank can be within it at a
+    higher TP degree. Returns True when the layer was swapped and its weights
+    created, in which case the caller must not create its own.
+    """
+    output_size_per_partition = sum(output_partition_sizes)
+    if output_size_per_partition <= NPU_QUANT_MATMUL_MAX_OUT_FEATURES:
+        return False
+
+    logger.warning_once(
+        "Keeping a %d-wide linear unquantized: npu_quant_matmul rejects an output dimension past "
+        "%d. Tensor parallelism shrinks this per-rank dimension, so a higher TP degree brings such "
+        "layers back into range.",
+        output_size_per_partition,
+        NPU_QUANT_MATMUL_MAX_OUT_FEATURES,
+    )
+    fallback = UnquantizedLinearMethod()
+    layer.quant_method = fallback
+    fallback.create_weights(
+        layer,
+        input_size_per_partition,
+        output_partition_sizes,
+        input_size,
+        output_size,
+        params_dtype,
+        **extra_weight_attrs,
+    )
+    return True
+
+
 def create_weight_parameter(
     output_size_per_partition: int,
     input_size_per_partition: int,
@@ -231,6 +277,21 @@ class LazyWeightMixin:
 
     uses_meta_device: bool = True
 
+    # This mixin knows when a layer's weight is final, so it can hand the layer
+    # back to the host right there. Loaders that intend to offload the whole
+    # model after loading opt in per layer via ``enable_offload_after_quant``.
+    supports_offload_after_quant: bool = True
+    _offload_after_quant: bool = False
+
+    def enable_offload_after_quant(self) -> None:
+        """Return each layer to host memory as soon as it has been quantized.
+
+        Caps the load-time device footprint at one layer instead of the whole
+        model. A quant method instance belongs to a single layer, so this is not
+        a global switch.
+        """
+        self._offload_after_quant = True
+
     def create_weights(
         self,
         layer: torch.nn.Module,
@@ -287,6 +348,11 @@ class LazyWeightMixin:
                 # anything
                 layer._already_called_process_weights_after_loading = True
 
+                # This layer's weight is final, so nothing needs it on the
+                # accelerator until inference.
+                if self._offload_after_quant:
+                    layer.to("cpu")
+
                 # Note that we keep `layer._loaded_numel` around just in case
                 # there is logic added to vllm in the future which calls a
                 # weight loader twice - we do not want to re-initialize in
@@ -354,6 +420,11 @@ class NPUInt8LinearMethod(BaseInt8LinearMethod):
     def __init__(self, quant_config: DiffusionInt8Config):
         super().__init__(quant_config)
 
+    def create_weights(self, layer: torch.nn.Module, *args, **kwargs) -> None:
+        if _fell_back_to_unquantized_npu(layer, *args, **kwargs):
+            return
+        super().create_weights(layer, *args, **kwargs)
+
     def process_weights_after_loading(self, layer: Module) -> None:
         layer.weight.data = layer.weight.data.t().contiguous()
         layer.weight_scale.data = layer.weight_scale.data.squeeze()
@@ -424,6 +495,13 @@ class NPUInt8OnlineLinearMethod(LazyWeightMixin, NPUInt8LinearMethod):
     and quantized the weights during loading.
     """
 
+    def create_weights(self, layer: torch.nn.Module, *args, **kwargs) -> None:
+        # NPUInt8LinearMethod's override is unreachable from here: LazyWeightMixin
+        # comes first in the MRO and does not call super().
+        if _fell_back_to_unquantized_npu(layer, *args, **kwargs):
+            return
+        super().create_weights(layer, *args, **kwargs)
+
     def process_weights_after_loading(self, layer: Module) -> None:
         if getattr(layer, "_already_called_process_weights_after_loading", False):
             return
diff --git a/vllm_omni/quantization/quack_fp8.py b/vllm_omni/quantization/quack_fp8.py
index 8c7251e43..e92515432 100644
--- a/vllm_omni/quantization/quack_fp8.py
+++ b/vllm_omni/quantization/quack_fp8.py
@@ -94,10 +94,33 @@ def quack_scaled_fp8_mm(
         return None
     out = torch.empty(a.shape[0], b.shape[1], device=a.device, dtype=out_dtype)
     alpha = scale_a.reshape(1).float() * scale_b.reshape(1).float()
-    gemm.gemm_tuned(a, b, out, bias=bias, alpha=alpha)
+    gemm.gemm(a, b, out=out, bias=bias, alpha=alpha, tuned=True)
     return out
 
 
+_valid_scale_ptrs: set[tuple[int, int]] = set()
+
+
+def _scales_valid(scale_a: torch.Tensor, scale_b: torch.Tensor) -> bool:
+    """True when both per-tensor scales are finite and positive.
+
+    vLLM initializes a per-tensor FP8 scale to ``finfo(float32).min`` and fills it at
+    weight-load time, so a call made before that (the dummy profiling forward) would
+    make ``alpha = scale_a * scale_b`` overflow to ``+inf`` and return an all-inf tile.
+    Cache only positive results: a buffer still holding the sentinel is re-checked and
+    picks up the fast path once the real scale is written.
+    """
+    key = (scale_a.data_ptr(), scale_b.data_ptr())
+    if key in _valid_scale_ptrs:
+        return True
+    ok = bool(
+        torch.isfinite(scale_a).all() and torch.isfinite(scale_b).all() and (scale_a > 0).all() and (scale_b > 0).all()
+    )
+    if ok:
+        _valid_scale_ptrs.add(key)
+    return ok
+
+
 def install_quack_fp8_patch() -> None:
     if not quack_enabled():
         return
@@ -115,6 +138,10 @@ def install_quack_fp8_patch() -> None:
         return
 
     def apply_scaled_mm(self, *, A, B, out_dtype, As, Bs, bias, output_shape):  # noqa: N803
+        # An unpopulated scale makes alpha overflow to +inf; hand those calls to
+        # FlashInfer, whose bmm_fp8 tolerates them.
+        if As.numel() != 1 or Bs.numel() != 1 or not _scales_valid(As, Bs):
+            return original(self, A=A, B=B, out_dtype=out_dtype, As=As, Bs=Bs, bias=bias, output_shape=output_shape)
         try:
             out = quack_scaled_fp8_mm(A, B, As, Bs, out_dtype, bias)
             if out is not None:
diff --git a/vllm_omni/request.py b/vllm_omni/request.py
index b094f2d39..2f1fd5379 100644
--- a/vllm_omni/request.py
+++ b/vllm_omni/request.py
@@ -35,6 +35,7 @@ class OmniRequest(Request):
         # Optional external request ID for tracking
         external_req_id: str | None = None,
         additional_information: AdditionalInformationPayload | None = None,
+        model_intermediate_buffer: dict | None = None,
         **kwargs,
     ):
         if prompt_embeds is not None:
@@ -48,6 +49,8 @@ class OmniRequest(Request):
         self.external_req_id: str | None = external_req_id
         # Serialized additional information payload (optional)
         self.additional_information: AdditionalInformationPayload | None = additional_information
+        # Runner-owned runtime payload.
+        self.model_intermediate_buffer: dict | None = model_intermediate_buffer
 
     @staticmethod
     def _maybe_decode_prompt_embeds(
@@ -94,6 +97,7 @@ class OmniRequest(Request):
             trace_headers=request.trace_headers,
             block_hasher=block_hasher,
             additional_information=request.additional_information,
+            model_intermediate_buffer=getattr(request, "model_intermediate_buffer", None),
             resumable=request.resumable,
             reasoning_ended=request.reasoning_ended,
             reasoning_parser_kwargs=request.reasoning_parser_kwargs,
@@ -117,6 +121,7 @@ class OmniStreamingUpdate:
     arrival_time: float
     sampling_params: SamplingParams | None
     additional_information: AdditionalInformationPayload | None = None
+    model_intermediate_buffer: dict | None = None
 
     @classmethod
     def from_request(cls, request: "Request") -> "OmniStreamingUpdate | None":
@@ -129,4 +134,5 @@ class OmniStreamingUpdate:
             arrival_time=request.arrival_time,
             sampling_params=request.sampling_params,
             additional_information=request.additional_information,
+            model_intermediate_buffer=getattr(request, "model_intermediate_buffer", None),
         )
diff --git a/vllm_omni/transformers_utils/configs/mammoth_moda2.py b/vllm_omni/transformers_utils/configs/mammoth_moda2.py
index 1c6352264..d0848d1ca 100644
--- a/vllm_omni/transformers_utils/configs/mammoth_moda2.py
+++ b/vllm_omni/transformers_utils/configs/mammoth_moda2.py
@@ -8,6 +8,11 @@ from transformers.models.qwen2_5_vl.configuration_qwen2_5_vl import (
     Qwen2_5_VLTextConfig,
     Qwen2_5_VLVisionConfig,
 )
+from transformers.models.qwen3_vl.configuration_qwen3_vl import (
+    Qwen3VLConfig,
+    Qwen3VLTextConfig,
+    Qwen3VLVisionConfig,
+)
 
 from vllm_omni.tokenizers.mammoth_moda2_tokenizer import MammothUTokenizer
 
@@ -16,6 +21,9 @@ __all__ = [
     "Mammothmoda2Qwen2_5_VLConfig",
     "Mammothmoda2Qwen2_5_VLTextConfig",
     "Mammothmoda2Qwen2_5_VLVisionConfig",
+    "Mammothmoda2Qwen3VLConfig",
+    "Mammothmoda2Qwen3VLTextConfig",
+    "Mammothmoda2Qwen3VLVisionConfig",
 ]
 
 
@@ -209,6 +217,77 @@ class Mammothmoda2Qwen2_5_VLConfig(Qwen2_5_VLConfig):
         self.tokenizer_class = "MammothUTokenizer"
 
 
+class Mammothmoda2Qwen3VLVisionConfig(Qwen3VLVisionConfig):
+    model_type = "mammothmoda2_qwen3_vl_vision"
+    base_config_key = "vision_config"
+
+
+class Mammothmoda2Qwen3VLTextConfig(Qwen3VLTextConfig):
+    model_type = "mammothmoda2_qwen3_vl_text"
+    base_config_key = "text_config"
+
+    def __init__(
+        self,
+        extra_gen_vocab: bool = True,
+        gen_vocab_size: int = 32800,
+        gen_vocab_start_index: int | None = None,
+        moe_type: str = "ffn",
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.base_vocab_size = int(self.vocab_size)
+        self.extra_gen_vocab = extra_gen_vocab
+        self.gen_vocab_size = gen_vocab_size
+        self.gen_vocab_start_index = self.vocab_size if gen_vocab_start_index is None else gen_vocab_start_index
+        self.moe_type = moe_type
+        if self.extra_gen_vocab:
+            self.vocab_size = int(self.gen_vocab_start_index) + int(self.gen_vocab_size)
+
+
+class Mammothmoda2Qwen3VLConfig(Qwen3VLConfig):
+    """MammothModa2-Dev AR config backed by Qwen3-VL."""
+
+    model_type = "mammothmoda2_qwen3_vl"
+    sub_configs = {
+        "vision_config": Mammothmoda2Qwen3VLVisionConfig,
+        "text_config": Mammothmoda2Qwen3VLTextConfig,
+    }
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        text_config: dict | PretrainedConfig | None = None,
+        vision_config: dict | PretrainedConfig | None = None,
+        extra_gen_vocab: bool = True,
+        gen_vocab_size: int = 32800,
+        gen_vocab_start_index: int | None = None,
+        moe_type: str = "ffn",
+        **kwargs,
+    ) -> None:
+        if isinstance(vision_config, dict):
+            vision_config = self.sub_configs["vision_config"](**vision_config)
+        elif vision_config is None:
+            vision_config = self.sub_configs["vision_config"]()
+        extras = {
+            "extra_gen_vocab": extra_gen_vocab,
+            "gen_vocab_size": gen_vocab_size,
+            "gen_vocab_start_index": gen_vocab_start_index,
+            "moe_type": moe_type,
+        }
+        if isinstance(text_config, dict):
+            for key, value in extras.items():
+                text_config.setdefault(key, value)
+            text_config = self.sub_configs["text_config"](**text_config)
+        elif text_config is None:
+            text_config = self.sub_configs["text_config"](**extras)
+        super().__init__(text_config=text_config, vision_config=vision_config, **kwargs)
+        self.extra_gen_vocab = getattr(self.text_config, "extra_gen_vocab", extra_gen_vocab)
+        self.gen_vocab_size = getattr(self.text_config, "gen_vocab_size", gen_vocab_size)
+        self.gen_vocab_start_index = getattr(self.text_config, "gen_vocab_start_index", gen_vocab_start_index)
+        self.moe_type = getattr(self.text_config, "moe_type", moe_type)
+        self.tokenizer_class = "MammothUTokenizer"
+
+
 class Mammothmoda2Config(PretrainedConfig):
     """Top-level MammothModa2 composition configuration"""
 
@@ -289,6 +368,10 @@ AutoConfig.register(Mammothmoda2Config.model_type, Mammothmoda2Config)
 AutoConfig.register(Mammothmoda2Qwen2_5_VLConfig.model_type, Mammothmoda2Qwen2_5_VLConfig)
 AutoConfig.register(Mammothmoda2Qwen2_5_VLTextConfig.model_type, Mammothmoda2Qwen2_5_VLTextConfig)
 AutoConfig.register(Mammothmoda2Qwen2_5_VLVisionConfig.model_type, Mammothmoda2Qwen2_5_VLVisionConfig)
+AutoConfig.register(Mammothmoda2Qwen3VLConfig.model_type, Mammothmoda2Qwen3VLConfig)
+AutoConfig.register(Mammothmoda2Qwen3VLTextConfig.model_type, Mammothmoda2Qwen3VLTextConfig)
+AutoConfig.register(Mammothmoda2Qwen3VLVisionConfig.model_type, Mammothmoda2Qwen3VLVisionConfig)
 # Register tokenizer_type -> the configs & AutoTokenizer
 AutoTokenizer.register(config_class=Mammothmoda2Config, slow_tokenizer_class=MammothUTokenizer)
 AutoTokenizer.register(config_class=Mammothmoda2Qwen2_5_VLConfig, slow_tokenizer_class=MammothUTokenizer)
+AutoTokenizer.register(config_class=Mammothmoda2Qwen3VLConfig, slow_tokenizer_class=MammothUTokenizer)
diff --git a/vllm_omni/transformers_utils/processors/ming.py b/vllm_omni/transformers_utils/processors/ming.py
index b32f10d12..aa59e5324 100644
--- a/vllm_omni/transformers_utils/processors/ming.py
+++ b/vllm_omni/transformers_utils/processors/ming.py
@@ -24,6 +24,8 @@ from transformers.processing_utils import ProcessorMixin
 from transformers.tokenization_utils_base import PreTokenizedInput, TextInput
 from transformers.utils import logging
 
+from vllm_omni.transformers_utils.configs.ming_flash_omni import BailingMM2Config
+
 try:
     from transformers import AutoVideoProcessor
 except ImportError:
@@ -479,5 +481,10 @@ class MingFlashOmniProcessor(ProcessorMixin):
         return list(dict.fromkeys(names))
 
 
-AutoFeatureExtractor.register("MingWhisperFeatureExtractor", MingWhisperFeatureExtractor)
-AutoProcessor.register("MingFlashOmniProcessor", MingFlashOmniProcessor)
+# transformers >= 5.x requires the config *class* (not a string) as the first
+# arg to AutoFeatureExtractor/AutoProcessor.register — it does `key.__module__`
+# internally. Passing "MingWhisperFeatureExtractor" raises:
+#   AttributeError: 'str' object has no attribute '__module__'
+# Same API change as minicpmo_4_5_omni_llm.py / processing_gr00t_n1d7.py.
+AutoFeatureExtractor.register(BailingMM2Config, MingWhisperFeatureExtractor, exist_ok=True)
+AutoProcessor.register(BailingMM2Config, MingFlashOmniProcessor, exist_ok=True)
diff --git a/vllm_omni/utils/mm_outputs.py b/vllm_omni/utils/mm_outputs.py
index 189cc00aa..af8f9ac14 100644
--- a/vllm_omni/utils/mm_outputs.py
+++ b/vllm_omni/utils/mm_outputs.py
@@ -26,6 +26,18 @@ _CLIENT_MM_ROOT_KEYS: frozenset[str] = frozenset(
     }
 )
 
+_CLIENT_MM_META_KEYS: frozenset[str] = frozenset(
+    {
+        "audio_text_total_chars",
+        "duplex_epoch",
+        "duplex_turn_id",
+        "llm_output_text_utf8",
+        "segment_end",
+        "tts_is_last_chunk",
+        "turn_end",
+    }
+)
+
 
 def partition_flat_payload(
     payload: Mapping[str, object],
@@ -39,6 +51,13 @@ def partition_flat_payload(
         root = key.split(".", 1)[0]
         if root in _CLIENT_MM_ROOT_KEYS:
             client_mm[key] = value
+        elif root == "meta" and "." in key and key.split(".", 1)[1] in _CLIENT_MM_META_KEYS:
+            # Small final-output metadata needed by serving (for example
+            # transcript text attached to audio) must ride with client MM
+            # output. Keep it in inter-stage too so downstream stages that read
+            # metadata from the full payload are not starved.
+            inter_stage[key] = value
+            client_mm[key] = value
         else:
             inter_stage[key] = value
     return inter_stage, client_mm
diff --git a/vllm_omni/worker/gpu_ar_model_runner.py b/vllm_omni/worker/gpu_ar_model_runner.py
index 6cd2b3566..b2437ca02 100644
--- a/vllm_omni/worker/gpu_ar_model_runner.py
+++ b/vllm_omni/worker/gpu_ar_model_runner.py
@@ -22,9 +22,10 @@ from vllm.distributed.kv_transfer import get_kv_transfer_group, has_kv_transfer_
 from vllm.distributed.parallel_state import get_pp_group, get_tp_group
 from vllm.forward_context import set_forward_context
 from vllm.logger import init_logger
+from vllm.sequence import IntermediateTensors
 from vllm.utils.platform_utils import is_pin_memory_available
 from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput
-from vllm.v1.outputs import AsyncModelRunnerOutput, make_empty_encoder_model_runner_output
+from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT, AsyncModelRunnerOutput, make_empty_encoder_model_runner_output
 from vllm.v1.spec_decode.dflash import DFlashProposer
 from vllm.v1.spec_decode.draft_model import DraftModelProposer
 from vllm.v1.spec_decode.eagle import EagleProposer
@@ -33,15 +34,17 @@ from vllm.v1.spec_decode.gemma4 import Gemma4Proposer
 from vllm.v1.structured_output.utils import apply_grammar_bitmask
 from vllm.v1.utils import record_function_or_nullcontext
 from vllm.v1.worker.gpu_model_runner import (
-    EMPTY_MODEL_RUNNER_OUTPUT,
     AsyncGPUModelRunnerOutput,
-    IntermediateTensors,
 )
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 from vllm.v1.worker.utils import is_residual_scattered_for_sp
 
 from vllm_omni.data_entry_keys import flatten_payload
 from vllm_omni.distributed.omni_connectors.kv_transfer_manager import OmniKVTransferManager
+from vllm_omni.distributed.omni_connectors.utils.config import (
+    get_stage_connector_role,
+    stage_sends_async_output,
+)
 from vllm_omni.outputs import OmniModelRunnerOutput
 from vllm_omni.utils.mm_outputs import build_mm_cpu, partition_payload_list, to_payload_element
 from vllm_omni.worker.gpu_model_runner import OmniGPUModelRunner
@@ -318,16 +321,46 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
             "Qwen3TTSTalkerForConditionalGeneration",
             "Qwen3TTSCode2Wav",
             "CosyVoice3Model",
+            "NemotronDenseForCausalLM",
+            "NemotronHForCausalLM",
             "DyninOmniForConditionalGeneration",
             "IndexTTS2TalkerForConditionalGeneration",
         }
-        if getattr(self.model_config, "model_arch", None) in _OMNI_CONNECTOR_INIT_ARCHS:
+        # The stage-level ``model_arch`` override may be blank so the class
+        # resolves from the checkpoint's own ``architectures`` (e.g. the Audex
+        # TTA/TTS thinker stages, which bind dense on the 2B and NemotronH on
+        # the 30B-A3B). Gate on the RESOLVED architectures, not only the raw
+        # override — otherwise a blank-override producer stage never creates
+        # its worker connector and the sync full-payload flush silently never
+        # runs (downstream stage starves on connector input).
+        stage_archs = set(getattr(self.model_config, "architectures", None) or ())
+        model_arch_override = getattr(self.model_config, "model_arch", None)
+        if model_arch_override:
+            stage_archs.add(model_arch_override)
+        if stage_archs & _OMNI_CONNECTOR_INIT_ARCHS or get_stage_connector_role(self.model_config) is not None:
             self.init_omni_connectors(
-                vllm_config=self.vllm_config,
                 model_config=self.model_config,
                 kv_transfer_manager=self.kv_transfer_manager,
             )
         self._downstream_payload_cache: dict[str, bool] = {}
+        self._duplex_sampling_hook = None
+        self._duplex_sampling_hook_resolved = False
+
+    def load_model(self, *args, **kwargs) -> None:
+        super().load_model(*args, **kwargs)
+        self._resolve_duplex_sampling_hook(force=True)
+
+    def _resolve_duplex_sampling_hook(self, *, force: bool = False):
+        if not force and getattr(self, "_duplex_sampling_hook_resolved", False):
+            return self._duplex_sampling_hook
+        candidate = getattr(getattr(self, "model", None), "prepare_duplex_sampling", None)
+        self._duplex_sampling_hook = candidate if callable(candidate) else None
+        self._duplex_sampling_hook_resolved = True
+        if self._duplex_sampling_hook is not None and not hasattr(self, "_duplex_sampling_helper"):
+            from vllm_omni.experimental.fullduplex.model_executor import DuplexSamplingHelper
+
+            self._duplex_sampling_helper = DuplexSamplingHelper()
+        return self._duplex_sampling_hook
 
     def _make_buffer(self, *size, dtype, numpy=True):
         # Prevent ray from pinning the buffer due to large size
@@ -391,9 +424,18 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
         if getattr(self.model, "skips_model_sampler_output_token_history", False):
             return sampling_metadata
         output_token_ids = self._build_model_sampler_output_token_ids()
-        if output_token_ids == sampling_metadata.output_token_ids:
-            return sampling_metadata
-        return replace(sampling_metadata, output_token_ids=output_token_ids)
+        if output_token_ids != sampling_metadata.output_token_ids:
+            return replace(sampling_metadata, output_token_ids=output_token_ids)
+        return sampling_metadata
+
+    def _update_states(self, scheduler_output: SchedulerOutput) -> Callable | None:
+        deferred_state_corrections_fn = super()._update_states(scheduler_output)
+        if self._resolve_duplex_sampling_hook() is None:
+            return deferred_state_corrections_fn
+        helper = getattr(self, "_duplex_sampling_helper", None)
+        if helper is not None:
+            helper.update_states(self, scheduler_output)
+        return deferred_state_corrections_fn
 
     def _request_final_stage_id(self, req_id: str) -> int | None:
         info = self.model_intermediate_buffer.get(req_id)
@@ -520,6 +562,9 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
             self._downstream_payload_cache.clear()
         if hasattr(self, "model_intermediate_buffer"):
             self.model_intermediate_buffer.clear()
+        duplex_helper = getattr(self, "_duplex_sampling_helper", None)
+        if duplex_helper is not None:
+            duplex_helper.clear()
 
         # 5. Release all CUDA graphs unconditionally (upstream only does this
         #    on ROCm; on CUDA the graphs are only freed by Python GC during
@@ -1058,7 +1103,8 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
                         output.kv_extracted_req_ids = kv_ids
                     return self.attach_omni_connector_output(output)
 
-            if not num_scheduled_tokens:
+            # `<= 0`: upstream can schedule a negative span, which is truthy (#5196).
+            if num_scheduled_tokens <= 0:
                 if (
                     self.parallel_config.distributed_executor_backend == "external_launcher"
                     and self.parallel_config.data_parallel_size > 1
@@ -1430,10 +1476,16 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
                         self.input_batch.idx_mapping_np,
                         self.input_batch.positions[self.input_batch.logits_indices],
                     )
-                sampler_output = model_sample(
-                    logits,
-                    self._sampling_metadata_for_model_sampler(sampling_metadata),
-                )
+                prepared_sampling_metadata = self._sampling_metadata_for_model_sampler(sampling_metadata)
+                prepare_duplex_sampling = self._resolve_duplex_sampling_hook()
+                if prepare_duplex_sampling is not None:
+                    helper = getattr(self, "_duplex_sampling_helper", None)
+                    rows = helper.rows(self) if helper is not None and helper.active_request_ids else ()
+                    if rows or (helper is not None and helper.hook_active):
+                        prepare_duplex_sampling(logits, prepared_sampling_metadata, rows)
+                    if helper is not None:
+                        helper.hook_active = bool(rows)
+                sampler_output = model_sample(logits, prepared_sampling_metadata)
                 if sampler_output is not None:
                     return sampler_output
             return self.sampler(
@@ -1464,6 +1516,120 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
             return None
         return hidden_states_cpu[start:end]
 
+    def _run_post_sample_talker_mtp(
+        self,
+        *,
+        req_ids: list[str],
+        valid_sampled_token_ids: list[list[int]],
+        sampled_token_ids: torch.Tensor,
+        invalid_req_indices: list[int],
+        sample_hidden_states: torch.Tensor,
+        multimodal_outputs: Any,
+    ) -> Any:
+        """Run an opt-in talker MTP with the token sampled in this step.
+
+        Some frame-synchronous talkers need the current temporal hidden state
+        and its newly sampled text token to produce the same frame's codec
+        codes. A resumable ``max_tokens=1`` segment has no later decode
+        preprocess in which to do that work, so those models expose
+        ``post_sample_talker_mtp`` instead.
+        """
+        model = getattr(self, "model", None)
+        hook = getattr(model, "post_sample_talker_mtp", None)
+        if not callable(hook):
+            return multimodal_outputs
+
+        selected_indices: list[int] = []
+        selected_req_ids: list[str] = []
+        selected_req_infos: list[dict[str, Any]] = []
+        duplex_indices: list[int] = []
+        invalid_indices = set(invalid_req_indices)
+        use_async_scheduling = bool(getattr(self, "use_async_scheduling", False))
+        for idx, req_id in enumerate(req_ids):
+            req_info = self.model_intermediate_buffer.get(req_id)
+            duplex = req_info.get("duplex") if isinstance(req_info, dict) else None
+            if not isinstance(duplex, dict) or duplex.get("data_plane") is not True:
+                continue
+            duplex_indices.append(idx)
+            if use_async_scheduling:
+                if idx in invalid_indices:
+                    continue
+            else:
+                token_ids = valid_sampled_token_ids[idx] if idx < len(valid_sampled_token_ids) else []
+                if not token_ids:
+                    continue
+                if len(token_ids) != 1:
+                    raise ValueError(
+                        "post_sample_talker_mtp requires exactly one sampled token "
+                        f"per request, got {len(token_ids)} for {req_id}"
+                    )
+            selected_indices.append(idx)
+            selected_req_ids.append(req_id)
+            selected_req_infos.append(req_info)
+
+        if not selected_indices:
+            return multimodal_outputs
+        if sampled_token_ids.ndim != 2 or sampled_token_ids.shape[0] < len(req_ids):
+            raise ValueError(
+                "post_sample_talker_mtp sampled-token rows do not match requests: "
+                f"shape={tuple(sampled_token_ids.shape)}, requests={len(req_ids)}"
+            )
+        if sampled_token_ids.shape[1] != 1:
+            raise ValueError(
+                "post_sample_talker_mtp does not support speculative token rows: "
+                f"shape={tuple(sampled_token_ids.shape)}"
+            )
+
+        empty_audio = torch.empty(0, dtype=torch.long, device=sample_hidden_states.device)
+        merged = dict(multimodal_outputs) if isinstance(multimodal_outputs, dict) else {}
+        existing_codes = merged.get("codes")
+        codes_payload = dict(existing_codes) if isinstance(existing_codes, dict) else {}
+        existing_audio = codes_payload.get("audio")
+        if isinstance(existing_audio, list) and len(existing_audio) == len(req_ids):
+            per_request_audio = list(existing_audio)
+        elif (
+            isinstance(existing_audio, torch.Tensor)
+            and existing_audio.ndim > 0
+            and existing_audio.shape[0] == len(req_ids)
+        ):
+            per_request_audio = [existing_audio[idx : idx + 1] for idx in range(len(req_ids))]
+        else:
+            per_request_audio = [empty_audio for _ in req_ids]
+        for idx in duplex_indices:
+            per_request_audio[idx] = empty_audio
+
+        indices = torch.tensor(
+            selected_indices,
+            dtype=torch.long,
+            device=sample_hidden_states.device,
+        )
+        input_ids = sampled_token_ids.index_select(0, indices).reshape(-1).to(torch.long)
+        codes = hook(
+            input_ids=input_ids,
+            hidden_states=sample_hidden_states.index_select(0, indices),
+            req_ids=selected_req_ids,
+            req_infos=selected_req_infos,
+        )
+        if not isinstance(codes, torch.Tensor) or codes.ndim != 2:
+            raise TypeError(f"post_sample_talker_mtp must return a rank-2 Tensor, got {type(codes).__name__}")
+        if codes.shape[0] != len(selected_req_ids):
+            raise ValueError(
+                f"post_sample_talker_mtp row count does not match requests: {codes.shape[0]} != {len(selected_req_ids)}"
+            )
+        for row, (idx, req_id) in enumerate(zip(selected_indices, selected_req_ids, strict=True)):
+            request_codes = codes[row : row + 1]
+            per_request_audio[idx] = request_codes
+            self._update_intermediate_buffer(
+                req_id,
+                {"codes": {"audio": request_codes}},
+            )
+
+        # Empty rows are intentional: they suppress replay of the previous
+        # frame while a chunked prefill has not sampled a token yet.
+        codes_payload["audio"] = per_request_audio
+        merged["codes"] = codes_payload
+        return merged
+
     def _build_multimodal_outputs(
         self,
         per_req_payloads: list[dict[str, object] | None] | None,
@@ -1805,14 +1971,11 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
                     pooler_output.append(flatten_payload(payload))
 
         pooler_output = pooler_output or []
-        if self._async_chunk:
+        if self._async_chunk and stage_sends_async_output(self.model_config):
             pooler_inter, pooler_client = partition_payload_list(pooler_output)
         else:
-            # Non-async-chunk still ships the full payload to the next stage (via
-            # accumulate_full_payload_output and the inter_stage_outputs field); only
-            # client mm keys are split out when async_chunk is enabled. #4527 set this
-            # to (None, pooler_output), which skipped accumulation and starved the
-            # downstream stage (300s connector-input timeout / empty audio). (PR #4792)
+            # Connector-less stages expose the same payload through the
+            # orchestrator bridge; non-async stages preserve legacy behavior.
             pooler_inter, pooler_client = pooler_output, pooler_output
 
         if pooler_inter and self._should_accumulate_full_payload_output():
@@ -1824,7 +1987,9 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
 
         with record_function_or_nullcontext("omni_output_builder:build_multimodal_outputs"):
             inter_stage_outputs = self._build_multimodal_outputs(pooler_inter)
-            multimodal_outputs = self._build_multimodal_outputs(pooler_client)
+            multimodal_outputs = (
+                inter_stage_outputs if pooler_client is pooler_inter else self._build_multimodal_outputs(pooler_client)
+            )
 
         with record_function_or_nullcontext("gpu_model_runner: ModelRunnerOutput"):
             routed_experts_lists = None
@@ -1985,6 +2150,15 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin):
                 scheduler_output.total_num_scheduled_tokens,
             )
 
+        multimodal_outputs = self._run_post_sample_talker_mtp(
+            req_ids=req_ids_output_copy,
+            valid_sampled_token_ids=valid_sampled_token_ids,
+            sampled_token_ids=sampler_output.sampled_token_ids,
+            invalid_req_indices=invalid_req_indices,
+            sample_hidden_states=sample_hidden_states,
+            multimodal_outputs=multimodal_outputs,
+        )
+
         if propose_drafts_after_bookkeeping:
             # ngram and other speculative decoding methods use the sampled
             # tokens on the CPU, so they are run after bookkeeping.
diff --git a/vllm_omni/worker/gpu_generation_model_runner.py b/vllm_omni/worker/gpu_generation_model_runner.py
index c8fe92eba..62d8b9cef 100644
--- a/vllm_omni/worker/gpu_generation_model_runner.py
+++ b/vllm_omni/worker/gpu_generation_model_runner.py
@@ -18,9 +18,10 @@ from vllm.distributed.ec_transfer import get_ec_transfer, has_ec_transfer
 from vllm.distributed.kv_transfer import get_kv_transfer_group, has_kv_transfer_group
 from vllm.distributed.parallel_state import get_pp_group
 from vllm.forward_context import set_forward_context
+from vllm.sequence import IntermediateTensors
 from vllm.utils.math_utils import cdiv
 from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput
-from vllm.v1.outputs import AsyncModelRunnerOutput, make_empty_encoder_model_runner_output
+from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT, AsyncModelRunnerOutput, make_empty_encoder_model_runner_output
 from vllm.v1.spec_decode.dflash import DFlashProposer
 from vllm.v1.spec_decode.draft_model import DraftModelProposer
 from vllm.v1.spec_decode.eagle import EagleProposer
@@ -28,14 +29,13 @@ from vllm.v1.spec_decode.extract_hidden_states import ExtractHiddenStatesPropose
 from vllm.v1.spec_decode.gemma4 import Gemma4Proposer
 from vllm.v1.utils import record_function_or_nullcontext
 from vllm.v1.worker.gpu_model_runner import (
-    EMPTY_MODEL_RUNNER_OUTPUT,
     AsyncGPUModelRunnerOutput,
-    IntermediateTensors,
     PerLayerAttnMetadata,
 )
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 from vllm.v1.worker.utils import sanity_check_mm_encoder_outputs
 
+from vllm_omni.distributed.omni_connectors.utils.config import get_stage_connector_role
 from vllm_omni.outputs import OmniModelRunnerOutput
 from vllm_omni.utils.mm_outputs import partition_payload_list
 from vllm_omni.worker.gpu_ar_model_runner import ExecuteModelState, _ensure_tensor_values
@@ -64,22 +64,22 @@ class GPUGenerationModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin
             "MiMoAudioModel",
             "Qwen3TTSTalkerForConditionalGeneration",
             "Qwen3TTSCode2Wav",
+            "AudexCode2Wav",
+            "AudexXCodec1",
             "CosyVoice3Model",
             "DyninOmniForConditionalGeneration",
             "IndexTTS2S2MelDecoder",
         }
-        if getattr(self.model_config, "model_arch", None) in _OMNI_CONNECTOR_INIT_ARCHS:
+        if (
+            getattr(self.model_config, "model_arch", None) in _OMNI_CONNECTOR_INIT_ARCHS
+            or get_stage_connector_role(self.model_config) is not None
+        ):
             self.init_omni_connectors(
-                vllm_config=self.vllm_config,
                 model_config=self.model_config,
             )
 
     def _update_request_states(self, scheduler_output: SchedulerOutput):
         # remove requests
-        # Some stateful vocoder model may need to clean the state
-        # to avoid the leak of slots when the requests have been aborted.
-        if scheduler_output.finished_req_ids and hasattr(self.model, "on_requests_finished"):
-            self.model.on_requests_finished(scheduler_output.finished_req_ids)
         for req_id in scheduler_output.finished_req_ids:
             self.input_batch.remove_request(req_id)
         scheduled_req_ids = scheduler_output.num_scheduled_tokens.keys()
@@ -157,7 +157,15 @@ class GPUGenerationModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin
             if self.model_config.async_chunk and num_scheduled_tokens:
                 self._update_request_states(scheduler_output)
             deferred_state_corrections_fn = self._update_states(scheduler_output)
-            if not scheduler_output.total_num_scheduled_tokens:
+
+            # Notify stateful models of finished requests before the
+            # zero-token early return. Request cleanup is a model lifecycle
+            # concern and does not depend on the inter-stage transfer mode.
+            if scheduler_output.finished_req_ids and hasattr(self.model, "on_requests_finished"):
+                self.model.on_requests_finished(scheduler_output.finished_req_ids)
+
+            # `<= 0`: upstream can schedule a negative span, which is truthy (#5196).
+            if scheduler_output.total_num_scheduled_tokens <= 0:
                 return self.attach_omni_connector_output(EMPTY_MODEL_RUNNER_OUTPUT)
 
             if has_ec_transfer() and not get_ec_transfer().is_consumer:
@@ -314,6 +322,8 @@ class GPUGenerationModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin
             )
             # [Omni] Pass token counts per request for code2wav output slicing
             model_kwargs["seq_token_counts"] = tokens
+            if getattr(self.model, "requires_request_ids", False):
+                model_kwargs["request_ids"] = list(req_ids)
 
         # Set cudagraph mode to none if calc_kv_scales is true.
         # KV scales calculation involves dynamic operations that are incompatible
diff --git a/vllm_omni/worker/gpu_model_runner.py b/vllm_omni/worker/gpu_model_runner.py
index b816a36f7..9fb781dc4 100644
--- a/vllm_omni/worker/gpu_model_runner.py
+++ b/vllm_omni/worker/gpu_model_runner.py
@@ -13,6 +13,7 @@ from vllm.logger import init_logger
 from vllm.model_executor.models.interfaces import supports_mrope
 from vllm.model_executor.models.interfaces_base import VllmModelForPooling
 from vllm.sampling_params import SamplingType
+from vllm.sequence import IntermediateTensors
 from vllm.tracing import instrument
 from vllm.utils.import_utils import LazyLoader
 from vllm.utils.math_utils import cdiv
@@ -26,7 +27,7 @@ from vllm.v1.spec_decode.ngram_proposer_gpu import (
     update_scheduler_for_invalid_drafts,
 )
 from vllm.v1.worker.gpu_input_batch import CachedRequestState
-from vllm.v1.worker.gpu_model_runner import GPUModelRunner, IntermediateTensors, PerLayerAttnMetadata
+from vllm.v1.worker.gpu_model_runner import GPUModelRunner, PerLayerAttnMetadata
 from vllm.v1.worker.ubatch_utils import maybe_create_ubatch_slices
 
 from vllm_omni.core.prefix_cache import OmniTensorPrefixCache
@@ -537,7 +538,7 @@ class OmniGPUModelRunner(GPUModelRunner):
         for new_req_data in scheduler_output.scheduled_new_reqs:
             req_id = new_req_data.req_id
             if req_id in self.requests:
-                self._update_streaming_input_additional_info(req_id)
+                self._update_streaming_input_additional_info(new_req_data, req_id)
                 req_state = self._update_streaming_request(req_id, new_req_data)
                 reqs_to_add.append(req_state)
                 continue
@@ -598,6 +599,15 @@ class OmniGPUModelRunner(GPUModelRunner):
                         pass
             except Exception as e:
                 logger.error(f"Error decoding prompt embeds: {e}")
+            # Direct runner data-plane payloads populate
+            # model_intermediate_buffer without going through the deprecated
+            # additional_information request transport.
+            try:
+                model_buffer = getattr(new_req_data, "model_intermediate_buffer", None)
+                if isinstance(model_buffer, dict) and model_buffer:
+                    self._update_intermediate_buffer(req_id, model_buffer)
+            except Exception as e:
+                logger.error(f"Error updating model intermediate buffer: {e}")
             # Decode additional_information payloads (dictionary)
             try:
                 if getattr(new_req_data, "additional_information", None) is not None:
@@ -1260,6 +1270,9 @@ class OmniGPUModelRunner(GPUModelRunner):
             pe_cpu = self._resolve_prompt_embeds_cpu(getattr(nr, "prompt_embeds", None))
             if pe_cpu is not None:
                 setattr(self.requests[req_id], "prompt_embeds_cpu", pe_cpu)
+            model_buffer = getattr(nr, "model_intermediate_buffer", None)
+            if isinstance(model_buffer, dict) and model_buffer:
+                self._update_intermediate_buffer(req_id, model_buffer)
             info_payload = getattr(nr, "additional_information", None)
             if info_payload is not None:
                 logger.warning_once(
@@ -1349,6 +1362,14 @@ class OmniGPUModelRunner(GPUModelRunner):
         if nstp is not None and len(nstp) == len(self.input_batch.req_ids):
             try:
                 model_kwargs_extra["request_token_spans"] = self._compute_request_token_spans(nstp)
+                if getattr(self.model, "requires_request_sample_eligibility", False):
+                    model_kwargs_extra["request_sample_eligible"] = [
+                        bool(
+                            (req := self.requests.get(req_id)) is not None
+                            and int(req.num_computed_tokens) + int(nstp[req_index]) >= int(req.num_tokens)
+                        )
+                        for req_index, req_id in enumerate(self.input_batch.req_ids)
+                    ]
             except Exception as e:
                 # Visible on purpose: the fallback is the equal rows-per-request
                 # split, which can re-introduce the cross-request corruption this
@@ -1466,15 +1487,21 @@ class OmniGPUModelRunner(GPUModelRunner):
 
     def _update_additional_information(self, scheduler_output: "SchedulerOutput") -> None:
         for new_req in scheduler_output.scheduled_new_reqs:
+            model_buffer = getattr(new_req, "model_intermediate_buffer", None)
+            if isinstance(model_buffer, dict) and model_buffer:
+                self._update_intermediate_buffer(new_req.req_id, model_buffer)
             payload_info = getattr(new_req, "additional_information", None)
-            if isinstance(payload_info, dict):
-                self._update_intermediate_buffer(new_req.req_id, payload_info)
+            decoded_info = deserialize_additional_information(payload_info)
+            if decoded_info:
+                self._update_intermediate_buffer(new_req.req_id, decoded_info)
 
         if hasattr(scheduler_output.scheduled_cached_reqs, "additional_information"):
             cached_infos = getattr(scheduler_output.scheduled_cached_reqs, "additional_information", {})
             if isinstance(cached_infos, dict):
                 for req_id, req_infos in cached_infos.items():
-                    self._update_intermediate_buffer(req_id, req_infos)
+                    decoded_info = deserialize_additional_information(req_infos)
+                    if decoded_info:
+                        self._update_intermediate_buffer(req_id, decoded_info)
 
     def _maybe_attach_mimo_audio_req_infos(
         self,
@@ -1646,9 +1673,8 @@ class OmniGPUModelRunner(GPUModelRunner):
         # (e.g., code2wav) so runtime_additional_information can be refreshed
         # from scheduler cached infos on every step.
         if hasattr(self.model, "has_preprocess") or hasattr(self.model, "enable_update_additional_information"):
-            if self.vllm_config.model_config.async_chunk:
-                self._update_additional_information(scheduler_output)
-            else:
+            self._update_additional_information(scheduler_output)
+            if not self.vllm_config.model_config.async_chunk:
                 # In full-payload (non-async-chunk) mode, connector-delivered
                 # stage payloads must override any earlier engine-level
                 # additional_information written by the legacy
@@ -1657,7 +1683,11 @@ class OmniGPUModelRunner(GPUModelRunner):
                 self._sync_local_stage_payloads()
 
         if hasattr(self.model, "has_preprocess") and self.model.has_preprocess:
-            preprocess_device = input_ids.device if input_ids is not None else inputs_embeds.device
+            # Multimodal wrappers forward embeddings and therefore intentionally
+            # set ``input_ids`` to None. Model-specific preprocess hooks still
+            # need the scheduled token ids to build or replace those embeddings.
+            preprocess_input_ids = input_ids if input_ids is not None else self.input_ids.gpu[:num_input_tokens]
+            preprocess_device = preprocess_input_ids.device
             self._maybe_run_batch_preprocess(self.input_batch.req_ids, preprocess_device)
 
             # Overlay custom prompt_embeds per request for the prompt portion;
@@ -1675,21 +1705,27 @@ class OmniGPUModelRunner(GPUModelRunner):
                 req_ids_b = [item[0] for item in decode_batch_items]
                 start_offsets_b = [item[1] for item in decode_batch_items]
                 req_infos_b = [item[2] for item in decode_batch_items]
-                ids_b = torch.stack([input_ids[offset : offset + 1].reshape(-1)[0] for offset in start_offsets_b])
+                ids_b = torch.stack(
+                    [preprocess_input_ids[offset : offset + 1].reshape(-1)[0] for offset in start_offsets_b]
+                )
                 req_input_ids, req_embeds, last_talker_hidden, text_step, updates = batch_decode_preprocess(
                     input_ids=ids_b,
                     req_infos=req_infos_b,
                 )
                 if inputs_embeds is None:
                     inputs_embeds = torch.empty(
-                        (input_ids.shape[0], req_embeds.shape[-1]),
+                        (preprocess_input_ids.shape[0], req_embeds.shape[-1]),
                         device=req_embeds.device,
                         dtype=req_embeds.dtype,
                     )
 
                 offsets_t = torch.tensor(start_offsets_b, device=req_embeds.device, dtype=torch.long)
                 inputs_embeds.index_copy_(0, offsets_t, req_embeds)
-                input_ids.index_copy_(0, offsets_t, req_input_ids.reshape(-1).to(dtype=input_ids.dtype))
+                preprocess_input_ids.index_copy_(
+                    0,
+                    offsets_t,
+                    req_input_ids.reshape(-1).to(dtype=preprocess_input_ids.dtype),
+                )
 
                 dst = slice(len(decode_req_ids), len(decode_req_ids) + len(req_ids_b))
                 self.talker_mtp_input_ids.gpu[dst].copy_(req_input_ids.reshape(-1))
@@ -1704,6 +1740,7 @@ class OmniGPUModelRunner(GPUModelRunner):
                 decode_start_offsets.extend(start_offsets_b)
                 decode_batch_items.clear()
 
+            preprocess_input_ids = input_ids if input_ids is not None else self.input_ids.gpu[:num_input_tokens]
             for req_index, req_id in enumerate(self.input_batch.req_ids):
                 req_infos = self.model_intermediate_buffer.get(req_id, {})
 
@@ -1718,6 +1755,8 @@ class OmniGPUModelRunner(GPUModelRunner):
 
                 # call the custom process function
                 req_infos["request_id"] = req_id
+                req_infos["duplex_token_offset"] = int(self.input_batch.num_computed_tokens_cpu[req_index])
+                req_infos["duplex_prompt_len"] = len(req_state.prompt_token_ids) if req_state is not None else None
                 prompt_token_ids = getattr(req_state, "prompt_token_ids", ()) if req_state is not None else ()
                 prompt_len = len(prompt_token_ids or ())
                 num_computed_tokens = int(self.input_batch.num_computed_tokens_cpu[req_index])
@@ -1733,14 +1772,17 @@ class OmniGPUModelRunner(GPUModelRunner):
 
                 embed_slice = inputs_embeds[s:e] if inputs_embeds is not None else None
                 req_input_ids, req_embeds, update_dict = self.model.preprocess(
-                    input_ids=input_ids[s:e], input_embeds=embed_slice, **req_infos
+                    input_ids=preprocess_input_ids[s:e],
+                    input_embeds=embed_slice,
+                    **req_infos,
                 )
                 if inputs_embeds is None:
                     inputs_embeds = torch.empty(
-                        (input_ids.shape[0], req_embeds.shape[-1]),
+                        (preprocess_input_ids.shape[0], req_embeds.shape[-1]),
                         device=req_embeds.device,
                         dtype=req_embeds.dtype,
                     )
+                    input_ids = preprocess_input_ids
 
                 if self.has_talker_mtp and span_len == 1 and not is_prefill:
                     last_talker_hidden, text_step = update_dict.pop("mtp_inputs")
@@ -1759,7 +1801,9 @@ class OmniGPUModelRunner(GPUModelRunner):
                 seg_len = min(span_len, req_embeds.shape[0])
                 inputs_embeds[s : s + seg_len] = req_embeds[:seg_len]
                 if isinstance(req_input_ids, torch.Tensor) and req_input_ids.numel() == seg_len:
-                    input_ids[s : s + seg_len] = req_input_ids
+                    preprocess_input_ids[s : s + seg_len] = req_input_ids
+            if input_ids is None:
+                input_ids = preprocess_input_ids
 
             flush_decode_batch()
 
@@ -1977,12 +2021,26 @@ class OmniGPUModelRunner(GPUModelRunner):
         # Backward compatible: mirror to old setattr location
         setattr(req_state, "additional_information_cpu", existing)
 
-    def _update_streaming_input_additional_info(self, req_id):
-        # For streaming input prefill case only. Set num processed tokens = 0 for new segment input
+    def _update_streaming_input_additional_info(self, new_req_data, req_id):
+        # For streaming input prefill case only. Update buffer from last segment input.
         cached_additional_info = self.model_intermediate_buffer.get(req_id, {})
-        if cached_additional_info:
-            merged_info = dict(cached_additional_info)
-            merged_info.setdefault("meta", {})["num_processed_tokens"] = 0
-            merged_info.setdefault("meta", {})["resumable"] = True
-            self.model_intermediate_buffer[req_id] = merged_info
-            setattr(self.requests[req_id], "additional_information_cpu", merged_info)
+        inc_info = getattr(new_req_data, "model_intermediate_buffer", None)
+        if not isinstance(inc_info, dict) or not inc_info:
+            payload_info = getattr(new_req_data, "additional_information", None)
+            inc_info = deserialize_additional_information(payload_info)
+        if not isinstance(inc_info, dict) or not inc_info:
+            return
+        merged_info = dict(cached_additional_info) if isinstance(cached_additional_info, dict) else {}
+        for key, value in inc_info.items():
+            if isinstance(value, dict):
+                existing_sub = merged_info.get(key)
+                merged_sub = dict(existing_sub) if isinstance(existing_sub, dict) else {}
+                for sk, sv in value.items():
+                    merged_sub[sk] = sv
+                merged_info[key] = merged_sub
+            else:
+                merged_info[key] = value
+        merged_info.setdefault("meta", {})["num_processed_tokens"] = 0
+        merged_info.setdefault("meta", {})["resumable"] = True
+        self.model_intermediate_buffer[req_id] = merged_info
+        setattr(self.requests[req_id], "additional_information_cpu", merged_info)
diff --git a/vllm_omni/worker/omni_connector_model_runner_mixin.py b/vllm_omni/worker/omni_connector_model_runner_mixin.py
index b173f81ac..07a0327a6 100644
--- a/vllm_omni/worker/omni_connector_model_runner_mixin.py
+++ b/vllm_omni/worker/omni_connector_model_runner_mixin.py
@@ -17,7 +17,6 @@ import inspect
 import os
 import threading
 from collections import defaultdict, deque
-from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
 import torch
@@ -26,7 +25,10 @@ from vllm.logger import init_logger
 
 from vllm_omni.data_entry_keys import OmniPayload
 from vllm_omni.distributed.omni_connectors.factory import OmniConnectorFactory
-from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec
+from vllm_omni.distributed.omni_connectors.utils.config import (
+    ConnectorSpec,
+    get_stage_connector_role,
+)
 from vllm_omni.outputs import OmniConnectorOutput
 from vllm_omni.worker.payload_span import (
     get_tensor_span,
@@ -36,6 +38,7 @@ from vllm_omni.worker.payload_span import (
 _EMBED_SPAN_GROUPS: tuple[tuple[str, str, str], ...] = (("decode", "decode_token_start", "decode_token_end"),)
 
 if TYPE_CHECKING:
+    from vllm_omni.config.model import OmniModelConfig
     from vllm_omni.distributed.omni_connectors.connectors.base import (
         OmniConnectorBase,
     )
@@ -46,6 +49,19 @@ if TYPE_CHECKING:
 logger = init_logger(__name__)
 
 
+def _should_create_payload_connector(model_config: Any) -> bool:
+    """Whether this stage owns runner payload transport for its edge.
+
+    Sender edges may instead be owned solely by KV transfer. Receivers still
+    need a connector even though they do not declare a downstream payload hook.
+    """
+    if get_stage_connector_role(model_config) != "sender":
+        return True
+
+    next_stage_func = getattr(model_config, "custom_process_next_stage_input_func", None)
+    return isinstance(next_stage_func, str) and bool(next_stage_func)
+
+
 def should_accumulate_full_payload_output(model_config, custom_process_func) -> bool:
     """Producer-side structural gate.
 
@@ -87,18 +103,18 @@ class OmniConnectorModelRunnerMixin:
 
     def init_omni_connectors(
         self,
-        vllm_config: Any,
-        model_config: Any,
+        model_config: OmniModelConfig,
         kv_transfer_manager: OmniKVTransferManager | None = None,
     ) -> None:
         """Initialize connectors and background threads.
 
         Args:
-            vllm_config: Full vLLM config object.
             model_config: Stage-level model config with connector settings.
             kv_transfer_manager: Existing KV transfer manager to delegate to.
         """
-        self._omni_connector: OmniConnectorBase | None = self._create_connector(model_config)
+        self._omni_connector: OmniConnectorBase | None = (
+            self._create_connector(model_config) if _should_create_payload_connector(model_config) else None
+        )
         self._kv_transfer_manager = kv_transfer_manager
 
         self._async_chunk: bool = getattr(model_config, "async_chunk", False)
@@ -124,6 +140,19 @@ class OmniConnectorModelRunnerMixin:
 
         # -- heterogeneous TP rank support --
         rank_cfg = self._parse_rank_mapping(model_config)
+        if self._kv_transfer_manager is not None:
+            topology = getattr(self._kv_transfer_manager, "tp_topology", None)
+            effective_mapping = (
+                getattr(topology, "source_tp_size", None),
+                getattr(topology, "target_tp_size", None),
+                getattr(topology, "local_rank", None),
+            )
+            if all(isinstance(value, int) for value in effective_mapping):
+                rank_cfg = {
+                    "from_tp": effective_mapping[0],
+                    "to_tp": effective_mapping[1],
+                    "local_rank": effective_mapping[2],
+                }
         self._from_tp: int = rank_cfg["from_tp"]
         self._to_tp: int = rank_cfg["to_tp"]
         self._local_rank: int = rank_cfg["local_rank"]
@@ -136,6 +165,11 @@ class OmniConnectorModelRunnerMixin:
         # -- chunk index tracking (ported from OmniChunkTransferAdapter) --
         self._put_req_chunk: dict[str, int] = defaultdict(int)
         self._get_req_chunk: dict[str, int] = defaultdict(int)
+        # Segment-local chunk counter: incremented alongside _put_req_chunk
+        # and popped at request cleanup. Note: the mixin path (uniproc mode)
+        # does not have segment boundary infrastructure; multi-segment support
+        # is only available via chunk_transfer_adapter (distributed path).
+        self._ramp_chunk_count: dict[str, int] = defaultdict(int)
         # Send-side async accumulation / staging buffer. Receive-side payload
         # ownership lives in ``_local_stage_payload_cache``.
         self._send_side_request_payload: dict[str, dict[str, Any]] = {}
@@ -285,6 +319,7 @@ class OmniConnectorModelRunnerMixin:
                 self._send_side_request_payload.pop(k, None)
                 self._code_prompt_token_ids.pop(k, None)
                 self._cached_ic.pop(k, None)
+                self._ramp_chunk_count.pop(k, None)
             self._kv_pending_transfers.pop(req_id, None)
             self._kv_active_transfers.discard(req_id)
             self._kv_completed_transfers.discard(req_id)
@@ -1000,6 +1035,7 @@ class OmniConnectorModelRunnerMixin:
             external_req_id = self._resolve_external_req_id(request, req_id)
             chunk_id = self._put_req_chunk[req_id]
             self._put_req_chunk[req_id] += 1
+            self._ramp_chunk_count[req_id] += 1
             connector_put_key = f"{external_req_id}_{self._stage_id}_{chunk_id}"
 
             logger.debug(
@@ -1024,31 +1060,6 @@ class OmniConnectorModelRunnerMixin:
             self._work_available.set()
         return sent_ids
 
-    def recv_stage_inputs(self, scheduler_output: Any) -> dict[str, Any] | None:
-        """Compatibility wrapper for ``recv_full_payload_inputs``."""
-        return self.recv_full_payload_inputs(scheduler_output)
-
-    def accumulate_batch_output(
-        self,
-        req_id: str,
-        pooler_output: Any,
-        request: Any,
-    ) -> None:
-        """Compatibility wrapper for ``accumulate_full_payload_output``."""
-        self.accumulate_full_payload_output(req_id, pooler_output, request)
-
-    def flush_batch_outputs(self, finished_req_ids: set[str]) -> None:
-        """Compatibility wrapper for ``flush_full_payload_outputs``."""
-        self.flush_full_payload_outputs(finished_req_ids)
-
-    def send_stage_outputs(
-        self,
-        scheduler_output: Any,
-        outputs: dict[str, tuple[Any, Any] | Any],
-    ) -> list[str]:
-        """Compatibility wrapper for ``send_full_payload_outputs``."""
-        return self.send_full_payload_outputs(scheduler_output, outputs)
-
     # ------------------------------------------------------------------ #
     #  Streaming chunk mode  (recv_chunk / send_chunk)
     # ------------------------------------------------------------------ #
@@ -1150,6 +1161,7 @@ class OmniConnectorModelRunnerMixin:
             return False
 
         self._put_req_chunk[request_id] += 1
+        self._ramp_chunk_count[request_id] += 1
         next_stage_id = self._next_stage_id
         connector_put_key = f"{request_id}_{self._stage_id}_{chunk_id}"
 
@@ -1294,6 +1306,10 @@ class OmniConnectorModelRunnerMixin:
         For heterogeneous TP receive, the local rank is the target rank and must
         fetch one or more source-rank shards keyed as ``from_rank -> to_rank``.
         """
+        if self._from_tp <= 1 and self._to_tp <= 1:
+            resolved_to_stage = self._next_stage_id if to_stage is None else to_stage
+            return [f"omni_{from_stage}_to_{resolved_to_stage}_kv_cache_{req_id}"]
+
         remote_ranks = self.get_kv_remote_ranks()
         return [
             self.get_kv_connector_key(
@@ -1326,6 +1342,10 @@ class OmniConnectorModelRunnerMixin:
         chunk_id: int = 0,
     ) -> list[str]:
         """Build send-side connector keys for this rank's KV shard(s)."""
+        if self._from_tp <= 1 and self._to_tp <= 1:
+            resolved_to_stage = self._next_stage_id if to_stage is None else to_stage
+            return [f"omni_{from_stage}_to_{resolved_to_stage}_kv_cache_{req_id}"]
+
         target_ranks = self.get_kv_target_ranks_for_send()
         return [
             self.get_kv_connector_key(
@@ -1505,20 +1525,6 @@ class OmniConnectorModelRunnerMixin:
     #  Output aggregation
     # ------------------------------------------------------------------ #
 
-    def _empty_output_with_connector_signals(self) -> Any:
-        """Return a minimal ModelRunnerOutput carrying pending connector signals.
-
-        Used by early-return paths (e.g. ``num_scheduled_tokens == 0``)
-        that still need to deliver ``omni_connector_output`` to the
-        Scheduler so that WAITING_FOR_INPUT / WAITING_FOR_CHUNK
-        transitions are not lost.
-        """
-        from vllm_omni.outputs import OmniModelRunnerOutput
-
-        output = OmniModelRunnerOutput(req_ids=[], req_id_to_index={})
-        output.omni_connector_output = self.get_omni_connector_output()
-        return output
-
     def get_omni_connector_output(self) -> OmniConnectorOutput:
         """Collect and reset transfer results for this execute_model cycle.
 
@@ -1608,7 +1614,7 @@ class OmniConnectorModelRunnerMixin:
 
         from copy import copy
 
-        from vllm.v1.worker.gpu_model_runner import EMPTY_MODEL_RUNNER_OUTPUT
+        from vllm.v1.outputs import EMPTY_MODEL_RUNNER_OUTPUT
 
         wrapped = copy(result if result is not None else EMPTY_MODEL_RUNNER_OUTPUT)
         wrapped.omni_connector_output = omni_output
@@ -1623,6 +1629,10 @@ class OmniConnectorModelRunnerMixin:
     def put_req_chunk(self) -> dict[str, int]:
         return self._put_req_chunk
 
+    @property
+    def ramp_chunk_count(self) -> dict[str, int]:
+        return self._ramp_chunk_count
+
     @property
     def request_payload(self) -> dict[str, dict[str, Any]]:
         return self._send_side_request_payload
@@ -2005,6 +2015,7 @@ class OmniConnectorModelRunnerMixin:
                 self._send_side_request_payload.pop(cleanup_req_id, None)
                 self._code_prompt_token_ids.pop(cleanup_req_id, None)
                 self._cached_ic.pop(cleanup_req_id, None)
+                self._ramp_chunk_count.pop(cleanup_req_id, None)
 
     # ------------------------------------------------------------------ #
     #  Payload accumulation  (ported from OmniChunkTransferAdapter)
@@ -2088,48 +2099,6 @@ class OmniConnectorModelRunnerMixin:
     #  Helpers
     # ------------------------------------------------------------------ #
 
-    @staticmethod
-    def _freeze_request_attr(value: Any) -> Any:
-        if isinstance(value, list):
-            return list(value)
-        if isinstance(value, tuple):
-            return list(value)
-        if isinstance(value, torch.Tensor):
-            return value.clone()
-        raw_list = getattr(value, "_x", None)
-        if raw_list is not None:
-            return list(raw_list)
-        return value
-
-    def _snapshot_request_for_send(self, request: Any, external_req_id: str) -> Any:
-        finished = bool(getattr(request, "is_finished", lambda: False)())
-        attrs: dict[str, Any] = {}
-        try:
-            attrs.update(vars(request))
-        except TypeError:
-            pass
-
-        for name in (
-            "request_id",
-            "req_id",
-            "external_req_id",
-            "prompt_token_ids",
-            "output_token_ids",
-            "all_token_ids",
-            "additional_information",
-            "sampling_params",
-            "multi_modal_data",
-            "mm_hashes",
-        ):
-            if hasattr(request, name):
-                attrs[name] = self._freeze_request_attr(getattr(request, name))
-
-        attrs["external_req_id"] = external_req_id
-        attrs["_frozen_is_finished"] = finished
-        snapshot = SimpleNamespace(**attrs)
-        snapshot.is_finished = lambda: finished
-        return snapshot
-
     @staticmethod
     def _create_connector(model_config: Any) -> OmniConnectorBase | None:
         """Create a connector from model_config, or None if unconfigured."""